2.1 Methods for solving ODEs

The ZVODE package was built on a basis of the VODE package [21]. The VODE package was based on the LSODE package. The numerical methods, used for the LSODE (Livermore Solver for Ordinary Differential Equations) package implementation, are the computational routines based on the group of Linear Multistep Methods (LMMs). In general, LSODE uses the Adams methods (so-called predictor-corrector methods) for the non-stiff ODEs solving. In case of stiff ODEs, the Backward Differentiation Formula (BDF) methods are used. In this section, the most important mathematical aspects of the aforementioned methods are briefly presented—the detailed report concerning standard (i.e. sequential) implementation of LSODE may be found in [22].

The choice of the ZVODE package is determined by the fact that the QTM needs using complex numbers and the ZDOVE package allows performing calculations on complex numbers of single and double precision.

For the Initial Value Problem (IVP) in general: (1)

The LMMs, approximating the problem’s solution, may be described as: (2) where and α_k ≠ 0 and |α₀| + |β₀| > 0. The parameter h represents the step width for integration. Naturally, a value of h is selected during the solver’s work with the use of adaptive methods.

The LSODE routine uses two methods based on the LMMs: the Adams-Moulton method and the BDF method.

The implicit Adams-Moulton method, this means the values of β_i ≠ 0 (the detailed description of used symbols may be found in [23]), may be presented as: (3) where (4)

The ∇ⁱ symbol stands for the backward differences. It should be pointed out that: ∇ⁱ f_n = f_n and ∇ⁱ⁺¹ f_n = ∇ⁱ f_n − ∇ⁱ f_n−1. The value k expresses the number of steps, i.e. the values of y_i used in the specified method.

The BDF method is defined as: (5)

The above notation means that β_k ≠ 0 but β_i = 0 for i = 0, 1, 2, …, k − 1. The values of α_i are arbitrarily defined and may be found in many publications concerning the methods of solving ODEs.

In both cases, for the Adams-Moulton and the BDF method, the problem is to estimate the value of f_n+1. It should be stressed that this value is needed to estimate itself. The Newton method [24] is used in this case to calculate the estimation. The Newton method is quite rapidly convergent, though for the system of equations it needs to calculate the Jacobian. This method for (ZV/LS)ODE may be expressed as: (6) where and stand for the next approximations of y_n+1. The function g(⋅) represents the function approximating values of y_n+1.

The BDF method is used for stiff ODE problems and the Adams-Moulton method for non-stiff ODE problems. Using these both approaches together makes the (ZV/LS)ODE a hybrid method—see Fig 1. The presented QTM implementation allows choosing the method, respectively to solving easier (non-stiff ODE) or more difficult (stiff ODE) QTM problems. Moreover, in ZVODE, for every method the method’s order can also be controlled automatically. For the Adams-Moulton method, the orders from the first to the twelfth are available, and for the BDF method the orders from the first to the sixth.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 1. A general overview of the ODE solver and the methods used in the (ZV/LS)ODE implementation.

https://doi.org/10.1371/journal.pone.0208263.g001

2.2 Quantum Trajectories Method

A description of quantum states’ dynamics may be presented for two fundamental situations. The first case is an evolution of a closed quantum system, whereas the second case concerns an evolution of an open quantum system. As an example of a closed quantum system, we may refer to a model of a quantum circuit. If we want to consider a quantum system where its dynamics is affected by the influence of an external environment, we deal with an open quantum system.

In this subsection, we do not aim to describe the mathematical models of dynamics in open and closed quantum systems—the details concerning this subject may be found in [4] and [25]. For clarity, it should be recalled that for closed systems, the evolution is a unitary operation, and it can be denoted as Schrödinger equation: (7) where (C1) is the form of a partial differential equation and (C2) is the form which is convenient to use in numerical simulations. In (C2) H is a Hamiltonian describing system’s dynamics, and |ψ〉 stands for the initial system’s state.

The von Neumann equation describes the quantum system’s evolution if an influence of an external environment has to be considered: (8) where H_sys denotes the dynamics of a closed/core system, H_env stands for the environment’s dynamics, and H_int describes the interaction’s dynamics between the external environment and the system. The environment’s influence can be removed from (8) by the partial trace operation. In such a case, we obtain an equation which describes the dynamics of the core system. Such a system can be expressed by the Lindblad master equation: (9) where C_n stands for a set of collapse operators. These operators represent the influence of an external environment which affects a simulated system. Naturally, applying a collapse operator causes irreversible modification of a quantum state. It should be emphasized that simulating the behavior of a quantum system needs exponentially growing memory capacity according to the system’s dimension.

The QTM is a method which facilitates reducing the memory requirements during the simulation. Of course, any simulation of a quantum system’s behavior needs calculating many single trajectories—the more, the better—because they will be averaged to one final trajectory, and a greater number of trajectories ensures improved accuracy. However, every trajectory may be simulated separately, and this fact provides a natural background to utilize a parallel approach while implementing the QTM.

If we would like to compare simulating the behavior of a quantum system with the use of Lindblad master equation and the QTM, we should consider the requirements of both methods on computational resources. The Lindblad master equation methods utilize the density matrix formalism and the QTM is based on a wave function of n-dimensional state’s vector (termed as a pure state). A number of this vector’s entries grows exponentially, but using sparse matrices facilitates efficient simulation of a quantum system’s behavior. It should be stressed that a simulation based on the wave function concerns only one state of a quantum system what seems to be a disadvantage of this solution because for the Lindblad master equation methods, the density matrix describes many different states of the same system. Unfortunately, using density matrices in most cases is not possible because of memory requirements—the size of the density matrix grows exponentially when the dimension of a simulated system increases. While the QTM enables monitoring the influence of an external environment on a quantum state by modifying the state’s vector with the use of a collapse operator.

For the QTM, an evolution of a quantum system is described by so-called effective Hamiltonian H_eff, defined with the use of a set of collapse operators C_n, and a system’s Hamiltonian H_sys: (10)

The set of operators C_n determines the probability of a quantum jump occurrence. This phenomenon is caused by a single collapse operator acting on a current quantum state of the system. A probability of a quantum jump occurrence is: (11)

If a quantum jump takes place, the system’s state at the moment of time (t + δt)—that is just after the collapse operation—can be expressed as: (12)

Furthermore, if many collapse operators may be applied in the considered model, the probability of using i-th operator is: (13)

Of course, simulating the phenomenon of a system’s collapse needs a random numbers generator to ensure its probabilistic character (this issue is discussed in the following subsection).

Let us emphasize that all the considered calculations correspond to operations implemented on matrices and vectors within the QTM package. The needed matrices are usually band matrices. Namely, it is convenient, in terms of the memory consumption and the speed of calculation, to use sparse matrices. In consequence, the compressed sparse row (CSR) format may be utilized—it also gives an additional speed-up, especially when many matrix-vector multiplications have to be realized.

By summarizing the above remarks, we can formulate an algorithm which presents how a single quantum trajectory is calculated:

Algorithm 1 Computation of a single trajectory

The algorithm computing a single trajectory, according to the QTM, may be described as four computational steps:

1. (A) a value 0 ≤ r < 1 is computed by a pseudorandom number generator (r denotes the probability of a quantum jump occurrence);
2. (B) to get the state’s vector at the moment t the Schrödinger equation is integrated with the Hamiltonian H_eff (providing that the state’s vector norm has to be equal or greater to r: 〈ψ(t)|ψ(t)〉 ≥ r);
3. (C) if a quantum jump is realized, then the system’s state projection at the moment t, to one of the states given by Eq (12), is calculated. The operator C_n is selected to meet the following relation for the adequate n: and P_i(t) is given by Eq (13);
4. (D) the state obtained by the projection of wave-function in the previous step is a new initial value corresponding to the moment of time t; next, the new value of r is randomly selected, and the procedure repeats the process of the quantum trajectory generation, starting from the step (B)—more precisely: the simulation is performed again, but starts from the previously given value of t.

The presented approach is based on [8], [9], [14], [15], [26], [27].

2.3 Pseudorandom number generator

The QTM package described in this work utilizes a pseudorandom number generator from the Generalized Feedback Shift Register (GFSR) class. More precisely, we chose the LFSR113 method which is defined by using recurrence over the field F₂ consisting of elements 0, 1: (14) where are generator’s parameters (j₁ = 1, …, k) and are generator’s seeds (j₂ = n − 1, …, n − k). The generator’s period is r = 2^k − 1 if and only if the characteristic polynomial of recurrence: (15) is primitive.

The generated values, for n ≥ 0, may be expressed as: (16) where s denotes the step size, and L stands for the number of bits in a generated word. If (x₀, x₁, …, x_k−1) ≠ 0, and s is coprime to r, then we obtain a periodic sequence of u_n (with a period denoted as r).

Of course, the quality of a generator is determined by the sequence x_n. The proper choice of seeds is described in [28] where it is also shown that four seeds (k = 4) are sufficient to generate high-quality pseudorandom numbers. The LFSR113 generator’s realization is very fast because of the bitwise operations usage—this feature also does not collide with ensuring a sufficient period for generated numbers: 2¹¹³. However, it should be emphasized that the selection of generator’s seeds is crucial—there are four initial values, and they have to be integers greater than 1, 7, 15 and 127, respectively.

4.1 Unitary Hamiltonian

The first example concerns a simulation of a system described by the following unitary Hamiltonian: (17) where σ_x represents Pauli operator X (also termed as the NOT operator). The initial state of the analyzed system is (18)

The collapse operator and the expectation value operator, used in the simulation, are given below: (19) where σ_z stands for the Pauli operator Z.

We ran the experiment on a PC equipped with the Intel i7-4950k 4.0 Ghz processor under the Ubuntu 16.04 LTS operating system. The utilized version of the QuTIP package is 4.2 and the QuantumOptics.jl ran on Julia 0.6.4. Although the dimensions of the above structures are quite small, the simulation of 1000 trajectories with the QuTIP package, when only one core is running, needs about ≈ 0.90 seconds. Utilizing e.g. two cores for the calculation does not reduce the time of process because the QuTIP needs time for coordinating two threads. Of course, with the greater number of trajectories, it is easy to observe that the time of simulation is shorter when more cores are active. If the QTM package is used, calculating 1000 trajectories with the use of e.g. of eight MPI computational nodes cores takes 2-3 seconds. This time is mainly consumed by starting the MPI processes. It should be mentioned that the QuantumOptics.jl package needs more time for calculation because of the JIT compiler usage. However, for a such small problems the time of calculation is almost the same, irrespective of the used package.

Fig 5 shows the evolution of the expectation value with the Pauli Z gate in time.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 5. The figure showing changes of the unitary Hamiltonian’s expectation value in the time.

https://doi.org/10.1371/journal.pone.0208263.g005

The most important pieces of the code are written in a direct form (we define an effective Hamiltonian form directly filling the matrix H with suitable entries) because the QTM package allows specifying data structures directly. Constants WD_LD and WD_LD_SQR respectively stand for the vector state dimension, and its square and they are equal to two and four; co represents the collapse operator, eo stands for the expectation operator value and H is the Hamiltonian:

int r = 0;

co[0] = msc(0.0, 0.0); co[1] = msc(0.05, 0.0);

co[2] = msc(0.05, 0.0); co[3] = msc(0.0, 0.0);

eo[0] = msc(1.0, 0.0); eo[1] = msc(0.0, 0.0);

eo[2] = msc(0.0, 0.0); eo[3] = msc(-1.0, 0.0);

alpha[0] = msc(1.0, 0.0);

alpha[1] = msc(0.0, 0.0);

H[0] = msc(-0.00125, 0.0);

H[1] = msc(0.0, -0.62831853);

H[2] = msc(0.0, -0.62831853);

H[3] = msc(-0.00125, 0.0);

c_ops[0].rows = 2; c_ops[0].cols = 2;

c_ops[0].m = co;

opt.type_output = OUTPUT_FILE;

opt.only_final_trj = 1;

opt.ode_method = METADAMS;

opt.tolerance = 1e-7;

opt.file_name = strdup(“output-data.txt”);

opt.fnc = &myfex_fnc_f1;

r = mpi_main<N, Ntrj, WV_LD, WV_LD_SQR, 1>(argc, argv, 1, 0, 10, 1, 1, opt);

A significant part of the source code is a function calculating the right side of the ODEs. In the case of the example for a unitary Hamiltonian, we may utilize a direct approach that is multiplying the matrix form of the Hamiltonian H by the vector Y. The product is assigned to the variable YDOT. We can describe these calculation in detail as follows:

int myfex_fnc_f1(long int *NEQ,

       double *T,

       dblcmplx *Y,

       dblcmplx *YDOT,

       dblcmplx *RPAR,

       long int *IPAR)

{

 simpleComplex<double> o0, o1, out0, out1;

  o0.re = 0.0;  o0.im = 0.0; o1.re = 0.0;  o1.im = 0.0;

 out0.re = 0.0; out0.im = 0; out1.re = 0.0; out1.im = 0.0;

 o0 = Y[0] * H[0]; o1 = Y[1] * H[1];

 out0 = o0 + o1;

 o0.re = 0.0; o0.im = 0.0; o1.re = 0.0; o1.im = 0.0;

 o0 = Y[0] * H[2]; o1 = Y[1] * H[3];

 out1 = o0 + o1;

 YDOT[0] = out0; YDOT[1] = out1;

 return 0;

}

The approach presented above naturally allows further optimization of the code during the operation of multiplying the matrix by the vector.

4.2 Trilinear Hamiltonian

In this example, we first assume that the Hamiltonian H is also time-independent. The simulated process is a time evolution of an optical parametric amplifier given by the following trilinear Hamiltonian [30]: (20)

The symbols a, b and c stand for the boson annihilation operators corresponding to the pump, signal and idler fields respectively. The variable K represents the value of the coupling constant. For the purpose of the tests, we assumed that K = 1, and i represents an imaginary unit. The initial state of analyzed system is: (21) it is a coherent state for the pump mode (a), and the vacuum states for the signal (b) and the idler (c) modes.

We also utilize three expectation operators defined as: (22) where a, b, c still represent the boson annihilation operators with the same or different dimensionality. I_a, I_b and I_c are the identity operators for fields: pump_mode (a), vacuum (b) and idler (c). The collapse operators are denoted as: (23) where γ₀ = γ₁ = 0.1, γ₂ = 0.4.

The obtained expectation values of the photons’ number, during the experiment with 1000 trajectories, are presented in Fig 6.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 6. The expectation values describing the number of photons for different expectation operators (N0—Blue, N1—Red, N2—Green defined by Eq (22)) for a trilinear Hamiltonian—Eq (20).

https://doi.org/10.1371/journal.pone.0208263.g006

Fig (7) depicts the simulations’ duration for the QuTIP, the QuantumOptics.jl and the QTM packages with the different number of trajectories. We also diversify the number of dimensions for the initial state in our experiments. The calculation for the MPI protocol was conducted with the use of nine computers equipped with Intel Core i7-4790K 4.0 GHZ processing units, and working under the Ubuntu 16.04 LTS operating system. Each processor has four cores, therefore, we were able to run the 32 MPI processes in eight computational nodes. The last processing unit serves as a master node.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 7. The duration of the simulation for the trilinear Hamiltonian.

The experiments were run for the different number of trajectories with use of the QuTIP (four CPU cores were used), the QuantumOptics.jl (termed as QuanOpt, with only one CPU core used during the computations), and the QTM package (with two different numbers of the computational nodes).

https://doi.org/10.1371/journal.pone.0208263.g007

We can observe a direct profit thanks to dividing tasks between many computational nodes. We should expect a significant speed-up of calculations if the number of computational nodes increases, therefore, we consider this to be a very good result. Especially for high-dimensional systems utilizing parallel computing and many computational nodes, the execution of the tasks directly translates into better performance i.e. shorter computation time with the QTM package. It should be emphasized that in the case of calculating 10.000—20.000 trajectories 32 MPI processes still offer sufficient computing power to increase the size of the problem or the number of trajectories. For the QuTIP package, this computation was run with the use of one computational node and the whole computing power was consumed. The same situation can be observed in the case of the QuantumOptics.jl package. It also utilizes the JIT system of compilation and offers a very efficient usage of a processing unit. However, only calculating many trajectories using the MPI technology causes significant reduction of the calculation time.

The simulation of a trilinear Hamiltonian requires using sparse matrices in order to maintain both low memory requirements and high performance. The QTM package offers basic data types to simplify the basic transformations and realize the calculation (also the definitions of operators may be given directly, as it was done for the Hamiltonian). A few selected steps connected with the preparation of the Hamiltonian representations are presented below:

// Hamiltonian preparations

const int N0 = 8, N1 = 8, N2 = 8;

double K = 1.0, gamma0 = 0.1, gamma1 = 0.1, gamma2 = 0.4;

double alpha_triham = sqrt(3);

uMatrix< simpleComplex<double> > d1(N0);

…

uMatrix< simpleComplex<double> > a0(N0*N1*N2),

        C0(N0*N1*N2), num0(N0*N1*N2);

…

uMatrix< simpleComplex<double> > H(N0*N1*N2);

…

destroy_operator(d1);

eye_of_matrix(d2);

eye_of_matrix(d3);

a0 = tensor(d1, d2, d3);

…

H = unity*K*(a0*dagger(a1)*dagger(a2)–dagger(a0)*a1*a2);

Heff = prepare_effective_H(H, C0, C1, C2);

H = convertToCSRMatrix(Heff);

…

vacuum = tensor(basis(N0,0), basis(N1, 0), basis(N2,0));

D = exp_of_matrix(alpha_triham * dagger(a0)

         − cojugate(alpha_triham)*a0);

alpha = D*vacuum;

…

r = mpi_main<100, Ntrj, WV_LD, WV_LD_SQR, 3>(argc, argv, 1, 0, 4, 1, 1, opt);

The changes also apply to the function calculating the right side of the ODEs. Luckily, only the function realizing multiplication has to be changed to the one supporting the CSR matrices. Therefore, the function calculating the right side of the ODEs is:

int myfex_fnc_f1(long int *NEQ,

       double *T,

       dblcmplx *Y,

       dblcmplx *YDOT,

       dblcmplx *RPAR,

       long int *IPAR)

{

  size_t i, j;

  for (i = 0; i < WAVEVECTOR_LEAD_DIM; i++)

  {

   YDOT[i].re = 0.0;

   YDOT[i].im = 0.0;

   for (j = H.row_ptr [i]; j < H.row_ptr [i+1]; j++)

   {

    YDOT[i] = YDOT[i] + (H.values[j] * Y[H.col_ind[j]]);

   }

  }

   return 0;

}

Referring to the function calculating the right side of the ODEs, it should be emphasized that the access to the current time value (parameter T) is possible, what facilitates using a time-dependent Hamiltonian.

The QTM package is implemented in the C++ language and the presented examples have to be compiled, therefore, the computation is carried out with a high efficiency.

4.3 Jaynes-Cummings model

The third example refers to the Jaynes-Cummings Model (JCM). This problem may also be simulated in the QTM package. In this case, a single trajectory corresponds to a computation run with the use of the master equation. Let us assume that the system’s dimension is N = 40. The dimensions of the operators are given in subscripts. (24) where I₂ stands for the identity operator sized 2 × 2, σ⁻ represents the annihilation operator for Pauli spins. The values Δ and g represent coupling strength between an atom and a cavity. The initial state is expressed as: (25) where we make tensor product between a coherent state and a single qubit in the state |1〉.

The results obtained during the simulation of the JCM are presented in Fig 8. It should be emphasized that we utilize only one trajectory, and needed operators were represented by sparse matrices.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 8. The values of the spin excitation in the JCM obtained after calculating one trajectory without using collapse operators.

https://doi.org/10.1371/journal.pone.0208263.g008

The most important pieces of the code for the JCM are listed as follows:

const int N = 40;

double g = 1.0, delta = -0.1, alpha = 4.0

uMatrix< simleComplex<double> > d1(N);

uMatrix< simleComplex<double> > eye2(2), sigmam(2);

…

sigmam_operator sigmam);

destroy_operator(d1); eye_of_matrix(eye2);

…

a = tensor(d1, eye2);

sigmaminus = tensor(eyeN, sigmam);

expect = dagger(sigmamnus)*sigmaminus;

H = delta * dagger(a) * a + g*(dagger(a)*sigmaminus + a * dagger(sigmaminus));

Heff = prepare_effective_H(H);

H = convertToCSRMatrix(Heff);

…

r = mpi_main<600, 1, N, N*N, 0>(argc, argv, 1, 0, 35, 0, 1, opt);

4.4 The birth and death of a photon in a cavity

The fourth and the last example refers to the convergency of the simulation of photon’s birth and death in a cavity, and it is based on paper [29]. Let N be a number of task’s dimensions, and N = 5. Then, the Hamiltonian and the collapse operators are expressed as: (26) where d⁻ denotes the destroy operator, H—the Hamiltonian and c₀, c₁ represent the collapse operators, t—the temperature of the environment.

Fig 9 shows that the number of generated trajectories improves the accuracy for a solved problem. Naturally, it also confirms the correctness of the realized QTM implementation.

Download:

• PPT
  PowerPoint slide
• PNG
  larger image
• TIFF
  original image

Fig 9. The probability of the decay for the one-photon state obtained with the different numbers of trajectories.

Increasing the number of trajectories improves the accuracy of calculation.

https://doi.org/10.1371/journal.pone.0208263.g009

The source code for this example is very similar to the previously presented pieces of the code. We utilize dense matrices because the system’s dimension is low, and it does not influence the performance.