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]'