The disjointness of stabilizer codes and limitations on fault-tolerant logical gates

Stabilizer codes are a simple and successful class of quantum error-correcting codes. Yet this success comes in spite of some harsh limitations on the ability of these codes to fault-tolerantly compute. Here we introduce a new metric for these codes, the disjointness, which, roughly speaking, is the number of mostly non-overlapping representatives of any given non-trivial logical Pauli operator. We use the disjointness to prove that transversal gates on error-detecting stabilizer codes are necessarily in a finite level of the Clifford hierarchy. We also apply our techniques to topological code families to find similar bounds on the level of the hierarchy attainable by constant depth circuits, regardless of their geometric locality. For instance, we can show that symmetric 2D surface codes cannot have non-local constant depth circuits for non-Clifford gates.


I. INTRODUCTION
Quantum error-correcting codes form the foundation of scalable quantum computing [1][2][3]. By construction, quantum codes serve as quantum memories by protecting encoded data from a noisy environment and successfully extending the storage time, at least if the noise is sufficiently small. However, a quantum computer should do more than just store quantum data; it needs to also apply logical operations to the data [4,5]. These operations must therefore be implemented fault-tolerantly upon quantum codes.
Generally, operators are fault-tolerant if they do not couple too many qubits within a particular codeblock. This condition is sufficient to limit the spread of errors and also guarantee that if parts of the circuitry implementing the operator were to fail that not many qubits would be affected. With respect to some partitioning of the code qubits into small, disjoint subsets Q i , a transversal operator acts on each subset of qubits Q i independently. For a family of codes with increasing size, a constant-depth logical operator is implementable by a constant (independent of the code size) depth circuit over the subsets Q i . Transversal and constant depth circuits are some of the simplest possible fault-tolerant operators both theoretically and experimentally, so it is important to understand exactly what logical operators they can implement.
Unfortunately, the set of transversal or, more generally, constant-depth logical operators is inherently limited, with computational universality generally incommensurate with the error-correction capabilities of the code. In particular, there is a no-go theorem due to Eastin and Knill which states that transversal operators on any non-trivial quantum code belong to a finite group, and thus cannot be universal [6,7]. Similar no-go theorems limiting logical operators to be in a finite level of the Clifford hierarchy were derived for transversal singlequbit gates and two-qubit diagonal gates on stabilizer codes [8], as well as for constant-depth, local circuits on stabilizer and subsystem topological codes [9,10]. The latter result has an important implication -one cannot achieve a universal gate set with constant-depth local circuits on two-dimensional (2D) topological codes such as those in [11,12]. We also remark that one can consider more general models beyond stabilizer codes, such as 2D topological quantum field theories, and characterize the set of gates implementable by locality-preserving unitaries [13,14].
Here we address several related questions regarding transversal and constant depth logical operators on stabilizer codes using a new quantity called the disjointness of the code. The disjointness, roughly speaking, is the number of mostly non-overlapping representatives of any given non-trivial logical Pauli operator. We use the disjointness to show that all transversal logical operators on stabilizer codes must be in the Clifford hierarchy, as conjectured by Zeng et al. [7]. Moreover, we find explicit upper bounds on the level attainable. Importantly, our result, when applied to families of codes of growing size, restricts constant depth circuits to the Clifford hierarchy, regardless of their geometric locality. For instance, for the 2D toric code on a square lattice of size O(l)×O(l) we find that even non-local constant depth circuits cannot implement logical non-Clifford operators. Asymmetry of logical operators appears in our bounds as a necessary condition for possessing constant depth circuits for non-Clifford gates, such as those on 3D color and toric codes [15,16] and on asymmetric 2D Bacon-Shor codes [17].

II. THE INTUITION
In this section, we sketch out the proof that constant depth circuits, even with gates that are geometrically non-local, cannot implement logical non-Clifford operators on the 2D toric code of size O(l) × O(l), see Fig. 1. We use the following two key ideas: (i) there are many non-overlapping representatives for logical PauliX and Z operators, (ii) logical operators supported on a cor- rectable region are trivial.
In order to find out what logical gate a unitary U implements, it is sufficient to characterize the action of U on the logical Pauli operators. Let [A, B] = ABA † B † represent the group commutator of two unitaries A and B [9]. We know that for any two logical Pauli operators P ,Q ∈ {X,Z}, if the group commutator [[U,P ],Q] is a trivial logical operator, then the unitary U implements a logical Clifford operator. 1 Let us pick a representative p of the logical operator P ∈ {X,Z}, such that |supp(p)| = O(l). We denote by supp(A) the set of qubits an operator A acts on nontrivially (we will later generalize this notion). Since we assume that U is constant depth, then |supp([U, p])| = O(l). Note that a tensor product of Pauli Z operators on qubits along any vertical path on the lattice would implement the logical PauliZ, see Fig. 1 The property of any stabilizer code which we would like to abstract from the provided example of the 2D toric code is the existence of several (mostly) disjoint representatives of the same logical Pauli operator. In the following sections, we will introduce a notion of disjointness of a stabilizer code, which quantitatively captures 1 Since we restrict unitary operators to the Clifford group, it is sufficient to consider generatorsX andZ of the logical Pauli group. However, restricting operators to levels of the Clifford hierarchy beyond the third requires considering all logical Paulis. that property. We remark that the disjointness of the 2D toric code is O(l), since we can find a set of O(l) non-overlapping representatives ofX orZ.

III. PRELIMINARIES
Let us consider systems composed of m-dimensional qudits, m ≥ 2. The Pauli group on a set of n qudits, denoted P n , is generated by the X-and Z-type operators 2 where addition ⊕ inside bra-kets is modulo m and ω m = exp(2πi/m). Letting U n denote the group of n-qudit unitaries, we note that P n is a subgroup of U n because X, Z ∈ U n . Any Pauli group P can be used to define a hierarchy of n-qudit unitaries called the Clifford hierarchy [18]. The M th level of this hierarchy is a finite set of unitaries (if the global phases are ignored) recursively defined as The first and second levels of the hierarchy correspond to the Pauli and Clifford groups, respectively.
In this article, we focus our attention on a particularly popular class of quantum codes -stabilizer codes [19]. A stabilizer code is defined by the stabilizer group S = s 1 , s 2 , . . . , s n−k ⊆ P n , which is generated by n − k mutually commuting Pauli operators. The codespace C is a subspace of the Hilbert space H (C m ) ⊗n on n qudits, which is the simultaneous (+1)-eigenspace of all stabilizer generators s i . We denote by n, k a qudit stabilizer code, which uses n physical qudits to encode k logical ones.
For any stabilizer code, a logical operator is a unitary on the Hilbert space H that maps states in C to states in C. In particular, logical Pauli operators can be found as elements of the normalizer N (S) of the stabilizer group S in the Pauli group P n . We choose 2k generatorsX i ,Z i ∈ P n of the logical Pauli group P k that commute with all stabilizer generators, as well as satisfy We define L to be the set of sets of all non-trivial logical Pauli operators as follows 2 Qubit Paulis m = 2 are traditionally defined to be generated by X, Z, and also Y = iXZ. Doing so does not change our results.
We remark that each element G ∈ L is a coset of S in N (S), although in examples we abuse notation and equate G with the logical Pauli it corresponds to (e.g.X = SX ∈ L). Also, G contains |S| = m n−k representatives of the same non-trivial logical operator.

IV. TRANSVERSAL GATES
All the logical operators we implement should be faulttolerant, in a sense that they do not spread errors throughout the system in an uncontrollable way. The simplest example of such an operator is a transversal logical operator U . Typically, when one says U is transversal, it means that U is a tensor product of single-qudit unitaries. However, we consider a more general definition of a transversal gate 3 . Partition the set of n physical qudits, labeled by integers from [n] = {1, 2, . . . , n}, into N disjoint, non-empty subsets Q i ⊆ [n], namely Then, we say that an n-qudit unitary U is transversal if it can be decomposed as U = N i=1 U i , where each unitary U i acts only on qudits in the subset Q i . The support of U , denoted by supp(U ) ⊆ [N ], is the index set of all subsets Q i , on which U acts non-trivially. The typical notion of transversal gate now simply corresponds to the partition into single-qudits, Q i = {i}.
We emphasize that for a given code, the set of transversal logical operators can depend on the choice of the qudit partition. In particular, if the partition is not fixed, then one can achieve a universal gate set of transversal operators, as in the following example [20].
Example 1. Consider the [[105, 1]] code, which is a concatenation of the Steane 7-qubit code with the 15-qubit Reed-Muller code. We illustrate this code in Fig. 2 as a 7 × 15 array of qubits. We consider two qubit partitions: (a) each Q i is a subset of 7 qubits from the i th column, (b) each Q i is a subset of 15 qubits from the i th row. With respect to the first and second partitions, the [[105, 1]] code has, correspondingly, transversal logical T = diag(1, e 2πi/8 ) and Hadamard gates. For more details, see [20].
In contrast, we fix a partition and prove limitations on logical operators with respect to that partition. For instance, in this fixed-partition scenario, [6] implies that the group of transversal operators is finite and therefore not universal.
Transversal unitaries are a special case of what we call q-local operators of depth h (with respect to the parti- is transversal with respect to a second, "coarse-grained" partition {R j }, where each R j is the union of at most q of the Q i . Accordingly, a q-local unitary of depth h is a product of h q-local unitaries of depth one. We note that transversal operators are 1-local unitaries of depth one.

V. DISTANCE AND DISJOINTNESS
A fundamental property of stabilizer codes is the distance. Typically, one says that the code has distance d if it can detect any error which affects at most d − 1 qudits. Here, however, we consider distance with respect to the qudit partition {Q i }. First, we define the distance d(G) of the non-trivial logical operator G ∈ L to be the size of the smallest support of any of its representatives: Then, we introduce two notions of the distance d ↓ and d ↑ , the min-and max-distance of the code, as follows, We call a code error-detecting iff its min-distance d ↓ is greater than one. Note that the min-distance d ↓ is never greater than the (standard) distance d of the code. Also, if we choose a single-qudit partition, then those two quantities coincide, d ↓ = d.
In this article, we propose a new quantity for quantum stabilizer codes, the disjointness, which proves remarkably useful for establishing limitations on logical gates. First, for any non-trivial logical operator G ∈ L and a positive integer c ≥ 1 we define c-disjointness ∆ c (G) to be the maximal number (divided by c) of representatives of G chosen in such a way that at most c representatives have support on any Q i , a subset of the qudit partition: have support on any Q i }. (10) We call the set A in Eq. (10) c-disjoint. To build intuition about the c-disjointness consider a small example.
Example 2. Consider the 4, 2 qubit code with the stabilizer group S = X ⊗4 , Z ⊗4 and the single-qubit partition. There are four equivalent logical operators implementing a logicalX 1 = X 1 X 2 , which form a set The set {X 1 X 2 , X 3 X 4 } is a maximal 1-disjoint set, Now, we are ready to define the disjointness ∆ of a code.
Definition 1 (disjointness). For any n-qudit stabilizer code with the set of non-trivial logical operators L and a qudit partition We illustrate disjointness with the following example of the 2D surface code.
Example 3. Consider the 2D surface code of size l×l encoding one logical qubit [21] and the single-qubit partition.
Moreover, there are exactly l representatives ofX with weight l, and they are all disjoint. Thus, ∆ 1 (X) = l. Similarly, ∆ 1 (Z) = l. In contrast, different representatives ofȲ necessarily overlap, but we can nevertheless find l representatives of minimal weight 2l − 1, such that each qubit is in the support of at most two of them. Those representatives ofȲ form a 2-disjoint set. Thus, ∆ 1 (Ȳ ) = 1, but ∆ 2 (Ȳ ) = l/2. We conclude that the disjointness ∆ of the surface code satisfies ∆ ≥ l/2.
The disjointness ∆ turns out to be an important quantity characterizing stabilizer codes. In particular, we use it to find bounds on the level of the logical Clifford hierarchy achievable with transversal (see Theorem 5 in Section VI) or constant-depth (see Theorem 9 in Section VII) logical unitaries. To facilitate further discussion, we present key properties of the disjointness.
Lemma 2 (properties of disjointness). For any n, k stabilizer code and any partition [n] = Q 1 ∪Q 2 ∪· · ·∪Q N , the disjointness satisfies Proof. We begin by proving four bounds on c-disjointness that together imply (i). In particular, let G, G ∈ L be two non-commuting, non-trivial logical operators. That is, [g, g ] = I for all g ∈ G and g ∈ G . Then, for any 1 ≤ c ≤ m n−k (recall m is the qudit dimension), Moreover, each upper bound holds for all c ≥ 1. The lower bound in Eq. (13) is true because any c ≤ m n−k elements of G form a c-disjoint set of size c. The upper bound in Eq. (13) results because any c-disjoint set A ⊆ G satisfies |A| ≤ |G| = m n−k . As a result of the upper bound, for any c > m n−k , ∆ c (G) < 1. Along with the lower bound, this implies min c≥1 ∆ c (G) = min 1≤c≤m n−k ∆ c (G) for all G ∈ L, which simplifies the definition of disjointenss Eq. (12).
For Eq. (14), choose a maximal c-disjoint set A ⊆ G and a representative g ∈ G of minimal support. That is, |A| = c∆ c (G) and |supp(g )| = d(G ). By definition, every g ∈ A does not commute with g . Thus, g and g have to have non-trivial overlap, |supp(g)∩supp(g )| ≥ 1. Consider any collection H ⊆ [N ] of some qudit subsets Q i . Since at most c elements of A intersect at any subset of qudits Q i , we have the inequality To get (i) from Eqs. (13)(14)(15), note that they each hold for all c, and so we can replace ∆ c (G) with max c≥1 ∆ c (G) in all three equations. Since Eq. (13) also holds for all G ∈ L, minimizing it over G immediately implies 1 ≤ ∆ as well. In Eq. (14) take G ∈ L such that d(G ) = d ↓ (and G to be any anti-commuting logical Pauli) and in Eq. (15) We now prove (ii). First, note that the implication d ↓ = 1 =⇒ ∆ = 1 follows from (i). To show d ↓ > 1 =⇒ ∆ > 1, we establish a stronger fact: for all G ∈ L, if d ↓ > 1, then there exists 1 ≤ c ≤ d(G) such that ∆ c (G) > 1. We make use of the following version of the Cleaning Lemma.
Lemma 3 (Cleaning Lemma [22,23]). For any nontrivial logical operator G ∈ L and any collection R ⊆ Suppose g is a minimal weight representative of G and set H = supp(g). Without loss of generality, we assume H = [d(G)] (which might involve relabeling the qudit subsets Q i ). For any i ∈ H, Lemma 3 and the assumption d ↓ > 1 guarantee we can find g i ∈ G that is not supported on the qudit subset Q i , i.e, i ∈ supp(g i ). We choose all distinct representatives g, g 1 , . . . , g d(G) of G to form a set A. By construction, there are at most |A| − 1 elements of the set A intersecting at any qudit subset Q i . Namely, if i ∈ H, then i ∈ supp(g i ), whereas if i ∈ H, then i ∈ supp(g).
Thus, the set A can serve as an example of a c-disjoint subset of G for c = |A| − 1, and we obtain a lower bound ∆ c (G) ≥ |A|/c > 1 on the c-disjointness of G. This, in turn, implies that the disjointness ∆ of the code is greater than one, ∆ > 1, finishing the proof of (ii).
Certain codes even have disjointness saturating the upper bound in Lemma 2(i), as in the following example.
Example 4. Consider the family of Reed-Muller codes n = 2 D+1 − 1, k = 1 for D ≥ 2, which coincides with a family of color codes of distance three in D spatial dimensions [24][25][26]. We consider the single-qubit partition. The two smallest codes in this family correspond to the 7-qubit Steane and the 15-qubit Reed-Muller codes. The distance of logicalX,Ȳ ,Z operators satisfies d(X) = d(Ȳ ) = 2 D − 1 and d(Z) = 3. Thus, d ↓ = 3 and d ↑ = 2 D − 1. There are 2 D+1 representatives ofX and 2 D+1 − 1 of them have minimal support. The set of minimal representatives ofX is, in fact, d ↑ -disjoint, and therefore ∆ d ↑ (X) = n/d ↑ . Moreover, for each representative g ofX one can always find at least one representative ofZ (and thus ofȲ ) supported on supp(g). We The c-disjointness ∆ c (G) of a non-trivial logical operator G ∈ L quantifies how well G can be "cleaned" (in the sense of [22]) from an arbitrary subset of qudits. We conclude this section with a useful lemma needed to prove main results of our work.
Lemma 4 (scrubbing lemma). Consider a non-trivial logical operator G ∈ L and a collection H ⊆ [N ] of qudit subsets Q i . For any 1 ≤ c ≤ m n−k , there exists a representative g ∈ G such that ∆ c (G)|supp(g) ∩ H| ≤ |H|.
Proof. Let A ⊆ G be a maximal c-disjoint set, |A| = c∆ c (G). Then, where we use Eqs. (16)(17) for the second inequality.
We note that if ∆ c (G) = 1, then the bound in Lemma 4 is trivial, |supp(g) ∩ H| ≤ |H|. We get a non-trivial bound whenever ∆ c (G) > 1, which is exactly the situation for error-detecting stabilizer codes, see Lemma 2(ii).

VI. LIMITATIONS ON TRANSVERSAL GATES
In this section, we use the disjointness to bound the transversal logical gates on any error-detecting stabilizer code to the Clifford hierarchy of the logical Pauli group C M = C M (P). We start with a theorem for transversal operators on a single codeblock, which we later generalize to operators between r codeblocks. Theorem 5. Consider a stabilizer code with mindistance d ↓ , max-distance d ↑ , and disjointness ∆. If M is an integer satisfying then all transversal logical operators are in the M th level of the Clifford hierarchy C M .
Proof. Let G j ∈ L be any non-trivial logical Pauli operator, and let K 0 be a transversal logical operator. We choose a representative g 1 of G 1 to have minimal support, |supp(g 1 )| = d(G 1 ). For j ≥ 1, we recursively define K j = [K j−1 , g j ], which is a transversal logical operator, and find g j+1 ∈ G j+1 satisfying Lemma 4 with H = supp(K j ). Notice that bounding the support of the group commutator of two transversal operators U 1 , U 2 is especially simple which leads to the following bound for j > 1 where the first and second inequalities were obtained by using Eq. (22) and Lemma 4, respectively. Since we may choose arbitrary c j , we set c j = argmax c≥1 ∆ c (G j ). Now, using (23) recursively, we find where in the the second inequality we used |supp(K 1 )| ≤ |supp(g 1 )| ≤ d(G 1 ) ≤ d ↑ and ∆ ≥ ∆ cj (G j ). Since |supp(K M )| is smaller than the min-distance d ↓ of the code, K M has to be a trivial logical operator. Therefore, by definition of the Clifford-hierarchy, we recursively obtain that K M −j is a logical operator from the j th level. In particular, K 0 must be in the M th level C M .
We remark that Theorem 5 implies that transversal operators on a single codeblock of any error-detecting code must be in a finite level of the Clifford hierarchy. Namely, from Lemma 2(ii) we get ∆ > 1, and thus we can always find an integer M = log ∆ (d ↑ /d ↓ ) satisfying Eq. (21). We illustrate Theorem 5 with the following examples.

Example
5. The non-CSS 5-qubit stabilizer code [27,28] has the stabilizer group S = Z 1 Z 2 X 3 X 5 , X 1 Z 2 Z 3 X 4 , X 2 Z 3 Z 4 X 5 , X 1 X 3 Z 4 Z 5 and logical Pauli representativesX = X ⊗5 andZ = Z ⊗5 has d ↑ = d ↓ = 3 and ∆ = 5/3 with respect to the single-qubit partition. Thus, d ↑ < d ↓ ∆ and so transversal logical gates must be in the Clifford group. In fact, the 5-qubit code has a transversal logical Clifford gate SH. Example 6. As we already discussed in Example 4, the Reed-Muller code n = 2 D+1 − 1, k = 1 has parameters d ↓ = 3, d ↑ = 2 D − 1 and ∆ = n/d ↑ . Thus, Theorem 5 implies that the code can have transversal logical gates from at most the M th level of the Clifford hierarchy, where M = log ∆ (d ↑ /d ↓ ) = D. In fact, the Reed-Muller code saturates this bound for any D ≥ 2, since it has a transversal logicalR D = diag(1, e 2πi/2 D ) gate. We emphasize that the transversal gates on the 105, 1 code saturate those bounds [20].
It is possible to treat multiple codeblocks (these need not even be the same code) as one large effective code. If the b th codeblock has partition {Q (b) i }, one can define a partition {Q i } of the effective code with each Q i consisting of (at most) one subset Q ↓ > 1, so too will the partition of the effective code have d ↓ > 1. Then, applying Theorem 5 to the effective code leads to the following corollary.

Corollary 6. Transversal gates on error-detecting stabilizer codes must be in the Clifford hierarchy.
This in turn implies that the group of transversal logical gates on stabilizer codes is finite and not universal, providing an alternative proof of the main result of [7].
There are subtleties with this simple argument for multi-codeblock operators. First, it leaves the possibility that the achievable level of the Clifford hierarchy might depend on the number of considered codeblocks. Second, the bound on level is not conveniently stated in terms of d ↓ , d ↑ , ∆ of the base code, but rather of the effective multiblock code. We address both of these issues in Appendix A with more detailed arguments for the multi-codeblock case. We summarize the results with the following version of Theorem 5 for stabilizer codes with multiple codeblocks.
Theorem 7 (multi-codeblock case). Consider an n, k stabilizer code constructed from m-dimensional qudits. With respect to a partition of the qudits into N subsets Q i , let the code's parameters be d ↓ , d ↑ , and ∆. Now, consider r codeblocks of this code, and let r = min(r, N !m n−k ). If M is an integer satisfying then all transversal logical operators on r codeblocks are in the M th level of the hierarchy C M .
We remark that Theorem 7 can do more than rule out universal sets of transversal operators. Any set of operators that is capable of bootstrapping itself up the Clifford hierarchy indefinitely also cannot be transversally implemented. A simple example is the Toffoli gate, which can be used to implement an M -qubit controlled-X gate C M −1 X for any M . Since the C M −1 X gate is in the M th level, no stabilizer code can implement the Toffoli gate transversally; see Appendix A for more details. We remark that the same limitation on the transversal Toffoli gate was recently proved for most quantum codes by using entirely different means [29].
Finally, a further generalization of Theorem 5 comes by considering logical operators K 0 = U P that can be written as a product of a transversal operator U and a permutation P of the subsets Q i (allowing for a different permutation on every codeblock). We can similarly restrict such logical operators to the Clifford hierarchy; see Appendix B. However, for r > 1 these logical operators do not form a group, so there is no obvious analog of the Eastin-Knill theorem [6] for them.

VII. LIMITATIONS ON SHALLOW CIRCUITS
Our methods are powerful enough to put limitations on transversal as well as shallow-depth circuits which implement logical operators on stabilizer codes with respect to the given qudit partition. In this section, we find bounds on the level of the Clifford hierarchy achievable by qlocal circuits of depth h (which may be geometrically non-local). The key ingredient needed to derive explicit bounds in terms of parameters of the code (d ↓ , d ↑ , ∆) and of the circuit (q, h) is the following lemma. Proof. First, we express the transversal operator A = i∈supp(A) A i as a product of operators A i , each of which is supported only on one of the qudit subset, i.e., Note that for any two operators V and W we have supp(V W ) ⊆ supp(V ) ∪ supp(W ). Using this fact we get and then using the union bound we arrive at This finishes the proof, since |I| = |supp(U ) ∩ supp(A)|.
With Lemma 8, we update Eq. (23) to read where h j−1 = 2 j−1 h is an upper bound on the depth of K j−1 . 4 Accordingly, by repeating the argument recursively, we obtain a version of Theorem 5 for q-local circuits of depth h.
Theorem 9 (shallow circuit case). Consider a stabilizer code with min-distance d ↓ , max-distance d ↑ , and disjointness ∆. If M is an integer satisfying then all logical operators implemented by q-local circuits of depth h are in the M th level of the hierarchy C M .
We remark that, unlike in Theorem 5 for transversal operators, there is no guarantee that there exists M satisfying Eq. (34) for q > 1. Nevertheless, the shallow circuit version Theorem 9 is still useful for bounding logical gates on code families in the asymptotic limit. Namely, consider a family of codes n(l), k(l) with parameters d ↓ (l), d ↑ (l) and ∆(l) with respect to some qudit partitions, parametrized by a positive integer l. We say that the code family has a q-local logical gate of depth h if there exists a constant l 0 such that for all l ≥ l 0 one can implement the logical gate in the corresponding codes with some q-local circuits of depth h. To rule out logical gates from outside the M th level of the hierarchy C M with constant depth h = h(l) and constant locality q = q(l), it is therefore sufficient to consider the limit of Eq. (34). We arrive at the following corollary.
then for any constants q and h all q-local logical gates of depth h are in the M th level of the hierarchy C M .
We require the limit vanish with l (rather than, say, just being less than 1) so that we can ignore the factors of constant locality and depth that appear in Eq. (34). We conclude this section with a few examples illustrating the usefulness of Corollary 10.
Example 8. Consider the family of surface codes on square lattices of size l × l. As shown in Example 3, the code parameters are d ↓ (l) = l, d ↑ (l) = 2l − 1, and ∆(l) ≥ l/2. Since for M > 1 we have thus constant-depth, constant-locality circuits on surface codes can only implement logical Clifford gates.
Surprisingly, asymmetric 2D codes can have transversal logical non-Clifford gates. For instance, asymmetric Bacon-Shor codes have the transversal logical CCZ gate [17]. We emphasize that the asymmetry in the weight of different logical Pauli operators affects the ability to bound logical gates.
Example 9. Consider the stabilizer code family of asymmetric Bacon-Shor codes in the Z-gauge on square lattices l × l a , a ≥ 1. The code parameters d ↓ (l) = l and d ↑ (l) = l a + l − 1 are asymptotically different. Similarly to Example 3, we find ∆(l) ≥ l/2. For M > a we have and thus constant-depth, constant-locality logical circuits on asymmetric Bacon-Shor codes are restricted to the ( a + 1) th level of the hierarchy C a +1 .
The multi-block versions of the asymptotic arguments (taking the limit of Eq. (27)) in these two examples yield the same bounds. One can also generalize Example 8 to other topological codes that are equivalent to the D-dimensional toric code, such as the color code [16]. Note that as in Example 9, the greater the asymmetry of the support of the logical operators (or, in other words, the difference in the dimensionality of those operators), the higher the level of the Clifford hierarchy that is accessible. It is unclear though how to bound disjointness on more exotic topological codes with fractal-like logical operators, such as Haah's cubic code [30].

VIII. DISCUSSION
We have provided explicit upper bounds on the level of the Clifford hierarchy that is accessible for logical operators on any stabilizer code, which are implemented by transversal and constant-depth circuits. We expect our techniques to apply similarly to stabilizer codes composed of qudits, which differ in local dimension. As long as stabilizers and Pauli logical operators are tensor products of Pauli operators on physical qudits, presented results and proofs should carry through.
We remark that in the proof of Theorem 5 instead of Lemma 4 we could use the following simple corollary of the Cleaning Lemma 3: for any non-trivial logical operator G ∈ L and a collection H ⊆ [N ] of qudit subsets Q i satisfying |H| ≤ d ↓ − 1, one can find a representative g ∈ G such that |H ∩ supp(g)| ≤ |H| − (d ↓ − 1). We follow the same recursive reduction of support of K j as in Theorem 5 and obtain that if M is an integer satisfying On the other hand, Theorem 5 limits the gates to the third level, which is indeed accessible in this code family, as we have seen in Example 9. However, a strengthening of the bound Eq. (38) can be achieved by using any M + 1 cleanable regions, each of which could potentially be supported on more than d ↓ − 1 qudits [31]. While our main results are derived without assumptions of geometric locality, we can derive even stronger bounds by assuming geometric locality of the circuits. For instance, D-dimensional surface codes (encoding a single logical qubit) cannot implement non-Clifford logical operators with geometrically local, constant-depth circuits. The argument follows exactly the same lines as that in Section II, relying essentially on the ability to choose representatives g 1 , g 2 of any two logical Paulis such that |supp(g 1 ) ∩ supp(g 2 )| = O(1). Since a geometrically-local circuit U cannot greatly distort the support of these representatives |supp([[U, g 1 ], g 2 ])| = O(1) as well. Note, however, that this argument breaks for geometrically local circuits that operate instead on several superimposed D-dimensional surface codes [16], while Bravyi and König's theorem would still hold in this case.
The notion of disjointness for stabilizer codes, which we introduced, appears to be difficult to calculate exactly. If stabilizer codes have some underlying structure, as Reed-Muller codes in Example 4 or topological codes in Examples 8 and 9, then we can find bounds on the disjointness, and this usually suffices to establish limits on the accessible level of the Clifford hierarchy. We believe that it is a challenging open problem to find efficient methods to compute (or approximate) the disjointness for an arbitrary stabilizer code. This problem, however, might be substantially simpler for topological codes, where one could exploit code and lattice symmetries. Also, it would be interesting to extend the notion of disjointness to the subsystem codes and find possible relations to other new stabilizer code quantities, such as the price [32]. for comments on the manuscript and who also showed the transversal gates of all stabilizer and subsystem codes are restricted to the Clifford hierarchy in unpublished work with John Preskill [31]. TJ acknowledges the support from the Walter Burke Institute for Theoretical Physics in the form of the Sherman Fairchild Fellowship. In this section, we describe how to restrict gates on multiple codeblocks to the Clifford hierarchy. We flesh out the argument in the main text by giving formulas for d ↓ , d ↑ , ∆ of the multi-codeblock code in terms of those for the the single codeblock. Then we argue how the bound on level of the Clifford hierarchy obtainable by transversal gates can be made independent of the number of codeblocks.
Consider r codeblocks of the same 5 n, k base stabilizer code, each with identical 6 qudit partitions, which we write as {Q The effective stabilizer code is formed by treating all r codeblocks as a rn, rk stabilizer code, and the qudits of the effective code can be partitioned into subsets 5 Taking the blocks to be the same is for simplification of the argument only. For instance, we do not have to deal with different quantities d ↓ , d ↑ , ∆ for each code. Running through a more general argument where the stabilizer codes are allowed to be different is possible, and similarly restricts transversal gates to the Clifford hierarchy. 6 Again, the sameness of the partitions can be relaxed at the cost of notational encumbrance.
{Q i }, each consisting of one subset from each of the r codeblocks, 3. Making a C 4 X gate with controls c1, c2, c3, c4 and target t from five Toffolis and two ancillas.
r arbitrarily can increase M 0 arbitrarily as well. This would imply that high-level transversal gates between different codeblocks are easier to find than transversal single block gates. While this may be true to some extent there is a limit, which we describe now.
The key is to realize in what instances we can find g (j) so that |H j | = |H j−1 | in Eq. (A11). This happens when we can choose g (j) so that For instance, in the simple case when σ b are each the identity permutation, then whenever G (b1) = G (b2) = G , we might as well choose the same representative g ∈ G for both g (b1) and g (b2) because then H ∩ supp(g (b1) ) = H ∩ supp(g (b2) ).
Moreover, we are guaranteed to start repeating cosets in the decomposition Eq. (A2) when r > m n−k , so effectively we can replace r in Eq. (A17) with min(r, m n−k ), thus achieving an r-independent bound. When σ b is arbitrary, we can make the same argument when G (b1) = G (b2) and σ b1 = σ b2 . Since there are finitely many permutations as well, we can replace r in Eq. (A17) with min(r, N !m n−k ), which admittedly is large but at least finite. The previous arguments complete the proof of Theorem 7.
The upshot of these finite bounds on M 0 is that we can state further no-go theorems on what particular gates can be implemented on stabilizer codes. For instance, Corollary 13. No error-detecting stabilizer code (on qubits) can implement Toffoli transversally.
Proof. There is a well-known construction [33] where, for any integer w ≥ 2, 2w − 3 Toffoli gates and 2w − 1 qubits (w − 2 of which are ancillas) suffice to make C w X, i.e. X with w control qubits. See Fig. 3 for an example with w = 4. Since C w X ∈ C w+1 , we see that having transversal Toffoli would imply transversal gates in every level of the Clifford hierarchy. But this is ruled out by the finite bound on level argued for above. The same conclusion was shown for most quantum codes in [29] by reduction to bounds in homomorphic encryption. Our proof technique can be applied to any other set of gates that is, like Toffoli, capable of bootstrapping itself indefinitely up the hierarchy.

Appendix B: Transversal gates with permutations
In this section, we extend Theorem 7 to the case of permuting transversal operators K 0 , which are those that can be written as K 0 = U P for transversal U and permutation P of the partitions H i separately for each codeblock.
As in the proof of Theorem 5, take an arbitrary sequence of cosets G 1 , G 2 , · · · ∈ L and define K 1 = [K 0 , g 1 ] = U P g 1 P U † g † 1 and K j = [K j−1 , g j ] for some choices of g j ∈ G j . The key thing to notice is that the recursive reduction of support of the K j is modified only at K 1 . Take g 1 ∈ G 1 ∈ L to have minimal support |supp(g 1 )| = d(G 1 ), so that simply because P g 1 P may have disjoint support from g † 1 . Bounding the supports of K j can then be done exactly as in the proof of Theorem 5. More generally, the argument for Theorem 7 found in Appendix A can incorporate the observation Eq. (B1) to show Theorem 14. Consider a stabilizer code with quantities d ↓ , d ↑ , ∆. Let r = min(r, N !m n−k ). If then all permuting transversal gates on r codeblocks are in C M . When r = 1, implies the same for one codeblock.
Notice that for single codeblocks r = 1 the permuting transversal operators K 0 do form a group, and thus this theorem has a corollary that the group of permuting transversal operators on a single codeblock is finite and non-universal.