Application of the QDST algorithm for the Schrödinger particle simulation in the infinite potential well

Abstract

This paper examines whether a quantum computer can efficiently simulate the time evolution of the Schrödinger particle in a one-dimensional infinite potential well. In order to solve the Schrödinger equation in the quantum register, an algorithm based on the Quantum Discrete Sine Transform (QDST) is applied. The paper compares the results obtained in this way with the results given by the previous method (based on the QFT algorithm).

1 Introduction

In the near future, quantum calculations can make a major contribution to the development of informatics [1]. Nowadays some institutions claim to have a quantum computer and offer its computing power. Therefore, it is worth examining the properties of such machines.

For many years we have known Shor [2] and Grover [3, 4] algorithms which are of lower computational complexity than their best classical counterparts. Another promising application of quantum computer are quantum simulations [5–8], i.e. the computer modeling of behavior of physical quantum systems. It gives the possibility of effective modeling quantum processes, which is not possible using classical computers [9]. Quantum computers can simulate a wide variety of quantum systems, including fermionic lattice models [10–12], Heisenberg chains [13], Lattice Boltzmann methods [14] quantum chemistry [15, 16], field theories [17, 18], gravitational waves [19], and paradoxes in quantum mechanics [20].

As is well known, simulations of quantum systems performed using conventional computers are not effective. This means that for classical computer the memory resources and time required to simulate grow exponentially with the size of quantum system. In the case of a quantum computer, the situation is different. The relationship between the size of quantum computer (register) and the size of the simulated quantum system is linear. Therefore, a very important task is to find the appropriate algorithms that can properly simulate complex quantum systems and non-trivial interactions between them. This is a difficult issue, because most of the interesting quantum systems is feasible in infinitely-dimensional Hilbert spaces. In such situations, we can use the technique of sampling the wave function and build an algorithm based on the Quantum Fourier Transform (QFT). This case was tested in [21–24], which examined the free particle and the harmonic oscillator.

In our previous works algorithms based on the QFT have been used. We have successfully simulated both the Schrödinger particle with a continuous spectrum [25], and a particle trapped in a potential well with finite length [26]. In this paper we examine a modification of that approach. We show that algorithm based on the Quantum Discrete Sine Transform (QDST) can be successfully used for simulation of the Schrödinger particle inside infinite potential well. We also demonstrate that this approach has significant advantages.

The physical system we simulate here is simple and is successfully simulated on classical computers. However, the presented algorithm can be easily generalized to the three-dimensional case. Moreover, it may be part of a larger simulation of multi-molecular processes. In such situations, the use of quantum computer offers significant advantages.

The possibility of using a quantum register to simulate the Schrödinger particle has already been discussed in the literature. For example, in [27] simulation of noisy Schrödniger equation is examined. It is also worth mentioning about [28, 29], where technique based on the quantum lattice-gas model was examined. Our approach is completely different. We examine the problem on purely algorithmic grounds, using abstract model of quantum system. We abstract completely from specified physical implementation of the quantum register.

As is well known, quantum transforms are widely used in quantum processing. We can mention here the Quantum Fourier Transform [30, 31] and the cosine transform [32], which is used in image compression issues [33, 34]. The wavelet [35, 36] (e.g. in image processing [37, 38]) and the Walsh-Hadamard [39] transforms are also considered.

In order to simulate a quantum register, we used an environment written in C++ language. We also performed several tests of the algorithm with the use of IBM hardware [40]. In both cases we obtained the same results. Python (Qiskit) code of the algorithm main blocks can be found in Appendix E.

2 Description of the simulated system

In this work we consider the one-dimensional Schrödinger particle in a infinite potential well, as shown in Fig. 1. Our main purpose is the simulation of time evolution of such system in the quantum register.

Figure 1

The infinite one-dimensional potential well used in the simulation

Time evolution of the Schrödinger particle in a one-dimensional case takes the form:

$$ i\hbar \frac{d}{dt}\psi _{S}(x,t)= \bigl(H_{0}+V(x)\bigr)\psi _{S}(x,t), $$

(1)

where $H_{0}=p^{2}/(2m)$ is free Hamiltonian and $V(x)$ is the potential of the well from Fig. 1. The time evolution operator corresponding to Eq. (1) can be approximated as follows:

$$\begin{aligned} U(\Delta t)\psi _{S}(t) =&\exp \bigl(-i \bigl(H_{0}+V(x)\bigr) \Delta t/\hbar \bigr)\psi _{S}(t) \\ =&\exp \bigl(-i V(x)\Delta t/\hbar \bigr)\mathcal{F}^{-1} \bigl\{ \exp \bigl(-i p^{2}/(2m \hbar )\bigr)\mathcal{F}\bigl\{ \psi _{S}(t)\bigr\} \bigr\} , \end{aligned}$$

(2)

where $\mathcal{F}$ is the Quantum Fourier Transform. This method has been tested in paper [26]. In this work we show that algorithm based on the Quantum Discrete Sine Transform (QDST) can be used as well. Moreover, there are advantages to this approach. Both the QFT and the QDST algorithms applied to the quantum particle state allow the transition from the position to the momentum representation (stationary states). However, the QDST transformation is dedicated to states that meet the Dirichlet boundary conditions. Thus, it maps much more accurately the state of the particle to stationary states in the well (Eq. (C.4)). The accuracy of the mapping is not the only advantage. The fulfillment of the condition $\psi _{S}(-a)=\psi _{S}(a)=0$ means that the potential $V(x)$ from Fig. 1 is implemented automatically. The block implementing $\exp (-i V(x)\Delta t/\hbar )$ operator is not required. For this reason the algorithm can be run only in the energy domain and for time step of any value (i.e. the Trotter time step dt with error $O(\text{d}t^{2})$ [41] is not required). The algorithm based on the QFT (examined in an earlier work [26]) does not show the advantages described above.

3 Description of the algorithm

In the simulation a $n_{q}$-qubit register has been used. The state of the Schrödinger particle is encoded in all qubits exept the last one. Initial state of the last qubit is $\vert 1\rangle$, as shown in Fig. 2. It is an auxiliary qubit for the QDST algorithm (see Appendix B). The state of the Schrödinger particle is sampled and encoded in the subregister state in the following way:

$$ \psi _{i}=\psi _{S}(\Delta{x}\cdot{i}-a) \quad \text{for } i=0,1 \dots 2^{n_{x}}-1, $$

(3)

where $n_{x}=n_{q}-1$, $\psi _{S}(x)$ is the Schrödinger particle wave function, $\Delta{x}=2a/2^{n_{x}}$ is the distance between adjacent spatial samples. The $\psi _{i}$ numbers are probability amplitudes of i-th subregister base state (i.e. $\psi _{0}= _{n_{x}-1} \langle 0\vert \dots _{1} \langle 0\vert _{0} \langle 0\vert \Psi \rangle$, $\psi _{1}= _{n_{x}-1} \langle 0\vert \dots _{1} \langle 0\vert _{0} \langle 1\vert \Psi \rangle$, $\psi _{2}= _{n_{x}-1} \langle 0\vert \dots _{1} \langle 1\vert _{0} \langle 0\vert \Psi \rangle$, etc., where $\vert \Psi \rangle$ is the subregister state). Thus, amplitude $\psi _{0}$ corresponds to $\psi _{S}(-a)$, while amplitude $\psi _{2^{n_{x}}-1}$ corresponds to $\psi _{S}(+a-\Delta{x})$.

Figure 2

The scheme of the algorithm

The scheme of the algorithm is shown in Fig. 2. The first QDST block implements the QDST algorithm which changes the state of the particle from the position to the energy representation (the stationary states given by Eq. (C.4)). A detailed description of the QDST algorithm implementation can be found in [32] (see also Appendix B). The FES block implements free evolution of the particle ($\hat{U}(t)=\exp (-\text{i}t\hat{p}^{2})/(2\hbar m)$ operator). Its implementation is shown in Fig. 3. Gates $P_{\phi}$ are phase shift gates ($\vert 1\rangle \rightarrow \text{e}^{i\phi}\vert 1\rangle$), and controlled phase shift gates ($\vert 1,1\rangle \rightarrow \text{e}^{i \phi}\vert 1,1\rangle$). Implementation of the FES block is based on decomposition of the $\hat{U}(t)$ operator in the following way:

$$\begin{aligned} \exp \biggl(-\frac {\text{i}tp^{2}}{2\hbar m} \biggr) =&\exp \bigl(-\text{i} \alpha n^{2}\bigr) \\ =& \exp \Biggl(-\text{i}\alpha \sum _{k_{1}=0}^{n_{x}-1} \sum_{k_{2}=0}^{n_{x}-1} 2^{k_{1}+k_{2}}i_{k_{1}}i_{k_{2}} \Biggr) \\ =&\prod_{k=0}^{n_{x}-1}\exp \bigl(-\text{i}\alpha 2^{2k}i_{k} \bigr) \prod_{k_{1}=1}^{n_{x}-1} \prod_{k_{2}=0}^{k_{1}-1} \exp \bigl(- \text{i}\alpha 2^{k_{1}+k_{2}+1}i_{k_{1}}i_{k2} \bigr), \end{aligned}$$

(4)

where $\alpha =\pi ^{2}\hbar t/(8ma^{2})$, n is level number in the well (see Eq. (C.3)), and $i_{k}$ are binary digits of n ($n= \sum_{k}2^{k}i_{k}$). The first product from Eq. (4) corresponds to one-qubit gates from Fig. 3, while the second one (over $k_{1}$ and $k_{2}$) corresponds to two-qubits gates ($k_{1}$ is position of the gate, while $k_{2}$ is its control qubit number). The second QDST block implements the QDST⁻¹ transformation which is identical with the QDST transformation.

Figure 3

The scheme of the FES block implementing free evolution of the particle. Gates labeled by $P_{k}$ are controlled phase shift gates with angle $\phi _{k}=-\pi ^{2}k\hbar t/(8ma^{2})$

4 The simulation results

The algorithm has been tested in the $n_{q}=9$ qubit quantum register. We examined both the QDST algorithm from Fig. 2 and the algorithm based on the QFT transformation presented in [26]. In both cases we simulated a particle with the mass of electron in a well with length $2a=4$ nm. In the case of the QFT algorithm time step is $dt=10^{-18}s$. The results of simulation are shown in Figs. 4–7. In all plots only single curves are visible because the results of both algorithms coincide with each other.

Figure 4

Simulation of the particle stationary state ($n=3$) in the well. The X₀ curve is the initial state of the particle (for t = 0 s). Other curves are result of simulation for time $t=4.5\cdot 10^{-16}$ s. The X_S curve is result of the QDST simulation while the X_F curve is result of simulation based on the QFT algorithm. The right plot shows the momentum representation of the particle state (for the QFT method only positive values of momentum are shown)

Plots from Fig. 4 show example of the stationary state given by Eq. (C.4) for $n=3$. In the next figures propagation of the localized Gaussian state (given by Eq. (D.1)) is tested. In the case from Fig. 5 initial packet parameters take the following values: $dx=0.04a$, $\langle{x}\rangle =-0.6a$ and $T=25$ eV. In the case from Fig. 6 packet with parameters: $dx=0.04a$, $\langle{x}\rangle =+0.5a$ and $T=150$ eV has been used. In all figures the left plots show the particle state in the position representation. Numbers on the horizontal axes correspond to spatial sample values (sample no. 0 corresponds to $x=-a$ while sample no. 256 corresponds to $x=+a$). The right plots show the particle state in the momentum representation. Numbers on the horizontal axes correspond to n (number of the stationary state in the well).

Figure 5

Simulation of the localized Gaussian state inside the well. On the left plot the initial state and three phases of motion are shown (with time step $1.5\cdot 10^{-16}$ s). Dotted curves (denoted by “s”) are results of the QDST simulation. Solid curves (denoted by “f”) are results of simulation based on the QFT algorithm. The right plot shows the momentum representation of the particle state

Figure 6

Simulation of the Gaussian state collision with edge of the well. On the left plot the initial state and three phases of motion are shown (with time step $1.5\cdot 10^{-16}$ s). Dotted curves (denoted by “s”) are results of the QDST simulation. Solid curves (denoted by “f”) are results of simulation based on the QFT algorithm. The right plot shows the momentum representation of the particle state

Plot from Fig. 7 shows results from the IBM simulator (ibmq_qasm_simulator) [40]. We examine exactly the same case as in Fig. 6. As we can see, the results from both simulations are similar.

Figure 7

Simulation of the Gaussian state collision with edge of the well. The IBM hardware (‘ibmq_qasm_simulator’) has been used (for shots = 2048). The initial state and three phases of motion are shown (with time step $1.5\cdot 10^{-16}$ s). Exactly the same case as in Fig. 6 is examined. Numbers on the horizontal axis correspond to the numbers of the spatial samples

5 Conclusions

• Both methods (the QDST and the QFT) give convergent results. The states in the position representation coincide with each other for all three cases from Figs. 4-6.

• The QFT method does not calculate exactly the number of the stationary level inside the well (the right plot from Fig. 4). This affects the accuracy of the simulation as shown in the left plot from Fig. 4.

• Preparation of the initial state was excluded from the discussion. A simple algorithm for inputting these types of states into the quantum register has been proposed in [42].

• Implementation of the QDST transform requires more gates than implementation of the QFT transform (according to [32]). Therefore, in the case of a free Schrödinger particle, a QFT-based simulation is faster. In the case of a particle trapped inside a well (regardless of its initial state), a simulation based on QDST is definitely better because it does not require the Trotter time step.

• In the QDST method the well potential $V(x)$ is implemented automatically. For this reason the algorithm can be run only in the momentum representation and the simulation can be performed in one time step. This is a particularly important advantage for simulations on currently available quantum computers, which are characterized by high error rates.

Appendices

Appendix A: The Discrete Sine Transform (DST-1)

• formal definition of the DST-1 transform:

  $$ X_{k}=\sqrt{\frac {2}{N+1}}\sum _{n=0}^{N-1}x_{n}\sin \biggl( \frac {\pi}{N+1}(n+1) (k+1) \biggr) \quad \text{for } k=0,\dots ,N-1 $$

  (A.1)

• inverse transformation is given by the same formula:

  $$ x_{n}=\sqrt{\frac {2}{N+1}}\sum _{k=0}^{N-1}X_{k}\sin \biggl( \frac {\pi}{N+1}(n+1) (k+1) \biggr) \quad \text{for } n=0,\dots ,N-1 $$

  (A.2)

• inserting $X_{k}=(1,0\dots 0)$ to Eq. (A.2) we obtain:

  $$ x_{n}=\sqrt{\frac{2}{N+1}}\sin \biggl(\frac {\pi}{N+1}(n+1) \biggr). $$

  (A.3)

  Samples $x_{-1}=x_{N}=0$. Therefore N is number of non-zero samples. Function period is equal to $N+1$.

• k-th sample $X_{k}$ from Eq. (A.1) corresponds to the stationary state $\psi _{n}(x)$ from Eq. (C.4) for $k=n-1$.

Appendix B: The QDCT and the QDST algorithms

In our simulation the QDST1 algorithm has been used. The algorithm (shown in Fig. 2 from [32]) implements both the DCT-1 and the DST-1 transforms. In the first $2^{n_{q}-1}$ samples the DCT-1 transform of the input state is computed, while in the last $2^{n_{q}-1}$ samples the DST-1 transform is obtained (with multiplication by i factor). Hence, in our simulation the state of the last (auxiliary) qubit is set to $\vert 1\rangle$.

Important note: in the DST-1 transform from Appendix An-th sample codes $\psi _{n+1}$ state. For the QDST algorithm n-th sample stores $\psi _{n}$ state.

Appendix C: The Schrödinger particle in the infinite potential well

Let us consider the Schrödinger particle with the mass m inside the infinite potential well with a length 2a (as showni in Fig. 1). The stationary states of the particle can be predicted in the following form:

$$ \psi (x)=A\exp (ikx)+B\exp (-ikx), $$

(C.1)

where $k=\sqrt{2Em}/\hbar$.

By imposing boundary conditions in the form $\psi (-a)=\psi (a)=0$ we get:

$$ \psi _{n}(x)=A \bigl(\exp \bigl(ik_{n}(x-a) \bigr)-\exp \bigl(-ik_{n}(x-a) \bigr) \bigr), $$

(C.2)

where

$$ k_{n}=\frac{\pi n}{2a}\quad \text{for } n=1,2\dots . $$

(C.3)

The normalization condition allows to calculate $A=\frac {1}{2\sqrt{a}}$.

Finally, we obtain the stationary states in the well in the following form:

$$ \psi _{n}(x)=\frac {1}{2\sqrt{a}} \bigl( \text{e}^{ik_{n}(x-a)}- \text{e}^{-ik_{n}(x-a)} \bigr) =\frac {i}{\sqrt{a}}\sin \bigl(k_{n}(x-a) \bigr). $$

(C.4)

Appendix D: The Gaussian state

The localized Gaussian state of the Schrödinger particle takes the form:

$$ \psi _{S}(x)=C\exp \biggl(-\frac{(x-\langle x\rangle )^{2}}{4dx^{2}} + \frac{i \langle p\rangle x}{\hbar} \biggr), $$

(D.1)

where $\langle x\rangle$ is the expected value of the position, $\langle p\rangle$ is the expected value of the momentum, dx is standard deviation of the position while C is a normalization constant. In our work, instead of explicit value of $\langle p\rangle$, kinetic energy of the particle $T=\langle p\rangle ^{2}/(2m)$ is used.

Appendix E: The simulation code in Qiskit