A Quantum Algorithm for Finding Common Matches Between Databases with Reliable Behavior

TL;DR

This paper introduces a quantum algorithm that efficiently finds common entries across multiple unstructured databases using amplitude amplification, requiring fewer queries than classical methods.

Contribution

It presents a novel quantum algorithm that constructs an oracle for common entries and employs a reliable amplitude amplification technique for improved success probability.

Findings

Requires O(κ√N) queries to find common entries.

Constructs an oracle to mark common entries.

Uses a variation of amplitude amplification with reliable behavior.

Abstract

Given $\kappa$ databases of unstructured entries, we propose a quantum algorithm to find the common entries between those databases. The proposed algorithm requires $\mathcal{O}(\kappa \sqrt{N})$ queries to find the common entries, where $N$ is the number of records for each database. The proposed algorithm constructs an oracle to mark common entries, and then uses a variation of amplitude amplification technique with reliable behavior to increase the success probability of finding them.

Equations

$$|\phi ⟩=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩\otimes |0⟩.$$

$$Y=(H^{\otimes n}\otimes I)(2|0⟩⟨0|-I_{n+1})(H^{\otimes n}\otimes I).$$

$$|\varphi^{q}\rangle=a_{q}\sum_{i=0}^{{N-1}}{}^{\prime\prime}\big{(}|i\rangle\otimes|0\rangle\big{)}+b_{q}\sum_{i=0}^{{N-1}}{}^{\prime}\big{(}|i\rangle\otimes|0\rangle\big{)}+c_{q}\sum_{i=0}^{{N-1}}{}^{\prime}\big{(}|i\rangle\otimes|1\rangle\big{)},$$

$$a_q$$

$$\langle\alpha_{q}\rangle=\Big{(}\big{(}1-\frac{M}{N}\big{)}a_{q-1}+\big{(}\frac{M}{N}\big{)}c_{q-1}\Big{)}.$$

$$P_{s}=\big{(}1-\cos\big{(}\theta\big{)}\big{)}\Big{(}\frac{\sin^{2}\big{(}\big{(}q+1\big{)}\theta\big{)}}{\sin^{2}\big{(}\theta\big{)}}+\frac{\sin^{2}\big{(}q\theta\big{)}}{\sin^{2}\big{(}\theta\big{)}}\Big{)},$$

$$q=\Bigl{\lfloor}\frac{\pi}{2\theta}\Bigr{\rfloor}\leq\frac{\pi}{2\sqrt{2}}\sqrt{\frac{N}{M}},$$

$$U_{\hslash }{=}_{n+1}^{0\to n-1}{U}_B{\times }_n^{0\to n-1}{U}_A{\times }_{n+2}^{n\to n+1}{U}_{\kappa }{\times }_{n+1}^{0\to n-1}{U}_B{\times }_n^{0\to n-1}{U}_A,$$

$$f_{\kappa }(x)=f_A(x)\cdot f_B(x),$$

$$|{\phi }_0⟩=|0{⟩}^{\otimes n}\otimes |0{⟩}^{\otimes 3}.$$

$$|{\phi }_1⟩$$

$$=H^{\otimes n}|0{⟩}^{\otimes n}\otimes |0{⟩}^{\otimes 3}$$

$$=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩\otimes |0{⟩}^{\otimes 3}.$$

$$|{\phi }_2⟩$$

$$=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩\otimes |f_A(i)⟩\otimes |0{⟩}^{\otimes 2}.$$

$$|{\phi }_3⟩$$

$$=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩\otimes |f_A(i)⟩\otimes |f_B(i)⟩\otimes |0⟩.$$

$$|{\phi }_4⟩$$

$$=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩\otimes |f_A(i)⟩\otimes |f_B(i)⟩\otimes |f_{\kappa }(i)⟩,$$

$$|{\phi }_5⟩$$

$$=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩\otimes |0{⟩}^{\otimes 2}\otimes |f_{\kappa }(i)⟩.$$

$$|{\phi }_5⟩=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}{}^{\prime \prime }(|i⟩\otimes |0⟩)+\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}{}^{\prime }(|i⟩\otimes |1⟩),$$

$$U_{\hslash }=\prod _{j=0}^{\kappa -1}{}_{n+j}^{0\to n-1}{U}_j{\times }_{n+\kappa }^{n\to n+\kappa -1}{U}_{\kappa }\times \prod _{j=0}^{\kappa -1}{}_{n+j}^{0\to n-1}{U}_j,$$

$$f_{\kappa }(x)=\underset{j=0}{\overset{\kappa -1}{\bigwedge }}{f}_j(x),$$

$$|\phi ⟩=\frac{1}{\sqrt{N}}\sum _{i=0}^{N-1}|i⟩\otimes |0{⟩}^{\otimes \kappa }\otimes |f_{\kappa }(i)⟩.$$

$$q_t$$

$$=2\times \kappa \times \frac{\pi }{2\sqrt{2}}\sqrt{N/M_c}$$

$$=\kappa \times \frac{\pi }{\sqrt{2}}\sqrt{N/M_c}$$

Full text

1 Introduction

Given $\kappa$ databases with unstructured entries, it is required to find the joint entries between those databases. Considering this problem in classical computers, an intuitive approach is to count similar entries from those databases and store them in a memory which keeps track of each entry and its number of occurrences, and then iterate over this memory and observe when the number of occurrences of certain entries equal to $\kappa$. This procedure requires at most $\mathcal{O}(\kappa N)$ queries.

Quantum computers [1, 2, 3] are inherently probabilistic devices which promise to significantly accelerate certain types of computations compared to classical computers [4], by utilizing quantum phenomena like entanglement and superposition. Many quantum algorithms have emerged recently, for example, Deutch-Jousza algorithm [5] that tests whether a given Boolean function is a balanced Boolean function or a constant Boolean function, using only a single oracle call. P. Shor introduced a polynomial-time algorithm [6] to factorize a composite integer to its prime factors. L. Grover presented a quantum algorithm [7] to search for an entry in an unstructured list of entries in quadratic speed-up compared to classical computers.

In 1998, Burhman et al. introduced an algorithm [8] that solves a problem similar to the common entries problem: given two remotely separated schedules of unknown free slots out of $N=2^{n}$ slots, find a common slot between those two schedules, in as minimum communication bits sent as possible. Burhman et al. algorithm requires $\mathcal{O}(\sqrt{N}\log_{2}N)$ communication complexity and $\mathcal{O}(k\sqrt{N})$ query calls, with $k$ trails and error at most $2^{-k}$ [8]. Later in 2002, L. Grover proposed an algorithm [9] to solve scheduling problem with $\mathcal{O}(\sqrt{\epsilon N}\log_{2}{N})$ computation complexity.

In 2012, A. Tulsi proposed a quantum algorithm [10] to find a single common element between two sets in $\mathcal{O}(\sqrt{N})$ using an ancilla qubit to mark the common solution with phase-shift and applying amplitude amplification algorithm to increase the success probability of the desired result.

In 2013, Pang et al. introduced a quantum algorithm [11] for set operations. In that literature, Pang et al. provided a subroutine to find common intersected elements between two sets of size $2^{n}$ and $2^{m}$ elements in $\mathcal{O}(\sqrt{2^{m+n}/C})$, where $C$ is the number of common entries, using a similar algorithm proposed in [12].

The aim of this paper is to propose an algorithm to find the common matches $M$ between given $\kappa$ databases each of $N$ entries. Each given database uses a black-box to identify its elements. The proposed algorithm can find a match among the common entries using a new oracle $U_{\hbar}$ which is constructed from the set of all given black-boxes $\hbar$. The new oracle $U_{\hbar}$ is then used along with amplitude amplification technique based on partial diffusion operator, to increase the success probability of finding the desired results. As well, the algorithm works with probability of success at least $2/3$.

The paper is organized as follows: Section  2 depicts an amplitude amplification algorithm with reliable behavior used to solve the problem at hand. Section  3 cover the construction of the oracle $U_{\hbar}$. Section  4 introduces the proposed algorithm. Section  5 analyzes the proposed algorithm. Section 6 compares the proposed algorithm to other literature, followed by a conclusion in Section  7.

2 Amplitude Amplification

Consider having a list $L$ of $N=2^{n}$ of unstructured entries, which has an oracle $U_{f}$ that is being used to access those entries. Each entry $i\in L=\{0,1,...,N-1\}$ in the list $L$ is mapped to either [math] or $1$ according to any certain property satisfied by $i$ in $L$, i.e. $f:L\rightarrow\{0,1\}$. The amplitude amplification problem is stated as follows: find the entry $i\in L$ such that $f(i)=1$.

In 1996, L. Grover proposed a unique approach to solve this typical problem with quadratic speed-up compared to classical algorithms [7]. The algorithm Grover proposed takes advantage of quantum parallelism to solve this problem by preparing a perfect superposition of all the possible $N$ entries corresponding to the list $L$, after that it starts marking the solution using phase shift of $-1$ using the oracle $U_{f}$, followed by amplifying the amplitude of the solution using inversion about the mean operator. It was shown in [7, 13] that the algorithm requires $\pi/4\sqrt{N}$ iteration to optimally [14] find a solution to the search problem with high probability, assuming there is only one solution $i\in L$ that satisfies the oracle $U_{f}$.

Boyer et al. later generalized Grover’s quantum search algorithm to fit the purpose of finding multiple solutions $M$ to the oracle $U_{f}$, i.e. $\forall p$, for which $1\leq p\leq M\leq 3N/4$, $f(i_{p})=1$, to require a number of $\pi/4\sqrt{N/M}$ iterations of the algorithm [12]. For the case of unknown number of solutions $M$ to the oracle, an algorithm [15] was proposed to find such number $M$. However, the generalized quantum search algorithm has shown to exponentially fail in the case of $M>3N/4$ [12, 13].

Younes et al. introduced a variation of the generalized quantum search algorithm [16] with reliable behavior in case of multiple solutions to the oracle $U_{f}$, i.e. $1\leq M\leq N$, and requires $\mathcal{O}(\sqrt{N/M})$ oracle calls.

In the case of known multiple solutions $M$ for a list $L$ of size $N=2^{n}$, Younes et al. algorithm is outlined as follows:

Prepare a quantum register with $n+1$ qubits in a uniform superposition:

[TABLE] 2. 2.

Iterate the algorithm for ${\pi}/{(2\sqrt{2})}\sqrt{{N}/{M}}$ times by applying the partial diffusion operator $Y$ on the state $U_{f}|\varphi\rangle$ in each iteration, such that it performs the inversion about the mean on a subspace of the system, where

[TABLE]

At any iteration $q\geq 2$, the system can be described as follows [16]:

[TABLE]

where the amplitudes $a_{q},~{}b_{q}$ and $c_{q}$ are recursively defined as follows:

[TABLE]

and

[TABLE]

For this algorithm, the success probability is as follows [16]:

[TABLE]

where \cos\big{(}\theta\big{)}=1-M/N, $0<\theta\leq\pi/2$, and the required number of iterations $q$ is given by [16]:

[TABLE]

where $\lfloor~{}\rfloor$ is the floor operation.

Although Younes et al. variation of quantum search algorithm runs slower compared to Grover’s algorithm by $\sqrt{2}$ for small $M/N$, but Younes et al. algorithm is more reliable with high probability than generalized Grover search algorithm for multiple matches $M$ [16] such that $1\leq M\leq N$.

3 Constructing the Oracle $U_{\hbar}$

In this section, the given set of oracles $\hbar$ will be utilized to construct the oracle $U_{\hbar}$ which will be used for finding the common solutions $M$ between the oracles in the set $\hbar$, assuming that all the given oracles are of $N=2^{n}$ unstructured entries, given that $n$ is the number of inputs to all of the given oracles. For the sake of simplification, we will provide a simple illustration for the oracle $U_{\hbar}$ assuming that the size of the set $\hbar$ is only $\kappa=2$ oracles, and after that we will propose the generalized form of the oracle $U_{\hbar}$ for multiple oracles $\kappa\geq 2$.

Definition 3.1**.**

Let’s assume having a Boolean function $f$ that maps a vector of size $n$ to either [math] or $1$, i.e. $f:\{0,1\}^{n}\rightarrow\{0,1\}$. An oracle $U_{f}$ is defined to perform such mapping. We say that $U_{f}$ is an operator on $n+t+q+1$ qubits, taking the control $0\rightarrow n-1$ qubits and targets the qubit with the index $n+t$; this configuration will be denoted as ${}^{0\rightarrow n-1}_{n+t}U_{f}$. Such defined oracle can be illustrated as follows:

For the problem of finding common entries $M$ between $\kappa$ oracles, the problem statement can be defined as follows:

Definition 3.2**.**

Consider having a set $\mathcal{Z}$ of $\kappa\geq 2$ lists, $\mathcal{Z}=\{L_{0},\cdots,L_{\kappa-1}\}$. Each list $L_{j}\in\mathcal{Z}$ is of $N=2^{n}$ unstructured entries, which has an oracle $U_{j}$ that is being used to access those entries in $L_{j}$. Each entry $i\in L_{j}=\{0,1,\cdots,N-1\}$ in the list $L_{j}$ is mapped to either [math] or $1$ according to any certain property satisfied by $i$ in $L_{j}$, i.e. $f_{j}:L_{j}\rightarrow\{0,1\}$. The common elements problem is stated as follows: find the entry $i\in L_{j}$ such that $\forall L_{j}\in\mathcal{Z},~{}f_{j}(i)=1$.

3.1 Constructing the Oracle $U_{\hbar}$ for Two Databases

Given that $\kappa=2$ oracles, $U_{A}$ and $U_{B}$, which map the elements of black-box functions $f_{A}$ and $f_{B}$ of $n$ input to either [math] or $1$, it is required to find the common solutions $M$ between them. It will be required to reserve $3$ auxiliary qubits. An illustration of this circuit is shown in Figure  3.

A quantum circuit for the oracle $U_{\hbar}$ can be constructed as follows:

[TABLE]

where the operator $U_{\kappa}$ represents the function $f_{\kappa}(x)$:

[TABLE]

such that $\cdot$ is the AND logic operation, and $x\in\{0,1\}^{n}$.

To clarify the effect of the proposed oracle $U_{\hbar}$, let’s analyze that effect on a uniform superposition as follows:

Register Preparation. Prepare a quantum register of size $n+3$ qubits in the state $|0\rangle$, where the last $3$ qubits will be utilized as extra space to compute the oracles $U_{A}$, $U_{B}$ and the common solutions between them:

[TABLE] 2. 2.

Register Initialization. Apply Hadamard gates on the first $n$ qubits to get a uniform superposition of all the possible $N=2^{n}$ states:

[TABLE] 3. 3.

Applying the Oracle $U_{A}$. Apply the oracle $U_{A}$ on the register to mark all its possible solutions in the first extra qubit, where non-solutions will be marked with $|0\rangle$ and the solutions will be marked with $|1\rangle$:

[TABLE] 4. 4.

Applying the Oracle $U_{B}$. Apply the oracle $U_{B}$ on the register to mark all its possible solutions in the second extra qubit, where the non-solution states will be marked with $|0\rangle$ and the solution states will be marked with $|1\rangle$:

[TABLE] 5. 5.

Applying the Operator $U_{\kappa}$. Apply the operator $U_{\kappa}$ on the register to mark all possible common solutions between the oracles $U_{A}$ and $U_{B}$ in the third extra qubit, where non-common solutions will be marked with $|0\rangle$ and the common solutions will be marked with $|1\rangle$:

[TABLE]

where $f_{\kappa}(i)$ is defined as in Equation  (3.2). 6. 6.

Applying $U_{B}U_{A}$. Apply both the oracles $U_{B}U_{A}$ to remove any entanglement between the solutions of both oracles from the first and the second extra qubits, and reset them to their initial state ${\left|{0}\right\rangle}^{\otimes 2}$:

[TABLE]

Ignoring the reset extra qubits, the state ${\left|{\varphi_{5}}\right\rangle}$ can be rewritten as follows:

[TABLE]

where $\sum^{\prime\prime}$ are all the possible uncommon solutions between the oracles $U_{A}$ and $U_{B}$ marked with $|0\rangle$, and $\sum^{\prime}$ are all the possible common solutions between those oracles marked with $|1\rangle$.

The main reason behind applying each oracle for the second time on its target qubit at each call of $U_{\hbar}$, is that the solutions of that specific oracle are still entangled with their target qubit. Discarding that qubit at the stage of amplifying the common solutions will drastically affect the desired outcome of the algorithm [17]. So to get rid of this entanglement, applying each oracle on its respective target qubit is necessary to remove such correlation and maintain a valid result.

3.2 The Oracle $U_{\hbar}$ for more than Two Databases

Given that $\kappa\geq 2$ oracles of $n$ input qubits and $\kappa+1$ auxiliary qubits, we illustrate the circuit of the oracle $U_{\hbar}$ in Figure  4.

The oracle $U_{\hbar}$ can be generally defined as follows:

[TABLE]

where $U_{\kappa}$ represents the function $f_{\kappa}(x)$ such that

[TABLE]

and $\bigwedge$ represents the AND logic operation.

The general system in a uniform superposition for $\kappa\geq 2$ after a single iteration, can be generally described as follows:

[TABLE]

4 The Proposed Algorithm

In this section, we will propose the algorithm to find the common solutions $M_{c}$ such that $1\leq M_{c}\leq N$, among $\kappa$ oracles, based on Younes et al. amplitude amplification algorithm. An illustration of the circuit is shown in Figure  5.

The algorithm is carried quantum mechanically as follows:

5 Analysis of the Proposed Algorithm

In this section, we will discuss the behavior of the proposed algorithm with respect to all possible scenarios for any given databases.

5.1 In Case of Known Number of Common Matches between Databases

Given that $\kappa\geq 2$ oracles, a single call to the oracle $U_{\hbar}$ will execute each given oracle $U_{j}$ exactly $2$ times. After the amplitude amplification of the desired common solutions, the total number of oracle calls $q_{t}$ for all given oracles can be expressed as the following sum:

[TABLE]

So, for any given $\kappa$ oracles with the same size, the number of oracle call to solve the common matches problem is $\mathcal{O}(\kappa\sqrt{N/M_{c}})$.

5.2 In Case of Unknown Matches $M$

An algorithm for estimating the number of matches was presented in [15], known as quantum counting. The proposed oracle $U_{\hbar}$ can be used with the quantum counting algorithm to estimate the number of matches $M$, before executing the proposed algorithm.

In [16], another algorithm was presented by Younes et al. to search for a match in a database, with unknown number of matches $M$ such that $1\leq M\leq N$. This algorithm can be combined with the proposed oracle $U_{\hbar}$ to find a common match, when the number of matches is not known in advance.

6 Comparison with Other literature

In 2012, Tulsi proposed an algorithm [10] that given two oracles that can identify the elements of two sets with the same size, the goal is to find a common element between those two sets. The success of finding that single element is further enhanced using a variation Tulsi introduced of Grover’s amplitude amplification algorithm, with some restrictive conditions.

6.1 Single Common Solution Amplification

In the case of a single common solution between $\kappa=2$ oracles, Tulsi’s algorithm is found to be optimal with restrictions, and requires $\mathcal{O}(\sqrt{N})$ oracle calls. However, the proposed algorithm requires the same oracle calls $\mathcal{O}(\sqrt{N})$ but with no restrictive conditions. In the case of single common solution when $\kappa>2$ oracles which was not covered by Tulsi [10], the proposed algorithm is found to require $\mathcal{O}(\kappa\sqrt{N})$ oracle calls.

6.2 Multiple Common Solutions Amplification

In the case of multiple common solutions between $\kappa=2$ oracles, the expected oracle calls of the proposed algorithm is $\mathcal{O}(\sqrt{N/M_{c}})$, when $M_{c}$ is $1\leq M_{c}\leq N$. Tulsi’s algorithm can be used to cover the case of multiple solutions when $\kappa=2$, but the problem becomes exponentially harder when $M_{c}>3N/4$ [12, 13]. In the case of multiple common solutions between $\kappa\geq 2$ oracles, this case is not covered by Tulsi  [10], however, the proposed algorithm requires $\mathcal{O}(\kappa\sqrt{N/M_{c}})$ oracle calls.

7 Conclusion

In this paper, we proposed an algorithm to find the common entries $M$ between $\kappa$ databases. Each database uses an oracle to access its entries. It is shown that the given oracles is used to construct another oracle that exhibits the behavior of finding only the common entries between those databases. The constructed oracle is used to mark the common entries with entanglement, then an amplitude amplification algorithm is applied to increase the success probability of finding the common entries.

It is found that when the given $\kappa$ databases are of the same size, it will require $\mathcal{O}(\kappa\sqrt{N/M_{c}})$ oracle calls. As well, It is found that the performance of the proposed algorithm is more reliable in the case of multiple matches and quadratically faster than other literature solving this problem, and handles the general case of multiple databases with similar sizes. The proposed oracle can be extended using [15] to count the number of common entries between any given oracles, or find a match as in [12, 16], when the number of common entries $M$ is unknown.