def test_run_program(self): """Test run. If all correct should the data. """ QP_program = QuantumProgram(specs=QPS_SPECS) qr = QP_program.get_quantum_register("qname") cr = QP_program.get_classical_register("cname") qc2 = QP_program.create_circuit("qc2", [qr], [cr]) qc3 = QP_program.create_circuit("qc3", [qr], [cr]) qc2.h(qr[0]) qc2.cx(qr[0], qr[1]) qc2.cx(qr[0], qr[2]) qc3.h(qr) qc2.measure(qr, cr) qc3.measure(qr, cr) circuits = ['qc2', 'qc3'] shots = 1024 # the number of shots in the experiment. backend = 'local_qasm_simulator' qobj = QP_program.compile(circuits, backend=backend, shots=shots, seed=88) out = QP_program.run(qobj) results2 = out.get_counts('qc2') results3 = out.get_counts('qc3') self.assertEqual(results2, {'000': 518, '111': 506}) self.assertEqual(results3, {'001': 119, '111': 129, '110': 134, '100': 117, '000': 129, '101': 126, '010': 145, '011': 125})
def main(): qp = QuantumProgram() #Create 1 qubit quantum_r = qp.create_quantum_register("qr",1) #Create 1 classical register classical_r = qp.create_classical_register("cr",1) #Create a circuit qp.create_circuit("Circuit", [quantum_r], [classical_r]) #Get the circuit by name circuit = qp.get_circuit('Circuit') #enable logging qp.enable_logs(logging.DEBUG); #pauliX gate circuit.x(quantum_r[0]) #measure gate from qubit 0 to classical bit 0 circuit.measure(quantum_r[0], classical_r[0]) #backend simulator backend = 'local_qasm_simulator' #circuits to execute circuits = ['Circuit'] #Compile the program qobj = qp.compile(circuits, backend) #run simulator result = qp.run(qobj, timeout=240) #Show result counts print(str(result.get_counts('Circuit')))
def test_run_program_map(self): """Test run_program_map. If all correct should return 10010. """ QP_program = QuantumProgram() QP_program.set_api(API_TOKEN, URL) backend = 'local_qasm_simulator' # the backend to run on shots = 100 # the number of shots in the experiment. max_credits = 3 coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]} initial_layout = { ("q", 0): ("q", 0), ("q", 1): ("q", 1), ("q", 2): ("q", 2), ("q", 3): ("q", 3), ("q", 4): ("q", 4) } QP_program.load_qasm_file(QASM_FILE_PATH_2, name="circuit-dev") circuits = ["circuit-dev"] qobj = QP_program.compile(circuits, backend=backend, shots=shots, max_credits=max_credits, seed=65, coupling_map=coupling_map, initial_layout=initial_layout) result = QP_program.run(qobj) self.assertEqual(result.get_counts("circuit-dev"), {'10010': 100})
def test_compile_coupling_map(self): """Test compile_coupling_map. If all correct should return data with the same stats. The circuit may be different. """ QP_program = QuantumProgram() q = QP_program.create_quantum_register("q", 3, verbose=False) c = QP_program.create_classical_register("c", 3, verbose=False) qc = QP_program.create_circuit("circuitName", [q], [c]) qc.h(q[0]) qc.cx(q[0], q[1]) qc.cx(q[0], q[2]) qc.measure(q[0], c[0]) qc.measure(q[1], c[1]) qc.measure(q[2], c[2]) backend = 'local_qasm_simulator' # the backend to run on shots = 1024 # the number of shots in the experiment. coupling_map = {0: [1], 1: [2]} initial_layout = {("q", 0): ("q", 0), ("q", 1): ("q", 1), ("q", 2): ("q", 2)} circuits = ["circuitName"] qobj = QP_program.compile(circuits, backend=backend, shots=shots, coupling_map=coupling_map, initial_layout=initial_layout, seed=88) result = QP_program.run(qobj) to_check = QP_program.get_qasm("circuitName") self.assertEqual(len(to_check), 160) self.assertEqual(result.get_counts("circuitName"), {'000': 518, '111': 506})
def test_run_program(self): """Test run. If all correct should the data. """ QP_program = QuantumProgram(specs=QPS_SPECS) qr = QP_program.get_quantum_register("qname") cr = QP_program.get_classical_register("cname") qc2 = QP_program.create_circuit("qc2", [qr], [cr]) qc3 = QP_program.create_circuit("qc3", [qr], [cr]) qc2.h(qr[0]) qc2.cx(qr[0], qr[1]) qc2.cx(qr[0], qr[2]) qc3.h(qr) qc2.measure(qr[0], cr[0]) qc3.measure(qr[0], cr[0]) qc2.measure(qr[1], cr[1]) qc3.measure(qr[1], cr[1]) qc2.measure(qr[2], cr[2]) qc3.measure(qr[2], cr[2]) circuits = ['qc2', 'qc3'] shots = 1024 # the number of shots in the experiment. backend = 'local_qasm_simulator' qobj = QP_program.compile(circuits, backend=backend, shots=shots, seed=88) out = QP_program.run(qobj) results2 = out.get_counts('qc2') results3 = out.get_counts('qc3') self.assertEqual(results2, {'000': 518, '111': 506}) self.assertEqual(results3, {'001': 119, '111': 129, '110': 134, '100': 117, '000': 129, '101': 126, '010': 145, '011': 125})
def twoBitsAdder(): Circuit = 'twoBitsAdderCircuit' # Create the quantum program qp = QuantumProgram() # Creating registers n_qubits = 8 qr = qp.create_quantum_register("qr", n_qubits) cr = qp.create_classical_register("cr", n_qubits) # Two-bits adder circuit, where: # qr[0|1] and qr[2|3] are adders # qr[4-5] are the result # qr[6] is the carry_out # qr[7] is the temp reg obc = qp.create_circuit(Circuit, [qr], [cr]) # Prepare bits to add obc.h(qr[0]) obc.h(qr[1]) obc.h(qr[2]) obc.h(qr[3]) # The low-bit result in qr[4] obc.cx(qr[0], qr[4]) obc.cx(qr[2], qr[4]) # The carry in temp reg obc.ccx(qr[0], qr[2], qr[7]) # The high-bit result in qr[5] obc.cx(qr[1], qr[5]) obc.cx(qr[3], qr[5]) obc.cx(qr[7], qr[5]) # The carry_out in qr[6] obc.ccx(qr[1], qr[3], qr[6]) obc.ccx(qr[1], qr[7], qr[6]) obc.ccx(qr[3], qr[7], qr[6]) # Measure for i in range(0, n_qubits): obc.measure(qr[i], cr[i]) # Get qasm source source = qp.get_qasm(Circuit) print(source) # Compile and run backend = 'local_qasm_simulator' circuits = [Circuit] # Group of circuits to execute qobj = qp.compile(circuits, backend) # Compile your program result = qp.run(qobj, wait=2, timeout=240) print(result) results = result.get_counts(Circuit) print(results) validate(results)
def test_run_program(self): QP_program = QuantumProgram(specs=QPS_SPECS) qc = QP_program.get_circuit("circuitName") qr = QP_program.get_quantum_registers("qname") cr = QP_program.get_classical_registers("cname") qc2 = QP_program.create_circuit("qc2", ["qname"], ["cname"]) qc3 = QP_program.create_circuit("qc3", ["qname"], ["cname"]) qc2.h(qr[0]) qc3.h(qr[0]) qc2.measure(qr[0], cr[0]) qc3.measure(qr[0], cr[0]) circuits = ['qc2', 'qc3'] device = 'simulator' # the device to run on shots = 1024 # the number of shots in the experiment. credits = 3 coupling_map = None apiconnection = QP_program.set_api(API_TOKEN, URL) QP_program.compile(circuits, device, shots, credits, coupling_map) result = QP_program.run() # print(QP_program()) print(result) # TODO: Revire result self.assertEqual(result['status'], 'COMPLETED')
def q_add_one_mod_5(self, n): qasm = """ OPENQASM 2.0; include "qelib1.inc"; qreg q[5]; creg c[3]; // Inputs. {}x q[0]; {}x q[1]; {}x q[2]; cx q[2],q[3]; cx q[1],q[4]; x q[2]; ccx q[1],q[2],q[4]; cx q[3],q[1]; cx q[4],q[0]; reset q[3]; reset q[4]; ccx q[0],q[1],q[3]; cx q[3],q[1]; cx q[3],q[0]; ccx q[2],q[3],q[1]; cx q[3],q[2]; reset q[3]; x q[0]; x q[1]; x q[2]; ccx q[0],q[1],q[3]; ccx q[2],q[3],q[4]; x q[0]; x q[1]; x q[2]; reset q[3]; cx q[4],q[2]; cx q[4],q[1]; measure q[0] -> c[2]; measure q[1] -> c[1]; measure q[2] -> c[0]; """ binary = bin(n)[2:].zfill(3) comments = ['' if int(bi) else '//' for bi in binary] qasm = qasm.format(*comments) qp = QuantumProgram() qp.load_qasm_text(qasm, name='circuit') qobj = qp.compile(['circuit']) result = qp.run(qobj, wait=2, timeout=240) counted_result = Counter(result.get_counts('circuit')) # Turn binary back to decimal. output = int(counted_result.most_common()[0][0], 2) return output
def oneBitAdder(): from qiskit import QuantumProgram Circuit = 'oneBitAdderCircuit' # Create the quantum program qp = QuantumProgram() # Creating registers n_qubits = 4 qr = qp.create_quantum_register("qr", n_qubits) cr = qp.create_classical_register("cr", n_qubits) # One-bit adder circuit, where: # qr[2] = qr[0] + qr[1] # qr[3] = carry obc = qp.create_circuit(Circuit, [qr], [cr]) # Prepare bits to add obc.h(qr[0]) obc.h(qr[1]) # qr[2] = 1 when qr0/1 has only one 1; # = 0 when qr0/1 are both 0 or 1; obc.cx(qr[0], qr[2]) obc.cx(qr[1], qr[2]) # qr[3] = 1 when qr0/1 are both 1; # = 0 otherwise; obc.ccx(qr[0], qr[1], qr[3]) # Measure for i in range(0, n_qubits): obc.measure(qr[i], cr[i]) # Get qasm source source = qp.get_qasm(Circuit) print(source) # Compile and run backend = 'local_qasm_simulator' circuits = [Circuit] # Group of circuits to execute qobj = qp.compile(circuits, backend) # Compile your program result = qp.run(qobj, wait=2, timeout=240) print(result) results = result.get_counts(Circuit) print(results) validate(results)
def test_teleport(self): """test teleportation as in tutorials""" self.log.info('test_teleport') pi = np.pi shots = 1000 qp = QuantumProgram() qr = qp.create_quantum_register('qr', 3) cr0 = qp.create_classical_register('cr0', 1) cr1 = qp.create_classical_register('cr1', 1) cr2 = qp.create_classical_register('cr2', 1) circuit = qp.create_circuit('teleport', [qr], [cr0, cr1, cr2]) circuit.h(qr[1]) circuit.cx(qr[1], qr[2]) circuit.ry(pi / 4, qr[0]) circuit.cx(qr[0], qr[1]) circuit.h(qr[0]) circuit.barrier(qr) circuit.measure(qr[0], cr0[0]) circuit.measure(qr[1], cr1[0]) circuit.z(qr[2]).c_if(cr0, 1) circuit.x(qr[2]).c_if(cr1, 1) circuit.measure(qr[2], cr2[0]) backend = 'local_qasm_simulator' qobj = qp.compile('teleport', backend=backend, shots=shots, seed=self.seed) results = qp.run(qobj) data = results.get_counts('teleport') alice = {} bob = {} alice['00'] = data['0 0 0'] + data['1 0 0'] alice['01'] = data['0 1 0'] + data['1 1 0'] alice['10'] = data['0 0 1'] + data['1 0 1'] alice['11'] = data['0 1 1'] + data['1 1 1'] bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1'] bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1'] self.log.info('test_telport: circuit:') self.log.info(circuit.qasm()) self.log.info('test_teleport: data {0}'.format(data)) self.log.info('test_teleport: alice {0}'.format(alice)) self.log.info('test_teleport: bob {0}'.format(bob)) alice_ratio = 1 / np.tan(pi / 8)**2 bob_ratio = bob['0'] / float(bob['1']) error = abs(alice_ratio - bob_ratio) / alice_ratio self.log.info('test_teleport: relative error = {0:.4f}'.format(error)) self.assertLess(error, 0.05)
def test_new_run(self): QP_program = QuantumProgram() device = 'local_qasm_simulator' # the device to run on shots = 1 # the number of shots in the experiment. credits = 3 coupling_map = None QP_program.load_qasm("circuit-dev", "test.qasm") circuits = ["circuit-dev"] result = QP_program.compile(circuits, device, shots, credits, coupling_map) result = QP_program.run() self.assertEqual(result['status'], 'COMPLETED')
def test_teleport(self): """test teleportation as in tutorials""" self.log.info('test_teleport') pi = np.pi shots = 1000 qp = QuantumProgram() qr = qp.create_quantum_register('qr', 3) cr0 = qp.create_classical_register('cr0', 1) cr1 = qp.create_classical_register('cr1', 1) cr2 = qp.create_classical_register('cr2', 1) circuit = qp.create_circuit('teleport', [qr], [cr0, cr1, cr2]) circuit.h(qr[1]) circuit.cx(qr[1], qr[2]) circuit.ry(pi/4, qr[0]) circuit.cx(qr[0], qr[1]) circuit.h(qr[0]) circuit.barrier(qr) circuit.measure(qr[0], cr0[0]) circuit.measure(qr[1], cr1[0]) circuit.z(qr[2]).c_if(cr0, 1) circuit.x(qr[2]).c_if(cr1, 1) circuit.measure(qr[2], cr2[0]) backend = 'local_qasm_simulator' qobj = qp.compile('teleport', backend=backend, shots=shots, seed=self.seed) results = qp.run(qobj) data = results.get_counts('teleport') alice = {} bob = {} alice['00'] = data['0 0 0'] + data['1 0 0'] alice['01'] = data['0 1 0'] + data['1 1 0'] alice['10'] = data['0 0 1'] + data['1 0 1'] alice['11'] = data['0 1 1'] + data['1 1 1'] bob['0'] = data['0 0 0'] + data['0 1 0'] + data['0 0 1'] + data['0 1 1'] bob['1'] = data['1 0 0'] + data['1 1 0'] + data['1 0 1'] + data['1 1 1'] self.log.info('test_telport: circuit:') self.log.info( circuit.qasm() ) self.log.info('test_teleport: data {0}'.format(data)) self.log.info('test_teleport: alice {0}'.format(alice)) self.log.info('test_teleport: bob {0}'.format(bob)) alice_ratio = 1/np.tan(pi/8)**2 bob_ratio = bob['0']/float(bob['1']) error = abs(alice_ratio - bob_ratio) / alice_ratio self.log.info('test_teleport: relative error = {0:.4f}'.format(error)) self.assertLess(error, 0.05)
def QISKit_NOT_Gate(x): backend = 'local_qasm_simulator' Circuit = 'NOT_GATE' qProgram = QuantumProgram() qRegister = qProgram.create_quantum_register('q1', 1) cRegister = qProgram.create_classical_register('c1', 1) qCircuit = qProgram.create_circuit(Circuit, [qRegister], [cRegister]) if (x == 1): qCircuit.x(qRegister[0]) qCircuit.x(qRegister[0]) qCircuit.measure(qRegister[0], cRegister[0]) qobj = qProgram.compile([Circuit], backend=backend) result = qProgram.run(qobj, wait=2, timeout=240) dic_result = result.get_counts(Circuit) max_prob_key = max(dic_result, key=dic_result.get) return int(max_prob_key)
def test_run_program_map(self): """Test run_program_map. If all correct should return 10010. """ QP_program = QuantumProgram() QP_program.set_api(API_TOKEN, URL) backend = 'local_qasm_simulator' # the backend to run on shots = 100 # the number of shots in the experiment. max_credits = 3 coupling_map = {0: [1], 1: [2], 2: [3], 3: [4]} initial_layout = {("q", 0): ("q", 0), ("q", 1): ("q", 1), ("q", 2): ("q", 2), ("q", 3): ("q", 3), ("q", 4): ("q", 4)} QP_program.load_qasm_file(QASM_FILE_PATH_2, name="circuit-dev") circuits = ["circuit-dev"] qobj = QP_program.compile(circuits, backend=backend, shots=shots, max_credits=max_credits, seed=65, coupling_map=coupling_map, initial_layout=initial_layout) result = QP_program.run(qobj) self.assertEqual(result.get_counts("circuit-dev"), {'10010': 100})
def execute(argv, verbose=False): from qiskit import QuantumProgram # Create the quantum program qp = QuantumProgram() # Load from filename circuit = qp.load_qasm_file(filename) # Get qasm source source = qp.get_qasm(circuit) if verbose: print(source) # Compile and run backend = 'local_qasm_simulator' qobj = qp.compile([circuit], backend) # Compile your program result = qp.run(qobj, wait=2, timeout=240) if verbose: print(result) print(result.get_counts(circuit))
def main(): # create a program qp = QuantumProgram() # create 1 qubit quantum_r = qp.create_quantum_register("qr", 1) # create 1 classical register classical_r = qp.create_classical_register("cr", 1) # create a circuit circuit = qp.create_circuit("Circuit", [quantum_r], [classical_r]) # enable logging qp.enable_logs(logging.DEBUG); # Pauli X gate to qubit 1 in the Quantum Register "qr" circuit.x(quantum_r[0]) # measure gate from qubit 0 to classical bit 0 circuit.measure(quantum_r[0], classical_r[0]) # backend simulator backend = 'local_qasm_simulator' # Group of circuits to execute circuits = ['Circuit'] # Compile your program: ASM print(qp.get_qasm('Circuit')), JSON: print(str(qobj)) qobj = qp.compile(circuits, backend) # run in the simulator wait=2, result = qp.run(qobj, timeout=240) # Show result counts print (str(result.get_counts('Circuit')))
# Measure all of the qubits in the standard basis for i in range(5): ghz.measure(q[i], c[i]) # Create a Bell state bell.h(q[0]) bell.cx(q[0], q[1]) bell.barrier() bell.measure(q[0], c[0]) bell.measure(q[1], c[1]) print(ghz.qasm()) print(bell.qasm()) ############################################################### # Set up the API and execute the program. ############################################################### result = qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) if not result: print("Error setting API") sys.exit(1) qp.compile(["bell"], device='local_qasm_simulator', shots=1024) qp.compile(["ghz"], device='simulator', shots=1024, coupling_map=coupling_map) qp.run() print(qp.get_counts("bell")) # returns error, don't do this print(qp.get_counts("bell", device="local_qasm_simulator")) print(qp.get_counts("ghz"))
circuit.ccx(q_register[0], q_register[1], q_register[2]) # XOR gate from Qbit 0 to the Qbit 3 circuit.cx(q_register[0], q_register[3]) # XOR gate from Qbit 1 to the Qbit 3 circuit.cx(q_register[1], q_register[3]) # measure gate from the Qbit 0 to Classical bit 3 circuit.measure(q_register[0], c_register[3]) # measure gate from the Qbit 1 to Classical bit 2 circuit.measure(q_register[1], c_register[2]) # measure gate from the Qbit 2 to Classical bit 1 circuit.measure(q_register[2], c_register[1]) # measure gate from the Qbit 3 to Classical bit 0 circuit.measure(q_register[3], c_register[0]) source = program.get_qasm('circuit') print(source) backend = 'local_qasm_simulator' circuits = ['circuit'] object = program.compile(circuits, backend) result = program.run(object, wait=2, timeout=240) print(result) print(result.get_counts('circuit'))
qc.x(a[0]) # Set input a = 0...0001 qc.x(b) # Set input b = 1...1111 # Apply the adder qc += adder_subcircuit # Measure the output register in the computational basis for j in range(n): qc.measure(b[j], ans[j]) qc.measure(cout[0], ans[n]) ############################################################### # Set up the API and execute the program. ############################################################### qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) # First version: not mapped result = qp.execute(["rippleadd"], backend=backend, coupling_map=None, shots=1024) print(result) print(result.get_counts("rippleadd")) # Second version: mapped to 2x8 array coupling graph obj = qp.compile(["rippleadd"], backend=backend, coupling_map=coupling_map, shots=1024) result = qp.run(obj) print(result) print(result.get_ran_qasm("rippleadd")) print(result.get_counts("rippleadd")) # Both versions should give the same distribution
# Measure the output register in the computational basis for j in range(n): qc.measure(b[j], ans[j]) qc.measure(cout[0], ans[n]) ############################################################### # Set up the API and execute the program. ############################################################### qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) # First version: not mapped result = qp.execute(["rippleadd"], backend=backend, coupling_map=None, shots=1024) print(result) print(result.get_counts("rippleadd")) # Second version: mapped to 2x8 array coupling graph obj = qp.compile(["rippleadd"], backend=backend, coupling_map=coupling_map, shots=1024) result = qp.run(obj) print(result) print(result.get_ran_qasm("rippleadd")) print(result.get_counts("rippleadd")) # Both versions should give the same distribution
def shorTest(): # N=15 and a=7 # Let's find period of f(x) = a^x mod N Circuit = 'shorTest' # Create the quantum program qp = QuantumProgram() # Creating registers n_qubits = 8 qr = qp.create_quantum_register("qr", n_qubits) cr = qp.create_classical_register("cr", n_qubits) # We are going to find Q=2^q, where N^2 <= Q < 2*N^2 # So the max Q is 450, needing 9 bits? # Shor algorithm with 4 qbits, where: # qr[0-3] are the bits for Q # qr[4-7] are the bits for U-gates obc = qp.create_circuit(Circuit, [qr], [cr]) # Prepare bits obc.h(qr[0]) obc.h(qr[1]) obc.h(qr[2]) obc.h(qr[3]) # U0 # U-a^2^0: multi 7*1 # Refer to https://github.com/QISKit/ibmqx-user-guides/blob/master/rst/full-user-guide/004-Quantum_Algorithms/110-Shor's_algorithm.rst obc.x(qr[4]) shorU(obc, qr, cr, 0) # U1 shorU(obc, qr, cr, 1) shorU(obc, qr, cr, 1) # U2 shorU(obc, qr, cr, 2) shorU(obc, qr, cr, 2) shorU(obc, qr, cr, 2) shorU(obc, qr, cr, 2) # U3 shorU(obc, qr, cr, 3) shorU(obc, qr, cr, 3) shorU(obc, qr, cr, 3) shorU(obc, qr, cr, 3) shorU(obc, qr, cr, 3) shorU(obc, qr, cr, 3) shorU(obc, qr, cr, 3) shorU(obc, qr, cr, 3) # These are here for reference # # U-a^2^1: multi 7*7 # obc.cx(qr[1], qr[5]) # obc.cx(qr[1], qr[6]) # obc.cx(qr[1], qr[7]) # shorU(obc, qr, cr, 1) # # # U-a^2^2: multi 7*4 # obc.cx(qr[2], qr[5]) # shorU(obc, qr, cr, 2) # # # U-a^2^3: multi 7*13 # obc.cx(qr[3], qr[4]) # obc.cx(qr[3], qr[5]) # obc.cx(qr[3], qr[7]) # shorU(obc, qr, cr, 3) # Measure all gates for i in range(0, 8): obc.measure(qr[i], cr[i]) # Get qasm source source = qp.get_qasm(Circuit) print(source) # Compile and run backend = 'local_qasm_simulator' circuits = [Circuit] # Group of circuits to execute qobj = qp.compile(circuits, backend, shots = 32) # Compile your program result = qp.run(qobj, wait=2, timeout=240) print(result) results = result.get_counts(Circuit) print(results) validate(results)
def test_example_multiple_compile(self): """Test a toy example compiling multiple circuits. Pass if the results are correct. """ coupling_map = {0: [1, 2], 1: [2], 2: [], 3: [2, 4], 4: [2]} QPS_SPECS = { "circuits": [{ "name": "ghz", "quantum_registers": [{ "name": "q", "size": 5 }], "classical_registers": [{ "name": "c", "size": 5} ]}, { "name": "bell", "quantum_registers": [{ "name": "q", "size": 5 }], "classical_registers": [{ "name": "c", "size": 5 }]} ] } qp = QuantumProgram(specs=QPS_SPECS) ghz = qp.get_circuit("ghz") bell = qp.get_circuit("bell") q = qp.get_quantum_register("q") c = qp.get_classical_register("c") # Create a GHZ state ghz.h(q[0]) for i in range(4): ghz.cx(q[i], q[i+1]) # Insert a barrier before measurement ghz.barrier() # Measure all of the qubits in the standard basis for i in range(5): ghz.measure(q[i], c[i]) # Create a Bell state bell.h(q[0]) bell.cx(q[0], q[1]) bell.barrier() bell.measure(q[0], c[0]) bell.measure(q[1], c[1]) qp.set_api(API_TOKEN, URL) bellobj = qp.compile(["bell"], backend='local_qasm_simulator', shots=2048, seed=10) ghzobj = qp.compile(["ghz"], backend='local_qasm_simulator', shots=2048, coupling_map=coupling_map, seed=10) bellresult = qp.run(bellobj) ghzresult = qp.run(ghzobj) print(bellresult.get_counts("bell")) print(ghzresult.get_counts("ghz")) self.assertEqual(bellresult.get_counts("bell"), {'00000': 1034, '00011': 1014}) self.assertEqual(ghzresult.get_counts("ghz"), {'00000': 1047, '11111': 1001})
def evaluate(compiler_function=None, test_circuits=None, verbose=False, backend='local_qiskit_simulator', seed=19): """ Evaluates the given complier_function with the circuits in test_circuits and compares the output circuit and quantum state with the original and a reference obtained with the qiskit compiler. Args: compiler_function (function): reference to user compiler function test_circuits (dict): named dict of circuits for which the compiler performance is evaluated test_circuits: { "name": { "qasm": 'qasm_str', "coupling_map": 'target_coupling_map } } verbose (bool): specifies if performance of basic QISKit unroler and mapper circuit is shown for each circuit backend (string): backend to use. For Windows Systems you should specify 'local_qasm_simulator' until 'local_qiskit_simulator' is available. Returns: dict { "name": circuit name { "optimizer_time": time taken by user compiler, "reference_time": reference time taken by qiskit circuit mapper/unroler (if verbose), "cost_original": original circuit cost function value (if verbose), "cost_reference": reference circuit cost function value (if verbose), "cost_optimized": optimized circuit cost function value, "coupling_correct_original": (bool) does original circuit satisfy the coupling map (if verbose), "coupling_correct_reference": (bool) does circuit produced by the qiskit mapper/unroler satisfy the coupling map (if verbose), "coupling_correct_optimized": (bool) does optimized circuit satisfy the coupling map, "state_correct_optimized": (bool) does optimized circuit return correct state } } """ # Initial Setup basis_gates = 'u1,u2,u3,cx,id' # or use "U,CX?" gate_costs = {'id': 0, 'u1': 0, 'measure': 0, 'reset': 0, 'barrier': 0, 'u2': 1, 'u3': 1, 'U': 1, 'cx': 10, 'CX': 10, 'seed': seed} # pass the seed through gate costs # Results data structure results = {} fileJSONExists = False # paler json if os.path.isfile("run_once_results.json"): with open("run_once_results.json", "r") as f: fileJSONExists = True results = json.load(f) print("Paler: Loaded JSON") # end paler json # Load QASM files and extract DAG circuits for name, circuit in test_circuits.items(): print("....name " + name) qp = QuantumProgram() qp.load_qasm_text( circuit["qasm"], name, basis_gates=basis_gates) circuit["dag_original"] = qasm_to_dag_circuit(circuit["qasm"], basis_gates=basis_gates) test_circuits[name] = circuit if not fileJSONExists: results[name] = {} # build empty result dict to be filled later # Only return results if a valid compiler function is provided if compiler_function is not None: # step through all the test circuits using multiprocessing compile_jobs = [[name, circuit, 0, compiler_function, gate_costs] for name, circuit in test_circuits.items()] with Pool(len(compile_jobs)) as job: res_values_opt = job.map(_compile_circuits, compile_jobs) # stash the results in the respective dicts print("..... [compiled optimised]") for job in range(len(compile_jobs)): name = res_values_opt[job].pop("name") test_circuits[name].update( res_values_opt[job].pop("circuit")) # remove the circuit from the results and store it # results[name] = res_values_opt[job] results[name].update(res_values_opt[job]) # do the same for the reference compiler in qiskit if verbose == True # paler json if verbose and (not fileJSONExists): compile_jobs = [[name, circuit, 1, _qiskit_compiler, gate_costs] for name, circuit in test_circuits.items()] with Pool(len(compile_jobs)) as job: res_values = job.map(_compile_circuits, compile_jobs) # also stash this but use update so we don't overwrite anything print("..... [compiled reference]") for job in range(len(compile_jobs)): name = res_values[job].pop("name") test_circuits[name].update( res_values[job].pop("circuit")) # remove the circuit from the results and store it results[name].update(res_values[job]) # determine the final permutation of the qubits # this is done by analyzing the measurements on the qubits compile_jobs = [[name, circuit, verbose] for name, circuit in test_circuits.items()] with Pool(len(compile_jobs)) as job: res_values = job.map(_prep_sim, compile_jobs) for job in range(len(compile_jobs)): name = res_values[job].pop("name") test_circuits[name].update( res_values[job].pop("circuit")) # remove the circuit from the results and store it results[name].update(res_values[job]) # Compose qobj for simulation config = { 'data': ['quantum_state'], } # generate qobj for original circuit qobj_original = _compose_qobj("original", test_circuits, backend=backend, config=config, basis_gates=basis_gates, shots=1, seed=None) # Compute original cost and check original coupling map if verbose and (not fileJSONExists): for circuit in qobj_original["circuits"]: name = circuit["name"] coupling_map = test_circuits[name].get("coupling_map", None) coupling_map_passes = True cost = 0 for op in circuit["compiled_circuit"]["operations"]: cost += gate_costs.get(op["name"]) # compute cost if op["name"] in ["cx", "CX"] \ and coupling_map is not None: # check coupling map coupling_map_passes &= ( op["qubits"][0] in coupling_map) if op["qubits"][0] in coupling_map: coupling_map_passes &= ( op["qubits"][1] in coupling_map[op["qubits"][0]] ) results[name]["cost_original"] = cost results[name]["coupling_correct_original"] = coupling_map_passes # Run simulation if not skipVerif: time_start = time.process_time() res_original = qp.run(qobj_original, timeout=GLOBAL_TIMEOUT) print("..... [executed original]") results[name]["sim_time_orig"] = time.process_time() - time_start # Generate qobj for optimized circuit qobj_optimized = _compose_qobj("optimized", test_circuits, backend=backend, config=config, basis_gates=basis_gates, shots=1, seed=None) # Compute compiled circuit cost and check coupling map for circuit in qobj_optimized["circuits"]: name = circuit["name"] coupling_map = test_circuits[name].get("coupling_map", None) coupling_map_passes = True cost = 0 for op in circuit["compiled_circuit"]["operations"]: cost += gate_costs.get(op["name"]) # compute cost if op["name"] in ["cx", "CX"] \ and coupling_map is not None: # check coupling map coupling_map_passes &= ( op["qubits"][0] in coupling_map) if op["qubits"][0] in coupling_map: coupling_map_passes &= ( op["qubits"][1] in coupling_map[op["qubits"][0]] ) results[name]["cost_optimized"] = cost results[name]["coupling_correct_optimized"] = coupling_map_passes # Run simulation if not skipVerif: time_start = time.process_time() res_optimized = qp.run(qobj_optimized, timeout=GLOBAL_TIMEOUT) results[name]["sim_time_opti"] = time.process_time() - time_start print("..... [executed optimised]") # paler json if verbose and (not fileJSONExists): # Generate qobj for reference circuit optimized by qiskit compiler qobj_reference = _compose_qobj("reference", test_circuits, backend=backend, config=config, basis_gates=basis_gates, shots=1, seed=None) # Compute reference cost and check reference coupling map for circuit in qobj_reference["circuits"]: name = circuit["name"] coupling_map = test_circuits[name].get("coupling_map", None) coupling_map_passes = True cost = 0 for op in circuit["compiled_circuit"]["operations"]: cost += gate_costs.get(op["name"]) # compute cost if op["name"] in ["cx", "CX"] \ and coupling_map is not None: # check coupling map coupling_map_passes &= ( op["qubits"][0] in coupling_map) if op["qubits"][0] in coupling_map: coupling_map_passes &= ( op["qubits"][1] in coupling_map[op["qubits"][0]] ) results[name]["cost_reference"] = cost results[name]["coupling_correct_reference"] = coupling_map_passes # Skip simulation of reference State to speed things up! # time_start = time.process_time() # res_reference = qp.run(qobj_reference, timeout=GLOBAL_TIMEOUT) # results[name]["sim_time_ref"] = time.process_time() - time_start # Check output quantum state of optimized circuit is correct in comparison to original for name in results.keys(): # handle errors here if skipVerif: results[name]["state_correct_optimized"] = True continue data_original = res_original.get_data(name) if test_circuits[name]["dag_optimized"] is not None: data_optimized = res_optimized.get_data(name) correct = _compare_outputs(data_original, data_optimized, test_circuits[name]["perm_optimized"]) # paler transform np.bool_ to bool results[name]["state_correct_optimized"] = bool(correct) print(name, bool(correct)) # skip verification # results[name]["state_correct_optimized"] = True else: results[name]["state_correct_optimized"] = False # Skip verification of the reference State to speed things up! # if verbose: # if test_circuits[name]["dag_reference"] is not None: # data_reference = res_reference.get_data(name) # correct = _compare_outputs(data_original, data_reference, test_circuits[name]["perm_reference"]) # results[name]["state_correct_reference"] = correct # else: # results[name]["state_correct_reference"] = False # paler json with open("run_once_results.json", "w") as f: json.dump(results, f) print("Paler: Wrote JSON") # end paler json return results
def run(self, **kwargs): if self._qobj is None: self.compile() self._qresult = QuantumProgram.run(self, self._qobj, **kwargs) print(self._qresult) return self._qresult
if sys.argv[1] == "run": backend = "ibmqx5" tomo_circuits = tomo.create_tomography_circuits(qp, 'tomo', qr, cr, tomo_set) qobj = qp.compile(tomo_circuits, backend=backend, shots=1024) qasms = split_qobj(qobj, M=1) run_splitted_qasms(qasms, qobj, backend) sys.exit(0) elif sys.argv[1] == "simulate": tomo_circuits = tomo.create_tomography_circuits(qp, 'tomo', qr, cr, tomo_set) qobj = qp.compile(tomo_circuits, backend="local_qiskit_simulator", shots=1024) res = qp.run(qobj) else: res = recover(sys.argv[1]) # pprint(res1._result) # pprint(res._result) # print(res.get_counts("tomo_meas_X(0)X(1)X(2)X(3)")) tomo_data = tomo.tomography_data(res, "tomo", tomo_set) rho_fit = tomo.fit_tomography_data(tomo_data) np.save("state_tomography/rho.npy", rho_fit) ev = eigvals(rho_fit) plt.bar(range(len(ev)), ev.real) plt.show()
qCircuit.z(qRegister[0]) qCircuit.cz(qRegister[1], qRegister[2]) # Now, we apply the H-gate to all the qubits again. for i in range(n): qCircuit.h(qRegister[i]) # That's it for this algorithm! Measure the qubits into the classical registers. # For a constant function, we expect a 100% chance of observing all 0s. (if simulated) # For a balanced function, we expect anything else. # This means that when we examine the probability of measuring all 0s, we get 1 for a constant # function (due to constructive interference) and 0 for a balanced function (destructed interference). # This is a deterministic algorithm. # The math behind this algorithm is on IBM's QX Full user guide: # https://quantumexperience.ng.bluemix.net/qx/tutorial?sectionId=8443c4f713521c10b1a56a533958286b&pageIndex=3 # The biggest resource that helped my understand constructive/destructive interference in the algorithm was this video: # https://www.youtube.com/watch?v=mGqyzZ-fnnY # This algorithm can evaluate the function in one call, which is exponentially faster than # a classical computer's 2^(n-1) + 1. qCircuit.measure(qRegister[0], cRegister[0]) qCircuit.measure(qRegister[1], cRegister[1]) qCircuit.measure(qRegister[2], cRegister[2]) device = 'ibmqx_qasm_simulator' # Backend to execute your program, in this case it is the online simulator circuits = ["qCircuit"] # Group of circuits to execute qProgram.compile(circuits, "local_qasm_simulator") # Compile your program # Run your program in the device and check the execution result every 2 seconds result = qProgram.run(wait=2, timeout=240) print(qProgram.get_counts("qCircuit"))
qc.h(qr[0]) qc.cx(qr[0], qr[1]) qc.measure(qr[0], cr[0]) qc.measure(qr[1], cr[1]) source = qp.get_qasm('Bell') print(source) #result = qp.execute('Bell') circuits = ['Bell'] qobj = qp.compile(circuits, backend) result = qp.run(qobj, wait=2, timeout=240) #print(result.get_counts('Bell')) pprint(qp.available_backends()) #pprint(qp.get_backend_status('ibmqx2')) pprint(qp.get_backend_configuration('ibmqx5')) # quantum register for the first circuit
for j in range(n): qc.measure(b[j], ans[j]) qc.measure(cout[0], ans[n]) ############################################################### # Set up the API and execute the program. ############################################################### result = qp.set_api(Qconfig.APItoken, Qconfig.config["url"]) if not result: print("Error setting API") sys.exit(1) # First version: not compiled result = qp.execute(["rippleadd"], device=device, coupling_map=None, shots=1024) print(result) print(qp.get_counts("rippleadd")) # Second version: compiled to 2x8 array coupling graph qp.compile(["rippleadd"], device=device, coupling_map=coupling_map, shots=1024) # qp.print_execution_list(verbose=True) result = qp.run() print(result) print(qp.get_compiled_qasm("rippleadd")) print(qp.get_counts("rippleadd")) # Both versions should give the same distribution
class QC(): ''' class QC ''' # pylint: disable=too-many-instance-attributes def __init__(self, backend='local_qasm_simulator', remote=False, qubits=3): # private member # __qp self.__qp = None # calc phase self.phase = [ ['0', 'initialized.'] ] # config self.backend = backend self.remote = remote self.qubits = qubits # circuits variable self.shots = 2 # async self.wait = False self.last = ['init', 'None'] self.load() def load(self, api_info=True): ''' load ''' self.__qp = QuantumProgram() if self.remote: try: import Qconfig self.__qp.set_api(Qconfig.APItoken, Qconfig.config["url"], hub=Qconfig.config["hub"], group=Qconfig.config["group"], project=Qconfig.config["project"]) except ImportError as ex: msg = 'Error in loading Qconfig.py!. Error = {}\n'.format(ex) sys.stdout.write(msg) sys.stdout.flush() return False if api_info is True: api = self.__qp.get_api() sys.stdout.write('<IBM Quantum Experience API information>\n') sys.stdout.flush() sys.stdout.write('Version: {0}\n'.format(api.api_version())) sys.stdout.write('User jobs (last 5):\n') jobs = api.get_jobs(limit=500) def format_date(job_item): ''' format ''' return datetime.strptime(job_item['creationDate'], '%Y-%m-%dT%H:%M:%S.%fZ') sortedjobs = sorted(jobs, key=format_date) sys.stdout.write(' {0:<32} {1:<24} {2:<9} {3}\n' .format('id', 'creationDate', 'status', 'backend')) sys.stdout.write('{:-^94}\n'.format("")) for job in sortedjobs[-5:]: sys.stdout.write(' {0:<32} {1:<24} {2:<9} {3}\n' .format(job['id'], job['creationDate'], job['status'], job['backend']['name'])) sys.stdout.write('There are {0} jobs on the server\n' .format(len(jobs))) sys.stdout.write('Credits: {0}\n' .format(api.get_my_credits())) sys.stdout.flush() self.backends = self.__qp.available_backends() status = self.__qp.get_backend_status(self.backend) if 'available' in status: if status['available'] is False: return False return True def set_config(self, config=None): ''' set config ''' if config is None: config = {} if 'backend' in config: self.backend = str(config['backend']) if 'local_' in self.backend: self.remote = False else: self.remote = True if 'remote' in config: self.remote = config['remote'] if 'qubits' in config: self.qubits = int(config['qubits']) return True def _progress(self, phasename, text): self.phase.append([str(phasename), str(text)]) text = "Phase {0}: {1}".format(phasename, text) sys.stdout.write("{}\n".format(text)) sys.stdout.flush() def _init_circuit(self): self._progress('1', 'Initialize quantum registers and circuit') qubits = self.qubits quantum_registers = [ {"name": "cin", "size": 1}, {"name": "qa", "size": qubits}, {"name": "qb", "size": qubits}, {"name": "cout", "size": 1} ] classical_registers = [ {"name": "ans", "size": qubits + 1} ] if 'cin' in self.__qp.get_quantum_register_names(): self.__qp.destroy_quantum_registers(quantum_registers) self.__qp.destroy_classical_registers(classical_registers) q_r = self.__qp.create_quantum_registers(quantum_registers) c_r = self.__qp.create_classical_registers(classical_registers) self.__qp.create_circuit("qcirc", q_r, c_r) def _create_circuit_qadd(self): # quantum ripple-carry adder from Cuccaro et al, quant-ph/0410184 def majority(circuit, q_a, q_b, q_c): ''' majority ''' circuit.cx(q_c, q_b) circuit.cx(q_c, q_a) circuit.ccx(q_a, q_b, q_c) def unmaj(circuit, q_a, q_b, q_c): ''' unmajority ''' circuit.ccx(q_a, q_b, q_c) circuit.cx(q_c, q_a) circuit.cx(q_a, q_b) def adder(circuit, c_in, q_a, q_b, c_out, qubits): ''' adder ''' # pylint: disable=too-many-arguments majority(circuit, c_in[0], q_b[0], q_a[0]) for i in range(qubits - 1): majority(circuit, q_a[i], q_b[i + 1], q_a[i + 1]) circuit.cx(q_a[qubits - 1], c_out[0]) for i in range(qubits - 1)[::-1]: unmaj(circuit, q_a[i], q_b[i + 1], q_a[i + 1]) unmaj(circuit, c_in[0], q_b[0], q_a[0]) if 'add' not in self.__qp.get_circuit_names(): [c_in, q_a, q_b, c_out] = map(self.__qp.get_quantum_register, ["cin", "qa", "qb", "cout"]) ans = self.__qp.get_classical_register('ans') qadder = self.__qp.create_circuit("qadd", [c_in, q_a, q_b, c_out], [ans]) adder(qadder, c_in, q_a, q_b, c_out, self.qubits) return 'add' in self.__qp.get_circuit_names() def _create_circuit_qsub(self): circuit_names = self.__qp.get_circuit_names() if 'qsub' not in circuit_names: if 'qadd' not in circuit_names: self._create_circuit_qadd() # subtractor circuit self.__qp.add_circuit('qsub', self.__qp.get_circuit('qadd')) qsubtractor = self.__qp.get_circuit('qsub') qsubtractor.reverse() return 'qsub' in self.__qp.get_circuit_names() def _qadd(self, input_a, input_b=None, subtract=False, observe=False): # pylint: disable=too-many-locals def measure(circuit, q_b, c_out, ans): ''' measure ''' circuit.barrier() for i in range(self.qubits): circuit.measure(q_b[i], ans[i]) circuit.measure(c_out[0], ans[self.qubits]) def char2q(circuit, cbit, qbit): ''' char2q ''' if cbit == '1': circuit.x(qbit) elif cbit == 'H': circuit.h(qbit) self.shots = 5 * (2**self.qubits) def input_state(circuit, input_a, input_b=None): ''' input state ''' input_a = input_a[::-1] for i in range(self.qubits): char2q(circuit, input_a[i], q_a[i]) if input_b is not None: input_b = input_b[::-1] for i in range(self.qubits): char2q(circuit, input_b[i], q_b[i]) def reset_input(circuit, c_in, q_a, c_out): ''' reset input ''' circuit.reset(c_in) circuit.reset(c_out) for i in range(self.qubits): circuit.reset(q_a[i]) # get registers [c_in, q_a, q_b, c_out] = map(self.__qp.get_quantum_register, ["cin", "qa", "qb", "cout"]) ans = self.__qp.get_classical_register('ans') qcirc = self.__qp.get_circuit('qcirc') self._progress('2', 'Define input state ({})' .format('QADD' if subtract is False else 'QSUB')) if input_b is not None: if subtract is True: # subtract input_state(qcirc, input_b, input_a) else: # add input_state(qcirc, input_a, input_b) else: reset_input(qcirc, c_in, q_a, c_out) input_state(qcirc, input_a) self._progress('3', 'Define quantum circuit ({})' .format('QADD' if subtract is False else 'QSUB')) if subtract is True: self._create_circuit_qsub() qcirc.extend(self.__qp.get_circuit('qsub')) else: self._create_circuit_qadd() qcirc.extend(self.__qp.get_circuit('qadd')) if observe is True: measure(qcirc, q_b, c_out, ans) def _qsub(self, input_a, input_b=None, observe=False): self._qadd(input_a, input_b, subtract=True, observe=observe) def _qope(self, input_a, operator, input_b=None, observe=False): if operator == '+': return self._qadd(input_a, input_b, observe=observe) elif operator == '-': return self._qsub(input_a, input_b, observe=observe) return None def _compile(self, name, cross_backend=None, print_qasm=False): self._progress('4', 'Compile quantum circuit') coupling_map = None if cross_backend is not None: backend_conf = self.__qp.get_backend_configuration(cross_backend) coupling_map = backend_conf.get('coupling_map', None) if coupling_map is None: sys.stdout.write('backend: {} coupling_map not found' .format(cross_backend)) qobj = self.__qp.compile([name], backend=self.backend, shots=self.shots, seed=1, coupling_map=coupling_map) if print_qasm is True: sys.stdout.write(self.__qp.get_compiled_qasm(qobj, 'qcirc')) sys.stdout.flush() return qobj def _run(self, qobj): self._progress('5', 'Run quantum circuit (wait for answer)') result = self.__qp.run(qobj, wait=5, timeout=100000) return result def _run_async(self, qobj): ''' _run_async ''' self._progress('5', 'Run quantum circuit') self.wait = True def async_result(result): ''' async call back ''' self.wait = False self.last = self.result_parse(result) self.__qp.run_async(qobj, wait=5, timeout=100000, callback=async_result) def _is_regular_number(self, numstring, base): ''' returns input binary format string or None. ''' if base == 'bin': binstring = numstring elif base == 'dec': if numstring == 'H': binstring = 'H'*self.qubits else: binstring = format(int(numstring), "0{}b".format(self.qubits)) if len(binstring) != self.qubits: return None return binstring def get_seq(self, text, base='dec'): ''' convert seq and check it if text is invalid, return the list of length 0. ''' operators = u'(\\+|\\-)' seq = re.split(operators, text) # length check if len(seq) % 2 == 0 or len(seq) == 1: return [] # regex if base == 'bin': regex = re.compile(r'[01H]+') else: regex = re.compile(r'(^(?!.H)[0-9]+|H)') for i in range(0, len(seq), 2): match = regex.match(seq[i]) if match is None: return [] num = match.group(0) seq[i] = self._is_regular_number(num, base) if seq[i] is None: return [] return seq def result_parse(self, result): ''' result_parse ''' data = result.get_data("qcirc") sys.stdout.write("job id: {0}\n".format(result.get_job_id())) sys.stdout.write("raw result: {0}\n".format(data)) sys.stdout.write("{:=^40}\n".format("answer")) counts = data['counts'] sortedcounts = sorted(counts.items(), key=lambda x: -x[1]) sortedans = [] for count in sortedcounts: if count[0][0] == '1': ans = 'OR' else: ans = str(int(count[0][-self.qubits:], 2)) sortedans.append(ans) sys.stdout.write('Dec: {0:>2} Bin: {1} Count: {2} \n' .format(ans, str(count[0]), str(count[1]))) sys.stdout.write('{0:d} answer{1}\n' .format(len(sortedans), '' if len(sortedans) == 1 else 's')) sys.stdout.write("{:=^40}\n".format("")) if 'time' in data: sys.stdout.write("time: {0:<3} sec\n".format(data['time'])) sys.stdout.write("All process done.\n") sys.stdout.flush() uniqanswer = sorted(set(sortedans), key=sortedans.index) ans = ",".join(uniqanswer) return [str(result), ans] def exec_calc(self, text, base='dec', wait_result=False): ''' exec_calc ''' seq = self.get_seq(text, base) print('QC seq:', seq) if seq == []: return ["Syntax error", None] # fail message fail_msg = None try: self._init_circuit() numbers = seq[0::2] # slice even index i = 1 observe = False for oper in seq[1::2]: # slice odd index if i == len(numbers) - 1: observe = True if i == 1: self._qope(numbers[0], oper, numbers[1], observe=observe) else: self._qope(numbers[i], oper, observe=observe) i = i + 1 qobj = self._compile('qcirc') if wait_result is True: [status, ans] = self.result_parse(self._run(qobj)) else: self._run_async(qobj) [status, ans] = [ 'Wait. Calculating on {0}'.format(self.backend), '...' ] except QISKitError as ex: fail_msg = ('There was an error in the circuit!. Error = {}\n' .format(ex)) except RegisterSizeError as ex: fail_msg = ('Error in the number of registers!. Error = {}\n' .format(ex)) if fail_msg is not None: sys.stdout.write(fail_msg) sys.stdout.flush() return ["FAIL", None] return [status, ans]
from qiskit import QuantumProgram #why? if __name__ == '__main__': qp = QuantumProgram() qr = qp.create_quantum_register('qr', 1) cr = qp.create_classical_register('cr', 1) qc = qp.create_circuit('cir1', [qr], [cr]) qc.x(qr[0]) qc.measure(qr[0], cr[0]) # print result count qobj = qp.compile(['cir1'], 'local_qasm_simulator') result = qp.run(qobj, wait=5, timeout=2400) print(result.get_counts('cir1'))