Improved Quantum Query Complexity on Easier Inputs

TL;DR

This work addresses the problem of achieving quantum query advantages without requiring a prior promise about input structure. It generalizes span-program and state-conversion frameworks by introducing iterative, exponentially growing subroutines with completion flags, leveraging Phase Checking, Phase Reflection, and Iterative Amplitude Estimation to obtain favorable average-case performance. The main results show that, for inputs with smaller witness sizes, the average query complexity scales as $O(\sqrt{w_+(x)W_-}\log\frac{W_+}{w_+(x)\delta})$ when $f(x)=1$ and $O(\sqrt{w_-(x)W_+}\log\frac{W_-}{w_-(x)\delta})$ when $f(x)=0$, while worst-case bounds remain $O(\sqrt{W_+W_-}\log(1/\delta))$. The paper also extends these ideas to state conversion, introduces a Probing Stage, and shows how fast verification can boost average performance; as applications, it achieves exponential and superpolynomial speedups in average query complexity for search problems and provides promise-free quantum advantages for decision-tree scenarios, including a generalization of Montanaro’s Search with Advice. Overall, the results broaden the practical impact of span-program/state-conversion methods by delivering input-dependent average speedups without requiring upfront structure promises.

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].

Figures (2)

• Figure 1: Probability tree diagrams for a round of the for loop in \ref{['alg:bool']} when $i\geq i^*$, and $f(x)=0$ (\ref{['fig:f0']}), and $f(x)=1$ (\ref{['fig:f1']}). By our choice of parameters, $a_i$ is small (it is always less than $1/4$), and decreases exponentially with increasing $i$.
• Figure 2: The decision tree we use to design the quantum algorithm for finding two bits with value $1$. Each vertex is labelled by its name ($v_i$) for some $i$, and $J (v_i)$, which is the bit of the input that is queried if the algorithm reaches that vertex of the tree. Each edge $(v_i,v_j)$ is labelled by $Q (v_i,v_j)$, which is the set in curly brackets alongside each edge. The algorithm follows the edge $(v_i,v_j)$ from vertex $v_i$ if the value of the query made at vertex $v_i$ is contained in $Q(v_i,v_j)$. Each edge is also labelled by its weight, $r(e)$, and is also colored red or black (and red edges are additionally rendered with dot-dashes.) Black edges all have weight $G ({\mathcal{T}})$, which in this case is $2$. Each red edge has a weight that is equal to the number of edges on the path from the root $v_1$ to that edge, inclusive. The vertex $v_1$ is the root, and each leaf (denoted as a rectangular vertex) is labelled by the output of the algorithm on that input.

Theorems & Definitions (42)

• Lemma 1: Phase Checking kitaevQuantumMeasurementsAbelian1995cleveQuantumAlgorithmsRevisited1998magniezSearchQuantumWalk2011
• Lemma 2: Phase Reflection magniezSearchQuantumWalk2011leeQuantumQueryComplexity2011
• Lemma 3: Iterative Quantum Amplitude Estimation Grinko2021
• Lemma 4: Effective spectral gap lemma, leeQuantumQueryComplexity2011
• Definition 5: Span Program
• Definition 6: Positive and Negative Witness
• Theorem 7: reichardtSpanProgramsQuantum2009itoApproximateSpanPrograms2019
• Lemma 7
• Definition 8: Converting vector set
• Theorem 9: leeQuantumQueryComplexity2011