def test_exatn(): a1 = np.random.randn(2, 3, 4) print('A1 shape: ', a1.shape) b1 = np.random.randn(2, 3, 4, 5) print('B1 shape: ', b1.shape) exatn.createTensor('C1', [3, 4, 5], 0.0) exatn.createTensor('A1', a1.copy(order='F')) exatn.createTensor('B1', b1.copy(order='F')) exatn.contractTensors('C1(b,c,d)=A1(a,b,c)*B1(a,b,c,d)', 1.0) c1 = exatn.getLocalTensor('C1') print('C1 shape: ', c1.shape) print('ExaTN result c1 = a1 * b1:\n', c1) d1 = np.einsum('abc, abcd->bcd', a1, b1) print('D1 shape: ', d1.shape) print('NumPy result c1 = a1 * b1:\n', d1) exatn.destroyTensor('B1') exatn.destroyTensor('A1') exatn.destroyTensor('C1')
def test_exatn(): a1 = np.array([ [1., 0., 0.], [0., 1., 1.]]) print('A1 shape: ',a1.shape) b1 = np.array([ [ 1., 0., 3., 0.], [ 1., 1., 2., 2.], [-1., 1., -2., 2.]]) print('B1 shape: ',b1.shape) exatn.createTensor('C1', [2, 4], 0.0) exatn.createTensor('A1', a1.copy(order='F')) exatn.createTensor('B1', b1.copy(order='F')) exatn.contractTensors('C1(a,c)=A1(a,b)*B1(b,c)',1.0) c1 = exatn.getLocalTensor('C1') print('C1 shape: ',c1.shape) d1 = np.dot(a1, b1) print('D1 shape: ',d1.shape) print('NumPy result c1 = a1 * b1:\n', d1) print('ExaTN result c1 = a1 * b1:\n', c1) exatn.destroyTensor('B1') exatn.destroyTensor('A1') exatn.destroyTensor('C1')
def run(n, num_iter, num_batch): tn.createTensor("C", np.zeros((n, n))) tn.createTensor("A", np.random.rand(n, n)) tn.createTensor("B", np.random.rand(n, n)) nops = 2 * n**3 / 1e9 elapsed = benchmark(num_iter, num_batch, foo) tn.getLocalTensor("C") tn.destroyTensor("A") tn.destroyTensor("B") tn.destroyTensor("C") print(n, ", ", nops / elapsed)
import exatn, numpy as np exatn.createTensor("Sx", np.array([[0., 1.], [1., 0.]])) exatn.createTensor("Sy", np.array([[0., -1.j], [1.j, 0.]])) exatn.print("Sx") exatn.print("Sy") def negate(data): data *= -1. exatn.transformTensor("Sx", negate) exatn.print("Sx") exatn.transformTensor("Sx", negate) exatn.print("Sx") exatn.transformTensor("Sy", negate) exatn.print("Sy")
from pathlib import Path sys.path.insert(1, str(Path.home()) + '/.exatn') import exatn, numpy as np #Quantum Circuit: #Q0----H--------- #Q1----H----C---- #Q2----H----N---- #Define the initial qubit state vector: qzero = np.array([1.0, 0.0], dtype=complex) hadamard = np.array([[1., 1.],[1., -1.]], dtype=complex) cnot = np.reshape(np.array([[1, 0, 0, 0],[0, 1, 0, 0],[0, 0, 0, 1],[0, 0, 1, 0]], dtype=complex), (2,2,2,2)) exatn.createTensor('Q0', qzero) exatn.createTensor('Q1', qzero) exatn.createTensor('Q2', qzero) exatn.createTensor('H', hadamard) exatn.createTensor('CNOT', cnot) exatn.registerTensorIsometry('H', [0], [1]) exatn.registerTensorIsometry('CNOT', [0,1], [2,3]) circuit = exatn.TensorNetwork('QuantumCircuit') circuit.appendTensor(1, 'Q0') circuit.appendTensor(2, 'Q1') circuit.appendTensor(3, 'Q2') circuit.appendTensorGate(4, 'H', [0])
import exatn, numpy as np # Create some numpy arrays s = np.random.rand(2) r = np.random.rand(2) # Create the ExaTN tensors exatn.createTensor("Z0", 0.0) exatn.createTensor("S", s) exatn.createTensor("R", r) # Print S, R exatn.print("S") exatn.print("R") # Demonstrate transformTensor interface by # negating the tensor data in S def negate(data): data *= -1. exatn.transformTensor("S", negate) exatn.print("S") # Compute the dot product, store in Z0 exatn.evaluateTensorNetwork('MyTN', 'Z0() = S(a) * R(a)') exatn.print('Z0') z0_data = exatn.getLocalTensor('Z0')
import sys from pathlib import Path sys.path.insert(1, str(Path.home()) + '/.exatn') import exatn import numpy as np # Demonstrate simple tensor network manipulation exatn.createTensor('X', [2, 2], 0) exatn.createTensor('Y', [2, 2], 0) exatn.createTensor('Z', [2, 2], 0) exatn.initTensorRnd('X') exatn.initTensorRnd('Y') exatn.initTensorRnd('Z') tNet = exatn.TensorNetwork('test') tNet.appendTensor(1, 'X') tNet.appendTensor(2, 'Y') tNet.appendTensor(3, 'Z') # print tensor network tNet.printIt() tNetOriginal = exatn.TensorNetwork(tNet) # Merge X and Y pattern = tNet.mergeTensors(1, 2, 4) print("After merge:") tNet.printIt() # Print the generic merge pattern print(pattern) # Create the merged tensor pattern = pattern.replace("D", tNet.getTensor(4).getName())
import sys from pathlib import Path sys.path.insert(1, str(Path.home()) + '/.exatn') import exatn, numpy as np qzero = np.array([1.0, 0.0], dtype=complex) hadamard = np.array([[1., 1.],[1., -1.]], dtype=complex) nQubits = 10 [exatn.createTensor('Q'+str(i), qzero) for i in range(nQubits)] exatn.createTensor('H', hadamard) exatn.registerTensorIsometry('H', [0], [1]) tensorCounter = 1 circuit = exatn.TensorNetwork('QuantumCircuit') [circuit.appendTensor(tensorCounter+c, 'Q'+str(i)) for i,c in enumerate(range(nQubits))] tensorCounter += nQubits qubitReg = exatn.TensorNetwork(circuit) qubitReg.rename('QubitKet') [circuit.appendTensorGate(tensorCounter+c, 'H', [i]) for i, c in enumerate(range(nQubits))] tensorCounter += nQubits circuit.printIt() inverse = exatn.TensorNetwork(circuit) inverse.rename('InverseCircuit') [inverse.appendTensorGate(tensorCounter+c, 'H', [nQubits - i - 1], True) for i,c in enumerate(range(nQubits))]
import sys from pathlib import Path sys.path.insert(1, str(Path.home()) + '/.exatn') import exatn, numpy as np qzero = np.array([1.0, 0.0], dtype=complex) unitary = np.reshape(np.array([1, -1j, -1j, 1], dtype=complex), (2, 2)) exatn.createTensor('Q0', qzero) exatn.createTensor('U', unitary) exatn.registerTensorIsometry('U', [0], [1]) circuit = exatn.TensorNetwork('QuantumCircuit') circuit.appendTensor(1, 'Q0') circuit.appendTensorGate(2, 'U', [0]) circuit.printIt() conj_circuit = exatn.TensorNetwork(circuit) conj_circuit.rename('ConjugatedCircuit') conj_circuit.conjugate() conj_circuit.printIt() assert (exatn.evaluate(circuit)) assert (exatn.evaluate(conj_circuit)) print(exatn.getLocalTensor(circuit.getTensor(0).getName())) print(exatn.getLocalTensor(conj_circuit.getTensor(0).getName()))
def conjugate(tName): exatn.createTensor(tName + 'conj', np.conj(exatn.getLocalTensor(tName)))
chosen = np.transpose(chosen, (0, 2, 1, 3)) print(np.reshape(chosen, (4, 4))) #isometryGuess = np.array([[[1,0],[0,0]],[[0,1/np.sqrt(2)],[1/np.sqrt(2),0]],[[0,0],[0,0]],[[0,0],[0,1]]]) + np.array([[[0,0],[0,0]],[[0,0],[0,0]],[[0,1/np.sqrt(2)],[-1/np.sqrt(2),0]],[[0,0],[0,0]]])*1j #isometryGuess = np.array([[[1,0],[0,0]],[[0,.5],[.5,0]],[[0,.5],[.5,0]],[[0,0],[0,1]]]) + np.array([[[0,0],[0,0]],[[0,-.5],[.5,0]],[[0,.5],[-.5,0]],[[0,0],[0,0]]])*1j # isometryGuess = np.array([[[1,0],[0,0]],[[0,1],[0,0]],[[0,0],[1,0]],[[0,0],[0,1]]]) + np.array([[[0,0],[0,0]],[[0,0],[0,0]],[[0,0],[0,0]],[[0,0],[0,0]]])*1j angles = [np.random.uniform(0, np.pi) for i in range(15)] SSU = anglesToTensor(angles) SSU = anglesToTensor([ -0.020491765812750733, 1.0849813938928623, 0.1823094915565751, -0.01892176877947449, 1.8492804753843204, 0.16753058604914656, 1.5707963267913112, -7.266906333088912e-13, 1.5707963267988387, 2.4032056784753717, 0.13338369000216244, 0.5760507158714833, 0.28699706946011383, 0.3217444561240923, -0.11511191774971147 ]) I = exatn.createTensor('I', np.reshape(SSU, (4, 2, 2))) conjugate('I') #test I is isometry, II should be identity exatn.createTensor('II', [4, 4], 0 + 0j) exatn.contractTensors('II(a,b)=I(a,i,j)*Iconj(b,i,j)') print('I doubled') exatn.print('II') rho = np.reshape(chosen, (4, 4)) w, sig1, e = np.linalg.svd(rho)[0], np.linalg.svd(rho)[1], np.linalg.svd( rho)[2] w, e = np.reshape(w, (2, 2, 4)), np.reshape(e, (4, 2, 2)) wi = np.tensordot(w.copy(), exatn.getLocalTensor('I').copy(), axes=((2), (0))) ei = np.tensordot(e.copy(), exatn.getLocalTensor('I').copy(), axes=((0), (0)))
dimVars = dimVars[:-1] dimVarList = dimVars.split("; ") vardict = {} for var in dimVarList: varName, varVal = var.split(":") vardict[varName] = varVal gFlops *= float(varVal) exprSplits = re.split(' = | * ', expr) rhsTensor = exprSplits[0] lhsTensorOperand1 = exprSplits[1] lhsTensorOperand2 = exprSplits[3] #print("{}:{}:{}".format(rhsTensor, lhsTensorOperand1, lhsTensorOperand2)) # LHS (result) 'C' tensor assert (rhsTensor[0] == "C") exatn.createTensor("C", getTensorDimArray(rhsTensor, vardict), 0.0) # RHS A tensor assert (lhsTensorOperand1[0] == "A") exatn.createTensor("A", getTensorDimArray(lhsTensorOperand1, vardict), 0.0) # Initialize random tensor body exatn.initTensorRnd("A") # RHS B tensor assert (lhsTensorOperand2[0] == "B") exatn.createTensor("B", getTensorDimArray(lhsTensorOperand2, vardict), 0.0) # Initialize random tensor body exatn.initTensorRnd("B") # Convert [] to () (ExaTN convention) exatnExpr = expr.replace('[', '(').replace(']', ')')
import sys from pathlib import Path sys.path.insert(1, str(Path.home()) + '/.exatn') import exatn exatn.createTensor('Z0') exatn.createTensor('T0', [2,2], .01) exatn.createTensor('T1', [2,2,2], .01) exatn.createTensor('T2', [2,2], .01) exatn.createTensor('H0', [2,2,2,2], .01) exatn.createTensor('S0', [2,2], .01) exatn.createTensor('S1', [2,2,2], .01) exatn.createTensor('S2', [2,2], .01) exatn.evaluateTensorNetwork('{0,1} 3-site MPS closure', 'Z0() = T0(a,b) * T1(b,c,d) * T2(d,e) * H0(a,c,f,g) * S0(f,h) * S1(h,g,i) * S2(i,e)') z0 = exatn.getLocalTensor('Z0') assert(abs(z0 - 5.12e-12) < 1e-12) print(z0)
import sys from pathlib import Path sys.path.insert(1, str(Path.home()) + '/.exatn') import exatn, numpy as np # Declare MPS tensors: exatn.createTensor('Q0', [2, 2], 1e-2) exatn.createTensor('Q1', [2, 2, 4], 1e-2) exatn.createTensor('Q2', [4, 2, 2], 1e-2) exatn.createTensor('Q3', [2, 2], 1e-2) # Declare Hamiltonian Tensors exatn.createTensor('H01', [2, 2, 2, 2], 1e-2) exatn.createTensor('H12', [2, 2, 2, 2], 1e-2) exatn.createTensor('H23', [2, 2, 2, 2], 1e-2) exatn.createTensor('Z0', [2, 2, 2, 2], 1e-2) # Get them as exatn.Tensor q0 = exatn.getTensor('Q0') q1 = exatn.getTensor('Q1') q2 = exatn.getTensor('Q2') q3 = exatn.getTensor('Q3') h01 = exatn.getTensor('H01') h12 = exatn.getTensor('H12') h23 = exatn.getTensor('H23') z0 = exatn.getTensor('Z0') # Declare the Hamiltonian Operator ham = exatn.TensorOperator('Hamiltonian') ham.appendComponent(h01, [[0, 0], [1, 1]], [[0, 2], [1, 3]], 1.0) ham.appendComponent(h12, [[1, 0], [2, 1]], [[1, 2], [2, 3]], 1.0)