1. Introduction

2. Fundamental Concepts of Quantum Computing

3. Leading Open-Source Simulators for Quantum Computing

4. Implementing a Simulator

• Dynamic memory management. The primary purpose is to test the strategy of removing less probable states.
• Full State: The objective is to accelerate the simulations, avoiding the overhead introduced by the search of the states.
• Full State with OpenMP: The intention is to accelerate the simulations of the previous version.
• Full State with data compression: The purpose is to test a lossy compression library like ZFP.
• Full State with MPI: The main objective of this scenario is to distribute the amplitude vector among different computing nodes, allowing for a greater number of qubits.
• Full State with MPI and data compression: Here, data compression was incorporated into the previous scenario.

4.2. Single Processor Case

4.2.1. State Vector

The state vector is a linear combination of states represented by the following expression.

$$|\psi \rangle ={\alpha }_0|0...00\rangle +{\alpha }_1|0...01\rangle +...+{\alpha }_{2^n-1}|1...11\rangle$$

(3)

Where ${\alpha }_i$ are the amplitudes. As we said previously, these amplitudes are complex numbers, so we need two float or two double numbers to represent them in the code. Of course, the state vector must fit in the local memory.

The amplitudes of the states are implemented using a single-dimension double-precision array stored in a continuous memory space. To increase performance, a single array was used to store both the real and the imaginary parts of each amplitude; that is, the state vector was linearized. The real parts are placed in the odd positions of this arrangement, and the imaginary parts are placed in the even positions. This strategy avoids jumping between two arrays, one for the real part and one for the imaginary part. Figure 5 depicts this data structure.

4.2.2. Quantum Gates

Like other simulators such as Intel-QS, this prototype only implements single-qubit gates and controlled two-qubit gates. The minimum list of quantum gates developed to implement the Quantum Fourier Transform algorithm are: Identity, Hadamard, ControlledPhaseShift, ControlledNot, Swap. All these quantum gates are implemented as two-dimensional double-precision arrays. This reduced set of quantum gates limits the simulation of algorithms that require additional gates. However, adding new single-qubit and controlled two-qubit gates is very easy. Just insert the corresponding matrix into the quantumGate.cpp source file.

4.2.3. Applying a Quantum Gate to a Quantum Register

To apply a quantum gate $G_k$ to the $k-th$ qubit of a state vector $|$ we have the following result.

$$G_k|1\rangle =|{\psi }^{\prime }\rangle =\left(\begin{array}{c}{\alpha }_{0...00}^{\prime }\\ {\alpha }_{0...01}^{\prime }\\ ⋮\\ {\alpha }_{1...10}^{\prime }\\ {\alpha }_{1...11}^{\prime }\end{array}\right)$$

(4)

4.2.3.1. Applying Single-Qubit Gates

The first traditional approach to face this problem is using sparse matrix management methods. However, [16,17] states that applying a single-qubit gate $G_k$

$$G_k=\left(\begin{array}{cc}{g}_{00}& g_{01}\\ g_{10}& g_{11}\end{array}\right)$$

(5)

To the k-th qubit of a quantum register of N qubits is equivalent to applying the gate to pairs of amplitudes whose indices differ by k-th bits from their binary index.

$$\begin{array}{c}{\alpha }_{*...*0_k*...*}^{\prime }=g_{11}·{\alpha }_{*...*0_k*...*}+g_{12}·{\alpha }_{*...*1_k*...*}\\ {\alpha }_{*...*1_k*...*}^{\prime }=g_{21}·{\alpha }_{*...*0_k*...*}+g_{22}·{\alpha }_{*...*1_k*...*}\end{array}$$

(6)

This implies that all state vector elements must be processed in pairs. Let’s see how to apply the Hadamard gate to the first qubit of the state 00. For the values: $k=0$, $*...*0_k*...*=00$, $*...*1_k*...*=10$, ${\alpha }_{00}=1+0i=1$, ${\alpha }_{10}=0$ and Hadamard gate.

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

(7)

Replacing these values in Equation (6), we obtain the following results.

$$\begin{array}{c}{\alpha }_{00}^{\prime }={\displaystyle \frac{1}{\sqrt{2}}}·1+{\displaystyle \frac{1}{\sqrt{2}}}·0={\displaystyle \frac{1}{\sqrt{2}}}\\ {\alpha }_{10}^{\prime }={\displaystyle \frac{1}{\sqrt{2}}}·1-{\displaystyle \frac{1}{\sqrt{2}}}·0={\displaystyle \frac{1}{\sqrt{2}}}\end{array}$$

(8)

4.2.3.2. Applying Two-Qubits Gates

Similarly, to apply a controlled two-qubit quantum gate to a quantum register, using a control qubit c on a target qubit t, authors of [17] state that the new amplitudes can be obtained by performing the following operations:

$$\begin{array}{c}{\alpha }_{*..*1_c*..*0_t*..*}^{\prime }=g_{11}·{\alpha }_{*..*1_c*..*0_t*..*}+g_{12}·{\alpha }_{*..*1_c*..*1_t*..*}\\ {\alpha }_{*..*1_c*..*1_t*..*}^{\prime }=g_{21}·{\alpha }_{*..*1_c*..*0_t*..*}+g_{22}·{\alpha }_{*..*1_c*..*1_t*..*}\end{array}$$

(9)

Let’s see how to apply the CPS gate to the second qubit of the state 11 controlled by the first qubit. All amplitudes are equal to 0 except ${\alpha }_{11}$ which is equal to 1. Replacing these values in the Equation (9) we have:

$${\begin{array}{c}{\alpha }_{10}^{\prime }=1·0+0·0=0\\ {\alpha }_{11}^{\prime }=0·1+e^{i\varphi }·1=e^{i\varphi }\end{array}}^{\prime }$$

(10)

Thus, we obtain the amplitude values for the states |10〉 and |11〉

4.2.3.3. Qubits Order

Some simulators, like qiskit, reverse the order of the qubits such that qubit 0 corresponds to the least significant bit of the binary representation of the state. In this case, the distance between ${\alpha }_{*...*0_k*...*}^{\prime }$ and ${\alpha }_{*...*1_k*...*}^{\prime }$ is equal to $2^k$.

In this work, we maintain the natural order of the qubits. For example, in state 011, qubit 0 is the leftmost, qubit 1 is in the middle, and qubit 2 is the rightmost. Therefore, the distance between ${\alpha }_{*...*0_k*...*}^{\prime }$ and ${\alpha }_{*...*1_k*...*}^{\prime }$ is equal to $2^{(numQubits-1)-(k-thqubit)}$. To illustrate this, Figure 6 shows the distance between the states of a 4-qubit state vector.

Generally, a single-qubit gate can be applied to a quantum register performing the following pseudo-code.

In summary, calculating the amplitudes for the current state and the new affected state is done as follows: Determine the value of the current state’s amplitude using Equation (6). Then, find the pair corresponding to the current state, and finally, calculate the value of the latter using that same equation.

To find the pair corresponding to the current state, we can use two methods: the first calculates the distance using the relation $2^{(numQubits-1)-(k-thqubit)}$, as we explained before. The second method applies an XOR operation between the binary representation of the current state and a sequence of 0s with a 1 placed in the k-th position corresponding to the qubit we are working on. For example, applying a quantum gate on the 0th qubit on a for 4-qubits state 0101 we can find the corresponding pair using the following operation.

$$\oplus {\displaystyle \frac{\begin{array}{c}0101\\ 1000\end{array}}{1101}}$$

(11)

This result can be corroborated in Figure 6. C++ offers binary operations to execute this operation efficiently and effortlessly.

4.2.4. State Prunning

In the version of the simulator where the least probable states are pruned, we use a dynamic memory management because the states are stored non-sequentially in memory. This arrangement results from their computation via Equation (6). Consequently, a state search method was developed to facilitate access to a specific state for calculations in subsequent iterations. However, performance is negatively impacted because a lot of time has to be spent searching for a state’s values before they are used in a calculation. Figure 7 depicts the order of a 3-qubits state vector after applying a single-qubit gate (Hadamard) on the qubit 0.

Because of this, the less probable states elimination approach was discarded early, therefore, we focus on pure states, which imply that the state vector contains the complete information about the quantum state; and this approach was adopted for the rest of this simulator’s design.

4.2.5. Shared Memory Case

In order to improve performance, parallelizing the code is necessary. The first method is to apply a shared memory programming model. This was done using OpenMP.

We use valgrind to run program profiling and determine the sections of code that consume the most resources. Afterward, it was determined that the QuantumRegister::applyGate method is the component of the simulator where we had to focus on increasing performance. Figure 8 shows the profiling results.

The QuantumRegister::applyGate method iterates through the state vector, implementing Equation (6). To enhance performance, we partition the data and execute instructions on segments of the state vector, thereby speeding up the simulation. It is crucial to carefully manage the method’s internal variables to prevent race conditions.

5. Results

References

1. Report, Q.C. Qbit Count. https://quantumcomputingreport.com/scorecards/qubit-count/, 2019.
2. Quantiki. List of QC simulators. https://www.quantiki.org/wiki/list-qc-simulators, 2019.
3. Fingerhuth, M. Open-Source Quantum Software Projects. https://github.com/qosf/os_quantum_software, 2019.
4. Team, Q.O.S.F. Quantum Open Source Foundation. https://qosf.org/, 2019.
5. Bergou, J.A.; Hillery, M. Introduction to the Theory of Quantum Information Processing; Springer Publishing Company, Incorporated, 2013.
6. Artur Ekert, P.H.; Inamori, H. Basic concepts in quantum computation. Coherent atomic matter waves 2001, pp. 661–701.
7. Shoshany, B. In layman’s term, what is a quantum state? https://www.quora.com/In-laymans-term-what-is-a-quantum-state, 2018.
8. Williams, C.P. Explorations in Quantum Computing, Second Edition; Texts in Computer Science, Springer, 2011. doi:10.1007/978-1-84628-887-6. [CrossRef]
9. Eleanor, R.; Wolfgang, P. Quantum Computing, A Gentle Introduction; The MIT Press, 2011.
10. Guerreschi, G.G.; Hogaboam, J.; Baruffa, F.; Sawaya, N. Intel Quantum Simulator: A cloud-ready high-performance simulator of quantum circuits, 2020, [arXiv:quant-ph/2001.10554].
11. Gheorghiu, V. Quantum++: A modern C++ quantum computing library 2014. [arXiv:1412.4704]. doi:10.1371/journal.pone.0208073. [CrossRef]
12. team, Q.A.; collaborators. qsim, 2020. doi:10.5281/zenodo.4023103. [CrossRef]
13. Jones, T.; Brown, A.; Bush, I.; Benjamin, S.C. QuEST and High Performance Simulation of Quantum Computers. Scientific Reports 2019, 9, 10736. doi:10.1038/s41598-019-47174-9. [CrossRef]
14. Strano, D. Qrack. https://vm6502q.readthedocs.io/en/latest/, 2019.
15. Díaz, G. Prototype Quantum Computing Simulator. https://github.com/diaztoro/TMFQSfullstate.git, 2024.
16. Trieu, D.B. Large-Scale Simulations of Error-Prone Quantum Computation Devices. Dr. (univ.), Universität Wuppertal, Jülich, 2009. Record converted from VDB: 12.11.2012; Universität Wuppertal, Diss., 2009.
17. Smelyanskiy, M.; Sawaya, N.P.D.; Aspuru-Guzik, A. qHiPSTER: The Quantum High Performance Software Testing Environment. CoRR 2016, abs/1601.07195. [CrossRef]
18. Lindstrom, P. Fixed-Rate Compressed Floating-Point Arrays. IEEE Transactions on Visualization and Computer Graphics 2014, 20, 2674–2683. doi:10.1109/TVCG.2014.2346458. [CrossRef]