旋转#

量子力学角动量。

class sympy.physics.quantum.spin.J2Op(*args, **kwargs)[源代码]#: J^2算符。

class sympy.physics.quantum.spin.JxBra(j, m)[源代码]#

Jx的Eigenbra。

关于自旋本征态的用法，见JzKet。

参见

JzKet: 自旋态的使用

class sympy.physics.quantum.spin.JxBraCoupled(j, m, jn, *jcoupling)[源代码]#

Jx的耦合特征bra。

关于耦合自旋本征态的用法，见JzKetCoupled。

参见

JzKetCoupled: 耦合自旋态的应用

class sympy.physics.quantum.spin.JxKet(j, m)[源代码]#

Jx的Eigket。

关于自旋本征态的用法，见JzKet。

参见

JzKet: 自旋态的使用

class sympy.physics.quantum.spin.JxKetCoupled(j, m, jn, *jcoupling)[源代码]#

Jx的耦合特征。

关于耦合自旋本征态的用法，见JzKetCoupled。

参见

JzKetCoupled: 耦合自旋态的应用

class sympy.physics.quantum.spin.JyBra(j, m)[源代码]#

Jy的本征胸罩。

关于自旋本征态的用法，见JzKet。

参见

JzKet: 自旋态的使用

class sympy.physics.quantum.spin.JyBraCoupled(j, m, jn, *jcoupling)[源代码]#

Jy的耦合特征bra。

关于耦合自旋本征态的用法，见JzKetCoupled。

参见

JzKetCoupled: 耦合自旋态的应用

class sympy.physics.quantum.spin.JyKet(j, m)[源代码]#

Jy的特征。

关于自旋本征态的用法，见JzKet。

参见

JzKet: 自旋态的使用

class sympy.physics.quantum.spin.JyKetCoupled(j, m, jn, *jcoupling)[源代码]#

Jy的耦合特征。

关于耦合自旋本征态的用法，见JzKetCoupled。

参见

JzKetCoupled: 耦合自旋态的应用

class sympy.physics.quantum.spin.JzBra(j, m)[源代码]#

Jz的Eigenbra。

本征态的用法见本征态。

参见

JzKet: 自旋态的使用

class sympy.physics.quantum.spin.JzBraCoupled(j, m, jn, *jcoupling)[源代码]#

Jz的耦合特征bra。

关于耦合自旋本征态的用法，请参阅JzKetCoupled。

参见

JzKetCoupled: 耦合自旋态的应用

class sympy.physics.quantum.spin.JzKet(j, m)[源代码]#

Jz的特征。

自旋态是Jz算符的本征态。非耦合态，即表示多个独立自旋态相互作用的状态，被定义为状态的张量积。

参数:

j ：数字，符号

总自旋角动量

m ：数字，符号

Jz自旋算符的本征值

实例

正常状态：

定义简单的自旋状态，包括数值和符号：

>>> from sympy.physics.quantum.spin import JzKet, JxKet
>>> from sympy import symbols
>>> JzKet(1, 0)
|1,0>
>>> j, m = symbols('j m')
>>> JzKet(j, m)
|j,m>

根据Jx算符的本征基重写JzKet：注意：得到的本征态是JxKet的本征态

>>> JzKet(1,1).rewrite("Jx")
|1,-1>/2 - sqrt(2)*|1,0>/2 + |1,1>/2

根据Jx操作符的基本元素得到状态的向量表示：

>>> from sympy.physics.quantum.represent import represent
>>> from sympy.physics.quantum.spin import Jx, Jz
>>> represent(JzKet(1,-1), basis=Jx)
Matrix([
[      1/2],
[sqrt(2)/2],
[      1/2]])

在状态之间应用内部产品：

>>> from sympy.physics.quantum.innerproduct import InnerProduct
>>> from sympy.physics.quantum.spin import JxBra
>>> i = InnerProduct(JxBra(1,1), JzKet(1,1))
>>> i
<1,1|1,1>
>>> i.doit()
1/2

非耦合状态：

将非耦合状态定义为两个Jz特征元之间的张量积：

>>> from sympy.physics.quantum.tensorproduct import TensorProduct
>>> j1,m1,j2,m2 = symbols('j1 m1 j2 m2')
>>> TensorProduct(JzKet(1,0), JzKet(1,1))
|1,0>x|1,1>
>>> TensorProduct(JzKet(j1,m1), JzKet(j2,m2))
|j1,m1>x|j2,m2>

张量积可以重写，在这种情况下，构成张量积的本征态被重写为新的基：

>>> TensorProduct(JzKet(1,1),JxKet(1,1)).rewrite('Jz')
|1,1>x|1,-1>/2 + sqrt(2)*|1,1>x|1,0>/2 + |1,1>x|1,1>/2

张量积的表示方法给出了状态的向量表示。注意，乘积基中的状态相当于分量本征态矢量表示的张量积：

>>> represent(TensorProduct(JzKet(1,0),JzKet(1,1)))
Matrix([
[0],
[0],
[0],
[1],
[0],
[0],
[0],
[0],
[0]])
>>> represent(TensorProduct(JzKet(1,1),JxKet(1,1)), basis=Jz)
Matrix([
[      1/2],
[sqrt(2)/2],
[      1/2],
[        0],
[        0],
[        0],
[        0],
[        0],
[        0]])

参见

JzKetCoupled: 耦合本征态
sympy.physics.quantum.tensorproduct.TensorProduct: 用于指定非耦合状态
uncouple: 解耦给定耦合参数的状态
couple: 非耦合状态

class sympy.physics.quantum.spin.JzKetCoupled(j, m, jn, *jcoupling)[源代码]#

Jz耦合本征

自旋态是Jz的一个本征值，它代表了不同自旋空间的耦合。

创建JzKetCoupled实例的参数是 j ， m ， jn 还有一个可选的 jcoupling 争论。这个 j 和 m 选项是总角动量量子数，用于正常状态（例如JzKet）。

中的另一个必需参数 jn ，它是一个定义 \(j_n\) 乘积空间的角动量量子数。例如，如果一个状态表示产品基态的耦合 \(\left|j_1,m_1\right\rangle\times\left|j_2,m_2\right\rangle\) , the jn 因为这种状态 (j1,j2) .

最后的选择是 jcoupling ，它用于定义 jn 是耦合的，这包括这些空间耦合在一起的顺序和由这些耦合产生的量子数。这个 jcoupling 参数本身是一个列表列表，因此每个子列表定义了自旋空间之间的单个耦合。如果存在N个耦合角动量空间，即 jn 有N个元素，则必须有N-1个子列表。这些子列表组成了 jcoupling 参数的长度为3。前两个元素是被认为耦合在一起的积空间的指数。例如，如果我们想结婚 \(j_1\) 和 \(j_4\) ，指数为1和4。如果一个状态已经被耦合，它被耦合的最小索引引用，那么如果 \(j_2\) 和 \(j_4\) 已经与一些 \(j_{{24}}\) ，则可以通过引用索引2来耦合此值。子列表的最后一个元素是耦合态的量子数。所以把所有的东西放在一个有效的子列表中 jcoupling 如果 \(j_1\) 和 \(j_2\) 与具有量子数的角动量空间耦合 \(j_{{12}}\) 用价值 j12 ，子列表将是 (1,2,j12) 这些子列表在N-1中使用 jcoupling .

注意 jcoupling 参数是可选的，如果未指定，则采用默认耦合。此默认值是按顺序耦合空间，并以耦合的量子数为最大值。例如，如果自旋空间是 \(j_1\) ， \(j_2\) ， \(j_3\) ， \(j_4\) ，则默认耦合对 \(j_1\) 和 \(j_2\) 到 \(j_{{12}}=j_1+j_2\) ，然后， \(j_{{12}}\) 和 \(j_3\) 耦合到 \(j_{{123}}=j_{{12}}+j_3\) 最后 \(j_{{123}}\) 和 \(j_4\) 到 \(j=j_{{123}}+j_4\) . 与此对应的jcoupling值为：

((1,2,j1+j2),(1,3,j1+j2+j3))

参数:: args ：元组

必须传递的参数 j ， m ， jn 和 jcoupling . 这个 j 值是总角动量。这个 m 值是Jz自旋算符的特征值。这个 jn 列表是耦合在一起的参数动量空间的j值。这个 jcoupling 参数是定义空间如何耦合在一起的可选参数。有关这些耦合参数的定义，请参见上述说明。

实例

定义简单的自旋状态，包括数值和符号：

>>> from sympy.physics.quantum.spin import JzKetCoupled
>>> from sympy import symbols
>>> JzKetCoupled(1, 0, (1, 1))
|1,0,j1=1,j2=1>
>>> j, m, j1, j2 = symbols('j m j1 j2')
>>> JzKetCoupled(j, m, (j1, j2))
|j,m,j1=j1,j2=j2>

用各种耦合参数定义2个以上耦合空间的耦合自旋态：

>>> JzKetCoupled(2, 1, (1, 1, 1))
|2,1,j1=1,j2=1,j3=1,j(1,2)=2>
>>> JzKetCoupled(2, 1, (1, 1, 1), ((1,2,2),(1,3,2)) )
|2,1,j1=1,j2=1,j3=1,j(1,2)=2>
>>> JzKetCoupled(2, 1, (1, 1, 1), ((2,3,1),(1,2,2)) )
|2,1,j1=1,j2=1,j3=1,j(2,3)=1>

用Jx算符的本征基重写JzKetCoupled：注意：得到的本征态是JxKetCoupled

>>> JzKetCoupled(1,1,(1,1)).rewrite("Jx")
|1,-1,j1=1,j2=1>/2 - sqrt(2)*|1,0,j1=1,j2=1>/2 + |1,1,j1=1,j2=1>/2

重写方法可用于将耦合状态转换为非耦合状态。这是通过将coupled=False传递给重写函数来完成的：

>>> JzKetCoupled(1, 0, (1, 1)).rewrite('Jz', coupled=False)
-sqrt(2)*|1,-1>x|1,1>/2 + sqrt(2)*|1,1>x|1,-1>/2

根据Jx操作符的基本元素得到状态的向量表示：

>>> from sympy.physics.quantum.represent import represent
>>> from sympy.physics.quantum.spin import Jx
>>> from sympy import S
>>> represent(JzKetCoupled(1,-1,(S(1)/2,S(1)/2)), basis=Jx)
Matrix([
[        0],
[      1/2],
[sqrt(2)/2],
[      1/2]])

参见

JzKet: 正常自旋本征态
uncouple: 耦合自旋态的解耦
couple: 非耦合自旋态的耦合

class sympy.physics.quantum.spin.JzOp(*args, **kwargs)[源代码]#: Jz操作员。

class sympy.physics.quantum.spin.Rotation(*args, **kwargs)[源代码]#

用欧拉角表示的Wigner D算子。

Defines the rotation operator in terms of the Euler angles defined by the z-y-z convention for a passive transformation. That is the coordinate axes are rotated first about the z-axis, giving the new x'-y'-z' axes. Then this new coordinate system is rotated about the new y'-axis, giving new x''-y''-z'' axes. Then this new coordinate system is rotated about the z''-axis. Conventions follow those laid out in [R767].

参数:

阿尔法 ：数字，符号

第一欧拉角

beta ：数字，符号

第二欧拉角

伽马：数字，符号

第三欧拉角

实例

一个简单的旋转操作符示例：

>>> from sympy import pi
>>> from sympy.physics.quantum.spin import Rotation
>>> Rotation(pi, 0, pi/2)
R(pi,0,pi/2)

使用符号欧拉角并计算逆旋转操作符：

>>> from sympy import symbols
>>> a, b, c = symbols('a b c')
>>> Rotation(a, b, c)
R(a,b,c)
>>> Rotation(a, b, c).inverse()
R(-c,-b,-a)

参见

WignerD: 符号Wigner-D函数
D: Wigner-D函数
d: Wigner小d函数

工具书类

[R767] (1,2)

Varshalovich，D A，角动量的量子理论。1988

classmethod D(j, m, mp, alpha, beta, gamma)[源代码]#

维格纳D函数。

返回与参数指定的Wigner-D函数对应的WignerD类的实例。

参数:

j ：编号

总角动量

m ：编号

旋转后沿轴角动量的特征值

mp ：编号

旋转轴角动量的特征值

阿尔法 ：数字，符号

第一欧拉旋转角

beta ：数字，符号

第二欧拉旋转角

伽马：数字，符号

第三欧拉旋转角

实例

返回已定义旋转的Wigner-D矩阵元素，包括数字和符号：

>>> from sympy.physics.quantum.spin import Rotation
>>> from sympy import pi, symbols
>>> alpha, beta, gamma = symbols('alpha beta gamma')
>>> Rotation.D(1, 1, 0,pi, pi/2,-pi)
WignerD(1, 1, 0, pi, pi/2, -pi)

参见

WignerD: 符号Wigner-D函数

classmethod d(j, m, mp, beta)[源代码]#

Wigner小d函数。

返回与参数指定的Wigner-D函数相对应的Wignard类实例，其alpha和gamma角度为0。

参数:

j ：编号

总角动量

m ：编号

旋转后沿轴角动量的特征值

mp ：编号

旋转轴角动量的特征值

beta ：数字，符号

第二欧拉旋转角

实例

返回已定义旋转的Wigner-D矩阵元素，包括数字和符号：

>>> from sympy.physics.quantum.spin import Rotation
>>> from sympy import pi, symbols
>>> beta = symbols('beta')
>>> Rotation.d(1, 1, 0, pi/2)
WignerD(1, 1, 0, 0, pi/2, 0)

参见

WignerD: 符号Wigner-D函数

class sympy.physics.quantum.spin.WignerD(*args, **hints)[源代码]#

Wigner-D函数

Wigner D函数给出了jm表示中旋转算子的矩阵元素。对于欧拉角 \(\alpha\) ， \(\beta\) ， \(\gamma\) ，D函数的定义如下：

\[<j，m |\mathcal{R}（\alpha、\beta、\gamma）| j'，m'>=\delta{jj'}D（j，m，m'，\alpha，\beta，\gamma）\]

Where the rotation operator is as defined by the Rotation class [R768].

以这种方式定义的维格纳D函数给出：

\[D（j，m，m'，\alpha，\beta，\gamma）=e^{-i m\alpha}D（j，m，m'，\beta）e^{-i m'\gamma}\]

其中d是Wigner小d函数，由旋转给出。

Wigner小d函数给出了由第二个Euler角确定的Wigner d函数的分量。这就是Wigner D函数是：

\[D（j，m，m'，\alpha，\beta，\gamma）=e^{-i m\alpha}D（j，m，m'，\beta）e^{-i m'\gamma}\]

其中d是小d函数。Wigner D函数由旋转D给出。

注意，要计算D函数，j、m和mp参数必须是整数或半整数。

参数:

j ：编号

总角动量

m ：编号

旋转后沿轴角动量的特征值

mp ：编号

旋转轴角动量的特征值

阿尔法 ：数字，符号

第一欧拉旋转角

beta ：数字，符号

第二欧拉旋转角

伽马：数字，符号

第三欧拉旋转角

实例

计算简单旋转的Wigner-D矩阵元素：

>>> from sympy.physics.quantum.spin import Rotation
>>> from sympy import pi
>>> rot = Rotation.D(1, 1, 0, pi, pi/2, 0)
>>> rot
WignerD(1, 1, 0, pi, pi/2, 0)
>>> rot.doit()
sqrt(2)/2

求简单旋转的Wigner-d矩阵元

>>> rot = Rotation.d(1, 1, 0, pi/2)
>>> rot
WignerD(1, 1, 0, 0, pi/2, 0)
>>> rot.doit()
-sqrt(2)/2

参见

Rotation: 旋转运算符

工具书类

[R768] (1,2)

Varshalovich，D A，角动量的量子理论。1988

sympy.physics.quantum.spin.couple(expr, jcoupling_list=None)[源代码]#

耦合自旋态的张量积

这个函数可以用来耦合自旋态的非耦合张量积。所有要耦合的本征态必须属于同一类。它将返回本征态的线性组合，这些本征态是Clebsch-Gordan角动量耦合系数确定的耦合pinstate的子类。

参数:

expr ：表达式

包含要耦合的自旋态张量积的表达式。每个状态必须是SpinState的一个子类，并且它们都必须是同一个类。

jcoupling_list ：列表或元组

这个列表的元素是长度为2的子列表，指定自旋空间的耦合顺序。这个长度必须是N-1，其中N是要耦合的张量积中的状态数。此子列表的元素与中每个子列表的前两个元素相同 jcoupling 为JzKetCoupled定义的参数。如果未指定此参数，则采用默认值，即耦合第一和第二乘积基空间，然后将此新耦合空间耦合到第三乘积空间，依此类推

实例

耦合两个空间中数值状态的张量积：

>>> from sympy.physics.quantum.spin import JzKet, couple
>>> from sympy.physics.quantum.tensorproduct import TensorProduct
>>> couple(TensorProduct(JzKet(1,0), JzKet(1,1)))
-sqrt(2)*|1,1,j1=1,j2=1>/2 + sqrt(2)*|2,1,j1=1,j2=1>/2

使用默认耦合方法对三个空间进行数值耦合，即第一个和第二个空间耦合，然后耦合到第三个空间：

>>> couple(TensorProduct(JzKet(1,1), JzKet(1,1), JzKet(1,0)))
sqrt(6)*|2,2,j1=1,j2=1,j3=1,j(1,2)=2>/3 + sqrt(3)*|3,2,j1=1,j2=1,j3=1,j(1,2)=2>/3

执行相同的耦合，但我们将耦合定义为第一个耦合第一个和第三个空间：

>>> couple(TensorProduct(JzKet(1,1), JzKet(1,1), JzKet(1,0)), ((1,3),(1,2)) )
sqrt(2)*|2,2,j1=1,j2=1,j3=1,j(1,3)=1>/2 - sqrt(6)*|2,2,j1=1,j2=1,j3=1,j(1,3)=2>/6 + sqrt(3)*|3,2,j1=1,j2=1,j3=1,j(1,3)=2>/3

耦合符号状态的张量积：

>>> from sympy import symbols
>>> j1,m1,j2,m2 = symbols('j1 m1 j2 m2')
>>> couple(TensorProduct(JzKet(j1,m1), JzKet(j2,m2)))
Sum(CG(j1, m1, j2, m2, j, m1 + m2)*|j,m1 + m2,j1=j1,j2=j2>, (j, m1 + m2, j1 + j2))

sympy.physics.quantum.spin.uncouple(expr, jn=None, jcoupling_list=None)[源代码]#

解耦合自旋态

给出了耦合自旋态的非耦合表示。参数必须是一个自旋状态（它是coupedspinstate的子类），或者是一个自旋状态（SpinState的子类）和一个给出要耦合的空间j值的数组

参数:

expr ：表达式

包含要耦合的状态的表达式。如果状态是SpinState的子类，则 jn 和 jcoupling 必须定义参数。如果状态是coupedSpinState的子类， jn 和 jcoupling 将被从州政府带走。

jn ：列表或元组

耦合的j值列表。如果state是coupedSpinState，则忽略此参数。如果state不是coupedSpinState的子类，则必须定义此属性。此参数的语法与 jn JzKetCoupled的参数。

jcoupling_list ：列表或元组

定义j值如何耦合在一起的列表。如果state是coupedSpinState，则忽略此参数。如果state不是coupedSpinState的子类，则必须定义此属性。此参数的语法与 jcoupling JzKetCoupled的参数。

实例

使用coupedSpinState状态解除数值状态的耦合：

>>> from sympy.physics.quantum.spin import JzKetCoupled, uncouple
>>> from sympy import S
>>> uncouple(JzKetCoupled(1, 0, (S(1)/2, S(1)/2)))
sqrt(2)*|1/2,-1/2>x|1/2,1/2>/2 + sqrt(2)*|1/2,1/2>x|1/2,-1/2>/2

使用SpinState状态执行相同的计算：

>>> from sympy.physics.quantum.spin import JzKet
>>> uncouple(JzKet(1, 0), (S(1)/2, S(1)/2))
sqrt(2)*|1/2,-1/2>x|1/2,1/2>/2 + sqrt(2)*|1/2,1/2>x|1/2,-1/2>/2

使用coupedSpinState状态将三个耦合空间的数值状态解耦：

>>> uncouple(JzKetCoupled(1, 1, (1, 1, 1), ((1,3,1),(1,2,1)) ))
|1,-1>x|1,1>x|1,1>/2 - |1,0>x|1,0>x|1,1>/2 + |1,1>x|1,0>x|1,0>/2 - |1,1>x|1,1>x|1,-1>/2

使用SpinState状态执行相同的计算：

>>> uncouple(JzKet(1, 1), (1, 1, 1), ((1,3,1),(1,2,1)) )
|1,-1>x|1,1>x|1,1>/2 - |1,0>x|1,0>x|1,1>/2 + |1,1>x|1,0>x|1,0>/2 - |1,1>x|1,1>x|1,-1>/2

使用coupedSpinState状态断开符号状态：

>>> from sympy import symbols
>>> j,m,j1,j2 = symbols('j m j1 j2')
>>> uncouple(JzKetCoupled(j, m, (j1, j2)))
Sum(CG(j1, m1, j2, m2, j, m)*|j1,m1>x|j2,m2>, (m1, -j1, j1), (m2, -j2, j2))

使用SpinState状态执行相同的计算

>>> uncouple(JzKet(j, m), (j1, j2))
Sum(CG(j1, m1, j2, m2, j, m)*|j1,m1>x|j2,m2>, (m1, -j1, j1), (m2, -j2, j2))