二次量子化

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

这是遵循费特和韦勒卡的“多粒子系统的量子理论”的公式

class sympy.physics.secondquant.AnnihilateBoson(k)

玻色子湮没算符。

实例

>>> 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。

实例

>>> 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。

实例

>>> 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

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

实例

>>> 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

粒子总是产生准粒子？（创建孔或创建粒子）

实例

>>> 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

我们能摧毁一个准粒子吗？（湮灭空穴或湮灭粒子）如果是的话，那是在费米面之上还是之下？

实例

>>> 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

我们能创造出一个准粒子吗？（创造洞或创造粒子）如果是，那是在费米表面之上还是之下？

实例

>>> 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)

在单独的元组中存储上下索引。

假设每组指标都是反对称的。

实例

>>> 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

返回较低的索引。

实例

>>> 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

返回张量的符号。

实例

>>> 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

返回上层索引。

实例

>>> 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] =一个 B - B A

参数的排序依据是

实例

>>> 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)

启用复杂表达式的计算。

实例

>>> 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是。

实例

>>> 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。

实例

>>> 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。

实例

>>> 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

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

实例

>>> 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

粒子总是产生准粒子？（创建孔或创建粒子）

实例

>>> 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

我们能摧毁一个准粒子吗？（湮灭空穴或湮灭粒子）如果是的话，那是在费米面之上还是之下？

实例

>>> 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

我们能创造出一个准粒子吗？（创造洞或创造粒子）如果是，那是在费米表面之上还是之下？

实例

>>> 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)

计算匕首实例。

实例

>>> 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)

ket的表示。

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

胸罩和肩带之间未经估价的内部产品。

解释

目前这个类只是将事物简化为Kronecker Deltas的产品。将来，我们可以引入抽象状态，比如 |a> 和 |b> ，将内部产品保留为 <a|b> .

property bra

返回状态的bra部分

property ket

返回状态的ket部分

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

离散的，或Kronecker，delta函数。

参数:

i ：数字，符号

delta函数的第一个索引。

j ：数字，符号

delta函数的第二个索引。

解释

接受两个整数\(i\)和\(j\)的函数。如果\(i\)和\(j\)不相等，则返回\(0\)，如果\(i\)和\(j\)相等，则返回\(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]

https://en.wikipedia.org/wiki/Kronecker_delta

classmethod eval(i, j, delta_range=None)

计算离散增量函数。

实例

>>> 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)

#间接试验

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

如果δ在费米之上不为零，则为真。

实例

>>> 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)

此对象用于表示普通顺序括号。

i、 e.{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))

注意

If you want to generate a normal ordered equivalent of an expression, you should use the function wicks(). This class only indicates that all operators inside the brackets anticommute, and have vanishing contractions. Nothing more, nothing less.

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处返回一个不带fermionicooperator的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

如果第一个参数的最左边的参数不是一个qu创建者，则返回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（一）

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)

Take a SymPy expression with operators and states and apply the operators.

实例

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

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

计算费米子算符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_指数以及KroneckerDelta.killable_指数.

如果没有可能的替换，或者如果替换意味着信息丢失，则不会采取任何措施。

如果一个指数出现在不止一个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]

PrimeTyx运算符是要考虑的置换操作列表。

If置换算子= [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表达式。

其思想是根据术语的结构，一致地替换所有虚拟变量。对于每个项，我们得到一个所有虚拟变量的序列，其中顺序由指数范围、指数所属的因子及其在每个因子中的位置决定。有关虚拟对象排序的详细信息，请参见“获取”“有序的”虚拟对象（）。然后在每个项中一致地替换索引序列。

实例

>>> 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_index=True，则将生成并插入新的虚拟对象。关键字“pretty_indexes”可用于控制这一代新符号。

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

{索引组：字符串}

字母将用作新虚拟符号的标签。索引组必须是“高于”、“低于”或“常规”之一。

>>> 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)

如果字母用完，或者某个索引组没有关键字，则默认的虚拟生成器将用作备用：

>>> 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)

返回使用Wicks定理的表达式的正规有序等价物。

实例

>>> 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)