def getBMPSRowOps(GammaC, LambdaC, GammaD, LambdaD, AEnv, BEnv, steps): convergence = [] 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]) op = envOpBA for i in range(steps): oldGammaC, oldLambdaC, oldGammaD, oldLambdaD = GammaC, LambdaC, GammaD, LambdaD GammaC, LambdaC, GammaD, LambdaD = bmpsRowStep(GammaC, LambdaC, GammaD, LambdaD, op) GammaD, LambdaD, GammaC, LambdaC = bmpsRowStep(GammaD, LambdaD, GammaC, LambdaC, op) # if i > 0: # convergence.append( # checkConvergence(oldGammaC, oldLambdaC, oldGammaD, oldLambdaD, GammaC, LambdaC, GammaD, LambdaD, 2)) bops.removeState([oldGammaC, oldLambdaC, oldGammaD, oldLambdaD]) # cUp = bops.multiContraction(GammaC, LambdaC, '2', '0', isDiag2=True) # dUp = bops.multiContraction(GammaD, LambdaD, '2', '0', isDiag2=True) # GammaC, LambdaC, GammaD, LambdaD = bmpsRowStep(GammaC, LambdaC, GammaD, LambdaD, op) # cDown = bops.multiContraction(GammaC, LambdaC, '2', '0', isDiag2=True) # dDown = bops.multiContraction(GammaD, LambdaD, '2', '0', isDiag2=True) bops.removeState([ GammaC, LambdaC, GammaD, LambdaD, oldGammaC, oldLambdaC, oldGammaD, oldLambdaD ]) return GammaC, LambdaC, GammaD, LambdaD
def applyHToM(HL, HR, H, M, k): k1 = k k2 = k + 1 # Add HL.opSum x h.identity(k1) x h.identity(k2) x I(Right) # and I(Left) x h.identity(k1) x h.identity(k2) x HR.opSum Hv = bops.multiContraction(HL.opSum, M, '0', '0') Hv = bops.addNodes(Hv, bops.multiContraction(M, HR.opSum, '3', '0')) # Add I(Left) x h.single(k1) x h.identity(k2) x I(Right) # And I(Left) x h.identity(k1) x h.single(k2) x I(Right) Hv = bops.addNodes(Hv, \ bops.permute(bops.multiContraction(M, H.singles[k1], '1', '0'), [0, 3, 1, 2])) Hv = bops.addNodes(Hv, \ bops.permute(bops.multiContraction(M, H.singles[k2], '2', '0'), [0, 1, 3, 2])) # Add HL.openOp x h.r2l(k1) x h.identity(k2) x I(Right) # And I(Left) x h.identity(k1) x h.l2r(k2) x HR.openOp HK1R2L = bops.permute(bops.multiContraction(M, H.r2l[k1], '1', '0'), [0, 4, 3, 1, 2]) Hv = bops.addNodes(Hv, \ bops.multiContraction(HL.openOp, HK1R2L, '02', '01')) HK2L2R = bops.permute(bops.multiContraction(M, H.l2r[k2], '2', '0'), [0, 1, 3, 4, 2]) Hv = bops.addNodes(Hv, \ bops.multiContraction(HK2L2R, HR.openOp, '43', '02')) # Add I(Left) x h.l2r(k1) x h.r2l(k2) x I(Right) HK1K2 = bops.multiContraction(M, H.l2r[k1], '1', '0') HK1K2 = bops.multiContraction(HK1K2, H.r2l[k2], '14', '02') HK1K2 = bops.permute(HK1K2, [0, 2, 3, 1]) Hv = bops.addNodes(Hv, HK1K2) return Hv
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) rightUp = toricCode.applyOpTosite(currSites[0][i * 2 + 1], op) rightDown = toricCode.applyOpTosite(currSites[1][i * 2 + 1], op) left = bops.multiContraction(left, rightUp, '23', '30', cleanOr1=True) left = bops.multiContraction(left, rightDown, '14', '30', cleanOr1=True) left = bops.permute( bops.multiContraction(left, cDown, '04', '21', cleanOr1=True), [3, 2, 1, 0]) bops.removeState([leftUp, leftDown, rightDown, rightUp]) return bops.multiContraction(left, rightRow, '0123', '3210').tensor * 1
def XXVar(statesDir: str, outDir: str, NA, theta, phi): maxBondDim = 100 res = np.zeros(2, dtype=complex) U = tn.Node( np.matmul(ru.getUPhi(np.pi * phi / 2, 2), ru.getUTheta(np.pi * theta / 2, 2))) with open(statesDir + 'psiXX_NA_' + str(NA) + '_NB_' + str(NA), 'rb') as f: psi = pickle.load(f) psiCopy = bops.relaxState(psi, 64) res[0] = bops.getOverlap(psi, psiCopy) bops.removeState(psi) for i in range(NA): psiCopy[i] = bops.permute( bops.multiContraction(psiCopy[i], U, '1', '0'), [0, 2, 1]) doublePsi = [None for j in range(len(psiCopy))] for j in range(len(psiCopy)): doublePsi[j] = doubleMPSSite(psiCopy[j]) doubleCopy = bops.copyState(doublePsi) for j in range(NA): doublePsi[j] = bops.permute( bops.multiContraction(doublePsi[j], E, '1', '0', cleanOr1=True), [0, 2, 1]) res[1] = bops.getOverlap(doublePsi, doubleCopy) with open( outDir + 'XXVar_NA_' + str(NA) + '_t_' + str(theta) + '_p_' + str(phi), 'wb') as f: pickle.dump(res, f) print(res)
def applyLocalOperators(cUp, dUp, cDown, dDown, leftRow, rightRow, A, B, l, ops): left = leftRow for i in range(l): left = bops.multiContraction(left, cUp, '3', '0', cleanOr1=True) leftUp = applyOpTosite(B, ops[i * 4]) leftDown = applyOpTosite(A, ops[i * 4 + 1]) 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) rightUp = applyOpTosite(A, ops[i * 4 + 2]) rightDown = applyOpTosite(B, ops[i * 4 + 3]) left = bops.multiContraction(left, rightUp, '23', '30', cleanOr1=True) left = bops.multiContraction(left, rightDown, '14', '30', cleanOr1=True) left = bops.permute( bops.multiContraction(left, cDown, '04', '21', cleanOr1=True), [3, 2, 1, 0]) bops.removeState([leftUp, leftDown, rightDown, rightUp]) return bops.multiContraction(left, rightRow, '0123', '3210').tensor * 1
def projectS(psi, AEnd): projector0Tensor = np.zeros((2, 2)) projector0Tensor[0, 0] = 1 projector0 = tn.Node(projector0Tensor, backend=None) projector1Tensor = np.zeros((2, 2)) projector1Tensor[1, 1] = 1 projector1 = tn.Node(projector1Tensor, backend=None) for i in range(AEnd + 1): if i % 2 == 0: psi[i] = bops.permute(bops.multiContraction(psi[i], projector0, [1], [0]), [0, 2, 1]) else: psi[i] = bops.permute(bops.multiContraction(psi[i], projector1, [1], [0]), [0, 2, 1])
def horizontalPair(leftSite, rightSite, cleanLeft=True, cleanRight=True): pair = bops.multiContraction(leftSite, rightSite, '1', '3', cleanOr1=cleanLeft, cleanOr2=cleanRight) pair = bops.multiContraction(pair, ru.getPairUnitary(d), '37', '01') [left, right, te] = bops.svdTruncation(pair, [0, 1, 2, 6], [3, 4, 5, 7], '>>', maxBondDim=16) return bops.permute(left, [0, 4, 1, 2, 3]), bops.permute(right, [1, 2, 3, 0, 4])
def stateEnergy(psi: List[tn.Node], H: HOp): E = 0 for i in range(len(psi)): psiCopy = bops.copyState(psi) single_i = bops.copyState([H.singles[i]])[0] psiCopy[i] = bops.permute(tn.contract(psiCopy[i][1] ^ single_i[0], name=('site' + str(i))), [0, 2, 1]) E += bops.getOverlap(psiCopy, psi) bops.removeState(psiCopy) tn.remove_node(single_i) for i in range(len(psi) - 1): psiCopy = bops.copyState(psi) r2l = bops.copyState([H.r2l[i+1]])[0] l2r = bops.copyState([H.l2r[i]])[0] psiCopy[i][2] ^ psiCopy[i+1][0] psiCopy[i][1] ^ l2r[0] r2l[0] ^ psiCopy[i+1][1] l2r[2] ^ r2l[2] M = tn.contract_between(psiCopy[i], \ tn.contract_between(l2r, tn.contract_between(r2l, psiCopy[i+1]))) if bops.multiContraction(M, M, '0123', '0123*').tensor != 0: [psiCopy, te] = bops.assignNewSiteTensors(psiCopy, i, M, '>>') E += bops.getOverlap(psiCopy, psi) bops.removeState(psiCopy) tn.remove_node(r2l) tn.remove_node(l2r) return E
def expectationValues(psi: List[tn.Node], vs: List[List[np.array]]): vs = np.round(vs, 10) n = len(vs) NA = len(vs[0]) result = 1 # result = np.eye(2, dtype=complex) for copy in range(n): psiCopy = bops.copyState(psi) for alpha in range(NA - 1, -1, -1): overlap = np.matmul(vs[copy][alpha], np.conj(vs[np.mod(copy + 1, n)][alpha])) toEstimate = np.outer(vs[copy][alpha], np.conj(vs[np.mod(copy + 1, n)][alpha])) if np.abs(np.round(overlap, 8)) == 2: toMeasure = toEstimate else: hermitianComponent = np.random.randint(2) if hermitianComponent: toMeasure = (toEstimate + np.conj(np.transpose(toEstimate))) else: toMeasure = (toEstimate - np.conj(np.transpose(toEstimate))) psiCopy[alpha] = bops.permute(bops.multiContraction(psiCopy[alpha], tn.Node(toMeasure), \ '1', '1'), [0, 2, 1]) psiCopy = bops.shiftWorkingSite(psiCopy, alpha, '<<') result *= bops.getOverlap(psiCopy, psi) # result = np.matmul(result, toMeasure) bops.removeState(psiCopy) return result
def estimateOp(xRight, xLeft, upRow, downRow, A, ops): N = len(ops) curr = xLeft for i in range(int(N / 2)): closedA = tn.Node( np.trace(bops.multiContraction(ops[i * 2], A, '1', '0').tensor, axis1=0, axis2=5)) closedB = tn.Node( np.trace(bops.multiContraction(ops[i * 2 + 1], A, '1', '0').tensor, axis1=0, axis2=5)) closed = bops.permute( bops.multiContraction(closedA, closedB, '1', '3'), [0, 3, 2, 4, 1, 5]) curr = bops.multiContraction(bops.multiContraction( bops.multiContraction(curr, upRow, '0', '0'), closed, '023', '201', cleanOr1=True), downRow, '034', '012', cleanOr1=True) return bops.multiContraction(curr, xRight, '012', '012').tensor
def toEnvOperator(op): result = bops.unifyLegs( bops.unifyLegs( bops.unifyLegs( bops.unifyLegs(bops.permute(op, [0, 4, 1, 5, 2, 6, 3, 7]), 6, 7), 4, 5), 2, 3), 0, 1) tn.remove_node(op) return result
def bmpsDensityMatrix(cUp, dUp, cDown, dDown, AEnv, BEnv, A, B, steps): rightRow = bmpsCols(cUp, dUp, cDown, dDown, AEnv, BEnv, steps, 'right') leftRow = bmpsCols(cUp, dUp, cDown, dDown, AEnv, BEnv, steps, 'left') upRow = bops.multiContraction(cUp, dUp, '2', '0') downRow = bops.multiContraction(cDown, dDown, '2', '0') circle = bops.multiContraction( bops.multiContraction(bops.multiContraction(leftRow, upRow, '3', '0'), rightRow, '5', '0'), downRow, '07', '03') parityTensor = np.eye(4, dtype=complex) parityTensor[1, 1] = -1 parityTensor[3, 3] = -1 parity = tn.Node(parityTensor) if A[0].dimension == 4: parityA = tn.Node( np.trace(bops.multiContraction(parity, A, '1', '0').tensor, axis1=0, axis2=5)) ABNet = bops.permute( bops.multiContraction( bops.multiContraction(parityA, parityA, '1', '3'), bops.multiContraction(parityA, parityA, '1', '3'), '15', '03', cleanOr1=True, cleanOr2=True), [5, 1, 0, 2, 3, 6, 4, 7]) p2 = bops.multiContraction(circle, ABNet, '01234567', '01234567') b = 1 ABNet = bops.permute( bops.multiContraction(bops.multiContraction(B, A, '2', '4'), bops.multiContraction(A, B, '2', '4'), '28', '16', cleanOr1=True, cleanOr2=True), [2, 10, 9, 13, 14, 5, 1, 6, 0, 4, 8, 12, 3, 7, 11, 15]) dm = bops.multiContraction(circle, ABNet, '23140567', '01234567', cleanOr1=True, cleanOr2=True) ordered = np.round(np.reshape(dm.tensor, [16, 16]), 13) ordered = ordered / np.trace(ordered) return dm
def trotterSweep(trotterGates, psi, startSite, endSite, maxBondDim=1024): psiCopy = bops.copyState(psi) truncErr = 0 N = len(psi) for k in [endSite - i for i in range(startSite, endSite)]: M = bops.multiContraction(psiCopy[k - 1], psiCopy[k], [2], [0]) M = bops.permute( bops.multiContraction(M, trotterGates[k - 1], [1, 2], [0, 1]), [0, 2, 3, 1]) [l, r, currTruncErr] = bops.svdTruncation(M, M[:2], M[2:], '<<', maxBondDim, leftName='site' + str(k - 1), rightName='site' + str(k), edgeName='v' + str(k)) if currTruncErr > truncErr: truncErr = currTruncErr psiCopy[k] = r psiCopy[k - 1] = l bops.multiContraction(r, r, [1, 2], [1, 2, '*']) for k in range(startSite, endSite): M = bops.multiContraction(psiCopy[k], psiCopy[k + 1], [2], [0]) M = bops.permute( bops.multiContraction(M, trotterGates[k], [1, 2], [0, 1]), [0, 2, 3, 1]) [l, r, currTruncErr] = bops.svdTruncation(M, M[:2], M[2:], '>>', maxBondDim, leftName='site' + str(k), rightName='site' + str(k + 1), edgeName='v' + str(k + 1)) if currTruncErr > truncErr: truncErr = currTruncErr psiCopy[k] = l psiCopy[k + 1] = r # For imaginary time propagation, renormalize state. norm = bops.getOverlap(psiCopy, psiCopy) psiCopy[N - 1].tensor = psiCopy[N - 1].tensor / math.sqrt(abs(norm)) return psiCopy, truncErr
def exactPurity(l, xRight, xLeft, upRow, downRow, A, filename, d=2): curr = xLeft pair = bops.permute(bops.multiContraction(A, A, '2', '4'), [1, 6, 3, 7, 2, 8, 0, 5, 4, 9]) for i in range(int(l / 2)): curr = bops.multiContraction( bops.multiContraction(curr, upRow, '0', '0'), downRow, '1', '0') curr = bops.multiContraction( curr, pair, [0, i * 4 + 1, i * 4 + 2, i * 4 + 4, i * 4 + 5], '20145') curr = bops.permute(curr, [i * 4, i * 4 + 2, i * 4 + 1] + list(range(i * 2)) + [i * 4 + 3, i * 4 + 4] + list(range(i * 2, i * 4)) + [i * 4 + 5, i * 4 + 6]) dm = bops.multiContraction(curr, xRight, '012', '012') ordered = np.reshape(dm.tensor, [d**l, d**l]) / np.trace( np.reshape(dm.tensor, [d**l, d**l])) purity = sum(np.linalg.eigvalsh(np.matmul(ordered, ordered))) with open(filename + '_l_' + str(l), 'wb') as f: pickle.dump(purity, f) return purity
def applyH(psi: List[tn.Node], H: HOp): psiCopy = bops.copyState(psi) single_0 = bops.copyState([H.singles[0]])[0] psiCopy[0] = bops.permute(tn.contract(psiCopy[0][1] ^ single_0[0], name=('site' + str(0))), [0, 2, 1]) result = psiCopy for i in range(1, len(psi)): psiCopy = bops.copyState(psi) single_i = bops.copyState([H.singles[i]])[0] psiCopy[i] = bops.permute(tn.contract(psiCopy[i][1] ^ single_i[0], name=('site' + str(i))), [0, 2, 1]) result = bops.addStates(result, psiCopy) for i in range(len(psi) - 1): psiCopy = bops.copyState(psi) r2l = bops.copyState([H.r2l[i+1]])[0] l2r = bops.copyState([H.l2r[i]])[0] psiCopy[i][2] ^ psiCopy[i+1][0] psiCopy[i][1] ^ l2r[0] r2l[0] ^ psiCopy[i+1][1] l2r[2] ^ r2l[2] M = tn.contract_between(psiCopy[i], \ tn.contract_between(l2r, tn.contract_between(r2l, psiCopy[i+1]))) [psiCopy, te] = bops.assignNewSiteTensors(psiCopy, i, M, '>>') result = bops.addStates(result, psiCopy) return result
def makeMeasurement(psi, site, toProject): localDM = bops.multiContraction(psi[site], psi[site], '02', '02*').tensor projectionProbability = np.trace(np.matmul(localDM, toProject)) / np.trace(localDM) # Project to the measured vector if np.random.uniform(0, 1) < projectionProbability: psi[site] = bops.permute( bops.multiContraction(psi[site], tn.Node(toProject), '1', '1', cleanOr1=True, cleanOr2=True), [0, 2, 1]) res = 1 else: psi[site] = bops.permute( bops.multiContraction(psi[site], tn.Node(np.eye(d) - toProject), '1', '1', cleanOr1=True, cleanOr2=True), [0, 2, 1]) res = 0 return res
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
def get2ByNExplicit(l: int): with open('results/toricBoundaries', 'rb') as f: [upRow, downRow, leftRow, rightRow, openA, openB, A, B] = pickle.load(f) left = bops.multiContraction( downRow, bops.multiContraction(leftRow, upRow, '3', '0'), '3', '0') for i in range(1, l): left = bops.multiContraction( downRow, bops.multiContraction(left, upRow, [3 + 4 * i], '0', cleanOr1=True), '3', '0') circle = bops.multiContraction(left, downRow, [3 + 4 * l, 0], '03') openA = tn.Node( np.transpose( np.reshape(np.kron(A.tensor, A.tensor), [d**2, d**2, d**2, d**2, d, d]), [4, 0, 1, 2, 3, 5])) openB = tn.Node( np.transpose( np.reshape(np.kron(B.tensor, B.tensor), [d**2, d**2, d**2, d**2, d, d]), [4, 0, 1, 2, 3, 5])) ABNet = bops.permute( bops.multiContraction(bops.multiContraction(openB, openA, '2', '4'), bops.multiContraction(openA, openB, '2', '4'), '28', '16', cleanOr1=True, cleanOr2=True), [1, 5, 6, 13, 14, 9, 10, 2, 0, 4, 8, 12, 3, 7, 11, 15]) if l == 2: curr = bops.multiContraction(circle, ABNet, '234567', '456701') res = bops.permute( bops.multiContraction(curr, ABNet, '23450176', '01234567'), [0, 1, 2, 3, 8, 9, 10, 11, 4, 5, 6, 7, 12, 13, 14, 15]) rdm = np.reshape(res.tensor, [2**8, 2**8]) rdm = rdm / np.trace(rdm) return rdm
def twoCopiesEntanglement(circle, A, B): doubleCircle = tn.Node(np.kron(circle.tensor, circle.tensor)) doubleA = tn.Node(np.kron(A.tensor, A.tensor)) doubleB = tn.Node(np.kron(B.tensor, B.tensor)) AEnv = tn.Node(np.trace(A.get_tensor(), axis1=0, axis2=5)) BEnv = tn.Node(np.trace(B.get_tensor(), axis1=0, axis2=5)) ABNet = bops.permute( bops.multiContraction(bops.multiContraction(BEnv, AEnv, '1', '3'), bops.multiContraction(AEnv, BEnv, '1', '3'), '15', '03'), [5, 1, 0, 2, 3, 6, 4, 7]) n = bops.multiContraction(circle, ABNet, '01234567', '01234567').tensor p2 = bops.multiContraction(doubleCircle, ABNet, '01234567', '01234567').tensor return p2
def verticalPair(topSite, bottomSite, cleanTop=True, cleanBottom=True): pair = bops.multiContraction(topSite, bottomSite, '2', '0', cleanOr1=cleanTop, cleanOr2=cleanBottom) pair = bops.multiContraction(pair, ru.getPairUnitary(d), '37', '01', cleanOr1=True, cleanOr2=True) [top, bottom, te] = bops.svdTruncation(pair, [0, 1, 2, 6], [3, 4, 5, 7], '>>', maxBondDim=16) return bops.permute(top, [0, 1, 4, 2, 3]), bottom
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 getDMRGH(N, onsiteTerms, neighborTerms, d=2): hSingles = [None] * N for i in range(N): hSingles[i] = tn.Node(onsiteTerms[i], name=('single' + str(i)), axis_names=['s' + str(i) + '*', 's' + str(i)]) hr2l = [None] * (N) hl2r = [None] * (N) for i in range(N-1): if d == 2: neighborTerm = np.reshape(neighborTerms[i], (2, 2, 2, 2)) elif d == 3: neighborTerm = np.reshape(neighborTerms[i], (3, 3, 3, 3)) pairOp = tn.Node(neighborTerm, \ axis_names=['s' + str(i) + '*', 's' + str(i+1) + '*', 's' + str(i), 's' + str(i+1)]) splitted = tn.split_node(pairOp, [pairOp[0], pairOp[2]], [pairOp[1], pairOp[3]], \ left_name=('l2r' + str(i)), right_name=('r2l' + str(i) + '*'), edge_name='m') hr2l[i+1] = bops.permute(splitted[1], [1, 2, 0]) hl2r[i] = splitted[0] return HOp(hSingles, hr2l, hl2r)
def localVecsEstimate(psi: List[tn.Node], vs: List[List[np.array]], half='left'): vs = np.round(vs, 10) n = len(vs) result = 1 for copy in range(n): if half == 'left': NA = len(vs[0]) curr = bops.multiContraction(psi[NA], psi[NA], '12', '12*') sites = range(NA - 1, -1, -1) elif half == 'right': NA = len(psi) - len(vs[0]) curr = bops.multiContraction(psi[len(psi) - NA - 1], psi[len(psi) - NA - 1], '01', '01*') sites = range(NA, len(psi)) psiCopy = bops.copyState(psi) for alpha in sites: toEstimate = np.outer(vs[copy][alpha - NA], np.conj(vs[np.mod(copy + 1, n)][alpha - NA])) psiCopy[alpha] = bops.permute(bops.multiContraction(psiCopy[alpha], tn.Node(toEstimate), \ '1', '1'), [0, 2, 1]) if half == 'left': curr = bops.multiContraction(bops.multiContraction( psiCopy[alpha], curr, '2', '0', cleanOr2=True), psi[alpha], '12', '12*', cleanOr1=True) elif half == 'right': curr = bops.multiContraction(bops.multiContraction( curr, psiCopy[alpha], '0', '0', cleanOr2=True), psi[alpha], '01', '01*', cleanOr1=True) # psiCopy = bops.shiftWorkingSite(psiCopy, alpha, '<<') result *= np.trace(curr.tensor) tn.remove_node(curr) bops.removeState(psiCopy) return result
def singleHaarEstimation(psi: List[tn.Node], us: List[tn.Node], n: int, NA: int): psiCopy = bops.copyState(psi) projector0 = np.zeros((2, 2)) projector0[0, 0] = 1 projector1 = np.zeros((2, 2)) projector1[1, 1] = 1 measurementResults = np.array(NA) estimation = 1 for i in range(NA): psiCopy[i] = bops.permute( bops.multiContraction(psiCopy[i], us[i], '1', '1', cleanOr1=True), [0, 2, 1]) measurementResults[i] = makeMeasurement(psiCopy, i, projector0) if measurementResults: resultProjector = projector0 else: resultProjector = projector1 localEstimation = np.matmul(np.matmul(np.conj(np.transpose(us[i].tensor)), resultProjector), us[i].tensor) \ - np.eye(2) estimation *= np.trace(localEstimation**4) psiCopy = bops.shiftWorkingSite(psiCopy, i, '<<') return estimation
def getExplicit2by2(g=0): if g == 0: with open('results/toricBoundaries', 'rb') as f: [upRow, downRow, leftRow, rightRow, openA, openB, A, B] = pickle.load(f) else: with open('results/toricBoundaries_g_' + str(g), 'rb') as f: [upRow, downRow, leftRow, rightRow, openA, openB, A, B] = pickle.load(f) circle = bops.multiContraction( bops.multiContraction(bops.multiContraction(upRow, rightRow, '3', '0'), downRow, '5', '0'), leftRow, '70', '03') ABNet = bops.permute( bops.multiContraction(bops.multiContraction(openB, openA, '2', '4'), bops.multiContraction(openA, openB, '2', '4'), '28', '16', cleanOr1=True, cleanOr2=True), [1, 5, 6, 13, 14, 9, 10, 2, 0, 4, 8, 12, 3, 7, 11, 15]) dm = bops.multiContraction(circle, ABNet, '01234567', '01234567') ordered = np.round(np.reshape(dm.tensor, [16, 16]), 14) ordered /= np.trace(ordered) return ordered
'3', '0', cleanOr1=True), base, '4', '0', cleanOr1=True) AEnv = tn.Node(np.trace(A.get_tensor(), axis1=0, axis2=5)) GammaATensor = np.zeros((d, d, d), dtype=complex) GammaATensor[1, 1, 1] = 1 GammaATensor[0, 0, 0] = 1 GammaBTensor = np.zeros((d, d, d), dtype=complex) GammaBTensor[1, 1, 1] = 1 GammaBTensor[1, 1, 0] = -1 GammaBTensor[0, 0, 1] = 1 GammaBTensor[0, 0, 0] = 1 LambdaTensor = np.ones(d, dtype=complex) cUp, dUp, cDown, dDown = peps.getBMPSRowOps(tn.Node(GammaATensor), tn.Node(LambdaTensor), tn.Node(GammaBTensor), tn.Node(LambdaTensor), AEnv, AEnv, 100) xRight = peps.bmpsSides(cUp, dUp, cUp, dUp, AEnv, AEnv, 100, option='right') xLeft = peps.bmpsSides(cUp, dUp, cUp, dUp, AEnv, AEnv, 100, option='left') pair = bops.permute(bops.multiContraction(A, A, '2', '4'), [1, 6, 3, 7, 2, 8, 0, 5, 4, 9]) upRow = bops.multiContraction(cUp, dUp, '2', '0') downRow = bops.multiContraction(cDown, dDown, '2', '0')
# origSizes = [T.tensor.shape[0], T.tensor.shape[1]] # tMatrix = np.round(np.reshape(T.tensor, [origSizes[0] * origSizes[1], origSizes[0] * origSizes[1]]), 14) # vals, vecs = scipy.sparse.linalg.eigs(tMatrix, k=1) # # vals = np.round(vals, 6) # # uVec = vecs[:, list(vals).index(1)] # uVec = vecs[:, 0] # uMatrix = np.reshape(uVec, origSizes) # uMatrix /= np.sqrt(np.trace(np.matmul(uMatrix, np.conj(np.transpose(uMatrix)))) / len(uMatrix)) # print(np.trace(np.matmul(uMatrix, np.conj(uMatrix))) / len(uMatrix)) # U = tn.Node(uMatrix, backend=None) psiP = bops.copyState(psi, conj=True) for i in A1 + A2: currU = trUnitary(i) psiP[i] = bops.permute(bops.multiContraction(psiP[i], currU, [1], [0]), [0, 2, 1]) psiConj = bops.copyState(psi, conj=True) curr = bops.multiContraction(psiP[A1[0]], psiConj[A1[0]], [0, 1], [0, 1]) for i in range(A1[1], A2[-1]-1): curr = bops.multiContraction(bops.multiContraction(curr, psiP[i], [0], [0]), psiConj[i], [0, 1], [0, 1]) curr = bops.multiContraction(bops.multiContraction(curr, psiP[A2[-1]], [0], [0]), psiConj[A2[-1]], [0, 1, 2], [0, 1, 2]) # pt = getPartiallyTransposed(psi, A1[0], A1[-1], A2[0], A2[-1]) # reg = getStraightDM(psiP, A1[0], A1[-1], A2[0], A2[-1]) b=1 """ This does not give the same result as Poleman-Turner's paper! """ def applySwap(psi, psiP, startInd, endInd): psiDagger = bops.copyState(psi, conj=True) psiPDagger = bops.copyState(psi, conj=True) curr = bops.multiContraction(psi[startInd], psiDagger[startInd], [0], [0]) currP = bops.multiContraction(psiP[startInd], psiPDagger[startInd], [0], [0])
with open( homedir + '/expected_MPS_NA_' + str(NA) + '_NB_' + str(NB) + '_n_' + str(n) + '_' + half, 'wb') as f: pickle.dump(Sn, f) mySum = 0 M = 1000 if half == 'left': steps = int(2**(NA * n)) for k in range(len(psi) - 1, NA - 1, -1): psi = bops.shiftWorkingSite(psi, k, '<<') sites = range(NA) else: steps = int(2**(NB * n)) sites = range(NA, len(psi)) for site in sites: psi[site] = bops.permute(bops.multiContraction(psi[site], U, '1', '0'), [0, 2, 1]) for m in range(M * steps): if half == 'left': vs = [[np.array([np.exp(1j * np.pi * np.random.randint(4) / 2), np.exp(1j * np.pi * np.random.randint(4) / 2)]) \ for alpha in range(NA)] for copy in range(n)] else: vs = [[np.array([np.exp(1j * np.pi * np.random.randint(4) / 2), np.exp(1j * np.pi * np.random.randint(4) / 2)]) \ for alpha in range(NB)] for copy in range(n)] u = np.matmul(ru.getUTheta(theta, d=2), ru.getUPhi(phi, d=2)) for i in range(len(vs)): for j in range(len(vs[0])): vs[i][j] = np.matmul(u, vs[i][j]) currEstimation = localVecsEstimate(psi, vs, half=half) mySum += currEstimation if m % M == M - 1: with open(
'1', '0') u1 = tn.Node(randomUs.haar_measure(d)) openA1 = bops.multiContraction(u1, bops.multiContraction(openA, u1, '5', '1*'), '1', '0') u2 = tn.Node(randomUs.haar_measure(d)) openA2 = bops.multiContraction(u2, bops.multiContraction(openA, u2, '5', '1*'), '1', '0') u3 = tn.Node(randomUs.haar_measure(d)) openB3 = bops.multiContraction(u3, bops.multiContraction(openB, u3, '5', '1*'), '1', '0') env123 = bops.multiContraction(circle, BEnv, '12', '03') env23 = bops.multiContraction(env123, AEnv, '126', '013') env3 = bops.permute(bops.multiContraction(env23, AEnv, '430', '023'), [2, 0, 1, 3]) us[m] = [u0.tensor, u1.tensor, u2.tensor, u3.tensor] rho3 = bops.multiContraction(env3, openB3, '0123', '1234') ks[m][3] = randomMeas(rho3.tensor / np.trace(rho3.tensor)) if ks[m][3] == 0: B3 = tn.Node(openB3.tensor[0, :, :, :, :, 0]) else: B3 = tn.Node(openB3.tensor[1, :, :, :, :, 1]) env2 = bops.permute(bops.multiContraction(env23, B3, '512', '012'), [2, 3, 1, 0]) rho2 = bops.multiContraction(env2, openA2, '0123', '1234') ks[m][2] = randomMeas(rho2.tensor / np.trace(rho2.tensor)) if ks[m][2] == 0: A2 = tn.Node(openA2.tensor[0, :, :, :, :, 0])
AEnv = toEnvOperator(bops.multiContraction(A, A, '4', '4*')) BEnv = toEnvOperator(bops.multiContraction(B, B, '4', '4*')) chi = 32 nonPhysicalLegs = 1 GammaTensor = np.ones((nonPhysicalLegs, d**2, nonPhysicalLegs), dtype=complex) GammaC = tn.Node(GammaTensor, name='GammaC', backend=None) LambdaC = tn.Node(np.eye(nonPhysicalLegs) / np.sqrt(nonPhysicalLegs), backend=None) GammaD = tn.Node(GammaTensor, name='GammaD', backend=None) LambdaD = tn.Node(np.eye(nonPhysicalLegs) / np.sqrt(nonPhysicalLegs), backend=None) steps = 50 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]) # # curr = bops.permute(bops.multiContraction(envOpBA, envOpAB, '45', '01'), [0, 2, 4, 6, 1, 3, 5, 7]) # # for i in range(50): # [C, D, te] = bops.svdTruncation(curr, [0, 1, 2, 3], [4, 5, 6, 7], '>>', normalize=True) # curr = bops.permute(bops.multiContraction(D, C, '23', '12'), [1, 3, 0, 5, 2, 4]) # curr = bops.permute(bops.multiContraction(curr, envOpAB, '45', '01'), [0, 2, 4, 6, 1, 3, 5, 7]) # # currAB = curr # [C, D, te] = bops.svdTruncation(curr, [0, 1, 2, 3], [4, 5, 6, 7], '>>', normalize=True) # currBA = bops.permute(bops.multiContraction(D, C, '23', '12'), [1, 3, 0, 5, 2, 4]) # currBA = bops.permute(bops.multiContraction(currBA, envOpAB, '45', '01'), [0, 2, 4, 6, 1, 3, 5, 7]) #