1. Introduction

2. Quantum Search Algorithm

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

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

References

1. Ivan H. Deutsch. Harnessing the power of the second quantum revolution. PRX Quantum, 1:020101, Nov 2020. [CrossRef]
2. Matteo Atzori and Roberta Sessoli. The second quantum revolution: Role and challenges of molecular chemistry. Journal of the American Chemical Society, 141(29):11339–11352, 2019. [CrossRef]
3. Barbara M Terhal. Quantum supremacy, here we come. Nature Physics, 14(6):530–531, 2018. [CrossRef]
4. Aram W Harrow and Ashley Montanaro. Quantum computational supremacy. Nature, 549(7671):203–209, 2017. [CrossRef]
5. Elizabeth Gibney. The quantum gold rush. Nature, 574(7776):22–24, 2019.
6. Guido Peterssen. Quantum technology impact: The necessary workforce for developing quantum software. In QANSWER, pages 6–22, 2020.
7. Xinbiao Wang, Yuxuan Du, Yong Luo, and Dacheng Tao. Towards understanding the power of quantum kernels in the nisq era. Quantum, 5:531, 2021. [CrossRef]
8. John Preskill. Quantum computing in the nisq era and beyond. Quantum, 2:79, 2018.
9. Yasunari Suzuki, Suguru Endo, Keisuke Fujii, and Yuuki Tokunaga. Quantum error mitigation as a universal error reduction technique: Applications from the nisq to the fault-tolerant quantum computing eras. PRX Quantum, 3:010345, Mar 2022. [CrossRef]
10. M. AbuGhanem and Hichem Eleuch. Nisq computers: A path to quantum supremacy. ArXiv, abs/2310.01431, 2023. [CrossRef]
11. J. A. Montanez-Barrera, M. V. von Spakovsky, Cesar E. Damian Ascencio, and S. Cano-Andrade. Decoherence predictions in a superconducting quantum processor using the steepest-entropy-ascent quantum thermodynamics framework. Physical Review A, 2022.
12. S. Dasgupta and T. Humble. Reliability of noisy quantum computing devices. ArXiv, abs/2307.06833, 2023.
13. https://myqlm.github.io/02_user_guide/01_write/01_digital_circuit/05_aqasm.html. Accessed: 09/04/2024.
14. https://atos.net/en/2017/press-release/general-press-releases_2017_07_04/atos-launches-highest-performing-quantum-simulator-world. Accessed: 07/04/2022.
15. https://atos.net/en/lp/myqlm. Accessed: 09/04/2024.
16. https://atos.net/en/2019/press-release_2019_05_16/atos-launches-myqlm-to-democratize-quantum-programming-for-researchers-students-and-developers-worldwide. Accessed: 07/04/2022.
17. https://atos.net/en/solutions/quantum-learning-machine. Accessed: 09/04/2024.
18. https://github.com/maheloisaf/Supplementary-Information-Grover-Paper/tree/main. Accessed: 07/04/2022.
19. Gleydson Fernandes de Jesus, Maria Heloísa Fraga da Silva, Teonas Gonçalves Dourado Netto, Lucas Queiroz Galvão, Frankle Gabriel de Oliveira Souza, and Clebson Cruz. Quantum computing: an undergraduate approach using qiskit. Revista Brasileira de Ensino de Física, 43:e20210033, 2021. [CrossRef]
20. https://www.anaconda.com/download#downloads. Accessed: 09/04/2024.
21. https://docs.jupyter.org/en/latest/. Accessed: 09/04/2024.
22. https://myqlm.github.io/01_getting_started/%3Amyqlm%3A01_install.html. Accessed: 09/04/2024.
23. https://myqlm.github.io/02_user_guide/01_write/01_digital_circuit/05_aqasm.html. Accessed: 09/04/2024.
24. Michael A Nielsen and Isaac Chuang. Quantum computation and quantum information, 2002.
25. Caroline Figgatt, Dmitri Maslov, Kevin A Landsman, Norbert M Linke, Shantanu Debnath, and Christofer Monroe. Complete 3-qubit grover search on a programmable quantum computer. Nature communications, 8(1):1–9, 2017. [CrossRef]
26. Jairo Ernesto Castillo, Yesenia Sierra, and Nelson L Cubillos. Classical simulation of grovers quantum algorithm. Revista Brasileira de Ensino de Física, 42, 2019. [CrossRef]
27. https://www.senaicimatec.com.br/. Accessed: 09/04/2024.
28. IBM Quantum Experience https://quantum-computing.ibm.com. [Accessed: 11-November-2021].
29. Barbara M Terhal. Quantum error correction for quantum memories. Reviews of Modern Physics, 87(2):307, 2015. [CrossRef]
30. Aashish A Clerk, Michel H Devoret, Steven M Girvin, Florian Marquardt, and Robert J Schoelkopf. Introduction to quantum noise, measurement, and amplification. Reviews of Modern Physics, 82(2):1155, 2010. [CrossRef]
31. Rahaf Youssef. Measuring and simulating t1 and t2 for qubits. Technical report, Fermi National Accelerator Lab.(FNAL), Batavia, IL (United States), 2020.
32. Brian Rost, Barbara Jones, Mariya Vyushkova, Aaila Ali, Charlotte Cullip, Alexander Vyushkov, and Jarek Nabrzyski. Simulation of thermal relaxation in spin chemistry systems on a quantum computer using inherent qubit decoherence. arXiv preprint arXiv:2001.00794, 2020. [CrossRef]
33. C. Lü, J.L. Cheng, M.W. Wu, and I.C. da Cunha Lima. Spin relaxation time, spin dephasing time and ensemble spin dephasing time in n-type GaAs quantum wells. Physics Letters A, 365(5-6):501–504, jun 2007. [CrossRef]
34. JL Skinner and D Hsu. Pure dephasing of a two-level system. The Journal of Physical Chemistry, 90(21):4931–4938, 1986. [CrossRef]
35. E Ferraro, M Fanciulli, and M De Michielis. Phonon-induced relaxation and decoherence times of the hybrid qubit in silicon quantum dots. Physical Review B, 100(3):035310, 2019. [CrossRef]
36. Angela Dudley, Michael Nock, Thomas Konrad, Filippus S. Roux, and Andrew Forbes. Amplitude damping of laguerre-gaussian modes. Opt. Express, 18(22):22789–22795, Oct 2010. [CrossRef]