Lower bounds for randomized and quantum query complexity
using Kolmogorov arguments
Abstract
We prove a very general lower bound technique for quantum and randomized query complexity, that is easy to prove as well as to apply. To achieve this, we introduce the use of Kolmogorov complexity to query complexity. Our technique generalizes the weighted, unweighted methods of Ambainis, and the spectral method of Barnum, Saks and Szegedy. As an immediate consequence of our main theorem, adversary methods can only prove lower bounds for boolean functions in , where is the certificate complexity, and is the size of the input. We also derive a general form of the ad hoc weighted method used by Høyer, Neerbek and Shi to give a quantum lower bound on ordered search and sorting.
1 Introduction
1.1 Overview
In this paper, we study lower bounds for randomized and quantum query complexity. In the query model, the input is accessed using oracle queries, and the query complexity of an algorithm is the number of calls to the oracle. Since it is difficult to obtain lower bounds on time directly, the query model is often used to prove concrete lower bounds, in classical as well as quantum computation.
The two main tools for proving lower bounds of randomized query complexity, the polynomial method [BBC01] and the adversary method [Amb02], were successfully extended to quantum computation. In the randomized setting, the adversary method is most often applied using Yao’s minimax principle [Yao77]. Using a different approach, which introduces the notion of quantum adversaries, Ambainis developed a general scheme in which it suffices to analyze the combinatorial properties of the function in order to obtain a quantum lower bound. Recently, Aaronson [Aar03] brought these combinatorial properties back to randomized computation, using Yao’s minimax principle.
The most general method for proving lower bounds in quantum query complexity is the semidefinite programming method of Barnum, Saks and Szegedy [BSS03]. This method is in fact an exact characterization of the query complexity. However, the method is so general as to be very difficult to apply to obtain concrete lower bounds. Barnum, Saks and Szegedy gave a weaker method derived from the semidefinite programming approach, using weight matrices and their largest eigenvalue. This spectral method can be thought of as a generalization of Ambainis’ unweighted method. Other generalizations of Ambainis’ unweighted method have been previously introduced [BS02, Amb03]. All of them use a weight function on the instances. The difficulty in applying these methods is finding a good weight function on the instances. Høyer, Neerbek and Shi [HNS02] were the first to use such weight assignments to prove lower bounds for searching in ordered lists and sorting. Their ad hoc method, though similar in many respects, does not fall into setting of the weighted method of Ambainis [Amb03].
This paper presents a new, very general adversary technique (Theorem 1) to prove lower bounds in quantum and randomized query complexity. We believed that this technique is simpler to prove and to apply. It is based on the framework of Kolmogorov complexity. This framework has proven to be very useful for proving negative results in other models of computation, for example for number of rounds and length of advice in randomselfreductions in [FFLN98, BL99]. The techniques we use here are an adaptation of those techniques to the framework of query complexity. We expect that this framework will not only prove to be useful for negative results in other quantum models of computation, for instance, communication complexity, but also for finer analysis of query complexity in terms of the number of rounds of queries.
The proof of Theorem 1 is in two parts. The first part (Divergence Lemma) shows how fast the computations can diverge when they start on different inputs. This part depends on the model of computation (randomized or quantum). The quantum case of this lemma was first proven by Ambainis [Amb02]. The second part (Query Information Lemma) does not depend on the model of computation. It establishes the relationship between the Kolmogorov complexity of individual positions of the input, and the probability that a given algorithm makes a query to this position. Whereas Aaronson [Aar03] used a different approach to prove a version of Ambainis’ method for randomized algorithms, here we use the same framework to establish lower bounds for both quantum and randomized query complexities ( and ).
We show that our method encompasses all previous adversary methods, including the quantum and randomized weighted methods [Amb03, Aar03] (Theorem 2) and the spectral method [BSS03] (Theorem 3). As an immediate consequence of our main theorem (observed by Troy Lee), our method can only prove lower bounds for boolean functions in , where and is the certificate complexity of negative and positive instances, respectively, of , and is the size of the input (Theorem 4). Prior to our work, it was known [Amb03] that the unweighted Ambainis method [Amb02, Theorem 5.1] could not prove bounds better than ; Szegedy [Sze03] also proved independently that the semidefinite programming method could not prove lower bounds better than , and Zhang [Zha03] proved the same thing for Ambainis’ weighted method.
We also give a generalization (Theorem 5) of the ad hoc proofs of Høyer, Neerbek and Shi [HNS02] as a corollary of our method. For this we introduce a new distance scheme. This new scheme separates the quantum part from the combinatorial part of these ad hoc proofs. Using it, we prove the lower bound of [HNS02] using only combinatorial arguments. We end the paper by giving some applications of our method to prove lower bounds for some graph properties: bipartiteness (Theorem 6) and connectivity (Theorem 7). This lower bounds were proven in [DHH03]. We reprove them here to illustrate the simplicity of our method.
1.2 Main result
Our main result is stated below.
Theorem 1.
There exists a constant such that the following holds. Let be a finite set, let be an integer, and let and be sets. Let . Let be an algorithm that for all computes , with bounded error and at most queries to the input. Then for every with :

If is a quantum algorithm then

If is a randomized algorithm then
We briefly describe the intuition behind the proof of Theorem 1. Consider an algorithm that purports to compute , presented with two inputs that lead to different outputs. The algorithm must query those positions where and differ with average probability of the order of , or it will not successfully compute the function. On the other hand, the queries that are made with high average probability can be described succinctly given the input and the algorithm, using the ShannonFano code. If we exhibit a pair of strings for which there is no succinct description of any of the positions where and differ, then the number of queries must be large.
The same reasoning can be applied to classical and to quantum computing; the only difference is how fast two different input states cause the outputs to diverge to different outcomes.
To conclude the introduction we give a very simple application, for Grover search.
Example 1.
Fix and a quantum algorithm for Grover search for instances of length . Let be a binary string of length , with . Let be the integer between and whose binary expansion is . Consider , the all ’s string, and let be everywhere except at position , where it is . Then and , therefore, .
2 Preliminaries
2.1 Kolmogorov complexity
We use a few standard results in Kolmogorov complexity and information theory in this paper. We briefly review these here. The reader is invited to consult standard textbooks such as [LV97] for more background on Kolmogorov complexity, and [CT91] for more on information theory. We denote the length of a finite string by . We assume that the Turing machine’s alphabet is the same finite alphabet as the alphabet used to encode instances of the function under consideration. Letters typically represent instances; is an index into the representation of the instance; and are probability distributions. Programs are denoted , and the output of a Turing machine on input is written . When there are multiple inputs, we assume that a standard encoding of tuples is used.
Definition 1.
Let be a Turing machine. Let and be finite strings.

The Kolmogorov complexity of given with respect to is denoted , and defined as follows:

A set of strings is prefixfree if no string is a prefix of another in the set.

The prefixfree Kolmogorov complexity of given with respect to is denoted , and defined as follows:
where is taken in some fixed prefixfree set.
In the rest of the paper is some fixed universal Turing machine, and we will write and instead of and . When is the empty string, we write instead of .
Proposition 1.
There exists a constant such that for every finite string ,
Proposition 2 (Kraft’s inequality).
Let be any prefixfree set of finite strings. Then
Proposition 3 (Shannon’s coding theorem).
Consider a source of finite strings where occurs with probability . Then for any code for , the average code length is bounded below by the entropy of the source, that is, if is encoded by the code word of length , .
Lemma 1.
Let be a source as above. Then for any fixed finite string , there exists a string such that and .
Proof.
By Shannon’s coding theorem,
because is the length of an encoding of . Therefore there exists such that and ∎
The ShannonFano code is a prefixfree code that encodes each word with , using bits. We will write to simplify notation. The code can easily be computed given a description of the probability distribution. This allows us to write the following proposition, where means the prefixfree Kolmogorov complexity of given a finite description of .
Proposition 4 (ShannonFano code).
There exists a constant , such that for every source as above, for all such that , .
We shall also use the following bound on conditional Kolmogorov complexity.
Proposition 5.
There is a constant such that for any three strings ,
Proof.
Using [LV97, Theorem 3.9.1, page 232], there is a constant such that
Substituting for and for :
which gives the result. ∎
2.2 Randomized and quantum query models
The quantum query model was implicitly introduced by Deutsch, Jozsa, Simon and Grover [Deu85, DJ92, Sim97, Gro96], and explicitly by Beals, Buhrman, Cleve, Mosca and de Wolf [BBC01]. In this model, as in its classical counterpart, we pay for accessing the oracle, but unlike the classical case, the machine can use the power of quantum parallelism to make queries in superposition. Access to the input , where is a finite set, is achieved by way of a query operator . The query complexity of an algorithm is the number of calls to .
The state of a computation is represented by a register composed of three subregisters: the query register , the answer register and the work register . We denote a register using the ket notation , or simply . In the quantum (resp. randomized) setting, the state of the computation is a complex (resp. nonnegative real) combination of all possible values of the registers. Let denote the corresponding finitedimensional vector space. We denote the state of the computation by a vector over the basis . Furthermore, the state vectors are unit length for the norm in the quantum setting, and for the norm in the randomized setting.
A query algorithm is specified by a uple of matrices. When is quantum (resp., randomized), the matrices are unitary (resp., stochastic). The computation takes place as follows. The query operator is the unitary (resp. stochastic) matrix that satisfies , for every , where by convention . Initially the state is set to some fixed value . Then the sequence of transformations is applied.
We say that the algorithm computes a function , for some sets and , if the observation of the last bits of the work register equals with probability at least , for every . Then (resp. ) is the minimum query complexity of quantum (resp. randomized) query algorithms that compute , where is a fixed positive constant no greater than .
3 Proof of the main theorem
This section is devoted to the proof of the main theorem. We prove Theorem 1 in two main steps. Lemma 2 shows how fast the computations diverge when they start on different individual inputs, in terms of the query probabilities. This lemma depends on the model of computation. Lemma 3 establishes the relationship between the Kolmogorov complexity of individual positions of the input, and the probability that a given algorithm makes a query to this position. This lemma is independent of the model of computation. Theorem 1 follows immediately by combining these two lemmas.
In the following two lemmas, let be an bounded error algorithm for that makes at most queries to the input. Let be the probability that queries at query on input , and let be the average query probability over all the time steps up to time . We assume henceforth without loss of generality that . (For example, we start by uniformly querying all positions and reverse the process.)
Lemma 2 (Divergence Lemma).
For every input such that the following holds.

For quantum algorithms:

For randomized algorithms:
We defer the proof of Lemma 2 to the end of this section.
The next lemma relates the query probabilities to the Kolmogorov complexity of the strings. In this lemma and the results that follow, we assume that a finite description of the algorithm is given. Using the knowledge of , we may assume without loss of generality that the function that it computes is also given, as is the length of the inputs. With additional care, the additive constants in all of the proofs can be made very small by adding to the auxiliary information made available to the description algorithms, those constantsize programs that are described within the proofs.
Lemma 3 (Query Information Lemma).
There exists an absolute constant such that for every input and position ,
Proof.
We describe the program that prints given and . Given , use and to compute the probabilities . This can be done in a finite number of steps because the number of queries is bounded by . The program includes a hard coded copy of the encoding of under the ShannonFano code for this probability distribution. Decode this and print . ∎
From these two lemmas we derive the main theorem.
Proof of Theorem 1.
We now give the proof of Lemma 2. The proof of the quantum case is very similar to the proofs found in many papers which give quantum lower bounds on query complexity. To our knowledge, the randomized case is new despite the simplicity of its proof. Whereas Aaronson [Aar03] used a different approach to prove a version of Ambainis’ method for randomized algorithms, our lemma allows us to use the same framework to establish lower bounds for both quantum and randomized query complexities.
Proof of Lemma 2.
Let be the state of the bounded error algorithm just before the th oracle query, on input . By convention, is the final state. When is a quantum algorithm is a unit vector for the norm; otherwise it is a probabilistic distribution, that is, a nonnegative and unit vector for the norm. Observe that the distance is the total variation distance.
First we prove the quantum case. Initially, the starting state of does not depend on the input, thus before the first question we have , so . At the end of the computation, if the algorithm is correct with probability , then . At each time step, we consider how much the two states can diverge.
Claim 1.
Over time steps, the two states diverge as follows. The proof uses only Claim 1 and the CauchySchwartz inequality.
Now we prove the randomized case. Again, initially . At the end of the computation, if the algorithm is correct with probability , then . At each time step, the distribution states now diverge according the following claim.
Claim 2.
4 Comparison with previous adversary methods
In this section, we reprove, as a corollary of Theorem 1, the previously known adversary lower bounds. Our framework also allows us to obtain somewhat stronger statements for free.
To obtain the previously known adversary methods as a corollary of Theorem 1, we must give a lower bound on terms and . To this end, we apply Proposition 5, and give a lower bound on , and upper bounds on and . The lower bound is obtained by applying Lemma 1, a consequence of Shannon’s coding theorem, for an appropriate distribution. The upper bounds are obtained using the ShannonFano code, for appropriate distributions.
The following lemma is the general formulation of the sketch above.
Lemma 4.
There exists a constant such that the following holds. Let be a finite set, let be an integer, and let . Let be a probability distribution on , let be a probability distribution on and let be a set of probability distributions on . Then for every finite string , there exist with , such that
provided that whenever or , or or for some such that .
Proof.
In this proof, are some appropriate nonnegative constants. By Lemma 1, there exists a pair such that and
where stands for a complete description of all the .
4.1 Ambainis’ weighted scheme
Theorem 2 (Ambainis’ weighted method).
Let be a finite set, let be an integer, and let and be sets. Let . Consider a weight scheme as follows:

Every pair is assigned a nonnegative weight such that whenever .

Every triple is assigned a nonnegative weight such that whenever or .
For all , let and . If for all such that , then
Furthermore, if for all such that , then
The relation in Ambainis’ original statement is implicit in this formulation, since it corresponds to the nonzeroweight pairs. A weaker version of the randomized case was proven independently by Aaronson [Aar03] using a completely different approach. We show that Theorem 2 follows from Theorem 1.
Proof.
We derive probability distributions from the weight schemes as follows. Let in
It is easy to check that by construction and hypothesis, these distributions satisfy the conditions of Lemma 4. Rearranging and simplifying the terms allows us to conclude. ∎
We conclude this section by sketching the proof of the unweighted version of Ambainis’ adversary method, as it affords a simpler combinatorial proof, that does not require Lemma 4. To simplify notation we omit additive constants and the usual auxiliary strings including .
Let , be a relation on pairs of instances, where , and let be the restriction of to pairs for which . Viewing the relation as a bipartite graph, let be as follows.

is a lower bound on the degree of all ,

is a lower bound on the degree of all ,

for any fixed and , the number of adjacent to for which is at most ,

for any fixed and , the number of adjacent to for which is at most .
We make the following observations.

, so

and , for all .

and similarly, .
4.2 Spectral lower bound
We now show how to prove the spectral lower bound of Barnum, Saks ans Szegedy [BSS03] as a corollary of Theorem 1. Recall that for any matrix , is the largest eigenvalue of .
Theorem 3 (BarnumSaksSzegedy spectral method).
Let be a finite set, let be an integer, and let and be sets. Let . Let be an arbitrary nonnegative real symmetric matrix that satisfies whenever . For let be the matrix:
Then
Proof.
Let (resp. ) be the unit eigenvector of (resp. ) with nonnegative entries and whose eigenvalue is (resp. ). We define the probability distributions as follows. Let in
By construction these distributions satisfy the conditions of Lemma 4, which suffices to conclude. ∎
5 Certificate complexity and adversary techniques
Let be a boolean function. For any positive instance of (), a positive certificate for is the smallest subset of indices of , such that for any with for all , .
The certificate complexity of , denoted , is the size of the largest positive certificate for , over all positive instances . The certificate complexity is defined similarly for negative instances of ().
Prior to our work, it was known that the best possible bound that could be proven using the unweighted adversary technique [Amb02, Theorem 5.1] is . Independently, Szegedy [Sze03] showed that the best possible lower bound using the spectral method is , and Zhang [Zha03] proved the same for Ambainis’ weighted method.
The following lemma, due to Troy Lee, results in a very simple proof of the fact that our method, and hence, all the known variants of the adversary method, cannot prove lower bounds larger than .
Lemma 5.
There exists a constant such that the following holds. Let be a finite set, let be an integer, and let be a set. Let . For every with and , there is an with for which , and similarly, there is a with such that .
Proof.
Let be the lexicographically smallest certificate for . Since , and must differ on some . To describe given , it suffices to give an index into , which requires bits. The same can also be done with and reversed. ∎
Theorem 4.
Let be a finite set, let be an integer, and let be a set. Let . Then any quantum query lower bound for given by Theorem 1 is in
6 Applications
6.1 A general method for distance schemes
We generalize the technique of Høyer, Neerbek and Shi [HNS02], which they used to prove lower bounds on ordered search and sorting. Though their technique is similar, it does not appear to be a special case of the weighted adversary method.
Here, we restrict ourselves to those weight functions that take values of the form , for integer values . Therefore, instead of a weight function, we consider an integer function , which may be thought of as a distance function on pairs of instances (even though it is not the case in general). We will define the load of an instance , to be the maximum number of instances at distance from , for any . This will allow us to bound the complexity of printing , given and . (In the case of ordered search, the load will be for all instances.)
More formally, for any nonnegative integer function on pairs , we define the right load to be the maximum over all values , of the number of such that and . The left load is defined similarly, inverting and .
Theorem 5.
Let be a finite set, let be an integer, and let and be sets. Let . Let be a nonnegative integer function on such that whenever . Let . Then
Proof.
We use a variation on Lemma 4. We define probability distributions whenever and otherwise; . Fix to be the string containing a description of and , where is a complete description of the distance function, and where we assume that includes a description of , hence and are also given.
We give an upper bound on the terms and directly, using left and right loads. Given and some integer , there are at most instances such that and . Therefore
where is some constant, The same is true for :
Now, we conclude following the same sketch as the proof of Lemma 4. ∎
We reprove some of the lower bounds of Høyer, Neerbek and Shi. The distance schemes we use are exactly the ones of [HNS02]. Whereas they did not separate the quantum part from the combinatorial part in their proofs, here we only need to evaluate the combinatorial objects and to get the results.
Corollary 1.
Proof.
Fix . We only consider the set of instances of length of the form . Note that . Define distance for pairs as , and for all other instances, where and with . The inverse distance has total weight . Furthermore, for every such that and , . The result follows by Theorem 5. ∎
A lower bound for sorting [HNS02] in the comparison model can also be obtained by applying Theorem 5.
Corollary 2.
Proof.
Fix . An input is an comparison matrix defined by if , and otherwise, where is some permutation of . (In the usual array representation, the element of rank in the array would be stored at position .) The set of inputs is .
We consider pairs of instances , where is obtained from by changing the value of the element of rank to a value that immediately precedes the element of rank in . This changes the rank of the elements of intermediate rank, incrementing their rank by one.
More formally, define , for . For every permutations we let if there exists such that , and otherwise. Observe that whenever , the comparison matrices and differ only in entries and , for .
Then for every