Abstract 1 Introduction 2 Preliminaries 3 𝖰𝖬𝖠 and Non-collapsing Measurements 4 QMA and Hidden Variables 5 Open Problems References

PDQMA = DQMA = NEXP: QMA with Hidden Variables and Non-Collapsing Measurements

Scott Aaronson University of Texas at Austin, TX, USA Sabee Grewal ORCID University of Texas at Austin, TX, USA Vishnu Iyer ORCID University of Texas at Austin, TX, USA Simon C. Marshall Leiden University, The Netherlands Ronak Ramachandran ORCID University of Texas at Austin, TX, USA
Abstract

We define and study a variant of 𝖰𝖬𝖠 (Quantum Merlin Arthur) in which Arthur can make multiple non-collapsing measurements to Merlin’s witness state, in addition to ordinary collapsing measurements. By analogy to the class 𝖯𝖣𝖰𝖯 defined by Aaronson, Bouland, Fitzsimons, and Lee (2014), we call this class 𝖯𝖣𝖰𝖬𝖠. Our main result is that 𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯; this result builds on the 𝖯𝖢𝖯 theorem and complements the result of Aaronson (2018) that 𝖯𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫. While the result has little to do with quantum mechanics, we also show a more “quantum” result: namely, that 𝖰𝖬𝖠 with the ability to inspect the entire history of a hidden variable is equal to 𝖭𝖤𝖷𝖯, under mild assumptions on the hidden-variable theory. We also observe that a quantum computer, augmented with quantum advice and the ability to inspect the history of a hidden variable, can solve any decision problem in polynomial time.

Keywords and phrases:
quantum Merlin-Arthur, non-collapsing measurements, hidden-variable theories
Funding:
Scott Aaronson: SA is supported by a Vannevar Bush Fellowship by the US Department of Defense, the Berkeley NSF-QLCI CIQC Center, a Simons Investigator Award, and the Simons “It from Qubit” collaboration.
Vishnu Iyer: VI is supported by an NSF Graduate Research Fellowship.
Simon C. Marshall: SCM is supported by the European Union’s Horizon 2020 program (NEQASQC) and a gift from Google Quantum AI.
Copyright and License:
[Uncaptioned image] © Scott Aaronson, Sabee Grewal, Vishnu Iyer, Simon C. Marshall, and Ronak Ramachandran; licensed under Creative Commons License CC-BY 4.0
2012 ACM Subject Classification:
Theory of computation Complexity classes
; Theory of computation Quantum computation theory ; Theory of computation Quantum complexity theory ; Theory of computation Quantum complexity theory
Related Version:
Full Version: https://arxiv.org/abs/2403.02543
Acknowledgements:
SCM thanks David Dechant for useful discussions. SG, VI, and RR thank Joshua Cook, Siddhartha Jain, and Kunal Marwaha for helpful conversations.
Funding:
SG and RR are supported via SA from the same funding sources.
Editors:
C. Aiswarya, Ruta Mehta, and Subhajit Roy

1 Introduction

To understand the power of quantum computation is, in large part, to understand how that power depends on the central features of quantum mechanics itself, such as linearity, unitarity, tensor products, complex numbers, the Born Rule, or the destructive nature of measurement. But since quantum mechanics is usually presented as a “package deal,” how can we pick apart these dependencies? One natural approach has been to define complexity classes based on “fantasy” versions of quantum mechanics, which change one or more of its features, and see how they relate to the standard 𝖡𝖰𝖯 (Bounded-Error Quantum Polynomial-Time). Some representative findings of that research program over the past few decades include:

  1. (1)

    Quantum mechanics over the reals or quaternions leads to the same computational power as quantum mechanics over the complex numbers, despite the theories differing in other respects [25].

  2. (2)

    Quantum mechanics with a nonlinear Schrödinger equation would generically allow 𝖭𝖯- and even #𝖯-complete problems to be solved in polynomial time, in contrast to what is conjectured for standard (linear) quantum mechanics [11].

  3. (3)

    A quantum computer with closed timelike curves could solve exactly the problems in 𝖯𝖲𝖯𝖠𝖢𝖤, same as a classical computer with closed timelike curves [10].

  4. (4)

    Quantum computers with nonunitary linear evolution, or modifications of the Born rule (say, |ψ|3), with normalization of probabilities imposed, yield at least the power of quantum computers with postselected measurement outcomes – a model that Aaronson called 𝖯𝗈𝗌𝗍𝖡𝖰𝖯 and proved to coincide with the classical complexity class 𝖯𝖯 [2, 5].

  5. (5)

    Generalized probabilistic theories (GPTs), a class of theories that includes quantum mechanics and classical probability theory as special cases, are as a whole characterized by the complexity class 𝖠𝖶𝖯𝖯 [23, 15].

  6. (6)

    If we allow multiple, non-collapsing measurements of the same state – or, closely related, to see the entire history of a hidden variable as in Bohmian mechanics – we get a model of computation that seems more powerful than standard quantum computation, but only “slightly” so [4]. As examples, we can quickly find collisions in many-to-one functions (and thus, for example, solve Graph Isomorphism), and we can solve the Grover search problem in N1/3 steps rather than N. But we still seem unable to solve 𝖭𝖯-complete problems in polynomial time.

Example (6) is the one of most interest to us here. To our knowledge, it is the only natural example known where changing the rules of quantum mechanics leads to complexity classes that appear only modestly larger than 𝖡𝖰𝖯. Much of the power comes from the combination of non-collapsing measurements with ordinary collapsing ones. As an example, given a two-to-one function f:[N][M], the way to find collisions is simply to prepare

1Nx[N]|x|f(x),

then measure the |f(x) register in the ordinary way to get

|x+|y2

where f(x)=f(y) in the first register, and finally perform multiple non-collapsing measurements on the first register in the standard basis, until both x and y are observed with high probability.111The reason why non-collapsing measurement allows Grover search in N1/3 steps is simpler and does not require us to combine collapsing with non-collapsing measurements. Instead, given a unique marked item out of N, one simply runs Grover’s algorithm for T=N1/3 iterations, thereby boosting the probability of the marked item to T2N=N1/3, and then performs N1/3 non-collapsing measurements so that the marked item is found with constant probability.

In a hidden-variable theory, where the hidden variable is either at |x or |y with equal probabilities, the solution at this point is to “juggle” – for example, by repeatedly applying Fourier transforms followed by their inverses. The goal here is to cause the hidden variable to “forget” whether it was at |x or |y, so that it must eventually visit both of them with high probability. In such a case, if (as we’re imagining) we could see the whole history of the hidden variable at once, from some godlike vantage point, we would learn both |x and |y and thereby solve our computational problem.

The history of these ideas is a bit tangled. In 2005, Aaronson defined the class 𝖣𝖰𝖯 (Dynamical Quantum Polynomial-Time), to capture the problems that quantum computers could efficiently solve, if only one could examine the entire history of a hidden variable (in any hidden-variable theory that satisfies reasonable axioms, called robustness and indifference). He showed that 𝖲𝖹𝖪𝖣𝖰𝖯, where 𝖲𝖹𝖪 is Statistical Zero Knowledge, basically because 𝖣𝖰𝖯 could simulate non-collapsing measurements (although he didn’t formalize this). Combined with Aaronson’s quantum lower bound for finding collisions [1], which implies the existence of an oracle relative to which 𝖲𝖹𝖪𝖡𝖰𝖯, this gives us an oracle separation between 𝖡𝖰𝖯 and 𝖣𝖰𝖯. Aaronson also showed that 𝖣𝖰𝖯𝖤𝖷𝖯, which has not been improved since then. He claimed to give an oracle relative to which 𝖭𝖯𝖣𝖰𝖯, although his proof had a bug [8] and the existence of such an oracle remains open. Then, in 2014, Aaronson, Bouland, Fitzsimons, and Lee [8] defined the class 𝖯𝖣𝖰𝖯 (Product Dynamical Quantum Polynomial-Time), to capture non-collapsing measurements specifically. They showed that 𝖯𝖣𝖰𝖯 also contains 𝖲𝖹𝖪, showed the upper bound 𝖯𝖣𝖰𝖯𝖡𝖯𝖯𝖯𝖯, and gave a correct proof that there exists an oracle relative to which 𝖭𝖯𝖯𝖣𝖰𝖯.

Overall, as we said, these results painted a picture of 𝖣𝖰𝖯 and 𝖯𝖣𝖰𝖯 as only modestly more powerful than 𝖡𝖰𝖯. However, a surprising new wrinkle came in 2018, when Aaronson [6] observed that 𝖯𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫, where /𝗊𝗉𝗈𝗅𝗒 means “with polynomial-sized quantum advice,” and 𝖠𝖫𝖫 is the class of all languages. This stands in contrast to 2004 results of Aaronson [3] that limit the power of 𝖡𝖰𝖯/𝗊𝗉𝗈𝗅𝗒: namely, that 𝖡𝖰𝖯/𝗊𝗉𝗈𝗅𝗒𝖯𝖯/𝗉𝗈𝗅𝗒 (later improved by Aaronson and Drucker [9] to 𝖡𝖰𝖯/𝗊𝗉𝗈𝗅𝗒𝖰𝖬𝖠/𝗉𝗈𝗅𝗒), and that there exists an oracle relative to which 𝖭𝖯𝖡𝖰𝖯/𝗊𝗉𝗈𝗅𝗒. In other words, quantum advice and non-collapsing measurements have a “Mentos and Coke” character, where each one is only modestly powerful in isolation, but together they trigger a complexity-theoretic explosion.

To prove the 𝖯𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫 result, Aaronson adapted a 2005 theorem of Raz [24] that 𝖰𝖨𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫, where 𝖰𝖨𝖯 is the class of languages that admit quantum interactive proofs. In both Raz’s protocol and Aaronson’s, given an arbitrary Boolean function f:{0,1}n{0,1} that one wants to compute, one first chooses a prime qn. The whole truth table of f is then encoded by the quantum advice state

|ψ=1qnz𝔽qn|z|p(z),

where p:𝔽qn𝔽q is the unique multilinear polynomial over 𝔽q such that p(x)=f(x) for all x{0,1}n. Next, given a point of interest x{0,1}n, on which one wants to evaluate f(x), one measures |ψ so as to collapse it to an equal superposition

|ψ=1q1z{x}|z|p(z)

over a random line 𝔽qn that passes through x, minus the point x itself. Finally, one uses polynomial interpolation on this line to recover p(x)=f(x). In the non-collapsing measurements model, this is done by simply measuring the state |ψ over and over in the standard basis, until enough (z,p(z)) pairs have been observed for the interpolation to work.222Since p is a multilinear extension of a Boolean function on n variables, its degree is at most n. Hence, n+1 pairs are needed to do polynomial interpolation, so q must be chosen to be at least n+2.

1.1 This Paper

Here we show a new example where non-collapsing measurements combined with one other resource yield extraordinary computational power – vastly more power than either resource in isolation.

The class 𝖰𝖬𝖠 (Quantum Merlin Arthur) is a well-known quantum generalization of 𝖭𝖯; it consists of all languages for which a “yes” answer can be verified in quantum polynomial time with the help of a polynomial-size quantum witness state. We define and study 𝖯𝖣𝖰𝖬𝖠 (Product Dynamical 𝖰𝖬𝖠), or 𝖰𝖬𝖠 augmented with non-collapsing measurements. Our main result is that 𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯, even if 𝖯𝖣𝖰𝖬𝖠 is defined with a completeness/soundness gap of (say) 12n vs. 2n (Theorem 5).

Since the inclusion 𝖯𝖣𝖰𝖬𝖠𝖭𝖤𝖷𝖯 is straightforward, the interesting part is 𝖭𝖤𝖷𝖯𝖯𝖣𝖰𝖬𝖠. By the celebrated PCP theorem [14, 13], it suffices to show that a two-query PCP system (Definition 3) can be simulated by 𝖯𝖣𝖰𝖬𝖠. Our proof builds on Aaronson’s proof [6] that 𝖯𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫, but with two key differences. First, to simulate a two-query PCP system, we need a witness state that can support at least two queries to an exponentially long truth table, rather than just one query. Second, we now need an analysis of soundness: why, for example, can the prover not cheat by sending a witness that causes the response to each query to depend on the other query? This problem seems particularly acute once we realize that we can no longer rely on the no-signaling principle of quantum mechanics when non-collapsing measurements are allowed. To address the first challenge, we extend Aaronson’s algorithm to support multiple queries to an exponentially long truth table. To address the second challenge, we show that one can use non-collapsing measurements to perform a low-degree test, ensuring that Merlin’s witness has the “error-correcting code” structure of an honest witness state.

Let us highlight our simulation of a classical PCP as additional motivation for our work. Specifically, simulating PCP systems is one of the few approaches to show that quantum Merlin-Arthur systems can solve 𝖭𝖤𝖷𝖯 (see e.g. [7, 22]). An important direction for future work is to adapt our simulation to quantum Merlin-Arthur systems that adhere to the laws of quantum mechanics (even if the verifier is allowed exponential time or to interact with the prover). We view any progress of this form as progress toward understanding more “reasonable” quantum Merlin-Arthur systems, such as 𝖰𝖬𝖠(2).

We point out some implications of our result. First, combining with the Nondeterministic Time Hierarchy Theorem (𝖭𝖯𝖭𝖤𝖷𝖯), we find that 𝖯𝖣𝖰𝖬𝖠 is unconditionally more powerful than 𝖭𝖯. Second, “scaling down by an exponential,” we find that when non-collapsing measurements are allowed, the problem of optimizing an acceptance probability over all N-dimensional quantum states jumps from easy (a principal eigenvector problem) to 𝖭𝖯-hard even to approximate.

Let us place our result in the context of previous work on generalizations of 𝖰𝖬𝖠. Aharonov and Regev [12] defined 𝖰𝖬𝖠+, a variant of 𝖰𝖬𝖠 where the verifier can directly obtain the probability a given two-outcome measurement will accept, and showed 𝖰𝖬𝖠+=𝖰𝖬𝖠. More recently, Jeronimo and Wu [22] showed that 𝖰𝖬𝖠+(𝟤)=𝖭𝖤𝖷𝖯, where 𝖰𝖬𝖠+(𝟤) is 𝖰𝖬𝖠 with two unentangled proofs that have nonnegative real amplitudes. Bassirian, Fefferman, and Marwaha [16] improved this to show that 𝖰𝖬𝖠+=𝖭𝖤𝖷𝖯 – i.e., nonnegative amplitudes alone suffice for the jump to 𝖭𝖤𝖷𝖯. As of this writing, it remains a matter of avid speculation whether unentangled witnesses also suffice for the jump to 𝖭𝖤𝖷𝖯: that is, whether 𝖰𝖬𝖠(𝟤)=𝖭𝖤𝖷𝖯. Of course, our result implies that it would suffice to simulate non-collapsing measurements using unentangled proofs – i.e., to show 𝖯𝖣𝖰𝖬𝖠𝖰𝖬𝖠(𝟤).

One important observation about our 𝖯𝖣𝖰𝖬𝖠 protocol is that it only ever measures the witness state in the computational basis – and hence, one could say, never exploits quantum interference. So in particular, if we defined a complexity class 𝖯𝖣𝖬𝖠 (Product Dynamical Merlin-Arthur) in mathematical parallel to 𝖯𝖣𝖰𝖬𝖠, where the witness was a classical probability distribution 𝒟, and one was allowed to sample from 𝒟 with or without doing Bayesian updating to it, we would equally have 𝖯𝖣𝖬𝖠=𝖭𝖤𝖷𝖯. The main difference here is simply that it seems hard to invent a story that motivates 𝖯𝖣𝖬𝖠.

In Section 4, we sharpen this point by defining and studying a class that we call 𝖣𝖰𝖬𝖠 (Dynamical 𝖰𝖬𝖠), or 𝖰𝖬𝖠 augmented by the ability to see the entire history of a hidden variable. In particular, the verifier can perform a 𝖣𝖰𝖯 (Dynamical Quantum Polynomial-Time) computation, a complexity class introduced by Aaronson to study hidden variable theories from a quantum computing perspective [4]. In short, 𝖣𝖰𝖯 captures computations where one evolves a state vector unitarily, but there is a deeper “hidden variable” in a definite state that evolves stochastically. At the end of the computation, the history of the hidden variable (i.e., the sequence of definite states it occupied at each step) can be viewed when making the final accept/reject decision. 𝖣𝖰𝖯 captures any hidden variable theory that satisfies a set of axioms (given in Section 4), including theories due to Dieks [19] and Schrödinger [26].

We show that 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 (Theorem 16). Here the reasons really do depend on quantum mechanics. Specifically, they depend on the ability to “hide” crucial information in the phases of amplitudes, to prevent a hidden variable trajectory from remembering that information. If we tried to define the analogous class 𝖣𝖬𝖠 (Dynamical 𝖬𝖠), it would trivially coincide with 𝖬𝖠. Assuming 𝖬𝖠=𝖭𝖯, as follows from a standard derandomization assumption, this has the amusing consequence that 𝖣𝖬𝖠𝖣𝖰𝖬𝖠 – that is, in the presence of both witness states and trajectory sampling, quantum can already be known to be stronger than classical. In the same section, we also observe that our techniques imply 𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫 (Theorem 17), complementing Aaronson’s result that 𝖯𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫 [6]. This result relies on quantum mechanics in the same way that our 𝖣𝖰𝖬𝖠 result does.

One might also wonder about other “fantasy” variants of 𝖰𝖬𝖠. In principle, any variant of 𝖡𝖰𝖯 can be combined with 𝖰𝖬𝖠 to yield a new complexity class. For example, consider a variant of 𝖡𝖰𝖯 that can clone states (i.e., perform the transformation |ψ|0n|ψ2). It is easy to see that one can simulate k non-collapsing measurements of a state by cloning the state k times and then measuring each copy in the usual collapsing way. Hence, combining this 𝖡𝖰𝖯 variant with 𝖰𝖬𝖠 yields a complexity class equal to 𝖭𝖤𝖷𝖯 by our Theorem 5. Indeed, if one wants to alter Arthur’s powers without triggering a “Mentos and Coke” effect, they would need to find a 𝖡𝖰𝖯 variant that is only modestly more powerful, the way 𝖯𝖣𝖰𝖯 is.

1.2 Main Ideas

We give a high-level overview of our proof that 𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 (Theorem 5). Informally, 𝖯𝖣𝖰𝖬𝖠 is like 𝖰𝖬𝖠 except the verifier can perform non-collapsing measurements in addition to the normal collapsing ones (see Definition 2 for a formal definition). The containment 𝖯𝖣𝖰𝖬𝖠𝖭𝖤𝖷𝖯 is straightforward because 𝖭𝖤𝖷𝖯 can guess the exponentially-long classical description of the 𝖯𝖣𝖰𝖬𝖠 witness and verify it in exponential time.

Thus, the challenge is proving 𝖭𝖤𝖷𝖯𝖯𝖣𝖰𝖬𝖠. We show this by simulating a two-query probabilistically checkable proof (PCP) system for 𝖭𝖤𝖷𝖯 (see Definition 3 and Theorem 4). In short, the celebrated PCP theorem [14, 13] tells us that languages in 𝖭𝖤𝖷𝖯 can be decided by a verifier that queries a PCP π:{0,1}nΣ at two points of the verifier’s choosing, where Σ is a constant-sized alphabet. Hence, our result follows from simulating two queries to a π.

The honest witness is the same as in [6]:

|ψ=1qnz𝔽qn|z|p(z),

where p:𝔽qn𝔽q is the unique degree-n multilinear extension of the PCP π:{0,1}nΣ and q=O(n) is chosen to be sufficiently large. However, our setting differs from [6] in two key ways: (i) we must retrieve two values π(w) and π(w) for our choice of w, w, rather than one, and (ii) the quantum witness can no longer be trusted (as it can be in the advice setting).

To explain how to handle the first difference, let us briefly recall how to simulate a single query. As discussed, given a point of interest w{0,1}n, on which one wants to evaluate π(w), Aaronson [6] measures |ψ so as to collapse it to an equal superposition

|ψ=1q1z{w}|z|p(z)

over a random line 𝔽qn that passes through w, minus the point w itself. To recover two values w,w{0,1}n, one can generalize Aaronson’s procedure so that the measurement on |ψ collapses it to an equal superposition over an affine plane that contains the points w and w, minus the unique affine line containing w and w. (Indeed, this can be generalized to any k-dimensional affine subspace, where the measurement collapses |ψ to a superposition over a random k-dimensional affine subspace containing points w1,,wk minus the unique (k1)-dimensional affine subspace containing w1,,wk.) Then, just as in [6], one performs enough non-collapsing measurements to recover π(w) and π(w) via polynomial interpolation.

The only remaining issue is that Merlin can potentially cheat and send a quantum state that is far from the honest witness. To address this, we use the lines-point low-degree test (Lemma 1) given by Friedl and Sudan [20]. Recall that an affine line 𝔽qn passing through points x,y𝔽qn is the set {x+(yx)t}t𝔽qn, so a function g:𝔽q can be viewed as a univariate polynomial in t. The lines-point low-degree test says that if a function f:𝔽qn𝔽q restricted to a randomly chosen line agrees with a degree-n univariate polynomial, then f agrees with some degree-n polynomial h:𝔽qn𝔽q on all of 𝔽qn.

Observe that to perform this low-degree test, we need to make sure the function that Merlin encodes into his witness agrees with a low-degree polynomial on a randomly chosen affine line. Therefore, rather than interpolating a polynomial on a random affine plane containing the points w and w of interest, our verification procedure interpolates a polynomial on an affine cube. This affine cube contains the points w,w{0,1}n but we also ensure that it contains a point w′′𝔽qn that the verifier chooses uniformly at random. This ensures that the affine cube contains a uniformly random line independent of the points w and w. Then, if the polynomial interpolation succeeds, we can (i) recover π(w) and π(w) as desired and (ii) conclude that Merlin’s witness encoded a low-degree polynomial because it passed the lines-point low degree test (i.e., it agreed with a low-degree polynomial on a randomly chosen line).

To summarize, the procedure works as follows. First, Merlin commits to some witness state |ψ. Then the 𝖯𝖣𝖰𝖬𝖠 verifier simulates the 𝖯𝖢𝖯 verifier to obtain queries w,w{0,1}n and picks a uniformly random w′′𝔽qn. The verifier measures Merlin’s witness state |ψ to collapse it to a superposition over points in a random affine cube containing w,w, and w′′ minus the affine plane containing w, w, and w′′. Then the verifier uses non-collapsing measurements to collect all (z,p(z)) pairs in the affine cube (minus the affine plane) and interpolates a polynomial u:𝔽q3𝔽q that fits these pairs. If the polynomial interpolation succeeds, Merlin passes the lines-point low-degree test and the verifier can learn π(w) and π(w) by evaluating the polynomial u.

1.3 Concurrent Work

In concurrent and independent work, Bassirian and Marwaha [17] show that 𝖰𝖬𝖠 with non-collapsing measurements equals 𝖭𝖤𝖷𝖯. They observe that the proof of 𝖰𝖬𝖠+=𝖭𝖤𝖷𝖯 [16] goes through even if one replaces the promise of a non-negative witness state with the ability for the verifier to perform non-collapsing measurements. [16] can prove a containment (for a constant completeness/soundness gap) using a constant number of non-collapsing measurements, whereas our verification procedure always uses O(nlogn) non-collapsing measurements. Our approach readily extends to prove 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 and 𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫.

2 Preliminaries

Throughout this work, we use the following notation. {1,2,3,} denotes the natural numbers. For a finite field 𝔽q, 𝔽q𝔽q{0}.

Let denote the set of all affine lines (i.e., 1-dimensional affine subspaces) of 𝔽qn. Recall that the line passing through points a,b𝔽qn is the set {a+(ba)t}t𝔽q. Therefore, a polynomial g that maps a line to 𝔽q can be thought of as a univariate polynomial. We will use the following lines-point low-degree test of Friedl and Sudan [20] (see also the restatement in [21, Theorem 1.2]).

Lemma 1 (Multivariate low-degree test [20]).

Let f:𝔽qn𝔽q be any n-variate function, and let G={g} be a collection of degree-d polynomials g:𝔽q. There is a constant C large enough such that for any d satisfying q>Cd, if

Prz[f(z)g(z)]δ,

for some 0<δ<0.01, then there exists an n-variate degree-d polynomial h such that

Prz𝔽qn[f(z)h(z)]4δ.

In words, Lemma 1 is saying that, if a function f restricted to a randomly chosen line disagrees with a low-degree polynomial on at most a δ fraction of points, then there must exist a globally low-degree polynomial that f disagrees with on at most a 4δ fraction of points. In short, Lemma 1 gives a local way to test that the entire function is low degree.

This work also involves affine planes and cubes (i.e., 2- and 3-dimensional affine subspaces). Recall that an affine plane is uniquely defined by three independent points a,b,c𝔽qn. The plane containing these points is the set

{a+(ba)t1+(ca)t2}t1,t2𝔽q.

Similarly, the unique affine cube containing the independent points a,b,c,d𝔽qn is the set

{a+(ba)t1+(ca)t2+(da)t3}t1,t2,t3𝔽q.

We now give a formal definition of 𝖯𝖣𝖰𝖬𝖠.

Definition 2.

𝖯𝖣𝖰𝖬𝖠c,s is the class of languages L{0,1} for which there exists a 𝖯𝖣𝖰𝖯 verifier V (to be defined shortly) such that, for all x{0,1}:

  • Completeness: If xL then there exists a witness state |ϕ, on poly(n) qubits, such that V(x,|ϕ) accepts with probability at least c.

  • Soundness: If xL then V(x,|ϕ) accepts with probability at most s for all witness states |ϕ.

A 𝖯𝖣𝖰𝖯 verifier consists of two phases. In the first phase, a 𝖯-uniform quantum circuit Cx, depending on the input x, is applied to the initial state |ϕ|0p(n), where |ϕ is the witness and p is a polynomial. This Cx can consist of three types of gates: CNOT gates, 1-qubit π/8 rotations, and measurements in the {|0,|1} basis. The CNOT and π/8 gates provide universality for 𝖡𝖰𝖯, while the measurement gates introduce a probabilistic component. In the second phase, we consider the final state |ψ of Cx, which depends in part on the probabilistic results of the measurement gates. Let 𝒟 be the probability distribution induced by measuring all qubits of |ψ in the computational basis and let q be a polynomial. Then a classical polynomial-time algorithm, A, receives as input x as well as q(n) independent samples from 𝒟, and then either accepts or rejects.

Our proof that 𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 will rely on the characterization 𝖭𝖤𝖷𝖯 by probabilistically checkable proof (PCP) systems where the verifier only makes 2 queries to the PCP. Although this is well-known to classical complexity theorists, we explain this formally below for completeness. We begin by defining the complexity classes 𝖯𝖢𝖯.

Definition 3.

𝖯𝖢𝖯c,s[r,q]Σ is the class of languages L{0,1} for which there exists a probabilistic polynomial-time verifier V𝖯𝖢𝖯 which uses r random bits and makes q queries to an oracle π, each time receiving a response in some alphabet Σ such that

  1. 1.

    Completeness: If xL, then π such that Pr[V𝖯𝖢𝖯π(x)=1]c.

  2. 2.

    Soundness: If xL, then π, Pr[V𝖯𝖢𝖯π(x)=1]s.

The celebrated 𝖯𝖢𝖯 theorem [14, 13] tells us that 𝖭𝖯=𝖯𝖢𝖯1,s[O(log(n)),3]{0,1} for any constant s. A simple consequence is that 𝖭𝖤𝖷𝖯=𝖯𝖢𝖯1,s[poly(n),3]{0,1}. It is folklore that 𝖯𝖢𝖯c,s[r,q]Σ𝖯𝖢𝖯c,s/q[r+log(q),2]Σq, i.e., that the number of queries can be reduced to two at the cost of a larger alphabet and worse soundness error.

Theorem 4.

For a size-8 alphabet Σ and any constant s(0,1), 𝖯𝖢𝖯1,s[poly(n),2]Σ=𝖭𝖤𝖷𝖯.

One can improve the soundness error to sub-constant by further increasing the alphabet size and our proofs that 𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 (Theorem 5) and 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 (Theorem 16) still go through with only slight (if any) modification.

3 𝖰𝖬𝖠 and Non-collapsing Measurements

We prove our main result: if 𝖰𝖬𝖠 is modified so that Arthur can perform non-collapsing measurements in addition to standard quantum computation, then the resulting class equals 𝖭𝖤𝖷𝖯.

The hard part is to show that 𝖭𝖤𝖷𝖯𝖯𝖣𝖰𝖬𝖠, which we prove by simulating a two-query PCP system for 𝖭𝖤𝖷𝖯. At a high level, the 𝖯𝖣𝖰𝖬𝖠 verifier is given a PCP π:{0,1}nΣ encoded in a quantum proof, and it suffices to learn π at two points of the verifier’s choosing.

Our starting point is Aaronson’s result that 𝖯𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫 [6] where he showed how to evaluate π at one point but this assumed that the verifier is provided with a trusted quantum advice state. Hence, our contribution is to show that one can retrieve two points of choice even if the quantum proof is from an untrusted prover.

Theorem 5.

𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯.

Proof.

𝖯𝖣𝖰𝖬𝖠𝖭𝖤𝖷𝖯 is clear, since in 𝖭𝖤𝖷𝖯 we can guess an exponentially-long classical description of the 𝖯𝖣𝖰𝖬𝖠 witness and then verify it.

Thus, we show 𝖭𝖤𝖷𝖯𝖯𝖣𝖰𝖬𝖠. By Theorem 4, it suffices to show 𝖯𝖢𝖯c,s[poly(n),2]Σ𝖯𝖣𝖰𝖬𝖠 for some constant-size alphabet Σ. In particular, we can assume the 𝖯𝖢𝖯 verifier makes two queries to a PCP and receives responses in a constant-size alphabet. Let π:{0,1}nΣ be the Boolean function that encodes the PCP for all possible queries x{0,1}n. Let p:𝔽qn𝔽q be the unique degree-n multilinear extension of π, where q is chosen so that the conditions of Lemma 1 are satisfied and qn+2. Note that q=O(n) by Bertrand’s postulate. To simulate the PCP system, it suffices for the verifier to learn π(w)=p(w) and π(w)=p(w) at two points w and w of the verifier’s choosing, given a witness state |ψ sent by Merlin.

We explain the verification procedure as we analyze the honest case (i.e., the case when there exists a π such that the 𝖯𝖢𝖯 verifier accepts with probability at least c). Let a,b{0,1}n be distinct points and let c𝔽qn be independent of a and b. Let A be the unique affine plane that contains a,b, and c. Let Ca,b,c be the following function. For a vector y𝔽qn, if yA, then Ca,b,c(y)=0n. Otherwise, a,b,c, and y define a unique affine cube, which we denote by B. In this case, Ca,b,c(y)=y𝔽qn is a canonical representation of the point y, so that (a,b,c,y) and (a,b,c,y) define the same affine cube.

We describe the canonical representation in more detail. First, note that y must be one of the q3q2 points in the cube B that are not in the plane A (otherwise Ca,b,c(y)=0n). There are many ways to pick a canonical representative y. For example, of the q3q2 many points, one can have Ca,b,c(y) output the point y with the fewest nonzero entries (and if there are ties, pick the one that comes first in lexicographic order). This ensures that all of the q3q2 points get mapped to the same canonical representative y, which is crucial for our verification procedure. Recall that q=O(n), so Ca,b,c can be computed efficiently.

The honest 𝖯𝖣𝖰𝖬𝖠 witness is

1qnz𝔽qn|z|p(z).

Given this witness, the 𝖯𝖣𝖰𝖯 verification procedure is as follows:

  1. (1)

    Simulating the 𝖯𝖢𝖯 verifier, choose two queries w,w{0,1}n. Pick a point w′′𝔽qn uniformly at random.

  2. (2)

    Map the witness to

    1qnz𝔽qn|z|p(z)|Cw,w,w′′(z).
  3. (3)

    Measure the |Cw,w,w′′(z) register in the usual collapsing way to obtain the outcome y𝔽qn. If the measurement outcome is 0n, reject. Let B denote the affine cube containing w,w, w′′, and y, and let A denote the affine plane containing w, w, and w′′.

  4. (4)

    Make O(n4) non-collapsing measurements of the |z and |p(z) registers.

  5. (5)

    If exactly the q3q2 points in BA are obtained and the empirical distribution over these points is O(1/n)-close in total variation distance to the uniform distribution, continue. Otherwise, reject.

  6. (6)

    If more than one p(z) value was obtained for the same z, reject.

  7. (7)

    Perform polynomial interpolation to obtain trivariate polynomial uB:𝔽q3𝔽q of degree at most n that is consistent with p on the measured points. If this interpolation fails, then reject.

  8. (8)

    Calculate π(w)=p(w)=u(0,0,0) and π(w)=p(w)=u(0,1,0). Plug these responses into the 𝖯𝖢𝖯 verifier, and accept if and only if it does.

Let us analyze the verification procedure in more detail. Suppose, upon measuring the register |Cw,w,w′′(z) in Step 3, the verifier sees y𝔽qn. With probability q2n, we observe y=0n, because there are q2 points on the affine plane {w+(ww)t1+(w′′w)t2}t1,t2𝔽q. In this case, the verifier will reject (which is incorrect). Otherwise, with probability 1q2n=1exp(Ω(n)), the verifier will see some canonical point y𝔽qn so that the points (w,w,w′′,y) defines an affine cube B.

The post-measurement state of the remaining two registers will then be in superposition over all points z𝔽qn such that z,w, w, and w′′ define the same affine cube as y, w, w, and w′′. Recall that the affine cube B is the set

B={w+(yw)t1+(ww)t2+(w′′w)t3}t1,t2,t3𝔽q,

and the affine plane AB containing w,w, and w′′ is the set

A={w+(ww)t1+(w′′w)t2}t1,t2𝔽q.

Observe that z can be any of the q3q2 points in BA. In particular,

z=w+(yw)t1+(ww)t2+(w′′w)t3

for any t1𝔽q and t2,t3𝔽q. Therefore, our post-measurement state |ϕ can be expressed as

1qq1t1𝔽qt2𝔽qt3𝔽q|w+(yw)t1+(ww)t2+(w′′w)t3|p(w+(yw)t1+(ww)t2+(w′′w)t3).

Define uB:𝔽q3𝔽 by u(t1,t2,t3)p(w+(yw)t1+(ww)t2+(w′′w)t3), and notice that uB(0,0,0)=p(w) and uB(0,1,0)=p(w). Because p is the multilinear extension of π, we also have that p(w)=π(w) and p(w)=π(w).

After Step 6, the verifier has collected q3q2 pairs (z,p(z))zBA. Collecting these pairs is an instance of the coupon collector’s problem, so O(q3logq)=O(n3logn) many samples suffice to succeed with high probability. We take more samples, which will be relevant to the soundness of our protocol. With the (z,p(z)) pairs, the verifier runs polynomial interpolation to learn the polynomial uB. We note that q is chosen to be n+2 to ensure that q3q2 pairs suffice for polynomial interpolation. After learning uB, the verifier has learned π(w) and π(w) as desired and will accept with the same probability as the 𝖯𝖢𝖯 verifier.

A crucial part of our verification procedure is that the verifier tests that p is a low-degree polynomial. Because we picked a point w′′𝔽qn uniformly at random, we ensure that the affine cube B contains a random affine line, independent of the points w and w. Therefore, the polynomial interpolation succeeds if and only if the truth table of p matches a low-degree polynomial on a randomly chosen line . Hence, by Lemma 1, p must also be globally low degree. After taking into account the failures that can occur during the verification procedure, we conclude that the verifier accepts with probability at least cexp(Ω(n)).

We now analyze the soundness of our verification procedure. That is, suppose the 𝖯𝖢𝖯 verifier will accept with probability at most s for all possible proofs π. We will show that the 𝖯𝖣𝖰𝖬𝖠 verifier accepts with probability at most s+exp(Ω(n)). The key insight for the soundness case is that, by deviating from the honest witness state above, Merlin only increases the probability that the polynomial interpolation will fail, causing Arthur to reject. In particular, the only way Merlin can cheat is to encode a truth table in |ψ that is not degree n, but some function with much larger degree. However, the verifier will detect this with the lines-point low-degree test.

Before going through the technical details, let us emphasize that Merlin does not know the points w,w, and w′′ that the verifier will select – these are chosen after Merlin commits to a witness state. Hence, Merlin must send a witness state |ψ that passes all the checks in the verification procedure for all choices of w,w, and w′′ and no matter the random outcome y the verifier observes in Step 3.

Formally, Merlin can send an arbitrary state:

|ψ=z𝔽qn,b𝔽qαz,b|z|b.

The verifier maps the witness to

z𝔽qn,b𝔽qαz,b|z|b|Cw,w,w′′(z),

and measures the last register. Suppose the measurement outcome is some y𝔽qn. If y=0n, the verifier rejects, but we will pessimistically assume this never happens. Suppose y0n. As discussed previously, there are q3q2 points z such that z,w,w, and w′′ define the same affine cube B as y,w, w, and w′′. These correspond to the points in BA (recall that A is the affine plane containing w,w, and w′′). Define DBA to be the points zBA for which there exists at least one nonzero αz,b for some b𝔽q. The post-measurement state |ϕ is then

|ϕ=zD,b𝔽qαz,b~|z|b,

where

αz,b~=|αz,b|zD,b𝔽q|αz,b|2.

Note that we can assume without loss of generality that αz,b~ as the verifier only performs non-collapsing measurements on |ϕ. In fact, in Step 4, the verifier’s actions can be understood as drawing samples from a classical probability distribution where each (z,b) pair has a probability of |αz,b~|2.

Recall the well-known fact that Θ(n+log(1/δ)ε2) samples are necessary and sufficient to learn a distribution to total variation distance at most ε with probability at least 1δ (cf. [18, Theorem 1]). Hence, the O(n4) non-collapsing measurements in Step 5 suffice to learn the distribution over (z,b) pairs in the support of |ϕ to total variation distance at most O(1/n) with probability at least 1exp(Ω(n)). In particular, for Steps 4 through 6 to pass, |ϕ must be (approximately) uniformly supported on pairs (z,bz) for each zBA. (The verifier will immediately reject if any zBA is paired with more than one b𝔽q value.) Because this must hold for any affine plane A and affine cube B, we can deduce that Merlin is forced to send a state that is (approximately) uniform over pairs (z,bz) for every z𝔽qn.

Assuming these steps pass, Step 7 passes only if the observed pairs (z,bz)zBA fit a degree-n trivariate polynomial uB. As discussed in the honest case, by selecting a w′′𝔽qn uniformly at random, we guarantee that the affine cube B contains a random line , independent of the w and w (this is precisely why we need a 3-dimensional affine subspace). Therefore, the interpolation succeeding implies that the function encoded by Merlin matches a degree-n polynomial on a randomly chosen line. By Lemma 1, we can conclude that Merlin indeed encoded a truth table for a degree-n polynomial.

If all of these steps pass, then the verifier can learn π(w) and π(w) as desired by evaluating uB(0,0,0) and uB(0,1,0). By plugging the values π(w) and π(w) into the 𝖯𝖢𝖯 verifier, the 𝖯𝖣𝖰𝖬𝖠 verifier accepts with probability at most s.

4 QMA and Hidden Variables

We introduce and characterize the complexity class 𝖣𝖰𝖬𝖠, a variant of 𝖰𝖬𝖠 where the verifier can perform 𝖣𝖰𝖯 computations. Informally, 𝖣𝖰𝖯 is like 𝖡𝖰𝖯 with the ability to inspect the entire history of a hidden variable. For completeness, we begin this section by giving a formal definition of 𝖣𝖰𝖬𝖠. Then, as with 𝖯𝖣𝖰𝖬𝖠, we prove that 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯. This result is more “quantum” than 𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 (Theorem 5) because the 𝖣𝖰𝖯 verifier will use quantum circuits (as opposed to merely computational basis measurements).

4.1 The Complexity Class DQMA

We give a formal definition of 𝖣𝖰𝖬𝖠. To do so, we must recall a few definitions related to the class 𝖣𝖰𝖯 (see [4] for more detail about this class).

We begin by defining hidden-variable theories. To aid intuition, one can think of hidden-variable theories like standard quantum mechanics where there is a state vector that evolves unitarily. However, there is also a deeper “hidden variable” in some definite state (i.e., not in superposition) that evolves stochastically in a manner determined by the state vector and the state vector’s unitary evolution. In the series of definitions that follow, we are building up to defining a model of computation where one evolves a state vector unitarily, and then (at the end of the computation) can inspect which states the hidden variable was in at each step of the computation.

Definition 6 (Hidden-variable theory).

A hidden-variable theory is a family of functions {Sd}d, where each Sd maps a d-dimensional mixed state ρ and a d×d unitary matrix U onto a singly stochastic matrix Sd(ρ,U).

That is, we take a hidden-variable theory to be a function that maps the unitary evolution of a state to a stochastic matrix that evolves one probability distribution to another. Conditioned on a hidden variable being in a state |j, (S)ij is the probability that a hidden variable transitions to the |j.

Aaronson [4] defined a number of axioms a hidden-variable theory could satisfy. We require three of these axioms to define 𝖣𝖰𝖯: the marginalization axiom, the indifference axiom, and the robustness axiom. In the following definitions, S denotes the hidden-variable theory, ρ a d-dimensional quantum state, and U a d×d unitary matrix. Each axiom must hold for all d.

Definition 7 (Marginalization axiom).

The marginalization axiom says that for all j{1,,d},

i(S)ij(ρ)ii=(UρU)jj.

In words, the marginalization axiom says that the hidden-variable theory should make predictions that are consistent with quantum mechanics.

Definition 8 (Indifference axiom).

For a matrix Md×d, let a block be a subset B{1,,d} such that (M)ij=0 for all (i,j) such that iB, jB and iB, jB. The indifference axiom says that the stochastic matrix S(ρ,U) must have the same blocks as U.

Physically, the indifference axiom says the following. Given any quantum state ρ in a tensor product space AB and any unitary U acting nontrivially only on A, the stochastic matrix S(ρ,U) acts nontrivially only on A as well.

Finally, we state the robustness axiom, for which we need the following notation. Let P(ρ,U) be the matrix of joint probabilities whose (i,j) entry is (P)ij(S)ij(ρ)ii.

Definition 9 (Robustness axiom).

Let ρ~ and U~ be perturbations of ρ and U, respectively, and, for a matrix M, let Mmaxi,j|(M)ij|. The robustness axiom says that, for all polynomials p, there should exist a polynomial q such that,

P(ρ~,U~)P(ρ,U)1p(d),

whenever ρ~ρ1/q(d) and U~U1/q(d).

The robustness axiom is necessary to prove that the class 𝖣𝖰𝖯 is not sensitive to the choice of gate set defining the class.

Next, we define the history of a hidden variable.

Definition 10 (Hidden variable history).

Let |ψinit be an n-qubit quantum state, and let UUTU1 be an n-qubit, depth-T quantum circuit, where U1,,UT denote each layer of the quantum circuit U. The history of a hidden variable is a sequence H=(v0,,vT) of basis states, where vt is the state of the hidden variable immediately after the layer Ut of the circuit is applied. Given a hidden-variable theory 𝒯{Sd}d, we obtain a probability distribution over hidden variable histories Ω(𝒯,U,|ψinit) via the stochastic matrices

S(|ψinit,U1),S(U1|ψinit,U2),,S(UT1U1|ψinit,UT).

We can now define the complexity class 𝖣𝖰𝖬𝖠.

Definition 11.

𝖣𝖰𝖬𝖠(c,s) is the class of languages L{0,1} for which there exists a 𝖣𝖰𝖯 verifier V (to be defined shortly) such that, for all x{0,1}:

  • Completeness: If xL then there exists a witness state |ϕ, on poly(n) qubits, such that V(x,|ϕ) accepts with probability at least c.

  • Soundness: If xL then V(x,|ϕ) accepts with probability at most s for all witness states |ϕ.

A 𝖣𝖰𝖯 verifier is defined as follows. Let 𝒯 be a hidden-variable theory satisfying the marginalization, indifference, and robustness axioms (Definitions 7, 8, and 9), and let Cx (depending on the input x) be a 𝖯-uniform quantum circuit comprised of gates from any finite gate set that is universal for 𝖡𝖰𝖯. A 𝖣𝖰𝖯 verifier is a deterministic classical Turing machine that is allowed to draw one sample from the distribution Ω(𝒯,Cx,|ϕ|0p(n)) (Definition 10), where |ϕ is the witness and p is a polynomial.

4.2 DQMA = NEXP and DQP/qpoly = ALL

We conclude this section by proving 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 and 𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫. Recall that in the proof of 𝖯𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 (Theorem 5), the verifier uses non-collapsing measurements to sample O(nlogn) values of a multivariate polynomial along an affine line of one’s choice and then does interpolation. To prove 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯, we use the same verification procedure, except we use the history of a hidden variable to collect the samples in place of non-collapsing measurements. Hence, to prove 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯 it suffices to explain how we collect these samples with the history of a hidden variable. We achieve this by generalizing the “juggle subroutine” due to Aaronson [4, Section VII].

Lemma 12 (Juggle subroutine [4, Section VII]).

Suppose we have an -qubit state

|a±|b2,

where |a and |b are unknown basis states. Given a single copy of the state, the juggle subroutine (a 𝖣𝖰𝖯 algorithm) can efficiently learn both a and b with success probability at least 1e.

We generalize this algorithm to work on states that are an equal superposition over polynomially many strings by reducing to the case of an equal superposition over two strings. Before explaining the generalization, we first must define (and give a simple fact about) pairwise independent families of hash functions, which are used in our reduction.

Definition 13 (Pairwise independent family of hash functions).

A family of hash functions ={h:{0,1}R} is called pairwise independent if xy{0,1} and a1,a2R, we have

Pr[h(x)=a1h(y)=a2]=1|R|2.
Claim 14.

Let S{0,1} be a subset, and let {h:{0,1}R} be a family of pairwise independent hash functions such that 2|S|4|R|3|S|3. Then, for any fixed xS, the probability that x collides with exactly one other yS is at least 16.

Proof.

Let h be chosen uniformly at random, and let xS be some fixed element. The probability that exactly one other element collides with x is

|S|1|R|(11|R|)|S|2.

We lower bound this quantity.

|S|1|R|(11|R|)|S|2 |S|1|R|(1|S|2|R|)
13(1|S|2|R|)
16.

The first inequality follows from Bernoulli’s inequality. The second and third inequalities use the fact that 2|S|4|R|3|S|3.

We now give the generalized juggle subroutine.

Lemma 15 (Generalized juggle subroutine).

Suppose we have an -qubit state

1|S|xS|x,

where S{0,1} is an unknown subset of |S|poly() basis states. Given a single copy of the state, the generalized juggle subroutine (a 𝖣𝖰𝖯 algorithm) can efficiently learn S with success probability at least 1e.

Proof.

We begin with the state of the form

|ψ=1|S|xS|x.

We perform a procedure that involves applying transformations to |ψ and then inverting them to get back to |ψ, in an attempt to “dislodge” the hidden variable from whichever basis state it’s currently sitting in, and get it into a different, uniformly random one. Each time we do this, we have a 1/poly() probability of success. Importantly, since there’s no penalty for failure, we can repeat this procedure poly() times, and then with overwhelming probability, the hidden variable will have visited every basis state |x for xS. Therefore, one will learn S upon observing the hidden-variable history.

The procedure works as follows. First, choose a random hash function h (with a range satisfying the conditions in Claim 14) from some pairwise-independent family, and then map each |x to |x|h(x). Let y be the current state of the hidden variable. By Claim 14, with probability at least 16, there’s exactly one other basis state zy such that h(z)=h(y), and this z is uniformly random. If that happens, then because of the indifference axiom (which says that, if we don’t touch the h-register, then the hidden variable will never move between h-values), we’ve reduced to the problem handled by the original juggle subroutine. In particular, we can now run the original juggle subroutine on the first register (where the hidden variable is). Lemma 12 tells us that, with probability at least 1e, the hidden variable moves from y to z. Finally, we uncompute h, leaving us with our original state |ψ. Overall, the inner loop moves the hidden variable from y to a uniformly random z with probability at least 16e61/poly().333We note that there is some chance that the hidden variable stays put or moves to somewhere other than z, but that’s OK too, since our ultimate goal is for the hidden variable to visit every possible state in S. In any case, we keep repeating. Since there is no penalty for failure, we can repeat this procedure 22 times to ensure that with probability at least 1e, the hidden variable was successfully moved to a uniformly random basis state. Finally, since we visit a uniformly random state with high probability, we can visit every state with high probability by repeating this entire procedure a polynomial number of times.

We are now ready to prove the main theorem of this section. Namely, that giving Arthur access to hidden-variable histories blows up the power of 𝖰𝖬𝖠 to 𝖭𝖤𝖷𝖯.

Theorem 16.

𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯.

Proof.

It is clear that 𝖣𝖰𝖬𝖠𝖭𝖤𝖷𝖯. By Theorem 4, we can complete the proof by showing 𝖬𝖨𝖯𝖣𝖰𝖬𝖠.

The verification procedure and the honest witness sent by Merlin are the same as in the proof of Theorem 5. Suppose we have a yes-instance, and Merlin sends the honest witness with the form:

1qnz𝔽qn|z|p(z).

We must explain how to use the history of a hidden variable in lieu of non-collapsing measurements. After the verifier makes collapsing measurements, they must learn the support of the post-measurement state. To do this, the verifier runs the generalized juggle subroutine (Lemma 15). After that, the verifier can do polynomial interpolation with just classical computation (or reject if there is insufficient data to do the interpolation).

The only difference in the verification procedure is that the data for polynomial interpolation is collected via the generalized juggle subroutine instead of non-collapsing measurements. Therefore, the completeness and soundness of this procedure follow in the same way as for Theorem 5. In particular, if Merlin deviates from the honest witness state, then he can only hurt his success probability by causing the polynomial interpolation step to fail.

Finally, we remark that our generalized juggle subroutine can be used to prove 𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫, complementing Aaronson’s result that 𝖯𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫 [6] and Raz’s result that 𝖰𝖨𝖯(𝟤)/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫 [24]. Similar to Theorem 16, this result is more “quantum” than Aaronson’s or Raz’s, because the generalized juggle subroutine requires quantum computation.

Theorem 17.

𝖣𝖰𝖯/𝗊𝗉𝗈𝗅𝗒=𝖠𝖫𝖫.

Proof.

The advice state and verification procedure are the same as in [6, Theorem 2], except we replace the non-collapsing measurements with the generalized juggle subroutine in the same manner described in the proof of Theorem 16.

5 Open Problems

Is 𝖯𝖣𝖰𝖯𝖣𝖰𝖯? Aaronson et al. [8] give intuition for why this containment ought to be true, but it remains an open problem. Proving 𝖯𝖣𝖰𝖯𝖣𝖰𝖯 (combined with Theorem 5) immediately implies 𝖣𝖰𝖬𝖠=𝖭𝖤𝖷𝖯, simplifying our proof in Theorem 16. We also remark that improving the upper bound 𝖣𝖰𝖯𝖤𝖷𝖯 remains an interesting open problem.

We now know that modifying 𝖰𝖬𝖠 by giving the verifier access to non-collapsing measurements, hidden-variable histories, or non-negative witnesses will cause 𝖰𝖬𝖠 to “explode” in power to 𝖭𝖤𝖷𝖯. Is it possible to replace the verifier with some variant that does not lead to 𝖭𝖤𝖷𝖯? Having access to such variants may find applications in proving better bounds on 𝖰𝖬𝖠(𝟤).

References

  • [1] S. Aaronson. Quantum Lower Bound for the Collision Problem. In Proc. ACM STOC, pages 635–642, 2002. quant-ph/0111102.
  • [2] S. Aaronson. Is Quantum Mechanics An Island In Theoryspace? In A. Khrennikov, editor, Proceedings of the Växjö Conference “Quantum Theory: Reconsideration of Foundations”, 2004. quant-ph/0401062.
  • [3] S. Aaronson. Limitations of Quantum Advice and One-Way Communication. Theory of Computing, 1:1–28, 2005. Earlier version in CCC’2004. quant-ph/0402095. doi:10.4086/TOC.2005.V001A001.
  • [4] S. Aaronson. Quantum Computing and Hidden Variables. Phys. Rev. A, 71(032325), 2005. quant-ph/0408035 and quant-ph/0408119.
  • [5] S. Aaronson. Quantum Computing, Postselection, and Probabilistic Polynomial-Time. Proc. Roy. Soc. London, A461(2063):3473–3482, 2005. quant-ph/0412187.
  • [6] S. Aaronson. PDQP/qpoly = ALL. arXiv:1805.08577, 2018. arXiv:1805.08577.
  • [7] S. Aaronson, S. Beigi, A. Drucker, B. Fefferman, and P. Shor. The power of unentanglement. In Proc. Conference on Computational Complexity, pages 223–236, 2008. arXiv:0804.0802.
  • [8] S. Aaronson, A. Bouland, J. Fitzsimons, and M. Lee. The space “just above” BQP. In Proc. Innovations in Theoretical Computer Science (ITCS), pages 271–280, 2016. arXiv:1412.6507.
  • [9] S. Aaronson and A. Drucker. A Full Characterization of Quantum Advice. SIAM J. Comput., 43(3):1131–1183, 2014. Earlier version in STOC’2010. arXiv:1004.0377.
  • [10] S. Aaronson and J. Watrous. Closed Timelike Curves Make Quantum and Classical Computing Equivalent. Proc. Roy. Soc. London, A465:631–647, 2009. arXiv:0808.2669.
  • [11] D. S. Abrams and S. Lloyd. Nonlinear quantum mechanics implies polynomial-time solution for 𝖭𝖯-complete and #𝖯 problems. Phys. Rev. Lett., 81:3992–3995, 1998. quant-ph/9801041.
  • [12] D. Aharonov and O. Regev. A Lattice Problem in Quantum 𝖭𝖯. In Proc. IEEE FOCS, pages 210–219, 2003. quant-ph/0307220.
  • [13] S. Arora, C. Lund, R. Motwani, M. Sudan, and M. Szegedy. Proof Verification and the Hardness of Approximation Problems. J. of the ACM, 45(3):501–555, 1998. doi:10.1145/278298.278306.
  • [14] S. Arora and S. Safra. Probabilistic Checking of Proofs: A New Characterization of 𝖭𝖯. Journal of the ACM (JACM), 45(1):70–122, 1998. doi:10.1145/273865.273901.
  • [15] J. Barrett, N. de Beaudrap, M. J. Hoban, and C. M. Lee. The computational landscape of general physical theories. npj Quantum Information, 5(1):41, 2019. doi:10.1038/s41534-019-0156-9.
  • [16] R. Bassirian, B. Fefferman, and K. Marwaha. Quantum merlin-arthur and proofs without relative phase, 2023. arXiv:2306.13247.
  • [17] R. Bassirian and K. Marwaha. Superposition detection and 𝖰𝖬𝖠 with non-collapsing measurements, 2024. arXiv:2403.02532.
  • [18] C. L. Canonne. A short note on learning discrete distributions, 2020. arXiv:2002.11457.
  • [19] D. Dieks. Modal interpretation of quantum mechanics, measurements, and macroscopic behaviour. Phys. Rev. A, 49:2290–2300, 1994.
  • [20] K. Friedl and M. Sudan. Some improvements to total degree tests. In Proceedings Third Israel Symposium on the Theory of Computing and Systems, pages 190–198. IEEE, 1995. doi:10.1109/ISTCS.1995.377032.
  • [21] P. Harsha, M. Kumar, R. Saptharishi, and M. Sudan. An improved line-point low-degree test, 2023. arXiv:2311.12752.
  • [22] F. G. Jeronimo and P. Wu. The Power of Unentangled Quantum Proofs with Non-Negative Amplitudes. In Proc. ACM STOC, pages 1629–1642, 2023. doi:10.1145/3564246.3585248.
  • [23] C. M. Lee and J. Barrett. Computation in generalised probabilisitic theories. New Journal of Physics, 17(8):083001, 2015. doi:10.1088/1367-2630/17/8/083001.
  • [24] R. Raz. Quantum Information and the 𝖯𝖢𝖯 Theorem. Algorithmica, 55(3):462–489, 2009. Earlier version in FOCS’2005. quant-ph/0504075. doi:10.1007/S00453-007-9033-6.
  • [25] T. Rudolph and L. Grover. A 2 rebit gate universal for quantum computing, 2002. arXiv:quant-ph/0210187.
  • [26] E. Schrödinger. Über die Umkehrung der Naturgesetze. Sitzungsberichte der Preussischen Akademie der Wissenschaften, Physikalisch-Mathematische Klasse, 8(9):144–153, 1931. English title: On the Reversal of the Laws of Nature.