Fault-tolerant logical gates in holographic stabilizer codes are severely restricted

We evaluate the usefulness of holographic stabilizer codes for practical purposes by studying their allowed sets of fault-tolerantly implementable gates. We treat them as subsystem codes and show that the set of transversally implementable logical operations is contained in the Clifford group for sufficiently localized logical subsystems. As well as proving this concretely for several specific codes, we argue that this restriction naturally arises in any stabilizer subsystem code that comes close to capturing certain properties of holography. We extend these results to approximate encodings, locality-preserving gates, certain codes whose logical algebras have non-trivial centers, and discuss cases where restrictions can be made to other levels of the Clifford hierarchy. A few auxiliary results may also be of interest, including a general definition of entanglement wedge map for any subsystem code, and a thorough classification of different correctability properties for regions in a subsystem code.


I. INTRODUCTION
The anti-de Sitter/conformal field theory (AdS/CFT) correspondence [1,2] is a particularly fruitful instance of the holographic principle [3,4] from high-energy theory -it refers to a duality between a theory of quantum gravity in D + 1 dimensions and a conformally-invariant quantum field theory on the D-dimensional boundary of the original space. It was observed in Ref. [5] that this duality has many properties in common with quantum error-correcting codes, which motivated the development of several families of error-correcting codes built out of tensor networks [6][7][8][9][10][11][12][13][14] as toy models for the holographic correspondence. These holographic codes encode information into a series of degrees of freedom which are increasingly non-local, with the degree of non-locality manifesting in the logical system as an additional emergent geometric dimension. The logical system is associated with this higher-dimensional "bulk" geometry, and the physical system with the lower-dimensional "boundary".
Quantum error correction is a remarkable idea that unlocks the possibility of feasible quantum computation [15][16][17]. Many of the leading proposals for implementing quantum error correction are based on a concept borrowed from theoretical condensed matter physics, namely topological order [18][19][20]. These topological codes [21][22][23] encode information into the (necessarily non-local) degrees of freedom that are sensitive to the topology of the surface on which the code lives. Thus they protect against local, topologically trivial, operations. The success of topological codes motivates us to assess the usefulness of these new holographic codes for practical quantum computation.
There are a number of reasons to suspect that holographic codes may be of practical use for quantum computing. Holographic codes can admit erasure thresholds comparable to that of the widely-studied surface code [6,11], and likewise for their threshold against Pauli errors [12]. Their holographic structure also naturally leads to an organization of encoded qubits into a hierarchy of levels of protection from errors, which could be arXiv:2103.13404v1 [quant-ph] 24 Mar 2021 useful for applications which call for many qubits with varying levels of protection. In particular, this is reminiscent of many schemes for magic state distillation [24,25] -and indeed, the concatenated codes [26] utilized for magic state distillation share a similar hierarchical structure to holographic codes. The layered structure of holographic codes is also reminiscent of memory architectures in classical computers, where it is useful to have different levels of short-and long-term memory. Although these codes have some notable drawbacks, in particular holographic stabilizer codes require non-local stabilizer generators, other codes such as concatenated codes suffer similar drawbacks and have still proven to be useful. Conversely, the stringent requirement of non-local stabilizer generators allows holographic codes to protect many more qubits than a topological code and in fact attain a finite nonzero encoding rate, which is typically not possible for topological codes. Nonetheless, many open questions remain about the usefulness of holographic codes for fault-tolerant quantum computing.
Beyond the robust storage of quantum information, a desirable feature of a quantum codes is the ability to perform a large set (ideally a universal set) of logical operations while maintaining the protection provided by the code. Thus it is useful to study the set of faulttolerant logic gates implementable in a given code, i.e. those that confine the spread of a physically relevant set of correctable errors sufficiently well that they remain correctable. The simplest examples are transversal gates, which do not couple the physical subsystems of the code and hence do not spread errors at all. The desirable error correction properties of these gates come at a cost, which is that they are restricted to implement a non-universal (and in fact, finite) group of logical operations on a code with non-trivial distance [27].
Topological codes possess additional geometric structure, which results in a wider class of fault-tolerant gates that subsumes the set of transversal gates: those implementable by locality-preserving operations. Localitypreserving operations are those which, when acting on a local operator via conjugation, expand the region on which it acts by a bounded amount. These preserve the correctability of errors confined to sufficiently small regions. However, like transversal gates, locality-preserving gates in topological codes are also restricted to form a finite group 1 [30,31]. Specifically, it has been shown that locality-preserving gates in topological stabilizer subsystem codes [30,32,33] in D spatial dimensions can implement only gates from C D , the D-th level of the Clifford hierarchy, which is a series of increasing sets of gates that includes the Pauli group (C 1 ) and the Clifford group (C 2 ). These sets obey C 1 ⊂ C 2 ⊂ . . . , and the bound is known to be saturated; i.e. for all D > 1, one can find a Ddimensional topological stabilizer (subsystem) code that can transversally implement a gate from C D \C D−1 , for example the color code [34,35].
Just as for topological codes, the geometric structure of holographic codes endows locality-preserving gates with fault tolerance. This raises a natural question: what restrictions does the holographic structure of these codes impose on locality-preserving gates? A natural guess for holographic stabilizer codes in D spatial dimensions might be that one can access C D+1 , the (D + 1)th level of the Clifford hierarchy, due to their locality in the extra holographic dimension and the analogy to topological codes. Here we show that the restrictions are in fact much more severe than this; namely that locality-preserving gates for such holographic codes are dimension-independently restricted to the Clifford group, C 2 .

A. Summary of results & main ideas
In this work, we show that for sufficiently localitypreserving physical gates, the restricted logical action on a sufficiently small region of the bulk cannot implement a non-Clifford gate for any stabilizer code with a holographic structure that captures certain properties of AdS/CFT in any spatial dimension. Deeper into the bulk, this restriction applies even to unitaries that expand the support of local operators by increasingly large amounts. We describe a number of generalizations of our result, including an extension to approximate stabilizer encoding maps and to the codes studied in Ref. [8] with logical algebras whose centers are non-trivial; in all these cases we show that it remains impossible to implement a logical non-Clifford gate. We also show that as our assumptions are relaxed then even if non-Clifford gates are allowed, the logical gate is still restricted to some higher level of the Clifford hierarchy determined by the size of the logical bulk region and the degree of spreading by the locality-preserving unitary.
We now explain the relatively simple idea that underlies most of our results. First, we recall the following implication of a lemma due to Pastawski and Yoshida stated informally: any stabilizer subsystem code whose physical qudits can be partitioned into three correctable regions can only support transversal Clifford gates (see below for the technical statement, Lemma II. 18). For any given instance of a holographic code and choice of small bulk subregion, it is typically easy to find a partitioning of the physical system into three correctable regions, meaning this lemma can be applied. The main contribution of this work is to argue from the physical principles of holography when and why it is possible to find such a tripartition. A key error-correcting property of holographic codes is a relationship between the correctability of two complementary regions, known as complementary recovery. We argue that so long as regions that almost satisfy complementary recovery are not too rare, then the partitioning into three correctable regions is possible -see Fig. 1. We go on to make use of the geometric structure and locality inherent to the physical qubits at the boundary of a holographic code to extend our results to cover locality-preserving unitaries. Informally, we show the following.
Theorem I.1 (Informal Statement of Theorem IV.6). If there exists an appropriate region that almost satisfies complementary recovery, and the protected bulk subsystem is sufficiently small, then any sufficiently localitypreserving unitary with well-defined logical action implements an element of the Clifford group.
We remark that there already exists a bound [32] establishing that transversal unitaries acting on logical subsystems that have sufficiently large distances, such as those associated with qubits deep in the bulk, are already confined to a particular level of the Clifford hierarchy. Our work can be seen as a strengthening of that result in the specific context of holographic codes. We apply it to non-transversal but locality-preserving gates, as well as logical qubits associated to more shallow regions of the bulk whose distances are not sufficiently large for the previously established arguments to apply.
Our results share some similarities with recent work ruling out global symmetries in AdS/CFT [36,37]. The results proved there imply that holographic codes satisfying a set of assumptions motivated by the AdS/CFT correspondence do not support any non-trivial locality preserving gates that act uniformly on the bulk encoded qubits. Our results differ on one hand as we require weaker assumptions to be satisfied by the holographic codes in question, and we consider a broader class of locality-preserving gates that may act on the bulk in a non-uniform fashion. As a consequence, our results are in a sense weaker where they overlap, only ruling out non-Clifford global symmetries in the bulk rather than all global symmetries. Our broader assumptions necessarily require this weakening of the results, as our notion of holographic codes includes the well-known HaPPY code [32], which is known to violate the stronger "no global symmetries" result by admitting non-trivial Clifford global symmetries 2 . On the other hand, we also assume additional structure by requiring the codes to be stabilizer codes, which allows us to make stronger claims about bulk logical operations that are not global symmetries.
As far as practical applications are concerned, unfortunately our main results point out an obstacle for any potential application of holographic stabilizer codes for magic state distillation. Specifically, we show that such codes essentially do not support transversal logical gates 2 Despite the no-go result in Ref. [36], such global symmetries are in fact possible when domain walls of the boundary symmetry cannot be locally mapped back into the code subspace. This does not contradict Ref. [36] as it violates the assumptions made there, we plan to discuss this further in a forthcoming work [38].

FIG. 1.
A partition of the physical qubits on the boundary into three regions R1, R2, (R1 ∪ R2) c , that are all correctable with respect to some logical qubits associated to a bulk region due to the holographic structure of the code. In this setting locality preserving logic gates U that only spread local operators by an amount SU can only implement Clifford gates on the logical qubits.
outside the Clifford group as required for magic state distillation.

B. Outline
The manuscript is laid out as follows: We first introduce background on subsystem codes in Section II and prove some of their properties that are useful for our purposes. We also introduce a general definition of entanglement wedge, termed the maximal entanglement wedge, which is defined for an arbitrary subsystem code without any assumptions of additional structure such as a particular geometry. This contributes to a growing set of such results [39][40][41] which identify holographic features that emerge from surprisingly simple quantum error-correction properties. We then describe some of the properties that we associate with holographic codes, such as complementary recovery and a geometric structure. We also review the stabilizer formalism, to emphasize some crucial subtleties that allow for a natural definition of the Clifford group on the logical space. Finally, we review background on fault-tolerant implementation of logical gates; in particular a crucial lemma from Ref. [32] (the Pastawski-Yoshida lemma) that shows that the existence of regions with certain error-correction properties implies a restriction on the logical gates implementable by locality-preserving operations.
In Section III, we consider a prototypical family of holographic codes constructed from perfect tensors; known as HaPPY codes after the authors of Ref. [6]. We show that any code made from copies of a single perfect tensor must support appropriate regions to apply the Pastawski-Yoshida lemma; and argue that this property extends to any HaPPY code built from more general combinations of perfect and planar-perfect tensors.
Since the introduction of HaPPY, many other families of holographic stabilizer codes have been introduced which extend beyond the assumptions made in Ref. [6]. Thus, we argue in Section IV on more general grounds that any holographic code that even almost captures the code properties of AdS/CFT (complementary recovery in particular) must also have their locality-preserving gates restricted to only implement Clifford gates. We also extend this argument to approximate codes such as that in Ref. [9], and to codes whose logical algebras may have non-trivial centers [8]. Finally, in Section IV G we show variants of this argument for other levels of the Clifford hierarchy. For example, even if a bulk region is sufficiently large that the arguments of Section IV do not apply, we can still establish a weaker restriction to a level C n for some n > 2. Interestingly, in other cases we are able to show an even stronger restriction than our main result. In these cases, a codespace-preserving operator that acts only on the logical subsystem and trivially elsewhere can not even implement a Clifford gate unless it is a Pauli; i.e. it is restricted to C 1 .

II. PRELIMINARIES
In this section, we introduce various properties and additional structures on error-correcting codes that are necessary to formulate and prove the main results of our work in later sections. We review subsystem and stabilizer codes, introduce the error-correction and geometric properties of holographic codes, and review some useful lemmas about locality-preserving gates.
In holographic codes, the bulk space (which we denote B) is associated with the encoded space of the code, and the boundary space (denoted ∂B) with the physical degrees of freedom of the code. Different encoded/bulk qubits have different levels of protection against error. Those near the boundary are susceptible to small errors occurring nearby on the boundary, whereas those deep in the bulk are well protected against all small errors. For this reason, it is useful to characterize the errorcorrection properties of such a code with respect to a choice of a subset of the encoded qubits that are intended to be protected while the remainder need not be. This can be accomplished with the subsystem code formalism, which we introduce here.

A. Subsystem codes
For a general error-correcting code, the physical Hilbert space H p decomposes into H p = H c ⊕H c , with H c the code subspace andH c its complement. For a standard code, the code subspace is taken to be isomorphic to a logical system H L which represents the important encoded quantum information. In the more general framework of subsystem codes, H c is isomorphic to a tensor product H L ⊗ H J , with the logical subsystem H L storing the "important information", and the junk subsystem (sometimes known as the gauge subsystem) 3 H J storing "unimportant information". This division is particularly useful when different subsystems of the code space experience different levels of protection against error, as one can evaluate the error-correction properties of H L independently of H J , which may be highly susceptible to errors. We sometimes refer to the combined system The encoding isometry V : H L ⊗ H J → H p maps the combination of these two subsystems into the physical Hilbert space. Its image is the code subspace, H c , and we denote the projector onto this subspace as Π = V V † ∈ B(H), where B(H) denotes the set of operators acting on the Hilbert space H. An operator A ∈ B(H) is said to be codespace-preserving (CSP) if it commutes with the code projector, [A, Π] = 0. As we only aim to protect the logical subsystem from error, a codespace-preserving operator that entangles the two encoded subsystems is undesirable, as it can contaminate the important information with junk information that has not been well-protected from error. Thus we focus on dressed-CSP operators, which are CSP operators A that act as a product operator on the two subsystems, i.e. V † AV = A L ⊗ A J ∈ B (H L ⊗ H J ). We say that such an operator A implements the logical operation A L ⊗A J , which is a dressed-logical operator. When the operator acts trivially on the junk subsystem, i.e. A J = 1 J , we say that A is a bare-CSP operator, and its implemented operator A L ⊗ 1 J is a bare-logical operator. We say that a pair of bare-or dressed-CSP operators A and B are logically equivalent if, up to scalar multiplication, they act the same way on the logical subsystem, i.e. A L ∝ B L .
Let us now discuss error-correction properties of subsystem codes. We present three equivalent conditions for a particular region R (that is, a collection of physical subsystems) to be correctable 4 -i.e. when it is possible 3 Operations acting on the gauge subsystem that act trivially on the logical subsystem are unimportant, as we do not care about the state of the gauge system -in this way, they are similar to gauge transformations in gauge theory, hence the name. 4 One can generalize this definition by considering correctability with respect to any particular noise channel, rather than just erasure channels as we do here. However we are primarily interested in the implications of the geometric local structure of holographic codes, which is most readily apparent when studying correctability with respect to erasure of particular regions.
to correct for the erasure of R. The conditions are expressed in terms of operators that are supported in R, by which we mean those elements of B(H) that take the Lemma II.1. For a region R of a physical Hilbert space of a code with projector Π, the following properties are equivalent [32]: • There exists a recovery channel R such that for every bare-CSP operator A, Π(R•N R ) † (A)Π = ΠAΠ, with N R (·) := tr R (·) the channel that completely erases subsystem R.
• For any operator B R supported in R, and any bare-CSP operator A, [A, ΠB R Π] = 0.
• For any logical operator A L , there exists a bare-CSP operator A supported in R c such that A im- Definition II.2. A region R of the physical Hilbert space is said to be correctable if the above conditions hold.
We remark that each of these conditions refers to bare-CSP operators, which is in turn dependent on the choice of logical subsystem H L . Some regions may be correctable for some choices of H L and not others. In the case that the junk subsystem is trivial, i.e. H L ≡ H c , then the equivalence of the first two points in Lemma II.1 corresponds to the familiar Knill-Laflamme error-correction conditions [24], and the equivalence of the third point is the so-called cleaning lemma for stabilizer codes [42].
In standard codes, there is another equivalent property to the three presented in Lemma II.1, which is that any CSP operator A supported in R implements the logical identity up to a scalar, V † AV ∝ 1. A similar property holds for correctable regions in subsystem codes, although it is not known to be a sufficient criterion for correctability in this context.

B. Entanglement wedge in subsystem codes
The encoded space of a subsystem code factorizes into a tensor product of a logical subsystem and a junk subsystem. More generally, it typically has a richer tensor product structure in the form of a decomposition into local encoded subsystems e.g. individual qudits, sites of a lattice, etc. Then each subset S ⊂ {1, . . . , n L } corresponds to a choice of logical subsystem H L = i∈S H i , with junk subsystem H J = i / ∈S H i . We then say that a region is correctable with respect to S if it is correctable with respect to the corresponding choice of logical and junk subsystems.
The correctability of a physical region is preserved under union of logical subsystems, i.e. if a region R is correctable with respect to S 1 and S 2 , it is also 5 correctable with respect to S 1 ∪ S 2 . This implies the existence of a unique "maximal" logical subsystem given by the union of all local encoded subsystems with respect to which R is correctable. We define this to be the maximal entanglement wedge of R c in the subsystem code.
Definition II.4. The maximal entanglement wedge, denoted E[R], is defined to be the union of all local encoded subsystems with respect to which R c is correctable.
Let us justify the terminology used here by comparing to the entanglement wedge as defined in holography. Any operator acting on local encoded subsystems in the entanglement wedge of R can be reconstructed in R, just as in holography. Furthermore, any alternative definition of an entanglement wedge with this property (for example, the greedy entanglement wedge map of HaPPY), must be included within the maximal entanglement wedge as defined above 6 .
We remark that this definition of maximal entanglement wedge makes no additional assumptions beyond a particular choice of decomposition into local encoded subsystems. Thus the existence of an entanglement wedge map is a general feature of any subsystem code.
Relevant to our purposes of assessing the usefulness of holographic codes for fault-tolerant quantum computation, the maximal entanglement wedge suggests a correlation between the usefulness of a subsystem code for prac- 5 This follows from the fact that any operator A supported on the Hilbert space associated with S 1 ∪ S 2 can be written as a linear combination of product operators on the spaces associated with with an implicit identity acting on systems not labelled. By correctability of R w.r.t. S 1,2 , each operator A i 1 and A i 2\1 can be implemented by a CSP operator supported on R c . These operators can be multiplied and linearly combined appropriately to implement A with a CSP operator on R c , and thus R is correctable w.r.t. S 1 ∪ S 2 . 6 We conjecture that our definition in fact coincides with that of the greedy entanglement wedge from HaPPY -essentially, perfect tensors are already so highly constrained that the entire algebra of operators on a subsystem can only be correctable if this is already guaranteed by the properties of perfect tensors.
tical error-correction against erasure of R c , and its quality as a model of holography -namely, both of these characteristics are improved when the entanglement wedge of R is larger. The former should be clear; a larger entanglement wedge means that R c is correctable with respect to more subsystems, and so more encoded information can be protected from erasures. As for the latter, we remark that there is a limit to how large entanglement wedges can be -a limit which, it turns out, AdS/CFT saturates. A given local encoded subsystem cannot belong to both the maximal entanglement wedge of a boundary region R and its complement R c , as this would imply that its bare logical operators can be reconstructed in both R and R c , which would mean that all its bare logical operators must commute; a contradiction. Thus we have in general, If this limit is saturated for some R, that is In full AdS/CFT, the entanglement wedge map is expected to satisfy this property for any region R -in this case we say that the code itself obeys complementary recovery. In fact, it is known that a subsystem code with complementary recovery automatically exhibits the Ryu-Takayanagi formula from holography [39]. Thus, codes with larger entanglement wedges -closer to the limit set by Eq. (2) -are both better at protecting from errors 7 , and more closely resemble holography.
Following this line of reasoning, several previous works have defined holographic codes to be those that satisfy complementary recovery. As we show later in Theorem IV.1, our results are particularly straightforward to state for these codes. However, this class of codes, which we refer to as ideal holographic codes, is too restrictive for our purposes. In particular, the most notable (and original) example of a holographic stabilizer code, the HaPPY code, is excluded from this class. It is relatively easy in HaPPY to construct a region with many disconnected pieces, such that the majority of the bulk qubits lie in neither its entanglement wedge nor that of its complementan example in Fig. 2c is shown where both entanglement wedges are completely empty. One can also construct connected regions in HaPPY codes which do not obey complementary recovery, for example see Fig. 2b; however these typically have only a small fraction of the bulk that lies in neither entanglement wedge. Furthermore, many regions do not have any such residual bulk region, as in Fig. 2a. Other holographic codes with promising attributes for practical application similarly fail to meet the stringent criterion of an ideal holographic code [11,12]. Thus for our purposes, a holographic code is one which (almost) saturates Eq. (2) for many regions R; the more common this property is among the code's regions, the closer to an ideal holographic code it becomes. For example, connected regions in HaPPY typically fail to satisfy complementary recovery by a small fraction of the total number of bulk sites, tending to zero in the worst case 8 as log |R|/|B| → 0 as the number of sites in the boundary diverges. Hence the connected regions in HaPPY almost satisfy complementary recovery, making it a close model of holographic features for connected boundary regions.

C. Geometric structure of holographic codes
To this point, we have only relied on the tensor product structure of the physical and logical spaces, and not on the associated geometric structures that are typically associated with holographic codes (and assumed in pictures such as Fig. 2). Although some of our results hold without a geometric structure, we require it at timesfor example, to generalize beyond transversal gates to locality-preserving gates in Section IV E.
Following Ref. [40] each local encoded subsystem in the tensor product decomposition of Eq. (1) is associated with a specific point in some continuous bulk geometry. A geometric region is then associated with the tensor product of Hilbert spaces corresponding to each local encoded subsystem located in that region. We typically identify geometric distances in the bulk with the graph distances along the graph that underlies the tensor network of the encoding isometry. The boundary geometry is then inherited by smoothly continuing this bulk geometry to the outward-facing legs of the outermost layer of tensors. We make use of the geometric structure in two ways; first, we sometimes refer to connected regions of the boundary, which are defined in terms of this geometry (e.g. in the above discussion about connected regions in HaPPY). Second, we occasionally make use of distance measures in either the bulk or the boundary; these are defined in terms of the graph distance of the relevant lattice. We assume these distance measures are normalized such that two adjacent sites are a distance of order one apart.
We now introduce some characterizations of how well protected a logical subsystem S is against errors, some of which make explicit use of the geometric structure associated with holographic codes.
Definition II.6. We define the code distance d(S) of a logical subsystem S in a subsystem code as the size (c) An example of a choice of a highly disconnected region R (shown along with its entanglement wedge in yellow) such that both it and its complement (shown along with its entanglement wedge in red) have empty entanglement wedges. This is an extreme case in which complementary recovery maximally fails to hold.

FIG. 2.
Assorted examples where complementary recovery holds or fails in HaPPY. This and following figures are adapted from those in [6].
of the smallest boundary region R that is not correctable with respect to S, with size measured by number of qubits. This is equivalent to Physically motivated topological and holographic codes come endowed with a richer geometric structure. This leads to refined notions of generalized code distance, several of which we now introduce with holographic codes in mind.
Definition II.7. We define the connected code distance d c (S) of a logical subsystem S of a subsystem code as the size of the smallest connected boundary region R that is non-correctable with respect to S, with size measured by number of qubits. This definition satisfies d c ≥ d.
Finally, we may wish to incorporate the geometric structure in any number of other ways. We define a notion of distance which depends on an arbitrary "size" function, σ(R), defined for any region R. Typically, a useful definition will satisfy other constraints, like Definition II.8. Take any notion of "size" of a region, σ(R). We define the σ-code distance d σ (S) of a logical subsystem S of a subsystem code as the minimum size of a non-correctable region, i.e.
We remark that Definition II.7 can be thought of as a special case, in which σ is defined to be infinity for non-connected regions, and the number of qubits in the region otherwise.
Along with the above definitions of distance, we recall the notion of code price [40], defined as follows.
Definition II.9. We define the code price p(S) of a logical subsystem S of a subsystem code as the minimum size of a region which can reconstruct all logical operators on S, with size measured by number of qubits. This is equivalent to As with distance, equivalent versions of the connected code price p c and the σ-code price p σ can be defined. We remark that the following is a straightforward corollary of Eq. (2).
Lemma II.10. The price is larger than the distance, We expect the entanglement wedge map in a holographic stabilizer code to be compatible with its geometric structure, as is the case in AdS/CFT. Specifically, we expect that a local extension of the bulk region should be possible by locally deforming the boundary regionthe entanglement wedge map is "smooth" in some sense 9 .
(a) An example of a region R with small κ R . The region R is shown in red, and for an expansion of 1 graph distance in the bulk, a boundary expansion of only 1 site in either direction is required; thus κ R (1) = 1. The expanded region is shown in yellow.
(b) An example of a region R with a large κ R . Expansion by 1 in the bulk requires at least 11 sites added to either side, thus κ R (1) = 11. Of course, the hyperbolic nature of geometries associated with spatial slices of AdS means that an O(1) extension of the entanglement wedge in the bulk by an amount δ may require an O(exp(r + δ)) extension to the diameter of the boundary region, where r is the distance to the boundary in AdS units (the continuous analogue of the number of layers in HaPPY). Nevertheless, this weak notion of continuity is sufficient for our purposes, as the distance of a bulk region typically also scales exponentially with r. The following definition formalizes this notion.
Definition II.11. A code is said to have a κ R -smooth entanglement wedge map if for any choice of a connected boundary region R and positive numbers δ, x that satisfy κ R (δ) ≤ x then there exists a connected bound- . In most cases we take κ R to be a non-decreasing function that satisfies κ R (0) = 0.
In the above definition κ R measures how much a boundary region R must be extended to accommodate a small extension of its entanglement wedge E(R) in the bulk.

D. Stabilizer subsystem codes
The main results of this paper refer to the Clifford hierarchy, which is closely related to the Pauli group that arises in stabilizer codes. In this section we carefully introduce this notion to point out a few subtleties.
Given a decomposition of a Hilbert space into qudits and a particular choice of basis for each qudit, one can construct a Pauli group as follows. The Hilbert space The Pauli group P is generated by generalized X operators X n = d j=1 |(j + 1) mod d n j| (with identities acting on all but the nth qudit) and generalized Z oper- A stabilizer code requires the physical space to be equipped with a specific tensor product structure and choice of local basis, and some abelian subgroup of the Pauli group S ⊂ P such that the only element of S in the center 10 of P is the identity, Z[P]∩S = {1} 11 ; this group S is called the stabilizer group. The code subspace H c is then characterized as the space of states that are +1eigenstates of all of elements S ∈ S. For a given choice of stabilizer group, there exists a unique 12 tensor product structure and local basis for the encoded space H e ∼ = H c such that the codespace-preserving physical Pauli operators implement elements of the encoded Pauli group [43]. A stabilizer subsystem code corresponds to a particular division of these encoded qudits into logical and junk subsystems such that the logical subsystem has at least one qudit 13 .
When the junk subsystem is not trivial, it may be possible that no operator supported on R c can implement the logical Pauli operator A L ⊗1 J , but some dressed-CSP operator can implement A L ⊗ A J . Thus it is useful to introduce a weaker correctability property that we term dressed-cleanable, following Ref. [32].
Definition II.12. R is dressed-cleanable if for any logical Pauli operator P L there exists a dressed-CSP operator supported on R c that implements P L ⊗ P J , for some operator P J ∈ B(H J ). 10 Recall that the center Z[A] of an algebra A is the set of elements of A that commute with all of A. 11 In other words, for j = 1, . . . , d − 1, ω j d / ∈ S. In the qubit case, this condition coincides with the familiar −1 / ∈ S. 12 The tensor product structure and local basis for the encoded space H = H L ⊗ H J are only unique up to transformation by a Clifford operation, which preserves the encoded Pauli group. 13 One can equivalently define a stabilizer subsystem code by choosing some generally non-abelian subgroup G ⊂ P, defining the stabilizer group S as the center of G, and then defining the division into logical and junk subsystems such that elements of the quotient group G/S are identified with dressed-CSP operators that act only on the junk subsystem [44,45]. This is a strictly weaker requirement than correctability. Compare both notions using tensor networks in Fig. 4.
Lemma II.13. A correctable region is also dressedcleanable.
Proof. Suppose R is correctable. Then for each barelogical operator, such as P L , there exists a bare-CSP operator supported in R c that implements it. This is also a dressed-CSP operator, satisfying the condition for dressed-cleanability.
We remark again that due to the dependence on dressed-CSP operators, Definition II.12 is defined relative to a particular choice of logical subsystem. Similar to Lemma II.3, a corresponding property holds for dressed-cleanable regions.
Lemma II.14. Suppose a region R is dressedcleanable. Then any bare-CSP operator supported on R implements a logical operation of the form c1 L ⊗ 1 J , with c ∈ C.
Proof. Suppose R is dressed-cleanable. Then take any bare-CSP operator A supported on R with V † AV = A L ⊗ 1 J . By assumption, for any P L ∈ P(H L ), one can find P supported on R c such that V † P V = P L ⊗ P J . Since A and P are supported on complementary regions, we have [A, P ] = 0, which implies [A L , P L ] = 0. Since this is true for any P L , A L must commute with all Pauli operators in P(H L ); thus it commutes with all of B(H L ), so it must be proportional to the identity, A L = c1 L .
Furthermore, although dressed-cleanability is generally a weaker requirement than correctability, these properties are in fact equivalent for a region obeying complementary recovery.
Lemma II.15. Suppose that some region R obeys complementary recovery, and it is dressed-cleanable with respect to the logical subsystem given by S. Then it is also correctable with respect to S.
, then correctability of R c ensures that logical operators on those local encoded subsystems can be implemented on R, which would be non-trivial bare-CSP operators; contradicting Lemma II.14.
In stabilizer subsystem codes, it has been shown that the converse directions for Lemmas II.3 and II.14 are also true (see Ref. [46], which is easily generalized from qubit to qudit stabilizer codes). This proof is more involved, however, and fortunately we do not need it here. There is more to be said about a number of different correctability properties of regions of subsystem codes, which we elaborate on further in Appendix A for the interested reader.

E. Fault-tolerant operations in stabilizer subsystem codes
A core result from the theory of quantum errorcorrecting codes is the Eastin-Knill theorem [27], which states that no code can allow a universal set of gates to be implemented transversally, as long as it can detect errors on a single subsystem. Several related results have strengthened this in various contexts [30][31][32][33][47][48][49][50], such as more narrowly specifying the set of gates that can be implemented transversally. For a family of stabilizer subsystem codes with locally generated stabilizer groups known as topological stabilizer subsystem codes, the Pastawski-Yoshida theorem [32] establishes a restriction on transversally implementable gates that depends only on the dimension of the code's geometry. Specifically, in D dimensions a transversal gate must implement a logical operation to the Dth level of the so-called Clifford hierarchy, which is defined as follows.
Definition II. 16. Denote P as the Pauli group on the logical subsystem H L , and the zeroth level of the Clifford hierarchy to be C 0 := C. Then the Clifford hierarchy for i > 0 is a family of sets C i of unitary operators defined recursively as follows 14 : We emphasize that this is defined in terms of the Pauli strings acting on the logical subsystem H L .
In any code with a finite distance, another set of faulttolerant gates is those that do not increase the support of an operator too much under conjugation. For example, suppose that an operator U has the property that when conjugating any local one-site operator X, the resultant operator U XU † has support on only k < d sites. Then any one-site error will remain correctable after the application of this gate. However, successive applications of these gates may expand the support of the error exponentially, unless there is some particular structure in how the errors are spread (or k = 1, for example with transversal gates).
Fortunately, when there is a geometric structure associated with physical space, such as in topological codes and holographic codes, we can restrict to a more specific class of gates with even better protection properties. If application of a unitary U causes the support of an error to spread by some bounded amount, not just in terms of the number of sites affected, but also in terms of the geometric extent of these errors, then we say that U is localitypreserving. For example, evolution by a local Hamiltonian for a short time period can be well-approximated by such a unitary, e.g. via Trotterization. We remark that unlike the previous example, successive applications of locality-preserving gates in flat geometries only spread errors to a polynomial number of total sites in the number of applications (raised to the power D, the geometric dimension), rather than an exponential number.
We now formalize this notion.
Definition II.17. The extent to which a gate U is locality-preserving is quantified by its spread s U , the maximum distance by which it can increase the support of a local operator supported on some region R. Formally, the spread of U is We remark that the spread of a transversal operator is zero.
It was shown by Pastawski and Yoshida in Ref. [32] that for any D-dimensional topological subsystem stabilizer code satisfying some basic error-correction prop- 14 We remark that this differs slightly from the standard definition of the Clifford hierarchy [30], which consists of unitaries such that U P U † ∈ C i−1 . It was shown in [32] that the definitions coincide for i > 1. For i = 1, this definition gives C 1 = P × C, whereas the standard definition gives C 1 = P. This definition also allows C 0 to be non-empty, unlike the standard definition. erties 15 , any dressed-CSP operator with sufficiently limited spread can only implement a dressed-logical operator A L ⊗ A J such that A L ∈ C D . This generalizes a result due to Bravyi and Koenig [30] that applies only to standard topological stabilizer codes. A key step in the proof of this result was the following lemma, which we make frequent use of in this work.
Lemma II.18 (Pastawski-Yoshida lemma). For a subsystem stabilizer code, let U be a dressed-CSP unitary operator supported on the union of regions {R j } j∈[0,m] . If R 0 is correctable and each R + j := B(R j , 2 m−j s U ) is dressed-cleanable for j > 0, then the logical unitary implemented by U belongs to C m .
For completeness, we replicate the proof of this lemma here from Ref. [32].
Proof. Use induction on m. For m = 0, U is a dressed-CSP operator supported on a correctable region, so by Lemma II.3, it must implement a scalar multiple of the identity on the logical subsystem, i.e. an element of C 0 , thus the base case holds. Now assume the case m holds, and that we wish to show it for m + 1. Suppose we have a dressed- Consider an arbitrary Pauli operator on the logical subsystem, P L ∈ P. Because R + 1 is dressed-cleanable, P can be implemented by a dressed-CSP operator P supported in Supp(P ) ⊆ (R + m+1 ) c . Then where we used the fact that R + m+1 = B(R m+1 , s U ) in the second last line. We can now apply the inductive hypothesis to the dressed-CSP unitary U P U † P † , so long as B(R j , 2 m−j s U P U † P † ) are dressed-cleanable. Fortunately, since s U P U † P † ≤ 2s U , this is implied by the fact that B(R j , 2 m+1−j s U ) is dressed-cleanable, and thus U P U † P † ∈ C m . By the definition of the Clifford hierarchy, we have U ∈ C m+1 . This lemma is simpler in the case that U is transversal, which implies that s U = 0 and so R + j = R j . We also introduce a stronger form of this lemma in the case that U is also bare-CSP. We prove it using virtually an identical proof to that of Lemma II.18 from Ref. [32].
Lemma II. 19. For a subsystem stabilizer code, let U be a bare-CSP unitary operator supported on the union of regions {R j } j∈[0,m] . If R 0 and each R + j := B(R j , 2 j−1 s U ) are dressed-cleanable, then the logical unitary implemented by U belongs to C m .
Proof. Use induction on m. For m = 0, U is a bare-CSP operator supported on a dressed-cleanable region, so by Lemma II.14, it must implement a scalar multiple of the identity on the logical subsystem, i.e. an element of C 0 , thus the base case holds.
The proof then follows identically to Lemma II.18, until it comes time to apply the inductive hypothesis, which now additionally requires that U P U † P † be a bare-CSP operator. Fortunately, as U is a bare-CSP operator, then even though P is only dressed-CSP, the component P J acting on the junk subsystem cancels with its inverse, and the product is indeed a bare-CSP operator.
The final lemma of this section establishes a useful sufficient condition, in terms of price, to guarantee the existence of three correctable regions that suffice to place restrictions on the logical action of fault-tolerant gates.
Lemma II.20. If a logical subsystem S of a subsystem stabilizer code satisfies the relationship then any dressed-CSP transversal unitary U can only implement an element of the Clifford group C 2 on the logical subsystem associated with S.
Proof. By definition of price, there exists some region R with size |R| = p(S) such that R c is correctable. Then as |R| ≥ 2, R can be split into two non-empty regions R 1 and R 2 such that |R 1 |, |R 2 | ≤ d(S) − 1, meaning that R 1 and R 2 are smaller than the smallest non-correctable region; thus they must be correctable. Also, recall that Lemma II.13 showed that correctability is stronger than dressed-cleanability, so these regions are also dressedcleanable. Thus we can apply Lemma II.18 with s U = 0 because of its transversality, to conclude that U implements a Clifford gate, U L ∈ C 2 .
We re-express the lemma in this way in order to crystallize the physical intuition for why holographic codes should not permit transversal non-Clifford gates for sufficiently small bulk regions. In a code satisfying complementary recovery, it was shown in Ref. [40] that the distance is equal to the price for a logical subsystem associated with a single point. Although holographic stabilizer codes do not generally satisfy complementary recovery, we use this observation as motivation to argue that the difference between price and distance is an effective measure of the effective "size" of a region, after accounting for the degree to which complementary recovery fails. In this way, Lemma II.20 can be interpreted as saying non-Cliffords cannot be transversally implemented on sufficiently small regions -i.e. those with p − d ≤ d − 2.
We remark that an analogous definition can be formed in terms of the generalized notions of price and distance, p σ (S) and d σ (S). Finally, the lemma could also be strengthened by redefining distance in terms of the smallest non-dressed-cleanable region; this would be a larger notion of distance and thus easier to satisfy Eq. (13). R 1 and R 2 would be dressed-cleanable, and thus Lemma II.18 could still be invoked.
We remark that both Lemmas II.18 and II.19 were originally proven in the context of qubit stabilizer codes, but easily generalize to qudits. From here on, we restrict our exposition to the case of qubits for simplicity, however we emphasize that all of our results apply likewise to qudit-based holographic stabilizer codes.

III. HAPPY CODES & NON-CLIFFORD GATES
The simplest holographic stabilizer code, commonly referred to as HaPPY [6], is built out of perfect tensorsa class of tensors with particularly nice error-correction properties that allow the entanglement wedge map to mimic the geometric behaviour of AdS/CFT. As the encoding map is given by a tensor network built from identical local encoding tensors, any gates that can be implemented transversally on this encoding tensor are inherited by the larger network 16 . For example, the standard choice of perfect tensor is the encoding isometry of the five-qubit code (see the appendix of Ref. [6] for a review). This code admits a transversal gate set generated by the homogeneous tensor product of single site Pauli group elements and the Clifford gate K, which can be defined as mapping X → Z → Y → X under conjugation [57]. Transversal implementation of the group generated by these gates is inherited by the larger network built out of this perfect tensor, as shown in Fig. 5. This is the most straightforward way in which a holographic code can allow for transversal implementation of a logical gate; and we now argue that no non-Clifford gate can be implemented in such a fashion.
Consider a rank-2N tensor T i1,i2,...,i 2N , and suppose that for any n ≤ N , the matrix given by lowering the first n indices is an isometry, i.e. If this holds not only for the first n indices but for any choice of n indices, then we say that T is a perfect tensor. We remark that the tensor need not be permutation invariant, i.e. it may form different isometries depending on which legs are chosen to be inputs and which to be outputs. For a review of perfect tensors, see Ref. [6].
with the distance of N being guaranteed by the perfect tensor property (see Ref. [6] for details). Furthermore, it guarantees that any region of N − 1 qubits or fewer is correctable. Thus, the 2N − 1 qubits in the physical system can easily be partitioned into three sets such that each is correctable. By Lemma II.18, this means that for any transversal unitary U , the logically implemented gate is a Clifford, V † U V ∈ C 2 . Furthermore, the same can be said about holographic codes built from a slightly broader class of tensors known as planar perfect [58] or block perfect [11]. In these tensors, the order of the indices matters -the isometry property is only required to hold for a set of n consecutive indices (where i 2N is understood to be adjacent to i 1 ).
Of course, the above argument does not rule out the possibility of transversally implemented non-Clifford gates in networks built out of these tensors -it only excludes the simplest possible way for such a gate to be implemented, which would be that it is transversal on each individual tensor that makes up the network. Nevertheless, rigorous arguments can be formulated that rule out any kind of transversal non-Clifford in a HaPPY code. Essentially, one starts with a logical operator on some central tensor and considers the boundary regions that it can be pushed out to at each successive layer of the network. Due to the "negative curvature" (which is a necessary requirement for the network to form a bulk to boundary isometry), the angular size of the region which can be pushed to does not increase too much layer by layer; the total size of each layer grows at least as quickly as the region being pushed to does. Thus the complement of the region being pushed to, which is correctable, is sufficiently large that one can divide the physical space into three such regions and proceed by applying Lemma II.18 to exclude the possibility of transversal non-Cliffords.
In Appendix B, we use a rigorous form of the above argument to prove that any HaPPY network built out of a homogeneous hyperbolic planar tiling does not accommodate the transversal application of non-Cliffords. We remark that the idea behind our proof of no transversal non-Clifford gates in holographic tensor network stabilizer codes can be extended to rule out more general locality preserving gates. In the following section we describe such a generalization for more general families of sufficiently holographic stabilizer codes that should include tensor network codes as a special case.

IV. COMPLEMENTARY RECOVERY & NON-CLIFFORD GATES
In the previous section we argued that HaPPY codes generally cannot admit transversal non-Clifford gates. In this section we turn our attention to wider families of holographic codes that have been introduced and studied more recently. The natural question that occurs is whether the transversal Clifford restriction is a particular attribute of HaPPY codes, or a more general phenomenon due to some underlying physical reason that extends to these other families. In Section IV A we argue for the latter -specifically that it is a consequence of any code for which regions satisfying complementary recovery are sufficiently common. In fact, the argument we present can even apply if no regions satisfy complementary recovery, as long as some almost do (see Section IV C). We extend to finite-size regions of the bulk in Section IV B, codes with only approximate stabilizer encoding maps in Section IV D, non-transversal locality-preserving gates in Section IV E, and codes with non-trivial centers in Section IV F.

A. Complementary recovery & transversal non-Clifford gates
First, we begin with a proof that satisfying complementary recovery for every region is sufficient to exclude transversal non-Cliffords. A stronger variant of this theorem is one in which only every connected region needs to satisfy complementary recovery. This is stronger for two reasons: firstly, the assumption is less stringent and applies to more codes, and secondly, the assumption of d c ≥ 2 is weaker than d ≥ 2.
Theorem IV.1. Consider a holographic stabilizer code with encoding isometry V , and a particular choice of local bulk subsystem i. Suppose that every (connected) region satisfies complementary recovery, and the (connected) code distance is at least d (c) ({i}) ≥ 2. Then any transversal dressed-CSP unitary U can only act on this subsystem via an element of the Clifford group, Proof. Let the region R be the smallest non-correctable region. As R is non-correctable, the entanglement wedge of its complement E[R c ] cannot contain i. By complementary recovery, this means that i ∈ E[R], and so R c must be correctable. Since we have a (connected) region of size d (c) ({i}) with a correctable complement, the price must be at most d Of course, insisting on complementary recovery for every region, or even every connected region, is highly restrictive. We do not even know if such a holographic stabilizer code exists 17 . Fortunately, the following theorem requires a much weaker sufficient condition to exclude the possibility of transversal implementation of non-Clifford gates on a logical subsystem. The idea is that we need just one region R satisfying complementary recovery to exist that would be suitable for use in the proof of Theorem IV.1. This region R need only satisfy a few basic properties for the proof to work.
Theorem IV.2. Consider a holographic stabilizer code with encoding isometry V , and a particular choice of local bulk subsystem i. Suppose there exists a non-correctable (connected) region R with size 2 ≤ |R| ≤ 2d (c) ({i}) − 2 that obeys complementary recovery 18 . Then any transversal dressed-CSP unitary U can only act on this subsystem via an element of the Clifford group, Proof. The proof proceeds exactly as that of Theorem IV.1.
An example of the construction used in this proof is shown in Fig. 6. In many holographic codes, such as certain instances of HaPPY, we expect the connected code distance to be significantly larger than the code distance, making the connected form of this theorem again more useful 19 .
FIG. 6. An alternating pentagon-hexagon HaPPY code. We show how to construct three appropriate regions to be used in the proof of Theorem IV.2. In this case, the logical subsystem consists of only the central bulk qubit, and its connected code distance dc is 13; an example of a connected non-correctable region R with this size, along with its entanglement wedge, is highlighted in yellow. In this case, R obeys complementary recovery, and hence can be used to prove Theorem IV.2 as follows: due to complementary recovery, R c (highlighted along with its entanglement wedge in blue), is correctable. Furthermore, the two regions highlighted in red must be correctable as they are smaller than R, the smallest non-correctable region; thus the boundary partitions into three correctable regions. Lemma II.18 then implies that a non-Clifford gate cannot be applied transversally on the central qubit.
In any case, the definition of (connected) code distance implies the existence of at least one non-correctable region of size d (c) ; in addition to a number of (connected) supersets of this region that are also non-correctable and smaller than 2d (c) − 2. As long as regions obeying complementary recovery are not too rare, which they should not be for a purported holographic code, at least one such region will obey complementary recovery and the theorem will apply. For example, although HaPPY codes do not generally obey complementary recovery, Fig. 6 shows an example of a HaPPY code in which an appropriate region can still be found to apply Theorem IV.2.
One can also construct a variant for any definition of size σ(R), as per Definition II.8, so long as it is always possible to break a region into two smaller regions according to this notion of size. As long as the assumptions are satisfied for any such notion of size, the conclusion holds.
One can strengthen this theorem by noting that the three regions do not necessarily need to be correctable. Two regions need only be dressed-cleanable, which is a weaker condition in general -relaxing the assumptions necessary to apply the theorem. For example, the red and blue regions of the HaPPY code in Fig. 8 are both dressed-cleanable but not correctable. We remark that this freedom is irrelevant in a code with all regions satisfying complementary recovery, due to Lemma II.15 -which also suggests holographic codes should not generally have too large a difference between dressed-cleanable and correctable regions.
It follows from the proof that if R is close to d (c) in size, then there is significant "room to spare" when dividing the boundary system into three correctable regions. That is, R 1 and R 2 are not only smaller than the smallest non-correctable region; they are roughly half its size. Instead of choosing R 0 , R 1 and R 2 to be mutually non-intersecting, we could instead choose them to have some overlap while still being correctable and satisfying R = R 0 ∪ R 1 ∪ R 2 . Such an overlap proves useful in many of our subsequent extensions of this simple initial setup.
For example, it proves useful in generalizing beyond the case where the logical subsystem S ⊂ {1, . . . , n L } is chosen to consist of only a single local encoded subsystem i. First, let us point out why the argument as presented above breaks down if multiple local encoded subsystems are included -for example, suppose that two local encoded subsystems are contained in the logical subsystem, S = {i, j}. Then it may be the case that i ∈ E[R c ] and j ∈ E[R], in which case both R and R c are non-correctable with respect to {i, j} -even if complementary recovery is satisfied. By contrast, with a single local encoded subsystem, complementary recovery guaranteed that either R or R c be correctable. Nonetheless, in many cases three appropriate regions can still be constructed for a collection of sites in the bulk; an example in a HaPPY code is shown in Fig. 7. We argue below that due to the existence of "room to spare" in the above argument, this should generally be the case.

B. Finite-size bulk regions
We now generalize our argument to bulk regions with a finite, non-zero size. First we attempt to provide some intuition: We have seen that a logical subsystem associated to a point in a holographic code satisfies (connected) distance equals (connected) price. For extended bulk regions this equality no longer holds. However, from AdS/CFT we expect for the logical subsystem associated to a ball of radius δ in the bulk p c ≤ d c + κ(δ), where κ(δ) grows exponentially with δ for any spatial dimension. Hence for sufficiently small bulk regions of a code with a holographic structure we expect 2 ≤ p c ≤ 2d c −2 is still satisfied. By Lemma II.20 this implies that transversal gates can only act via Cliffords on the logical subsystem associated to any such bulk region. This argument is extended to locality-preserving gates for logical regions that are sufficiently deep within the bulk below.
To make this generalization more rigorous we need to make reference to the geometric structure of the code, as introduced in Section II C. Specifically, we use the notion of a κ R -smooth entanglement wedge map. As discussed where it was introduced, κ R is typically exponentially large in r; however the amount of "room to spare" available from the proof of Theorem IV.2 is proportional to FIG. 7. An example with a bulk region containing more than one site, illustrating theorem IV.3. More perfect tensors than usual, colored (not highlighted) yellow, are included in order to be able to pick boundary regions with greater precision. A non-correctable region R has an entanglement wedge bordering the logical region. R needs to be expanded only slightly, to R d , in order to include the whole of the logical region. Thus R c d is correctable. Furthermore, we can break R d into two correctable regions, highlighted in yellow and red. Thus we have found three correctable regions and Lemma II.18 can be applied.
the code distance d, which is also expected to be exponential in r for deep bulk inputs. Thus we are usually able to trade this overlap for the inclusion of a size O(1) region in the bulk.
Theorem IV.3. Consider a holographic stabilizer code with encoding isometry V , and a particular choice of local bulk subsystem S of diameter D S with a κ R -smooth entanglement wedge. Suppose there exists a non-correctable connected region R with size 2 ≤ |R| ≤ 2d c (S) − 2 − κ R (D S ) that obeys complementary recovery. Then any transversal dressed-CSP unitary U is constrained to act on this subsystem via an element of the Clifford group, Proof. As R is not correctable and obeys complementary recovery, there is at least one subsystem i ⊂ S contained in E(R). S ⊂ B(E(R), D S ) because the distance between two points in S is at most D S . Thus, if x = κ R (D S ) then there exists a connected boundary region R x such that S ⊂ E(R x ), meaning its complement R c x is correctable. Thus the code price is upper bounded by |R x | = |R| + x, which in turn is upper bounded by 2d c (S) − 2, so we can apply Lemma II.20 to conclude the proof.

C. Almost complementary recovery
We now move on to consider a more general case where the entanglement wedge map is smooth, but the region R only almost obeys complementary recovery. In this case, i may not belong to the entanglement wedge E[R], but a slightly larger R + ⊃ R can be chosen such that i ∈ E[R + ], and thus R +c is correctable with respect to {i}.
Definition IV.4. We say that a region R satisfies εalmost complementary recovery if it can be expanded by ε in all directions, such that the new entanglement wedge includes the complement of the entanglement wedge of Theorem IV.5. Consider a holographic stabilizer code with encoding isometry V , and a particular choice of local bulk subsystem S of diameter D S with a κ R -smooth entanglement wedge.
Suppose there exists a non-correctable connected region R with size 2 ≤ |R| ≤ 2d(S) − 2 − κ R (D S ) − ε that obeys εcomplementary recovery. Then any transversal dressed-CSP unitary U can only act on this subsystem via an element of the Clifford group, Proof. The proof is a straightforward combination of Definition IV.4 with the proof of Theorem IV.3.

D. Approximate stabilizer codes
AdS/CFT is believed to not be an exact quantum error-correcting code, as its error-correction properties only hold to first order in a perturbative expansion [5]. Instead, it is best understood as an approximate code [5]. One family of toy models [9] attempt to capture this aspect of AdS/CFT in terms of an encoding map that is only approximately equal to an encoding isometry of a stabilizer code. Specifically, the map V : H L → H P is given by with V 0 an encoding isometry for a stabilizer code, and δV some small perturbation; δV 1 = ε for some small ε > 0.
In such a case, it is straightforward to see that a CSP unitary must implement a logical gate which is approximately equal to an element of the Clifford group. To see this, note that V 0 is an exact holographic stabilizer code, and thus the unitary applied to this code implements some element of the Clifford group, Then one can show using Hölder's inequality that i.e. the logical operation implemented by the full code V is close to an element of the Clifford group.

E. Non-transversal locality-preserving gates
We now combine the Pastawski-Yoshida lemma Lemma II.18 with the geometric structure introduced in Section II C to extend the previous result to the case of unitaries that are not necessarily transversal, but are still locality-preserving -i.e. that have some finite spread s U > 0.
This generalization is simplest to formulate when the spatial boundary geometry is one-dimensional.
Theorem IV.6. For a subsystem stabilizer code S with a one-dimensional boundary, if there is a non-correctable region R of size d c ({i}) that satisfies complementary recovery then any dressed-CSP unitary operator U with s U < dc 6 implements a logical unitary in C 2 on the logical system {i}.
Proof. To apply Lemma II.18, we need to partition the boundary space into three regions such that one is correctable, one is correctable even after expansion by a distance of s U either side, and one is correctable after expansion by 2s U either side. Furthermore, the definition of d c means that any connected region smaller than d c is correctable. Thus we can proceed as follows.
Parametrize the interval R as [0, d c ], and choose R 1 as [0, 2dc 3 ] and R 2 as [ 2dc 3 , d c ]. Then for any unitary with spread s U < dc 6 , the extended regions are both less than d c in length, and therefore remain correctable; R 0 also remains correctable, and thus Lemma II.18 applies.
More generally, this argument extends to higher dimensions as follows: let d be the size of the smallest non-correctable region. Let R be a connected region of size d. We then split R into two regions R 1 and R 2 of sizes 2d 3 and d 3 , respectively. We assume that we can choose sufficiently nice regions R 1 and R 2 in the sense that the size of their extensions B(R i , s) do not increase too fast 21 with s. Then for sufficiently small s U the re-gions R + i = B(R i , 2 2−i s U ) have size smaller than d and thus remain correctable. We can then apply Lemma II.18 to achieve the desired result. Following this line of reasoning, Theorem IV.6 generalizes straightforwardly to a higher dimensional setting where the boundary is a sphere and the region R is a ball. At this time we do not know of a clean statement of the most general higher dimensional version of our result. This is in part due to the richer set of possibilities for the topology of connected regions in dimensions higher than one. Furthermore, degenerate cases exist where the region R is itself a (thickened) boundary and as such the scaling of B(R i , s) with s for any subregion is neccesarily too fast to accommodate any positive spreading s U > 0. However, recall that the region R was chosen as a non-correctable region with minimal size. In AdS/CFT, such regions are generally expected to be solid spheres [59], and as such the analogous regions in discrete models of AdS/CFT are expected to be approximately spherical and thus avoid the troublesome degenerate cases mentioned above.

F. Entanglement wedge surface algebras with non-trivial centers
Subsystem codes are a special case of operatoralgebraic quantum error correction, in which some general algebra of operators (the "logical algebra") is protected against error. In subsystem codes, this is the algebra of bare logical operators {A L ⊗ 1 J }. An algebra of this form is special in that its only central elements are those proportional to the identity . More generally, the logical algebra may have a non-trivial center, i.e. it may contain elements which commute with all other elements, but are not proportional to the identity on L. The physical consequence of this is that the logical region is no longer associated with a Hilbert space -it is now identified with a logical algebra instead [60,61]. Because the entanglement wedge map associates a bulk region with each boundary region, this means it now identifies each boundary region with an algebra and not a subsystem [5]. As a result, the limit from Eq. (2) no longer applies, and the regions E[R] and E[R c ] can have a non-empty overlap E(R) ∩ E(R c ) = ∅, which we refer to as the entangling surface. Because this algebra can be reconstructed on independent regions of the boundary, it must be associated with an abelian algebra, which also forms the center of the algebras associated with E[R] and E[R c ] respectively.
For example, in Ref. [8] codes were introduced (which we refer to as LOTE codes after the title of that paper) that are constructed from HaPPY codes, but with additional qubits associated to the entangling surface of any given region R. However, only the algebra of operators generated by {1, σ Z } acting on such a qubit can be recovered on either R or R c . The full set of Paulis {1, σ X , σ Y , σ Z } can still be recovered on the boundary, but not on R or R c alone. This means that with respect to this partition of the boundary, the data on the entan-gling surface is composed of classical bits. This is meant to model an intuitive feature of AdS/CFT: the area of the entangling surface is information which ought to be recoverable from both R and R c .
Even for LOTE codes we are still able to apply our methods to exclude transversal implementation of non-Clifford gates. We do this fairly straightforwardly -we simply ignore the additional algebraic structure, and proceed as if it were a subsystem code with local encoded subsystems as in Eq. (1). A qubit on the entangling surface has a subalgebra reconstructable on either R or R c , but its entire algebra can be reconstructed on neither -thus it does not belong to the subsystem associated with either region's maximal entanglement wedge. In other words, such qubits contribute to any given region's failure to obey complementary recovery. Thus there are no non-trivial regions satisfying complementary recovery (as we have defined it here) in such a code. Nonetheless, so long as regions satisfying complementary recovery are not too rare in the underlying HaPPY code, regions that almost satisfy complementary recovery are not too rare in the corresponding LOTE code. Thus we can apply the results of Section IV C to show that non-Cliffords cannot be implemented in the interior of a region's entanglement wedge. It is unclear how to define a Clifford operator on an algebra with a mixture of bits and qubits, so this appears to be the most that can be said -localitypreserving gates cannot implement logical non-Cliffords on a slightly smaller quantum subalgebra that excludes the classical parts.

G. Other levels of the Clifford hierarchy
For the special case that U is a bare-CSP operator, Lemma II.19 implies a stronger result; namely that one can allow R 0 to only be dressed-cleanable rather than correctable. This can be used to strengthen the result further. In fact, in some cases it can even be used to show that only Pauli gates can be implemented, such as in Fig. 8, by dividing the boundary into just two dressedcleanable regions R 0 and R 1 . This case of the bound is relevant if one wishes to implement a desired bare logical gate on a small bulk subsystem without causing any disturbances to other regions of the bulk.
We remark that it is not possible to restrict a dressed-CSP operator to implement something only from C 1 in this way. To do so would require expressing the boundary as a union of a dressed-cleanable and a correctable region, which is impossible; any bare-logical operator could be cleaned to R 1 using correctability of R 0 , but Lemma II.14 applied to R 1 means that the operator must be triviala contradiction.
Finally, for sufficiently large bulk regions, the arguments of Section IV E do not apply. The reason for this is that all correctable regions are too small to cover the entire boundary using only three of them; some greater number would be required. In these cases, a restriction on locality-preserving gates still exists, depending on the number k of required correctable regions. Thus, even if a non-Clifford cannot be ruled out for very large bulk regions, some restriction still exists corresponding to a higher level of the Clifford hierarchy, C k−1 .
Theorem IV.7. For a subsystem stabilizer code S with a one-dimensional boundary, if there is a region R of size d c (S) that satisfies complementary recovery then any dressed-CSP unitary operator U with s U < dc 2(2 m −1) implements a logical unitary in C m for m ≥ 2.
Proof. As in Sec. IV E, we subdivide the region R into m consecutive regions R j=1,...,m of sizes 2 m−j dc (2 m −1) .
We can thus apply Lemma II.18 and obtain the result.
The above argument can be generalized to higher dimensions along similar lines to the discussion at the end of Section IV E. Again we assume that there is a boundary region R of the smallest non-correctable region size that can be decomposed into a set of subregions R i , i = 1, . . . , m, that are sufficiently nice in the sense that the size of their extensions B(R i , s) do not grow too fast with s. Then for sufficiently small s U , the argument presented above for Theorem IV.7 can be applied straightforwardly, leading to the same conclusion. Similar to Section IV E, we do not currently have a clean statement of the most general version of this result but we expect the statement for a solid spherical boundary region to be the most relevant.

V. DISCUSSION & CONCLUSIONS
In this work we have established a specialisation and strengthening of the Eastin-Knill theorem for holographic subsystem stabilizer codes, inspired by analogous work due to Bravyi-Koenig and Pastawski-Yoshida for topological stabilizer codes. Specifically, we have shown that sufficiently locality-preserving operations on the physical qubits of a holographic stabilizer code can implement only logical Clifford gates on sufficiently small regions of the bulk. This result was extended in several ways, including to approximate stabilizer encodings and to codes in which algebras with non-trivial centers live on the surfaces of entanglement wedges. We have further shown that upon weakening our assumptions, localitypreserving gates are still restricted to implement an element from a fixed level of the Clifford hierarchy. In the course of deriving our results we also introduced a general definition of the maximal entanglement wedge for arbitrary subsystem codes which may be of independent interest. While we have focused on the simple case of the hyperbolic disc in our figures, we remark that our results also apply to non-trivial bulk topologies and higher dimensional spaces.
There is a recurring theme in fault-tolerant quantum computation that the set of fault-tolerantly implementable gates is more severely restricted the better the error-correction properties of a code are. This makes some intuitive sense -better protected logical information should also be harder to manipulate. For example, Eastin-Knill's theorem establishing the impossibility of universal transversal gate sets only applies when the code distance is greater one; the Brayi-Koenig theorem and Pastawski-Yoshida's subsystem generalization require a macroscopically large code distance; and another result of Pastawski-Yoshida restricts transversally implementable gates more strongly the higher the loss threshold is. Similarly, our results require assumptions about the quality of the code; namely that the distance of a region is "large enough" with respect to the price of the region.
An interesting future direction is the extension of our results restricting locality-preserving gates to the setting of the full AdS/CFT duality, possibly by exploiting conformal invariance. This approach is inspired by the generalization of the Bravyi-Koenig bound to all (2+1)D TQFTs (on closed manifolds) [31] that was established by exploiting consequences of topological invariance. As explained in the introduction, it has been successfully argued that AdS/CFT supports no global symmetries [62]. While this result partially overlaps with our goal, our aim is somewhat stronger, restricting the possible bulk evolutions generated by arbitrary locality-and codespacepreserving evolutions on the boundary with no requirement that they take the form of a global symmetry. This could have potentially interesting implications for the prospect of implementing bulk Hamiltonian evolution via locality-preserving operations on the boundary.
There is an apparent tension between the results of this paper and the intuition that there ought to exist states in AdS/CFT which contain a quantum computer in the bulk. In a short amount of time, this quantum computer ought to be able to perform, at least approximately, an arbitrary element of SU (2 k ) on k qubits for k ≥ 2 (but not much greater). But short time evolution is implemented on the boundary by a locality preserving unitary, which we have seen can only implement Cliffords in holographic stabilizer codes. Of course, in AdS/CFT the local bulk or boundary degrees of freedom are larger than simply qubits, so a fairer comparison should use qudit rather than qubit stabilizer codes. However, even for large qudit dimension it is impossible for the Clifford group to contain a subgroup arbitrarily approximating SU (2 k ) [63]. Thus it appears unlikely that exact or approximate (as defined in Section IV D) stabilizer codes alone can capture this aspect of AdS/CFT. Our results can hence be interpreted as placing severe limitations on how well stabilizer toy models are able to capture aspects of holography to do with locality-preserving boundary evolutions. In a future work we plan to show that by adding additional constraints to the logical bulk of a qudit stabilizer code, it is indeed possible to build an ap-proximate holographic code which can transversally implement any element of SU (2 k ).
It would be very interesting to combine our restrictions on locality-preserving operations based on holographic structure and locality with the approximate covariant code trade-off bounds derived in Ref. [64]. We expect that both of these directions are relevant to studying the action of locality-preserving evolutions in the full AdS/CFT duality which is expected to lead to approximate quantum codes with a holographic locality structure.

Subsystem codes
To begin with, in general subsystem codes, a notion of dressed-cleanable can be defined analogous to Definition II.12 but for any dressed operator, not just Pauli operators.
Definition A.1. A region R of a subsystem code is defined to be • bare-cleanable (aka "correctable") iff for any logical operator A L there exists a bare-CSP operator A supported on R c which implements A L ⊗ 1 J .
• dressed-cleanable iff for any logical operator A L there exists a dressed-CSP operator A supported on R c which implements A L ⊗ A J .
• bare-trivial iff any bare-CSP operator supported on R implements a logical operation of the form c1 L ⊗ 1 J , with c ∈ C.
• dressed-trivial iff any dressed-CSP operator supported on R implements a logical operation of the form 1 L ⊗ A J , for some A J ∈ B(H J ).
We remark that Lemmas II.3 and II.14 can then be expressed as meaning that bare-cleanable implies dressedtrivial and dressed-cleanable implies bare-trivial. Fur-thermore, Lemma II.13 means that bare-cleanable implies dressed-cleanable, and it is easy to show similarly that dressed-trivial implies bare-trivial. We can summarise these results, along with Lemma II.15 for regions satisfying complementary recovery, in Fig. 9.

Stabilizer subsystem codes
In the special case of a stabilizer subsystem code, there is some additional structure. The definition in Definition A.1 are still valid, but we could instead choose to define analogous properties that only require the respective properties to hold for Pauli operators. It turns out that most of these properties are equivalent to those in Definition A.1, for example: Lemma A.2. A region R of a stabilizer subsystem code is bare-cleanable if and only if for any logical Pauli operator P L , there exists a bare-CSP Pauli operator P supported on R c which implements P L ⊗ 1 J .
Proof. ( =⇒ ) For any logical operator P L , barecleanability tells us there is a bare-CSP operator A supported on R c that implements P L ⊗ 1. A can be decomposed into Pauli operators supported on R c , as A = i λ i P i . Since A commutes with every stabilizer, each of these Pauli operators P i must also commute with all the stabilizers, and therefore be codespacepreserving. Furthermore, the basis of the logical space has been chosen such that CSP physical Pauli operators always implement logical Paulis, so each P i is a dressed-CSP operator supported on R c implementing Since the Paulis form a basis of logical operators, at least one P i is a bare-CSP implementing P L ⊗ 1 J , completing the proof.
( ⇐= ) Any logical operator A L can be decomposed into Paulis as i λ i P i L . Then each of these Paulis can be implemented as a bare-CSP operator P i on R c . Then i λ i P i is a bare-CSP operator supported on R c implementing A L , concluding the proof. Similar proofs can be constructed for the bare-trivial and dressed-trivial properties; however the reasoning breaks down for the dressed-cleanable property. We remark that in the converse direction of the above proof, it was crucial that the linear combination of bare-CSP operators i λ i P i was also a bare-CSP operator. However, this does not apply to dressed-CSP operators, which are not closed under linear combination. Thus, we need to define two separate notions of dressed-cleanability for stabilizer subsystem codes -one based on general operators and one based on Paulis. The latter of these two is the one that was used in the main text and referred to simply as "dressed-cleanable" -because it is the one which is useful for the Pastawski-Yoshida lemma, Lemma II.18.
Definition A.3. A region R of a subsystem stabilizer code is defined to be • general dressed-cleanable iff for any logical operator A L there exists a dressed-CSP operator A supported on R c which implements A L ⊗ A J .
• Pauli dressed-cleanable iff for any logical Pauli operator P L there exists a dressed-CSP operator P supported on R c which implements P L ⊗ P J .
It can still be shown analogously to the first part of the proof of Lemma A.2 that general dressed-cleanable regions are also Pauli dressed-cleanable.
The one other difference for stabilizer subsystem codes is that the converse directions for Lemmas II.3 and II.14 are also true (see Ref. [46]), as mentioned in the main text. These are shown specifically for Pauli dressedcleanability, and not general dressed-cleanability. Thus the web of relationships for stabilizer subsystem codes is shown in Fig. 10. To the best of our knowledge, this is the extent of the known relationships between different correctability properties in both subsystem and stabilizer subsystem codes. This leaves many open questions: are dressed-trivial and bare-cleanable equivalent for any subsystem code? Is the general dressed-cleanable property of stabilizer subsystem codes equivalent to Pauli dressedcleanability after all, is it equivalent to bare-cleanability, or is it distinct from both? In HaPPY codes, such as in Fig. 8, regions are found which are Pauli dressedcleanable and not bare-cleanable, which already shows that some of the above properties must be distinct. Perhaps similar counter-examples can be found demonstrating that the relationships shown here are all that can be generally expressed without additional information. We leave this to future work. In Ref. [65], a range of possible HaPPY codes were considered by systematically exploring possible homogeneous hyperbolic tilings characterized by Schlafli symbols. Schlafli symbols are a characterization of a regular polygonal tiling via a pair of integers n, k, such that k n-sided polygons (n-gons) meeting at each vertex. Such a tiling is hyperbolic if the total internal angles of each polygon exceeds (n − 2)π, which is equivalent to In Ref. [65], the perfect tensors of HaPPY are associated to polygons of this tiling; however for our purposes we consider the dual identification of these tensors with the vertices of the graph instead. Thus for a network with a rank 2N perfect tensor, we should have k = 2N − 1 as the number of in-plane legs. These two conventions are related by Poincaré duality, where faces and vertices are interchanged, which corresponds to switching n ↔ k in the Schlafli symbol. The symmetry of Eq. (B1) shows that a tiling is hyperbolic if and only if its dual is hyperbolic, as expected.
Of course, the HaPPY tensor network is more than just a hyperbolic tiling filled with a network of perfect tensors; it must also be an isometry from the bulk to the boundary. The former does not imply the latter, as one can see from the case where k = 3. In this case, a local bulk operator cannot be pushed out to the boundary; whenever an operator is pushed to a new vertex, there are two inputs (one from the leg "pushed" from the previous vertex, and one from the bulk input), so the result of the pushing is that some operator is pushed to both remaining legs of the tensor. In this way, there is no control over the pushing process to guide the output towards the boundary; it inevitably loops back on itself as soon as given the chance, because it follows all available paths. Thus an isometry does not occur for this case.
Whenever k > 3, it appears that the tensor network does result in an isometry. In Ref. [65], these cases were studied separately according to n = 3 and n > 3. A central perfect tensor is placed to begin with, and then consecutive layers of polygons are added. This is done such that each vertex is on the boundary of the tiling when it is in the most-recently added layer, and it is in the interior afterwards.
Then the vertices of the network can be characterized according to how many other vertices they are connected to from the same or previous layers. Each such vertex is connected with exactly two from the same layer as itself, as it is on the boundary of the tiling. Either (a) it connect to no vertices from previous layers (only two of those from the same layer as itself); (b) they connect to one vertex from a previous layer (and thus a total of three including those of the same layer); or (c) they can connect to two vertices of previous layers (for a total of four vertices). We label these types of vertices as a, b and c respectively, and note that the third type c only appears when n = 3. The initial vertex effectively counts as a distinct category, i, which connects to no vertices from the same or previous layers.
The construction of each new layer can be surmised using replacement rules of these vertex types as follows [65] n = 3 : a → a n−4 b a n−3 b k−3 b → a n−4 b a n−3 b The resultants of these replacement rules are written in a specific order to denote a particular ordering of each layer; e.g. one can use a clockwise convention such that the new vertices are in the appropriate order from left to right. We also require the rules for i-type vertices which were not present in Ref. [65] due to the different convention, which are as follows for all n: i → (ba n−3 ) k (B4) Our proof strategy is as follows -we construct the network such that the initial site is the one onto which a local bulk operator is applied. This operator is then pushed through to three different choices of region S 1 , S 2 and S 3 . Each of these regions can fully reconstruct an arbitrary bulk logical operator on the initial site, so their complements are correctable, and if the union of these complements covers the full boundary space we can apply Lemma II.18 to obtain the desired result. Thus we must show that S 1 , S 2 and S 3 can be constructed such that no site of the boundary lies in the intersection of all three regions. We proceed by partitioning the boundary into k = 2N − 1 sets, {M j } j=2N −1 j=1 ; each of which corresponds to some b j , one of the b-type vertices that directly connects to the initial vertex. Each of these vertices comes with n − 3 a-type vertices from the i replacement rule Eq. (B4). Together, these vertices, along with all of the vertices obtained from them via repeated application of the replacement rules in Eq. (B3), form the set M j .
One can push out the bulk operator acting on the initial vertex to any choice of N of the b j vertices. Consider what would happen if one could construct a pushing protocol such that an operator acting on each b j can always be pushed out into just the boundary region M j . Then the initial bulk operator can be pushed to any N of the M j , and we could use these sets to form S 1 , S 2 and S 3 . For example, let S 1 = j=N j=1 , S 2 = j=N +1 j=2 , and S 3 = j=2N −1 j=N +1 . Each S i consists of the union of N of the M j regions, and no M j belongs to all three, so these choices of S i are appropriate choices that allow application of the main lemma Lemma II.18, and thus no non-Cliffords can be applied transversally.
Definition B.1 (Replacement Pushing Assumption). An operator acting on a vertex b j connected to the initial vertex can be pushed out to M j , which is defined as the image of b j under repeated applications of the replacement rules Eq. (B3).
In other words, the replacement pushing assumption means that we can partition the boundary into 2N − 1 regions {R j } such that each b j ∈ E[R j ], with the entanglement wedge E as defined in Definition II.4.
When does the replacement pushing assumption apply? The replacement rules are constructed such that whenever they are applied to an existing vertex and a new b or c vertex is obtained, it must connect to that existing vertex. Thus, if at least N vertices of b or c type are obtained from any replacement rule, then the replacement pushing assumption applies straightforwardly; each vertex can be pushed into its replacement, which is repeated until the boundary is reached.
First, let us consider the n > 3 case. The rules for a and b result in k − 2 and k − 3 new b-type vertices respectively. Thus, so long as k − 3 ≥ N , i.e. k ≥ 7, replacement pushing applies, and the result follows. Now, for n = 3 -note that because none of the replacement rules in Eqs. (B3) and (B4) produce any a vertices, we only need to consider b and c (again, this is different to Ref. [65], where their conventions necessitate starting with some a vertices). Thus, if N ≥ k − 5, i.e. k ≥ 11, replacement pushing applies, and the result follows.
The cases of {n, k} which produce valid HaPPY networks (i.e. have odd k = 2N − 1, satisfy Eq. (B1), and form actual isometries i.e. k = 3), but for which replacement pushing does not straightforwardly apply according to the above arguments, are (A) {n > 3, 5}, (B) {3, 9}, and (C) {3, 7}. In each of these cases, replacement pushing does in fact still apply, but with a little more effort required to complete the argument.
(A) In this case, replacement pushing does straightforwardly apply for a-type vertices, as their replacement rule gives three b-type vertices, and N = k+1 2 = 3. However, b-type vertices are potential causes for concern, as operators acting here must be pushed to N = 3 connecting vertices, but there are only two available connected b-type vertices in the succeeding layer. Thus, one leg must be pushed into along the boundary, i.e. there must be some pushing to the same layer. However, this is fine; we just push in the direction of the nearest a-type vertex that belongs to the same vertex set M j -noting that because n > 3, there always exists at least one such atype vertex. Even if the b-type vertex in question does not connect to an a-type vertex directly, it can push to a neighouring b-type vertex, which will eventually connect to an appropriate a-type from the same set M j .
(B) Each b-type vertex is mapped under replacement to a cbbbb string of vertices, so these straightforwardly obey the replacement pushing assumption. Each c-type vertex is mapped under replacement with cbbb, but we must push to N = 5 vertices. We remark that due to the replacement rules, no two c vertices are ever adjacent, so there must be a b vertex to the right of each c vertex. Furthermore, this b vertex must belong to the same set M j , again because of the nature of the replacement rules. Thus we simply push from each c-type vertex onto its four descendant vertices, and for the remaining leg, push into the b vertex to its right -a protocol which satisfies the replacement pushing assumption.
(C) This case is slightly more complicated as we must employ different pushing rules for b-type vertices depending on their position. We remark that since the n = 3 replacement rules always generate a c for each vertex, and c vertices by definition connect with two vertices from the previous layer, the c in a given vertex's replacement is also connected to that of the vertex to its left. Thus, a vertex has three options for pushing -it can push "forwards" to the vertices in its replacement; it can push "sideways" to adjacent vertices of the same layer, or it can push "diagonally" to the c-type vertex in the replacement of its neighbor on the right. Each b-type vertex is mapped under replacement to a cbb string of vertices, but must be pushed along N = 4 legs. For any b-type vertex that is not on the very far right of the corresponding set M j , it can be pushed into the three vertices in its replace-ment, and also to the c-type vertex in the replacement of its neighbor on the right. For the rightmost vertex, which is always a b-type, it can be pushed to its left neighbour (which is always a b), as well as to the three in its replacement. The rightmost vertex must always have a b neighbour because of the replacement rules; although some b vertices have c-types on either side, these are never on the boundary of the M j set.
Finally, each c-type vertex is mapped under replacement to cb, but must also be pushed along four legs. Again, we can push into the two in its replacement, as well as the c-type in the replacement of its rightward neighbor. For the final leg, we can push sideways to an adjacent b-vertex from the same M j .
None of these pushing rules are in conflict with one another, so we have shown a consistent pushing protocol which keeps each operator in the same M j ; i.e. the replacement pushing assumption is satisfied.
We remark that all of these ideas still apply in the case of perfect planar/block perfect tensors as well, as we never need to push to non-adjacent legs. Similar arguments can be generalized to non-homogeneous codes (such as Fig. 6), as well as higher-dimensional HaPPY codes.