On the complexity of zero gap MIP*

02/24/2020 ∙ by Hamoon Mousavi, et al. ∙ UNIVERSITY OF TORONTO 0

The class MIP^* is the set of languages decidable by multiprover interactive proofs with quantum entangled provers. It was recently shown by Ji, Natarajan, Vidick, Wright and Yuen that MIP^* is equal to RE, the set of recursively enumerable languages. In particular this shows that the complexity of approximating the quantum value of a non-local game G is equivalent to the complexity of the Halting problem. In this paper we investigate the complexity of deciding whether the quantum value of a non-local game G is exactly 1. This problem corresponds to a complexity class that we call zero gap MIP^*, denoted by MIP^*_0, where there is no promise gap between the verifier's acceptance probabilities in the YES and NO cases. We prove that MIP^*_0 extends beyond the first level of the arithmetical hierarchy (which includes RE and its complement coRE), and in fact is equal to Π_2^0, the class of languages that can be decided by quantified formulas of the form ∀ y ∃ z R(x,y,z). Combined with the previously known result that MIP^co_0 (the commuting operator variant of MIP^*_0) is equal to coRE, our result further highlights the fascinating connection between various models of quantum multiprover interactive proofs and different classes in computability theory.

READ FULL TEXT VIEW PDF
POST COMMENT

Comments

There are no comments yet.

Authors

page 1

page 2

page 3

page 4

This week in AI

Get the week's most popular data science and artificial intelligence research sent straight to your inbox every Saturday.

1 Introduction

A two-player non-local 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 non-local 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 non-local 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 non-local 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 non-local game is or at most .

Conversely, one can reduce the problem of approximating the quantum value of non-local games to the Halting problem; there is an algorithm that for every non-local game exhaustively searches over finite-dimensional 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 complexity-theoretic 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 finite-dimensional prover strategies that cause the verifier to accept with probability approaching . In the NO case (i.e. ), all finite-dimensional 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 non-local 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 three-player non-local game has quantum value . It is likely that a similar reduction holds for two-player non-local games but we leave this for future work. We also show that the problem of deciding if a non-local 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 zero-gap 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 infinite-dimensional quantum strategies, and the measurement operators of Alice only need to commute with those of Bob (rather than be in tensor product).

            

Figure 1: The computability landscape of quantum multiprover interactive proofs. Arrows denote inclusion. The set denotes the set of all decidable languages. The set denotes the recursively enumerable languages, and denotes the set of co-recursively enumerable languages. It is known that , but unknown whether they are equal.

One of the consequences of the fact that is that . This is because , due to the fact that the commuting operator value of a non-local game can be upper-bounded 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 counter-intuitive aspects about this landscape of complexity for non-local 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) finite-dimensional strategies than can be decided with provers using infinite-dimensional 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 time-efficient verifier whose quantum value is related in some predictable way to the quantum value of . Several recent results about the complexity of non-local 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 three-player111The 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. non-local game (which is a multiprover protocol with only one round of interaction) whose properties are as follows:

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

  2. 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 three-player non-local 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 gap-preserving.

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 gap-preserving compression.

As mentioned, the key to proving  [JNV20] was establishing a gap-preserving compression theorem for non-local games, albeit for a special case of non-local games satisfying a so-called ‘‘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 gap-preserving 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 ‘‘zero-gap 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.

  1. 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 model-theoretic approaches to the Connes’ embedding problem (see, e.g., [GH13, Gol17]).

  2. What is the complexity of ? Is it equal to ?

  3. Can the reduction from languages to the problem of deciding whether be improved to hold for two-player games ?

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

  5. Does imply in a ‘‘black-box’’ fashion?

Acknowledgments

We thank Matt Coudron and especially William Slofstra for numerous helpful discussions. HY was supported by NSERC Discovery Grant 2019-06636. 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 non-local 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, finite-dimensional prover strategies (or simply a strategy) for the interaction specified by a -input, -prover verifier . This is a specification of the following data:

  1. Local dimension ,

  2. A state , and

  3. 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 finite-dimensional 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:

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

  2. For all , .

  3. If , then .

  4. 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 finite-dimensional 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

  1. The description length of is at most .

  2. 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

  1. If , then

  2. 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 so-called ‘‘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 non-local 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

  1. If halts on empty tape then , and otherwise .

  2. .

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.

[style=figstyle] Input: where , , is a verifier.
Perform the following steps:

  1. Compute (where is from Theorem 6).

  2. Execute the interactive protocol specified by the verifier . If the verifier rejects then reject, otherwise continue.

  3. Compute (where is from Theorem 5).

  4. Execute the interactive protocol specified by the verifier and accept if and only if the verifier accepts.

Figure 2: Specification of the -input -prover verifier

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.

Let then . Let be the -input -prover verifier, that on input executes the verifier where . By Claim 8, and by Theorem 9, iff . Thus is an protocol for the language , and . ∎

This concludes the proof of the main result of this paper.

4 implies gap-preserving compression

As mentioned in the introduction, the key to proving in [JNV20] was establishing a gap-preserving compression theorem for non-local games. Here we observe that the reverse holds: implies a gap-preserving 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:

  1. if then

  2. if then

  3. 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 finite-dimensional 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.

[style=figstyle] Input: , where
Perform the following steps:

  1. Compute (where is from Theorem 6).

  2. Execute the interactive protocol specified by the verifier and accept if and only if the verifier accepts.

Figure 3: Specification of the compressed verifier

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 gap-preserving 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