Upper bounds on quantum query complexity inspired by the ElitzurVaidman bomb tester
Abstract
Inspired by the ElitzurVaidman bomb testing problem [elitzur1993], we introduce a new query complexity model, which we call bomb query complexity . We investigate its relationship with the usual quantum query complexity , and show that .
This result gives a new method to upper bound the quantum query complexity: we give a method of finding bomb query algorithms from classical algorithms, which then provide nonconstructive upper bounds on . We subsequently were able to give explicit quantum algorithms matching our upper bound method. We apply this method on the singlesource shortest paths problem on unweighted graphs, obtaining an algorithm with quantum query complexity, improving the best known algorithm of [furrow2008]. Applying this method to the maximum bipartite matching problem gives an algorithm, improving the best known trivial upper bound.
1 Introduction
Quantum query complexity is an important method of understanding the power of quantum computers. In this model we are given a blackbox containing a boolean string , and we would like to calculate some function with as few quantum accesses to the blackbox as possible. It is often easier to give bounds on the query complexity than to the time complexity of a problem, and insights from the former often prove useful in understanding the power and limitations of quantum computers. One famous example is Grover’s algorithm for unstructured search [grover1997]; by casting this problem into the query model it was shown that queries was required [bbbv1997], proving that Grover’s algorithm is optimal.
Several methods have been proposed to bound the quantum query complexity. Upper bounds are almost always proven by finding better query algorithms. Some general methods of constructing quantum algorithms have been proposed, such as quantum walks [ambainis2003, szegedy2004, magniez2006, jeffery2012] and learning graphs [belovs2011]. For lower bounds, the main methods are the polynomial method [beals1998] and adversary method [ambainis2000]. In particular, the general adversary lower bound [hoyer2007] has been shown to tightly characterize quantum query complexity [reichardt2009, reichardt2011, lee2010], but calculating such a tight bound seems difficult in general. Nevertheless, the general adversary lower bound is valuable as a theoretical tool, for example in proving composition theorems [reichardt2011, lee2010, kimmel2013] or showing nonconstructive (!) upper bounds [kimmel2013].
Our work
To improve our understanding of quantum query complexity, we introduce and study an alternative oracle model, which we call the bomb oracle (see Section LABEL:sect:bomb_query for the precise definition). Our model is inspired by the concept of interaction free measurements, illustrated vividly by the ElitzurVaidman bomb testing problem [elitzur1993], in which a property of a system can be measured without disturbing the system significantly. Like the quantum oracle model, in the bomb oracle model we want to evaluate a function on a hidden boolean string while querying the oracle as few times as possible. In this model, however, the bomb oracle is a controlled quantum oracle with the extra requirement that the algorithm fails if the controlled query returns a 1. This seemingly impossible task can be tackled using the quantum Zeno effect [misra1977], in a fashion similar to the ElitzurVaidman bomb tester [kwiat1995] (Section 2.1).
Our main result (Theorem LABEL:thm:main_result) is that the bomb query complexity, , is characterized by the square of the quantum query complexity :
Theorem LABEL:thm:main_result.
(1.1) 
We prove the upper bound, (Theorem LABEL:thm:upperbound), by adapting Kwiat et al.’s solution of the ElitzurVaidman bomb testing problem (Section 2.1, [kwiat1995]) to our model. We prove the lower bound, (Theorem LABEL:thm:lowerbound), by demonstrating that is lower bounded by the square of the general adversary bound [hoyer2007], . The aforementioned result that the general adversary bound tightly characterizes the quantum query complexity [reichardt2009, reichardt2011, lee2010], , allows us to draw our conclusion.
This characterization of Theorem LABEL:thm:main_result allows us to give nonconstructive upper bounds to the quantum query complexity for some problems. For some functions a bomb query algorithm is easily designed by adapting a classical algorithm: specifically, we show that (stated informally):
Theorem LABEL:thm:classical (informal).
Suppose there is a classical algorithm that computes in queries, and the algorithm guesses the result of each query (0 or 1), making no more than an expected mistakes for all . Then we can design a bomb query algorithm that uses queries, and hence . By our characterization of Theorem LABEL:thm:main_result, .
This result inspired us to look for an explicit quantum algorithm that reproduces the query complexity . We were able to do so:
Theorem LABEL:thm:classical_to_quantum.
Under the assumptions of Theorem LABEL:thm:classical, there is an explicit algorithm (Algorithm LABEL:alg:classical) for with query complexity .
Using Algorithm LABEL:alg:classical, we were able to give an algorithm for the singlesource shortest paths (SSSP) problem in an unweighted graph with vertices, beating the bestknown algorithm [furrow2008]. A more striking application is our algorithm for maximum bipartite matching; in this case the bestknown upper bound was the trivial , although the time complexity of this problem had been studied in [ambainis2006] (and similar problems in [dorn2008]).
Finally, in Section LABEL:sect:projective_query we briefly discuss a related query complexity model, which we call the projective query complexity , in which each quantum query to is immediately followed by a classical measurement of the query result. This model seems interesting to us because its power lies between classical and quantum: we observe that and , where is the classical randomized query complexity. We note that Regev and Schiff [regev2008] showed that .
Past and related work
Mitchison and Jozsa have proposed a different computational model called counterfactual computation [mitchison2001], also based on interactionfree measurement. In counterfactual computation the result of a computation may be learnt without ever running the computer. There has been some discussion on what constitutes counterfactual computation; see for example [hosten2006, mitchison2006, hosten20062, vaidman2006, hosten20063, salih2013, vaidman2013].
There have also been other applications of interactionfree measurement to quantum cryptography. For example, Noh has proposed counterfactual quantum cryptography [noh2009], where a secret key is distributed between parties, even though a particle carrying secret information is not actually transmitted. More recently, Brodutch et al. proposed an adaptive attack [brodutch2014] on Wiesner’s quantum money scheme [wiesner1983]; this attack is directly based off Kwiat et al.’s solution of the ElitzurVaidman bomb testing problem [kwiat1995].
Our Algorithm LABEL:alg:classical is very similar to Kothari’s algorithm for the oracle identification problem [kothari2014], and we refer to his analysis of the query complexity in our work.
The projective query model we detail in Section LABEL:sect:projective_query was, to our knowledge, first considered by Aaronson in unpublished work in 2002 [aaronson2014].
Discussion and outlook
Our work raises a number of open questions. The most obvious ones are those pertaining to the application of our recipe for turning classical algorithms into bomb algorithms, Theorem LABEL:thm:classical:

Can we generalize our method to handle nonboolean input and output? If so, we might be able to find better upper bounds for the adjacencylist model, or to study graph problems with weighted edges.

Can our explicit (through Theorem LABEL:thm:classical_to_quantum) algorithm for maximum bipartite matching be made more time efficient? The best known quantum algorithm for this task has time complexity in the adjacency matrix model [ambainis2006].

Finally, can we find more upper bounds using Theorem LABEL:thm:classical? For example, could the query complexity of the maximum matching problem on general nonbipartite graphs be improved with Theorem LABEL:thm:classical, by analyzing the classical algorithm of Micali and Vazirani [micali1980]?
Perhaps more fundamental, however, is the possibility that the bomb query complexity model will help us understand the relationship between the classical randomized query complexity, , and the quantum query complexity . It is known [beals1998] that for all total functions , ; however, there is a longstanding conjecture that actually . In light of our results, this conjecture is equivalent to the conjecture that . Some more open questions, then, are the following:

Can we say something about the relationship between and for specific classes of functions? For example, is for total functions?

Referring to the notation of Theorem LABEL:thm:classical, we have . Is the quantity related to other measures used in the study of classical decisiontree complexity, for example the certificate complexity, sensitivity [cook1986], block sensitivity [nisan1991], or (exact or approximate) polynomial degree? (For a review, see [buhrman1999].)

What about other query complexity models that might help us understand the relationship between and ? One possibility is the projective query complexity, , considered in Section LABEL:sect:projective_query. Regev and Schiff [regev2008] have shown (as a special case of their results) that even with such an oracle, queries are needed to evaluate the OR function.
We hope that further study on the relationship between bomb and classical randomized complexity will shed light on the power and limitations of quantum computation.
2 Preliminaries
2.1 The ElitzurVaidman bomb testing problem
The ElitzurVaidman bomb testing problem [elitzur1993] is a wellknown thought experiment to demonstrate how quantum mechanics differs drastically from our classical perceptions. This problem demonstrates dramatically the possibility of interaction free measurements, the possibility of a measurement on a property of a system without disturbing the system.
The bombtesting problem is as follows: assume we have a bomb that is either a dud or a live bomb. The only way to interact with the bomb is to probe it with a photon: if the bomb is a dud, then the photon passes through unimpeded; if the bomb is live, then the bomb explodes. We would like to determine whether the bomb is live or not without exploding it. If we pass the photon through a beamsplitter before probing the bomb, we can implement the controlled probe, pictured below: