How hard is it to answer a question? As theoretical computer scientists, this query haunts us. We formalize a ‘question’ as a function on some input and ‘answering’ as running a finite procedure. This procedure might run on a Turing Machine, your cellphone, or a quantum computer. ‘Hard’ is quantified by use of resources such as energy, space or time. Unfortunately, the most popular notion of hardness — time complexity — is notoriously difficult to characterize in a quantum computing model. If we want to show what a model of computation can and can’t do, we must use a related, but simpler measure of complexity. For quantum computing this measure is quantum query complexity. This post explains quantum query complexity and lays the foundations for future entries that will introduce the lower bound technique of the (negative) adversary method, and show how it characterizes quantum query complexity through its connection to span programs.

In the query model, the input to our algorithm is given as a black-box (called the oracle).
We can only gain knowledge about the input by asking the oracle for individual bits. The input is a bit-string \( x \in D \subseteq \{0, 1\}^n \)
and the goal is to compute some function \(f : D \rightarrow \{0,1\}\).
If \(D = \{0,1\}^n\) then we call the function total. For simplicity, we only consider
decision problems (binary range), although the machinery has been developed
for functions over finite strings in arbitrary finite input and output alphabets.

The query complexity of a function is the minimum number of queries used by any circuit computing the function. For a two-sided error \(\epsilon\), we denote the query complexity by \(Q_\epsilon(f)\).
Since success amplification is straightforward, we abbreviate
further by setting \(Q(f) = Q_{1/3}(f)\). Similar measures exist for classical
algorithms, where this model is more frequently referred to as decision-tree
complexity. The usual notation is \(D(f)\) for deterministic query complexity, \(R(f)\)
for two-sided error (\(1/3\)) randomized query complexity, and \(C(f)\) for certificate
(or non-deterministic) complexity. We specify our model concretely, following [HS05]:

Quantum query model: formally

The memory of a quantum query algorithm is described by three Hilbert spaces (registers): the input
register, \(H_I\), which holds the input \(x \in D\), the query register, \(H_Q\),
which holds an integer \(1 \leq i \leq n\) and a bit \(b \in \{0,1\}\), and the working
memory, \(H_W\), which holds an arbitrary value. The query register and working
memory together form the memory accessible to the algorithm, denoted \(H_A\). The
unitaries that define the algorithm can only act on this space. The accessible
memory of a quantum query algorithm is initialized to a fixed state. On input \(x\)
the initial state of the algorithm is \(|x\rangle_I \otimes |1, 0\rangle_Q \otimes |0\rangle_W\).
The state of the algorithm then evolves through queries, which depend on the
input register, and accessible memory operators which do not.

A query is a unitary operator where the oracle answer is given in the phase.
We definite the operator \(O\) by its action on the basis state \(|x\rangle_I \otimes |i,b\rangle_Q\)
as

The accessible memory operator is an arbitrary unitary operation \(U\) on the
accessible memory \(H_A\). This operation is extended to act on the whole space by
interpreting it as \(I_I \otimes U\) and \(O\) is interpreted as \(O \otimes I_W\).
Thus the state of the algorithm on input \(x\) after \(t\) queries can be written as:

Where we noticed that the input register is left unchanged by the algorithm. The
output of a \(T\)-query algorithm is distributed according to the state of the
accessible memory \(|\psi^T_x\rangle\) and two projections \(\Pi_0\) and \(\Pi_1\) such
that \(\Pi_0 + \Pi_1 = I\) corresponding to the possible outcomes of a decision problem.
The probability that given input \(x\) the algorithm returns \(0\) is \(||\Pi_0|\psi^T_x\rangle||^2\)
and \(1\) is \(||\Pi_1|\psi^T_x\rangle||^2\). \(Q_\epsilon(f)\) is the minimum number of queries
made by an algorithm which outputs \(f(x)\) with probability \(1 – \epsilon\) for every \(x\).

Relations between models

For partial functions, the quantum query complexity can be exponentially smaller than randomized or deterministic query complexity [Sho95, BV97, Sim97, Aar10]. However, if the partial function is invariant under permuting inputs and outputs then the complexities are polynomially related with \(R(f) = O(Q(f)^9)\) [AA09]. If the function is total, then \(D(f)\) is bounded by \(O(Q(f)^6)\) ,
\(O(Q(f)^4)\) for monotone total functions, and \(O(Q(f)^2)\) for symmetric total functions [BBC+01]. However, no greater than quadratic separations are known for total functions (this separation is achieved by \(OR\), for example). This has led to the conjecture that for total functions \(D(f) = O(Q(f)^2)\). This conjecture is open for all classes of total functions, except monotone [BBC+01], read-once [BS04], and constant-sized 1-certificate functions.

The infamous time complexity is always at least as large as the query complexity since each query takes one unit step. For famous algorithms such as Grover’s search [Gro96] and Shor’s period finding (which is the quantum part of his famed polynomial time factoring algorithm) [Sho95], the time complexity is within poly-logarithmic factors of the query complexity. There are also exceptions to the tight correspondence. The Hidden Subgroup Problem has polynomial query complexity [EHK04], yet polynomial time algorithms are not known for the problem.

By taking the computation between queries as free, we get a handle for producing lower bounds. This allows us to develop strong information-theoretic techniques for lower bounding quantum query complexity. In my next post I will use this framework to develop the (negative) adversary method.