Quantum Search on Computation Trees

TL;DR

The paper addresses locating a marked leaf in a computation tree where each vertex may incur different computation times. It introduces a simple, explicit quantum-walk framework that weights edges by per-vertex costs, achieving a core bound of $O(\sqrt{TD})$ queries for known times and $O(\sqrt{TD\log t_{\max}})$ for unknown times, with $T=\sum_v t_v^2$ and $D$ the tree depth. The authors extend this to optimal variable-time search bounds, a divide-and-conquer flavor yielding near-linear-time quantum algorithms for certain geometric problems, and a bomb-query interpretation, thereby unifying several quantum algorithmic paradigms under a single, tractable approach with favorable poly-logarithmic factors. This framework resolves open questions on the exact query complexity of variable-time search and delivers practical speedups, including an $\widetilde{O}(n)$-time quantum algorithm for Point-On-3-Lines. Overall, the work provides a simple, flexible, and broadly applicable method to harness quantum walks for backtracking-like computation while preserving tight complexity guarantees.

Abstract

We show a simple generalization of the quantum walk algorithm for search in backtracking trees by Montanaro (ToC 2018) to the case where vertices can have different times of computation. If a vertex $v$ in the tree of depth $D$ is computed in $t_v$ steps from its parent, then we show that detection of a marked vertex requires $\text{O}(\sqrt{TD})$ queries to the steps of the computing procedures, where $T = \sum_v t_v^2$. This framework provides an easy and convenient way to re-obtain a number of other quantum frameworks like variable time search, quantum divide & conquer and bomb query algorithms. The underlying algorithm is simple, explicitly constructed, and has low poly-logarithmic factors in the complexity. As a corollary, this gives a quantum algorithm for variable time search with unknown times with optimal query complexity $\text{O}(\sqrt{T \log \min(n,t_{\max})})$, where $T = \sum_i t_i^2$ and $t_{\max} = \max_i t_i$ if $t_i$ is the number of steps required to compute the $i$-th variable. This resolves the open question of the query complexity of variable time search, as the matching lower bound was recently shown by Ambainis, Kokainis and Vihrovs (TQC'23). As another result, we obtain an $\widetilde{\text{O}}(n)$ time algorithm for the geometric task of determining if any three lines among $n$ given intersect at the same point, improving the $\text{O}(n^{1+\text{o}(1)})$ algorithm of Ambainis and Larka (TQC'20).

Figures (4)

• Figure 1: A way of seeing different quantum frameworks as computation trees: (a) a star in the case of variable time search; (b) the divide & conquer process is represented by a full $k$-ary tree; (c) a line in the case of quantum bomb query algorithms.
• Figure 2: The computation tree of variable time search.
• Figure 3: The computation tree of divide & conquer.
• Figure 4: The computation tree of the quantum bomb query algorithm.

Theorems & Definitions (16)

• Theorem 1: informal
• Theorem 2: Effective Spectral Gap Lemma SSRTM11
• Theorem 3: Quantum Phase Estimation Kit95CEMM98
• Theorem 4
• proof
• Claim 5
• Theorem 6
• proof
• Theorem 7
• proof