Qutip

zLanqing/codex-claude-academic-skills/scientific-toolkit-skill/references/scientific-skills/qutip

by zLanqing7ed6377f0efb6a38951b48ef03b19d996e454b1fBSD-3-Clause licenseListed Oct 9, 2026Updated Oct 9, 2026

Quantum physics simulation library for open quantum systems. Use when studying master equations, Lindblad dynamics, decoherence, quantum optics, or cavity QED. Best for physics research, open system dynamics, and educational simulations. NOT for circuit-based quantum computing—use qiskit, cirq, or pennylane for quantum algorithms and hardware execution.

Instructions onlyResearch & Analysis Learning & Education

AI-generated overview

Guides quantum physics simulation with QuTiP for open and closed quantum systems, solvers, and analysis.

What it does: This skill provides instructions and reference material for using the QuTiP Python library to simulate quantum mechanical systems. It covers creating quantum states and operators, running time-evolution solvers such as sesolve, mesolve and mcsolve, and computing quantities like entropy, fidelity, correlation functions and steady states. It also describes visualization options including Bloch spheres, Wigner functions and matrix plots, plus advanced methods such as Floquet theory and HEOM.
When to use it: Use it when studying master equations, Lindblad dynamics, decoherence, quantum optics or cavity QED. It is intended for physics research, open-system dynamics and educational simulations. It is not meant for circuit-based quantum computing, where the document points to qiskit, cirq or pennylane instead.
Requirements: Requires the QuTiP Python package, installed for example with uv pip install qutip, along with NumPy and Matplotlib for the examples. Optional packages qutip-qip and qutip-qtrl add quantum information processing and trajectory viewing. The skill ships no scripts; it is instructions plus reference documents.

QuTiP: Quantum Toolbox in Python

Overview

QuTiP provides comprehensive tools for simulating and analyzing quantum mechanical systems. It handles both closed (unitary) and open (dissipative) quantum systems with multiple solvers optimized for different scenarios.

Installation

Optional packages for additional functionality:

bash

# Quantum information processing (circuits, gates)uv pip install qutip-qip
# Quantum trajectory vieweruv pip install qutip-qtrl

# Quantum information processing (circuits, gates)uv pip install qutip-qip
# Quantum trajectory vieweruv pip install qutip-qtrl

Quick Start

python

from qutip import *import numpy as npimport matplotlib.pyplot as plt
# Create quantum statepsi = basis(2, 0)  # |0⟩ state
# Create operatorH = sigmaz()  # Hamiltonian
# Time evolutiontlist = np.linspace(0, 10, 100)result = sesolve(H, psi, tlist, e_ops=[sigmaz()])
# Plot resultsplt.plot(tlist, result.expect[0])plt.xlabel('Time')plt.ylabel('⟨σz⟩')plt.show()

from qutip import *import numpy as npimport matplotlib.pyplot as plt
# Create quantum statepsi = basis(2, 0)  # |0⟩ state
# Create operatorH = sigmaz()  # Hamiltonian
# Time evolutiontlist = np.linspace(0, 10, 100)result = sesolve(H, psi, tlist, e_ops=[sigmaz()])
# Plot resultsplt.plot(tlist, result.expect[0])plt.xlabel('Time')plt.ylabel('⟨σz⟩')plt.show()

Core Capabilities

1. Quantum Objects and States

Create and manipulate quantum states and operators:

python

# Statespsi = basis(N, n)  # Fock state |n⟩psi = coherent(N, alpha)  # Coherent state |α⟩rho = thermal_dm(N, n_avg)  # Thermal density matrix
# Operatorsa = destroy(N)  # Annihilation operatorH = num(N)  # Number operatorsx, sy, sz = sigmax(), sigmay(), sigmaz()  # Pauli matrices
# Composite systemspsi_AB = tensor(psi_A, psi_B)  # Tensor product

# Statespsi = basis(N, n)  # Fock state |n⟩psi = coherent(N, alpha)  # Coherent state |α⟩rho = thermal_dm(N, n_avg)  # Thermal density matrix
# Operatorsa = destroy(N)  # Annihilation operatorH = num(N)  # Number operatorsx, sy, sz = sigmax(), sigmay(), sigmaz()  # Pauli matrices
# Composite systemspsi_AB = tensor(psi_A, psi_B)  # Tensor product

See references/core_concepts.md for comprehensive coverage of quantum objects, states, operators, and tensor products.

2. Time Evolution and Dynamics

Multiple solvers for different scenarios:

python

# Closed systems (unitary evolution)result = sesolve(H, psi0, tlist, e_ops=[num(N)])
# Open systems (dissipation)c_ops = [np.sqrt(0.1) * destroy(N)]  # Collapse operatorsresult = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])
# Quantum trajectories (Monte Carlo)result = mcsolve(H, psi0, tlist, c_ops, ntraj=500, e_ops=[num(N)])

# Closed systems (unitary evolution)result = sesolve(H, psi0, tlist, e_ops=[num(N)])
# Open systems (dissipation)c_ops = [np.sqrt(0.1) * destroy(N)]  # Collapse operatorsresult = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])
# Quantum trajectories (Monte Carlo)result = mcsolve(H, psi0, tlist, c_ops, ntraj=500, e_ops=[num(N)])

Solver selection guide:

sesolve: Pure states, unitary evolution
mesolve: Mixed states, dissipation, general open systems
mcsolve: Quantum jumps, photon counting, individual trajectories
brmesolve: Weak system-bath coupling
fmmesolve: Time-periodic Hamiltonians (Floquet)

See references/time_evolution.md for detailed solver documentation, time-dependent Hamiltonians, and advanced options.

3. Analysis and Measurement

Compute physical quantities:

python

# Expectation valuesn_avg = expect(num(N), psi)
# Entropy measuresS = entropy_vn(rho)  # Von Neumann entropyC = concurrence(rho)  # Entanglement (two qubits)
# Fidelity and distanceF = fidelity(psi1, psi2)D = tracedist(rho1, rho2)
# Correlation functionscorr = correlation_2op_1t(H, rho0, taulist, c_ops, A, B)w, S = spectrum_correlation_fft(taulist, corr)
# Steady statesrho_ss = steadystate(H, c_ops)

# Expectation valuesn_avg = expect(num(N), psi)
# Entropy measuresS = entropy_vn(rho)  # Von Neumann entropyC = concurrence(rho)  # Entanglement (two qubits)
# Fidelity and distanceF = fidelity(psi1, psi2)D = tracedist(rho1, rho2)
# Correlation functionscorr = correlation_2op_1t(H, rho0, taulist, c_ops, A, B)w, S = spectrum_correlation_fft(taulist, corr)
# Steady statesrho_ss = steadystate(H, c_ops)

See references/analysis.md for entropy, fidelity, measurements, correlation functions, and steady state calculations.

4. Visualization

Visualize quantum states and dynamics:

python

# Bloch sphereb = Bloch()b.add_states(psi)b.show()
# Wigner function (phase space)xvec = np.linspace(-5, 5, 200)W = wigner(psi, xvec, xvec)plt.contourf(xvec, xvec, W, 100, cmap='RdBu')
# Fock distributionplot_fock_distribution(psi)
# Matrix visualizationhinton(rho)  # Hinton diagrammatrix_histogram(H.full())  # 3D bars

# Bloch sphereb = Bloch()b.add_states(psi)b.show()
# Wigner function (phase space)xvec = np.linspace(-5, 5, 200)W = wigner(psi, xvec, xvec)plt.contourf(xvec, xvec, W, 100, cmap='RdBu')
# Fock distributionplot_fock_distribution(psi)
# Matrix visualizationhinton(rho)  # Hinton diagrammatrix_histogram(H.full())  # 3D bars

See references/visualization.md for Bloch sphere animations, Wigner functions, Q-functions, and matrix visualizations.

5. Advanced Methods

Specialized techniques for complex scenarios:

python

# Floquet theory (periodic Hamiltonians)T = 2 * np.pi / w_drivef_modes, f_energies = floquet_modes(H, T, args)result = fmmesolve(H, psi0, tlist, c_ops, T=T, args=args)
# HEOM (non-Markovian, strong coupling)from qutip.nonmarkov.heom import HEOMSolver, BosonicBathbath = BosonicBath(Q, ck_real, vk_real)hsolver = HEOMSolver(H_sys, [bath], max_depth=5)result = hsolver.run(rho0, tlist)
# Permutational invariance (identical particles)psi = dicke(N, j, m)  # Dicke statesJz = jspin(N, 'z')  # Collective operators

# Floquet theory (periodic Hamiltonians)T = 2 * np.pi / w_drivef_modes, f_energies = floquet_modes(H, T, args)result = fmmesolve(H, psi0, tlist, c_ops, T=T, args=args)
# HEOM (non-Markovian, strong coupling)from qutip.nonmarkov.heom import HEOMSolver, BosonicBathbath = BosonicBath(Q, ck_real, vk_real)hsolver = HEOMSolver(H_sys, [bath], max_depth=5)result = hsolver.run(rho0, tlist)
# Permutational invariance (identical particles)psi = dicke(N, j, m)  # Dicke statesJz = jspin(N, 'z')  # Collective operators

See references/advanced.md for Floquet theory, HEOM, permutational invariance, stochastic solvers, superoperators, and performance optimization.

Common Workflows

Simulating a Damped Harmonic Oscillator

python

# System parametersN = 20  # Hilbert space dimensionomega = 1.0  # Oscillator frequencykappa = 0.1  # Decay rate
# Hamiltonian and collapse operatorsH = omega * num(N)c_ops = [np.sqrt(kappa) * destroy(N)]
# Initial statepsi0 = coherent(N, 3.0)
# Time evolutiontlist = np.linspace(0, 50, 200)result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])
# Visualizeplt.plot(tlist, result.expect[0])plt.xlabel('Time')plt.ylabel('⟨n⟩')plt.title('Photon Number Decay')plt.show()

# System parametersN = 20  # Hilbert space dimensionomega = 1.0  # Oscillator frequencykappa = 0.1  # Decay rate
# Hamiltonian and collapse operatorsH = omega * num(N)c_ops = [np.sqrt(kappa) * destroy(N)]
# Initial statepsi0 = coherent(N, 3.0)
# Time evolutiontlist = np.linspace(0, 50, 200)result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])
# Visualizeplt.plot(tlist, result.expect[0])plt.xlabel('Time')plt.ylabel('⟨n⟩')plt.title('Photon Number Decay')plt.show()

Two-Qubit Entanglement Dynamics

python

# Create Bell statepsi0 = bell_state('00')
# Local dephasing on each qubitgamma = 0.1c_ops = [    np.sqrt(gamma) * tensor(sigmaz(), qeye(2)),    np.sqrt(gamma) * tensor(qeye(2), sigmaz())]
# Track entanglementdef compute_concurrence(t, psi):    rho = ket2dm(psi) if psi.isket else psi    return concurrence(rho)
tlist = np.linspace(0, 10, 100)result = mesolve(qeye([2, 2]), psi0, tlist, c_ops)
# Compute concurrence for each stateC_t = [concurrence(state.proj()) for state in result.states]
plt.plot(tlist, C_t)plt.xlabel('Time')plt.ylabel('Concurrence')plt.title('Entanglement Decay')plt.show()

# Create Bell statepsi0 = bell_state('00')
# Local dephasing on each qubitgamma = 0.1c_ops = [    np.sqrt(gamma) * tensor(sigmaz(), qeye(2)),    np.sqrt(gamma) * tensor(qeye(2), sigmaz())]
# Track entanglementdef compute_concurrence(t, psi):    rho = ket2dm(psi) if psi.isket else psi    return concurrence(rho)
tlist = np.linspace(0, 10, 100)result = mesolve(qeye([2, 2]), psi0, tlist, c_ops)
# Compute concurrence for each stateC_t = [concurrence(state.proj()) for state in result.states]
plt.plot(tlist, C_t)plt.xlabel('Time')plt.ylabel('Concurrence')plt.title('Entanglement Decay')plt.show()

Jaynes-Cummings Model

python

# System parametersN = 10  # Cavity Fock spacewc = 1.0  # Cavity frequencywa = 1.0  # Atom frequencyg = 0.05  # Coupling strength
# Operatorsa = tensor(destroy(N), qeye(2))  # Cavitysm = tensor(qeye(N), sigmam())  # Atom
# Hamiltonian (RWA)H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
# Initial state: cavity in coherent state, atom in ground statepsi0 = tensor(coherent(N, 2), basis(2, 0))
# Dissipationkappa = 0.1  # Cavity decaygamma = 0.05  # Atomic decayc_ops = [np.sqrt(kappa) * a, np.sqrt(gamma) * sm]
# Observablesn_cav = a.dag() * an_atom = sm.dag() * sm
# Evolvetlist = np.linspace(0, 50, 200)result = mesolve(H, psi0, tlist, c_ops, e_ops=[n_cav, n_atom])
# Plotfig, axes = plt.subplots(2, 1, figsize=(8, 6), sharex=True)axes[0].plot(tlist, result.expect[0])axes[0].set_ylabel('⟨n_cavity⟩')axes[1].plot(tlist, result.expect[1])axes[1].set_ylabel('⟨n_atom⟩')axes[1].set_xlabel('Time')plt.tight_layout()plt.show()

# System parametersN = 10  # Cavity Fock spacewc = 1.0  # Cavity frequencywa = 1.0  # Atom frequencyg = 0.05  # Coupling strength
# Operatorsa = tensor(destroy(N), qeye(2))  # Cavitysm = tensor(qeye(N), sigmam())  # Atom
# Hamiltonian (RWA)H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())
# Initial state: cavity in coherent state, atom in ground statepsi0 = tensor(coherent(N, 2), basis(2, 0))
# Dissipationkappa = 0.1  # Cavity decaygamma = 0.05  # Atomic decayc_ops = [np.sqrt(kappa) * a, np.sqrt(gamma) * sm]
# Observablesn_cav = a.dag() * an_atom = sm.dag() * sm
# Evolvetlist = np.linspace(0, 50, 200)result = mesolve(H, psi0, tlist, c_ops, e_ops=[n_cav, n_atom])
# Plotfig, axes = plt.subplots(2, 1, figsize=(8, 6), sharex=True)axes[0].plot(tlist, result.expect[0])axes[0].set_ylabel('⟨n_cavity⟩')axes[1].plot(tlist, result.expect[1])axes[1].set_ylabel('⟨n_atom⟩')axes[1].set_xlabel('Time')plt.tight_layout()plt.show()

Tips for Efficient Simulations

Truncate Hilbert spaces: Use smallest dimension that captures dynamics
Choose appropriate solver: sesolve for pure states is faster than mesolve
Time-dependent terms: String format (e.g., 'cos(w*t)') is fastest
Store only needed data: Use e_ops instead of storing all states
Adjust tolerances: Balance accuracy with computation time via Options
Parallel trajectories: mcsolve automatically uses multiple CPUs
Check convergence: Vary ntraj, Hilbert space size, and tolerances

Troubleshooting

Memory issues: Reduce Hilbert space dimension, use store_final_state option, or consider Krylov methods

Slow simulations: Use string-based time-dependence, increase tolerances slightly, or try method='bdf' for stiff problems

Numerical instabilities: Decrease time steps (nsteps option), increase tolerances, or check Hamiltonian/operators are properly defined

Import errors: Ensure QuTiP is installed correctly; quantum gates require qutip-qip package

References

This skill includes detailed reference documentation:

references/core_concepts.md: Quantum objects, states, operators, tensor products, composite systems
references/time_evolution.md: All solvers (sesolve, mesolve, mcsolve, brmesolve, etc.), time-dependent Hamiltonians, solver options
references/visualization.md: Bloch sphere, Wigner functions, Q-functions, Fock distributions, matrix plots
references/analysis.md: Expectation values, entropy, fidelity, entanglement measures, correlation functions, steady states
references/advanced.md: Floquet theory, HEOM, permutational invariance, stochastic methods, superoperators, performance tips

External Resources

Documentation: https://qutip.readthedocs.io/
Tutorials: https://qutip.org/qutip-tutorials/
API Reference: https://qutip.readthedocs.io/en/stable/apidoc/apidoc.html
GitHub: https://github.com/qutip/qutip

Source and attribution

Source:zLanqing/codex-claude-academic-skillsinscientific-toolkit-skill/references/scientific-skills/qutipat commit7ed6377

License: BSD-3-Clause license

Content belongs to its original authors. SourceWeft indexes it from a public repository.

Report or request removal

Qutip

QuTiP: Quantum Toolbox in Python

Overview

Installation

Quick Start

Core Capabilities

1. Quantum Objects and States

2. Time Evolution and Dynamics

3. Analysis and Measurement

4. Visualization

5. Advanced Methods

Common Workflows

Simulating a Damped Harmonic Oscillator

Two-Qubit Entanglement Dynamics

Jaynes-Cummings Model

Tips for Efficient Simulations

Troubleshooting

References

External Resources

Source and attribution

More from zLanqing/codex-claude-academic-skills

Sympy

Statsmodels

Seaborn

Scikit Learn

Pymoo

Networkx

More in Research & Analysis

Sector Overview

Sector Overview

Idea Generation

Competitive Analysis

Equity Research

Sector Overview