An efficient method of computing the dynamics of a pure quantum state under the time-dependent Schrödinger equation is described: At each timestep, a restricted subspace of the potentially infinite-dimensional total Hilbert space is systematically and naturally constructed via the image of repeated applications of the Hamiltonian operator, and the time evolution is computed exactly within said subspace. The subspace is dynamically recomputed at each timestep such that it co-evolves with the state vector. We benchmark the method using the Holstein model and compare the formal information content of its representation to the matrix-product state formalism. The method is built from the ground up as a parallel algorithm for graphics processing units and is applicable to arbitrary Hamiltonians that are sparse in a given basis. It can be extended to open quantum system dynamics and/or time-dependent generators.
An efficient method of computing the dynamics of a pure quantum state under the time-dependent Schrödinger equation is described: At each timestep, a restricted subspace of the potentially infinite-dimensional total Hilbert space is systematically and naturally constructed via the image of repeated applications of the Hamiltonian operator, and the time evolution is computed exactly within said subspace. The subspace is dynamically recomputed at each timestep such that it co-evolves with the state vector. We benchmark the method using the Holstein model and compare the formal information content of its representation to the matrix-product state formalism. The method is built from the ground up as a parallel algorithm for graphics processing units and is applicable to arbitrary Hamiltonians that are sparse in a given basis. It can be extended to open quantum system dynamics and/or time-dependent generators.
The present thesis describes an efficient algorithm to determine the time evolution of the Bose-Hubbard model with time-dependent potentials. The Bose-Hubbard model was interpreted as a system of particles in a periodic structure at absolute zero. The system described here had M potential wells and N particles. The main part of the algorithm presented here was the calculation of a matrix-vector product, which was carried out matrix-free, i.e. without storing the matrix explicitly. Due to the 'on-the-fly' nature of the matrix-vector product, it was straightforward to incorporate a time dependence of the potentials into the system. The order of Fock states was an important part of the derivation of this algorithm. Using combinatorics a state indexing routine was found. For neighbouring site transitions of particles between two states the access time to the amplitudes of these states is of order O(1). Therefore the time complexity of the matrix-vector product is O(MD) with the Hilbert space dimension D. It is also possible to use the neighbouring site transitions multiple times to perform an arbitrary transition, so more complicated operators can be implemented. The time evolution itself was carried out using two different Runge-Kutta methods, namely the classical 4th order Runge-Kutta method and an embedded Runge-Kutta method, which can provide 4th and 5th order time steps simultaneously. A performance improvement was achieved by executing the presented algorithm in parallel utilizing a graphics card as a general purpose computational device. The GPU was chosen as a platform for these calculations, as it is capable to execute a large amount of tasks simultaneously. The implementation was done using CUDA, an API provided by Nvidia. The performance of this implementation was compared to cuSPARSE, a library for parallel sparse matrix computations also developed by Nvidia. The presented algorithm was found to outperform the well optimized cuSPARSE implementation by a factor of 165% on a consumer level graphics card. To prove the relevancy of the GPU implementation, a CPU one of the very same algorithm was made. The execution time of the CPU implementation surpassed the GPU one by a factor of 200% with consumer level hardware and 2300% on a professional graphics card. The presented algorithm was also compared to a different method of matrix-free matrix-vector multiplication involving hash functions and a Bisection search to retrieve the index of a given Fock state. Due to this required search algorithm, the time complexity of this method is O(MDlog D), which has a worse scaling behaviour than the presented algorithm. Last but not least, the functionality of the presented method was demonstrated by application to different systems and comparison to another work, where the Bogoliubov-Backreaction method was implemented.
This document aims to describe the methodology of quantum lattice gas algorithm based quantum physics simulations with details on implementation using graphics processing units. A variety of examples illustrating the general application of these methods are included. These examples are used to highlight topics such as scaling, potentials, momentums, multiple particle and dimensions, and various Hamiltonians in quantum simulations. Although intended to fullfill the doctor of philosophy degree requirement, this document is well suited as an introduction to this approach to modeling physics. In recent times parallelization has significantly improved the available computational power. Graphics processing units (GPUs) are a shining example of this, with thousands of compute cores and continually improved general computational capabilities, these processors can outshine their central processing unit (CPU) counterparts by orders of magnitude. Presented here are a number of examples of efficient computational methods for simulating physics using GPUs. Our quantum simulation method involves the quantum lattice gas model of quantum computation [59, 68, 64], however much of the parallel technology implementation is applicable to other numerical approaches. The quantum lattice gas model of computation is based on a unitary stream-collide quantum algorithm applied repeatedly over time upon an ordered array of qubits [53, 56, 68, 61, 63, 67]. The stream-collide quantum algorithm represents local quantum evolution of the system of quantum particles whose motion is constrained to reside on a spacetime lattice. Each particle in the system undergoes a quantum walk, interacting locally with other particles in the system that may reside on the same point. We will first mathematically describe the basic idea of quantum lattice gas algorithms. Next we will discuss GPUs and the basic features needed for implementation. We will then describe several examples of quantum lattice gas algorithm approach to illustrate the various applications and implementation challenges. Of particular interest is a look at modeling time-dependent many-body quantum mechanics using quantum lattice gas methods. For practical purposes we focus on the case of two fermions governed by the nonrelativistic Schrödinger equation. Numerical comparisons to analytic prediction show the high accuracy of these methods. Quantum lattice gas methods are chosen as a unitary algorithm for time dependent quantum simulation as they are efficient, accurate, and avoid the Fermi sign problem. Our findings from two-particle simulations under various conditions include the physics of the one and two particle systems diverging in their respective time-dependent behavior with increasing entanglement. We also confirm the multiple particle extension of the Ehrenfest theorem. Using the examples discussed throughout this document, we will then describe our specific computational implementation utilizing the computational power of GPUs through Nvidia’s compute unified device architecture (CUDA) language. Here we will discuss the open source software our group is developing based on these methods, along with some implementation verification and debugging concepts. Education is another application peripherally connected to this work and our software. The applications of this type of modeling as a learning tool is not fully explored yet, but the opportunities are promising.
We present an approach for integrating the time evolution of quantum systems. We leverage the computation power of graphics processing units (GPUs) to perform the integration of all time steps in parallel. The performance boost is especially prominent for small to medium-sized quantum systems. The devised algorithm can largely be implemented using the recently-specified batched versions of the BLAS routines, and can therefore be easily ported to a variety of platforms. Our PARAllelized Matrix Exponentiation for Numerical Time evolution (PARAMENT) implementation runs on CUDA-enabled graphics processing units. Program Title: PARAMENT CPC Library link to program files: https://doi.org/10.17632/zy5v4xs89d.1 Developer's repository link: https://github.com/parament-integrator/parament Licensing provisions: Apache 2.0 Programming language: C / CUDA / Python Nature of problem: Time-integration of the Schrödinger equation with a time-dependent Hamiltonian for quantum systems with a small Hilbert space but many time-steps. Solution method: A 4th order Magnus integrator, highly parallelized on a GPU, implemented using a small subset of BLAS functions for improved portability.
We propose a new variational quantum algorithm, which we refer to as TIMES-ADAPT, that prepares time-evolved states in a low-energy or symmetric subspace of a time-independent Hamiltonian on a quantum computer. Using a specially trained unitary that diagonalizes the Hamiltonian in a subspace, we construct fixed-depth circuits for real-time evolution in the subspace, where time only enters as a circuit parameter. We present two versions of the algorithm depending on whether the initial state is specified in the energy eigenbasis or computational basis. We consider two important applications of our methods: wave packet evolution and energy transport in spin systems. We benchmark our algorithms using variants of the Heisenberg XXZ model.
Simulating quantum many-body dynamics is important both for fundamental understanding of physics and practical applications for quantum information processing. Therefore, classical simulation methods have been developed so far. Specifically, the Trotter-Suzuki decomposition can analyze a highly complex quantum dynamics, if the number of qubits is sufficiently small so that main memory can store the state vector. However, simulation of quantum dynamics via Trotter-Suzuki decomposition requires a huge number of steps, each of which accesses the state vector, and hence the simulation time becomes impractically long. To settle this issue, we propose a technique to accelerate simulation of quantum dynamics via simultaneous diagonalization of mutually commuting Pauli groups, which is also attracting a lot of attention to reduce the measurement overheads in quantum algorithms. We group the Hamiltonian into mutually commuting Pauli strings, and each of them is diagonalized in the computational basis via a Clifford transformation. Since diagonal operators are applied on the state vector simultaneously with minimum memory access, this method successfully uses performance of highly parallel processors such as Graphics Processing Units (GPU). Compared to both CPU and GPU implementations using fast quantum circuit simulator “qulacs,” the numerical experiments have shown that our method provides a few tens of times acceleration.
Any system in the world is comprised of particles like electrons. To analyze the behaviors of these systems the behavior of these particles must be predicted. The ground state energy of a molecule is important information about a molecule and can be calculated by solving the Schrodinger equation. As the number of atoms increase, the number of variables (coordinates of each atom) that the equation represents increases by three times. Due to the large state space and the nonlinear nature of the Schrodinger equation, it is very difficult to solve this equation. Quantum Monte Carlo (QMC) is a very efficient method to solve the Schrodinger equation for accurate results. This method uses random numbers to sample the complex equation and get very accurate results. Due to the large data involved in this method, it exhibits a rich amount of data parallelism. Variational path integral (VPI) simulations are a class of QMC methods that permit direct computation of expectation values of coordinate-space observables for the nodeless ground states of many-body quantum systems. The high degree of data parallelism involved in this method facilitates the use of Graphical Processing Units (GPUs), a powerful type of processor well known to computer gamers. In