Skip to content

Google Summer of Code 2023

Jump to bottom
Simon Cross edited this page Feb 22, 2023 · 17 revisions

QuTiP has participated very successfully in Google Summer of Code for the last three years, and we are once again participating in Google Summer of Code (GSoC) 2023 under the NumFocus umbrella.

Current project ideas

See here.

Past projects

You can look at the 2020, 2021 and 2022 student project blogs to get an idea of the kinds of projects we've offered and the experience of working on them:

Learning 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.

Other resources to learn about QuTiP are:

How to apply

QuTiP participates in GSoC via NumFocus, so start by reading 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.

Application deadline: March 20 - April 4

In order to demonstrate your communication, technical skills, and or, scientific knowledge, we encourage applicants to complete one or more small tasks before applying. Suitable tasks might include making a small improvement to any part of QuTiP (documentation, tutorials, the code itself, the QuTiP web site), reviewing open pull requests, debugging issues, replying to questions on the mailing list. There is no specific task checklist, but some examples are:

  • 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

If you do complete one or more tasks, be sure to refer to them clearly in your application.

Note that there are multiple QuTiP GitHub repositories where contributions might be made:

All have open issues. Those labelled 'help wanted' and 'good first issue' 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.

We encourage prospective students to email the admin team at qutip-admin@googlegroups.com and introduce themselves.

There is a template proposal from NumFOCUS for the student application at https://github.com/numfocus/gsoc/blob/master/templates/proposal.md and an archive of past projects, including QuTiP's, at https://summerofcode.withgoogle.com/archive/. You are welcome to deviate from the proposal template if you wish.

Project ideas

Here are some project ideas that have been proposed by our core development team. Note that you are welcome to submit a proposal for a project idea of your own devising that you believe fits within our organization. This could be an addition to one of our existing packages or a new complementary package. A list of project ideas can be found in qutip: just open a pull request or email the admin team at qutip-admin@googlegroups.com if you'd like to propose a new idea.

Summary

1 - QuTiP Virtual Lab

2 - qutip-jax solver enhancement

3 - QuTiP Control Optimization

4 - Enhanced Quantum Circuit Diagrams

5 - Spectral Density Tools for the HEOM

6 - Visualization with QuTiP

1 - QuTiP Virtual Lab

Simulating quantum physics in QuTiP provides an excellent educational tool. However, using QuTiP requires writing Python code, which may present an obstacle in some teaching contexts. Programming is, of course, a very valuable skill to master. Attempting to master it while simultaneously coming to grips with quantum mechanics is perhaps less advisable.

We would like to create a graphical virtual laboratory powered by QuTiP which allows users to explore quantum systems without being distracted by the need to write software.

The virtual lab would allow building up experiments from components (e.g. sub-spaces such as qubits, Hamiltonians for those subspaces, interaction Hamiltonians, environment baths), evolving the system over time, applying measurements, and attaching monitoring of quantum states or measurement outcomes (e.g. Hinton plots, Bloch sphere plots).

We'd like the laboratory to have a beautiful user interface and to support tablets and smartphones eventually, thus Kivy or Godot look like good libraries to build the interface with.

Project size:

  • 350 hours

Difficulty:

  • Hard

Deliverables:

  • A graphical interface that acts as a virtual laboratory
  • Allows the construction of simple quantum systems (e.g. placing four neutral atoms)
  • Allows defining the evolution of each system component
  • Allows defining the interactions between system components
  • Allows coupling the system to an environment bath
  • Allows simulating the system dynamics and visualizing their evolution over time
  • Allows visualizing the steady state of the defined system
  • Can be run on both desktop and tablets

Skills:

  • Familiar with Python and numpy
  • Familiar with Git
  • Familiar with or keen to learn Kivy or Godot
  • Really excited about building a virtual laboratory!

Mentors:

2 - qutip-jax enhancement

QuTiP has recently improved its solver module to extend its flexibility and allow different Integrator (ODE solvers). Integrator in qutip are the classes responsible for the low level computation of the evolution of a Quantum state. These are used in the QuTiP's solvers (see sesolve, mesolve, srmsolve) to provide a user friendly interface for the computation of the time dynamics of a wide variety of systems. QuTiP also includes a data layer to represent its main class, Qobj, using different array interfaces. The data layer has been extended in previous projects (some of them GSoC) giving birth to a family of packages (TensorFlow, CuPy and most recently Jax) that allow, among other things, GPU operation and auto-differentiation of QuTiP's Qobj. Those data-layers open new avenues for quantum control applications in QuTiP, where the auto-differentiation of a system evolution may provide and improvement in performance.

A first step to extend the auto-differentiation capabilities of qutip has recently been carried out on qutip-jax implementing an Integrator (DiffraxIntegrator). Your task as part of the GSoC project will be to benchmark the results with existing integrators, implement a user friendly interface to work with the result object from the solvers and provide an example of use of the auto-differentiation feature, possibly in the context of quantum control.

Project size:

  • 350 hours

Difficulty:

  • Medium

Deliverables:

  • Benchmark the results of solvers/operations implemented in qutip-jax.
  • Design and implement a user friendly interface to use together with jax.grad .
  • Add documentation showing examples of use for jax.jit and jax.grad in the context of Qobj operations and solvers.
  • Make the following notebooks that use qutip functions from qgrad work with qutip-jax

Skills:

  • Familiar with Python and Git
  • Understand the concepts of Python closures and decorators (which are used widely in JAX function transformations).
  • Familiar with JAX (beneficial, but not required)

Mentors:

3 - QuTiP Control Optimization

The control package inside of qutip has been used by a great many researchers to produce many important results since its inclusion in the project back in 2015. The modules use the GRAPE algorithm, based on an implementation described in [DYNAMO paper].

Version 5 of the qutip core will be released very soon, and as part of this we plan to move the control modules into a separate “family” package. Central to v.5 is the new data layer, which provides many performance enhancements through an intrinsic ability to choose the appropriate data storage type for the application. This gives us opportunity to streamline the coding of the existing control modules to take advantage of the new qutip data layer.

There have been many advancements in the field of quantum control optimization in recent times and we would like implement some of these within the QuTiP project. The qutip core modules offer a wide range of quantum dynamics solvers, supporting many models of quantum noise. We would like to take advantage of these in control optimization and the approach described in [GOAT paper] is ideally suited to exploiting our solvers.

Project size:

  • 350 hours

Difficulty:

  • Hard

Deliverables:

  • A QuTiP family package “qutip-grape” that utilises the data layer in qutip core.
  • Another QuTiP family package that uses the solvers in qutip core for computing the time evolution and gradients with respect control function parameters.

Skills:

  • Familiar with Python
  • Familiar with Git
  • Familiar with or keen to learn JAX auto-differentiation
  • Some understanding of quantum dynamics (helpful)
  • A basic understand of control theory (helpful)

Mentors:

4 - Enhanced Quantum Circuit Diagrams

QuTiP QIP includes the ability to render quantum circuits in Jupyter notebooks using LaTeX. However, installing and rendering LaTeX is an onerously additional task for novice, and even experienced, users.

The primary goal of this project is to replace QuTiP QIP's circuit rendering with a pluggable framework and to implement both text-only and Matplotlib based renderers. The text-only rendererer should allow circuits to be rendered in terminal Python consoles and Jupyter notebooks without requiring any dependencies not included by default. The Matplotlib renderer should allow circuits to be rendered beautifully in Jupyter notebooks with only Matplotlib required as an additional dependency. The existing LaTeX renderer should be ported to the new pluggable framework and there should be a means to select the rendering backend and an intelligent, but not too intelligent, selection of a default renderer.

A secondary but important goal is to render the circuits beautifully. The existing renderer is functional, but it would be better to have circuits that users would be proud to include in their documentation, academic papers and presentations. Specific improvements which could be made include a better ability to label wires, better distinguishing of classical and quantum wires, the ability to display sub-circuits and organize the gates in the rendering, better default font choices, more useful rendering of custom gates, the addition of colour, the ability to render barriers between sets of gates, and the option to style the plot in useful ways.

The addition of the text-only and Matplotlib renderers should also enable the rendering of circuits in Try QuTiP, a version of QuTiP that runs entirely in the browser when LaTeX is not available.

Implementations in other projects:

Project size:

  • 350 hours

Difficulty:

  • Medium

Deliverables:

  • a pluggable framework for rendering quantum circuits
  • a port of the current LaTeX renderer to the new framework
  • a new text-only circuit renderer
  • a new Matplotlib-based circuit renderer
  • a means to select the renderer and intelligent selection of the default renderer
  • unit tests for all of the above
  • documentation for all of the above
  • example notebooks for all of the above

Skills:

  • Familiar with Python, Jupyter, git and GitHub.
  • Familiar with the basics of quantum circuit diagrams.
  • Willing to learn a lot.
  • Excited about beautiful diagrams!

Mentors:

5 - Spectral Density Tools for the HEOM

QuTiP has a recently updated implementation of the Hierarchical Equations of Motion (HEOM), a technique for evolving quantum systems interacting with a stateful environment (also called a bath). The environment is described by a spectral density which determines its single time correlation function. To apply the HEOM technique, the correlation functions must then be expanded in an exponential series. QuTiP already provides descriptions of a number of important environments, but determining the expansion coefficients for a custom spectral density is still a challenging task that requires understanding many of the details of the HEOM.

This project aims to make it possible for those who aren't experts in the HEOM technique to define their own environments by supplying only a spectral density or correlation function. Since determining the goodness of the fit of the exponential series is vital to successfully employing the HEOM, we also wish to include tools for working with the spectral density and correlation functions easily and for examining the goodness of fit.

During the project is should be kept in mind that the descriptions of the environments might be useful outside of the HEOM.

Project size:

  • 350 hours

Difficulty:

  • Medium

Deliverables:

  • methods for calculating the spectral density for the existing baths
  • methods for calculating the correlation function for the existing baths
  • methods for calculating the approximate correlation function after truncation of the expansion series
  • methods for calculating the approximate spectral density after truncation of the expansion series
  • methods for plotting goodness of fit after truncation of the expansion series
  • a simple means to construct baths from spectral density functions
  • a simple means to construct baths from correlation functions
  • one or more functions for optimally fitting the expansion series to the correlation function
  • one or more Jupyter notebooks demonstrating the use of the new functionality
  • possibly a separation of the environment descriptions into HEOM-specific and generic components.

Skills:

  • Familiar with Python, Jupyter, git and GitHub.
  • Familiar with the basics of the evolution of open quantum systems.
  • Willing to learn a lot about the HEOM.
  • Excited about numerical expansions, spectral densities and correlation functions!

Mentors:

6 - Visualization with QuTiP

QuTiP has many functions to plot quantum states and results from evolution. These functions need to be improvements, their interfaces are inconstant and only one support the colorblind_safe options. Moreover, the only animation function available has been in experimental status for years.

This project consists first in improving the existing plotting functions, by adding support for colorblind mode, adding plotting options, unifying the interface and adding automated tests for those. The second goal is to write animation functions to show the evolution produced by the solvers.

Project size:

  • 175 hours

Difficulty:

  • Easy

Deliverable

  • Unify existing function interface.
  • Ensure the colorblind options is supported everywhere.
  • Add ploting method to Result object.
  • Create animation function for state evolutions.
  • Create a notebook showing the new features.

Skills:

  • Familiar with QuTiP, Jupyter, git and GitHub.
  • Knowledgeable about matplotlib and python

Mentors:

Clone this wiki locally