SymPy 1.13 中文文档（二十九）

原文：docs.sympy.org/latest/index.html

物理

原文：docs.sympy.org/latest/reference/public/physics/index.html

一个帮助解决物理问题的模块。

氢波函数
矩阵
泡利代数
一维量子谐振子
三维量子谐振子
二次量子化
Wigner 符号
单位系统
- 单位系统背后的哲学
- 更多例子
- 维度与维度系统
- 单位前缀
- 单位与单位系统
- 物理量
高能物理
物理向量模块
- 向量与参考框架
- 向量：运动学
- 物理/向量模块的潜在问题/高级主题/未来功能
- 标量和向量场功能
- 物理向量 API
  - 基础课程
  - 运动学（文档字符串）
  - 打印（文档字符串）
  - 基本函数（文档字符串）
  - 基本场函数的文档字符串
经典力学
- 物理/力学中的质量、惯性、粒子和刚体
- 凯恩力学中的方法
- 拉格朗日力学中的方法
- 物理/力学中的关节框架
- 物理/力学中的符号系统
- 物理/力学中的线性化
  - 非最小坐标摆
- 物理/力学示例
  - 滚动盘
    - 使用 Kane 方法的滚动盘
    - 滚动盘，使用 Kane 方法和约束力
    - 使用 Lagrange 方法的滚动盘
  - 自行车
  - 非最小坐标摆
  - 多自由度完整系统
  - 四杆连杆
- 物理/力学中的潜在问题/高级主题/未来特性
- 物理/力学参考
- Autolev 解析器
- SymPy 力学对 Autolev 用户
- 力学 API 参考
  - 物体、惯性、载荷及其他函数（文档字符串）
  - Kane 方法与 Lagrange 方法（文档字符串）
  - 关节框架（文档字符串）
  - 系统（文档字符串）
  - 线性化（文档字符串）
  - 表达式操作（文档字符串）
  - 打印（文档字符串）
  - 路径（文档字符串）
  - 致动器（文档字符串）
  - 包装几何（文档字符串）
  - 已弃用类（文档字符串）
生物力学
- 生物力学 API 参考
  - 肌腱肌腱（文档字符串）
  - 激活（文档字符串）
  - 曲线（文档字符串）
量子力学
- 反对易子
- Clebsch-Gordan 系数
- 对易子
- 常数
- 达格尔算符
- 内积
- 张量积
- 笛卡尔算符和态
- 希尔伯特空间
- 算符
- 算符/态辅助函数
- Qapply
- 表示
- 自旋
- 状态
- 电路绘图
- 门
- 格罗弗算法
- 傅里叶变换
- 量子比特
- 肖尔算法
- 盒中的粒子
光学模块
- 高斯光学
- 介质
- 偏振
- 实用工具
- 波
控制模块
- 控制
- 控制 API
- 控制系统图
连续介质力学
- 梁（文档字符串）
- 使用奇异函数解决梁弯曲问题
- 桁架（文档字符串）
- 电缆（文档字符串）

氢波函数

原文链接：docs.sympy.org/latest/modules/physics/hydrogen.html

sympy.physics.hydrogen.E_nl(n, Z=1)

返回状态 (n, l) 的能量，以 Hartree 原子单位表示。

能量不依赖于“l”。

参数：

n : 整数

主量子数，是一个整数，可能的取值为 1, 2, 3, 4,…

Z :

原子序数（氢为 1，氦为 2，…）

示例

>>> from sympy.physics.hydrogen import E_nl
>>> from sympy.abc import n, Z
>>> E_nl(n, Z)
-Z**2/(2*n**2)
>>> E_nl(1)
-1/2
>>> E_nl(2)
-1/8
>>> E_nl(3)
-1/18
>>> E_nl(3, 47)
-2209/18

sympy.physics.hydrogen.E_nl_dirac(n, l, spin_up=True, Z=1, c=137.035999037000)

返回状态（n, l, 自旋）的相对论能量，以 Hartree 原子单位表示。

能量是通过狄拉克方程计算的。未包括静止质能。

参数：

n : 整数

主量子数，是一个整数，可能的取值为 1, 2, 3, 4,…

l : 整数

l 是角动量量子数，其取值范围从 0 到n-1。

spin_up :

如果电子自旋为向上（默认），则为真；否则为向下。

Z :

原子序数（氢为 1，氦为 2，…）

c :

光速，以原子单位表示。默认值为 137.035999037，取自arxiv.org/abs/1012.3627

示例

>>> from sympy.physics.hydrogen import E_nl_dirac
>>> E_nl_dirac(1, 0)
-0.500006656595360

>>> E_nl_dirac(2, 0)
-0.125002080189006
>>> E_nl_dirac(2, 1)
-0.125000416028342
>>> E_nl_dirac(2, 1, False)
-0.125002080189006

>>> E_nl_dirac(3, 0)
-0.0555562951740285
>>> E_nl_dirac(3, 1)
-0.0555558020932949
>>> E_nl_dirac(3, 1, False)
-0.0555562951740285
>>> E_nl_dirac(3, 2)
-0.0555556377366884
>>> E_nl_dirac(3, 2, False)
-0.0555558020932949

sympy.physics.hydrogen.Psi_nlm(n, l, m, r, phi, theta, Z=1)

返回氢波函数 psi_{nlm}。它是径向波函数 R_{nl} 和球谐函数 Y_{l}^{m} 的乘积。

参数：

n : 整数

主量子数，是一个整数，可能的取值为 1, 2, 3, 4,…

l : 整数

l 是角动量量子数，其取值范围从 0 到n-1。

m : 整数

m 是磁量子数，其取值范围从-l到l。

r :

径向坐标

phi :

方位角

theta :

极角

Z :

原子序数（氢为 1，氦为 2，…）

所有单位均为 Hartree 原子单位。

示例

>>> from sympy.physics.hydrogen import Psi_nlm
>>> from sympy import Symbol
>>> r=Symbol("r", positive=True)
>>> phi=Symbol("phi", real=True)
>>> theta=Symbol("theta", real=True)
>>> Z=Symbol("Z", positive=True, integer=True, nonzero=True)
>>> Psi_nlm(1,0,0,r,phi,theta,Z)
Z**(3/2)*exp(-Z*r)/sqrt(pi)
>>> Psi_nlm(2,1,1,r,phi,theta,Z)
-Z**(5/2)*r*exp(I*phi)*exp(-Z*r/2)*sin(theta)/(8*sqrt(pi))

对氢波函数 psi_{nlm} 的绝对平方积分得到 1。

氢波函数 Psi_nlm 的归一化为：

>>> from sympy import integrate, conjugate, pi, oo, sin
>>> wf=Psi_nlm(2,1,1,r,phi,theta,Z)
>>> abs_sqrd=wf*conjugate(wf)
>>> jacobi=r**2*sin(theta)
>>> integrate(abs_sqrd*jacobi, (r,0,oo), (phi,0,2*pi), (theta,0,pi))
1

sympy.physics.hydrogen.R_nl(n, l, r, Z=1)

返回氢原子径向波函数 R_{nl}。

参数：

n : 整数

主量子数，是一个整数，可能的取值为 1, 2, 3, 4,…

l : 整数

l 是角动量量子数，其取值范围从 0 到n-1。

r :

径向坐标。

Z :

原子序数（氢为 1，氦为 2，…）

所有单位均为 Hartree 原子单位。

示例

>>> from sympy.physics.hydrogen import R_nl
>>> from sympy.abc import r, Z
>>> R_nl(1, 0, r, Z)
2*sqrt(Z**3)*exp(-Z*r)
>>> R_nl(2, 0, r, Z)
sqrt(2)*(-Z*r + 2)*sqrt(Z**3)*exp(-Z*r/2)/4
>>> R_nl(2, 1, r, Z)
sqrt(6)*Z*r*sqrt(Z**3)*exp(-Z*r/2)/12

对于氢原子，你可以使用 Z=1 的默认值：

>>> R_nl(1, 0, r)
2*exp(-r)
>>> R_nl(2, 0, r)
sqrt(2)*(2 - r)*exp(-r/2)/4
>>> R_nl(3, 0, r)
2*sqrt(3)*(2*r**2/9 - 2*r + 3)*exp(-r/3)/27

对于银原子，你可以使用 Z=47：

>>> R_nl(1, 0, r, Z=47)
94*sqrt(47)*exp(-47*r)
>>> R_nl(2, 0, r, Z=47)
47*sqrt(94)*(2 - 47*r)*exp(-47*r/2)/4
>>> R_nl(3, 0, r, Z=47)
94*sqrt(141)*(4418*r**2/9 - 94*r + 3)*exp(-47*r/3)/27

径向波函数的归一化为：

>>> from sympy import integrate, oo
>>> integrate(R_nl(1, 0, r)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 0, r)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 1, r)**2 * r**2, (r, 0, oo))
1

对于任意原子序数成立：

>>> integrate(R_nl(1, 0, r, Z=2)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 0, r, Z=3)**2 * r**2, (r, 0, oo))
1
>>> integrate(R_nl(2, 1, r, Z=4)**2 * r**2, (r, 0, oo))
1

矩阵

原文链接：docs.sympy.org/latest/modules/physics/matrices.html

与物理相关的已知矩阵

sympy.physics.matrices.mdft(n)

自版本 1.9 起弃用：请改用 sympy.matrices.expressions.fourier 中的 DFT。

要获得与 mdft(n) 相同的行为，请使用 DFT(n).as_explicit()。

sympy.physics.matrices.mgamma(mu, lower=False)

返回标准（Dirac）表示中的 Dirac 伽马矩阵 (\gamma^\mu)。

解释

如果你想要 (\gamma_\mu)，使用 gamma(mu, True)。

我们使用一个约定：

(\gamma⁵ = i \cdot \gamma⁰ \cdot \gamma¹ \cdot \gamma² \cdot \gamma³)

(\gamma_5 = i \cdot \gamma_0 \cdot \gamma_1 \cdot \gamma_2 \cdot \gamma_3 = - \gamma⁵)

示例

>>> from sympy.physics.matrices import mgamma
>>> mgamma(1)
Matrix([
[ 0,  0, 0, 1],
[ 0,  0, 1, 0],
[ 0, -1, 0, 0],
[-1,  0, 0, 0]])

参考文献

[R737]

en.wikipedia.org/wiki/Gamma_matrices

sympy.physics.matrices.msigma(i)

返回具有 (i=1,2,3) 的 Pauli 矩阵 (\sigma_i)。

示例

>>> from sympy.physics.matrices import msigma
>>> msigma(1)
Matrix([
[0, 1],
[1, 0]])

参考文献

[R738]

en.wikipedia.org/wiki/Pauli_matrices

sympy.physics.matrices.pat_matrix(m, dx, dy, dz)

返回平行轴定理矩阵，以便将惯性矩阵沿 ((dx, dy, dz)) 距离转换为质量为 m 的物体。

示例

要将质量为 2 单位的物体沿 (x)-轴移动 1 单位的距离进行翻译，我们得到：

>>> from sympy.physics.matrices import pat_matrix
>>> pat_matrix(2, 1, 0, 0)
Matrix([
[0, 0, 0],
[0, 2, 0],
[0, 0, 2]])

Pauli 代数

原文：docs.sympy.org/latest/modules/physics/paulialgebra.html

该模块通过子类化符号实现了Pauli 代数。仅使用了 Pauli 矩阵的代数性质（我们不使用 Matrix 类）。

请参阅 Pauli 类的文档获取示例。

参考资料

[R748]

en.wikipedia.org/wiki/Pauli_matrices

sympy.physics.paulialgebra.evaluate_pauli_product(arg)

帮助函数，用于评估与符号对象的 Pauli 矩阵乘积。

参数：

arg: 包含 Pauli 矩阵的符号表达式

示例

>>> from sympy.physics.paulialgebra import Pauli, evaluate_pauli_product
>>> from sympy import I
>>> evaluate_pauli_product(I*Pauli(1)*Pauli(2))
-sigma3

>>> from sympy.abc import x
>>> evaluate_pauli_product(x**2*Pauli(2)*Pauli(1))
-I*x**2*sigma3

一维量子谐振子

原文：docs.sympy.org/latest/modules/physics/qho_1d.html

sympy.physics.qho_1d.E_n(n, omega)

返回一维谐振子的能量。

参数：

n：

“节点”量子数。

omega：

谐振子的角频率。

注意

返回值的单位与 hw 的单位匹配，因为能量的计算为：

E_n = hbar * omega*(n + 1/2)

示例

>>> from sympy.physics.qho_1d import E_n
>>> from sympy.abc import x, omega
>>> E_n(x, omega)
hbar*omega*(x + 1/2)

sympy.physics.qho_1d.coherent_state(n, alpha)

返回 1D 谐振子相干态的 <n|alpha>。参见 en.wikipedia.org/wiki/Coherent_states

参数：

n：

“节点”量子数。

alpha：

湮灭算符的本征值。

sympy.physics.qho_1d.psi_n(n, x, m, omega)

返回一维谐振子的波函数 psi_{n}。

参数：

n：

“节点”量子数。对应于波函数中的节点数。n >= 0

x：

x 坐标。

m：

粒子的质量。

omega：

振子的角频率。

示例

>>> from sympy.physics.qho_1d import psi_n
>>> from sympy.abc import m, x, omega
>>> psi_n(0, x, m, omega)
(m*omega)**(1/4)*exp(-m*omega*x**2/(2*hbar))/(hbar**(1/4)*pi**(1/4))

三维量子谐振子

原文链接：docs.sympy.org/latest/modules/physics/sho.html

sympy.physics.sho.E_nl(n, l, hw)

返回各向同性谐振子的能量。

参数：

n：

"节点"量子数。

l：

轨道角动量。

hw：

谐振子参数。

注意事项

返回值的单位与hw的单位相匹配，因为能量计算公式为：

( E_{nl} = (2n + l + \frac{3}{2}) \cdot hw )

示例

>>> from sympy.physics.sho import E_nl
>>> from sympy import symbols
>>> x, y, z = symbols('x, y, z')
>>> E_nl(x, y, z)
z*(2*x + y + 3/2)

sympy.physics.sho.R_nl(n, l, nu, r)

返回三维各向同性谐振子的径向波函数 ( R_{nl} ) 。

参数：

n：

"节点"量子数。对应于波函数中的节点数。 n >= 0

l：

轨道角动量的量子数。

nu：

质量标度频率：( \nu = \frac{m \cdot \omega}{2 \cdot \hbar} )，其中 ( m ) 是质量， ( \omega ) 是振荡器的频率。（在原子单位中， ( \nu == \frac{\omega}{2} ) ）

r：

径向坐标。

示例

>>> from sympy.physics.sho import R_nl
>>> from sympy.abc import r, nu, l
>>> R_nl(0, 0, 1, r)
2*2**(3/4)*exp(-r**2)/pi**(1/4)
>>> R_nl(1, 0, 1, r)
4*2**(1/4)*sqrt(3)*(3/2 - 2*r**2)*exp(-r**2)/(3*pi**(1/4))

l、nu 和 r 可能是符号变量：

>>> R_nl(0, 0, nu, r)
2*2**(3/4)*sqrt(nu**(3/2))*exp(-nu*r**2)/pi**(1/4)
>>> R_nl(0, l, 1, r)
r**l*sqrt(2**(l + 3/2)*2**(l + 2)/factorial2(2*l + 1))*exp(-r**2)/pi**(1/4)

径向波函数的归一化为：

>>> from sympy import Integral, oo
>>> Integral(R_nl(0, 0, 1, r)**2*r**2, (r, 0, oo)).n()
1.00000000000000
>>> Integral(R_nl(1, 0, 1, r)**2*r**2, (r, 0, oo)).n()
1.00000000000000
>>> Integral(R_nl(1, 1, 1, r)**2*r**2, (r, 0, oo)).n()
1.00000000000000

二次量子化

原文：docs.sympy.org/latest/modules/physics/secondquant.html

玻色子的二次量子化算符和状态。

这遵循费特和韦勒克的《多粒子系统的量子理论》的表述。

class sympy.physics.secondquant.AnnihilateBoson(k)

玻色子湮灭算符。

Examples

>>> from sympy.physics.secondquant import B
>>> from sympy.abc import x
>>> B(x)
AnnihilateBoson(x)

apply_operator(state)

如果 self 不是符号化的且 state 是 FockStateKet，则将 state 应用于 self，否则将 self 乘以 state。

Examples

>>> from sympy.physics.secondquant import B, BKet
>>> from sympy.abc import x, y, n
>>> B(x).apply_operator(y)
y*AnnihilateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))

class sympy.physics.secondquant.AnnihilateFermion(k)

费米子湮灭算符。

apply_operator(state)

如果 self 不是符号化的且 state 是 FockStateKet，则将 state 应用于 self，否则将 self 乘以 state。

Examples

>>> from sympy.physics.secondquant import B, Dagger, BKet
>>> from sympy.abc import x, y, n
>>> Dagger(B(x)).apply_operator(y)
y*CreateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))

property is_only_q_annihilator

总是销毁一个准粒子吗？（湮灭空穴或湮灭粒子）

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')

>>> F(a).is_only_q_annihilator
True
>>> F(i).is_only_q_annihilator
False
>>> F(p).is_only_q_annihilator
False

property is_only_q_creator

总是创建一个准粒子吗？（创建空穴或创建粒子）

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')

>>> F(a).is_only_q_creator
False
>>> F(i).is_only_q_creator
True
>>> F(p).is_only_q_creator
False

property is_q_annihilator

我们能够销毁一个准粒子吗？（湮灭空穴或湮灭粒子）如果可以，那么这会在费米面之上还是之下？

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=1)
>>> i = Symbol('i', below_fermi=1)
>>> p = Symbol('p')

>>> F(a).is_q_annihilator
1
>>> F(i).is_q_annihilator
0
>>> F(p).is_q_annihilator
1

property is_q_creator

我们能够创建一个准粒子吗？（创建空穴或创建粒子）如果可以，那么这会在费米面之上还是之下？

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import F
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')

>>> F(a).is_q_creator
0
>>> F(i).is_q_creator
-1
>>> F(p).is_q_creator
-1

class sympy.physics.secondquant.AntiSymmetricTensor(symbol, upper, lower)

将上下标存储在单独的 Tuple 中。

每组指标假定为反对称。

Examples

>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i j', below_fermi=True)
>>> a, b = symbols('a b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (i, a), (b, j))
-AntiSymmetricTensor(v, (a, i), (b, j))

如您所见，指标会自动排序为规范形式。

property lower

返回较低的指标。

Examples

>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (a, i), (b, j)).lower
(b, j)

property symbol

返回张量的符号。

Examples

>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (a, i), (b, j)).symbol
v

property upper

返回较高的指标。

Examples

>>> from sympy import symbols
>>> from sympy.physics.secondquant import AntiSymmetricTensor
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> AntiSymmetricTensor('v', (a, i), (b, j))
AntiSymmetricTensor(v, (a, i), (b, j))
>>> AntiSymmetricTensor('v', (a, i), (b, j)).upper
(a, i)

sympy.physics.secondquant.B

别名为AnnihilateBoson

sympy.physics.secondquant.BBra

别名为FockStateBosonBra

sympy.physics.secondquant.BKet

别名为FockStateBosonKet

sympy.physics.secondquant.Bd

别名为CreateBoson

class sympy.physics.secondquant.BosonicBasis

玻色子 Fock 态基础集合的基类。

class sympy.physics.secondquant.Commutator(a, b)

交换子：[A, B] = AB - BA

根据.cmp()对参数进行排序。

Examples

>>> from sympy import symbols
>>> from sympy.physics.secondquant import Commutator
>>> A, B = symbols('A,B', commutative=False)
>>> Commutator(B, A)
-Commutator(A, B)

使用.doit()评估交换子。

>>> comm = Commutator(A,B); comm
Commutator(A, B)
>>> comm.doit()
A*B - B*A

对于两个二次量子化算符，交换子立即计算：

>>> from sympy.physics.secondquant import Fd, F
>>> a = symbols('a', above_fermi=True)
>>> i = symbols('i', below_fermi=True)
>>> p,q = symbols('p,q')

>>> Commutator(Fd(a),Fd(i))
2*NO(CreateFermion(a)*CreateFermion(i))

但对于更复杂的表达式，通过调用.doit()来触发评估。

>>> comm = Commutator(Fd(p)*Fd(q),F(i)); comm
Commutator(CreateFermion(p)*CreateFermion(q), AnnihilateFermion(i))
>>> comm.doit(wicks=True)
-KroneckerDelta(i, p)*CreateFermion(q) +
 KroneckerDelta(i, q)*CreateFermion(p)

doit(**hints)

启用计算复杂表达式。

Examples

>>> from sympy.physics.secondquant import Commutator, F, Fd
>>> from sympy import symbols
>>> i, j = symbols('i,j', below_fermi=True)
>>> a, b = symbols('a,b', above_fermi=True)
>>> c = Commutator(Fd(a)*F(i),Fd(b)*F(j))
>>> c.doit(wicks=True)
0

classmethod eval(a, b)

交换子[A, B]在 A < B 时处于规范形式。

Examples

>>> from sympy.physics.secondquant import Commutator, F, Fd
>>> from sympy.abc import x
>>> c1 = Commutator(F(x), Fd(x))
>>> c2 = Commutator(Fd(x), F(x))
>>> Commutator.eval(c1, c2)
0

class sympy.physics.secondquant.CreateBoson(k)

玻色子产生算符。

apply_operator(state)

如果 self 不是符号化的且 state 是 FockStateKet，则将 state 应用于 self，否则将 self 乘以 state。

Examples

>>> from sympy.physics.secondquant import B, Dagger, BKet
>>> from sympy.abc import x, y, n
>>> Dagger(B(x)).apply_operator(y)
y*CreateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))

class sympy.physics.secondquant.CreateFermion(k)

费米子产生算符。

apply_operator(state)

如果 self 不是符号化的且 state 是 FockStateKet，则将 state 应用于 self，否则将 self 乘以 state。

Examples

>>> from sympy.physics.secondquant import B, Dagger, BKet
>>> from sympy.abc import x, y, n
>>> Dagger(B(x)).apply_operator(y)
y*CreateBoson(x)
>>> B(0).apply_operator(BKet((n,)))
sqrt(n)*FockStateBosonKet((n - 1,))

property is_only_q_annihilator

总是销毁一个准粒子吗？（湮灭空穴或湮灭粒子）

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')

>>> Fd(a).is_only_q_annihilator
False
>>> Fd(i).is_only_q_annihilator
True
>>> Fd(p).is_only_q_annihilator
False

property is_only_q_creator

总是创建一个准粒子吗？（创建空穴或创建粒子）

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')

>>> Fd(a).is_only_q_creator
True
>>> Fd(i).is_only_q_creator
False
>>> Fd(p).is_only_q_creator
False

property is_q_annihilator

我们能够销毁一个准粒子吗？（湮灭空穴或湮灭粒子）如果可以，那么这会在费米面之上还是之下？

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=1)
>>> i = Symbol('i', below_fermi=1)
>>> p = Symbol('p')

>>> Fd(a).is_q_annihilator
0
>>> Fd(i).is_q_annihilator
-1
>>> Fd(p).is_q_annihilator
-1

property is_q_creator

我们能够创建一个准粒子吗？（创建空穴或创建粒子）如果可以，那么这会在费米面之上还是之下？

Examples

>>> from sympy import Symbol
>>> from sympy.physics.secondquant import Fd
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')

>>> Fd(a).is_q_creator
1
>>> Fd(i).is_q_creator
0
>>> Fd(p).is_q_creator
1

class sympy.physics.secondquant.Dagger(arg)

创建/湮灭算符的厄米共轭。

示例。

>>> from sympy import I
>>> from sympy.physics.secondquant import Dagger, B, Bd
>>> Dagger(2*I)
-2*I
>>> Dagger(B(0))
CreateBoson(0)
>>> Dagger(Bd(0))
AnnihilateBoson(0)

classmethod eval(arg)

评估 Dagger 实例。

示例。

>>> from sympy import I
>>> from sympy.physics.secondquant import Dagger, B, Bd
>>> Dagger(2*I)
-2*I
>>> Dagger(B(0))
CreateBoson(0)
>>> Dagger(Bd(0))
AnnihilateBoson(0)

自动调用 eval() 方法。

sympy.physics.secondquant.F

AnnihilateFermion 的别名。

sympy.physics.secondquant.FBra

FockStateFermionBra 的别名。

sympy.physics.secondquant.FKet

FockStateFermionKet 的别名。

sympy.physics.secondquant.Fd

CreateFermion 的别名。

class sympy.physics.secondquant.FixedBosonicBasis(n_particles, n_levels)

固定粒子数的基组。

示例。

>>> from sympy.physics.secondquant import FixedBosonicBasis
>>> b = FixedBosonicBasis(2, 2)
>>> state = b.state(1)
>>> b
[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]
>>> state
FockStateBosonKet((1, 1))
>>> b.index(state)
1

index(state)

返回基础中状态的索引。

示例。

>>> from sympy.physics.secondquant import FixedBosonicBasis
>>> b = FixedBosonicBasis(2, 3)
>>> b.index(b.state(3))
3

state(i)

返回在基础中索引为 i 的态。

示例。

>>> from sympy.physics.secondquant import FixedBosonicBasis
>>> b = FixedBosonicBasis(2, 3)
>>> b.state(3)
FockStateBosonKet((1, 0, 1))

class sympy.physics.secondquant.FockState(occupations)

具有一系列占据数的多粒子 Fock 态。

在任何可以有 FockState 的地方，也可以有 S.Zero。所有代码必须检查这一点！

代表 FockStates 的基类。

class sympy.physics.secondquant.FockStateBosonBra(occupations)

描述了一组 BosonBra 粒子。

示例。

>>> from sympy.physics.secondquant import BBra
>>> BBra([1, 2])
FockStateBosonBra((1, 2))

class sympy.physics.secondquant.FockStateBosonKet(occupations)

具有一系列占据数的多粒子 Fock 态。

占据数可以是任何大于等于 0 的整数。

示例。

>>> from sympy.physics.secondquant import BKet
>>> BKet([1, 2])
FockStateBosonKet((1, 2))

class sympy.physics.secondquant.FockStateBra(occupations)

左矢的表示。

class sympy.physics.secondquant.FockStateFermionBra(occupations, fermi_level=0)

示例。

>>> from sympy.physics.secondquant import FBra
>>> FBra([1, 2])
FockStateFermionBra((1, 2))

另请参见。

FockStateFermionKet

class sympy.physics.secondquant.FockStateFermionKet(occupations, fermi_level=0)

具有一系列占据轨道的多粒子 Fock 态。

解释。

每个状态只能有一个粒子，因此我们选择存储一组占据轨道而不是具有占据数（零和一）的元组。

费米面以下的态被称为空穴，并且在占据列表中用负标签表示。

对于符号态标签，费米面限制了允许的空穴态数。

示例。

>>> from sympy.physics.secondquant import FKet
>>> FKet([1, 2])
FockStateFermionKet((1, 2))

class sympy.physics.secondquant.FockStateKet(occupations)

右矢的表示。

class sympy.physics.secondquant.InnerProduct(bra, ket)

一个未评估的左矢和右矢之间的内积。

解释。

目前该类只将事物简化为 Kronecker Delta 的乘积。将来，我们可以引入像 |a> 和 |b> 这样的抽象态，并将内积保持为未评估状态 <a|b>。

property bra

返回态的左矢部分。

property ket

返回态的右矢部分。

class sympy.physics.secondquant.KroneckerDelta(i, j, delta_range=None)

离散或 Kronecker Delta 函数。

参数：

i：数字，符号

Delta 函数的第一个索引。

j：数字，符号

Delta 函数的第二个索引。

解释。

一个函数，接受两个整数 (i) 和 (j)。如果 (i) 和 (j) 不相等，则返回 (0)，如果相等，则返回 (1)。

示例。

具有整数索引的示例：

>>> from sympy import KroneckerDelta
>>> KroneckerDelta(1, 2)
0
>>> KroneckerDelta(3, 3)
1

符号索引：

>>> from sympy.abc import i, j, k
>>> KroneckerDelta(i, j)
KroneckerDelta(i, j)
>>> KroneckerDelta(i, i)
1
>>> KroneckerDelta(i, i + 1)
0
>>> KroneckerDelta(i, i + 1 + k)
KroneckerDelta(i, i + k + 1)

另请参见。

eval，DiracDelta

参考文献。

[R771]

en.wikipedia.org/wiki/Kronecker_delta

classmethod eval(i, j, delta_range=None)

评估离散 Delta 函数。

示例。

>>> from sympy import KroneckerDelta
>>> from sympy.abc import i, j, k

>>> KroneckerDelta(i, j)
KroneckerDelta(i, j)
>>> KroneckerDelta(i, i)
1
>>> KroneckerDelta(i, i + 1)
0
>>> KroneckerDelta(i, i + 1 + k)
KroneckerDelta(i, i + k + 1)

间接的 doctest。

property indices_contain_equal_information

返回 True，如果指标要么都在费米能级上，要么都在费米能级下。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, q).indices_contain_equal_information
True
>>> KroneckerDelta(p, q+1).indices_contain_equal_information
True
>>> KroneckerDelta(i, p).indices_contain_equal_information
False

property is_above_fermi

如果 Delta 在费米能级上方可以非零，则为真。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_above_fermi
True
>>> KroneckerDelta(p, i).is_above_fermi
False
>>> KroneckerDelta(p, q).is_above_fermi
True

另请参阅

is_below_fermi, is_only_below_fermi, is_only_above_fermi

property is_below_fermi

如果 Delta 在费米能级下方可以非零，则为真。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_below_fermi
False
>>> KroneckerDelta(p, i).is_below_fermi
True
>>> KroneckerDelta(p, q).is_below_fermi
True

另请参阅

is_above_fermi, is_only_above_fermi, is_only_below_fermi

property is_only_above_fermi

如果 Delta 受限于费米能级上方，则为真。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, a).is_only_above_fermi
True
>>> KroneckerDelta(p, q).is_only_above_fermi
False
>>> KroneckerDelta(p, i).is_only_above_fermi
False

另请参阅

is_above_fermi, is_below_fermi, is_only_below_fermi

property is_only_below_fermi

如果 Delta 受限于费米能级下方，则为真。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> p = Symbol('p')
>>> q = Symbol('q')
>>> KroneckerDelta(p, i).is_only_below_fermi
True
>>> KroneckerDelta(p, q).is_only_below_fermi
False
>>> KroneckerDelta(p, a).is_only_below_fermi
False

另请参阅

is_above_fermi, is_below_fermi, is_only_above_fermi

property killable_index

返回在最终表达式中要替换的首选指标。

解释

要替换的指标是在费米能级方面具有较少信息的指标。如果指标包含相同信息，则‘a’优于‘b’。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> j = Symbol('j', below_fermi=True)
>>> p = Symbol('p')
>>> KroneckerDelta(p, i).killable_index
p
>>> KroneckerDelta(p, a).killable_index
p
>>> KroneckerDelta(i, j).killable_index
j

另请参阅

preferred_index

property preferred_index

返回在最终表达式中要保留的首选指标。

解释

首选指标是在费米能级方面具有更多信息的指标。如果指标包含相同信息，则‘a’优于‘b’。

示例

>>> from sympy import KroneckerDelta, Symbol
>>> a = Symbol('a', above_fermi=True)
>>> i = Symbol('i', below_fermi=True)
>>> j = Symbol('j', below_fermi=True)
>>> p = Symbol('p')
>>> KroneckerDelta(p, i).preferred_index
i
>>> KroneckerDelta(p, a).preferred_index
a
>>> KroneckerDelta(i, j).preferred_index
i

另请参阅

killable_index

class sympy.physics.secondquant.NO(arg)

该对象用于表示正规顺序括号。

即 {abcd} 有时写作 :abcd:

解释

对一个参数应用 NO(arg)函数意味着假设参数中的所有算符均反对易，并且具有消失的收缩。这允许在对象创建时立即重新排序为规范形式。

例子

>>> from sympy import symbols
>>> from sympy.physics.secondquant import NO, F, Fd
>>> p,q = symbols('p,q')
>>> NO(Fd(p)*F(q))
NO(CreateFermion(p)*AnnihilateFermion(q))
>>> NO(F(q)*Fd(p))
-NO(CreateFermion(p)*AnnihilateFermion(q))

注意

如果您想生成一个表达式的正规顺序等价物，则应使用 wicks()函数。此类仅指示括号内的所有算符均反对易，并具有消失的收缩。不多不少。

doit(**hints)

要么去掉括号或在其参数中启用复杂计算。

例子

>>> from sympy.physics.secondquant import NO, Fd, F
>>> from textwrap import fill
>>> from sympy import symbols, Dummy
>>> p,q = symbols('p,q', cls=Dummy)
>>> print(fill(str(NO(Fd(p)*F(q)).doit())))
KroneckerDelta(_a, _p)*KroneckerDelta(_a,
_q)*CreateFermion(_a)*AnnihilateFermion(_a) + KroneckerDelta(_a,
_p)*KroneckerDelta(_i, _q)*CreateFermion(_a)*AnnihilateFermion(_i) -
KroneckerDelta(_a, _q)*KroneckerDelta(_i,
_p)*AnnihilateFermion(_a)*CreateFermion(_i) - KroneckerDelta(_i,
_p)*KroneckerDelta(_i, _q)*AnnihilateFermion(_i)*CreateFermion(_i)

get_subNO(i)

返回在索引 i 处没有 FermionicOperator 的 NO()。

例子

>>> from sympy import symbols
>>> from sympy.physics.secondquant import F, NO
>>> p, q, r = symbols('p,q,r')

>>> NO(F(p)*F(q)*F(r)).get_subNO(1)
NO(AnnihilateFermion(p)*AnnihilateFermion(r))

property has_q_annihilators

如果第一个参数的最右边参数不是 q 湮灭算符，则返回 0，否则如果其在费米面上方则返回 1，如果在费米面下方则返回-1。

例子

>>> from sympy import symbols
>>> from sympy.physics.secondquant import NO, F, Fd

>>> a = symbols('a', above_fermi=True)
>>> i = symbols('i', below_fermi=True)
>>> NO(Fd(a)*Fd(i)).has_q_annihilators
-1
>>> NO(F(i)*F(a)).has_q_annihilators
1
>>> NO(Fd(a)*F(i)).has_q_annihilators
0

property has_q_creators

如果第一个参数的最左边参数不是 q 创造算符，则返回 0，否则如果其在费米面上方则返回 1，如果在费米面下方则返回-1。

例子

>>> from sympy import symbols
>>> from sympy.physics.secondquant import NO, F, Fd

>>> a = symbols('a', above_fermi=True)
>>> i = symbols('i', below_fermi=True)
>>> NO(Fd(a)*Fd(i)).has_q_creators
1
>>> NO(F(i)*F(a)).has_q_creators
-1
>>> NO(Fd(i)*F(a)).has_q_creators           
0

iter_q_annihilators()

迭代湮灭算符。

例子

>>> from sympy import symbols
>>> i, j = symbols('i j', below_fermi=True)
>>> a, b = symbols('a b', above_fermi=True)
>>> from sympy.physics.secondquant import NO, F, Fd
>>> no = NO(Fd(a)*F(i)*F(b)*Fd(j))

>>> no.iter_q_creators()
<generator object... at 0x...>
>>> list(no.iter_q_creators())
[0, 1]
>>> list(no.iter_q_annihilators())
[3, 2]

iter_q_creators()

迭代创建算符。

例子

>>> from sympy import symbols
>>> i, j = symbols('i j', below_fermi=True)
>>> a, b = symbols('a b', above_fermi=True)
>>> from sympy.physics.secondquant import NO, F, Fd
>>> no = NO(Fd(a)*F(i)*F(b)*Fd(j))

>>> no.iter_q_creators()
<generator object... at 0x...>
>>> list(no.iter_q_creators())
[0, 1]
>>> list(no.iter_q_annihilators())
[3, 2]

class sympy.physics.secondquant.PermutationOperator(i, j)

表示指数置换算符 P(ij)。

P(ij)*f(i)*g(j) = f(i)*g(j) - f(j)*g(i)

get_permuted(expr)

返回具有置换指数的-expr。

解释

>>> from sympy import symbols, Function
>>> from sympy.physics.secondquant import PermutationOperator
>>> p,q = symbols('p,q')
>>> f = Function('f')
>>> PermutationOperator(p,q).get_permuted(f(p,q))
-f(q, p)

class sympy.physics.secondquant.VarBosonicBasis(n_max)

一个单态、变粒子数的基组。

例子

>>> from sympy.physics.secondquant import VarBosonicBasis
>>> b = VarBosonicBasis(5)
>>> b
[FockState((0,)), FockState((1,)), FockState((2,)),
 FockState((3,)), FockState((4,))]

index(state)

返回基础中状态的索引。

例子

>>> from sympy.physics.secondquant import VarBosonicBasis
>>> b = VarBosonicBasis(3)
>>> state = b.state(1)
>>> b
[FockState((0,)), FockState((1,)), FockState((2,))]
>>> state
FockStateBosonKet((1,))
>>> b.index(state)
1

state(i)

单一基组的状态。

例子

>>> from sympy.physics.secondquant import VarBosonicBasis
>>> b = VarBosonicBasis(5)
>>> b.state(3)
FockStateBosonKet((3,))

sympy.physics.secondquant.apply_operators(e)

以 SymPy 表达式和算符为参数，应用这些算符。

例子

>>> from sympy.physics.secondquant import apply_operators
>>> from sympy import sympify
>>> apply_operators(sympify(3)+4)
7

sympy.physics.secondquant.contraction(a, b)

计算 Fermionic 算符 a 和 b 的收缩。

例子

>>> from sympy import symbols
>>> from sympy.physics.secondquant import F, Fd, contraction
>>> p, q = symbols('p,q')
>>> a, b = symbols('a,b', above_fermi=True)
>>> i, j = symbols('i,j', below_fermi=True)

收缩仅在准创造算符位于准湮灭算符右侧时才非零：

>>> contraction(F(a),Fd(b))
KroneckerDelta(a, b)
>>> contraction(Fd(i),F(j))
KroneckerDelta(i, j)

对于一般指标，非零结果将限制指标位于费米面以下/以上：

>>> contraction(Fd(p),F(q))
KroneckerDelta(_i, q)*KroneckerDelta(p, q)
>>> contraction(F(p),Fd(q))
KroneckerDelta(_a, q)*KroneckerDelta(p, q)

两个创建算符或两个湮灭算符总是消失的：

>>> contraction(F(p),F(q))
0
>>> contraction(Fd(p),Fd(q))
0

sympy.physics.secondquant.evaluate_deltas(e)

我们在表达式中假设按照爱因斯坦求和约定评估 KroneckerDelta 符号。

解释

如果一个指标重复，则对其求和，并实际上用另一个指标代替它。如果两个指标都重复，则根据首选指标进行替换。这由 KroneckerDelta.preferred_index 和 KroneckerDelta.killable_index 决定。

如果没有可能的替换或者替换会导致信息丢失，则不进行任何操作。

如果一个指标出现在多个 KroneckerDelta 中，则结果的替换取决于因子的顺序。由于排序依赖于平台，因此从此函数得到的文字表达可能难以预测。

例子

我们假设以下情况：

>>> from sympy import symbols, Function, Dummy, KroneckerDelta
>>> from sympy.physics.secondquant import evaluate_deltas
>>> i,j = symbols('i j', below_fermi=True, cls=Dummy)
>>> a,b = symbols('a b', above_fermi=True, cls=Dummy)
>>> p,q = symbols('p q', cls=Dummy)
>>> f = Function('f')
>>> t = Function('t')

根据 KroneckerDelta，这些指标的优先顺序是(a, b, i, j, p, q)。

简单的情况：

>>> evaluate_deltas(KroneckerDelta(i,j)*f(i))       # d_ij f(i) -> f(j)
f(_j)
>>> evaluate_deltas(KroneckerDelta(i,j)*f(j))       # d_ij f(j) -> f(i)
f(_i)
>>> evaluate_deltas(KroneckerDelta(i,p)*f(p))       # d_ip f(p) -> f(i)
f(_i)
>>> evaluate_deltas(KroneckerDelta(q,p)*f(p))       # d_qp f(p) -> f(q)
f(_q)
>>> evaluate_deltas(KroneckerDelta(q,p)*f(q))       # d_qp f(q) -> f(p)
f(_p)

更有趣的情况：

>>> evaluate_deltas(KroneckerDelta(i,p)*t(a,i)*f(p,q))
f(_i, _q)*t(_a, _i)
>>> evaluate_deltas(KroneckerDelta(a,p)*t(a,i)*f(p,q))
f(_a, _q)*t(_a, _i)
>>> evaluate_deltas(KroneckerDelta(p,q)*f(p,q))
f(_p, _p)

最后，这里有一些不做任何操作的情况，因为那将意味着信息的丢失：

>>> evaluate_deltas(KroneckerDelta(i,p)*f(q))
f(_q)*KroneckerDelta(_i, _p)
>>> evaluate_deltas(KroneckerDelta(i,p)*f(i))
f(_i)*KroneckerDelta(_i, _p)

sympy.physics.secondquant.matrix_rep(op, basis)

查找算符在基组中的表示。

例子

>>> from sympy.physics.secondquant import VarBosonicBasis, B, matrix_rep
>>> b = VarBosonicBasis(5)
>>> o = B(0)
>>> matrix_rep(o, b)
Matrix([
[0, 1,       0,       0, 0],
[0, 0, sqrt(2),       0, 0],
[0, 0,       0, sqrt(3), 0],
[0, 0,       0,       0, 2],
[0, 0,       0,       0, 0]])

sympy.physics.secondquant.simplify_index_permutations(expr, permutation_operators)

通过引入适当的置换算符来执行简化。

解释

示意性地：

[abij] - [abji] - [baij] + [baji] -> P(ab)P(ij)[abij]

permutation_operators 是要考虑的置换算符列表。

如果 permutation_operators=[P(ab),P(ij)]，我们将尝试在表达式中引入排列算子 P(ij)和 P(ab)。如果还有其他可能的简化，我们将忽略它们。

>>> from sympy import symbols, Function
>>> from sympy.physics.secondquant import simplify_index_permutations
>>> from sympy.physics.secondquant import PermutationOperator
>>> p,q,r,s = symbols('p,q,r,s')
>>> f = Function('f')
>>> g = Function('g')

>>> expr = f(p)*g(q) - f(q)*g(p); expr
f(p)*g(q) - f(q)*g(p)
>>> simplify_index_permutations(expr,[PermutationOperator(p,q)])
f(p)*g(q)*PermutationOperator(p, q)

>>> PermutList = [PermutationOperator(p,q),PermutationOperator(r,s)]
>>> expr = f(p,r)*g(q,s) - f(q,r)*g(p,s) + f(q,s)*g(p,r) - f(p,s)*g(q,r)
>>> simplify_index_permutations(expr,PermutList)
f(p, r)*g(q, s)*PermutationOperator(p, q)*PermutationOperator(r, s)

sympy.physics.secondquant.substitute_dummies(expr, new_indices=False, pretty_indices={})

通过替换虚拟变量来收集项。

解释

此例程允许简化包含仅因虚拟变量而不同的项的 Add 表达式。

这个想法是根据项的结构一致地替换所有虚拟变量。对于每个项，我们获得一个所有虚拟变量的序列，其中顺序由索引范围、索引所属的因子以及其在每个因子中的位置决定。有关虚拟变量排序的更多信息，请参阅 _get_ordered_dummies()。然后在每个项中一致地进行替换。

示例

>>> from sympy import symbols, Function, Dummy
>>> from sympy.physics.secondquant import substitute_dummies
>>> a,b,c,d = symbols('a b c d', above_fermi=True, cls=Dummy)
>>> i,j = symbols('i j', below_fermi=True, cls=Dummy)
>>> f = Function('f')

>>> expr = f(a,b) + f(c,d); expr
f(_a, _b) + f(_c, _d)

由于 a、b、c 和 d 是等效的求和索引，因此表达式可以简化为单一项（其中虚拟指数仍然被求和）

>>> substitute_dummies(expr)
2*f(_a, _b)

控制输出：

默认情况下，将在表达式中已经存在的虚拟符号重新用于不同的排列。然而，如果 new_indices=True，则会生成并插入新的虚拟符号。“pretty_indices”关键字可用于控制此新符号的生成。

默认情况下，新的虚拟符号将以 i_1、i_2、a_1 等形式生成。如果您提供一个键值对字典，形式为：

{ index_group: string_of_letters }

这些字母将用作新虚拟符号的标签。index_groups 必须是“above”、“below”或“general”之一。

>>> expr = f(a,b,i,j)
>>> my_dummies = { 'above':'st', 'below':'uv' }
>>> substitute_dummies(expr, new_indices=True, pretty_indices=my_dummies)
f(_s, _t, _u, _v)

如果我们用完了字母，或者某些 index_group 没有关键字，则默认的虚拟生成器将作为后备：

>>> p,q = symbols('p q', cls=Dummy)  # general indices
>>> expr = f(p,q)
>>> substitute_dummies(expr, new_indices=True, pretty_indices=my_dummies)
f(_p_0, _p_1)

sympy.physics.secondquant.wicks(e, **kw_args)

使用 Wick 定理返回表达式的正常排序等效物。

示例

>>> from sympy import symbols, Dummy
>>> from sympy.physics.secondquant import wicks, F, Fd
>>> p, q, r = symbols('p,q,r')
>>> wicks(Fd(p)*F(q))
KroneckerDelta(_i, q)*KroneckerDelta(p, q) + NO(CreateFermion(p)*AnnihilateFermion(q))

默认情况下，表达式被展开：

>>> wicks(F(p)*(F(q)+F(r)))
NO(AnnihilateFermion(p)*AnnihilateFermion(q)) + NO(AnnihilateFermion(p)*AnnihilateFermion(r))

使用关键字“keep_only_fully_contracted=True”，仅返回完全收缩的项。

根据请求，结果可以按以下顺序简化：

– KroneckerDelta 函数被评估 – 虚拟变量在各项中一致地替换

>>> p, q, r = symbols('p q r', cls=Dummy)
>>> wicks(Fd(p)*(F(q)+F(r)), keep_only_fully_contracted=True)
KroneckerDelta(_i, _q)*KroneckerDelta(_p, _q) + KroneckerDelta(_i, _r)*KroneckerDelta(_p, _r)

SymPy-1-13-中文文档-二十九-

SymPy 1.13 中文文档（二十九）

物理

氢波函数

矩阵

Pauli 代数

参考资料

一维量子谐振子

三维量子谐振子

二次量子化

间接的 doctest。