예제 #1
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) == set([j])
    o = B(0)
예제 #2
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
예제 #3
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)
예제 #4
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])
예제 #5
0
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])
예제 #6
0
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
예제 #7
0
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)
예제 #8
0
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}"
예제 #9
0
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")
예제 #10
0
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)
예제 #11
0
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]
예제 #12
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), 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
예제 #13
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)]"
    )
예제 #14
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)))
예제 #15
0
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)
예제 #16
0
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])
예제 #17
0
def test_number_operator():
    o = Bd(0) * B(0)
    e = apply_operators(o * Ket([n]))
    assert e == n * Ket([n])
예제 #18
0
def test_number_operator():
    n = symbols("n")
    o = Bd(0) * B(0)
    e = apply_operators(o * BKet([n]))
    assert e == n * BKet([n])
예제 #19
0
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)
예제 #20
0
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])
예제 #21
0
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]
예제 #22
0
def test_issue_19661():
    a = Symbol('0')
    assert latex(Commutator(
        Bd(a)**2, B(a))) == '- \\left[b_{0},{b^\\dagger_{0}}^{2}\\right]'