Quantum Approximate Counting with Nonadaptive Grover Iterations

A famous, textbook algorithm in quantum computing is Grover Search [6], which solves the following task: Given is a quantum oracle for a function $f:[N]\to\{0,1\}$, where queries for $f(x)$ may be made in quantum superposition. It is promised that $K=\#\{x:f(x)=1\}$ is exactly $1$. The task is to find $x^{*}$ such that $f(x^{*})=1$. Grover Search solves this problem (with high probability) using $O(\sqrt{N})$ queries.

The algorithm is particularly simple: First, a state $\ket{s}$ equal to the uniform superposition over all $\ket{x}$ is prepared; this state makes an angle of $\arccos\sqrt{1/N}$ with $\ket{x^{*}}$. We write $\ket{x^{*}}^{\bot}$ for the state perpendicular to $\ket{x^{*}}$ making an angle of $\theta^{*}=\arcsin\sqrt{1/N}$ with $\ket{s}$. Then the algorithm repeatedly performs Grover iterations, each of which consists of one query followed by the simple “Grover diffusion” operation. The effect of a Grover iteration is to rotate $\ket{s}$ by an angle of $2\theta^{*}$; thus after $r$ rotations the angle of $\ket{s}$ from $\ket{x^{*}}^{\bot}$ is $(2r+1)\theta^{*}$. Setting $r\approx\tfrac{\pi}{4}\sqrt{N}$, the algorithm makes $O(\sqrt{N})$ queries and ends up with a state at angle approximately $\tfrac{\pi}{2}$ from $\ket{x^{*}}^{\bot}$; measuring then results in $\ket{x^{*}}$ with probability $\sin^{2}((2r+1)\theta^{*})\approx\sin^{2}\tfrac{\pi}{2}=1$.

In this form the algorithm relies on the assumption $K=1$. For $K\geq 1$, the only change is that the parameter $\theta^{*}$ becomes $\arcsin\sqrt{K/N}$. Thus if the correct value of $K$ is known to the algorithm (and we assume for simplicity that $K\leq N/2$), it can choose $r\approx\tfrac{\pi}{4}\sqrt{N/K}$ and solve the search problem using $O(\sqrt{N/K})$ iterations/queries. This algorithm also works if the algorithm knows an estimate $K^{\prime}$ of $K$ that is correct up to small multiplicative error; say, $K^{\prime}\overset{1.1}{\approx}K$. Here we are using the following notation:

If $K$ is unknown to the algorithm, one possibility is try all estimates $K^{\prime}=1$, $1.1$, $1.1^{2}$, $1.1^{3},\ \dots,\ N/2$. The total number of Grover iterations (hence queries) will be $O(\sum_{i}\sqrt{N/1.1^{i}})=O(\sqrt{N})$.²²2One must take a small amount of care to bound the overall failure probability without incurring a log factor. A strategy with improved query complexity for large $K$ was given by Boyer, Brassard, Høyer, and Tapp [2]; in brief, for $i=0,1,2,\dots$ it tries a random number of rotations in the range $[1,1.1^{i}]$, stopping if ever an $x\in f^{-1}(1)$ is found. This algorithm solves the search problem using $O(\sqrt{N/K})$ iterations, despite not knowing $K$ in advance.

A natural related problem, called Approximate Counting and introduced in [2], is to estimate $K$. More precisely, given as input a parameter $\epsilon\geq 0$, the task is to output a number $\widehat{K}$ such that (with high probability) $\widehat{K}\overset{1+\epsilon}{\approx}K$. To keep the exposition simple, in this paper we will make the following standard assumptions:

• •

  $1/N\leq\epsilon\leq 1$ (setting $\epsilon=1/N$ just yields the problem of exact counting — any smaller value of $\epsilon$ does not change the problem);

• •

  $K\leq N/2$ (otherwise there is generally a dependence on $N-K$, since one can switch the roles of $0$ and $1$ in $f$’s output);

• •

  $K\neq 0$ (generally, all algorithms can easily be extended to work in the case of $K=0$, with query complexity being the worst-case query complexity over all $K>0$).

The quantum Approximate Counting problem was solved with optimal query complexity by Brassard, Høyer, Mosca, and Tapp [3]. Combining quantum Fourier transform ideas from Shor’s Algorithm with the ideas behind Grover Search, their algorithm solves Approximate Counting using $O\lparen\sqrt{N/K}\!\bigm{/}\!\epsilon\rparen$ queries.

Let us make some remarks about this query complexity. First, note that the bound takes $K$ into account, even though $K$ is (initially) unknown to the algorithm. Second, although $K$ could be as small as $1$, the worst-case query complexity over all $K$ need not be $\Omega\lparen\sqrt{N}\!\bigm{/}\!\epsilon\rparen$. (Indeed, this would lead to an illogical query complexity of $\Omega(N^{3/2})$ if one set $\epsilon=1/N$ to do exact counting.) Instead, note that an algorithm can first run the [3] algorithm with $\epsilon=1$, expending $O\lparen\sqrt{N/K}\rparen\leq O(\sqrt{N})$ queries and learning a preliminary estimate $K^{\prime}\overset{2}{\approx}K$. Now since $K$ is an integer, there is no point in trying to approximate it to a factor better than $1+1/K$, hence better than $1+1/(2K^{\prime})$. Thus the algorithm can now raise the initial input $\epsilon$ to $1/(2K^{\prime})$ if necessary, and then run [3] to obtain its final estimate. This yields a final query complexity of

(where in the last inequality we took the geometric mean). This $K$-independent bound of $O(\sqrt{N/\epsilon})$ is logical: the smallest $\epsilon$ one should ever take is $\epsilon=1/N$, and this leads to a query complexity of $O(N)$ for the general case of exact counting. By similar reasoning one can obtain the more precise fact that exact counting can done with $O(\sqrt{NK})$ queries. Finally, we remark that [3]’s query complexity was shown to be optimal by Nayak and Wu [8].

Let us also briefly mention the quantum Amplitude Estimation problem, which is essentially the same as the Approximate Counting problem except that the “initial angle” $\theta^{*}$ need not be of the form $\arcsin\sqrt{K/N}$ for some integer $K$, but can be any value. The solution to the Amplitude Estimation problem in [3] is a widely used tool in quantum algorithm design, and leads to quadratic speedups over classical algorithms for a variety of statistical problems.

Although the Approximate Counting algorithm from [3] has optimal query complexity, there has recently been a lot of interest in simplifying it [10, 9, 1]. In particular the latter two of these just-cited works strove to replace it with an algorithm that only uses Grover iterations, both for analytic simplicity and practical simplicity (the controlled amplifications of [3] being particularly problematic for NISQ devices). The work of Aaronson and Rall [1] provably succeeds at this challenge, providing an algorithm that solves the Approximate Counting problem using $O\lparen\sqrt{N/K}\!\bigm{/}\!\epsilon\rparen$ Grover iterations (hence queries). Briefly, the Aaronson–Rall algorithm has a first phase (somewhat similar to the [2] algorithm) that performs a geometrically increasing sequence of Grover iterations until $K$ can be estimated up to a constant factor of $1.1$ (see Theorem 3.1 herein). This requires $O(\sqrt{N/K})$ iterations. In the second phase, their algorithm performs a kind of binary search to improve the approximation factor to $1+\epsilon$; each step of the binary search requires additional Grover iterations, totalling $O\lparen\sqrt{N/K}\!\bigm{/}\!\epsilon\rparen$ in the end.

From the point of view of practicality and simplicity, there is a downside to the Aaronson–Rall algorithm, which is that its Grover iterations are adaptive (especially in the second phase of the algorithm). In other words, the steps of the algorithm involve many repetitions of the following: performing some Grover iterations, measuring, and doing some classical computation to decide how many Grover iterations to do in the next step. It has been argued that this repeated switching between quantum and classical computation could be undesirable in practice. Indeed, the final open question in [1] concerned the optimal query complexity of Approximate Counting using nonadaptive Grover iterations. This version of the problem was also stressed and studied in [9], but without any provable guarantees being provided.

Other recent developments in the area of approximate counting include [5, 7], which propose variants of the algorithm from [1] but with improved constant factors. As well, the work [4] proves a lower bound for the query complexity of approximate counting in the parallel case.

We investigate the problem of Approximate Counting using only nonadaptive Grover iterations. Note that for this version of the problem, there is no hope of obtaining the query complexity $O\lparen\sqrt{N/K}\!\bigm{/}\!\epsilon\rparen$ that improves as a function of $K$. To see this, suppose even that $\epsilon$ is fixed to $1$. If the algorithm is to achieve query complexity $O(\sqrt{N/K})$, then it must be able to achieve $O(1)$ query complexity when $K=\Theta(N)$. Since it is nonadaptive, this means it must always make only $O(1)$ queries. But this is impossible, as even for adaptive algorithms it is known that $\Omega(\sqrt{N})$ queries are required in the case of $K=O(1)$, $\epsilon=1$.

In other words, with nonadaptive algorithms we can only hope to achieve the optimal query complexity that is independent of $K$, namely $O(\sqrt{N/\epsilon})$. In this work we indeed show this is achievable. Our main theorem is:

We also briefly sketch an extension of our algorithm achieving improved query complexity in the setting where we are allowed multiple rounds of nonadaptive Grover iterations (as opposed to just one).

We will use the following elementary numerical fact:

This lemma helps us show that approximating $\theta^{*}$ well is equivalent to approximating $K$ well:

The algorithm for Lemma 3.2 is structured exactly as described in Definition 2.2 and Fact 1; there is an initial nonadaptive quantum part with a fixed Grover schedule (that we will later define), and a classical post-processing step at the end that uses the results of the quantum part to estimate $\theta^{*}$.

Before stating the key ideas in the quantum part of our algorithm, we mention the “Rotation Lemma” of Aaronson and Rall [1, Lem. 2]. The main idea in that lemma can be roughly stated as follows: given that $\theta^{*}$ lies in some range $[\theta_{\mathrm{min}},\theta_{\mathrm{min}}+\Delta\theta]$, we can pick an odd integer value of $r$ (where $r=O(1/(\theta\cdot\Delta\theta))$), such that $r\theta_{\mathrm{min}}$ is close to $2\pi k$ and $r(\theta_{\mathrm{min}}+\Delta\theta)$ is close to $2\pi k+\pi/2$. If $\theta$ is close to $\theta_{\mathrm{min}}$, $p(r)$ will be nearly $0$ (and if it is close to $\theta_{\mathrm{min}}+\Delta\theta$, it will be nearly $1$). Aaronson and Rall use this lemma to continually shrink the possible range that $\theta^{*}$ could lie in by a geometric factor at each iteration, until the range is $1\pm\epsilon$.

We will adopt a similar idea to find an efficient Grover schedule that can distinguish any two candidate angles with high probability; we do this by relaxing the condition of one angle being close to $2\pi k$ and the other being at distance $\pi/2$ from it. Instead, we choose the sequence $R$ in our Grover schedule such that for any pair of values $\theta_{1}$, and $\theta_{2}$, there is some $r\in R$ such that $r\theta_{1}$ and $r\theta_{2}$ differ by approximately $\pi/8$, and are also “in the same quadrant” (meaning the same interval $[0,\tfrac{\pi}{2})$, $[\tfrac{\pi}{2},\pi)$, $[\pi,\tfrac{3\pi}{2})$, $[\tfrac{3\pi}{2},2\pi)$ modulo $2\pi$). This relaxation allows us to save on the total number of queries made by reusing the same value of $r$ to distinguish many pairs of candidate angles. Due to this, the nonadaptivity requirement does not make the query complexity grow polynomially larger (whereas, for example, naively simulating the search tree from [1] in a nonadaptive fashion would incur an extra $1/\epsilon^{\prime}$ factor).

The classical post-processing involves running a “tournament” between all candidate estimates of $\theta^{*}$, which outputs the winning value as the estimate. This post-processing step can be implemented efficiently in $O(\log(1/\epsilon^{\prime})/\epsilon^{\prime})$ classical time.

We now define some useful sequences and prove a couple of arithmetic lemmas about them.

For the $u_{i}$ given by Lemma 4.2, we have $u_{i}\theta_{1}-u_{i}\theta_{0}\approx\frac{\pi}{8}$. This seems promising, in that the “coin probabilities” associated to these angles, namely $\sin^{2}(u_{i}\theta_{1})$ and $\sin^{2}(u_{i}\theta_{0})$, seem as though they should be far apart. Unfortunately, something annoying could occur; it could be that these angles are, say, $100\pi\pm\frac{\pi}{16}$, in which case the coin probabilities would be identical. As mentioned in Section 4.1, what we would really like is to have the two angles be far apart but also in the same quadrant. To achieve this, we will define a new sequence.

We can now describe our “second stage” algorithm, which simply runs the Grover schedule $G$ defined as follows.

Note that the $T_{i,j}$ values we use are exactly the number of coin flips used in the second stage of the algorithm in [1]. Like in their algorithm, this choice of values allows us to avoid stray $\log(1/\epsilon)$ or $\log\log(1/\epsilon)$ factors in the overall query complexity.

It now remains for us to show how to approximate $\theta^{*}$ (with high probability) using the data collected from this Grover schedule.

We first prove a lemma showing that we can distinguish between any pair of angles (that are not already sufficiently close to each other) by using the ideas developed in Lemma 4.2 and Lemma 4.10.