In the quantum database search problem we are required to search for an item in a database. In this paper, we consider a generalization of this problem, where we are provided d identical copes of a database each with N items which we can query in parallel. Then, given k items, we are required to determine the locations where these items are stored. We show that any quantum algorithm for this task must perform Omega(sqrt{Nk/d min{d,k}}) parallel queries. We also design an algorithm whose performance comes within a factor O(log d) of this lower bound.
We describe a method for private database queries using exchange of quantum states with bits encoded in mutually incompatible bases. For technology with limited coherence time, the database vendor can announce the encoding after a suitable delay to allow the user to privately learn one of two items in the database without the ability to also definitely infer the second item. This quantum approach also allows the user to choose to learn other functions of the items, such as the exclusive-or of their bits, but not to gain more information than equivalent to learning one item, on average. This me…
We consider two combinatorial problems. The first we call "search with wildcards": given an unknown n-bit string x, and the ability to check whether any subset of the bits of x is equal to a provided query string, the goal is to output x. We give a nearly optimal O(sqrt(n) log n) quantum query algorithm for search with wildcards, beating the classical lower bound of Omega(n) queries. Rather than using amplitude amplification or a quantum walk, our algorithm is ultimately based on the solution to a state discrimination problem. The second problem we consider is combinatorial group testing, whic…
We propose a cheat sensitive quantum protocol to perform a private search on a classical database which is efficient in terms of communication complexity. It allows a user to retrieve an item from the server in possession of the database without revealing which item she retrieved: if the server tries to obtain information on the query, the person querying the database can find it out. Furthermore our protocol ensures perfect data privacy of the database, i.e. the information that the user can retrieve in a single queries is bounded and does not depend on the size of the database. With respect …
This paper gives a simple proof of why a quantum computer, despite being in all possible states simultaneously, needs at least 0.707 sqrt(N) queries to retrieve a desired item from an unsorted list of items. The proof is refined to show that a quantum computer would need at least 0.785 sqrt(N) queries. The quantum search algorithm needs precisely this many queries.
We consider a database separated into blocks. Blocks containing target items are called target blocks. Blocks without target items are called non-target blocks. We consider a case, when each target block has the same number of target items. We present a fast quantum algorithm, which finds one of the target blocks. Our algorithm is based on Grover-Radhakrishnan algorithm of partial search. We minimize the number of queries to the oracle.
We present a security analysis of the recently introduced Quantum Private Query (QPQ) protocol. It is a cheat sensitive quantum protocol to perform a private search on a classical database. It allows a user to retrieve an item from the database without revealing which item was retrieved, and at the same time it ensures data privacy of the database (the information that the user can retrieve in a query is bounded and does not depend on the size of the database). The security analysis is based on information-disturbance tradeoffs which show that whenever the provider tries to obtain information …
We present three new quantum algorithms in the quantum query model for \textsc{graph-collision} problem: \begin{itemize} \item an algorithm based on tree decomposition that uses $O\left(\sqrt{n}t^{\sfrac{1}{6}}\right)$ queries where $t$ is the treewidth of the graph; \item an algorithm constructed on a span program that improves a result by Gavinsky and Ito. The algorithm uses $O(\sqrt{n}+\sqrt{α^{**}})$ queries, where $α^{**}(G)$ is a graph parameter defined by \[α^{**}(G):=\min_{VC\text{-- vertex cover of}G}{\max_{\substack{I\subseteq VC\\I\text{-- independent set}}}{\sum_{v\in I}{°{v}}}};\]…
One of the most basic computational problems is the task of finding a desired item in an ordered list of N items. While the best classical algorithm for this problem uses log_2 N queries to the list, a quantum computer can solve the problem using a constant factor fewer queries. However, the precise value of this constant is unknown. By characterizing a class of quantum query algorithms for ordered search in terms of a semidefinite program, we find new quantum algorithms for small instances of the ordered search problem. Extending these algorithms to arbitrarily large instances using recursion…
We consider the problem of inserting one item into a list of N-1 ordered items. We previously showed that no quantum algorithm could solve this problem in fewer than log N/(2 log log N) queries, for N large. We transform the problem into a "translationally invariant" problem and restrict attention to invariant algorithms. We construct the "greedy" invariant algorithm and show numerically that it outperforms the best classical algorithm for various N. We also find invariant algorithms that succeed exactly in fewer queries than is classically possible, and iterating one of them shows that the in…
Sorting is a fundamental computational process, which facilitates subsequent searching of a database. It can be thought of as factorisation of the search process. The location of a desired item in a sorted database can be found by classical queries that inspect one letter of the label at a time. For an unsorted database, no such classical quick search algorithm is available. If the database permits quantum queries, however, then mere digitisation is sufficient for efficient search. Sorting becomes redundant with the quantum superposition of states. A quantum algorithm is written down which loc…
Quantum algorithms often use quantum RAMs (QRAM) for accessing information stored in a database-like manner. QRAMs have to be fast, resource efficient and fault-tolerant. The latter is often influenced by access speeds, because shorter times introduce less exposure of the stored information to noise. The total execution time of an algorithm depends on the QRAM access time which includes: 1) address translation time, and 2) effective query time. The bucket brigade QRAMs were proposed to achieve faster addressing at the cost of exponentially many ancillae. We illustrate a systematic method to si…
For the unsorted database quantum search with the unknown fraction $λ$ of target items, there are mainly two kinds of methods, i.e., fixed-point or trail-and-error. (i) In terms of the fixed-point method, Yoder et al. [Phys. Rev. Lett. 113, 210501 (2014)] claimed that the quadratic speedup over classical algorithms has been achieved. However, in this paper, we point out that this is not the case, because the query complexity of Yoder's algorithm is actually in $O(1/\sqrt{λ_0})$ rather than $O(1/\sqrtλ)$, where $λ_0$ is a known lower bound of $λ$. (ii) In terms of the trail-and-error method, cu…
Quantum partial search algorithm is approximate search. It aims to find a target block (which has the target items). It runs a little faster than full Grover search. In this paper, we consider quantum partial search algorithm for multiple target items unevenly distributed in database (target blocks have different number of target items). The algorithm we describe can locate one of the target blocks. Efficiency of the algorithm is measured by number of queries to the oracle. We optimize the algorithm in order to improve efficiency. By perturbation method, we find that the algorithm runs the fas…
Quantum Grover search algorithm can find a target item in a database faster than any classical algorithm. One can trade accuracy for speed and find a part of the database (a block) containing the target item even faster, this is partial search. A partial search algorithm was recently suggested by Grover and Radhakrishnan. Here we optimize it. Efficiency of the search algorithm is measured by number of queries to the oracle. The author suggests new version of Grover-Radhakrishnan algorithm which uses minimal number of queries to the oracle. The algorithm can run on the same hardware which is us…
We prove lower bounds on the error probability of a quantum algorithm for searching through an unordered list of N items, as a function of the number T of queries it makes. In particular, if T=O(sqrt{N}) then the error is lower bounded by a constant. If we want error <1/2^N then we need T=Omega(N) queries. We apply this to show that a quantum computer cannot do much better than a classical computer when amplifying the success probability of an RP-machine. A classical computer can achieve error <=1/2^k using k applications of the RP-machine, a quantum computer still needs at least ck applicatio…
Quantum private query (QPQ) is a kind of quantum protocols to protect both users' privacy in their communication. There is an interesting example, that is, Alice wants to buy one item from Bob's database, which is composed of a quantity of valuable messages. QPQ protocol is the communication procedure ensuring that Alice can get only one item from Bob, and at the same time, Bob cannot know which one was taken by Alice. Owing to its practicability, quantum-key-distribution-based QPQ has draw much attention in recent years. However, the post-processing of the key in such protocols, called oblivi…
We study the complexity of quantum query algorithms that make p queries in parallel in each timestep. This model is in part motivated by the fact that decoherence times of qubits are typically small, so it makes sense to parallelize quantum algorithms as much as possible. We show tight bounds for a number of problems, specifically Theta((n/p)^{2/3}) p-parallel queries for element distinctness and Theta((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 m…
