Neill Lambert, Eric Giguère, Paul Menczel, Boxi Li, Patrick Hopf, Gerardo Suárez, M. A. Galí Labarias, Jake Lishman, Rushiraj Gadhvi, Rochisha Agarwal, Asier Galicia, Nathan Shammah, Paul D. Nation, J. R. Johansson, Shahnawaz Ahmed, Simon Cross, Alexander Pitchford, Franco Nori
QuTiP, the Quantum Toolbox in Python (Johansson et al., 2012, Johansson et al., 2013), has been at the forefront of open-source quantum software for the past 13 years. It is used as a research, teaching, and industrial tool, and has been downloaded millions of times by users around the world. Here we introduce the latest developments in QuTiP v5, which are set to have a large impact on the future of QuTiP and enable it to be a modern, continuously developed and popular tool for another decade and more. We summarize the code design and fundamental data layer changes as well as efficiency improvements, new solvers, applications to quantum circuits with QuTiP-QIP, and new quantum control tools with QuTiP-QOC. Additional flexibility in the data layer underlying all “quantum objects” in QuTiP allows us to harness the power of state-of-the-art data formats and packages like JAX, CuPy, and more. We explain these new features with a series of both well-known and new examples. The code for these examples is available in a static form on GitHub ( https://github.com/qutip/qutip-paper-v5-examples ) and as continuously updated and documented notebooks in the qutip-tutorials package ( https://github.com/qutip/qutip-tutorials ).
QuTiP, the Quantum Toolbox in Python (Johansson et al., 2012, Johansson et al., 2013), has been at the forefront of open-source quantum software for the past 13 years. It is used as a research, teaching, and industrial tool, and has been downloaded millions of times by users around the world. Here we introduce the latest developments in QuTiP v5, which are set to have a large impact on the future of QuTiP and enable it to be a modern, continuously developed and popular tool for another decade and more. We summarize the code design and fundamental data layer changes as well as efficiency improvements, new solvers, applications to quantum circuits with QuTiP-QIP, and new quantum control tools with QuTiP-QOC. Additional flexibility in the data layer underlying all “quantum objects” in QuTiP allows us to harness the power of state-of-the-art data formats and packages like JAX, CuPy, and more. We explain these new features with a series of both well-known and new examples. The code for these examples is available in a static form on GitHub ( https://github.com/qutip/qutip-paper-v5-examples ) and as continuously updated and documented notebooks in the qutip-tutorials package ( https://github.com/qutip/qutip-tutorials ).
We present QuTiP (http://www.qutip.org),an object-oriented, opensource framework for solving the dynamics of open quantum systems.Written in Python, and using a combination of Cython, NumPy, SciPy, and matplotlib, QuTiP provides an environment for computational quantum mechanics that is both easy and efficient to use.Arbitrary quantum systems, including timedependent systems, may be built up from operators and states defined by a quantum object class, and then passed on to a choice of unitary or dissipative evolution solvers.Here we give an overview of the basic structure for the framework, and the techniques used in its implementation.We also present a few selected examples from current research on quantum mechanics that illustrate the strengths of the framework, as well as the types of calculations that can be performed.This framework is particularly well suited to the fields of quantum optics, superconducting circuit devices, nanomechanics, and trapped ions, while also being ideal as an educational tool.
Quantum computing takes significant place among the spheres of modern information technology. Quantum computation is usually expressed by the quantum circuit with its sequences of quantum gates. One of the practical applications of quantum computation is to use it in a web-based tool for variety of purposes. Thereby, this project aimed to create an educational simulator for studying quantum circuits with different gates, functions, and transformation rules. The tool would help students to learn the principles of quantum circuit in their courses during undergraduate study. The application was created on the Python based Django framework with the help of Python library packages especially Quantum Toolbox in Python (QuTiP) package. Major steps of simulator implementation included the creation of functions able to build a quantum circuit, to add and remove of quantum gates, apply transformation rules. The challenge appeared around the frontend functions, particularly with the Drag and Drop feature. The result of entire work on this project ended up in a web-based simulator applicable for educational purposes, which allows investigation of quantum circuit work, and quantum gates influence on the quantum circuit unitary matrix
Quantum computers are becoming a reality and numerous quantum computing applications with a near-term perspective (e.g., for finance, chemistry, machine learning, and optimization) and with a long-term perspective (e.g., for cryptography or unstructured search) are currently being investigated. However, designing and realizing potential applications for these devices in a scalable fashion requires automated, efficient, and user-friendly software tools that cater to the needs of end users, engineers, and physicists at every level of the entire quantum software stack. Many of the problems to be tackled in that regard are similar to design problems from the classical realm for which sophisticated design automation tools have been developed in the previous decades.The Munich Quantum Toolkit (MQT) is a collection of software tools for quantum computing developed by the Chair for Design Automation at the Technical University of Munich which explicitly utilizes this design automation expertise. Our overarching objective is to provide solutions for design tasks across the entire quantum software stack. This entails high-level support for end users in realizing their applications, efficient methods for the classical simulation, compilation, and verification of quantum circuits, tools for quantum error correction, support for physical design, and more. These methods are supported by corresponding data structures (such as decision diagrams or the ZX-calculus) and core methods (such as SAT encodings/solvers). All of the developed tools are available as open-source implementations and are hosted on github.com/cda-tum.Note: A live version of this document is available at mqt.readthedocs.io.
We present release 3.0 of the ALPS (Algorithms and Libraries for Physics Simulations) project, an open-source software project to develop libraries and application programs for the simulation of strongly correlated quantum lattice models such as quantum magnets, lattice bosons, and strongly correlated fermion systems. As in previous releases, development is centered on common data formats, on libraries to simplify and speed up code development, and on full-featured simulation programs that let non-experts carry out serial or parallel numerical simulations using the important algorithms for quantum lattice models: classical and quantum Monte Carlo (QMC) using non-local updates, extended-ensemble simulations, exact and full diagonalization (ED), the density matrix renormalization group (DMRG), and continuous-time QMC solvers for dynamical mean-field theory (DMFT). Major changes in release 3.0 include distribution of the pyalps binary through the Python Package Index (pip install pyalps) and through Spack for HPC systems; migration of development to GitHub with continuous integration and automated testing; relicensing of the package under the permissive MIT license; a rebuilt documentation and tutorial website, including a set of Jupyter-notebook tutorials and localized content; a broad modernization of the C++ codebase (C++17 compliance, Boost and NumPy 2.0 compatibility, and warning and dead-code cleanup) together with a major DMRG update and associated reliability and build-compatibility fixes; the removal of legacy components (the VisTrails provenance integration and the TEBD, MPS, and directed-worm-algorithm application codes); archival of release 3.0.0 with a Zenodo DOI; and a formal governance and sustainability model developed under the US National Science Foundation (NSF) POSE program. The software is available at https://alps.comp-phys.org.
Shortcuts to adiabaticity with a quantum control field — Code & data========================================================== This repository contains a Jupyter notebook and supporting data files (csv) to reproduce the numerical results and figures in our manuscript (arXiv 2508.06304), which investigates adiabatic shortcuts mediated by a quantum control field.The code implements a Landau–Zener two-level system coupled to a spectator qubit, time evolution of the full system (LZ qubit + spectator) via QuTiP, parameter sweeps (parallelized with joblib), and plotting utilities for the manuscript figures. Related publication----------------------------This code is complementary to the preprint: https://arxiv.org/abs/2508.06304. Requirements---------------------The simulations were developed for and tested on Python 3.9+. Recommended packages and minimum versions: - Python >= 3.9- numpy >= 1.22- scipy >= 1.8- matplotlib >= 3.5- qutip >= 4.6 (install a recent stable qutip; some installations require `pip install qutip` or `conda` channels)- joblib >= 1.2- tqdm >= 4.60- pandas (optional, for CSV handling)- jupyterlab / notebook (for interactive use) Running the notebook (interactive) Open the notebook with JupyterLab or Jupyter Notebook. Execute cells sequentially in the order indicated by the notebook outline.The sections “Definitions” and “Figure imports and setup” must be executed before generating any data or figures, as they define all operators, and helper functions. The notebook is organized into separate sections for each figure of the manuscript, allowing you to re-run only the figure(s) of interest. Note: Figure 4 (Density plot) is configured to load precomputed data files to reduce computational cost. To reproduce Figure 4 without recomputing the full dataset, ensure the required .csv files are downloaded and located in the same directory as the notebook. To explore different parameter regimes: Modify the relevant parameter definitions (e.g., anneal_window, g, epsilon, omega_c, x0, x0_vals, q_vals). To include dissipation of the spectator (ancilla) qubit, set the parameter kappa> 0. For questions about reproducing the figures or about parameter choices used in the paper, contact the corresponding authors listed in the preprint. If you reuse this data/code, please cite the associated preprint and this code archive.