qutip

Par mkurman · zorai

Bibliothèque de simulation de physique quantique pour les systèmes quantiques ouverts. À utiliser pour l'étude des équations maîtresses, la dynamique de Lindblad, la décohérence, l'optique quantique ou la QED en cavité. Idéale pour la recherche en physique, la dynamique des systèmes ouverts et les simulations pédagogiques. PAS pour le calcul quantique à base de circuits — utilisez qiskit, cirq ou pennylane pour les algorithmes quantiques et l'exécution sur matériel.

npx skills add https://github.com/mkurman/zorai --skill qutip

QuTiP : Quantum Toolbox in Python

Présentation générale

QuTiP fournit des outils complets pour simuler et analyser des systèmes mécaniques quantiques. Il gère à la fois les systèmes quantiques fermés (unitaires) et ouverts (dissipatifs) avec plusieurs solveurs optimisés pour différents scénarios.

Installation

uv pip install qutip

Packages optionnels pour des fonctionnalités supplémentaires :

# Traitement de l'information quantique (circuits, portes)
uv pip install qutip-qip

# Visualiseur de trajectoires quantiques
uv pip install qutip-qtrl

Démarrage rapide

from qutip import *
import numpy as np
import matplotlib.pyplot as plt

# Créer un état quantique
psi = basis(2, 0)  # état |0⟩

# Créer un opérateur
H = sigmaz()  # Hamiltonien

# Évolution temporelle
tlist = np.linspace(0, 10, 100)
result = sesolve(H, psi, tlist, e_ops=[sigmaz()])

# Tracer les résultats
plt.plot(tlist, result.expect[0])
plt.xlabel('Time')
plt.ylabel('⟨σz⟩')
plt.show()

Capacités principales

1. Objets quantiques et états

Créer et manipuler des états quantiques et des opérateurs :

# États
psi = basis(N, n)  # État de Fock |n⟩
psi = coherent(N, alpha)  # État cohérent |α⟩
rho = thermal_dm(N, n_avg)  # Matrice densité thermale

# Opérateurs
a = destroy(N)  # Opérateur d'annihilation
H = num(N)  # Opérateur nombre
sx, sy, sz = sigmax(), sigmay(), sigmaz()  # Matrices de Pauli

# Systèmes composites
psi_AB = tensor(psi_A, psi_B)  # Produit tensoriel

Voir references/core_concepts.md pour une couverture complète des objets quantiques, états, opérateurs et produits tensoriels.

2. Évolution temporelle et dynamique

Plusieurs solveurs pour différents scénarios :

# Systèmes fermés (évolution unitaire)
result = sesolve(H, psi0, tlist, e_ops=[num(N)])

# Systèmes ouverts (dissipation)
c_ops = [np.sqrt(0.1) * destroy(N)]  # Opérateurs d'effondrement
result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])

# Trajectoires quantiques (Monte Carlo)
result = mcsolve(H, psi0, tlist, c_ops, ntraj=500, e_ops=[num(N)])

Guide de sélection du solveur :

  • sesolve : États purs, évolution unitaire
  • mesolve : États mixtes, dissipation, systèmes ouverts généraux
  • mcsolve : Sauts quantiques, comptage de photons, trajectoires individuelles
  • brmesolve : Couplage faible système-bain
  • fmmesolve : Hamiltoniens périodiques en temps (Floquet)

Voir references/time_evolution.md pour la documentation détaillée des solveurs, les Hamiltoniens dépendant du temps et les options avancées.

3. Analyse et mesure

Calculer des grandeurs physiques :

# Valeurs d'espérance
n_avg = expect(num(N), psi)

# Mesures d'entropie
S = entropy_vn(rho)  # Entropie de Von Neumann
C = concurrence(rho)  # Intrication (deux qubits)

# Fidélité et distance
F = fidelity(psi1, psi2)
D = tracedist(rho1, rho2)

# Fonctions de corrélation
corr = correlation_2op_1t(H, rho0, taulist, c_ops, A, B)
w, S = spectrum_correlation_fft(taulist, corr)

# États stationnaires
rho_ss = steadystate(H, c_ops)

Voir references/analysis.md pour l'entropie, la fidélité, les mesures, les fonctions de corrélation et les calculs d'état stationnaire.

4. Visualisation

Visualiser des états quantiques et des dynamiques :

# Sphère de Bloch
b = Bloch()
b.add_states(psi)
b.show()

# Fonction de Wigner (espace des phases)
xvec = np.linspace(-5, 5, 200)
W = wigner(psi, xvec, xvec)
plt.contourf(xvec, xvec, W, 100, cmap='RdBu')

# Distribution de Fock
plot_fock_distribution(psi)

# Visualisation de matrice
hinton(rho)  # Diagramme de Hinton
matrix_histogram(H.full())  # Barres 3D

Voir references/visualization.md pour les animations de sphère de Bloch, les fonctions de Wigner, les fonctions Q et les visualisations de matrice.

5. Méthodes avancées

Techniques spécialisées pour les scénarios complexes :

# Théorie de Floquet (Hamiltoniens périodiques)
T = 2 * np.pi / w_drive
f_modes, f_energies = floquet_modes(H, T, args)
result = fmmesolve(H, psi0, tlist, c_ops, T=T, args=args)

# HEOM (non-markovien, couplage fort)
from qutip.nonmarkov.heom import HEOMSolver, BosonicBath
bath = BosonicBath(Q, ck_real, vk_real)
hsolver = HEOMSolver(H_sys, [bath], max_depth=5)
result = hsolver.run(rho0, tlist)

# Invariance permutationelle (particules identiques)
psi = dicke(N, j, m)  # États de Dicke
Jz = jspin(N, 'z')  # Opérateurs collectifs

Voir references/advanced.md pour la théorie de Floquet, HEOM, l'invariance permutationelle, les solveurs stochastiques, les superopérateurs et l'optimisation de performance.

Flux de travail courants

Simuler un oscillateur harmonique amorti

# Paramètres du système
N = 20  # Dimension de l'espace de Hilbert
omega = 1.0  # Fréquence de l'oscillateur
kappa = 0.1  # Taux de décroissance

# Hamiltonien et opérateurs d'effondrement
H = omega * num(N)
c_ops = [np.sqrt(kappa) * destroy(N)]

# État initial
psi0 = coherent(N, 3.0)

# Évolution temporelle
tlist = np.linspace(0, 50, 200)
result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])

# Visualiser
plt.plot(tlist, result.expect[0])
plt.xlabel('Time')
plt.ylabel('⟨n⟩')
plt.title('Photon Number Decay')
plt.show()

Dynamique d'intrication à deux qubits

# Créer un état de Bell
psi0 = bell_state('00')

# Déphasage local sur chaque qubit
gamma = 0.1
c_ops = [
    np.sqrt(gamma) * tensor(sigmaz(), qeye(2)),
    np.sqrt(gamma) * tensor(qeye(2), sigmaz())
]

# Suivre l'intrication
def 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)

# Calculer la concurrence pour chaque état
C_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()

Modèle de Jaynes-Cummings

# Paramètres du système
N = 10  # Espace de Fock de la cavité
wc = 1.0  # Fréquence de la cavité
wa = 1.0  # Fréquence de l'atome
g = 0.05  # Force de couplage

# Opérateurs
a = tensor(destroy(N), qeye(2))  # Cavité
sm = tensor(qeye(N), sigmam())  # Atome

# Hamiltonien (RWA)
H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())

# État initial : cavité en état cohérent, atome à l'état fondamental
psi0 = tensor(coherent(N, 2), basis(2, 0))

# Dissipation
kappa = 0.1  # Décroissance de la cavité
gamma = 0.05  # Décroissance atomique
c_ops = [np.sqrt(kappa) * a, np.sqrt(gamma) * sm]

# Observables
n_cav = a.dag() * a
n_atom = sm.dag() * sm

# Évoluer
tlist = np.linspace(0, 50, 200)
result = mesolve(H, psi0, tlist, c_ops, e_ops=[n_cav, n_atom])

# Tracer
fig, 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()

Conseils pour des simulations efficaces

  1. Tronquer les espaces de Hilbert : Utiliser la plus petite dimension qui capture la dynamique
  2. Choisir un solveur approprié : sesolve pour les états purs est plus rapide que mesolve
  3. Termes dépendant du temps : Le format string (par ex., 'cos(w*t)') est le plus rapide
  4. Stocker uniquement les données nécessaires : Utiliser e_ops au lieu de stocker tous les états
  5. Ajuster les tolérances : Équilibrer précision et temps de calcul via Options
  6. Trajectoires parallèles : mcsolve utilise automatiquement plusieurs CPU
  7. Vérifier la convergence : Faire varier ntraj, la taille de l'espace de Hilbert et les tolérances

Dépannage

Problèmes de mémoire : Réduire la dimension de l'espace de Hilbert, utiliser l'option store_final_state ou considérer les méthodes de Krylov

Simulations lentes : Utiliser la dépendance temporelle basée sur des strings, augmenter légèrement les tolérances ou essayer method='bdf' pour les problèmes raides

Instabilités numériques : Diminuer les pas de temps (option nsteps), augmenter les tolérances ou vérifier que l'Hamiltonien/les opérateurs sont bien définis

Erreurs d'import : Vérifier que QuTiP est installé correctement ; les portes quantiques nécessitent le package qutip-qip

Références

Ce skill inclut une documentation de référence détaillée :

  • references/core_concepts.md : Objets quantiques, états, opérateurs, produits tensoriels, systèmes composites
  • references/time_evolution.md : Tous les solveurs (sesolve, mesolve, mcsolve, brmesolve, etc.), Hamiltoniens dépendant du temps, options des solveurs
  • references/visualization.md : Sphère de Bloch, fonctions de Wigner, fonctions Q, distributions de Fock, tracés de matrices
  • references/analysis.md : Valeurs d'espérance, entropie, fidélité, mesures d'intrication, fonctions de corrélation, états stationnaires
  • references/advanced.md : Théorie de Floquet, HEOM, invariance permutationelle, méthodes stochastiques, superopérateurs, conseils de performance

Ressources externes

Skills similaires

cirq
mkurman / zorai

Concevoir, simuler et exécuter des circuits quantiques avec Python via Cirq.

309
eval-bootstrap
datadog-labs / agent-skills

Générer du code d'évaluation Python à partir de traces de production LLM Datadog.

126
qiskit
mkurman / zorai

Construire, optimiser et exécuter des circuits quantiques sur simulateurs ou hardware réel.

309
ad-model-onboard
nvidia / skills

Automatiser l'intégration de modèles HuggingFace dans AutoDeploy avec tests et rapport.

1 033
claude-api
anthropics / skills

Construire des applications LLM avec Claude via le SDK officiel adapté au langage.

146 952