高能物理学#

伽马矩阵#

模块来处理表示为张量对象的伽马矩阵。

实例#

>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, LorentzIndex
>>> from sympy.tensor.tensor import tensor_indices
>>> i = tensor_indices('i', LorentzIndex)
>>> G(i)
GammaMatrix(i)

注意，已经有一个GammaMatrixHead在四个维度中的实例：GammaMatrix，它被简单地声明为

>>> from sympy.physics.hep.gamma_matrices import GammaMatrix
>>> from sympy.tensor.tensor import tensor_indices
>>> i = tensor_indices('i', LorentzIndex)
>>> GammaMatrix(i)
GammaMatrix(i)

访问度量张量

>>> LorentzIndex.metric
metric(LorentzIndex,LorentzIndex)

sympy.physics.hep.gamma_matrices.extract_type_tens(expression, component)[源代码]#

从a中提取 TensExpr 所有张量 \(component\) .

返回两个张量表达式：

第一个包含所有 Tensor 拥有 \(component\) .
第二个包含所有剩余的。

sympy.physics.hep.gamma_matrices.gamma_trace(t)[源代码]#

单列伽马矩阵的迹

实例

>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G,         gamma_trace, LorentzIndex
>>> from sympy.tensor.tensor import tensor_indices, tensor_heads
>>> p, q = tensor_heads('p, q', [LorentzIndex])
>>> i0,i1,i2,i3,i4,i5 = tensor_indices('i0:6', LorentzIndex)
>>> ps = p(i0)*G(-i0)
>>> qs = q(i0)*G(-i0)
>>> gamma_trace(G(i0)*G(i1))
4*metric(i0, i1)
>>> gamma_trace(ps*ps) - 4*p(i0)*p(-i0)
0
>>> gamma_trace(ps*qs + ps*ps) - 4*p(i0)*p(-i0) - 4*p(i0)*q(-i0)
0

sympy.physics.hep.gamma_matrices.kahane_simplify(expression)[源代码]#

此函数用于取消四维伽马矩阵乘积中的收缩元素，从而得到一个等于给定表达式的表达式，而不包含收缩伽马矩阵。

参数:: `expression` the tensor expression containing the gamma matrices to simplify.

笔记

如果给定了旋量指数，矩阵必须按乘积中给定的顺序给出。

算法

算法背后的思想是使用一些众所周知的恒等式，即对于包含偶数个 \(\gamma\) 矩阵

\(\gamma^\mu \gamma_{a_1} \cdots \gamma_{a_{2N}} \gamma_\mu = 2 (\gamma_{a_{2N}} \gamma_{a_1} \cdots \gamma_{a_{2N-1}} + \gamma_{a_{2N-1}} \cdots \gamma_{a_1} \gamma_{a_{2N}} )\)

对于奇数 \(\gamma\) 矩阵

\(\gamma^\mu \gamma_{a_1} \cdots \gamma_{a_{2N+1}} \gamma_\mu = -2 \gamma_{a_{2N+1}} \gamma_{a_{2N}} \cdots \gamma_{a_{1}}\)

不必重复应用这些恒等式来抵消所有收缩指数，而是有可能识别出这种操作所产生的联系，从而将问题简化为自由伽马矩阵的简单重新排列。

实例

使用时，请始终记住原始表达式系数必须单独处理

>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G, LorentzIndex
>>> from sympy.physics.hep.gamma_matrices import kahane_simplify
>>> from sympy.tensor.tensor import tensor_indices
>>> i0, i1, i2 = tensor_indices('i0:3', LorentzIndex)
>>> ta = G(i0)*G(-i0)
>>> kahane_simplify(ta)
Matrix([
[4, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 4]])
>>> tb = G(i0)*G(i1)*G(-i0)
>>> kahane_simplify(tb)
-2*GammaMatrix(i1)
>>> t = G(i0)*G(-i0)
>>> kahane_simplify(t)
Matrix([
[4, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 4]])
>>> t = G(i0)*G(-i0)
>>> kahane_simplify(t)
Matrix([
[4, 0, 0, 0],
[0, 4, 0, 0],
[0, 0, 4, 0],
[0, 0, 0, 4]])

如果没有收缩，则返回相同的表达式

>>> tc = G(i0)*G(i1)
>>> kahane_simplify(tc)
GammaMatrix(i0)*GammaMatrix(i1)

工具书类

[1] 伽马矩阵收缩积的减少算法，约瑟夫·卡恩，数学物理杂志，第9卷，第10期，1968年10月。

sympy.physics.hep.gamma_matrices.simplify_gpgp(ex, sort=True)[源代码]#

产品简化 G(i)*p(-i)*G(j)*p(-j) -> p(i)*p(-i)

实例

>>> from sympy.physics.hep.gamma_matrices import GammaMatrix as G,         LorentzIndex, simplify_gpgp
>>> from sympy.tensor.tensor import tensor_indices, tensor_heads
>>> p, q = tensor_heads('p, q', [LorentzIndex])
>>> i0,i1,i2,i3,i4,i5 = tensor_indices('i0:6', LorentzIndex)
>>> ps = p(i0)*G(-i0)
>>> qs = q(i0)*G(-i0)
>>> simplify_gpgp(ps*qs*qs)
GammaMatrix(-L_0)*p(L_0)*q(L_1)*q(-L_1)