Complexity and entanglement in non-local computation and holography

Does gravity constrain computation? We study this question using the AdS/CFT correspondence, where computation in the presence of gravity can be related to non-gravitational physics in the boundary theory. In AdS/CFT, computations which happen locally in the bulk are implemented in a particular non-local form in the boundary, which in general requires distributed entanglement. In more detail, we recall that for a large class of bulk subregions the area of a surface called the ridge is equal to the mutual information available in the boundary to perform the computation non-locally. We then argue the complexity of the local operation controls the amount of entanglement needed to implement it non-locally, and in particular complexity and entanglement cost are related by a polynomial. If this relationship holds, gravity constrains the complexity of operations within these regions to be polynomial in the area of the ridge.


Introduction
Quantum information theory addresses the fundamental limits and capabilities of information processing given the rules of quantum mechanics. However, to fully understand information processing we need to go beyond quantum mechanics: our universe is described more completely by a theory of quantum gravity. How can we understand the theory of quantum-gravitational information processing?
Progress in understanding information processing in the presence of gravity has been made on a number of fronts. Most famously, a basic question is whether unitarity is preserved in the context of gravity, and recent progress has supported that it is [1,2]. Others have asked about the computational properties of quantum field theories, with an eventual goal of understanding the computational power of quantum gravity [3]. As we discuss in more detail later on, a well-known claim is that gravity should constrain computation [4]. However, existing arguments for this idea have flaws [5].
A precise framework within which we can address questions about quantum gravity is the AdS/CFT correspondence [6,7]. There, a theory of quantum gravity in asymptotically d + 1 dimensional anti de Sitter space ("the bulk") is given an alternative, non-gravitational description as a conformal field theory, which lives in the boundary of that spacetime. See e.g. [8] for a review. In this setting, we can ask questions about information processing in the bulk, gravitating, theory by translating them into non-gravitational questions in the boundary.
In the AdS/CFT correspondence quantum-gravitational physics is captured by a purely quantum mechanical description in the boundary. Because of this, we could expect that quantum-gravitational information processing is captured by standard quantum information theory -we need only note the conformal field theory is quantum mechanical, so described by the usual theory of quantum information, and we are apparently done. However, the true situation is more subtle. The gravitational and non-gravitational descriptions have additional structure beyond quantum mechanics alone: they have causal structure, and this causal structure constrains information processing. Further, the same information processing task viewed in the bulk and boundary perspectives will have different causal structures. We argue that consequently gravity implies constraints on information processing, beyond those that a naive application of quantum mechanics would suggest.
In this article, we will be particularly interested in the limits of computation within a finite gravitating region, and ask if gravity limits computation within such a region. Our starting observation is that computations which happen within a finite bulk region are reproduced in a particular, non-local, form in the boundary. See fig. 1. This was pointed out in [9], and the geometric observation underlying this has been made earlier [10][11][12]. For carefully chosen computations, it is possible to prove that entanglement between appropriate spacetime regions is necessary for the computation to be reproduced in this non-local form. In [9,13,14], this was exploited to argue for constraints on the state of the CFT in the boundary that follow from aspects of bulk geometry. In particular, the non-emptiness of an overlap of a particular set of bulk light cones and an assumption that certain simple computations can happen within this region implies appropriate entanglement is available in the boundary. Here we reverse this perspective, and ask how the existence of the boundary description, and in particular the finite entanglement available there, constrains computation in the bulk.
To do this, we use the techniques in [13,14] to make the connection between local computation in the bulk and non-local computation in the boundary quantitative. For a special class of bulk regions called scattering regions constructed within pure AdS, we recall arguments from [9,13,14] that computations inside the region are reproduced in the boundary using an entangled system with mutual information equal to the area of the ridge, a particular surface on the scattering region. 1 Existing methods for performing computations in the non-local form of fig. 1b use entanglement which is exponential in the input size to implement a general unitary. Unless this can be dramatically improved, the fact that local computations in the Because there is no location where A 0 and A 1 can meet while still being in the past of r 0 , r 1 , the channel implemented in the bulk must be reproduced in the non-local form shown above.
bulk are reproduced using only an area's worth of entanglement will place some form of constraint on computation in the presence of gravity. To understand this constraint better, we wish to identify the property of a unitary that controls the entanglement cost to implement it non-locally. We explore the possibility that it is the complexity 2 which controls the entanglement cost. Given this conjecture, it would follow that the complexity of computations happening within such a region is bounded above by a function of the region's area. Non-local quantum computation is also of independent interest in quantum information theory, in particular because of the connection to position verification [15][16][17][18]. Some of our results are of independent interest in that context, including some new lower bounds on entanglement use. Further, a negative resolution of our conjecture -that complexity controls entanglement cost -would have important implications for position-verification. We discuss this further in section 8.
Overview of the paper: In section 2, we establish a number of preliminaries needed to understand our arguments. In section 2.1 we review the argument of [9] that local computations in the bulk are reproduced in the boundary in the nonlocal form of fig. 1b. In section 2.2 we highlight some observations from [13,14] that relate the entanglement available in the boundary to the geometry of the bulk scattering region. In section 2.3 we define a family of measures of complexity which are appropriate for our setting. Finally in section 2.4 we state precisely the expected relationship between computations in a bulk scattering region and non-local computation in the boundary.
In section 3 we begin discussing constraints on bulk computation that arise from the boundary perspective. We point out that the strongest known constraints on non-local computation lead to an upper bound on the input size to a bulk computation, enforcing in particular that the input size should be at most of the order of the area of the ridge. We point out that this constraint is always weak enough to be implied by the covariant entropy bound [19][20][21], applied in the bulk.
In section 4 we motivate and state two conjectures relating entanglement cost and complexity. The weak complexity-entanglement conjecture states that complexity is the quantity controlling entanglement cost in non-local computation. The strong complexity-entanglement conjecture says that the entanglement cost is a polynomial in circuit complexity. We motivate this from a bulk perspective, noting that a simple assumption about bulk computation would imply this complexity-entanglement relationship.
In section 5 we begin giving evidence from a quantum information perspective that the complexity of a local operation controls the entanglement cost to implement it non-locally. To start, in sections 5.1 and 5.2 we review some existing non-local computation protocols, which have an entanglement cost upper bounded by complexity. Then in section 5.3 we present a new (but weak) lower bound on entanglement in non-local computation, which is in terms of the complexity.
In section 6 we discuss non-local computation under restrictions on the set of allowed protocols used. For certain classes of protocols we can prove upper and lower bounds on entanglement in terms of complexity that agree up to polynomial overheads. In particular we prove this for protocols which use only Clifford unitaries. We also point out an analogous result, applying to protocols restricted to Bell measurements and classical computations, proven earlier in [22].
In section 7 we point out that the weak complexity-entanglement conjecture has an interesting consequence for the f -routing task, a well studied setting in the cryptographic literature. In particular the conjecture implies more efficient protocols should exist for f -routing than were previously known. Following up on this reasoning, in recent work we established new protocols with the needed efficiency, supporting the conjecture [23].
In section 8 we summarize our argument that complexity controls entanglement in non-local computation.
Section 9 gives some future directions.

Summary of notation:
• We use script capital letters for boundary spacetime regions, A, B, C...
• The entanglement wedge of a boundary region A is denoted by E A .
• The Ryu-Takayanagi surface associated to region A is denoted γ A .
• We use J ± (A) to denote the causal future or past of region A taken in the bulk geometry, andĴ ± (A) when restricting to the boundary geometry.
• We use capital letters to denote quantum systems A, B, C, ...

Holography implements non-local computations
The AdS/CFT correspondence describes quantum gravity in an asymptotically AdS d+1 dimensional spacetime in terms of a lower dimensional, non-gravitating theory living at the AdS boundary. This raises a puzzle in the context of a geometric observation made in [10][11][12] which we illustrate for AdS 2+1 in fig. 1c. Choose four points in the boundary, two at an early time and two at a later time. We can choose these four points such that light rays from the two early points may meet, then travel from the meeting point to both late time points. Consider two systems A 0 and A 1 , falling inward along these incoming light rays, interacting where they meet, then traveling outward to the boundary after the interaction has occurred. This process happens in the bulk picture under evolution by a local Hamiltonian. In the boundary picture, it can happen that for the same four points there is no region of the boundary where the two systems can be brought together while still in the past of both late time points. See fig. 1d. It then becomes puzzling how, using local Hamiltonian evolution, the boundary can reproduce the bulk dynamics.
To resolve this puzzle, [9] argued that a local interaction in the bulk is described via a "non-local quantum computation" 3 in the boundary. In particular a channel N A 0 A 1 →B 0 B 1 (·) can always be implemented in the form [18,24] although in general it is not well understood how much entanglement is needed in the LR system, as we discuss in detail later on. The basic observation of [9] is that when a local channel is implemented in the bulk, it is realized in the non-local form on the right of eq. (1) in the boundary. The puzzle is resolved by the observation that local interactions plus shared entanglement in the more restrictive boundary geometry can be used to reproduce local interactions in the higher dimensional bulk. In fact, even general scenarios, with more inputs and outputs and requiring computations in multiple spacetime locations from a bulk perspective, can always be reproduced in the boundary with sufficient entanglement [25].
To understand the role of non-local computation in holography in more detail, we first need to introduce a few aspects of AdS/CFT. The basic claim of the AdS/CFT correspondence is that any bulk quantity can be calculated using boundary degrees of freedom, and vice versa. One important quantity studied in the boundary is the von Neumann entropy. In CFT states corresponding to semi-classical geometries, this can be calculated in a simple way using the bulk via the Ryu-Takayanagi formula [26][27][28][29][30][31][32] 4 , The extremization is taken over all spacelike, codimension 2 surfaces γ which are homologous to R, which means that there exists some codimension 1 spacelike surface E γ such that ∂E γ = γ ∪ R. The term S bulk (E γ ) captures the entropy of degrees of freedom sitting within E γ . If there is more than one extremal surface, one should pick the surface that minimizes the functional on the right of the above equation. There is also a useful reformulation of this formula known as the maximin formula [36,37], stated as follows.
Here the maximization is over bulk Cauchy surfaces which include R in their boundary. The Ryu-Takayanagi formula picks a minimal extremal codimension 2 surface, call it γ R , given the boundary region R. We call this the RT surface of R. It also picks out a family of codimension one surfaces E R such that ∂E R = γ R ∪ R. Taking the domain of dependence of any member of this family we obtain a codimension 0 region we label E R and call the entanglement wedge. In this section we will be most interested in the entanglement wedge, in particular because it has an important meaning as the portion of the bulk spacetime which is recorded into the density matrix ρ R [33,36,[38][39][40][41][42][43]. In particular, a quantum system Q which in the bulk picture can be recovered from the region E R can in the boundary picture be recovered from region R. This statement is known as entanglement wedge reconstruction.
The next step towards understanding eq. (1) will be to introduce the "quantum tasks" language of [9,14,16]. In a quantum task, we consider two parties, Alice and Bob. Bob prepares a set of input systems, which he gives to Alice at a set of input locations. In particular at input location C i Bob gives Alice system A i . Alice should process the input systems in some way, then return quantum systems B i at a set of output locations R i . To fully specify the task we need to specify an initial state of the boundary CFT, which fixes the resource systems available in the boundary to perform the task, as well as fixes the bulk geometry and fields. We call this initial state |Ψ .
While the early references considering quantum tasks in the context of AdS/CFT [9,13] deal with the case where the input and output locations consist of points, it will be helpful to follow [14] and allow input and output systems to be recorded into spacetime regions. Because of entanglement wedge reconstruction, a quantum task defined in the bulk with input regions E C i and output regions E R i corresponds in the boundary picture to a task with the same input and output systems, but now with input regions C i and output regions R i .
In a quantum task then, we have Bob couple to the CFT within the regions C i to introduce the input systems, and then couple to R i to collect the output systems. We can take two perspectives on the role of Alice. The first is what we will call the 'Alice-in-the-box' perspective, where Alice is thought of as a collection of agents living within the AdS spacetime. In this case, Bob is holding a CFT and probing it, and all of Alice's actions are recorded already into the initial CFT state |Ψ . This is the perspective used earlier [9,13,14]. Here, we will additionally make use of an alternative 'Alice-out-of-the-box' perspective, wherein Alice is, like Bob, a set of agents outside the CFT, who may couple to it. We require however that this 'out-of-the-box' Alice 1) respect the causal structure of the boundary spacetime 2) not hold entanglement aside from the CFT degrees of freedom. Now we are ready to understand eq. (1). Consider a quantum task which has only two input regions and two output regions. That is, Bob records systems A 0 , A 1 into E C 0 , E C 1 , and requires systems B 0 , B 1 be recorded into regions E R 0 , E R 1 . We require the input and output systems be related by some specified quantum channel N A 0 A 1 →B 0 B 1 . We show this in fig. 1c, where the input and output regions are located in the boundary of an asymptotically AdS spacetime. We are most interested in the setting where C 0 , C 1 , R 0 , R 1 are such that the region 5 is non-empty, and such that this region does not extend to the AdS boundary. We call this the scattering region.
In the bulk perspective, the task can be completed by bringing A 0 , A 1 into the scattering region, performing the channel, and sending the outputs to E R 0 , E R 1 . Now consider this same process from a boundary perspective. Because the scattering region does not extend to the boundary, there is no spacetime region where A 0 and A 1 can be directly interacted to perform the channel. Nonetheless, while only evolving according to its local Hamiltonian, the boundary theory has to reproduce the overall channel. What are available in the boundary are the regionŝ where theĴ ± indicate future and past light cones taken in the boundary geometry. We call V i :=Ĵ i→01 the decision regions, and also define W i :=Ĵ 01→i . Performing quantum channels within each of these regions on the available systems, including entanglement shared between V 0 , V 1 , is exactly a computation in the form of eq. (1). We show this in fig. 1b. The shared correlation in the non-local computation circuit of fig. 1b is, in the spacetime picture, held between regions V 0 and V 1 . Because these are separated regions, the correlation between them in the conformal field theory is finite. The basic strategy we pursue in this paper is to try and constrain the computations which can happen inside the scattering region by constraining which computations can be performed non-locally in the boundary picture with this limited correlation.
There is one possible obstruction in identifying what happens in the boundary CFT with a non-local computation in the form of eq. (1). In the idealized form of eq. (1), the output locations R 0 and R 1 receive quantum systems from C 0 and C 1 , and nowhere else. In the holographic setting, the corresponding locations W 0 , W 1 additionally have some region, call it X , sitting in their past light cones but outside the future of both C 0 and C 1 . In particular X is the spacelike complement of V 0 ∪ V 1 . Using this extra region, [13] showed how to complete certain non-local computations with zero mutual information between regions V 0 and V 1 , even while this mutual information is provably necessary when the region X is absent. In fact, it is now known that any computation can be performed non-locally with zero mutual information between the input regions by exploiting the X regions [44]! Given this, it does not seem reasonable to take the causal structure implicit in eq. (1) as our model for the boundary.
However, in this article we are interested in asymptotics, in particular in how the class of computations that can be performed within the scattering region behaves as the size of the region is made large. For instance, we will ask about how the complexity of computations that can happen within the region scales with the area of the ridge at large ridge area. For this purpose, we can better justify the form eq. (1) by noting that to make the ridge large, we are moving the output points forwards in time, and in the boundary this corresponds to the X regions shrinking to empty. Thus our assumption is that as the X regions shrink and become empty, their relevance to the class of computations which can happen in the scattering region becomes small. Additionally, there are hints that the causal structure shown in fig. 1b is a good model for how bulk computations are reproduced in the boundary, even for fixed, large X regions (although we emphasize that we don't need this). First, the gravity proof of the connected wedge theorem (see theorem 1) shows that the mutual information I(V 0 : V 1 ) is Θ(1/G N ) whenever the scattering region exists. 6 This follows from a boundary argument if we naively assume fig. 1b is a good model, but does not follow if we include the X regions, suggesting the AdS/CFT correspondence fails to exploit the X regions for some (apparently mysterious) reason. Another hint is that the scattering region sits inside of the entanglement wedge of the input regions, again suggesting the primacy of correlation between the input regions in supporting bulk computation. We leave better understanding these observations to future work.

Geometry of the scattering region and boundary entanglement
It will be helpful to have a more detailed picture of the geometry of the scattering region, and to understand something about how this geometry relates quantitatively to entanglement in the boundary. First, recall the definition of the scattering region from eq. (4), We illustrate a scattering region constructed in 2 + 1 bulk dimensions in figure fig. 2. The scattering region takes the basic shape of a tetrahedron, though the sides and faces can be curved. The lower two faces (shown in red) are portions of the boundary of the future of C 0 and C 1 . In particular, we define The upper two faces (shown in blue) are portions of the boundary of the past of R 0 and R 1 , Finally, we will be interested in the lower edge of the tetrahedron, which we call the ridge which is also just Σ 0 ∩ Σ 1 .
As mentioned in the last section, whenever the scattering region is non-empty the mutual information I(V 0 : V 1 ) is large, and in particular it is Θ(1/G N ). In fact, [13,14] proved the following theorem. 7 Theorem 1 (Connected wedge theorem) Pick four regions C 0 , C 1 , R 0 , R 1 on the boundary of an asymptotically AdS spacetime such that Then with the ridge r defined as in eq. (8).
It will be instructive to briefly outline the elements of the proof of theorem 1.
For more details the reader may consult [14]. Begin by recalling that the mutual information is where we assume the bulk matter has O(1) entropy. We will use a focusing argument to compare the sum of the first term to the the second. We consider the lift As well, take a Cauchy surface Σ that contains γ V 0 ∪V 1 , and define the slope, In fig. 3 we illustrate the null membrane, which is the union of the lift and the slope. The null membrane allows us to compare the area of γ V 0 ∪ γ V 1 to the area of γ V 0 ∪V 1 . To see this, note that light rays moving up the lift have decreasing area, because Figure 3: The null membrane. The blue surface is the lift L, which is generated by the null geodesics defined by the inward, future pointing null normals to γ V 0 ∪ γ V 1 . The red surfaces make up the slope S Σ , which is generated by the null geodesics defined by the inward, past directed null normals to γ R 1 ∪ γ R 2 . The ridge r is where null rays from γ V 1 and γ V 2 collide.
The contradiction surface C Σ is where the slope meets a specified Cauchy surface Σ. Figure  reproduced from [14].
they are initially orthogonal to γ V 0 ∪ γ V 1 . Similarly, light rays moving down the slope have decreasing area, because they are initially orthogonal to γ V 0 ∪V 1 . Thus, consider pushing γ V 0 ∪γ V 1 upwards along the lift, removing any light rays that collide with each other and stopping whenever the surface reaches the slope. Note that we remove at least twice the ridges area in doing this. Then push the surface downwards along the slope, again noting that the area decreases, stopping when we reach Σ. This produces a surface C Σ in the slice Σ which has area smaller than γ V 0 ∪ γ V 1 by at least 2 area(r). As well, since C Σ lies in a single Cauchy slice with γ V 0 ∪V 1 , according to the maximin formula it must have area larger or equal to that of γ V 0 ∪V 1 . This gives which is as needed.
Notice from the argument in the last paragraph that if the expansion of the null membrane is everywhere zero, the only area removed during the focusing argument is the area of the ridge, so inequality (10) is saturated. This occurs for example in pure AdS. Another comment on this theorem is that the converse is not true, in that there are states with Θ(1/G N ) mutual information but where the scattering region is empty.
In the context of understanding the limits of computations in the bulk, we are interested in scenarios where our computation may change the bulk geometry, for instance because the inputs to the computation and matter used to build a computing device backreacts on the geometry. Fortunately, the way in which we have defined the scattering region remains natural in this setting. Recall that the definition of the quantum task includes a specification of the state of the CFT at some early time, which we call |Ψ . The scattering region is defined by |Ψ along with a choice of input and output regions according to eq. (4). Alice can then attempt to perform computations within the scattering region by coupling to the decision regions, which in general deforms the bulk geometry. The data defining the region, namely the choice of boundary regions plus initial state |Ψ , remains fixed however, so we can define a precise notion of the 'same' scattering region even for the deformed geometries.
We have defined our scattering region in terms of boundary data, but later will want to characterize scattering regions from a bulk perspective. Given this, we can ask what data about the scattering region remains well defined, even when Alice is allowed to couple to the decision region. We focus on the case where the initial state |Ψ is the CFT vacuum. In this case, and without Alice coupling to the decision regions, we have that equation 14 is an equality and half the mutual information is equal to the ridge area. Noting that Alice's couplings don't change the mutual information, and applying theorem 1, we see that her couplings can only decrease the ridge area. 8 For scattering regions defined with the initial state as the CFT vacuum, we can use the area of the ridge in the undeformed geometry to characterize the scattering region from a bulk perspective. Whenever we refer to the area of a scattering region S, we will mean the area of the ridge r in the undeformed geometry.

The 'interaction class' of a unitary
We are interested in studying computations that can happen in the bulk scattering region, and in understanding this using the boundary description. Specifying the inputs and outputs as they appear near the boundary however does not precisely capture the computation which happens inside the scattering region. Instead, the bulk process can involve messages sent directly from C 0 and C 1 to R 0 or R 1 , and can involve operations that act separately on A 0 and A 1 as they fall into or come out of the scattering region. To capture the computation which happens inside of the scattering region, we need a notion of the interaction class of U, which we define as follows.
Definition 2 Given a unitary U the approximate interaction class of U is the set of unitaries U I such that there exist isometries V L , V R , W L , W R satisfying fig. 4b for a circuit diagram. We denote the interaction class of U A 0 A 1 by We have used the diamond norm in the above definition so that the circuit exploiting an interaction unitary is operationally nearly indistinguishable from the target unitary. As an example, for a tensor product unitary includes the trivial unitary, which acts on an empty input system and produces an empty output system. We will be particularly interested in understanding the complexity of what happens inside of the scattering region. To capture this, we will define a notion of complexity which is minimized over the interaction class. Definition 3 Given any notion of complexity for a unitary U, call it the type X complexity C(U), we define as the interaction-class type X complexity of U. We sometimes drop the argument and write C A 0 :A 1 = C A 0 :A 1 (U) when the relevant unitary is clear from context.
As an example, we have Unless otherwise specified, we will take the complexity C(U) to be the circuit complexity of U. Because we deal with finite dimensional quantum systems and only argue the complexity is related to entanglement cost up to polynomial overheads 9 , any choice of universal gate set will suffice. Our notion of interaction-class complexity is similar to one introduced in [22] (and also used in [23]), although the earlier notion applied only to a specific class of quantum tasks, known as f -routing. In section 6.2 we will see that our definition reduces to the one in [22,23] when applied to f -routing.
It is sometimes important to distinguish between the complexity of a unitary and the complexity of a task. A task is specified by the allowed inputs and a required condition on the outputs. In some cases, there could be many unitaries that produce the correct outputs, with possibly differing complexities. If we wish to discuss the complexity of a task, rather than of a unitary, we will use the minimal complexity of all possible unitaries that correctly complete the task. Usually, we will consider tasks where the requirement is to implement a specific unitary, so the notions of task complexity and unitary complexity coincide.
An instructive example is to consider the case where the inputs and outputs to the task are classical. Call the inputs x 0 and x 1 , and required outputs f 0 (x 0 , x 1 ) and f 1 (x 0 , x 1 ). In this case, the inputs on each side can be copied, and sent to both output locations. Then, the outputs f 0 (x 0 , x 1 ) and f 1 (x 0 , x 1 ) can be computed separately on each side, and output to Bob. This shows there is a method to complete the task with trivial interaction unitary, so the interaction-class complexity for this task is 0.

Computations in gravitating regions and non-local computation
Recall that a scattering region S is defined by the choice of state |Ψ of the CFT before the decision regions, along with a choice of input and output regions. We focus on constraints on computation in bulk scattering regions in the setting where the initial state is the CFT vacuum |Ψ 0 , corresponding to pure AdS geometry in the bulk. In this context, we have that the ridge area in the undeformed geometry is equal to the mutual information in the boundary. Later, we will discuss the case where the scattering region is defined by an arbitrary semi-classical early time state. In that setting, we are not able to argue for the same constraint, for reasons that we point out.
Before proceeding, we should discuss what we mean by a unitary happening within a given spacetime region. We will say U A 0 A 1 is performed within S if A 0 , A 1 enter separately through the lower two faces of S in an arbitrary state |ψ A 0 A 1 R with R a distantly located reference system, and exit separately through the upper two faces in state Notice that this is defined with respect to a particular factorization of the Hilbert space into subsystems A 0 and A 1 .
With this notion in hand, we define the following set of unitaries.
Definition 4 Define QG A 0 :A 1 (S) to be the set of unitaries U A 0 A 1 which have a unitary in their interaction class that can be performed within scattering region S.
The set QG A 0 :A 1 (S) may depend not just on the geometry of the scattering region, but also on the bulk matter fields and other details of the theory it lives in. We are always interested in scattering regions constructed within theories with consistent boundary descriptions.
To relate QG A 0 :A 1 (S) to non-local computation, we define another set of unitaries.

Definition 5 N LQC
is the set of unitaries U A 0 A 1 for which there exists a resource system that can be used to implement the computation non-locally, and which has mutual information at most E.
Note that when we say a unitary U A 0 A 1 is performed non-locally, we mean with respect to the tensor product decomposition of The observations recalled in section 2.1 give that, for scattering regions constructed using the CFT vacuum as initial state, computations happening inside the scattering region are realized non-locally in the boundary, with the same tensor product decomposition and with a resource system whose mutual information is equal to the area of the ridge. We can summarize this as where by the area of S 0 we mean the area of the ridge, measured in Planck units in the undeformed geometry.
The situation for the non-vacuum case is less clear, and we do not believe the containment 16 holds. In this case we still have but it is unclear how to relate the geometry of the scattering region to the mutual information. In fact, in the non-vacuum case we can have ridge area strictly less than half the mutual information, and in fact the ridge area can be Θ(1) even when the mutual information is Θ(1/G N ). In general, our inability to give constraints on computation in the scattering region away from the vacuum case is related to the fact that the CFT can only be used to probe boundary anchored quantities. In this context, that means we can probe what quantum tasks can be completed, and not directly probe what happens in the scattering region. Because the scattering region is defined by shooting light rays in from the boundary (or from extremal surfaces anchored to the boundary), it becomes difficult in some cases to relate its geometry to boundary defined quantities. This difficulty disappears in the case where the initial state is the CFT vacuum. We could try to write an analogue of eq. (16) for the non-vacuum case by for example considering the ridge area maximized over choices of operations on V 1 , V 2 , and claiming for example that QG A 0 :A 1 (S) ⊆ N LQC A 0 :A 1 (area(r )) where r has maximal area over choices of operation. While the area of r is upper bounded by the mutual information, it is still possible the mutual information can be arbitrarily large compared to this maximized area, and consequently unclear that any containment like this one should hold. Given these difficulties, we focus on the case where the initial state, on a time slice before the decision regions, is the vacuum. We emphasize however that because we allow Alice to perform arbitrary operations to the decision regions, the geometry may still undergo large changes during the computation. 10

Explicit linear lower bounds on entanglement and the CEB
In the last section we argued that Because of this containment, lower bounding the entanglement required for a given computation to be larger than the area of S shows it cannot be implemented within the scattering region.
There are a few tasks where lower bounds on the resources needed in non-local computation have been proven [18,24,45,46]. All known bounds that do not make assumptions about the protocol used are linear, with each different bound applying for a different choice of task. Let us focus on the bound following from [45].
The strategy for obtaining this bound is as follows. We consider a general task T . We suppose that there is some entangled resource state ρ V 0 V 1 and corresponding protocol that completes the task with probability 1. Then, we consider running the same protocol, but replacing the entangled resource state with the product state Then there is a simple argument [14] that shows 11 Intuitively, this says that a task which can only be completed with low probability without entanglement requires lots of entanglement to complete with high probability.
For a specific family of quantum tasks related to monogamy-of-entanglement games [45], it is known how to prove upper bounds on success probability. In particular these consist of tasks where A 0 holds one end of a maximally entangled state, and A 1 holds a choice of measurement basis. Bob measures his end of the maximally entangled state in the chosen basis, and obtains outcome b. Alice's task is to return b at both R 0 and R 1 . Using monogamy-of-entanglement games that exploit constructions of mutually unbiased bases in large dimensions [47][48][49] (19), this leads to where α = 1/2. 13 As a consequence of the above bound, we obtain that the inputs to this task cannot be taken larger than the corresponding mutual information in the boundary, divided by 2α. An observation is that, by randomly guessing Bob's measurement outcome, Alice can always achieve p suc = 1/d A 0 . If there were a game which did no better than this lower bound on the success probability, that game would lead to α = 1 in the bound (20). Consequently, it is clear we can never prove a lower bound on the mutual information that is stronger than eq. (20) with α = 1 using monogamy games. Similarly, all of the bounds in [18,24,46] are linear with α < 1.
It is interesting to ask how the bound (20) is enforced by bulk physics. To understand this, recall the covariant entropy bound (CEB) [19][20][21], which can be stated as follows. Consider a codimension 2 spacelike surface γ, and consider a null surface Σ which is swept out by null geodesics that start on γ, are orthogonal to γ, and end on σ or on caustics. Then the covariant entropy bound says that if the expansion along Σ is non-positive, then where ∆S[Σ] is the matter entropy passing through Σ. By assuming the CEB, we can place a constraint on what happens within the scattering region. It turns out that this constraint is strong enough to enforce eq. (20). Recall that the two lower faces of the scattering region labelled Σ 0 , Σ 1 are defined as portions of the boundary of the causal future of extremal surfaces (see eq. (6)). Because of this, both surfaces have non-positive expansion. Further, r is a surface inside of the lightsheet Σ 0 , and as a consequence the generators of Σ 0 are also orthogonal to r. These facts mean that we can apply the CEB by taking γ in eq. (21) to be r, with Σ 0 the associated lightsheet. We could consider including the subtracted term, taking σ to be the edges Σ 0 ∩ Γ 0 and Σ 1 ∩ Γ 1 , but this subtracted term does not seem to lead to a well defined bound on non-local computation. This is because each choice of protocol will deform the bulk geometry in the future of the null membrane in some way, and in particular change the area of Σ 0 ∩ Γ 0 and Σ 1 ∩ Γ 1 (but not the area of r). Fortunately, the CEB will be strong enough to enforce the constraint from non-local computation even with this subtracted term removed.
Applying the CEB to the ridge, and dropping the subtracted area term, we learn that A similar bound holds for Σ 1 . Since the inputs could in general be in the maximally mixed state, the right hand side here is just ln d A 0 . Thus computation inside the scattering region is limited to having at most an area's worth of inputs from each side.
Recall that we can upper bound the area of the ridge in terms of the mutual information, as given in eq. (10). Using this, we have that the left hand side of the CEB is bounded above by 1/2 the mutual information.
This bound is of the same form as eq. (20), but with α = 1. Since all monogamygame based bounds have α ≤ 1, the CEB based statement is strong enough to enforce all bounds coming from monogamy games. An important goal is to understand if there are other quantum tasks for which stronger lower bounds in terms of the input dimension on the mutual information exist. For example linear bounds with α > 1, or other explicit bounds with a super-linear behaviour. See for example [50] for work in this direction, where a 'smoothness' assumption is made on the form of the non-local computation protocol, and new interesting bounds can be obtained. 14 For bounds linear in ln d A 0 with α > 1, one would have to carefully understand if the subtraction term in the CEB, interpreted appropriately, suffices to enforce this constraint, or if new physics is needed. For super-linear bounds, it's clear physics beyond the CEB is needed, since the upper bound on ln d A 0 from the CEB bound scales like 1/G N , while the new bound would scale differently in G N .
There is reason to expect proving super-linear lower bounds on entanglement in non-local computation to be a difficult problem. In the context of the f -routing tasks discussed in [22,23], upper bounds on entanglement in terms of measures of the complexity of a classical function f have been proven. Consequently, proving lower bounds on entanglement cost proves lower bounds on these measures of complexity. For example the protocol in [23] shows that entanglement lower bounds imply lower bounds on span program size [51]. While some such lower bounds are known, they are never stronger than linear, and proving stronger bounds is a long standing and elusive goal in complexity theory. Because of this, it is especially valuable to look for lower bounds of a different type. In particular bounds in terms of the complexity of the operation to be performed, rather than explicit bounds in terms of the input size, do not suffer the same challenges as explicit bounds. We begin exploring such bounds in the next section.

What is the bulk dual of entanglement cost?
The strongest existing lower bounds on entanglement cost in non-local computation are linear in the number of qubits of input. As discussed in the previous section, the bulk consequences of such bounds can be understood as enforced by the covariant entropy bound. As we discuss in detail below, the best protocols for performing nonlocal computation use entanglement exponential in the input size. In general then, we know little about the entanglement necessary to implement a unitary non-locally -there is an exponential gap between our upper and lower bounds. Within this gap some property of the unitary U must control its entanglement cost, and we would like to understand what this property is. Somewhat trivially, this property could just be the size of the inputs, and (for example) all unitaries could be implementable with linear entanglement, although this seems unlikely. 15 Whatever controls the entanglement cost, bulk physics must see this quantity and somehow enforce the associated constraint on computation. In particular if this quantity is too large, bulk physics must enforce that the computation cannot happen within the scattering region. If the controlling quantity is the input size, the CEB gives an appropriate bulk mechanism. If the controlling quantity is something else, bulk physics must see that quantity and enforce a new constraint.
Lloyd has suggested [4] that the circuit complexity of a unitary controls how large a region is necessary to implement it, and has suggested a mechanism by which this could be enforced. Lloyd assumed that in gravity the implementation of a unitary U can be modelled as a sequence of elementary gates acting on O(1) qubits, each of which maps the input to an orthogonal state. Given this assumption, the Margolus-Levitin theorem [52] gives that the time required to implement a single gate is related inversely to the expectation value of the energy of the system, 16 where E is the energy above the ground state. Lloyd then noted that the energy inside the subregion should be less than the energy of a black hole that encloses the system, say of area R, so E R. Calling the time extent of the region T , we would then have Assuming T ∼ R, we can also express this in terms of the regions area A For scattering regions, the naturally associated area is the ridge area, which we expect is similar to the area of an enclosing sphere. It is interesting that a simple assumption about bulk computations -that they happen via local gates that map to orthogonal states -leads to a bound on complexity. We will later argue that the non-local computation perspective also suggests a bound on complexity.
It is important to emphasize that Lloyd's assumption really is an assumption, and not a fact about quantum mechanics: even implementing high complexity unitaries need not involve moving through many orthogonal states. Further, this assumption or some additional input is needed for Lloyd's conclusion to hold, as it is possible within the framework of quantum mechanics to do arbitrarily complex unitaries arbitrarily quickly, while at arbitrarily low energy, as pointed out by Jordan [5]. It would be interesting to understand if Lloyd's assumption can be better justified, perhaps by considering the covariant entropy bound and the finite speed of light.
Starting from Lloyd's suggestion that complexity controls how large a region is needed to implement a computation, we will explore the possibility that circuit complexity controls the entanglement cost to implement a unitary non-locally. Before taking this up in the next section, we will formalize this idea as a pair of conjectures.

Conjecture 6
Given a unitary U A 0 A 1 , the minimal entanglement cost needed to implement U A 0 A 1 non-locally, labelled E A 0 :A 1 , and the interaction-class complexity of U, labelled C A 0 :A 1 , are related by where F 1 (C) = poly(F 0 (C)).
We will refer to this statement as the weak complexity-entanglement conjecture.
Roughly, this says that the complexity is the relevant quantity controlling entanglement cost, without specifying the relationship between the two quantities. When upper and lower bounds are related polynomially, as in this conjecture, we will say they are 'nearly matching'. We can also make a stronger conjecture that specifies this relationship. In particular, suppose that bound (24) can be saturated. That is, assume it is possible to do gates on O(1) qubits in time inversely related to the system's energy. Then we could saturate the bound (26), which suggests the following relationship between complexity and entanglement in non-local computation.
Conjecture 7 Given a unitary U A 0 A 1 , the minimal entanglement cost needed to implement U A 0 A 1 non-locally, E A 0 :A 1 , and the interaction-class complexity of U A 0 A 1 , C A 0 :A 1 are related polynomially, where F 0 and F 1 are polynomial in the complexity C.
We will refer to this statement as the strong complexity-entanglement conjecture. In both conjectures we are agnostic about the specific choice of complexity C underlying the definition of the interaction-class complexity, although the (non-uniform) circuit complexity is a natural choice given Lloyd's argument.

Complexity and entanglement in non-local computation
To support conjectures 6 and 7, we first show that there exist some non-trivial upper and lower bounds in terms of complexity on the entanglement cost. For upper bounds, we use [53]. The lower bound we prove here. Together they give, where C A 0 :A 1 is the interaction-class circuit complexity, E A 0 :A 1 is the entanglement cost. The lower bound holds for a large but not fully general class of quantum tasks, where the input on one side must be classical. As well, there are upper and lower bounds in terms of n , the minimal number of qubits sent into the interaction unitary. These bounds are where we prove the lower bound here and review the upper bound, which was shown in [24]. Note that the lower bound holds for any task where the inputs on one side are classical, whereas the linear bounds discussed in section 3 hold for specially constructed tasks. Our upper and lower bounds are unfortunately far from being related polynomially to each other or to the entanglement cost. As well, aside from the complexity based bound, there is also the system size based bound of eq. (30), which raises n as a possible quantity controlling the entanglement cost, and possibly undermining our argument. Section 6 and section 7 offer other evidence for the complexity based conjectures.

Upper bound from complexity
We briefly recall an upper bound due to Speelman [53]. Speelman considers the task of implementing a unitary U A 0 A 1 , given a circuit decomposition of U A 0 A 1 into the Cliffords + T gate set. He gives two protocols, which achieve Here n is the number of qubits in each of the inputs, k is the number of T gates appearing in the circuit decomposition, and d, is the number of layers of T gates.
To implement U A 0 A 1 , we can first simplify as much as possible via local pre-and post-processing, and then use Speelman's protocol on a unitary in the interaction class of U A 0 A 1 . For the interaction unitary U I , call the number of input qubits n , the number of T gates k , and the number of layers of T gates d . We can consider n 2 k or (68n ) d as (slightly obscure) measures of the complexity of the interaction unitary, and consider these as upper bounds on entanglement cost from these measures of complexity. Alternatively, we can rephrase these bounds in terms of the more traditional circuit complexity using These bounds follow, respectively, from the fact that qubits with no gates acting on them can always be removed from the interaction unitary, because the number of T gates is less than the total number of gates, and because the number of layers of T gates is always less than the number of gates. Using the first bound in eq. (31), these lead to the upper bound in eq. (29). When the interaction unitary can be taken to be a low complexity unitary, this provides a good bound. 17 Because the interaction unitary can be exponentially complex, this upper bound becomes doubly exponential. We give a different bound which is at worst singly exponential in the next section.

Upper bound for arbitrary unitaries
For unitaries with high complexity interaction unitarys, a different protocol performs better than Speelman's. This is the Beigi-König protocol [24], which uses as its basic tool port-teleportation [54]. We briefly describe port-teleportation before describing the Beigi-König protocol. Note that our review of both topics follows [55]. In general, a teleportation procedure has the following form.
With high fidelity, A system is reproduced on R i * . The teleportation is successful when the final state on QA is the same as the initial state on QA.
The most familiar example of a teleportation procedure occurs when A is a qubit, |Ψ LR = |Ψ + LR is the maximally entangled state, and the measurement is in the Bell-basis, We will call this Bell-basis teleportation, or just teleportation when it is clear from context that we mean this teleportation procedure specifically. An important fact about Bell-basis teleportation is that after Alice 0 's measurement the QR system is in one of the states Bob's correction operation is to apply Z x 1 R X x 2 R , which he can do once he receives x = x 1 x 2 from Alice, and then relabel R as A.
A port-teleportation procedure is illustrated in fig. 5. In port-teleportation, the entangled state is Each L i , R i system has the dimensionality of A. The measurement will produce an outcome i * ∈ {1, ..., N }, and the correction operation will be to trace out all but the i * subsystem R i . See [54] for a description of how to choose this measurement. In port-teleportation N may be large, so that the dimensionality of the resource system is much larger than that of the input system A. Further, the correction operation is the trace, which has the interesting feature that We will see below that this is portteleportation's key feature relevant for non-local computation.
In port-teleportation, the reproduction of the A system in the receiver's lab is approximate. Call the teleportation channel T . We can bound the diamond norm distance of the teleportation channel from the identity according to Notice that for a good teleportation, the number of ports must be chosen to be large compared to the dimension of the input system. Consequently the number of qubits in the resource system will be exponential in the number of input qubits.
With this background, we are ready to give the Beigi-König protocol to compute a unitary U A 0 A 1 non-locally. Intuitively, the protocol is as follows. First, we use a Bell basis measurement to bring the A 0 and A 1 systems together on one side, say the right side, obtaining measurement outcome x. Then, we port-teleport A 0 A 1 to the left, obtaining measurement outcome i * . On the left, we apply U(P x ⊗ I). At this stage the input state, with the unitary correctly applied, is held on one port on the left, and the data about which port the state is recorded into is held on the right. During the communication round the A 0 portions of every port are sent to R 0 , and the A 1 portion to R 1 . Additionally, i * is sent to both R 0 and R 1 . At the output locations, all systems but the i * port are traced out, and the subsystem from the correct port is returned.
This protocol is described in more detail below.
Protocol 8 Arbitrary unitaries using port-teleportation: Preparation phase: 1. Distribute a maximally entangled system |Ψ + F 0 F 1 consisting of n EPR pairs, with F 0 sent to C 0 and F 1 to C 1 . 2. Distribute a set of N maximally entangled systems ⊗ N i=1 |Ψ + L i R i , with each of the states |Ψ + L i R i consisting of n EPR pairs, with all L i sent to C 0 and all R i to C 1 .
Execution phase: 1. At C 0 , measure A 0 F 0 in the Bell basis, obtaining outcome x. Then Alice 1 holds the state at C 1 , and the index x is held at C 0 . 2. At C 1 , perform the appropriate measurement as if port-teleporting systems F 1 A 1 using the N maximally entangled pairs ⊗ N i=1 |Ψ + L i R i . Call the measurement outcome i * . Then i * is held at C 1 and the L 1 ...L N systems of the state |Ψ ≈ (P x ⊗ I) |ψ L i * ⊗ |ρ L c i * X (40) are held at C 0 , where X is some purifying system.
3. At C 0 , apply U(P x ⊗ I) to every subsystem L k . Then Alice holds with all L systems at C 0 , and i * at C 1 . 4. Relabel the L k qubits as A 0,k A 1,k , and send all of the A 0,k systems to R 0 and all of the A 1,k systems to R 1 . Send i * from C 1 to both R 0 and R 1 . 5. At R 0 trace out all but the A 0,i * system, relabel it as A 0 , and return it to Bob.
Similarly at R 1 trace out all but the A 1,i * system, relabel it as A 1 , and return it to Bob.
This completes the arbitrary unitary non-locally, although the use of port-teleportation means this performs the intended unitary only approximately. Note that we can always apply the Beigi-König protocol only to a unitary in the interaction class of the target unitary U. We let the minimal number of input qubits to the interaction unitary be n . Using the bound (38), we find where U · U † is the intended (unitary) channel, and N U is the applied channel. We are interested in fixing the closeness with which the channel is performed, and understanding how the entanglement required scales with the number of input qubits. Thus we fix := 2 4n +2 √ N , and find that N = 2 8n +4 / 2 . Note that there is also an additional, sub-leading, linear entanglement cost of at most n EPR pairs from the first, Bell basis, teleportation. Thus in total we need at most n + 2 8n +4 / 2 EPR pairs, which gives the second upper bound in eq. (29).

Lower bound from complexity
In this section we prove a lower bound on entanglement cost from the complexity of the interaction unitary, for a broad (but not fully general) class of quantum tasks.
The proof idea is to suppose there exists a non-local implementation of a given task using E EPR pairs. Then, we manipulate the non-local computation circuit to remove the need for EPR pairs and replace them with an interaction unitary in the new protocol. We describe this as a 'surgery' that involves cutting the EPR pairs and then stitching the protocol back together using an interaction unitary. Importantly, we do the surgery in such a way that the complexity of the interaction unitary is upper bounded by a function of E, call it F (E). Then the minimal complexity interaction unitary must have lower complexity than this, so C A 0 :A 1 ≤ F (E). Solving for E we get a lower bound of the desired form.
To perform the surgery, we will make use of the port-teleportation protocol described in the last section. As well, we will need to restrict the set of tasks that we consider to 'one-sided' tasks, which are as follows. The input at C 0 is both quantum systems A 0 , A 1 , and the input on the right is a classical string x, which specifies a unitary U x A 0 A 1 . The task is to bring systems A 0 and A 1 to R 0 and R 1 respectively, after performing U Figure 6: a) The starting non-local quantum computation, using E EPR pairs. b) A local computation which performs the same unitary as at left. Doubled lines indicate a set of N EPR pairs, where N is taken to be Θ(2 8E ). The measurement in the center is the portteleportation measurement. The measurement outcome i * is sent to both output locations and used to trace out all but the Y i * 0 and Y i * 1 systems.
Note that if we begin with the standard unitary task, with a fixed unitary U A 0 A 1 and A 1 starting on the right, a set of n = log dim A 0 EPR pairs can be used to bring the task into the one-sided form. Thus if one can prove bounds relating complexity and entanglement in the one-sided task these can be translated, up to linear terms, into bounds on the standard task. Unfortunately because the bound we prove is so weak the linear factors would make our lower bound negative, and so trivial, so we are restricted to bounding the one-sided case.
Lemma 9 For a one-sided quantum task with the set of unitaries {U x A 0 A 1 } x , the interaction-class circuit complexity of the task C A 0 A 1 :x lower bounds the entanglement cost according to Ω(log log Proof. Our prescription for performing surgery on the non-local computation to turn it into a local one is shown in fig. 6. To describe it more carefully, we fix some notation for the non-local computation. In particular the non-local computation has the form where V 0 and V 1 each consist of E qubits. Notice that because the input on the right is classical, we can without loss of generality consider protocols that implement an isometry V R,x on the right that doesn't take any inputs except the V 1 system.
We perform the surgery as follows. On the left, the state |Ψ + V 0 V 1 consisting of E EPR pairs is prepared locally. The V 0 system is input into V L , just as in the non-local protocol. V 1 is brought into the interaction unitary. On the right, N copies of |Ψ + are prepared locally, call them |Ψ + with i running 1 through N . All of the V i 0 systems are sent to the interaction unitary, and all of the V i 1 systems are kept. Also on the right, V R,x is applied to each V i 1 , producing systems Y i 0 Y i 1 . Each of the Y i 0 systems are sent to R 0 , each of the Y i 1 systems are sent to R 1 . In the interaction unitary, the port-teleportation measurement is performed with V 1 as the input system, and the V 1 0 ...V N 0 as the resource system. The measurement outcome i * ∈ {1, ..., N } is sent to both output locations. At the output locations, all but Y i * 0 and Y i * 1 systems are traced out. Finally, at the output locations we perform

as in the non-local computation protocol.
To see why the modified procedure performs the same unitary as the initial nonlocal protocol, consider that after the port-teleportation measurement the ) c X for X some purifying system. This is then fed into a protocol in the non-local form, which is now We can perform the traces to simplify this to which is just the original non-local circuit of eq. (43).
To quantify how well this local protocol reproduces the unitary implemented by the non-local protocol, we again make use of the bound on the diamond norm eq. (38). This leads to the channel implemented by our modified protocol, call itŨ, agreeing with the one implemented by the non-local protocol, U, up to Fixing then, we need to take Given a non-local protocol using E EPR pairs then, we see that there exists a local protocol where the interaction unitary consists of port-teleporting E qubits using 2 8E+8 2 ports. To upper bound complexity in terms of entanglement, we just need to upper bound the complexity of a port-teleportation in terms of the input size and number of ports, both given here in terms of E.
To bound the complexity of port-teleportation, we can view the measurement as a quantum channel, and then purify this channel to a unitary process on a larger system. 18 This has N = 2 8E+8 / 2 Kraus operators, d X = E, and d V = 2 E+N . This can therefore be written as a unitary acting on a system of log The maximal complexity of this unitary is 2 O(2 8E / 2 ) , and the minimal complexity of the interaction unitary must be less than the complexity used in this particular protocol, so Inverting this we obtain as needed. This argument also leads to a lower bound on E in terms of any measure of complexity or other property of port-teleportation, so long as we minimize over choices of interaction unitary. In particular, we also obtain the lower bound of eq. (30), where n is the minimal number of qubits brought into the interaction unitary. This follows immediately from the proof of lemma 9, now noting that the portteleportation measurement brings O(2 8E ) qubits into the interaction unitary, which must be larger than n , the minimal number brought into the interaction unitary. It is also interesting to note that while minimizing the entanglement used in portteleportation has been carefully considered [54,57], to our knowledge minimizing the complexity of the needed measurement procedure has not. Finding a less complex measurement or better algorithm for implementing the existing measurement would lead to a better lower bound in our context.

Results for restricted classes of protocols
Conjecture 6 claims that, up to polynomial overheads, the complexity of a unitary controls the entanglement cost of implementing it non-locally. In the last section we gave upper and lower bounds on entanglement in terms of complexity, but these are far from being polynomially related -in fact, the upper and lower bounds are separated by three exponentials from one another. Ideally, we would improve the upper and lower bounds until they nearly match, but so far this hasn't been possible. 18 An alternative approach would be to note that the port-teleportation measurement is a 'prettygood measurement' and use the algorithm given in [56]. Unfortunately for our specific case their bound on complexity for pretty-good measurements does no better than the naive purification argument we give here.
To make progress, and further explore the entanglement-complexity conjecture, in this section we consider simplifying the problem by restricting the protocols available to perform the computation non-locally. We give two examples. The first considers protocols which use only Clifford unitaries. This restricts the protocols to perform tasks consisting of implementing a Clifford unitary. We recall an existing upper bound for implementing Clifford unitaries, and prove a new, nearly matching lower bound. Under this restriction the strong complexity-entanglement conjecture holds. The second example considers protocols that are limited to Bell basis measurements plus classical computations. This type of protocol restricts the tasks implemented to be of a type known as f -routing tasks. We recall the results of [22], where they prove nearly matching upper and lower bounds for such protocols. This shows the weak complexity-entanglement conjecture holds in this context.

Strong complexity-entanglement conjecture holds for Clifford protocols
In this section we show that the strong complexity-entanglement conjecture is true under a restriction to Clifford protocols. In particular, we show the following.
Theorem 10 The entanglement cost to implement a Clifford unitary C A 0 A 1 nonlocally using a protocol consisting only of Clifford operations, E c , is related to the interaction-class circuit complexity, C A 0 :A 1 , of that Clifford according to As well, we also show the following related fact.

Theorem 11 Given a Clifford unitary C
and define the entanglement cost to implement this unitary non-locally using only Clifford circuits to be E c . Then E c = n /2.
To be as general as possible, we discuss Clifford unitaries defined with respect to the generalized Pauli operations acting on n qudits, C ⊗n d , with d prime. Recall that the d dimensional Pauli operators X and Z are defined by where ω = e 2πi/d . These operators generate the d dimensional Pauli group. One can straightforwardly check that the generalized CNOT, Hadamard, and phase gates are in the normalizer, and in fact, these generate the full Clifford group over qudits [58]. To prove theorems 10 and 11, we first need an upper bound on entanglement cost for implementing a Clifford non-locally. To perform a Clifford C A 0 A 1 , where each of A 0 and A 1 consist of n qudits, we first reduce implementing C A 0 A 1 to implementing an interaction unitary of we use the following protocol [59]. The input state is labelled |ψ A 0 A 1 , where we take a pure state for notational convenience but the protocol works generally.

Execution phase:
• Alice 0 measures A 0 L in the generalized Bell basis, obtaining a measurement outcome x. She maintains a copy of x and sends a copy to Alice 1 .
• Alice 1 relabels the R system as A 0 , and performs the Clifford C E . She sends the A 0 system to Alice 0 and keeps the A 1 system.
• After the communication round, Alice 0 and Alice 1 both locally compute (P 0 • Alice 0 applies (P 0 y ) † to the A 0 system, then returns A 0 to Bob. • Alice 1 applies (P 1 y ) † to the A 1 system, then returns A 1 to Bob.
To see this works correctly, notice that after Alice 0 measures the A 0 L system in the Bell basis, and Alice 1 relabels R as A 0 , Alice 1 holds the state is Clifford. After the communication round, both Alice 0 and Alice 1 can determine the Pauli string y, so they correct the local part of their strings and obtain C E . Notice that if A 1 consists of fewer qudits than A 0 we could have reversed their roles and teleported A 1 instead.
We collect the resulting upper bound on entanglement as the following remark.

Remark 13 For a Clifford unitary C
where n i := min C E ∈E(C) log dimA i .
Next, we will give a lower bound on entanglement cost in terms of n 0 and n 1 . This is done in the following lemma. Figure 7: a) The starting non-local quantum computation, using E EPR pairs. Here we assume V L , V R , W L , W R are all Clifford unitaries. b) A local computation which performs the same unitary as at left. The measurement in the center is a Bell basis measurement. The measurement outcome i * is sent to both output locations and used to undo the effect of the Pauli operators introduced by the Bell measurement.
Lemma 14 When using a protocol consisting only of Clifford operations, the entanglement cost E c is lower bounded according to both (n 0 + n 1 )/2 ≤ E c and C A 0 : Proof. Suppose we have a non-local computation protocol which implements C A 0 A 1 using E c EPR pairs, and only uses Clifford unitaries. We will show that this protocol can be manipulated to produce a local protocol with an interaction unitary that acts on at most 2E c qudits.
To do this, first consider the general form of a non-local computation protocol, shown in fig. 7a. By our assumption, V L , V R are Clifford unitaries. We will manipulate this circuit diagram to produce a new protocol that replaces the E c EPR pairs with a local computation.
The local protocol is shown in fig. 7b. The basic idea is to replace the shared EPR pair with EPR pairs prepared locally on each side. The local computation then consists of measuring corresponding pairs in the Bell basis. This sews the two EPR pairs together, but inserts a random Pauli. Because V L and V R are Clifford, this Pauli can be corrected for before applying W L and W R .
The local computation acts on 2E c qudits, which upper bounds the minimal number of qudits which must be used in the local computation. But this is just n 0 + n 1 , so n 0 + n 1 ≤ 2E c , giving the first lower bound.
For the second lower bound, notice that the local computation consists of measuring E c EPR pairs in the Bell basis. Each of these measurements can be done using one Hadamard gate, one CNOT, and two single qubit measurements in the computational basis. The total complexity of the measurement then is 4E c , so C ≤ 4E c , giving the second lower bound.
We are now ready to combine the upper and lower bounds to prove theorems 11 and 10.
Proof. (Of theorem 11) Combining lemma 14 and remark 13, we have that To avoid a contradiction, these bounds require that n 0 = n 1 , so we learn the interesting fact that the optimal protocol always has an interaction unitary that acts on subsystems from the left and right which are of equal size. Taking n 0 = n 1 we obtain E c = n where n = n 0 + n 1 .
Next we prove theorem 10.
Proof. (Of theorem 10) Any qubit which does not have at least one gate acting on it can be taken out of the interaction unitary, so we also have n ≤ C A 0 A 1 , so from theorem 11 we have that E c ≤ C A 0 A 1 . Combining this with the complexity lower bound of lemma 14 proves the theorem. It would be interesting to understand if whenever C is Clifford the entanglement cost is realized by a protocol that only uses Clifford operations. If so, we would have n = E c (C) = E A 0 :A 1 (C), so this would provide an example of an explicit bound of the form of eq. (20) discussed in section 3 where α = 1.
We also note that our lower bound technique works for a larger class of tasks. In particular, suppose that in addition to the quantum systems A 0 and A 1 input on the left and right, there are additional classical strings x 0 and x 1 on the left and right, respectively. The task is to implement a Clifford C (x 0 ,x 1 ) A 0 A 1 , where the choice of Clifford is a function of the classical inputs. Then the same surgery technique in lemma 14 provides a lower bound C A 0 :A 1 /4 ≤ E c . We have not found a good upper bound in this case, however, and we don't believe this lower bound is tight. As well, the same lower bound technique applies when only V L , V R are Clifford but W L , W R are not.

Weak complexity-entanglement conjecture holds for garden-hose protocols
In this section we discuss another class of restricted protocols. In this setting, earlier work [22] has found upper and lower bounds on entanglement as a function of the complexity which are related to each other by a polynomial, but the entanglement itself is exponential in the complexity. Thus in this setting only the weak complexityentanglement conjecture is true. We consider tasks that have classical and quantum inputs, and restrict the protocol to consist of classical computations and Bell basis measurements, where the choice of systems to measure can depend on the classical computations. Because of this restriction, the tasks we can complete become limited to what are called f -routing tasks, defined as follows. At input location C 0 , Alice 0 receives a quantum system, call it Q, along with a classical string x ∈ {0, 1} ×n . At input location C 1 , Alice 1 receives a classical string y ∈ {0, 1} ×n . To complete the task, system Q should be returned at r f (x,y) , where f n (x, y) ∈ {0, 1}. To complete a routing task locally, the simplest strategy is to bring x, y and Q together, compute the function f , and then direct Q based on the result of the computation. To perform the routing task non-locally, a well known protocol is the garden-hose strategy [22]. The garden-hose protocol involves sharing EPR pairs between the left and right, then doing a set of Bell measurements on Q and entangled particles. Which measurements are performed depends on the values of the strings x and y. The measurement outcomes are then communicated to both of the regions R 0 and R 1 . For any function f , if the mappings from strings x, y to a set of measurements on both sides is chosen then Q is brought to R f (x,y) . We give simple examples of computing a NOT and AND function in fig. 8.
The entanglement cost of performing the routing task in this way has a simple relationship with the complexity of the function f , as was shown in [22]. To state their result we will need a different notion of complexity, which contrasts with our notion of 'interaction-class' complexity from definition 3. With this notion of pre-processed complexity, we can state the result of [22], which is as follows. Let GH(f ) denote the entanglement cost to perform the frouting task using the garden-hose strategy. Let SPACE(f ) be the memory required to compute f on a Turing machine. Then To relate this result to our conjecture 6, we should understand the relationship between the pre-processed complexity and the interaction-class complexity C A 0 :A 1 . In particular, we need a notion of interaction-class space complexity to make a comparison.
Definition 16 For an f -routing task, consider protocols of the local form given in fig. 4b which use only classical computation and Bell basis measurements, and where the measurements may be controlled based on the bits held in memory during the classical computation. We define SPACE Q,x:y (f ) as the minimal memory needed in the interaction unitary.
With this definition, we can state the following lemma that relates interaction-class of pre-processed notions of complexity.
We show this in appendix A.
Because of lemma 17, eq. (57) remains true (up to some changed constants) with the pre-processed complexity of f replaced by the interaction-class complexity of the f -routing task. At least under the restriction to garden-hose protocols then, [22] establishes polynomially related upper and lower bounds on entanglement cost in terms of interaction-class complexity.

A prediction for f -routing
Conjecture 6 states that the complexity of a task controls the entanglement cost needed to implement it non-locally. If indeed complexity controls entanglement, it is meaningful to compare complexity-entanglement relationships among different tasks. In particular, in this section we point out that the Clifford protocol 12 efficiently implements computations of higher complexity than does the garden-hose protocol. If conjecture 6 is true then, it would follow that improvements to the garden-hose protocol exist. We explore this in more detail below.
Using polynomial entanglement, the garden-hose protocol introduced in the last section can complete the f -routing task for functions f that, after local preprocessing, can be computed in log-space. We recall the following definition from [22] that captures the set of such functions. In terms of this definition, the efficiently implementable functions in the garden-hose model are those functions in L (2) .
To characterize the complexity of the Clifford unitaries, consider the following computational problem.
CliffordMeasurement d : • Input: A description of a Clifford circuit over n qudits and a Z eigenstate |k .
Here Π k,n is the projector |k k| on the nth qudit. The next theorem characterizes the complexity of Clifford unitaries.

Theorem 19
The CliffordMeasurement d problem is complete under log-space reductions for the class Mod d L.
This is proven in [60] for d = 2 and in [61] for prime d. To clarify the meaning of complete under log-space reductions, this means that any problem in the class Mod d L can be mapped to an instance of Clifford measurement using a Turing machine that has logarithmic memory, and that the Clifford measurement problem is itself in the class. It is important that this theorem does not say that, given a function f in Mod d L and input x, that there is a single Clifford circuit C f into which we can feed the input to compute f . Instead, the choice of Clifford circuit depends on both f and x, and the circuit always runs on the all zero's state.
We can now argue as follows. First, assume the weak complexity-entanglement conjecture, which says that complexity controls entanglement in non-local computation up to polynomial overheads and second, note that the Clifford's have complexity Mod d L and can be implemented efficiently. Together, these imply the f -routing task should be efficiently implementable for all functions f in Mod d L. Allowing for preprocessing, we should further be able to achieve the class Mod d L (2) , defined from Mod d L in a way analogous to L (2) from L.
The most obvious approach to this problem is to somehow solve the f -routing task by using the Clifford protocol 12 as a subroutine, perhaps by using the logspace reduction from functions in Mod d L to Clifford circuits. Because the reduction is really a map from the function plus the given input string to a Clifford circuit, it is not possible (so far as we understand) to do this. Nonetheless our claim is that it should somehow be possible to improve on the garden-hose protocol and achieve those functions in Mod d L.
Recently, we studied the f -routing task and were able to achieve exactly the expected improvement [23]. In particular, we showed where SP d, (2) and SP d (M ) is the minimal size of a span-program [51] over the field Z d that computes M . The complexity class of functions that can be computed with polynomialsized span programs is Mod d L, so that here the functions for which we can perform f -routing using polynomial entanglement is at least Mod d L (2) , where again the added subscript accounts for performing local pre-processing of the inputs. This aligns exactly with the expectation raised above, which followed from the weak complexity-entanglement conjecture.
The protocol which achieves this improvement is inspired loosely by the holographic context, where error-correction is understood to play an important role in Figure 9: Some simple code-routing protocols. The map E takes in the Q system and records it into a 3 share secret sharing scheme where any 2 shares recover the secret. The lower boxes indicate the share should be brought to the side labelled by the corresponding bit value, which we can achieve using a garden-hose protocol that uses O(1) EPR pairs. a) Code-routing protocol for computing AN D(x, y). b) Code-routing protocol for OR(x, y). Figure reproduced from [23].
how bulk information is recorded into the boundary. Roughly, the idea of the protocol is to combine quantum error-correction with the teleportation based strategies used in the garden-hose protocol. Two simple examples are shown in fig. 9. Replacing the simple threshold code used in those examples with the general access structure secret sharing schemes constructed in [62], it is possible to achieve the performance given in eq. (58). This is discussed in detail in [23].
Unfortunately, for code-routing protocols we were not able to prove complexity based lower bounds on entanglement cost, as is possible in for example the gardenhose case. Some partial results were established in [23]. It is interesting to note however that the codes constructed in [62] are stabilizer codes, so the code-routing protocol uses only classical computations plus Clifford unitaries. It might be possible then to prove lower bounds on code-routing using the circuit manipulation technique of section 6.1. The key step would be to relate the pre-processed and interaction class span program complexity.

Discussion
Broadly, our strategy in this article has been to try and understand constraints on information processing in the presence of gravity by restricting to the setting of AdS/CFT, and making use of the boundary, non-gravitational description of a given bulk information processing task. While we have focused on possible constraints on computation within a scattering region, there are other questions we could ask about bulk information processing. For example, another interesting setting was discussed in [63].
An important question is if constraints on computation derived from non-local computation and in the context of AdS/CFT will continue to hold in more general spacetimes. We find this plausible, for the following reasons. First, the scattering region can be constructed to be much smaller than the AdS length 19 , suggesting the bulk geometry being asymptotically AdS doesn't play a role in enforcing any constraints. Second, computational statements often exhibit independence from the microscopic details of the underlying systems. For example, many different physical systems can be used as computers, and can simulate the computations run on each other with only polynomial overheads. Consequently, we expect the microscopic details of the bulk theory in any specific realization of AdS/CFT to also be unimportant in enforcing these constraints. Given that we expect neither the detailed field content nor the asymptotic structure to play a role, we are lead to think constraints derived from non-local computation should apply in general spacetimes.
In fact, this intuition is correct for the constraints we can currently derive from non-local computation. In section 3 we reviewed linear constraints on entanglement in non-local computation, which in the bulk imply no more than an area's worth of inputs can be brought into the scattering region. The natural bulk mechanism that enforces these constraints is the covariant entropy bound. In an ahistorical world where the role of non-local computation in holography was understood before the covariant entropy bound, we would, according to the reasoning of the last paragraph, be led to conjecture the CEB holds in general spacetimes. Indeed, all evidence thus far points to this being a correct generalization.
Returning to the question of whether or not stronger than linear bounds on entanglement cost in non-local computation exist, it is interesting to frame the problem in terms of two options, at least one of which must be true. Either: 1. There are no constraints on computation in the bulk beyond the covariant entropy bound, or... In the boundary, there are also two mutually exclusive possibilities, a. All computations can be implemented non-locally with entanglement which is no larger than their inputs plus a description of the unitary to be performed, or... b. ... some unitaries require more entanglement than the size of their inputs plus the size of their description.
Notice that we have framed the first possibility to account for the size of a description of the unitary, which must be brought into the region and contributes towards the entropy bounded by the CEB. Notice also that our reasoning shows that, at least for scattering regions constructed with the initial CFT state being vacuum, 1. ⇒ a. and b. ⇒ 2., both by applying QG(S 0 ) ⊆ N LQC(S 0 ). We find both possibilities a. and b. above exciting: the first is surprising from a quantum information theoretic perspective, and has severe consequences for the cryptographic task of positionverification (see below for comments). The second is exciting from a gravitational perspective, in that it implies 2.
To better understand these possibilities, we have tried to identify plausible properties of a unitary that could control it's entanglement cost. In particular, we raised two conjectures which assert a role for the complexity in determining the entanglement cost of a unitary. We briefly summarize the evidence for the weak complexityentanglement conjecture (conjecture 7), which says roughly that interaction-class complexity controls entanglement cost.
• From section 5: there exist weak upper and lower bounds on entanglement cost in terms of complexity.
• From section 6.1: restricting to protocols that use Clifford unitaries, entanglement cost is upper and lower bounded by complexity, with the upper and lower bounds being related linearly.
• From section 6.2: restricting to protocols that use Bell basis measurements, polynomially related upper and lower bounds on entanglement can be proven in terms of complexity.
• From section 7: as a consequence of the weak complexity-entanglement conjecture, we find that f -routing should be possible for all functions f in Mod d L (2) using polynomial entanglement. After this prediction was noticed, we were able to verify it [23].
The strong complexity-entanglement conjecture (conjecture 6) states that interactionclass complexity and entanglement cost should be related polynomially. We briefly summarize the evidence.
• From section 4: there is a plausible, simple, assumption about bulk physics that would enforce the resulting upper bound on complexity in the scattering region.
• From the bound E = O(2 8n ): the maximal entanglement cost is polynomial in the maximal complexity (they are both exponential in n , the input size). As well, whenever interaction-class complexity is zero the entanglement cost is also zero, and vice versa.
• From section 6.1: restricting to protocols that use Clifford unitaries, entanglement cost and complexity are related polynomially.
We discuss some future directions aimed at better understanding these conjectures in the next section. We also note that resolving these conjectures, and better understanding entanglement cost in non-local computation generally, has important implications for position-verification [15][16][17][18]. In that context, Bob wishes to verify that Alice is able to perform quantum operations within a specified spacetime region. To do this, Bob arranges a quantum task of his choosing. If Alice behaves honestly, she will complete the task locally by entering the given spacetime region and performing the needed operations. If Alice behaves dishonestly, she will use a non-local computation to complete the task while remaining outside of the spacetime region.
Ideally, Bob chooses a task such that the local strategy is much easier in some way than the non-local strategy, so that it is much easier to be honest than to cheat. An ideal task for the cryptographic setting then is one which has low complexity but high entanglement cost. If conjecture 7 is true, this will in one sense never be the case, since entanglement cost and complexity would be related polynomially. Of course, one could still consider settings where, for example, the local computation is mostly classical and of polynomial complexity, while the non-local computation requires polynomial entanglement. Assuming classical computation is easy and storing (even polynomial) entanglement is hard then still leads to a gap between the difficulty of honest and dishonest strategies. For work in this direction see [46].

Future directions
There are many open avenues towards better understanding the relationship between complexity, entanglement, and computation in the presence of gravity. We list a few directions below.

Commuting algebras vs tensor products
While we are interested in AdS/CFT, concretely we have studied non-local quantum computation assuming that the two players Alice 0 and Alice 1 hold factorized Hilbert spaces. In AdS/CFT, the subsystems held by Alice 0 and Alice 1 (including their resource states) instead are described by commuting subalgebras. For at least some information processing tasks, in particular non-local games [64], there can be a gap between the best strategies in the tensor product and general von Neumann algebra cases. One basic question is to understand if a similar improvement by generalizing beyond tensor product structures occurs in the context of non-local computation. Note however that the examples in [64] rely on algebras that fail to have the split property. Since the relevant regions here, V 0 and V 1 , are separated, we naively don't expect a similar gap. 20

Improved lower bounds on entanglement
In this work we gave the first lower bound on entanglement from complexity. Qualitatively, this is different from existing bounds, which are either for specific tasks [24,45] or specific families of tasks [46]. While it is interesting a lower bound of this type exists, the bound we have given is much weaker than suggested by our 'strong' complexity-entanglement conjecture. An interesting goal is to strengthen the lower bound. One route towards doing so would be to understand if portteleportation can be carried out with a low complexity measurement. This may also be a question of independent interest in quantum information. 21

Improved upper bounds on entanglement
The upper bound on entanglement cost from complexity is also weaker than suggested by the strong complexity-entanglement conjecture. Recently, we improved on the most-efficient known protocol for performing the f -routing task by exploiting error-correcting codes [23]. The use of error-correction was loosely inspired by its role in AdS/CFT. It would be interesting to understand if more detailed features of AdS/CFT could be used to inspire other non-local computation protocols, in particular protocols which solve tasks which implement general unitaries. One new protocol which efficiently performs computations on unitaries that do not spread operators too much was recently given in [66], although the relationship here to complexity is unclear.

Relaxing restrictions on protocols
We studied protocols restricted to Clifford operations or restricted to Bell basis measurements, and found polynomial relationships between complexity and entanglement in those settings. Another approach to establishing the complexityentanglement conjecture is to continue relaxing the set of allowed protocols, and attempt to establish good upper and lower bounds in the larger setting. For example, it might be interesting to restrict the circuit complexity of the protocol. This also upper bounds the complexity of the implemented unitary, so the upper bound due to Speelman [53] applies. We could look for a similar lower bound, perhaps using our 'surgery' strategy combined with the techniques of [53]. section, we prove the following theorem relating interaction-class and pre-processed space complexities, in the garden-hose setting.
Proof. Suppose we have a protocol for completing an f -routing task using only Bell basis measurements and classical computation, with pre-processed space complexity SP ACE (2) (f ). Then, this is already of the interaction-class form of fig. 4b (with W L , W R trivial), so SP ACE Q,x:y (f ) ≤ SP ACE (2) (f ).
Next we want to prove the opposite inequality, up to constant factors. Assume we have a local computation circuit of the form shown in fig. 4b, which defines a protocol P . By assumption, this protocol consists only of Bell basis measurements and classical computations, and the classical computations performed in the interaction unitary can be performed in space SPACE Q,x:y (f ) Now consider a new protocol P , which includes the same Bell measurements and classical computations as in P , but adds a classical memory register R which tracks the location of the Q system through successive Bell measurements. In particular, the register initially stores 'Q , the label for the system Q. Then, we run the classical computation associated with P until it specifies that QE i should be measured in the Bell basis, where E i E j is in a maximally entangled state. Then E j is recorded into the register, and the computation is restarted. We then look for a measurement involving E j E k , and record E k into the register, and so on. Note that initially R should be held on the left, since Q is on the left.
If the system holding Q is sent from the left directly to either R 0 or R 1 , we erase the label of the system in the register and just record 0 or 1. Otherwise, Q will be recorded into some system E i that is sent into the interaction unitary. In this case send the memory register along with the inputs to the interaction unitary. Note that the memory added to the interaction unitary need not be bigger than SPACE Q,x:y (f ) + 2. This is because the original computation must have a memory large enough to index the input systems, so the size of R is less than SPACE Q,x:y (f ). The additional two bits are added to record the possibility of a direct sending of Q to R 0 or R 1 . 22 In the interaction unitary, continue to use the memory register to track the location of the Q system. Then, if this system is sent towards R 0 output 0, and if this system is sent towards R 1 output 1. This is now a computation in the preprocessed form, and the added memory register uses at most SPACE Q,x:y (f ) + 2, so SP ACE (2) (f ) ≤ 2SP ACE Q,x:y (f ) + 2 (60) so we have that SPACE Q,x:y (f ) = Θ(SPACE (2) (f )), as needed.