Recommendation systems with quantum k-NN and Grover's algorithms for data processing

TL;DR

This paper presents a quantum recommendation system utilizing quantum k-NN and Grover's algorithms, detailing its construction, complexity, correctness verification, and numerical behavior analysis.

Contribution

It introduces a novel quantum recommendation system framework combining quantum k-NN and Grover's algorithms with detailed circuit construction and correctness analysis.

Findings

Quantum algorithms can effectively implement recommendation systems.

The proposed system's complexity and success probability are analytically evaluated.

Numerical examples demonstrate the system's behavior in specific cases.

Abstract

In this article, we discuss the implementation of a quantum recommendation system that uses a quantum variant of the k-nearest neighbours algorithm and the Grover algorithm to search for a specific element in unstructured database. In addition to the presentation of the recommendation system as an algorithm, the article also shows a main steps in construction of a suitable quantum circuit for realisation of a given recommendation system. The computational complexity of individual calculation steps during recommendation system was also indicated. The verification correctness of a proposed recommendation system was also analysed, indicating an algebraic equation describing the probability of success of the recommendation. The article also shows numerical examples presenting the behaviour of the recommendation system for two selected cases.

Equations

$$|0\rangle=\left[\begin{array}[]{c}1\\ 0\\ \end{array}\right],\enspace|1\rangle=\left[\begin{array}[]{c}0\\ 1\\ \end{array}\right].$$

$$|\psi ⟩=\alpha |0⟩+\beta |1⟩$$

$$|\psi ⟩=|{\psi }_0⟩\otimes |{\psi }_1⟩\otimes |{\psi }_2⟩\otimes ...\otimes |{\psi }_{n-1}⟩,$$

$$\rho=|\psi\rangle\langle\psi|=\left[\begin{array}[]{cc}\alpha^{2}&\alpha\beta\\ \alpha\beta&\beta^{2}\end{array}\right]$$

$$\rho =\sum _i{\lambda }_i|{\psi }_i⟩⟨{\psi }_i|,$$

$$U|{\psi }_0⟩=|{\psi }_1⟩.$$

$$U{\rho }_0{U}^{†}={\rho }_1.$$

$$U=u_1\otimes I\otimes u_2$$

$$X=\left(\begin{array}[]{cc}0&1\\ 1&0\\ \end{array}\right),\;Y=\left(\begin{array}[]{cc}0&-i\\ i&0\\ \end{array}\right),\;Z=\left(\begin{array}[]{cc}1&0\\ 0&-1\\ \end{array}\right).$$

$$H=\frac{1}{\sqrt{2}}\left(\begin{array}[]{cc}1&1\\ 1&-1\\ \end{array}\right),$$

$$|\Xi ⟩=|{\xi }_0⟩\otimes |{\xi }_1⟩\otimes \cdots \otimes |{\xi }_{n-2}⟩\otimes |{\xi }_{n-1}⟩.$$

$$\begin{array}[]{c}H|\Xi\rangle=H(|\xi_{0}\rangle\otimes|\xi_{1}\rangle\otimes\dots\otimes|\xi_{n-2}\rangle\otimes|\xi_{n-1}\rangle)=\\ \\ =H|\xi_{0}\rangle\otimes H|\xi_{1}\rangle\otimes\dots\otimes H|\xi_{n-2}\rangle\otimes H|\xi_{n-1}\rangle=\\ \\ =\bigotimes_{i=0}^{n-1}H|\xi_{i}\rangle=\frac{1}{\sqrt{2^{n}}}\left[\bigotimes_{i=0}^{n-1}\big{(}|0\rangle+(-1)^{\xi_{i}}|1\rangle\big{)}\right].\\ \end{array}$$

$$U=|000⟩⟨000|I+|010⟩⟨010|X+|111⟩⟨111|I$$

$$M=\sum _i{\lambda }_i{P}_i,$$

$$P({\lambda }_i)=⟨\psi |P_i|\psi ⟩.$$

$$|{\psi }^{{}^{\prime }}⟩=\frac{P_i|\psi ⟩}{\sqrt{{\lambda }_i}},$$

$$|\Psi ⟩=|{\psi }_q⟩\otimes |{\psi }_{f_f}⟩\otimes |{\psi }_{f_u}⟩|{\psi }_k⟩,$$

$$O_1(l,N)=2l+N(N-1)/2.$$

$$O_2(l)=3l+2.$$

$$O_3(l)=7l+2c+3.$$

$$|{\psi }_0⟩=|0{⟩}^{\otimes 2l+1}.$$

$$|{\Psi }_1⟩=\frac{1}{\sqrt{L}}\sum _{p=1}^L|r_1^p,\dots ,r_l^p⟩,$$

$$|{\Psi }_2⟩=\frac{1}{\sqrt{L}}\left(\sum _{p=1}^L|r_1^p,\dots ,r_l^p⟩\right)\otimes |t_1,\dots ,t_l⟩\otimes \frac{1}{\sqrt{2}}(|0⟩+|1⟩).$$

$$U=e^{-\mathbf{i}\frac{\pi}{2l}\hat{H}},\;\;\;\hat{H}=\left[\begin{array}[]{cc}1&0\\ 0&0\\ \end{array}\right]^{\otimes l}\\ \otimes I_{{l}\times{l}}\otimes\left[\begin{array}[]{cc}1&0\\ 0&-1\\ \end{array}\right].$$

$$P_{1}=\left[\begin{array}[]{cc}e^{-\mathbf{i}\frac{\pi}{2l}}&0\\ 0&1\\ \end{array}\right],$$

$$P_2=|0⟩⟨0|+|1⟩⟨1|\otimes {P_1}^{-2}.$$

$$\begin{gathered} |{\psi }_4⟩=\frac{1}{\sqrt{L}}\sum _{p=1}^L(e^{\mathbf{i}\frac{\pi }{2l}d(t,r^p)}|d_1^p,\dots ,d_l^p⟩ \\ \otimes |t_1,\dots ,t_l⟩\otimes |0⟩+e^{-\mathbf{i}\frac{\pi }{2l}d(t,r^p)}|d_1^p,\dots ,d_l{1}^p⟩ \\ \otimes |t_1,\dots ,t_l⟩\otimes |1⟩). \end{gathered}$$

$$\begin{gathered} |{\psi }_5⟩=\frac{1}{\sqrt{L}}\sum _{p=1}^L(\cos \left(\frac{\pi }{2l}d(t,r^p)\right)|d_1^p,\dots ,d_l^p⟩ \\ \otimes |t_1,\dots ,t_l⟩\otimes |0⟩+\sin \left(\frac{\pi }{2l}d(t,r^p)\right)|d_1^p,\dots ,d_l^p⟩ \\ \otimes |t_1,\dots ,t_l⟩\otimes |1⟩). \end{gathered}$$

$$P(c_0)=\frac{1}{L}\sum _p{\cos }^2\left(\frac{\pi }{2l}d(t,r^p)\right).$$

$$|{\psi }_6⟩=\frac{1}{\sqrt{L}}\sum _{p=1}^L{m}_p|{\psi }_{rcmd}⟩,$$

Full text

1 Introduction

The development of quantum computational methods [16] allows for its use in areas such as machine learning [28], decisions models [9] or big-data [17]. The classical methods of analysing a data sets of big-data are widely used, but the use of quantum computers that allow the processing of exponential amounts of data seems to be extremely important in this area [24], [26]. In addition, due to the features of quantum information, the lack of the possibility of cloning information and direct comparison of two quantum registers, the construction of such a system requires a slightly different approach. In this article we show that the recommendation process can be based on the method of k-nearest neighbours classification [14]. Such approach allows to create a system where the effectiveness of the recommendation can be very high.

In the article, we discuss the construction of a recommendation system based on two quantum computing algorithms. The first is the quantum algorithm of k-nearest neighbours (termed as qk-NN) [18], [20], [28], based on the method presented in the work [25]. In this algorithm, we use the Hamming distance to classify the elements to be recommended [29]. Grover‘s algorithm [13], [11] is used to improve the quality of recommendations. The use of both methods allows for the construction of a recommendation algorithm, which in the recommendation process is characterized by the better computational complexity than classical approaches [4], [5]. However, it should be emphasized that the described solution, like other quantum algorithms [22], is probabilistic, however the probability of indicating recommended elements is very high.

It should be noted that this article is an extension of a publication [19]. This article presents more precisely the structure of the quantum register and two numerical examples showing the behaviour of the recommending system. The computational complexity of individual steps implemented in the recommendation process was also indicated.

The organization of the article is as follows: in the part of 2 selected issues of quantum computing, such as quantum register and superposition are presented. The mentioned concepts characteristic of quantum computing are directly applied in the discussed recommendation system. In the part 3 we discuss the construction of the recommendation system, present the algorithm of conduct and discuss the construction of the quantum circuit, which implements the discussed solution. The correctness of the recommendation system operation, i.e. the description of the probability of indicating the correct element is presented in the section 3.4. Numerical experiments were also implemented, which are discussed in the section 4. The experiment shows the behaviour of the system in two cases when one and two elements are recommended. The summary of the article is given in the section 5, where the final conclusions and some comments about possible further work on the method described in this article were given. The article ends with thanks and a list of the cited bibliography.

2 Brief introduction to the Quantum Information Basics

The concept of a classic bit, which is the basic unit of information, can be extended to qubit for quantum systems [27], [23]. For this purpose, we consider a two-dimensional Hilbert space $\mathcal{H}_{2}$ and indicate orthonormal basis:

[TABLE]

In last equation a Dirac‘s notation has been used. The vector $|0\rangle$ usually means a zero. The natural thing is that $|1\rangle$ represents an one. The given Eq. 1 base is also called a standard computation base.

In quantum information, notion of qubit is the equivalent of the classical bit. The qubit state is represented by a vector in the two-dimensional Hilbert space $\mathcal{H}$:

[TABLE]

This vector is normalized, therefore $|\alpha|^{2}+|\beta|^{2}=1$ occurs, wherein $\alpha,\beta\in\mathcal{C}$ (where $\mathcal{C}$ represents a set of complex numbers). The presented state $|\psi\rangle$ is called a vector state or a pure state.

Following the classic computer science, concatenation of multiple classical bits creates a register. The $|\psi\rangle$ register with $n$ – qubits is built by using a tensor product:

[TABLE]

where $\otimes$ is a tensor product operation.

Remark 1**.**

Quantum entanglement It should be added that there are cases where the register can not be written in the form of a tensor product. This state of the register is called a entangled state. $\square$

It should also be noted that in addition to the description in the form of pure states, so-called unknown density matrices - the pure state of qubit $|\psi\rangle$ taking the following form are also used:

[TABLE]

where the $\langle\psi|$ vector represents a transposed $|\psi\rangle$ vector.

In general, the representation for a mixed state for which only pure states are included: $|\psi_{i}\rangle$ takes the following form:

[TABLE]

where $\lambda_{i}$ determines the probability of a state $|\psi_{i}\rangle$ and $\sum_{i}\lambda_{i}=1$.

Remark 2**.**

Exponential capacity of a quantum register One of the main differences between the classic and quantum registers is the exponential capacity of the quantum register. The amount of classical information contained in the quantum register described by the state vector can be described by $2^{n}$, where $n$ is the number of qubits. What causes that classical simulation of the quantum register is unfortunately not possible effectively using a classical computations methods. There are, of course, special cases such as the so-called CHP circuits [3] states, but in general the quantum register requires an exponential computational resources to simulate the operation of the quantum register using a classical machine. This situation is much worse when we using a density matrix, as their size is described as $d^{n}\times d^{n}$.

The state vector for 16 qubits needs 512kb of memory, and the 256MB for density matrix, assuming that we use double precision floating point numbers describing individual amplitudes of probability. However, doubling the number of qubits to 32 due to the exponential capacity of the quantum register already requires 32GB of available memory, and 1 ZB (zetta bytes) for the density matrix. $\square$

A several additional operations can be performed on the quantum register. As part of this brief introduction, we will only quote the two most important examples of operations, i.e. unitary operation and measurement operation.

The realization of unitary operation of $U$ for the quantum state represented by the vector is represented by the equation:

[TABLE]

For a density matrix, the unitary operation $U$ is described by the following relationship:

[TABLE]

A very important thing is the method of creating a unitary operation for the quantum register. In the case of state modifications for the first and third qubit, the unitary unit construction takes the following form:

[TABLE]

The unitary operation is a reversible operation (called also as uncompute operation), i.e. for the operation $U$ you can always enter the operation $U^{\dagger}$, where the symbol $\dagger$ represents the Hermitian adjoint operation. If $U=U^{\dagger}$ then $U$ is called as a self-adjoint operation.

The basic set of unit operations includes a so-called Pauli‘s gates (operators): $X$, $Y$, $Z$. Their matrix representation is as follows:

[TABLE]

The Hadamard gate marked as $H$ is also very important:

[TABLE]

because it is used to introduce the so-called superposition for quantum states. For example, let $|\Xi\rangle$ be $n$ - qubit state:

[TABLE]

Using the $|\Xi\rangle$ register, you can easily show how the use of a single Hadamard gate works:

[TABLE]

The use of the Hadamard gateway results in the amplitude values being equal to the absolute value $\frac{1}{\sqrt{2^{n}}}$ for all states taken by the specified quantum register.

Should be also pay attention to the construction of controlled gates, which construction requires in addition to the tensor product the use of direct sum of matrices and also uses the projection matrix.

The one of example may be one of the possible implementations of the CNOT gate (controlled negation gate) for qubits:

[TABLE]

This gate performs a qubit negation operation, in case if the so-called control qubit takes the state one.

The second type of basic operation is the so-called measurement operation. We will present only one example of this type of operation: a von Neumann type measurement. It begins with the preparation of observables. Operator, the form of which is presented in the following way:

[TABLE]

where $P_{i}$ is a projector for the operator‘s eigenspace $M$ with the eigenvalue $\lambda_{i}$.

The results of the measurement performed represent the eigenvalues $\lambda_{i}$. Wherein the individual results occur with following probability:

[TABLE]

The obtained result $\lambda_{i}$ indicates that the $|\psi\rangle$ register has been transformed to:

[TABLE]

with the probability determined by the Eq. 15.

3 Quantum recommendation system

This part presents the construction of a quantum recommendation system. An example of a database is indicated, from which the elements indicated by users will be recommended. The quantum register was also described in 3.1. The point 3.2 describes the necessary calculation steps for the implementation of the quantum recommendation algorithm. The construction of a quantum circuit is also indicated in part 3.3. Analysis of the correctness of the proposed algorithm is given in the point 3.4. An analytical description of the probability of success of indicating the recommended element (or many elements) has been presented.

3.1 Database and quantum register structure

The proposal for building a quantum recommendation system (QRS - quantum recommendation system) presented in this article is a hybrid system. The database from which items are recommended based on the user‘s suggestions and needs is naturally stored in the classical system. As an example of a classical database on the basis of which a quantum recommendation system can be built, the IMDB movie database [2]. Fig. 1 shows several selected records from the database with a field describing the feature of the particular movie.

It should be emphasized that there is no need store the entire database into the quantum system. Usually only two columns of data are relevant: identifier of recommended elements and element‘s feature saved as a binary word. The length of words that are used to describe the identifier and characteristics are important. It is assumed that these will be binary numbers, the identifier will be described with $q$ bits, while the feature with $l$ bits. Usually the entire of the classic database can be divided into sections referring to elements with common features. Based on this, you can create a quantum register that contains a information about the database. Representation of this register and its possible division is shown in Fig. 2. If we use the entire database in this case we have only one register, or divide the whole register into sub-registers with common features, e.g. all historical films would be collected in one register.

In view of the remarks about the form of the database and the structure of the quantum register, we distinguish four main parts:

[TABLE]

however the order of quantum sub-register is not important, the order can be changed e.g. in the case of features: $|\Psi\rangle=|\psi_{q}\rangle\otimes|\psi_{f_{u}}\rangle|\psi_{f_{f}}\rangle\otimes|\psi_{k}\rangle$.

The first $q$ qubits of the registry $|\Psi\rangle$ i.e. $|\psi_{q}\rangle$ is used to encode the identifier of the recommended element. The next part of the $|\psi_{f_{f}}\rangle$ register describes the features of individual database elements. They refer naturally to the identifier of the individuals items. The $l$ qubits are used to describe the feature, because thanks to the superposition properties, we will create $2^{l}$ various features in the database containing $2^{q}$ of classical elements. The third part of $|\psi_{f_{u}}\rangle$ is a description of the feature desired by the user. Once again, $l$ qubits are used, although we describe only one feature desired by the user. Again by the superposition principle, applying only $l$ operations (the feature is described by a binary number with a width of $l$ bits) we connect information about user features with the rest of database. The last part denoted by $|\psi_{k}\rangle$ register represents an additional qubits. The more precise amount was specified a later at point 3.3. The point 3.4 presents an analytical analysis a probability success of the recommendation is described by $P_{max}$ quantity.

Remark 3**.**

Quantity of recommendations In the description of the registry structure, we have provided only one feature for the user $|\psi_{f_{u}}\rangle$, of course, you can add additional user features, e.g. $|\psi_{f_{u_{1}}}\rangle,|\psi_{f_{u_{2}}}\rangle,\ldots,|\psi_{f_{u_{K}}}\rangle$, to compute a $K$ recommendation. However, in the remainder of this article, for simplicity, we limit our analysis to a single feature. $\square$

3.2 The main algorithm QRS

The scheme of proceeding in the proposed approach to the recommendation system is based on two main stages. The first one points the database elements whose features are closest to those indicated by the user. For this purpose, the quantum version of the k-nearest neighbors algorithm is used. Then, to amplify the effectiveness of the recommendation, the Grover‘s algorithm is used. The individual computational steps are presented as the Algorithm 1.

The algorithm 1 can also be represented as a control flow in the proposed approach to the recommendation system. The corresponding diagram is shown in Fig. 3. Because the algorithm is based on measurement operations, an additional qubit called $c_{0}$ has been introduced in the quantum register. Performing the measurement operation on the qubit $c_{0}$, allows you to determine whether you have successfully converted the registry to the correct probability distribution. The measurement result $c_{0}$ assuming the state $|0\rangle$ means that the quantum register has been transformed into a proper state, and it is probability distribution for the next measurement will indicate a recommended element.

3.3 Quantum circuit for QRS and computational complexity

Fig. 4 part (A) shows the general structure of the quantum circuit implementing the quantum recommendation system. Three exemplary circuits implementing the most important stages of the recommendation system were also given there. The examples are based on a 16-element database shown in table (B) on Fig. 4.

Diagram (C) in the Fig. 4 shows the database initialization process, which consists of three stages. The first stage creates database identifiers, for this purpose it applies exactly $l$ Hadamard gates. The next stage is the encoding of features, unfortunately it requires a larger amount of operation which depends on the number of elements in the database. In general, after creating identifiers in the $|\psi_{q}\rangle$ register, the permutation of elements must be performed in the register $|\psi_{f_{f}}\rangle$. Permutation will generally requires no more than $N(N-1)/2$ single qubit and controlled gates [15], with $N=2^{q}$. Unfortunately, the process of creating a database will not be significantly better than the creation of a classic database, although the structure of feature codes may be helpful in the process of creating a database. It can also be seen in the presented example, where six operators of controlled negation are enough (the given relation defines the upper limit, therefore for 16 elements, the maximum number of gates is 120) to generate 16 database entries. The third stage, due to superposition principle will require only $l$ negation gates to build the user‘s feature. Computational complexity in the $O$ notation of this stage can be written as:

[TABLE]

However, as shown in the correctness analysis 3.4, you do not need to repeat the process of building the entire database. Circuit (D) presents the process of calculating the Hamming distance and the so-called sum of distances to make a classification. The recommendation process is completed after the measurement has been made auxiliary qubits $c_{0}$, if the result measurement is $|0\rangle$, further details are presented in sec. 3.4. The number of operations to be performed when calculating the Hamming distance (D) is linear and depends on the width of the feature, i.e. the number of classic bits $l$ describing the feature:

[TABLE]

Remark 4**.**

Complexity of q-kNN part Particular attention should be paid to the fact that the computational complexity of this step depends only on the width of the pattern. Unlike to the classic methods, where the number of rows should be taken into account for the process to analysis of computational complexity. $\square$

The construction of the amplifying amplitude circuit for one or several amplitudes with the Grover algorithm depends on the form of the feature described by the user. Plot (E) in Fig. 4 shows the amplification of one amplitude for exemplary database shown in table (B) in Fig. 4. The number and arrangement of the negation gates in the oracle section is an exact mapping of the feature specified by the user. Definition of oracle can be simplified by using only negation on the bits that are encoded, which encode the main feature, e.g. a historical movie, can be encoded with the oldest or youngest bit. However, it can be assumed that the feature requires the use of the largest number of gates, their number can be defined as:

[TABLE]

where $l$ is the width of the feature, and $c$ means the number of gates after decomposing the negation gate in stage of the oracle of the Grover algorithm and in the controlled gate $Z$ in the part performing the rotation around the average. Decomposition of controlled gates can be done according to the works [6] and [21], however, and because we have $l$ wide feature then finally we can obtain polynomial complexity (in addition we still operate on $2^{q}$-th classical data).

All computational complexity is naturally dominated by the database creation process, but the calculation process of the recommendation depends only on the width of the feature, and not on the amount of data in the database.

3.4 Correctness of quantum recommendation system

Algebraic correctness of quantum recommendation system will be started by defining the initial state of a quantum register during the first stage, i.e. preparation of the database (see ). For easy further analysis, qubits describing the record identifier will be omitted:

[TABLE]

The first $l$ qubits represents the database file, the second $l$ qubits, the user feature vector. Initializing the sub-register with the feature database results in obtaining the following status:

[TABLE]

where $L=2^{l}$, and $r_{p}^{k}$ is a bit description of the features a selected row in the database. It is obvious that, for transparency the part $|\psi_{q}\rangle$ was omitted from Fig.2.

After entering the form of the user‘s feature vector, the state of the quantum register is given the form:

[TABLE]

From that moment, we can calculate the distance between Hamming between the user‘s characteristics and the features stored in the database table. Responsible for distance calculation in quantum circuit (D) on Fig. 4 is first set of controlled gates NOT which is described by unitary operations $U$:

[TABLE]

The operation $U$ can be decomposed on the set of single qubit gates $P_{1}$:

[TABLE]

and controlled gate:

[TABLE]

Additional discussion about decomposition of $U$ can be found at work [25].

The use of the $U$ operation described by equation Eq.(24) causes that we get the following state:

[TABLE]

The perform of Hadamard operation on the additional qubit $c_{0}$ allows to obtain the final state for the stage related to the quantum k-NN algorithm:

[TABLE]

The probability of measuring zero on the state $c_{0}$, i.e. success, that we will go to the desired probability distribution with the correct indication of the recommended element:

[TABLE]

If you have measured the state $|1\rangle$ on qubits $c_{0}$, then you should restore the state $|\psi_{4}\rangle$. You can do this by performing an inverse operation to $U$ given by Eq. 24 i.e. $U^{\dagger}$. This operation will require the same amount of work as the $U$ operation and once again use the negated control operators, which are self-adjoint, which will restore the state of the registry to the state before Hamming distance calculation and summing. In this way, we avoid the costly process of rebuilding the database.

If, by simplifying, by $P$ we denote the probability of receiving a particular recommendation, then obtaining a probability distribution with accuracy of $\varepsilon$ requires in generally $O(P\cdot(1-P)\cdot\frac{1}{\varepsilon^{2}})$ repetitions of the implementation a quantum algorithm of the k-nearest neighbors. It should be emphasized, however, that using classical multiprocessor solutions, you can use many quantum machines to solve the same task, for example to obtain a linear time calculation of the probability distribution for the exponential amount of data $L$, described by Eq. (22).

Remark 5**.**

Improving the distribution of the probability of success The distribution of the probability obtained is not satisfactory if the user‘s designated feature determines the choice of one compatible item or a few from a very close neighborhood. Therefore, using the Grover algorithm significantly improves the final probability distribution of the received recommendation [8]. $\square$

Therefore, assuming that zero was obtained by measuring the state of $c_{0}$, we get the state of:

[TABLE]

wherein $|\psi_{rcmd}\rangle=|d_{1}^{p},\dots,d_{l}^{p}\rangle\otimes|t_{1},\dots,t_{l}\rangle\otimes|0\rangle$, whereas $m_{p}$ is represented by the probability amplitudes obtained after the measurement. In the existing registry, you can emphasize $g$ amplitudes for recommended elements with the highest compatibility value a feature of the $m^{r}_{p}$ and also $L-g$ with lower compatibility $m^{nr}_{p}$:

[TABLE]

Average for amplitudes and variance for probability amplitudes for state $|\psi_{7}\rangle$, takes the following form based on the article [7]:

[TABLE]

where $t$ is the iteration number commonly referred to as the execution time of the Grover algorithm, for $t=0$, of course, the initial values of the distribution of probability amplitudes are known [7]. The highest probability of measuring the existing recommended elements from the database is described as follows:

[TABLE]

with $O(\sqrt{\frac{L}{g\textbf{}}})$ iteration.

4 Numerical experiments

The given algebraic relations describing the states of the quantum register after particular stages of the implementation of Algorithm 1 allow us to give numerical examples presenting the behaviour of the recommending system. Fig. 5 presents probability distributions showing the state of the registry for a database of sixteen elements. There have been cases where one $f_{15}$ amplified in the database or two $f_{6}$ and $f_{13}$ elements that match the user‘s expectations.

Regardless of the case, the plots (A) and (D) on Fig. 5, shows the probability distribution for the database after the execution of the k-NN part. In both cases (Fig. 5 graphs (A) and (S)) we have no explicit indication of the element nearest to the user feature. Although, for the eligible feature, for example $f_{10}$, we have the highest probability of measuring this state. However, due to the fact that the difference in Hamming distance for the other features was not significantly large, the other elements also have a high probability of measurement. If we stop the process of recommendation at this stage, we should repeat the implementation of steps (I), (II), (III), (IV) from Alg. 1 and the measurement operation to collect the results which the probability described by Eq. 29.

It should also be emphasized that in charts (B), (C) we describe the case of a recommendation of only one element. However, the quality of the amplification will be good for two or more elements that will be indicated by a user-specified characteristic. What is presented in graphs (E), (F) of Fig.5. It should be emphasized that the sum of probabilities of recommended elements is determined by Eq. 33.

Remark 6**.**

The use of Grover‘s algorithm At this moment, you can ask whether instead of using k-NN you can use only the Grover algorithm itself to amplified the recommended element or more elements. The answer is affirmative only if there is an element or elements with this same vector of features as the user‘s requirements. If, however, there is no such element, then the Grover algorithm will not be able to amplify elements similar to those defined by the user. It should be added that you do not have to specify that we are interested in amplify only one element that fully complies with the user-defined characteristic. You can specify that we amplify the k-NN result for a leading user-specified characteristic (e.g. historical films, and the idea of such a gain is shown as cases (F), (G), (H) from Fig. 5). Therefore, the combination of two quantum k-NN algorithms and amplitude amplification using the Grover algorithm allows to building a recommendation system. $\square$

According to the note 6 it is reasonable to use the Grover algorithm to amplify the probability for the element (elements) indicated by k-NN. For values for $t>1$ we already have a very high probability (close to the maximum theoretical value) to measure the recommended element. However, even for smaller values of $t$ it amplify the desired effect, while maintaining the probability distribution obtained after the quantum part k-NN. It also means shortening the circuit‘s operating time, because you do not have to do an additional iterations during the amplify with the help of the Grover algorithm.

5 Conclusions

The article presents the structure of the recommendation system based on the quantum k-NN algorithm and the Grover algorithm. The discussed approach is characterized by better computational complexity in the recommendation process. However, the construction of the database can be done only once, at the beginning of the mentioned stage. The process of its construction depends only on the amount of data. The probability value of the recommendation‘s success was also indicated. Showing that it depends directly on Hamming distance and amplitude amplification using the Grover algorithm.

One of the next tasks may be a different approach to verifying the correctness operation of the system using the quantum predicate system [10], [12]. An attempt to implement the presented system is also planned to check the quality of recommendations on existing systems of experimental installations of quantum computing systems [1]. They offer access to a quantum register of 20 qubits. This is not a sufficient number to build a larger system. However, technological advances seem to soon allow for the construction of a system containing over 50 qubits, and this size is already available in the system [1].

The exemplary full database includes over 12,000 records. However, in the case of quantum calculations, the quantum register stores an exponential amount of data. Therefore, in the case of the OMDB movie database, indexes of individual films, we only need 15 qubits: $2^{15}>12,000$. Therefore, if nearby quantum processing systems offer access to 50 qubits, this number will allow full implementation of the proposed solution. $\square$

Acknowledgment

We would like to thank for useful discussions with the Q-INFO group at the Institute of Control and Computation Engineering (ISSI) of the University of Zielona Góra, Poland. We would like also to thank to anonymous referees for useful comments on the preliminary version of this chapter. The numerical results were done using the hardware and software available at the ‘‘GPU $\mu$-Lab‘‘ located at the Institute of Control and Computation Engineering of the University of Zielona Góra, Poland.