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) == set([j])
o = B(0)
def test_commutation():
c = commutator(B(0), Bd(0))
e = simplify(apply_operators(c * Ket([n])))
assert e == Ket([n])
c = commutator(B(0), B(1))
e = simplify(apply_operators(c * Ket([n, m])))
assert e == 0
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_annihilate():
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)
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_annihilate():
i, j, n, m = var('i j n m')
o = B(i)
assert isinstance(o, AnnihilateBoson)
o = o.subs(i, j)
assert o.atoms(Symbol) == set([j])
o = B(0)
assert o.apply_operator(Ket([n])) == sqrt(n) * Ket([n - 1])
o = B(n)
assert o.apply_operator(Ket([n])) == o * Ket([n])
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(Rational(1, 2) * I / 3.0) == -Rational(1, 2) * I / 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
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_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_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_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_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), 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
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_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_dummy_order_ambiguous():
aa, bb = symbols('ab', 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')
dums = _get_ordered_dummies
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], permutator.next()))
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], permutator.next()))
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], permutator.next()))
for permut in permutator:
subslist = zip([p1, p2, p3, p4, p5], permut)
expr = template.subs(subslist)
assert substitute_dummies(expr) == substitute_dummies(base)
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_number_operator():
o = Bd(0) * B(0)
e = apply_operators(o * Ket([n]))
assert e == n * Ket([n])
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_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_basic_apply():
e = B(0) * Ket([n])
assert apply_operators(e) == sqrt(n) * Ket([n - 1])
e = Bd(0) * Ket([n])
assert apply_operators(e) == sqrt(n + 1) * Ket([n + 1])
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_issue_19661():
a = Symbol('0')
assert latex(Commutator(
Bd(a)**2, B(a))) == '- \\left[b_{0},{b^\\dagger_{0}}^{2}\\right]'
