Effect of Pure Dephasing Quantum Noise in the Quantum Search Algorithm Using Atos Quantum Assembly

1. Introduction

The advent of quantum computing is one of the bases of the so-called second quantum revolution [1,2,3,4]. The scientific community ceased to be mere observers of the laws of quantum mechanics and is now actively acting to use them in the development of practical quantum devices [1,2]. In this scenario, developing devices that work according to the laws of quantum mechanics is one of the most ambitious goals of the current century. This revolution is expected to be responsible for the major technological breakthroughs of the 21st century, and millions of dollars are already being invested in research into the development of quantum hardware by companies and universities around the world [5,6]. The advent of this technological revolution also marks the onset of the Noisy Intermediate-Scale Quantum (NISQ) era [7,8,9], characterized by the development of quantum devices with a limited number of qubits and high susceptibility to noise [8]. In this scenario, the NISQ era provides an enticing insight into the capacity of quantum computing to revolutionize fields ranging from cryptography and optimization to drug discovery and materials science [10].

Nevertheless, the realization of this potential depends on successfully overcoming challenging technological obstacles [8]. NISQ devices are inherently prone to errors arising from decoherence, gate imperfections, and environmental noise [11,12]. Moreover, the developing fault-tolerant quantum error correction codes is challenging and requires new methods to reduce the effects of noise on quantum computing [9].

In this context, our work delves into the intricacies of quantum noise and its impact on quantum algorithms. We present a study on the Effect of pure dephasing quantum noise in the quantum search algorithm, employing an implementation of the 4-qubit quantum search algorithm on the Atos Quantum Assembly Language (AQASM) [13,14]. Leveraging the my Quantum Learning Machine (myQLM) quantum software stack [15,16], we provide a practical framework for writing and executing quantum algorithms through a Python interface. Our approach enables researchers to conduct noise-free simulations using the PyLinalg linear algebra simulator via myQLM, all from the convenience of a standard home computer. Importantly, we make our programming code readily available throughout the text, facilitating reproducibility and enabling others to build upon our work.

However, the implementation of Grover’s algorithm, a cornerstone of quantum search, presents challenges due to the necessity for multi-controlled quantum gates. To address this obstacle, we utilize the NoisyQProc simulator, an invaluable resource within the Quantum Learning Machine (QLM) programming development platform [17]. While this simulator is a private version of myQLM and not publicly accessible, it allows for the emulation of real quantum processors with adjustable architectures, enabling comprehensive analysis of quantum noise effects in the quantum search problem.

Our findings underscore the efficacy of AQASM as a versatile tool for building, implementing, and simulating quantum hardware, thus bridging the gap between theory and practice in the NISQ era. By elucidating the challenges and opportunities inherent in quantum computing, we contribute to the ongoing dialogue surrounding the development of practical quantum technologies and pave the way for future advancements in the field.

2. Quantum Search Algorithm

First, let us start with an overview of the four-qubit quantum search algorithm. The search problem is a very common topic in classical computing. Considering an unstructured database with N entries, the problem consists in determining the index of the database entry (x) that satisfies some predefined search criteria $x=y$, where y is the searched element - a brief explanation of the algorithm can be found on supplementary material[18].

Assuming Grover’s algorithm for $n=4$ qubits, one can create a list of $N=16$ items, represented by each state of the computational basis of a 4 qubits system. Table 1 shows the list of 16 items for which we chose color names randomly arranged. Each item is associated with a number from 0 to 15, as listed in the second column. In the third column, we represent each decimal as its equivalent in binary code. Finally, as Grover’s algorithm performs the search on the state vectors, each binary entry is associated with a state vector in the computational basis for 4 qubits, as per the last column.

In the following, we present the four steps that characterize Grover’s algorithm: Initialization, Oracle, Amplitude Amplification, and Measurement [19], along with the integral code written using AQASM language and myQLM quantum software stack.

First of all, we recommend installing the Jupyter Notebook environment, which is available for free. In order to do this, we recommend installing the free Anaconda platform, which can be downloaded for Windows, macOS and Linux operating systems from the official website [20]. Once installed, the platform’s interface on the home page displays applications including Jupyter Notebook. By clicking on "Launch", the user is automatically directed to the Jupyter environment, where it is possible to create a Python-compatible ipynb file and perform actions explained in the Jupyter documentation [21]. Secondly, the myQLM tool must be installed and it is also available for free using the official guide provided [22]. Once the above installations have been made, one can proceed to write and run the code shown in the boxes below using AQASM, which documentation is available on the official GitHub [23].

Finally, both the Jupyter Notebook file in myQLM regarding the Boxes in Section II for the noise-free simulation and the Jupyter Notebook file in QLM regarding the Boxes in Section III for the noisy simulation are available in a GitHub repository created by the authors for easy access by readers [18].

Once the integrated development environment has been established, the first step is to import the computational tools needed to implement the quantum algorithm in AQASM. Box 1 shows the command cell that imports the computational tools required to implement Grover’s algorithm in AQASM.

Subsequently, we allocate the amount of quantum and classical bits that will compose our quantum circuit, as shown in Box 2. The same quantity is defined for both since the bits will store the results of the measurements performed on the qubits to identify their final states [19].   

2.1. Initialization

In order to initialize the qubits in a balanced superposition represented by the state $|S\rangle$, one can apply the $\mathtt{Hadamard}$ gate on all the qubits

$$|S\rangle =H^{\otimes 4}|0000\rangle .$$

(1)

In terms of coding, Box 3 shows the initialization process of Grover’s algorithm.

2.2. Oracle

In the following, we must build the Oracle that searches for the desired item. There are two main methods used in literature to build the Oracle subroutine: the Boolean and phase inversion methods [19,24,25]. In the boolean technique, the presence of an auxiliary qubit, also known as ancilla, initialized in the $|1\rangle$ state, is necessary. In this scenario, the ancilla is changed only if the input to the circuit is the sought state. However, this method is analogous to the classical search problem [24,25] and is generally applied to compare the computing power of the quantum superposition principle for quantum computing [25].

Thus, for the purposes of simplicity, we opted for the most straightforward method, the phase inversion method [24,25]. This method excludes the need for an ancilla, and the Oracle’s function in this process becomes to identify the sought element in the balanced superposition of the states of the computational base described above and to add to it a negative phase. In this context, the Oracle function can be represented by the unitary operator:

$$\begin{array}{c}\hfill O|x\rangle =\left\{\begin{array}{cc}-|x\rangle \hfill & \mathrm{se}x=y,\hfill \\ |x\rangle \hfill & \mathrm{se}x\ne y,\hfill \end{array}\right.\end{array}$$

(2)

where $|x\rangle$ is a state of the computational basis. Therefore, O can be defined as a diagonal matrix, which adds a negative phase to the state corresponding to the searched item $|y\rangle$. It is important to highlight that there is an oracle to search for each state vector on the 4-qubit computational basis. Table 2 shows the quantum circuits for all oracles in the 4-qubit Grover’s algorithm.

Here we arbitrarily choose to find the item “Blue", associated with decimal 15, which correspondent binary is 1111 and state vector $|1111\rangle$ according to Table 1. The oracle responsible for marking this item is composed solely of the multi-controlled gate $\mathtt{Z}$ ($\mathtt{MCZ}$), having qubits 0 to 3 as the controls and qubit 4 as the target, as shown in Box 4.

However, even having indicated the sought element with a negative phase, the Oracle routine is still insufficient to guarantee that the searched element in the list will be found if we measure our balanced superposition. This is due to the fact that adding the phase in the sought state does not affect the probability distribution of the global state. In this sense, the probability of finding the searched item is $1/N$ ($6.25\%$), which is equivalent to the classical Oracle in a single query in the list. Therefore, it is necessary to amplify the probability of the sought element, increasing the chance of finding it and reducing the probabilities of the other states in the process. This step is performed by the Amplitude Amplification method [24,25,26].

2.3. Amplitude Amplification

In contrast to the Oracle, the Amplitude Amplification subroutine is the same, regardless of the state representing the item sought. The amplification is done by performing a reflection represented by the unitary operation

$$A=2|S\rangle \langle S|-\mathbb{I},$$

(3)

increasing the amplitude of the searched item $|y\rangle$[25]. Box 4 shows the cell that creates the Amplitude Amplification subroutine. First, we apply the $\mathtt{Hadamard}$ gate to all qubits in the Oracle-modified state. Then gate $\mathtt{X}$ is used to flip all qubits and we apply the $\mathtt{MCZ}$ gate. Finally, the process is finished by flipping all qubits again and applying the $\mathtt{Hadamard}$ gate, as shown in Box 5, obtaining the final state and amplifying the probability of the sought item being found.   

When we reach the final state, Grover’s algorithm is completed by measuring the amplified state. The probability of finding the searched item in a single measurement after the Amplitude Amplification process in the 4-qubit algorithmic probability is $39.0625\%$, which is an improvement compared to the $6.25\%$, achieved in the classical algorithm in a single query of the Oracle, but still insufficient to assure that the search will be successful. Thus, in order to achieve the full potential of Grover’s algorithm, subroutines Oracle and Amplitude Amplification need to be repeated to maximize the probability of finding the sought state in the measurement of the quantum state [24]. The algorithmic probability of finding the searched item after r repetitions is given by

$$P={\left[\frac{2}{\sqrt{N}}\left(\frac{N-2r}{2N}+\frac{N-r}{N}\right)\right]}^2.$$

(4)

From Eq. (4), it is possible to verify that $r=\sqrt{N}$ is enough to assure that the user obtains the sought state after the measurement. Figure 1 shows a sketch of the process, with a pictorial representation of the probability amplitudes in the 4-qubits scenario.

Since it is up to the user to inform which item he or she is looking for, it is possible to make available, at the beginning of the code, an interaction instructing him to type the name of the item so that our software applies the corresponding oracle (Box 6). In this context, the conditional statement if was used for item 0, elif for items 1 to 15, and else if the user enters an item that doesn’t belong to the list.

At this point, the user would type the input “Blue" implying the application of the subroutines Oracle and Amplitude Amplification. The following output is displayed:

Which item do you want to find? Use initial capital letters. Blue

2.4. Measurement

The fourth and final step of the Algorithm is to perform measurements. Here we will store the final result of each qubit in the corresponding classical bit via the measure command, as illustrated in Box 7. Note that it is necessary to transform the program into a circuit before representing it graphically in a drawing, which is laid out in SVG format as in Figure 2.

We can visualize below the complete circuit of Grover’s algorithm for the Blue item search, assembled through the commands entered so far.

Figure 2. Grover’s circuit using myQLM (abbreviated).

Figure 2. Grover’s circuit using myQLM (abbreviated).

Therefore, using the quantum simulator PyLinalg made available by Atos and SENAI CIMATEC [27] for data processing, one can turn the search results into histogram format, as shown in Figure 3. Moreover, PyLinalg simulates the execution of quantum circuits on a local processor and returns the counts of each measurement in the final state for a given set of repetitions (or shots) of that circuit in quantity defined by the user. Increasing the number of shots optimizes the exploratory simulation process, bringing it closer to the theoretically predicted result [19]. As shown in Box 8, we performed $2^{13}$ shots.

As can be seen, the searched item was found with 95.86% probability, while the other items in the list shown in Table 1 did not reach 0.5% probability each. This significant increase in probability is related to the application of the repetitions of the oracle and amplitude amplification subroutines, as shown in Eq. (4). This is in contrast to the classical scenario since the probability of finding an item in an unstructured list with N=16 entries, running just one query to the list, is 6.25%. This result highlights the benefit of using quantum features such as superposition to process information. In addition, while classically, the Oracle needs to query the list N/2 on average, the quantum algorithm can find the marked item in $\sqrt{N}$ attempts using Grover’s amplitude amplification method for solving the search problem. In conclusion, it is shown that the combination of Oracle and Amplification subroutines for developing Grover’s algorithm results in a quadratic acceleration of the search problem, demonstrating that quantum computers have a major advantage over conventional computers.

3. Quantum Noise Interference on Grover’s Algorithm

Despite its clear advantage, Grover’s algorithm requires the application of multi-controlled quantum gates [19], which is an obstacle to implementing its 4-qubit and up versions in some quantum processors architectures presents in the popular IBM Quantum Experience [28] platform, for example. Consequently, there is a barrier to the scalability that would be required to make some algorithms useful and marketable on a large scale [8,29]. On the other hand, the number of qubits that are accessible in the system can be increased to substantially benefit the Grover algorithm. This would result in an exponential rise in the amount of storage space available in the database, which is the location where the searches are carried out. In this context, we carried out an emulation of a genuine quantum processor by making use of myQLM as a means of simulating the interconnectivity amongst the necessary qubits in an effort to overcome this challenge of compatibility.

In addition, the existence of noise that affects the qubits during the implementation of quantum operations or even during idle time is the primary obstacle that prevents present quantum computers from reaching their full potential. In this scenario, Grover’s algorithm is one of the main hostages of noise since the quantum advantage of this algorithm can be better leveraged in quantum computers with a large number of qubits, which implies a large amount of noise and requires error correction protocols.

It is essential to note that all measurements conducted on a system are impacted by noise to varying degrees. This is anticipated by quantum physics, which postulates that quantum states collapse instantaneously at the point of measurement. This disturbance is inherent to the theory and cannot be prevented by any measuring technique [30]. Therefore, in order to simulate the quantum noise interference of the quantum processor on Grover’s algorithm, we use the quantum computing simulator CIMATEC KUATOMU, an ATOS QLM simulator, located at SENAI CIMATEC’s HPC center in Brazil, to build a simulated quantum hardware topology, since the AQASM noisy section is restricted to QLM users.

3.1. Quantum Hardware Model Simulation

To simulate our quantum hardware model, we need to adjust our code to meet the technical requirement that our hardware supports a maximum arity port of 3, which means that a quantum gate can be applied to a maximum of three qubits simultaneously. For this purpose, we decomposed the CCCZ gate into a set formed by Hadamard and CCNOT gates, as illustrated below. Consequently, it is necessary to introduce an auxiliary qubit for the circuit implementation to decompose this gate.

Therefore, to implement this new circuit, we created a specific 5-qubit topology in order to support the 4-qubit Grover algorithm and the auxiliary qubit of the decomposed $\mathtt{CCCZ}$ gate. All qubits are linked for the sake of simplicity; as a result, all of them can be concurrently controlled or targeted by controlled quantum operations. Figure 4 shows a sketch of the 5-qubit topology in which the 4-qubit Grover algorithm is implemented.

Similar to how we completed the noise-free simulation in Section II, we needed to import the logic gates we would use, as seen in Box 9.   

In this scenario, the allocation of classical bits and quantum bits takes place in the exact same manner as it did in the previous simulation. The fact that we employ one of these qubits as an ancilla necessitates that we now assign 4 classical bits and 5 quantum bits in our system. (see Box 10).   

In order to build the topology connections for the quantum hardware (as shown in Figure 4), we must import the libraries Topology and HardwareSpecs. Box 11 contains the coding for the list items that represent the connections between the qubits in the idealized topology. The first member of each ordered pair is the control qubit, and the second element is the target one.

In Box 12, the initialization of the qubits occurs during the first step of Grover’s algorithm by putting them in a balanced superposition. Since qubit 2 is a supplementary qubit in this instance, it is unnecessary to start it in a superposition state.   

The second and third phases of the quantum search algorithm, implemented on the simulated quantum hardware are shown in Box 13. Initially, we apply the oracle that explicitly looks for the state $|1111\rangle$ by applying the $\mathtt{MCZ}$ gate decomposed as illustrated in Figure 5 (c). Next, we use amplitude amplification to enhance the probability that the marked object will be discovered while decreasing the probability that other items. These two procedures are repeated $\sqrt{N}$ times, in order to maximize the probability of finding the sought state, in the same way as performed in the noise-free simulation in section II.

After this, we will finish the last step of Grover’s algorithm, which consists of taking measurements in accordance with Box 14. It is worth noting that, the execution of the measurement on the auxiliary qubit is completely unnecessary.   

3.2. Quantum Noise

In the following, we introduce the quantum noise model in the simulated quantum hardware. Generally, to quantify quantum noise in quantum hardware setups, the measurement of two constants is performed: qubit relaxation time $T_1$ (i.e., longitudinal relaxation or amplitude damping) and qubit dephasing time $T_2$ (i.e., transverse relaxation) [31,32,33]. There is also a third parameter called Pure dephasing time which is often the dominant contribution to $T_2$ [34,35]. This parameter determines how long a system will be able to keep its coherence, whereas amplitude damping offers a model for the physical process of energy decay associated with the application of quantum noise [36] and it is represented by the following equation:

$$T_{\varphi }=\frac{1}{\frac{1}{T_2}-\frac{1}{2T_1}}$$

(5)

In this regard, we introduce the Pure Dephasing channel in order to perform the noisy simulations on the quantum processor emulated with the topology described in Figure 4.

In order to perform the noisy simulation, there are some properties that must be specified: the running time of the quantum gates used to build the quantum hardware topology and the operating time for the quantum gates used in building quantum hardware topology. The gate application and relaxation times are properties of each quantum computer, which can be altered once the calibrations are performed. Therefore, we selected these settings not with the objective of recreating the results of a particular system but rather with the only purpose of demonstrating the impact of these noises on the outcomes of the simulation. Consequently, it will be possible to make a comparison between the results of the noisy simulation and the results of the ideal noise-free simulation performed in the previous section.

Box 15 imports the library DefaultGatesSpecification and specifies the application timings of the gates used in Grover’s algorithm. Therefore, regarding the time needed to complete the procedures, we considered the following gate times in the code: X gate → 35.5 ns; Hadamard gate → 35.5 ns; CCNOT gate → 350 ns, Measurements → 35.5 ns.   

Furthermore, in order to apply the Pure Dephasing channel in Box 16, we need to import the library known as ParametricPureDephasing. In addition to the noise model, one can define the qubit relaxation times $T_1$ and $T_2$, respectively as shown in the second code line of Box 16. Finally, in the last code line we use the equation  5 to define $T_{\varphi }$.   

Subsequently, after importing the HardwareModel and NoisyQProc libraries, we specify the model of the quantum processor that we will use, including the gate specifications and the noise model that will be applied (see Box 17). Note that these parameters were defined by us in Boxes 15 and 16.

The last step of our code is to simulate Grover’s algorithm in the emulated quantum hardware under the Pure Dephasing noise model, as presented in Box 18. First, we need to create a $\mathtt{job}$ and link it to the quantum circuit created in Box 14 from Grover’s program developed in the previous steps, as in the first code line of the following box. The parameter $\mathtt{nbshots}$ indicates the amount of repetitions used in the circuit, as will be explained later. Finally, these instructions were applied only to qubits 0, 1, 3 and 4 because, as explained before, qubit 2 is an auxiliary one.

The simulations were conducted out using the stochastic technique, which requires that the density matrix be interpreted using a probability distribution based on pure states [24]. Using this method, the error scales with $\frac{1}{\sqrt{shots}}$. Thus, we perform the simulation with $2^{13}$ shots to get proper results.

Figure 6 shows the probability distributions of Grover’s algorithm performed in quantum hardware simulated under the Pure Dephasing noise model. Based on the results obtained from this analysis, we can gradually observe the effects of noise in the application of the algorithm by decreasing the dephasing time ($T_2$). It is worth noting that, although the most probable state is still the searched item $|1111\rangle$, the other states arose with significant probabilities even after the $\sqrt{N}$ repetitions of the Oracle and Amplitude Amplification subroutines, different from the noise-free simulation presented in Figure 3. As expected, the situation becomes worse when we gradually decrease the dephasing time. The effect of the noise is to reduce the algorithm’s accuracy, approximating the probability of the sought state to the other items of the unstructured list.

In order to obtain a landscape of the effect of the Pure Dephasing channel on the sought state, we plot the probability of the sought state as a function of the Pure Dephasing times ($T_{\varphi }$) in Figure 7. As can be seen, as $T_{\varphi }$ increases, the probability of the sought state approximates to a probability limit 95.86%, obtained for the noise-free simulation presented in Figure 3, highlighted in the dashed blue line. On the other hand, the performance of the search algorithm is negatively impacted by decreasing the dephasing time, rapidly decreasing the probability sought state. Therefore, we are convinced that these findings demonstrate that the existence of quantum noise in quantum processors reduces the efficiency of the algorithm, which can lead to inaccurate outcomes when simulating quantum circuits.

4. Conclusion

This paper presents the quantum search problem based on the famous Grover’s algorithm associated with the binary encoding of words into quantum states of the 4-qubits computational basis. We highlight the main conditions for developing projects and their implementation in dedicated hardware processors. Our findings are consistent with the theoretical predictions found in the aforementioned literature for the examples that were covered, and they demonstrate that AQASM and myQLM would be practical tools for both the implementation and analysis of quantum algorithms. Moreover, we emulate a genuine quantum processor by configuring a dedicated quantum simulator to conform to the necessary architectural specifications for performing Grover’s algorithm. Furthermore, we demonstrate that the existence of quantum noise leads to a progressive decline in the quality of the outcomes produced by a quantum noisy simulation when compared to the result performed in a noise-free setup. Finally, we propose as a potential direction for future study the scaling up of our program to a greater number of qubits, which would result in an exponential increase in our database capacity.