1281 lines
47 KiB
Python
1281 lines
47 KiB
Python
from sympy.physics.secondquant import (
|
|
Dagger, Bd, VarBosonicBasis, BBra, B, BKet, FixedBosonicBasis,
|
|
matrix_rep, apply_operators, InnerProduct, Commutator, KroneckerDelta,
|
|
AnnihilateBoson, CreateBoson, BosonicOperator,
|
|
F, Fd, FKet, BosonState, CreateFermion, AnnihilateFermion,
|
|
evaluate_deltas, AntiSymmetricTensor, contraction, NO, wicks,
|
|
PermutationOperator, simplify_index_permutations,
|
|
_sort_anticommuting_fermions, _get_ordered_dummies,
|
|
substitute_dummies, FockStateBosonKet,
|
|
ContractionAppliesOnlyToFermions
|
|
)
|
|
|
|
from sympy.concrete.summations import Sum
|
|
from sympy.core.function import (Function, expand)
|
|
from sympy.core.numbers import (I, Rational)
|
|
from sympy.core.singleton import S
|
|
from sympy.core.symbol import (Dummy, Symbol, symbols)
|
|
from sympy.functions.elementary.miscellaneous import sqrt
|
|
from sympy.printing.repr import srepr
|
|
from sympy.simplify.simplify import simplify
|
|
|
|
from sympy.testing.pytest import slow, raises
|
|
from sympy.printing.latex import latex
|
|
|
|
|
|
def test_PermutationOperator():
|
|
p, q, r, s = symbols('p,q,r,s')
|
|
f, g, h, i = map(Function, 'fghi')
|
|
P = PermutationOperator
|
|
assert P(p, q).get_permuted(f(p)*g(q)) == -f(q)*g(p)
|
|
assert P(p, q).get_permuted(f(p, q)) == -f(q, p)
|
|
assert P(p, q).get_permuted(f(p)) == f(p)
|
|
expr = (f(p)*g(q)*h(r)*i(s)
|
|
- f(q)*g(p)*h(r)*i(s)
|
|
- f(p)*g(q)*h(s)*i(r)
|
|
+ f(q)*g(p)*h(s)*i(r))
|
|
perms = [P(p, q), P(r, s)]
|
|
assert (simplify_index_permutations(expr, perms) ==
|
|
P(p, q)*P(r, s)*f(p)*g(q)*h(r)*i(s))
|
|
assert latex(P(p, q)) == 'P(pq)'
|
|
|
|
|
|
def test_index_permutations_with_dummies():
|
|
a, b, c, d = symbols('a b c d')
|
|
p, q, r, s = symbols('p q r s', cls=Dummy)
|
|
f, g = map(Function, 'fg')
|
|
P = PermutationOperator
|
|
|
|
# No dummy substitution necessary
|
|
expr = f(a, b, p, q) - f(b, a, p, q)
|
|
assert simplify_index_permutations(
|
|
expr, [P(a, b)]) == P(a, b)*f(a, b, p, q)
|
|
|
|
# Cases where dummy substitution is needed
|
|
expected = P(a, b)*substitute_dummies(f(a, b, p, q))
|
|
|
|
expr = f(a, b, p, q) - f(b, a, q, p)
|
|
result = simplify_index_permutations(expr, [P(a, b)])
|
|
assert expected == substitute_dummies(result)
|
|
|
|
expr = f(a, b, q, p) - f(b, a, p, q)
|
|
result = simplify_index_permutations(expr, [P(a, b)])
|
|
assert expected == substitute_dummies(result)
|
|
|
|
# A case where nothing can be done
|
|
expr = f(a, b, q, p) - g(b, a, p, q)
|
|
result = simplify_index_permutations(expr, [P(a, b)])
|
|
assert expr == result
|
|
|
|
|
|
def test_dagger():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
assert Dagger(1) == 1
|
|
assert Dagger(1.0) == 1.0
|
|
assert Dagger(2*I) == -2*I
|
|
assert Dagger(S.Half*I/3.0) == I*Rational(-1, 2)/3.0
|
|
assert Dagger(BKet([n])) == BBra([n])
|
|
assert Dagger(B(0)) == Bd(0)
|
|
assert Dagger(Bd(0)) == B(0)
|
|
assert Dagger(B(n)) == Bd(n)
|
|
assert Dagger(Bd(n)) == B(n)
|
|
assert Dagger(B(0) + B(1)) == Bd(0) + Bd(1)
|
|
assert Dagger(n*m) == Dagger(n)*Dagger(m) # n, m commute
|
|
assert Dagger(B(n)*B(m)) == Bd(m)*Bd(n)
|
|
assert Dagger(B(n)**10) == Dagger(B(n))**10
|
|
assert Dagger('a') == Dagger(Symbol('a'))
|
|
assert Dagger(Dagger('a')) == Symbol('a')
|
|
|
|
|
|
def test_operator():
|
|
i, j = symbols('i,j')
|
|
o = BosonicOperator(i)
|
|
assert o.state == i
|
|
assert o.is_symbolic
|
|
o = BosonicOperator(1)
|
|
assert o.state == 1
|
|
assert not o.is_symbolic
|
|
|
|
|
|
def test_create():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
o = Bd(i)
|
|
assert latex(o) == "{b^\\dagger_{i}}"
|
|
assert isinstance(o, CreateBoson)
|
|
o = o.subs(i, j)
|
|
assert o.atoms(Symbol) == {j}
|
|
o = Bd(0)
|
|
assert o.apply_operator(BKet([n])) == sqrt(n + 1)*BKet([n + 1])
|
|
o = Bd(n)
|
|
assert o.apply_operator(BKet([n])) == o*BKet([n])
|
|
|
|
|
|
def test_annihilate():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
o = B(i)
|
|
assert latex(o) == "b_{i}"
|
|
assert isinstance(o, AnnihilateBoson)
|
|
o = o.subs(i, j)
|
|
assert o.atoms(Symbol) == {j}
|
|
o = B(0)
|
|
assert o.apply_operator(BKet([n])) == sqrt(n)*BKet([n - 1])
|
|
o = B(n)
|
|
assert o.apply_operator(BKet([n])) == o*BKet([n])
|
|
|
|
|
|
def test_basic_state():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
s = BosonState([0, 1, 2, 3, 4])
|
|
assert len(s) == 5
|
|
assert s.args[0] == tuple(range(5))
|
|
assert s.up(0) == BosonState([1, 1, 2, 3, 4])
|
|
assert s.down(4) == BosonState([0, 1, 2, 3, 3])
|
|
for i in range(5):
|
|
assert s.up(i).down(i) == s
|
|
assert s.down(0) == 0
|
|
for i in range(5):
|
|
assert s[i] == i
|
|
s = BosonState([n, m])
|
|
assert s.down(0) == BosonState([n - 1, m])
|
|
assert s.up(0) == BosonState([n + 1, m])
|
|
|
|
|
|
def test_basic_apply():
|
|
n = symbols("n")
|
|
e = B(0)*BKet([n])
|
|
assert apply_operators(e) == sqrt(n)*BKet([n - 1])
|
|
e = Bd(0)*BKet([n])
|
|
assert apply_operators(e) == sqrt(n + 1)*BKet([n + 1])
|
|
|
|
|
|
def test_complex_apply():
|
|
n, m = symbols("n,m")
|
|
o = Bd(0)*B(0)*Bd(1)*B(0)
|
|
e = apply_operators(o*BKet([n, m]))
|
|
answer = sqrt(n)*sqrt(m + 1)*(-1 + n)*BKet([-1 + n, 1 + m])
|
|
assert expand(e) == expand(answer)
|
|
|
|
|
|
def test_number_operator():
|
|
n = symbols("n")
|
|
o = Bd(0)*B(0)
|
|
e = apply_operators(o*BKet([n]))
|
|
assert e == n*BKet([n])
|
|
|
|
|
|
def test_inner_product():
|
|
i, j, k, l = symbols('i,j,k,l')
|
|
s1 = BBra([0])
|
|
s2 = BKet([1])
|
|
assert InnerProduct(s1, Dagger(s1)) == 1
|
|
assert InnerProduct(s1, s2) == 0
|
|
s1 = BBra([i, j])
|
|
s2 = BKet([k, l])
|
|
r = InnerProduct(s1, s2)
|
|
assert r == KroneckerDelta(i, k)*KroneckerDelta(j, l)
|
|
|
|
|
|
def test_symbolic_matrix_elements():
|
|
n, m = symbols('n,m')
|
|
s1 = BBra([n])
|
|
s2 = BKet([m])
|
|
o = B(0)
|
|
e = apply_operators(s1*o*s2)
|
|
assert e == sqrt(m)*KroneckerDelta(n, m - 1)
|
|
|
|
|
|
def test_matrix_elements():
|
|
b = VarBosonicBasis(5)
|
|
o = B(0)
|
|
m = matrix_rep(o, b)
|
|
for i in range(4):
|
|
assert m[i, i + 1] == sqrt(i + 1)
|
|
o = Bd(0)
|
|
m = matrix_rep(o, b)
|
|
for i in range(4):
|
|
assert m[i + 1, i] == sqrt(i + 1)
|
|
|
|
|
|
def test_fixed_bosonic_basis():
|
|
b = FixedBosonicBasis(2, 2)
|
|
# assert b == [FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]
|
|
state = b.state(1)
|
|
assert state == FockStateBosonKet((1, 1))
|
|
assert b.index(state) == 1
|
|
assert b.state(1) == b[1]
|
|
assert len(b) == 3
|
|
assert str(b) == '[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]'
|
|
assert repr(b) == '[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]'
|
|
assert srepr(b) == '[FockState((2, 0)), FockState((1, 1)), FockState((0, 2))]'
|
|
|
|
|
|
@slow
|
|
def test_sho():
|
|
n, m = symbols('n,m')
|
|
h_n = Bd(n)*B(n)*(n + S.Half)
|
|
H = Sum(h_n, (n, 0, 5))
|
|
o = H.doit(deep=False)
|
|
b = FixedBosonicBasis(2, 6)
|
|
m = matrix_rep(o, b)
|
|
# We need to double check these energy values to make sure that they
|
|
# are correct and have the proper degeneracies!
|
|
diag = [1, 2, 3, 3, 4, 5, 4, 5, 6, 7, 5, 6, 7, 8, 9, 6, 7, 8, 9, 10, 11]
|
|
for i in range(len(diag)):
|
|
assert diag[i] == m[i, i]
|
|
|
|
|
|
def test_commutation():
|
|
n, m = symbols("n,m", above_fermi=True)
|
|
c = Commutator(B(0), Bd(0))
|
|
assert c == 1
|
|
c = Commutator(Bd(0), B(0))
|
|
assert c == -1
|
|
c = Commutator(B(n), Bd(0))
|
|
assert c == KroneckerDelta(n, 0)
|
|
c = Commutator(B(0), B(0))
|
|
assert c == 0
|
|
c = Commutator(B(0), Bd(0))
|
|
e = simplify(apply_operators(c*BKet([n])))
|
|
assert e == BKet([n])
|
|
c = Commutator(B(0), B(1))
|
|
e = simplify(apply_operators(c*BKet([n, m])))
|
|
assert e == 0
|
|
|
|
c = Commutator(F(m), Fd(m))
|
|
assert c == +1 - 2*NO(Fd(m)*F(m))
|
|
c = Commutator(Fd(m), F(m))
|
|
assert c.expand() == -1 + 2*NO(Fd(m)*F(m))
|
|
|
|
C = Commutator
|
|
X, Y, Z = symbols('X,Y,Z', commutative=False)
|
|
assert C(C(X, Y), Z) != 0
|
|
assert C(C(X, Z), Y) != 0
|
|
assert C(Y, C(X, Z)) != 0
|
|
|
|
i, j, k, l = symbols('i,j,k,l', below_fermi=True)
|
|
a, b, c, d = symbols('a,b,c,d', above_fermi=True)
|
|
p, q, r, s = symbols('p,q,r,s')
|
|
D = KroneckerDelta
|
|
|
|
assert C(Fd(a), F(i)) == -2*NO(F(i)*Fd(a))
|
|
assert C(Fd(j), NO(Fd(a)*F(i))).doit(wicks=True) == -D(j, i)*Fd(a)
|
|
assert C(Fd(a)*F(i), Fd(b)*F(j)).doit(wicks=True) == 0
|
|
|
|
c1 = Commutator(F(a), Fd(a))
|
|
assert Commutator.eval(c1, c1) == 0
|
|
c = Commutator(Fd(a)*F(i),Fd(b)*F(j))
|
|
assert latex(c) == r'\left[{a^\dagger_{a}} a_{i},{a^\dagger_{b}} a_{j}\right]'
|
|
assert repr(c) == 'Commutator(CreateFermion(a)*AnnihilateFermion(i),CreateFermion(b)*AnnihilateFermion(j))'
|
|
assert str(c) == '[CreateFermion(a)*AnnihilateFermion(i),CreateFermion(b)*AnnihilateFermion(j)]'
|
|
|
|
|
|
def test_create_f():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
o = Fd(i)
|
|
assert isinstance(o, CreateFermion)
|
|
o = o.subs(i, j)
|
|
assert o.atoms(Symbol) == {j}
|
|
o = Fd(1)
|
|
assert o.apply_operator(FKet([n])) == FKet([1, n])
|
|
assert o.apply_operator(FKet([n])) == -FKet([n, 1])
|
|
o = Fd(n)
|
|
assert o.apply_operator(FKet([])) == FKet([n])
|
|
|
|
vacuum = FKet([], fermi_level=4)
|
|
assert vacuum == FKet([], fermi_level=4)
|
|
|
|
i, j, k, l = symbols('i,j,k,l', below_fermi=True)
|
|
a, b, c, d = symbols('a,b,c,d', above_fermi=True)
|
|
p, q, r, s = symbols('p,q,r,s')
|
|
|
|
assert Fd(i).apply_operator(FKet([i, j, k], 4)) == FKet([j, k], 4)
|
|
assert Fd(a).apply_operator(FKet([i, b, k], 4)) == FKet([a, i, b, k], 4)
|
|
|
|
assert Dagger(B(p)).apply_operator(q) == q*CreateBoson(p)
|
|
assert repr(Fd(p)) == 'CreateFermion(p)'
|
|
assert srepr(Fd(p)) == "CreateFermion(Symbol('p'))"
|
|
assert latex(Fd(p)) == r'{a^\dagger_{p}}'
|
|
|
|
|
|
def test_annihilate_f():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
o = F(i)
|
|
assert isinstance(o, AnnihilateFermion)
|
|
o = o.subs(i, j)
|
|
assert o.atoms(Symbol) == {j}
|
|
o = F(1)
|
|
assert o.apply_operator(FKet([1, n])) == FKet([n])
|
|
assert o.apply_operator(FKet([n, 1])) == -FKet([n])
|
|
o = F(n)
|
|
assert o.apply_operator(FKet([n])) == FKet([])
|
|
|
|
i, j, k, l = symbols('i,j,k,l', below_fermi=True)
|
|
a, b, c, d = symbols('a,b,c,d', above_fermi=True)
|
|
p, q, r, s = symbols('p,q,r,s')
|
|
assert F(i).apply_operator(FKet([i, j, k], 4)) == 0
|
|
assert F(a).apply_operator(FKet([i, b, k], 4)) == 0
|
|
assert F(l).apply_operator(FKet([i, j, k], 3)) == 0
|
|
assert F(l).apply_operator(FKet([i, j, k], 4)) == FKet([l, i, j, k], 4)
|
|
assert str(F(p)) == 'f(p)'
|
|
assert repr(F(p)) == 'AnnihilateFermion(p)'
|
|
assert srepr(F(p)) == "AnnihilateFermion(Symbol('p'))"
|
|
assert latex(F(p)) == 'a_{p}'
|
|
|
|
|
|
def test_create_b():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
o = Bd(i)
|
|
assert isinstance(o, CreateBoson)
|
|
o = o.subs(i, j)
|
|
assert o.atoms(Symbol) == {j}
|
|
o = Bd(0)
|
|
assert o.apply_operator(BKet([n])) == sqrt(n + 1)*BKet([n + 1])
|
|
o = Bd(n)
|
|
assert o.apply_operator(BKet([n])) == o*BKet([n])
|
|
|
|
|
|
def test_annihilate_b():
|
|
i, j, n, m = symbols('i,j,n,m')
|
|
o = B(i)
|
|
assert isinstance(o, AnnihilateBoson)
|
|
o = o.subs(i, j)
|
|
assert o.atoms(Symbol) == {j}
|
|
o = B(0)
|
|
|
|
|
|
def test_wicks():
|
|
p, q, r, s = symbols('p,q,r,s', above_fermi=True)
|
|
|
|
# Testing for particles only
|
|
|
|
str = F(p)*Fd(q)
|
|
assert wicks(str) == NO(F(p)*Fd(q)) + KroneckerDelta(p, q)
|
|
str = Fd(p)*F(q)
|
|
assert wicks(str) == NO(Fd(p)*F(q))
|
|
|
|
str = F(p)*Fd(q)*F(r)*Fd(s)
|
|
nstr = wicks(str)
|
|
fasit = NO(
|
|
KroneckerDelta(p, q)*KroneckerDelta(r, s)
|
|
+ KroneckerDelta(p, q)*AnnihilateFermion(r)*CreateFermion(s)
|
|
+ KroneckerDelta(r, s)*AnnihilateFermion(p)*CreateFermion(q)
|
|
- KroneckerDelta(p, s)*AnnihilateFermion(r)*CreateFermion(q)
|
|
- AnnihilateFermion(p)*AnnihilateFermion(r)*CreateFermion(q)*CreateFermion(s))
|
|
assert nstr == fasit
|
|
|
|
assert (p*q*nstr).expand() == wicks(p*q*str)
|
|
assert (nstr*p*q*2).expand() == wicks(str*p*q*2)
|
|
|
|
# Testing CC equations particles and holes
|
|
i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
|
|
p, q, r, s = symbols('p q r s', cls=Dummy)
|
|
|
|
assert (wicks(F(a)*NO(F(i)*F(j))*Fd(b)) ==
|
|
NO(F(a)*F(i)*F(j)*Fd(b)) +
|
|
KroneckerDelta(a, b)*NO(F(i)*F(j)))
|
|
assert (wicks(F(a)*NO(F(i)*F(j)*F(k))*Fd(b)) ==
|
|
NO(F(a)*F(i)*F(j)*F(k)*Fd(b)) -
|
|
KroneckerDelta(a, b)*NO(F(i)*F(j)*F(k)))
|
|
|
|
expr = wicks(Fd(i)*NO(Fd(j)*F(k))*F(l))
|
|
assert (expr ==
|
|
-KroneckerDelta(i, k)*NO(Fd(j)*F(l)) -
|
|
KroneckerDelta(j, l)*NO(Fd(i)*F(k)) -
|
|
KroneckerDelta(i, k)*KroneckerDelta(j, l) +
|
|
KroneckerDelta(i, l)*NO(Fd(j)*F(k)) +
|
|
NO(Fd(i)*Fd(j)*F(k)*F(l)))
|
|
expr = wicks(F(a)*NO(F(b)*Fd(c))*Fd(d))
|
|
assert (expr ==
|
|
-KroneckerDelta(a, c)*NO(F(b)*Fd(d)) -
|
|
KroneckerDelta(b, d)*NO(F(a)*Fd(c)) -
|
|
KroneckerDelta(a, c)*KroneckerDelta(b, d) +
|
|
KroneckerDelta(a, d)*NO(F(b)*Fd(c)) +
|
|
NO(F(a)*F(b)*Fd(c)*Fd(d)))
|
|
|
|
|
|
def test_NO():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True)
|
|
p, q, r, s = symbols('p q r s', cls=Dummy)
|
|
|
|
assert (NO(Fd(p)*F(q) + Fd(a)*F(b)) ==
|
|
NO(Fd(p)*F(q)) + NO(Fd(a)*F(b)))
|
|
assert (NO(Fd(i)*NO(F(j)*Fd(a))) ==
|
|
NO(Fd(i)*F(j)*Fd(a)))
|
|
assert NO(1) == 1
|
|
assert NO(i) == i
|
|
assert (NO(Fd(a)*Fd(b)*(F(c) + F(d))) ==
|
|
NO(Fd(a)*Fd(b)*F(c)) +
|
|
NO(Fd(a)*Fd(b)*F(d)))
|
|
|
|
assert NO(Fd(a)*F(b))._remove_brackets() == Fd(a)*F(b)
|
|
assert NO(F(j)*Fd(i))._remove_brackets() == F(j)*Fd(i)
|
|
|
|
assert (NO(Fd(p)*F(q)).subs(Fd(p), Fd(a) + Fd(i)) ==
|
|
NO(Fd(a)*F(q)) + NO(Fd(i)*F(q)))
|
|
assert (NO(Fd(p)*F(q)).subs(F(q), F(a) + F(i)) ==
|
|
NO(Fd(p)*F(a)) + NO(Fd(p)*F(i)))
|
|
|
|
expr = NO(Fd(p)*F(q))._remove_brackets()
|
|
assert wicks(expr) == NO(expr)
|
|
|
|
assert NO(Fd(a)*F(b)) == - NO(F(b)*Fd(a))
|
|
|
|
no = NO(Fd(a)*F(i)*F(b)*Fd(j))
|
|
l1 = list(no.iter_q_creators())
|
|
assert l1 == [0, 1]
|
|
l2 = list(no.iter_q_annihilators())
|
|
assert l2 == [3, 2]
|
|
no = NO(Fd(a)*Fd(i))
|
|
assert no.has_q_creators == 1
|
|
assert no.has_q_annihilators == -1
|
|
assert str(no) == ':CreateFermion(a)*CreateFermion(i):'
|
|
assert repr(no) == 'NO(CreateFermion(a)*CreateFermion(i))'
|
|
assert latex(no) == r'\left\{{a^\dagger_{a}} {a^\dagger_{i}}\right\}'
|
|
raises(NotImplementedError, lambda: NO(Bd(p)*F(q)))
|
|
|
|
|
|
def test_sorting():
|
|
i, j = symbols('i,j', below_fermi=True)
|
|
a, b = symbols('a,b', above_fermi=True)
|
|
p, q = symbols('p,q')
|
|
|
|
# p, q
|
|
assert _sort_anticommuting_fermions([Fd(p), F(q)]) == ([Fd(p), F(q)], 0)
|
|
assert _sort_anticommuting_fermions([F(p), Fd(q)]) == ([Fd(q), F(p)], 1)
|
|
|
|
# i, p
|
|
assert _sort_anticommuting_fermions([F(p), Fd(i)]) == ([F(p), Fd(i)], 0)
|
|
assert _sort_anticommuting_fermions([Fd(i), F(p)]) == ([F(p), Fd(i)], 1)
|
|
assert _sort_anticommuting_fermions([Fd(p), Fd(i)]) == ([Fd(p), Fd(i)], 0)
|
|
assert _sort_anticommuting_fermions([Fd(i), Fd(p)]) == ([Fd(p), Fd(i)], 1)
|
|
assert _sort_anticommuting_fermions([F(p), F(i)]) == ([F(i), F(p)], 1)
|
|
assert _sort_anticommuting_fermions([F(i), F(p)]) == ([F(i), F(p)], 0)
|
|
assert _sort_anticommuting_fermions([Fd(p), F(i)]) == ([F(i), Fd(p)], 1)
|
|
assert _sort_anticommuting_fermions([F(i), Fd(p)]) == ([F(i), Fd(p)], 0)
|
|
|
|
# a, p
|
|
assert _sort_anticommuting_fermions([F(p), Fd(a)]) == ([Fd(a), F(p)], 1)
|
|
assert _sort_anticommuting_fermions([Fd(a), F(p)]) == ([Fd(a), F(p)], 0)
|
|
assert _sort_anticommuting_fermions([Fd(p), Fd(a)]) == ([Fd(a), Fd(p)], 1)
|
|
assert _sort_anticommuting_fermions([Fd(a), Fd(p)]) == ([Fd(a), Fd(p)], 0)
|
|
assert _sort_anticommuting_fermions([F(p), F(a)]) == ([F(p), F(a)], 0)
|
|
assert _sort_anticommuting_fermions([F(a), F(p)]) == ([F(p), F(a)], 1)
|
|
assert _sort_anticommuting_fermions([Fd(p), F(a)]) == ([Fd(p), F(a)], 0)
|
|
assert _sort_anticommuting_fermions([F(a), Fd(p)]) == ([Fd(p), F(a)], 1)
|
|
|
|
# i, a
|
|
assert _sort_anticommuting_fermions([F(i), Fd(j)]) == ([F(i), Fd(j)], 0)
|
|
assert _sort_anticommuting_fermions([Fd(j), F(i)]) == ([F(i), Fd(j)], 1)
|
|
assert _sort_anticommuting_fermions([Fd(a), Fd(i)]) == ([Fd(a), Fd(i)], 0)
|
|
assert _sort_anticommuting_fermions([Fd(i), Fd(a)]) == ([Fd(a), Fd(i)], 1)
|
|
assert _sort_anticommuting_fermions([F(a), F(i)]) == ([F(i), F(a)], 1)
|
|
assert _sort_anticommuting_fermions([F(i), F(a)]) == ([F(i), F(a)], 0)
|
|
|
|
|
|
def test_contraction():
|
|
i, j, k, l = symbols('i,j,k,l', below_fermi=True)
|
|
a, b, c, d = symbols('a,b,c,d', above_fermi=True)
|
|
p, q, r, s = symbols('p,q,r,s')
|
|
assert contraction(Fd(i), F(j)) == KroneckerDelta(i, j)
|
|
assert contraction(F(a), Fd(b)) == KroneckerDelta(a, b)
|
|
assert contraction(F(a), Fd(i)) == 0
|
|
assert contraction(Fd(a), F(i)) == 0
|
|
assert contraction(F(i), Fd(a)) == 0
|
|
assert contraction(Fd(i), F(a)) == 0
|
|
assert contraction(Fd(i), F(p)) == KroneckerDelta(i, p)
|
|
restr = evaluate_deltas(contraction(Fd(p), F(q)))
|
|
assert restr.is_only_below_fermi
|
|
restr = evaluate_deltas(contraction(F(p), Fd(q)))
|
|
assert restr.is_only_above_fermi
|
|
raises(ContractionAppliesOnlyToFermions, lambda: contraction(B(a), Fd(b)))
|
|
|
|
|
|
def test_evaluate_deltas():
|
|
i, j, k = symbols('i,j,k')
|
|
|
|
r = KroneckerDelta(i, j) * KroneckerDelta(j, k)
|
|
assert evaluate_deltas(r) == KroneckerDelta(i, k)
|
|
|
|
r = KroneckerDelta(i, 0) * KroneckerDelta(j, k)
|
|
assert evaluate_deltas(r) == KroneckerDelta(i, 0) * KroneckerDelta(j, k)
|
|
|
|
r = KroneckerDelta(1, j) * KroneckerDelta(j, k)
|
|
assert evaluate_deltas(r) == KroneckerDelta(1, k)
|
|
|
|
r = KroneckerDelta(j, 2) * KroneckerDelta(k, j)
|
|
assert evaluate_deltas(r) == KroneckerDelta(2, k)
|
|
|
|
r = KroneckerDelta(i, 0) * KroneckerDelta(i, j) * KroneckerDelta(j, 1)
|
|
assert evaluate_deltas(r) == 0
|
|
|
|
r = (KroneckerDelta(0, i) * KroneckerDelta(0, j)
|
|
* KroneckerDelta(1, j) * KroneckerDelta(1, j))
|
|
assert evaluate_deltas(r) == 0
|
|
|
|
|
|
def test_Tensors():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
|
|
p, q, r, s = symbols('p q r s')
|
|
|
|
AT = AntiSymmetricTensor
|
|
assert AT('t', (a, b), (i, j)) == -AT('t', (b, a), (i, j))
|
|
assert AT('t', (a, b), (i, j)) == AT('t', (b, a), (j, i))
|
|
assert AT('t', (a, b), (i, j)) == -AT('t', (a, b), (j, i))
|
|
assert AT('t', (a, a), (i, j)) == 0
|
|
assert AT('t', (a, b), (i, i)) == 0
|
|
assert AT('t', (a, b, c), (i, j)) == -AT('t', (b, a, c), (i, j))
|
|
assert AT('t', (a, b, c), (i, j, k)) == AT('t', (b, a, c), (i, k, j))
|
|
|
|
tabij = AT('t', (a, b), (i, j))
|
|
assert tabij.has(a)
|
|
assert tabij.has(b)
|
|
assert tabij.has(i)
|
|
assert tabij.has(j)
|
|
assert tabij.subs(b, c) == AT('t', (a, c), (i, j))
|
|
assert (2*tabij).subs(i, c) == 2*AT('t', (a, b), (c, j))
|
|
assert tabij.symbol == Symbol('t')
|
|
assert latex(tabij) == '{t^{ab}_{ij}}'
|
|
assert str(tabij) == 't((_a, _b),(_i, _j))'
|
|
|
|
assert AT('t', (a, a), (i, j)).subs(a, b) == AT('t', (b, b), (i, j))
|
|
assert AT('t', (a, i), (a, j)).subs(a, b) == AT('t', (b, i), (b, j))
|
|
|
|
|
|
def test_fully_contracted():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True)
|
|
p, q, r, s = symbols('p q r s', cls=Dummy)
|
|
|
|
Fock = (AntiSymmetricTensor('f', (p,), (q,))*
|
|
NO(Fd(p)*F(q)))
|
|
V = (AntiSymmetricTensor('v', (p, q), (r, s))*
|
|
NO(Fd(p)*Fd(q)*F(s)*F(r)))/4
|
|
|
|
Fai = wicks(NO(Fd(i)*F(a))*Fock,
|
|
keep_only_fully_contracted=True,
|
|
simplify_kronecker_deltas=True)
|
|
assert Fai == AntiSymmetricTensor('f', (a,), (i,))
|
|
Vabij = wicks(NO(Fd(i)*Fd(j)*F(b)*F(a))*V,
|
|
keep_only_fully_contracted=True,
|
|
simplify_kronecker_deltas=True)
|
|
assert Vabij == AntiSymmetricTensor('v', (a, b), (i, j))
|
|
|
|
|
|
def test_substitute_dummies_without_dummies():
|
|
i, j = symbols('i,j')
|
|
assert substitute_dummies(att(i, j) + 2) == att(i, j) + 2
|
|
assert substitute_dummies(att(i, j) + 1) == att(i, j) + 1
|
|
|
|
|
|
def test_substitute_dummies_NO_operator():
|
|
i, j = symbols('i j', cls=Dummy)
|
|
assert substitute_dummies(att(i, j)*NO(Fd(i)*F(j))
|
|
- att(j, i)*NO(Fd(j)*F(i))) == 0
|
|
|
|
|
|
def test_substitute_dummies_SQ_operator():
|
|
i, j = symbols('i j', cls=Dummy)
|
|
assert substitute_dummies(att(i, j)*Fd(i)*F(j)
|
|
- att(j, i)*Fd(j)*F(i)) == 0
|
|
|
|
|
|
def test_substitute_dummies_new_indices():
|
|
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')
|
|
assert substitute_dummies(f(i, a, p) - f(j, b, q), new_indices=True) == 0
|
|
|
|
|
|
def test_substitute_dummies_substitution_order():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
|
|
f = Function('f')
|
|
from sympy.utilities.iterables import variations
|
|
for permut in variations([i, j, k, l], 4):
|
|
assert substitute_dummies(f(*permut) - f(i, j, k, l)) == 0
|
|
|
|
|
|
def test_dummy_order_inner_outer_lines_VT1T1T1():
|
|
ii = symbols('i', below_fermi=True)
|
|
aa = symbols('a', above_fermi=True)
|
|
k, l = symbols('k l', below_fermi=True, cls=Dummy)
|
|
c, d = symbols('c d', above_fermi=True, cls=Dummy)
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
|
|
# Coupled-Cluster T1 terms with V*T1*T1*T1
|
|
# t^{a}_{k} t^{c}_{i} t^{d}_{l} v^{lk}_{dc}
|
|
exprs = [
|
|
# permut v and t <=> swapping internal lines, equivalent
|
|
# irrespective of symmetries in v
|
|
v(k, l, c, d)*t(c, ii)*t(d, l)*t(aa, k),
|
|
v(l, k, c, d)*t(c, ii)*t(d, k)*t(aa, l),
|
|
v(k, l, d, c)*t(d, ii)*t(c, l)*t(aa, k),
|
|
v(l, k, d, c)*t(d, ii)*t(c, k)*t(aa, l),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_dummy_order_inner_outer_lines_VT1T1T1T1():
|
|
ii, jj = symbols('i j', below_fermi=True)
|
|
aa, bb = symbols('a b', above_fermi=True)
|
|
k, l = symbols('k l', below_fermi=True, cls=Dummy)
|
|
c, d = symbols('c d', above_fermi=True, cls=Dummy)
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
|
|
# Coupled-Cluster T2 terms with V*T1*T1*T1*T1
|
|
exprs = [
|
|
# permut t <=> swapping external lines, not equivalent
|
|
# except if v has certain symmetries.
|
|
v(k, l, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
|
|
v(k, l, c, d)*t(c, jj)*t(d, ii)*t(aa, k)*t(bb, l),
|
|
v(k, l, c, d)*t(c, ii)*t(d, jj)*t(bb, k)*t(aa, l),
|
|
v(k, l, c, d)*t(c, jj)*t(d, ii)*t(bb, k)*t(aa, l),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
exprs = [
|
|
# permut v <=> swapping external lines, not equivalent
|
|
# except if v has certain symmetries.
|
|
#
|
|
# Note that in contrast to above, these permutations have identical
|
|
# dummy order. That is because the proximity to external indices
|
|
# has higher influence on the canonical dummy ordering than the
|
|
# position of a dummy on the factors. In fact, the terms here are
|
|
# similar in structure as the result of the dummy substitutions above.
|
|
v(k, l, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
|
|
v(l, k, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
|
|
v(k, l, d, c)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
|
|
v(l, k, d, c)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) == dums(permut)
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
exprs = [
|
|
# permut t and v <=> swapping internal lines, equivalent.
|
|
# Canonical dummy order is different, and a consistent
|
|
# substitution reveals the equivalence.
|
|
v(k, l, c, d)*t(c, ii)*t(d, jj)*t(aa, k)*t(bb, l),
|
|
v(k, l, d, c)*t(c, jj)*t(d, ii)*t(aa, k)*t(bb, l),
|
|
v(l, k, c, d)*t(c, ii)*t(d, jj)*t(bb, k)*t(aa, l),
|
|
v(l, k, d, c)*t(c, jj)*t(d, ii)*t(bb, k)*t(aa, l),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_get_subNO():
|
|
p, q, r = symbols('p,q,r')
|
|
assert NO(F(p)*F(q)*F(r)).get_subNO(1) == NO(F(p)*F(r))
|
|
assert NO(F(p)*F(q)*F(r)).get_subNO(0) == NO(F(q)*F(r))
|
|
assert NO(F(p)*F(q)*F(r)).get_subNO(2) == NO(F(p)*F(q))
|
|
|
|
|
|
def test_equivalent_internal_lines_VT1T1():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
|
|
exprs = [ # permute v. Different dummy order. Not equivalent.
|
|
v(i, j, a, b)*t(a, i)*t(b, j),
|
|
v(j, i, a, b)*t(a, i)*t(b, j),
|
|
v(i, j, b, a)*t(a, i)*t(b, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [ # permute v. Different dummy order. Equivalent
|
|
v(i, j, a, b)*t(a, i)*t(b, j),
|
|
v(j, i, b, a)*t(a, i)*t(b, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
exprs = [ # permute t. Same dummy order, not equivalent.
|
|
v(i, j, a, b)*t(a, i)*t(b, j),
|
|
v(i, j, a, b)*t(b, i)*t(a, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) == dums(permut)
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [ # permute v and t. Different dummy order, equivalent
|
|
v(i, j, a, b)*t(a, i)*t(b, j),
|
|
v(j, i, a, b)*t(a, j)*t(b, i),
|
|
v(i, j, b, a)*t(b, i)*t(a, j),
|
|
v(j, i, b, a)*t(b, j)*t(a, i),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_equivalent_internal_lines_VT2conjT2():
|
|
# this diagram requires special handling in TCE
|
|
i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
|
|
a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
|
|
p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
|
|
h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
|
|
|
|
from sympy.utilities.iterables import variations
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
|
|
# v(abcd)t(abij)t(ijcd)
|
|
template = v(p1, p2, p3, p4)*t(p1, p2, i, j)*t(i, j, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert dums(base) != dums(expr)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
template = v(p1, p2, p3, p4)*t(p1, p2, j, i)*t(j, i, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert dums(base) != dums(expr)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
# v(abcd)t(abij)t(jicd)
|
|
template = v(p1, p2, p3, p4)*t(p1, p2, i, j)*t(j, i, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert dums(base) != dums(expr)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
template = v(p1, p2, p3, p4)*t(p1, p2, j, i)*t(i, j, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert dums(base) != dums(expr)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
|
|
def test_equivalent_internal_lines_VT2conjT2_ambiguous_order():
|
|
# These diagrams invokes _determine_ambiguous() because the
|
|
# dummies can not be ordered unambiguously by the key alone
|
|
i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
|
|
a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
|
|
p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
|
|
h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
|
|
|
|
from sympy.utilities.iterables import variations
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
|
|
# v(abcd)t(abij)t(cdij)
|
|
template = v(p1, p2, p3, p4)*t(p1, p2, i, j)*t(p3, p4, i, j)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert dums(base) != dums(expr)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
template = v(p1, p2, p3, p4)*t(p1, p2, j, i)*t(p3, p4, i, j)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert dums(base) != dums(expr)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
|
|
def test_equivalent_internal_lines_VT2():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
exprs = [
|
|
# permute v. Same dummy order, not equivalent.
|
|
#
|
|
# This test show that the dummy order may not be sensitive to all
|
|
# index permutations. The following expressions have identical
|
|
# structure as the resulting terms from of the dummy substitutions
|
|
# in the test above. Here, all expressions have the same dummy
|
|
# order, so they cannot be simplified by means of dummy
|
|
# substitution. In order to simplify further, it is necessary to
|
|
# exploit symmetries in the objects, for instance if t or v is
|
|
# antisymmetric.
|
|
v(i, j, a, b)*t(a, b, i, j),
|
|
v(j, i, a, b)*t(a, b, i, j),
|
|
v(i, j, b, a)*t(a, b, i, j),
|
|
v(j, i, b, a)*t(a, b, i, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) == dums(permut)
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [
|
|
# permute t.
|
|
v(i, j, a, b)*t(a, b, i, j),
|
|
v(i, j, a, b)*t(b, a, i, j),
|
|
v(i, j, a, b)*t(a, b, j, i),
|
|
v(i, j, a, b)*t(b, a, j, i),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [ # permute v and t. Relabelling of dummies should be equivalent.
|
|
v(i, j, a, b)*t(a, b, i, j),
|
|
v(j, i, a, b)*t(a, b, j, i),
|
|
v(i, j, b, a)*t(b, a, i, j),
|
|
v(j, i, b, a)*t(b, a, j, i),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_internal_external_VT2T2():
|
|
ii, jj = symbols('i j', below_fermi=True)
|
|
aa, bb = symbols('a b', above_fermi=True)
|
|
k, l = symbols('k l', below_fermi=True, cls=Dummy)
|
|
c, d = symbols('c d', above_fermi=True, cls=Dummy)
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
|
|
exprs = [
|
|
v(k, l, c, d)*t(aa, c, ii, k)*t(bb, d, jj, l),
|
|
v(l, k, c, d)*t(aa, c, ii, l)*t(bb, d, jj, k),
|
|
v(k, l, d, c)*t(aa, d, ii, k)*t(bb, c, jj, l),
|
|
v(l, k, d, c)*t(aa, d, ii, l)*t(bb, c, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
exprs = [
|
|
v(k, l, c, d)*t(aa, c, ii, k)*t(d, bb, jj, l),
|
|
v(l, k, c, d)*t(aa, c, ii, l)*t(d, bb, jj, k),
|
|
v(k, l, d, c)*t(aa, d, ii, k)*t(c, bb, jj, l),
|
|
v(l, k, d, c)*t(aa, d, ii, l)*t(c, bb, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
exprs = [
|
|
v(k, l, c, d)*t(c, aa, ii, k)*t(bb, d, jj, l),
|
|
v(l, k, c, d)*t(c, aa, ii, l)*t(bb, d, jj, k),
|
|
v(k, l, d, c)*t(d, aa, ii, k)*t(bb, c, jj, l),
|
|
v(l, k, d, c)*t(d, aa, ii, l)*t(bb, c, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_internal_external_pqrs():
|
|
ii, jj = symbols('i j')
|
|
aa, bb = symbols('a b')
|
|
k, l = symbols('k l', cls=Dummy)
|
|
c, d = symbols('c d', cls=Dummy)
|
|
|
|
v = Function('v')
|
|
t = Function('t')
|
|
dums = _get_ordered_dummies
|
|
|
|
exprs = [
|
|
v(k, l, c, d)*t(aa, c, ii, k)*t(bb, d, jj, l),
|
|
v(l, k, c, d)*t(aa, c, ii, l)*t(bb, d, jj, k),
|
|
v(k, l, d, c)*t(aa, d, ii, k)*t(bb, c, jj, l),
|
|
v(l, k, d, c)*t(aa, d, ii, l)*t(bb, c, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert dums(exprs[0]) != dums(permut)
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_dummy_order_well_defined():
|
|
aa, bb = symbols('a b', above_fermi=True)
|
|
k, l, m = symbols('k l m', below_fermi=True, cls=Dummy)
|
|
c, d = symbols('c d', above_fermi=True, cls=Dummy)
|
|
p, q = symbols('p q', cls=Dummy)
|
|
|
|
A = Function('A')
|
|
B = Function('B')
|
|
C = Function('C')
|
|
dums = _get_ordered_dummies
|
|
|
|
# We go through all key components in the order of increasing priority,
|
|
# and consider only fully orderable expressions. Non-orderable expressions
|
|
# are tested elsewhere.
|
|
|
|
# pos in first factor determines sort order
|
|
assert dums(A(k, l)*B(l, k)) == [k, l]
|
|
assert dums(A(l, k)*B(l, k)) == [l, k]
|
|
assert dums(A(k, l)*B(k, l)) == [k, l]
|
|
assert dums(A(l, k)*B(k, l)) == [l, k]
|
|
|
|
# factors involving the index
|
|
assert dums(A(k, l)*B(l, m)*C(k, m)) == [l, k, m]
|
|
assert dums(A(k, l)*B(l, m)*C(m, k)) == [l, k, m]
|
|
assert dums(A(l, k)*B(l, m)*C(k, m)) == [l, k, m]
|
|
assert dums(A(l, k)*B(l, m)*C(m, k)) == [l, k, m]
|
|
assert dums(A(k, l)*B(m, l)*C(k, m)) == [l, k, m]
|
|
assert dums(A(k, l)*B(m, l)*C(m, k)) == [l, k, m]
|
|
assert dums(A(l, k)*B(m, l)*C(k, m)) == [l, k, m]
|
|
assert dums(A(l, k)*B(m, l)*C(m, k)) == [l, k, m]
|
|
|
|
# same, but with factor order determined by non-dummies
|
|
assert dums(A(k, aa, l)*A(l, bb, m)*A(bb, k, m)) == [l, k, m]
|
|
assert dums(A(k, aa, l)*A(l, bb, m)*A(bb, m, k)) == [l, k, m]
|
|
assert dums(A(k, aa, l)*A(m, bb, l)*A(bb, k, m)) == [l, k, m]
|
|
assert dums(A(k, aa, l)*A(m, bb, l)*A(bb, m, k)) == [l, k, m]
|
|
assert dums(A(l, aa, k)*A(l, bb, m)*A(bb, k, m)) == [l, k, m]
|
|
assert dums(A(l, aa, k)*A(l, bb, m)*A(bb, m, k)) == [l, k, m]
|
|
assert dums(A(l, aa, k)*A(m, bb, l)*A(bb, k, m)) == [l, k, m]
|
|
assert dums(A(l, aa, k)*A(m, bb, l)*A(bb, m, k)) == [l, k, m]
|
|
|
|
# index range
|
|
assert dums(A(p, c, k)*B(p, c, k)) == [k, c, p]
|
|
assert dums(A(p, k, c)*B(p, c, k)) == [k, c, p]
|
|
assert dums(A(c, k, p)*B(p, c, k)) == [k, c, p]
|
|
assert dums(A(c, p, k)*B(p, c, k)) == [k, c, p]
|
|
assert dums(A(k, c, p)*B(p, c, k)) == [k, c, p]
|
|
assert dums(A(k, p, c)*B(p, c, k)) == [k, c, p]
|
|
assert dums(B(p, c, k)*A(p, c, k)) == [k, c, p]
|
|
assert dums(B(p, k, c)*A(p, c, k)) == [k, c, p]
|
|
assert dums(B(c, k, p)*A(p, c, k)) == [k, c, p]
|
|
assert dums(B(c, p, k)*A(p, c, k)) == [k, c, p]
|
|
assert dums(B(k, c, p)*A(p, c, k)) == [k, c, p]
|
|
assert dums(B(k, p, c)*A(p, c, k)) == [k, c, p]
|
|
|
|
|
|
def test_dummy_order_ambiguous():
|
|
aa, bb = symbols('a b', above_fermi=True)
|
|
i, j, k, l, m = symbols('i j k l m', below_fermi=True, cls=Dummy)
|
|
a, b, c, d, e = symbols('a b c d e', above_fermi=True, cls=Dummy)
|
|
p, q = symbols('p q', cls=Dummy)
|
|
p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
|
|
p5, p6, p7, p8 = symbols('p5 p6 p7 p8', above_fermi=True, cls=Dummy)
|
|
h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
|
|
h5, h6, h7, h8 = symbols('h5 h6 h7 h8', below_fermi=True, cls=Dummy)
|
|
|
|
A = Function('A')
|
|
B = Function('B')
|
|
|
|
from sympy.utilities.iterables import variations
|
|
|
|
# A*A*A*A*B -- ordering of p5 and p4 is used to figure out the rest
|
|
template = A(p1, p2)*A(p4, p1)*A(p2, p3)*A(p3, p5)*B(p5, p4)
|
|
permutator = variations([a, b, c, d, e], 5)
|
|
base = template.subs(zip([p1, p2, p3, p4, p5], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4, p5], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
# A*A*A*A*A -- an arbitrary index is assigned and the rest are figured out
|
|
template = A(p1, p2)*A(p4, p1)*A(p2, p3)*A(p3, p5)*A(p5, p4)
|
|
permutator = variations([a, b, c, d, e], 5)
|
|
base = template.subs(zip([p1, p2, p3, p4, p5], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4, p5], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
# A*A*A -- ordering of p5 and p4 is used to figure out the rest
|
|
template = A(p1, p2, p4, p1)*A(p2, p3, p3, p5)*A(p5, p4)
|
|
permutator = variations([a, b, c, d, e], 5)
|
|
base = template.subs(zip([p1, p2, p3, p4, p5], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4, p5], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
|
|
def atv(*args):
|
|
return AntiSymmetricTensor('v', args[:2], args[2:] )
|
|
|
|
|
|
def att(*args):
|
|
if len(args) == 4:
|
|
return AntiSymmetricTensor('t', args[:2], args[2:] )
|
|
elif len(args) == 2:
|
|
return AntiSymmetricTensor('t', (args[0],), (args[1],))
|
|
|
|
|
|
def test_dummy_order_inner_outer_lines_VT1T1T1_AT():
|
|
ii = symbols('i', below_fermi=True)
|
|
aa = symbols('a', above_fermi=True)
|
|
k, l = symbols('k l', below_fermi=True, cls=Dummy)
|
|
c, d = symbols('c d', above_fermi=True, cls=Dummy)
|
|
|
|
# Coupled-Cluster T1 terms with V*T1*T1*T1
|
|
# t^{a}_{k} t^{c}_{i} t^{d}_{l} v^{lk}_{dc}
|
|
exprs = [
|
|
# permut v and t <=> swapping internal lines, equivalent
|
|
# irrespective of symmetries in v
|
|
atv(k, l, c, d)*att(c, ii)*att(d, l)*att(aa, k),
|
|
atv(l, k, c, d)*att(c, ii)*att(d, k)*att(aa, l),
|
|
atv(k, l, d, c)*att(d, ii)*att(c, l)*att(aa, k),
|
|
atv(l, k, d, c)*att(d, ii)*att(c, k)*att(aa, l),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_dummy_order_inner_outer_lines_VT1T1T1T1_AT():
|
|
ii, jj = symbols('i j', below_fermi=True)
|
|
aa, bb = symbols('a b', above_fermi=True)
|
|
k, l = symbols('k l', below_fermi=True, cls=Dummy)
|
|
c, d = symbols('c d', above_fermi=True, cls=Dummy)
|
|
|
|
# Coupled-Cluster T2 terms with V*T1*T1*T1*T1
|
|
# non-equivalent substitutions (change of sign)
|
|
exprs = [
|
|
# permut t <=> swapping external lines
|
|
atv(k, l, c, d)*att(c, ii)*att(d, jj)*att(aa, k)*att(bb, l),
|
|
atv(k, l, c, d)*att(c, jj)*att(d, ii)*att(aa, k)*att(bb, l),
|
|
atv(k, l, c, d)*att(c, ii)*att(d, jj)*att(bb, k)*att(aa, l),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == -substitute_dummies(permut)
|
|
|
|
# equivalent substitutions
|
|
exprs = [
|
|
atv(k, l, c, d)*att(c, ii)*att(d, jj)*att(aa, k)*att(bb, l),
|
|
# permut t <=> swapping external lines
|
|
atv(k, l, c, d)*att(c, jj)*att(d, ii)*att(bb, k)*att(aa, l),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_equivalent_internal_lines_VT1T1_AT():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
|
|
|
|
exprs = [ # permute v. Different dummy order. Not equivalent.
|
|
atv(i, j, a, b)*att(a, i)*att(b, j),
|
|
atv(j, i, a, b)*att(a, i)*att(b, j),
|
|
atv(i, j, b, a)*att(a, i)*att(b, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [ # permute v. Different dummy order. Equivalent
|
|
atv(i, j, a, b)*att(a, i)*att(b, j),
|
|
atv(j, i, b, a)*att(a, i)*att(b, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
exprs = [ # permute t. Same dummy order, not equivalent.
|
|
atv(i, j, a, b)*att(a, i)*att(b, j),
|
|
atv(i, j, a, b)*att(b, i)*att(a, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [ # permute v and t. Different dummy order, equivalent
|
|
atv(i, j, a, b)*att(a, i)*att(b, j),
|
|
atv(j, i, a, b)*att(a, j)*att(b, i),
|
|
atv(i, j, b, a)*att(b, i)*att(a, j),
|
|
atv(j, i, b, a)*att(b, j)*att(a, i),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_equivalent_internal_lines_VT2conjT2_AT():
|
|
# this diagram requires special handling in TCE
|
|
i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
|
|
a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
|
|
p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
|
|
h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
|
|
|
|
from sympy.utilities.iterables import variations
|
|
|
|
# atv(abcd)att(abij)att(ijcd)
|
|
template = atv(p1, p2, p3, p4)*att(p1, p2, i, j)*att(i, j, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
template = atv(p1, p2, p3, p4)*att(p1, p2, j, i)*att(j, i, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
# atv(abcd)att(abij)att(jicd)
|
|
template = atv(p1, p2, p3, p4)*att(p1, p2, i, j)*att(j, i, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
template = atv(p1, p2, p3, p4)*att(p1, p2, j, i)*att(i, j, p3, p4)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
|
|
def test_equivalent_internal_lines_VT2conjT2_ambiguous_order_AT():
|
|
# These diagrams invokes _determine_ambiguous() because the
|
|
# dummies can not be ordered unambiguously by the key alone
|
|
i, j, k, l, m, n = symbols('i j k l m n', below_fermi=True, cls=Dummy)
|
|
a, b, c, d, e, f = symbols('a b c d e f', above_fermi=True, cls=Dummy)
|
|
p1, p2, p3, p4 = symbols('p1 p2 p3 p4', above_fermi=True, cls=Dummy)
|
|
h1, h2, h3, h4 = symbols('h1 h2 h3 h4', below_fermi=True, cls=Dummy)
|
|
|
|
from sympy.utilities.iterables import variations
|
|
|
|
# atv(abcd)att(abij)att(cdij)
|
|
template = atv(p1, p2, p3, p4)*att(p1, p2, i, j)*att(p3, p4, i, j)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
template = atv(p1, p2, p3, p4)*att(p1, p2, j, i)*att(p3, p4, i, j)
|
|
permutator = variations([a, b, c, d], 4)
|
|
base = template.subs(zip([p1, p2, p3, p4], next(permutator)))
|
|
for permut in permutator:
|
|
subslist = zip([p1, p2, p3, p4], permut)
|
|
expr = template.subs(subslist)
|
|
assert substitute_dummies(expr) == substitute_dummies(base)
|
|
|
|
|
|
def test_equivalent_internal_lines_VT2_AT():
|
|
i, j, k, l = symbols('i j k l', below_fermi=True, cls=Dummy)
|
|
a, b, c, d = symbols('a b c d', above_fermi=True, cls=Dummy)
|
|
|
|
exprs = [
|
|
# permute v. Same dummy order, not equivalent.
|
|
atv(i, j, a, b)*att(a, b, i, j),
|
|
atv(j, i, a, b)*att(a, b, i, j),
|
|
atv(i, j, b, a)*att(a, b, i, j),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [
|
|
# permute t.
|
|
atv(i, j, a, b)*att(a, b, i, j),
|
|
atv(i, j, a, b)*att(b, a, i, j),
|
|
atv(i, j, a, b)*att(a, b, j, i),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) != substitute_dummies(permut)
|
|
|
|
exprs = [ # permute v and t. Relabelling of dummies should be equivalent.
|
|
atv(i, j, a, b)*att(a, b, i, j),
|
|
atv(j, i, a, b)*att(a, b, j, i),
|
|
atv(i, j, b, a)*att(b, a, i, j),
|
|
atv(j, i, b, a)*att(b, a, j, i),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_internal_external_VT2T2_AT():
|
|
ii, jj = symbols('i j', below_fermi=True)
|
|
aa, bb = symbols('a b', above_fermi=True)
|
|
k, l = symbols('k l', below_fermi=True, cls=Dummy)
|
|
c, d = symbols('c d', above_fermi=True, cls=Dummy)
|
|
|
|
exprs = [
|
|
atv(k, l, c, d)*att(aa, c, ii, k)*att(bb, d, jj, l),
|
|
atv(l, k, c, d)*att(aa, c, ii, l)*att(bb, d, jj, k),
|
|
atv(k, l, d, c)*att(aa, d, ii, k)*att(bb, c, jj, l),
|
|
atv(l, k, d, c)*att(aa, d, ii, l)*att(bb, c, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
exprs = [
|
|
atv(k, l, c, d)*att(aa, c, ii, k)*att(d, bb, jj, l),
|
|
atv(l, k, c, d)*att(aa, c, ii, l)*att(d, bb, jj, k),
|
|
atv(k, l, d, c)*att(aa, d, ii, k)*att(c, bb, jj, l),
|
|
atv(l, k, d, c)*att(aa, d, ii, l)*att(c, bb, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
exprs = [
|
|
atv(k, l, c, d)*att(c, aa, ii, k)*att(bb, d, jj, l),
|
|
atv(l, k, c, d)*att(c, aa, ii, l)*att(bb, d, jj, k),
|
|
atv(k, l, d, c)*att(d, aa, ii, k)*att(bb, c, jj, l),
|
|
atv(l, k, d, c)*att(d, aa, ii, l)*att(bb, c, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_internal_external_pqrs_AT():
|
|
ii, jj = symbols('i j')
|
|
aa, bb = symbols('a b')
|
|
k, l = symbols('k l', cls=Dummy)
|
|
c, d = symbols('c d', cls=Dummy)
|
|
|
|
exprs = [
|
|
atv(k, l, c, d)*att(aa, c, ii, k)*att(bb, d, jj, l),
|
|
atv(l, k, c, d)*att(aa, c, ii, l)*att(bb, d, jj, k),
|
|
atv(k, l, d, c)*att(aa, d, ii, k)*att(bb, c, jj, l),
|
|
atv(l, k, d, c)*att(aa, d, ii, l)*att(bb, c, jj, k),
|
|
]
|
|
for permut in exprs[1:]:
|
|
assert substitute_dummies(exprs[0]) == substitute_dummies(permut)
|
|
|
|
|
|
def test_issue_19661():
|
|
a = Symbol('0')
|
|
assert latex(Commutator(Bd(a)**2, B(a))
|
|
) == '- \\left[b_{0},{b^\\dagger_{0}}^{2}\\right]'
|
|
|
|
|
|
def test_canonical_ordering_AntiSymmetricTensor():
|
|
v = symbols("v")
|
|
|
|
c, d = symbols(('c','d'), above_fermi=True,
|
|
cls=Dummy)
|
|
k, l = symbols(('k','l'), below_fermi=True,
|
|
cls=Dummy)
|
|
|
|
# formerly, the left gave either the left or the right
|
|
assert AntiSymmetricTensor(v, (k, l), (d, c)
|
|
) == -AntiSymmetricTensor(v, (l, k), (d, c))
|