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