def half_adder(a, b):
print('Computing %d + %d.\n' % (a, b))
qc = QuantumCircuit(4, 2)
# qc[i] = 0, so need to flip according to a, b input
if a == 1:
qc.x(0)
if b == 1:
qc.x(1)
qc.barrier()
# store binary addition on qc[2, 3]
qc.cx(0, 2)
qc.cx(1, 2)
qc.ccx(0, 1, 3)
qc.barrier()
# read result to classical register
qc.measure(2, 0)
qc.measure(3, 1)
qc.draw(output='mpl')
job = execute(qc, Aer.get_backend('qasm_simulator'))
hist = job.result().get_counts()
plot_histogram(hist)
def display(self, circuit):
if self.qiskit_backend != 'local_unitary_simulator':
print('drawing circuit...')
circuit_drawer(circuit)
print('drawing histogram...,')
print(' (close graph windows to proceed)')
plot_histogram(self.job_exp.result().get_counts(circuit))
def plot_results(result, title=''):
counts = result.get_counts()
print('\ncounts : {}\n'.format(counts))
plot_histogram(counts)
plt.title(title)
plt.savefig("img/qt_res.png")
plt.show()
def start_quantum(self):
start_time = time.time()
q = QuantumRegister(5, 'q')
c = ClassicalRegister(5, 'c')
a = self.ui.q_input.currentText()
shor = QuantumCircuit(q, c)
# circuit for a = 7, and plot the results:
self.circuit_a_period_15(shor, q, c, int(a))
backend = Aer.get_backend('qasm_simulator')
sim_job = execute([shor], backend)
sim_result = sim_job.result()
sim_data = sim_result.get_counts(shor)
plot_histogram([sim_data]).show()
self.ui.q_period_label.setText(str(len(sim_data)))
time_diff = time.time() - start_time
self.ui.q_time_label.setText(str(time_diff))
factor_p = math.gcd(
int(self.ui.q_input.currentText())**int(len(sim_data) / 2) + 1,
15) # compute the factor classically
factor_q = math.gcd(
int(self.ui.q_input.currentText())**int(len(sim_data) / 2) - 1,
15) # compute the factor classically
self.ui.q_upper_factor_label.setText(str(factor_q))
self.ui.q_lower_factor_label.setText(str(factor_p))
def get_result(ckt):
shots = 10000
backend = 'local_qasm_simulator'
job = execute(ckt, backend=backend, shots=shots)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
def run_grover(algorithm,oracle_type,oracle_method):
# Run the algorithm on a simulator, printing the most frequently occurring result
backend = Aer.get_backend('qasm_simulator')
result = algorithm.run(backend)
print("Oracle method:",oracle_method)
print("Oracle for:", oracle_type)
print("Aer Result:",result['top_measurement'])
display(plot_histogram(result['measurement']))
# Run the algorithm on an IBM Q backend, printing the most frequently occurring result
print("Getting provider...")
if not IBMQ.active_account():
IBMQ.load_account()
provider = IBMQ.get_provider()
from qiskit.providers.ibmq import least_busy
filtered_backend = least_busy(provider.backends(n_qubits=5, operational=True, simulator=False))
result = algorithm.run(filtered_backend)
print("Oracle method:",oracle_method)
print("Oracle for:", oracle_type)
print("IBMQ "+filtered_backend.name()+" Result:",result['top_measurement'])
display(plot_histogram(result['measurement']))
print(result)
def main():
Q_program = QuantumProgram()
Q_program.register(Qconfig.APItoken, Qconfig.config["url"])
#Creating registers
q = Q_program.create_quantum_register("q", 2)
c = Q_program.create_classical_register("c", 2)
#Quantum circuit to make shared entangled state
superdense = Q_program.create_circuit("superdense", [q], [c])
#Party A : Alice
superdense.h(q[0])
superdense.cx(q[0], q[1])
#00:do nothing, 10:apply x, 01:apply z
superdense.x(q[0])
superdense.z(q[0])
#11:apply zx
superdense.z(q[0])
superdense.x(q[0])
superdense.barrier()
#Party B : Bob
superdense.cx(q[0], q[1])
superdense.h(q[0])
superdense.measure(q[0], c[0])
superdense.measure(q[1], c[1])
circuits = ["superdense"]
print(Q_program.get_qasms(circuits)[0])
backend = "ibmq_qasm_simulator"
shots = 1024
result = Q_program.execute(circuits, backend=backend, shots=shots, max_credits=3, timeout=240)
print("Counts:" + str(result.get_counts("superdense")))
plot_histogram(result.get_counts("superdense"))
def plot(pt,counts):
if pt == 'hist':
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
if pt == 'bloch_mv':
from qiskit.tools.visualization import plot_bloch_multivector
plot_bloch_multivector(counts)
def draw_results(circuit, result, title=''):
counts = result.get_counts(circuit)
print(counts)
plot_histogram(counts)
plt.title(title)
plt.savefig("img/qe_res.png")
plt.show()
def get_job_status(backend, job_id):
backend = IBMQ.get_backend(backend)
try:
print("Backend {0} is operational? {1}".format(
backend.name(),
backend.status()['operational']))
print("Backend was last updated in {0}".format(
backend.properties()['last_update_date']))
print("Backend has {0} pending jobs".format(
backend.status()['pending_jobs']))
except:
print("Maybe some errors in the properties of backend")
ibmq_job = backend.retrieve_job(job_id)
status = ibmq_job.status()
print(status.name)
print(ibmq_job.creation_date())
if (status.name == 'DONE'):
print("EUREKA")
result = ibmq_job.result()
counts = result.get_counts()
print("Result is: {0}".format(counts))
plot_histogram(counts)
else:
print("... Work in progress ...")
print("Queue position = {0}".format(ibmq_job.queue_position()))
print("Error message = {0}".format(ibmq_job.error_message()))
def run(self):
for i in range(self.n):
self.qc.x(self.q[i])
self.qc.barrier()
for i in range(self.n // 2):
self.qc.h(self.q[i])
self.qc.barrier()
for i in range(int(self.n)):
self.oracle()
self.qc.barrier()
self.diffusion_gate()
self.qc.barrier()
self.qc.measure(self.q, self.c)
"""run_sim"""
# See a list of available local simulators
# print("Local backends: ", Aer.available_backends())
# compile and run the Quantum circuit on a simulator backend
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(self.qc, backend_sim)
result_sim = job_sim.result()
# Show the results
print("simulation: ", result_sim)
counts = result_sim.get_counts(self.qc)
counts_l = [(i, counts[i]) for i in counts.keys()]
print('Sim: ', sorted(counts_l, key=lambda x: x[1], reverse=True)[:5])
plot_histogram(counts)
def shorSequential(N, a, args=None):
n = math.ceil(math.log(N, 2))
ctrl = QuantumRegister(1, name='ctrl')
down = QuantumRegister(n, name='x')
down_b = QuantumRegister(n + 1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
qc = QuantumCircuit(ctrl, down, down_b, ancilla)
cr_lis = []
for i in range(0, 2 * n):
cr = ClassicalRegister(1)
qc.add_register(cr)
cr_lis.append(cr)
qc.x(down[n - 1])
for i in range(2 * n):
qc.x(ctrl).c_if(cr_lis[i], 1)
neighbor_range = range(np.max([0, i - 2 * n + 1]), 2 * n - i - 1)
qc.h(ctrl)
gate = cu_a(n, a**(2**(2 * n - 1 - i)), N)
qc.append(gate, qargs=ctrl[:] + down[:] + down_b[:] + ancilla[:])
qc.h(ctrl)
# qc.measure(ctrl,i)
qc.measure(ctrl, cr_lis[i])
if neighbor_range != range(0, 0):
gate = myR(i, neighbor_range, cr_lis)
qc.append(gate, qargs=ctrl[:])
if args == None:
return qc
if args.draw:
qcpath = f'./sequential/circuit'
if not os.path.exists(qcpath):
os.makedirs(qcpath)
circuit_drawer(qc,
output='mpl',
filename=f'./sequential/circuit/{N}_{a}.png',
scale=0.6)
res = sim.mySim(qc, args)
print(res)
new_dict = {}
for iter in list(res):
tmp = iter
tmp = tmp.replace(" ", "")
new_dict[tmp] = res.pop(iter)
# print(new_dict)
lis = sim.sort_by_prob(new_dict)
# print(lis)
if args.output:
respath = f'./sequential/result'
if not os.path.exists(respath):
os.makedirs(respath)
plot_histogram(
new_dict, figsize=(10, 10),
title=f'N={N} a={a} result(Seq)').savefig(respath +
f'/{N}_{a}_res.png')
with open(f'./sequential/result/{N}_{a}.csv', 'w') as out:
csv_out = csv.writer(out)
for i in lis:
csv_out.writerow(i)
def shorNormal(N, a, args=None):
# check whether a, N is coprime
if math.gcd(a, N) != 1:
raise Exception("a,N are not coprime.")
# circuit preparation
n = math.ceil(math.log(N, 2))
up = QuantumRegister(2 * n, name='up')
down = QuantumRegister(n, name='x')
down_b = QuantumRegister(n + 1, name='b')
ancilla = QuantumRegister(1, name='ancilla')
cr = ClassicalRegister(2 * n, name='cr')
qc = QuantumCircuit(up, down, down_b, ancilla, cr)
# initialize
qc.h(up)
qc.x(down[n - 1])
# control-unitary gate application
for i in range(0, 2 * n):
gate = cu_a(n, a**(2**i), N, print_qc=False)
qc.append(gate, qargs=[up[i]] + down[:] + down_b[:] + ancilla[:])
# rest circuit construction
qftgate = myQFT(2 * n, inverse=True)
qc.append(qftgate, qargs=up)
for i in range(0, 2 * n):
qc.measure(up[i], cr[2 * n - 1 - i])
# ===========================================================================
# Result formation
if args is None:
return qc
if args.draw:
qcpath = f'./normal/circuit'
if not os.path.exists(qcpath):
os.makedirs(qcpath)
circuit_drawer(qc,
output='mpl',
filename=f'./normal/circuit/{N}_{a}.png',
scale=0.6)
if args.simcmp:
sim.gpuSim(qc)
sim.cpuSim(qc)
return
res = sim.mySim(qc, args)
lis = sim.sort_by_prob(res)
if args.output:
respath = f'./normal/result'
if not os.path.exists(respath):
os.makedirs(respath)
plot_histogram(
res, figsize=(10, 10),
title=f'N={N} a={a} result(Nor)').savefig(respath +
f'/{N}_{a}_res.png')
path = f'./normal/result/{N}_{a}.csv'
if os.path.exists(path):
print("Overwriting the existing data....")
with open(f'./normal/result/{N}_{a}.csv', 'w') as out:
csv_out = csv.writer(out)
for i in lis:
csv_out.writerow(i)
def execute_circuit(backend, noise_model):
# Construct the GHZ-state quantum circuit
circ = QuantumCircuit(3, 3)
circ.h(0)
circ.cx(0, 1)
circ.cx(0, 2)
circ.measure([0, 1, 2], [0, 1, 2])
print(circ)
# Execute on QASM simulator and get counts
counts = execute(
circ, Aer.get_backend('qasm_simulator')).result().get_counts(circ)
display(
plot_histogram(
counts,
title='Ideal counts for 3-qubit GHZ state on local qasm_simulator')
)
# Execute noisy simulation on QASM simulator and get counts
counts_noise = execute(circ,
Aer.get_backend('qasm_simulator'),
noise_model=noise_model).result().get_counts(circ)
display(
plot_histogram(
counts_noise,
title=
"Counts for 3-qubit GHZ state with noise model on local qasm simulator"
))
# Execute noisy simulation on the ibmq_qasm_simulator and get counts
counts_noise_ibmq = execute(
circ,
provider.get_backend('ibmq_qasm_simulator'),
noise_model=noise_model).result().get_counts(circ)
display(
plot_histogram(
counts_noise_ibmq,
title=
"Counts for 3-qubit GHZ state with noise model on IBMQ qasm simulator"
))
# Execute job on IBM Q backend and get counts
job = execute(circ, backend)
job_monitor(job)
counts_ibmq = job.result().get_counts()
title = "Counts for 3-qubit GHZ state on IBMQ backend " + backend.name()
display(plot_histogram(counts_ibmq, title=title))
# Display the results for all runs
display(
plot_histogram([counts, counts_noise, counts_noise_ibmq, counts_ibmq],
bar_labels=True,
legend=[
"Baseline", "Noise on simulator",
"Noise on IBMQ simulator", "IBM Q backend"
],
title="Comparison"))
def iqft(qci, q, n):
for i in range(n):
for j in range(i): qci.cu1(-math.pi/float(2**(i-j)), q[i], q[j])
qci.h(q[i])
#量子ビット数
bx = 3
#量子ビット数
by = 4
#古典的ビット数
cn = 4
qx = QuantumRegister(bx) #bx個の 量子 レジスタqの 生成
qy = QuantumRegister(by) #by個の 量子 レジスタqの 生成
c = ClassicalRegister(cn) #cn個の 古典 的 レジスタcの 生成
qcx = QuantumCircuit(qx, c) #量子回路の生成
qcy = QuantumCircuit(qy, c) #量子回路の生成
qc = qcx + qcy
for i in range(bx):
qc.h(qx[i])
# 量子ゲート部分 ＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
qc.x(qy[3])
# 制御NOTゲート部分
qc.cx(qx[2],qy[1])
qc.cx(qx[2],qy[2])
qc.cx(qx[1],qy[1])
qc.cx(qx[1],qy[3])
# 制御・制御NOTゲート（トフォリゲート）部分
for i in range(by):
qc.ccx(qx[1],qx[2],qy[i])
# 逆量子フーリエ変換
iqft(qc,qx,3)
# スワップゲート
swap(qc,qx[0],qx[2])
# 古典的レジスタで観測
for i in range(bx):
qc.measure(qx[bx-1-i],c[i])
# 量子ゲート部分 ＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊
#量子 回路 を 実 行 し、 結 果 rに 代入 する
# Use Aer's qasm_simulator
backend_sim = BasicAer.get_backend('qasm_simulator')
r = execute(qc, backend_sim, shots=8192).result()
rc = r.get_counts()
print(rc)
# circuit_drawer(qc)
plot_histogram(rc)
def test_circuit_C_MOD_GROVER_COIN(d, c, sh):
Q_program = QuantumProgram()
build_circuit_C_MOD_GROVER_COIN(Q_program, d, c)
result = Q_program.execute(["test"],
backend="local_qasm_simulator",
shots=sh,
silent=True)
plot_histogram(result.get_counts('test'))
def sample(G, gamma, beta, backend, n_samples = 1024, plot_histogram = False):
circ = create_circuit(G,beta,gamma)
result = qiskit.execute(circ, backend = backend, shots = n_samples).result()
counts = result.get_counts()
if plot_histogram:
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
return counts
def test_circuit_C_GROVER_DIFF_OPER(c, sh):
Q_program = QuantumProgram()
initpattern = numpy.zeros((c + 1), dtype=bool)
initpattern[0] = True
build_circuit_C_GROVER_DIFF_OPER(Q_program, c, initpattern)
result = Q_program.execute(["test"],
backend="local_qasm_simulator",
shots=sh,
silent=True)
plot_histogram(result.get_counts('test'))
def counts_to_valueCounts(self, counts, plot_histogram=False):
d2 = defaultdict(int)
for k, v in counts.items():
d2[self.objective(k)] += v
if plot_histogram:
from qiskit.tools.visualization import plot_histogram
plot_histogram(d2)
return d2
def test_adder(a, b, n, args):
if args.log:
if not os.path.exists('adder/log'):
os.makedirs('adder/log')
path = f'adder/log/a{a}_b{b}_n{n}.log'
sys.stdout = open(path, 'w')
qc = adder(a, b, n)
# print("="*40)
print('=========================')
print(f"Executing adder with a={a}, b={b}, n={n}...")
if args.draw:
figdir = f'./adder/qcfig'
if not os.path.exists(figdir):
os.makedirs(figdir)
figpath = f'./adder/qcfig/a{a}_b{b}_n{n}.png'
if not os.path.isfile(figpath):
circuit_drawer(qc, filename=figpath, output='mpl')
res = sim.mySim(qc, args)
res_lis = list(res)
expect_res = a + b
meas_lis = []
for i in range(len(res_lis)):
meas_lis.append(int(res_lis[i], 2))
equal_flag = False
if args.simulation:
dir_name = args.simulation
if len(res) != 1:
raise Exception("The measurement result should be determinisitic!")
print(f"Expect ans = {expect_res}, Measure res = {meas_lis[0]}")
if expect_res == meas_lis[0]:
equal_flag = True
else:
dir_name = 'real'
for i in range(len(meas_lis)):
print(f"Expect ans = {expect_res}, Measure res = {meas_lis[i]}")
if meas_lis[i] == expect_res:
equal_flag = True
if equal_flag:
print("Result correct! Adder success!")
else:
print("Result wrong! Adder failed!")
if expect_res >= (2**n):
print("Overflow occurs!")
if args.output:
dir = f'./adder/result/{dir_name}'
if not os.path.exists(dir):
os.makedirs(dir)
path = f'./adder/result/{dir_name}/adder{a}_{b}.png'
plot_histogram(res, figsize=(10, 10),
title=f'adder{a}_{b}').savefig(path)
# print("="*40)
print('=========================')
def qft3u(g):
Q_program = QuantumProgram()
qr = Q_program.create_quantum_register("qr", 3)
cr = Q_program.create_classical_register("cr", 3)
qc = Q_program.create_circuit("superposition", [qr], [cr])
#Entradas
#qc.h(qr[1])
qc.h(qr[0])
#qc.x(qr[0])
#qc.x(qr[1])
#qc.x(qr[2])
#QFT 3
qc.h(qr[2]) #aplica H no 1 qubit
#S controlada de 2 para 1
qc.u1(pi/4, qr[2])
qc.cx(qr[1], qr[2])
qc.u1(pi/4, qr[1])
qc.u1(-pi/4, qr[2])
qc.cx(qr[1], qr[2])
#T controlada de 0 para 2
qc.u1(pi/8, qr[2]) #u1=sqrt(T)
qc.cx(qr[0], qr[2])
qc.u1(pi/8, qr[0])
qc.u1(-pi/8, qr[2])
qc.cx(qr[0], qr[2])
qc.h(qr[1]) #aplica H no 2 qubit
#S controlada de 1 para 2
qc.u1(pi/4, qr[1])
qc.cx(qr[0], qr[1])
qc.u1(pi/4, qr[0])
qc.u1(-pi/4, qr[1])
qc.cx(qr[0], qr[1])
qc.h(qr[0]) #aplica H no 3 qubit
qc.swap(qr[2], qr[0]) # troca o 1 e 3 qubit
qc.measure(qr, cr)
result = Q_program.execute(["superposition"], backend='local_qasm_simulator', shots=g)
print(result)
print(result.get_data("superposition"))
tmp = result.get_data("superposition")
plot_histogram(tmp['counts'])
def visualize(self, nsamples=20):
""" Plot a histogram of the top 'nsamples' results from the grover run
Returns:
dict: top nsamples solutions and their count
"""
d = self.result['measurement']
ks = sorted(d.keys(), key=lambda a: d[a])[-nsamples:]
d = {k: d[k] for k in ks}
plot_histogram(self.result['measurement'])
return d
def test_circuit_CNOT(N, sh):
Q_program = QuantumProgram()
pattern = numpy.ones((N + 1), dtype=bool)
pattern[0] = False
pattern[1] = False
pattern[2] = False
pattern[3] = True
build_circuit_CNOT(Q_program, N, pattern)
result = Q_program.execute(["test"],
backend="local_qasm_simulator",
shots=sh,
silent=True)
plot_histogram(result.get_counts('test'))
def run(input, shot):
#Define the Hamiltonian extracted from the picture
Picture_Hamilt = np.array(input)
#Make it Hermitian
Hermitian_Hamilt = 1 / (np.matrix.trace(Picture_Hamilt)) * Picture_Hamilt
#Classically get its eigenvalues "l" and eigenvectors "u", we will use the later to intialize one of the qubits
l, u = LA.eig(Hermitian_Hamilt)
#Let's create the circuit!
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)
#The inithial state of the second qubit of our circuit will be one of the eigenvectors of the Hamiltonian, we define it:
state_vector = [u[0][j] for j in range(2)]
qc.initialize(state_vector, [q[1]])
#Quantum Phase Estimation begins
#create superposition wuth the Hadamard gate
qc.h(q[0])
#The unitary matrix of the controlled unitary gate of the quantum phase estimation circuit is the following:
UH = expm(1j * Hermitian_Hamilt)
(th, ph, lam
) = qiskit.quantum_info.synthesis.two_qubit_decompose.euler_angles_1q(UH)
qc.cu3(th, ph, lam, q[0], q[1])
#Inverse QFT
qc.h(q[0])
#projection and meassurement
qc.barrier(q[0])
qc.barrier(q[1])
qc.measure(q[0], c[0])
qc.measure(q[1], c[1])
#Run on qasm simulator
backend_qasm = BasicAer.get_backend('qasm_simulator')
job_qasm = execute(qc, backend_qasm, shots=shot)
result_qasm = job_qasm.result()
counts = result_qasm.get_counts(qc)
print(counts)
Emo1 = (counts.get('11') or 0)
Emo2 = (counts.get('10') or 0)
Emo3 = (counts.get('01') or 0)
Emo4 = (counts.get('00') or 0)
ProbEmo1 = round(Emo1 / shot, 2)
ProbEmo2 = round(Emo2 / shot, 2)
ProbEmo3 = round(Emo3 / shot, 2)
ProbEmo4 = round(Emo4 / shot, 2)
plot_histogram(counts)
probs = {"11": ProbEmo1, "10": ProbEmo2, "01": ProbEmo3, "00": ProbEmo4}
return probs
def test_circuit_C_DECR(N, flag, sh, iter):
Q_program = QuantumProgram()
initpattern = numpy.zeros((N + 1), dtype=bool)
cpattern = numpy.zeros((N), dtype=bool)
initpattern[0] = False
initpattern[1] = False
initpattern[2] = False
initpattern[3] = True
build_circuit_C_DECR(Q_program, N, flag, initpattern, iter)
result = Q_program.execute(["test"],
backend="local_qasm_simulator",
shots=sh,
silent=True)
plot_histogram(result.get_counts('test'))
def get_value_distribution(circuit, key_bits, value_bits, neg=False):
probs = get_probs(circuit, False)
ordered_probs = sorted(probs.items(), key=lambda x: x[1], reverse=True)
print("Probabilities: ", ordered_probs)
v_freq = process_values(key_bits, value_bits, probs, neg)
from qiskit.tools import visualization
visualization.plot_histogram(v_freq)
ordered_freq = sorted(v_freq.items(), key=lambda x: x[1], reverse=True)
print("Value Distribution", ordered_freq)
def get_value_for_key(circuit, key_bits, value_bits, neg=False):
probs = get_probs(circuit, False)
from qiskit.tools import visualization
visualization.plot_histogram(probs)
ordered_probs = sorted(probs.items(), key=lambda x: x[1], reverse=True)
print("Probabilities: ", ordered_probs)
_, outcomes = process(key_bits, value_bits, probs, neg)
ordered_outcomes = sorted(outcomes.items(), key=lambda x: x[1], reverse=True)
print("Outcomes", ordered_outcomes)
return ordered_probs[0][0]
def get_value_distribution(self):
circuit = self.__build_circuit(self.key_bits, self.value_bits, self.f, None, None)
probs = get_probs((circuit, None, None), 'sim', False)
ordered_probs = sorted(probs.items(), key=lambda x: x[1], reverse=True)
print("Probabilities: ", ordered_probs)
v_freq = self.__process_values(self.key_bits, self.value_bits, probs)
from qiskit.tools import visualization
visualization.plot_histogram(v_freq)
ordered_freq = sorted(v_freq.items(), key=lambda x: x[1], reverse=True)
print("Value Distribution", ordered_freq)
def get_value_for_key(self, key, neg = False):
circuit = self.__build_circuit(self.key_bits, self.value_bits, self.f, key)
probs = get_probs((circuit, None, None), 'sim', False)
from qiskit.tools import visualization
visualization.plot_histogram(probs)
ordered_probs = sorted(probs.items(), key=lambda x: x[1], reverse=True)
print("Probabilities: ", ordered_probs)
_, outcomes = self.__process(self.key_bits, self.value_bits, probs, neg)
ordered_outcomes = sorted(outcomes.items(), key=lambda x: x[1], reverse=True)
print("Outcomes", ordered_outcomes)
return ordered_probs[0][0]
def execute_quantum_circuit(cir,
shots=100,
number_qubits=None,
use_ibmq=False,
specific_ibmq_backend=None):
# Select a specific quantum circuit
quantum_instance = get_quantumcomputer_quantum_instance(
shots, number_qubits, use_ibmq, specific_ibmq_backend)
# Execute quantum circut
result = quantum_instance.execute(cir)
plot_histogram(result.get_counts(cir))
return quantum_instance.backend_name
