⚠️

重要前提

安装AI Skills的关键前提是：必须科学上网，且开启TUN模式，这一点至关重要，直接决定安装能否顺利完成，在此郑重提醒三遍：科学上网，科学上网，科学上网。查看完整安装教程 →

QuTiP量子计算Python库教程：安装、模拟与可视化量子系统

qutip by k-dense-ai/claude-scientific-skills

115 周安装量

17,800 GitHub Stars

GitHub

安装命令

npx skills add https://github.com/k-dense-ai/claude-scientific-skills --skill qutip

Python Web框架科研工具量子计算

🇨🇳中文介绍

QuTiP: Python 中的量子工具箱

概述

QuTiP 提供了用于模拟和分析量子力学系统的全面工具。它处理封闭（幺正）和开放（耗散）量子系统，并针对不同场景优化了多种求解器。

安装

uv pip install qutip

用于附加功能的可选包：

# 量子信息处理（电路、门）
uv pip install qutip-qip

# 量子轨迹查看器
uv pip install qutip-qtrl

快速入门

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

# 创建量子态
psi = basis(2, 0)  # |0⟩ 态

# 创建算符
H = sigmaz()  # 哈密顿量

# 时间演化
tlist = np.linspace(0, 10, 100)
result = sesolve(H, psi, tlist, e_ops=[sigmaz()])

# 绘制结果
plt.plot(tlist, result.expect[0])
plt.xlabel('时间')
plt.ylabel('⟨σz⟩')
plt.show()

核心功能

1. 量子对象与态

创建和操作量子态与算符：

# 态
psi = basis(N, n)  # Fock 态 |n⟩
psi = coherent(N, alpha)  # 相干态 |α⟩
rho = thermal_dm(N, n_avg)  # 热密度矩阵

# 算符
a = destroy(N)  # 湮灭算符
H = num(N)  # 粒子数算符
sx, sy, sz = sigmax(), sigmay(), sigmaz()  # 泡利矩阵

# 复合系统
psi_AB = tensor(psi_A, psi_B)  # 张量积

广告位招租

在这里展示您的产品或服务

触达数万 AI 开发者，精准高效

联系我们

2. 时间演化与动力学

针对不同场景的多种求解器：

# 封闭系统（幺正演化）
result = sesolve(H, psi0, tlist, e_ops=[num(N)])

# 开放系统（耗散）
c_ops = [np.sqrt(0.1) * destroy(N)]  # 坍缩算符
result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])

# 量子轨迹（蒙特卡洛）
result = mcsolve(H, psi0, tlist, c_ops, ntraj=500, e_ops=[num(N)])

求解器选择指南：

sesolve: 纯态，幺正演化
mesolve: 混合态，耗散，一般开放系统
mcsolve: 量子跳跃，光子计数，单个轨迹
brmesolve: 弱系统-浴耦合
fmmesolve: 时间周期哈密顿量（Floquet）

参见 references/time_evolution.md 以获取详细的求解器文档、时间相关哈密顿量和高级选项。

# 期望值
n_avg = expect(num(N), psi)

# 熵度量
S = entropy_vn(rho)  # Von Neumann 熵
C = concurrence(rho)  # 纠缠度（两个量子比特）

# 保真度与距离
F = fidelity(psi1, psi2)
D = tracedist(rho1, rho2)

# 关联函数
corr = correlation_2op_1t(H, rho0, taulist, c_ops, A, B)
w, S = spectrum_correlation_fft(taulist, corr)

# 稳态
rho_ss = steadystate(H, c_ops)

参见 references/analysis.md 以获取关于熵、保真度、测量、关联函数和稳态计算的详细信息。

可视化量子态和动力学：

# Bloch 球
b = Bloch()
b.add_states(psi)
b.show()

# Wigner 函数（相空间）
xvec = np.linspace(-5, 5, 200)
W = wigner(psi, xvec, xvec)
plt.contourf(xvec, xvec, W, 100, cmap='RdBu')

# Fock 分布
plot_fock_distribution(psi)

# 矩阵可视化
hinton(rho)  # Hinton 图
matrix_histogram(H.full())  # 3D 条形图

参见 references/visualization.md 以获取关于 Bloch 球动画、Wigner 函数、Q-函数和矩阵可视化的信息。

针对复杂场景的专门技术：

# Floquet 理论（周期哈密顿量）
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（非马尔可夫，强耦合）
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)

# 置换不变性（全同粒子）
psi = dicke(N, j, m)  # Dicke 态
Jz = jspin(N, 'z')  # 集体算符

参见 references/advanced.md 以获取关于 Floquet 理论、HEOM、置换不变性、随机求解器、超算符和性能优化的信息。

模拟阻尼谐振子

# 系统参数
N = 20  # Hilbert 空间维度
omega = 1.0  # 振荡器频率
kappa = 0.1  # 衰减率

# 哈密顿量和坍缩算符
H = omega * num(N)
c_ops = [np.sqrt(kappa) * destroy(N)]

# 初始态
psi0 = coherent(N, 3.0)

# 时间演化
tlist = np.linspace(0, 50, 200)
result = mesolve(H, psi0, tlist, c_ops, e_ops=[num(N)])

# 可视化
plt.plot(tlist, result.expect[0])
plt.xlabel('时间')
plt.ylabel('⟨n⟩')
plt.title('光子数衰减')
plt.show()

双量子比特纠缠动力学

# 创建 Bell 态
psi0 = bell_state('00')

# 每个量子比特上的局域退相位
gamma = 0.1
c_ops = [
    np.sqrt(gamma) * tensor(sigmaz(), qeye(2)),
    np.sqrt(gamma) * tensor(qeye(2), sigmaz())
]

# 跟踪纠缠
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)

# 计算每个态的 concurrence
C_t = [concurrence(state.proj()) for state in result.states]

plt.plot(tlist, C_t)
plt.xlabel('时间')
plt.ylabel('Concurrence')
plt.title('纠缠衰减')
plt.show()

Jaynes-Cummings 模型

# 系统参数
N = 10  # 腔 Fock 空间
wc = 1.0  # 腔频率
wa = 1.0  # 原子频率
g = 0.05  # 耦合强度

# 算符
a = tensor(destroy(N), qeye(2))  # 腔
sm = tensor(qeye(N), sigmam())  # 原子

# 哈密顿量（RWA）
H = wc * a.dag() * a + wa * sm.dag() * sm + g * (a.dag() * sm + a * sm.dag())

# 初始态：腔处于相干态，原子处于基态
psi0 = tensor(coherent(N, 2), basis(2, 0))

# 耗散
kappa = 0.1  # 腔衰减
gamma = 0.05  # 原子衰减
c_ops = [np.sqrt(kappa) * a, np.sqrt(gamma) * sm]

# 可观测量
n_cav = a.dag() * a
n_atom = sm.dag() * sm

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

# 绘图
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('时间')
plt.tight_layout()
plt.show()

截断 Hilbert 空间：使用能捕捉动力学的最小维度
选择合适的求解器：对于纯态，sesolve 比 mesolve 更快
时间相关项：字符串格式（例如 'cos(w*t)'）是最快的
仅存储所需数据：使用 e_ops 而不是存储所有态
调整容差：通过 Options 平衡精度与计算时间
并行轨迹：mcsolve 自动使用多个 CPU
检查收敛性：改变 ntraj、Hilbert 空间大小和容差

内存问题：减小 Hilbert 空间维度，使用 store_final_state 选项，或考虑 Krylov 方法

模拟缓慢：使用基于字符串的时间依赖性，稍微增加容差，或对于刚性问题尝试 method='bdf'

数值不稳定：减小时间步长（nsteps 选项），增加容差，或检查哈密顿量/算符是否正确定义

导入错误：确保 QuTiP 正确安装；量子门需要 qutip-qip 包

此技能包含详细的参考文档：

references/core_concepts.md：量子对象、态、算符、张量积、复合系统
references/time_evolution.md：所有求解器（sesolve、mesolve、mcsolve、brmesolve 等）、时间相关哈密顿量、求解器选项
references/visualization.md：Bloch 球、Wigner 函数、Q-函数、Fock 分布、矩阵图
references/analysis.md：期望值、熵、保真度、纠缠度量、关联函数、稳态
references/advanced.md：Floquet 理论、HEOM、置换不变性、随机方法、超算符、性能提示

🇺🇸English

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

uv pip install qutip

Optional packages for additional functionality:

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

# Quantum trajectory viewer
uv pip install qutip-qtrl

Quick Start

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

# Create quantum state
psi = basis(2, 0)  # |0⟩ state

# Create operator
H = sigmaz()  # Hamiltonian

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

# Plot results
plt.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:

# States
psi = basis(N, n)  # Fock state |n⟩
psi = coherent(N, alpha)  # Coherent state |α⟩
rho = thermal_dm(N, n_avg)  # Thermal density matrix

# Operators
a = destroy(N)  # Annihilation operator
H = num(N)  # Number operator
sx, sy, sz = sigmax(), sigmay(), sigmaz()  # Pauli matrices

# Composite systems
psi_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:

# 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 operators
result = 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:

# Expectation values
n_avg = expect(num(N), psi)

# Entropy measures
S = entropy_vn(rho)  # Von Neumann entropy
C = concurrence(rho)  # Entanglement (two qubits)

# Fidelity and distance
F = fidelity(psi1, psi2)
D = tracedist(rho1, rho2)

# Correlation functions
corr = correlation_2op_1t(H, rho0, taulist, c_ops, A, B)
w, S = spectrum_correlation_fft(taulist, corr)

# Steady states
rho_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:

# Bloch sphere
b = 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 distribution
plot_fock_distribution(psi)

# Matrix visualization
hinton(rho)  # Hinton diagram
matrix_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:

# Floquet theory (periodic Hamiltonians)
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-Markovian, strong coupling)
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)

# Permutational invariance (identical particles)
psi = dicke(N, j, m)  # Dicke states
Jz = 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

# System parameters
N = 20  # Hilbert space dimension
omega = 1.0  # Oscillator frequency
kappa = 0.1  # Decay rate

# Hamiltonian and collapse operators
H = omega * num(N)
c_ops = [np.sqrt(kappa) * destroy(N)]

# Initial state
psi0 = coherent(N, 3.0)

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

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

Two-Qubit Entanglement Dynamics

# Create Bell state
psi0 = bell_state('00')

# Local dephasing on each qubit
gamma = 0.1
c_ops = [
    np.sqrt(gamma) * tensor(sigmaz(), qeye(2)),
    np.sqrt(gamma) * tensor(qeye(2), sigmaz())
]

# Track entanglement
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)

# Compute concurrence for each state
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()

Jaynes-Cummings Model

# System parameters
N = 10  # Cavity Fock space
wc = 1.0  # Cavity frequency
wa = 1.0  # Atom frequency
g = 0.05  # Coupling strength

# Operators
a = tensor(destroy(N), qeye(2))  # Cavity
sm = 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 state
psi0 = tensor(coherent(N, 2), basis(2, 0))

# Dissipation
kappa = 0.1  # Cavity decay
gamma = 0.05  # Atomic decay
c_ops = [np.sqrt(kappa) * a, np.sqrt(gamma) * sm]

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

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

# Plot
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()

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

Weekly Installs

Repository

k-dense-ai/clau…c-skills

GitHub Stars

17.3K

First Seen

Jan 20, 2026

Security Audits

Gen Agent Trust HubPass SocketPass SnykPass

Installed on

opencode48

codex47

gemini-cli46

cursor45

claude-code44

github-copilot43

marimo-batch：Python批处理任务神器，Pydantic声明式数据源与UI/CLI双模式

973 周安装