Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Log inSign up
Challenges
Datasets
Workspaces
Papers
Discussions
Leaderboard
Blog
Job Board
Q3AS

© 2026 Aqora Quantum S.A.S.

TermsPrivacyLegal Notice

arXiv:quant-ph/0309123 · Quantum Information and Computation

How significant are the known collision and element distinctness quantum algorithms?

Lov K. Grover, Terry Rudolph

Published May 1, 2004• 23 citations
arXivHTMLPDF

Abstract

Quantum search is a technique for searching $N$ possibilities for a desired target in $O(\sqrt{N})$ steps. It has been applied in the design of quantum algorithms for several structured problems. Many of these algorithms require significant amount of quantum hardware. In this paper we propose the criterion that an algorithm which requires $O(S)$ hardware should be considered significant if it produces a speedup of better than $O\left(\sqrt{S}\right)$ over a simple quantum search algorithm. This is because a speedup of $O\left(\sqrt{S}\right)$ can be trivially obtained by dividing the search space into $S$ separate parts and handing the problem to $S$ independent processors that do a quantum search (in this paper we drop all logarithmic factors when discussing time/space complexity). Known algorithms for collision and element distinctness exactly saturate the criterion.

DOI
10.26421/qic4.3-5

Related papers

How significant are the known collision and element distinctness quantum algorithms

GroverLov, RudolphTerry

Quantum search is a technique for searching N possibilities for a desired target in O(√N)steps. It has been applied in the design of quantum algorithms fur several structuredproblems. Many of these...

Quantum Information and Computation•May 1, 2004•0 citations

Tight Time-Space Lower Bounds for Collision Finding and Element Distinctness under Label Symmetry

Frédéric Magniez, Sebastian Zur

How much memory is needed to retain the quantum speedup for collision finding? For a uniformly random function $f:[N]\to [N]$, the BHT algorithm finds a collision using $O(N^{1/3})$ queries and a quantumly accessible classical table containing $O(N^{1/3})$ input-output pairs, whereas a logarithmic-space Grover search uses $O(\sqrt N)$ queries. Determining the optimal query-space tradeoff between these extremes remains a major open problem. We resolve this equation within the class of label-symmetric algorithms, which treat the function $f$'s output labels as interchangeable. We prove that such algorithm that makes $T$ queries, uses $S$ qubits, and finds a collision in a uniformly random function $f:[M]\to [N]$ with constant probability satisfies $$T=Ω(N^{1/3}) \qquad\text{and}\qquad T^2S=Ω(N\log N).$$ For the setting where $M=N$, these bounds are matched by a space-efficient implementation of the BHT algorithm. As a consequence of our tradeoff, any label-symmetric algorithm for the search version of Element Distinctness on $f: [n] \to [n^2]$ must satisfy $$T=Ω(n^{2/3}) \qquad\text{and}\qquad T^2S=Ω(n^2\log n),$$ matching Ambainis's quantum walk. Thus, both tradeoffs are optimal within the class of label-symmetric algorithms. To prove these results, we develop a space-sensitive version of the compressed oracle technique. The compressed oracle records the information learned by the algorithm in an evolving superposition of databases. Using label symmetry and representation theory, we show that an algorithm using $S$ qubits can effectively retain information about only $O(S/\log N)$ collision-free database entries. Substituting this estimate into the compressed oracle technique yields the stated tradeoffs.

quant-pharXiv:2609.10808•Sep 11, 2026•0 citations

An efficient quantum search engine on unsorted database

Heping Hu, Yingyu Zhang, Zhengding Lu

We consider the problem of finding one or more desired items out of an unsorted database. Patel has shown that if the database permits quantum queries, then mere digitization is sufficient for efficient search for one desired item. The algorithm, called factorized quantum search algorithm, presented by him can locate the desired item in an unsorted database using $O(log_{4}N)$ queries to factorized oracles. But the algorithm requires that all the property values must be distinct from each other. In this paper, we discuss how to make a database satisfy the requirements, and present a quantum search engine based on the algorithm. Our goal is achieved by introducing auxiliary files for the property values that are not distinct, and converting every complex query request into a sequence of calls to factorized quantum search algorithm. The query complexity of our algorithm is $O(P*Q*M*log_{4}N)$, where P is the number of the potential simple query requests in the complex query request, Q is the maximum number of calls to the factorized quantum search algorithm of the simple queries, M is the number of the auxiliary files for the property on which our algorithm are searching for desired items. This implies that to manage an unsorted database on an actual quantum computer is possible and efficient.

arXiv:0904.3060•Apr 20, 2009•0 citations

Grover’s quantum searching algorithm is optimal

Christof Zalka

I show that for any number of oracle lookups up to about $\ensuremath{\pi}/4\sqrt{N},$ Grover's quantum searching algorithm gives the maximal possible probability of finding the desired element. I explain why this is also true for quantum algorithms which use measurements during the computation. I also show that unfortunately quantum searching cannot be parallelized better than by assigning different parts of the search space to independent quantum computers.

arXiv:quant-ph/9711070•Physical Review A•Oct 1, 1999•636 citations

An Efficient Quantum Multi-Collision Search Algorithm

Jian Xiao Zou, Yongyang Liu, Le Dong

In this article, we propose an efficient quantum k-collision search algorithm with low quantum memory O(n). The previous quantum k-collision algorithms can not be converted into a low quantum memory k-collision algorithm directly, because the time complexity of the converted algorithm is larger than the basic k-collision algorithm. To solve this problem, we shall not only divide our low memory quantum k-collision algorithm into several subroutines, but also need to achieve some balances between these subrou tines. The time complexity of our k-collision search algorithm is O(2(2k-2)n/2k+1-3 ), and the classical memory and quantum memory complexities are O(2(2k-2)n/2k+1-3 ) and O(n) respectively. In addition, we propose an efficient k-claw search algorithm, which can output a k-claw with O(n) qubits. Given 2squantum processors, we can construct our quantum k-collision and k-claw parallel algorithm with the time of O(2(2k-2)n-(2k+1-2k-1-3)s/2k+1-3 )while the classical memory and quantum memory complexities are O(2(2k-1-1)n+s-2k-2/2k+1-3 ) and O(n), respectively.

IEEE Access•Jan 1, 2020•3 citations

Hardware Efficient Quantum Search Algorithm

Ji Liu, Huiyang Zhou

Quantum computing has noteworthy speedup over classical computing by taking advantage of quantum parallelism, i.e., the superposition of states. In particular, quantum search is widely used in various computationally hard problems. Grover's search algorithm finds the target element in an unsorted database with quadratic speedup than classical search and has been proved to be optimal in terms of the number of queries to the database. The challenge, however, is that Grover's search algorithm leads to high numbers of quantum gates, which make it infeasible for the Noise-Intermediate-Scale-Quantum (NISQ) computers. In this paper, we propose a novel hardware efficient quantum search algorithm to overcome this challenge. Our key idea is to replace the global diffusion operation with low-cost local diffusions. Our analysis shows that our algorithm has similar oracle complexity to the original Grover's search algorithm while significantly reduces the circuit depth and gate count. The circuit cost reduction leads to a remarkable improvement in the system success rates, paving the way for quantum search on NISQ machines.

arXiv:2103.14196•Mar 26, 2021•6 citations
Quantum search is a technique for searching NNN possibilities for a desired target in O(N)O(\sqrt{N})O(N​) steps. It has been applied in the design of quantum algorithms for several structured problems. Many of these algorithms require significant amount of quantum hardware. In this paper we propose the criterion that an algorithm which requires O(S)O(S)O(S) hardware should be considered significant if it produces a speedup of better than O(S)O\left(\sqrt{S}\right)O(S​) over a simple quantum search algorithm. This is because a speedup of O(S)O\left(\sqrt{S}\right)O(S​) can be trivially obtained by dividing the search space into SSS separate parts and handing the problem to SSS independent processors that do a quantum search (in this paper we drop all logarithmic factors when discussing time/space complexity). Known algorithms for collision and element distinctness exactly saturate the criterion.
How much memory is needed to retain the quantum speedup for collision finding? For a uniformly random function f:[N]→[N]f:[N]\to [N]f:[N]→[N], the BHT algorithm finds a collision using O(N1/3)O(N^{1/3})O(N1/3) queries and a quantumly accessible classical table containing O(N1/3)O(N^{1/3})O(N1/3) input-output pairs, whereas a logarithmic-space Grover search uses O(N)O(\sqrt N)O(N​) queries. Determining the optimal query-space tradeoff between these extremes remains a major open problem. We resolve this equation within the class of label-symmetric algorithms, which treat the function fff's output labels as interchangeable. We prove that such algorithm that makes TTT queries, uses SSS qubits, and finds a collision in a uniformly random function f:[M]→[N]f:[M]\to [N]f:[M]→[N] with constant probability satisfies T=Ω(N1/3)andT2S=Ω(Nlog⁡N).T=Ω(N^{1/3}) \qquad\text{and}\qquad T^2S=Ω(N\log N).T=Ω(N1/3)andT2S=Ω(NlogN). For the setting where M=NM=NM=N, these bounds are matched by a space-efficient implementation of the BHT algorithm. As a consequence of our tradeoff, any label-symmetric algorithm for the search version of Element Distinctness on f:[n]→[n2]f: [n] \to [n^2]f:[n]→[n2] must satisfy T=Ω(n2/3)andT2S=Ω(n2log⁡n),T=Ω(n^{2/3}) \qquad\text{and}\qquad T^2S=Ω(n^2\log n),T=Ω(n2/3)andT2S=Ω(n2logn), matching Ambainis's quantum walk. Thus, both tradeoffs are optimal within the class of label-symmetric algorithms. To prove these results, we develop a space-sensitive version of the compressed oracle technique. The compressed oracle records the information learned by the algorithm in an evolving superposition of databases. Using label symmetry and representation theory, we show that an algorithm using SSS qubits can effectively retain information about only O(S/log⁡N)O(S/\log N)O(S/logN) collision-free database entries. Substituting this estimate into the compressed oracle technique yields the stated tradeoffs.
We consider the problem of finding one or more desired items out of an unsorted database. Patel has shown that if the database permits quantum queries, then mere digitization is sufficient for efficient search for one desired item. The algorithm, called factorized quantum search algorithm, presented by him can locate the desired item in an unsorted database using O(log4N)O(log_{4}N)O(log4​N) queries to factorized oracles. But the algorithm requires that all the property values must be distinct from each other. In this paper, we discuss how to make a database satisfy the requirements, and present a quantum search engine based on the algorithm. Our goal is achieved by introducing auxiliary files for the property values that are not distinct, and converting every complex query request into a sequence of calls to factorized quantum search algorithm. The query complexity of our algorithm is O(P∗Q∗M∗log4N)O(P*Q*M*log_{4}N)O(P∗Q∗M∗log4​N), where P is the number of the potential simple query requests in the complex query request, Q is the maximum number of calls to the factorized quantum search algorithm of the simple queries, M is the number of the auxiliary files for the property on which our algorithm are searching for desired items. This implies that to manage an unsorted database on an actual quantum computer is possible and efficient.
In this article, we propose an efficient quantum k-collision search algorithm with low quantum memory O(n). The previous quantum k-collision algorithms can not be converted into a low quantum memory k-collision algorithm directly, because the time complexity of the converted algorithm is larger than the basic k-collision algorithm. To solve this problem, we shall not only divide our low memory quantum k-collision algorithm into several subroutines, but also need to achieve some balances between these subrou tines. The time complexity of our k-collision search algorithm is O(2(2k-2)n/2k+1-3 ), and the classical memory and quantum memory complexities are O(2(2k-2)n/2k+1-3 ) and O(n) respectively. In addition, we propose an efficient k-claw search algorithm, which can output a k-claw with O(n) qubits. Given 2squantum processors, we can construct our quantum k-collision and k-claw parallel algorithm with the time of O(2(2k-2)n-(2k+1-2k-1-3)s/2k+1-3 )while the classical memory and quantum memory complexities are O(2(2k-1-1)n+s-2k-2/2k+1-3 ) and O(n), respectively.
Quantum computing has noteworthy speedup over classical computing by taking advantage of quantum parallelism, i.e., the superposition of states. In particular, quantum search is widely used in various computationally hard problems. Grover's search algorithm finds the target element in an unsorted database with quadratic speedup than classical search and has been proved to be optimal in terms of the number of queries to the database. The challenge, however, is that Grover's search algorithm leads to high numbers of quantum gates, which make it infeasible for the Noise-Intermediate-Scale-Quantum (NISQ) computers. In this paper, we propose a novel hardware efficient quantum search algorithm to overcome this challenge. Our key idea is to replace the global diffusion operation with low-cost local diffusions. Our analysis shows that our algorithm has similar oracle complexity to the original Grover's search algorithm while significantly reduces the circuit depth and gate count. The circuit cost reduction leads to a remarkable improvement in the system success rates, paving the way for quantum search on NISQ machines.