Quantum Query Algorithms Research Articles

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.

Quantum Algorithm for Lexicographically Minimal String Rotation

Lexicographically minimal string rotation (LMSR) is a problem to find the minimal one among all rotations of a string in the lexicographical order, which is widely used in equality checking of graphs, polygons, automata and chemical structures. In this paper, we propose an O(n3/4)\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$O(n^{3/4})$$\\end{document} quantum query algorithm for LMSR. In particular, the algorithm has average-case query complexity O(nlogn)\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$O(\\sqrt{n} \\log n)$$\\end{document}, which is shown to be asymptotically optimal up to a polylogarithmic factor, compared to its Ωn/logn\\documentclass[12pt]{minimal} \\usepackage{amsmath} \\usepackage{wasysym} \\usepackage{amsfonts} \\usepackage{amssymb} \\usepackage{amsbsy} \\usepackage{mathrsfs} \\usepackage{upgreek} \\setlength{\\oddsidemargin}{-69pt} \\begin{document}$$\\Omega \\left( \\sqrt{n/\\log n}\\right) $$\\end{document} lower bound. Furthermore, we show that our quantum algorithm outperforms any (classical) randomized algorithms in both worst and average cases. As an application, it is used in benzenoid identification and disjoint-cycle automata minimization.

A linear algorithm for the restricted subtraction games

The subtraction game is a well-known problem in the field of game theory, which is often called a one-heap Nim game. There are two players, a heap of tokens, and a strategy matrix, in this game. It is called a restricted subtraction game if some constraints are imposed on the strategy matrix. The subtraction game could be solved by a classical algorithm with a query complexity no less than O(N2) and computed by an O(N32logN) quantum query algorithm with an error probability ϵ≤1N. The restricted subtraction game proposed by Huang et al. can be computed by an exact quantum algorithm with O(N32) queries. They also proved that the classical exact query complexity is Θ(N2). In this study, we use an array and an adjacency list to replace the strategy matrix and propose another more general subtraction game than the one introduced by Huang et al. Based on dynamic programming and the replaced game strategy, two linear classical query algorithms are designed to solve the restricted subtraction game proposed by Huang and this study, respectively.

Quantum Proofs of Proximity

We initiate the systematic study of QMA algorithms in the setting of property testing, to which we refer as QMA proofs of proximity (QMAPs). These are quantum query algorithms that receive explicit access to a sublinear-size untrusted proof and are required to accept inputs having a property Π and reject inputs that are ε-far from Π, while only probing a minuscule portion of their input.We investigate the complexity landscape of this model, showing that QMAPs can be exponentially stronger than both classical proofs of proximity and quantum testers. To this end, we extend the methodology of Blais, Brody, and Matulef (Computational Complexity, 2012) to prove quantum property testing lower bounds via reductions from communication complexity. This also resolves a question raised in 2013 by Montanaro and de Wolf (cf. Theory of Computing, 2016).Our algorithmic results include a purpose an algorithmic framework that enables quantum speedups for testing an expressive class of properties, namely, those that are succinctly decomposable. A consequence of this framework is a QMA algorithm to verify the Parity of an n-bit string with O(n2/3) queries and proof length. We also propose a QMA algorithm for testing graph bipartitneness, a property that lies outside of this family, for which there is a quantum speedup.

Simplified quantum algorithm for the oracle identification problem

In the oracle identification problem we have oracle access to bits of an unknown string x of length n, with the promise that it belongs to a known set \(C\subseteq \{0,1\}^{n}\). The goal is to identify x using as few queries to the oracle as possible. We develop a quantum query algorithm for this problem with query complexity \(O\left (\sqrt {\frac {n\log M }{\log (n/\log M)+1}}\right )\), where M is the size of C. This bound is already derived by Kothari in 2014, for which we provide a more elegant simpler proof.

Testing Boolean Functions Properties

The goal in the area of functions property testing is to determine whether a given black-box Boolean function has a particular given property or is ɛ-far from having that property. We investigate here several types of properties testing for Boolean functions (identity, correlations and balancedness) using the Deutsch-Jozsa algorithm (for the Deutsch-Jozsa (D-J) problem) and also the amplitude amplification technique. At first, we study here a particular testing problem: namely whether a given Boolean function f, of n variables, is identical with a given function g or is ɛ-far from g, where ɛ is the parameter. We present a one-sided error quantum algorithm to deal with this problem that has the query complexity O(1ε). Moreover, we show that our quantum algorithm is optimal. Afterwards we show that the classical randomized query complexity of this problem is Θ(1ε). Secondly, we consider the D-J problem from the perspective of functional correlations and let C(f, g) denote the correlation of f and g. We propose an exact quantum algorithm for making distinction between |C(f, g)| = ɛ and |C(f, g)| = 1 using six queries, while the classical deterministic query complexity for this problem is Θ(2n) queries. Finally, we propose a one-sided error quantum query algorithm for testing whether one Boolean function is balanced versus ɛ-far balanced using O(1ε) queries. We also prove here that our quantum algorithm for balancedness testing is optimal. At the same time, for this balancedness testing problem we present a classical randomized algorithm with query complexity of O(1/ɛ2). Also this randomized algorithm is optimal. Besides, we link the problems considered here together and generalize them to the general case.

From the sum-of-squares representation of a Boolean function to an optimal exact quantum query algorithm

In quantum computation, designing an optimal exact quantum query algorithm (i.e., a quantum decision tree algorithm) for any small input Boolean function is a fundamental and abstract problem. As we are aware, there is not a general method for this problem. Due to the fact that every Boolean function can be represented by a sum-of-squares of some multilinear polynomials, in this paper a primary algorithm framework is proposed with three basic steps: The first basic step is to find sum-of-squares representations of the Boolean function and its negation function; the second basic step is to construct a state which is assumed to be the final state of an optimal exact quantum query algorithm; the third basic step is to find each unitary operator in the undetermined algorithm. However, there still exist some intractable problems such that the algorithm framework may not be feasible in some cases, but it can be used to investigate the quantum query model with low complexity, such as Deutsch’s problem, a five-bit symmetric Boolean function and the characterization of Boolean functions with exact quantum 2-query complexity.

Quantum Speedup Based on Classical Decision Trees

Lin and Lin \cite{LL16} have recently shown how starting with a classical query algorithm (decision tree) for a function, we may find upper bounds on its quantum query complexity. More precisely, they have shown that given a decision tree for a function f:{0,1}n→[m] whose input can be accessed via queries to its bits, and a guessing algorithm that predicts answers to the queries, there is a quantum query algorithm for f which makes at most O(GT) quantum queries where T is the depth of the decision tree and G is the maximum number of mistakes of the guessing algorithm. In this paper we give a simple proof of and generalize this result for functions f:[ℓ]n→[m] with non-binary input as well as output alphabets. Our main tool for this generalization is non-binary span program which has recently been developed for non-binary functions, and the dual adversary bound. As applications of our main result we present several quantum query upper bounds, some of which are new. In particular, we show that topological sorting of vertices of a directed graph G can be done with O(n3/2) quantum queries in the adjacency matrix model. Also, we show that the quantum query complexity of the maximum bipartite matching is upper bounded by O(n3/4m+n) in the adjacency list model.

Span program for non-binary functions

Span programs characterize the quantum query complexity of binary functions f:\{0,\ldots,\ell\}^n \to \{0,1\} up to a constant factor. In this paper we generalize the notion of span programs for functions with non-binary input/output alphabets f: [\ell]^n \to [m]. We show that non-binary span program characterizes the quantum query complexity of any such function up to a constant factor. We argue that this non-binary span program is indeed the generalization of its binary counterpart. We also generalize the notion of span programs for a special class of relations. Learning graphs provide another tool for designing quantum query algorithms for binary functions. In this paper, we also generalize this tool for non-binary functions, and as an application of our non-binary span program show that any non-binary learning graph gives an upper bound on the quantum query complexity.

A quantum query algorithm for computing the degree of a perfect nonlinear Boolean function

The degree of a Boolean function is a basic primitive that has applications in coding theory and cryptography. This paper considers a problem of computing the degree of a perfect nonlinear Boolean function in a quantum system. The details are as follows: Given a promise that the function f is either linear or perfect nonlinear in $$F^{n}_{d}$$ , we propose a quantum algorithm 1 to distinguish which case it is with a high probability, where d is an even number. Furtherly, for computing the degree of a perfect nonlinear Boolean function f, we present a quantum Algorithm 2 to solve it by calling quantum Algorithm 1 when $$d=2$$ . The quantum query complexity of the proposed quantum Algorithm 2 is O(s), and the space complexity (the number of quantum logic gate) is $$O(2^{s})$$ , where $$s+1=\text {deg}(f)$$ . The analysis shows that the quantum Algorithm 2 proposed in this paper is more efficient than any classical algorithm for solving this problem.

Quantum Query Algorithms Are Completely Bounded Forms

We prove a characterization of $t$-query quantum algorithms in terms of the unit ball of a space of degree-$2t$ polynomials. Based on this, we obtain a refined notion of approximate polynomial degree that equals the quantum query complexity, answering a question of Aaronson et al. (CCC'16). Our proof is based on a fundamental result of Christensen and Sinclair (J. Funct. Anal., 1987) that generalizes the well-known Stinespring representation for quantum channels to multilinear forms. Using our characterization, we show that many polynomials of degree four are far from those coming from two-query quantum algorithms. We also give a simple and short proof of one of the results of Aaronson et al. showing an equivalence between one-query quantum algorithms and bounded quadratic polynomials. Revision note: A mistake was found in the proof of the second result on degree-4 polynomials far from 2-query quantum algorithms. An explanation of the issue, a corrected proof and stronger examples are presented in work of Escudero Guti\'errez and the second author.

A Quantum Algorithm for the Commutativity of Finite Dimensional Algebras

A quantum procedure for testing the commutativity of a finite dimensional algebra is introduced. This algorithm, based on Grover's quantum search, is shown to provide a quadratic speed-up (when the number of queries to the algebra multiplication constants is considered) over any classical algorithm (both deterministic and randomized) with equal success rate and shown to be optimal among the class of probabilistic quantum query algorithms. This algorithm can also be readily adapted to test commutativity and hermiticity of square matrices, again with quadratic speed-up. The results of the experiments carried out on a quantum computer simulator and on one of IBM's 5-qubit quantum computers are presented.

Generalized Deutsch-Jozsa problem and the optimal quantum algorithm

The Deutsch-Jozsa algorithm is one of the first examples of a quantum algorithm that is exponentially faster than any possible deterministic classical algorithm. It was proposed by Deutsch and Jozsa in 1992 with improvements by Cleve, Ekert, Macchiavello, and Mosca in 1998. The Deutsch-Jozsa problem is a promise problem and we can equivalently describe it as a partial function ${\text{DJ}}_{n}^{0}:{{0,1}}^{n}\ensuremath{\rightarrow}{0,1}$ defined as ${\text{DJ}}_{n}^{0}(x)=1$ for $|x|=n/2, {\text{DJ}}_{n}^{0}(x)=0$ for $|x|=0,n$, and it is undefined for the rest of the cases, where $n$ is even, and $|x|$ is the Hamming weight of $x$. The optimal quantum algorithm needs only one query to compute ${\text{DJ}}_{n}^{0}$ but the classical deterministic algorithm requires ${2}^{n\ensuremath{-}1}+1$ queries to compute it in the worse case. In this article, we generalize the Deutsch-Jozsa problem as ${\text{DJ}}_{n}^{k}(x)=1$ for $|x|=n/2, {\text{DJ}}_{n}^{k}(x)=0$ for $|x|$ in the set ${0,1,...,k,n\ensuremath{-}k,n\ensuremath{-}k+1,...,n}$, and it is undefined for the rest of the cases, where $0\ensuremath{\le}kln/2$. In particular, we give and prove an optimal exact quantum query algorithm with complexity $k+1$ for computing the generalized Deutsch-Jozsa problem ${\text{DJ}}_{n}^{k}$. It is clear that the case of $k=0$ is in accordance with the Deutsch-Jozsa problem. Also, we give a method for finding the approximate and exact degrees of symmetric partial Boolean functions.

Grover’s Search with Faults on Some Marked Elements

Grover’s algorithm is a quantum query algorithm solving the unstructured search problem of size [Formula: see text] using [Formula: see text] queries. It provides a significant speed-up over any classical algorithm [3]. The running time of the algorithm, however, is very sensitive to errors in queries. Multiple authors have analysed the algorithm using different models of query errors and showed the loss of quantum speed-up [2, 6]. We study the behavior of Grover’s algorithm in the model where the search space contains both faulty and non-faulty marked elements. We show that in this setting it is indeed possible to find one of marked elements in [Formula: see text] queries. We also analyze the limiting behavior of the algorithm for a large number of steps and show the existence and the structure of a limiting state [Formula: see text].

Quantum algorithms on Walsh transform and Hamming distance for Boolean functions

Walsh spectrum or Walsh transform is an alternative description of Boolean functions. In this paper, we explore quantum algorithms to approximate the absolute value of Walsh transform $$W_f$$Wf at a single point $$z_{0}$$z0 (i.e., $$|W_f(z_{0})|$$|Wf(z0)|) for n-variable Boolean functions with probability at least $$\frac{8}{\pi ^{2}}$$8?2 using the number of $$O(\frac{1}{|W_f(z_{0})|\varepsilon })$$O(1|Wf(z0)|?) queries, promised that the accuracy is $$\varepsilon $$?, while the best known classical algorithm requires $$O(2^{n})$$O(2n) queries. The Hamming distance between Boolean functions is used to study the linearity testing and other important problems. We take advantage of Walsh transform to calculate the Hamming distance between two n-variable Boolean functions f and g using O(1) queries in some cases. Then, we exploit another quantum algorithm which converts computing Hamming distance between two Boolean functions to quantum amplitude estimation (i.e., approximate counting). If $$Ham(f,g)=t\ne 0$$Ham(f,g)=t?0, we can approximately compute Ham(f, g) with probability at least $$\frac{2}{3}$$23 by combining our algorithm and $${Approx-Count(f,\varepsilon )\, algorithm}$$Approx-Count(f,?)algorithm using the expected number of $$\varTheta ( \sqrt{\frac{N}{(\lfloor \varepsilon t\rfloor +1)}}+\frac{\sqrt{t(N-t)}}{\lfloor \varepsilon t\rfloor +1})$$?(N(??t?+1)+t(N-t)??t?+1) queries, promised that the accuracy is $$\varepsilon $$?. Moreover, our algorithm is optimal, while the exact query complexity for the above problem is $$\varTheta (N)$$?(N) and the query complexity with the accuracy $$\varepsilon $$? is $$O(\frac{1}{\varepsilon ^{2}}N/(t+1))$$O(1?2N/(t+1)) in classical algorithm, where $$N=2^{n}$$N=2n. Finally, we present three exact quantum query algorithms for two promise problems on Hamming distance using O(1) queries, while any classical deterministic algorithm solving the problem uses $$\varOmega (2^{n})$$Ω(2n) queries.

Experimental study of Forrelation in nuclear spins

Correlation functions are often employed to quantify the relationships among interdependent variables or sets of data. Recently, a new class of correlation functions, called Forrelation, has been introduced by Aaronson and Ambainis for studying the query complexity of quantum devices. It was found that there exists a quantum query algorithm solving 2-fold Forrelation problems with an exponential quantum speedup over all possible classical means, which represents essentially the largest possible separation between quantum and classical query complexities. Here we report an experimental study probing the 2-fold and 3-fold Forrelations encoded in nuclear spins. The major experimental challenge is to control the spin fluctuation to within a threshold value, which is achieved by developing a set of optimized GRAPE pulse sequences. Overall, our small-scale implementation indicates that the quantum query algorithm is capable of determining the values of Forrelations within an acceptable accuracy required for demonstrating quantum supremacy, given the current technology and in the presence of experimental noise.

A formulation of a matrix sparsity approach for the quantum ordered search algorithm

One specific subset of quantum algorithms is Grovers Ordered Search Problem (OSP), the quantum counterpart of the classical binary search algorithm, which utilizes oracle functions to produce a specified value within an ordered database. Classically, the optimal algorithm is known to have a [Formula: see text] complexity; however, Grovers algorithm has been found to have an optimal complexity between the lower bound of [Formula: see text] and the upper bound of [Formula: see text]. We sought to lower the known upper bound of the OSP. With Farhi et al. MITCTP 2815 (1999), arXiv:quant-ph/9901059], we see that the OSP can be resolved into a translational invariant algorithm to create quantum query algorithm restraints. With these restraints, one can find Laurent polynomials for various [Formula: see text] — queries — and [Formula: see text] — database sizes — thus finding larger recursive sets to solve the OSP and effectively reducing the upper bound. These polynomials are found to be convex functions, allowing one to make use of convex optimization to find an improvement on the known bounds. According to Childs et al. [Phys. Rev. A 75 (2007) 032335], semidefinite programming, a subset of convex optimization, can solve the particular problem represented by the constraints. We were able to implement a program abiding to their formulation of a semidefinite program (SDP), leading us to find that it takes an immense amount of storage and time to compute. To combat this setback, we then formulated an approach to improve results of the SDP using matrix sparsity. Through the development of this approach, along with an implementation of a rudimentary solver, we demonstrate how matrix sparsity reduces the amount of time and storage required to compute the SDP — overall ensuring further improvements will likely be made to reach the theorized lower bound.

Identifying Generalized Reed-Muller Codewords by Quantum Queries

We provide an exact quantum query algorithm that identifies uncorrupted codewords from a degree-d generalized Reed-Muller code of length qn over the finite field of size q. When d is constant, the algorithm needs 𝒪(nd-1) quantum queries, which is optimal. Classically, Ω(nd) queries are necessary to accomplish this task, even with constant probability of error admitted. Our work extends a result by Montanaro about learning multilinear polynomials.

Optimal Parallel Quantum Query Algorithms

We study the complexity of quantum query algorithms that make p queries in parallel in each timestep. We show tight bounds for a number of problems, specifically Θ((n/p)2/3) p-parallel queries for element distinctness and Θ((n/p) k/(k + 1)) for k-sum. Our upper bounds are obtained by parallelized quantum walk algorithms, and our lower bounds are based on a relatively small modification of the adversary lower bound method, combined with recent results of Belovs et al. on learning graphs. We also prove some general bounds, in particular that quantum and classical p-parallel complexity are polynomially related for all total functions f when p is small compared to f’s block sensitivity.

Improved Quantum Query Algorithms for Triangle Detection and Associativity Testing

We show that the quantum query complexity of detecting if an n-vertex graph contains a triangle is $$O(n^{9/7})$$O(n9/7). This improves the previous best algorithm of Belovs (Proceedings of 44th symposium on theory of computing conference, pp 77---84, 2012) making $$O(n^{35/27})$$O(n35/27) queries. For the problem of determining if an operation $$\circ : S \times S \rightarrow S$$ź:S×SźS is associative, we give an algorithm making $$O(|S|^{10/7})$$O(|S|10/7) queries, the first improvement to the trivial $$O(|S|^{3/2})$$O(|S|3/2) application of Grover search. Our algorithms are designed using the learning graph framework of Belovs. We give a family of algorithms for detecting constant-sized subgraphs, which can possibly be directed and colored. These algorithms are designed in a simple high-level language; our main theorem shows how this high-level language can be compiled as a learning graph and gives the resulting complexity. The key idea to our improvements is to allow more freedom in the parameters of the database kept by the algorithm.