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_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_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
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 test_kronecker_delta():
i, j, k = var('i j k')
assert KroneckerDelta(i, i) == 1
assert KroneckerDelta(i, i + 1) == 0
assert KroneckerDelta(0, 0) == 1
assert KroneckerDelta(0, 1) == 0
# assert KroneckerDelta(i, i + k) == KroneckerDelta(1, k)
assert KroneckerDelta(i + k, i + k) == 1
assert KroneckerDelta(i + k, i + 1 + k) == 0
assert KroneckerDelta(i, j).subs(dict(i=1, j=0)) == 0
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 singModeTritter(self, list_modes, inp_op_mode, op_name):
#matrix of creation operators:
op_name = MatrixSymbol(op_name, 3 * self.n_systems, 1)
#complex 3-rd root of unity, as a symbol:
#w = exp(2*pi*1j/3)
w = Symbol('w')
try:
state1 = 0
for k in list_modes:
state1 = state1 + (1 / sqrt(3)) * (w**KroneckerDelta(
inp_op_mode, k)) * op_name[k, 0]
return state1
except (RuntimeError, TypeError, NameError, IndexError):
print(
"Improper constructing parameters - check compatibility of object's dimensions and types"
)
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_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_move2():
i, j = symbols('i,j')
A, C = symbols('A,C', cls=Function)
o = C(j)*A(i)
# This almost works, but has a minus sign wrong
assert move(o, 0, 1) == -KroneckerDelta(i, j) + A(i)*C(j)
def Xtest_move1():
i, j = symbols('i,j')
o = A(i)*C(j)
# This almost works, but has a minus sign wrong
assert move(o, 0, 1) == KroneckerDelta(i, j) + C(j)*A(i)
