def get_ibmq_ints(qslot): qslot.children[1].children[0].options = ['qasm_simulator', 'ANU QRNG'] qslot.children[1].children[0].value = 'qasm_simulator' back = IBMQ.get_backend('ibmq_5_tenerife') q = QuantumRegister(3, name='q') c = ClassicalRegister(3, name='c') qc = QuantumCircuit(q, c) for kk in range(3): qc.h(q[kk]) qc.measure(q, c) job = execute(qc, backend=back, shots=300, memory=True) qslot.children[1].children[2].clear_output() with qslot.children[1].children[2]: job_monitor(job) qslot.children[0]._stored_ints = [ int(kk, 16) for kk in job.result().results[0].data.memory] qslot.children[1].children[0].options = ['qasm_simulator', 'ibmq_5_tenerife', 'ANU QRNG']
#qprovider.backends() # Get the least busy backend #qbackend = least_busy(qprovider.backends(filters=lambda x: x.configuration().n_qubits == 5 and not x.configuration().simulator and x.status().operational==True)) qbackend = local_sim backend_name = qbackend.name() #print("least busy backend: ", qbackend) #qbackend = qprovider.get_backend('ibmq_vigo') #job_manager = IBMQJobManager() # Default for this backend seems to be 1024 ibmqx2 qshots = 1024 print("Submitting to IBM Q...\n") job = execute(simonCircuit, backend=qbackend, shots=qshots) job_monitor(job, interval=2) #job_set_bar = job_manager.run(simonCircuit, backend=qbackend, name='bar', max_experiments_per_job=5) #print(job_set_bar.report()) qresults = job.result() qcounts = qresults.get_counts() #print("Getting Results...\n") #print(qcounts) #print("") print("\nIBM Q Backend %s: Resulting Values and Probabilities" % local_sim) print("===============================================\n") print("Simulated Runs:", qshots, "\n") # period, counts, prob,a0,a1,...,an #
def run_circuits(self): import glob if "True" in self.plot_flag: import matplotlib.pyplot as plt if self.backend in "ibm": import qiskit as qk from qiskit.tools.monitor import job_monitor from qiskit.visualization import plot_histogram, plot_gate_map, plot_circuit_layout from qiskit import Aer, IBMQ, execute from qiskit.providers.aer import noise from qiskit.providers.aer.noise import NoiseModel from qiskit.circuit import quantumcircuit from qiskit.circuit import Instruction q_regs = qk.QuantumRegister(self.num_spins, 'q') c_regs = qk.ClassicalRegister(self.num_spins, 'c') ## Show available backends provider = qk.IBMQ.get_provider(group='open') provider.backends() #choose the device you would like to run on device = provider.get_backend(self.device) #gather fidelity statistics on this device if you want to create a noise model for the simulator if (self.device != "ibmq_qasm_simulator"): properties = device.properties() coupling_map = device.configuration().coupling_map noise_model = NoiseModel.from_backend(device) basis_gates = noise_model.basis_gates #add measurements temp = [] for circ in self.ibm_circuits_list: circ.measure(self.q_regs, self.c_regs) temp.append(circ) self.ibm_circuits_list = temp #compile circuits to run temp = qk.compiler.transpile(self.ibm_circuits_list, backend=device, optimization_level=2) self.ibm_circuits_list = temp #CHOOSE TO RUN ON QUANTUM COMPUTER OR SIMULATOR if self.QCQS in ["QC"]: #quantum computer execution job = qk.execute(self.ibm_circuits_list, backend=device, shots=self.shots) job_monitor(job) elif self.QCQS in ["QS"]: simulator = Aer.get_backend('qasm_simulator') #simulator execution if self.noise_choice in ["True"]: print("Running noisy simulator job...") with open(self.namevar, 'a') as tempfile: tempfile.write("Running noisy simulator job...\n") result_noise = execute(self.ibm_circuits_list, simulator, noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates, shots=self.shots).result() print("Noisy simulator job successful") with open(self.namevar, 'a') as tempfile: tempfile.write("Noisy simulator job successful\n") elif self.noise_choice in ["False"]: print("Running noiseless simulator job...") with open(self.namevar, 'a') as tempfile: tempfile.write("Running noiseless simulator job...\n") result_noise = execute(self.ibm_circuits_list, backend=simulator, shots=self.shots).result() print("Noiseless simulator job successful") with open(self.namevar, 'a') as tempfile: tempfile.write("Noiseless simulator job successful\n") else: print( "Please enter either True or False for the simulator noise query" ) with open(self.namevar, 'a') as tempfile: tempfile.write( "Please enter either y or n for the simulator noise query\n" ) else: print("Please enter either QC or QS") with open(self.namevar, 'a') as tempfile: tempfile.write("Please enter either QC or QS\n") #Post Processing Depending on Choice self.result_out_list = [] if self.QCQS in ["QS"]: #SIMULATOR POST PROCESSING if (self.observable == "local_magnetization"): for j in range(self.num_spins): avg_mag_sim = [] temp = [] i = 1 print("Post-processing qubit {} data".format(j + 1)) with open(self.namevar, 'a') as tempfile: tempfile.write( "Post-processing qubit {} data\n".format(j + 1)) for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) temp.append( local_magnetization(self.num_spins, result_dict, self.shots, j)) if i % (self.steps + 1) == 0: avg_mag_sim.append(temp) temp = [] i += 1 # time_vec=np.linspace(0,total_t,steps) # time_vec=time_vec*JX/H_BAR if "True" in self.plot_flag: fig, ax = plt.subplots() plt.plot(range(self.steps + 1), avg_mag_sim[0]) plt.xlabel("Simulation Timestep", fontsize=14) plt.ylabel("Average Magnetization", fontsize=14) plt.tight_layout() every_nth = 2 for n, label in enumerate( ax.xaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) every_nth = 2 for n, label in enumerate( ax.yaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) # plt.yticks(np.arange(-1, 1, step=0.2)) # Set label locations. plt.savefig( "data/Simulator_result_qubit{}.png".format(j + 1)) plt.close() self.result_out_list.append(avg_mag_sim[0]) existing = glob.glob( "data/Spin {} Average Magnetization Data, Qubits={}, num_*.txt" .format(j + 1, self.num_spins)) np.savetxt( "data/Spin {} Average Magnetization Data, Qubits={}, num_{}.txt" .format(j + 1, self.num_spins, len(existing) + 1), avg_mag_sim[0]) self.result_matrix = np.stack(self.result_out_list) print("Done") with open(self.namevar, 'a') as tempfile: tempfile.write("Done\n") elif (self.observable == "staggered_magnetization"): avg_sm = [] for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) avg_sm.append( staggered_magnetization(result_dict, self.shots)) #plt.plot.range(self.steps+1), avg_zs[0]) #plt.xlabel("Simulation Timestep",fontsize=14) #plt.ylabel("Order Parameter",fontsize=14) #plt.savefig("data/order_param.png") #plt.close() self.result_out_list.append(avg_sm) self.result_matrix = avg_sm elif (self.observable == "system_magnetization"): avg_mag = [] for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) avg_mag.append( system_magnetization(result_dict, self.shots)) #plt.plot.range(self.steps+1), avg_zs[0]) #plt.xlabel("Simulation Timestep",fontsize=14) #plt.ylabel("Order Parameter",fontsize=14) #plt.savefig("data/order_param.png") #plt.close() self.result_out_list.append(avg_mag) self.result_matrix = avg_mag elif (self.observable == "excitation_displacement"): disp = [] for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) disp.append( excitation_displacement(self.num_spins, result_dict, self.shots)) self.result_out_list.append(disp) self.result_matrix = disp elif self.QCQS in ["QC"]: #QUANTUM COMPUTER POST PROCESSING result_noise = job.result() if (self.observable == "local_magnetization"): for j in range(self.num_spins): avg_mag_sim = [] temp = [] i = 1 print("Post-processing qubit {} data".format(j + 1)) with open(self.namevar, 'a') as tempfile: tempfile.write( "Post-processing qubit {} data\n".format(j + 1)) for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) temp.append( local_magnetization(self.num_spins, result_dict, self.shots, j)) if i % (self.steps + 1) == 0: avg_mag_sim.append(temp) temp = [] i += 1 # time_vec=np.linspace(0,total_t,steps) # time_vec=time_vec*JX/H_BAR if "True" in self.plot_flag: fig, ax = plt.subplots() plt.plot(range(self.steps + 1), avg_mag_sim[0]) plt.xlabel("Simulation Timestep", fontsize=14) plt.ylabel("Average Magnetization", fontsize=14) plt.tight_layout() every_nth = 2 for n, label in enumerate( ax.xaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) every_nth = 2 for n, label in enumerate( ax.yaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) # plt.yticks(np.arange(-1, 1, step=0.2)) # Set label locations. plt.savefig( "data/Simulator_result_qubit{}.png".format(j + 1)) plt.close() self.result_out_list.append(avg_mag_sim[0]) existing = glob.glob( "data/Spin {} Average Magnetization Data, Qubits={}, num_*.txt" .format(j + 1, self.num_spins)) np.savetxt( "data/Spin {} Average Magnetization Data, Qubits={}, num_{}.txt" .format(j + 1, self.num_spins, len(existing) + 1), avg_mag_sim[0]) self.result_matrix = np.stack(self.result_out_list) print("Done") with open(self.namevar, 'a') as tempfile: tempfile.write("Done\n") elif (self.observable == "staggered_magnetization"): avg_sm = [] for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) avg_sm.append( staggered_magnetization(result_dict, self.shots)) #plt.plot.range(self.steps+1), avg_zs[0]) #plt.xlabel("Simulation Timestep",fontsize=14) #plt.ylabel("Order Parameter",fontsize=14) #plt.savefig("data/order_param.png") #plt.close() self.result_out_list.append(avg_sm) self.result_matrix = avg_sm elif (self.observable == "system_magnetization"): avg_mag = [] for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) avg_mag.append( system_magnetization(result_dict, self.shots)) #plt.plot.range(self.steps+1), avg_zs[0]) #plt.xlabel("Simulation Timestep",fontsize=14) #plt.ylabel("Order Parameter",fontsize=14) #plt.savefig("data/order_param.png") #plt.close() self.result_out_list.append(avg_mag) self.result_matrix = avg_mag elif (self.observable == "excitation_displacement"): disp = [] for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) disp.append( excitation_displacement(self.num_spins, result_dict, self.shots)) self.result_out_list.append(disp) self.result_matrix = disp elif "rigetti" in self.backend: import pyquil from pyquil.quil import Program from pyquil.gates import H, RX, RZ, CZ, RESET, MEASURE from pyquil.api import get_qc print("Running Pyquil programs...") with open(self.namevar, 'a') as tempfile: tempfile.write("Running Pyquil programs...\n") qc = get_qc(self.device) results_list = [] first_ind = 0 #each circuit represents one timestep for circuit in self.rigetti_circuits_list: temp = qc.run(circuit) results_list.append(temp) #Post Processing Depending on Choice self.result_out_list = [] #SIMULATOR POST PROCESSING if (self.observable == "local_magnetization"): for j in range(self.num_spins): avg_mag_sim = [] temp = [] i = 1 print("Post-processing qubit {} data".format(j + 1)) with open(self.namevar, 'a') as tempfile: tempfile.write( "Post-processing qubit {} data\n".format(j + 1)) for result in results_list: temp.append( local_magnetization_rigetti( self.num_spins, result, self.shots, j)) if i % (self.steps + 1) == 0: avg_mag_sim.append(temp) temp = [] i += 1 # time_vec=np.linspace(0,total_t,steps) # time_vec=time_vec*JX/H_BAR if "True" in self.plot_flag: fig, ax = plt.subplots() plt.plot(range(self.steps + 1), avg_mag_sim[0]) plt.xlabel("Simulation Timestep", fontsize=14) plt.ylabel("Average Magnetization", fontsize=14) plt.tight_layout() every_nth = 2 for n, label in enumerate(ax.xaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) every_nth = 2 for n, label in enumerate(ax.yaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) # plt.yticks(np.arange(-1, 1, step=0.2)) # Set label locations. plt.savefig( "data/Simulator_result_qubit{}.png".format(j + 1)) plt.close() self.result_out_list.append(avg_mag_sim[0]) existing = glob.glob( "data/Spin {} Average Magnetization Data, Qubits={}, num_*.txt" .format(j + 1, self.num_spins)) np.savetxt( "data/Spin {} Average Magnetization Data, Qubits={}, num_{}.txt" .format(j + 1, self.num_spins, len(existing) + 1), avg_mag_sim[0]) self.result_matrix = np.stack(self.result_out_list) print("Done") with open(self.namevar, 'a') as tempfile: tempfile.write("Done\n") elif (self.observable == "staggered_magnetization"): avg_sm = [] for result in results_list: avg_sm.append( staggered_magnetization_rigetti(result, self.shots)) #plt.plot.range(self.steps+1), avg_zs[0]) #plt.xlabel("Simulation Timestep",fontsize=14) #plt.ylabel("Order Parameter",fontsize=14) #plt.savefig("data/order_param.png") #plt.close() self.result_out_list.append(avg_sm) self.result_matrix = avg_sm elif (self.observable == "system_magnetization"): avg_mag = [] for result in results_list: avg_mag.append( system_magnetization_rigetti(result, self.shots)) #plt.plot.range(self.steps+1), avg_zs[0]) #plt.xlabel("Simulation Timestep",fontsize=14) #plt.ylabel("Order Parameter",fontsize=14) #plt.savefig("data/order_param.png") #plt.close() self.result_out_list.append(avg_mag) self.result_matrix = avg_mag elif (self.observable == "excitation_displacement"): disp = [] for result in results_list: disp.append( excitation_displacement_rigetti( self.num_spins, result, self.shots)) self.result_out_list.append(disp) self.result_matrix = disp
def Groverexp(backend,file_address = ''): num = 3 Grover = QuantumCircuit(num,num) Grover.x(0) Grover.h(1) Grover.h(2) Grover.barrier() Grover.h(0) Grover.barrier() Grover.h(0) Grover.cx(1,0) Grover.tdg(0) Grover.cx(2,0) Grover.t(0) Grover.cx(1,0) Grover.tdg(0) Grover.cx(2,0) Grover.barrier() Grover.t(0) Grover.tdg(1) Grover.barrier() Grover.h(0) Grover.cx(2,1) Grover.tdg(1) Grover.cx(2,1) Grover.s(1) Grover.t(2) Grover.barrier() Grover.h(1) Grover.h(2) Grover.barrier() Grover.x(1) Grover.x(2) Grover.barrier() Grover.h(1) Grover.cx(2,1) Grover.h(1) Grover.x(2) Grover.barrier() Grover.x(1) Grover.h(2) Grover.barrier() Grover.h(1) Grover.barrier() Grover.measure([1,2],[1,2]) Grover_trans = transpile(Grover, backend,initial_layout=[0,1,2]) print('Grover circuit depth is ', Grover_trans.depth()) # Run on real device shots = 8192 job_exp = execute(Grover_trans, backend=backend, shots=shots, optimization_level = 0) job_monitor(job_exp) exp_results = job_exp.result() with open(file_address + 'Count_Grover.csv', mode='w', newline='') as sgm: count_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for key, val in exp_results.get_counts().items(): count_writer.writerow([key,val])
def QAOAexp(backend,file_address = ''): pi = np.pi g1 = 0.2*pi g2 = 0.4*pi b1 = 0.15*pi b2 = 0.05*pi num = 5 QAOA = QuantumCircuit(num,num) for i in range(1,5): QAOA.h(i) QAOA.barrier() # k = 1 QAOA.cx(3,2) QAOA.u1(-g1,2) QAOA.cx(3,2) QAOA.barrier() QAOA.cx(4,2) QAOA.u1(-g1,2) QAOA.cx(4,2) QAOA.barrier() QAOA.cx(1,2) QAOA.u1(-g1,2) QAOA.cx(1,2) QAOA.cx(4,3) QAOA.u1(-g1,3) QAOA.cx(4,3) QAOA.barrier() for i in range(1,5): QAOA.u3(2*b1,-pi/2,pi/2,i) QAOA.barrier() # k = 2 QAOA.cx(3,2) QAOA.u1(-g2,2) QAOA.cx(3,2) QAOA.barrier() QAOA.cx(4,2) QAOA.u1(-g2,2) QAOA.cx(4,2) QAOA.barrier() QAOA.cx(1,2) QAOA.u1(-g2,2) QAOA.cx(1,2) QAOA.cx(4,3) QAOA.u1(-g2,3) QAOA.cx(4,3) QAOA.barrier() for i in range(1,5): QAOA.u3(2*b2,-pi/2,pi/2,i) QAOA.barrier() QAOA.barrier() QAOA.measure([1,2,3,4],[1,2,3,4]) QAOA_trans = transpile(QAOA, backend,initial_layout=range(num)) print('QAOA circuit depth is ', QAOA_trans.depth()) # Run on simulator simulator = Aer.get_backend("qasm_simulator") simu_shots = 100000 simulate = execute(QAOA, backend=simulator, shots=simu_shots) QAOA_results = simulate.result() with open(file_address + 'Count_QAOA_Simulator.csv', mode='w', newline='') as sgm: count_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for key, val in QAOA_results.get_counts().items(): count_writer.writerow([key,val]) # Run on real device shots = 8192 job_exp = execute(QAOA_trans, backend=backend, shots=shots, optimization_level = 0) job_monitor(job_exp) exp_results = job_exp.result() with open(file_address + 'Count_QAOA.csv', mode='w', newline='') as sgm: count_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for key, val in exp_results.get_counts().items(): count_writer.writerow([key,val])
def ChooseBackEnd(quantumCircuit, backendType="statevector_simulator", qubitsToBeMeasured=range(4), numberShots=4096, noisePresent=False, RealDeviceName="ibmq_ourense",number=12): if backendType == "statevector_simulator": backend = Aer.get_backend('statevector_simulator') result = execute(quantumCircuit, backend).result() probabilityVectors = np.square(np.absolute(result.get_statevector())) listForMusic = [] for k in range(2**len(qubitsToBeMeasured)): listForMusic.append("%.3f" % (probabilityVectors[k])) elif backendType == "qasm_simulator": if noisePresent == False: # no noise quantumCircuit.measure(qubitsToBeMeasured, qubitsToBeMeasured) print(qubitsToBeMeasured) backend = Aer.get_backend('qasm_simulator') result = execute(quantumCircuit, backend, shots=numberShots).result() counts = result.get_counts() listForMusic = [] for i in range(2**len(qubitsToBeMeasured)): bitstring = str(bin(i)[2:]) bitstring = "0"*(4-len(bitstring))+bitstring if bitstring in counts.keys(): listForMusic.append("%.3f" % (counts[bitstring]/float(numberShots))) else: listForMusic.append("0.000") else: print(qubitsToBeMeasured) quantumCircuit.measure(qubitsToBeMeasured,qubitsToBeMeasured) provider=IBMQ.save_account('XXX-YOUR-TOKEN') # simulate noise of a real device IBMQ.load_account() IBMQ.providers() device = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend(RealDeviceName) properties = device.properties() coupling_map = device.configuration().coupling_map # Generate an Aer noise model for device noise_model = noise.device.basic_device_noise_model(properties) basis_gates = noise_model.basis_gates # Perform noisy simulation backend = Aer.get_backend('qasm_simulator') job_sim = execute(quantumCircuit, backend, coupling_map=coupling_map, noise_model=noise_model, basis_gates=basis_gates) result = job_sim.result() counts = result.get_counts() listForMusic = [] for i in range(2**len(qubitsToBeMeasured)): bitstring = str(bin(i)[2:]) bitstring = "0"*(4-len(bitstring))+bitstring if bitstring in counts.keys(): listForMusic.append("%.3f" % (counts[bitstring]/float(numberShots))) else: listForMusic.append("0.000") elif backendType == "real_device": # real device quantumCircuit.measure(qubitsToBeMeasured,qubitsToBeMeasured) provider=IBMQ.save_account('XXX-YOUR-TOKEN') # simulate noise of a real device IBMQ.load_account() IBMQ.providers() device = IBMQ.get_provider(hub='ibm-q', group='open', project='main').get_backend(RealDeviceName) job_exp = execute(quantumCircuit, backend=device) job_monitor(job_exp) result = job_exp.result() counts = result.get_counts() listForMusic = [] for i in range(2**len(qubitsToBeMeasured)): bitstring = str(bin(i)[2:]) bitstring = "0"*(4-len(bitstring))+bitstring if bitstring in counts.keys(): listForMusic.append(" %.3f" % (counts[bitstring]/float(numberShots))) else: listForMusic.append("0.000") return listForMusic
def rabi_experiment(qubit, backend, num_shots, measurement_schedule, measurement_setting): """Run a Rabi experiment.""" # Get qubit frequency qubit = 0 backend.properties(refresh=True) qubit_frequency_updated = backend.properties().qubit_property( qubit, "frequency")[0] # Drive and measurement channels inst_sched_map = backend_defaults.instruction_schedule_map pi_default = inst_sched_map.get("x", qubits=backend_config.meas_map[qubit]) # The minimum duration of a pulse in the armonk backend is 64*dt num_time_points = 50 # Number of points in the Rabi experiment pulse_amp = 0.4 pulse_times = np.array([ 64 + np.arange( 0, get_closest_multiple_of_16(16 * 2 * num_time_points), get_closest_multiple_of_16(16 * 2), ) ]) rabi_schedules = [] for integer_duration in pulse_times[0]: waveform = np.ones([integer_duration]) * pulse_amp this_schedule = pulse.Schedule( name=f"I pulse: duration = {integer_duration}") this_schedule += pulse.Play(pulse.Waveform(waveform), drive_chan) this_schedule += measurement_schedule << this_schedule.duration rabi_schedules.append(this_schedule) if measurement_setting == "calibrated": # Create two schedules # Excited state schedule exc_schedule = pulse.Schedule(name="cal_11") exc_schedule += pi_default exc_schedule += measurement_schedule # Ground state schedule gnd_schedule = pulse.Schedule(name="cal_00") gnd_schedule += measurement_schedule # Add calibration schedules to Rabi schedules rabi_schedules = [gnd_schedule] + [exc_schedule] + rabi_schedules # Assemble schedules in experiment rabi_experiment_program = assemble( rabi_schedules, backend=backend, meas_level=1, meas_return="single", shots=num_shots, schedule_los=[{ drive_chan: qubit_frequency_updated }] * (len(pulse_times[0]) + 2), ) # Run job = backend.run(rabi_experiment_program) job_monitor(job) rabi_results = job.result(timeout=120) return rabi_results elif measurement_setting == "default": # Assemble schedules in experiment rabi_experiment_program = assemble( rabi_schedules, backend=backend, meas_level=2, meas_return="avg", shots=num_shots, schedule_los=[{ drive_chan: qubit_frequency_updated }] * (len(pulse_times[0])), ) # Run job = backend.run(rabi_experiment_program) job_monitor(job) rabi_results = job.result(timeout=120) return rabi_results else: sys.exit( "Select correct measurement setting: 'default' or 'calibrated' ")
# Measure qubit circuit.measure(qr[0], cr[0]) # Run our circuit with local simulator backend = BasicAer.get_backend('qasm_simulator') shots = 1024 results = execute(circuit, backend=backend, shots=shots).result() answer = results.get_counts() print("Simulator result") for c1c0 in answer: print(f'c0 = {c1c0[1]} ({answer[c1c0]} shots)') # C0 observed as 1 in 1024 shots # It indicates f(0) != f(1) # Run our circuit with real devices IBMQ.load_account() IBMQ.backends() backend_lb = least_busy(IBMQ.backends(simulator=False)) backend = backend_lb shots = 1024 job_exp = execute(circuit, backend=backend, shots=shots) job_monitor(job_exp, interval=2) results = job_exp.result() answer = results.get_counts(circuit) print("Real Device Result") for c1c0 in answer: print(f'c0 = {c1c0[1]} ({answer[c1c0]} shots)') # As we can see in results, most of the results for C0 is 1 # It indicates f(0) != f(1) # The results with C0 = 0 occur due to errors in the quantum computation.
def simons_algorithm(f, n, token="", factor=1): """ Inputs: f is a blackbox function (f:{0,1}^n -> {0,1}^n) that is either one-to-one or two-to-one. n is the dimension of the input into f. This function finds and returns the key s, if one exists, for a two-to-one. token is a unique code token referencing a ibm account. token is needed to run on a real quantum computer. If no token is passed as a parameter, then i factor is intended to adjust the number of trials to be executed function by first creating a matrix U_f that represents f, then applying the appropriate quantum gates to generate a linear equation. By running the circuit until we generate n-1 unique equations, the set of equations can solve for s. The Classical solver returns s. Returns: the key string s, if found, or the zero bitstring """ # Account and backend setup using_simulator = False if token != "": # Sets the IBMQ token IBMQ.save_account(token) try: # Attempts to load IBMQ based on a previously stored token IBMQ.load_account() provider = IBMQ.get_provider('ibm-q') backend = provider.get_backend("ibmq_16_melbourne") except: # Failure loading an IBMQ account will default to simulator usage print("Error in loading IBMQ account. Running simulation instead.") backend = Aer.get_backend('qasm_simulator') using_simulator = True # Generate the oracle gate oracle = generate_uf_simons(f, n) # Initialize the circuit circuit = QuantumCircuit(2 * n, 2 * n) indices = list(range(2 * n)) indices.reverse() # apply Hadamards to first n qubits for i in range(n): circuit.h(i) # apply oracle gate circuit.unitary(oracle, indices, label="oracle") # apply Hadamards again to first n qubits for i in range(n): circuit.h(i) indices = list(range(n)) # measure first n qubits circuit.measure(indices, indices) # circuit.draw('mpl') # plt.show() # Run the entire process 20 times for i in range(20 * factor): s = set() s_trials = [] # Run quantum circuit until at least n-1 unique eqautions are obtained while (len(s) < n - 1): # Run and evaluate the job results job = execute(circuit, backend, shots=n - 1, optimization_level=3) if not using_simulator: job_monitor(job) try: result = job.result() except: print(job.error_message()) return print(result.time_taken) counts = result.get_counts() for count in counts: s.add(count[2 * n:n - 1:-1]) if len(s) == n - 1: break for bitstring in s: s_trials.append([int(bit) for bit in bitstring]) s_trials = np.array(s_trials) # Solve system of equations val = simons_solver(s_trials, n) # if s = 0^n , skip check if val == [0] * n: continue # if the correct function value is found, no need to keep searching f_val = f(val) if f_val == f([0] * n): return val # s not found, return 0 bit string return [0] * n
def bv_algorithm(f, n, shots=1024, token=""): """ This function is intended to determine to find a,b s.t. f(x) = a*x + b where a*x is bitwise inner product and + is addition modulo 2, for a given function f s.t. f:{0,1}^n -> {0,1}. It is assumed that f can be represented as f(x) = a*x + b. The algorithm first calculates b by solving for f(0^n). It then initializes the qubits with H for the first n qubits and X and H for the last qubit. The algorithm then constructs a Uf oracle gate based on the function input f. It then applies Uf to all the qubits and applies H to the first n qubits. Finally, the simulator is run on the circuit and measures the results. The function then returns the first n measured qubits. UPDATE: This program will now handle running on IBM's quantum computers. A new parameter token is provided which can be used to pass in a user token. If no token is specified, the running machine will attempt to use a previously saved token if one can be found. If no token is found, the program will default to running on the simulator. This function has an anonymous function and integer n as parameters. """ # Account and backend setup using_simulator = False if token != "": # Sets the IBMQ token IBMQ.save_account(token) if comp != "": # Attempts to load IBMQ based on a previously stored token IBMQ.load_account() provider = IBMQ.get_provider('ibm-q') backend = provider.get_backend("ibmq_16_melbourne") else: # Failure loading an IBMQ account will default to simulator usage print("Error in loading IBMQ account. Running simulation instead.") backend = Aer.get_backend('qasm_simulator') using_simulator = True initialize_list = [0] * n # calculate b by f(0^n) = b b = f(initialize_list) print("b is: ", b) # Initialize circuit by applying H to first n qubits and X H to last qubit (ancilla qubit) initialize_list.append(1) qubits = list(range(len(initialize_list))) circuit = initialize(initialize_list) # Generate Uf oracle from f (anonymous function) uf_gate = generate_uf(f, n) # Applying the uf_gate must be done with the qubits in the reverse order due to the implementation of qiskit rv_qubits = qubits[::-1] circuit.unitary(uf_gate, rv_qubits) # Apply H to all qubits except for the last qubit apply_to_list = [1] * n apply_to_list.append(0) circuit = apply_H(circuit, apply_to_list) circuit.measure(range(n), range(n)) # Draw the circle circuit.draw('mpl') plt.show() # run circuit and measure qubits job = execute(circuit, backend, shots=shots, optimization_level=3) if not using_simulator: job_monitor(job) try: result = job.result() except: print(job.error_message()) return print("Time taken:", result.time_taken) counts = result.get_counts(circuit) plot_histogram(counts) # Will return the key with the highest number of hits. While the simulation will be deterministic, # the any real quantum computer will have errors. This helps to mitigate those errors max = 0 for count in counts: if max < counts[count]: max = counts[count] a = count return a, b
import qiskit as q from qiskit import Aer, execute from qiskit import IBMQ from qiskit.tools.visualization import plot_histogram from qiskit.tools.monitor import job_monitor import matplotlib f = open('ibmtoken.txt') token = f.read() IBMQ.load_account() qr = q.QuantumRegister(2) cr = q.ClassicalRegister(2) circuit = q.QuantumCircuit(qr, cr) circuit.x(qr[0]) circuit.cx(qr[0], qr[1]) ##circuit.measure([qr[0],qr[1]],[cr[0],cr[1]])#measureing and storing result in classical bits ##simulator=Aer.get_backend('qasm_simulator')#using the qasm simulator ##Result=execute(circuit,backend=simulator).result() ##plot_histogram(Result.get_counts(circuit)).show() ##print(circuit) ##circuit.draw(output = 'mpl',filename='ckt.png') provider = IBMQ.get_provider('ibm-q') #using actual quantum computer qcomp = provider.get_backend('ibmq_16_melbourne') #using the ibmq_16_melbourne job = execute(circuit, backend=qcomp) job_monitor(job) #monitoring for the completion of our job result = job.result() plot_histogram(result.get_counts(circuit)).show() #plotting the results
args = parser.parse_args() IBMQ.load_account() provider = get_provider(qc_name_dict[args.name]) if args.name is not None: circ = QuantumCircuit(1, 1) circ.h(0) circ.measure(0, 0) logger.info(f"Queue on {args.name}") backend = provider.get_backend(qc_name_dict[args.name]) job1 = execute(circ, backend) job2 = execute(circ, backend) print('here1') job_monitor(job1, interval=1) print('here2') job_monitor(job2, interval=1) exit(0) backends = provider.backends( filters=lambda x: x.configuration().n_qubits >= args.n and not x. configuration().simulator and x.status().operational) candidates = [] now = datetime.now() for back in backends: backend_status = back.status() if not backend_status.operational or \ backend_status.status_msg != 'active':
local_sim_backend = Aer.get_backend('qasm_simulator') sim_backend = provider.get_backend('ibmq_qasm_simulator') ### real_backend = least_busy(provider.backends(simulator=False)) # old real_backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= nqubits and not x.configuration().simulator and x.status().operational==True)) print("least busy backend: ", real_backend) print(real_backend) job1 = execute(circ,local_sim_backend) job2 = execute(circ,sim_backend) job3 = execute(circ,real_backend) job_monitor(job3) counts1 = job1.result().get_counts() counts2 = job2.result().get_counts() counts3 = job3.result().get_counts() # may be commented out to speed up testing shots = job3.result().to_dict()["results"][0]["shots"] measured_results = [] for i in range(len(counts3)): binary_state = str(bin(i)) binary_state = binary_state.split('b')[1].zfill(nqubits) print(binary_state, end = ' | ') measured_result = math.sqrt(counts2[''.join(binary_state)] / shots) * key measured_results.append(measured_result)
#classical measurement register circuit = qiskit.QuantumCircuit(qregister, cregister) #gates circuit.h(0) circuit.cx(0, 1) #measurement circuit.measure([0], [0]) #q[0] to c[0] circuit.measure([1], [1]) #q[1] to c[1] #or simply... #circuit.measure([0,1], [0,1]) # ------------------------------------ print(circuit) print('plotting the circuit drawning') circuit.draw(output='mpl') pyplot.show() job = qiskit.execute(circuit, backend, shots=1024) #call simulator job_monitor(job) #show job's progress counts = job.result().get_counts() #get measurement results print(counts) #print measurement results #plot results plot_histogram(counts) pyplot.show()
def run_job(circ_, backend_, shots_=1000, optimization_level_=0): job = execute(circ_, backend=backend_, shots=shots_, optimization_level=optimization_level_) job_monitor(job) return job.result().get_counts(circ_)
def run_circuits(self): import glob if "y" in self.plot_flag: import matplotlib.pyplot as plt if self.backend in "ibm": import qiskit as qk from qiskit.tools.monitor import job_monitor from qiskit.visualization import plot_histogram, plot_gate_map, plot_circuit_layout from qiskit import Aer, IBMQ, execute from qiskit.providers.aer import noise from qiskit.providers.aer.noise import NoiseModel from qiskit.circuit import quantumcircuit from qiskit.circuit import Instruction ## Show available backends provider = qk.IBMQ.get_provider(group='open') provider.backends() #choose the device you would like to run on device = provider.get_backend(self.device_choice) #gather fidelity statistics on this device if you want to create a noise model for the simulator properties = device.properties() coupling_map = device.configuration().coupling_map #TO RUN ON THE SIMULATOR #create a noise model to use for the qubits of the simulator noise_model = NoiseModel.from_backend(device) # Get the basis gates for the noise model basis_gates = noise_model.basis_gates # Select the QasmSimulator from the Aer provider simulator = Aer.get_backend('qasm_simulator') #To run on the quantum computer, assign a quantum computer of your choice as the backend backend = provider.get_backend(self.device_choice) #CHOOSE TO RUN ON QUANTUM COMPUTER OR SIMULATOR if self.QCQS in ["QC"]: #quantum computer execution job = qk.execute(self.ibm_circuits_list, backend=backend, shots=self.shots) job_monitor(job) elif self.QCQS in ["QS"]: #simulator execution if self.noise_choice in ["y"]: print("Running noisy simulator job...") with open(self.namevar, 'a') as tempfile: tempfile.write("Running noisy simulator job...\n") result_noise = execute(self.ibm_circuits_list, simulator, noise_model=noise_model, coupling_map=coupling_map, basis_gates=basis_gates, shots=self.shots).result() print("Noisy simulator job successful") with open(self.namevar, 'a') as tempfile: tempfile.write("Noisy simulator job successful\n") elif self.noise_choice in ["n"]: print("Running noiseless simulator job...") with open(self.namevar, 'a') as tempfile: tempfile.write("Running noiseless simulator job...\n") result_noise = execute(self.ibm_circuits_list, simulator, coupling_map=coupling_map, basis_gates=basis_gates, shots=self.shots).result() print("Noiseless simulator job successful") with open(self.namevar, 'a') as tempfile: tempfile.write("Noiseless simulator job successful\n") else: print( "Please enter either y or n for the simulator noise query" ) with open(self.namevar, 'a') as tempfile: tempfile.write( "Please enter either y or n for the simulator noise query\n" ) else: print("Please enter either QC or QS") with open(self.namevar, 'a') as tempfile: tempfile.write("Please enter either QC or QS\n") #Post Processing Depending on Choice self.result_out_list = [] if self.QCQS in ["QS"]: #SIMULATOR POST PROCESSING for j in range(self.num_qubits): avg_mag_sim = [] temp = [] i = 1 print("Post-processing qubit {} data".format(j + 1)) with open(self.namevar, 'a') as tempfile: tempfile.write( "Post-processing qubit {} data\n".format(j + 1)) for c in self.ibm_circuits_list: result_dict = result_noise.get_counts(c) temp.append( self.average_magnetization(result_dict, self.shots, j)) if i % (self.steps + 1) == 0: avg_mag_sim.append(temp) temp = [] i += 1 # time_vec=np.linspace(0,total_t,steps) # time_vec=time_vec*JX/H_BAR if "y" in self.plot_flag: fig, ax = plt.subplots() plt.plot(range(self.steps + 1), avg_mag_sim[0]) plt.xlabel("Simulation Timestep", fontsize=14) plt.ylabel("Average Magnetization", fontsize=14) plt.tight_layout() every_nth = 2 for n, label in enumerate(ax.xaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) every_nth = 2 for n, label in enumerate(ax.yaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) # plt.yticks(np.arange(-1, 1, step=0.2)) # Set label locations. plt.savefig( "data/Simulator_result_qubit{}.png".format(j + 1)) plt.close() self.result_out_list.append(avg_mag_sim[0]) existing = glob.glob( "data/Spin {} Average Magnetization Data, Qubits={}, num_*.txt" .format(j + 1, self.num_qubits)) np.savetxt( "data/Spin {} Average Magnetization Data, Qubits={}, num_{}.txt" .format(j + 1, self.num_qubits, len(existing) + 1), avg_mag_sim[0]) self.result_matrix = np.stack(self.result_out_list) print("Done") with open(self.namevar, 'a') as tempfile: tempfile.write("Done\n") elif self.QCQS in ["QC"]: #QUANTUM COMPUTER POST PROCESSING for j in range(self.num_qubits): results = job.result() avg_mag_qc = [] temp = [] i = 1 print("Post-processing qubit {} data".format(j + 1)) with open(self.namevar, 'a') as tempfile: tempfile.write( "Post-processing qubit {} data\n".format(j + 1)) for c in self.ibm_circuits_list: result_dict = results.get_counts(c) temp.append( self.average_magnetization(result_dict, self.shots, j)) if i % (self.steps + 1) == 0: avg_mag_qc.append(temp) temp = [] i += 1 # QC if "y" in self.plot_flag: fig, ax = plt.subplots() plt.plot(range(self.steps + 1), avg_mag_qc[0]) plt.xlabel("Simulation Timestep", fontsize=14) plt.ylabel("Average Magnetization", fontsize=14) plt.tight_layout() every_nth = 2 for n, label in enumerate(ax.xaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) every_nth = 2 for n, label in enumerate(ax.yaxis.get_ticklabels()): if (n + 1) % every_nth != 0: label.set_visible(False) plt.savefig("data/QC_result_qubit{}.png".format(j + 1)) plt.close() self.result_out_list.append(avg_mag_qc[0]) existing = glob.glob( "data/Spin {} Average Magnetization Data, Qubits={}, num_*.txt" .format(j + 1, self.num_qubits)) np.savetxt( "data/Spin {} Average Magnetization Data, Qubits={}, num_{}.txt" .format(j + 1, self.num_qubits, len(existing) + 1), avg_mag_qc[0]) self.result_matrix = np.stack(self.result_out_list) print("Done") with open(self.namevar, 'a') as tempfile: tempfile.write("Done\n") elif "rigetti" in self.backend: import pyquil from pyquil.quil import Program from pyquil.gates import H, RX, RZ, CZ, RESET, MEASURE from pyquil.api import get_qc print("Running Pyquil programs...") with open(self.namevar, 'a') as tempfile: tempfile.write("Running Pyquil programs...\n") qc = get_qc(self.device_choice) results_list = [] first_ind = 0 #each circuit represents one timestep for circuit in self.rigetti_circuits_list: temp = qc.run(circuit) results_list.append(temp) for i in range(self.num_qubits): print("Post-processing qubit {} data...".format(i + 1)) with open(self.namevar, 'a') as tempfile: tempfile.write( "Post-Processing qubit {} data...\n".format(i + 1)) qubit_specific_row = np.zeros(len(results_list)) for j in range(len(self.rigetti_circuits_list)): results = results_list[j] summation = 0 for array in results: summation += (1 - 2 * array[i]) summation = summation / len( results) #average over the number of shots qubit_specific_row[j] = summation if first_ind == 0: self.result_matrix = qubit_specific_row first_ind += 1 else: self.result_matrix = np.vstack( (self.result_matrix, qubit_specific_row)) if "y" in self.plot_flag: plt.figure() xaxis = np.linspace(0, self.steps, num=self.steps + 1) plt.plot(qubit_specific_row) plt.xlabel("Simulation Timestep") plt.ylabel("Average Magnetization") plt.savefig("data/Result_qubit{}.png".format(i + 1)) plt.close() existing = glob.glob( "data/Spin {} Average Magnetization Data, Qubits={}, num_*.txt" .format(i + 1, self.num_qubits)) np.savetxt( "data/Spin {} Average Magnetization Data, Qubits={}, num_{}.txt" .format(i + 1, self.num_qubits, len(existing) + 1), qubit_specific_row) print("Done") with open(self.namevar, 'a') as tempfile: tempfile.write("Done\n")
circuit.cx(index, len(serectnumber)) # circuit.cx(5,6) # circuit.cx(3,6) # circuit.cx(0,6) circuit.barrier() circuit.h(range(len(serectnumber))) circuit.barrier() circuit.measure(range(len(serectnumber)), range(len(serectnumber))) circuit.draw(output="mpl") simulator = Aer.get_backend("qasm_simulator") result = execute(circuit, simulator, shots=1000).result() #1 attempt plot_histogram(result.get_counts()) IBMQ.load_account() provider = IBMQ.get_provider( "ibm-q") #Choose the actual quatnum computer provider qcomp = provider.get_backend( "ibmq_london") #get the actual quantum compter as backend job = execute( circuit, backend=qcomp) #assign the job sending to the quantum computer to run from qiskit.tools.monitor import job_monitor job_monitor(job) #to monitor the current job status since it maybe queed. answer_q = job.result() plot_histogram(answer_q.get_counts(circuit))
def mitigate(circuit, amplification_factors,\ expectationvalue_fun,\ execution_backend, \ experimentname, cx_error_map,\ num_shots, num_experiments,\ target_backend=None, noise_model=None, basis_gates=None,\ paulitwirling=True, verbose=True): """ it is of utter most importance, that the circit is executable on the backend that it is to be executed/targeted for target_backend: is used if execution_backend is a simulator noisemodel: is used if execution_backend is a simulator this function is implemented with convenience in mind, the classical part can be trivially made more memory efficient """ optimization_level = 1 n_qubits = execution_backend.configuration().n_qubits is_simulator = execution_backend.configuration().simulator max_depth_dict = {} mean_depth_dict = {} max_depth_transpiled_dict = {} mean_depth_transpiled_dict = {} jobs_dict = {} E_dict = {} E_av_dict = {} result_dict = {} ### sanity checks if len(amplification_factors) < 2: raise ValueError( "specify at least 2 amplification factors, e.g., (1,2) ") if is_simulator: if target_backend == None: raise ValueError("you need to specify a taget backend") if noise_model == None: raise ValueError("you need to specify a noise model") if basis_gates == None: raise ValueError("you need to specify basis gates") else: execution_backend = target_backend if verbose: print("Sanity checks passed") if is_simulator: # in the case of a simulator, # we do not need to split the runs, # because max_experiments is not limited experimentname += "_backend" + execution_backend.name() experimentname += "_noisemodel" + target_backend.name() experimentname += "_shots" + str(num_shots) experimentname += "_experiments" + str(num_experiments) experimentname += "_paulitwirling" + str(paulitwirling) for r in amplification_factors: name = experimentname + "_r" + str(r) result_dict[name] = read_results(name) if verbose: if result_dict[name] == None: print("Could not read result for job '", name, "' from disk") else: print("Result for job '", name, "' successfully read from disk") ### read circuit depth statistics from file if not result_dict[name] == None: with open('results/' + name + '.mean_circuit_depth', 'r') as f: mean_depth_dict[name] = float(f.read()) with open('results/' + name + '.max_circuit_depth', 'r') as f: max_depth_dict[name] = float(f.read()) with open('results/' + name + '.mean_transpiled_circuit_depth', 'r') as f: mean_depth_transpiled_dict[name] = float(f.read()) with open('results/' + name + '.max_transpiled_circuit_depth', 'r') as f: max_depth_transpiled_dict[name] = float(f.read()) for r in amplification_factors: name = experimentname + "_r" + str(r) if not result_dict[name] == None: continue mean_depth = 0 max_depth = 0 mean_depth_transpiled = 0 max_depth_transpiled = 0 circuits_r = [] for p in range(1, num_experiments + 1): if verbose and p % 25 == 0: print("Creating circuits for '", name, "'", p, "/", num_experiments, end='\r') circ_tmp = create_Paulitwirled_and_noiseamplified_circuit(\ circuit, r, cx_error_map, paulitwirling) depth = circ_tmp.depth() mean_depth += depth max_depth = max(max_depth, depth) # now we can transpile to combine single qubit gates, etc. circ_tmp_transpiled=transpile(circ_tmp,\ backend=target_backend,\ optimization_level=optimization_level) circuits_r.append(circ_tmp_transpiled) depth = circ_tmp_transpiled.depth() mean_depth_transpiled += depth max_depth_transpiled = max(max_depth_transpiled, depth) if verbose: print("Creating circuits for '", name, "'", num_experiments, "/", num_experiments) max_depth_dict[name] = max_depth mean_depth_dict[name] = mean_depth / num_experiments max_depth_transpiled_dict[name] = max_depth_transpiled mean_depth_transpiled_dict[ name] = mean_depth_transpiled / num_experiments if verbose: print("Starting job for '", name, "'") jobs_dict[name] = execute(circuits_r,\ execution_backend,\ noise_model=noise_model,\ basis_gates=basis_gates,\ shots=num_shots) for r in amplification_factors: name = experimentname + "_r" + str(r) if not result_dict[name] == None: continue job_monitor(jobs_dict[name]) success = write_results(name, jobs_dict[name]) if verbose: if success: print("Result for job '", name, "' successfully written to disk") else: print("Could not write result for job '", name, "' from disk") ### write circuit depth statistics to file with open('results/' + name + '.mean_circuit_depth', 'w') as f: f.write(str(mean_depth_dict[name])) with open('results/' + name + '.max_circuit_depth', 'w') as f: f.write(str(max_depth_dict[name])) with open('results/' + name + '.mean_transpiled_circuit_depth', 'w') as f: f.write(str(mean_depth_transpiled_dict[name])) with open('results/' + name + '.max_transpiled_circuit_depth', 'w') as f: f.write(str(max_depth_transpiled_dict[name])) first = True for r in amplification_factors: name = experimentname + "_r" + str(r) if result_dict[name] == None: result_dict[name] = read_results(name) E_dict[name] = expectationvalue_fun(result_dict[name]) E_av_dict[name] = np.zeros_like(E_dict[name]) for j in range(1, num_experiments + 1): E_av_dict[name][j - 1] = sum(E_dict[name][0:j]) / j if first: E_av = E_av_dict[name] first = False else: E_av = np.append( E_av, E_av_dict[name]) ## this is not very efficient coding else: raise ValueError("not yet implemented, coming soon") R=Richardson_extrapolate(E_av.reshape(len(amplification_factors),num_experiments),\ np.array(amplification_factors)) return R, E_dict, E_av_dict,\ max_depth_dict,mean_depth_dict,\ max_depth_transpiled_dict,mean_depth_transpiled_dict,\ experimentname
def execute_real(qc, str_backend, shots): backend = IBMQ.get_backend(str_backend) job = execute(qc, backend=backend, shots=shots) job_monitor(job) results = job.result() return results.get_counts()
def run(b, circuit): provider = IBMQ.get_provider("ibm-q") backend = provider.get_backend(b) job = q.execute(circuit, backend=backend, shots=1000) job_monitor(job) return (job)
circuit.h(0) circuit.cx(0, 1) circuit.cx(1, 2) circuit.measure(range(nqubits), range(nqubits)) circuit.draw(output='mpl') simulator = Aer.get_backend("qasm_simulator") result = execute(circuit, simulator, shots=1024).result() #1 attempt plot_histogram(result.get_counts()) IBMQ.load_account() provider = IBMQ.get_provider("ibm-q") qcom = provider.get_backend("ibmq_burlington") job = execute(circuit, qcom, shots=1024) job_monitor(job) result_q = job.result() plot_histogram(result_q.get_counts()) ## main part! from qiskit.ignis.mitigation.measurement import (complete_meas_cal, CompleteMeasFitter) cal_circuits, state_labels = complete_meas_cal( qr=circuit.qregs[0], circlabel="measerrormitigationcal" ) #circuit.qregs[0] is the quantum register to show all qubits we have #cal_circuits is the calibrated circuit of all qubits possible outcomes, state labels are 000 - 111 cal_job = execute(cal_circuits, qcom, shots=1024, optimization_level=0) print(cal_job.job_id()) job_monitor(cal_job) result_cal = cal_job.result() plot_histogram(result_cal.get_counts())
def sys_evolve(nsites, excitations, total_time, dt, hop, U, trotter_steps): #Check for correct data types of input if not isinstance(nsites, int): raise TypeError("Number of sites should be int") if np.isscalar(excitations): raise TypeError("Initial state should be list or numpy array") if not np.isscalar(total_time): raise TypeError("Evolution time should be scalar") if not np.isscalar(dt): raise TypeError("Time step should be scalar") if not isinstance(trotter_steps, int): raise TypeError("Number of trotter slices should be int") numq = 2 * nsites num_steps = int(total_time / dt) print('Num Steps: ', num_steps) print('Total Time: ', total_time) data = np.zeros((2**numq, num_steps)) for t_step in range(0, num_steps): #Create circuit with t_step number of steps q = QuantumRegister(numq) c = ClassicalRegister(numq) qcirc = QuantumCircuit(q, c) #=========USE THIS REGION TO SET YOUR INITIAL STATE============== #Loop over each excitation for flip in excitations: qcirc.x(flip) # qcirc.z(flip) #=============================================================== qcirc.barrier() #Append circuit with Trotter steps needed qc_evolve(qcirc, nsites, t_step * dt, dt, hop, U, trotter_steps) #Measure the circuit for i in range(numq): qcirc.measure(i, i) #Choose provider and backend #provider = IBMQ.get_provider() #backend = Aer.get_backend('statevector_simulator') backend = Aer.get_backend('qasm_simulator') #backend = provider.get_backend('ibmq_qasm_simulator') #backend = provider.get_backend('ibmqx4') #backend = provider.get_backend('ibmqx2') #backend = provider.get_backend('ibmq_16_melbourne') shots = 8192 max_credits = 10 #Max number of credits to spend on execution job_exp = execute(qcirc, backend=backend, shots=shots, max_credits=max_credits) job_monitor(job_exp) result = job_exp.result() counts = result.get_counts(qcirc) print(result.get_counts(qcirc)) print("Job: ", t_step + 1, " of ", num_steps, " complete.") #Store results in data array and normalize them for i in range(2**numq): if counts.get(get_bin(i, numq)) is None: dat = 0 else: dat = counts.get(get_bin(i, numq)) data[i, t_step] = dat / shots return data
for i in range(2 * n): qc.h(q[i]) oracle1(qc, q, 0, anc) for j in range(n): qc.cx(q[j], q[j + n]) oracle1(qc, q, 0, anc) for j in range(n): qc.cx(q[j], q[j + n]) qc.measure(q, c) #Executing the circuit and getting the result. qjob = execute(qc, shots=shots, backend=backend) job_monitor(qjob) result = qjob.result() stats = result.get_counts() #print(stats) #Printing the selected outputs. bitstring = [] for i in range(int(pow(2, n))): bitstring.append(bin(i)[2:].zfill(2 * n)) count = 0 for string in bitstring: if string in stats: count += stats[string]
def all_methods_data(interested_qubits,backend, itr, QDT_correlated, shots_per_point = 1024, file_address = ''): """Collect data for our method, Qiskit method, QDT, and standard Bayesian. Args: interested_qubits: an array of ints. REMEBER TO FOLLOW THE ORDER [LAST QUBIT, ..., FIRST QUBIT] backend: backend from provider.get_backend(). itr: number of iterations of job submission in our method only. QDT_correlated: True if want qubits corrlected in QDT method. file_address: file address, string ends with '/' if not empty Returns: None """ with open(file_address + 'interested_qubits.csv', mode='w', newline='') as sgm: param_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) param_writer.writerow(interested_qubits) # Record data for filters (ourmethod) print('Our method') collect_filter_data(backend, itr = itr, shots = 8192, if_monitor_job = True, if_write = True, file_address = file_address) # Qiskit Method print('Qiskit Method') qr = QuantumRegister(len(interested_qubits)) meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal') for i in range(len(meas_calibs)): meas_calibs[i] = transpile(meas_calibs[i], backend,initial_layout=interested_qubits) job = execute(meas_calibs, backend=backend, shots=8192, optimization_level = 0) job_monitor(job) cal_results = job.result() meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal') meas_filter = meas_fitter.filter cal_matrix = meas_fitter.cal_matrix with open(file_address + 'cal_matrix.csv', mode='w', newline='') as sgm: param_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for row in cal_matrix: param_writer.writerow(row) with open(file_address + 'state_labels.csv', mode='w', newline='') as sgm: param_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) param_writer.writerow(state_labels) # QDT print('QDT, correlation = ', QDT_correlated) if QDT_correlated: qdt_qubit_indices = interested_qubits qdt_probe_kets = povmtools.pauli_probe_eigenkets qdt_calibration_circuits = detector_tomography_circuits(qdt_qubit_indices, qdt_probe_kets) print('Number of Circuits needed is ',len(qdt_calibration_circuits)) # We then execute them on backend prepared earlier. shots_number = 8192 # Perform a noisy simulation job = execute(qdt_calibration_circuits, backend=backend, shots=shots_number, optimization_level = 0) job_monitor(job) result = job.result() dtf = DetectorTomographyFitter() calibration_setup = QDTCalibrationSetup.from_qiskit_results([result], qdt_probe_kets) ml_povm_estimator = dtf.get_maximum_likelihood_povm_estimator(calibration_setup) mitigator = QDTErrorMitigator() mitigator.prepare_mitigator(ml_povm_estimator) trans_mat = mitigator.transition_matrix with open(file_address + 'trans_matrix.csv', mode='w', newline='') as sgm: param_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for row in trans_mat: param_writer.writerow(row) else: for q in interested_qubits: qdt_qubit_indices = [q] qdt_probe_kets = povmtools.pauli_probe_eigenkets qdt_calibration_circuits = detector_tomography_circuits(qdt_qubit_indices, qdt_probe_kets) print('Number of Circuits needed is ',len(qdt_calibration_circuits)) # We then execute them on backend prepared earlier. shots_number = 8192 # Perform a noisy simulation job = execute(qdt_calibration_circuits, backend=backend, shots=shots_number, optimization_level = 0) job_monitor(job) result = job.result() # Create Mitigator dtf = DetectorTomographyFitter() calibration_setup = QDTCalibrationSetup.from_qiskit_results([result], qdt_probe_kets) ml_povm_estimator = dtf.get_maximum_likelihood_povm_estimator(calibration_setup) mitigator = QDTErrorMitigator() mitigator.prepare_mitigator(ml_povm_estimator) trans_mat = mitigator.transition_matrix with open(file_address + 'trans_matrix' + str(q) + '.csv', mode='w', newline='') as sgm: param_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for row in trans_mat: param_writer.writerow(row) # Data for Standard Bayesian # Read data to for measurement error while input is |0> print('Write data for standard Bayesian') prop_dict = backend.properties().to_dict() with open(file_address + 'given_params.csv', mode='w', newline='') as sgm: param_writer = csv.writer(sgm, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) for q in interested_qubits: p0m0 = 1 - prop_dict['qubits'][q][5]['value'] if p0m0 == 1 or p0m0 < 0.7: p0m0 = 0.9 p1m1 = 1 - prop_dict['qubits'][q][4]['value'] if p1m1 == 1 or p1m1 < 0.7: p1m1 = 0.9 param_writer.writerow([p0m0,p1m1]) with open(file_address + 'Filter_data.csv', mode='r') as measfile: reader = csv.reader(measfile) cali01 = np.asarray([row for row in reader][0]) Data = cali01 for q in interested_qubits: y = getData0(Data,itr*int(8192/shots_per_point),q) with open(file_address + 'Qubit{}.csv'.format(q), mode='w',newline='') as sgr: read_writer = csv.writer(sgr, delimiter=',', quotechar='"', quoting=csv.QUOTE_MINIMAL) read_writer.writerow(['x','y']) for i in range(len(y)): read_writer.writerow([0.5,y[i]])
initialization(qc, q_input, q_extra, n_literals, n_clauses) formula_rep(qc, q_input, q_auxiliar, q_extra, sat_formula) junction(qc, q_extra, q_auxiliar, q_output, n_clauses) junction_inversion(qc, q_extra, q_auxiliar, n_clauses) circuit_inversion(qc, q_input, q_auxiliar, q_extra, sat_formula, n_literals) finalization(qc, q_input, q_output, q_auxiliar, n_literals) measuring(qc, q_input, ans) # See a list of available local simulators print("IBMQ backends: ", IBMQ.backends()) backend_ibmq = IBMQ.get_backend('ibmq_qasm_simulator') job_ibmq = execute(qc, backend_ibmq) job_monitor(job_ibmq) result_ibmq = job_ibmq.result() circuit_drawer(qc).save("circuit.pdf", "PDF") x = plot_histogram(result_ibmq.get_counts(qc)) x.savefig("out_quantum.png") # Show the results print(result_ibmq.get_counts(qc))
#projection and meassurement qc.barrier(q[0]) qc.barrier(q[1]) qc.barrier(q[2]) qc.measure(q[0], c[0]) qc.measure(q[1], c[1]) qc.measure(q[2], c[2]) qc.draw(output='mpl') #Run on qasm simulator backend_qasm = BasicAer.get_backend('qasm_simulator') job_qasm = execute(qc, backend_qasm, shots=8192) result_qasm = job_qasm.result() counts = result_qasm.get_counts(qc) print(counts) plot_histogram(counts) sim_jobID = job_qasm.job_id() print('SIMULATION JOB ID: {}'.format(sim_jobID)) #Run on real device backend_exp = IBMQ.get_backend('ibmqx2') backend_exp.name() job_exp = execute(qc, backend_exp, shots=8192) #,max_credits=3) job_monitor(job_exp) result_exp = job_exp.result() counts_exp = result_exp.get_counts() print(counts_exp) plot_histogram([counts_exp, counts]) jobID = job_exp.job_id() print('JOB ID: {}'.format(jobID))
def process_parameterized(self, q_device: tq.QuantumDevice, q_layer_parameterized: tq.QuantumModule, q_layer_fixed: tq.QuantumModule, q_layer_measure: tq.QuantumModule, x, parallel=True): """ separate the conversion, encoder part will be converted to a parameterized Qiskit QuantumCircuit. The remaining part will be a non-parameterized QuantumCircuit. In this case, only one time of compilation is required. q_layer_parameterized needs to have a func_list to specify the gates for parallel: JobManager has bugs when submitting job, so use multiprocessing instead """ transpiled_circ, binds_all = self.preprocess_parameterized( q_device, q_layer_parameterized, q_layer_fixed, q_layer_measure, x) if parallel: if hasattr(self.backend.configuration(), 'max_experiments'): chunk_size = self.backend.configuration().max_experiments else: # using simulator, apply multithreading chunk_size = len(binds_all) // self.max_jobs split_binds = [binds_all[i:i + chunk_size] for i in range( 0, len(binds_all), chunk_size)] qiskit_verbose = self.max_jobs <= 6 feed_dicts = [] for split_bind in split_binds: feed_dict = { 'experiments': transpiled_circ, 'backend': self.backend, 'pass_manager': self.empty_pass_manager, 'shots': self.n_shots, 'seed_simulator': self.seed_simulator, 'noise_model': self.noise_model, 'parameter_binds': split_bind, } feed_dicts.append([feed_dict, qiskit_verbose]) p = multiprocessing.Pool(self.max_jobs) results = p.map(run_job_worker, feed_dicts) p.close() if all(isinstance(result, dict) for result in results): counts = results else: if isinstance(results[-1], dict): results[-1] = [results[-1]] counts = list(itertools.chain(*results)) else: job = execute(experiments=transpiled_circ, backend=self.backend, pass_manager=self.empty_pass_manager, shots=self.n_shots, seed_simulator=self.seed_simulator, noise_model=self.noise_model, parameter_binds=binds_all ) job_monitor(job, interval=1) result = job.result() counts = result.get_counts() measured_qiskit = get_expectations_from_counts( counts, n_wires=q_device.n_wires) measured_qiskit = torch.tensor(measured_qiskit, device=x.device) return measured_qiskit
#IBMQ.save_account('token', overwrite = True) ''' provider = IBMQ.load_account() backend = provider.backends.ibmq_vigo qobj = assemble(transpile(circuit, backend = backend), backend = backend) job = backend.run(qobj) ''' from qiskit.tools.monitor import job_monitor, backend_overview IBMQ.load_account() provider = IBMQ.get_provider('ibm-q') backend_overview() backend_name = input("Which backend do you want to use: ") qcomp = provider.get_backend(backend_name) job = execute(circuit, backend=qcomp) job_monitor(job) result = job.result() plot_histogram(result.get_counts(circuit)) plt.show()
qc_best.measure(q1[cx_best_worst[0][0][1]], c1[1]) print("Best CX:") print(qc_best) #Worst circuit qc_worst.h(q1[cx_best_worst[1][0][0]]) qc_worst.cx(q1[cx_best_worst[1][0][0]], q1[cx_best_worst[1][0][1]]) qc_worst.measure(q1[cx_best_worst[1][0][0]], c1[0]) qc_worst.measure(q1[cx_best_worst[1][0][1]], c1[1]) print("Worst CX:") print(qc_worst) # Run the best and worst circuits on the backend job_best = execute(qc_best, backend, shots=1000) job_monitor(job_best) job_worst = execute(qc_worst, backend, shots=1000) job_monitor(job_worst) # Create and run a benchmark circuit on a local simulator q = QuantumRegister(backend.configuration().n_qubits) c = ClassicalRegister(backend.configuration().n_qubits) qc = QuantumCircuit(q, c) qc.h(q[0]) qc.cx(q[0], q[1]) qc.measure(q[0], c[0]) qc.measure(q[1], c[1]) backend_sim = Aer.get_backend('qasm_simulator') job_sim = execute(qc, backend_sim)
print(qc1_new) print("Superposition circuit before passes:") print(qc2) print("Superposition circuit after passes:") print(qc2_new) # Assemble the two circuits into a runnable qobj qobj = assemble([qc1_new, qc2_new], shots=1000) # Running qobj on the simulator print("Running on simulator:") sim_job = qasm_simulator.run(qobj) # Getting the result sim_result = sim_job.result() # Show the results print(sim_result.get_counts(qc1)) print(sim_result.get_counts(qc2)) # Running the job. print("Running on device:") exp_job = least_busy_device.run(qobj) job_monitor(exp_job) exp_result = exp_job.result() # Show the results print(exp_result.get_counts(qc1)) print(exp_result.get_counts(qc2))
from qiskit import IBMQ IBMQ.load_account() # In[17]: #Ejecución en un computador cuantico real proveedor = IBMQ.get_provider('ibm-q') comp_cuantico = proveedor.get_backend('ibmq_burlington') ejecucion = execute(circuito_12, backend=comp_cuantico,shots=1000) from qiskit.tools.monitor import job_monitor job_monitor(ejecucion) resultado = ejecucion.result() conteos = resultado.get_counts() print(conteos) # In[20]: plot_histogram(conteos) # **1.4. Experimento:** Cuando un qubit esta inicializado en $|1>\rangle$ el resultado de la medición debe ser, en teoria, siempre $|1>\rangle$(con probabilidad del 100%). 1000 shots en computador cuantico real # In[28]: