01627nas a2200193 4500008004100000245002900041210002900070260001400099300001500113490000800128520112700136100002801263700002301291700002301314700001901337700002001356700002001376856003701396 2020 eng d00aQuantum Coupon Collector0 aQuantum Coupon Collector c2/18/2020 a10:1-10:170 v1583 a
We study how efficiently a k-element set S⊆[n] can be learned from a uniform superposition |S〉 of its elements. One can think of |S〉=∑i∈S|i〉/|S|−−−√ as the quantum version of a uniformly random sample over S, as in the classical analysis of the ``coupon collector problem.'' We show that if k is close to n, then we can learn S using asymptotically fewer quantum samples than random samples. In particular, if there are n−k=O(1) missing elements then O(k) copies of |S〉 suffice, in contrast to the Θ(klogk) random samples needed by a classical coupon collector. On the other hand, if n−k=Ω(k), then Ω(klogk) quantum samples are~necessary. More generally, we give tight bounds on the number of quantum samples needed for every k and n, and we give efficient quantum learning algorithms. We also give tight bounds in the model where we can additionally reflect through |S〉. Finally, we relate coupon collection to a known example separating proper and improper PAC learning that turns out to show no separation in the quantum case.
1 aArunachalam, Srinivasan1 aBelovs, Aleksandrs1 aChilds, Andrew, M.1 aKothari, Robin1 aRosmanis, Ansis1 ade Wolf, Ronald uhttps://arxiv.org/abs/2002.0768802454nas a2200133 4500008004100000245005300041210005300094520206100147100002202208700001802230700001602248700001902264856003702283 2018 eng d00aClassical lower bounds from quantum upper bounds0 aClassical lower bounds from quantum upper bounds3 aWe prove lower bounds on complexity measures, such as the approximate degree of a Boolean function and the approximate rank of a Boolean matrix, using quantum arguments. We prove these lower bounds using a quantum query algorithm for the combinatorial group testing problem.
We show that for any function f, the approximate degree of computing the OR of n copies of f is Omega(sqrt{n}) times the approximate degree of f, which is optimal. No such general result was known prior to our work, and even the lower bound for the OR of ANDs function was only resolved in 2013.
We then prove an analogous result in communication complexity, showing that the logarithm of the approximate rank (or more precisely, the approximate gamma_2 norm) of F: X x Y -> {0,1} grows by a factor of Omega~(sqrt{n}) when we take the OR of n copies of F, which is also essentially optimal. As a corollary, we give a new proof of Razborov's celebrated Omega(sqrt{n}) lower bound on the quantum communication complexity of the disjointness problem.
Finally, we generalize both these results from composition with the OR function to composition with arbitrary symmetric functions, yielding nearly optimal lower bounds in this setting as well.
Harrow, Hassidim, and Lloyd showed that for a suitably specified N×N matrix A and N-dimensional vector b⃗ , there is a quantum algorithm that outputs a quantum state proportional to the solution of the linear system of equations Ax⃗ =b⃗ . If A is sparse and well-conditioned, their algorithm runs in time poly(logN,1/ϵ), where ϵ is the desired precision in the output state. We improve this to an algorithm whose running time is polynomial in log(1/ϵ), exponentially improving the dependence on precision while keeping essentially the same dependence on other parameters. Our algorithm is based on a general technique for implementing any operator with a suitable Fourier or Chebyshev series representation. This allows us to bypass the quantum phase estimation algorithm, whose dependence on ϵ is prohibitive.
1 aChilds, Andrew, M.1 aKothari, Robin1 aSomma, Rolando, D. uhttp://epubs.siam.org/doi/10.1137/16M108707201453nas a2200145 4500008004100000245007600041210006900117260001500186300001200201520099300213100002301206700002301229700001901252856003601271 2015 eng d00aHamiltonian simulation with nearly optimal dependence on all parameters0 aHamiltonian simulation with nearly optimal dependence on all par c2015/01/08 a792-8093 a We present an algorithm for sparse Hamiltonian simulation that has optimal dependence on all parameters of interest (up to log factors). Previous algorithms had optimal or near-optimal scaling in some parameters at the cost of poor scaling in others. Hamiltonian simulation via a quantum walk has optimal dependence on the sparsity $d$ at the expense of poor scaling in the allowed error $\epsilon$. In contrast, an approach based on fractional-query simulation provides optimal scaling in $\epsilon$ at the expense of poor scaling in $d$. Here we combine the two approaches, achieving the best features of both. By implementing a linear combination of quantum walk steps with coefficients given by Bessel functions, our algorithm achieves near-linear scaling in $\tau := d \|H\|_{\max} t$ and sublogarithmic scaling in $1/\epsilon$. Our dependence on $\epsilon$ is optimal, and we prove a new lower bound showing that no algorithm can have sublinear dependence on $\tau$. 1 aBerry, Dominic, W.1 aChilds, Andrew, M.1 aKothari, Robin uhttp://arxiv.org/abs/1501.0171501120nas a2200181 4500008004100000245006700041210006700108260001500175300001100190490000800201520058500209100002300794700002300817700001900840700001900859700002300878856003700901 2015 eng d00aSimulating Hamiltonian dynamics with a truncated Taylor series0 aSimulating Hamiltonian dynamics with a truncated Taylor series c2015/03/03 a0905020 v1143 a We describe a simple, efficient method for simulating Hamiltonian dynamics on a quantum computer by approximating the truncated Taylor series of the evolution operator. Our method can simulate the time evolution of a wide variety of physical systems. As in another recent algorithm, the cost of our method depends only logarithmically on the inverse of the desired precision, which is optimal. However, we simplify the algorithm and its analysis by using a method for implementing linear combinations of unitary operations to directly apply the truncated Taylor series. 1 aBerry, Dominic, W.1 aChilds, Andrew, M.1 aCleve, Richard1 aKothari, Robin1 aSomma, Rolando, D. uhttp://arxiv.org/abs/1412.4687v102001nas a2200181 4500008004100000020002200041245007600063210006900139260001500208300001200223520144000235100002301675700002301698700001901721700001901740700002301759856003701782 2014 eng d a978-1-4503-2710-700aExponential improvement in precision for simulating sparse Hamiltonians0 aExponential improvement in precision for simulating sparse Hamil c2014/05/31 a283-2923 a We provide a quantum algorithm for simulating the dynamics of sparse Hamiltonians with complexity sublogarithmic in the inverse error, an exponential improvement over previous methods. Specifically, we show that a $d$-sparse Hamiltonian $H$ acting on $n$ qubits can be simulated for time $t$ with precision $\epsilon$ using $O\big(\tau \frac{\log(\tau/\epsilon)}{\log\log(\tau/\epsilon)}\big)$ queries and $O\big(\tau \frac{\log^2(\tau/\epsilon)}{\log\log(\tau/\epsilon)}n\big)$ additional 2-qubit gates, where $\tau = d^2 \|{H}\|_{\max} t$. Unlike previous approaches based on product formulas, the query complexity is independent of the number of qubits acted on, and for time-varying Hamiltonians, the gate complexity is logarithmic in the norm of the derivative of the Hamiltonian. Our algorithm is based on a significantly improved simulation of the continuous- and fractional-query models using discrete quantum queries, showing that the former models are not much more powerful than the discrete model even for very small error. We also simplify the analysis of this conversion, avoiding the need for a complex fault correction procedure. Our simplification relies on a new form of "oblivious amplitude amplification" that can be applied even though the reflection about the input state is unavailable. Finally, we prove new lower bounds showing that our algorithms are optimal as a function of the error. 1 aBerry, Dominic, W.1 aChilds, Andrew, M.1 aCleve, Richard1 aKothari, Robin1 aSomma, Rolando, D. uhttp://arxiv.org/abs/1312.1414v201395nas a2200169 4500008004100000245006500041210006500106260001500171300001000186490000700196520090400203100002301107700001901130700001701149700002201166856003701188 2013 eng d00aEasy and hard functions for the Boolean hidden shift problem0 aEasy and hard functions for the Boolean hidden shift problem c2013/04/16 a50-790 v223 a We study the quantum query complexity of the Boolean hidden shift problem. Given oracle access to f(x+s) for a known Boolean function f, the task is to determine the n-bit string s. The quantum query complexity of this problem depends strongly on f. We demonstrate that the easiest instances of this problem correspond to bent functions, in the sense that an exact one-query algorithm exists if and only if the function is bent. We partially characterize the hardest instances, which include delta functions. Moreover, we show that the problem is easy for random functions, since two queries suffice. Our algorithm for random functions is based on performing the pretty good measurement on several copies of a certain state; its analysis relies on the Fourier transform. We also use this approach to improve the quantum rejection sampling approach to the Boolean hidden shift problem. 1 aChilds, Andrew, M.1 aKothari, Robin1 aOzols, Maris1 aRoetteler, Martin uhttp://arxiv.org/abs/1304.4642v100867nas a2200145 4500008004100000245007400041210006900115260001500184520040100199100002300600700002000623700001900643700002200662856003700684 2013 eng d00aA Time-Efficient Quantum Walk for 3-Distinctness Using Nested Updates0 aTimeEfficient Quantum Walk for 3Distinctness Using Nested Update c2013/02/283 a We present an extension to the quantum walk search framework that facilitates quantum walks with nested updates. We apply it to give a quantum walk algorithm for 3-Distinctness with query complexity ~O(n^{5/7}), matching the best known upper bound (obtained via learning graphs) up to log factors. Furthermore, our algorithm has time complexity ~O(n^{5/7}), improving the previous ~O(n^{3/4}). 1 aChilds, Andrew, M.1 aJeffery, Stacey1 aKothari, Robin1 aMagniez, Frederic uhttp://arxiv.org/abs/1302.7316v101823nas a2200157 4500008004100000245005500041210005000096260001500146300001200161490000900173520138500182100002301567700001901590700001901609856003701628 2012 eng d00aThe quantum query complexity of read-many formulas0 aquantum query complexity of readmany formulas c2012/09/10 a337-3480 v75013 a The quantum query complexity of evaluating any read-once formula with n black-box input bits is Theta(sqrt(n)). However, the corresponding problem for read-many formulas (i.e., formulas in which the inputs have fanout) is not well understood. Although the optimal read-once formula evaluation algorithm can be applied to any formula, it can be suboptimal if the inputs have large fanout. We give an algorithm for evaluating any formula with n inputs, size S, and G gates using O(min{n, sqrt{S}, n^{1/2} G^{1/4}}) quantum queries. Furthermore, we show that this algorithm is optimal, since for any n,S,G there exists a formula with n inputs, size at most S, and at most G gates that requires Omega(min{n, sqrt{S}, n^{1/2} G^{1/4}}) queries. We also show that the algorithm remains nearly optimal for circuits of any particular depth k >= 3, and we give a linear-size circuit of depth 2 that requires Omega (n^{5/9}) queries. Applications of these results include a Omega (n^{19/18}) lower bound for Boolean matrix product verification, a nearly tight characterization of the quantum query complexity of evaluating constant-depth circuits with bounded fanout, new formula gate count lower bounds for several functions including PARITY, and a construction of an AC^0 circuit of linear size that can only be evaluated by a formula with Omega(n^{2-epsilon}) gates. 1 aChilds, Andrew, M.1 aKimmel, Shelby1 aKothari, Robin uhttp://arxiv.org/abs/1112.0548v101380nas a2200145 4500008004100000245006200041210006100103260001500164300001200179490000600191520095800197100002301155700001901178856003701197 2011 eng d00aQuantum query complexity of minor-closed graph properties0 aQuantum query complexity of minorclosed graph properties c2011/01/01 a661-6720 v93 a We study the quantum query complexity of minor-closed graph properties, which include such problems as determining whether an $n$-vertex graph is planar, is a forest, or does not contain a path of a given length. We show that most minor-closed properties---those that cannot be characterized by a finite set of forbidden subgraphs---have quantum query complexity \Theta(n^{3/2}). To establish this, we prove an adversary lower bound using a detailed analysis of the structure of minor-closed properties with respect to forbidden topological minors and forbidden subgraphs. On the other hand, we show that minor-closed properties (and more generally, sparse graph properties) that can be characterized by finitely many forbidden subgraphs can be solved strictly faster, in o(n^{3/2}) queries. Our algorithms are a novel application of the quantum walk search framework and give improved upper bounds for several subgraph-finding problems. 1 aChilds, Andrew, M.1 aKothari, Robin uhttp://arxiv.org/abs/1011.1443v201041nas a2200121 4500008004100000245006000041210006000101260001500161520066400176100002300840700001900863856003700882 2010 eng d00aSimulating sparse Hamiltonians with star decompositions0 aSimulating sparse Hamiltonians with star decompositions c2010/03/183 a We present an efficient algorithm for simulating the time evolution due to a sparse Hamiltonian. In terms of the maximum degree d and dimension N of the space on which the Hamiltonian H acts for time t, this algorithm uses (d^2(d+log* N)||Ht||)^{1+o(1)} queries. This improves the complexity of the sparse Hamiltonian simulation algorithm of Berry, Ahokas, Cleve, and Sanders, which scales like (d^4(log* N)||Ht||)^{1+o(1)}. To achieve this, we decompose a general sparse Hamiltonian into a small sum of Hamiltonians whose graphs of non-zero entries have the property that every connected component is a star, and efficiently simulate each of these pieces. 1 aChilds, Andrew, M.1 aKothari, Robin uhttp://arxiv.org/abs/1003.3683v201322nas a2200121 4500008004100000245006100041210006000102260001500162520094400177100002301121700001901144856003701163 2009 eng d00aLimitations on the simulation of non-sparse Hamiltonians0 aLimitations on the simulation of nonsparse Hamiltonians c2009/08/313 a The problem of simulating sparse Hamiltonians on quantum computers is well studied. The evolution of a sparse N x N Hamiltonian H for time t can be simulated using O(||Ht||poly(log N)) operations, which is essentially optimal due to a no--fast-forwarding theorem. Here, we consider non-sparse Hamiltonians and show significant limitations on their simulation. We generalize the no--fast-forwarding theorem to dense Hamiltonians, ruling out generic simulations taking time o(||Ht||), even though ||H|| is not a unique measure of the size of a dense Hamiltonian $H$. We also present a stronger limitation ruling out the possibility of generic simulations taking time poly(||Ht||,log N), showing that known simulations based on discrete-time quantum walk cannot be dramatically improved in general. On the positive side, we show that some non-sparse Hamiltonians can be simulated efficiently, such as those with graphs of small arboricity. 1 aChilds, Andrew, M.1 aKothari, Robin uhttp://arxiv.org/abs/0908.4398v2