Skip to content

Google Summer of Code 2022

Jump to bottom
Simon Cross edited this page Apr 18, 2022 · 18 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) 2022 under the NumFocus umbrella.

Current project ideas

See here.

Past projects

You can look at the 2019, 2020 and 2021 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: April 4 to 19

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 Notebooks 5

2 - QuTiP Benchmarks

3 - QuTiP Virtual Lab

4 - qutip-qip as a Qiskit backend

5 - JAX data backend

QuTiP Notebooks 5

QuTiP comes with an impressive set of Jupyter notebooks -- https://github.com/qutip/qutip-notebooks. The notebooks range from basic tutorials, through intermediate guides, and to demonstrations of advanced techniques. However, there is no real infrastructure for running the notebooks and keeping them up to date. We would like to build such infrastructure, so that the beautiful notebooks become a well-maintained library of examples and not one grand edifice gathering mould.

This is an amazing opportunity for a contributor to learn the devops around managing and running notebooks, and to explore a wide range of quantum physics in the notebooks themselves.

Project size:

  • 350 hours (could be reduced to 175 hours)

Difficulty:

  • Medium

Deliverables:

  • Store the notebooks in a markdown format (so that changes over time are human readable and that we don't store all the output).
  • Be able to run and build the notebooks daily using GitHub Actions (so that we know they work with the latest version of QuTiP).
  • Be able to detect when notebooks fail or produce incorrect results (i.e. add built-in notebook tests)
  • Store the executed notebooks where they can be linked to from the QuTiP website and elsewhere.
  • Update all of the notebooks to be able to work with QuTiP 5 (and update QuTiP 5 itself if needed).

Skills:

  • Familiarity with Python, Jupyter notebooks, Git and GitHub.
  • Familiarity with basic quantum physics.
  • Willingness to learn a lot!

Mentors:

QuTiP Benchmarks

QuTiP's users often want to simulate the dynamics of large open quantum systems accurately. Such simulations are computationally costly, and so performance is often the limiting factor. Even moderately sized quantum systems may consume hours of CPU time on a typical laptop.

To keep track of QuTiP's performance over time and ensure that performance regressions don't pass unnoticed, we would like to implement a suite of benchmarks and be able to record their results daily against the latest version of QuTiP.

Benchmarking is an extremely complicated topic. To get an idea of the immense challenges, some background reading:

QuTiP has a very old set of existing benchmarks which we could use for some ideas, but essentially this project would start from scratch.

As a frontend for the benchmarks we could use the very nice Airspeed Velocity package. See the ASV documentation and its demo site.

Project size:

  • 350 hours (could be reduced to 175 hours)

Difficulty:

  • Medium

Deliverables:

  • A suite of benchmarks that cover the important mathematical operations on quantum objects (tensor product, multiplication, addition, trace).
  • A suite of benchmarks that cover some of the solvers used to simulate system dynamics.
  • The ability to run those benchmarks against different data backends.
  • The ability to record benchmark performance over time and provide the results in a useful interface.
  • Reliable benchmark runs (or at least ones where the variability is understood, quantified and documented).
  • Stretch goal: Provide a visual display of benchmarks for the QuTiP website.

Skills:

  • An interest in the nuts and bolts of what determines performance on modern CPUs.
  • A determined attention to small details and a relentless desire to dig deeper and take nothing for granted.
  • Familiarity with Python
  • Familiarity with basic quantum physics.
  • A willingness to learn a lot!

Mentors:

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:

qutip-qip as a Qiskit backend

The qutip-qip package, QuTiP quantum information processing, aims at providing tools for quantum computing simulation both for quantum algorithm design and for experimental realization. Using the package, one can perform circuit simulation both at the gate level and at the pulse level, with several predefined physical models. The pulse-level simulation explores the capability of qutip solvers and allows noise defined at the Hamiltonian level.

Although the qutip-qip package focuses more on the pulse-level simulation, there are many useful techniques for circuit optimization and scheduling at the gate level. It is impractical and unnecessary to implement them again. Therefore, it is beneficial to integrate with other libraries, allowing quantum circuits defined in other libraries to be imported into qutip-qip.

Qiskit is an open-source library for circuit simulation and operating real quantum computers. It has a wide user base and also provides high-level functionality such as transpilers and quantum error correction circuits. In addition, Qiskit allows custom defined providers and backends that takes the circuit and performs the simulation using external libraries.

More information:

Project size:

  • 175/350 hours

Difficulty:

  • Medium

Deliverables:

  • Implement a module that allows using qutip-qip as a backend for Qiskit.
  • Define a qutip provider and backends that use QubitCircuit and Processor to perform the circuit simulation.
  • Draft a notebook to demonstrate an example.
  • As a bonus goal: The backend can also be implemented to access pulse information via qiskit.pulse.

Skills:

  • Familiar with Qiskit and QuTiP
  • Familiar with Python and Git

Mentors:

JAX data backend

QuTiP's data layer provides the mathematical operations needed to work with quantum states and operators, i.e. Qobjs, inside QuTiP. As part of Google Summer of Code 2020, the data layer was rewritten to allow new backends to be added more easily and for different backends to interoperate with each other. In 2021, several different data-backend was added as qutip family package, including TensorFlow, CuPy and Tensor network.

The package JAX provides XLA compilation and automatic-differentiation composable transformations of Python+NumPy programs: differentiate, vectorize, parallelize, Just-In-Time compile to GPU/TPU, and more. JAX usage is growing a lot with new libraries such as DIFFRAX for Numerical differential equation solving in JAX. Supporting JAX as a data type for QuTiP is very useful for fast simulations, integrating with machine learning and other optimization libraries

Project size:

  • 350 hours

Difficulty:

  • Medium

Deliverables:

  • Implement a sub-package qutip-jax to support using jax.numpy.ndarray as a data type for qutip.Qobj.
  • Implement specialisations for some important operations including addition, multiplication, conjugation, transposition etc.
  • Support JAX function transformations such as jax.jit and jax.grad.
  • Use Jupyter notebook to demonstrate some simple examples, e.g.: a jit accelerated simulation of a parametrized quantum circuit using qutip-qip.

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:

Clone this wiki locally