Quantum Query Complexity Research Articles

Upper Bounds on Quantum Query Complexity Inspired by the Elitzur--Vaidman Bomb Tester

Inspired by the Elitzur--Vaidman bomb testing problem (1993), we introduce a new query complexity model, which we call bomb query complexity, $B(f)$. We investigate its relationship with the usual quantum query complexity $Q(f)$, and show that $B(f)=\Theta(Q(f)^2)$. This result gives a new method to derive upper bounds on quantum query complexity: we give a method of finding bomb query algorithms from classical algorithms, which then provide non-constructive upper bounds on $Q(f)=\Theta(\sqrt{B(f)})$. Subsequently, we were able to give explicit quantum algorithms matching our new bounds. We apply this method to the single-source shortest paths problem on unweighted graphs, obtaining an algorithm with $O(n^{1.5})$ quantum query complexity, improving the best known algorithm of $O(n^{1.5}\log n)$ (Dürr et al. 2006, Furrow 2008). Applying this method to the maximum bipartite matching problem gives an algorithm with $O(n^{1.75})$ quantum query complexity, improving the best known (trivial) $O(n^2)$ upper bound. <! footnote> A conference version of this paper appeared in the Proceedings of the 30th Computational Complexity Conference, 2015.

Improved Quantum Query Algorithms for Triangle Detection and Associativity Testing

We show that the quantum query complexity of detecting if an n-vertex graph contains a triangle is $$O(n^{9/7})$$O(n9/7). This improves the previous best algorithm of Belovs (Proceedings of 44th symposium on theory of computing conference, pp 77---84, 2012) making $$O(n^{35/27})$$O(n35/27) queries. For the problem of determining if an operation $$\circ : S \times S \rightarrow S$$ź:S×SźS is associative, we give an algorithm making $$O(|S|^{10/7})$$O(|S|10/7) queries, the first improvement to the trivial $$O(|S|^{3/2})$$O(|S|3/2) application of Grover search. Our algorithms are designed using the learning graph framework of Belovs. We give a family of algorithms for detecting constant-sized subgraphs, which can possibly be directed and colored. These algorithms are designed in a simple high-level language; our main theorem shows how this high-level language can be compiled as a learning graph and gives the resulting complexity. The key idea to our improvements is to allow more freedom in the parameters of the database kept by the algorithm.

Application of Grover’s algorithm to check non-resiliency of a Boolean function

In this paper, we explore quantum algorithms to check the resiliency property of a Boolean function (in particular, when it is non-resilient). First we explain that Deutsch-Jozsa algorithm can be immediately used for this purpose. We further analyse how the quadratic improvement in query complexity can be obtained using Grover's technique. While the worst case quantum query complexity to check the resiliency order is exponential in the number of input variables of the Boolean function, in our strategy one requires polynomially many measurements only. We also describe a subset of n-variable Boolean functions for which the algorithm works in polynomially many steps, i.e., we can achieve an exponential speed-up over best known classical algorithms.

Explicit relation between all lower bound techniques for quantum query complexity

The polynomial method and the adversary method are the two main techniques to prove lower bounds on quantum query complexity, and they have so far been considered as unrelated approaches. Here, we show an explicit reduction from the polynomial method to the multiplicative adversary method. The proof goes by extending the polynomial method from Boolean functions to quantum state generation problems. In the process, the bound is even strengthened. We then show that this extended polynomial method is a special case of the multiplicative adversary method with an adversary matrix that is independent of the function. This new result therefore provides insight on the reason why in some cases the adversary method is stronger than the polynomial method. It also reveals a clear picture of the relation between the different lower bound techniques, as it implies that all known techniques reduce to the multiplicative adversary method.

A note on the quantum collision and set equality problems

A collision for a function $f$ is two distinct inputs $x_1\neq x_2$ such that $f$ outputs the same value on both inputs: $f(x_1)=f(x_2)$. The quantum query complexity of finding collisions has been shown~\cite{BHT1997,AS2004, Ambainis05, Kutin05} in some settings to be $\Theta(N^{1/3})$; however, these results do not apply to random functions. The issues are two-fold. First, the $\Omega(N^{1/3})$ lower bound only applies when the domain is no larger than the co-domain, which precludes many of the cryptographically interesting applications. Second, most of the results in the literature only apply to $r$-to-1 functions, which are quite different from random functions. Understanding the collision problem for random functions is of great importance to cryptography, and we seek to fill the gaps of knowledge for this problem. To that end, we prove that, as expected, a quantum query complexity of $\Theta(N^{1/3})$ holds for all interesting domain and co-domain sizes. Our proofs are simple, and combine existing techniques with several novel tricks to obtain the desired results. Using our techniques, we also give an optimal $\Omega(M^{1/3})$ lower bound for the set equality problem. This lower bound can be used to improve the relationship between classical randomized query complexity and quantum query complexity for so-called permutation-symmetric functions.

A note on the quantum collision and set equality problems

A collision for a function f is two distinct inputs x1 ≠ x2 such that f outputs the same value on both inputs: f(x1) = f(x2). The quantum query complexity of finding collisions has been shown [9, 2...

Quantum Algorithms for Learning Symmetric Juntas via the Adversary Bound

In this paper, we study the following variant of the junta learning problem. We are given oracle access to a Boolean function f on n variables that only depends on k variables, and, when restricted to them, equals some predefined function h. The task is to identify the variables the function depends on.When h is the XOR or the OR function, this gives a restricted variant of the Bernstein–Vazirani or the combinatorial group testing problem, respectively. We analyze the general case using the adversary bound and give an alternative formulation for the quantum query complexity of this problem. We construct optimal quantum query algorithms for the cases when h is the OR function (complexity is $${\Theta(\sqrt{k})}$$ ) or the exact-half function (complexity is $${\Theta(k^{1/4})}$$ ). The first algorithm resolves an open problem from Ambainis & Montanaro (Quantum Inf Comput 14(5&6): 439–453, 2014). For the case when h is the majority function, we prove an upper bound of $${O(k^{1/4})}$$ . All these algorithms can be made exact. We obtain a quartic improvement when compared to the randomized complexity (if h is the exact-half or the majority function), and a quadratic one when compared to the non-adaptive quantum complexity (for all functions considered in the paper).

Exact quantum algorithms have advantage for almost all Boolean functions

It has been proved that almost all n-bit Boolean functions have exact classical query complexity n. However, the situation seemed to be very different when we deal with exact quantum query complexity. In this paper, we prove that almost all n-bit Boolean functions can be computed by an exact quantum algorithm with less than n queries. More exactly, we prove that ANDn is the only n-bit Boolean function, up to isomorphism, that requires n queries.

Improving Quantum Query Complexity of Boolean Matrix Multiplication Using Graph Collision

The quantum query complexity of Boolean matrix multiplication is typically studied as a function of the matrix dimension, \(n\), as well as the number of \(1\)s in the output, \(\ell \). We prove an upper bound of \(\widetilde{\hbox {O}}(n\sqrt{\ell +1})\) for all values of \(\ell \). This is an improvement over previous algorithms for all values of \(\ell \). On the other hand, we show that for any \(\varepsilon < 1\) and any \(\ell \le \varepsilon n^2\), there is an \(\Omega (n\sqrt{\ell })\) lower bound for this problem, showing that our algorithm is essentially tight. We first reduce Boolean matrix multiplication to several instances of graph collision. We then provide an algorithm that takes advantage of the fact that the underlying graph in all of our instances is very dense to find all graph collisions efficiently. Using similar ideas, we also show that the time complexity of Boolean matrix multiplication is \(\tilde{O}(n\sqrt{\ell +1}+\ell \sqrt{n})\).

A quantum lower bound for distinguishing random functions from random permutations

The problem of distinguishing between a random function and a random permutation on a domain of size $N$ is important in theoretical cryptography, where the security of many primitives depend on the problem's hardness. We study the quantum query complexity of this problem, and show that any quantum algorithm that solves this problem with bounded error must make $\Omega(N^{1/5}/\polylog N)$ queries to the input function. Our lower bound proof uses a combination of the Collision Problem lower bound and Ambainis's adversary theorem.

On the Power of Non-adaptive Learning Graphs

We introduce a notion of the quantum query complexity of a certificate structure. This is a formalization of a well-known observation that many quantum query algorithms only require the knowledge of the position of possible certificates in the input string, not the precise values therein. Next, we derive a dual formulation of the complexity of a non-adaptive learning graph and use it to show that non-adaptive learning graphs are tight for all certificate structures. By this, we mean that there exists a function possessing the certificate structure such that a learning graph gives an optimal quantum query algorithm for it. For a special case of certificate structures generated by certificates of bounded size, we construct a relatively general class of functions having this property. The construction is based on orthogonal arrays and generalizes the quantum query lower bound for the k-sum problem derived recently by Belovs and ?palek (Proceeding of 4th ACM ITCS, 323---328, 2013). Finally, we use these results to show that the learning graph for the triangle problem by Lee et al. (Proceeding of 24th ACM-SIAM SODA, 1486---1502, 2013) is almost optimal in the above settings. This also gives a quantum query lower bound for the triangle sum problem.

How Low can Approximate Degree and Quantum Query Complexity be for Total Boolean Functions?

It has long been known that any Boolean function that depends on n input variables has both degree and exact quantum query complexity of Ω(log n), and that this bound is achieved for some functions. In this paper, we study the case of approximate degree and bounded-error quantum query complexity. We show that for these measures, the correct lower bound is Ω(log n/ log log n), and we exhibit quantum algorithms for two functions where this bound is achieved.

Uselessness for an Oracle model with internal randomness

We consider a generalization of the standard oracle model in which the oracle acts on the target with a permutation selected according to internal random coins. We describe several problems that are impossible to solve classically but can be solved by a quantum algorithm using a single query; we show that such infinity-vs-one separations between classical and quantum query complexities can be constructed from much weaker separations. We also give conditions to determine when oracle problems -- either in the standard model, or in any of the generalizations we consider -- cannot be solved with success probability better than random guessing would achieve. In the oracle model with internal randomness where the goal is to gain any nonzero advantage over guessing, we prove (roughly speaking) that k quantum queries are equivalent in power to 2k classical queries, thus extending results of Meyer and Pommersheim.

Uselessness for an oracle model with internal randomness

We consider a generalization of the standard oracle model in which the oracle acts on the target with a permutation selected according to internal random coins. We describe several problems that are impossible to solve classically but can be solved by a quantum algorithm using a single query; we show that such infinity-vs-one separations between classical and quantum query complexities can be constructed from much weaker separations. We also give conditions to determine when oracle problems--either in the standard model, or in any of the generalizations we consider--cannot be solved with success probability better than random guessing would achieve. In the oracle model with internal randomness where the goal is to gain any nonzero advantage over guessing, we prove (roughly speaking) that k quantum queries are equivalent in power to 2k classical queries, thus extending results of Meyer and Pommersheim.

Span Programs are Equivalent to Quantum Query Algorithms

Span programs form a linear-algebraic model of computation that is studied to prove classical lower bounds. Quantum query complexity is a coherent generalization for quantum algorithms of decision-tree complexity. It is characterized by a semidefinite program known as the general adversary bound. We connect these classical and quantum models by proving that for any boolean function, the optimal “witness size” of a span program equals the general adversary bound. Therefore, span program witness size and quantum query complexity are equivalent measures. In particular, quantum algorithms can be designed based on span programs.

The Need for Structure in Quantum Speedups

Is there a general theorem that tells us when we can hope for exponential speedups from quantum algorithms, and when we cannot? In this paper, we make two advances toward such a theorem, in the black-box model where most quantum algorithms operate. First, we show that for any problem that is invariant under permuting inputs and outputs (like the collision or the element distinctness problems), the quantum query complexity is at least the 9 th root of the classical randomized query complexity. This resolves a conjecture of Watrous from 2002. Second, inspired by recent work of O’Donnell et al. and Dinur et al., we conjecture that every bounded low-degree polynomial has a “highly influential” variable. Assuming this conjecture, we show that every T-query quantum algorithm can be simulated on most inputs by a poly(T)query classical algorithm, and that one essentially cannot hope to prove P 6 BQP relative to a random oracle.

RECOVERING STRINGS IN ORACLES: QUANTUM AND CLASSIC

Recovering unknown inputs in oracles with as few queries as possible is one of the most basic problems in theoretical computer science. In this paper, we survey the classical and quantum query complexity of this problem for various types of oracles with different types of queries.

On Exact Quantum Query Complexity

We present several families of total boolean functions which have exact quantum query complexity which is a constant multiple (between 1/2 and 2/3) of their classical query complexity, and show that optimal quantum algorithms for these functions cannot be obtained by simply computing parities of pairs of bits. We also characterise the model of nonadaptive exact quantum query complexity in terms of coding theory and completely characterise the query complexity of symmetric boolean functions in this context. These results were originally inspired by numerically solving the semidefinite programs characterising quantum query complexity for small problem sizes. We include numerical results giving the optimal success probabilities achievable by quantum algorithms computing all boolean functions on up to 4 bits, and all symmetric boolean functions on up to 6 bits.

A strong direct product theorem for quantum query complexity

We show that quantum query complexity satisfies a strong direct product theorem. This means that computing k copies of a function with fewer than k times the quantum queries needed to compute one copy of the function implies that the overall success probability will be exponentially small in k. For a boolean function f, we also show an XOR lemma—computing the parity of k copies of f with fewer than k times the queries needed for one copy implies that the advantage over random guessing will be exponentially small. We do this by showing that the multiplicative adversary method, which inherently satisfies a strong direct product theorem, characterizes bounded-error quantum query complexity. In particular, we show that the multiplicative adversary bound is always at least as large as the additive adversary bound, which is known to characterize bounded-error quantum query complexity.

Quantum Adversary (Upper) Bound

We describe a method to upper bound the quantum query complexity of Boolean formula evaluation problems, using fundamental theorems about the general adversary bound. This nonconstructive method can give an upper bound on query complexity without producing an algorithm. For example, we describe an oracle problem which we prove (non-constructively) can be solved in $O(1)$ queries, where the previous best quantum algorithm uses a polylogarithmic number of queries. We then give an explicit $O(1)$-query algorithm for this problem based on span programs.