Skip to content

Google Summer of Code 2019

Jump to bottom
Nathan Shammah edited this page Jan 30, 2020 · 34 revisions

We are applying under the NumFocus umbrella. Please read the NumFocus guidelines for students. You will need to register on the Google Summer of Code website - https://summerofcode.withgoogle.com/ and make a final proposal before the deadline. You can add your draft and contact respective mentors so that we can provide feedback before the deadline.

Check out the GSoC 2020 project ideas

Learn about QuTiP

The best way to learn about QuTiP is to study the lectures and tutorials on our website. If you need help, then look first in the documentation, then the Help Group - post a message if you need to.

Applications

In order to demonstrate your communication, technical skills, and or, scientific knowledge, please complete one or more of these tasks before applying. Be sure to refer to them clearly in your application. Note that we have three other associated repositories.

All have open issues, those labelled 'help wanted' are a good place to look. Understanding of quantum dynamics, technical (programming) skills, and being helpful to users, are all highly valued by QuTiP. Make sure to read the Contributing to QuTiP Development guidelines if you are submitting a Pull Request.

Tasks before applying

  • Submit a pull request in QuTiP solving some issue from the issues page.
  • Make some helpful suggestion of how to resolve some issue or enhance the toolkit. The more specific the better.
  • Help some user who is having technical or usage problems on the Help Group

Projects

1. Lattice models in QuTiP

Lattice models not only lay the foundation for condensed matter physics, but also lie at the heart of cutting edge research, e.g., in the fields of topological transport or computational complexity. Already seemingly basic 1D models, such as an Ising spin chain, can exhibit rich physics, ranging from phase transitions, to Anderson localization, to the encoding of NP-hard computational problems. Other cleverly designed lattices open up the world of topologically protected, disorder-robust particle propagation, anyons, or spintronics, to mention just a few of the intriguing features that can emerge in such systems. Simulating the dynamics of lattice models can significantly support the understanding and fostering of desired lattice features and thus is of vital interest in these communities. The underlying vision of this project is develop a tool kit, within QuTiP, for lattice dynamics, which, by design, provides the generic building blocks to simulate not only paradigmatic lattice models, but also generalizations thereof. Ideally, this is achieved by combining a user-friendly interface with efficient and scalable algorithms. The Google SoC project will lay the ground for such a QuTiP module, with the focus on one-dimensional lattices.

Expected outcomes

  • A qutip.lattice module implementing Hamiltonians for paradigmatic 1D lattice models, e.g., Ising model, XY model, Bose-Hubbard model, Su-Schrieffer-Heeger model, etc.
  • Simulating single-particle and many-particle dynamics on 1D lattice geometries, possibly in presence of environmental noise, building upon existing simulation tools in QuTiP.
  • Tools and functions to compute important properties, eg., eigenstates, band structure, etc.

Skills

  • Some background in (quantum) physics.
  • Git, python and familiarity with the Python scientific computing stack

Mentors

Difficulty

Medium

References

[1] Slides on quantum spin models by Anders W. Sandvik, Boston University.

[2] Quantum algorithms for classical lattice models G De las Cuevas1,2,5, W Dür1, M Van den Nest3 and M A Martin-Delgado4

Published 9 September 2011 • IOP Publishing and Deutsche Physikalische Gesellschaft New Journal of Physics, Volume 13, September 2011

2. GPU implementation of the Hierarchical Equations of Motion

The Hierarchical Equations of Motion (HEOM) method is a non-perturbative approach to simulate the evolution of the density matrix of dissipative quantum systems. The underlying equations are a system of coupled ODEs which can be run on a GPU. This will allow the study of larger systems as discussed in [1]. The goal of this project would be to extend QuTiP's HEOM method qutip.nonmarkov.heom and implement it on a GPU.

Since the method is related to simulating large, coupled ODEs, it can also be quite general and extended to other solvers.

Expected outcomes

  • A version of HEOM which runs on a GPU.
  • Performance comparison with the CPU version.

Skills

  • Git, python and familiarity with the Python scientific computing stack
  • CUDA and OpenCL knowledge

Mentors

Difficulty

Hard

References

[1] https://pubs.acs.org/doi/abs/10.1021/ct200126d?src=recsys&journalCode=jctcce

3. Quantum-Optics Simulations with Dynamic Hilbert-Space Dimension

Quantum-optics simulations are crucial to the study of the fundamental properties of the light-matter interaction. Light-matter interactions arise in several domains including physics, chemistry and biology, and have recently become the workhorse to manipulate quantum information stored in atoms (matter) and/or photons (light). For this reason, light-matter interactions are engineered and exploited in almost all quantum-computing hardware architectures.

A quantum-optics simulation requires to solve the time-dependent Schrödinger equation of an open quantum system. “Open” here means that the simulation includes both a Hamiltonian (non-dissipative) and a Lindbladian (dissipative) part. This translates to the need of solving a system of N2 coupled differential equations for a system of size N. Therefore, quantum-optics simulations become quickly expensive with system size.

As a potential way to circumvent this problem, this project proposes to perform dynamical quantum-optics simulations that can adjust the effective simulation size Neff in time by discarding a set of irrelevant equations by means of a convergence criteria [1, 2]. In particular, dynamical quantum-optics simulations are expected to greatly accelerate the simulation of driven quantum systems, which appear in typical quantum-optics and quantum-information setup.

Expected outcomes

  • A new solver for open quantum system with an adaptive Hilbert Space.
  • Performance comparisons with existing solvers and existing C++ implementation.

Skills

  • Some background in (quantum) physics.
  • Git, python and familiarity with the Python scientific computing stack.
  • Optionally, some fluency in C++.

Mentors

Difficulty

Medium

References

[1] Schack, Rüdiger, and Todd A. Brun. "A C++ library using quantum trajectories to solve quantum master equations." Computer physics communications 102.1-3 (1997): 210-228.

[2] Schack, Rüdiger, Todd A. Brun, and Ian C. Percival. "Quantum-state diffusion with a moving basis: Computing quantum-optical spectra." Physical Review A 53.4 (1996): 2694.

4. Abstraction of the quantum object class (qutip.qobj.Qobj)

QuTiP's Qobj class uses sparse matrices (csr) to store data by default. Recently, we have had some issues due to using int32 for the sparse matrix indices in QuTiP (see #845, #842, #828, #853). Also, in smaller problems, using a sparse matrix for storing data is not optimal, (see the detailed discussion by @agpitch in #437). Therefore there needs to be an abstraction of the quantum object class such that one can use any structure to store the underlying data. A starting point would be the possibility to switch between dense/sparse/int32/int64 and then to determine what other parts of the code are affected by this change. The disentangling of the matrix representation of the data has several benefits which can allow us to use other types of linear algebra tools (Numba, TensorFlow). This project would be challenging as the components are integral to the library and hence changes would have wide-reaching implications. Even beyond GSoC, the abstraction of the quantum object class can lead to some very interesting directions for QuTiP.

But as a first goal, enabling int32/int64 indices for sparse along with a switch for dense/sparse in a consistent manner should be within the timeline for GSoC 2019.

Read the relevant discussions -

Expected outcomes

  • An encapsulation of the quantum object class which can switch between dense/sparse matrices with the possibility of int32/int64 for indices
  • Updating of other parts of the code which assume default sparse behavior of Qobj
  • Performance analysis.

Skills

  • Git, python and familiarity with the Python scientific computing stack

Mentors

Difficulty

Hard

5. Noise Models in QIP Module

QuTiP has a quantum circuit configuration and simulator, see qutip.qip and associated notebooks. The simulation of the circuit currently assumes perfect gate implementations and no decoherence. That is, each gate is effected as an instantaneous unitary transformation on the qubits. In code terms this is matrix multiplication of the state vector.

QuTiP is most famous for its computation of open quantum system dynamics. That is, simulating how noise affects the dynamics of the quantum system. Increasingly users have been asking if the noise models implemented in QuTiP can be applied to the circuits in the QIP module. For this to be possible a Hamiltonian model for the qubit register must be defined. The Hamiltonian model would describe how the controlling fields drive the qubits and how the interactions between them effect their dynamics. In this model, the gates are not instantaneous, they are effected by driving fields over a given time. Also in this model, interactions with the environment that lead to decoherence can be simulated by evolving the circuit using a Lindbladian model (mesolve) or Bloch-Redfield model (brsolve) or HEOM model nonmarkov.heom or any of the other open-system solvers in QuTiP.

The objective of this project is to allow for these open-system noise models to be applied to quantum circuits defined in the QIP submodule. Specific tasks start with a Hamiltonian model to be added to a quantum register. That is, Hamiltonians for each qubit that can therefore be tensored to get the Hamiltonian of the full system (quantum register). Some method for automating this based on templates should be included in the design. For this project a single idealised template, based on same controls for each qubit and nearest neighbour interactions, will be sufficient. The design should allow for other templates as well, such as those based on well known devices. The times for effecting the gates must also be specified.

Given the configuration above, the control modules (qutip.control) can be used to determine control sequences for performing each step of the circuit. For this it is necessary to discretize the time to run the circuit, that is, the time is split into short timeslots. It should be possible to parallelize this, as each step can be considered independent. The output of this will give a time-dependent Hamiltonian of the system that will result in the same unitary transformation of the circuit. The time-dependence comes in the form of arrays containing the amplitudes of each control with an timeslot. Some method of exporting and importing this time-dependent Hamiltonian will be required.

The time-dependent Hamiltonian can then used in any of the open-system solvers. Noisy controls can also be modelled by adding random noise to the control sequences. In this way the final evolution can then be compared with the idealised unitary output, by comparing the final states using existing fidelity measures.

Expected outcomes

  • Time-dependent Hamiltonian that performs quantum circuit
  • Template for producing this from existing QIP submodule circuits
  • Export / import method for time-dependent Hamiltonian
  • Notebooks demonstrating the use of above comparing QIP circuit output with noising system output

Skills

  • Git, Python and familiarity with the Python scientific computing stack
  • Some knowledge of and experience with quantum circuits would be helpful.

Mentors

Difficulty

Hard

Clone this wiki locally