Quantum Query Complexity Research Articles

Quantum Speed-Ups for String Synchronizing Sets, Longest Common Substring, and k -mismatch Matching

Longest common substring (LCS) is an important text processing problem, which has recently been investigated in the quantum query model. The decision version of this problem, LCS with threshold \(d\) , asks whether two length- \(n\) input strings have a common substring of length \(d\) . The two extreme cases, \(d=1\) and \(d=n\) , correspond, respectively to Element Distinctness and Unstructured Search, two fundamental problems in quantum query complexity. However, the intermediate case \(1\ll d\ll n\) was not fully understood. We show that the complexity of LCS with threshold \(d\) smoothly interpolates between the two extreme cases up to \(n^{o(1)}\) factors: — LCS with threshold \(d\) has a quantum algorithm in \(n^{2/3+o(1)}/d^{1/6}\) query complexity and time complexity, and requires at least \(\Omega(n^{2/3}/d^{1/6})\) quantum query complexity. Our result improves upon previous upper bounds \(\widetilde{O}(\min\{n/d^{1/2},n^{2/3}\})\) (Le Gall and Seddighin ITCS 2022, Akmal and Jin SODA 2022), and answers an open question of Akmal and Jin. Our main technical contribution is a quantum speed-up of the powerful String Synchronizing Set technique introduced by Kempa and Kociumaka (STOC 2019). It consistently samples \(n/\tau^{1-o(1)}\) synchronizing positions in the string depending on their length- \(\Theta(\tau)\) contexts, and each synchronizing position can be reported by a quantum algorithm in \(\widetilde{O}(\tau^{1/2+o(1)})\) time. Our quantum string synchronizing set also yields a near-optimal LCE data structure in the quantum setting. As another application of our quantum string synchronizing set, we study the \(k\) -mismatch Matching problem, which asks if the pattern has an occurrence in the text with at most \(k\) Hamming mismatches. Using a structural result of Charalampopoulos et al. (FOCS 2020), we obtain: — \(k\) -mismatch matching has a quantum algorithm with \(k^{3/4}n^{1/2+o(1)}\) query complexity and \(\widetilde{O}(kn^{1/2})\) time complexity. We also observe a non-matching quantum query lower bound of \(\Omega(\sqrt{kn})\) .

Variational learning algorithms for quantum query complexity

Quantum query complexity is pivotal in the analysis of quantum algorithms, encompassing well-known examples like search and period-finding algorithms. These algorithms typically involve a sequence of unitary operations and oracle calls dependent on an input variable. In this study, we introduce a variational learning approach to explore quantum query complexity. Our method employs an efficient parameterization of the unitary operations and utilizes a loss function derived from the algorithm’s error probability. We apply this technique to various quantum query complexities, notably devising a new algorithm that resolves the 5-bit Hamming modulo problem with four queries, addressing an open question from Cornelissen et al (2021 arXiv:2112.14682). This finding is corroborated by a semidefinite programming (SDP) approach. Our numerical method exhibits superior memory efficiency compared to SDP and can identify quantum query algorithms (QQAs) that require a smaller workspace register dimension, an aspect not optimized by SDP. These advancements present a significant step forward in the practical application and understanding of QQAs.

A New Minimax Theorem for Randomized Algorithms

The celebrated minimax principle of Yao says that for any Boolean-valued function f with finite domain, there is a distribution μ over the domain of f such that computing f to error ε against inputs from μ is just as hard as computing f to error ε on worst-case inputs. Notably, however, the distribution μ depends on the target error level ε: the hard distribution which is tight for bounded error might be trivial to solve to small bias, and the hard distribution which is tight for a small bias level might be far from tight for bounded error levels. In this work, we introduce a new type of minimax theorem which can provide a hard distribution μ that works for all bias levels at once. We show that this works for randomized query complexity, randomized communication complexity, some randomized circuit models, quantum query and communication complexities, approximate polynomial degree, and approximate logrank. We also prove an improved version of Impagliazzo’s hardcore lemma. Our proofs rely on two innovations over the classical approach of using Von Neumann’s minimax theorem or linear programming duality. First, we use Sion’s minimax theorem to prove a minimax theorem for ratios of bilinear functions representing the cost and score of algorithms. Second, we introduce a new way to analyze low-bias randomized algorithms by viewing them as “forecasting algorithms” evaluated by a certain proper scoring rule. The expected score of the forecasting version of a randomized algorithm appears to be a more fine-grained way of analyzing the bias of the algorithm. We show that such expected scores have many elegant mathematical properties—for example, they can be amplified linearly instead of quadratically. We anticipate forecasting algorithms will find use in future work in which a fine-grained analysis of small-bias algorithms is required.

T-depth-optimized quantum search with quantum data-access machine

Abstract Quantum search algorithms offer a remarkable advantage of quadratic reduction in query complexity using quantum superposition principle. However, how an actual architecture may access and handle the database in a quantum superposed state has been largely unexplored so far; the quantum state of data was simply assumed to be prepared and accessed by a black-box operation—so-called oracle, even though this process, if not appropriately designed, may adversely diminish the quantum query advantage. Here, we introduce an efficient quantum data-access process, dubbed as quantum data-access machine (QDAM), and present a general architecture for quantum search algorithm. We analyze the runtime of our algorithm in view of the fault-tolerant quantum computation (FTQC) consisting of logical qubits within an effective quantum error correction code. Specifically, we introduce a measure involving two computational complexities, i.e. quantum query and T-depth complexities, which can be critical to assess performance since the logical non-Clifford gates, such as the T (i.e. π / 8 rotation) gate, are known to be costliest to implement in FTQC. Our analysis shows that for N searching data, a QDAM model exhibiting a logarithmic, i.e. O ( log N ) , growth of the T-depth complexity can be constructed. Further analysis reveals that our QDAM-embedded quantum search requires O ( N × log N ) runtime cost. Our study thus demonstrates that the quantum data search algorithm can truly speed up over classical approaches with the logarithmic T-depth QDAM as a key component.

An Optimal Separation of Randomized and Quantum Query Complexity

We prove that for every decision tree, the absolute values of the Fourier coefficients of a given order sum to at most , where is the number of variables, is the tree depth, and is an absolute constant. This bound is essentially tight and settles a conjecture due to Tal [Towards optimal separations between quantum and randomized query complexities, in Proceedings of the Sixty-First Annual IEEE Symposium on Foundations of Computer Science (FOCS), 2020, pp. 228–239]. The bounds prior to our work degraded rapidly with , becoming trivial already at . As an application, we obtain, for every integer , a partial Boolean function on bits that has bounded-error quantum query complexity at most and randomized query complexity . This separation of bounded-error quantum versus randomized query complexity is best possible, by the results of Aaronson and Ambainis [SIAM J. Comput., 47 (2018), pp. 982–1038] and Bravyi et al. [Classical Algorithms for Forrelation, arXiv preprint, 2021]. Prior to our work, the best known separation was polynomially weaker: versus for any [A. Tal, Towards optimal separations between quantum and randomized query complexities, in Proceedings of the Sixty-First Annual IEEE Symposium on Foundations of Computer Science (FOCS), 2020, pp. 228–239]. As another application, we obtain an essentially optimal separation of versus for bounded-error quantum versus randomized communication complexity for any . The best previous separation was polynomially weaker: versus (this is implicit in [A. Tal, Towards optimal separations between quantum and randomized query complexities, in Proceedings of the Sixty-First Annual IEEE Symposium on Foundations of Computer Science (FOCS), 2020, pp. 228–239]).

Quantum Multi-Solution Bernoulli Search with Applications to Bitcoin's Post-Quantum Security

A proof of work (PoW) is an important cryptographic construct enabling a party to convince others that they invested some effort in solving a computational task. Arguably, its main impact has been in the setting of cryptocurrencies such as Bitcoin and its underlying blockchain protocol, which received significant attention in recent years due to its potential for various applications as well as for solving fundamental distributed computing questions in novel threat models. PoWs enable the linking of blocks in the blockchain data structure and thus the problem of interest is the feasibility of obtaining a sequence (chain) of such proofs. In this work, we examine the hardness of finding such chain of PoWs against quantum strategies. We prove that the chain of PoWs problem reduces to a problem we call multi-solution Bernoulli search, for which we establish its quantum query complexity. Effectively, this is an extension of a threshold direct product theorem to an average-case unstructured search problem. Our proof, adding to active recent efforts, simplifies and generalizes the recording technique of Zhandry (Crypto'19). As an application, we revisit the formal treatment of security of the core of the Bitcoin consensus protocol, the Bitcoin backbone (Eurocrypt'15), against quantum adversaries, while honest parties are classical and show that protocol's security holds under a quantum analogue of the classical “honest majority'' assumption. Our analysis indicates that the security of Bitcoin backbone is guaranteed provided the number of adversarial quantum queries is bounded so that each quantum query is worth O(p−1/2) classical ones, where p is the success probability of a single classical query to the protocol's underlying hash function. Somewhat surprisingly, the wait time for safe settlement in the case of quantum adversaries matches the safe settlement time in the classical case.

Exact quantum query complexity of weight decision problems via Chebyshev polynomials

The weight decision problem, which requires to determine the Hamming weight of a given binary string, is a natural and important problem, with applications in cryptanalysis, coding theory, fault-tolerant circuit design and so on. In particular, both Deutsch-Jozsa problem and Grover search problem can be interpreted as special cases of weight decision problems. In this work, we investigate the exact quantum query complexity of weight decision problems, where the quantum algorithm must always output the correct answer. More specifically we consider a partial Boolean function which distinguishes whether the Hamming weight of the length-$n$ input is $k$ or it is $l$. Our contribution includes both upper bounds and lower bounds for the precise number of queries. Furthermore, for most choices of $(\frac{k}{n},\frac{l}{n})$ and sufficiently large $n$, the gap between our upper and lower bounds is no more than one. To get the results, we first build the connection between Chebyshev polynomials and our problem, then determine all the boundary cases of $(\frac{k}{n},\frac{l}{n})$ with matching upper and lower bounds, and finally we generalize to other cases via a new \emph{quantum padding} technique. This quantum padding technique can be of independent interest in designing other quantum algorithms.

Tight bound for estimating expectation values from a system of linear equations

The System of Linear Equations Problem (SLEP) is specified by a complex invertible matrix $A$, the condition number $\kappa$ of $A$, a vector $b$, a Hermitian matrix $M$ and an accuracy $\epsilon$, and the task is to estimate $x^\dagger Mx$, where $x$ is the solution vector to the equation $Ax = b$. We aim to establish a lower bound on the complexity of the end-to-end quantum algorithms for SLEP with respect to $\epsilon$, and devise a quantum algorithm that saturates this bound. To make lower bounds attainable, we consider query complexity in the setting in which a block encoding of $M$ is given, i.e., a unitary black box $U_M$ that contains $M/\alpha$ as a block for some $\alpha \in \mathbb R^+$. We show that the quantum query complexity for SLEP in this setting is $\Theta(\alpha/\epsilon)$. Our lower bound is established by reducing the problem of estimating the mean of a black box function to SLEP. Our $\Theta(\alpha/\epsilon)$ result tightens and proves the common assertion of polynomial accuracy dependence (poly$(1/\epsilon)$) for SLEP, and shows that improvement beyond linear dependence on accuracy is not possible if $M$ is provided via block encoding.

Quantum and classical query complexities for generalized Simon's problem

Simon's problem is an essential example demonstrating the faster speed of quantum computers than classical computers for solving some problems. The optimal separation between exact quantum and classical query complexities for Simon's problem has been proved by Cai & Qiu. Generalized Simon's problem can be described as follows. Given a function f:{0,1}n→{0,1}m, with the property that there is some unknown hidden subgroup S such that f(x)=f(y) iff x⊕y∈S, for any x,y∈{0,1}n, where |S|=2k for some 0≤k≤n(m≥n−k). The goal of generalized Simon's problem is to find S. For the case of k=1, it is Simon's problem exactly. In this paper, we propose an exact quantum algorithm with O(n−k) queries and an non-adaptive deterministic classical algorithm with O(k2n−k) queries for solving the generalized Simon's problem. Also, we prove that their lower bounds are Ω(n−k) and Ω(k2n−k), respectively. Therefore, we obtain a tight exact quantum query complexity Θ(n−k) and an almost tight non-adaptive classical deterministic query complexities Ω(k2n−k)∼O(k2n−k) for this problem.

A tight lower bound for non-coherent index erasure

The index erasure problem is a quantum state generation problem that asks a quantum computer to prepare a uniform superposition over the image of an injective function given by an oracle. We prove a tight $\Omega(\sqrt{n})$ lower bound on the quantum query complexity of the non-coherent case of the problem, where, in addition to preparing the required superposition, the algorithm is allowed to leave the ancillary memory in an arbitrary function-dependent state. This resolves an open question of Ambainis et al., who gave a tight bound for the coherent case, the case where the ancillary memory must return to its initial state. To prove our main result, we first extend the automorphism principle}of Hoyer et al. to the general adversary method of Lee et al. for state generation problems, which allows one to exploit the symmetries of these problems to lower bound their quantum query complexity. Using this method, we establish a strong connection between the quantum query complexity of non-coherent symmetric state generation problems and the Krein parameters of an association scheme defined on injective functions. In particular, we use the spherical harmonics a finite symmetric Gelfand pair associated with the space of injective functions to obtain asymptotic bounds on certain Krein parameters, from which the main result follows.

Open Problems Related to Quantum Query Complexity

I offer a case that quantum query complexity still has loads of enticing and fundamental open problems—from relativized QMA versus QCMA and BQP versus IP , to time/space tradeoffs for collision and element distinctness, to polynomial degree versus quantum query complexity for partial functions, to the Unitary Synthesis Problem and more.

Quantum algorithms and approximating polynomials for composed functions with shared inputs

We give new quantum algorithms for evaluating composed functions whose inputs may be shared between bottom-level gates. Letfbe anm-bit Boolean function and consider ann-bit functionFobtained by applyingfto conjunctions of possibly overlapping subsets ofnvariables. Iffhas quantum query complexityQ(f), we give an algorithm for evaluatingFusingO~(Q(f)⋅n)quantum queries. This improves on the bound ofO(Q(f)⋅n)that follows by treating each conjunction independently, and our bound is tight for worst-case choices off. Using completely different techniques, we prove a similar tight composition theorem for the approximate degree off.By recursively applying our composition theorems, we obtain a nearly optimalO~(n1−2−d)upper bound on the quantum query complexity and approximate degree of linear-size depth-dAC0circuits. As a consequence, such circuits can be PAC learned in subexponential time, even in the challenging agnostic setting. Prior to our work, a subexponential-time algorithm was not known even for linear-size depth-3 AC0circuits.As an additional consequence, we show that AC0∘⊕circuits of depthd+1require sizeΩ~(n1/(1−2−d))≥ω(n1+2−d)to compute the Inner Product function even on average. The previous best size lower bound wasΩ(n1+4−(d+1))and only held in the worst case (Cheraghchi et al., JCSS 2018).

Quantum algorithms for escaping from saddle points

We initiate the study of quantum algorithms for escaping from saddle points with provable guarantee. Given a functionf:Rn→R, our quantum algorithm outputs anϵ-approximate second-order stationary point usingO~(log2⁡(n)/ϵ1.75)queries to the quantum evaluation oracle (i.e., the zeroth-order oracle). Compared to the classical state-of-the-art algorithm by Jin et al. withO~(log6⁡(n)/ϵ1.75)queries to the gradient oracle (i.e., the first-order oracle), our quantum algorithm is polynomially better in terms oflog⁡nand matches its complexity in terms of1/ϵ. Technically, our main contribution is the idea of replacing the classical perturbations in gradient descent methods by simulating quantum wave equations, which constitutes the improvement in the quantum query complexity withlog⁡nfactors for escaping from saddle points. We also show how to use a quantum gradient computation algorithm due to Jordan to replace the classical gradient queries by quantum evaluation queries with the same complexity. Finally, we also perform numerical experiments that support our theoretical findings.

Quantum query complexity of symmetric oracle problems

We study the query complexity of quantum learning problems in which the oracles form a group G of unitary matrices. In the simplest case, one wishes to identify the oracle, and we find a description of the optimal success probability of a t-query quantum algorithm in terms of group characters. As an application, we show that Ω(n) queries are required to identify a random permutation in Sn. More generally, suppose H is a fixed subgroup of the group G of oracles, and given access to an oracle sampled uniformly from G, we want to learn which coset of H the oracle belongs to. We call this problem coset identification and it generalizes a number of well-known quantum algorithms including the Bernstein-Vazirani problem, the van Dam problem and finite field polynomial interpolation. We provide character-theoretic formulas for the optimal success probability achieved by a t-query algorithm for this problem. One application involves the Heisenberg group and provides a family of problems depending on n which require n+1 queries classically and only 1 query quantumly.

Partial Boolean Functions with Exact Quantum Query Complexity One.

We provide two sufficient and necessary conditions to characterize any n-bit partial Boolean function with exact quantum query complexity 1. Using the first characterization, we present all n-bit partial Boolean functions that depend on n bits and can be computed exactly by a 1-query quantum algorithm. Due to the second characterization, we construct a function F that maps any n-bit partial Boolean function to some integer, and if an n-bit partial Boolean function f depends on k bits and can be computed exactly by a 1-query quantum algorithm, then is non-positive. In addition, we show that the number of all n-bit partial Boolean functions that depend on k bits and can be computed exactly by a 1-query quantum algorithm is not bigger than an upper bound depending on n and k. Most importantly, the upper bound is far less than the number of all n-bit partial Boolean functions for all efficiently big n.

Classical algorithms for quantum mean values

We consider the task of estimating the expectation value of an $n$-qubit tensor product observable $O_1\otimes O_2\otimes \cdots \otimes O_n$ in the output state of a shallow quantum circuit. This task is a cornerstone of variational quantum algorithms for optimization, machine learning, and the simulation of quantum many-body systems. Here we study its computational complexity for constant-depth quantum circuits and three types of single-qubit observables $O_j$ which are (a) close to the identity, (b) positive semidefinite, (c) arbitrary. It is shown that the mean value problem admits a classical approximation algorithm with runtime scaling as $\mathrm{poly}(n)$ and $2^{\tilde{O}(\sqrt{n})}$ in cases (a,b) respectively. In case (c) we give a linear-time algorithm for geometrically local circuits on a two-dimensional grid. The mean value is approximated with a small relative error in case (a), while in cases (b,c) we satisfy a less demanding additive error bound. The algorithms are based on (respectively) Barvinok's polynomial interpolation method, a polynomial approximation for the OR function arising from quantum query complexity, and a Monte Carlo method combined with Matrix Product State techniques. We also prove a technical lemma characterizing a zero-free region for certain polynomials associated with a quantum circuit, which may be of independent interest.

A Quantum Evolving Secret Sharing Scheme

An evolving secret sharing scheme is supposed to accommodate unbounded number (potentially infinite) of new participants over time and the dealer should not know the set of participants in advance. In this paper we initiate the study of quantum evolving schemes to share a quantum secret and show how to construct such a scheme where the qualified subsets (the sets which can reconstruct the secret) of participants are of increasing size as the number of participants increases with time. Share is given to new participants without modifying shares of old participants. While quantum secret sharing schemes which can accommodate new participants over time have been constructed before, a quantum scheme which can handle an unbounded and unspecified number of participants has not been considered so far. We also discuss the resilience of our scheme against a bounded number of quantum queries by an adversary/eavesdropper. This is achieved by using special functions for which lower bounds on their quantum query complexity is known.

Revisiting Deutsch-Jozsa algorithm

The Deutsch-Jozsa algorithm is essentially faster than any possible deterministic classical algorithm for solving a promise problem that is in fact a symmetric partial Boolean function, named as the Deutsch-Jozsa problem. The Deutsch-Jozsa problem can be equivalently described as a partial function DJn0:{0,1}n→{0,1} defined as: DJn0(x)=1 for |x|=n/2, DJn0(x)=0 for |x|=0,n, and it is undefined for the remaining cases, where n is even, and |x| is the Hamming weight of x. The Deutsch-Jozsa algorithm needs only one query to compute DJn0 but the classical deterministic algorithm requires n2+1 queries to compute it in the worse case.We present all symmetric partial Boolean functions with degree 1 and 2; We prove the exact quantum query complexity of all symmetric partial Boolean functions with degree 1 and 2. We prove Deutsch-Jozsa algorithm can compute any symmetric partial Boolean function f with exact quantum 1-query complexity.

Quantum algorithm for the multicollision problem

The current paper presents a new quantum algorithm for finding multicollisions, often denoted by ℓ-collisions, where an ℓ-collision for a function is a set of ℓ distinct inputs that are mapped by the function to the same value. In cryptology, it is important to study how many queries are required to find an ℓ-collision for a random function of which domain is larger than its range. However, the problem of finding ℓ-collisions for random functions has not received much attention in the quantum setting. The tight bound of quantum query complexity for finding a 2-collisions of a random function has been revealed to be Θ(N1/3), where N is the size of the range of the function, but neither the lower nor upper bounds are known for general ℓ-collisions. The paper first integrates the results from existing research to derive several new observations, e.g., ℓ-collisions can be generated only with O(N1/2) quantum queries for any integer constant ℓ. It then provides a quantum algorithm that finds an ℓ-collision for a random function with the average quantum query complexity of O(N(2ℓ−1−1)/(2ℓ−1)), which matches the tight bound of Θ(N1/3) for ℓ=2 and improves upon the known bounds, including the above simple bound of O(N1/2). More generally, the algorithm achieves the average quantum query complexity of O(cN⋅N(2ℓ−1−1)/(2ℓ−1)), and runs over O˜(cN⋅N(2ℓ−1−1)/(2ℓ−1)) qubits in O˜(cN⋅N(2ℓ−1−1)/(2ℓ−1)) expected time for a random function F:X→Y such that |X|≥ℓ⋅|Y|/cN for any 1≤cN∈o(N1/(2ℓ−1)), where it is assumed that QRAM is available. With the same query complexity, it is actually able to find a multiclaw for random functions, which is harder to find than a multicollision.

Quantum and classical query complexities for generalized Deutsch–Jozsa problems

The Deutsch–Jozsa algorithm is one of the first examples of a quantum algorithm that is exponentially faster than any possible deterministic classical algorithm. We generalize the Deutsch–Jozsa problem from the perspective of functional correlation, i.e., given two unknown n-bit Boolean functions f, g, the testing problem is to determine whether $$|C(f,g)|=0$$ or $$|C(f,g)|=\epsilon $$, where $$1/2^{(n-1)}\le \epsilon \le 1$$, promised that one of these is the case. Firstly, we propose two exact quantum algorithms for making distinction between $$|C(f,g)|=0$$ and $$|C(f,g)|=\epsilon $$ using the Deutsch–Jozsa algorithm and also the amplitude amplification technique with query complexity of $$O(1/\epsilon )$$, where C(f, g) denotes the correlation between two Boolean functions f, g. Secondly, we present a lower bound $${\varOmega }(1/\epsilon )$$ on the above promised problem, which proves that our quantum algorithms are optimal. Thirdly, we can accurately distinguish $$|C(f,g)|=\varepsilon $$ from $$|C(f,g)|=1$$ using the similar methods mentioned above, where $$0\le \varepsilon \le 1-1/2^{(n-1)}$$, promised that one of these is the case. We give a lower bound $${\varOmega }(1/\sqrt{1-\varepsilon })$$ and an upper bound $$O(4/\sqrt{1-\varepsilon ^{2}})$$ on this promised problem, which implies that the two bounds are almost tight. However, the query complexity of classical deterministic algorithms for two promised problems is $${\varTheta }(2^{n})$$.