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]:
