1 Introduction
A twoplayer nonlocal game is played between a verifier and two cooperating players named Alice and Bob who cannot communicate with each other once the game starts. During the game, the verifier samples a pair of questions
from a joint distribution
, sends to Alice and to Bob, who respond with answers and respectively. The verifier accepts if and only if for some predicate . The quantum value of a nonlocal game , denoted by , is defined to be the supremum of the verifier’s acceptance probability over all possible finite dimensional quantum strategies of Alice and Bob for the game .What is the complexity of computing the quantum value of nonlocal games? In [Slo19], Slofstra proved that the problem of determining whether a given game has is undecidable. Recently, it was shown that approximating up to any additive constant is also an uncomputable problem [JNV20]
. In particular, there is a computable reduction from Turing machines
to nonlocal games such that if halts (when run on an empty input), then , and otherwise . Since determining whether a given Turing machine halts (i.e. the Halting problem) is undecidable, so is the problem of determining whether the quantum value of a nonlocal game is or at most .Conversely, one can reduce the problem of approximating the quantum value of nonlocal games to the Halting problem; there is an algorithm that for every nonlocal game exhaustively searches over finitedimensional strategies of increasing dimension to find one that succeeds with probability close to (above , say). If then the algorithm is guaranteed to find such a strategy; otherwise if the algorithm will run forever. In complexitytheoretic terms, this shows that the class , the set of languages decidable by multiprover interactive proofs with quantum provers, is equal to , the set of recursively enumerable languages (i.e. the class for which the Halting problem is complete).
In this paper, we return to the problem originally investigated by Slofstra [Slo19]: what is the complexity of deciding if is exactly equal to for nonlocal games ? This corresponds to the complexity class that we call zero gap , denoted by . In this model of interactive proofs, in the YES case (i.e. ), there is a sequence of finitedimensional prover strategies that cause the verifier to accept with probability approaching . In the NO case (i.e. ), all finitedimensional prover strategies are rejected with positive probability  but could be arbitrarily close to .
It is easy to see that and thus contains undecidable languages. Furthermore, we know that cannot be equal to ; the results of [Slo19, FJVY19] imply that , the complement of , is also contained in . Since , this implies that strictly contains .
What problems can be reduced to the task of exactly computing the quantum value of nonlocal games, rather than ‘‘just’’ approximating it? We characterize the class by showing that it is equal to , a class that belongs to the arithmetical hierarchy from computability theory. The arithmetical hierarchy is defined by classes of languages decidable via formulas with alternating quantifiers. For example, the class is equal to the class , which is the set of languages of the form for some decidable predicate . The class is equal to , the set of languages of the form . The class is the set of languages of the form .
An equivalent definition of the class is that it is the set of languages such that there is a Turing machine that has oracle access to the Halting problem, and if and only if . It is known that strictly contains . This shows that contains problems that are harder (in a computability sense) than the Halting problem.
We specifically show that there exists a computable reduction from languages to the problem of deciding whether a threeplayer nonlocal game has quantum value . It is likely that a similar reduction holds for twoplayer nonlocal games but we leave this for future work. We also show that the problem of deciding if a nonlocal game has quantum value can be reduced to a language, thus establishing the equality .
This paper, combined with the results of [JNV20] and [Slo19], paints a fascinating landscape about the complexity of quantum multiprover interactive proofs, in which there are four different complexity classes to consider. The first two are and , which we defined already. The second two are and its zerogap variant . The class stands for languages that are decidable by quantum multiprover interactive proofs in the commuting operator
model: here, the provers are allowed to use infinitedimensional quantum strategies, and the measurement operators of Alice only need to commute with those of Bob (rather than be in tensor product).
One of the consequences of the fact that is that . This is because , due to the fact that the commuting operator value of a nonlocal game can be upperbounded using a convergent sequence of semidefinite programs [NPA08, DLTW08]. It is also the case that , and in fact equality holds due to [Slo19, CS19]. It remains an open question to determine if .
There are a number of curious and counterintuitive aspects about this landscape of complexity for nonlocal games. First, if , then there would be a pleasing symmetry in that and (even though the ‘‘co’’ refer to different things on each side of the equation!). On the other hand, we have that and , meaning that  in the zero gap setting  there are more languages that can be verified with provers using (a limit of) finitedimensional strategies than can be decided with provers using infinitedimensional commuting operator strategies! Of course, in the setting of interactive proofs, giving provers access to more resources can change the complexity of the interactive proof model in unexpected ways.
1.1 Proof overview
We prove the lower bound by combining two components: first we leverage the result of [JNV20] that as a black box, which implies that there is a quantum multiprover interactive proof for the Halting problem. Next, we use a compression theorem for quantum multiprover interactive proofs that was proved in [FJVY19]. A compression theorem, roughly speaking, states that given a verifier for a quantum multiprover interactive protocol (which can be modeled as a Turing machine with tapes to receive/send messages to the provers), one can compute a much more timeefficient verifier whose quantum value is related in some predictable way to the quantum value of . Several recent results about the complexity of nonlocal games crucially rely on proving compression theorems with various properties [Ji17, FJVY19, NW19, JNV20].
In more detail, the compression theorem of [FJVY19] (which in turn is a refinement of the compression theorem of [Ji17]) states that given a description of a verifier , one can compute a description of a threeplayer^{1}^{1}1The results of [FJVY19] are stated for games with players, but can be improved to hold for player games by using a different error correcting code in the construction. nonlocal game (which is a multiprover protocol with only one round of interaction) whose properties are as follows:

The time complexity of the verifier in is polylogarithmic in the time complexity of .

The quantum value of the protocol executed by is related to the quantum value of in the following manner:
and furthermore if then .
The utilization of the compression theorem of [FJVY19] is the reason why the main result of this paper holds for threeplayer nonlocal games, rather than two.
We call this compression theorem a ‘‘zero gap’’ compression theorem, because it does not preserve any promise gap on the value of the input verifier : if the value of is promised to be either or , then is only guaranteed to have value either or . If we iterate this compression procedure, then we get a promise gap that goes to zero. In contrast, the compression theorem used to prove is gappreserving.
The zero gap compression theorem was used to prove that in [FJVY19]. At a high level, this is shown by constructing a verifier that recursively calls the zero gap compression procedure on itself. In this paper, we follow this approach, except we also embed an protocol for inside the verifier that is recursively calling the zero gap compression procedure; this composition of protocols allows the verifier to verify languages in .
1.2 Further remarks
is equivalent to gappreserving compression.
As mentioned, the key to proving [JNV20] was establishing a gappreserving compression theorem for nonlocal games, albeit for a special case of nonlocal games satisfying a socalled ‘‘normal form’’ property. In Section 4, we present a relatively simple  but in our opinion quite interesting  observation that is in some sense, equivalent to a gappreserving compression theorem.
refutes Connes’ embedding conjecture.
One might wonder if there might be an elementary way of proving that , without relying on the statement that . For example, the results of [Slo19, FJVY19] show that and furthermore [Slo19] shows that . These previous ‘‘zerogap results’’ do not appear to have the same mathematical consequences as (e.g. yielding a negative answer to Connes’ embedding problem), which suggests the intuition that characterizing the complexity of exactly computing the quantum (or commuting operator) value of nonlocal games may be fundamentally easier than characterizing the complexity of approximating it.
This intuition is not entirely correct: the statement that is already enough to refute Connes’ embedding conjecture, because it implies that the quantum value and commuting operator value of games are not always the same. Put another way, if Connes’ embedding conjecture were true, then . However, we know that strictly contains , and thus strictly contains .
This suggests that our characterization of the class must necessarily involve a nontrivial tool such as .
1.3 Open problems
We list some open problems.

Just as the complexity statement has consequences for questions in pure mathematics (such as the Connes’ embedding problem), does the equality have any implications for operator algebras? We believe there may be a connection to modeltheoretic approaches to the Connes’ embedding problem (see, e.g., [GH13, Gol17]).

What is the complexity of ? Is it equal to ?

Can the reduction from languages to the problem of deciding whether be improved to hold for twoplayer games ?

We showed that, essentially, implies a gappreserving compression theorem. Can one show that it also implies in a blackbox fashion, a zero gap compression theorem, of the same kind as proved in [FJVY19]? This then proves that directly implies .

Does imply in a ‘‘blackbox’’ fashion?
Acknowledgments
We thank Matt Coudron and especially William Slofstra for numerous helpful discussions. HY was supported by NSERC Discovery Grant 201906636. HM was supported by the Ontario Graduate Scholarship (OGS).
2 Preliminaries
We write to denote the natural numbers . All logarithms are base . For a string let denote the length of . For a natural number let be the length of the binary encoding of .
2.1 Turing machines and the arithmetical hierarchy
A total Turing machine is one that halts on every input. Fix a string encoding of Turing machines, and for a Turing machine , let denote the length of the encoding of .
Proposition 1 (Universal Turing machine).
There exists a universal constant and a universal Turing machine that, given an input pair where is an encoding of a Turing machine, computes in time , where is the number of steps taken by on input before it halts.
Definition 2.
The th level of the arithmetical hierarchy contains classes , , and . The class is the set of languages defined as
for some total Turing machine , where is the quantifier when is even and otherwise is the quantifier. The class is the complement of , and .
In particular the first level of the arithmetical hierarchy corresponds to the classes , , and the set of decidable languages .
2.2 Interactive verifiers
In this section, we model multiprover interactive protocols, which is specified by a verifier , as a randomized algorithm. In the protocol, the verifier interacts with multiple provers, and at the end of the protocol the verifier outputs a bit indicating whether to accept or reject. A verifier can be identified with the interactive protocol it executes, and vice versa.
In more detail, define a input, prover verifier to be a randomized interactive Turing machine that has designated input tapes, communication tapes, a single workspace tape, and a single output tape. An interaction with provers is executed in the following way: the Turing machine alternates between computation and communication phases; in the computation phase, the Turing machine behaves like a normal Turing machine with tapes, and it may halt and indicate accept or reject on the output tape. It can also pause its computation and go into a communication phase, in which case the contents of each of th communication tape is read by the th prover, who then edits the th communication tape with its answer. After all the provers have finished with their responses, the next computation phase resumes. This is the standard way of modeling interactive Turing machines [BGKW88]. In this formulation, a nonlocal game is simply specified by a input, prover verifier that has only one communication phase.
Given a input, prover verifier , define its time complexity with respect to a tuple of inputs to be the maximum number of time steps taken by the verifier when it is initialized with on its input tapes, over all possible responses of the provers, before it halts. We denote this by .
We now define, in a somewhat informal level, finitedimensional prover strategies (or simply a strategy) for the interaction specified by a input, prover verifier . This is a specification of the following data:

Local dimension ,

A state , and

For every prover , for every round , for every string , a POVM acting on .
Given a verifier , a tuple , and a prover strategy for , the interaction proceeds as follows: at the beginning of the protocol, the provers share the state , and the verifier’s input tapes are initialized to . At round , the th prover performs the measurement on its local space to obtain an outcome , where is the history of all the messages seen by prover in all previous rounds (including the message from the verifier in the th round). It then writes outcome on the th communication tape of the verifier. Thus at each round the shared state between the provers depend on the outcomes of their measurements, and evolves probabilistically over time. The value of strategy in the interaction with verifier on input is defined to be the probability that the verifier halts and accepts. We denote this by . The quantum value of verifier on input is defined to be the supremum of over all finitedimensional strategies , which we denote by .
Definition 3.
Let and let . The class is defined to be the set of languages for which there exists a verifier and a polynomial with the following properties:

is a input, prover verifier that halts after communication phases.

For all , .

If , then .

If , then .
We define the class to be the union of for all and . We define the class to be the union of over all . In other words, in the YES case (i.e., ), there is a sequence of finitedimensional prover strategies that are accepted with probability approaching . In the NO case (i.e., ), there exists a positive (that generally depends on ) such that all finite dimensional strategies are rejected with probability at least .
2.3 Compression of quantum multiprover interactive protocols
In this section we formally present the two main ingredients used in our proof: the zero gap compression procedure of [FJVY19], and the reduction from the Halting problem to the problem of approximating the quantum value of a quantum multiprover interactive protocol.
First we introduce the definition of boundedness, which specifies how both the description and time complexity of a verifier is bounded by a polynomial with exponent .
Definition 4.
Let . A input prover verifier is bounded if

The description length of is at most .

For all , we have .
Theorem 5 (Zero gap compression [Fjvy19]).
Let be an integer. For every , there exists a Turing machine and an integer , with the following properties. Given as input a input prover verifier that is bounded, the Turing machine outputs a input prover verifier in time with the following properties: for all , we have


If , then

is bounded.
The zero gap compression theorem, as presented here, differs from the one presented in [FJVY19]. For example, verifiers in [FJVY19] are described using socalled ‘‘Gate Turing Machines’’ (GTMs). However, using the same oblivious Turing machine simulation techniques as discussed in the appendix of [FJVY19], from a verifier (as defined in this paper), we can obtain a GTM that specifies the same interactive protocol.
Another difference is that the compressed verifier simulates the verifier on an exponentially larger index . We do not need such a dramatic compression for our result, so we state a milder version (i.e., the ‘‘compressed’’ verifier simulates , and if the original verifier runs in time, then the compressed verifier runs in time).
Next we present the main result of [JNV20], which presents a computable reduction from the Halting problem to the problem of approximating the quantum value of a nonlocal game.
Theorem 6 ( [Jnv20]).
There exists a Turing machine and a universal constant with the following properties. Given as input a Turing machine , it runs in time and outputs a input prover verifier such that

If halts on empty tape then , and otherwise .

.
3
We start this section by showing the upper bound .
Theorem 7.
Proof.
Let . There exists a input prover verifier such that iff for all . Let be an net for the space of strategies of dimension ; in particular, for every dimension strategy there exists a strategy such that for all verifiers we have that (in other words, the winning probability of the strategies differ by at most ). Because the set of strategies over a finite dimensional Hilbert space of a fixed dimension is a compact set [GW07], we can take to be a finite set. Let , and let be an enumeration of strategies in .
Consider the following total Turing machine : On input triple where . It outputs if and only . Now it is easy to verify that
and therefore is a language.
To see this, let . Then , and for any gap (i.e. ) there exists a strategy such that . Choosing , then there must also exist a strategy such that . Therefore .
Likewise, if then there exists for which and so no strategy can win with probability greater or equal to . Therefore . ∎
Now we prove the reverse inclusion. Fix an and let be a total Turing machine such that . To prove , we construct a input prover verifier that takes as input and , and has the key property that if and only if . Therefore if and only if .
We first give the explicit description of a input prover verifier below. We then use that to construct . In the description of , we refer to the Turing machine . For every and , is the Turing machine that on the empty tape enumerates over and accepts if , otherwise it loops forever.
Now let be the input prover verifier that on the input runs . Informally, first decides by simulating the verifier in from Theorem 6. Recall that the existence of the protocol is due to and the fact that is an predicate. Now if for all , then rejects. Otherwise, runs the compression algorithm to obtain . It then executes . Informally speaking, this has the same effect as recursively executing . This is made precise in the proof of Theorem 9.
In order to apply Theorem 5 to compress in step 3, we must ensure that the verifier is bounded for some .
Claim 8.
There exists a such that is bounded.
Proof.
We bound the running time of by bounding the running time of each of the steps in its specification. The time to generate , in step 1, is for some constant . The time to generate the encoding of is . This also bounds the running time of . Therefore the time to simulate is bounded by . The time to simulate is . The time to simulate is bounded by . Therefore the running time of is bounded above by
So we just need to show that exits such that is larger than the quantity above. Since from the guarantees of the Theorem 5, , we can write
so choosing sufficiently large we can ensure
We can also choose sufficiently large so that
This completes the proof of the claim that is bounded for some . ∎
Now that we established that is bounded, we can apply Theorem 5 to get the main theorem of this paper.
Theorem 9.
if and only if
Proof.
First suppose . Then . Since the Turing machine halts for every , by Theorem 6, . Therefore by the construction (step 4). Now, from Theorem 5, we have
and by applications of the theorem, we obtain
for every . Taking the limit , we have for all . In particular .
Now suppose . Then . We prove that . Let be the smallest integer for which for every . In other words, the Turing machine does not halt. Therefore by Theorem 6 we have that .
If , we are done. Suppose . For all , the game never rejects since the Turing machine halts, by the minimality of . Therefore . So by recursivively applying Theorem 5, we have that
Since then . ∎
Corollary 10.
.
Proof.
This concludes the proof of the main result of this paper.
4 implies gappreserving compression
As mentioned in the introduction, the key to proving in [JNV20] was establishing a gappreserving compression theorem for nonlocal games. Here we observe that the reverse holds: implies a gappreserving compression theorem.
Theorem 11.
If , then there exists a Turing machine , with the following properties. Given as input a input prover verifier , outputs a input prover verifier in time polynomial in the description length of , with the following properties:

if then

if then

The runtime of the verifier is polynomial in the description length of and its input.
Proof.
is the Turing machine that, when given input a verifier , it returns the description of the verifier from Figure 3.
In the description of , we refer to the Turing machine . For every input prover verifier and , is the Turing machine that on empty tape enumerates over finitedimensional quantum strategies for and only accepts if it finds a strategy that wins the game with probability greater than . It does this via enumerating over nets (for ) for strategies of dimension for all , as with the proof of Theorem 7.
By Theorem 6, if the Turing machine halts then
otherwise . Also the runtime of is , for some polynomial .
Then if the Turing machine finds a strategy that wins with probability greater than and halts. Therefore
Otherwise, if then there is no strategy that wins the game with probability and the Turing machine never halts. Therefore
∎
Note that in this gappreserving compression theorem, the time complexity of the verifier is polynomial in the description length of and its input  rather than the time complexity of .
References

[BGKW88]
Michael BenOr, Shafi Goldwasser, Joe Kilian, and Avi Wigderson.
Multiprover interactive proofs: how to remove intractability
assumptions.
In
Proceedings of the twentieth annual ACM symposium on Theory of computing
, pages 113131, 1988.  [CS19] Matthew Coudron and William Slofstra. Complexity lower bounds for computing the approximatelycommuting operator value of nonlocal games to high precision. arXiv preprint arXiv:1905.11635, 2019.

[DLTW08]
Andrew C Doherty, YeongCherng Liang, Ben Toner, and Stephanie Wehner.
The quantum moment problem and bounds on entangled multiprover games.
In 2008 23rd Annual IEEE Conference on Computational Complexity, pages 199210. IEEE, 2008.  [FJVY19] Joseph Fitzsimons, Zhengfeng Ji, Thomas Vidick, and Henry Yuen. Quantum proof systems for iterated exponential time, and beyond. In Proceedings of the 51st Annual ACM SIGACT Symposium on Theory of Computing, STOC 2019, page 473–480, New York, NY, USA, 2019. Association for Computing Machinery.
 [GH13] Isaac Goldbring and Bradd Hart. A computabilitytheoretic reformulation of the connes embedding problem. arXiv preprint arXiv:1308.2638, 2013.
 [Gol17] Isaac Goldbring. Enforceable operator algebras. Journal of the Institute of Mathematics of Jussieu, pages 133, 2017.
 [GW07] Gus Gutoski and John Watrous. Toward a general theory of quantum games. In Proceedings of the ThirtyNinth Annual ACM Symposium on Theory of Computing, STOC ’07, page 565–574, New York, NY, USA, 2007. Association for Computing Machinery.
 [Ji17] Zhengfeng Ji. Compression of quantum multiprover interactive proofs. In Proceedings of the 49th Annual ACM SIGACT Symposium on Theory of Computing, pages 289302, 2017.
 [JNV20] Zhengfeng Ji, Anand Natarajan, Thomas Vidick, John Wright, and Henry Yuen. . arXiv preprint arXiv:2001.04383, 2020.
 [NPA08] Miguel Navascués, Stefano Pironio, and Antonio Acín. A convergent hierarchy of semidefinite programs characterizing the set of quantum correlations. New Journal of Physics, 10(7):073013, 2008.
 [NW19] Anand Natarajan and John Wright. . In IEEE 60th Annual Symposium on Foundations of Computer Science (FOCS), pages 510518, 2019.
 [Slo19] William Slofstra. The set of quantum correlations is not closed. In Forum of Mathematics, Pi, volume 7. Cambridge University Press, 2019.
Comments
There are no comments yet.