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 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_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_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_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_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_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_sigma(self):
i = Idx(0, "occ")
j = Idx(1, "occ")
a = Idx(0, "vir")
S1 = Sigma(i)
S2 = Sigma(i)
S3 = Sigma(j)
S4 = Sigma(a)
self.assertTrue(S2 == S1)
self.assertTrue(S2 != S3)
self.assertTrue(S2 != S4)
self.assertTrue(S3 != S4)
self.assertTrue(S1 < S3)
self.assertTrue(S1 <= S3)
self.assertTrue(S1 <= S2)
self.assertTrue(S1 >= S2)
self.assertTrue(S4 > S2)
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 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_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_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_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 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_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)
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_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)
