Improved Quantum Query Complexity on Easier Inputs

TL;DR

This paper develops a modified quantum span program algorithm that maintains improved query complexity without input promises and demonstrates exponential quantum advantages in average query complexity for certain search problems.

Contribution

It introduces a new span program algorithm that extends previous promise-based improvements to unpromised inputs and applies it to show significant quantum advantages in search tasks.

Findings

Maintains query complexity improvements without input promises

Achieves exponential quantum advantages in average query complexity

Generalizes Montanaro's Search with Advice to broader problems

Abstract

Quantum span program algorithms for function evaluation sometimes have reduced query complexity when promised that the input has a certain structure. We design a modified span program algorithm to show these improvements persist even without a promise ahead of time, and we extend this approach to the more general problem of state conversion. As an application, we prove exponential and superpolynomial quantum advantages in average query complexity for several search problems, generalizing Montanaro's Search with Advice [Montanaro, TQC 2010].

Equations

$$w_{+}(\mathcal{P},x)=w_{+}(x):=\min \left\{\Vert |w⟩{\Vert }^2:|w⟩\in H(x)\text{ and }A|w⟩=\tau \right\}.$$

$$w_{-}(\mathcal{P},x)=w_{-}(x):=\min \left\{\Vert \omega A{\Vert }^2:\omega \in L(V,\mathbb{R}),\omega A{\Pi }_{H(x)}=0,\text{ and }\omega \tau =1\right\}.$$

$$W_{+}(\mathcal{P},f)=W_{+}:=\underset{x\in f^{-1}(1)}{\max }{w}_{+}(\mathcal{P},x),W_{-}(\mathcal{P},f)=W_{-}:=\underset{x\in f^{-1}(0)}{\max }{w}_{-}(\mathcal{P},x).$$

$$\forall x,y\in X,(\rho -\sigma {)}_{xy}=\sum _{j\in [n]:x_j\ne y_j}⟨u_{xj}|v_{yj}⟩.$$

$$O\left(\max \left\{\underset{x\in X}{\max }\sum _j\Vert |v_{xj}⟩{\Vert }^2,\underset{y\in X}{\max }\sum _j\Vert |u_{yj}⟩{\Vert }^2\right\}\frac{\log (1/\epsilon )}{{\epsilon }^2}\right).$$

$$w_{+}(\mathcal{P},x):=\sum _j\Vert |v_{xj}⟩{\Vert }^2$$

$$w_{-}(\mathcal{P},x):=\sum _j\Vert |u_{xj}⟩{\Vert }^2$$

$$W_{+}(\mathcal{P})=W_{+}:=\underset{x\in X}{\max }{w}_{+}(\mathcal{P},x)$$

$$W_{-}(\mathcal{P})=W_{-}:=\underset{x\in X}{\max }{w}_{-}(\mathcal{P},x)$$

$${\tilde{A}}^{\alpha }=\frac{1}{\alpha }|\tau ⟩⟨\hat{0}|+A.$$

$$U(\mathcal{P},x,\alpha )=(2{\Pi }_x-I)(2{\Lambda }^{\alpha }-I).$$

$$Pr(error)$$

$$Pr(erri)\le a_i$$

$$Pr(conti)\le 1.$$

$$1-(1-e^{-N_i/18})=a_i.$$

$$Pr(conti)$$

$$Pr(final)$$

$$Pr(error)$$

$$\sum _{i=0}^{i^{\ast }}{a}_i$$

$$\sum _{i=1}^{T-i^{\ast }+1}(a_T{)}^i<\frac{e^{-(N-T)}}{1-e^{-(N-T)}}<\delta /2.$$

$$Pr(erri)\le a_i^2\le a_i,$$

$$Pr(contj)$$

$$\mathbb{E}[Q_x]=\sum _{i=0}^T\left(\prod _{j=0}^{i-1}Pr(contj)\right)\cdot (1-Pr(conti))\cdot Q(i).$$

$$Q(i)=\sum _{j=0}^{i}O\left(2^j{N}_j\right).$$

$$\mathbb{E}[Q_x]$$

$$\sum _{j=0}^i{2}^j(N-j)\le 2^{i+1}(N-i+1),\text{and}$$

$$\sum _{i=i^{\ast }+1}^T{2}^{-i}(T-i)\le 2^{-i^{\ast }}(T-i^{\ast })$$

$$\mathbb{E}[Q_x]=O\left(2^{i^{\ast }}(N-i^{\ast }+1)\right).$$

$$\mathbb{E}[Q_x]=O\left(\sqrt{w_{+}(\mathcal{P},x)W_{-}(\mathcal{P},f)}\log \left(\frac{W_{+}(\mathcal{P},f)}{w_{+}(\mathcal{P},x)\delta }\right)\right),$$

$$\mathbb{E}[Q_x]=O\left(\sqrt{w_{-}(\mathcal{P},x)W_{+}(\mathcal{P},f)}\log \left(\frac{W_{-}(\mathcal{P},f)}{w_{-}(\mathcal{P},x)\delta }\right)\right),$$

$$\sum _{j=0}^{T}O\left(2^j{N}_j\right)=O\left(\sqrt{W_{+}{W}_{-}}\log (1/\delta )\right),$$

$$O\left(\frac{\sqrt{w_{+}(\mathcal{P},x)W_{-}(\mathcal{P})}}{{\epsilon }^5}\log \left(\frac{1}{\epsilon }\right)\log \left(\frac{W_{+}(\mathcal{P})}{w_{+}(\mathcal{P},x)\delta }\log \left(\frac{1}{\epsilon }\right)\right)\right).$$

Full text

1 Introduction

Quantum algorithms often perform better when given a promise on the input. For example, if we know that there are $M$ marked items out of $N$, or no marked items at all, then Grover’s search can be run in time and query complexity $O(\sqrt{N/M})$, rather than $O(\sqrt{N})$, the worst case complexity with a single marked item [Gro97, Aha99].

In the case of Grover’s algorithm, a series of results [BBHT98, BHMT00, BHT98] removed the promise; if there are $M$ marked items, there is a quantum search algorithm that runs in $O(\sqrt{N/M})$ complexity, even without knowing the number of marked items ahead of time. Most relevant for our work, several of these algorithms involve iteratively running Grover’s search with exponentially growing runtimes [BBHT98, BHMT00] until a marked item is found.

Grover’s algorithm was one of the first quantum query algorithms discovered [Gro97]. Since that time, span programs and the dual of the general adversary bound were developed, providing frameworks for creating optimal query algorithms for function decision problems [Rei09, Rei11] and nearly optimal algorithms for state conversion problems, in which the goal is to generate a quantum state based on an oracle and an input state [LMR*+*11]. Moreover, these frameworks are also useful in practice [BT20, BR12a, Bel12, BR20, CMB18, DKW19].

For some span program algorithms, analogous to multiple marked items in Grover’s search, there are features which, if promised to exist, allow for improvement over the worst case query complexity. For example, a span program algorithm for deciding $st$-connectivity uses $O\left(n^{3/2}\right)$ queries on an $n$-vertex graph. However, if promised that the shortest path, if it exists, has length at most $k$, then the problem can be solved with $O(\sqrt{k}n)$ queries [BR12a].

Our contribution is to remove the requirement of the promise; we improve the query complexity of generic span program and state conversion algorithms in the case that some speed-up inducing property (such as multiple marked items or a short path) is present, even without knowing about the structure in advance. One might expect this is trivial: surely if an algorithm produces a correct result with fewer queries when promised a property is present, then it should also produce a correct result with fewer queries without the promise if the property still holds? While this is true and these algorithms always output a result, even if run with fewer queries, the problem is that they don’t produce a flag of completion, and their output cannot always be easily verified. Without a flag of completion or a promise of structure, it is impossible to be confident that the result is correct. Span program and state conversion algorithms differ from Grover’s algorithm in their lack of a flag; in Grover’s algorithm one can use a single query to test whether the output is a marked item, thus flagging that the output of the algorithm is correct, and that the algorithm has run for a sufficiently long time. We note that when span program algorithms previously have claimed an improvement with structure, they always included a promise, or they give the disclaimer that running the algorithm will be incorrect with high probability if the promise is not known ahead of time to be satisfied, e.g. Ref. [CMB18, App. C.3].

We use an approach that is similar to the iterative modifications to Grover’s algorithm; we run subroutines for exponentially increasing times, and we have novel ways to flag when the computation should halt. On the hardest inputs, our algorithms match the asymptotic performance of existing bounded error algorithms. On easier inputs, our approach on average matches the asymptotic performance, up to log factors, of existing algorithms when those existing algorithms additionally have an optimal promise.

Because our algorithms use fewer queries on easier inputs without needing to know they are easier inputs, they provide the possibility of improved average query complexity over input oracles when there is a distribution of easier and harder inputs. In this direction, we generalize a result by Montanaro that showed a super-exponential quantum advantage in average query complexity for the problem of searching for a single marked item under a certain distribution [Mon10]. In particular, we provide a framework for proving similar advantages using quantum algorithms based on classical decision trees, opening up the potential for a broader range of applications than the approach used by Montanaro. We apply this technique to prove an exponential and superpolynomial quantum advantage in average query complexity for searching for multiple items and searching for the first occurring marked items, respectively.

Where prior work showed improvements for span program algorithms with a promise, our results immediately provide an analogous improvement without the promise:

• •

For undirected $st$-connectivity described above, our algorithm determines whether there is a path from $s$ to $t$ in an $n$-vertex graph with $\tilde{O}(\sqrt{k}n)$ queries if there is a path of length $k$, and if there is no path, the algorithm uses $\tilde{O}(\sqrt{nc})$ queries, where $c$ is the size of the smallest cut between $s$ and $t$. In either case, $k$ and $c$ need not be known ahead of time.

• •

For an $n$-vertex undirected graph, we can determine if it is connected in $\tilde{O}(n\sqrt{R})$ queries, where $R$ is the average effective resistance, or not connected in $\tilde{O}(\sqrt{n^{3}/\kappa})$ queries, where $\kappa$ is the number of components. These query complexities hold without knowing $R$ or $\kappa$ ahead of time. See Ref. [JJKP18] for the promise version of this problem.

• •

For cycle detection on an $n$-vertex undirected graph, whose promise version was analyzed in Ref. [DKW19], if the circuit rank is $C$, then our algorithm will detect a cycle in $\tilde{O}(\sqrt{n^{3}/C})$ queries, while if there is no cycle and at most $\mu$ edges, the algorithm will decide there is no cycle in $\tilde{O}(\mu\sqrt{n})$ queries. This holds without knowing $C$ or $\mu$ ahead of time.

To achieve our results for decision problems, we modify the original span program function evaluation algorithm to create two one-sided error subroutines. In the original span program algorithm, the final measurement tells you with high probability whether $f(x)=1$ or $f(x)=0.$ In one of our subroutines, the final measurement certifies that with high probability $f(x)=1$, providing our flag of completion, or it signals that more queries are needed to determine whether $f(x)=1$. The other behaves similarly for $f(x)=0$. By interleaving these two subroutines with exponentially increasing queries, we achieve our desired performance.

The problem is more challenging for state conversion, as the standard version of that algorithm does not involve any measurements, and so there is nothing to naturally use as a flag of completion. We thus design a novel probing routine that iteratively tests exponentially increasing query complexities until a sufficient level is reached, before then running an algorithm similar to the original state conversion algorithm.

While we analyze query complexity, the algorithms we create have average time complexity on input $x$ that scales like $O(T_{U}\mathbb{E}[Q_{x}])$, where $\mathbb{E}[Q_{x}]$ is the average query complexity on input $x$, and $T_{U}$ is the time complexity of implementing an input-independent unitary. Since the existing worst-case span program and state conversion algorithms have time complexities that scale as $O(\max_{x}T_{U}\mathbb{E}[Q_{x}])$, our algorithms also improve in average time complexity relative to the original algorithms on easier inputs. For certain problems, like $st$-connectivity [BR12b] and search [CJOP20], it is known that $T_{U}=\tilde{O}(1)$, meaning that the query complexities of our algorithms for these problems match the time complexity up to log factors.

1.1 Directions for Future Work

Ambainis and de Wolf show that while there is no quantum query advantage for the problem of majority in the worst case, on average there is a quadratic quantum advantage [AdW01]. However, their quantum algorithm uses a technique that is specific to the problem of majority, and it is not clear how it might extend to other problems. On the other hand, since our approach is based on span programs, a generic optimal framework, it may provide opportunities of proving similar results for more varied problems.

In the original state conversion algorithm, to achieve an error of $\varepsilon$ in the output state (by some metric), the query complexity scales as $O\left(\varepsilon^{-2}\right)$ [LMR*+*11]. In our result, the query complexity scales as $O\left(\varepsilon^{-5}\right)$. While this does not matter for applications like discrete function evaluation, as considered in Section 4.2, in cases where accuracy must scale with the input size, this error term could overwhelm any advantage from our approach, and so it would be beneficial to improve this error scaling.

Ito and Jeffery [IJ19] give an algorithm to estimate the positive witness size (a measure of how easy an instance is) with fewer queries on easier inputs. While there are similarities between our approaches, neither result seems to directly imply the other. Better understanding the relationship between these strategies could lead to improved algorithms for determining properties of input structure for both span programs and state conversion problems.

Our work can be contrasted with the work of Belovs and Yolcu [BY23], which also has a notion of reduced query complexity on easier inputs. Their work focuses on the “Las Vegas query complexity,” which is related to the amount of the state that a controlled version of the oracle acts on over the course of the algorithm, and which is an input-dependent quantity. They show the “Monte Carlo query complexity,” what we call the query complexity, is bounded by the Las Vegas query complexity of the worst-case input. We suspect that using techniques similar to those in our work, it would be possible to modify their algorithm to obtain an algorithm with input-dependent average query complexity that scales roughly with the geometric mean of the Las Vegas and Monte Carlo complexities for that input, without knowing anything about the input ahead of time.

2 Preliminaries

Basic Notation: For $n>2$, let $[n]$ represent $\{1,2,\dots,n\}$, while for $n=2$, $[n]=\{0,1\}$. We use $\log$ to denote base 2 logarithm. For set builder notation like $\{r_{z}:z\in Z\}$ we will frequently use $\{r_{z}\}_{z\in Z}=\{r_{z}\}$, where we drop the subscript outside the curly brackets if clear from context. We denote a linear operator from the space $V$ to the space $U$ as ${\mathcal{L}}(V,U)$. We use $I$ for the identity operator. (It will be clear from context which space $I$ acts on.) Given a projection $\Pi$, its complement is $\overline{\Pi}=I-\Pi.$ For a matrix $M$, by $M_{xy}$ or $(M)_{xy}$, we denote the element in the $x^{\textrm{th}}$ row and $y^{\textrm{th}}$ column of $M$. By $\tilde{O}$, we denote big-O notation that ignores log factors. The $l_{2}$-norm of a vector $|v\rangle$ is denoted by $\||v\rangle\|$. For any unitary $U$, let $P_{\Theta}(U)$ be the projection onto the eigenvectors of $U$ with phase at most $\Theta$. That is, $P_{\Theta}(U)$ is the projection onto $\textrm{span}\{|u\rangle:U|u\rangle=e^{i\theta}|u\rangle\textrm{ with }|\theta|\leq\Theta\}$. For a function $f:D\rightarrow[m]$, we define $f^{-1}(b)=\{x\in D:f(x)=b\}.$

2.1 Quantum Algorithmic Building Blocks

We consider quantum query algorithms, in which one can access a unitary $O_{x}$, called the oracle, which encodes a string $x\in X$ for $X\subseteq[q]^{n}$, $q\geq 2$. The oracle acts on the Hilbert space $\mathbb{C}^{n}\otimes\mathbb{C}^{q}$ as $O_{x}|i\rangle|b\rangle=|i\rangle|x_{i}+b\textrm{ mod }q\rangle$, where $x_{i}\in[q]$ is the $i^{\textrm{th}}$ element of $x$.

Given $O_{x}$ for $x\in X$, we would like to perform a computation that depends on $x$. The query complexity is the minimum number of uses of the oracle required such that for all $x\in X$, the computation is successful with some desired probability of success. We denote by $\mathbb{E}[Q_{x}]$ the average number of queries used by the algorithm on input $x$ where the expectation is over the algorithm’s internal randomness. Given a probability distribution $\{p_{x}\}_{x\in X}$ over the elements of $X$, then $\sum_{x\in X}p_{x}\mathbb{E}[Q_{x}]$ is the average quantum query complexity of performing the computation with respect to $\{p_{x}\}.$

Several of our key algorithmic subroutines use a parallelized version of phase estimation [MNRS11], in which for a unitary $U$, a precision $\Theta>0$, and an accuracy $\epsilon>0$, a circuit $D(U)$ implements $O(\log\frac{1}{\epsilon})$ copies of the phase estimation circuit on $U$, each to precision $O(\Theta)$, that all measure the phase of a single state on the same input register. If $U$ acts on a Hilbert Space ${\mathcal{H}}$, then $D(U)$ acts on the space ${\mathcal{H}}_{A}\otimes((\mathbb{C}^{2})^{\otimes b})_{B}$ for $b=O\left(\log\frac{1}{\Theta}\log\frac{1}{\epsilon}\right)$, where we have used $A$ to label the register that stores the input state, and $B$ to label the registers that store the results of the parallel phase estimations.

The circuit $D(U)$ can be used for Phase Checking: applying $D(U)$ to $|\psi\rangle_{A}|0\rangle_{B}$ and then measuring register $B$ in the standard basis; the probability of outcome $|0\rangle_{B}$ provides information on whether $|\psi\rangle$ is close to an eigenvector of $U$ that has eigenphase close to [math] (in particular, with eigenphase within $\Theta$ of [math]). To characterize this probability, we define $\Pi_{0}(U)$ to be the orthogonal projection onto the subspace of ${\mathcal{H}}_{A}\otimes((\mathbb{C}^{2})^{\otimes b})_{B}$ that $D(U)$ maps to states with $|0\rangle_{B}$ in the $B$ register. That is, $\Pi_{0}(U)=D(U)^{\dagger}\left(I_{A}\otimes|0\rangle\!\langle 0|_{B}\right)D(U).$ (Since $\Pi_{0}(U)$ depends on the choice of $\Theta$ and $\epsilon$ used in $D(U)$, those values must be specified, if not clear from context, when discussing $\Pi_{0}(U)$.) We now summarize prior results for Phase Checking in Lemma 1:

Lemma 1** (Phase Checking [Kit95, CEMM98, MNRS11]).**

Let $U$ be a unitary on a Hilbert Space ${\mathcal{H}}$, and let $\Theta,\epsilon>0$. We call $\Theta$ the precision and $\epsilon$ the accuracy. Then there is a circuit $D(U)$ that acts on the space ${\mathcal{H}}_{A}\otimes((\mathbb{C}^{2})^{\otimes b})_{B}$ for $b=O\left(\log\frac{1}{\Theta}\log\frac{1}{\epsilon}\right)$, and that uses $O\left(\frac{1}{\Theta}\log\frac{1}{\epsilon}\right)$ calls to control-$U$. Then for any state $|\psi\rangle\in{\mathcal{H}}$

• •

$\|P_{0}(U)|\psi\rangle\|^{2}\leq\|\Pi_{0}(U)\left(|\psi\rangle_{A}|0\rangle_{B}\right)\|^{2}\leq\|P_{\Theta}(U)|\psi\rangle\|^{2}+\epsilon,$* and*

• •

$\|\Pi_{0}(U)\left(\overline{P}_{\Theta}(U)|\psi\rangle\right)_{A}|0\rangle_{B}\|^{2}\leq\epsilon.$**

We also consider implementing $D(U)$ as described above, applying a $-1$ phase to the $A$ register if the $B$ register is not in the state $|0\rangle_{B}$, and then implementing $D(U)^{\dagger}$. We call this circuit Phase Reflection222In Ref. [LMR*+*11], this procedure is referred to as “Phase Detection,” but since no measurement is made, and rather only a reflection is applied, we thought renaming this protocol as “Phase Reflection” would be more descriptive and easier to distinguish from “Phase Checking.” We apologize for any confusion this may cause when comparing to prior work. and denote it as $R(U).$ Note that $R(U)=\Pi_{0}(U)-\overline{\Pi}_{0}(U)$, where $R(U)$ and $\Pi_{0}(U)$ have the same implicit precision $\Theta$ and accuracy $\epsilon$. The following lemma summarizes prior results on relevant properties of Phase Reflection.

Lemma 2** (Phase Reflection [MNRS11, LMR*+*11]).**

Let $U$ be a unitary on a Hilbert Space ${\mathcal{H}}$, and let $\Theta,\epsilon>0$. We call $\Theta$ the precision and $\epsilon$ the accuracy. Then there is a circuit $R(U)$ that acts on the space ${\mathcal{H}}_{A}\otimes((\mathbb{C}^{2})^{\otimes b})_{B}$ for $b=O\left(\log\frac{1}{\Theta}\log\frac{1}{\epsilon}\right)$, and that uses $O\left(\frac{1}{\Theta}\log\frac{1}{\epsilon}\right)$ calls to control-$U$ and control-$U^{\dagger}$, such that for any state $|\psi\rangle\in{\mathcal{H}}$

• •

$R(U)(P_{0}(U)|\psi\rangle)|0\rangle_{B}=(P_{0}(U)|\psi\rangle)_{A}|0\rangle_{B}$, and

• •

$\|(R(U)+I)(\overline{P}_{\Theta}(U)|\psi\rangle)_{A}|0\rangle_{B}\|<\epsilon$.

We will use Iterative Quantum Amplitude Estimation [GGZW21], which is like standard quantum amplitude estimation [BHMT00], but with exponentially better success probability:

Lemma 3** (Iterative Quantum Amplitude Estimation [GGZW21]).**

Let $\delta>0$ and $\mathcal{A}$ be a quantum circuit such that on a state $|\psi\rangle$, $\mathcal{A}|\psi\rangle=\alpha_{0}|0\rangle|\psi_{0}\rangle+\alpha_{1}|1\rangle|\psi_{1}\rangle$. Then there is an algorithm that estimates $|\alpha_{0}|^{2}$ to additive error $\delta$ with success probability at least $1-p$ using $O\left(\frac{1}{\delta}\log\left(\frac{1}{p}\log\frac{1}{\delta}\right)\right)$calls to $\mathcal{A}$ and $\mathcal{A}^{\dagger}$.

A key lemma in span program and state conversion algorithms is the effective spectral gap lemma:

Lemma 4** (Effective spectral gap lemma, [LMR*+*11]).**

Let $\Pi$ and $\Lambda$ be projections, and let $U=(2\Pi-I)(2\Lambda-I)$ be the unitary that is the product of their associated reflections. If $\Lambda|w\rangle=0$, then $\|P_{\Theta}(U)\Pi|w\rangle\|\leq\frac{\Theta}{2}\||w\rangle\|.$

2.2 Span Programs

Span programs are a tool for designing quantum query algorithms for decision problems.

Definition 5** (Span Program).**

A span program is a tuple ${\mathcal{P}}=(H,V,\tau,A)$ on $[q]^{n}$ where

$H$* is a direct sum of finite-dimensional inner product spaces: $H=H_{1}\oplus H_{2}\cdots H_{n}\oplus H_{\textrm{true}}\oplus H_{\textrm{false}},$ and for $j\in[n]$ and $a\in[q]$, we have $H_{j,a}\subseteq H_{j}$, such that $\sum_{a\in[q]}H_{j,a}=H_{j}$.* 2. 2.

$V$* is a vector space* 3. 3.

$\tau\in V$* is a target vector, and* 4. 4.

$A\in{\mathcal{L}}(H,V)$.

Given a string $x\in[q]^{n}$, we use $H(x)$ to denote the subspace $H_{1,x_{1}}\oplus\cdots\oplus H_{n,x_{n}}\oplus H_{\textrm{true}}$, and we denote by $\Pi_{{H}(x)}$ the orthogonal projection onto the space $H(x)$.

We use Definition 5 for span programs because it applies to both binary and non-binary inputs ($q\geq 2$). The definitions in Refs. [BR12a, CMB18] only apply to binary inputs ($q=2$).

Definition 6** (Positive and Negative Witness).**

Given a span program ${\mathcal{P}}=(H,V,\tau,A)$ on $[q]^{n}$ and $x\in[q]^{n}$, then $|w\rangle\in H(x)$ is a positive witness for $x$ in ${\mathcal{P}}$ if $A|w\rangle=\tau$. If a positive witness exists for $x$, we define the positive witness size of $x$ in ${\mathcal{P}}$ as

[TABLE]

Then $|w\rangle\in H(x)$ is an optimal positive witness for $x$ if $\||w\rangle\|^{2}={w_{+}({\mathcal{P}},{x})}$ and $A|w\rangle=\tau$.

We say $\omega\in{\mathcal{L}}(V,\mathbb{R})$ is a negative witness for $x$ in $\mathcal{P}$ if $\omega\tau=1$ and $\omega A\Pi_{{H}(x)}=0$. If a negative witness exists for $x$, we define the negative witness size of $x$ in $\mathcal{P}$ as

[TABLE]

Then $\omega$ is an optimal negative witness for $x$ if $\|\omega A\|^{2}={w_{-}({\mathcal{P}},{x})}$, $\omega A\Pi_{{H}(x)}=0,$ and $\omega\tau=1$.

Each $x\in[q]^{n}$ has a positive or negative witness (but not both).

We say that a span program ${\mathcal{P}}$ decides the function $f:X\subseteq[q]^{n}\rightarrow\{0,1\}$ if each $x\in f^{-1}(1)$ has a positive witness in ${\mathcal{P}}$, and each $x\in f^{-1}(0)$ has a negative witness in ${\mathcal{P}}$. Then we denote the maximum positive and negative witness of ${\mathcal{P}}$ on $f$ as

[TABLE]

Given a span program that decides a function, one can use it to design an algorithm that evaluates that function with query complexity that depends on $W_{+}({\mathcal{P}},f)$ and $W_{-}({\mathcal{P}},f)$:

Theorem 7** ([Rei09, IJ19]).**

For $X\subseteq[q]^{n}$ and $f:X\rightarrow\{0,1\}$, let ${\mathcal{P}}$ be a span program that decides $f$. Then there is a quantum algorithm that for any $x\in X$, evaluates $f(x)$ with bounded error, and uses $O\left(\sqrt{W_{+}({\mathcal{P}},f)W_{-}({\mathcal{P}},f)}\right)$ queries to the oracle $O_{x}$.

Not only can any span program that decides a function $f$ be used to create a quantum query algorithm that decides $f$, but there is always a span program that creates an algorithm with asymptotically optimal query complexity [Rei09, Rei11]. Thus when designing quantum query algorithms for function decision problems, it is sufficient to consider only span programs.

Given a function $f:X\rightarrow\{0,1\}$, we denote the negation of the $f$ as $f^{\neg}$, where $\forall x\in X,f^{\neg}(x)=\neg f(x)$. We use a transformation that takes a span program ${\mathcal{P}}$ that decides a function $f:X\rightarrow\{0,1\}$ and creates a span program ${\mathcal{P}}^{\dagger}$ that decides $f^{\neg}$, while preserving witness sizes for each input $x$. While such a transformation is known for Boolean span programs [Rei09], in Lemma 8 we show it exists for the span programs of Definition 5. The proof is in Appendix A.

Lemma 8**.**

Given a span program ${\mathcal{P}}=(H,V,\tau,A)$ on $[q]^{n}$ that decides a function $f:X\rightarrow\{0,1\}$ for $X\subseteq[q]^{n}$, there is a span program ${\mathcal{P}}^{\dagger}=(H^{\prime},V^{\prime},\tau^{\prime},A^{\prime})$ that decides $f^{\neg}$ such that $\forall x\in f^{-1}(1),{w_{+}({{\mathcal{P}}},{x})}={w_{-}({{\mathcal{P}}^{\dagger}},{x})}$ and $\forall x\in f^{-1}(0),{w_{-}({{\mathcal{P}}},{x})}={w_{+}({{\mathcal{P}}^{\dagger}},{x})}$.

2.3 State Conversion

In the state conversion problem, for $X\subseteq[q]^{n}$, we are given descriptions of sets of pure states $\{|\rho_{x}\rangle\}_{x\in X}$ and $\{|\sigma_{x}\rangle\}_{x\in X}$. Then given access to an oracle for $x$, and the quantum state $|\rho_{x}\rangle$, the goal is to create a state $|\sigma_{x}^{\prime}\rangle$ such that $\||\sigma_{x}^{\prime}\rangle-|\sigma_{x}\rangle|0\rangle\|\leq\varepsilon$. We call $\varepsilon$ the error of the state conversion procedure.

Let $\rho$ and $\sigma$ be the Gram matrices of the sets $\{|\rho_{x}\rangle\}$ and $\{|\sigma_{x}\rangle\}$, respectively, so $\rho$ and $\sigma$ are matrices whose rows and columns are indexed by the elements of $X$ such that $\rho_{xy}=\langle{\rho_{x}}|{\rho_{y}}\rangle,$ and $\sigma_{xy}=\langle{\sigma_{x}}|{\sigma_{y}}\rangle.$

We now define the analogue of a span program for the problem of state conversion, which we call a converting vector set:

Definition 9** (Converting vector set).**

Let $\mathscr{P}=\left(\{|v_{xj}\rangle\},\{|u_{xj}\rangle\}\right)_{x\in X,j\in[n]}$, where $\forall x\in X,j\in[n],|v_{xj}\rangle,|u_{xj}\rangle\in\mathbb{C}^{d}$ for some $d\in\mathbb{N}$. Then we say $\mathscr{P}$ converts $\rho$ to $\sigma$ if it satisfies

[TABLE]

We call such a $\mathscr{P}$ a converting vector set from $\rho$ to $\sigma$.

Then the query complexity of state conversion is characterized as follows:

Theorem 10** ([LMR*+*11]).**

Given $X\in[q]^{n}$ and a converting vector set $\mathscr{P}=\left(\{|v_{xj}\rangle\},\{|u_{xj}\rangle\}\right)_{x\in X,j\in[n]}$ from $\rho$ to $\sigma$, then there is quantum algorithm that on every input $x\in X$ converts $|\rho_{x}\rangle$ to $|\sigma_{x}\rangle$ with error $\varepsilon$ and has query complexity

[TABLE]

Analogous to witness sizes in span programs, we define a notion of witness sizes for converting vector sets:

Definition 11** (Converting vector set witness sizes).**

Given a converting vector set $\mathscr{P}=\left(\{|u_{xj}\rangle\},\{|v_{xj}\rangle\}\right)$, we define the witness sizes of $\mathscr{P}$ as

[TABLE]

By scaling the converting vector sets, we obtain the following two results: a rephrasing of Theorem 10 in terms of witness sizes, and a transformation that exchanges positive and negative witness sizes. Both proofs can be found in Appendix A.

Corollary 12**.**

Let $\mathscr{P}$ be a converting vector set from $\rho$ to $\sigma$ with maximum positive and negative witness sizes $W_{+}$ and $W_{-}$. Then there is quantum algorithm that on every input $x\in X$ converts $|\rho_{x}\rangle$ to $|\sigma_{x}\rangle$ with error $\varepsilon$ and uses $O\left(\sqrt{W_{+}W_{-}}\frac{\log(1/\varepsilon)}{\varepsilon^{2}}\right)$ queries to $O_{x}$.

Lemma 13**.**

If $\mathscr{P}$ converts $\{|\rho_{x}\rangle\}_{x\in X}$ to $\{|\sigma_{x}\rangle\}_{x\in X}$ , then there is a complementary converting vector set $\mathscr{P}^{\dagger}$ that also converts $\rho$ to $\sigma$, such that for all $x\in X$ and for all $j\in[n]$, we have $w_{+}(\mathscr{P},x)=w_{-}(\mathscr{P}^{\dagger},x)$, and $w_{-}(\mathscr{P},x)=w_{+}(\mathscr{P}^{\dagger},x)$; the complement exchanges the values of the positive and negative witness sizes.

3 Function Decision

Our main result for function decision (deciding if $f(x)=0$ or $f(x)=1$) is the following:

Theorem 14**.**

For $X\subseteq[q]^{n}$, let ${\mathcal{P}}$ be a span program that decides $f:X\rightarrow\left\{0,1\right\}$. Then there is a quantum algorithm such that for any $x\in X$ and $\delta>0$

The algorithm returns $f(x)$ with probability $1-\delta$. 2. 2.

On input $x$, if $f(x)=1$ the algorithm uses $O\left(\sqrt{{w_{+}({x})}W_{-}}\log\left(\frac{W_{+}}{{w_{+}({x})}\delta}\right)\right)$ queries on average, and if $f(x)=0$ it uses $O\left(\sqrt{{w_{-}({x})}W_{+}}\log\left(\frac{W_{-}}{{w_{-}({x})}\delta}\right)\right)$ queries on average. 3. 3.

The worst-case (not average) query complexity is $O\left(\sqrt{W_{+}W_{-}}\log(1/\delta)\right)$.

Comparing Theorem 14 to Theorem 7 (which assumes constant error $\delta$), we see that in the worst case, with an input $x$ where ${w_{+}({x})}=W_{+}$ or ${w_{-}({x})}=W_{-}$, the average and worst-case performance of our algorithm is the same as the standard span program algorithm. However, when we have an instance $x$ with a smaller witness size, then our algorithm has improved average query complexity, without having to know about the witness size ahead of time.

We can also compare the query complexity our algorithm, which does not require a promise, to the original span program algorithm when that algorithm is additionally given a promise. If the original span program algorithm is promised that, if $f(x)=1$, then ${w_{+}({x})}=O(\sf w)$, then the bounded error query complexity of the original algorithm on this input would be $O(\sqrt{{\sf w}W_{-}})$ by Theorem 7. On the other hand, without needing to know ahead of time that ${w_{+}({x})}=O(\sf w)$, our algorithm would use $\tilde{O}(\sqrt{\sf wW_{-}})$ queries on this input on average, and in fact would do better than this if ${w_{+}({x})}=o(\sf w)$.

A key routine in our algorithm is to apply Phase Checking to a unitary ${U({{\mathcal{P}}},{x},{\alpha})}$, which we describe now. We follow notation similar to that in [BR12a]. In particular, for a span program ${\mathcal{P}}=(H,V,\tau,A)$ on $[q]^{n}$, let $\tilde{H}=H\oplus\textrm{span}\{|\hat{0}\rangle\},$ and $\tilde{H}(x)=H(x)\oplus\textrm{span}\{|\hat{0}\rangle\},$ where $|\hat{0}\rangle$ is orthogonal to $H$ and $V$. Then we define ${\tilde{A}^{\alpha}}\in{\mathcal{L}}(\tilde{H},V)$ as

[TABLE]

Let ${\Lambda^{\!{\alpha}}}\in{\mathcal{L}}(\tilde{H},\tilde{H})$ be the orthogonal projection onto the kernel of ${\tilde{A}^{\alpha}}$, and let $\Pi_{x}\in{\mathcal{L}}(\tilde{H},\tilde{H})$ be the projection onto $\tilde{H}(x).$ Finally, let

[TABLE]

Note that $2\Pi_{x}-I$ can be implemented with two applications of $O_{x}$ [IJ19, Lemma 3.1], and $2{\Lambda^{\!{\alpha}}}-I$ can be implemented without any applications of $O_{x}$. Queries are only made in our algorithm when we apply ${U({{\mathcal{P}}},{x},{\alpha})}$. To analyze the query complexity, we will track the number of applications of ${U({{\mathcal{P}}},{x},{\alpha})}.$

The time complexity will also scale with the number of applications of ${U({{\mathcal{P}}},{x},{\alpha})}.$ We denote the time required to implement ${U({{\mathcal{P}}},{x},{\alpha})}$ by $T_{U}$, which is an input independent quantity. Since our query complexity analysis counts the number of applications of ${U({{\mathcal{P}}},{x},{\alpha})}$, and the runtime scales with the number of applications of ${U({{\mathcal{P}}},{x},{\alpha})}$, to bound the average time complexity of our algorithms, simply determine $T_{U}$ and multiply this by the query complexity.

The following lemma gives us guarantees about the results of Phase Checking of ${U({{\mathcal{P}}},{x},{\alpha})}$ applied to the state $|\hat{0}\rangle$:

Lemma 15**.**

Let the span program ${\mathcal{P}}$ decide the function $f$, and let $C\geq 2$. Then for Phase Checking with unitary ${U({{\mathcal{P}}},{x},{\alpha})}$ on the state $|\hat{0}\rangle_{A}|0\rangle_{B}$ with error $\epsilon$ and precision $\Theta=\sqrt{\frac{\epsilon}{\alpha^{2}W_{-}}}$,

If $f(x)=1$, and $\alpha^{2}\geq C{w_{+}({{\mathcal{P}}},{x})}$, then the probability of measuring the $B$ register to be in the state $|0\rangle_{B}$ is at least $1-1/C$. 2. 2.

If $f(x)=0$ and $\alpha^{2}\geq 1/W_{-}({\mathcal{P}},f)$, then the probability of measuring the $B$ register in the state $|0\rangle_{B}$ is at most $\frac{3}{2}\epsilon.$

Note that if $f(x)=1$ and $\alpha^{2}<C{w({{\mathcal{P}}},{x})}$, Lemma 15 makes no claims about the output.

To prove Lemma 15, we use techniques from the Boolean function decision algorithm of Belovs and Reichardt [BR12a, Section 5.2] and Cade et al. [CMB18, Section C.2] and the dual adversary algorithm of Reichardt [Rei11, Algorithm 1]. Our approach differs from these previous algorithms in the addition of a parameter that controls the precision of our phase estimation. This approach has not (to the best of our knowledge)333Jeffery and Ito [IJ19] also design a function decision algorithm for non-Boolean span programs, but it has a few differences from our approach and from that of Refs. [BR12a, CMB18]; for example, the initial state of Jeffery and Ito’s algorithm might require significant time to prepare, while our initial state can be prepared in $O(1)$ time. been applied to the non-Boolean span program formulation of Definition 5, so while not surprising that it works in this setting, our analysis in Appendix B may be of independent interest for other applications.

We use Alg. 1 to prove Theorem 14.

High Level Idea of Alg. 1 The algorithm makes use of a test that, when successful, tells us that $f(x)=1$. However, the test is one-sided, in that failing the test does not mean that $f(x)=0$, but instead is inconclusive. We repeatedly run this test for both functions $f$ and $f^{\neg}$ while increasing the queries used at each round. If we see an inconclusive result for both $f$ and $f^{\neg}$ at an intermediate round, we can conclude neither $f(x)=1$ nor $f(x)=0$, so we repeat the subroutine with larger queries. Once we reach a critical round that depends on ${w_{+}({x})}$ (if $f(x)=1$) or on ${w_{-}({x})}$ (if $f(x)=0$), the probability of an inconclusive result becomes unlikely from that critical round onward.

We stop iterating when the test returns a conclusive result, or when we have passed the critical round for all $x$. While it is unlikely that we get an inconclusive result at the final round, we return 1 if this happens.

More specifically, we use Phase Checking to perform our one-sided test; we iteratively run Phase Checking on ${U({\mathcal{P}},{x},{\alpha_{+}})}$ in Alg. 1 to check if $f(x)=1$, and on ${U({\mathcal{P}^{\dagger}},{x},{\alpha_{-}})}$ in Alg. 1 to check if $f(x)=0$, increasing the parameters $\alpha_{+}$ and $\alpha_{-}$ by a factor of 2 at each round. At some round, which we label $i^{*}$, $\alpha_{+}^{2}$ becomes at least $3{w_{+}({\mathcal{P}},{x})}$ or $\alpha_{-}^{2}$ becomes at least $3{w_{-}({\mathcal{P}},{x})}=3{w_{+}({P^{\dagger}},{x})}$ (by Lemma 13), depending on whether $f(x)=1$ or $f(x)=0$, respectively. Using Lemma 15 Item 1, from round $i^{*}$ onward we have a high probability of measuring the $B$ register to be in the state $|0\rangle_{B}$ at Alg. 1 if $f(x)=1$ or at Alg. 1 if $f(x)=0$, causing the algorithm to terminate and output the correct result. Item 2 of Lemma 15 ensures that at all rounds we have a low probability of outputting the incorrect result. We don’t need to know $i^{*}$ ahead of time; the behavior of the algorithm will change on its own, giving us a smaller average query complexity for instances with smaller witness size, the easier instances.

The number of queries used by Phase Checking increases by a factor of 2 at each round of the for loop. If $N_{i}$, the number of repetitions of Phase Checking at round $i$, were a constant $N$, then using a geometric series, we would find that the query complexity would be asymptotically equal to the queries used by Phase Checking in the round at which the algorithm terminates, times $N$. At round $i^{*}$, the round at which termination is most likely, the query complexity of Phase Checking is $O\left(\sqrt{{w_{+}({\mathcal{P}},{x})}W_{-}(\mathcal{P},f)}\right)$ or $O\left(\sqrt{{w_{-}({\mathcal{P}},{x})}W_{+}(\mathcal{P},f)}\right)$ (depending on if $f(x)=1$ or $f(x)=0$) by Lemma 1. We show the probability of continuing to additional rounds after $i^{*}$ is exponentially decreasing with each extra round, so we find an average query complexity of $O\left(N\sqrt{{w_{+}({\mathcal{P}},{x})}W_{-}(\mathcal{P},f)}\right)$ or $O\left(N\sqrt{{w_{-}({\mathcal{P}},{x})}W_{+}(\mathcal{P},f)}\right)$ on input $x$. Since there can be $T=\left\lceil\log\left(\sqrt{W_{+}W_{-}}\right)\right\rceil$ rounds in Alg. 1 the worst case, this suggests that each round should have a probability of error bounded by $O\left(T^{-1}\right)$, which we can accomplish through repetition and majority voting, but which requires $N=\Omega(\log T)$, adding an extra log factor to our query complexity.

To mitigate this effect, we modify the number of repetitions (given by $N_{i}$ in Alg. 1) over the course of the algorithm so that we have a lower probability of error (more repetitions) at earlier rounds, and a higher probability (fewer repetitions) at later rounds. This requires additional queries at the earlier rounds, but since these rounds are cheaper to begin with, we can spend some extra queries to reduce our error. As a result, instead of a log factor that depends only on $T$, we end up with a log factor that also decreases with increasing witness size, so when ${w_{+}({x})}=W_{+}$ or ${w_{-}({x})}=W_{-}$, our average query complexity is at most $O\left(\sqrt{W_{+}W_{-}}\log(1/\delta)\right)$ without any additional log factors.

Proof of Theorem 14.

We analyze Alg. 1.

We first prove that the total success probability is at least $1-\delta$. Consider the case that $f(x)=0$. Let $i^{*}=\left\lceil\log\sqrt{3{w_{-}({{\mathcal{P}}},{x})}W_{+}({\mathcal{P}},f)}\right\rceil$, which is the round at which we will show our probability of exiting the for loop becomes large. The total number of possible iterations is $T=\left\lceil\log\sqrt{3W_{+}W_{-}}\right\rceil$, which is at least $i^{*}$. Let $N=\lceil T+\log(3/\delta)\rceil+1$, so $N_{i}=18(N-i)$. Let $Pr(cont\textrm{ }i)$ denote the probability of continuing to the next round of the for loop at round $i$, conditioned on reaching round $i$, let $Pr(err\textrm{ }i)$ be the probability of returning the wrong answer at round $i$, conditioned on reaching round $i$, and let $Pr(final)$ be the probability of reaching the end of the for loop without terminating. (Since we return $1$ if we reach the end of the for loop without terminating, this event produces an error when $f(x)=0$.) The total probability of error is then

[TABLE]

We will use the probability tree diagram in Fig. 1(a) to help us analyze events and probabilities.

Since $f(x)=0$, $Pr(err\textrm{ }i)$ is the probability of returning 1, which depends on the probability of measuring $|0\rangle_{B}$ in Phase Checking of ${U({{\mathcal{P}}},{x},{\alpha_{+}})}$ in Alg. 1 of Alg. 1. Since $\alpha_{+}^{2}W_{-}\geq 1$, we can use Item 2 of Lemma 15, to find that there is at most a $\frac{3}{2}\epsilon=1/3$ probability of measuring $|0\rangle_{B}$ at each repetition of Phase Checking. Using Hoeffding’s inequality [Hoe63], the probability of measuring outcome $|0\rangle$ at least $N_{i}/2$ times and returning $1$ in Alg. 1 of Alg. 1 is at most $a_{i}\coloneqq e^{-N_{i}/18}$. Therefore,

[TABLE]

which holds for all $i$ but in particular, gives us a bound on the first left branching of Fig. 1(a), corresponding to outputting a $1$ when $i\geq i^{*}$.

When $i<i^{*}$, we trivially bound the probability of continuing to the next round:

[TABLE]

When $i\geq i^{*}$, we continue to the next round when we do not return 1 in Alg. 1 of Alg. 1 and then do not return 0 in Alg. 1, corresponding to the two right branchings of the diagram in Fig. 1(a). We upper bound the probability of the first event (first right branch in Fig. 1(a)) by

1. To bound the probability of the second event, consider Phase Checking of ${U({{\mathcal{P}}^{\dagger}},{x},{\alpha_{-}})}$ in Alg. 1. Since $i\geq i^{*}$, we have $\alpha_{-}^{2}\geq 3{w_{-}({{\mathcal{P}}},{x})}=3{w_{+}({{\mathcal{P}}^{\dagger}},{x})}$ by Lemma 8. Also since $W_{+}({\mathcal{P}},f)=W_{-}({\mathcal{P}}^{\dagger},f)$ by Lemma 8, we have $\alpha^{2}\geq 1/W_{-}({\mathcal{P}}^{\dagger},f)$. Thus, as we are performing Phase Checking with precision $\sqrt{\epsilon/(\alpha^{2}W_{+}({\mathcal{P}},f))}=\sqrt{\epsilon/(\alpha^{2}W_{-}({\mathcal{P}}^{\dagger},f))}$, we can use Item 1 of Lemma 15 with $C=3$ to conclude that the probability of measuring $|0\rangle_{B}$ at a single repetition of Alg. 1 is at least $2/3$. Using Hoeffding’s inequality [Hoe63], the probability of measuring $|0\rangle_{B}$ more than $N_{i}/2$ times, and therefore returning 0, is at least $1-e^{-N_{i}/18}$. Thus the probability of not returning 0 in Alg. 1 is at most

[TABLE]

Therefore when $i\geq i^{*}$, using the product rule, the probability of following both right branchings of Fig. 1(a) and continuing to the next iteration of the for loop is

[TABLE]

Finally, if we ever reach the end of the for loop without terminating, our algorithm returns 1, which is the wrong answer. This happens with probability

[TABLE]

using Eq. 11 for $i<i^{*}$ and Eq. 13 for $i\geq i^{*}$.

Now we calculate the total probability of error. Plugging in Eq. 10, Eq. 11, Eq. 13, and Eq. 14 into Eq. 9, and splitting the first term of Eq. 9 into two parts to account for the different behavior of the algorithm before and after round $i^{*}$, we get:

[TABLE]

Since $N_{i}=18(N-i)$, we have $a_{i}=e^{-(N-i)}$, which means the first sum in Eq. 15 is a geometric series, and is bounded by:

[TABLE]

where the final inequality arises from our choice of $N=\lceil T+\log(3/\delta)\rceil+1$. Combining the second and third terms of Eq. 15, and upper bounding their $a_{j}$’s and $a_{i}$’s by $a_{T}$, we get another geometric series that sums to less than $\delta/2$:

[TABLE]

Thus, $Pr(error)<\delta$, and our success probability is at least $1-\delta$.

Now we analyze the probability of error for $f(x)=1$ and set $i^{*}=\left\lceil\log\sqrt{3{w_{+}({{\mathcal{P}}},{x})}W_{-}({\mathcal{P}},f)}\right\rceil$. Then nearly identical analyses as in the $f(x)=0$ case (and using Lemma 8 to relate witness sizes of ${\mathcal{P}}$ and ${\mathcal{P}}^{\dagger}$) provide the bounds on probabilities of relevant events, corresponding to branchings in Fig. 1(b). By following the first right branching and then the next left branching in Fig. 1(b), we see the probability of error at round $i$ for $i\geq i^{*}$ is

[TABLE]

since by our choice of parameters, $a_{i}$ is always less than $1$. Following the two right branchings in Fig. 1(b), the probability of continuing when $i\geq i^{*}$ is

[TABLE]

Thus the rest of the analysis is the same, and so we find that for $f(x)=0$ or $f(x)=1$, the probability of success is at least $1-\delta$.

Now we calculate the average query complexity on input $x$, $\mathbb{E}[Q_{x}]$, given by

[TABLE]

Here, $Q(i)$ is the number of queries used by the algorithm up to and including round $i$, and $\left(\prod_{j=0}^{i-1}Pr(cont\textrm{ }j)\right)\cdot(1-Pr(cont\textrm{ }i))$ is the probability that we terminate at round $i$.

The only time we make queries is in the Phase Checking subroutine. By Lemma 1, the number of queries required to run a single repetition of Phase Checking in the $i^{\textrm{th}}$ round is $O\left(\frac{1}{\theta}\log\left(\frac{1}{\epsilon}\right)\right)=O(\alpha_{\pm}\sqrt{W_{\mp}})=O(2^{i})$, since $\epsilon=\Theta(1)$. Taking into account the $N_{i}$ repetitions of Phase Checking in the $i^{\textrm{th}}$ round, we find

[TABLE]

Now setting $i^{*}$ to be $\left\lceil\log\sqrt{3{w_{+}({{\mathcal{P}}},{x})}W_{-}({\mathcal{P}},f)}\right\rceil$ or $\left\lceil\log\sqrt{3{w_{-}({{\mathcal{P}}},{x})}W_{+}({\mathcal{P}},f)}\right\rceil$ depending on whether $f(x)=1$ or [math], respectively, we can use our bounds on event probabilities from our error analysis to bound the relevant probabilities for average query complexity. When $i<i^{*}$, we use the trivial bound $Pr(cont\textrm{ }i)\leq 1$. When $i\geq i^{*}$, we use Eqs. 13 and 19 and our choice of $a_{i}$ to conclude that $Pr(cont\textrm{ }i)\leq a_{i}\leq 1/4$. For all $i$, we use that $(1-Pr(cont\textrm{ }i))\leq 1.$ Splitting up the sum in Eq. 20 into $2$ terms, for $i\leq i^{*}$ and $i>i^{*}$, and using these bounds on $Pr(cont\textrm{ }i)$ along with Eq. 21, we have

[TABLE]

We use the following inequalities to simplify Eq. 22,

[TABLE]

and finally find that

[TABLE]

By our choice of $i^{*}$, $T$, and $N$, on input $x$ when $f(x)=1$, the total query complexity is

[TABLE]

and when $f(x)=0$, the total average query complexity is

[TABLE]

and the worst case query complexity is

[TABLE]

where we have again used Eq. 23. ∎

3.1 Application to st-connectivity

As an example application of our algorithm, we analyze the query complexity of $st$-connectivity on an $n$-vertex graph. There is a span program $\mathcal{P}$ such that for inputs $x$ where there is a path from $s$ to $t$, ${w_{+}({\mathcal{P}},{x})}=R_{s,t}(x)$ where $R_{s,t}(x)$ is the effective resistance from $s$ to $t$ on the subgraph induced by $x$, and for inputs $x$ where there is not a path from $s$ to $t$, ${w_{-}({\mathcal{P}},{x})}=C_{s,t}(x)$, where $C_{s,t}(x)$ is the effective capacitance between $s$ and $t$ [BR12a, JJKP18]. In an $n$-vertex graph, the effective resistance is less than $n$, and the effective capacitance is less than $n^{2}$, so by Theorem 14, we can determine with bounded error that there is a path on input $x$ with $\tilde{O}(\sqrt{R_{s,t}(x)n^{2}})$ average queries or that there is not a path with $\tilde{O}(\sqrt{C_{s,t}(x)n})$ average queries. In the worst case, when $R_{s,t}(x)=n$ or $C_{s,t}(x)=n^{2}$, we recover the worst-case query complexity of $O(n^{3/2})$ of the original span program algorithm.

The effective resistance is at most the shortest path between two vertices, and the effective capacitance is at most the smallest cut between two vertices. Thus our algorithm determines whether or not there is a path from $s$ to $t$ with $\tilde{O}(\sqrt{k}n)$ queries on average if there is a path of length $k$, and if there is no path, the algorithm uses $\tilde{O}(\sqrt{cn})$ queries on average, where $c$ is the size of the smallest cut between $s$ and $t$. Importantly, one does not need to know bounds on $k$ or $c$ ahead of time to achieve this query complexity.

The analysis of the other examples listed in Section 1 is similar.

4 State Conversion Algorithm

Our main result for state conversion is the following:

Theorem 16**.**

Let $\mathscr{P}$ be a converting vector set from $\{|\rho_{x}\rangle\}_{x\in X}$ to $\{|\sigma_{x}\rangle\}_{x\in X}$. Then there is a quantum algorithm such that for any $x\in X$, any failure probability $\delta\leq 1/3$, and any error $\varepsilon>0$,

With probability $1-\delta$, on input $x$ the algorithm algorithm converts $|\rho_{x}\rangle$ to $|\sigma_{x}\rangle$ with error $\varepsilon$. 2. 2.

On input $x$, if $w_{+}(\mathscr{P},x)W_{-}(\mathscr{P})\leq w_{-}(\mathscr{P},x)W+-(\mathscr{P})$, the average query complexity is

[TABLE]

If $w_{+}(\mathscr{P},x)W_{-}(\mathscr{P})\geq w_{-}(\mathscr{P},x)W_{+}(\mathscr{P})$, the average query complexity is

[TABLE]

Comparing Theorem 16 with Corollary 12, and considering the case of $\varepsilon,\delta=\Omega(1)$, we see that in the worst case, when we have an input $x$ where ${w_{+}({\mathscr{P}},{x})}=W_{+}(\mathscr{P})$ or ${w_{-}({\mathscr{P}},{x})}=W_{-}(\mathscr{P})$ the average query complexity of our algorithm is asymptotically the same as the standard state conversion algorithm. However, when we have an instance $x$ with a smaller value of $w_{\pm}(\mathscr{P},x)$, then our algorithm has improved query complexity, without knowing anything about the input witness size ahead of time.

Our algorithm has worse scaling in $\varepsilon$ than Corollary 12, so our algorithm will be most useful when $\varepsilon$ can be constant. One could also do a hybrid approach: initially run our algorithm and then switch to that of Corollary 12.

The problem of state conversion is a more general problem than function decision, and it can be used to solve the function decision problem. However, because of the worse scaling with $\varepsilon$ in Theorem 16, we considered function decision separately (see Section 3).

We use Alg. 2 to prove Theorem 16. We now describe a key unitary, ${{\mathcal{U}}({{\mathcal{P}}},{x},{\alpha},{\hat{\varepsilon}})}$, that appears in the algorithm. In the following, we use most of the notation conventions of Ref. [LMR*+*11]. Let $\{|\mu_{i}\rangle\}_{i\in[q]}$ and $\{|\nu_{i}\rangle\}_{i\in[q]}$ be unit vectors in $\mathbb{C}^{q}$ as defined in [LMR*+*11, Fact 2.4], such that

[TABLE]

For $X\subseteq[q]^{n},$ let $\mathscr{P}=\left(\{|u_{xj}\rangle\},\{|v_{xj}\rangle\}\right)$ where $\forall x\in X,j\in[n],|v_{xj}\rangle,|u_{xj}\rangle\in\mathbb{C}^{m}$ be a converting vector set from $\rho$ to $\sigma$. For all $x\in X$, the states $|\rho_{x}\rangle$ and $|\sigma_{x}\rangle$ are in the Hilbert space ${\mathcal{H}}$. Then for all $x\in X$, define $|t_{x\pm}\rangle,|\psi_{x,\alpha,\hat{\varepsilon}}\rangle\in(\mathbb{C}^{2}\otimes{\mathcal{H}})\oplus(\mathbb{C}^{n}\otimes\mathbb{C}^{q}\otimes\mathbb{C}^{m})$ as

[TABLE]

where $\alpha$ is analogous to the parameter $\alpha$ in Eq. 7. We will choose $\hat{\varepsilon}$ to achieve a desired accuracy of $\varepsilon$ in our state conversion procedure. Set ${\Uplambda^{\!\alpha,\hat{\varepsilon}}}$ to equal the projection onto the orthogonal complement of the span of the vectors $\{|\psi_{x,\alpha,\hat{\varepsilon}}\rangle\}_{x\in X}$, and set $\Uppi_{x}=I-\sum_{j\in[n]}|j\rangle\!\langle j|\otimes|\mu_{x_{j}}\rangle\!\langle\mu_{x_{j}}|\otimes I_{\mathbb{C}^{n}}$. Finally, we set ${{\mathcal{U}}({{\mathcal{P}}},{x},{\alpha},{\hat{\varepsilon}})}=(2\Uppi_{x}-I)(2{\Uplambda^{\!\alpha,\hat{\varepsilon}}}-I)$. The reflection $2\Uppi_{x}-I$ can be implemented with two applications of $O_{x}$ [LMR*+*11], and the reflection $(2{\Uplambda^{\!\alpha,\hat{\varepsilon}}}-I)$ is independent of $x$ and so requires no queries.

As with function decision, the time and query complexity of the algorithm is dominated by the number of applications of ${{\mathcal{U}}({{\mathcal{P}}},{x},{\alpha},{\hat{\varepsilon}})}$. If $T_{U}$ is the time required to implement ${{\mathcal{U}}({{\mathcal{P}}},{x},{\alpha},{\hat{\varepsilon}})}$, then the time complexity of our algorithm is simply the query complexity times $T_{U}$.

High level idea of Alg. 2: when we apply Phase Reflection of ${{\mathcal{U}}({\mathscr{P}^{\prime}},{x},{\alpha},{\hat{\varepsilon}})}$ (for $\mathscr{P}^{\prime}\in\{\mathscr{P},\mathscr{P}^{\dagger}\})$ in Alg. 2 to $(|0\rangle|\rho_{x}\rangle)_{A}|0\rangle_{B}=\frac{1}{\sqrt{2}}(|t_{x+}\rangle_{A}|0\rangle_{B}+|t_{x-}\rangle_{A}|0\rangle_{B})$, we want $\frac{1}{\sqrt{2}}|t_{x+}\rangle_{A}|0\rangle_{B}$ to pick up a $+1$ phase and $\frac{1}{\sqrt{2}}|t_{x-}\rangle_{A}|0\rangle_{B}$ to pick up a $-1$ phase. (Note that in this case, half of the amplitude of the state is picking up a $+1$ phase, and half is picking up a $-1$ phase.) If this were to happen perfectly, we would have the desired state $(|1\rangle|\sigma_{x}\rangle)_{A}|0\rangle_{B}=\frac{1}{\sqrt{2}}(|t_{x+}\rangle_{A}|0\rangle_{B}-|t_{x-}\rangle_{A}|0\rangle_{B})$. We show that if $\alpha$ is larger than a critical value that depends on the witness size of the input $x$, then in Alg. 2, we will mostly pick up the desired phase. However, we don’t know ahead of time how large $\alpha$ should be. To determine this, we implement the Probing Stage (Lines 1-9), which uses Amplitude Estimation of a Phase Checking subroutine to test exponentially increasing values of $\alpha$.

We use the following two Lemmas (Lemma 17 and Lemma 18) to analyze Alg. 2 and prove Theorem 16:

Lemma 17**.**

For a converting vector set $\mathscr{P}$ that coverts $\rho$ to $\sigma$, and Phase Checking of ${{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})}$ done with accuracy $\hat{\varepsilon}^{2}$ and precision $\Theta=\hat{\varepsilon}^{3/2}/\sqrt{\alpha W_{-}(\mathscr{P})}$, then

If $\alpha\geq{w_{+}({\mathscr{P}},{x})}$, then $\|\Pi_{0}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})|t_{x+}\rangle|0\rangle\|^{2}>1-\hat{\varepsilon}.$ 2. 2.

If $\alpha\geq 1/W_{-}(\mathscr{P})$, then $\|P_{\Theta}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})|t_{x-}\rangle\|^{2}\leq\frac{\hat{\varepsilon}^{2}}{2}$ and $\left\|\Pi_{0}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})|t_{x-}\rangle|0\rangle\right\|\leq\hat{\varepsilon}(1+1/\sqrt{2})$.

Lemma 17 Item 2 ensures that the $|t_{x-}\rangle$ part of the state mostly picks up a $-1$ phase when we apply Phase Reflection regardless of the value of $\alpha$, and Lemma 17 Item 1 ensures that when $\alpha$ is large enough, the $|t_{x+}\rangle$ part of the state mostly picks up a $+1$ phase. Lemma 17 plays a similar role in state conversion to Lemma 15 in function decision. It shows us that the behavior of the algorithm changes at some point when $\alpha$ is large enough, without our having to know $\alpha$ ahead of time (Item 1) but it also is used to show that we don’t terminate early when we shouldn’t, leading to an incorrect outcome (Item 2).

Proof of Lemma 17.

Throughout this proof, $P_{\Theta}$ and $\Pi_{0}$ are shorthand for $P_{\Theta}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})$ and $\Pi_{0}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})$, with Phase Checking done to precision $\Theta=\hat{\varepsilon}^{3/2}/\sqrt{\alpha W_{-}(\mathscr{P})}$ and accuracy $\hat{\varepsilon}^{2}$.

Part 1: We first prove that $\|P_{0}|t_{x+}\rangle\|^{2}\geq 1-\hat{\varepsilon}$, which by Lemma 1 gives us a bound on $\|\Pi_{0}|t_{x+}\rangle\|^{2}$. Following [LMR*+*11, Claim 4.4], we consider the state

[TABLE]

where $|\nu_{x_{j}}\rangle$ is from Eq. 31. Note that for $|\psi_{y,\alpha,\hat{\varepsilon}}\rangle$ for all $y\in X$, because $\langle{t_{y-}}|{t_{x+}}\rangle=\frac{1}{2}\left(\langle{\rho_{y}}|{\rho_{x}}\rangle-\langle{\sigma_{y}}|{\sigma_{x}}\rangle\right)$, and also $\sum_{j:x_{j}\neq y_{j}}\langle{u_{yj}}|{v_{xj}}\rangle=\langle{\rho_{y}}|{\rho_{x}}\rangle-\langle{\sigma_{y}}|{\sigma_{x}}\rangle$ from the constraints of Eq. 4, we have

[TABLE]

Because $|\varphi\rangle$ is orthogonal to all of the $|\psi_{y,\alpha,\hat{\varepsilon}}\rangle$, we have ${\Uplambda^{\!\alpha,\hat{\varepsilon}}}|\varphi\rangle=|\varphi\rangle$. Also, $\Uppi_{x}|\varphi\rangle=|\varphi\rangle$ since $\Uppi_{x}|t_{x+}\rangle=|t_{x+}\rangle$ and $\langle{\mu_{x_{j}}}|{\nu_{x_{j}}}\rangle=0$ for every $j$. Thus $P_{0}|\varphi\rangle=|\varphi\rangle$.

Note

[TABLE]

because of our assumption that $\alpha\geq w_{+}(\mathscr{P},x)$. Also, $\langle{t_{x+}}|{\varphi}\rangle=1$, so

[TABLE]

Then by Lemma 1, we have $\|P_{0}|t_{x+}\rangle\|^{2}\leq\|\Pi_{0}|t_{x+}\rangle|0\rangle\|^{2}$, so

[TABLE]

Part 2: Let $|w\rangle=\sqrt{\frac{\alpha}{\hat{\varepsilon}}}|\psi_{x,\alpha,\hat{\varepsilon}}\rangle$, so ${\Uplambda^{\!\alpha,\hat{\varepsilon}}}|w\rangle=0$ and $\Uppi_{x}|w\rangle=|t_{x-}\rangle$. Applying Lemma 4, we have

[TABLE]

Now

[TABLE]

Combining Eqs. 38 and 39, and setting $\Theta=\hat{\varepsilon}^{3/2}/\sqrt{\alpha W_{-}}$, we have that

[TABLE]

where we have used our assumption from the statement of the lemma that $\alpha\geq 1/W_{-}$.

We next bound $\|\Pi_{0}|t_{x-}\rangle)|0\rangle\|.$ Inserting the identity operator $I=P_{\Theta}+\overline{P}_{\Theta}$ for $\Theta=\hat{\varepsilon}^{3/2}/\sqrt{\alpha W_{-}}$, we have

[TABLE]

where the second line comes from the triangle inequality and the fact that a projector acting on a vector cannot increase its norm. The first term in the final line comes from Eq. 40, and the second term comes Lemma 1. ∎

The following lemma, Lemma 18, tells us that when we break out of the Probing Stage due to a successful Amplitude Estimation in Alg. 2, we will convert $|\rho_{x}\rangle$ to $|\sigma_{x}\rangle$ with appropriate error in the State Conversion Stage in Alg. 2, regardless of the value of $\alpha$ (Eq. 45 in Lemma 18). However, Lemma 18 also tells us that once $\alpha\geq{w_{+}({\mathscr{P}},{x})}$, then if Amplitude Estimation does not fail, we will exit the Probing Stage (Item 2 in Lemma 18). Together Eq. 45 and Item 2 ensure that once $\alpha$ is large enough, the algorithm will be very likely to terminate and correctly produce the output state, but before $\alpha$ is large enough, if there is some additional structure in the converting vector set that causes our Probing Stage to end early (when $\alpha<{w_{+}({\mathscr{P}},{x})}$), we will still have a successful result.

Lemma 18**.**

For a converting vector set $\mathscr{P}$ that converts $\rho$ to $\sigma$, and Phase Checking and Phase Reflection of ${{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})}$ done with accuracy $\hat{\varepsilon}^{2}$ and precision $\Theta=\hat{\varepsilon}^{3/2}/\sqrt{\alpha W_{-}(\mathscr{P})}$ for $\hat{\varepsilon}\leq 1/9$, and $\alpha\geq 1/W_{-}(\mathscr{P}),$

If

[TABLE]

then

[TABLE] 2. 2.

If $\alpha\geq{w_{+}({\mathscr{P}},{x})}$ then $\|\Pi_{0}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})(|0\rangle|\rho_{x}\rangle)_{A}|0\rangle_{B}\|^{2}>\frac{1}{2}-\frac{5\hat{\varepsilon}}{2}$.

Proof.

For the rest of the proof, we will use $P_{\Theta}$, $\Pi_{0}$, and $R$ as shorthand for $P_{\Theta}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})$, $\Pi_{0}({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})$, and $R({{\mathcal{U}}({\mathscr{P}},{x},{\alpha},{\hat{\varepsilon}})})$ respectively.

Part 1: We have

[TABLE]

In the first term of Eq. 46, we can replace $R$ with $\Pi_{0}-\overline{\Pi}_{0}$ (as described above Lemma 2), and we can insert $I=\Pi_{0}+\overline{\Pi}_{0}$ to get

[TABLE]

where we have used the fact that $\Pi_{0}$ and $\overline{\Pi}_{0}$ are orthogonal.

To bound $\frac{2}{\sqrt{2}}\|\overline{\Pi}_{0}|t_{x+}\rangle|0\rangle\|$, we start from our assumption that $\|\Pi_{0}(|0\rangle|\rho_{x}\rangle)_{A}|0\rangle_{B}\|^{2}\geq 1/2-3\hat{\varepsilon}$. Writing $|0\rangle|\rho_{x}\rangle$ in terms of $|t_{x+}\rangle$ and $|t_{x+}\rangle$, and using the triangle inequality, we have

[TABLE]

From Lemma 17 Item 2 , we have $\|\Pi_{0}|t_{x-}\rangle|0\rangle\|<2\hat{\varepsilon}$, so plugging into Eq. 48, we have

[TABLE]

Rearranging, we find:

[TABLE]

Since $\|\Pi_{0}|t_{x+}\rangle|0\rangle\|^{2}+\|\overline{\Pi}_{0}|t_{x+}\rangle|0\rangle\|^{2}=1$, we have

[TABLE]

Plugging back into Eq. 47, we find

[TABLE]

In the second term of Eq. 46, we again replace $R$ with $\Pi_{0}-\overline{\Pi}_{0}$ and replace $I$ with $\Pi_{0}+\overline{\Pi}_{0}$ to get

[TABLE]

by Lemma 17 Item 2, where we have used our assumption that $\alpha\geq 1/W_{-}(\mathscr{P})$.

Combining Eqs. 52 and 53, and plugging into into Eq. 46 and using that $\hat{\varepsilon}\leq 1/9$, we have

[TABLE]

Part 2: We analyze $\|\Pi_{0}{|0\rangle|\rho_{x}\rangle}|0\rangle\|.$ Using the triangle inequality, we have

[TABLE]

The first term we bound using Lemma 17 Item 1 and the second with Lemma 17 Item 2 to give us

[TABLE]

Squaring both sides and using a series expansion, we find

[TABLE]

∎

With Lemma 17 and Lemma 18, we can now proceed to the proof of Theorem 16:

Proof of Theorem 16.

We analyze Alg. 2. Note that the $l_{2}$ norm between two quantum states is at most $2$, so we may assume $\varepsilon\leq 2$ and hence $\hat{\varepsilon}\leq 9.$

First we show that the probability of returning a state $|\tilde{\sigma}_{x}\rangle$ such that $\||\tilde{\sigma}_{x}\rangle-|1\rangle|\sigma_{x}\rangle|0\rangle\|\geq\varepsilon$ is at most $\delta$. We first analyze the case that $w_{+}(\mathscr{P},x)W_{-}(\mathscr{P})\leq w_{-}(\mathscr{P},x)W_{+}(\mathscr{P})=w_{+}(\mathscr{P}^{\dagger},x)W_{-}(\mathscr{P}^{\dagger})$. Let $i^{*}=\lceil\log(w_{+}(\mathscr{P},x)W_{-}(\mathscr{P}))\rceil$ and $T=\lceil\log W_{+}(\mathscr{P})W_{-}(\mathscr{P})\rceil$.

Notice that once $i\geq i^{*}$, we have $\alpha\geq{w_{+}({\mathscr{P}},{x})}$, so by Lemma 18 Item 2 we have $\|\Pi_{0}({|0\rangle|\rho_{x}\rangle})_{A}|0\rangle_{B}\|^{2}\geq\frac{1}{2}-\frac{5\hat{\varepsilon}}{2}$. Thus when we do Amplitude Estimation in Alg. 2 of Alg. 2 to additive error $\hat{\varepsilon}/4$, with probability $1-\delta_{i}$ we will find the probability of outcome $|0\rangle_{B}$ will be at least $1/2-11\hat{\varepsilon}/4$, causing us to continue to the State Conversion Stage. Furthermore, by combining Lemma 18 Eq. 45 and Item 2, our algorithm is guaranteed to output the target state within error $6\sqrt{\hat{\varepsilon}}=\varepsilon$ regardless of an error in Amplitude Estimation. Therefore, the algorithm can only return a wrong state before round $i^{*}$, and only if Amplitude Estimation fails. Thus, we calculate the probability of error as:

[TABLE]

where $Pr(cont\textrm{ }i)$ is the probability of continuing to the next round of the for loop at round $i$, and $Pr(err\textrm{ }i)$ is the probability of a failure of Amplitude Estimation at round $i$, both conditioned on reaching round $i$. We upper bound $Pr(cont\textrm{ }j)$ by 1 and $Pr(err\textrm{ }i)$ by $2\delta_{i}$, as $\delta_{i}$ is the probability of Amplitude Estimation failure in Alg. 2, and we do two rounds (for $\mathscr{P}$ and $\mathscr{P}^{\dagger}$). This then gives us:

[TABLE]

where we have used our choice of $\delta_{i}$ and that $i^{*}\leq T$. Thus the probability of error is bounded by $\delta$.

Now we analyze the average query complexity. Let $Q(i)$ be the query complexity of the algorithm when it exits the Probing Stage at round $i$. Then the average query complexity on input $x$ is

[TABLE]

where $\left(\prod_{j=0}^{i-1}Pr(cont\textrm{ }j)\right)\left(1-Pr(cont\textrm{ }i)\right)$ is the probability of terminating at round $i$.

At the $i$th round of the Probing Stage, we implement Phase Checking with precision $\hat{\varepsilon}^{3/2}/\sqrt{2^{i}}$ and accuracy $\hat{\varepsilon}^{2}$, which uses $O\left(\frac{\sqrt{2^{i}}}{\hat{\varepsilon}^{3/2}}\log\left(\frac{1}{\hat{\varepsilon}}\right)\right)$ queries for a single iteration. By Lemma 3, we use $O\left(\frac{1}{\hat{\varepsilon}}\log\left(\frac{1}{\delta_{i}}\log\left(\frac{1}{\hat{\varepsilon}}\right)\right)\right)$ applications of Phase Checking inside the Iterative Amplitude Estimation subroutine to reach success probability of at least $1-\delta_{i}$ with error $\hat{\varepsilon}/4$. Therefore,

[TABLE]

where the second term in the first line is the query complexity of the State Conversion Stage, so the complexity is dominated by the Probing Stage.

We divide the analysis into two parts: $i\leq i^{*}$ and $i^{*}<i\leq T$. When $i\leq i^{*}$, we use the trivial bound $\left(\prod_{j=0}^{i-1}Pr(cont\textrm{ }j)\right)\left(1-Pr(cont\textrm{ }i)\right)\leq 1$. Thus, the contribution to the average query complexity from rounds $i$ with $i\leq i^{*}$ is at most:

[TABLE]

where we have used the following inequality twice:

[TABLE]

For $i$ from $i^{*}+1$ to $T$, as discussed below Eq. 57, Amplitude Estimation in Line 8 should produce an estimate that triggers breaking out of the Probing Stage at Line 9. Thus the probability of continuing to the next iteration depends on Amplitude Estimation failing, which happens with probability $\delta_{i}\leq\delta\leq\frac{1}{2\sqrt{2}}$, since $\delta\leq 1/3$. Using $(1-Pr(cont\textrm{ }i))\leq 1$, we thus have

[TABLE]

The contribution to the average query complexity for rounds after $i^{*}$ is therefore

[TABLE]

where we have used Eq. 63 and Eq. 24.

Combining Eqs. 62 and 4 and replacing $\hat{\varepsilon}$ with $\varepsilon$, the average query complexity of the algorithm on input $x$ is

[TABLE]

When $w_{+}(\mathscr{P},x)W_{-}(\mathscr{P})\geq w_{-}(\mathscr{P},x)W_{+}(\mathscr{P})=w_{+}(\mathscr{P}^{\dagger},x)W_{-}(\mathscr{P}^{\dagger})$, using the same analysis but with $\mathscr{P}^{\dagger}$ and applying Lemma 8, we find

[TABLE]

∎

4.1 Function Evaluation with Fast Verification

The state conversion algorithm can be used to evaluate a discrete function $f:X\rightarrow[m]$ for $X\subseteq[q]^{n}$ on input $x$ by converting from $|\rho_{x}\rangle=|0\rangle$ to $|\sigma_{x}\rangle=|f(x)\rangle$ and then measuring in the standard basis to learn $f(x)$. When the correctness of $f(x)$ can be verified with an additional constant number of queries, we can modify our state conversion algorithm to remove the Probing Stage, and instead use the correctness verification of the output state as a test of whether the algorithm is complete. In this case, we can remove a log factor from the complexity:

Theorem 19**.**

For a function $f:X\rightarrow[m]$, such that $f(x)$ can be verified without error using at most constant additional queries to $O_{x}$, given a converting vector set $\mathscr{P}$ from $\rho=\{|0\rangle\}_{x\in X}$ to $\sigma=\{|f(x)\rangle\}_{x\in X}$ and $\delta<2^{-1/2}$, then there is a quantum algorithm that correctly evaluates $f$ with probability at least $1-\delta$ and uses

[TABLE]

average queries on input $x.$

While removing a log factor might seem inconsequential, it yields an exponential quantum advantage in the next section for some applications, as opposed to only a superpolynomial advantage.

Proof of Theorem 19.

We analyze Alg. 3, which is similar to Alg. 2, but with the Probing Stage replaced by a post-State Conversion verification procedure.

We first analyze the case that $w_{+}(\mathscr{P},x)W_{-}(\mathscr{P})\leq w_{-}(\mathscr{P},x)W_{+}(\mathscr{P})=w_{+}(\mathscr{P}^{\dagger},x)W_{-}(\mathscr{P}^{\dagger})$. From Lemma 18, we have that when $\alpha\geq{w_{+}({\mathscr{P}},{x})}$, then the output state $|\psi\rangle$ of Line 7 of Alg. 3 satisfies

[TABLE]

This gives us

[TABLE]

Taking the square of both sides and using that $1-\delta\leq\left(1-\frac{\delta}{2}\right)^{2}$, we have

[TABLE]

Since $|1\rangle|f(x)\rangle|0\rangle$ is a standard basis state, if we measure $|\psi\rangle$ in the standard basis, this implies that probability that we measure the second register to be $|f(x)\rangle$ is at least $1-\delta.$

Once we measure $f(x)$, we can verify it with certainty using constant additional queries. Thus, our success probability is at least $1-\delta 2$ at a single round when $\alpha\geq w_{+}$ (which we only reach if we haven’t already correctly evaluated $f(x)$), and so our overall probability of success must be at least $1-\delta$ (from Line 1 of Alg. 3). This is because further rounds (if they happen) will only increase our probability of success.

To calculate the average query complexity, we note that the $i^{\textrm{th}}$ round uses

[TABLE]

queries, where the $1$ is from the verification step, which we henceforward absorb into the big-Oh notation.

We make a worst case assumption that the probability of measuring outcome $|f(x)\rangle$ in a round when $\alpha<{w_{+}({\mathscr{P}},{x})}$, or equivalently, at a round $i$ when $i<i^{*}$, is 0, so these rounds contribute

[TABLE]

queries to the average query complexity, where in the last equality, we’ve replaced $\hat{\varepsilon}$ with $\delta$.

At each additional round $i$ for $i\geq i^{*}$, we have a $1-\delta$ probability of successfully returning $f(x)$, conditioned on reaching that round, and $\delta$ probability of continuing to the next round. This gives us an average query complexity on input $x$ of

[TABLE]

By our assumption that $\delta<2^{1/2}$, the summation is bounded by a constant. Thus the average query complexity on input $x$ is

[TABLE]

When ${w_{+}({\mathscr{P}},{x})}W_{-}(\mathscr{P})>{w_{-}({\mathscr{P}},{x})}W_{+}(\mathscr{P})={w_{+}({\mathscr{P}^{\dagger}},{x})}W_{-}(\mathscr{P}^{\dagger})$, we get the same expression except with $\mathscr{P}$ replaced by $\mathscr{P}^{\dagger},$ which by Lemma 13 gives us the claimed query complexity. ∎

4.2 Quantum Advantages for Decision Trees with Advice

Montanaro showed that when searching for a single marked item, if there is a power law distribution on the location of the item, then a quantum algorithm can achieve a (super)exponential speed-up in average query complexity over the best classical algorithm [Mon10]. He called this “searching with advice,” as in order to achieve the best separations between quantum and classical performance, the algorithm had to know an ordering of the inputs such that the probability of finding the marked item was non-increasing, the “advice.”

In this section, we generalize Montanaro’s result to decision tree algorithms, and use this generalization to prove a superpolynomial and exponential speed-up for several additional search problems. We use a decision tree construction similar to that of Beigi and Taghavi [BT20].

A classical, deterministic query algorithm that evaluates $f:X\rightarrow[m]$ for $X\subseteq[q]^{n}$ is given access to an oracle $O_{x}$, for $x\in X$, and uses a single query to learn $x_{i}$, the $i^{\textrm{th}}$ bit of $x.$ We can describe the sequence of queries this classical algorithm makes as a directed tree ${\mathcal{T}}$, a decision tree, with vertex set $V({\mathcal{T}})$ and directed edge set $E({\mathcal{T}})$. Each non-leaf vertex $v$ of $V({\mathcal{T}})$ is associated with an index $J(v)\in[n]$, which is the index of $x$ that is queried when the algorithm reaches that vertex. The algorithm follows the edge labeled by $x_{J(v)}$ (the query result) from $v$ to another vertex in $V({\mathcal{T}})$. Each leaf is labelled by an element of $[m]$, which is the value that the algorithm outputs if it reaches that leaf. Let $path({\mathcal{T}},x)$ be the sequence of edges in $E({\mathcal{T}})$ that are followed on input $x$ when queries are made starting from the root of ${\mathcal{T}}$. We say that ${\mathcal{T}}$ decides $f:X\rightarrow[m]$ if the leaf node on $path({\mathcal{T}},x)$ is labelled by $f(x)$, for all $x\in X$.

For a non-leaf vertex $v\in{\mathcal{T}}$, each edge $(v,v^{\prime})\in E({\mathcal{T}})$ is labeled by a subset of $[q]$, that we denote $Q(v,v^{\prime})$. Then if a vertex $v$ is visited in $path({\mathcal{T}},x)$, the algorithm chooses to follow the edge $(v,v^{\prime})$ to vertex $v^{\prime}$, if $x_{J(v)}\in Q(v,v^{\prime}).$ We require that $\{Q(v,v^{\prime})\}$ for all edges $(v,v^{\prime})$ leaving vertex $v$ form a partition of $[q]$, so that there is always exactly one edge that the algorithm can choose to follow based on the result of the query at vertex $v$.

To create a quantum algorithm from such a decision tree ${\mathcal{T}}$, we label each edge $e\in E({\mathcal{T}})$ with a weight $r(e)\in\mathbb{R}^{+}$ and a color $c(e)\in\{red,black\}$, such that all edges coming out of a vertex $v$ with the same color have the same weight. There must be exactly one edge leaving each non-leaf vertex that is black, and the rest must be red. We denote by $r(v,black)$ the weight of the black edge leaving $v$, and $r(v,red)$ the weight of any red edge(s) leaving $v$. If there are no red edges leaving $v$, we set $r(v,red)=\infty.$ (In Ref. [BT20], the red and black weights are the same throughout the entire tree, instead of being allowed to depend on $v$.) Using these weights we design a converting vector set to decide $f$:

Lemma 20**.**

Given a decision tree ${\mathcal{T}}$ that decides a function $f:X\rightarrow[m]$, for $X\in[q]^{n}$, with weights $r(e)\in\mathbb{R}^{+}$ for each edge $e\in E({\mathcal{T}})$, then there is a converting vector set $\mathscr{P}$ that on input $x\in X$ converts $|\rho_{x}\rangle=|0\rangle$ to $|\sigma_{x}\rangle=|f(x)\rangle$ such that

[TABLE]

Proof.

In this proof $|u_{xj}\rangle$ and $|v_{yj}\rangle$, with double subscripts, refer to converting vector sets, and $u$, $v$ with single or no subscripts refer to vertices. We use essentially the same construction as in Ref. [BT20], but with a slightly different analysis because of our generalization to weights that can change throughout the tree.

We will make use of the unit vectors $\{|\tilde{\mu}_{i,d}\rangle\}_{i\in[d]}$ and $\{|\tilde{\nu}_{i,d}\rangle\}_{i\in[d]}$, defined in [BT20], which are scaled versions of the vectors in Eq. 31, which have the properties that $\forall i\in[d],\left\||\tilde{\mu}_{i,d}\rangle\right\|^{2},\left\||\tilde{\nu}_{i,d}\rangle\right\|^{2}\leq 2$ and $\langle{\tilde{\mu}_{i,d}}|{\tilde{\nu}_{j,d}}\rangle=1-\delta_{i,j}$.

First note that we can assume that on any input $x\in X$, for any index $j$, there is at most a single vertex on in $path({\mathcal{T}},x)$ at which $j$ is queried. Otherwise the tree would query the same index twice, which would be a non-optimal tree. The we define a converting vector set on $\mathbb{C}^{|V({\mathcal{T}})|}\otimes\mathbb{C}^{2}\otimes\mathbb{C}^{|V({\mathcal{T}})|}\otimes\mathbb{C}^{m}$ as follows

[TABLE]

and

[TABLE]

From Definition 9, Eq. 4, we want that

[TABLE]

For evaluating a discrete function $f$, we have $|\rho_{x}\rangle=|0\rangle$, and $|\sigma_{x}\rangle=|f(x)\rangle$, so $(\rho-\sigma)_{xy}=1-\delta_{f(x),f(y)}.$

Now if $f(x)=f(y)$, then because $\langle{\tilde{\mu}_{f(x),m}}|{\tilde{\nu}_{f(y),m}}\rangle=0$, we have $\forall j\in[n]$ $\langle{u_{xj}}|{v_{yj}}\rangle=0$, so

$\sum_{j\in[n]:x_{j}\neq y_{j}}\langle{u_{xj}}|{v_{yj}}\rangle=0$ , as desired.

If $f(x)\neq f(y)$, then there must be some vertex in the decision tree at which $path({\mathcal{T}},x)$ and $path({\mathcal{T}},y)$ diverge. Let’s call this vertex $v^{*}$, and assume that $J(v^{*})$, the index of the input queried at vertex $v^{*}$, is $j^{*}$. Let $(v^{*},u_{1})$ be the edge on $path({\mathcal{T}},x)$ and $(v^{*},u_{2})$ be the edge on $path({\mathcal{T}},y)$. This means that $x_{j^{*}}\in Q(v^{*},u_{1})$, and $y_{j^{*}}\in Q(v^{*},u_{2})$ and since $Q(v^{*},u_{1})$ and $Q(v^{*},u_{2})$ are part of a partition, this implies $x_{j^{*}}\neq y_{j^{*}}.$ Then if $c(v^{*},u_{1})=black$, we must have $c(v^{*},u_{2})=red$, while if $c(v^{*},u_{1})=red$, we can have $c(v^{*},u_{2})\in\{black,red\}$. In either case, we see from Eqs. 77 and 78 that

[TABLE]

Now for all other $j\in[n]$ with $j\neq j^{*}$, we have $\langle{u_{xj}}|{v_{yj}}\rangle=0$, which we can prove by looking at the following cases:

• •

There is no vertex in ${\mathcal{T}}$ where $j$ is queried for $x$ or $y$, which results in $|v_{xj}\rangle=0$ or $|u_{xj}\rangle=0$, and so $\langle{u_{xj}}|{v_{yj}}\rangle=0$.

• •

The index $j$ is queried for both $x$ and $y$ before their paths in ${\mathcal{T}}$ diverge, at a vertex $v$ where the paths for both $x$ and $y$ then travel to a vertex $u$, in which case, $\langle{u_{xj}}|{v_{yj}}\rangle=0$, since $\langle{\tilde{\mu}_{u,|V({\mathcal{T}})|}}|{\tilde{\nu}_{u,|V({\mathcal{T}})|}}\rangle=0$.

• •

The index $j$ is queried for both $x$ and $y$ after their paths in ${\mathcal{T}}$ diverge, at a vertex $v_{1}$ for $x$ and a vertex $v_{2}$ for $y$, in which case $\langle{u_{xj}}|{v_{yj}}\rangle=0$, since $\langle{v_{1}}|{v_{2}}\rangle=0$.

Putting this all together for $j=j^{*}$ and $j\neq j^{*}$, we have

[TABLE]

Now to calculate the positive and negative witness sizes. For the positive witness size, we have

[TABLE]

where in the second line, we have used Eq. 77 and that ${\mathcal{T}}$ will query each index at most once, according to the vertices that are encountered in $path({\mathcal{T}},x)$, and in the final line, we have used that $\||\tilde{\mu}_{u,|V({\mathcal{T}})|}\rangle\|^{2},\||\tilde{\mu}_{f(x),m}\rangle\|^{2}\leq 2.$

For the negative witness size, note that again for input $x$, ${\mathcal{T}}$ will query each index of $x$ at most once, according to the vertices that are encountered in $path({\mathcal{T}})$. Then if index $j$ of $x$ is queried at vertex $v$, where $(v,u)\in path({\mathcal{T}},x)$, and $c(v,u)=black$ then

[TABLE]

while if $c(v,u)=red$, then

[TABLE]

Thus

[TABLE]

∎

In Theorem 21, we use Lemma 20 to derive average quantum and classical query separations based on classical decision trees.

Theorem 21**.**

If ${\mathcal{T}}$ is a decision tree that decides $f:X\rightarrow[m]$ for $X\subseteq[q]^{n}$, with optimal average classical query complexity for the distribution $\{p_{x}\}_{x\in X}$, and ${\mathcal{T}}$ has a coloring such that there are at most $G$ red edges on any path from the root to a leaf, then the average quantum query complexity of deciding $f(x)$ with bounded error is

[TABLE]

If it is possible to verify a potential output $\hat{y}$ as correctly being $f(x)$ using constant queries, then the average quantum query complexity of deciding $f(x)$ with bounded error is

[TABLE]

The average classical query complexity of deciding $f(x)$ with bounded error is

[TABLE]

Proof.

The average classical query complexity comes from the fact that on input $x$, which occurs with probability $p_{x}$, the algorithm uses $|path({\mathcal{T}},x)|$ queries, since each edge on the path of the decision tree corresponds to a single additional query. By assumption, ${\mathcal{T}}$ is optimal for the distribution $\{p_{x}\}$, giving the complexity as in Eq. 88.

For the quantum algorithm, we will assign weights to each edge in ${\mathcal{T}}$, and then use Lemma 20 to create and analyze a state conversion algorithm. Then we will then apply Theorem 16 and Theorem 19 to achieve better complexity on easier inputs.

For each black edge $e$ in ${\mathcal{T}}$ let $r(e)=G$. For each red edge $e$, let $r(e)=l(e)$, where $l(e)$ is the number of edges on the path in ${\mathcal{T}}$ from the root to $e$, including $e$. Let $\mathscr{P}$ be the converting vector set from Lemma 20 that converts $|\rho_{x}\rangle=|0\rangle$ to $|\sigma_{x}\rangle=|f(x)\rangle$, based on ${\mathcal{T}}$.

We first analyze ${w_{+}({\mathscr{P}},{x})}$. By Lemma 20,

[TABLE]

where in the second-to-last line, we’ve used that the total number of black or red edges in the path is $|path({\mathcal{T}},x)|$. In the last line, we’ve used that the number of red edges on any path is at most $G$. This implies that $W_{+}(\mathscr{P})=O(nG).$

Now to analyze ${w_{-}({\mathscr{P}},{x})}$. From Lemma 20,

[TABLE]

Now applying Theorem 16 with $\varepsilon,\delta=\Theta(1)$ and $W_{+}(\mathscr{P})=O(n)$ gives us a bounded error algorithm with an average query complexity of $O\left(\sqrt{G|path({\mathcal{T}},x)|\log^{3}(n)}\right)$ on input $x$. On average over $x\in X$, we obtain an average query complexity of $O\left(\sum_{x\in X}p_{x}\sqrt{G|path({\mathcal{T}},x)|\log^{3}(n)}\right).$

When there is a way to verify $f(x)$ using a constant queries, we can apply Theorem 19 with $\delta=\Theta(1)$ to give us a bounded error algorithm with an average query complexity of $O\left(\sqrt{G|path({\mathcal{T}},x)|\log(n)}\right)$ on input $x$. On average over $x\in X$, we obtain an average query complexity of $O\left(\sum_{x\in X}p_{x}\left(\sqrt{G|path({\mathcal{T}},x)|\log(n)}\right)\right).$ ∎

We now use Theorem 21 to show an average quantum advantage for two problems related to searching: searching for $r$ marked items in a list and searching for the first $r$ marked items in a list:

Theorem 22**.**

For the problem of finding $r$ bits with value $1$ in an $n$-bit string, there are distributions for which there are exponential (when $r=O(1)$) and superpolynomial (when $r=O(\operatorname{polylog}(n)$) advantages in average quantum query complexity over average classical query complexity. For the problem of finding the first $r$ $1$-valued bits in an $n$-bit string, there is a distribution for which there is a superpolynomial (when $r=O(\operatorname{polylog}(n)$) advantage in average quantum query complexity over average classical query complexity.

The proof is based on a classical decision tree ${\mathcal{T}}$ that checks the $n$ bits of the string in order until $r$ $1$-valued bits are found. The tree for $r=2$ is shown in Fig. 2. Each time a $1$-valued bit is found, the edge that the algorithm traverses is colored red. Then $G({\mathcal{T}})=r$, so Theorem 21 tells us the average query complexity will be small when the $r$ items occur early in the list, resulting in a short path for that input. We combine this idea with a particular a power-law distribution that Montanaro also uses [Mon10]. This power-law distribution is tailored to allow a quantum algorithm, which has at most a quadratic advantage on any particular input, but which only uses constant queries on the easiest inputs, to achieve an exponential/superpolynomial advantage overall on average.

Proof of Theorem 22.

We first analyze the case of finding any $r$ $1$-valued bits. Let $f_{r}:X\rightarrow Y$, for $X\subset\{0,1\}^{n}$ and $Y\subseteq[n]^{r}$, such that $x\in X$ iff $x$ contains exactly $r$ bits with value $1$, and where $f_{r}(x)=\{i_{1},i_{2},\dots,i_{r}\}$ are the indices of the $r$ bits of $x$ that have value $1$.

We assume the distribution on inputs $X$ is such that if the values of the first $d\geq 0$ bits of $x$ are known, the probability of finding a $1$-valued bit among the remaining $n-d$ bits is non-increasing with increasing index. The probability of finding the $r^{\textrm{th}}$ $1$-valued bit at position $i$ is $p_{i}$, and is non-increasing in $i$.

Because the probability of finding $1$’s is non-increasing with increasing bit position, even conditioned on knowing some of the the initial bit values, the optimal strategy for a classical algorithm is to query the bits of the string in order until $r$ bits with value $1$ are found, at which point the algorithm returns the location of the bits with value $1$. This algorithm corresponds to a decision tree ${\mathcal{T}}$ where $|path({\mathcal{T}},x)|=i$, where $i$ is the position of the $r^{th}$ $1.$ Then the average classical query complexity is $\sum_{i=r}^{n}p_{i}i.$

We label an edge $(v,v^{\prime})$ of this tree as red whenever $1\in Q(v,v^{\prime})$; that is, edges that are traversed when a $1$-valued bit is found are colored red. Then $G({\mathcal{T}})=r.$

For this problem, one can verify whether an output of the algorithm is correct using an additional $r$ queries; if the output contains $r$ indices, query those $r$ indices to ensure there is a $1$ at each position, in which case, one knows with certainty that the output is correct. If the tested output does not contain $r$ indices, or if there is not a $1$ at one of the indices, one knows with certainty that the output is incorrect.

Then by Theorem 21, the average quantum query complexity is

[TABLE]

For the distribution $p_{i,n}\propto(i)^{-k}$, with $\sum_{i=1}^{n}p_{i,n}=1$, and $-2<k<-3/2$, Montanaro shows the following [Mon10, Prop. 2.5]:

[TABLE]

Now suppose we have the distribution $p_{i}=p_{i-r+1,n-r+1}$. Then

[TABLE]

where in the last line, we’ve used Eq. 94 and the fact that $\sum_{i=1}^{n-r+1}p_{i,n-r+1}=1.$ Thus the average quantum query complexity is

[TABLE]

We do a similar analysis for the classical query complexity:

[TABLE]

where we have again used Eq. 94 and the fact that $\sum_{i=1}^{n-r+1}p_{i,n-r+1}=1.$

Thus, for $r=\operatorname{polylog}n$, we find a superpolynomial improvement: the average quantum query complexity is $O(\operatorname{polylog}n)$ while the average classical query complexity is $\Omega(n^{k+2})$, for $-2<k<-3/2$. For $r=O(1)$, we have an exponential improvement, as the average quantum query complexity is $O\left(\log^{1/2}(n)\right)$ compared to the classical $\Omega(n^{k+2})$, , for $-2<k<-3/2$.

Now we consider the case of finding the first $r$ bits with value $1$. Let $f_{r}^{\prime}:\{0,1\}^{n}\rightarrow[n]^{r}$ where $f_{r}^{\prime}(x)=\{i_{1},\dots,i_{r}\}$ where $i_{k}$ is the $k^{\textrm{th}}$ smallest index such that $x_{i_{k}}=1$. We assume the distribution on inputs $\{0,1\}^{n}$ is such that the probability of finding the $r^{th}$ $1$-valued bit at position $i$ is $p_{i-r+1,n-r+1}$ and the optimal classical algorithm is to query the bits in order and return the indices where $1$’s were found.

This algorithm corresponds to a decision tree ${\mathcal{T}}$ where $|path({\mathcal{T}},x)|=i$, where $i$ is the position of the $r^{\textrm{th}}$ $1$ in the string.

Then the proof proceeds exactly as in the case of finding any $r$ elements, except in this case we can not verify using constant queries whether the output is correct. Thus we have that the average classical query complexity is $\Omega(n^{k-2})$ and the average quantum query complexity is $O\left(\operatorname{polylog}(n)\right).$

∎

Acknowledgments

We thank Stacey Jeffery for valuable discussions, especially for her preliminary notes on span program negation, and several past referees for insightful suggestions.

Funding

All authors were supported by the U.S. Army Research Office under Grant Number W911NF-20-1-0327. The views and conclusions contained in this document are those of the authors and should not be interpreted as representing the official policies, either expressed or implied, of the Army Research Office or the U.S. Government. The U.S. Government is authorized to reproduce and distribute reprints for Government purposes notwithstanding any copyright notation herein.

Appendix A Complements of Span Programs and Converting Vector Sets

We first prove that, given a span program that decides $f:X\rightarrow\{0,1\}$, we can create a span program that decides $f^{\neg}$ while preserving witnesses sizes for each $x$.

See 8

Proof.

We first define $H^{\prime}$, starting from $H^{\prime}_{j,a}$:

[TABLE]

where $H_{j,a}^{\perp}$ is the orthogonal complement of $H_{j,a}.$ We define $H^{\prime}_{j}=\sum_{a\in[q]}H^{\prime}_{j,a}$, and $H^{\prime}_{true}=H_{false}$ and $H^{\prime}_{false}=H_{true}$. Then

[TABLE]

Let $|\tilde{0}\rangle$ be a vector that is orthogonal to $H$ and $V$, and define $V^{\prime}=H\oplus\textrm{span}\{|\tilde{0}\rangle\}$ and $\tau^{\prime}=|\tilde{0}\rangle.$ Finally, set

[TABLE]

where $\Lambda_{A}$ is the projection onto the kernel of $A$, $\Pi_{H}$ is the projection onto $H$, and

[TABLE]

Let $x\in X$ be an input with $f(x)=1$, so $x$ has a positive witness $|w\rangle$ in ${\mathcal{P}}$. We will show $\omega^{\prime}=\langle\tilde{0}|+\langle w|$ is a negative witness for $x$ in ${\mathcal{P}}^{\dagger}$. Note $\omega^{\prime}\tau^{\prime}=1$, and also,

[TABLE]

where in the second line, we have used that $\langle\tilde{0}|\Lambda_{A}=0$ since $\Lambda_{A}$ projects onto the $H$ subspace, and $\langle{w}|{\tilde{0}}\rangle=0$ because $|\tilde{0}\rangle$ is orthogonal to $H$. The final line follows from [IJ19, Definition 2.12], which showed that every positive witness can be written as $|w\rangle=|w_{0}\rangle+|w^{\perp}\rangle$, where $|w^{\perp}\rangle$ is in the kernel of $A$ and $|w_{0}\rangle$ is orthogonal to the kernel of $A$.

Then $\langle w|\Pi_{H^{\prime}(x)}=0$, because $|w\rangle\in H(x)$, and $H^{\prime}(x)$ is orthogonal to $H(x),$ so $\omega^{\prime}$ is a negative witness for $x$ in ${\mathcal{P}}^{\dagger}$. Also, $\|\omega^{\prime}A^{\prime}\|^{2}=\||w\rangle\|^{2}$, so the witness size of this negative witness in ${\mathcal{P}}^{\dagger}$ is the same as the corresponding positive witness in ${\mathcal{P}}.$ This implies ${w_{-}({{\mathcal{P}}^{\dagger}},{x})}\leq{w_{+}({{\mathcal{P}}},{x})}.$

Next, we show that ${w_{-}({{\mathcal{P}}^{\dagger}},{x})}\geq{w_{+}({{\mathcal{P}}},{x})}$. Let $\omega^{\prime}$ be any negative witness for $x$ in ${\mathcal{P}}^{\dagger}$. Then since $\omega^{\prime}\in{\mathcal{L}}(H\oplus\textrm{span}\{|\tilde{0}\rangle\},\mathbb{R})$, and we must have $\omega^{\prime}\tau^{\prime}=\omega^{\prime}|\tilde{0}\rangle=1$, $\omega^{\prime}$ must have the form $\langle\tilde{0}|+\langle w|$, where $|w\rangle\in H$. Then

[TABLE]

where $|h\rangle$ is in the kernel of $A$. By the definition of $|w_{0}\rangle$, this implies that $A(|w_{0}\rangle+|h\rangle)=\tau$. Next, for $\omega^{\prime}$ to be a valid negative witness for $x$ in ${\mathcal{P}}^{\dagger}$, we must have that $\omega^{\prime}A^{\prime}\Pi_{H^{\prime}(x)}=0$, which implies that $(\omega^{\prime}A^{\prime})^{\dagger}\in H(x)$, and so $|w_{0}\rangle+|h\rangle\in H(x)$. Thus $(\omega^{\prime}A^{\prime})^{\dagger}$ is a positive witness for $x$ in ${\mathcal{P}}$, and so $\|\omega^{\prime}A^{\prime}\|^{2}\geq{w_{+}({{\mathcal{P}}},{x})}$, implying ${w_{-}({{\mathcal{P}}^{\dagger}},{x})}\geq{w_{+}({{\mathcal{P}}},{x})}$.

If $f(x)=0$, there is a negative witness $\omega$ for $x$ in ${\mathcal{P}}$. Consider $|w^{\prime}\rangle=(\omega A)^{\dagger}$. Then

[TABLE]

where in the second line, we have used that $(\omega A)^{\dagger}$ is orthogonal to the kernel of $A.$ Also, $\Pi_{H(x)}(\omega A)^{\dagger}=0$, so $|w^{\prime}\rangle\in H^{\prime}(x)$. This means $|w^{\prime}\rangle$ is a positive witness for $x$ in ${\mathcal{P}}^{\dagger}.$ Also, $\||w^{\prime}\rangle\|^{2}=\|\omega A\|^{2}$, so the witness size of this positive witness in ${\mathcal{P}}^{\dagger}$ is the same as the corresponding negative witness in ${\mathcal{P}}.$ This implies ${w_{+}({{\mathcal{P}}^{\dagger}},{x})}\leq{w_{-}({{\mathcal{P}}},{x})}.$

Now to show ${w_{+}({{\mathcal{P}}^{\dagger}},{x})}\geq{w_{-}({{\mathcal{P}}},{x})}$. Let $|w^{\prime}\rangle$ be a positive witness for $x$ in ${\mathcal{P}}^{\dagger}.$ Then since $\tau^{\prime}=A^{\prime}|w^{\prime}\rangle$, we have

[TABLE]

Since $\Lambda_{A}|\tilde{0}\rangle=0$, we must have $\Lambda_{A}|w^{\prime}\rangle=0$, which implies $|w^{\prime}\rangle=(\omega A)^{\dagger}$ for some $\omega\in V$. Plugging this into Eq. 113, and using Eq. 102, we have

[TABLE]

Thus we have $\omega\tau=1$. Since $|w^{\prime}\rangle$ is a positive witness for ${\mathcal{P}}^{\dagger}$, $\Pi_{H^{\prime}(x)}|w^{\prime}\rangle=|w^{\prime}\rangle$, which implies that $\Pi_{H(x)}(\omega A)^{\dagger}=0,$ or equivalently, $\omega A\Pi_{H(x)}=0$. Thus we see that $\omega$ must in fact be a negative witness for $x$ in ${\mathcal{P}}$. Therefore, ${w_{+}({{\mathcal{P}}^{\dagger}},{x})}\geq{w_{-}({{\mathcal{P}}},{x})}$.

Finally, since if $x$ has a positive witness in ${\mathcal{P}}$, we have shown it has a negative witness in ${\mathcal{P}}^{\dagger}$, and if $x$ has a negative witness in ${\mathcal{P}}$, we have shown it has a negative witness in ${\mathcal{P}}^{\dagger}$. Thus ${\mathcal{P}}^{\dagger}$ does indeed decide $f^{\neg}.$ ∎

The next two proofs deal with manipulating converting vector sets. See 12

Proof.

Let $\mathscr{P}=(|u_{xj}\rangle,|v_{xj}\rangle)_{x\in X,j\in[n]}$. We scale the vectors in $\mathscr{P}$ to create the converting vector set $\mathscr{P}^{\prime}$ with $|v_{xj}^{\prime}\rangle=|v_{xj}\rangle\sqrt{W_{-}/W_{+}}$ and $|u_{xj}^{\prime}\rangle=|u_{xj}\rangle\sqrt{W_{+}/W_{-}}$. The converting vector set $\mathscr{P}^{\prime}$ still satisfies the constraints of Eq. 4, but now has maximum witness sizes $W_{+}^{\prime}=W_{-}^{\prime}=\sqrt{W_{+}W_{-}}$, so applying Theorem 10 gives the result. ∎

Next we prove that given a converting vector set, we can design another converting vectors set that converts between the same states, but with positive and negative witness sizes exchanged.

See 13

Proof.

Let $\mathscr{P}=(|v_{xj}\rangle,|u_{xj}\rangle)_{x\in X,j\in[n]}$. For all $x\in X$ and $j\in[n]$, define

[TABLE]

Note $\langle{u^{C}_{xj}}|{v^{C}_{yj}}\rangle=(\langle{u_{yj}}|{v_{xj}}\rangle)^{*}$. Since $\mathscr{P}$ satisfies the constraints of Eq. 4,

[TABLE]

where we have used the fact that $\rho$ and $\sigma$ are Hermitian.

Thus the vectors $(|v_{xj}^{C}\rangle,|u_{xj}^{C}\rangle)_{x\in X,j\in[n]}$ satisfy the same constraints of Eq. 4, and thus produce the same have value in Eq. 5. However, now $w_{+}(\mathscr{P},x)=w_{-}(\mathscr{P}^{\dagger},x)$, and $w_{-}(\mathscr{P},x)=w_{+}(\mathscr{P}^{\dagger},x)$. ∎

Appendix B Proofs for the Function Decision Algorithm

See 15

Proof.

The proof is similar to Belovs and Reichardt [BR12a, Section 5.2] and Cade et al. [CMB18, Section C.2] and the dual adversary algorithm of Reichardt [Rei11, Algorithm 1]  

Part 1: Since $f(x)=1$, there is an positive optimal witness $|w\rangle\in H(x)$ for $x$. Then set $|u\rangle\in\tilde{H}(x)$ to be $|u\rangle=\alpha|\hat{0}\rangle-|w\rangle.$ Then $\Pi_{x}|u\rangle=|u\rangle$, but also, $|u\rangle$ is in the kernel of ${\tilde{A}^{\alpha}}$, because ${\tilde{A}^{\alpha}}|u\rangle=|\tau\rangle-|\tau\rangle=0$. Thus ${\Lambda^{\!{\alpha}}}|u\rangle=|u\rangle$, and so ${U({{\mathcal{P}}},{x},{\alpha})}|u\rangle=|u\rangle$; $|u\rangle$ is a 1-valued eigenvector of ${U({{\mathcal{P}}},{x},{\alpha})}$.

We perform Phase Checking on the state $|\hat{0}\rangle$, so the probability of measuring the state $|0\rangle_{B}$ in the phase register is at least (by Lemma 1), the overlap of $|\hat{0}\rangle$ and (normalized) $|u\rangle$. This is

[TABLE]

Using our assumption that ${w_{+}({{\mathcal{P}}},{x})}\leq\alpha^{2}/C$, and a Taylor series expansion for $C\geq 2$, the probability that we measure the state $|0\rangle_{B}$ in the phase register is at least $1-1/C$.

Part 2: Since $f(x)=0$, there is an optimal negative witness $\omega$ for $x$, and we set $|v\rangle\in\tilde{H}$ to be $|v\rangle=\alpha(\omega{\tilde{A}^{\alpha}})^{\dagger}$. By Definition 6, $\omega\tau=1$, so $|v\rangle=(\langle\hat{0}|+\alpha\omega A)^{\dagger}.$ Again, from Definition 6, $\omega A\Pi_{{H}(x)}=0$, so we have $\Pi_{x}|v\rangle=|\hat{0}\rangle.$

Then when we perform Phase Checking of the unitary ${U({{\mathcal{P}}},{x},{\alpha})}$ to some precision $\Theta$ with error $\epsilon$ on state $|\hat{0}\rangle$, by Lemma 1, we will measure $|0\rangle_{B}$ in the phase register with probability at most

[TABLE]

Now $|v\rangle$ is orthogonal to the kernel of ${\tilde{A}^{\alpha}}$. (To see this, note that if $|k\rangle$ is in the kernel of ${\tilde{A}^{\alpha}}$, then $\langle{v}|{k}\rangle=\alpha\omega{\tilde{A}^{\alpha}}|k\rangle=0$.) Applying Lemma 4, and setting $\Theta=\sqrt{\frac{\epsilon}{\alpha^{2}W_{-}}}$, we have

[TABLE]

To bound $\left\||v\rangle\right\|^{2}$, we observe that

[TABLE]

where we have used our assumption that $\alpha^{2}W_{-}\geq 1$.

Plugging Eqs. 121 and 122 into Eq. 120, we find that the probability of measuring $|0\rangle_{B}$ in the phase register is at most $\frac{3}{2}\epsilon$, as claimed. ∎