def getTridiagonal(HL, HR, H, k, psi, psiCompare=None):
accuracy = 1e-10 # 1e-12
v = bops.multiContraction(psi[k], psi[k + 1], '2', '0')
# Small innaccuracies ruin everything!
v.set_tensor(v.get_tensor() / bops.getNodeNorm(v))
psiCopy = bops.copyState(psi)
base = []
base.append(v)
Hv = applyHToM(HL, HR, H, v, k)
alpha = bops.multiContraction(v, Hv, '0123', '0123*').get_tensor()
if psiCompare is not None:
copyV = bops.copyState([v])[0]
psiCopy = bops.assignNewSiteTensors(psiCopy, k, copyV, '>>')[0]
E = stateEnergy(psi, H)
w = bops.addNodes(Hv, bops.multNode(v, -alpha))
beta = bops.getNodeNorm(w)
# Start with T as an array and turn into tridiagonal matrix at the end.
Tarr = [[0, 0, 0]]
Tarr[0][1] = alpha
counter = 0
formBeta = 2 * beta # This is just some value to init formBeta > beta.
while (beta > accuracy) and (counter <= 50) and (beta < formBeta):
Tarr[counter][2] = beta
Tarr.append([0, 0, 0])
Tarr[counter + 1][0] = beta
counter += 1
v = bops.multNode(w, 1 / beta)
base.append(v)
if psiCompare is not None:
copyV = bops.copyState([v])[0]
psiCopy = bops.assignNewSiteTensors(psiCopy, k, copyV, '>>')[0]
Hv = applyHToM(HL, HR, H, v, k)
alpha = bops.multiContraction(v, Hv, '0123', '0123*').get_tensor()
Tarr[counter][1] = alpha
w = bops.addNodes(bops.addNodes(Hv, bops.multNode(v, -alpha)), \
bops.multNode(base[counter-1], -beta))
formBeta = beta
beta = bops.getNodeNorm(w)
T = np.zeros((len(Tarr), len(Tarr)), dtype=complex)
T[0][0] = Tarr[0][1]
if len(Tarr) > 1:
T[0][1] = Tarr[0][2]
for i in range(1, len(Tarr)-1):
T[i][i-1] = Tarr[i][0]
T[i][i] = Tarr[i][1]
T[i][i+1] = Tarr[i][2]
T[len(Tarr)-1][len(Tarr)-2] = Tarr[len(Tarr)-1][0]
T[len(Tarr) - 1][len(Tarr) - 1] = Tarr[len(Tarr) - 1][1]
return [T, base]
def lanczos(HL, HR, H, k, psi, psiCompare):
[T, base] = getTridiagonal(HL, HR, H, k, psi, psiCompare)
[Es, Vs] = np.linalg.eig(T)
minIndex = np.argmin(Es)
E0 = Es[minIndex]
M = None
for i in range(len(Es)):
M = bops.addNodes(M, bops.multNode(base[i], Vs[i][minIndex]))
M = bops.multNode(M, 1/bops.getNodeNorm(M))
return [M, E0]
def getPurity(w, h):
with open('results/toricBoundaries_g_0.0', 'rb') as f:
[upRow, downRow, leftRow, rightRow, openA, openB, A,
B] = pickle.load(f)
upRow = tn.Node(upRow)
downRow = tn.Node(downRow)
leftRow = tn.Node(leftRow)
rightRow = tn.Node(rightRow)
openA = tn.Node(openA)
openB = tn.Node(openB)
[cUp, dUp, te] = bops.svdTruncation(upRow, [0, 1], [2, 3], '>>')
[cDown, dDown, te] = bops.svdTruncation(downRow, [0, 1], [2, 3], '>>')
norm = pe.applyLocalOperators(cUp, dUp, cDown, dDown, leftRow, rightRow, A,
B, w, h,
[tn.Node(np.eye(d)) for i in range(w * h)])
leftRow = bops.multNode(leftRow, 1 / norm)
res = pe.applyLocalOperators(
cUp, dUp, cDown, dDown, leftRow, rightRow, A, B, w, h,
[tn.Node(ru.proj0Tensor) for i in range(w * h * 4)])
# The density matrix is constructed of blocks of ones of size N and normalized by res.
# Squaring it adds a factor of N * res.
N = 2**(int(w * h / 4))
purity = N * res
return purity
def bmpsSides(cUp: tn.Node,
dUp: tn.Node,
cDown: tn.Node,
dDown: tn.Node,
AEnv: tn.Node,
BEnv: tn.Node,
steps,
option='right'):
envOpAB = bops.permute(bops.multiContraction(AEnv, BEnv, '1', '3'),
[0, 3, 2, 4, 1, 5])
upRow = bops.multiContraction(cUp, dUp, '2', '0')
downRow = bops.multiContraction(cDown, dDown, '2', '0')
if option == 'right':
X = tn.Node(
np.ones((upRow[3].dimension, envOpAB[3].dimension,
downRow[3].dimension),
dtype=complex))
else:
X = tn.Node(
np.ones((upRow[0].dimension, envOpAB[2].dimension,
downRow[0].dimension),
dtype=complex))
for i in range(steps):
if option == 'right':
X = bops.multiContraction(
bops.multiContraction(bops.multiContraction(
X, upRow, '0', '3'),
envOpAB,
'340',
'013',
cleanOr1=True), downRow, '034', '312')
else:
X = bops.multiContraction(bops.multiContraction(
bops.multiContraction(X, upRow, '0', '0'),
envOpAB,
'023',
'201',
cleanOr1=True),
downRow,
'034',
'012',
cleanOr1=True)
norm = np.sqrt(bops.multiContraction(X, X, '012', '012*').tensor)
X = bops.multNode(X, 1 / norm)
return X
def bmpsCols(upRow: tn.Node,
downRow: tn.Node,
AEnv: tn.Node,
BEnv: tn.Node,
steps,
option='right',
X=None):
envOpAB = bops.permute(bops.multiContraction(AEnv, BEnv, '1', '3'),
[0, 3, 2, 4, 1, 5])
envOpBA = bops.permute(bops.multiContraction(BEnv, AEnv, '1', '3'),
[0, 3, 2, 4, 1, 5])
if X is None:
if option == 'right':
X = tn.Node(
np.ones((upRow[3].dimension, envOpBA[3].dimension,
envOpAB[3].dimension, downRow[0].dimension),
dtype=complex))
else:
X = tn.Node(
np.ones((downRow[0].dimension, envOpAB[2].dimension,
envOpBA[2].dimension, upRow[0].dimension),
dtype=complex))
for i in range(steps):
if option == 'right':
X = bops.multiContraction(upRow, X, '3', '0')
X = bops.multiContraction(X, envOpBA, '123', '013', cleanOr1=True)
X = bops.multiContraction(X, envOpAB, '451', '013', cleanOr1=True)
X = bops.multiContraction(X, downRow, '154', '012', cleanOr1=True)
else:
X = bops.multiContraction(downRow, X, '3', '0')
X = bops.multiContraction(X, envOpAB, '321', '245', cleanOr1=True)
X = bops.multiContraction(X, envOpBA, '134', '245', cleanOr1=True)
X = bops.multiContraction(X, upRow, '134', '012', cleanOr1=True)
norm = np.sqrt(bops.multiContraction(X, X, '0123', '0123*').tensor)
X = bops.multNode(X, 1 / norm)
return X
boundaryFile = 'toricBoundaries_g_' + str(g)
topoOpt = sys.argv[9]
newdir = dirname + 'toric_g_' + str(g) + '_n_' + str(n) + '_w_' + str(w) + '_h_' + str(h) + '_' + topoOpt
argvl = 10
excludeIndices = []
if len(sys.argv) > argvl:
for i in range(argvl, len(sys.argv)):
excludeIndices.append(int(sys.argv[i]))
with open(dirname + boundaryFile, 'rb') as f:
[upRow, downRow, leftRow, rightRow, openA, openB, A, B] = pickle.load(f)
[cUp, dUp, te] = bops.svdTruncation(upRow, [0, 1], [2, 3], '>>')
[cDown, dDown, te] = bops.svdTruncation(downRow, [0, 1], [2, 3], '>>')
norm = pe.applyLocalOperators(cUp, dUp, cDown, dDown, leftRow, rightRow, A, B, w, h,
[tn.Node(np.eye(d)) for i in range(w * h)])
leftRow = bops.multNode(leftRow, 1 / norm**(2/w))
print(pe.applyLocalOperators(cUp, dUp, cDown, dDown, leftRow, rightRow, A, B, w, h,
[tn.Node(np.eye(d)) for i in range(w * h)]))
try:
os.mkdir(newdir)
except FileExistsError:
pass
option = 'complex'
ru.renyiEntropy(n, w, h, M, option, theta, phi, pe.applyLocalOperators, [cUp, dUp, cDown, dDown, leftRow, rightRow, A, B, w, h],
newdir + '/rep_' + str(rep), excludeIndices=excludeIndices)
# ru.renyiNegativity(n, l * 4, M, option, toricCode.applyLocalOperators, [cUp, dUp, cDown, dDown, leftRow, rightRow, toricCode.A, toricCode.B, l],
# newdir + '/')
import randomUs as ru
import sys
import pickle
import toricCode
import tensornetwork as tn
import numpy as np
import basicOperations as bops
d = 2
M = int(sys.argv[1])
l = int(sys.argv[2])
if len(sys.argv) == 4:
dirname = sys.argv[3]
else:
dirname = ''
with open(dirname + 'toricBoundaries', 'rb') as f:
[upRow, downRow, leftRow, rightRow, openA, openB] = pickle.load(f)
[cUp, dUp, te] = bops.svdTruncation(upRow, [0, 1], [2, 3], '>>')
[cDown, dDown, te] = bops.svdTruncation(downRow, [0, 1], [2, 3], '>>')
norm = toricCode.applyLocalOperators(cUp, dUp, cDown, dDown, leftRow, rightRow, toricCode.A, toricCode.B, l,
[tn.Node(np.eye(d)) for i in range(l * 4)])
leftRow = bops.multNode(leftRow, 1 / norm)
ru.localUnitariesFull(l * 4, M, toricCode.applyLocalOperators, [cUp, dUp, cDown, dDown, leftRow, rightRow, toricCode.A, toricCode.B, l],
dirname + 'toric_local_full')
l = int(sys.argv[2])
if len(sys.argv) == 4:
dirname = sys.argv[3]
else:
dirname = ''
with open(dirname + 'toricBoundaries', 'rb') as f:
[upRow, downRow, leftRow, rightRow, openA, openB] = pickle.load(f)
[cUp, dUp, te] = bops.svdTruncation(upRow, [0, 1], [2, 3], '>>')
[cDown, dDown, te] = bops.svdTruncation(downRow, [0, 1], [2, 3], '>>')
norm = toricCode.applyLocalOperators(
cUp, dUp, cDown, dDown, leftRow, rightRow, toricCode.A, toricCode.B, l,
[tn.Node(np.eye(d)) for i in range(l * 4)])
leftRow = bops.multNode(leftRow, 1 / norm)
def expectationValue(currSites, op):
left = leftRow
for i in range(l):
left = bops.multiContraction(left, cUp, '3', '0', cleanOr1=True)
leftUp = toricCode.applyOpTosite(currSites[0][i * 2], op)
leftDown = toricCode.applyOpTosite(currSites[1][i * 2], op)
left = bops.multiContraction(left, leftUp, '23', '30', cleanOr1=True)
left = bops.multiContraction(left, leftDown, '14', '30', cleanOr1=True)
left = bops.permute(
bops.multiContraction(left, dDown, '04', '21', cleanOr1=True),
[3, 2, 1, 0])
left = bops.multiContraction(left, dUp, '3', '0', cleanOr1=True)
def toricVar(ls: np.array, op=E, color='blue'):
w = 2
d = 2
chi = 4
with open('results/toricBoundaries', 'rb') as f:
[upRow, downRow, leftRow, rightRow, openA, openB, A,
B] = pickle.load(f)
[cUp, dUp, te] = bops.svdTruncation(upRow, [0, 1], [2, 3], '>>')
[cDown, dDown, te] = bops.svdTruncation(downRow, [0, 1], [2, 3], '>>')
def getDoubleOp(op, d):
return tn.Node(
np.reshape(
np.transpose(
np.reshape(np.outer(op.tensor, op.tensor), [d] * 10),
[0, 5, 1, 6, 2, 7, 3, 8, 4, 9]), [d**2] * 5))
doubleA = getDoubleOp(A, d)
doubleB = getDoubleOp(B, d)
def getDoubleRow(origRow, chi, d):
openRow = np.reshape(origRow.tensor, [chi, d, d, d, d, chi])
doubleRow = tn.Node(
np.reshape(
np.transpose(
np.reshape(np.outer(openRow,
openRow), [chi, d, d, d, d, chi] +
[chi, d, d, d, d, chi]),
[0, 6, 1, 7, 2, 8, 3, 9, 4, 10, 5, 11]),
[chi**2, d**4, d**4, chi**2]))
return doubleRow
doubleUpRow = getDoubleRow(upRow, chi, d)
doubleDownRow = getDoubleRow(downRow, chi, d)
doubleRightRow = getDoubleRow(rightRow, chi, d)
[doubleCUp, doubleDUp, te] = bops.svdTruncation(doubleUpRow, [0, 1],
[2, 3], '>>')
[doubleCDown, doubleDDown,
te] = bops.svdTruncation(doubleDownRow, [0, 1], [2, 3], '>>')
# qA = getDoubleOp(doubleA, d ** 2)
# qB = getDoubleOp(doubleB, d ** 2)
# qUpRow = getDoubleRow(doubleUpRow, chi**2, d**2)
# qDownRow = getDoubleRow(doubleDownRow, chi**2, d**2)
# qRightRow = getDoubleRow(doubleRightRow, chi**2, d**2)
# [qCUp, qDUp, te] = bops.svdTruncation(qUpRow, [0, 1], [2, 3], '>>')
# [qCDown, qDDown, te] = bops.svdTruncation(qDownRow, [0, 1], [2, 3], '>>')
hs = ls * 2
vs = np.zeros(len(hs))
v2s = np.zeros(len(hs))
for i in range(len(hs)):
h = hs[i]
norm = pe.applyLocalOperators(
cUp, dUp, cDown, dDown, leftRow, rightRow, A, B, w, h,
[tn.Node(np.eye(d)) for i in range(w * h)])
leftRow = bops.multNode(leftRow, 1 / norm**(2 / w))
doubleLeftRow = getDoubleRow(leftRow, chi, d)
ops = [op for i in range(w * h)]
vs[i] = pe.applyLocalOperators(doubleCUp, doubleDUp, doubleCDown,
doubleDDown, doubleLeftRow,
doubleRightRow, doubleA, doubleB, w, h,
ops)
# qLeftRow = getDoubleRow(doubleLeftRow, chi**2, d**2)
# ops = [tn.Node(np.eye(d**4)) for i in range(w * h)]
# v2s[i] = pe.applyLocalOperators(qCUp, qDUp, qCDown, qDDown, qLeftRow, qRightRow, qA, qB, w, h, ops)
print(vs)
print([expected(l) for l in ls])
ban.linearRegression(ls * 4, vs, show=False, color=color)
def bmpsRowStep(gammaL, lambdaMid, gammaR, lambdaSide, envOp):
row = bops.multiContraction(bops.multiContraction(bops.multiContraction(
bops.multiContraction(lambdaSide, gammaL, '1', '0', isDiag1=True),
lambdaMid,
'2',
'0',
cleanOr1=True,
cleanOr2=True,
isDiag2=True),
gammaR,
'2',
'0',
cleanOr1=True,
cleanOr2=True),
lambdaSide,
'3',
'0',
cleanOr1=True,
isDiag2=True)
opRow = bops.permute(
bops.multiContraction(row, envOp, '12', '01', cleanOr1=True),
[0, 2, 4, 5, 1, 3])
[U, S, V, truncErr] = bops.svdTruncation(opRow, [0, 1, 2], [3, 4, 5],
dir='>*<',
maxBondDim=chi)
newLambdaMid = bops.multNode(S, 1 / np.sqrt(sum(S.tensor**2)))
lambdaSideInv = tn.Node(
np.array([1 / val if val > 1e-15 else 0 for val in lambdaSide.tensor],
dtype=complex))
newGammaL = bops.multiContraction(lambdaSideInv,
U,
'1',
'0',
cleanOr2=True,
isDiag1=True)
splitter = tn.Node(
bops.getLegsSplitterTensor(newGammaL[0].dimension,
newGammaL[1].dimension))
newGammaL = bops.unifyLegs(newGammaL, 0, 1)
newGammaR = bops.multiContraction(V,
lambdaSideInv,
'2',
'0',
cleanOr1=True,
cleanOr2=True,
isDiag2=True)
newGammaR = bops.unifyLegs(newGammaR, 2, 3)
newLambdaSide = bops.multiContraction(bops.multiContraction(lambdaSide,
splitter,
'1',
'0',
cleanOr1=True,
isDiag1=True),
splitter,
'01',
'01',
cleanOr1=True,
cleanOr2=True)
temp = newLambdaSide
newLambdaSide = tn.Node(np.diag(newLambdaSide.tensor))
tn.remove_node(temp)
return newGammaL, newLambdaMid, newGammaR, newLambdaSide
