Optimal Query Complexity Research Articles

Learning Quantum States and Unitaries of Bounded Gate Complexity

While quantum state tomography is notoriously hard, most states hold little interest to practically minded tomographers. Given that states and unitaries appearing in nature are of bounded gate complexity, it is natural to ask if efficient learning becomes possible. In this work, we prove that to learn a state generated by a quantum circuit with G two-qubit gates to a small trace distance, a sample complexity scaling linearly in G is necessary and sufficient. We also prove that the optimal query complexity to learn a unitary generated by G gates to a small average-case error scales linearly in G. While sample-efficient learning can be achieved, we show that under reasonable cryptographic conjectures, the computational complexity for learning states and unitaries of gate complexity G must scale exponentially in G. We illustrate how these results establish fundamental limitations on the expressivity of quantum machine-learning models and provide new perspectives on no-free-lunch theorems in unitary learning. Together, our results answer how the complexity of learning quantum states and unitaries relate to the complexity of creating these states and unitaries. Published by the American Physical Society 2024

Tight quantum depth lower bound for solving systems of linear equations

Since Harrow [A. W. Harrow, A. Hassidim, and S. Lloyd, ] showed that a system of linear equations with N variables and condition number κ can be solved on a quantum computer in poly[log(N),κ] time, exponentially faster than any classical algorithms, its improvements and applications have been extensively investigated. The state-of-the-art quantum algorithm for this problem is due to Costa [P. C. S. Costa, D. An, Y. R. Sanders, Y. Su, R. Babbush, and D. W. Berry, ], with optimal query complexity Θ(κ). An important question that is left is whether parallelism can bring further optimization. In this paper, we study the limitation of parallel quantum computing on this problem. We show that any quantum algorithm for solving systems of linear equations with time complexity poly[log(N),κ] has a lower bound of Ω(κ) on the depth of queries, which is tight up to a constant factor. Published by the American Physical Society 2024

Practical and Parallelizable Algorithms for Non-Monotone Submodular Maximization with Size Constraint

We present combinatorial and parallelizable algorithms for the maximization of a submodular function, not necessarily monotone, with respect to a size constraint. We improve the best approximation factor achieved by an algorithm that has optimal adaptivity and nearly optimal query complexity to 1/6 − ε, and even further to 0.193 − ε by increasing the adaptivity by a factor of O(log(k)). The conference version of this work mistakenly employed a subroutine that does not work for non-monotone, submodular functions. In this version, we propose a fixed and improved subroutine to add a set with high average marginal gain, ThreshSeq, which returns a solution in O(log(n)) adaptive rounds with high probability. Moreover, we provide two approximation algorithms. The first has approximation ratio 1/6 − ε, adaptivity O(log(n)), and query complexity O(n log(k)), while the second has approximation ratio 0.193 − ε, adaptivity O(log(n) log(k)), and query complexity O(n log(k)). Our algorithms are empirically validated to use a low number of adaptive rounds and total queries while obtaining solutions with high objective value in comparison with state-of-the-art approximation algorithms, including continuous algorithms that use the multilinear extension.

Practical Parallel Algorithms for Submodular Maximization Subject to a Knapsack Constraint with Nearly Optimal Adaptivity

Submodular maximization has wide applications in machine learning and data mining, where massive datasets have brought the great need for designing efficient and parallelizable algorithms. One measure of the parallelizability of a submodular maximization algorithm is its adaptivity complexity, which indicates the number of sequential rounds where a polynomial number of queries to the objective function can be executed in parallel. In this paper, we study the problem of non-monotone submodular maximization subject to a knapsack constraint, and propose the first combinatorial algorithm achieving an (8+epsilon)-approximation under O(log n) adaptive complexity, which is optimal up to a factor of O(loglog n). Moreover, under slightly larger adaptivity, we also propose approximation algorithms with nearly optimal query complexity of O(n), while achieving better approximation ratios. We show that our algorithms can also be applied to the special case of submodular maximization subject to a cardinality constraint, and achieve performance bounds comparable with those of state-of-the-art algorithms. Finally, the effectiveness of our approach is demonstrated by extensive experiments on real-world applications.

Kernel-based Methods for Bandit Convex Optimization

We consider the adversarial convex bandit problem and we build the first poly( T )-time algorithm with poly( n ) √ T -regret for this problem. To do so, we introduce three new ideas in the derivative-free optimization literature: (i) kernel methods, (ii) a generalization of Bernoulli convolutions, and (iii) a new annealing schedule for exponential weights (with increasing learning rate). The basic version of our algorithm achieves Õ( n 9.5 √ T )-regret, and we show that a simple variant of this algorithm can be run in poly( n log ( T ))-time per step (for polytopes with polynomially many constraints) at the cost of an additional poly( n ) T o(1) factor in the regret. These results improve upon the Õ( n 11 √ T -regret and exp (poly( T ))-time result of the first two authors and the log ( T ) poly( n ) √ T -regret and log( T ) poly( n ) -time result of Hazan and Li. Furthermore, we conjecture that another variant of the algorithm could achieve Õ( n 1.5 √ T )-regret, and moreover that this regret is unimprovable (the current best lower bound being Ω ( n √ T ) and it is achieved with linear functions). For the simpler situation of zeroth order stochastic convex optimization this corresponds to the conjecture that the optimal query complexity is of order n 3 / ɛ 2 .

Hamiltonian Simulation by Qubitization

We present the problem of approximating the time-evolution operatore−iH^tto errorϵ, where the HamiltonianH^=(⟨G|⊗I^)U^(|G⟩⊗I^)is the projection of a unitary oracleU^onto the state|G⟩created by another unitary oracle. Our algorithm solves this with a query complexityO(t+log⁡(1/ϵ))to both oracles that is optimal with respect to all parameters in both the asymptotic and non-asymptotic regime, and also with low overhead, using at most two additional ancilla qubits. This approach to Hamiltonian simulation subsumes important prior art considering Hamiltonians which ared-sparse or a linear combination of unitaries, leading to significant improvements in space and gate complexity, such as a quadratic speed-up for precision simulations. It also motivates useful new instances, such as whereH^is a density matrix. A key technical result is `qubitization', which uses the controlled version of these oracles to embed anyH^in an invariantSU(2)subspace. A large class of operator functions ofH^can then be computed with optimal query complexity, of whiche−iH^tis a special case.

Encoding Electronic Spectra in Quantum Circuits with Linear T Complexity

We construct quantum circuits which exactly encode the spectra of correlated electron models up to errors from rotation synthesis. By invoking these circuits as oracles within the recently introduced "qubitization" framework, one can use quantum phase estimation to sample states in the Hamiltonian eigenbasis with optimal query complexity $O(\lambda / \epsilon)$ where $\lambda$ is an absolute sum of Hamiltonian coefficients and $\epsilon$ is target precision. For both the Hubbard model and electronic structure Hamiltonian in a second quantized basis diagonalizing the Coulomb operator, our circuits have T gate complexity $O({N + \log (1/\epsilon}))$ where $N$ is number of orbitals in the basis. This enables sampling in the eigenbasis of electronic structure Hamiltonians with T complexity $O(N^3 /\epsilon + N^2 \log(1/\epsilon)/\epsilon)$. Compared to prior approaches, our algorithms are asymptotically more efficient in gate complexity and require fewer T gates near the classically intractable regime. Compiling to surface code fault-tolerant gates and assuming per gate error rates of one part in a thousand reveals that one can error correct phase estimation on interesting instances of these problems beyond the current capabilities of classical methods using only about a million superconducting qubits in a matter of hours.

Distribution-free Junta Testing

We study the problem of testing whether an unknown n -variable Boolean function is a k -junta in the distribution-free property testing model, where the distance between functions is measured with respect to an arbitrary and unknown probability distribution over {0,1} n . Our first main result is that distribution-free k -junta testing can be performed, with one-sided error, by an adaptive algorithm that uses Õ( k 2 )/ϵ queries (independent of n ). Complementing this, our second main result is a lower bound showing that any non-adaptive distribution-free k -junta testing algorithm must make Ω(2 k /3 ) queries even to test to accuracy ϵ = 1/3. These bounds establish that while the optimal query complexity of non-adaptive k -junta testing is 2 Θ( k ) , for adaptive testing it is poly( k ), and thus show that adaptivity provides an exponential improvement in the distribution-free query complexity of testing juntas.

Near-optimal quantum circuit for Grover's unstructured search using a transverse field

Inspired by a class of algorithms proposed by Farhi et al. (arXiv:1411.4028), namely the quantum approximate optimization algorithm (QAOA), we present a circuit-based quantum algorithm to search for a needle in a haystack, obtaining the same quadratic speedup achieved by Grover's original algorithm. In our algorithm, the problem Hamiltonian (oracle) and a transverse field are applied alternately to the system in a periodic manner. We introduce a technique, based on spin-coherent states, to analyze the composite unitary in a single period. This composite unitary drives a closed transition between two states that have high degrees of overlap with the initial state and the target state, respectively. The transition rate in our algorithm is of order $\Theta(1/\sqrt N)$, and the overlaps are of order $\Theta(1)$, yielding a nearly optimal query complexity of $T\simeq \sqrt N (\pi/2\sqrt 2\,)$. Our algorithm is a QAOA circuit that demonstrates a quantum advantage with a large number of iterations that is not derived from Trotterization of an adiabatic quantum optimization (AQO) algorithm. It also suggests that the analysis required to understand QAOA circuits involves a very different process from estimating the energy gap of a Hamiltonian in AQO.

Faster quantum searching with almost any diffusion operator

Grover search algorithm drives a quantum system from an initial state to a desired final state by using selective phase inversions of these two states. In (1), we studied a generalization of Grover algorithm which relaxes the assumption of the efficient implementation of the selective phase inversion of the initial state, also known as diffusion operator. This assumption is known to become a serious handicap in cases of physical interest (2,3,4,5). Our general search algorithm works with almost arbitrary diffusion operator with only restriction of having the initial state as one of its eigenstates. The price that we pay for using arbitrary operator is an increase in the number of oracle queries by a factor of order of B, where B is a characteristic of the eigenspectrum of diffusion operator and it can be large in some situations. Here we show that by using quantum fourier transform, we can regain the optimal query complexity of Grover algorithm without losing the freedom of using arbitrary diffusion operators for quantum searching. However, the total number of operators required by algorithm is still order of B times more than that of Grover algorithm. So our algorithm offers advantage only if oracle operator is computationally more expensive than diffusion operator, which is true in most search problems.

A polynomial time approximation scheme for computing the supremum of Gaussian processes

We give a polynomial time approximation scheme (PTAS) for computing the supremum of a Gaussian process. That is, given a finite set of vectors $V\subseteq\mathbb{R}^d$, we compute a $(1+\varepsilon)$-factor approximation to $\mathop {\mathbb{E}}_{X\leftarrow\mathcal{N}^d}[\sup_{v\in V}|\langle v,X\rangle|]$ deterministically in time $\operatorname {poly}(d)\cdot|V|^{O_{\varepsilon}(1)}$. Previously, only a constant factor deterministic polynomial time approximation algorithm was known due to the work of Ding, Lee and Peres [Ann. of Math. (2) 175 (2012) 1409-1471]. This answers an open question of Lee (2010) and Ding [Ann. Probab. 42 (2014) 464-496]. The study of supremum of Gaussian processes is of considerable importance in probability with applications in functional analysis, convex geometry, and in light of the recent breakthrough work of Ding, Lee and Peres [Ann. of Math. (2) 175 (2012) 1409-1471], to random walks on finite graphs. As such our result could be of use elsewhere. In particular, combining with the work of Ding [Ann. Probab. 42 (2014) 464-496], our result yields a PTAS for computing the cover time of bounded-degree graphs. Previously, such algorithms were known only for trees. Along the way, we also give an explicit oblivious estimator for semi-norms in Gaussian space with optimal query complexity. Our algorithm and its analysis are elementary in nature, using two classical comparison inequalities, Slepian's lemma and Kanter's lemma.

Testing Odd-Cycle-Freeness in Boolean Functions

A functionf:2n→ {0,1} isodd-cycle-freeif there are nox1,. . .,xk∈2nwithkan odd integer such thatf(x1) = ··· =f(xk)= 1 andx1+ ··· +xk= 0. We show that one can distinguish odd-cycle-free functions from those ε-far from being odd-cycle-free by making poly(1/ε) queries to an evaluation oracle. We give two proofs of this result, each shedding light on a different connection between testability of properties of Boolean functions and of dense graphs.The first issue we study is directly reducing testing of linear-invariant properties of Boolean functions to testing associated graph properties. We show a black-box reduction from testing odd-cycle-freeness to testing bipartiteness of graphs. Such reductions have already been shown (Král’, Serra and Vena, and Shapira) for monotone linear-invariant properties defined by forbidding solutions to afinitenumber of equations. But for odd-cycle-freeness whose description involves an infinite number of forbidden equations, a reduction to graph property testing was not previously known. If one could show such a reduction more generally for any linear-invariant property closed under restrictions to subspaces, then it would likely lead to a characterization of the one-sided testable linear-invariant properties, an open problem raised by Sudan.The second issue we study is whether there is an efficientcanonicaltester for linear-invariant properties of Boolean functions. A canonical tester for linear-invariant properties operates by picking a random linear subspace and then checking whether the restriction of the input function to the subspace satisfies a fixed property. The question is if, for every linear-invariant property, there is a canonical tester for which there is only a polynomial blow-up from the optimal query complexity. We answer the question affirmatively for odd-cycle-freeness. The general question remains open.

An active learning algorithm for ranking from pairwise preferences with an almost optimal query complexity

Given a set V of n elements we wish to linearly order them given pairwise preference labels which may be non-transitive (due to irrationality or arbitrary noise). The goal is to linearly order the ...

The Geometry of Generalized Binary Search

This paper investigates the problem of determining a binary-valued function through a sequence of strategically selected queries. The focus is an algorithm called Generalized Binary Search (GBS). GBS is a well-known greedy algorithm for determining a binary-valued function through a sequence of strategically selected queries. At each step, a query is selected that most evenly splits the hypotheses under consideration into two disjoint subsets, a natural generalization of the idea underlying classic binary search. This paper develops novel incoherence and geometric conditions under which GBS achieves the information-theoretically optimal query complexity; i.e., given a collection of <formula formulatype="inline" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><tex Notation="TeX">$N$</tex></formula> hypotheses, GBS terminates with the correct function after no more than a constant times <formula formulatype="inline" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink"><tex Notation="TeX">$\log N$</tex></formula> queries. Furthermore, a noise-tolerant version of GBS is developed that also achieves the optimal query complexity. These results are applied to learning halfspaces, a problem arising routinely in image processing and machine learning.

Reconstructing weighted graphs with minimal query complexity

In this paper, we consider the problem of reconstructing a hidden weighted graph using additive queries. We prove the following. Let G be a weighted hidden graph with n vertices and m edges such that the weights on the edges are bounded between n − a and n b for any positive constants a and b . For any m , there exists a non-adaptive algorithm that finds the edges of the graph using O ( m log n log m ) additive queries. This solves the open problem in [S. Choi, J.H. Kim, Optimal query complexity bounds for finding graphs, in: STOC, 2008, pp. 749–758]. Choi and Kim’s proof holds for m ≥ ( log n ) α for a sufficiently large constant α and uses the graph theory. We use the algebraic approach for the problem. Our proof is simple and holds for any m .

Optimal query complexity bounds for finding graphs

We consider the problem of finding an unknown graph by using queries with an additive property. This problem was partially motivated by DNA shotgun sequencing and linkage discovery problems of artificial intelligence. Given a graph, an additive query asks the number of edges in a set of vertices while a cross-additive query asks the number of edges crossing between two disjoint sets of vertices. The queries ask the sum of weights for weighted graphs. For a graph G with n vertices and at most m edges, we prove that there exists an algorithm to find the edges of G using O ( m log n 2 m log ( m + 1 ) ) queries of both types for all m. The bound is best possible up to a constant factor. For a weighted graph with a mild condition on weights, it is shown that O ( m log n log m ) queries are enough provided m ⩾ ( log n ) α for a sufficiently large constant α, which is best possible up to a constant factor if m ⩽ n 2 − ε for any constant ε > 0 . This settles, in particular, a conjecture of Grebinski [V. Grebinski, On the power of additive combinatorial search model, in: Proceedings of the 4th Annual International Conference on Computing and Combinatorics (COCOON 1998), Taipei, Taiwan, 1998, pp. 194–203] for finding an unweighted graph using additive queries. We also consider the problem of finding the Fourier coefficients of a certain class of pseudo-Boolean functions as well as a similar coin weighing problem.

Box-Trees and R-Trees with Near-Optimal Query Time

A box-tree is a bounding-volume hierarchy that uses axis-aligned boxes as bounding volumes. The query complexity of a box-tree with respect to a given type of query is the maximum number of nodes visited when answering such a query. We describe several new algorithms for constructing box-trees with small worst-case query complexity with respect to queries with axis-parallel boxes and with points. We also prove lower bounds on the worst-case query complexity for box-trees, which show that our results are optimal or close to optimal. Finally, we present algorithms to convert box-trees to R-trees, resulting in R-trees with (almost) optimal query complexity.