Oracle Separations for the Quantum-Classical Polynomial Hierarchy
Abstract
We study the quantum-classical polynomial hierarchy, , which is the class of languages solvable by a constant number of alternating classical quantifiers followed by a quantum verifier. Our main result is that is infinite relative to a random oracle (previously, this was not even known relative to any oracle). We further prove that higher levels of are not contained in lower levels of relative to a random oracle; this is a strengthening of the somewhat recent result that is infinite relative to a random oracle (Rossman, Servedio, and Tan 2016).
The oracle separation requires lower bounding a certain type of low-depth alternating circuit with some quantum gates. To establish this, we give a new switching lemma for quantum algorithms which may be of independent interest. Our lemma says that for any , if we apply a random restriction to a function with quantum query complexity , the restricted function becomes exponentially close (in terms of ) to a depth- decision tree. Our switching lemma works even in a “worst-case” sense, in that only the indices to be restricted are random; the values they are restricted to are chosen adversarially. Moreover, the switching lemma also works for polynomial degree in place of quantum query complexity.
Keywords and phrases:
Switching Lemma, Polynomial Hierarchy, Approximate Degree, Random Oracles, Query Complexity, Quantum ComputingCopyright and License:
2012 ACM Subject Classification:
Theory of computation Oracles and decision trees ; Theory of computation Complexity classes ; Theory of computation Quantum complexity theoryFunding:
This research is supported in part by the Natural Sciences and Engineering Research Council of Canada (NSERC), DGECR-2019-00027 and RGPIN-2019-04804.111Cette recherche a été financée par le Conseil de recherches en sciences naturelles et en génie du Canada (CRSNG), DGECR-2019-00027 et RGPIN-2019-04804.Editor:
Shubhangi SarafSeries and Publisher:
Leibniz International Proceedings in Informatics, Schloss Dagstuhl – Leibniz-Zentrum für Informatik
1 Introduction
In classical complexity theory, an important complexity class is the polynomial hierarchy, . This is a generalization of to higher depth: it can be written as the union , and corresponds to languages that can be computed using a constant number of alternating quantifiers over certificates. A problem is in if it can be computed in polynomial time in the presence of two computationally-unbounded provers, one of which wants to convince the verifier the input is a yes-input, and one of which wants to convince the verifier the input is a no-input, with the provers exchanging polynomially-sized public messages for a constant number of rounds. The polynomial hierarchy can therefore be viewed as the class of problems solvable by an audience member sitting in a debate between experts, where the debate has the inefficient format of alternating between the two speakers only a constant number of times, even though the total debate time is polynomial in the input size (polynomially many alternations would result in the larger class ).
The polynomial hierarchy can be viewed as a union of different “levels”, where the -th level corresponds to debates with alternations. The hierarchy is said to collapse to level if level can solve no more problems than level ; in that case, all higher levels can also be simulated with rounds of debate. It is widely believed that the polynomial hierarchy is infinite, meaning it does not collapse to any level. This is a generalization of the conjecture, which is equivalent to the assertion that does not collapse to the -th level.
Since proving the polynomial hierarchy is infinite is beyond current techniques, one may ask instead for oracle separations. It turns out is infinite even relative to a random choice of oracle (with probability ), though this result is somewhat recent.
Theorem 1 ([13]).
is infinite relative to a random oracle.
We study a quantum version of the polynomial hierarchy known as the quantum-classical hierarchy (introduced in [11]). This is the class of problems solvable by a quantum audience member of a constant-round debate (with classical messages) between experts. This class, denoted , generalizes but not (since the proofs received are classical rather than quantum). More formally, is the union , where is defined as the class of languages for which there is a quantum verifier satisfying
for all input strings , where the represent polynomially-sized classical strings, is a quantifier, and is the opposite quantifier.
The class is interesting on its own, but another motivation for its study is the connection to quantum switching lemmas. Oracle separations for generally reduce to the problem of giving lower bounds on the classical circuit class , consisting of circuits of constant depth. Quantum versions of constant-depth circuits are of interest because they help model quantum devices with many qubits but few layers of gates. Lower bounds on such circuit classes are often shown using switching lemmas, which assert that certain types of functions must greatly simplify under a random restriction of their bits; these switching lemmas can therefore be useful both for the study of near-term quantum devices and for oracle separations for complexity classes such as .
1.1 Our results
Our main result generalizes Theorem 1 to the quantum setting.
Theorem 2.
The following holds relative to a random oracle with probability . For any constant , level of the polynomial hierarchy, , is not contained in level of the quantum-classical hierarchy, . In particular, is infinite, and no fixed level of the hierarchy contains all of .
Previously to this work, it was not even known whether there was any oracle relative to which is infinite, let alone a random oracle. Previous switching lemmas for quantum algorithms, such as the one in [1], are insufficient to prove such an oracle separation.222Most quantum circuit lower bounds are incomparable to ours, since they consider different models of quantum circuits. Our switching lemma is stronger than the comparable switching lemma of [1]. We also note that this theorem implies Theorem 1 as a special case, since it also implies that is infinite relative to a random oracle.
The study of relative to a random oracle boils down to the study of circuits against the uniform distribution. This, in turn, is usually done using random restrictions and the switching lemma, together with the random projection technique introduced in [13]. To prove Theorem 2, we need a new switching lemma for quantum query complexity.
Theorem 3.
Let be sufficiently large, and let be a possibly partial Boolean function on bits with . Let (we can choose ), and consider a random restriction of which fixes each bit with probability . Then for any , this restriction is approximated by a decision tree of height in the following sense.
For an input and a choice of unrestricted bits , we define a restriction which sets bits in to according to . Then for every input , there is an ensemble of decision trees , all of height at most , with acting on the unrestricted input bits which are strings of length , such that the following holds: if is chosen at random with each index included in independently with probability , then
Here denotes the restriction of to the partial assignment which fixes the bits of outside of .333If is undefined on input , we count it as equality holding in the probability, meaning that on inputs outside the domain the decision tree is allowed to output anything.
This is a type of switching lemma for quantum query complexity, though its statement can be confusing. We make a few clarifying comments. First, note that with the parameter , a function with quantum query complexity at most becomes constant with high probability under a random restriction. However, the probability of the function becoming constant is merely , which is not small enough. The point of the theorem is to approximate the function to exponentially small error (in the height of the approximating decision tree).
The random restriction in Theorem 3 is worst-case in the sense that while the positions to be fixed are chosen randomly, the bits to which those positions are fixed are specified by a string , which can be chosen arbitrarily. Moreover, the resulting restricted function must be approximated by a decision tree even on worst-case choices of input (except that the choice of the worst-case cannot depend on the random choice of ). From such a worst-case statement, we can easily derive a more familiar average-case switching lemma.
Corollary 4.
For sufficiently large , let be such that , let , and let . If is a random restriction in which each bit remains unfixed with probability (and is fixed randomly to or otherwise), then with probability at least , there is a decision tree of height at most which computes on a fraction of its inputs.
Theorem 3 can be viewed as a version of Corollary 4 which works even for non-uniform distributions. We also strengthen Theorem 3 so that it works for approximate degree instead of just quantum query complexity.
Theorem 5.
Theorem 3 still holds if the condition on is replaced by instead of .
This can be viewed as establishing a random-restriction version of the Aaronson-Ambainis conjecture, which asserts that low degree polynomials can be approximated by shallow decision trees against the uniform distribution. Our version works only after a random restriction is applied to the polynomial, but it works with extremely strong parameters444Note that Aaronson-Ambainis conjecture is about bounded real-valued functions rather than Boolean functions; our switching lemma also works in that setting.. Another (incomparable) version of the Aaronson-Ambainis conjecture for random restrictions was given in [7].
Although we don’t explicitly show it, Theorem 5 can be strengthened further, so that it works with a measure known in the literature as (the square root of) “critical fractional block sensitivity”, which lower bounds approximate degree [4]. This measure also lower bounds the positive-weight quantum adversary bound, so our switching lemma also works for that measure.
Finally, we give an application of our switching lemmas to yet another type of oracle separation: we show that the “ hierarcy,” that is,
is also infinite relative to a random oracle. Explicitly, defining and for , we have the following result.
Theorem 6.
The following holds relative to a random oracle with probability . For any constant , is not contained in . Moreover, no fixed level contains all of .
Proving lower bounds on relative to an oracle amounts to proving lower bounds on constant-depth circuits which have alternating layers of polynomial-fanin AND gates, and of “gates” consisting of quantum query algorithms which make few quantum queries. This demonstrates that our techniques can be useful for proving lower bounds on shallow quantum circuit classes.
1.2 Our techniques
Random oracle separations.
To prove our oracle separation for relative to a random oracle, it suffices to show that depth circuits with “quantum query complexity gates” at the bottom layer cannot compute some function in computable in depth classical , against the uniform distribution. The quantum query complexity gates means that at the bottom of the alternating layers of AND and OR gates lie Boolean functions which can each be computed in quantum queries. (For the separation, we need to allow quantum query complexity gates in the middle of the circuit as well, not just the bottom.) This circuit separation implies the random oracle separation through a standard technique sometimes called “slow diagonalization” (see full version).
To construct a function which is computable in depth classically but not in depth quantumly (against the uniform distribution), we use the construction of [13], which separated classical circuits of different depths. Their proof used random projections, which we also employ. We must modify their construction to account for the extra layer of quantum gates, which we will need to “strip away” in the analysis using a random projection and our quantum switching lemma.
In order to establish a depth-hierarchy theorem for circuits, the restrictions used need to ensure that an AND-OR tree retains structure (as in [12] and [13]) while a smaller-depth circuit simplifies. Thus the sequence of restrictions/projections used needs to alternate between heavily biased towards and heavily biased towards (so that not all AND/OR gates are set to constant). In the quantum switching lemma of [1], the quantum query algorithm becomes close to a DNF with respect to the uniform distribution, when the restriction is also sampled uniformly. We will however need to sample a projection from an underlying distribution different from the one with respect to which we compare the closeness of the resulting quantum query algorithm and DNF (because of the alternating choice of distributions described earlier). This mismatch between the two distributions requires us to use our “worst-case” type of quantum switching lemma.
Our separation for the hierarchy works similarly, but requires carefully changing the parameters to ensure the structure is maintained even in the presence of intermediate quantum query gates. See Section 6 for details.
Quantum switching lemma.
The proof of our quantum switching lemma relies on an adaptive application of the quantum hybrid method, which may be of independent interest. Given a quantum algorithm acting on a string , a standard hybrid argument of [6] says there will only be a small set of positions in the string that the algorithm “looks at”; the output of can only be sensitive to a change in a bit of at one of those few positions. Call those the heavy positions of . Now, if some of those heavy positions of are indeed changed, then not only can the output of change, but even the set of heavy positions of the input can change.
This poses a problem for us: we would like to restrict the function to the bits of , except at a few random positions. If some of those random positions are heavy (with respect to ), then the quantum algorithm can still depend on them in a nontrivial manner. We could try to mimic this by a classical algorithm which queries those few non-fixed heavy bits, but the problem is that this is not sufficient to fix the output of : the output of the algorithm may now depend on new heavy bits. (It is not clear if a classical decision tree can find these new heavy bits, since a quantum algorithm may try to query the rest of the unfixed bits in superposition.)
We get around this problem by applying the hybrid method iteratively, in an adaptive manner. Beginning with a string , we find its heavy bits, and randomly choose a few of them to leave unfixed; we replace those bits with values from a different string . This gives us a hybrid string which mostly contains bits of , but where a few heavy positions were replaced by bits of . We then iterate this process: we find the heavy bits of which are not heavy bits of , sample a few of those positions at random, and replace them with more bits from , resulting in . We continue this way and terminate when there are no new heavy bits.
In each round, there is a constant (or better) probability of having no new heavy bits which are unfixed, since the number of heavy bits is small and the probability of leaving a bit unfixed is also small. This means the number of rounds cannot be too large except with exponentially small probability. Once the process terminates, the set of all heavy bits encountered along the way cannot be too large (except with exponentially small probability), and can be used to compute the randomly-restricted function on most inputs.
Polynomial lower bound.
Since our quantum switching lemma relies fundamentally on the hybrid method, which talks about “where the quantum algorithm queried the string”, it may seem surprising that we can generalize our result to a switching lemma for polynomials as well. To do this, we rely on a property shown in [4] (expanding on earlier work by [14]) which says that approximate degree is lower bounded by fractional block sensitivity. Fractional block sensitivity, in turn, is equal to fractional certificate complexity, a measure which assigns to each bit of each input a non-negative weight: a way of saying “how much did the polynomial look at position when given string as input”.
In fact, we will need a stronger version of the result of [4]; we adapt their method to prove this. Our result is the following theorem, which may be of independent interest.
Theorem 7.
Let be a real-valued function which can be expressed as a polynomial of degree at most . Then there is an assignment of weights to inputs and positions such that for all , we have
The proof is similar to the one in [4]; it uses strong duality of linear programming to convert fractional certificates to fractional block sensitivity, and uses composition of with a version of promise-OR to convert fractional block sensitivity to regular block sensitivity; the latter can be turned into sensitivity using a projection, and results in approximation theory can be used to relate sensitivity to polynomial degree.
2 Preliminaries
Definition 8 (Projection).
Given a function , and a restriction in , the projected function is defined as where
So the projection operator maps all unrestricted variables in a given block of size , to the same new variable. If is a random restriction, then is a random projection.
2.1 Quantum-Classical Polynomial Hierarchy
Definition 9 ().
Let be a promise problem. We say that is in for poly-time computable functions if there exists a poly-bounded function and a poly-time uniform family of quantum circuits such that for every -bit input , takes in classical proofs and outputs a single qubit, such that:
-
Completeness: s.t. .
-
Soundness: s.t. .
Here, equals when is odd and equals otherwise and is the complementary quantifier to . Define
Note that the first level of this hierarchy corresponds to . The complement of the level of the hierarchy, , is the class defined next.
Definition 10 ().
Let be a promise problem. We say that for poly-time computable functions if there exists a polynomially bounded function and a poly-time uniform family of quantum circuits such that for every -bit input , takes in classical proofs and outputs a single qubit, such that:
-
Completeness: s.t. .
-
Soundness: s.t. s.t. .
Here, equals when is odd and equals otherwise, and is the complementary quantifier to . Define
Now the corresponding quantum-classical polynomial hierarchy is defined as follows.
Definition 11 (Quantum-Classical Polynomial Hierarchy ()).
See the full version for a survey of the previous work on quantum polynomial hierarchies.
Definition 12 ( circuits).
A circuit family is in for some function if it satisfies the following:
-
1.
has alternating layers of and gates, followed by a layer of quantum query circuits of size
-
2.
size() where size of the circuit is the number of , gates plus the number of quantum query circuits in the bottom layer
Note that in the above definition, if the quantum query circuits are not computing total functions, then we treat each gate in the circuit as computing a partial function, whose output is evaluated in the following manner. For an input to the circuit, a gate outputs 1 if at least one of its inputs is 1 regardless of the arbitrary 0/1 responses of the input partial functions whose promise is violated. It outputs 0 if all of its inputs are 0 regardless of the arbitrary 0/1 responses of the input partial functions whose promise is violated. Otherwise, the output of the gate is undefined. The evaluation of the output of gate is done in a similar manner. This method of evaluation gives the same output as the one if we evaluate the output of the circuit in a manner consistent with Definition 9 (or Definition 10). That is, a gate corresponds to an quantifier and a gate corresponds to a quantifier. We show this formally in the full version.
2.2 Query complexity
In query complexity, an algorithm (classical or quantum) is given black-box access to a string , and is supposed to compute some boolean function by querying as few times as possible. We have included the basic definitions of query complexity in the full version. Interested readers can refer to [8] for a detailed introduction to query complexity. Let . In the classical query model, an algorithm queries and receives , which we will denote by . In the quantum query model, an algorithm queries and receives , which we will denote by .
Definition 13 (Query Magnitudes [6]).
Given a quantum query algorithm computing a (partial) function (where ) with queries, define query magnitude at time step , denoted , for and as follows:
We call as the query magnitude of for bit on input . Since for all , we know that (it need not be exactly equal since the quantum algorithm might make less than queries on some inputs ).
Definition 14 (Partial Assignment).
A partial assignment of length is any string from the set . A string is consistent with if whenever .
Definition 15 (Certificate).
Given a (partial) function , a partial assignment is a -certificate for if for all which are consistent with . The length of this certificate is the number of bits in not equal to .
Definition 16 (Certificate Complexity).
Given a (partial) function , the certificate complexity of at input is defined as where the minimization is over all partial assignments consistent with , which are also -certificates for . Then the certificate complexity .
Definition 17 (Approximate Degree).
Given a (partial) function , the approximate degree of , denoted , is the minimum degree of a multi-linear polynomial which approximate to error within additive error for all input and for all .
Lemma 18 ([5]).
If a (partial) function is computable by a quantum algorithm making queries, we have that there is a multilinear polynomial of degree at most such that is equal to the probability that outputs 1 on input . Therefore approximates to error within additive error for all input and for all and .
2.3 Hierarchy
In this section, we define the hierarchy (called ). It is a hierarchy of classes, where the level, called is defined as follows:
Note that is a class of promise problems, thus when querying a oracle, any algorithm is making queries to a promise oracle. Note that the algorithm is different from the verifier (which takes a single proof as input and outputs 0/1), here instead refers to the OR of all these 0/1 outputs of the verifier for every possible proof. If makes a query on an input which violates the promise of the oracle, then the oracle can return an arbitrary 0/1 response. Therefore we need to be careful about when the behaviour of is well-defined. In this paper, we follow the definition of well-defined behaviour proposed in [1] (note however that there can be many other reasonable definitions of well-defined behaviour, though we do not describe them here). The behaviour of is well-defined, if the output of remains the same regardless of the arbitrary 0/1 responses of the oracle on inputs violating the promise. In particular for a yes input, the verifier might accept only one proof for some choice of oracle responses outside the promise, and it might accept (say) half of the proofs for some other choice of oracle responses, but the behaviour remains well-defined as long as it accepts at least one proof for every choice of oracle responses.
In the rest of the paper, we will denote as verifier as an -tuple of verifiers where corresponds to the base verifier and the remaining verifiers form the -tuple for the verifier corresponding to the oracle.
3 Polynomials and fractional block sensitivity
In this section, we establish a relationship between fractional block sensitivity and degree for real-valued functions. We will need this relationship to establish a switching lemma for approximate degree (the tools of this section are not necessary for the quantum switching lemma, which may instead rely on only the hybrid argument of [6], but we opt to prove the stronger switching lemma for polynomials).
3.1 Definitions for real-valued functions
When studying the degree of bounded real-valued functions, most of the literature uses the convention that the functions have signature , known as the basis. Switching between and does not affect most measures: we can interpret as and as , and we can plug in in each variable to convert a variable to a variable, or plug in to go in the reverse direction. This does not affect the degree. We will use the basis in this section.
Sensitivity.
The sensitivity of a real-valued function can be defined as follows. For a block , define
where the notation refers to the string with the block of bits flipped. Note that we divide by because can take values from instead of . This is the sensitivity of a specific block to a specific input , with respect to the function ; it is a value between and . We next define the sensitivity of at to be which is the total sensitivity of all the bits of . We then use it to define sensitivity of .
For a Boolean function, this definition matches the usual definition of sensitivity .
Block sensitivity.
We define block sensitivity analogously: will be the maximum possible value of over choices of disjoint blocks , and will be the maximum possible value of over choices of inputs .
Fractional block sensitivity.
We define to be the maximum possible value of the sum , subject to the constraints for all and for all . (The weights represent fractions of a block, and the total weight of all blocks containing a bit must be at most , making the blocks “fractionally disjoint”.) As usual, we define .
Fractional certificate complexity.
The definition of is the optimal value of a linear maximization program in terms of the real variables . The dual of this linear program can is as follows. The variables are , with the constraint for all . The objective is to minimize . This can be interpreted as finding a fractional certificate, with representing the fraction with which bit is used in the certificate, such that any block which, when flipped, changes the value of the function by must be “detected” by the certificate in the sense that the certificate puts total weight at least on the bits of .
Fractional certificate complexity is equal to fractional block sensitivity, so we will not give it new notation. However, we denoting by the fractional certificate for , we get that for all ,
The factor of comes from the use of outputs for ; if takes outputs in instead (for example, if we consider the function where takes values in we are comparing the differences to the value of ), we do not need to divide by .
3.2 Relationships to degree
Our results will rely on the following theorem by [9], which states that sensitivity lower bounds the squared degree even for a real-valued function. This theorem follows from results in approximation theory (though it is possible to get a version which is weaker by a constant factor using a proof analogous to the one for the discrete case).
Theorem 19 ([9]).
For any , we have .
With this theorem in hand, we show in Corollary 20 that block sensitivity also lower bounds the squared degree (proven in full version).
Corollary 20.
For any , we have .
Finally, we show in Theorem 21 that fractional block sensitivity lower bounds the squared degree (proven in full version).
Theorem 21.
For any , we have .
Theorem 7 follows.
4 Random restrictions for polynomials
In this section, we show that functions which have low fractional block sensitivity (and therefore, low approximate degree and low quantum query complexity) become close to a small-depth decision tree with high probability, after applying a sufficiently strong random restriction. This resolves an open problem in [1], asking whether functions with low approximate degree become close to a DNF on applying a random restriction. We first define a notion of -certificates for a function , which is approximated to error 1/3 by a real-valued function .
Definition 22 (-certificate).
Let be a partial function which is approximated to error 1/3 by a real-valued function . Then a pair for is a 1-certificate for on input if for all such that for all , . In particular, the bits of in certify that . Similarly, a pair for is a 0-certificate for on input if for all such that for all , .
A random restriction result was shown by [1] for quantum query algorithms, which they use to show that efficient QMA-query algorithms become close to a DNF in expectation over the choice of a suitably strong random restriction. We reprove this result (with minor change in parameters) for functions with low fractional block sensitivity in Lemma 23 (proof in full version). The proof is analogous to that of [1], with query magnitudes of a quantum algorithm replaced by the weight assignment for fractional certificate complexity.
Lemma 23 (Analogue of Theorem 60 of [1]).
Let be a partial function which is approximated to error 1/3 by a real-valued function of fractional block-sensitivity . Pick a set where each index is put in independently with probability . Choose an arbitrary and . Define and , is the fractional certificate of on index when the input is . Then with probability at least over choice of , , and for all with , we have:
Note that for Lemma 23, we have that with probability at most by a union bound. In particular, if and is sufficiently small (say ), then with reasonably high probability over the choice of (say ), none of the indices such that are included in . Therefore, the restricted function becomes a constant function in this case.
Theorem 24.
Let be a partial function which is approximated to error 1/3 by a real-valued function of fractional block sensitivity . Pick a set where each index is put in independently with probability , where . Then
where is the string restricted to indices in , is a -random restriction defined from and as follows:
and is a width- DNF dependent on (defined explicitly in the proof). Note that if , then is allowed to output 0 or 1 arbitrarily.
Proof.
Choose arbitrary , and choose as described in the theorem statement to define . Suppose is approximated to error 1/3 by a real-valued function of fractional block sensitivity . Let be the set of all 1-certificates for after applying the restriction . Then the DNF is defined as follows (this is the same DNF that [1] show closeness to):
Note that if , then outputs 0 because it will not find a 1-certificate in . In addition, we do not care about the output of when . So now we only worry about the case when . Define , where and is the fractional weight of on index for input . We now think of sampling in stages (instead of all at once), and we start by sampling for indices in . Note that the set is still sampled by putting each bit in independently with probability , we only adopt this viewpoint of stages to analyze the sampling. In particular, since each bit is included in independently, we can analyze the random restriction by looking at a subset of bits at a time and seeing whether they were included in or not, without affecting the inclusion/exclusion of other bits, which we can analyze in the next step. Recall, we start by sampling for indices in . Define , and as the string with bits in flipped. Then is sampled further in stage as follows: is obtained by sampling indices in , and . Note that , and therefore by a union bound, with probability at most over choice of (we assume that is sufficiently small, say ). If , then we stop the stage-wise analysis and make a decision for all the input bits we haven’t analyzed yet to get the full set . Therefore, the probability that we reach stage of the sampling to sample is at most , since the sampling in each stage is performed independently of the previous stages. Note that the decision of whether or not to put any given bit in is independent of the other bits, by stages of the sampling we only change the order in which we analyze this decision. Further, in each stage of sampling, by Lemma 23, with probability at most , thus the probability that any of has size more than for is at most by union bound. Therefore, with probability at least , and (since for all ). Now we sample the remaining indices of , and by Lemma 23, with probability at most . So now we assume that , and , which happens with probability at least . For convenience, we now set . Define as follows:
Therefore and . Let . Note that , because was sampled from bits in and the bits of in were sampled in . So because we assume . From Lemma 23, for all which differ from only on indices in . In particular, differs from only on bits in , because agrees with on all bits in and is a subset of these bits. Therefore . Therefore, if , then for all which differ from only on bits in . Thus, is a 1-certificate of size at most for when bits outside of are fixed to those of . Finally, is consistent with this certificate, thus . Since our assumption holds true with probability at least , therefore, for every , the statement in the theorem holds true. The argument above from Theorem 24 actually shows that a given 1-input of is consistent with a small 1-certificate (of size ) with high probability over the choice of unrestricted bits. A symmetric argument can be made for 0-certificates as well. Thus the theorem can be restated as follows:
Corollary 25.
Let be a partial function which is approximated to error 1/3 by a real-valued function of fractional block sensitivity . Pick a set where each index is put in independently with probability , where . Then
where is the string restricted to indices in , is a -random restriction defined from and as follows:
In particular, since we now have small certificates (with high probability) for the restricted function, we can construct a decision tree of small-depth which is correct with high probability over the choice of random restriction and a uniformly random input. We show this in Corollary 26 (proof in the full version).
Corollary 26.
Let be a partial function which is approximated to error 1/3 by a real-valued function of fractional block sensitivity . Pick a set where each index is put in independently with probability , where . Then
where is the string restricted to indices in , is a -random restriction defined from and as follows:
and is a decision tree of depth- (described explicitly in the proof), dependent on . Note that if , then is allowed to output 0 or 1 arbitrarily.
As a corollary of Theorem 24, we can also conclude that functions which have low quantum query complexity also become close to a decision tree of small depth, after applying a random restriction (using Lemma 18).
Theorem 27.
Theorem 24 also holds for partial functions of quantum query complexity , when we set to obtain a width- DNF.
Theorem 28.
Corollary 26 also holds for partial functions of quantum query complexity , when we set to obtain a depth- decision tree.
We discuss in the full version why our proof for the switching lemma from Theorem 27 does not directly extend to -query algorithms, unlike Theorem 65 of [1].
5 Random projections for quantum query algorithms
We now consider the effect of random projections on quantum query algorithms, and we start by showing the following theorem on block random restrictions (where we restrict an entire block of bits at a time, instead of restricting individual bits) for quantum query algorithms. This proof is essentially the same as Theorem 24, see full version for details.
Theorem 29.
Let be a partial function computable by a quantum query algorithm making queries to the input. Pick a set where each index is put in independently with probability , where . Then
where is the string restricted to blocks in , is a -block-random restriction defined from and as follows:
and is a width- DNF dependent on (defined explicitly in the proof). Note that if , then is allowed to output 0 or 1 arbitrarily.
We now state in Lemma 30 an average case version of Theorem 29, with respect to two (potentially distinct) block-product distributions from which the strings and are sampled (proof in full version). An analogous proof for random restrictions where both the distributions are uniform will recover Corollary 4. Note below that denotes the product distribution where each bit is set independently to or with probability 1/2, conditioned on not setting every bit to .
Lemma 30.
Let and be two block-product distributions on . Let be a -block-random restriction with underlying distribution , where each block is sampled from with probability and from the corresponding block of otherwise. Let be the distribution induced by on the indices set to by . Let be a partial function computable by a quantum query algorithm making queries to the input. Set , then there exists a DNF of width- such that
where is allowed to answer 0 or 1 arbitrarily if .
In particular, on applying to a quantum query algorithm, the resulting function is close to a DNF of width .
Corollary 31.
Let be a block-product distribution on and be a product distribution on . Let be a -block-random restriction with underlying distribution , where each block is sampled from with probability and from the corresponding block of otherwise. Let be the distribution induced by on the indices set to by . Let be a partial function computable by a quantum query algorithm making queries to the input. Set , then there exists a DNF of width- such that
where is allowed to answer 0 or 1 arbitrarily if .
Proof.
5.1 Random projections for circuits
In our proof we rely heavily on the notation as well as results from [13], therefore in this section we mention all the notation and results we use. Note that we reference the arXiv version of the paper in the rest of the discussion.
Definition 32 ( functions [13]).
The function is a depth read-once monotone formula with variables, with alternating layers of AND and OR gates. The bottom layer (adjacent to input variables) consists of AND gates, so the root is an OR gate if is even and AND gate otherwise. All the gates at a particular depth have the same fan-in, which is denoted by for gates of depth . So the bottom fan-in is and the top fan-in is . The parameters correspond to the bias of the distribution for the random projection for depth .
Next we describe the addressing scheme used for the gates and input variables of (which we will also use for ). Let , and for , let . An element of specifies the address of a gate at depth ; so is the set of addresses of the input variables. For some string , use for to denote the block of of length .
The symbol denotes the random bit string of length where each bit is sampled independently, and is with probability and with probability . The symbol denotes the product distribution conditioned on not outputting the string . For our setting, will be either or . The notation is shorthand for .
We modify the first random projection from that of [13], to replace the bottom layer of quantum circuits in circuits by DNFs. Our subsequent random projections are the same as that of [13]. Since the random projections are defined adaptively based on the outcome of the previous random projection, they define the notion of lift of a random restriction, which tells us the value taken by each gate in the bottom layer of the circuit to which the corresponding random projection has been applied, and this is used to decide how to sample the next random restriction.
Definition 33 (Lift of a restriction, Definition 7 from [13]).
Let and . Assume that the gates of (or ) at depth are gates (otherwise the roles of 0 and 1 below are reversed). The lift of is the string defined as follows: for each , the coordinate of is
To show that the function retains structure after applying a random projection, they define the notion of a typical restriction. Roughly, on applying a random projection corresponding to a typical restriction to , the depth of the formula is reduced by 1, and the bottom layer of gates of takes on values in such that the bottom fan-in of the projected formula is approximately . In addition, the fan-in of the layers above remains roughly the same. More generally, after applying a series of random projections to , all of which correspond to typical restrictions, applying the next random projection corresponding to a typical restriction ensures that the resulting formula has depth reduced by 1, bottom fan-in approximately and fan-ins of all other layers remain roughly the same. [13] show that each of their random restrictions is typical with high probability, assuming that the previous restriction is typical. We will show that the first random restriction which we redefine, is also typical with high probability, and therefore all the subsequent random restrictions remain typical using the results of [13]. Note that in the discussion above and the following definition, we talk about projections corresponding to restrictions which are typical, [13] however, talk about projections corresponding to restrictions for which the lift is typical. So though Definition 34 is identical to theirs, it is stated slightly differently here.
Definition 34 (Typical random restriction, Definition 14 of [13]).
Let where . The restriction is typical if
-
1.
(Bottom fan-in after projection ) For all
-
2.
(Preserves rest of the structure) For all
These conditions also imply that all the gates in remain undetermined. This is because suppose is applied to a layer of gates. Then by condition 1, the only values that gates in can get are or (so gates in have inputs from and ). By condition 2, gates in have at least one input, and since none of their inputs is , they remain undetermined.
Finally, [13] show that if an OR function (or its restriction) is close to unbiased under some input distribution where each bit of the input is independent and identically distributed, then it has a small correlation with CNFs of small width under this distribution.
Lemma 35 (Proposition 11.1 of [13]).
Let be a CNF of width- and . Let be the function on n bits and for , then
In order to get an average case depth-hierarchy theorem for circuits, [13] show three properties for their sequence of random projections:
-
1.
The sequence of random projections completes to the uniform distribution.
-
2.
The target function remains “hard” to compute after applying the sequence of random projections.
-
3.
The approximating circuit trying to compute “simplifies” greatly after applying the sequence of random projections.
We first re-establish Property 1 after modifying the initial random projection to be applied. Then we establish Property 2 for our modified function, by showing that the effect of the modified initial random projection on is roughly the same as the effect of the initial random projection of [13] on . Since our subsequent random projections are the same as theirs, we can conclude that retains structure under this sequence of random projections. Finally, we use our random projection result for quantum query algorithm to show that the bottom layer of a circuit simplifies after applying the initial random projection. Then we can use the results of [13] to conclude that the resulting circuit also simplifies after applying the subsequent random projections.
5.2 Random projections for circuits
We start by showing an analogue of [10] for in Proposition 36 (proof in full version), to use a circuit lower bound for to get oracle separation result for . Note that [1] show a similar analogue for the -hierarchy.
Proposition 36 (Analogue of [10]).
Let be some language decided by a verifier with oracle access to , and which has size at most for inputs of length . Then for every , there is a circuit of size at most and depth , where each layer upto depth is a layer of AND or OR gates, and depth contains sized quantum circuits with query complexity at most , such that
where denotes the concatenation of bits of on all strings of length at most .
We now describe the modification of function (used in [13]) that we show the lower bound for. The modified function which we use will be called and is exactly the same as defined previously, except for the bottom two fan-ins. The number of variables for will be denoted .
Note that and are polynomially related. We also redefine the first random projection that is applied to , in order to ensure that retains structure, while the quantum query algorithms become simple enough to be replaced by DNFs.
Definition 37 (Restriction for initial random projection).
The underlying random restriction on is defined as follows: independently for each
We will call this distribution on random restrictions as .
We first show in Lemma 38 (proof in full version) that the projection defined using on composition with the subsequent random projections of [13] completes to the uniform distribution on .
Lemma 38 (Analogue of Lemma 8.2 of [13]).
Let and , and let the string be defined as follows:
Then each bit of is independent and distributed uniformly at random.
The subsequent random projections applied to the function are the same as those of [13] (described formally in the full version). It was shown (in the proof of Proposition 8.4) in [13] that the subsequent (-2) random projections after (along with a suitably chosen distribution for the unrestricted variables) complete to the distribution . We state this formally in the full version. Therefore, we can conclude that the overall random projection completes to the uniform distribution, using Lemma 38.
For ease of writing, [13] use as notation for the resulting function after applying all the random projections sampled to a function . We define this formally in the full version.
Corollary 39 (Proposition 8.1 of [13]).
Consider be a circuit computing defined on variables. Let and (we assume that is even). If is sampled according to the sequence of projections,
We now show that as sampled above, results in a typical with high probability, in Lemma 40 and Lemma 41 (proof in full version).
Lemma 40 (Analogue of Lemma 10.3 of [13]).
Let so that . Then
Lemma 41 (Analogue of Lemma 10.4 of [13]).
Let so that . Then
Lemma 42 (Lemma 10.6 and Lemma 10.8 of [13]).
For , let be typical. Then is typical with probability at least .
On application of the overall sequence of random projections , the function becomes an OR of fan-in at most if is even, and an AND of fan-in at most otherwise. We will now assume that becomes an OR of fan-in at most , the case for AND is analogous. Then we sample the first (-2) restrictions and assume they are all typical, which happens with probability at least using Lemma 40, Lemma 41 and Lemma 42 and a union bound. We know from Definition 34 that the top OR gate of the function after applying the first (-2) projections is undetermined and has fan-in at least . [13] then show that in expectation over the final random projection, the bias of the projected function is close to 1/2 under the distribution .
Lemma 43 (Proposition 10.13 of [13]).
Let and be the random projection of when is sampled according to the sequence of projections. Then
Now we state and use the projection switching lemma of [13] (statement taken from their paper), to obtain our final circuit lower bound.
Theorem 44 (Proposition 9.2 of [13]).
Let and be a DNF/CNF of width . Then for all and ,
We want to use Theorem 44 (-2) times on the circuit obtained after applying the first random projection and replacing the layer of quantum circuits in a circuit with a small width DNF/CNF as per Corollary 31, to conclude that this circuit becomes a decision tree with high probability. Assuming that , we sample random restrictions same as that of [13], and use to denote the composition of the corresponding random projections. We define this formally in the full version.
Corollary 45 (Analogue of Proposition 9.13 of [13]).
For any constant , let be a depth- circuit which has or as output gate, with bottom fan-in and size . Then for any
Proof.
Apply Theorem 44 (-2) times on , with , along with a union bound on the number of gates in the bottom layer (at most ) for each application of Theorem 44. Finally, we can combine all the above ingredients to show the desired circuit lower bound for circuits in Theorem 46 (see full version for proof).
Theorem 46.
For any even constant , let be defined on variables. Let be any circuit of size , which has as its output gate. Then for a uniformly random input , we have
An analogous proof follows for the case when is odd, by replacing with (and with ) and flipping the values 0 and 1 in the relevant distributions. Note also that the function has bottom fan-in . Therefore, using Theorem 46, for every , we can conclude that relative to a random oracle , when is odd, and when is even. In particular, for every and relative to a random oracle , we have that . In addition, we can conclude that relative to a random oracle, is infinite (proof in full version).
Theorem 47.
With probability 1, a random oracle O satisfies for odd .
Corollary 48.
With probability 1, a random oracle O satisfies for even .
Proof.
Similar to Theorem 47, using the analogue of Theorem 46 for when is odd.
Corollary 49.
With probability 1, a random oracle satisfies for all , and therefore is infinite relative to .
Proof.
Follows from Theorem 47, Corollary 48 and collapse theorem for [3]. We discuss in the full version how our switching lemma for quantum query algorithms (Theorem 27) compares to the switching lemma (Theorem 65) from [1], and why the latter is not sufficient to establish our oracle separation result.
6 Oracle Separation for Hierarchy
In this section, we show that there exists an oracle such that the hierarchy (called ) is infinite, and no fixed level of hierarchy contains all of . We first redefine the function, which we will call . The function will be an AND-OR tree of depth (with AND gates at the bottom), and we will show that it can not be computed by a circuit corresponding to a machine. The exact parameters for and some properties of the function are given in the full version.
We will apply random projections. For , we sample random restrictions which acts on quantum query algorithms and which acts on DNFs. These are defined formally and some properties of the projections are shown in the full version.
A proof very similar to Proposition 8.4 of [13] (stated in full version) and Lemma 38 can then be used to conclude that this sequence of random projections sampled completes to the uniform distribution. More strongly, the proof of Proposition 8.4 of [13] tells us that for projections upto complete to the biased product distribution and projections upto complete to the biased product distribution. This fact will be useful later to be able to apply the projection switching lemma for quantum algorithms repeatedly.
In order to show that the formula retains structure after applying each random projection, we modify the definition of typical restrictions (Definition 34) slightly, to account for the new parameters. We state the formal definition in the full version. We then need to show that the sequence of projections applied is typical. It follows from Lemma 40 and Lemma 41 that is typical with probability at least . It follows from Lemma 42 that is typical, for (note that we have changed the fan-ins of the function and hence the definition of typical restriction, but the proof for Lemma 42 works to establish this as well). We then show (proof in the full version) that is typical with high probability, for . This proof is very similar to that of Lemma 42 and can be adapted to show typicality for as well.
Finally, we show an analogue of [10] for the hierarchy in Proposition 50 (proof in full version), to use a circuit lower bound to get an oracle separation result.
Proposition 50 (Analogue of [10]).
Let be some language decided by a verifier with oracle access to , and where each has size at most for inputs of length . Let where is composed times. Then for every , there is a circuit of size at most and depth , where the top layer is an OR gate and the layers alternate between OR gates of width , and quantum circuits of size with query complexity at most such that
where denotes the concatenation of bits of on all strings of length at most .
The proof for the depth-hierarchy theorem now follows very similarly to the proof for (or circuits) in Theorem 46. We noted earlier that the sequence of random projections completes to an appropriately biased product distribution at every level of the AND-OR tree, hence we can apply the projection switching lemma for quantum algorithms which works for arbitrary inner and outer product distributions. This switching lemma and the projection switching lemma for DNFs Theorem 44 by [13] are applied in an alternating manner to get a depth-hierarchy theorem (the projection switching lemma for quantum algorithms is applied for and the projection switching lemma for DNFs is applied for ). Then oracle separations analogous to the case for follow for using a standard diagonalization argument. Note however that now we will get an oracle separation between and relative to a random oracle (whereas for we got an oracle separation between and ).
References
- [1] Scott Aaronson, DeVon Ingram, and William Kretschmer. The acrobatics of BQP. In 37th Computational Complexity Conference, CCC, 2022. doi:10.4230/LIPIcs.CCC.2022.20.
- [2] Avantika Agarwal and Shalev Ben-David. Oracle separations for the quantum-classical polynomial hierarchy. CoRR, abs/2410.19062, 2024. doi:10.48550/arXiv.2410.19062.
- [3] Avantika Agarwal, Sevag Gharibian, Venkata Koppula, and Dorian Rudolph. Quantum Polynomial Hierarchies: Karp-Lipton, Error Reduction, and Lower Bounds. In 49th International Symposium on Mathematical Foundations of Computer Science (MFCS 2024), 2024. doi:10.4230/LIPIcs.MFCS.2024.7.
- [4] Anurag Anshu, Shalev Ben-David, and Srijita Kundu. On query-to-communication lifting for adversary bounds. In 36th Computational Complexity Conference, CCC, 2021. doi:10.4230/LIPIcs.CCC.2021.30.
- [5] Robert Beals, Harry Buhrman, Richard Cleve, Michele Mosca, and Ronald de Wolf. Quantum lower bounds by polynomials. J. ACM, 48(4):778–797, 2001. doi:10.1145/502090.502097.
- [6] Charles H. Bennett, Ethan Bernstein, Gilles Brassard, and Umesh Vazirani. Strengths and weaknesses of quantum computing. SIAM Journal on Computing, 26(5):1510–1523, October 1997. doi:10.1137/s0097539796300933.
- [7] Sreejata Kishor Bhattacharya. Aaronson-ambainis conjecture is true for random restrictions, 2024. doi:10.48550/arXiv.2402.13952.
- [8] Harry Buhrman and Ronald de Wolf. Complexity measures and decision tree complexity: a survey. Theor. Comput. Sci., 288(1):21–43, 2002. doi:10.1016/S0304-3975(01)00144-X.
- [9] Yuval Filmus, Hamed Hatami, Nathan Keller, and Noam Lifshitz. On the sum of the l1 influences of bounded functions, 2015. arXiv:1404.3396.
- [10] Merrick Furst, James B. Saxe, and Michael Sipser. Parity, circuits, and the polynomial-time hierarchy. Mathematical systems theory, 17(1):13–27, 1984. doi:10.1007/BF01744431.
- [11] Sevag Gharibian, Miklos Santha, Jamie Sikora, Aarthi Sundaram, and Justin Yirka. Quantum generalizations of the polynomial hierarchy with applications to QMA(2). Comput. Complex., 31(2):13, 2022. doi:10.1007/S00037-022-00231-8.
- [12] Johan Håstad. Almost optimal lower bounds for small depth circuits. In Proceedings of the 18th Annual ACM Symposium on Theory of Computing, pages 6–20. ACM, 1986. doi:10.1145/12130.12132.
- [13] Johan Håstad, Benjamin Rossman, Rocco A. Servedio, and Li-Yang Tan. An average-case depth hierarchy theorem for boolean circuits. J. ACM, 64(5):35:1–35:27, 2017. doi:10.1145/3095799.
- [14] Avishay Tal. Properties and applications of boolean function composition. In Innovations in Theoretical Computer Science, ITCS, pages 441–454. ACM, 2013. doi:10.1145/2422436.2422485.
