Error reduction of quantum algorithms

TL;DR

This paper introduces a novel quantum error reduction technique called Amplitude Separation, which improves the efficiency of quantum algorithms in determining properties of inputs, especially when error probabilities are high.

Contribution

The paper proposes the Amplitude Separation method that combines amplitude amplification and estimation to reduce quantum algorithm error with fewer executions than existing methods.

Findings

Achieves $O(1/(\sqrt{1- ho} - \sqrt{ ho}))$ executions, better than previous approaches for high errors.

Provides a quadratic speedup in the Multiple-Weight Decision Problem over classical and existing quantum algorithms.

Demonstrates improved error reduction efficiency in quantum algorithms for property testing.

Abstract

We give a technique to reduce the error probability of quantum algorithms that determine whether its input has a specified property of interest. The standard process of reducing this error is statistical processing of the results of multiple independent executions of an algorithm. Denoting by $\rho$ an upper bound of this probability (wlog., assume $\rho \le \frac{1}{2}$), classical techniques require $O(\frac{\rho}{[(1-\rho) - \rho]^2})$ executions to reduce the error to a negligible constant. We investigated when and how quantum algorithmic techniques like amplitude amplification and estimation may reduce the number of executions. On one hand, the former idea does not directly benefit algorithms that can err on both yes and no answers and the number of executions in the latter approach is $O(\frac{1}{(1-\rho) - \rho})$. We propose a novel approach named as {\em Amplitude Separation} that combines both these approaches and achieves $O(\frac{1}{\sqrt{1-\rho} - \sqrt{\rho}})$ executions that betters existing approaches when the errors are high. In the Multiple-Weight Decision Problem, the input is an $n$-bit Boolean function $f()$ given as a black-box and the objective is to determine the number of $x$ for which $f(x)=1$, denoted as $wt(f)$, given some possible values $\{w_1, \ldots, w_k\}$ for $wt(f)$. When our technique is applied to this problem, we obtain the correct answer, maybe with a negligible error, using $O(\log_2 k \sqrt{2^n})$ calls to $f()$ that shows a quadratic speedup over classical approaches and currently known quantum algorithms.

Equations

$$R_0$$

$$\dots R_i$$

$${\sin }^2{3}^s\tau -{\sin }^2{3}^s\beta \tau$$

$$=(1-\beta ){\sin }^2{3}^s\tau >(1-\beta )\frac{\pi }{12}$$

$$\sum _{i=0}^s(1+M)k_i=\frac{1}{2}(1+M)\sum _{i=0}^s(3^i-1)<\frac{1}{2}(1+M)\frac{3\pi }{8\tau }$$

$$=\tilde{O}\left(\frac{1}{(1-\beta )\tau }\log \frac{1}{\delta }\right)=\tilde{O}\left(\frac{1}{(1-\beta )\sqrt{t}}\log \frac{1}{\delta }\right)$$

$$\frac{1}{2}\cdot \frac{3\pi }{8{\sin }^{-1}\sqrt{t}}\left(1+7\lceil \frac{36}{1-\beta }\rceil (\ln \frac{1+s}{\delta }{)}^{1/3}\right)$$

$$⪅\frac{3\pi }{16\sqrt{1-{\rho }_y}}+\frac{48\pi }{\sqrt{1-{\rho }_y}-\sqrt{{\rho }_n}}(\ln \frac{1+s}{\delta }{)}^{1/3})$$

$$\sin \theta \le a\sin t\text{mbox}impliesthat\theta \le at.$$

Full text

In the Multiple-Weight Decision Problem, the input is an $n$-bit Boolean function $f()$ given as a black-box and the objective is to determine the number of $x$ for which $f(x)=1$, denoted as $wt(f)$, given some possible values $\{w_{1},\ldots,w_{k}\}$ for $wt(f)$. When our technique is applied to this problem, we obtain the correct answer, maybe with a negligible error, using $O(\log_{2}k\sqrt{2^{n}})$ calls to $f()$ that shows a quadratic speedup over classical approaches and currently known quantum algorithms.

Quantum algorithm, Amplitude amplification and estimation, Weight decision problem

I Introduction

Many of the famous problems for which early quantum algorithms were designed are “decision problems”, i.e., the solution of the problem requires identifying whether an input satisfies a given property. Inputs which evoke a “yes” answer are called as “yes”-inputs and, similarly, those that evoke a “no” answer are called as “no”-inputs. Quantum algorithms being inherently probabilistic, it is possible for such algorithms to be error-prone. An algorithm that makes the correct decision for every input is termed as an “exact algorithm”, otherwise the algorithm is a probabilistic one. This note concerns probabilistic quantum algorithms and the techniques to reduce their error. Specifically, we look at algorithms with bounded non-zero errors in the following sense: the probability of error for yes-inputs is upper bounded by $\rho_{y}\in(0,1)$ and the probability of error for no-inputs is upper bounded by $\rho_{n}\in(0,1)$. Without loss of generality, we will assume that $\rho_{n}\leq\rho_{y}$, else the notion of “yes” and “no” inputs can be interchanged; similarly, we can assume that $\rho_{y}+\rho_{n}\leq 1$, because otherwise, $(1-\rho_{y})+(1-\rho_{n})\leq 1$ so we can simply swap the “yes”-“no” answers.

Setting aside bespoke error reduction tactics, our focus is going to be black-box techniques for reducing error that applies to any algorithm. This is routinely done for day-to-day classical algorithms by running them independently enough number of times and analysing their output. For example, if $\rho_{n}$ is 0, then it suffices to simply output ‘‘yes’’ if any execution outputs “yes” In fact the versatile amplitude amplification (AA) technique used in quantum algorithms can also be used in such cases Brassard et al. (2002); Bera (2018).

However, directly applying AA is inadequate in reducing errors of algorithms if both $\rho_{y}>0$ and $\rho_{n}>0$. What AA does is non-linearly multiplies the probability that the output state of an algorithm is observed in a particular state (for which the algorithm outputs “yes”). Therefore, when both $\rho_{y}$ and $\rho_{n}$ are non-zero, there is a chance of error for every input. No matter which state is used for amplification, one of $\rho_{y}$ and $\rho_{n}$ will decrease but the other will increase, rendering ${\tt AA}$ ineffective.

There are standard “classical” techniques for handling such algorithms. Suppose $\mathcal{A}$ denotes the algorithm with error bounds $\rho_{y}$ and $\rho_{n}$. Therefore, for a “yes”-input, the probability of observing a “good” output state would be at least $1-\rho_{y}$ and for a “no”-input, the probability of observing the same would be at most $\rho_{n}$. One manner in which the error of $\mathcal{A}$ can be reduced (to, say, some $\delta$) is to estimate this probability with a precision of $\pm\frac{1}{2}[(1-\rho_{y})-\rho_{n}]$ and with error probability at most $\delta$. For a “yes”-input, the estimate will be less than $\frac{1}{2}[(1-\rho_{y})+\rho_{n}]$ with probability less than $\delta$ and for a “no”-input, the estimate will be more than the same threshold with probability less than $\delta$. Thus, to reduce the error of $\mathcal{A}$, it suffices to estimate the probability and claim that the input is a “yes”-input if the estimate is more than the threshold, and a “no”-input otherwise. Estimating the probability requires running $\mathcal{A}$ multiple times and calculating the fraction of times the “good” state is observed, and to achieve this within the required bounds requires \tilde{O}\big{(}(1-\rho_{y})/[(1-\rho_{y})-\rho_{n}]^{2}\big{)} executions 111$\tilde{O}()$ hides additional insignificant $\log$-factors within $O()$. of $\mathcal{A}$.

Another possibility is the use of amplitude estimation that is a quantum technique to estimate the probability that the output of any algorithm is observed to be in a “good” state. The probability can be estimated with any required precision — there is a chance of error but that too can be controlled at the expense of more operations. Use of this technique reduces the number of executions to $\tilde{O}(1/[(1-\rho_{y})-\rho_{n}])$.

However, both these techniques become inefficient when $1-\rho_{y}\approx\rho_{n}$ and both of these are small. This note presents the amplitude separation technique, a combination of amplitude amplification and estimation, to reduce both $\rho_{y}$ and $\rho_{n}$, even when they are non-zero, and the number of calls required is only $\tilde{O}(1/[\sqrt{1-\rho_{y}}-\sqrt{\rho_{n}}])$. As illustrated in Figure 1, this method outperforms the earlier techniques when $1-\rho_{y}\to 0$ and $\rho_{n}\to 0$.

If the errors for all the “yes”-inputs are same and equal to $\rho_{y}$, and similarly, those for all the “no”-inputs are equal to $\rho_{n}$ and if $\rho_{y}$ and $\rho_{n}$ are known then it is possible to perform a better error reduction. Using AA in a sophisticated manner, Bera has shown how to obtain an algorithm that correctly outputs ‘‘accept’’ for all “yes”-inputs and outputs ‘‘reject’’ for all “no”-inputs without any probability of error (see the result that $\mathrm{\mathbf{EBQP}}=\mathrm{\mathbf{EQP}}$ in Bera (2018)). However, that technique crucially uses the information that all error probabilities equal either $\rho_{y}$ or $\rho_{n}$ and are known priory — something which we relax in this note. Furthermore, the objective of that work was to design an error-less method whereas we allow error, albeit tunable, as a parameter.

An immediate application of our method is an efficient bounded-error algorithm for the Multiple Weight Decision problem ($\mathrm{\mathbf{MWDP}}$). $\mathrm{\mathbf{MWDP}}$ is a generalization of the Exact Weight Decision problem ($\mathrm{\mathbf{EWDP}}$) that, in turn, generalizes the Deutsch-Jozsa’s problem and the Grover’s unordered search problem Qiu and Zheng (2018); Braunstein et al. (2007); Choi and Braunstein (2011). The input to the $\mathrm{\mathbf{MWDP}}$ problem is an $n$-bit Boolean function $f()$ given in the form of a blackbox and a list of $k$ possible weights of $f()$: $\{0<w_{1}<w_{2}<\ldots<w_{k}<2^{n}\}$ along with a promise that $wt(f)=w_{i}$ for some $i$. The weight of $f()$ is defined as $wt(f)=|\{x\in\{0,1\}^{n}~{}:~{}f(x)=1\}|$. The objective is to determine the actual weight of $f()$ by making very few calls to $f()$. $\mathrm{\mathbf{EWDP}}$ can be defined as $\mathrm{\mathbf{MWDP}}$ with $k=2$.

Optimal algorithms for $\mathrm{\mathbf{EWDP}}$ are known that determines the weight exactly and make $\Theta(\sqrt{w_{2}(2^{n}-w_{1})}/(w_{2}-w_{1}))$ calls Choi and Braunstein (2011); Choi (2012) that could be as large as $\sqrt{2^{n}}$ when $w_{1}\approx w_{2}\ll 2^{n}$. Current algorithms for $\mathrm{\mathbf{MWDP}}$ give exact answer and follow two approaches Choi and Braunstein (2011). They either make $k-1$ calls to an $\mathrm{\mathbf{EWDP}}$ algorithm, and thus, could make nearly $2^{n}$ calls to $f()$ (when $k\approx\sqrt{2^{n}}$), or, they use a quantum counting algorithm Brassard et al. (2002) to count the number of solutions of $f(x)=1$ but that could also require nearly $2^{n}$ calls (when $wt(f)\approx 2^{n}$).

We use our amplitude separation technique to give an algorithm for $\mathrm{\mathbf{MWDP}}$ with small error that makes $O(\log_{2}k\sqrt{2^{n}})$ calls to $f()$. This is achieved by first designing a bounded-error algorithm for a variation of $\mathrm{\mathbf{EWDP}}$ in which we have to determine if $wt(f)\leq w_{1}$ or $wt(f)\geq w_{2}$ for given $0<w_{1}<w_{2}<2^{n}$.

Our approach uses the concept of amplitude amplification (AA) and amplitude estimation. Even though we describe our technique on algorithms that take its input in the form of oracle operators, we use can a method outlined in a work by Bera to apply AA, and hence the technique in this note, to algorithms that is given their input $x\in\{0,1\}^{n}$ in the form of an initial state $\left|x\right\rangle$ (along with ancillary qubits in a fixed state) Bera (2018).

II Background

Our method makes a subtle use of the well-known quantum amplitude estimation algorithm so we briefly discuss the relevant results along with the specific extension that we require.

Suppose we have an $n$-qubit quantum algorithm $\mathcal{A}$ that is said to “accept” its input when its output qubit is observed in a specific “good state” upon the final measurement. We will use $p$ to denote the probability of observing this good state for a specific input. The value of $p$ can be estimated by purely classical means, e.g., by running the algorithm multiple times and computing the fraction of times the good state is observed. Amplitude estimation is a quantum technique that essentially returns an estimate by making fewer calls to the algorithm compared to this technique.

The estimation method uses two parameters $k$ and $m$ that we shall fix later. The first and basic quantum amplitude estimation algorithm (say, named as $AmpEst$) was proposed by Brassard et al. Brassard et al. (2002) that acts on two registers of $m$ and $n$ qubits, makes $2^{m}$ calls to controlled-$\mathcal{A}$ and outputs a $\tilde{p}\in[0,1]$ that is a good approximation of $p$ in the following sense.

Theorem II.1**.**

The $AmpEst$ algorithm returns an estimate $\tilde{p}$ that has a confidence interval $|p-\tilde{p}|\leq 2\pi k\frac{\sqrt{p(1-p)}}{2^{m}}+\pi^{2}\frac{k^{2}}{2^{2m}}$ with probability at least $\frac{8}{\pi^{2}}$ if $k=1$ and with probability at least $1-\frac{1}{2(k-1)}$ if $k\geq 2$. If $p=0$ or 1 then $\tilde{p}=p$ with certainty.

The $AmpEst$ algorithm can be used to estimate $p$ with desired accuracy (at least $3/4$) and error. We now present an extension to the above Theorem to obtain an estimation with an additive error, say denoted by $\epsilon$, that is at most $1/4$. We will use $\delta$ to denote the maximum permissible error. For obtaining such an estimation, we will run $AmpEst$ presented above using $k=1$ and $m$ such that $2^{m}=\lceil\frac{3\pi}{2\epsilon}\rceil$. $AmpEst$ will be run $7\left(\ln\frac{1}{\delta}\right)^{1/3}=\Theta(\ln\frac{1}{\delta})$ times to obtain that many estimates of $p$ and the median of these obtained estimates is then returned as $\tilde{p}$. The total number of calls to controlled-$\mathcal{A}$ is, therefore, $O(\frac{1}{\epsilon}\ln\frac{1}{\delta})$. Next we analyse the accuracy of $\tilde{p}$.

Since $p(1-p)\leq 1/4$ for any $p$, $\frac{1}{2}e^{2\epsilon}\geq\sqrt{\frac{1}{4}+\epsilon}$ ($\because\epsilon\leq 1/4$), and $3\geq 1+e^{2\epsilon}$, it can be shown that $\frac{3\pi}{2\epsilon}\geq\frac{\pi}{\epsilon}\left[\sqrt{p(1-p)}+\sqrt{p(1-p)+\epsilon}\right]$ and for $2^{m}\geq\frac{3\pi}{2\epsilon}$, it can be further shown that $2\pi\frac{\sqrt{p(1-p)}}{2^{m}}+\frac{\pi^{2}}{2^{2m}}\leq\epsilon$. Therefore, for the setting of parameters specified above, using the above Theorem we obtain an estimate $\tilde{p}$ in each run of $AmpEst$ such that $\Pr[|p-\tilde{p}|\geq\epsilon]\leq\delta$ with probability of error at most $1-\frac{8}{\pi^{2}}$ which means the median of any number of such estimates also satisfies the same upper-bound on its additive error. The overall error can be reduced to any desired $\delta$ by taking a median of $\Theta(\ln\frac{1}{\delta})$ estimates and this is a standard error reduction technique whose proof uses Chernoff bounds.

So, to summarize this section, we have explained a method that returns an estimate $\tilde{p}$ to the success probability $p$ of a quantum algorithm $\mathcal{A}$ such that $\tilde{p}-\epsilon\leq p\leq\tilde{p}+\epsilon$ with a probability at least $1-\frac{1}{\delta}$. The method makes altogether $O(\frac{1}{\epsilon}\ln\frac{1}{\delta})$ calls to $\mathcal{A}$.

III Amplitude Separation Algorithm

Now we introduce the Amplitude Separation (AS) problem and describe an algorithm that is going to be our main technical tool. Suppose we are given a quantum algorithm $\mathcal{A}$ for a decision problem; without loss of generality, we can assume that the algorithm outputs “yes” if the output qubit is observed in the state $\left|1\right\rangle$ and “no” if the observed state is $\left|0\right\rangle$. Let $p$ denote the probability of observing the output qubit in the state $\left|1\right\rangle$. Suppose it is also given that for “yes”-inputs $p\geq t$ and for “no”-inputs $p\leq t^{\prime}$ for given $0<t^{\prime}<t<1$. The AS problem is to determine whether a given input is a “yes”-input or a “no”-input by making black-box calls to $\mathcal{A}$.

There are, of course, several alternative strategies. Consider the completely classical method of making multiple observations of $\mathcal{A}$ and deciding based on the number of times the output qubit is observed in the state $\left|1\right\rangle$ – the number of required queries to $\mathcal{A}$ can be obtained using probabilistic techniques (involving Chernoff bound) and scales as $O(\frac{1}{t-t^{\prime}})$. Another possibility would have been to use the quantum amplitude estimation methods. They come in various flavours and a quick summary of the relevant ones are presented in Section II. If we use the additive-accuracy estimation, then too the number of queries scales as in the previous case. One can also design an estimator with a relative-accuracy but to obtain an upper-bound on the number of queries, one would require a lower bound on $p$ which need not be known.

The decision algorithm is presented in Algorithm 1. For the simplicity of analysis, we use a separation variable $\beta$ chosen such that $t^{\prime}=\beta^{2}t$. On a high level, our algorithm first amplifies the amplitude of $\left|1\right\rangle$ state of the output qubit and only after that applies amplitude estimation since amplified probabilities have a larger gap and, therefore, are easier to distinguish. Recall that applying AA $k_{i}$ times increases the corresponding probability from any $\sin^{2}\theta$ to $\sin^{2}[(2k_{i}+1)\theta]$. We will see below how this allows us to solve the problem with a number of queries to $\mathcal{A}$ that scales as $O(\frac{1}{\sqrt{t}})$. For amplitude estimation we use the additive-accuracy estimator with additive-error $\epsilon^{\prime}$ and error $\delta^{\prime}$ that is explained in Section II.

Now we explain how Algorithm 1 makes $\tilde{O}\left(\frac{1}{\sqrt{t}-\sqrt{t^{\prime}}}\log\frac{1}{\delta}\right)$ calls to $\mathcal{A}$ (and $\mathcal{A}^{\dagger}$) and with probability of error at most $\delta$ returns accept if $p\geq t$ or returns reject if $p\leq t^{\prime}$.

To explain the claim we will use the two following trigonometric facts: (1) for any $a<1$ and $t\leq\pi/2$, $\sin\theta\leq a$ $\sin t$ implies $\theta\leq at$, and (2) for any $a<1$ and $t\leq\pi/4$, $a\sin t\leq\sin at\leq\sqrt{a}\sin t$ (proof of these are included in Appendix A).

Consider $\theta\in[0,\frac{\pi}{2}]$ such that $p=\sin^{2}\theta$ and $\tau\in[0,\frac{\pi}{2}]$ such that $t=\sin^{2}\tau$. Then the two cases of $\theta$ that are under consideration would be (i) $\sin\theta\geq\sin\tau$ and (ii) $\sin\theta\leq\beta\sin\tau$. Following a common technique of analysing amplitude amplification techniques Chakraborty and Maitra (2016), it will be helpful to break the interval [$\tau,\frac{\pi}{2}$] into these intervals:

[TABLE]

where $\psi=3^{s}\tau$ and $s=\lfloor\log_{3}\frac{\pi}{4\tau}\rfloor$. It can quickly verified that $3^{s}\tau\in(\frac{\pi}{12},\frac{\pi}{4}]$.

First, consider the case of $\sin\theta\geq\sin\tau$ that is equivalent to $\theta\geq\tau$ (refer to Figure 2). Notice that for any $\theta\in[\tau,\frac{\pi}{2}]$, there exists some $R_{i}$ such that $\theta\in R_{i}$. Consider the $i$-th iteration in the Algorithm in which we set $k_{i}=\frac{1}{2}(3^{i}-1)$. For any $\theta\in R_{i\neq 0}$, $(2k_{i}+1)\theta=3^{i}\theta\in[3^{s}\tau,3\cdot 3^{s}\tau]\subseteq[3^{s}\tau,3\pi/4]$ and for $\theta\in R_{0}$, $(2k_{i}+1)\theta\in[\frac{\pi}{12},\frac{\pi}{2}]\subseteq[3^{s}\tau,3\pi/4]$. Since $3^{s}\tau\in(\frac{\pi}{12},\frac{\pi}{4}]$, therefore, after amplification $\sin^{2}[(2k_{i}+1)\theta]\geq\sin^{2}3^{s}\tau$. So, the probability $p$ of observing the output qubit in $\left|1\right\rangle$ satisfies $p\geq\sin^{2}3^{s}\tau$. Therefore, using additive amplitude estimation with $\epsilon^{\prime}$ and $\delta^{\prime}$ as specified in the algorithm will ensure that $\tilde{p}\geq p-\epsilon^{\prime}\geq\epsilon^{*}$ holds with probability at least $1-\delta^{\prime}$. Hence, the probability that the algorithm with return accept in the $i$-th iteration is at least $1-\delta^{\prime}$ and the probability that the algorithm will correctly return accept eventually is also at least $1-\delta^{\prime}\geq 1-\delta$.

Next, consider the case where $\sin\theta\leq\beta\sin\tau$ (refer to Figure 2). As per the trigonometric claim above, this implies that $\theta\leq\beta\tau$. Therefore, for any $i=1\ldots s$, $(2k_{i}+1)\theta\leq(2k_{i}+1)\beta\tau\leq 3^{s}\beta\tau$. This implies that the probability $p$ defined above satisfies $p\leq\sin^{2}(3^{s}\beta\tau)$. Again using the additive amplitude estimation in a similar manner as above will ensure that $\tilde{p}\leq p+\epsilon^{\prime}\leq\epsilon^{*}$ with probability at least $1-\delta^{\prime}$. Hence, the probability that the algorithm will return accept in a specific iteration is at most $\delta^{\prime}$. Therefore, the probability that the algorithm will return accept in any of the $i=0\ldots s$ iterations is at most $(1+s)\delta^{\prime}=\delta$, which means that the probability that the algorithm will correctly return reject is also at least $1-\delta$.

Having shown that Algorithm 1 returns the correct answer to its decision problem with error at most $\delta$, now we explain the query complexity of the algorithm. We will use $M$ to denote the number of queries made by the additive amplitude estimation algorithm with parameters $\epsilon^{\prime}$ and $\delta^{\prime}$; it was shown in Section II that $M=O(\frac{\pi}{\epsilon^{\prime}}\log\frac{1}{\delta^{\prime}})$. We first need a lower bound on $\epsilon^{\prime}=\frac{1}{2}(\sin^{2}3^{s}\tau-\sin^{2}3^{s}\beta\tau)$. Using the fact that $3^{s}\tau\in(\frac{\pi}{12},\frac{\pi}{4}]$ and the trigonometric facts stated above we derive the following:

[TABLE]

Therefore, hiding all constants in the big-$O$ notation, $M=\tilde{O}(\frac{1}{(1-\beta)}\log\frac{1}{\delta})$. Now, in Algorithm 1, we can see that the oracle $\mathcal{A}$ is called a total of $(1+M)k_{i}$ times at each iteration as the oracle is explicitly called $k_{i}$ times during the amplitude amplification and the amplitude estimation subroutine itself calls the amplitude amplification $M$ times. So, the total number of calls to the oracle in the algorithm can be expressed as:

[TABLE]

where we used $\frac{1}{sin^{-1}\sqrt{t}}<\frac{1}{\sqrt{t}}$ in the last inequality.

Suppose $\mathcal{A}$ has bounded errors, say $\rho_{n}$ and $\rho_{y}$; then for “no”-inputs $p\leq\rho_{n}$ and for “yes”-inputs, $p\geq(1-\rho_{y})$. Further suppose we want to reduce its error to at most $\delta<\{\rho_{n},\rho_{y}\}$. Algorithm 1 can be applied to $\mathcal{A}$ by setting parameters $t$ to $1-\rho_{y}$ and $t^{\prime}$ to $\rho_{n}$, and, as shown above, will return ‘‘accept’’ for “yes”-inputs, as well as return ‘‘reject’’ for “no”-inputs, both with probability at least $1-\delta$. What we obtain is an algorithm that acts on the same input state as $\mathcal{A}$, and observed using the same measurement operators, but makes at most $\delta$ error in identifying “yes” and “no”-inputs. This is our proposal to reduce the error of $\mathcal{A}$ in a generic manner. The number of calls that will be made to $\mathcal{A}$ (and $\mathcal{A}^{\dagger}$) in the reduced error algorithm will be at most $O(\frac{1}{\sqrt{1-\rho_{y}}-\sqrt{\rho_{n}}}\log\frac{1}{\delta})$. 222The exact expression, along with all constants, turns out to be

$\displaystyle\frac{1}{2}\cdot\frac{3\pi}{8\sin^{-1}\sqrt{t}}\left(1+7\left\lceil\frac{36}{1-\beta}\right\rceil\textstyle(\ln\frac{1+s}{\delta})^{1/3}\right)$

$\displaystyle\lessapprox\frac{3\pi}{16\sqrt{1-\rho_{y}}}+\frac{48\pi}{\sqrt{1-\rho_{y}}-\sqrt{\rho_{n}}}\textstyle(\ln\frac{1+s}{\delta})^{1/3})$

IV Weight Decision Algorithm

Given an $n$-bit Boolean function $f()$ and two parameters $0<k_{1}<k_{2}<2^{n}$, suppose it is given that either $wt(f)\leq k_{1}$ or $wt(f)\geq k_{2}$. We define the Weight Decision problem, denoted by $\mathrm{\mathbf{WDP}}_{k_{1},k_{2}}$, as the question of determining whether $wt(f)\leq k_{1}$ or $wt(f)\geq k_{2}$. The objective is to minimize the number of calls to $f()$ that is given as input in the usual form of a blackbox operator $U_{f}:\left|x\right\rangle\left|b\right\rangle\mapsto\left|x\right\rangle\left|b\oplus f(x)\right\rangle$ where $x\in\{0,1\}^{n},b\in\{0,1\}$.

$\mathrm{\mathbf{WDP}}$ is fairly versatile in its applicability to Boolean function problems. For example, $\mathrm{\mathbf{EWDP}}$ is a restricted version of $\mathrm{\mathbf{WDP}}$ where it given that either $wt(f)=k_{1}$ or $wt(f)=k_{2}$ and the problem is identify which case it is. The decision version of the unordered “Grover’s” search problem is to identify whether $wt(f)=0$ or $wt(f)\geq 1$ which is $\mathrm{\mathbf{WDP}}_{0,1}$. The Deutsch’s problem and the Deutsch-Jozsa’s problem acts on Boolean functions that are either constant or balanced and their objective is to determine which one it is; for $n$-bit functions this is equivalent to identifying whether $wt(f)\in\{0,2^{n}\}$ or $wt(f)=2^{n-1}$. Following the technique suggested by Bera Bera (2015), one can define the function $g(x)=f(x)\oplus f(0)$; both the problems can now be reformulated as $\mathrm{\mathbf{EWDP}}$ with weights [math] and $2^{n-1}$ with the function $g()$ as input.

There is a very simple quantum algorithm for $\mathrm{\mathbf{WDP}}_{k_{1},k_{2}}$, illustrated in Figure 3. For ease of explanation, we recast the problem as a decision problem — we denote functions for which $wt(f)\geq k_{2}$ as “yes”-inputs and functions for which $wt(f)\leq k_{1}$ as “no”-inputs. Consider the algorithm that first runs the above circuit and then outputs “yes” (i.e., claims that the function satisfies $wt(f)\geq k_{2}$) if the last qubit is observed in the state $\left|1\right\rangle$ upon measurement and outputs “no” otherwise. If the input is a “yes”-input, then the probability of error is at most $\rho_{y}=(1-k_{2})/2^{n}$ and if the input is a “no”-input, then the probability of error is at most $\rho_{n}=k_{1}/2^{n}$. These errors can be reduced to any $\delta$ by using the above algorithm (in Figure 3) as $\mathcal{A}$ in Algorithm 1. The number of calls to $\mathcal{A}$, and so to $f()$, would be $O(\frac{\sqrt{2^{n}}}{\sqrt{k_{2}}-\sqrt{k_{1}}})$ — this is asymptotically optimal in $n$ for constant $k_{1}$ and $k_{2}$ due to the fact that $\mathrm{\mathbf{WDP}}$ generalizes the unordered search problem which has a $\Omega(\sqrt{2^{n}})$ lower bound.

A similar idea can be used to design an algorithm for the $\mathrm{\mathbf{MWDP}}$ problem with $k$ possible weights $\{0<w_{1}<w_{2}<\ldots<w_{k}\}$. Our bounded-error algorithm for determining $wt(f)$ is described in Algorithm 2. The algorithm recursively searches for the correct weight in the list $L$ that it maintains. In each recursive call, it uses ${\tt AS}$ to determine if $wt(f)$ lies in the lower half of the weights in $L$ or in the upper half, and accordingly, discards half of the possible weights from $L$. Specifically, if $wt(f)\leq w_{m}$, then $\mathcal{A}$’s probability of success is at most $w_{m}/2^{n}$ and otherwise, it is at least $w_{m+1}/2^{n}$; therefore, $t$ and $t^{\prime}$ are set to $w_{m+1}/2^{n}$ and $w_{m}/2^{n}$, respectively. The algorithm makes an error if and only if any of the ${\tt AS}$ makes an error, and since there are $\log_{2}(k)$ such calls, the maximum error that Algorithm 2 can make is $\log_{2}(k)\cdot\delta^{\prime}=\delta$.

The trivial classical complexity of exact $\mathrm{\mathbf{MWDP}}$ (without any error) with $k$ possible weights is $O(2^{n})$. The best known quantum method for exact $\mathrm{\mathbf{MWDP}}$ was also proposed by Choi et al. Choi and Braunstein (2011) in which the authors made $k-1$ calls to $\mathrm{\mathbf{EWDP}}$. Since the optimal query complexity of $\mathrm{\mathbf{EWDP}}$ is $\Theta(\sqrt{2^{n}})$, therefore, their approach yields a better-than-classical approach only when $k\ll\sqrt{2^{n}}$. Compared to those, our approach has a complexity $\tilde{O}(\sqrt{2^{n}}\log_{2}k\log\frac{1}{\delta})$ that we next explain, and suffers from a negligible probability of error $\delta$ — the dependency of the complexity on $\delta$ being logarithmic, it is possible to set a very low $\delta$ without heavy increase in the complexity. Recall that $\mathrm{\mathbf{MWDP}}(f,[w_{1},w_{2},\ldots,w_{k}])$ makes altogether $\log_{2}(k)$ calls to ${\tt AS}$ in a recursive manner. When ${\tt AS}$ is called with parameters $t^{\prime}=w_{m}/2^{n}$ and $t^{\prime}=w_{m+1}/2^{n}$, the number of calls to $f()$ is at most $O(\frac{\sqrt{2^{n}}}{\sqrt{w_{m+1}-\sqrt{w_{m}}}}\log\frac{1}{\delta^{\prime}})=\tilde{O}(\sqrt{2^{n}}\log\frac{1}{\delta})$ leading us to the complexity stated before. In particular, when $k=\Theta(n)$, existing quantum algorithms have the same asymptotic complexity of $O(2^{n})$ as classical algorithms but our approach uses only $O(n\sqrt{2^{n}})$ calls to $f()$.

V Conclusion

In this note we have described a technique to reduce error in quantum algorithms in a blackbox manner, akin to the classical approaches of running an algorithm multiple times. We showed how to use our approach for designing an efficient low-error algorithm for the Multiple Weight Decision problem. At the core of our approach is a new quantum algorithm that decides if the probability of success of an algorithm is less than $p_{1}$ or more than $p_{2}$ for given $p_{1}<p_{2}$. It would be interesting and beneficial to solve its multi-class version, i.e., given possible ranges, $[0,p_{1}],(p_{1},p_{2}],\ldots,(p_{k},1]$, determine the correct range of the success probability.

Acknowledgements.

Second author would like to thank Indraprastha Institute of Information Technology Delhi (IIIT-Delhi) for hosting him during which this work was accomplished.

Appendix A Proof of trigonometric facts

We include a quick geometric proof of the trigonometric identity that for any $a<1$ and $t\leq\pi/2$,

[TABLE]

For this consider the right-angled triangles $ABE$ and $CDE$ in Figure 4. $E$ is the point where the line segment $BD$ intersects the X-axis and $B$ and $D$ are points on the $sin(x)$ curve corresponding to $x=t$ and $x=at$, respectively.

We know from geometry that $CDE$ is similar to $ABE$, that is, $\frac{\sin at}{\sin t}=\frac{CD}{AB}=\frac{EC}{EA}$. From the figure, $EC=EO+at$ and $EA=EO+t$ which implies that $\frac{\sin at}{\sin t}=\frac{EO+at}{EO+t}\geq a$. Therefore, $a\sin t\leq\sin at$. Furthermore, we are given that $\sin\theta\leq a\sin t$. Combining the last two facts we get that $\sin\theta\leq\sin at$ which in turn implies that $\theta\leq at$ settling the fact.

In our analysis we make use of the fact that ${\sin at\geq a\sin t}$ for $a\in(0,1)$ and $t\in[0,\pi/2]$ which follows from the above result.

We make use of another fact which states that $\sin at\leq\sqrt{a}\sin t$ for $t\in[0,\frac{\pi}{4}]$ and $a<1$ whose proof we discuss now. Consider the real-valued continuous function $f(t)=a\sin^{2}t-\sin^{2}at$. We will now show that $f(t)$ is non-negative for $t\in[0,\frac{\pi}{4}]$. For showing this, first observe that $f(0)=0$. Furthermore, the first derivative satisfies $f^{\prime}(t)=a(\sin 2t-\sin 2at)\geq 0$ since $a\in(0,1)$ and $t\in[0,\frac{\pi}{4}]$. This shows that for the specified values of $t$, $f(t)\geq 0$, or equivalently, $\sin at\leq\sqrt{a}\sin t$.