def test_get_backend_configuration(self): """Test get_backend_configuration. If all correct should return configuration for the local_qasm_simulator. """ qp = QuantumProgram(specs=QPS_SPECS) test = len(qp.get_backend_configuration("local_qasm_simulator")) self.assertEqual(test, 6)
def get_available_qubit_number(self): if self._backend is None: raise RuntimeError( "You should select a backend before asking for its qubit number." ) if "local" in self._backend: return 16 return QuantumProgram.get_backend_configuration( self, self._backend)['n_qubits']
def vqe(molecule='H2', depth=6, max_trials=200, shots=1): if molecule == 'H2': n_qubits = 2 Z1 = 1 Z2 = 1 min_distance = 0.2 max_distance = 4 elif molecule == 'LiH': n_qubits = 4 Z1 = 1 Z2 = 3 min_distance = 0.5 max_distance = 5 else: raise QISKitError("Unknown molecule for VQE.") # Read Hamiltonian ham_name = os.path.join(os.path.dirname(__file__), molecule + '/' + molecule + 'Equilibrium.txt') pauli_list = Hamiltonian_from_file(ham_name) H = make_Hamiltonian(pauli_list) # Exact Energy exact = np.amin(la.eig(H)[0]).real print('The exact ground state energy is: {}'.format(exact)) # Optimization device = 'local_qasm_simulator' qp = QuantumProgram() if shots != 1: H = group_paulis(pauli_list) entangler_map = qp.get_backend_configuration(device)['coupling_map'] if entangler_map == 'all-to-all': entangler_map = {i: [j for j in range(n_qubits) if j != i] for i in range(n_qubits)} else: entangler_map = mapper.coupling_list2dict(entangler_map) initial_theta = np.random.randn(2 * n_qubits * depth) # initial angles initial_c = 0.01 # first theta perturbations target_update = 2 * np.pi * 0.1 # aimed update on first trial save_step = 20 # print optimization trajectory cost = partial(cost_function, qp, H, n_qubits, depth, entangler_map, shots, device) SPSA_params = SPSA_calibration(cost, initial_theta, initial_c, target_update, stat=25) output = SPSA_optimization(cost, initial_theta, SPSA_params, max_trials, save_step, last_avg=1) return qp
def vqe(molecule='H2', depth=6, max_trials=200, shots=1): if molecule == 'H2': n_qubits = 2 Z1 = 1 Z2 = 1 min_distance = 0.2 max_distance = 4 elif molecule == 'LiH': n_qubits = 4 Z1 = 1 Z2 = 3 min_distance = 0.5 max_distance = 5 else: raise QISKitError("Unknown molecule for VQE.") # Read Hamiltonian ham_name = os.path.join(os.path.dirname(__file__), molecule + '/' + molecule + 'Equilibrium.txt') pauli_list = Hamiltonian_from_file(ham_name) H = make_Hamiltonian(pauli_list) # Exact Energy exact = np.amin(la.eig(H)[0]).real print('The exact ground state energy is: {}'.format(exact)) # Optimization device = 'local_qasm_simulator' qp = QuantumProgram() if shots != 1: H = group_paulis(pauli_list) entangler_map = qp.get_backend_configuration(device)['coupling_map'] if entangler_map == 'all-to-all': entangler_map = { i: [j for j in range(n_qubits) if j != i] for i in range(n_qubits) } else: entangler_map = mapper.coupling_list2dict(entangler_map) initial_theta = np.random.randn(2 * n_qubits * depth) # initial angles initial_c = 0.01 # first theta perturbations target_update = 2 * np.pi * 0.1 # aimed update on first trial save_step = 20 # print optimization trajectory cost = partial(cost_function, qp, H, n_qubits, depth, entangler_map, shots, device) SPSA_params = SPSA_calibration(cost, initial_theta, initial_c, target_update, stat=25) output = SPSA_optimization(cost, initial_theta, SPSA_params, max_trials, save_step, last_avg=1) return qp
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]
def msquare(): ans = [] Q_program = QuantumProgram() Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url N = 4 # Creating registers qr = Q_program.create_quantum_register("qr", N) # for recording the measurement on qr cr = Q_program.create_classical_register("cr", N) circuitName = "sharedEntangled" sharedEntangled = Q_program.create_circuit(circuitName, [qr], [cr]) #Create uniform superposition of all strings of length 2 for i in range(2): sharedEntangled.h(qr[i]) #The amplitude is minus if there are odd number of 1s for i in range(2): sharedEntangled.z(qr[i]) #Copy the content of the fist two qubits to the last two qubits for i in range(2): sharedEntangled.cx(qr[i], qr[i + 2]) #Flip the last two qubits for i in range(2, 4): sharedEntangled.x(qr[i]) #we first define controlled-u gates required to assign phases from math import pi def ch(qProg, a, b): """ Controlled-Hadamard gate """ qProg.h(b) qProg.sdg(b) qProg.cx(a, b) qProg.h(b) qProg.t(b) qProg.cx(a, b) qProg.t(b) qProg.h(b) qProg.s(b) qProg.x(b) qProg.s(a) return qProg def cu1pi2(qProg, c, t): """ Controlled-u1(phi/2) gate """ qProg.u1(pi / 4.0, c) qProg.cx(c, t) qProg.u1(-pi / 4.0, t) qProg.cx(c, t) qProg.u1(pi / 4.0, t) return qProg def cu3pi2(qProg, c, t): """ Controlled-u3(pi/2, -pi/2, pi/2) gate """ qProg.u1(pi / 2.0, t) qProg.cx(c, t) qProg.u3(-pi / 4.0, 0, 0, t) qProg.cx(c, t) qProg.u3(pi / 4.0, -pi / 2.0, 0, t) return qProg # dictionary for Alice's operations/circuits aliceCircuits = {} # Quantum circuits for Alice when receiving idx in 1, 2, 3 for idx in range(1, 4): circuitName = "Alice" + str(idx) aliceCircuits[circuitName] = Q_program.create_circuit( circuitName, [qr], [cr]) theCircuit = aliceCircuits[circuitName] if idx == 1: #the circuit of A_1 theCircuit.x(qr[1]) theCircuit.cx(qr[1], qr[0]) theCircuit = cu1pi2(theCircuit, qr[1], qr[0]) theCircuit.x(qr[0]) theCircuit.x(qr[1]) theCircuit = cu1pi2(theCircuit, qr[0], qr[1]) theCircuit.x(qr[0]) theCircuit = cu1pi2(theCircuit, qr[0], qr[1]) theCircuit = cu3pi2(theCircuit, qr[0], qr[1]) theCircuit.x(qr[0]) theCircuit = ch(theCircuit, qr[0], qr[1]) theCircuit.x(qr[0]) theCircuit.x(qr[1]) theCircuit.cx(qr[1], qr[0]) theCircuit.x(qr[1]) elif idx == 2: theCircuit.x(qr[0]) theCircuit.x(qr[1]) theCircuit = cu1pi2(theCircuit, qr[0], qr[1]) theCircuit.x(qr[0]) theCircuit.x(qr[1]) theCircuit = cu1pi2(theCircuit, qr[0], qr[1]) theCircuit.x(qr[0]) theCircuit.h(qr[0]) theCircuit.h(qr[1]) elif idx == 3: theCircuit.cz(qr[0], qr[1]) theCircuit.swap(qr[0], qr[1]) theCircuit.h(qr[0]) theCircuit.h(qr[1]) theCircuit.x(qr[0]) theCircuit.x(qr[1]) theCircuit.cz(qr[0], qr[1]) theCircuit.x(qr[0]) theCircuit.x(qr[1]) #measure the first two qubits in the computational basis theCircuit.measure(qr[0], cr[0]) theCircuit.measure(qr[1], cr[1]) # dictionary for Bob's operations/circuits bobCircuits = {} # Quantum circuits for Bob when receiving idx in 1, 2, 3 for idx in range(1, 4): circuitName = "Bob" + str(idx) bobCircuits[circuitName] = Q_program.create_circuit( circuitName, [qr], [cr]) theCircuit = bobCircuits[circuitName] if idx == 1: theCircuit.x(qr[2]) theCircuit.x(qr[3]) theCircuit.cz(qr[2], qr[3]) theCircuit.x(qr[3]) theCircuit.u1(pi / 2.0, qr[2]) theCircuit.x(qr[2]) theCircuit.z(qr[2]) theCircuit.cx(qr[2], qr[3]) theCircuit.cx(qr[3], qr[2]) theCircuit.h(qr[2]) theCircuit.h(qr[3]) theCircuit.x(qr[3]) theCircuit = cu1pi2(theCircuit, qr[2], qr[3]) theCircuit.x(qr[2]) theCircuit.cz(qr[2], qr[3]) theCircuit.x(qr[2]) theCircuit.x(qr[3]) elif idx == 2: theCircuit.x(qr[2]) theCircuit.x(qr[3]) theCircuit.cz(qr[2], qr[3]) theCircuit.x(qr[3]) theCircuit.u1(pi / 2.0, qr[3]) theCircuit.cx(qr[2], qr[3]) theCircuit.h(qr[2]) theCircuit.h(qr[3]) elif idx == 3: theCircuit.cx(qr[3], qr[2]) theCircuit.x(qr[3]) theCircuit.h(qr[3]) #measure the third and fourth qubits in the computational basis theCircuit.measure(qr[2], cr[2]) theCircuit.measure(qr[3], cr[3]) a, b = random.randint(1, 3), random.randint(1, 3) #generate random integers for i in range(3): for j in range(3): a = i + 1 b = j + 1 # print("The values of a and b are, resp.,", a,b) aliceCircuit = aliceCircuits["Alice" + str(a)] bobCircuit = bobCircuits["Bob" + str(b)] circuitName = "Alice" + str(a) + "Bob" + str(b) Q_program.add_circuit(circuitName, sharedEntangled + aliceCircuit + bobCircuit) backend = "local_qasm_simulator" ##backend = "ibmqx2" shots = 1 # We perform a one-shot experiment results = Q_program.execute([circuitName], backend=backend, shots=shots) answer = results.get_counts(circuitName) # print(answer) for key in answer.keys(): aliceAnswer = [int(key[-1]), int(key[-2])] bobAnswer = [int(key[-3]), int(key[-4])] if sum(aliceAnswer ) % 2 == 0: #the sume of Alice answer must be even aliceAnswer.append(0) else: aliceAnswer.append(1) if sum(bobAnswer) % 2 == 1: #the sum of Bob answer must be odd bobAnswer.append(0) else: bobAnswer.append(1) break # print("Alice answer for a = ", a, "is", aliceAnswer) # print("Bob answer for b = ", b, "is", bobAnswer) print(a, b) ans.append(aliceAnswer) ans.append(bobAnswer) # if(aliceAnswer[b-1] != bobAnswer[a-1]): #check if the intersection of their answers is the same # print("Alice and Bob lost") # else: # print("Alice and Bob won") backend = "local_qasm_simulator" #backend = "ibmqx2" shots = 10 # We perform 10 shots of experiments for each round nWins = 0 nLost = 0 for a in range(1, 4): for b in range(1, 4): # print("Asking Alice and Bob with a and b are, resp.,", a,b) rWins = 0 rLost = 0 aliceCircuit = aliceCircuits["Alice" + str(a)] bobCircuit = bobCircuits["Bob" + str(b)] circuitName = "Alice" + str(a) + "Bob" + str(b) Q_program.add_circuit( circuitName, sharedEntangled + aliceCircuit + bobCircuit) if backend == "ibmqx2": ibmqx2_backend = Q_program.get_backend_configuration( 'ibmqx2') ibmqx2_coupling = ibmqx2_backend['coupling_map'] results = Q_program.execute( [circuitName], backend=backend, shots=shots, coupling_map=ibmqx2_coupling, max_credits=3, wait=10, timeout=240) else: results = Q_program.execute([circuitName], backend=backend, shots=shots) answer = results.get_counts(circuitName) for key in answer.keys(): kfreq = answer[ key] #frequencies of keys obtained from measurements aliceAnswer = [int(key[-1]), int(key[-2])] bobAnswer = [int(key[-3]), int(key[-4])] if sum(aliceAnswer) % 2 == 0: aliceAnswer.append(0) else: aliceAnswer.append(1) if sum(bobAnswer) % 2 == 1: bobAnswer.append(0) else: bobAnswer.append(1) #print("Alice answer for a = ", a, "is", aliceAnswer) #print("Bob answer for b = ", b, "is", bobAnswer) if (aliceAnswer[b - 1] != bobAnswer[a - 1]): #print(a, b, "Alice and Bob lost") nLost += kfreq rLost += kfreq else: #print(a, b, "Alice and Bob won") nWins += kfreq rWins += kfreq # print("\t#wins = ", rWins, "out of ", shots, "shots") # # print("Number of Games = ", nWins+nLost) # print("Number of Wins = ", nWins) # print("Winning probabilities = ", (nWins*100.0)/(nWins+nLost)) return ans
nWins = 0 nLost = 0 for a in range(1, 4): for b in range(1, 4): print("Asking Alice and Bob with a and b are, resp.,", a, b) rWins = 0 rLost = 0 aliceCircuit = aliceCircuits["Alice" + str(a)] bobCircuit = bobCircuits["Bob" + str(b)] circuitName = "Alice" + str(a) + "Bob" + str(b) Q_program.add_circuit(circuitName, sharedEntangled + aliceCircuit + bobCircuit) if backend == "ibmqx2": ibmqx2_backend = Q_program.get_backend_configuration('ibmqx2') ibmqx2_coupling = ibmqx2_backend['coupling_map'] results = Q_program.execute([circuitName], backend=backend, shots=shots, coupling_map=ibmqx2_coupling, max_credits=3, wait=10, timeout=240) else: results = Q_program.execute([circuitName], backend=backend, shots=shots) answer = results.get_counts(circuitName) for key in answer.keys():
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 q1 = qp.create_quantum_register('q1', 4) c1 = qp.create_classical_register('c1', 4) # quantum register for the second circuit q2 = qp.create_quantum_register('q2', 2) c2 = qp.create_classical_register('c2', 2) # making the first circuits qc1 = qp.create_circuit('GHZ', [q1], [c1]) qc2 = qp.create_circuit('superpostion', [q2], [c2]) qc1.h(q1[0]) qc1.cx(q1[0], q1[1])
def create_experiment(self, qp: QuantumProgram, input) -> Tuple[str, dict, str]: a, b = input qm = self.qubit_mapping name = self.name algorithm = self.algorithm backend = self.backend # qubit mapping if qm is None: index_a1 = 2 index_a2 = 1 index_b1 = 3 index_b2 = 0 else: index_a1 = qm["a1"] index_a2 = qm["a2"] index_b1 = qm["b1"] index_b2 = qm["b2"] # input build q: QuantumRegister = qp.create_quantum_register("q", 5) ans = qp.create_classical_register("ans", 5) qc: QuantumCircuit = qp.create_circuit(name, [q], [ans]) a1: Tuple[QuantumRegister, int] = q[index_a1] a2: Tuple[QuantumRegister, int] = q[index_a2] b1: Tuple[QuantumRegister, int] = q[index_b1] b2: Tuple[QuantumRegister, int] = q[index_b2] expected = list("00000") expected_result = (int(a, 2) + int(b, 2)) % 4 expected[index_a1] = str(int(expected_result / 2) % 2) expected[index_a2] = str(int(expected_result / 1) % 2) expected[index_b1] = b[2] expected[index_b2] = b[3] expected = "".join(reversed(expected)) # circuit setup if a[2] == "1": qc.x(a1) if a[3] == "1": qc.x(a2) if b[2] == "1": qc.x(b1) if b[3] == "1": qc.x(b2) processor = self.backend conf = qp.get_backend_configuration(processor, list_format=False) coupling_map = conf["coupling_map"] algorithm(qc, a1, a2, b1, b2, coupling_map) qc.measure(q, ans) # compilation qobj = qp.compile(name_of_circuits=[name], backend=backend, config=conf, max_credits=3) qasm = qp.get_compiled_qasm(qobj, name) qasm_lines = self.qasm((a, b), expected) + qasm.split("\n") qasm = "\n".join(filter(lambda x: len(x) > 0, qasm_lines)) return qasm, qobj, expected
def create_experiment(Q_program: QuantumProgram, a: str, b: str, experiment: Experiment, silent=True) -> Tuple[str, dict, str]: qm = experiment.qubit_mapping name = experiment.name algorithm = experiment.algorithm backend = experiment.backend # qubit mapping if qm is None: index_a1 = 2 index_a2 = 1 index_b1 = 3 index_b2 = 0 else: index_a1 = qm["a1"] index_a2 = qm["a2"] index_b1 = qm["b1"] index_b2 = qm["b2"] # input build q: QuantumRegister = Q_program.create_quantum_register("q", 5) ans = Q_program.create_classical_register("ans", 5) qc: QuantumCircuit = Q_program.create_circuit(name, [q], [ans]) a1: Tuple[QuantumRegister, int] = q[index_a1] a2: Tuple[QuantumRegister, int] = q[index_a2] b1: Tuple[QuantumRegister, int] = q[index_b1] b2: Tuple[QuantumRegister, int] = q[index_b2] expected = list("00000") expected_result = (int(a, 2) + int(b, 2)) % 4 expected[index_a1] = str(int(expected_result / 2) % 2) expected[index_a2] = str(int(expected_result / 1) % 2) expected[index_b1] = b[2] expected[index_b2] = b[3] expected = "".join(reversed(expected)) if not silent: print("Job: %s + %s = %s. Expecting answer: %s" % (a, b, bin(expected_result), expected)) # circuit setup if a[2] == "1": if not silent: print("a1 setting to 1") qc.x(a1) if a[3] == "1": if not silent: print("a2 setting to 1") qc.x(a2) if b[2] == "1": if not silent: print("b1 setting to 1") qc.x(b1) if b[3] == "1": if not silent: print("b2 setting to 1") qc.x(b2) processor = "ibmqx4" conf = Q_program.get_backend_configuration(processor, list_format=False) coupling_map = conf["coupling_map"] algorithm(qc, a1, a2, b1, b2, coupling_map) qc.measure(q, ans) # compilation qobj = Q_program.compile(name_of_circuits=[name], backend=backend, config=conf, max_credits=3) qasm = Q_program.get_compiled_qasm(qobj, name) qasm_lines = experiment.qasm((a, b), expected) + qasm.split("\n") qasm = "\n".join(filter(lambda x: len(x) > 0, qasm_lines)) return qasm, qobj, expected
print(ran_qasm) # You can use # `qp.execute(circuits) # to combine the compile and run in a single step. out = qp.execute(circuits, backend, wait=2, timeout=240) print(out) ## Execute on a Real Device qp.set_api(Qconfig.APItoken, Qconfig.config['url']) # set the APIToken and API url real_device_backend = [ backend for backend in qp.online_devices() if qp.get_backend_configuration(backend)['n_qubits'] == 5 and qp.get_backend_status(backend)['available'] == True ] print(qp.online_devices()) for backend in qp.online_devices(): print(qp.get_backend_configuration(backend)) print(qp.get_backend_status(backend)) # find and appropriate real device backend that your APIToken has access to run that has 5 qubits and is available print(real_device_backend) backend = real_device_backend[ 0] # Backend where you execute your programl in this case, on the real Quatum Chip online circuits = ['Circuit'] # Group of circuits to execute shots = 1024 # Number of shots to run the program (experiment); maximum is 8192 shots. max_credits = 3 # Maximu number of credits to spend on executions.
def create_experiment(Q_program: QuantumProgram, inputA: str, inputB: str, name: str, backend: str) -> Tuple[str, str]: # qubit mapping index_a1 = 2 index_a2 = 4 index_b1 = 0 index_b2 = 3 # input build q = Q_program.create_quantum_register("q", 5) ans = Q_program.create_classical_register("ans", 5) qc: QuantumCircuit = Q_program.create_circuit(name, [q], [ans]) a1 = q[index_a1] a2 = q[index_a2] b1 = q[index_b1] b2 = q[index_b2] expected = list("00000") expected_result = (int(a, 2) + int(b, 2)) % 4 expected[index_a1] = str(int(expected_result / 2) % 2) expected[index_a2] = str(int(expected_result / 1) % 2) expected[index_b1] = b[2] expected[index_b2] = b[3] expected = "".join(reversed(expected)) print("Job: %s + %s = %s. Expecting answer: %s" % (a, b, bin(expected_result), expected)) # circuit setup if a[2] == "1": print("a1 setting to 1") qc.x(a1) if a[3] == "1": print("a2 setting to 1") qc.x(a2) if b[2] == "1": print("b1 setting to 1") qc.x(b1) if b[3] == "1": print("b2 setting to 1") qc.x(b2) # circuit algorithm qc.h(a1) qc.crk(2, a1, a2, cnot_back=True) qc.h(a2) qc.crk(1, a2, b2) qc.crk(2, a1, b2) qc.crk(1, a1, b1, cnot_back=True) qc.h(a2) qc.crk(-2, a1, a2, cnot_back=True) qc.h(a1) qc.measure(q, ans) # job parameters processor = "ibmqx4" print("Compile & Run manually for '%s' using backend '%s':" % (processor, backend)) qobj_id = "@%s: %s(%s,%s) -> %s" % ( datetime.now().strftime('%Y-%m-%d %H:%M:%S'), name, a, b, expected) conf = Q_program.get_backend_configuration(processor, list_format=False) qobj = Q_program.compile(name_of_circuits=[name], backend=backend, shots=shots, config=conf, max_credits=3, qobj_id=qobj_id) qasm = Q_program.get_compiled_qasm(qobj, name) measurements = list(filter(lambda r: "measure" in r, qasm.split('\n'))) instructions = list(filter(lambda r: "measure" not in r, qasm.split('\n'))) qasm = "\n".join(["// draper(%s,%s)->%s" % (a, b, expected)] + instructions + measurements) return qasm, expected