Let’s say f : { 0 , 1 , 2 , ⋯ , N − 1 } → { 0 , 1 } is a function. In the case of an unstructured database, the domain of the function represents the indices of the database. f ( x ) can be 0 or 1. f ( x ) = 1 indicates that x points to one index of the database that contains the element that satisfies the search criteria. In all other cases, f ( x ) = 0 . Our purpose is to find the index x for which f ( x ) = 1 .

Let’s say N is the size of the search space. Let’s also assume that n = ⌈ log 2 N ⌉ . Therefore, the binary representation of an index needs a maximum n qubits.

For our proposed algorithm, we can use the quantum circuit as shown in Figure 1. The first n qubits contain all zeros. And the ancillary qubit contains a 1. A Hadamard gate is applied to the first n qubits. A Hadamard gate is also applied to the ancillary qubit. We get the following state as a result:

Figure 1. Quantum circuit for the proposed quantum algorithm.

In our proposed algorithm, we use an oracle U f . If | x 〉 is given as input and | y 〉 is the ancillary qubit, then we get the following state on querying the oracle:

⊕ is the addition modulo 2 operator. In our case, the ancillary qubit is 1, and one Hadamard gate is applied to it. Therefore, on querying the oracle U f , we get the following state [3]:

For example, if N = 4 , n = log 2 N = 2 . In that case, the state | ψ 1 〉 is going to be the following:

After querying the oracle, we will get the following state:

Let’s consider f ( x ) = 1 when x = 0 . And in all other cases, f ( x ) = 0 . Therefore, the state | ψ 2 〉 is going to be the following in this case:

Therefore, the first n qubits after querying the oracle are the following:

We can now apply a quantum gate G on this state, so that the output of this gate G is | 00 〉 . Please note that in our example, f ( x ) = 1 when x = 00 . For any other value of x , f ( x ) = 0 .

If we measure | ψ 3 〉 , we will get the index in the unsorted database that points to the entry that satisfies the search criteria.

Let’s say M is a unitary matrix that implements the quantum gate G. In this section, we will attempt to determine the unitary matrix M.

Let’s say N is the size of the search space. The indices in the unstructured database are 0 , 1 , ⋯ , N − 1 . It will take n = ⌈ log 2 N ⌉ qubits to represent these N indices.

Let the indices in the unstructured database be x 0 , x 1 , ⋯ , x N − 1 . And let the corresponding values of f ( x ) be y 0 , y 1 , ⋯ , y N − 1 .

For example, in our example, the binary indices in the unstructured database are 00 , 01 , 10 , 11 . The corresponding values of f ( x ) are the following:

This indicates the value pointed to by the binary index 00 satisfies the search criteria, and all other values do not. As a result, the first n qubits after querying the oracle are the following:

We want the output of the quantum gate G to be | 00 〉 .

Let’s say the column vector X represents the first n qubits after querying the oracle.

In our example, X represents the following state:

Therefore, in our example,

Let the column vector Y represent the expected output.

For example, in our example, the expected output is | 00 〉 . Therefore, Y is the following column vector.

In other words, the unitary matrix M is applied to X, and we get the output Y.

Therefore, if we assume g : { − 1 , 0 , 1 } → { 0 , 1 } to be a function that takes each element of X as input and gives the corresponding element of Y as output, then the following holds true:

Therefore,

Therefore, g is a function for which g ( g ( x ) ) = x . Therefore, g is an involution function. And the corresponding matrix M is an involutory matrix.

Property 1: M is a unitary matrix.

As M implements a quantum gate, M must be a unitary matrix [4]. For a unitary matrix U, the following holds true:

In our case, M is a real matrix. Therefore,

Property 2: M is an involutory matrix.

As M is an involutory matrix, we can write the following:

Therefore,

Property 3: M is an orthogonal matrix.

As M is a unitary matrix and an involutory matrix, we can write the following:

Therefore,

Therefore, M is an orthogonal matrix.

Property 4: M is a symmetric matrix.

As M is an orthogonal matrix, we can write the following:

As M is an involutory matrix, we can write the following:

Therefore,

Therefore, M is a symmetric matrix.

Based on the above properties, we will look for the value of the matrix M that is as close to X − 1 as possible. As the value of M is not equal to X − 1 for all values of N, the value of M is going to introduce an error term. We will discuss the error term in Section 6.

Ideally, we are looking for a matrix M for which the following condition holds true:

Therefore, M should be equal to X − 1 . However, X − 1 may not be a unitary matrix for all values of N. Therefore, we will try to find a unitary matrix M such that M X is as close to I as possible.

Let’s say,

This E X is the error term.

Therefore, we will look for an N × N matrix M for which the following conditions hold true:

1) M M T = M T M = I .

2) M M − 1 = M − 1 M = I .

3) M T = M − 1 .

4) det ( M ) = ± 1 as M is involutory.

5) M 2 = I .

6) The error term EX is minimum.

We observe the following:

Using the Sherman-Morrison formula [5], we get the following:

Let’s say M is the following matrix:

Using the Sherman-Morrison formula, we get the following:

As M is a symmetric, unitary, and involutory matrix, we get the following:

By comparing both sides, we get the following:

Here, I is the identity matrix, and J is a matrix with all entries equal to 1. Therefore, the diagonal entries of the matrix M are ( 1 − 2 N ) and the non-diagonal entries of M are − 2 N . Given the value of N, these values can be computed in O(1) time. The value of M does not depend on a specific input.

As we discussed, the error term is E X . We observe the following:

Let’s say N is the search space. n is the required number of qubits.

If we calculate the values of M , X , X − 1 , E , and E X for different values of n , and take the determinant of the error matrix E X , we get the following Table 1:

Table 1. Determinant of the error term.

Please note that the output matrix Y is the following:

In other words, the diagonal entries of the output matrix Y will be the following:

And, the non-diagonal entries will be the following:

Therefore, once we find the required matrix M, the first n qubits of the following state are applied to the corresponding quantum gate:

As output, we will obtain the index from which we can retrieve the positions of the elements in the subset that satisfy the search criteria, along with the error as stated above.

Until now, the time complexity of a quantum search algorithm is Ω ( N ) whereN is the size of the search space. This paper proposes a quantum algorithm that reduces this time complexity. The proposed quantum algorithm requires n qubits as input, where n = ⌈ log 2 N ⌉ , and one ancillary qubit. After measuring the n-qubit output of the quantum gate G implemented using the unitary matrixM, we get the index in the unsorted database that satisfies the search criteria with a significantly high probability.

Though the unitary matrix M corresponding to the quantum gate G is an N × N matrix, there are only two different values for elements of M. All the diagonal elements of M have the same value. All non-diagonal elements of M have the same value. Therefore, the matrixM can be constructed in O ( 1 ) time.