def get_CC_operators():
"""
Returns a tuple (T1,T2) of unique operators.
"""
i = symbols('i',below_fermi=True,dummy=True)
a = symbols('a',above_fermi=True,dummy=True)
t_ai = AntiSymmetricTensor('t',(a,),(i,))
ai = NO(Fd(a)*F(i))
i,j = symbols('ij',below_fermi=True,dummy=True)
a,b = symbols('ab',above_fermi=True,dummy=True)
t_abij = AntiSymmetricTensor('t',(a,b),(i,j))
abji = NO(Fd(a)*Fd(b)*F(j)*F(i))
T1 = t_ai*ai
T2 = Rational(1, 4)*t_abij*abji
return (T1,T2)
def get_CC_operators():
"""
Returns a tuple (T1,T2) of unique operators.
"""
i = symbols("i", below_fermi=True, cls=Dummy)
a = symbols("a", above_fermi=True, cls=Dummy)
t_ai = AntiSymmetricTensor("t", (a,), (i,))
ai = NO(Fd(a) * F(i))
i, j = symbols("i,j", below_fermi=True, cls=Dummy)
a, b = symbols("a,b", above_fermi=True, cls=Dummy)
t_abij = AntiSymmetricTensor("t", (a, b), (i, j))
abji = NO(Fd(a) * Fd(b) * F(j) * F(i))
T1 = t_ai * ai
T2 = Rational(1, 4) * t_abij * abji
return (T1, T2)
def get_ccsd_lambda_operators(ast_symb="l"):
i = symbols("i", below_fermi=True, cls=Dummy)
a = symbols("a", above_fermi=True, cls=Dummy)
l_ia = AntiSymmetricTensor(ast_symb, (i, ), (a, ))
c_ia = NO(Fd(i) * F(a))
i, j = symbols("i, j", below_fermi=True, cls=Dummy)
a, b = symbols("a, b", above_fermi=True, cls=Dummy)
l_ijab = AntiSymmetricTensor(ast_symb, (i, j), (a, b))
c_ijab = NO(Fd(i) * Fd(j) * F(b) * F(a))
L_1 = l_ia * c_ia
L_2 = Rational(1, 4) * l_ijab * c_ijab
return (L_1, L_2)
def get_ccsd_t_operators(ast_symb="t"):
i = symbols("i", below_fermi=True, cls=Dummy)
a = symbols("a", above_fermi=True, cls=Dummy)
t_ai = AntiSymmetricTensor(ast_symb, (a, ), (i, ))
c_ai = NO(Fd(a) * F(i))
i, j = symbols("i, j", below_fermi=True, cls=Dummy)
a, b = symbols("a, b", above_fermi=True, cls=Dummy)
t_abij = AntiSymmetricTensor(ast_symb, (a, b), (i, j))
c_abij = NO(Fd(a) * Fd(b) * F(j) * F(i))
T_1 = t_ai * c_ai
T_2 = Rational(1, 4) * t_abij * c_abij
return (T_1, T_2)
def test_is_commutative():
from sympy.physics.secondquant import NO, F, Fd
m = Symbol('m', commutative=False)
for f in (Sum, Product, Integral):
assert f(z, (z, 1, 1)).is_commutative is True
assert f(z * y, (z, 1, 6)).is_commutative is True
assert f(m * x, (x, 1, 2)).is_commutative is False
assert f(NO(Fd(x) * F(y)) * z, (z, 1, 2)).is_commutative is False
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
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 L1(expr):
j1,j2,j3 = symbols('j1,j2,j3' ,below_fermi=True, cls=Dummy)
b1,b2,b3 = symbols('b1,b2,b3' ,above_fermi=True, cls=Dummy)
if expr == "IP":
L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(j1,),())*Fd(j1)
return L1
elif expr == "DIP":
L1 = Fraction(1, 2)*AntiSymmetricTensor('l',(j1,j2),())*Fd(j1)*Fd(j2)
return L1
elif expr == "EA":
L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(),(b1,))*F(b1)
return L1
elif expr == "DEA":
L1 = Fraction(1, 2)*AntiSymmetricTensor('l',(),(b1,b2))*F(b2)*F(b1)
return L1
elif expr == "EE":
L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(j1,),(b1,))*Fd(j1)*F(b1)
return L1
elif expr == "CCSD":
L1 = Fraction(1, 1)*AntiSymmetricTensor('l',(j1,),(b1,))*Fd(j1)*F(b1)
return L1
def R1(expr):
i1,i2,i3 = symbols('i1,i2,i3' ,below_fermi=True, cls=Dummy)
a1,a2,a3 = symbols('a1,a2,i3' ,above_fermi=True, cls=Dummy)
if expr == "IP":
R1 = Fraction(1, 1)*AntiSymmetricTensor('r',(),(i1,))*(F(i1))
return R1
elif expr == "DIP":
R1 = Fraction(1, 2)*AntiSymmetricTensor('r',(),(i1,i2))*F(i2)*F(i1)
return R1
elif expr == "EA":
R1 = Fraction(1, 1)*AntiSymmetricTensor('r',(a1,),())*Fd(a1)
return R1
elif expr == "DEA":
R1 = Fraction(1, 2)*AntiSymmetricTensor('r',(a1,a2),())*NO(Fd(a1)*Fd(a2))
return R1
elif expr == "EE":
R1 = Fraction(1, 1)*AntiSymmetricTensor('r',(a1,),(i1,))*Fd(a1)*F(i1)
return R1
elif expr == "CCSD":
R1 = 0
return R1
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), 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 == -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
# assert (C(C(Y,Z),X).eval_nested() + C(C(Z,X),Y).eval_nested() + C(C(X,Y),Z).eval_nested()) == 0
# assert (C(X,C(Y,Z)).eval_nested() + C(Y,C(Z,X)).eval_nested() + C(Z,C(X,Y)).eval_nested()) == 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
def R2(expr):
i1,i2,i3,i4,i5 = symbols('i1,i2,i3,i4,i5' ,below_fermi=True, cls=Dummy)
a1,a2,a3,a4,a5 = symbols('a1,a2,a3,a4,a5' ,above_fermi=True, cls=Dummy)
if expr == "IP":
R2 = Fraction(1, 2)*AntiSymmetricTensor('r',(a1,),(i2,i3))*Fd(a1)*F(i3)*F(i2)
return R2
elif expr == "DIP":
R2 = Fraction(1, 6)*AntiSymmetricTensor('r',(a1,),(i3,i4,i5))*Fd(a1)*F(i5)*F(i4)*F(i3)
return R2
elif expr == "EA":
R2 = Fraction(1, 2)*AntiSymmetricTensor('r',(a2,a3),(i1,))*Fd(a2)*Fd(a3)*F(i1)
return R2
elif expr == "DEA":
R2 = Fraction(1, 6)*AntiSymmetricTensor('r',(a3,a4,a5),(i1,))*NO(Fd(a3)*Fd(a4)*Fd(a5)*F(i1))
return R2
elif expr == "EE":
R2 = Fraction(1, 4)*AntiSymmetricTensor('r',(a2,a3),(i2,i3))*Fd(a2)*Fd(a3)*F(i3)*F(i2)
return R2
elif expr == "CCSD":
R2 = 0
return R2
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)
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_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_sympy__physics__secondquant__NO():
from sympy.physics.secondquant import NO, F, Fd
assert _test_args(NO(Fd(x) * F(y)))
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 = [ind for ind in no.iter_q_creators()]
assert l1 == [0, 1]
l2 = [ind for ind in 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_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_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_equality():
# if this fails remove special handling below
raises(ValueError, lambda: Sum(x, x))
r = symbols('x', real=True)
for F in (Sum, Product, Integral):
try:
assert F(x, x) != F(y, y)
assert F(x, (x, 1, 2)) != F(x, x)
assert F(x, (x, x)) != F(x, x) # or else they print the same
assert F(1, x) != F(1, y)
except ValueError:
pass
assert F(a, (x, 1, 2)) != F(a, (x, 1, 3))
assert F(a, (x, 1, 2)) != F(b, (x, 1, 2))
assert F(x, (x, 1, 2)) != F(r, (r, 1, 2))
assert F(1, (x, 1, x)) != F(1, (y, 1, x))
assert F(1, (x, 1, x)) != F(1, (y, 1, y))
# issue 5265
assert Sum(x, (x, 1, x)).subs(x, a) == Sum(x, (x, 1, a))
def L2(expr):
j1,j2,j3,j4,j5 = symbols('j1,j2,j3,j4,j5' ,below_fermi=True, cls=Dummy)
b1,b2,b3,b4,b5 = symbols('b1,b2,b3,b4,b5' ,above_fermi=True, cls=Dummy)
if expr == "IP":
L2 = Fraction(1, 2)*AntiSymmetricTensor('l',(j2,j3),(b1,))*Fd(j2)*Fd(j3)*F(b1)
return L2
elif expr == "DIP":
L2 = Fraction(1, 6)*AntiSymmetricTensor('l',(j3,j4,j5),(b1,))*Fd(j3)*Fd(j4)*Fd(j5)*F(b1)
return L2
elif expr == "EA":
L2 = Fraction(1, 2)*AntiSymmetricTensor('l',(j1,),(b2,b3))*Fd(j1)*F(b3)*F(b2)
return L2
elif expr == "DEA":
L2 = Fraction(1, 6)*AntiSymmetricTensor('l',(j1,),(b3,b4,b5))*Fd(j1)*F(b5)*F(b4)*F(b3)
return L2
elif expr == "EE":
L2 = Fraction(1, 4)*AntiSymmetricTensor('l',(j2,j3),(b2,b3))*Fd(j2)*Fd(j3)*F(b3)*F(b2)
return L2
elif expr == "CCSD":
L2 = Fraction(1, 4)*AntiSymmetricTensor('l',(j2,j3),(b2,b3))*Fd(j2)*Fd(j3)*F(b3)*F(b2)
return L2
def test_limit_subs():
for F in (Sum, Product, Integral):
assert F(a*exp(a), (a, -2, 2)) == F(a*exp(a), (a, -b, b)).subs(b, 2)
assert F(a, (a, F(b, (b, 1, 2)), 4)).subs(F(b, (b, 1, 2)), c) == \
F(a, (a, c, 4))
assert F(x, (x, 1, x + y)).subs(x, 1) == F(x, (x, 1, y + 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_kronecker_delta():
i, j, k = symbols('i j k')
D = KroneckerDelta
assert D(i, i) == 1
assert D(i, i + 1) == 0
assert D(0, 0) == 1
assert D(0, 1) == 0
# assert D(i, i + k) == D(0, k)
assert D(i + k, i + k) == 1
assert D(i + k, i + 1 + k) == 0
assert D(i, j).subs(dict(i=1, j=0)) == 0
assert D(i, j).subs(dict(i=3, j=3)) == 1
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('pqrs', dumy=True)
assert D(i, a) == 0
assert D(i, j).is_above_fermi == False
assert D(a, b).is_above_fermi == True
assert D(p, q).is_above_fermi == True
assert D(i, q).is_above_fermi == False
assert D(a, q).is_above_fermi == True
assert D(i, j).is_below_fermi == True
assert D(a, b).is_below_fermi == False
assert D(p, q).is_below_fermi == True
assert D(p, j).is_below_fermi == True
assert D(q, b).is_below_fermi == False
assert not D(i, q).indices_contain_equal_information
assert not D(a, q).indices_contain_equal_information
assert D(p, q).indices_contain_equal_information
assert D(a, b).indices_contain_equal_information
assert D(i, j).indices_contain_equal_information
assert D(q, b).preferred_index == b
assert D(q, b).killable_index == q
assert D(q, i).preferred_index == i
assert D(q, i).killable_index == q
assert D(q, p).preferred_index == p
assert D(q, p).killable_index == q
EV = evaluate_deltas
assert EV(D(a, q) * F(q)) == F(a)
assert EV(D(i, q) * F(q)) == F(i)
assert EV(D(a, q) * F(a)) == D(a, q) * F(a)
assert EV(D(i, q) * F(i)) == D(i, q) * F(i)
assert EV(D(a, b) * F(a)) == F(b)
assert EV(D(a, b) * F(b)) == F(a)
assert EV(D(i, j) * F(i)) == F(j)
assert EV(D(i, j) * F(j)) == F(i)
assert EV(D(p, q) * F(q)) == F(p)
assert EV(D(p, q) * F(p)) == F(q)
assert EV(D(p, j) * D(p, i) * F(i)) == F(j)
assert EV(D(p, j) * D(p, i) * F(j)) == F(i)
assert EV(D(p, q) * D(p, i)) * F(i) == D(q, i) * F(i)
def main():
print()
print("Calculates the Coupled-Cluster energy- and amplitude equations")
print("See 'An Introduction to Coupled Cluster Theory' by")
print("T. Daniel Crawford and Henry F. Schaefer III")
print("http://www.ccc.uga.edu/lec_top/cc/html/review.html")
print()
# setup hamiltonian
p, q, r, s = symbols('p,q,r,s', cls=Dummy)
f = AntiSymmetricTensor('f', (p,), (q,))
pr = NO((Fd(p)*F(q)))
v = AntiSymmetricTensor('v', (p, q), (r, s))
pqsr = NO(Fd(p)*Fd(q)*F(s)*F(r))
H = f*pr + Rational(1, 4)*v*pqsr
print("Using the hamiltonian:", latex(H))
print("Calculating 4 nested commutators")
C = Commutator
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 1...")
comm1 = wicks(C(H, T))
comm1 = evaluate_deltas(comm1)
comm1 = substitute_dummies(comm1)
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 2...")
comm2 = wicks(C(comm1, T))
comm2 = evaluate_deltas(comm2)
comm2 = substitute_dummies(comm2)
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 3...")
comm3 = wicks(C(comm2, T))
comm3 = evaluate_deltas(comm3)
comm3 = substitute_dummies(comm3)
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 4...")
comm4 = wicks(C(comm3, T))
comm4 = evaluate_deltas(comm4)
comm4 = substitute_dummies(comm4)
print("construct Hausdoff expansion...")
eq = H + comm1 + comm2/2 + comm3/6 + comm4/24
eq = eq.expand()
eq = evaluate_deltas(eq)
eq = substitute_dummies(eq, new_indices=True,
pretty_indices=pretty_dummies_dict)
print("*********************")
print()
print("extracting CC equations from full Hbar")
i, j, k, l = symbols('i,j,k,l', below_fermi=True)
a, b, c, d = symbols('a,b,c,d', above_fermi=True)
print()
print("CC Energy:")
print(latex(wicks(eq, simplify_dummies=True,
keep_only_fully_contracted=True)))
print()
print("CC T1:")
eqT1 = wicks(NO(Fd(i)*F(a))*eq, simplify_kronecker_deltas=True, keep_only_fully_contracted=True)
eqT1 = substitute_dummies(eqT1)
print(latex(eqT1))
print()
print("CC T2:")
eqT2 = wicks(NO(Fd(i)*Fd(j)*F(b)*F(a))*eq, simplify_dummies=True, keep_only_fully_contracted=True, simplify_kronecker_deltas=True)
P = PermutationOperator
eqT2 = simplify_index_permutations(eqT2, [P(a, b), P(i, j)])
print(latex(eqT2))
def main():
print()
print("Calculates the Coupled-Cluster energy- and amplitude equations")
print("See 'An Introduction to Coupled Cluster Theory' by")
print("T. Daniel Crawford and Henry F. Schaefer III")
print(
"Reference to a Lecture Series: http://vergil.chemistry.gatech.edu/notes/sahan-cc-2010.pdf"
)
print()
# setup hamiltonian
p, q, r, s = symbols('p,q,r,s', cls=Dummy)
f = AntiSymmetricTensor('f', (p, ), (q, ))
pr = NO(Fd(p) * F(q))
v = AntiSymmetricTensor('v', (p, q), (r, s))
pqsr = NO(Fd(p) * Fd(q) * F(s) * F(r))
H = f * pr + Rational(1, 4) * v * pqsr
print("Using the hamiltonian:", latex(H))
print("Calculating 4 nested commutators")
C = Commutator
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 1...")
comm1 = wicks(C(H, T))
comm1 = evaluate_deltas(comm1)
comm1 = substitute_dummies(comm1)
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 2...")
comm2 = wicks(C(comm1, T))
comm2 = evaluate_deltas(comm2)
comm2 = substitute_dummies(comm2)
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 3...")
comm3 = wicks(C(comm2, T))
comm3 = evaluate_deltas(comm3)
comm3 = substitute_dummies(comm3)
T1, T2 = get_CC_operators()
T = T1 + T2
print("commutator 4...")
comm4 = wicks(C(comm3, T))
comm4 = evaluate_deltas(comm4)
comm4 = substitute_dummies(comm4)
print("construct Hausdorff expansion...")
eq = H + comm1 + comm2 / 2 + comm3 / 6 + comm4 / 24
eq = eq.expand()
eq = evaluate_deltas(eq)
eq = substitute_dummies(eq,
new_indices=True,
pretty_indices=pretty_dummies_dict)
print("*********************")
print()
print("extracting CC equations from full Hbar")
i, j, k, l = symbols('i,j,k,l', below_fermi=True)
a, b, c, d = symbols('a,b,c,d', above_fermi=True)
print()
print("CC Energy:")
print(
latex(wicks(eq, simplify_dummies=True,
keep_only_fully_contracted=True)))
# print("HERE")
# print("HERE")
# print("HERE")
# print(pycode(wicks(eq, simplify_dummies=True,
# keep_only_fully_contracted=True)))
# with open("cc_energy.py", "w") as f:
# f.
with open("ccsd.jl", "w") as f:
eq_energy = wicks(eq,
simplify_dummies=True,
keep_only_fully_contracted=True)
f.write(julia_code(eq_energy))
print()
print("CC T1:")
eqT1 = wicks(NO(Fd(i) * F(a)) * eq,
simplify_kronecker_deltas=True,
keep_only_fully_contracted=True)
eqT1 = substitute_dummies(eqT1)
print(latex(eqT1))
print()
print("CC T2:")
eqT2 = wicks(NO(Fd(i) * Fd(j) * F(b) * F(a)) * eq,
simplify_dummies=True,
keep_only_fully_contracted=True,
simplify_kronecker_deltas=True)
# P = PermutationOperator
# eqT2 = simplify_index_permutations(eqT2, [P(a, b), P(i, j)])
print(latex(eqT2))
print(latex(simplify(eqT2)))
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_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 = [ind for ind in no.iter_q_creators()]
assert l1 == [0, 1]
l2 = [ind for ind in no.iter_q_annihilators()]
assert l2 == [3, 2]
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_kronecker_delta_secondquant():
"""secondquant-specific methods"""
D = KroneckerDelta
i, j, v, w = symbols('i j v w', below_fermi=True, cls=Dummy)
a, b, t, u = symbols('a b t u', above_fermi=True, cls=Dummy)
p, q, r, s = symbols('p q r s', cls=Dummy)
assert D(i, a) == 0
assert D(i, t) == 0
assert D(i, j).is_above_fermi is False
assert D(a, b).is_above_fermi is True
assert D(p, q).is_above_fermi is True
assert D(i, q).is_above_fermi is False
assert D(q, i).is_above_fermi is False
assert D(q, v).is_above_fermi is False
assert D(a, q).is_above_fermi is True
assert D(i, j).is_below_fermi is True
assert D(a, b).is_below_fermi is False
assert D(p, q).is_below_fermi is True
assert D(p, j).is_below_fermi is True
assert D(q, b).is_below_fermi is False
assert D(i, j).is_only_above_fermi is False
assert D(a, b).is_only_above_fermi is True
assert D(p, q).is_only_above_fermi is False
assert D(i, q).is_only_above_fermi is False
assert D(q, i).is_only_above_fermi is False
assert D(a, q).is_only_above_fermi is True
assert D(i, j).is_only_below_fermi is True
assert D(a, b).is_only_below_fermi is False
assert D(p, q).is_only_below_fermi is False
assert D(p, j).is_only_below_fermi is True
assert D(q, b).is_only_below_fermi is False
assert not D(i, q).indices_contain_equal_information
assert not D(a, q).indices_contain_equal_information
assert D(p, q).indices_contain_equal_information
assert D(a, b).indices_contain_equal_information
assert D(i, j).indices_contain_equal_information
assert D(q, b).preferred_index == b
assert D(q, b).killable_index == q
assert D(q, t).preferred_index == t
assert D(q, t).killable_index == q
assert D(q, i).preferred_index == i
assert D(q, i).killable_index == q
assert D(q, v).preferred_index == v
assert D(q, v).killable_index == q
assert D(q, p).preferred_index == p
assert D(q, p).killable_index == q
EV = evaluate_deltas
assert EV(D(a, q) * F(q)) == F(a)
assert EV(D(i, q) * F(q)) == F(i)
assert EV(D(a, q) * F(a)) == D(a, q) * F(a)
assert EV(D(i, q) * F(i)) == D(i, q) * F(i)
assert EV(D(a, b) * F(a)) == F(b)
assert EV(D(a, b) * F(b)) == F(a)
assert EV(D(i, j) * F(i)) == F(j)
assert EV(D(i, j) * F(j)) == F(i)
assert EV(D(p, q) * F(q)) == F(p)
assert EV(D(p, q) * F(p)) == F(q)
assert EV(D(p, j) * D(p, i) * F(i)) == F(j)
assert EV(D(p, j) * D(p, i) * F(j)) == F(i)
assert EV(D(p, q) * D(p, i)) * F(i) == D(q, i) * F(i)
