Universal Fault-Tolerant Quantum Computing with Stabiliser Codes

The quantum logic gates used in the design of a quantum computer should be both universal, meaning arbitrary quantum computations can be performed, and fault-tolerant, meaning the gates keep errors from cascading out of control. A number of no-go theorems constrain the ways in which a set of fault-tolerant logic gates can be universal. These theorems are very restrictive, and conventional wisdom holds that a universal fault-tolerant logic gate set cannot be implemented natively, requiring us to use costly distillation procedures for quantum computation. Here, we present a general framework for universal fault-tolerant logic with stabiliser codes, together with a no-go theorem that reveals the very broad conditions constraining such gate sets. Our theorem applies to a wide range of stabiliser code families, including concatenated codes and conventional topological stabiliser codes such as the surface code. The broad applicability of our no-go theorem provides a new perspective on how the constraints on universal fault-tolerant gate sets can be overcome. In particular, we show how non-unitary implementations of logic gates provide a general approach to circumvent the no-go theorem, and we present a rich landscape of constructions for logic gate sets that are both universal and fault-tolerant. That is, rather than restricting what is possible, our no-go theorem provides a signpost to guide us to new, efficient architectures for fault-tolerant quantum computing.


I. INTRODUCTION
Quantum computing offers the promise of efficiently solving problems that are intractable for conventional computers. Delivering on this promise is a challenge, because quantum systems are especially vulnerable to noise, and a quantum advantage can easily be destroyed by decoherence. One approach to this challenge is to use quantum error-correcting codes to construct nearnoiseless logical qubits using redundancy in many physical qubits [1,2]. Furthermore, to process the encoded quantum information, we require quantum logic gates that are fault-tolerant, meaning that they do not compromise the protection of the code by significantly increasing the probability of logical errors. Realising fault-tolerant implementations of a quantum-computationally universal set of logical operators on a quantum error-correcting code family is essential for scalable quantum computing.
Constructing a quantum computing architecture with a universal, fault-tolerant gate set has been a longstanding challenge for the field, because the existence of such a gate set for a given quantum code is highly constrained by several no-go theorems [3][4][5][6][7][8][9][10][11][12]. The most significant of these is the Eastin-Knill theorem [3], which proves that the simplest approach to fault-tolerance -transversal gates -cannot yield a universal gate set for any quantum code. For particular code families, more general nogo theorems have subsequently been proven. For example, for topological stabiliser codes, implementing gates by locality-preserving logical operators [4] and braiding defects [10] is insufficient for universality. The conventional wisdom is that a quantum error correcting code cannot natively possess a universal, fault-tolerant set of logic gates.
Notwithstanding these no-go results, a large and apparently diverse range of approaches have been proposed to implement universal, fault-tolerant quantum logic [10,[13][14][15][16][17][18][19][20][21][22][23][24][25][26][27][28][29][30][31]. The most well-known amongst these approaches is magic state distillation [25], which lowers the logical error rate of a particular non-fault-tolerant gate by brute force, and as such is expensive in terms of resource cost. With distillation and more broadly, these approaches all make use of some extra technique that lies outside the scope of the no-go theorems. The theory of quantum computing architectures is left in an undesirable situation, where systematic approaches to designing fault-tolerant quantum logic are highly constrained by no-go theorems, and the 'tricks' used to circumvent these constraints are ad hoc and lack unifying principles. The result is a spectrum of potential quantum computing architectures with a mix of efficient and costly elements that are difficult to compare with each other.
In this paper, we resolve this situation for a broad class of stabiliser code families, by identifying the structures in the sets of logical operators that lead to such no-go theorems as well as the avenues for circumventing the constraints of these theorems. We present two main results. First (in Sec. II), we prove a highly general no-go result precluding a universal set of logical operators by quantum channels that are local noise preserving, meaning that they preserve locality of stochastic noise (in the sense of exponential suppression of high-weight errors, regardless of geometric locality [32]). This is significant since local noise preserving channels are those arXiv:2012.05260v2 [quant-ph] 20 May 2021 that are naturally fault-tolerant for local stochastic noise [1,2,32], generalising standard approaches to fault tolerance such as transversal gates [3] and (geometrically) locality-preserving logical operators [4]. This theorem applies to a wide range of stabiliser codes that includes concatenated stabiliser codes and topological stabiliser codes with conventional topological order as important subclasses, and can be understood as a substantial generalisation of the Eastin-Knill theorem [3] for these codes. Second (in Sec. III), we show how approaches to circumventing the no-go result to realise fault-tolerant implementations of a universal set of logical operators follow naturally from the logic of this theorem. Specifically, we generalise the notion of local noise preserving channels, while retaining fault tolerance, by constraining their action only on correctable errors but allowing any action on uncorrectable errors. This generalisation is trivial for unitary operators, but allows for universal fault tolerance by non-unitary channels that treat logical operators differently from correctable errors. Specifically, we describe two classes of such channels; gradational channels, which include code deformation and pieceable fault tolerance, and intrinsically fault-tolerant channels which include state injection and code switching. The apparent diversity of approaches to implementing a universal set of logical operators fault-tolerantly thus emerges naturally from our analysis.

II. RESTRICTIONS ON SETS OF FAULT-TOLERANT LOGICAL GATES
In this section, we prove our main no-go result. Specifically, we show that a highly general class of fault-tolerant quantum channels are not sufficient for implementing a universal set of logical operators on a large class of stabiliser codes. In Sec. II A we introduce the notion of fault-tolerant quantum channels and argue that the class of local noise preserving channels constitutes a natural class of fault-tolerant quantum channels under the assumption of local stochastic noise. In Sec. II B, we then prove our no-go result, showing that universal quantum computing using only local noise preserving channels is not possible on a large class of stabiliser codes including conventional topological stabiliser codes and concatenated stabiliser codes. This result clarifies that universal, fault-tolerant quantum computing with such codes necessitates generalising fault tolerance beyond local noise preserving channels, which we consider in Sec. III.
A. Fault-Tolerant Quantum Channels

Quantum Channels
Operations on quantum error-correcting codes can be described by quantum channels acting on the physical qubits. A quantum channel is a completely-positive trace-preserving (CPTP) map on the state of the qubits. Such a channel admits a dual map, A, that acts on operators on the physical qubits and corresponds to the Heisenberg picture [33]. We use this dual map throughout, referring to it as the quantum channel for brevity. We refer to a quantum channel as unitary if its action is equivalent to some unitary operator U (i.e. U(B) = U BU † ), but we emphasise that general quantum channels are not unitary.

Noise
We model the noise afflicting a quantum errorcorrecting code by a quantum channel, E η , that is applied before each timestep of computation. This noise is parameterised by a noise rate η, independent of the code, which we often leave implicit. In general, this noise can be time-dependent, with a different noise channel, E (t) η applied at each timestep t.
Scalable protection against noise can be achieved with a code family -a sequence of error-correcting codes indexed by a positive integer l. We require that this code family has a threshold, i.e., that there exists a non-zero noise rate below which the effect of noise on the logical qubits after error correction can be arbitrarily suppressed by choosing sufficiently large l. We quantify the effect of noise on the logical qubits using the distance between the noise channel followed by application of a decoder that performs error-correction, D, i.e. D • E, and the identity channel, I. We follow Ref. [1] by using the diamond norm as as our measure of distance, and restrict to the logical space, since we only require that error correction succeeds if the original state is a logical state. We denote this distance by · ,L . A code family (with decoder, D) then has a threshold, η I > 0, if lim l→∞ D • E η − I ,L = 0 , for η < η I . (1) In the case of time-dependent noise, we require that E (t) admits a threshold for all t.

Fault Tolerance
We now consider fault tolerance of quantum logic gates, expressed as quantum channels. Precisely, a logical operator implementation is a quantum channel that acts as a logical operator on the logical space of a code. Specifically, an implementation of logical operatorĀ is a quantum channel such that, for any logical operatorŪ , if U is a representative ofŪ , then A(U ) is a representative of logical operatorĀŪĀ † . A logical operator implementation can have any action on non-logical operators.
In the presence of noise, attempting to apply a quantum channel A will instead result in a noisy implementation A Eη . If the time over which A is applied is constant in the code size then we can assume that A Eη = A • E η ; more generally, A Eη corresponds to A along with the application of E (t) before each timestep, t, of its implementation.
We define A to be fault-tolerant if A Eη followed by decoding approximates A on the logical space to arbitrarily high precision. Precisely, we define A to be fault-tolerant (with decoder, D) if there exists a threshold η A > 0 such that Thus, to directly verify that a set of quantum channels, {A}, can be used to implement fault-tolerant quantum computing within a given architecture, we must first specify a noise model, E, and decoder, D, and then show that Eq. (2) is satisfied for each A. Such a direct approach to constructing fault-tolerant gate sets can be taken (for example, see Ref. [26] or Appendix F), but in general a more flexible approach is preferred whereby fault tolerance of a class of quantum channels is ensured for a wide range of realistic noise models and decoders. We now introduce such a naturally fault-tolerant class of channels; those that are local noise preserving.

Local Noise Preserving Channels
A standard class of noise models considered in the study of fault tolerance is those that are local and stochastic [2,32]. We define a stochastic noise model by specifying a set of unitary errors, E, and an associated probability distribution, {p i }, such that E acts by the application of an error E i ∈ E chosen with probability p i , independent of the current state of the code (i.e. of past errors). A stochastic noise model is local if the probability that any given set of physical qubits, A, is contained in the support of an error decays exponentially with the size of A, i.e. p ({E i |A ⊆ supp(E i )}) ≤ η |A| where η < 1 is the noise rate [32]. We emphasise that this does not imply any assumptions on the geometric locality of noise.
The action of a quantum channel, A can be understood to map a stochastic noise model, E to a different, effective stochastic noise model, E A . Informally, a quantum channel should be fault-tolerant if this mapping preserves properties of noise channels that make them amenable to error correction. Precisely, for quantum channel A and stochastic noise channel E, we can write A Eη = E Aη • A where E A is some stochastic noise model. Indeed, for constant-time A, E Aη corresponds to the stochastic noise model with probability distribution p A (E) = E ∈A −1 (E) p(E ); more generally p A (E) is the sum over the probabilities of all sets of errors occuring over the application of A that result in the final error, E. Thus, we can consider the effect of applying A Eη to be equivalent to applying the ideal channel A followed by an effective noise channel E Aη .
A logical operator implementation, A, is thus faulttolerant if the noise model E Aη necessarily admits a threshold provided that E (t) admits a threshold for all t. Indeed, Eq. (2) is equivalent to As a logical operator implementation, the action of A on the logical space is unitary and, hence, invertible. Thus, from Eq. (3), we have that fault tolerance of A is equivalent to the condition that there is a threshold for noise Theorems exist showing the existence of a threshold for local stochastic noise for a wide range of code families, including concatenated codes [1] and low-density parity check (LDPC) codes (e.g. topological stabiliser codes) [32,34], with appropriate decoders. Provided that E A is a local stochastic noise model, these theorems imply, via Eq. (4), that quantum channel A is fault-tolerant for such decoders.
Motivated by this observation, we introduce the class of local noise preserving (LNP) quantum channels, as quantum channels that map local stochastic noise models to local stochastic noise models. Precisely, we define quantum channel A to be LNP if, for any set of local stochastic noise models {E (t) }, the corresponding E A is a local stochastic noise model. LNP quantum channels on a code family thereby serve as a set of quantum channels that are manifestly fault-tolerant for any local stochastic noise model, and any decoder that gives a threshold for local stochastic noise. They can be understood as a generalisation of important classes of fault-tolerant gates, including transversal gates [3] and (geometrically) locality-preserving logical operators [4] (as shown in Appendix A), which are based on the principle of preserving locality of errors. By contrast, as shown in the following subsection, quantum channels that spread errors by a factor unbounded in the code size are not LNP.

Spread of Errors
The fault tolerance of quantum channels is often associated with the extent to which they spread errors. We justify this association by showing that LNP quantum channels indeed can only spread a Pauli error by a factor at most constant in the code size.
Specifically, we define the spread of a quantum channel as a measure of the extent to which it can increase the size of the support of errors. More precisely, the spread of a Pauli operator P ∈ P n under the action of a quantum channel A is We define the spread of A to be the maximum spread of any Pauli operator under A: We say A has bounded spread if there exists a constant C (independent of l) such that s A ≤ C for all l ∈ Z + . Bounded-spread quantum channels do not significantly increase the size of the support of errors. Many of the standard approaches to fault tolerance make use of bounded-spread quantum channels (see Appendix A for examples). Indeed, transversal gates have spread that is bounded by the number of code blocks they act on, and so have bounded spread (assuming they act on a fixed number of code blocks). More generally, the spread of a quantum circuit consisting of local unitary gates scales with its depth, and so constant-depth quantum circuits also have bounded spread. Locality-preserving logical operators in topological codes can only grow the support of errors within a constant-size neighbourhood around the original support [4,7,9], and so also have bounded spread. Finally, braiding defects in topological stabiliser codes is also bounded-spread, because such braiding operations can only increase the weight of logical operators (or uncorrectable errors) by a constant factor (as shown in Appendix A 3) and correctable errors are corrected before they can spread beyond a local region.
The following theorem relates LNP quantum channels to bounded-spread quantum channels. Theorem 1. An LNP quantum channel necessarily has bounded spread.
Proof. Let A be a quantum channel. By definition of the spread of A, there exists P ∈ P n such that s A = |supp(A(P ))| |supp(P )| . We define a stochastic noise model, E η , that acts as P with probability p(P ) = η |supp(P )| or as the identity with probability p(I) = 1 − η |supp(P )| . This is a local stochastic noise model, since it satisfies p(P ) ≤ η |supp(P )| . We consider a time-dependent local stochastic noise model that acts as E η at the first timestep, and trivially at all subsequent timesteps.
With this setup, we show that the effective noise model E Aη is local only if A has bounded spread, which implies the theorem. Indeed, with noise model E A the error A(P ) occurs with probability p(P ), since it is present after the implementation of A iff the error P occurs at the first timestep. Thus, E A is a local stochastic noise model only if there exists a constant effective noise rate η A ∈ (0, 1) (independent of l) such that which implies that Since, η and η A are independent of l, it follows from Eq. (8) that A indeed necessarily has bounded spread.

No-Go for Bounded-Spread Quantum Channels
We here present a no-go theorem that rules out the existence of a universal set of logical operators that admit bounded-spread implementations, that is applicable to a broad class of stabiliser code families. This class of stabiliser codes includes important code families such as conventional topological stabiliser codes and concatenated stabiliser codes. Our result is important in its own terms, but also takes on particular significance in the context of Theorem 1, because it thereby rules out a universal set of logical operators admitting LNP implementations.
The no-go theorem stems from the observation that bounded-spread logical operator implementations cannot significantly increase the size of the support of logical Pauli operators of stabiliser codes, and this constrains the set of such logic gates. Specifically, let dL denote the distance of logical operatorL, i.e., the minimum size of support of a representative ofL. If A is an implementation of logical operatorĀ then it must map representatives of logical operatorL to representatives ofĀLĀ † . Because representatives of logical Pauli operators of stabiliser codes are physical Pauli operators [35], this implies that for all logical Pauli operators,P , where s A is the spread of A. Thus,Ā can only admit a bounded-spread implementation if for some constant C independent of l for all logical Pauli operators,P . Thus, if there is no universal set of logical operators, {Ā}, that satisfy Eq. (10) on a given code family, then the code family cannot admit a universal set of bounded-spread logical operator implementations.
To formalise this argument, we define the subset of logical operators, L ↓ ⊆ L, of distance at most a constant factor larger than the code distance d, i.e., We also define P ↓ = L ↓ ∩ P n to be the subset of logical Pauli operators in L ↓ . The following lemma shows that a logical operator that admits a bounded-spread implementation necessarily maps elements of P ↓ to elements of L ↓ .
Lemma 1. Let A be a bounded-spread implementation of logical operatorĀ. Then Proof. IfP ∈ P ↓ then there exists a constant C such that dP /d ≤ C. Thus, Thus, A can have bounded spread only if dĀPĀ †/d is bounded, which implies thatĀPĀ † ∈ L ↓ .
We define a code family to be B-constrained if the group is not universal. The following no-go theorem then follows.
Theorem 2. A B-constrained code family cannot admit bounded-spread implementations of a universal set of logical operators.
Proof. By Lemma 1, the set of logical operators that admit bounded-spread implementations is contained in the set B ∈ L BPB † ∈ L ↓ ∀P ∈ P ↓ . Thus, if the group generated by this set is not universal then the set of logical operators that implement bounded-spread implementations cannot be universal.
This theorem implies that any approach to fault tolerance based on bounded-spread quantum channels cannot be universal in B-constrained code families. Indeed, Theorem 2 implies the Eastin-Knill theorem [3] for Bconstrained code families and the Bravyi-König theorem for conventional topological stabiliser codes [4] (which we show below are B-constrained). This is also true for nonunitary, bounded-spread implementations, such as those by braiding defects. In particular, Theorem 1 of Ref. [10] is also implied (for the case of defects with Pauli stabilisers).
From Theorem 1 and Theorem 2 we hence have the following corollary. Corollary 1. A universal set of logical operators on a B-constrained code family cannot be implemented by local noise preserving quantum channels.
Corollary 1 is our main no-go result. It shows that the most naturally fault-tolerant quantum channels for local stochasitic noise -those that are local noise preserving -are not sufficient for universal quantum computing in B-constrained code families. This is significant because large and important classes of stabiliser code families are B-constrained, as we now show.

B-constrained stabiliser code families
Stabiliser codes are widely used in quantum computing architectures, and many of the most commonlyconsidered stabiliser code families are B-constrained.
Here, we show that codes that are asymmetric or have infinite disjointness are necessarily B-constrained, which implies that important classes of code families such as conventional topological stabiliser codes and concatenated stabiliser codes are B-constrained.
Asymmetric code families are those with significantly different distances of logical Pauli operators. Precisely, a code family is symmetric if it admits a set of generators, P g of the logical Pauli group such that dP ∝ d for allP ∈ P g . Otherwise, it is asymmetric. Asymmetric code families are expected to be B-constrained, as their logical Pauli operators can be partitioned into sets of lower-distance operators and higher-distance operators which cannot be interchanged by bounded-spread quantum channels. This intuition can be made precise: as shown in Appendix B, L ↓ for asymmetric code families is contained in the subspace of the logical operators spanned by P ↓ , so B leaves invariant the subspace stabilised by these logical Pauli operators, precluding universality. Thus, asymmetric stabiliser code families are constrained by Theorem 2 and Corollary 1.
An illustrative example of an asymmetric code family is the three-dimensional surface code [13]. This has logi-calX andZ operators supported on regions of two and one dimensions respectively, and so their ratio scales with the linear dimensions of the code making the code family asymmeteric. For this code family, L ↓ = {Ī,Z} (sinceZ is the only one-dimensional logical operator), so |0 is stabilised by all bounded-spread logical operator implementations. This precludes a universal set of bounded-spread logical operator implementations and hence a universal set of LNP logical operator implementations.
An alternative way for a code family to be Bconstrained is for the group generated by L ↓ to be the logical Pauli group. This is sufficient because then B is contained in the Clifford group, which is not universal. A sufficient condition for this is that the code family is symmetric and has infinite disjointness. The disjointness of a stabiliser code is a measure of how many almost disjoint representatives there are of each logical Pauli operator (see Appendix C or Ref. [8] for a more precise definition) and infinite-disjointness code families are those with a disjointness, ∆, satisfying lim l→∞ ∆(l) = ∞. As shown in Appendix B, for infinite-disjointness code families all logical non-Pauli operators,Ū , satisfy lim l→∞ dŪ dP = ∞ for some logical Pauli operatorP . For a code family that is also symmetric, this implies that a generating set of logical Pauli operators is contained in P ↓ while no logical non-Pauli operators are in L ↓ , so B is contained in the Clifford group. Thus, symmetric, infinite-disjointness stabiliser code families are constrained by Theorem 2 and Corollary 1.
An illustrative example of a symmetric, infinitedisjointness code family is the two-dimensional surface code. This has only string-like logical Pauli operators which all have the same distance, l, so it is symmetric. By contrast, all non-Pauli logical operators, such as the Hadamard gate, have support on the full code and so have distance Θ(l 2 ). Thus, we indeed have that L ↓ is the logical Pauli group and it is clear that logical Pauli operators cannot be mapped to logical non-Pauli operators by bounded-spread quantum channels, so the boundedspread logical operator implementations are indeed in the Clifford group and so not universal.
Importantly, the two cases -asymmetric and symmetric with infinite disjointness -taken together imply that all stabiliser code families with infinite disjointness are Bconstrained. Thus, the no-go results apply to all infinitedisjointness code families which, as we show in Appendix C includes a number of important classes of stabiliser code families. Indeed, all concatenated stabiliser code families have infinite disjointness (see Appendix C 1). Conventional topological stabiliser codes -i.e., those with conventional topological order [36] -also all have infinite disjointness (see Appendix C 2). These are topological stabiliser codes that can be associated with topological quantum field theories (TQFTs) with excitations that correspond to error syndromes and which can propagate freely throughout the code [36]. This includes all twodimensional topological stabiliser codes [37] and all scale and translationally symmetric (STS) codes [38], including the surface and colour codes in all spatial dimensions.
It remains an open question whether more general classes of LDPC codes also necessarily have infinite disjointness and are therefore also constrained by our no-go results.
We conclude this section by noting that our results for stabiliser codes straightforwardly generalise to subsystem codes. Specifically, for subsystem codes we can define distances and disjointness to be calculated only on the bare logical operators. Considering only the bare logical operators is sufficient because logical operator implementations necessarily map bare logical operators to bare logical operators [6]. Hence, the proofs of all the results can naturally generalise to the case of subsystem codes by considering bare logical operators and so Theorems 1 and 2 and Corollary 1 also apply to subsystem codes.

III. UNIVERSAL FAULT-TOLERANT LOGICAL OPERATOR IMPLEMENTATIONS
A. Circumventing Corollary 1 The results of Sec. II place constraints on sets of faulttolerant logical operators. Importantly, however, these no-go theorems also point to the ways in which these constraints can be circumvented. Specifically, we observe that the logical action of a quantum channel depends only on its action on logical operators, which are necessarily not correctable errors. However, it is sufficient for fault tolerance that a quantum channel maps correctable errors to correctable errors, regardless of its action on uncorrectable errors. Corollary 1 can thus be circumvented by constructing fault-tolerant quantum channels that have bounded spread on correctable errors -so that correctable errors are not spread to uncorrectable errors -but unbounded spread on uncorrectable errors.
Specifically, we generalise the class of local noise preserving quantum channels to essentially local noise preserving (ELNP ) quantum channels. Informally, these are quantum channels that preserve the locality of stochastic noise models up to a set of errors of vanishing probability. Precisely, we define two stochastic noise models, E andÊ (with respective probability distributions p andp) to be essentially equivalent if there exists a set of errors E such that lim l→∞ p(E) = 1 and p(E) =p(E) for all E ∈ E. We define a stochastic noise model to be essentially local if it is essentially equivalent to some local stochastic noise model. We define quantum channel A to be essentially local noise preserving (ELNP) if, for any set of local stochastic noise models {E (t) }, the corresponding E A is an essentially local stochastic noise model. ELNP quantum channels straightforwardly inherit fault tolerance for local stochastic noise from LNP quantum channels. Indeed, if E andÊ are equivalent noise models, then lim l→∞ E −Ê = 0. Thus (by the triangle inequality on Eq.( 1)),Ê admits a threshold for a given code family and decoder if E does. Hence, threshold theorems for local stochastic noise trivially extend to essentially local stochastic noise models, and so imply the fault tolerance of ELNP quantum channels.
Unitary quantum channels that are ELNP still necessarily have bounded spread and hence cannot allow circumvention of Corollary 1 (as proven in Appendix D). This is because for a unitary quantum channel, U(E) = U EU † , the spread is lower-bounded by the spread of some single-qubit error. This fact holds because any Pauli can be decomposed into a product of single-qubit Pauli operators, P = i P i , and for a unitary operator, U , we have that U ( i P i ) U † = i U P i U † . For any single-qubit error, P i , there exists a local stochastic noise model where the probability of P i is constant in l. Thus, an unbounded-spread unitary quantum channel necessarily results in an error with unbounded support size and hence cannot be ELNP.
Importantly, however, there exist non-unitary quantum channels that are ELNP but not LNP. Indeed, if A is a non-unitary quantum channel, then it does not necessarily follow that A( i P i ) = i A(P i ). In particular, it is possible for a non-unitary quantum channel to have bounded spread on all correctable errors for some decoder but unbounded spread on a set of logical operators. Provided the decoder gives a threshold on all local stochastic noise models, the set of correctable errors necessarily asymptotically has probability one, and hence such a quantum channel is ELNP despite having unbounded spread. Non-unitary quantum channels of this type can be constructed by integrating error-correction, which by definition corrects correctable errors (thereby preventing their spread) while leaving logical operators unchanged. As we show in this section, a diverse range of techniques for realising a universal set of fault-tolerant logical operator implementations can be understood as instances of ELNP quantum channels of unbounded-spread con-structed in this way.
The challenge in realising a logical operator implementation that integrates error-correction into its action in this way is that the two processes cannot be separated. Indeed, it is not sufficient to simply first perform errorcorrection and then the logical operator implementation, since new errors can arise between these processes that will not be corrected before the logical operator implementation acts on them. There are two ways, however, that the necessary integration can be achieved.
One way is to decompose an unbounded-spread logical operator implementation into an unbounded-length sequence of bounded-spread logical operator implementations. This decomposition can then be interspersed with conventional error-correction which removes correctable errors before they are allowed to grow too much under the action of the logical operator implementation. We refer to such channels as gradational and consider them in Sec. III B.
The second way is to use an unconventional approach to error-correction that can be integrated more directly into a logical operator implementation. Specifically, we note that error correction by teleportation (as described in Ref. [39]) allows for simultaneous implementation of a logical operator in a way that yields the teleportation gadget of Ref. [40]. Arguably, this idea is what underpins standard universal, fault-tolerant schemes, of which approaches such as state injection and code switching are variants. We refer to such channels as intrinsically faulttolerant and consider them in Sec. III C.
Gradational and intrinsically fault-tolerant quantum channels represent two broad classes of fault-tolerant logical operator implementations that can circumvent our no-go results. Table I summarises their manifestations in a range of approaches to fault-tolerantly implementing a universal set of logical operators.

B. Gradational Logical Operator Implementations
A gradational logical operator implementation is one of the form where each U i is a unitary, LNP (and hence boundedspread) quantum channel and each K i is a quantum channel that allows for error-correction, but acts trivially on logical operators. The action of such an implementation consists of channels U i that each fault-tolerantly transform the logical space interspersed with channels K i that are used to remove errors to ensure that the state of the code remains in the appropriate logical space at all times. Gradational logical operator implementations are thus fault-tolerant by construction. Indeed, the non-unitary channels, K i , ensure they are ELNP by preventing the spread of correctable errors, but also allow the spread of uncorrectable errors necessary to circumvent Corollary 1.
Gradational logical operator implementations can be understood as the minimal approach to circumventing Corollary 1. Indeed, gradational logical operator implementations can be decomposed into unitary quantum channels used to transform the logical information interspersed with error correction, which is in the spirit of standard fault-tolerant quantum computing. However, unlike unitary implementations of logical operators, intermediate error-correction is integrated into gradational logical operator implementations themselves, and cannot be avoided by increasing the code size. Indeed, since the spread of each timestep is bounded (as each U i must have bounded spread), the time taken for an unbounded-spread, gradational logical operator implementation necessarily grows with the code size, l. Thus, gradational logical operator implementations allow for universal fault-tolerant quantum computing in a natural way, but only at the cost of introducing a significant time overhead associated with unbounded-spread logical operator implementations.
We now consider two common approaches to faulttolerant logic gates that are specific examples of gradational logical operator implementations: code deformation, and pieceable fault tolerance.

Code Deformation
An important class of gradational logical operator implementations is code deformation. A gradational implementation of logical operatorĀ can be constructed by decomposing a unitary implementation ofĀ into single and two-qubit gates. By staggering the implementation of these gates such that only a constant number are implemented in each timestep, we can ensure that the spread at each such timestep remains bounded. The product of gates performed at the ith timestep then corresponds to a bounded-spread unitary quantum channel U i . As a consequence of this staggering, each U i is not individually a logical operator implementation, and in general will not preserve the logical space. Rather, each U i will map the logical code space to the logical code space of a different code. This process can be understood as a form of code deformation, C → C 1 → · · · → C m−1 → C. This code deformation can be interspersed with error correction performed at the ith timestep by a decoder, D i on code C i , to construct a gradational implementation of logical operatorĀ of the form: We note that it is standard to instead present code deformation as a measurement-based operation, in which the unitaries are omitted and measurements used to simultaneously project to a new codespace and extract an error syndrome. Our presentation is equivalent, but separates the two processes to emphasise how bounded-spread unitaries can be used to map between successive codes, such

Code Switching Direct Implementation Gradational
Code Conversion [23,24] Pieceable Fault Tolerance [16,17] Dimensional Conversion with Delayed Error Correction [18] Intrinsically Fault-Tolerant Gauge fixing [19][20][21] Magic State Injection [31] Dimensional Jumping [22] Coherent State Injection [10,[13][14][15] TABLE I. Summary of approaches to fault-tolerant, universal gate sets. The approaches are classified as gradational or intrinsically fault-tolerant, corresponding to the two classes presented in Sec. III B and Sec. III C respectively. They are also classified based on whether they are a form of code switching (fault-tolerant mapping between two codes) or direct implementation (of an unbounded-spread logical operator within a single code).
that non-unitary operations are only essential for error correction.
To ensure fault tolerance, code deformation processes must be ELNP. This depends on a number of conditions. First, each quantum channel U i should be LNP, which is consistent with Theorem 1 because it has bounded spread. Second, each intermediate code family, C i , must have a threshold for local, stochastic noise, so that there exists a decoder D i that gives a threshold on the effective noise models at intermediate times. This second condition is significant and poses a challenge, as these intermediate codes do not necessarily maintain important structures of the original code that ensure a threshold. For example, even if the original code is LDPC, the intermediate codes are not necessarily LPDC nor even stabiliser codes.
An important first example of code deformation is braiding defects in topological (and hypergraph product [41]) codes. However, while such braiding logical operator implementations are not unitary, they nonetheless have bounded spread (as shown in Appendix A 3) meaning that they are also constrained by Corollary 1.
An alternative type of code deformation that can allow Corollary 1 to be circumvented is code conversion [42]. Examples can be found by re-expressing conventional code switching [19][20][21] as a gradational process. It involves deforming between an initial and final code that together admit a universal set of bounded-spread logical operator implementations, by passing through a sequence of codes such that each mapping between successive codes has bounded spread. One such example is concatenated Steane and Reed-Muller codes [43,44], which are connected by codes that are mixed concatenations of each type of code and so can be mapped between by code conversion (as detailed in Appendix E 2) [23,24]. This allows for the (transversal) Clifford group on the concatenated Steane code to be supplemented by a gradational implementation of the non-CliffordT gate to realise a universal gate set.
A second example is dimensional conversion, which is inspired by dimensional jumping [22]. It is code conversion between topological codes of different spatial dimensions (discussed in Appendix E 2). One such example is between the 3D and 2D surface codes, which are connected by a sequence of 3D surface codes on rectangular prisms. Dimensional conversion can be used to deform between these codes to allow for the non-Clifford CCZ, which completes a universal gate set for the 2D surface code.
Dimensional conversion on higher dimensional codes illuminates the role of non-unitarity in circumventing Corollary 1. Specifically, (as discussed in Appendix E 2) we can achieve a universal set of fault-tolerant logical operator implementations by using dimensional conversion between 4D and 6D surface codes such that the codes at all timesteps are self-correcting [45,46]. Such selfcorrecting memories allow for passive error-correction, i.e. dissipation of energy into the environment, to be used instead of active error-correction. This shows that non-unitary dissipative channels can be used to circumvent Corollary 1, disproving the common belief that measurements and classical processing are essential to faulttolerantly implementing a universal gate set.

Pieceable Fault Tolerance
Even without a convenient set of intermediate codes, a gradational logical operator implementation can still be possible. An important example is pieceable fault tolerance [16,17]. This approach can be used in the case of logical operators on Calderbank-Shor-Steane (CSS) codes where all the unitary operators, U i , used in the implementation ofŪ are diagonal in the computational basis. In this case, Z-type stabilisers are left unchanged throughout and so X errors can be corrected in the standard way by measuring Z stabilisers at appropriate intervals and using the initial decoder for such errors. At the same time, Z errors are not spread by such an implementation and so their correction can be deferred until the end of the process when the state has been returned to the original logical space. Such deferral allows Z errors to accumulate uncorrected over the time taken by the logical operator implementation. However, for concatenated codes, this time corresponds to a constant factor per layer of concatenation, and so fault tolerance can be ensured [16,17].
For topological codes, simply omitting correction of Z errors at intermediate times would undermine fault tolerance [17]. This is because the time taken by pieceably fault-tolerant logical operator implementations on a topological code scales polynomially in the code distance, meaning unacceptably many Z errors can accumulate. This can be addressed by extracting syndrome information on these accumulated errors by making appropriate X measurements on intermediate states of the code, and later performing the corrections of Z errors based on this information at the end of the implementation of the logical operator. This addition of delayed error correction to pieceable fault tolerance can allow for a fault-tolerant gradational implementation on topological codes without fully implementing thresholded decoders on each intermediate code. Indeed, as discussed in Appendix E 3, this technique can be understood as the basis for the faulttolerant implementation of the non-Clifford CCZ logical operator on the two-dimensional surface code in Ref. [18].

C. Intrinsically Fault-Tolerant Logical Operator Implementations
Intrinsically fault-tolerant logical operator implementations are an alternative approach to circumventing Corollary 1. Unlike gradational implementations, intrinsically fault-tolerant implementations can be performed in constant time (independent of code size). They require that error-correction and the logical operator implementation are performed as a single process, to ensure that all correctable errors present at the time the logical operator is implemented are corrected. In particular, since errors can arise at the beginning of a timestep at which a logical operator is implemented, we cannot simply apply standard error-correction before or after the implementation of the logic gate.
However, there exists an alternative approach to error correction that can meet this requirement: errorcorrection can be implemented via teleportation [39,47] (as in Fig. 1 withŪ =Ī). Furthermore, this technique allows for a logical operatorŪ to be implemented simultaneously with the error-correction gadget [40] via gate teleportation, as shown in Fig. 1. This provides a perspective on why this teleportation-based approach is so effective for implementing fault-tolerant logical operators -it allows for fault-tolerant implementation of logical operators of unbounded spread by correcting correctable errors while transforming logical operators. The elements of the teleportation gadget that are non-unitary are the adaptive quantum channels -implementations of logical operators conditional on logical measurement outcomes. These channels propagate logical operators but not correctable errors, as needed to circumvent Corollary 1, since the former affect the logical measurement outcome but the latter do not.
In the special case of CSS codes, and logical operator implementations that spread errors only of one type (i.e., only X or only Z errors), a simplification of this approach is possible. Specifically, in this case teleportation error-correction is only necessary for the type of error that is spread by the implementation ofŪ as the other type of error can be corrected in the standard way at a later time. This gives simplified teleportation gadgets, as shown in Fig. 2.
Since the teleportation gadget emerges naturally from the requirements of an intrinsically fault-tolerant logical operator implementation, it manifests in a range of apparently distinct approaches to implementing a universal set of fault-tolerant logical operators. In particular, we now briefly review its use in the two most standard approaches: state injection and code switching.

State Injection
State injection is a straightforward application of teleportation, named to put greater emphasis on the preparation of the state in the case that the other circuit components admit simple fault-tolerant implementations.
a. Symmetric Codes -Magic State Injection: Infinite-disjointness codes that are symmetric (i.e., those with approximately equal distances of logical Pauli operators) can admit only Clifford bounded-spread logical operators (as shown by the proof of Lemma 3). Completing a universal gate set thus requires a non-Clifford logical operator, typicallyT (a logicalZ rotation by π/4). Using teleportation to implement such an operator is referred to as magic state injection. Using the circuit in  Fig. 2(a) withŪ =T , we obtain the circuit for magic state injection shown in Fig. 3. The offline preparation of the magic state,T |+ , is generally the most challenging part of the procedure, but this can be achieved (albeit with significant resource cost) by magic state distillation [25]. Examples of codes for which magic state injection can be effective include two-dimensional topological codes [48,49] and concatenated Steane codes [50]. b. Asymmetric Codes -Coherent State Injection: Asymmetric codes (i.e. those with significantly different distances of logical Pauli operators) cannot admit bounded-spread logical operator implementations that interchange arbitary Pauli operators (see proof of Lemma 2). For example, such codes with a single logical qubit do not admit a bounded-spread logical Hadamard operator, which is often sufficient to complete a universal gate set. LettingŪ =H in the circuit in Fig. 2(b) we obtain the circuit shown in Fig. 4. We refer to this technique as coherent state injection since the injected state |+ is coherent -meaning that it is a superposition of computational basis states [51]-and it is this resource that cannot be created by bounded-spread logical operators in asymmetric codes, analogously to magic in symmetric codes. Unlike magic states, coherent states can be stabiliser states and thus can be prepared even in asymmetric codes in a straightforward way. Indeed, they can be prepared in constant-time in codes that admit singleshot error-correction of X errors. Examples of codes for which coherent state injection can complete a universal logical gate set include three-dimensional surface codes [10,13], three-dimensional colour codes [14] and concatenated Reed-Muller codes. We note that coherent state injection can also be used effectively for subsystem codes, such as the Bacon-Shor code [15].

Code Switching
Code switching is an approach by which logical information is teleported between two codes to complete a uni-versal gate set. It can be understood as the intrinsically fault-tolerant counterpart to code conversion. Specifically, we take two codes, C 1 and C 2 and construct faulttolerant implementations of the logical identity between the codes;Ī 1→2 : C 1 → C 2 and its inverse,Ī 2→1 : C 2 → C 1 . These operators allow any fault-tolerant logical operator,Ū 2 , of C 2 to be implemented fault-tolerantly on C 1 byŪ 1 =Ī 2→1Ū2Ī1→2 . They are thus sufficient to lift a set of bounded-spread logical operator implementations to universality in the case that the union of boundedspread logical operator implementations of C 1 and C 2 is universal. In this case, Theorem 2 implies that if C 1 and C 2 together admit bounded-spread implementations of a universal set of logical operators, thenĪ 1→2 or its inverse must have unbounded spread.
The essential question for realising a universal gate set by code switching is thus howĪ 1→2 andĪ 2→1 can be implemented. This can be done by applying teleportation with the special case thatŪ =Ī. Unlike state injection, the primary challenge in implementing this circuit is generally not state preparation, but instead the implementation of the entangling gate between the two codes.
Code switching has been effectively used to circumvent Corollary 1 in topological and concatenated code families. Specifically, dimensional jumping [22] can be understood as a form of code switching between twodimensional and three-dimensional colour codes. Similarly, code switching can also be used to switch between concatenated Steane and Reed-Muller codes [20,21]. While these code switching schemes are typically described in the language of gauge fixing, they can be translated into fundamentally equivalent circuits based on teleportation between different codes, as discussed in Appendix E 1.

IV. CONCLUSION
In this paper, we have provided a new lens through which to view architecture design for universal, faulttolerant quantum computing. This lens takes the form of a general no-go result (Corollary 1), which excludes the possibility of implementing a universal set of logical operators using only LNP quantum channels on a large class of stabiliser (and subsystem) code families, including important examples like concatenated codes and conventional topological stabiliser codes. With this new perspective, we see how natural approaches to universal, fault-tolerant logical operator implementations can be constructed by using non-unitary quantum channels that are not LNP but are nonetheless fault-tolerant, and how a range of apparently disparate schemes that achieve universal fault-tolerant logic can be understood as instances of our approach.
A natural question that remains open is: in what other ways can our no-go result can be circumvented? A natural approach is to consider other classes of faulttolerant quantum channels that are not LNP. In partic-ular, we could construct quantum channels that map local stochastic noise models to noise models that are not local but nonetheless retain desirable properties that ensure a threshold. Specifically, such channels can allow for local errors to spread to particular errors that have a large support but are nonetheless correctable for appropriately constructed decoders [26,52,53]. In particular, Jochym O'Connor and Laflamme have presented a universal scheme using non-ELNP logical operator implementations that are constructed in such a way that local errors are mapped to errors that are correctable for any decoder that respects the concatenated structure of the code family [26], and Jochym O'Connor has presented a similar scheme based on homological product codes [52]. We discuss this further in Appendix F.
Another approach could be to use a code family that is not B-constrained. Such a code family would be unconstrained by Theorem 2 and so could conceivably admit a universal set of logical operators implemented by LNP quantum channels. As we have shown, standard code families such as conventional topological stabiliser codes and concatenated stabiliser codes are B-constrained as they necessarily have infinite disjointness. However, it is unknown whether other classes of code families, such as topological stabiliser codes with fracton order, or more general LDPC codes, necessarily have infinite disjointness. In particular, since the disjointness of a code is upper-bounded by the ratio of the number of physical qubits (n) to the code distance (d) [8], if LDPC codes with d linear in n could be found then they could be unconstrained by Corollary 1. Such a code family could potentially allow for universal, fault-tolerant quantum computing using only unitary quantum channels and thus may avoid the challenges and high overheads associated with universality in standard code families.
Conversely, if more general LDPC codes are shown to have infinite disjointness and hence are constrained by our no-go results, then the results of Sec. III could be applied to them to overcome this obstacle. Indeed, the analysis of that section could serve as a template for constructing a universal set of fault-tolerant logical operations for important code families, such as LDPC codes with asymptotically non-zero rate. This could open up promising new avenues for more efficient and practical fault-tolerant quantum computing. In this appendix, we review important classes of bounded-spread logical operator implementations. Specifically, we identify such classes, consider their fault tolerance and show that they indeed have bounded spread. This is important as it shows the breadth of applicability of Theorem 2 to a range of types of logical operator implementations.

Transversal Gates
A transversal gate is a logical operator implementation that can be decomposed into a tensor product of physical unitary operators such that no more than one physical qubit from each code block is in the support of each of these operators [3]. Transversal gates are generally assumed to be fault-tolerant on any code family. This assumption is justified for local stochastic noise, since transversal gates are LNP. Indeed, for a local stochastic noise model E with noise rate η, and a transversal gate acting on m code blocks implemented by A, Since the number of code blocks, m, is constant in l, this implies that E A is a local stochastic noise model with noise rate η A = η 1 m . Theorem 1 thus implies that transversal gates must have bounded spread. Indeed, transversal gates clearly have a spread upper-bounded by the number of code blocks on which they act, which means that they have bounded spread (when acting on a cosntant number of code blocks). This corroborates that transversal gates cannot be universal on B-constrained code families, by Theorem 2. Indeed, the fact that transversal gates do not spread errors at all within a code block means that the requirement of infinite disjointness can be dropped and so Theorem 2 can be generalised for transversal gates on any stabiliser code family [8]. In fact, it is known by other means that transversal gates cannot be universal on any code family [3].

Locality-Preserving Logical Operators
A locality-preserving logical operator is a type of logical operator implementation on topological codes that preserves the geometric locality of errors. Localitypreserving logical operator implementations are typically unitary, but we do not assume that they necessarily are. We do assume, however, that they take constant time (since they only require interactions across regions of constant size) and so such an implementation A has noisy counterpart A Eη = A • E η .
Locality-preserving logical operators also have bounded spread. Indeed, a locality-preserving logical operator, A, maps an operator, E, to A(E) with support contained in an -neigbourhood around supp(E), for some constant . In a D-dimensional code, such an -neighbourhood is contained in the union of D-cubes with side length 2 + 1 centred on each qubit in the support of E. Thus, the spread of any error, E, under the action of a locality-preserving logical operator is bounded by and so they indeed have bounded spread. Since they have bounded spread, locality-preserving logical operators are not sufficient for universal quantum computing on infinite-disjointness codes, by Theorem 2. In particular, this applies to conventional topological stabiliser codes, as shown in Appendix C. This is consistent with existing no-go results constraining the gate sets implementable by locality-preserving logical operators [4,6,9]. Locality-preserving logical operators are also LNP. Indeed, assume that A is a locality-preserving logical operator and A ⊆ supp (A(E)) for some set of qubits, A. Then, necessarily, N A ⊆ supp(E), where N A is anneighbourhood around A. Thus, the probability, that A ⊆ supp (A(E)) satisfies (A2) As discussed in the previous paragraph, theneighbourhood around A satisfes |N A | ≤ (2 + 1) D |A|. Thus, if E is a local stochastic noise model, then the probability that A is contained in an error under the effective noise model E A satisfies Thus, E A is a local stochastic noise model with noise rate η A = η (2 +1) D and hence A is LNP.

Braiding Defects
Another common approach to fault tolerance in topological codes is the introduction of defects which can be braided to implement logical operators [10,[54][55][56][57][58][59]. More recently, it has been shown that this approach can also be taken in non-topological LDPC codes, such as hypergraph product codes [41]. Braiding defects is a form of code deformation and so can be fault-tolerant provided that decoders that give thresholds can be applied at intermediate times to meet the requirements discussed in Sec. III B 1. This is relatively easy to achieve in this case, since the fact that each of the intermediate codes differ only by the configuration of defects means the same approach to decoding can be taken in all cases.
General code deformations can have unbounded spread while being fault-tolerant and so can allow universality. However, it is known that braiding defects in topological stabiliser codes cannot be universal [10]. This is because logical operators implemented by braiding defects have bounded spread and so are constrained by Theorem 2.
Indeed, assume that the standard encoding into defects is used [10]. Assume also that all topologically non-trivial paths in a topological stabiliser code with defects all have lengths that are Θ(l), meaning that they differ by at most a constant factor in the size of the code. This is reasonable for the purpose of understanding the logical operators implementable by braiding, since it can be satisfied by choosing appropriate sizes and separations of defects and the action of a braiding logical operator on the logical space is independent of these factors. Under this assumption, all non-trivial braiding processes are topologically equivalent to a product of processes in which each point on a defect is moved through a distance Θ(l). Since the image of a logical Pauli operator under the action of a braiding logical operator can be represented by the topological excitation used to implement the original logical operator following a (possibly different) braiding process [10], and all braiding processes differ by a factor, c, bounded in l, the spread of any logical Pauli operator,P , by braiding logical operator implementation B is bounded by An example of the bounded spread of logical operators under braiding is shown in Fig. 5. Meanwhile, decoding during braiding corrects all local errors (which hence are removed before they are spread beyond a constant-size region), and maps only errors of support size proportional to the code distance to logical Pauli operators, which increases their support size only by a constant. Thus, the spread of errors under braiding is also bounded. Hence, braiding defects necessarily has bounded spread.
Thus, a universal set of logical operator implementations cannot be realised by braiding defects in topological stabiliser codes, in spite of the fact that such implementations are non-unitary.

Appendix B: Sufficient Conditions for a Code
Family to be B-constrained In this appendix we show that stabiliser code families that are either asymmetric or both symmetric and infinite-disjointness are necessarily B-constrained, as de-l l FIG. 5. Example of a logical operator implemented by braiding defects. The defect configuration is four holes, such that the closest holes are separated by a distance l. Braiding one hole around another grows the support of a string-like logical operator of length l (blue) but it remains string-like and of length Θ(l), so its spread under the braid is constant. scribed in Sec. II B 2. For these proofs, recall that and we define a stabiliser code family to be B-constrained if B is not universal.

Lemma 2. An asymmetric stabiliser code family is necessarily B-constrained.
Proof. Any logical operator,V , that is not expressible as a linear combination of elements of P ↓ must instead have expression in the logical Pauli basis that contains a term, Q, outside P ↓ . This implies that for any representative, V , ofV , there exists a representative, Q, ofQ such that supp(Q) ⊆ supp(V ). Hence dV ≥ dQ and soV ∈ L ↓ . Thus, any element of L ↓ is expressible as a linear combination of elements of P ↓ . Thus, B is a subgroup of the normaliser of the subspace of logical operators spanned by P ↓ . Hence the subspace stabilised by P ↓ is invariant under the action of operators in B. Since P ↓ is a non-empty, proper subgroup of P n , this subspace is a non-trivial, proper subspace. Thus, B is not universal and so the code family is B-constrained. Lemma 3. An infinite-disjointness, symmetric stabiliser code family is necessarily B-constrained.
Proof. LetŪ be a non-Pauli logical operator. Then, there exists logical PauliP such that [Ū ,P ] is not a scalar multiple ofĪ, which implies that for the smallest-support representative P ofP and U that is the smallest-support representative ofŪ for some logical operatorV . By the scrubbing lemma [8], Rearranging and using that dŪ = |supp(U )| and Eq. (B4), this implies Since the code family is assumed to be infinitedisjointness, then taking the limit of Eq. (B6) implies Thus,Ū ∈ L ↓ . Hence, L ↓ is a subset of the logical Pauli group and so also there is some non-trivial logical PauliP in L ↓ . Since the code family is assumed to be symmetric, there is some generating set P g of the logical Pauli group such that lim l→∞ dQ dP = ∞ for anyQ ∈ P g . Thus, P g ⊆ L ↓ and so all elements of B ∈ L BPB † ∈ L ↓ ∀P ∈ P ↓ are logical Clifford operators. Thus, B is contained in the logical Clifford group, which is not universal.

Appendix C: Disjointness of Code Families
The disjointness is a measure of how many mostly disjoint representatives of logical Pauli operators a stabiliser code has [8]. Specifically, the 1-disjointness is the largest integer ∆ 1 such that each logical Pauli operator admits at least ∆ 1 representatives with mutually disjoint support (i.e. such that no qubit is in the support of more than one of the representatives for each logical operator). The disjointness of a code is lower-bounded by its 1-disjointness. In particular, for a code to be infinite-disjointness it is sufficient that lim l→∞ ∆ 1 (l) = ∞.
The disjointness is a generalisation of the 1-disjointness that also accounts for almost disjoint representatives. Specifically, the unnormalised c-disjointness (for c ≥ 1) is the largest integer, ∆ c , such that each logical Pauli operator admits at least ∆ c representatives that are c-disjoint, i.e. such that no qubit is in the support of more than c of the representatives for each logical operator. The (normalised) c-disjointness is the unnormalised c-disjointness divided by c: ∆ c = c −1 ∆ c . The disjointness of the code is the maximum value taken by the c-disjointness for any c: In this appendix, we show that concatenated stabiliser code families and conventional topological stabiliser codes families necessarily have infinite disjointness. In each case, we also comment on possible extensions.

Concatenated Codes
Concatenation of quantum-error correcting codes is a natural and effective technique for constructing code families. Specifically, for any [[n, 1, d]] quantum errorcorrecting code, C, there exists a code family such that C l is an [[n l , 1, d l ]] code constructed by the l-fold concatenation of C. More generally, we may concatenate different codes -by concatenating a sequence of [[n i , 1, d i ]] codes, we can construct a code family such that code constructed by the concatenation of the first l codes in the sequence. (We assume here that n i is bounded in i, since the idea is that the codes used in the concatenation should be small codes that are used as building blocks for the large concatenated code.) The quantum threshold theorem implies that concatenated code families indeed have a threshold against local stochastic noise [1,2].
In order to prove that concatenated stabiliser codes (i.e. concatenated code families where all codes in the concatenation are stabiliser codes) have infinitedisjointness, we first prove the following lemma showing that the disjointness of a code constructed by concatenating a pair of codes is at least the product of the disjointnesses of the two codes.
Proof. Logical operator representatives of the concatenated code are constructed by specifying a representative of the logical operator on code 1, and then, for each nontrivial Pauli operator in this representative, specifying a representative of the corresponding logical operator on code 2. For each of the codes, i = 1, 2, there exists c i such that there is a set of c i δ i c i -disjoint representatives of each logical Pauli operator of code i. Using combinations of logical operator representatives from these sets, we can construct a set of c 1 c 2 δ 1 δ 2 representatives of any logical operator on the concatenated code. Each physical qubit is in the support of one of these representatives only if the chosen code 1 logical operator representative is one of the at most c 1 with support on the block that contains this qubit and the chosen code 2 logical operator representative is one of the at most c 2 with support on the corresponding qubit within the block. Thus, each qubit is in the support of at most c 1 c 2 of the c 1 c 2 δ 1 δ 2 logical operator representatives. Hence, We now prove that concatenated codes are necessarily infinite-disjointness.

Theorem 3. Concatenated stabiliser codes are infinitedisjointness
Proof. The disjointness is a ratio of cardinalities of sets of representatives of logical Pauli operators, which are necesarily upper-bounded by the number of representatives of each logical Pauli operator (which is equal to the size of the stabiliser group, 2 n−k ). Thus, since the disjointness of any non-trivial code satisfies ∆ > 1 [8], it follows that the disjointness is bounded by ∆ ≥ 2 n−k 2 n−k −1 . Since each code used in the concatenation has a number of physical qubits, n, bounded by some constant N , this implies that there exists a constant C = 2 N −k 2 N −k −1 > 1 such that the disjointness of each code used in the concatenation is at least C.
By induction, the disjointness, δ l , of the code after l levels of concatenation thus satisfies δ l ≥ C l . Indeed, this is trivial for l = 1 and, assuming that it is true for l = m − 1, it follows by Lemma 4 that where δ is the disjointness of the lth code in the concatenation. Thus, the disjointness of the concatenated code, By Theorem 2 and Corollary 1 respectively, we thus have the following no-go results for concatenated codes.  These results can also be generalised to concatenated subsystem codes by applying the same arguments to disjointness of bare logical operators (as discussed in Sec. II B 2).
We also note that concatenated codes are a special case of tensor network codes [60] that have a tree structure. This tree structure straightforwardly gives rise to the property of having infinite disjointness -increasing l corresponds to growing the tree which increases the number of indepenent blocks on which logical operator representatives can act, implying that the number of (almost) disjoint such representatives grows exponentially in l. An interesting question for future work concerns the disjointness of other classes of tensor network codes, especially holographic codes [61][62][63]. Holographic codes have a similar structure to concatenated codes, but correspond to more complex tensor networks in which a physical qubit can be dependent on multiple tensors closer to the centre of the network. This dependence makes it less clear whether sufficiently many almost disjoint logical operator representatives can necessarily be constructed in holographic codes for them to have infinite disjointness. We note that if they, or other classes of tensor network codes, do not necessarily have infinite disjointness then they could be promising candidates to circumvent our results and could possibly realise a universal set of LNP implementations of logical operators.

Conventional Topological Stabiliser Codes
Topological codes naturally correspond to code families. Specifically, a topological stabiliser code is defined by a stabiliser group generated by operators that are geometrically local on a lattice in D ≥ 2 dimensions. This group must be chosen such that all logical operators have support on a non-local region, meaning a region of at least the size of the shortest path across the lattice which we define as l. This defines a code family as logical error rates can be arbitrarily suppressed by increasing l.
Within the class of topological stabiliser codes, we can identify a subclass we refer to as conventional topological stabiliser codes. This subclass includes all twodimensional topological stabiliser codes, all scale and translationally symmetric (STS) codes [38] including the surface and colour codes in all spatial dimensions, and all topological stabiliser codes with defects that use the standard encoding as defined in Ref. [10]. Conventional topological stabiliser codes are topological stabiliser codes that have conventional topological order [36], meaning that they can be associated with topological quantum field theories with topological excitations that correspond to error syndromes and which can propagate freely through the code. Logical Pauli operators on conventional topological stabiliser codes have representatives that correspond to topologically equivalent paths of an excitation through the code, such as paths around a handle of a torus, around a topological defect, or between two code boundaries.
Conventional topological stabiliser codes necessarily have infinite disjointness, as we show below. This implies that, by Theorem 2 and Corollary 1 respectively, we have the following no-go results for conventional topological stabiliser codes.  While the proof of infinite disjointness for general conventional topological stabiliser codes that follows is quite technical, we note that it is straightforward to see for a number of the most common instances. Indeed, in Fig. 6 we show visually how some of these instances can easily be seen to have infinite disjointness.
We also note that it is unclear whether more general topological stabiliser codes necessarily have infinite disjointness. The property for conventional topological stabiliser codes emerges from their TQFT structure; increasing l can be understood to be like fine-graining the model to allow for a greater number of topologically equivalent paths of excitations. This generalises to encodings on any topological stabiliser code that depend only on topological excitations, as in the defect encodings considered in Ref. [10]. However, more general topological stabiliser codes (in D ≥ 3 dimensions) can have more exotic excitation structures integral to their encoding [36], which makes it unclear whether they necessarily must also have infinite disjointness. In particular, it is known that the locality-preserving logical operators admitted by such codes cannot be universal [4], but if finite-disjointness topological stabiliser codes are possible it could nonetheless be the case that more general LNP implementations of logical operators could be sufficient for universality. This is an interesting question for future work.

a. Proof of Infinite Disjointness
A code on a given lattice has a set of paths through the lattice. We allow such paths to have discontinuities, provided they are locally continuous. We define two paths to be topologically equivalent if one can be deformed into the other. We thereby define equivalence classes of paths, α i , such that two paths are in the same class iff they are topologically equivalent. Such classes of paths can be defined by, for example, the boundaries they pass between or the defects (such as holes or twists) that they enclose. We define a notion of product of classes whereby α ij = α i α j denotes the equivalence class of paths that are a representative path of α i followed by a representative path of α j . We can specify an independent generating set of classes of paths, A = {α j } with respect to this product.
A logical Pauli operator,P on a conventional topological stabiliser code can be defined by associating a list of excitations of the TQFT, EP = {p j }, with each class of paths α j ∈ A. By this, we mean that that representatives ofP are compositions of p j traversing a representative path of α j , for all j. We refer to a generating path class α j ∈ A as encoding if there is someP for which p j is not trivial (i.e. such that an excitation that is not the vacuum must traverse a path in α j to implementP ). The following lemma shows that encoding generating path classes necessarily have as many disjoint representatives as the code distance (which is necessarily extensive in l).
Lemma 5. Let α j ∈ A be an encoding generating path class on a code with distance d. Then, there exist at least d disjoint representatives of α j .
Proof. Assume that there are not d disjoint representatives. Then, there exists some region of the code that is a bottleneck for α j , by which we mean that there is a set of (a) Toric code: Logical operator representatives correspond to topologically non-trivial loops around the torus. Specifically,X1 andZ2 are vertically oriented loops,X2 andZ1 are horizontally oriented loops and products such asȲ1 andȲ2 are diagonally oriented loops (which go around both holes). Disjoint representatives of each logical operator correspond to parallel loops around the torus (e.g. translating the red loop gives a disjoint, topologically equivalent grey loop). The disjointness of the code is thus lower-bounded by the circumference around the torus, which is grows with l.
(b) Colour code: Logical operator representatives correspond to topological excitations that traverse to all three boundaries. Labelling the height of the triangle, l, we can construct l representatives (of the kind shown in red and grey) such that each qubit is in the support of at most two of the representatives). The disjointness is thus bounded by l 2 which goes to infinity (c) 3D surface code:Ȳ logical operator representatives correspond to the paths of point-like charge between top and bottom faces and a line-like flux stretching from front to back passing from left face to right. We can construct l representatives (of the kind shown) so that each qubit is only in the support of at most two of the representatives. Since theX andZ operators are simply planes and columns and so have l disjoint representatives, this implies that the disjointness of the code is at least l 2 .
less than d qubits on which all representatives must have support. However, by the cleaning lemma [64], we can necessarily clean all logical operators off this bottleneck so that it acts trivially there. Thus, no logical operator can have a non-trivial excitation on α j , and so α j is not an encoding path.
We now prove that conventional topological stabiliser codes necessarily have infinite disjointness. To do so, we make the assumption that the number of independent generating path classes is constant in l, which is true if the genus of the mainfold and the number of boundaries and defects are all constant. This assumption is justified by the fact that code families are intended to provide improved protection on a given topology by increasing code size, rather than altering this topology. Proof. LetP be a logical Pauli operator. Representatives ofP correspond to a choice of representative paths from each encoding generating path class, α j . By Lemma 5, we can choose d representatives ofP such that the representatives from each α j are disjoint. Thus, the number of these representatives of which any qubit is in the support is at most the number of encoding generating path classes which by assumption is a constant in l, C. Thus, the disjointness is bounded by ∆ = d C and so lim l→∞ ∆ = ∞.

Appendix D: Proof that ELNP Unitary Quantum Channels Cannot Be Universal
In this section, we present a complete proof of the fact, stated in Sec. III A, that unitary ELNP quantum channels cannot allow circumvention of Corollary 1. This justifies the focus on non-unitary quantum channels, which are not constrained by this fact.
Lemma 6. For a unitary quantum channel, U, there exists a single-qubit Pauli error, P j such that s U = s U (P j ).
Proof. By definition of spread, there exists an error, P ∈ P n such that s U = |supp(UP U † )| |supp(P )| . P can be decomposed into a product of single-qubit Pauli errors, P = |supp(P )| i=1 P i . Using this decomposition, Thus, there exists a single qubit error, P j such that s U ≤ s U (P j ). By definition of spread, this implies that s U = s U (P j ).

Theorem 5.
A unitary quantum channel that is ELNP necessarily has bounded spread.
Proof. For any single-qubit Pauli error, P i , there exists a local stochastic noise model such that p(P i ) = η and p(I) = 1 − η, where η = 0 is the noise rate. If that noise model is applied at the first timestep, and the noise is trivial at subsequent timesteps, then the effective noise model, E U , has a probability of U(P i ) given by p U (U(P i )) = p(P i ) = η. Thus, E U can only be essentially local if U(P i ) has a support size bounded in the code size, for any single-qubit Pauli operator P i . By Lemma 6, this implies that U has bounded spread.
The following corollary follows immmediately from Theorem 2 and Theorem 5: Corollary 6. A universal set of logical operators cannot be implemented by unitary ELNP quantum channels.

Appendix E: Examples of Fault-Tolerant, Unbounded-Spread Logical Operator Implementations
In this appendix, we provide further details on approaches to universal fault-tolerant quantum computing. Specifically, we first consider code switching, both as an intrinsically fault-tolerant process and as a gradational process. We then consider pieceable fault tolerance with delayed error correction.

Code Switching
Code switching is a useful technique between two codes that have sets of logical operators admitting boundedspread implementations such that the union is a universal gate set. We have examples of such codes for both concatenated and topological code families. In particular, the Steane code admits transversal implementations of the full Clifford group, while the Reed-Muller code admits a transversal implementation of a non-Clifford (T ) logical operator. (See Table II for the definitions of these codes.) These codes can be concatenated to construct code families -the concatenated Steane code and concatenated Reed-Muller code respectively. Alternatively, the codes can be generalised to (conventional) topological stabiliser code families -the Steane and Reed-Muller codes are the smallest instances of the two-dimensional triangular and three-dimensional tetrahedral colour codes respectively. In both cases, the code families inherit the transversal gates of the original codes. Code switching between the Steane and Reed-Muller codes can thus be used as a basis for realising a universal gate set with these code families.
This code switching can be done fault-tolerantly by using the circuits in Fig. 2. Specifically, there is a transversal implementation of CNOT with the control on the Reed-Muller (or concatenated Reed-Muller or 3D colour) code and target on the Steane (or concatenated Steane or 2D colour) code. Combined with standard techniques for preparing stabiliser states and performing fault-tolerant logical Pauli measurements in CSS codes, this allows for a logical state of the Reed-Muller (or concatenated Reed-Muller or 3D colour) code to be mapped to the same logical state of the Steane (or concatenated Steane or 2D colour) code by using the circuit in Fig. 2(b) with the first wire being the former code and the second code the lat-ter. The inverse mapping can similarly be implemented using the circuit in Fig. 2(a).
We emphasise that while codes based on Steane and Reed-Muller codes serve as useful examples, code switching can be used more generally to achieve a universal fault-tolerant gate set. Of particular importance for its relationship to other schemes discussed below, we note that the 2D and 3D surface codes similarly admit a tranversal implementation of CNOT between them, and so switching can similarly be performed between them. The 2D surface code admits bounded-spread implementations of the logical Clifford group, while the 3D code admits a bounded-spread implementation of a non-Clifford (CCZ) logical operator [9,13,65], and so a universal set of faulttolerant logical operator implementations can be realised by code switching between these codes.
Our notion of code switching is fundamentally similar to a number of important schemes for fault tolerant universal sets of logical operator implementations. Indeed, we note that it is closely related to that described in Ref. [66]. More generally, Ref. [20] presents a technique for switching between Steane and Reed-Muller codes by making appropriate stabiliser measurements of the code being switched into, and applying appropriate corrections conditionally on the measurement outcomes. This scheme can be understood to differ from the code switching technique we have described only in that the physical qubits of the Steane code are considered to be a subset of those of the Reed-Muller code. Due to the related structures of the two codes, this allows for operations that act only on these qubits (specificially, the transversal CNOT and measurements on these qubits) to be omitted, producing a potentially more efficient scheme. This technique can be generalised to concatenated Steane and concatenated Reed-Muller codes by performing the same operations at all levels of concatenation. While this scheme is physically different from our code switching technique, we emphasise that it retains the essential spirit. Specifically, the measurements performed during switching and corresponding corrections can be understood to introduce non-unitarity into the logical operator implementation, by allowing for correctable errors to be detected and corrected during the implementation. Since these corrections can be necessary even in the absence of noise, and can only be corrected based on measurements made during the logical operator implementation, this process differs from standard error correction, and thus highlights the implementation's intrinsically faulttolerant nature. As described in Ref. [20], the scheme can also be related to using gauge fixing of a subsystem code to realise the Steane and Reed-Muller codes as required [21]. This process of gauge fixing similarly is an intrinsically fault-tolerant process that uses measurement and adaptive corrections to circumvent Corollary 1.
Dimensional jumping, which switches between topological stabiliser codes of different dimensions, can similarly be understood as a variation on our code switching scheme. Indeed, switching between 3D and 2D colour codes in the way described in Ref. [22] is similar to the scheme of Ref. [20], in that it corresponds to the case where the physical qubits of the 2D code are a subset of those of the 3D code, which again allows some operations to be omitted without fundamentally altering the approach used to circumvent Corollary 1. Similar to above, this procedure can also be equivalently understood in terms of fixing the gauge of a subsystem code (the gauge colour code) [19].

Code Conversion
While code switching can be implemented intrinsically fault-tolerantly, it is also possible to modify it into a gradational process -code conversion. Code conversion has the advantage that all measurements and adaptively applied operators correspond to standard error-correction on the intermediate codes. This means that, in the case where decoders can be used on the intermediate codes that are analogous to those of the codes being switched between, standard error-correction and unitary implementations of logical operators can be sufficient for switching and hence for a universal gate set. Indeed, in the case where all codes involved are self-correcting, it allows for a universal gate set without requiring any measurements and adaptive gates.
As a first example, note that it is straightforward to construct a code conversion scheme for concatentated codes, such as the concatenated Steane and Reed-Muller codes. To do so, we first construct a unitary circuit to switch between Steane and Reed-Muller codes. With qubits numbered as in Table II, such a circuit for switching from the Steane code to the Reed-Muller code is i=1,5,7 CNOT i+7,15 , where controls are on the Steane code and targets on the Reed-Muller code. The inverse of this circuit, 15 , switches from the Reed-Muller code to the Steane code. Switching between the concatenated codes can then be performed by applying this circuit at one level of concatenation at a time. Since the CNOT operators are transversal at lower levels of concatenation, the spread of this circuit applied at a single level of concatenation does not scale with l and so remains bounded. Indeed, such a circuit applied at a single level of concatenation is fault-tolerant.
It is straightforward to perform error correction at each intermediate step, since the intermediate codes remain concatenated codes and so can be decoded one level at a time. Thus, a code conversion can be performed, where l is the number of levels of concatenation, each D i is a decoder for the appropriate concatenated code and U i is the unitary quantum channel performing the necessary code switch at the ith level of concatenation. This allows the universal set of logical operator implementations to be achieved, analogously to for intrinsically fault-tolerant code switching, using gradational logical operator implementations. We note that this scheme is related to other proposed code switching schemes [23,24], but differs in that we use unitary quantum channels instead of measurements to perform switching.

a. Dimensional Conversion
It is also possible to perform code switching between different topological stabiliser codes -dimensional jumping -gradationalally. In particular, we consider the example of code conversion between (planar) surface codes in different dimensions, called dimensional conversion.
Specifically, we consider a three-dimensional surface code on an l × l × l cubic lattice and a two-dimensional surface code on an l × l square lattice. These two codes together have a universal set of bounded-spread logical operator implementations (Clifford + CCZ) and are connected by a sequence of three-dimensional surface codes on asymmetric l × l × a lattices, for 1 ≤ a < l (as shown in Fig. 7). Each of these intermediate codes can be error-corrected using any valid three-dimensional surface code decoder. Thus, code conversion between these codes can be performed if unitary, bounded-spread implementations for switching between codes on l × l × a and l × l × (a + 1) lattices can be found (for 0 ≤ a < l).
We can indeed perform such switches. Specifically, a 2D layer can be added to produce an (l × l × (a + 1)) surface code by using a locality-preserving, unitary circuit to appropriately entangle the additional layer to the boundary of an (l × l × a) surface code. Indeed, this can be done using a product of nearest-neighbour CNOT operators, as described in Sec. IX of Ref. [67]. A layer can be removed by performing the inverse circuit between the boundary that is to be removed and the adjacent 2D layer of the code (see Fig. 8). Since both switches are locality-preserving, they necessarily have boundedspread as required. We note that successively adding layers gives a unitary circuit to encode a 3D surface code from 2D slices, similar to Ref. [67], but with the addition of intermediate error-correction to ensure fault tolerance.
The process of dimensional conversion can also be applied between more general pairs of surface codes by an analogous process.
In particular, we note that dimensional conversion between the symmetric (dim(X)=dim(Z)=2) 4D surface code and an asymmetric (dim(X)=4, dim(Z)=2) 6D surface code can be achieved and is theoretically interesting. Indeed, it can be performed by adding/removing 4D surface code layers to switch between a 4D and 5D code, combined with adding/removing 5D surface code layers to switch between 5D and 6D.
The significance of this case is that the union of the bounded-spread logical operator implementations of these codes is universal (Clifford for 4D + CCZ for 6D) [9] but both codes, and all intermediate codes, are selfcorrecting (as they all have logical Pauli operators supported on manifolds of at least two dimensions) [45,46]. A self-correcting code has a logical space that is the ground space of a local Hamiltonian with the property that high weight errors correspond to high energy states and so are naturally suppressed. This means that the active error-correction applied after adding or removing each layer can be replaced by passive errorr-correction. This passive error correction can be performed by dissipation of energy into the environment, without requiring measurements or classical processing for adaptive corrections. Thus, it shows that none of adaptivity, classical processing nor even measurements are necessary to circumvent Corollary 1 -unitary channels supplemented by non-unitary dissipation is sufficient. This is noteworthy since all other universal schemes we have seen depend on these ingredients in some way, either explicitly in intrinsically fault-tolerant implementations, or implicilty by active error-correction. Hence, this example supports the reasoning in the Sec. III A that it is differential treatment of logical operators and correctable errors made possible by non-unitary quantum channels that makes universality possible, not any of these more specific requirements that are common in universal schemes.

Pieceable Fault Tolerance with Delayed Error Correction
Code conversion uses code deformation to faulttolerantly (and non-unitarily) switch between two codes that together admit a universal set of bounded-spread logical operator implementations. The gradational technique of pieceable fault tolerance can also allow direct implementation of an unbounded-spread logical operator implementation on a single code [16,17]. Indeed, the scheme of Ref. [18] for implementing a non-Clifford logical operator on the two-dimensional surface code can be understood as taking such an approach, supplemented with the additional technique of delayed error correction to address the problem of uncorrected errors accumulating over time. We here describe a perspective on the scheme, focussing on elements salient to this understanding. For a complete presentation of the scheme, we refer the reader to Ref. [68].
Specifically, Ref. [18] implements an unbounded-spread CCZ logical operator on the two-dimensional surface code. As with all logical operators there exists a unitary circuit that implements this logical operator, but this circuit requires entangling each physical qubit non-locally with a large number of other physical qubits, allowing for errors to spread over these qubits. This problem is addressed in the way discussed in Sec. III B 1 -the circuit is decomposed into an extensive number of boundedspread (in this case transversal) steps and an operation performed between each step to allow for error-correction in order to give a gradational implementation.
In principle, this gradational implementation could be performed by standard code deformation. At intermediate times, the encoded state is not a logical state of  surface codes. A boundary is viewed as a 2D surface code (split) and then a locality-preserving logical circuit that is a product of nearest-neighbour CNOT operators is applied between it and the face of the 3D code adjacent to it to disentangle it from the 3D code. The final result is that the original logical operators are mapped to the corresponding logical operators on the new code with the layer removed. (The removed layer is discarded, so its state is not important.) A layer can be added by the inverse process.
the two-dimensional surface code, but will be a logical state of some more general code on the physical qubits (i.e. that with logical space stabilised by the image of the surface code stabilisers under the action of the physical CCZ operators performed up to that point require high-weight, non-local, non-Pauli measurements, which are unlikely to be practical. The scheme avoids this problem by taking a more nuanced approach based on pieceable fault tolerance to prevent uncontrolled arising of errors without standard decoding on intermediate codes. To clarify how this is done, it is helpful to consider X and Z type errors separately, which can be done because the surface code is CSS. To address X errors, we note that the Z-type stabilisers (which detect such errors) commute with all the physical CCZ operators. This means that the Z-type stabilisers of all intermediate codes during the code deformation are the same as in the two-dimensional surface code. Thus, X errors can in principle be corrected by use of a standard surface code decoder. It is important that this correction is performed because uncorrected X errors would be spread by subsequent CCZ operators, and thus become high-weight, uncorrectable errors. In practice, it is important to the scheme that this correction is done in constant time, which requires use of just-in-time decoding [30] -a technique that allows for the single-shot error-correction of X errors in the three-dimensional surface code to be leveraged in the context of this (2+1)D scheme. However, the fundamental approach remains to correct X errors by measuring Z stabilisers and inferring syndromes, as with standard decoding.
To address Z errors, the important observation is that Z errors commute with all the physical CCZ operators and so are not spread by them. This means that correction of such errors can be delayed without concern of spreading. Indeed, this is also used in Ref. [17], where such errors are indeed left unaddressed until after the deformation is complete and a standard decoder can again be used on the original code. However, this delaying also allows for new Z errors to arise unhindered throughout the duration of the code deformation. Since this duration scales polynomially with the code size, l, increasing the code size cannot be assumed to provide improved protection against such errors. Thus, entirely delaying dealing with Z errors will not ensure maintenance of a threshold and hence will not be fault-tolerant by our definition.
In order to address this issue, Ref. [18] extends upon pieceable fault tolerance by using delayed error correction. Specifically, syndrome information about Z errors is extracted at each step of the deformation by qubitwise X measurements. In particular, a teleportation circuit is applied at the level of physical qubits. (This process involves entangling two layers of 2D surface codes, and so is interpreted in [18] as creating an (l × l × 2) 3D surface code.) This teleportation circuit can be understood as similar to teleportation error-correction (as described in Sec. III C) but performed on the level of physical qubits instead of at the logical level because the logical X operator of the intermediate codes cannot practically be measured. The X measurements performed in this circuit yield information that can be used to reconstruct the state of X stabilisers of a three-dimensional surface code equvialent to the (2+1)D surface code realised during code deformation. (Repeated measurements are not necessary because the measurements are qubitwise instead of being of whole stabilisers, and so measurement errors can be treated equivalently to physical errors [18].) Since Z errors of a 3D surface code cannot be corrected locally, correction of the errors implied by this syndrome cannot be completed until the end of the code deformation process when all measurements have been made. Nevertheless, the syndrome of Z errors on the final 2D code can be inferred from this 3D code syndrome and so Z errors can be appropriately corrected. The Z errors of the 3D code correspond to all Z errors occuring throughout the deformation and so this correction ensures fault tolerance.
In summary, the scheme of Ref. [18] may thus be understood as a gradational logical operator implementation of the form U = t i=1 K i U i . Here, each U i is a transversal implementation of physical CCZ gates such that i U i = U. Each K i for i < t can be expressed as K i = D (x) T , where D (x) is a (just-in-time) decoder that corrects X errors and T is a physical teleportation circuit that extracts syndrome information about Z errors. The final channel K t also includes correction of Z errors based on the collected syndrome information, as described in the previous paragraph. Thus, the scheme can be understood as a form of gradational logical operator implementation.
Appendix F: Non-ELNP Fault-Tolerant Quantum Channels Throughout this paper, we have focussed on quantum channels whose fault tolerance is ensured by standard threshold theorems -first LNP channels, and then more generally ELNP channels. This approach allows us to characterise general classes of quantum channels as fault-tolerant without requiring the proof of tailored threshold theorems for each channel, or requiring the use of tailored decoders. It follows the lead of most previous approaches to fault tolerance and so is appropriate for contextualising most of these approaches, as is evident from Sec. III and Appendix E.
Nevertheless, an alternative approach is possible and can allow for new approaches to implementing a universal set of logical operators. Specifically, recall from Sec. II A that a quantum channel, A is fault-tolerant for a particular stochastic noise model, E, provided that the code family has a threshold for the effective noise channel, E A , i.e. there exists a decoder D and threshold η A > 0 such that lim l→∞ D • E Aη − I ,L = 0 , for η < η A . (F1) In particular settings, it can be possible to prove that this is true even if E A is not a local stochastic noise model. This can allow A to be fault-tolerant even if it is not ELNP. In particular, this could allow for a universal set of logical operators implemented by unitary, faulttolerant quantum channels. This possibility appears to have received relatively little attention to date; while tailored decoders have been used within broader schemes to address specific problems (such as just-in-time decoding [18,30]), they have rarely been used as the single technique to circumvent no-go theorems on fault-tolerant gate sets. Thus, further exploration could be fruitful. However, we note one prominent example of this approach that has been proposed by Jochym O'Connor and Laflamme [26]. Specifically, this scheme is based on alternated concatenation of Steane and Reed-Muller codes (for a total of l 2 of each type of code). A logicalT operator is transversal on the Reed-Muller code, but the standard unitary circuit has a spread of three on the Steane code. This means that the unitary implementation of T on the concatenated code by applying the appropriate implementation at each level of concatenation has a spread of 3 l 2 since a single-qubit error can be spread by a factor of 3 for each layer of Steane code. Similarly,H is transversal on Steane codes but not Reed-Muller codes, and so similarly has spread that scales with the number of layers of Reed-Muller codes, l 2 . Hence, the implementations have unbounded-spread and so (by Theorem 1) cannot be LNP. Indeed, since they are unitary, it also follows that they cannot be ELNP (as shown in Appendix D).
Nevertheless, these unbounded-spread, unitary implementations of logical operators are fault-tolerant (i.e. have a threshold) with standard concatenated code decoders and a depolarising noise model [69]. This is possible because large errors that arise due to spreading on the layers on which a logical operator implementation is not transversal can be corrected using the other type of layer, with respect to which errors are not spread such that uncorrectable errors do not arise as a result of the implementation. Thus, if E is a depolarising channel and H and T are implementations ofH andT respectively as described then E H and E T are noise models that are non-local, but which have specific structure that arises from the deliberate construction of the code family and channels that nonetheless allows for a threshold.
We note one illuminating nuance of the scheme that prevents it from allowing for arbitary quantum gates to be implemented fault-tolerantly by unitary channels. Specifically, H is not fault-tolerant for noise model E T and T is not fault-tolerant for noise model E H , since the resulting noise models (E HT and E T H ) have nonvanishing probability of uncorrectable errors affecting both types of codes in the concatenation. This means that composite logical operators,HT andTH cannot be implemented fault-tolerantly by unitary channels; intermediate error correction is required between the implementations ofH andT . Thus, while a universal gate set (i.e. generators of a group dense in the group of all quantum gates) can be implemented fault-tolerantly by unitary channels, the composition of such gates to realise arbitary operations requires non-unitary channels. By contrast, since LNP channels map all local stochastic noise models to local stochastic noise models, any sequence of them of length constant in the code size can be applied while retaining fault tolerance.
In summary, while the scheme of Ref. [26] is ostensibly similar to intrinsically fault-tolerant schemes using Steane and Reed-Muller codes [20,21], it actually uses a fundamentally different technique to leverage the properties of these codes from code switching or gauge fixing. Specifically, this technique is based on designing a code family and quantum channels specifically to ensure fault tolerance, even without preserving the locality of noise (even up to errors of probability zero) In addition to concatenation, an alternative version of this approach based on the homological product of codes has also been proposed [52]. It may be fruitful to further pursue analogous approaches on more general code families.