def testP2(self): bra = braP2("nm") ket = ketP2("nm") out = apply_wick(bra * ket) aout = AExpression(Ex=out) x = Idx(0, "nm", fermion=False) y = Idx(1, "nm", fermion=False) u = Idx(2, "nm", fermion=False) v = Idx(3, "nm", fermion=False) tensors = [Tensor([x, y], ""), Tensor([u, v], "")] tr1 = Term(1, [], tensors, [], [Delta(x, u), Delta(y, v)]) tr2 = Term(1, [], tensors, [], [Delta(x, v), Delta(y, u)]) ref = Expression([tr1, tr2]) aref = AExpression(Ex=ref) self.assertTrue(aout.pmatch(aref)) op = P2("A", ["nm"]) out = apply_wick(bra * op) out.resolve() aout = AExpression(Ex=out) sym = TensorSym([(0, 1), (1, 0)], [1, 1]) ext = Tensor([x, y], "") t1 = Tensor([x, y], "A", sym=sym) at1 = ATerm(scalar=1, sums=[], tensors=[ext, t1]) self.assertTrue(at1 == aout.terms[0])
def testEea2(self): bra = braEea2("occ", "vir", "vir") ket = ketEea2("occ", "vir", "vir") out = apply_wick(bra * ket) aout = AExpression(Ex=out) i = Idx(0, "occ") a = Idx(0, "vir") b = Idx(1, "vir") k = Idx(2, "occ") c = Idx(2, "vir") d = Idx(3, "vir") tensors = [Tensor([i, a, b], ""), Tensor([c, d, k], "")] tr1 = Term(1, [], tensors, [], [Delta(i, k), Delta(a, c), Delta(b, d)]) tr2 = Term( -1, [], tensors, [], [Delta(i, k), Delta(a, d), Delta(b, c)]) ref = Expression([tr1, tr2]) aref = AExpression(Ex=ref) self.assertTrue(aout.pmatch(aref)) op = Eea2("A", ["occ"], ["vir"]) out = apply_wick(bra * op) out.resolve() aout = AExpression(Ex=out) ext = Tensor([a, b, i], "") ten = Tensor([a, b, i], "A", sym=get_sym_ea2()) at1 = ATerm(scalar=1, sums=[], tensors=[ext, ten]) self.assertTrue(len(aout.terms) == 1) self.assertTrue(at1.pmatch(aout.terms[0]))
def testP1op(self): op = one_p("Hp", name2="Hq") bra = braP1("nm") ex = apply_wick(bra * op) ex.resolve() out = AExpression(Ex=ex) x = Idx(0, "nm", fermion=False) tr1 = ATerm(scalar=1, sums=[], tensors=[Tensor([x], "Hq"), Tensor([x], "")]) ref = AExpression(terms=[tr1]) self.assertTrue(ref.pmatch(out)) ket = ketP1("nm") ex = apply_wick(op * ket) ex.resolve() out = AExpression(Ex=ex) tr1 = ATerm(scalar=1, sums=[], tensors=[Tensor([x], "Hp"), Tensor([x], "")]) ref = AExpression(terms=[tr1]) self.assertTrue(ref.pmatch(out))
def testE1(self): bra = braE1("occ", "vir") ket = ketE1("occ", "vir") out = apply_wick(bra * ket) aout = AExpression(Ex=out) i = Idx(0, "occ") a = Idx(0, "vir") j = Idx(1, "occ") b = Idx(1, "vir") tr1 = Term(1, [], [Tensor([a, i], ""), Tensor([j, b], "")], [], [Delta(i, j), Delta(a, b)]) ref = Expression([tr1]) aref = AExpression(Ex=ref) self.assertTrue(aout.pmatch(aref)) op = E1("A", ["occ"], ["vir"]) out = apply_wick(bra * op) out.resolve() aout = AExpression(Ex=out) ext = Tensor([a, i], "") ten = Tensor([a, i], "A") at1 = ATerm(scalar=1, sums=[], tensors=[ext, ten]) self.assertTrue(len(aout.terms) == 1) self.assertTrue(at1 == aout.terms[0])
def testEP11op(self): op = ep11("Hp", ["occ", "vir"], ["nm"], name2="Hq") bra = braP1E1("nm", "occ", "vir") ex = apply_wick(bra * op) ex.resolve() out = AExpression(Ex=ex) x = Idx(0, "nm", fermion=False) a = Idx(0, "vir") i = Idx(0, "occ") tr1 = ATerm(scalar=1, sums=[], tensors=[Tensor([x, a, i], ""), Tensor([x, a, i], "Hq")]) ref = AExpression(terms=[tr1]) self.assertTrue(ref.pmatch(out)) ket = ketP1E1("nm", "occ", "vir") ex = apply_wick(op * ket) ex.resolve() out = AExpression(Ex=ex) tr1 = ATerm(scalar=1, sums=[], tensors=[Tensor([x, i, a], "Hp"), Tensor([x, i, a], "")]) ref = AExpression(terms=[tr1]) self.assertTrue(ref.pmatch(out))
def test_eq(self): s = 1.0 i = Idx(0, "occ") j = Idx(1, "occ") sums = [Sigma(i), Sigma(j)] tensors = [Tensor([i, j], 'f')] t1 = ATerm(s, sums, tensors) t0 = t1.copy() sums = [Sigma(i), Sigma(j)] tensors = [Tensor([j, i], 'f'), Tensor([i, j], 'g')] t2 = ATerm(s, sums, tensors) sums = [Sigma(i)] tensors = [Tensor([i, j], 'f')] t3 = ATerm(s, sums, tensors) sums = [Sigma(i)] tensors = [Tensor([i, j], 'g')] t4 = ATerm(s, sums, tensors) self.assertTrue(t1 < t2) self.assertTrue(t1 != t2) self.assertFalse(t0 < t1) self.assertTrue(t0 <= t1) self.assertTrue(t0 >= t1) self.assertTrue(t1 > t3) self.assertTrue(t3 < t4)
def test_string(self): a = Idx(0, "vir") b = Idx(1, "vir") sums = [Sigma(a), Sigma(b)] tensors = [Tensor([a, b], 'f')] t1 = ATerm(sums=sums, tensors=tensors) out = str(t1) ref = "1\\sum_{0}\\sum_{1}f_{01}" self.assertTrue(out == ref) out = t1._print_str() ref = "1.0\\sum_{ab}f_{ab}" self.assertTrue(out == ref) out = t1._einsum_str() ref = "1.0*einsum('ab->', f)" self.assertTrue(out == ref) a = Idx(0, "vir") b = Idx(1, "vir") sums = [Sigma(b)] tensors = [Tensor([a], ''), Tensor([a, b], 'f')] t2 = ATerm(sums=sums, tensors=tensors) out = t2._einsum_str() ref = "1.0*einsum('ab->a', f)" self.assertTrue(out == ref)
def testP1E1(self): bra = braP1E1("nm", "occ", "vir") ket = ketP1E1("nm", "occ", "vir") out = apply_wick(bra * ket) aout = AExpression(Ex=out) x = Idx(0, "nm", fermion=False) y = Idx(1, "nm", fermion=False) i = Idx(0, "occ") a = Idx(0, "vir") j = Idx(1, "occ") b = Idx(1, "vir") tensors = [Tensor([x, i, a], ""), Tensor([y, b, j], "")] tr1 = Term(1, [], tensors, [], [Delta(x, y), Delta(i, j), Delta(a, b)]) ref = Expression([tr1]) aref = AExpression(Ex=ref) self.assertTrue(aout.pmatch(aref)) op = EPS1("A", ["nm"], ["occ"], ["vir"]) out = apply_wick(bra * op) out.resolve() aout = AExpression(Ex=out) ext = Tensor([x, a, i], "") t1 = Tensor([x, a, i], "A") at1 = ATerm(scalar=1, sums=[], tensors=[ext, t1]) self.assertTrue(at1 == aout.terms[0])
def test_term_map3(self): s = 1 i = Idx(0, "occ") a = Idx(0, "vir") sums = [Sigma(i), Sigma(a)] tensors = [Tensor([i, a], 'f'), Tensor([a, i], 't')] t1 = ATerm(s, sums, tensors) sums = [Sigma(i)] t2 = ATerm(s, sums, tensors) self.assertFalse(t1.match(t2))
def test_term_map2(self): s = 1 i = Idx(0, "occ") j = Idx(1, "occ") sums = [Sigma(i), Sigma(j)] tensors = [Tensor([i, j], 'f')] t1 = ATerm(s, sums, tensors) sums = [Sigma(i)] tensors = [Tensor([j, i], 'f')] t2 = ATerm(s, sums, tensors) self.assertFalse(t1.match(t2))
def test_null(self): i = Idx(0, "occ") j = Idx(1, "occ") a = Idx(0, "vir") b = Idx(1, "vir") L1 = Tensor([i, j, a, b], "L") J1 = Tensor([j, b], "J") S1j = Sigma(j) S1b = Sigma(b) T1 = ATerm(scalar=1, sums=[S1j, S1b], tensors=[L1, J1]) T2 = ATerm(scalar=1, sums=[S1j, S1b], tensors=[L1, J1]) self.assertTrue(T1.match(T2)) self.assertTrue(T2.match(T1))
def test_tensor_sort(self): i = Idx(0, "occ") j = Idx(1, "occ") a = Idx(0, "vir") tensors = [ Tensor([j, i], 'f'), Tensor([a, i], ''), Tensor([a, j], "t") ] st = [tensors[1], tensors[0], tensors[2]] sigmas = [Sigma(j)] tt = ATerm(scalar=1.0, sums=sigmas, tensors=tensors) tt.sort_tensors() for ref, out in zip(st, tt.tensors): self.assertTrue(ref == out)
def testEdea1(self): bra = braEdea1("vir", "vir") ket = ketEdea1("vir", "vir") out = apply_wick(bra * ket) aout = AExpression(Ex=out) a = Idx(0, "vir") b = Idx(1, "vir") c = Idx(2, "vir") d = Idx(3, "vir") tensors = [Tensor([a, b], ""), Tensor([c, d], "")] tr1 = Term(1, [], tensors, [], [Delta(a, c), Delta(b, d)]) tr2 = Term(-1, [], tensors, [], [Delta(a, d), Delta(b, c)]) ref = Expression([tr1, tr2]) aref = AExpression(Ex=ref) self.assertTrue(aout.pmatch(aref))
def testEdip1(self): bra = braEdip1("occ", "occ") ket = ketEdip1("occ", "occ") out = apply_wick(bra * ket) aout = AExpression(Ex=out) i = Idx(0, "occ") j = Idx(1, "occ") k = Idx(2, "occ") l = Idx(3, "occ") tensors = [Tensor([i, j], ""), Tensor([k, l], "")] tr1 = Term(1, [], tensors, [], [Delta(i, k), Delta(j, l)]) tr2 = Term(-1, [], tensors, [], [Delta(i, l), Delta(j, k)]) ref = Expression([tr1, tr2]) aref = AExpression(Ex=ref) self.assertTrue(aout.pmatch(aref))
def testP2E1(self): bra = braP2E1("nm", "nm", "occ", "vir") op = EPS2("A", ["nm"], ["occ"], ["vir"]) out = apply_wick(bra * op) out.resolve() x = Idx(0, "nm", fermion=False) y = Idx(1, "nm", fermion=False) a = Idx(0, "vir") i = Idx(0, "occ") sym = TensorSym([(0, 1, 2, 3), (1, 0, 2, 3)], [1, 1]) aout = AExpression(Ex=out) ext = Tensor([x, y, a, i], "") t1 = Tensor([x, y, a, i], "A", sym=sym) at1 = ATerm(scalar=1, sums=[], tensors=[ext, t1]) self.assertTrue(at1 == aout.terms[0])
def test_resolve3(self): I1 = Idx(0, "o1") I2 = Idx(1, "o1") operators = [FOperator(I1, True), FOperator(I2, False)] out = Term( 1, [Sigma(I1), Sigma(I2)], [Tensor([I1, I2], "T")], operators, [Delta(I1, I2)]) out.resolve() roperators = [FOperator(I1, True), FOperator(I1, False)] ref = Term( 1, [Sigma(I1)], [Tensor([I1, I1], "T")], roperators, []) self.assertTrue(ref == out)
def test_tensor(self): i = Idx(0, "occ") a = Idx(0, "vir") T0 = Tensor([i], "g") T1 = Tensor([i, a], "g") T2 = Tensor([i, a], "f") T3 = Tensor([i, a], "f") T4 = Tensor([a, i], "f") self.assertTrue(T2 == T3) self.assertTrue(T2 != T4) self.assertTrue(T1 != T3) self.assertTrue(T1 != T4) self.assertTrue(T0 < T1) self.assertTrue(T2 <= T3) self.assertFalse(T2 < T3) self.assertTrue(T2 > T0) self.assertTrue(T4 >= T3)
def test_resolve0(self): I1 = Idx(0, "o1") I2 = Idx(1, "o1") I3 = Idx(0, "o2") operators = [FOperator(I1, True), FOperator(I3, False)] out = Term( 1, [Sigma(I3)], [Tensor([I1, I3], "T")], operators, [Delta(I1, I2)]) out.resolve() ref = Term( 1, [Sigma(I3)], [Tensor([I1, I3], "T")], operators, [Delta(I1, I2)]) self.assertTrue(ref == out)
def testP2op(self): op = two_p("H") bra = braP1("nm") ket = ketP1("nm") ex = apply_wick(bra * op * ket) ex.resolve() out = AExpression(Ex=ex) x = Idx(0, "nm", fermion=False) y = Idx(1, "nm", fermion=False) sym = TensorSym([(0, 1), (1, 0)], [1, 1]) tensors = [ Tensor([x], ""), Tensor([x, y], "H", sym=sym), Tensor([y], "") ] tr1 = ATerm(scalar=1, sums=[], tensors=tensors) ref = AExpression(terms=[tr1]) self.assertTrue(ref.pmatch(out))
def test_scalar_mul(self): s = 1.0 i = Idx(0, "occ") j = Idx(1, "occ") sums = [Sigma(i), Sigma(j)] tensors = [Tensor([i, j], 'f')] operators = [FOperator(i, True), FOperator(j, False)] t = Term(s, sums, tensors, operators, []) t1 = 3.14 * t t2 = t * 3.14 self.assertTrue(t1 == t2)
def test_ilist(self): s = 1.0 i = Idx("i", "occ") j = Idx("j", "occ") sums = [Sigma(i), Sigma(j)] tensors = [Tensor([i, j], 'f')] operators = [FOperator(i, True), FOperator(j, False)] t1 = Term(s, sums, tensors, operators, []) ilist = t1.ilist() iref = [i, j] self.assertTrue(set(iref) == set(ilist))
def test_mul(self): s = 1 i = Idx(0, "occ") j = Idx(1, "occ") sums = [Sigma(i), Sigma(j)] tensors = [Tensor([i, j], 'f')] t1 = ATerm(s, sums, tensors) t2 = t1.copy() out = t1 * t2 k = Idx(2, "occ") l = Idx(3, "occ") sumsx = [Sigma(i), Sigma(j), Sigma(k), Sigma(l)] tensorsx = [Tensor([i, j], 'f'), Tensor([k, l], 'f')] tx = ATerm(s, sumsx, tensorsx) self.assertTrue(tx == out) tx.scalar = 2 out = 2 * out self.assertTrue(tx == out) self.assertTrue(4 * tx == out * 4)
def test_mul(self): i = Idx(0, "occ") j = Idx(1, "occ") a = Idx(0, "vir") b = Idx(1, "vir") sum1 = [Sigma(i), Sigma(j)] ten1 = [Tensor([i, j], 'f')] ops1 = [FOperator(i, True), FOperator(j, False)] t1 = Term(1.0, sum1, ten1, ops1, []) sum2 = [Sigma(a), Sigma(b)] ten2 = [Tensor([a, b], 'f')] ops2 = [FOperator(a, True), FOperator(b, False)] t2 = Term(1.0, sum2, ten2, ops2, []) sum3 = sum2 + sum1 ten3 = ten1 + ten2 ops3 = ops1 + ops2 ref = Term(1.0, sum3, ten3, ops3, []) out = t1 * t2 self.assertTrue(ref == out)
def test_mul2(self): s = 1.0 i = Idx(0, "occ") j = Idx(1, "occ") sums = [Sigma(i), Sigma(j)] tensors = [Tensor([i, j], 'f')] operators = [FOperator(i, True), FOperator(j, False)] t1 = Term(s, sums, tensors, operators, []) t3 = t1 * t1 k = Idx(2, "occ") l = Idx(3, "occ") sums = [Sigma(i), Sigma(j), Sigma(k), Sigma(l)] tensors = [Tensor([i, j], 'f'), Tensor([k, l], 'f')] operators = [ FOperator(i, True), FOperator(j, False), FOperator(k, True), FOperator(l, False) ] ttest = Term(s, sums, tensors, operators, []) self.assertTrue(t3 == ttest)
def testP1(self): bra = braP1("nm") ket = ketP1("nm") out = apply_wick(bra * ket) aout = AExpression(Ex=out) x = Idx(0, "nm", fermion=False) y = Idx(1, "nm", fermion=False) tensors = [Tensor([x], ""), Tensor([y], "")] tr1 = Term(1, [], tensors, [], [Delta(x, y)]) ref = Expression([tr1]) aref = AExpression(Ex=ref) self.assertTrue(aout.pmatch(aref)) op = P1("A", ["nm"]) out = apply_wick(bra * op) out.resolve() aout = AExpression(Ex=out) ext = Tensor([x], "") ten = Tensor([x], "A") at1 = ATerm(scalar=1, sums=[], tensors=[ext, ten]) self.assertTrue(at1 == aout.terms[0])
def test_resolve_chain(self): I1 = Idx(0, "v1") I2 = Idx(0, "o1") I3 = Idx(1, "v1") I4 = Idx(1, "o1") operators = [ FOperator(I1, True), FOperator(I2, True), FOperator(I4, False), FOperator(I3, False)] out = Term( 1, [Sigma(I2), Sigma(I3), Sigma(I4)], [Tensor([I1, I2, I3, I4], "T")], operators, [Delta(I1, I3), Delta(I2, I4)]) out.resolve() roperators = [ FOperator(I1, True), FOperator(I2, True), FOperator(I2, False), FOperator(I1, False)] ref = Term( 1, [Sigma(I2)], [Tensor([I1, I2, I1, I2], "T")], roperators, []) self.assertTrue(ref == out)
def test_str(self): i = Idx(0, "occ") j = Idx(1, "occ") sums = [Sigma(i)] tensors = [Tensor([i, j], "X")] operators = [FOperator(i, False)] e1 = Term(1, sums, tensors, operators, [Delta(i, j)]) ex = Expression([e1]) out = str(ex) ref = "1\\sum_{0}\\delta_{0,1}X_{01}a_0(occ)" self.assertTrue(ref == out) out = ex._print_str() ref = " + 1\\sum_{i}\\delta_{ij}X_{ij}a_i" self.assertTrue(ref == out)
def test_merge_external(self): bra = braE1("occ", "vir") ket = ketE1("occ", "vir") out = apply_wick(bra * ket) aout = AExpression(Ex=out) aterm = aout.terms[0] aterm.merge_external() i = Idx(0, "occ") a = Idx(0, "vir") j = Idx(1, "occ") b = Idx(1, "vir") tensors = [ Tensor([a, i, j, b], ""), tensor_from_delta(Delta(i, j)), tensor_from_delta(Delta(a, b)) ] aref = ATerm(scalar=1, sums=[], tensors=tensors) self.assertTrue(aterm == aref)
def test_string(self): P1 = Projector() self.assertTrue(str(P1) == "P") i = Idx(0, "occ") a = Idx(0, "vir") O1 = FOperator(i, False) O2 = FOperator(i, True) O3 = FOperator(a, False) O4 = FOperator(a, True) so1 = "a_0(occ)" so2 = "a^{\\dagger}_0(occ)" so3 = "a_0(vir)" so4 = "a^{\\dagger}_0(vir)" self.assertTrue(str(O1) == so1) self.assertTrue(str(O2) == so2) self.assertTrue(str(O3) == so3) self.assertTrue(str(O4) == so4) x = Idx(0, "nm", fermion=False) Ob1 = BOperator(x, False) Ob2 = BOperator(x, True) sob1 = "b_0(nm)" sob2 = "b^{\\dagger}_0(nm)" self.assertTrue(str(Ob1) == sob1) self.assertTrue(str(Ob2) == sob2) T1 = Tensor([i, a], "g") st1 = "g_{00}" self.assertTrue(str(T1) == st1) S1 = Sigma(i) ss1 = "\\sum_{0}" self.assertTrue(str(S1) == ss1) j = Idx(1, "occ") D1 = Delta(i, j) sd1 = "\\delta_{0,1}" self.assertTrue(str(D1) == sd1)
def test_inc(self): i = Idx(0, "occ") j = Idx(1, "occ") a = Idx(0, "vir") I = Idx(0, "nm", fermion=False) J = Idx(1, "nm", fermion=False) iii = 3 # Fermion operator O1 = FOperator(i, False)._inc(iii) self.assertTrue(O1.idx.index == iii) # Boson operator O2 = BOperator(I, False)._inc(iii) O3 = BOperator(J, True)._inc(iii) self.assertTrue(O2.idx.index == iii) self.assertTrue(O3.idx.index == iii + 1) # Projector P1 = Projector() P2 = P1._inc(iii) self.assertTrue(P1 == P2) # tensor T1 = Tensor([i, a], "g")._inc(iii) self.assertTrue(T1.indices[0].index == iii) self.assertTrue(T1.indices[1].index == iii) # sigma S3 = Sigma(j)._inc(iii) self.assertTrue(S3.idx.index == iii + 1) # delta D1 = Delta(i, j)._inc(iii) self.assertTrue(D1.i1.index == iii) self.assertTrue(D1.i2.index == iii + 1)