def test_fullConnectedIsing(self):
print('begin testing full connected Ising model:')
latticeFC = completeGraph(n = 10, weight = 0.5)
tensorNetwork = IsingTNFromUndirectedGraph(latticeFC)
# seq = generateOptimalSequence(tensorNetwork, typicalDim = None)
seq = generateGreedySequence(tensorNetwork)
Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = seq)
print('Z = {}, cost = {}'.format(Z.single(), cost))
ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
print('Z from MPS = {}'.format(ZMPS.single()))
exactZ = exactZFromGraphIsing(latticeFC)
print('exact Z = {}'.format(exactZ))
self.assertTrue(funcs.floatEqual(Z.single(), exactZ, eps = 1e-3))
self.assertTrue(funcs.floatEqual(ZMPS.single(), exactZ, eps = 1e-3))
# latticeFC = completeGraph(n = 15, weight = 0.5)
# tensorNetwork = IsingTNFromUndirectedGraph(latticeFC)
# # seq = generateGreedySequence(tensorNetwork)
# # Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = seq)
# ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
# print('Z from MPS = {}'.format(ZMPS.single()))
# exactZ = exactZFromGraphIsing(latticeFC)
# print('exact Z = {}'.format(exactZ))
print('')
def example():
shapeA = (300, 400, 50)
shapeB = (300, 600)
shapeC = (400, 600, 50)
a = Tensor(labels=['a3', 'b4', 'c5'], data=np.ones(shapeA))
b = Tensor(labels=['a3', 'd6'], data=np.ones(shapeB))
c = Tensor(labels=['e4', 'd6', 'c5'], data=np.ones(shapeC))
# create tensors with labels
makeLink('a3', 'a3', a, b)
makeLink('c5', 'c5', a, c)
makeLink('d6', 'd6', b, c)
# make links via labels
# note that labels can also be made between the "Leg" objects to avoid reused leg names, but here for simplicity from leg names
# now we have a tensor network, we can generate the optimal sequence of this tensor list
optimalSeq = generateOptimalSequence([a, b, c])
print('optimal contraction sequence = {}'.format(optimalSeq))
# if we do not have any knowledge in prior, we can contract the tensor list like
res = contractTensorList([a, b, c])
print(res)
# if you already have a good sequence to use
res, cost = contractAndCostWithSequence([a, b, c], seq=optimalSeq)
print(res)
print('contraction cost = {}'.format(cost))
# if you want to save time / space by contract in place(note that after this you cannot contract them again, since their bonds between have been broken):
res = contractWithSequence([a, b, c], seq=optimalSeq, inplace=True)
print(res)
print('')
def contractHandmadeTN():
print('contractHandmadeTN():')
a = Tensor(shape=(3, 5, 7), labels=['a3', 'a5', 'a7'])
b = Tensor(shape=(2, 4, 5), labels=['b2', 'b4', 'b5'])
c = Tensor(shape=(2, 7, 7, 7), labels=['c2', 'c71', 'c72', 'c73'])
d = Tensor(shape=(7, 7, 3, 4), labels=['d71', 'd72', 'd3', 'd4'])
e = Tensor(shape=(3, 3, 5), labels=['e31', 'e32', 'e5'])
f = Tensor(shape=(2, 2, 5), labels=['f21', 'f22', 'f5'])
g = Tensor(shape=(4, 4, 3, 3), labels=['g41', 'g42', 'g31', 'g32'])
makeLink('a3', 'e31', a, e)
makeLink('a5', 'b5', a, b)
makeLink('a7', 'c72', a, c)
makeLink('b2', 'f21', b, f)
makeLink('b4', 'g41', b, g)
makeLink('c2', 'f22', c, f)
makeLink('c71', 'd72', c, d)
makeLink('c73', 'd71', c, d)
makeLink('d3', 'g31', d, g)
makeLink('d4', 'g42', d, g)
makeLink('e5', 'f5', e, f)
makeLink('e32', 'g32', e, g)
tensors = [a, b, d, c, g, f, e]
res, _ = contractAndCostWithSequence(tensors)
print('res from direct contraction = {}'.format(res.single()))
mpsRes = contractWithMPS(tensors, chi=32)
print('res from mps = {}'.format(mpsRes.single()))
print('')
def makeMPSContractionTest(self, tensors, eps=1e-8):
res, cost = contractAndCostWithSequence(tensors)
print('res = {}, cost = {}'.format(res.single(), cost))
mpsRes = contractWithMPS(tensors, chi=32)
print('res from mps = {}'.format(mpsRes.single()))
eps = 1e-8
self.assertTrue(
funcs.floatEqual(res.single(), mpsRes.single(), eps=eps))
def squareIsingTest():
print('squareIsingTest():')
latticeFBC = squareLatticeFBC(n=4, m=4, weight=0.5)
tensorNetwork = IsingTNFromUndirectedGraph(latticeFBC)
Z, cost = contractAndCostWithSequence(tensorList=tensorNetwork)
print('Z = {}, cost = {}'.format(Z.single(), cost))
ZMPS = contractWithMPS(tensorList=tensorNetwork, chi=16)
print('Z from MPS = {}'.format(ZMPS.single()))
exactZ = exactZFromGraphIsing(latticeFBC)
print('exact Z = {}'.format(exactZ))
def squareIsingTest(L=4):
print('squareIsingTest(L = {}):'.format(L))
weight = 0.5
a = plaquetteIsingTensor(weight=weight, diamondForm=True)
ctmrg = CTMRG(a, chi=16)
ZCTMRG = ctmrg.getZ(L=L)
print('CTMRG Z = {}'.format(ZCTMRG))
latticeFBC = doubleSquareLatticeFBC(n=L, m=L, weight=weight)
tensorNetwork = IsingTNFromUndirectedGraph(latticeFBC)
if (L <= 6):
Z, cost = contractAndCostWithSequence(tensorList=tensorNetwork,
greedy=True)
print('Z = {}, cost = {}'.format(Z.single(), cost))
ZMPS = contractWithMPS(tensorList=tensorNetwork, chi=16)
print('Z from MPS = {}'.format(ZMPS.single()))
if (L <= 3):
exactZ = exactZFromGraphIsing(latticeFBC)
print('exact Z = {}'.format(exactZ))
def test_IsingFromGraph(self):
latticePBC = squareLatticePBC(n = 4, m = 4, weight = 0.5)
# for (4, 4) PBC case: the cost is low(13328 for full contraction), but the CPU time for calculating the optimal sequence is about one minute, so we test here with pre-calculated sequence
tensorNetwork = IsingTNFromUndirectedGraph(latticePBC)
# seq = generateOptimalSequence(tensorNetwork, typicalDim = None)
seq = [(2, 3), (5, 6), (4, 7), (5, 4), (8, 12), (11, 15), (8, 11), (9, 13), (10, 14), (9, 10), (8, 9), (4, 8), (2, 4), (1, 2), (0, 1)] # pre-calculated
# print('optimal seq = {}'.format(seq))
Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = seq)
print('Z = {}, cost = {}'.format(Z.single(), cost))
ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
print('Z from MPS = {}'.format(ZMPS.single()))
exactZ = exactZFromGraphIsing(latticePBC)
print('exact Z = {}'.format(exactZ))
self.assertTrue(funcs.floatEqual(Z.single(), exactZ, eps = 1e-4))
self.assertTrue(funcs.floatEqual(ZMPS.single(), exactZ, eps = 1e-4))
latticeFBC = squareLatticeFBC(n = 4, m = 4, weight = 0.5)
tensorNetwork = IsingTNFromUndirectedGraph(latticeFBC)
# seq = generateOptimalSequence(tensorNetwork, typicalDim = None)
seq = [(3, 7), (2, 3), (6, 2), (12, 13), (8, 12), (9, 8), (14, 15), (11, 14), (10, 11), (8, 10), (2, 8), (5, 2), (4, 2), (1, 2), (0, 1)] # pre-calculated
# print('optimal seq = {}'.format(seq))
Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = seq)
print('Z = {}, cost = {}'.format(Z.single(), cost))
# ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16, seq = seq)
ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
print('Z from MPS = {}'.format(ZMPS.single()))
exactZ = exactZFromGraphIsing(latticeFBC)
print('exact Z = {}'.format(exactZ))
self.assertTrue(funcs.floatEqual(Z.single(), exactZ, eps = 1e-6))
self.assertTrue(funcs.floatEqual(ZMPS.single(), exactZ, eps = 1e-6))
doubleLatticeFBC = doubleSquareLatticeFBC(n = 2, m = 2, weight = 0.5) # 12 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
# seq = [(1, 8), (4, 9), (5, 11), (10, 5), (4, 5), (3, 4), (1, 3), (7, 1), (2, 1), (6, 1), (0, 1)] # calculate on-the-fly is ok
Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork)
print('Z = {}, cost = {}'.format(Z.single(), cost))
exactZ = exactZFromGraphIsing(doubleLatticeFBC)
print('exact Z = {}'.format(exactZ))
ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
print('Z from MPS = {}'.format(ZMPS.single()))
self.assertTrue(funcs.floatRelativeEqual(Z.single(), exactZ, eps = 1e-10))
self.assertTrue(funcs.floatRelativeEqual(ZMPS.single(), exactZ, eps = 1e-10))
# print(tensorNetwork)
doubleLatticeFBC = doubleSquareLatticeFBC(n = 3, m = 3, weight = 0.5) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
seq = [(2, 15), (14, 2), (5, 2), (9, 20), (21, 9), (6, 9), (16, 6), (11, 23), (22, 11), (8, 11), (19, 8), (10, 8), (6, 8), (7, 6), (18, 6), (2, 6), (17, 2), (4, 2), (1, 2), (13, 1), (3, 1), (12, 1), (0, 1)]
Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = seq)
print('Z = {}, cost = {}'.format(Z.single(), cost))
# exactZ = exactZFromGraphIsing(doubleLatticeFBC)
# print('exact Z = {}'.format(exactZ))
exactZ = 2694263494.5463686 # pre-calculated
print('exact Z = {}'.format(exactZ))
ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
print('Z from MPS = {}'.format(ZMPS.single()))
self.assertTrue(funcs.floatRelativeEqual(Z.single(), exactZ, eps = 1e-10))
self.assertTrue(funcs.floatRelativeEqual(ZMPS.single(), exactZ, eps = 1e-10))
doubleLatticeFBC = doubleSquareLatticeFBC(n = 3, m = 3, weight = (0.5, 1.0)) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
seq = [(2, 15), (14, 2), (5, 2), (9, 20), (21, 9), (6, 9), (16, 6), (11, 23), (22, 11), (8, 11), (19, 8), (10, 8), (6, 8), (7, 6), (18, 6), (2, 6), (17, 2), (4, 2), (1, 2), (13, 1), (3, 1), (12, 1), (0, 1)]
Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = seq)
print('Z = {}, cost = {}'.format(Z.single(), cost))
# exactZ = exactZFromGraphIsing(doubleLatticeFBC)
# print('exact Z = {}'.format(exactZ))
# exactZ = 2694263494.5463686 # pre-calculated
# print('exact Z = {}'.format(exactZ))
ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
print('Z from MPS = {}'.format(ZMPS.single()))
self.assertTrue(funcs.floatRelativeEqual(Z.single(), ZMPS.single(), eps = 1e-10))
def test_exactCTMRG(self):
# test case for non-interacting Ising model
weight = 0.0
doubleLatticeFBC = doubleSquareLatticeFBC(n=3, m=3,
weight=weight) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
seq = [(2, 15), (14, 2), (5, 2), (9, 20), (21, 9), (6, 9), (16, 6),
(11, 23), (22, 11), (8, 11), (19, 8), (10, 8), (6, 8), (7, 6),
(18, 6), (2, 6), (17, 2), (4, 2), (1, 2), (13, 1), (3, 1),
(12, 1), (0, 1)]
Z, cost = contractAndCostWithSequence(tensorList=tensorNetwork,
seq=seq)
print('Z = {}, cost = {}'.format(Z.single(), cost))
# exactZ = 2694263494.5463686 # pre-calculated
# print('exact Z = {}'.format(exactZ))
# ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
# print('Z from MPS = {}'.format(ZMPS.single()))
a = plaquetteIsingTensor(weight=weight, diamondForm=True)
ctmrg = CTMRG(a, chi=16)
# for i in range(1, 5):
# print('CTMRG Z(L = {}) = {}'.format(i, ctmrg.getZ(L = i)))
# with self.assertWarns(RuntimeWarning):
ZCTMRG = ctmrg.getZ(L=3)
print('CTMRG Z = {}'.format(ZCTMRG))
self.assertTrue(funcs.floatRelativeEqual(ZCTMRG, Z.single(),
eps=1e-10))
# test case for Ising model
weight = 0.5
for nn in range(1, 3):
doubleLatticeFBC = doubleSquareLatticeFBC(
n=nn, m=nn, weight=weight) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
Z, cost = contractAndCostWithSequence(tensorList=tensorNetwork)
print('Z for L = {} is {}'.format(nn, Z.single()))
doubleLatticeFBC = doubleSquareLatticeFBC(n=3, m=3,
weight=weight) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
seq = [(2, 15), (14, 2), (5, 2), (9, 20), (21, 9), (6, 9), (16, 6),
(11, 23), (22, 11), (8, 11), (19, 8), (10, 8), (6, 8), (7, 6),
(18, 6), (2, 6), (17, 2), (4, 2), (1, 2), (13, 1), (3, 1),
(12, 1), (0, 1)]
Z, cost = contractAndCostWithSequence(tensorList=tensorNetwork,
seq=seq)
print('Z = {}, cost = {}'.format(Z.single(), cost))
# exactZ = 2694263494.5463686 # pre-calculated
# print('exact Z = {}'.format(exactZ))
# ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
# print('Z from MPS = {}'.format(ZMPS.single()))
a = plaquetteIsingTensor(weight=weight, diamondForm=True)
# for i in range(1, 5):
# print('CTMRG Z(L = {}) = {}'.format(i, ctmrg.getSingleZ(L = i)))
ctmrg = CTMRG(a, chi=16)
# for i in range(1, 5):
# print('CTMRG Z(L = {}) = {}'.format(i, ctmrg.getZ(L = i)))
# with self.assertWarns(RuntimeWarning):
ZCTMRG = ctmrg.getZ(L=3)
print('CTMRG Z = {}'.format(ZCTMRG))
self.assertTrue(funcs.floatRelativeEqual(ZCTMRG, Z.single(),
eps=1e-10))
weight = 0.5
doubleLatticeFBC = doubleSquareLatticeFBC(n=5, m=5,
weight=weight) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
Z, cost = contractAndCostWithSequence(tensorList=tensorNetwork,
seq=None,
greedy=True)
print('Z = {}, cost = {}'.format(Z.single(), cost))
# ZMPS = contractWithMPS(tensorList = tensorNetwork, chi = 16)
# print('Z from MPS = {}'.format(ZMPS.single()))
a = plaquetteIsingTensor(weight=weight, diamondForm=True)
ctmrg = CTMRG(a, chi=16)
ZCTMRG = ctmrg.getZ(L=5)
print('CTMRG Z = {}'.format(ZCTMRG))
self.assertTrue(funcs.floatRelativeEqual(ZCTMRG, Z.single(),
eps=1e-10))
weight = 0.5
doubleLatticeFBC = doubleSquareLatticeFBC(n=7, m=7,
weight=weight) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
# Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = None, greedy = True)
# print('Z = {}, cost = {}'.format(Z.single(), cost))
ZMPS = contractWithMPS(tensorList=tensorNetwork, chi=16)
print('Z from MPS = {}'.format(ZMPS.single()))
a = plaquetteIsingTensor(weight=weight, diamondForm=True)
ctmrg = CTMRG(a, chi=16)
ZCTMRG = ctmrg.getZ(L=7)
print('CTMRG Z = {}'.format(ZCTMRG))
self.assertTrue(
funcs.floatRelativeEqual(ZCTMRG, ZMPS.single(), eps=1e-10))
weight = 0.7
doubleLatticeFBC = doubleSquareLatticeFBC(n=6, m=6,
weight=weight) # 24 tensors
tensorNetwork = IsingTNFromUndirectedGraph(doubleLatticeFBC)
# Z, cost = contractAndCostWithSequence(tensorList = tensorNetwork, seq = None, greedy = True)
# print('Z = {}, cost = {}'.format(Z.single(), cost))
ZMPS = contractWithMPS(tensorList=tensorNetwork, chi=16)
print('Z from MPS = {}'.format(ZMPS.single()))
a = plaquetteIsingTensor(weight=weight, diamondForm=True)
ctmrg = CTMRG(a, chi=16)
ZCTMRG = ctmrg.getZ(L=6)
print('CTMRG Z = {}'.format(ZCTMRG))
self.assertTrue(
funcs.floatRelativeEqual(ZCTMRG, ZMPS.single(), eps=1e-10))
def test_contraction(self):
self.showTestCaseBegin("diagonal tensor contraction")
# print('Begin test diagonalTensor contraction.')
a = DiagonalTensor(shape = (2, 2), labels = ['a', 'b'])
b = Tensor(shape = (2, ), labels = ['x'])
c = Tensor(shape = (2, ), labels = ['y'])
makeLink('a', 'x', a, b)
makeLink('b', 'y', a, c)
seq = generateOptimalSequence([a, b, c], typicalDim = 10)
# print('optimal sequence = {}'.format(seq))
prod, cost = contractAndCostWithSequence([a, b, c], seq = seq)
# print('cost = {}'.format(cost))
# prod = contractTensorList([a, b, c], outProductWarning = False)
self.assertTrue(funcs.compareLists(prod.labels, []))
self.assertListEqual(seq, [(0, 2), (1, 0)])
self.assertEqual(cost, 4.0)
# if we use Tensor instead of DiagonalTensor for a
# then the cost should be 12.0, and the order should be (1, 2), (0, 1)
# the optimal cost of diagonal tensors can be achieved if we use diagonal nature for contraction
a = DiagonalTensor(shape = (2, 2, 2), labels = ['a', 'b', 'c'])
b = DiagonalTensor(shape = (2, 2), labels = ['x', 'y'])
makeLink('a', 'x', a, b)
prod, cost = contractAndCostWithSequence([a, b])
self.assertEqual(cost, 2)
self.assertTrue(funcs.compareLists(prod.labels, ['b', 'c', 'y']))
aData = np.array([[[1, 0], [0, 0]], [[0, 0], [0, 3]]])
bData = np.random.random_sample(2)
cData = np.random.random_sample(2)
a = DiagonalTensor(data = aData, labels = ['a', 'b', 'c'])
b = Tensor(data = bData, labels = ['x'])
c = Tensor(data = cData, labels = ['y'])
makeLink('a', 'x', a, b)
makeLink('b', 'y', a, c)
res1, _ = contractAndCostWithSequence([a, b, c])
# print('seq = {}'.format(generateOptimalSequence([a, b, c])))
a = Tensor(data = aData, labels = ['a', 'b', 'c'])
b = Tensor(data = bData, labels = ['x'])
c = Tensor(data = cData, labels = ['y'])
makeLink('a', 'x', a, b)
makeLink('b', 'y', a, c)
res2, _ = contractAndCostWithSequence([a, b, c])
# self.assertListEqual(list(res1.a), list(res2.a))
self.assertTrue(funcs.floatArrayEqual(res1.a, res2.a))
# print(cost1, cost2)
# print(res1.a, res2.a)
# test diagonal tensor contraction
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'])
b = DiagonalTensor(shape = (2, 2, 2), labels = ['b1', 'b2', 'b3'])
makeLink('a1', 'b1', a, b)
res = a @ b
self.assertTupleEqual(res.shape, (2, 2, 2))
self.assertEqual(res.dim, 3)
self.assertTrue(res.diagonalFlag)
self.assertTrue((res.a == np.ones(2)).all())
# test for diagonal * diagonal contraction cost(just O(length))
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'])
b = DiagonalTensor(shape = 2, labels = ['b1', 'b2']) # deduce dim
makeLink('a1', 'b2', a, b)
cost, _ = contractCost(a, b)
self.assertEqual(cost, 2.0)
res, cost = contractAndCostWithSequence([a, b])
self.assertEqual(res.dim, 2)
self.assertEqual(res._length, 2)
self.assertTupleEqual(res.shape, (2, 2))
self.assertEqual(cost, 2.0)
self.assertTrue(res.diagonalFlag)
a = DiagonalTensor(shape = (2, 2), labels = ['a1', 'a2'])
b = Tensor(shape = (2, 3, 3), labels = ['b1', 'b2', 'b3']) # deduce dim
makeLink('a1', 'b1', a, b)
cost, _ = contractCost(a, b)
self.assertEqual(cost, 18.0)
res, cost = contractAndCostWithSequence([a, b])
# print(res)
self.assertEqual(res.dim, 3)
self.assertTrue(funcs.compareLists(list(res.shape), [2, 3, 3]))
self.assertEqual(cost, 18.0)
self.showTestCaseEnd("diagonal tensor contraction")
