repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/mingweii/My-Qiskit-codes
|
mingweii
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
#Import essential packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
from matplotlib import cm
from matplotlib.ticker import LinearLocator, FormatStrFormatter
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit import Aer, IBMQ
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, transpile, assemble
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
from qiskit.optimization.applications.ising import max_cut
from qiskit.optimization.applications.ising.common import sample_most_likely
# setup aqua logging
#import logging
#from qiskit.aqua import set_qiskit_aqua_logging
# set_qiskit_aqua_logging(logging.DEBUG) # choose INFO, DEBUG to see the log
# Generating a random graph with n nodes
n = 12
V = range(n)#np.arange(0,n,1)
E=[]
edge_bool=np.random.randint(2,size=n*(n-1)) #generate a sequence of boolen numbers for all possible edges
W=np.zeros([n,n])
idx=0
for i in range(n):
for j in range(i):
temp=np.random.randint(2)
if temp==1:
E.append((i,j,1.0))
W[i,j]=1
W[j,i]=1
#if edge_bool[idx]: # if the edge_bool is 1, then add an edge between i and j vertices with a weight 1.0.
idx+=1
G = nx.Graph()# Generate a graph
G.add_nodes_from(V) # Add the nodes
G.add_weighted_edges_from(E) # Add the edges from E
# Generate plot of the Graph
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
def draw_graph(G, colors, pos):
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=1, ax=default_axes, pos=pos)
#edge_labels = nx.get_edge_attributes(G, 'weight')
#nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=edge_labels)
draw_graph(G, colors, pos)
#nx.draw_networkx(G, node_color=colors, node_size=600, alpha=1, ax=default_axes, pos=pos)
print(W)
best_cost_brute = 0
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]
cost = 0
for i in range(n):
for j in range(n):
cost = cost + W[i,j]*x[i]*(1-x[j])
if best_cost_brute < cost:
best_cost_brute = cost
xbest_brute = x
#print('case = ' + str(x)+ ' cost = ' + str(cost))
colors = ['c' if xbest_brute[i] == 0 else 'r' for i in range(n)]
draw_graph(G, colors, pos)
print('\nBest solution = ' + str(xbest_brute) + ' cost = ' + str(best_cost_brute))
# Evaluate the function
step_size = 0.001;
a_gamma = np.arange(0, np.pi, step_size)
a_beta = np.arange(0, np.pi, step_size)
a_gamma, a_beta = np.meshgrid(a_gamma,a_beta)
F1 = 3-(np.sin(2*a_beta)**2*np.sin(2*a_gamma)**2-0.5*np.sin(4*a_beta)*np.sin(4*a_gamma))*(1+np.cos(4*a_gamma)**2)
# Grid search for the minimizing variables
result = np.where(F1 == np.amax(F1))
a = list(zip(result[0],result[1]))[0]
gamma = a[0]*step_size;
beta = a[1]*step_size;
#The smallest parameters and the expectation can be extracted
print('\n --- OPTIMAL PARAMETERS --- \n')
print('The maximal expectation value is: M1 = %.03f' % np.amax(F1))
print('This is attained for gamma = %.03f and beta = %.03f' % (gamma,beta))
# prepare the quantum and classical resisters
QAOA = QuantumCircuit(len(V), len(V))
# apply the layer of Hadamard gates to all qubits
QAOA.h(range(len(V)))
QAOA.barrier()
# apply the Ising type gates with angle gamma along the edges in E
for edge in E:
k = edge[0]
l = edge[1]
QAOA.cp(-2*gamma, k, l)
QAOA.p(gamma, k)
QAOA.p(gamma, l)
# then apply the single qubit X rotations with angle beta to all qubits
QAOA.barrier()
QAOA.rx(2*beta, range(len(V)))
# Finally measure the result in the computational basis
QAOA.barrier()
QAOA.measure(range(len(V)),range(len(V)))
### draw the circuit for comparison
QAOA.draw(output='mpl')
# Compute the value of the cost function
def cost_function_C(x,G):
E = G.edges()
if( len(x) != len(G.nodes())):
return np.nan
C = 0;
for index in E:
e1 = index[0]
e2 = index[1]
w=1.0
C = C + w*x[e1]*(1-x[e2]) + w*x[e2]*(1-x[e1])
return C
# run on local simulator
backend = Aer.get_backend("qasm_simulator")
shots = 200000
TQAOA = transpile(QAOA, backend)
qobj = assemble(TQAOA)
QAOA_results = backend.run(qobj).result()
plot_histogram(QAOA_results.get_counts(),figsize = (12,6),bar_labels = False)
# Evaluate the data from the simulator
counts = QAOA_results.get_counts()
avr_C = 0
max_C = [0,0]
hist = {}
for k in range(len(G.edges())+1):
hist[str(k)] = hist.get(str(k),0)
for sample in list(counts.keys()):
# use sampled bit string x to compute C(x)
x = [int(num) for num in list(sample)]
tmp_eng = cost_function_C(x,G)
# compute the expectation value and energy distribution
avr_C = avr_C + counts[sample]*tmp_eng
hist[str(round(tmp_eng))] = hist.get(str(round(tmp_eng)),0) + counts[sample]
# save best bit string
if( max_C[1] < tmp_eng):
max_C[0] = sample
max_C[1] = tmp_eng
M1_sampled = avr_C/shots
""
print('\n --- SIMULATION RESULTS ---\n')
print('The sampled mean value is M1_sampled = %.02f while the true value is M1 = %.02f \n' % (M1_sampled,np.amax(F1)))
print('The approximate solution is x* = %s with C(x*) = %d \n' % (max_C[0],max_C[1]))
print('The cost function is distributed as: \n')
plot_histogram(hist,figsize = (8,6),bar_labels = False)
colors = ['r' if max_C[0][i] == '0' else 'c' for i in range(n)]
draw_graph(G, colors, pos)
# Use the IBMQ essex device
provider = IBMQ.load_account()
large_enough_devices = provider.backends(filters=lambda x: x.configuration().n_qubits >= n and
not x.configuration().simulator)
backend = least_busy(large_enough_devices)
shots = 8192
TQAOA = transpile(QAOA, backend)
qobj = assemble(TQAOA, shots=shots)
job_exp = backend.run(qobj)
job_monitor(job_exp)
exp_results = job_exp.result()
plot_histogram(exp_results.get_counts(),figsize = (10,8),bar_labels = False)
# Evaluate the data from the experiment
counts_exp = exp_results.get_counts()
avr_C_exp = 0
max_C_exp = [0,0]
hist_exp = {}
for k in range(len(G.edges())+1):
hist_exp[str(k)] = hist_exp.get(str(k),0)
for sample in list(counts_exp.keys()):
# use sampled bit string x to compute C(x)
x = [int(num) for num in list(sample)]
tmp_eng = cost_function_C(x,G)
# compute the expectation value and energy distribution
avr_C_exp = avr_C_exp + counts_exp[sample]*tmp_eng
hist_exp[str(round(tmp_eng))] = hist_exp.get(str(round(tmp_eng)),0) + counts_exp[sample]
# save best bit string
if( max_C_exp[1] < tmp_eng):
max_C_exp[0] = sample
max_C_exp[1] = tmp_eng
M1_sampled_exp = avr_C_exp/shots
print('\n --- EXPERIMENTAL RESULTS ---\n')
print('The sampled mean value is M1_sampled = %.02f while the true value is M1 = %.02f \n' % (M1_sampled_exp,np.amax(F1)))
print('The approximate solution is x* = %s with C(x*) = %d \n' % (max_C_exp[0],max_C_exp[1]))
print('The cost function is distributed as: \n')
plot_histogram(hist_exp,figsize = (8,6),bar_labels = False)
colors = ['c' if max_C_exp[0][i] == '0' else 'r' for i in range(n)]
draw_graph(G, colors, pos)
from qiskit import Aer
from qiskit.optimization.applications.ising import max_cut
from qiskit.aqua.algorithms import QAOA as QAOAlib
from qiskit.aqua.components.optimizers import ADAM
from qiskit.aqua import aqua_globals
from qiskit.aqua import QuantumInstance
from qiskit.optimization.applications.ising.common import sample_most_likely
qubitOp, offset = max_cut.get_operator(W)
aqua_globals.random_seed = np.random.default_rng(123)
seed = 10598
backend = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)
adam = ADAM(maxiter=500)
qaoa=QAOAlib(operator=qubitOp,optimizer=adam,p=1,quantum_instance=quantum_instance)
result=qaoa.run(quantum_instance)
# print results
x = sample_most_likely(result.eigenstate)
print('energy:', result.eigenvalue.real)
print('time:', result.optimizer_time)
print('max-cut objective:', result.eigenvalue.real + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, W))
# plot results
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'c' for i in range(n)]
draw_graph(G, colors, pos)
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import transpile
import qiskit.providers.fake_provider
from qiskit_ibm_provider import IBMProvider
from qiskit.transpiler.passes import RemoveBarriers
from qiskit_aer import AerSimulator, Aer
def run_backend(quantum_circuit, backend, *args, **kwargs):
'''Run current circuit on a given backend'''
if quantum_circuit is None:
return None
job = execute(quantum_circuit, backend=backend, *args, **kwargs)
return job
def get_unitary(quantum_circuit, decimals=3, *args, **kwargs):
'''Get unitary matrix of current circuit'''
backend = Aer.get_backend('unitary_simulator')
result = run_backend(quantum_circuit, backend, *args, **kwargs).result()
return result.get_unitary(quantum_circuit, decimals)
def get_state_vector(quantum_circuit, *args, **kwargs):
'''Get state vector of current circuit'''
backend = Aer.get_backend('statevector_simulator')
result = run_backend(quantum_circuit, backend, *args, **kwargs).result()
return result.get_statevector(quantum_circuit)
def run_simulator(quantum_circuit, simulator_backend = None, shots = 1024, *args, **kwargs):
'''Run circuit on a simulation backend.'''
if quantum_circuit is None:
return None
if simulator_backend is None:
simulator_backend = AerSimulator()
result = run_backend(quantum_circuit, simulator_backend, shots = shots, *args, **kwargs).result()
return result
def get_fake_backend_list(min_qubit=None, max_qubit = None):
'''Get a list of the excisting fake backends provided by qiskit.\n
Docs: https://docs.quantum.ibm.com/api/qiskit/providers_fake_provider'''
output = set()
backend_list = dir(qiskit.providers.fake_provider)
i = 0
for backend_name in backend_list:
try:
backend = getattr(qiskit.providers.fake_provider, backend_name)()
num_qubit = len({q for map in backend.coupling_map for q in map})
if min_qubit is None and max_qubit is None:
output.add((backend_name, num_qubit))
elif max_qubit is None:
output.add((backend_name, num_qubit)) if num_qubit >= min_qubit else None
elif min_qubit is None:
output.add((backend_name, num_qubit)) if num_qubit <= max_qubit else None
else:
output.add((backend_name, num_qubit)) if num_qubit >= min_qubit and num_qubit <= max_qubit else None
except:
pass
return list(output)
def get_fake_backend(name):
try:
backend = getattr(qiskit.providers.fake_provider, name)()
return backend
except:
pass
def get_ibm_provider(token, instance="ibm-q/open/main"):
return IBMProvider(instance=instance, token=token)
def get_ibm_backend_list(provider, **kwargs):
'''Get backends list of the IBM provider.\n
Docs: https://qiskit.org/ecosystem/ibm-provider/stubs/qiskit_ibm_provider.IBMProvider.backends.html#qiskit_ibm_provider.IBMProvider.backends'''
return provider.backends(**kwargs)
def get_ibm_backend(provider, backend_name='ibm_lagos'):
'''Choose IBM backend with given backend name'''
try:
backend = provider.get_backend(backend_name, hub=None)
except:
print('Backend name is not in the IBM library')
return backend
def transpile_quantum_circuit(qc, backend_name="Aer", optimization_level=0, initial_layout = None):
backend = get_fake_backend(backend_name)
if backend is None:
backend = AerSimulator()
if initial_layout == 'Full_Range':
initial_layout = list(range(len(qc.qubits)))
removed_barriar_qc = RemoveBarriers()(qc)
transpiled_qc = transpile(circuits=removed_barriar_qc, backend=backend,optimization_level=optimization_level, initial_layout=initial_layout)
return transpiled_qc
def get_transpiled_circuits_of_circuit(qc, backend_name_list:list = ['Aer'], initial_layout_list:list = [None], optimization_level_list:list = [0]):
output_list = []
for backend in backend_name_list:
for layout in initial_layout_list :
for level in optimization_level_list:
output_list.append(transpile_quantum_circuit(qc, backend_name=backend, initial_layout=layout,optimization_level=level))
output_list[-1].name = f"{backend} | {layout} | {level}"
return output_list
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import *
from oracle_generation import generate_oracle
get_bin = lambda x, n: format(x, 'b').zfill(n)
def gen_circuits(min,max,size):
circuits = []
secrets = []
ORACLE_SIZE = size
for i in range(min,max+1):
cur_str = get_bin(i,ORACLE_SIZE-1)
(circuit, secret) = generate_oracle(ORACLE_SIZE,False,3,cur_str)
circuits.append(circuit)
secrets.append(secret)
return (circuits, secrets)
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from Grover.grover_num_list_cirq import find_num, find_num_list
from qiskit.visualization import plot_histogram, plot_coupling_map
from backend_operation import run_simulator, get_transpiled_circuits_of_circuit, get_fake_backend_list,get_unitary, get_fake_backend, get_fake_backend_list
from qiskit import transpile
import qiskit.providers.fake_provider
from qiskit_ibm_provider import IBMProvider
from qiskit.transpiler.passes import RemoveBarriers
from qiskit_aer import AerSimulator, Aer
Aer.get_backend('aer_simulator')
x=AerSimulator()
AerSimulator.available_methods(x)
5
import qiskit_ibm_runtime.fake_provider
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister
from bit_functions import full_bitfield, get_qubit_list
dir(qiskit_ibm_runtime.fake_provider)
backend = qiskit_ibm_runtime.fake_provider.FakeAuckland()
# GenericBackendV2 = Aer ()
backend = qiskit.providers.fake_provider.GenericBackendV2(num_qubits=5)
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(0,2)
circuit.measure_all()
circuit.draw('mpl')
backend.coupling_map.draw()
circuit.data
# Transpile the ideal circuit to a circuit that can be directly executed by the backend
transpiled_circuit = transpile(circuit, backend, optimization_level=0)
transpiled_circuit.draw('mpl')
transpiled_circuit.data
# Run the transpiled circuit using the simulated backend
job = backend.run(transpiled_circuit)
counts = job.result().get_counts()
plot_histogram(counts)
dir(qiskit.providers.fake_provider)
import random
import timeit
import matplotlib.colors as mcolors
from itertools import combinations, permutations
block_diagram = False
qc_size = 4
fake_backed_name = 'FakeAuckland' #random.sample(get_fake_backend_list(min_qubit=len(experiments[0].qubits), max_qubit=len(experiments[0].qubits) + 10),1)[0][0]
num_qubits = 3
num_list = list(range(2**num_qubits))
final_expermient = []
for winner in num_list:
grover_num = find_num()
grover_num.build_iteration([winner],circuit_nqubits=num_qubits, block_diagram=block_diagram)
grover_num.create_grover(solutions = 1, block_diagram=block_diagram)
final_expermient.append(grover_num.measure_qc[0])
transpiled_circuit = [
get_transpiled_circuits_of_circuit(qc, ['Aer', fake_backed_name],
[None] + list(permutations(range(num_qubits))),
optimization_level_list=[0,3])
for qc in final_expermient
]
result_for_circuiut = [
[
run_simulator(qc,shots = 1024 * 4)
for qc in qc_value
]
for qc_value in transpiled_circuit
]
output = []
for value, circuits in enumerate(result_for_circuiut):
for index, run_circuit in enumerate(circuits):
result_dict= run_circuit.to_dict()
cirq_result = result_dict['results'][0]
cirq_counts = cirq_result['data']['counts']
cirq_time = cirq_result['time_taken']
cirq_name = cirq_result['header']['name']
cirq_depth = transpiled_circuit[value][index].depth()
output.append({'value' : value, 'name' : cirq_name, 'time_taken' :cirq_time, 'depth':cirq_depth, 'count':cirq_counts})
data = {
'Value' : [],
'Backend' : [],
'Qubit_Position' : [],
'Optimization_level' : [],
'Depth' : [],
'Time_Taken' : [],
'Counts' : []
}
for cur_data in output:
data['Value'].append(cur_data['value'])
data['Backend'].append(cur_data['name'].split('|')[0].replace(" ",""))
data['Qubit_Position'].append(cur_data['name'].split('|')[1].replace(" ",""))
data['Optimization_level'].append(cur_data['name'].split('|')[2].replace(" ",""))
data['Depth'].append(cur_data['depth'])
data['Time_Taken'].append(cur_data['time_taken'])
data['Counts'].append([cur_data['count'][f'0x{index}'] for index in range(len(cur_data['count']))])
for cur_data in output:
data['Value'].append(cur_data['value']) # Assuming value is stored at index 0 in each sublist
backend, qubit_position, optimization_level = cur_data['name'].split('|')
data['Backend'].append(backend.strip())
data['Qubit_Position'].append(qubit_position.strip())
data['Optimization_level'].append(optimization_level.strip())
data['Depth'].append(cur_data['depth']) # Assuming depth is stored at index 2 in each sublist
data['Time_Taken'].append(cur_data['time_taken']) # Assuming time_taken is stored at index 3 in each sublist
counts = [cur_data['count'][f'0x{index}'] for index in range(len(cur_data['count']))] # Assuming counts is stored at index 4 in each sublist
data['Counts'].append(counts)
import pandas as pd
data = pd.DataFrame(data)
data
output
min_value = 5
max_value = 15
win = random.sample(range(min_value, max_value),1)
print(win)
grover_find_value_win_size = find_num()
grover_find_value_win_size.build_iteration(win, block_diagram=block_diagram)
grover_find_value_win_size.create_grover(block_diagram=block_diagram, solutions=len(list(win)))
experiments = grover_find_value_win_size.measure_qc
experiments[0].draw('mpl')
fake_backed_name = 'FakeAuckland' #random.sample(get_fake_backend_list(min_qubit=len(experiments[0].qubits), max_qubit=len(experiments[0].qubits) + 10),1)[0][0]
get_fake_backend_list()
backend = get_fake_backend('FakeGuadalupeV2')
print(backend.coupling_map)
backend.coupling_map.draw()
transpiled_qc_list = get_transpiled_circuits_of_circuit(experiments[0], ['Aer', fake_backed_name],
[None, 'Full_Range'],
optimization_level_list=[0,3])
plot_histogram({
qc.name : qc.depth()
for qc in transpiled_qc_list
})
transpiled_qc_list[0].draw('mpl')
transpiled_qc_list[1].draw('mpl')
transpiled_qc_list[4].draw('mpl')
transpiled_qc_list[5].draw('mpl')
plot_histogram([run_simulator(qc,shots = 1024 * 4).get_counts() for qc in transpiled_qc_list],
legend=[qc.name for qc in transpiled_qc_list], color=list(random.choices(list(mcolors.get_named_colors_mapping().values()), k = len(transpiled_qc_list))),
title="Result transpilers")
num_list_num = 4
data_arr = list(range(num_list_num))
random.shuffle(data_arr)
win = random.sample(data_arr, 1)
print(f"Data array: {data_arr} , the winner: {win}")
st = timeit.default_timer()
sol = []
for i, val in enumerate(data_arr):
if val in win:
sol.append(i)
end = timeit.default_timer()
print(f"Time: {end - st} , solution : {sol}")
grover_find_value_list = find_num_list()
grover_find_value_list.build_iteration(win, block_diagram=block_diagram, num_array = data_arr)
grover_find_value_list.create_grover(block_diagram=block_diagram, num_solutions=len(list(win)))
experiments = grover_find_value_list.measure_qc
print(experiments)
experiments[0].draw('mpl')
x = find_num_list()
x.build_iteration(winner_list=[5],num_array = [0,5,3], block_diagram=False)
x.create_grover(num_solutions=1,block_diagram=False)
x.measure_qc[0].draw('mpl')
from Grover.transpiler import *
qc = remove_barriar_gate(x.measure_qc[0])
qc.draw('mpl')
qc, did_remove = remove_similiar_adjacent(qc)
qc.draw('mpl')
transpiled_qc_list = get_transpiled_circuits_of_circuit(experiments[0], ['Aer', fake_backed_name],
[None, 'Full_Range'],
optimization_level_list=[0,3])
plot_histogram({
qc.name : qc.depth()
for qc in transpiled_qc_list
})
qc_result = [run_simulator(qc, shots = 1024 * 4) for qc in transpiled_qc_list]
plot_histogram([qc.get_counts() for qc in qc_result],
legend=[qc.name for qc in transpiled_qc_list], color=list(random.choices(list(mcolors.get_named_colors_mapping().values()), k = len(transpiled_qc_list))),
title="Result transpilers")
[{qc.name : result.time_taken} for result, qc in zip(qc_result, transpiled_qc_list)]
for qc in transpiled_qc_list:
print(qc.qubits)
transpiled_qc_list[1].draw('mpl')
transpiled_qc_list[6].draw('mpl')
transpiled_qc_list[1].draw('mpl')
for gate in transpiled_qc_list[1].data:
print(gate)
transpiled_qc_list[5].draw('mpl')
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister
from itertools import combinations
def and_gate(a = 0 , b = 0):
'''Create an AND gate in qiskit\n
The values of "a" and "b" are inisializing the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(2), AncillaRegister(1))
if a:
qc.x(0)
if b:
qc.x(1)
qc.mcx([0,1], qc.ancillas)
return qc
def nand_gate(a = 0 , b = 0):
'''Create an NAND gate in qiskit\n
The values of "a" and "b" are inisializing the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(2), AncillaRegister(1))
if a:
qc.x(0)
if b:
qc.x(1)
qc.mcx([0,1], qc.ancillas)
qc.x(qc.ancillas)
return qc
def mand_gate(nqubits, values = []):
'''Create an AND gate in qiskit with multiple qubits\n
The values in the list are corresponding to the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(nqubits), AncillaRegister(1))
for i, val in enumerate(values):
if val:
qc.x(i)
qc.mcx(list(range(nqubits)), qc.ancillas)
return qc
def xor_gate(a = 0 , b = 0):
'''Create an XOR gate in qiskit\n
The values of "a" and "b" are inisializing the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(2), AncillaRegister(1))
if a:
qc.x(0)
if b:
qc.x(1)
qc.cx(0, qc.ancillas)
qc.cx(1, qc.ancillas)
return qc
def xnor_gate(a = 0 , b = 0):
'''Create an XNOR gate in qiskit\n
The values of "a" and "b" are inisializing the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(2), AncillaRegister(1))
if a:
qc.x(0)
if b:
qc.x(1)
qc.cx(0, qc.ancillas)
qc.cx(1, qc.ancillas)
qc.x(qc.ancillas)
return qc
def mxor_gate(nqubits, values = []):
'''Create an XOR gate in qiskit with multiple qubits\n
The values in the list are corresponding to the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(nqubits), AncillaRegister(1))
for i, val in enumerate(values):
if val:
qc.x(i)
for i in range(nqubits):
qc.cx(i, qc.ancillas)
return qc
def or_gate(a = 0 , b = 0):
'''Create an OR gate in qiskit\n
The values of "a" and "b" are inisializing the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(2), AncillaRegister(1))
if a:
qc.x(0)
if b:
qc.x(1)
qc.cx(0, qc.ancillas)
qc.cx(1, qc.ancillas)
qc.mcx([0,1], qc.ancillas)
return qc
def nor_gate(a = 0 , b = 0):
'''Create an NOR gate in qiskit\n
The values of "a" and "b" are inisializing the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(2), AncillaRegister(1))
if a:
qc.x(0)
if b:
qc.x(1)
qc.cx(0, qc.ancillas)
qc.cx(1, qc.ancillas)
qc.mcx([0,1], qc.ancillas)
qc.x(qc.ancillas)
return qc
def mor_gate(nqubits, values = []):
'''Create an OR gate in qiskit with multiple qubits\n
The values in the list are corresponding to the qubits, the values (0/1)'''
qc = QuantumCircuit(QuantumRegister(nqubits), AncillaRegister(1))
for i, val in enumerate(values):
if val:
qc.x(i)
or_cirq = []
for i in range(1, nqubits + 1):
or_cirq = or_cirq + list(combinations(list(range(nqubits)), i))
for circ in or_cirq:
qc.mcx(list(circ), qc.ancillas)
return qc
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import sys
sys.path.insert(0, "D:/myProjects/AfekaCodeProjects/codeProjects/FinalProject_qiskit/qiskit_algorithm/qft_results.ipynb")
from shor_algorithm.shor_algo_adder_method import qft_dagger, qft, set_start_state
import numpy as np
import matplotlib.pyplot as plt
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_bloch_multivector
import pandas as pd
from qiskit.transpiler.passes import RemoveBarriers
from qiskit.providers.fake_provider import FakeAuckland
n = 4
number = 5
qc = QuantumCircuit(n, n)
set_start_state(qc, number, 0)
qc = qc.compose(qft(n, True), range(n))
qc = qc.compose(qft_dagger(n, True), range(n))
qc.measure(range(n), range(n))
qc.draw('mpl')
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
aer_sim = Aer.get_backend('aer_simulator')
qc_tran_aer = transpile(qc, aer_sim, optimization_level=0)
counts_aer = aer_sim.run(qc_tran_aer).result().get_counts()
plot_histogram(counts_aer)
fake_backend = FakeAuckland()
circ_no_bar = RemoveBarriers()(qc)
tran0 = transpile(circ_no_bar, backend=fake_backend, optimization_level=0)
# tran3 = transpile(circ_no_bar, backend=fake_backend, optimization_level=3)
counts_aer = fake_backend.run(qc_tran_aer).result().get_counts()
plot_histogram(counts_aer)
depth_basic = circ_no_bar.depth()
depth0 = tran0.depth()
depth3 = qc_tran_aer.depth()
plot_histogram({"basic":depth_basic, "level=0":depth0, "aer":depth3})
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import QuantumCircuit as QiskitQuantumCircuit
from qiskit.quantum_info import Operator, Statevector, DensityMatrix, StabilizerState
from qiskit import QuantumCircuit, AncillaRegister, ClassicalRegister, QuantumRegister
class QuantumCircuit(QiskitQuantumCircuit):
def get_unitary_matrix(self, input_dims=None, output_dims=None):
return Operator(self, input_dims, output_dims).data
def get_density_matrix(self, dims: int | tuple | list | None = None):
return DensityMatrix(self, dims)
def get_state_vector(self, dims: int | tuple | list | None = None):
return Statevector(self, dims)
def get_stabilizer_state(self, validate: bool = True):
return StabilizerState(self, validate)
@staticmethod
def from_qiskit_circuit(qiskit_circuit : QiskitQuantumCircuit):
custom_circuit = QuantumCircuit(qiskit_circuit.qubits)
custom_circuit.add_register(qiskit_circuit.clbits)
custom_circuit.data = qiskit_circuit.data.copy() # Copy the operations
custom_circuit.global_phase = qiskit_circuit.global_phase # Copy the global phase
custom_circuit.metadata = qiskit_circuit.metadata # Copy the metadata if any
return custom_circuit
if __name__ == "__main__":
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
for func in [qc.draw, qc.get_unitary_matrix, qc.get_density_matrix, qc.get_stabilizer_state, qc.get_state_vector]:
print(f"### Function : {func.__name__} ###")
print(func())
print()
qc = QiskitQuantumCircuit(5)
print(qc.draw())
qc = QuantumCircuit.from_qiskit_circuit(qc)
print(qc.draw())
# print(qc.draw())
# print(qc.get_unitary_matrix())
# print(qc.get_density_matrix())
# print(qc.get_state_vector())
# print(qc.get_stabilizer_state())
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import *
from qiskit.visualization import plot_histogram
def simon_oracle(b):
n = len(b)
circ = QuantumCircuit(2*n, n)
for i in range(n):
circ.cx(i, i+n)
# for i in range(n):
# if b[n-1-i] == '1':
# for j in range(n):
# if b[j] == '1':
# circ.cx(i, j + n)
# break
for i in range(n):
if b[n-1-i] == '1':
circ.cx(i, i+n)
return circ
b = '1001'
n = len(b)
circ = QuantumCircuit(2*n, n)
circ.h(range(n))
circ.barrier()
circ = circ.compose(simon_oracle(b))
circ.barrier()
circ.h(range(n))
circ.measure(range(n), range(n))
print("the coresponding function should saticfy")
b_dex = int(b, base=2)
for num in range(2**(n-1)):
print(f"f({num}) = f({num ^ b_dex})")
circ.draw('mpl')
sim = Aer.get_backend("qasm_simulator")
result = execute(circ, backend=sim).result()
plot_histogram(result.get_counts())
#find b
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
shots = 1024
for z in result.get_counts().keys():
print( '{} . {} = {} (mod 2) ({:.1f}%)'.format(b, z, bdotz(b,z), result.get_counts()[z]*100/shots))
import random
import timeit
import matplotlib.colors as mcolors
from backend_operation import run_simulator, get_transpiled_circuits_of_circuit, get_fake_backend_list,get_unitary, get_fake_backend, get_fake_backend_list
from itertools import combinations, permutations
fake_backed_name = 'FakeAuckland'
transpiled_circuit = get_transpiled_circuits_of_circuit(circ, ['Aer', fake_backed_name],
[None, "Full_Range"],
optimization_level_list=[0,3])
result_for_circuiut = [
run_simulator(qc,shots = 1024 * 4)
for qc in transpiled_circuit
]
output = []
for index, run_circuit in enumerate(result_for_circuiut):
result_dict= run_circuit.to_dict()
cirq_result = result_dict['results'][0]
cirq_counts = cirq_result['data']['counts']
cirq_time = cirq_result['time_taken']
cirq_name = cirq_result['header']['name']
cirq_depth = transpiled_circuit[index].depth()
output.append({'name' : cirq_name, 'time_taken' :cirq_time, 'depth':cirq_depth, 'count':cirq_counts})
print(output)
import pandas as pd
df = pd.DataFrame(output)
df
plot_histogram([run_simulator(qc,shots = 1024).get_counts() for qc in transpiled_circuit],
legend=[qc.name for qc in transpiled_circuit], color=list(random.choices(list(mcolors.get_named_colors_mapping().values()), k = len(transpiled_circuit))),
title="Result transpilers")
plot_histogram({
qc.name : qc.depth()
for qc in transpiled_circuit
})
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import Aer, IBMQ, execute
from qiskit import transpile, assemble
from qiskit.tools.monitor import job_monitor
from qiskit.tools.monitor import job_monitor
import matplotlib.pyplot as plt
from qiskit.visualization import plot_histogram, plot_state_city
"""
Qiskit backends to execute the quantum circuit
"""
def simulator(qc):
"""
Run on local simulator
:param qc: quantum circuit
:return:
"""
backend = Aer.get_backend("qasm_simulator")
shots = 2048
tqc = transpile(qc, backend)
qobj = assemble(tqc, shots=shots)
job_sim = backend.run(qobj)
qc_results = job_sim.result()
return qc_results, shots
def simulator_state_vector(qc):
"""
Select the StatevectorSimulator from the Aer provider
:param qc: quantum circuit
:return:
statevector
"""
simulator = Aer.get_backend('statevector_simulator')
# Execute and get counts
result = execute(qc, simulator).result()
state_vector = result.get_statevector(qc)
return state_vector
def real_quantum_device(qc):
"""
Use the IBMQ essex device
:param qc: quantum circuit
:return:
"""
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_santiago')
shots = 2048
TQC = transpile(qc, backend)
qobj = assemble(TQC, shots=shots)
job_exp = backend.run(qobj)
job_monitor(job_exp)
QC_results = job_exp.result()
return QC_results, shots
def counts(qc_results):
"""
Get counts representing the wave-function amplitudes
:param qc_results:
:return: dict keys are bit_strings and their counting values
"""
return qc_results.get_counts()
def plot_results(qc_results):
"""
Visualizing wave-function amplitudes in a histogram
:param qc_results: quantum circuit
:return:
"""
plt.show(plot_histogram(qc_results.get_counts(), figsize=(8, 6), bar_labels=False))
def plot_state_vector(state_vector):
"""Visualizing state vector in the density matrix representation"""
plt.show(plot_state_city(state_vector))
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(current_dir)
from quantum_circuit import QuantumCircuit
# import qiskit.providers.fake_provider
from qiskit.transpiler import CouplingMap
import qiskit_ibm_runtime.fake_provider
from Backend.backend import Backend
class FakeBackend(Backend):
def __init__(self, backend_name : str) -> None:
self.backend = FakeBackend.get_ibm_fake_backend(backend_name=backend_name)
@staticmethod
def get_ibm_fake_backend_name_list() -> list[str]:
ibm_dir = dir(qiskit_ibm_runtime.fake_provider)
return [val for val in ibm_dir if '__' not in val and 'Fake' in val]
@staticmethod
def get_ibm_fake_backend(backend_name : str):
try:
return getattr(qiskit_ibm_runtime.fake_provider, backend_name)()
except: pass
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
if backend.name == backend_name:
return backend
except: pass
return None
@staticmethod
def get_ibm_fake_backend_names_with_limit(min_qubit : int = 1, max_qubit: int = float('inf')) -> list[str]:
limited_backend = []
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
num_qubit = backend.num_qubits
if num_qubit >= min_qubit and num_qubit <= max_qubit:
limited_backend.append(backend.name)
except: pass
return limited_backend
if __name__ == "__main__":
print(FakeBackend.get_ibm_fake_backend_name_list())
backend = FakeBackend('fake_auckland')
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
qc.measure_all()
print(qc.draw())
job = backend.run(qc)
print(job.result())
qc_transpile = backend.traspile_qiskit(qc)[0]
print(qc_transpile.draw())
job = backend.run(qc_transpile)
print(job.result())
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(current_dir)
from qiskit import ClassicalRegister
from quantum_circuit import QuantumCircuit
import math
from bit_functions import get_qubit_list
from abc import ABC, abstractmethod
from circuits import cnz, set_value_circuit
class grover_circuit(ABC):
def __init__(self):
self.calculation_qc = None
self.iteration_qc = None
self.circuit = None
self.measure_qc = None
@staticmethod
def oracle(nqubits: int, set_change_value : list=[], mode:str = 'noancilla')->QuantumCircuit:
'''Building an oracle giving the value of the qubits to go into the oracle.\n
Each element of the list is a tuple with the index of the qubit and its value = (index, value)'''
cnz_qc = cnz(nqubits, mode=mode)
value_qc = set_value_circuit(nqubits, set_change_value, rest_hadamard=False)
qc = QuantumCircuit(cnz_qc.qubits)
qubits = get_qubit_list(qc)
qc = qc.compose(value_qc, qubits)
qc.barrier(qc.qubits)
qc = qc.compose(cnz_qc, cnz_qc.qubits)
qc.barrier(qc.qubits)
qc = qc.compose(value_qc, qubits)
qc.name = 'Oracle'
return qc
@staticmethod
def diffuser(nqubits:int, mode : str='noancilla') ->QuantumCircuit:
cnz_cirq = cnz(nqubits, mode)
qc = QuantumCircuit(cnz_cirq.qubits)
qc.h(get_qubit_list(qc))
qc.x(get_qubit_list(qc))
qc.barrier(qc.qubits)
qc = qc.compose(cnz_cirq, cnz_cirq.qubits)
qc.barrier(qc.qubits)
qc.x(get_qubit_list(qc))
qc.h(get_qubit_list(qc))
qc.name = f'Diffuser {nqubits}Q'
return qc
def __prep_qubits(self, nqubits : int, prep_value : list = []) -> tuple[QuantumCircuit, int]:
'''Prepare the qubits value and returns the circuit and the size of the "world", the amount of hadamard gates on the qubits'''
qc = set_value_circuit(nqubits, qubit_value_list=prep_value, rest_hadamard=True)
qc.name = 'Prep Qubit'
return qc, dict(qc.count_ops())['h']
@staticmethod
def calculate_iterations(qubit_world : int, num_solutions : int = 1) -> None:
size_N = pow(2, qubit_world)
if num_solutions is not None and num_solutions:
if size_N < num_solutions * 2:
raise Exception("Grover won't work properly! To many solutions!")
return [math.floor((math.pi * math.sqrt(size_N / num_solutions)) / 4)]
return list(range(1, math.floor((math.pi * math.sqrt(size_N)) / 4) + 1))
def create_grover(self, num_solutions : int = 1, prep_value : list = [], block_diagram : bool = True) -> None:
if self.iteration_qc is None:
raise Exception("Iteration circuit not found!")
qubits = get_qubit_list(self.iteration_qc)
prep_qc, world_qubit_size = self.__prep_qubits(len(qubits), prep_value)
iterations = grover_circuit.calculate_iterations(world_qubit_size, num_solutions)
grover_experiments = []
for i in iterations:
qc = QuantumCircuit(self.iteration_qc.qubits)
if block_diagram:
qc.append(prep_qc, qubits)
[qc.append(self.iteration_qc, qc.qubits) for _ in range(i)]
else:
qc = qc.compose(prep_qc, qubits)
for _ in range(i):
qc = qc.compose(self.iteration_qc, qc.qubits)
qc.name = f"{self.iteration_qc.name} : Iteration {i}"
grover_experiments.append(qc)
self.circuit = grover_experiments
self.__add_qubit_measurement()
def __add_qubit_measurement(self) -> None:
'''
Measure the qubits of the circuits
'''
if self.circuit is None:
raise Exception("Circuit not found!")
self.measure_qc = []
for cur_qc in self.circuit:
qc = cur_qc.copy()
qubits = get_qubit_list(qc)
qc.add_register(ClassicalRegister(len(qubits)))
qc.measure(qubits, qc.clbits)
self.measure_qc.append(qc)
@abstractmethod
def calculation_logic(self):
pass
@abstractmethod
def build_iteration(self):
pass
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(current_dir)
from quantum_circuit import QuantumCircuit
from qiskit import QuantumRegister, AncillaRegister
from bit_functions import full_bitfield, get_qubit_list
from Grover.grover_cirq import grover_circuit
class find_num(grover_circuit):
def __init__(self):
super().__init__()
@staticmethod
def num_oracle(nqubits: int, winner_num : int) -> QuantumCircuit:
bit_list = full_bitfield(winner_num, nqubits)[::-1]
if nqubits < len(bit_list):
raise Exception("The number needs more qubits!")
index_list = [(index, int(not val)) for index, val in enumerate(bit_list)]
qc = grover_circuit.oracle(nqubits, set_change_value=index_list)
qc.name = f"Num_Oracle ({winner_num})"
return qc
@staticmethod
def series_num_oracle(nqubits : int, winner_list :list , block_diagram = True) -> QuantumCircuit:
qc = QuantumCircuit(nqubits)
for num in winner_list:
cur_qc = find_num.num_oracle(nqubits, num)
if block_diagram:
qc.append(cur_qc, qc.qubits)
else:
qc.barrier(qc.qubits)
qc = qc.compose(cur_qc, qc.qubits)
qc.barrier(qc.qubits)
qc.name = f"Oracle {list(winner_list)}"
return qc
def calculation_logic(self) -> QuantumCircuit:
pass
def build_iteration(self, winner_num_list : list | int = [], circuit_nqubits : int = 0, block_diagram=True) -> None:
'''
Build the iteration for the Grover circuit for the winner list
:param circuit_nqubits = The number of qubits in the circuits (Minimum the vnumber needed for max value in the winner list)
'''
if not isinstance(winner_num_list,list):
winner_num_list = [winner_num_list]
if not len(winner_num_list):
raise Exception("Winner list is empty!")
max_winner_qubit_needed = len(full_bitfield(max(winner_num_list)))
circuit_nqubits = max(max_winner_qubit_needed, circuit_nqubits)
qc = find_num.series_num_oracle(circuit_nqubits, winner_num_list, block_diagram)
qubits = get_qubit_list(qc)
diffuser_qc = grover_circuit.diffuser(len(qubits))
qc.add_register(diffuser_qc.ancillas)
if block_diagram:
qc.append(diffuser_qc, qubits + list(diffuser_qc.ancillas))
else:
qc.barrier(qc.qubits)
qc = qc.compose(diffuser_qc, qubits + list(diffuser_qc.ancillas))
qc.barrier(qc.qubits)
qc.name = "Grover_Find_Num_Iteration"
self.iteration_qc = qc
class find_num_list(grover_circuit):
def __init__(self):
super().__init__()
def __index_data_cirq(self, index : int, value : int, index_nqubits : int, value_nqubits : int) -> QuantumCircuit:
'''
Build a circuit to check a specific index and its value\n
For 0, It will use X gates and cx gates for every value
'''
#https://arxiv.org/pdf/1502.04943.pdf
qc = QuantumCircuit(QuantumRegister(index_nqubits, 'index'), AncillaRegister(value_nqubits, 'value'))
index_bit_field = full_bitfield(index, index_nqubits)[::-1]
value_bit_field = full_bitfield(value, value_nqubits)[::-1]
for i in [i for i, _ in enumerate(index_bit_field) if not index_bit_field[i]]:
qc.x(i)
for bit in [i for i, _ in enumerate(value_bit_field) if value_bit_field[i]]:
qc.mcx(list(range(len(index_bit_field))), qc.ancillas[bit])
for i in [i for i, _ in enumerate(index_bit_field) if not index_bit_field[i]]:
qc.x(i)
qc.name = f"[I = {index}, Val = {value}]"
return qc
def calculation_logic(self, num_array : list = [], block_diagram : bool = True) -> None:
'''
Return a Calculation Circuit for the find_num_list Grover circuit.
'''
if num_array is None or not len(num_array):
return
data_qc = QuantumCircuit(
QuantumRegister(len(full_bitfield(len(num_array) - 1)), 'index'),
AncillaRegister(len(full_bitfield(max(num_array))), 'data')
)
value_qubit_length = len(data_qc.ancillas)
index_qubit_length = len(get_qubit_list(data_qc))
for index, data in enumerate(num_array):
if block_diagram:
data_qc.append(self.__index_data_cirq(index, data, index_qubit_length, value_qubit_length), data_qc.qubits)
else:
data_qc.barrier(data_qc.qubits)
data_qc = data_qc.compose(self.__index_data_cirq(index, data, index_qubit_length, value_qubit_length), data_qc.qubits)
data_qc.name = f"Data {num_array}"
self.calculation_qc = data_qc
def build_iteration(self, winner_list = [], num_array : list = [], block_diagram=True, default_value:int = 0):
'''
Build a iteration for the Find_Num_In_List Grover circuit
: param default_value is the default number in winner list, can search for it ONLY when the list is the length of 2 powered by N
'''
if not len(num_array):
raise Exception(f"The number array is empty!")
if not len(winner_list):
raise Exception(f"The winner list is empty!")
if default_value in winner_list and pow(2, (len(num_array) - 1).bit_length()) != len(num_array):
raise Exception(f"The winner list has a value of {default_value} when the number list is not the size of 2 powered by an N")
self.calculation_logic(num_array, block_diagram)
qc = QuantumCircuit(self.calculation_qc.qubits)
if block_diagram:
qc.append(self.calculation_qc, qc.qubits)
oracle = find_num.series_num_oracle(len(qc.ancillas), winner_list, block_diagram)
qc.append(oracle, qc.ancillas)
qc.append(self.calculation_qc.inverse(), qc.qubits)
else:
qc = qc.compose(self.calculation_qc, qc.qubits)
qc.barrier(qc.qubits)
oracle = find_num.series_num_oracle(len(qc.ancillas), winner_list, block_diagram)
qc = qc.compose(oracle, qc.ancillas)
qc.barrier(qc.qubits)
qc = qc.compose(self.calculation_qc.inverse(), qc.qubits)
qubits = get_qubit_list(qc)
diffuser_qc = grover_circuit.diffuser(len(qubits))
qc.add_register(diffuser_qc.ancillas)
if block_diagram:
qc.append(diffuser_qc, qubits + list(diffuser_qc.ancillas))
else:
qc.barrier(qc.qubits)
qc = qc.compose(diffuser_qc, qubits + list(diffuser_qc.ancillas))
qc.barrier(qc.qubits)
qc.name = "Grover_Find_Num_List_Iteration"
self.iteration_qc = qc
if __name__ == "__main__":
x = find_num()
x.build_iteration([5], 4, block_diagram=False)
x.create_grover(num_solutions=1,block_diagram=False)
print(x.measure_qc[0].draw())
x = find_num_list()
x.build_iteration(winner_list=[5],num_array = [2,5,3,1], block_diagram=False)
x.create_grover(num_solutions=1,block_diagram=False)
print(x.measure_qc[0].draw())
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister, ClassicalRegister, Aer, execute
from bit_functions import full_bitfield, get_qubit_list
from Grover.grover_cirq import diffuser, calculate_iteration, prep_qubits_circuit, check_solution_grover, generate_grover_circuits_with_iterations, simulate_grover_qc_list
from circuits import cnz
from logic_gate_circuits import and_gate, or_gate, xor_gate, xnor_gate, nand_gate, nor_gate, mor_gate, mand_gate
from Grover.grover_cirq import diffuser
def check_same_num(num_qubit = None, max_num_value = None):
'''Returns a circuit that sets the last ancilla qubit (Answer) if the numbers are the same'''
if num_qubit is None and max_num_value is None:
return None
if num_qubit is not None:
pass
else:
num_qubit = max_num_value.bit_length()
num_a = QuantumRegister(num_qubit, 'A')
num_b = QuantumRegister(num_qubit, 'B')
xnor_qc = QuantumCircuit(num_a, num_b)
for i in range(num_qubit):
xnor_g = xnor_gate()
xnor_qc.add_register(AncillaRegister(1))
xnor_qc = xnor_qc.compose(xnor_g, [num_a[i], num_b[i], xnor_qc.ancillas[-1]])
qc = QuantumCircuit(xnor_qc.qubits)
qc = qc.compose(xnor_qc, xnor_qc.qubits)
if len(qc.ancillas) > 1:
qc.add_register(AncillaRegister(1))
qc.mcx(xnor_qc.ancillas, qc.ancillas[-1])
qc = qc.compose(xnor_qc.inverse(), xnor_qc.qubits)
qc.name = 'Check_Same_Num'
return qc
#def prep_cnz(nqubits, set_qubit_value = [] ,mode='noancilla'):
# '''Prepare cnz circuit with vgiven values of the qubits\n
# Returns the prepared circuit\n
# set_value_list contains a list of tuples that contains (qubit_index , 0 or 1)'''
#
# x_qubit = [value[0] for value in set_qubit_value if value[1] and value[0] < nqubits]
#
# cnz_qc = cnz(nqubits, mode)
#
# qc = QuantumCircuit(cnz_qc.qubits)
# qc.x(x_qubit) if len(x_qubit) else None
# qc.barrier(qc.qubits)
# qc = qc.compose(cnz_qc, qc.qubits)
# qc.barrier(qc.qubits)
# qc.x(x_qubit) if len(x_qubit) else None
#
# qc.name = f"cnz {nqubits}"
# return qc
def create_sudoko_iteration(max_value = 2):
max_cells = list(range(pow(max_value, 2)))
qubit_num = (max_value - 1).bit_length()
if not qubit_num:
return None
pairs = get_matrix_pairs(max_value)
qubit_list = QuantumRegister(len(max_cells) * qubit_num)
anc_list = AncillaRegister(qubit_num) if qubit_num > 1 else []
answer_anc_list = []
qc_pair = QuantumCircuit(qubit_list, anc_list)
for p in pairs:
check_equal_qc = check_same_num(qubit_num)
answer_anc_list.append(check_equal_qc.ancillas[-1])
qc_pair.add_register([answer_anc_list[-1]])
qubit_connection = list(qubit_list[p[0] * qubit_num : (p[0] + 1) * qubit_num]) + list(qubit_list[p[1] * qubit_num : (p[1] + 1) * qubit_num]) + list(anc_list) + [check_equal_qc.ancillas[-1]]
qc_pair = qc_pair.compose(check_equal_qc, qubit_connection)
qc_pair.barrier(qc_pair.qubits)
qc_z = cnz(len(answer_anc_list), [(i, 0) for i in range(len(answer_anc_list))])
diffuser_qc = diffuser(len(get_qubit_list(qc_pair)))
qc = QuantumCircuit(qc_pair.qubits)
qc = qc.compose(qc_pair, qc_pair.qubits)
qc.barrier(qc.qubits)
qc = qc.compose(qc_z, answer_anc_list)
qc.barrier(qc.qubits)
qc = qc.compose(qc_pair.inverse(), qc_pair.qubits)
qc.barrier(qc.qubits)
qc = qc.compose(diffuser_qc, get_qubit_list(qc))
return qc
def create_sudoko_circuits(max_value = 2, set_qubit_value = []):
qc_iter = create_sudoko_iteration(max_value)
return generate_grover_circuits_with_iterations(qc_iter, set_qubit_value)
def get_matrix_pairs(matrix_size = 4, start_cell = 0):
output = []
if start_cell >= pow(matrix_size, 2):
return output
cur_index = start_cell + 1
while cur_index % matrix_size:
pair = (start_cell, cur_index)
output.append(pair) if pair not in output else None
cur_index = cur_index + 1
cur_index = start_cell + matrix_size
while cur_index < pow(matrix_size, 2):
pair = (start_cell, cur_index)
output.append(pair) if pair not in output else None
cur_index = cur_index + matrix_size
output = output + [i for i in get_matrix_pairs(matrix_size=matrix_size, start_cell= start_cell + 1) if i not in output]
return output
def check_under_nine(nqubits):
'''Returns a circuit that calculates if the value of the qubits are under nine (0 - 8)\n
The answer will be on the final ancilla bit.\n
The ancillas, except the last one (Answer), can be reused'''
nine_bit_size = int(9).bit_length()
additional_qubits = nqubits - nine_bit_size
if additional_qubits < 0:
return None
nand_three = mand_gate(3, [1] * 3)
nand_three.x(nand_three.ancillas[-1])
nand_three.barrier(nand_three.qubits)
nand_fourth = nand_gate()
nine_qubit_qc = QuantumCircuit(nand_three.qubits, nand_fourth.qubits[1:])
nine_qubit_qc = nine_qubit_qc.compose(nand_three, nand_three.qubits)
nine_qubit_qc = nine_qubit_qc.compose(nand_fourth, [nand_three.ancillas[-1]] + list(nand_fourth.qubits[1:]))
if additional_qubits:
add_qubits = QuantumRegister(additional_qubits)
nine_qubit_qc.add_register(add_qubits)
nine_qubit_qc.x(add_qubits)
qc = QuantumCircuit(nine_qubit_qc.qubits, AncillaRegister(1))
qc = qc.compose(nine_qubit_qc, nine_qubit_qc.qubits)
qc.barrier(qc.qubits)
qc.mcx(list(add_qubits) + [nine_qubit_qc.ancillas[-1]], qc.ancillas[-1])
qc.barrier(qc.qubits)
qc = qc.compose(nine_qubit_qc.inverse(), nine_qubit_qc.qubits)
else:
qc = QuantumCircuit(nine_qubit_qc.qubits)
qc = qc.compose(nine_qubit_qc, nine_qubit_qc.qubits)
qc = qc.compose(nand_three.inverse(), nand_three.qubits)
qc.name = "Check_under_nine"
return qc
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import QuantumCircuit, QuantumRegister, AncillaRegister, ClassicalRegister
from bit_functions import full_bitfield, get_qubit_list
from Grover.grover_cirq import grover_circuit
from logic_gate_circuits import xnor_gate
from backend_operation import run_simulator
class sudoko_grover(grover_circuit):
def __init__(self, max_num : int = 4):
super().__init__()
self.max_num = max_num
self.min_num = 1
self.max_num_circuit = None
def same_num_cirq(self):
bit = self.max_num.bit_length()
qubit_A = QuantumRegister(bit, 'A')
qubit_B = QuantumRegister(bit, 'B')
anc = AncillaRegister(bit + 1)
qc = QuantumCircuit(qubit_A, qubit_B, anc)
for i in range(bit):
xnor_qc = xnor_gate()
qc = qc.compose(xnor_qc, [qubit_A[i], qubit_B[i], anc[i]])
inv_qc = qc.inverse()
qc.mcx(anc[:-1], anc[-1])
qc = qc.compose(inv_qc, list(qubit_A) + list(qubit_B) + list(anc))
return qc
def calculation_logic(self):
pass
def build_iteration(self):
pass
if __name__ == "__main__":
x = sudoko_grover()
y=x.same_num_cirq()
print(y.draw())
y.add_register(ClassicalRegister(1))
y.measure(y.qubits[-1],y.clbits[-1])
print(y.draw())
print(run_simulator(y).get_counts())
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(os.path.dirname(os.path.abspath(current_dir)))
from Grover.grover_num_list_cirq import find_num, find_num_list
from Backend.fake_backend import FakeBackend
from Backend.backend import Backend
from Backend.ibm_backend import IBM_backend
from Result.result import ResultData
from qiskit.visualization import plot_histogram, plot_coupling_map
from backend_operation import run_simulator, get_transpiled_circuits_of_circuit, get_fake_backend_list,get_unitary, get_fake_backend, get_fake_backend_list
from qiskit import transpile
import qiskit.providers.fake_provider
from qiskit_ibm_provider import IBMProvider
from qiskit.transpiler.passes import RemoveBarriers
from qiskit_aer import AerSimulator, Aer
from itertools import permutations
# Sample of Find Number Grover Circuit
find_num_in_world_obj = find_num()
find_num_in_world_obj.build_iteration(winner_num_list=[0], circuit_nqubits=3, block_diagram=False)
find_num_in_world_obj.create_grover(num_solutions=1, prep_value=[], block_diagram=False)
cur_experiments = find_num_in_world_obj.measure_qc
print(f"Number of Grover circuits : {len(cur_experiments)}")
cur_experiments[0].draw('mpl')
backend = qiskit.providers.fake_provider.GenericBackendV2(num_qubits=3)
backend.coupling_map.draw()
# Transpile the ideal circuit to a circuit that can be directly executed by the backend
transpiled_circuit = transpile(cur_experiments[0], backend, optimization_level=0)
transpiled_circuit.draw('mpl')
transpiled_circuit = transpile(cur_experiments[0], backend, optimization_level=3)
transpiled_circuit.draw('mpl')
find_num_obj = find_num()
num_qubits = 3
qc_find_num_list = []
for value in range(2**num_qubits):
find_num_obj.build_iteration(winner_num_list=[value], circuit_nqubits=num_qubits, block_diagram=False)
find_num_obj.create_grover(num_solutions=1, prep_value=[], block_diagram=False)
qc_find_num_list.append(find_num_obj.measure_qc[0])
generic_backend = Backend(num_qubits)
backend_names = FakeBackend.get_ibm_fake_backend_names_with_limit(num_qubits)
fake_auckland_backend = FakeBackend.get_ibm_fake_backend('fake_auckland')
print(f"Fake Auckland number of qubits = {fake_auckland_backend.num_qubits}")
fake_backend_name = 'fake_auckland'
fake_backend = FakeBackend(fake_backend_name)
position_layout = permutations(range(fake_backend.get_backend_qubits()), num_qubits)
position_layout = permutations(range(num_qubits), num_qubits)
qc_find_num_list_without_barriar = [RemoveBarriers()(qc) for qc in qc_find_num_list]
# Add the Generic Aer Full Connectivity
qc_transpiled_list = [
generic_backend.transpile_save_param(qc=qc, optimization_level=0, initial_layout=None, seed_transpiler=None, input_search = index)
for index, qc in enumerate(qc_find_num_list_without_barriar)
]
qc_transpiled_list = qc_transpiled_list + [
generic_backend.transpile_save_param(qc=qc, optimization_level=3, initial_layout=None, seed_transpiler=None, input_search = index)
for index, qc in enumerate(qc_find_num_list_without_barriar)
]
position_layout = list(position_layout)
# Add the fake backend
for layout in [None] + position_layout:
qc_transpiled_list = qc_transpiled_list + [
fake_backend.transpile_save_param(qc=qc, optimization_level=0, initial_layout=layout, seed_transpiler=None, input_search = index)
for index, qc in enumerate(qc_find_num_list_without_barriar)
]
qc_transpiled_list = qc_transpiled_list + [
fake_backend.transpile_save_param(qc=qc, optimization_level=3, initial_layout=layout, seed_transpiler=None, input_search = index)
for index, qc in enumerate(qc_find_num_list_without_barriar)
]
# Sample that we entered an input value to the result parameters to save
qc_transpiled_list[60].backend_name
qc_res = [
qc_param.backend.run(qc_param.transpiled_qc,shots=1024)
for qc_param in qc_transpiled_list
]
len(qc_res)
result = ResultData(qc_res[60])
result.job
result.to_dict()
result.to_dict().keys()
result.get_result_time_taken(0)
result.to_dict()['time_taken']
result.to_dict()['results'][0].keys()
result.to_dict()['results'][0]['time_taken']
result.get_counts()
result.get_data()
result.to_dict().keys()
result.to_dict()['results'][0].keys()
result.to_dict()['results'][0]['time_taken']
result.to_dict()['results'][0]['header']
result.to_dict()['results'][0]['data']
result.to_dict()['results'][0]['metadata']
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=too-many-function-args, unexpected-keyword-arg
"""THIS FILE IS DEPRECATED AND WILL BE REMOVED IN RELEASE 0.9.
"""
import warnings
from qiskit.converters import dag_to_circuit, circuit_to_dag
from qiskit.transpiler import CouplingMap
from qiskit import compiler
from qiskit.transpiler.preset_passmanagers import (default_pass_manager_simulator,
default_pass_manager)
def transpile(circuits, backend=None, basis_gates=None, coupling_map=None,
initial_layout=None, seed_mapper=None, pass_manager=None):
"""transpile one or more circuits.
Args:
circuits (QuantumCircuit or list[QuantumCircuit]): circuits to compile
backend (BaseBackend): a backend to compile for
basis_gates (list[str]): list of basis gate names supported by the
target. Default: ['u1','u2','u3','cx','id']
coupling_map (list): coupling map (perhaps custom) to target in mapping
initial_layout (Layout or dict or list):
Initial position of virtual qubits on physical qubits. The final
layout is not guaranteed to be the same, as the transpiler may permute
qubits through swaps or other means.
seed_mapper (int): random seed for the swap_mapper
pass_manager (PassManager): a pass_manager for the transpiler stages
Returns:
QuantumCircuit or list[QuantumCircuit]: transpiled circuit(s).
Raises:
TranspilerError: in case of bad inputs to transpiler or errors in passes
"""
warnings.warn("qiskit.transpiler.transpile() has been deprecated and will be "
"removed in the 0.9 release. Use qiskit.compiler.transpile() instead.",
DeprecationWarning)
return compiler.transpile(circuits=circuits, backend=backend,
basis_gates=basis_gates, coupling_map=coupling_map,
initial_layout=initial_layout, seed_transpiler=seed_mapper,
pass_manager=pass_manager)
def transpile_dag(dag, basis_gates=None, coupling_map=None,
initial_layout=None, seed_mapper=None, pass_manager=None):
"""Deprecated - Use qiskit.compiler.transpile for transpiling from
circuits to circuits.
Transform a dag circuit into another dag circuit
(transpile), through consecutive passes on the dag.
Args:
dag (DAGCircuit): dag circuit to transform via transpilation
basis_gates (list[str]): list of basis gate names supported by the
target. Default: ['u1','u2','u3','cx','id']
coupling_map (list): A graph of coupling::
[
[control0(int), target0(int)],
[control1(int), target1(int)],
]
eg. [[0, 2], [1, 2], [1, 3], [3, 4]}
initial_layout (Layout or None): A layout object
seed_mapper (int): random seed_mapper for the swap mapper
pass_manager (PassManager): pass manager instance for the transpilation process
If None, a default set of passes are run.
Otherwise, the passes defined in it will run.
If contains no passes in it, no dag transformations occur.
Returns:
DAGCircuit: transformed dag
"""
warnings.warn("transpile_dag has been deprecated and will be removed in the "
"0.9 release. Circuits can be transpiled directly to other "
"circuits with the transpile function.", DeprecationWarning)
if basis_gates is None:
basis_gates = ['u1', 'u2', 'u3', 'cx', 'id']
if pass_manager is None:
# default set of passes
# if a coupling map is given compile to the map
if coupling_map:
pass_manager = default_pass_manager(basis_gates,
CouplingMap(coupling_map),
initial_layout,
seed_transpiler=seed_mapper)
else:
pass_manager = default_pass_manager_simulator(basis_gates)
# run the passes specified by the pass manager
# TODO return the property set too. See #1086
name = dag.name
circuit = dag_to_circuit(dag)
circuit = pass_manager.run(circuit)
dag = circuit_to_dag(circuit)
dag.name = name
return dag
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import numpy as np
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, AncillaRegister, Aer, transpile
from qiskit.tools.visualization import plot_histogram
from qiskit.circuit.gate import Gate
import sys
sys.path.insert(0, "D:/myProjects/AfekaCodeProjects/codeProjects/FinalProject_qiskit/qiskit_algorithm")
import bit_functions
def condition_phase_shift(k):
qc = QuantumCircuit(2) #control qbit and qbit to oparate on
angle = np.pi / (2**(k-1))
qc.cp(angle, 0, 1)
qc.name = str(k)
return qc
qc = QuantumCircuit(3)
def set_start_state(qc, number, start_qubit):
bin_num = bin(number)
for i in range(1, len(bin_num)+1):
if bin_num[-i] == '1':
qc.x(i+start_qubit-1)
def adder(n, kind = "fixed"): #n is the number of qubits requer for one number
qc = QuantumCircuit(QuantumRegister(n), AncillaRegister(n + (1 if kind == "half" else 0) ))
for j in range(n):
for k in range(j, n):
power = k - j + 1
angle = 2*np.pi / (2**power)
qc.cp(angle, j, n+k, label=str(power))
if kind == "half":
for i in range(n):
angle = 2*np.pi / (2**(i+2))
qc.cp(angle, n-1-i, 2*n)
qc.name = f"ADD_{n}"
return qc
def subtracter(n):
qc = adder(n, "half").inverse()
qc.name = f"SUB_{n}"
return qc
def adder_classic_a(n, a, kind = "fixed"): #n is the number of qubits require for one number
qc = QuantumCircuit(QuantumRegister(n + (1 if kind == "half" else 0)))
bit_field_a = bit_functions.full_bitfield(a, n)
for j in range(n):
if bit_field_a[n-1-j] == 1:
for k in range(j, n):
power = k - j + 1
angle = 2*np.pi / (2**power) # k starts from 0 but in the article in start from 1
qc.p(angle, k)
if kind == "half":
for i in range(n):
if bit_field_a[n-1-i] == 1:
angle = 2*np.pi / (2**(n-i+1))
qc.p(angle, n)
qc = qc.to_gate()
qc.name = f"ɸ ADD_{a}"
return qc
def subtracter_classic_a(n, a):
qc = adder_classic_a(n, a, "half").inverse()
qc.name = f"ɸ SUB_{a}"
return qc
def qft(n, swap = True):
"""n-qubit QFT the first n qubits in circ"""
qc = QuantumCircuit(n)
for j in range(n-1, -1, -1):
qc.h(j)
for m in range(j-1, -1, -1):
qc.cp(np.pi/float(2**(j-m)), j, m, label=f"{j-m+1}")
# Don't forget the Swaps!
if swap:
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
qc = qc.to_gate()
qc.name = "QFT"
return qc
def qft_dagger(n, swap = True):
"""n-qubit QFTdagger the first n qubits in circ"""
qc = QuantumCircuit(n)
# Don't forget the Swaps!
if swap:
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
qc = qc.to_gate()
qc.name = "QFT†"
return qc
def add_mod_n(a, N):
n = bit_functions.bit_length(N)
qr = QuantumRegister(n+3)
ar = AncillaRegister(1)
qc = QuantumCircuit(qr, ar)
qc.append(adder_classic_a(n, a, "half").control(2), [0, 1] + list(range(2, n+3)))
qc.append(subtracter_classic_a(n, N), range(2, n+3))
qc.append(qft_dagger(n+1, False), range(2, n+3))
qc.cx(n+2, n+3)
qc.append(qft(n+1, False), range(2, n+3))
qc.append(adder_classic_a(n, N, "half").control(1), [n+3] + list(range(2, n+3)))
qc.append(subtracter_classic_a(n, a).control(2), [0, 1] + list(range(2, n+3)))
qc.append(qft_dagger(n+1, False), range(2, n+3))
qc.x(n+2)
qc.cx(n+2, n+3)
qc.x(n+2)
qc.append(qft(n+1, False), range(2, n+3))
qc.append(adder_classic_a(n, a, "half").control(2), [0, 1] + list(range(2, n+3)))
qc = qc.to_gate()
qc.name = f"ɸ ADD_{a}_mod_{N}"
return qc
def c_mult_a_mod_n(a, N):
n = bit_functions.bit_length(N)
qr = QuantumRegister(2*n+4)
qc = QuantumCircuit(qr)
qc.append(qft(n+1, False), range(n+2, 2*n+3))
for i in range(n):
number = (a * 2**i)%N
qc.append(add_mod_n(number, N), [0, i+1] + list(range(n+2, 2*n+4)))
qc.append(qft_dagger(n+1, False), range(n+2, 2*n+3))
qc.name = f"CMULT({a}) mod {N}"
return qc
def inverse_c_mult_a_mod_n(a, N):
qc = c_mult_a_mod_n(a, N).inverse()
qc.name = f"CMULT({a}) mod {N}†"
return qc
def U(N, a, power):
a_pow = a**power
n = bit_functions.bit_length(N)
qc = QuantumCircuit(2*n + 4)
qc.append(c_mult_a_mod_n(a_pow, N), range(2*n + 4))
for i in range(1, n+2):
qc.cswap(0, i, i+n+1, label=f'{i} to {i+n}')
if np.gcd(a_pow, N) != 1:
raise ArithmeticError(f"inverse of {a}^{power} mod {N} doesn't exists")
i_a = pow(a_pow, -1, N)
qc.append(inverse_c_mult_a_mod_n(i_a, N), range(2*n+4))
qc.name = f"U{a}^{power} mod {N}"
return qc
def shor_circiut(N, a):
"""Creates the Shor's circuit and returns it
Args:
N (int): The number we want to factor
a (int): A guess number to base the circuit on. The gdc between N and a must be 1
Returns:
QuantumCircuit: circuit of Shor's algorithm
"""
n = bit_functions.bit_length(N)
qc = QuantumCircuit(4*n+3, 2*n)
qc.h(range(2*n))
qc.x(2*n)
for i in range(2*n):
qc.append(U(N,a,2**i), [i] + list(range(2*n, 4*n+3)))
qc.append(qft_dagger(2*n, True), range(2*n))
qc.measure(range(2*n), range(2*n))
return qc
if __name__ == "__main__":
qc = shor_circiut(15,4)
print(qc.draw())
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import numpy as np
import math
from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_bloch_multivector
from shor_algo_adder_method import *
from qiskit.circuit.library import DraperQFTAdder, QFT
n = 8
q = QuantumRegister(n, 'q')
c = ClassicalRegister(math.ceil(n/2), 'c')
thiers = QuantumCircuit(q, c)
main = QuantumCircuit(q, c)
a = 15
b = 12
set_start_state(thiers, a, 0)
set_start_state(thiers, b, n//2)
set_start_state(main, a, 0)
set_start_state(main, b, n//2)
main.append(qft(math.ceil(n/2), False), range(n//2, n))
main = main.compose(adder(n//2, kind="fixed"), qubits=range(n))
# main.append(adder(n//2, kind="fixed"), range(n))
main.append(qft_dagger(math.ceil(n/2), False), range(n//2, n))
thiers = thiers.compose(DraperQFTAdder(n//2, kind="fixed").decompose(), range(n))
# thiers.append(DraperQFTAdder(n//2, kind="fixed"), range(n))
thiers.measure(range(n//2, n), range(math.ceil(n/2)))
main.measure(range(n//2, n), range(math.ceil(n/2)))
thiers.draw("mpl")
b = 12
a = 15
n = 4
q = QuantumRegister(n, 'q')
c = ClassicalRegister(n, 'c')
classic_a = QuantumCircuit(q, c)
set_start_state(classic_a, b, 0)
classic_a.append(qft(n, False), range(n))
classic_a = classic_a.compose(adder_classic_a(n, a, kind="fixed"), range(n))
classic_a.append(qft_dagger(n, False), range(n))
classic_a.measure(range(n), range(n))
classic_a.draw('mpl')
main.draw('mpl')
sim = Aer.get_backend("aer_simulator")
qc_init = ft.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
aer_sim = Aer.get_backend('aer_simulator')
t_thiers = transpile(thiers, aer_sim)
t_main = transpile(main, aer_sim)
t_classic = transpile(classic_a, aer_sim)
counts_thiers = aer_sim.run(t_thiers).result().get_counts()
count_main = aer_sim.run(t_main).result().get_counts()
count_cls = aer_sim.run(t_classic).result().get_counts()
plot_histogram([count_main, counts_thiers, count_cls], legend=["main", "thiers", "cls"])
n = 5
q = QuantumRegister(n, 'q')
c = ClassicalRegister(math.ceil(n/2), 'c')
subtract = QuantumCircuit(q, c)
q = QuantumRegister(math.ceil(n/2), 'q')
c = ClassicalRegister(math.ceil(n/2), 'c')
subtract2 = QuantumCircuit(q, c)
a = 1
b = 3
set_start_state(subtract, a, 0)
set_start_state(subtract, b, n//2)
set_start_state(subtract2, b, 0)
subtract.append(qft(math.ceil(n/2), False), range(n//2, n))
# main = main.compose(adder(n//2, kind="half"), qubits=range(n))
# subtract = subtract.compose(adder(n//2, kind="half").inverse(), range(n))
subtract.append(subtracter(n//2), range(n))
subtract.append(qft_dagger(math.ceil(n/2), False), range(n//2, n))
subtract2.append(qft(math.ceil(n/2), False), range(math.ceil(n/2)))
# main = main.compose(adder(n//2, kind="half"), qubits=range(n))
# subtract = subtract.compose(adder(n//2, kind="half").inverse(), range(n))
subtract2.append(subtracter_classic_a(n//2, a), range(math.ceil(n/2)))
subtract2.append(qft_dagger(math.ceil(n/2), False), range(math.ceil(n/2)))
# thiers = thiers.compose(DraperQFTAdder(n//2, kind="half").decompose(), range(n))
subtract.measure(range(n//2, n), range(math.ceil(n/2)))
subtract2.measure(range(math.ceil(n/2)), range(math.ceil(n/2)))
subtract.draw("mpl")
subtract2.draw("mpl")
aer_sim = Aer.get_backend('aer_simulator')
t_subtract = transpile(subtract, aer_sim)
t_subtract2 = transpile(subtract2, aer_sim)
counts_subtract = aer_sim.run(t_subtract).result().get_counts()
counts_subtract2 = aer_sim.run(t_subtract2).result().get_counts()
plot_histogram([counts_subtract, counts_subtract2], legend=["draper", "a inside"])
n = 4
N = 11
a = 2
b = 0
x = 6
a_mod_n = QuantumCircuit(2*n + 4, n+1)
a_mod_n.x(0)
set_start_state(a_mod_n, x, 1)
set_start_state(a_mod_n, b, n+2)
# a_mod_n = a_mod_n.compose(add_mod_n(a, N), range(n+3))
a_mod_n = a_mod_n.compose(U(a, N).decompose(), range(2*n + 4))
a_mod_n.measure(range(1, n+2), range(n+1))
a_mod_n.draw('mpl', fold=-1)
aer_sim = Aer.get_backend('aer_simulator')
t_subtract = transpile(a_mod_n, aer_sim)
counts_subtract = aer_sim.run(t_subtract).result().get_counts()
plot_histogram(counts_subtract)
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import numpy as np
import matplotlib.pyplot as plt
# from qiskit import BasicAer, execute
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, Aer, transpile
from qiskit.tools.visualization import plot_histogram
import pandas as pd
from fractions import Fraction
from shor_algo_adder_method import shor_circiut
import bit_functions
N = 15
a = 13
N_COUNT = 2*bit_functions.bit_length(N)
qc = shor_circiut(N, a)
qc.draw('mpl', fold = -1)
aer_sim = Aer.get_backend('aer_simulator')
t_qc = transpile(qc, aer_sim)
# counts = execute(t_qc, aer_sim).result().get_counts()
counts = aer_sim.run(t_qc).result().get_counts()
plot_histogram(counts)
rows, measured_phases = [], []
for output in counts:
decimal = int(output, 2) # Convert (base 2) string to decimal
phase = decimal/(2**N_COUNT) # Find corresponding eigenvalue
measured_phases.append(phase)
# Add these values to the rows in our table:
rows.append([f"{output}(bin) = {decimal:>3}(dec)",
f"{decimal}/{2**N_COUNT} = {phase:.2f}"])
# Print the rows in a table
headers=["Register Output", "Phase"]
df = pd.DataFrame(rows, columns=headers)
print(df)
rows = []
for phase in measured_phases:
frac = Fraction(phase).limit_denominator(15)
rows.append([phase,
f"{frac.numerator}/{frac.denominator}",
frac.denominator])
# Print as a table
headers=["Phase", "Fraction", "Guess for r"]
df = pd.DataFrame(rows, columns=headers)
print(df)
guesses = {x[2] for x in rows if x[2] != 1}
for curr_gess in guesses:
if curr_gess % 2 == 0:
num1 = int(a**(curr_gess/2)+1)
num2 = int(a**(curr_gess/2)-1)
q = np.gcd(num1, N)
p = np.gcd(num2, N)
print(f"for r = {curr_gess} factors are: {p}, {q}")
|
https://github.com/MetalKyubit/Quantum-Algorithms-in-Qiskit
|
MetalKyubit
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import *
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta
from qiskit.providers.fake_provider import FakeNairobi
#defining a function to create the BV Algorithm circuit. Function takes in the oracle and number of qubits and
# ouputs the quantum circuit
def BV_algo(oracle,n):
# n input qubits and 1 helper qubit
qc = QuantumCircuit(n+1,n)
# helper qubit initialised to state ket_1
qc.x(n)
# creating superposition of all the inputs. and making the state of the helper qubit as ket_minus.
for i in range(n+1):
qc.h(i)
qc.barrier()
# applying the oracle that has the funciton encoded in it to the circuit
qc.append(oracle, range(n+1))
qc.barrier()
#applying the hadamard gates again to collapse the superposition to one state that has the final result
#encoded in it.
for i in range(n):
qc.h(i)
# measuring the input qubits to find the final result.
qc.measure(range(n),range(n))
return (qc)
def bv_oracle(n:int, s:str):
_circuit_oracle = QuantumCircuit(n+1)
#reverse the bit string because qiskit uses inverse endianness
s = s[::-1]
for _bit_position in range(n):
if(s[_bit_position] == '1'):
# phase flippping the helper qubit (as it is in ket_minus state x will phase flip it)
# flipping phase
_circuit_oracle.cx(_bit_position, n)
else:
_circuit_oracle.i(_bit_position)
_gate_oracle = _circuit_oracle.to_gate()
s = s[::-1]
_gate_oracle.name = "Oracle\n s: "+str(s)
return _gate_oracle
# Testing the algorithm for n=3 and a='101')
n = 3
oracle = bv_oracle(n, '101')
q1 = BV_algo(oracle, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Testing the algorithm for n=3 and a='101')
n = 5
oracle = bv_oracle(n, '10101')
q1 = BV_algo(oracle, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
|
https://github.com/MetalKyubit/Quantum-Algorithms-in-Qiskit
|
MetalKyubit
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import *
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta
from qiskit.providers.fake_provider import FakeNairobi
#defining a function to create the DJ Algorithm circuit. Function takes in the oracle and number or qubits and
# ouputs the circuit
def DJ_algo(oracle,n):
# n input qubits and 1 helper qubit
qc = QuantumCircuit(n+1,n)
# helper qubit initialised to state ket_1
qc.x(n)
# creating superposition of all the inputs. and making the state of the helper qubit as ket_minus.
for i in range(n+1):
qc.h(i)
qc.barrier()
# applying the oracle that has the funciton encoded in it to the circuit
qc.append(oracle, range(n+1))
qc.barrier()
#applying the hadamard gates again to collapse the superposition to one state that has the final result
#encoded in it.
for i in range(n):
qc.h(i)
# measuring the input qubits to find the final result.
qc.measure(range(n),range(n))
return (qc)
# The oracle is defined below
def dj_oracle(n:int, type:str):
#define a quantum circuit with n input qubits and 1 helper qubits
qc = QuantumCircuit(n+1)
#create an oracle based on whether balanced or constant function
if(type == 'balanced'):
#balanced oracle flips helper when the 0th qubit is 1 half the inputs will have 0th qubit 1 rest
# half will have 0th qubit 0.
qc.cx(0,n)
else:
#apply identity on the n+1 bit
qc.i(n)
#convert to gate
_gate_oracle = qc.to_gate()
if (type == 'balanced'):
_gate_oracle.name = "oracle_balanced"
else:
_gate_oracle.name = "oracle_constant"
# return the gate
return _gate_oracle
# Testing the algorithm for n=3 and constant function
n = 2
oracle = dj_oracle(n, 'constant')
q1 = DJ_algo(oracle, n)
q1.draw('mpl')
backend = Aer.get_backend('aer_simulator')
transpiled =transpile(q1, backend)
job= execute(transpiled, backend)
results= job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Testing the algorithm for n=3 and constant function
n = 6
oracle = dj_oracle(n, 'balanced')
q1 = DJ_algo(oracle, n)
q1.draw('mpl')
backend = Aer.get_backend('aer_simulator')
transpiled =transpile(q1, backend)
job= execute(transpiled, backend)
results= job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
|
https://github.com/MetalKyubit/Quantum-Algorithms-in-Qiskit
|
MetalKyubit
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import *
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta
from qiskit.providers.fake_provider import FakeNairobi
#defining a function to create the Grovers Algorithm circuit. Function takes in the oracle and number or qubits
# and ouputs the circuit
def Grover_function(oracle,n):
# n input qubits
qc = QuantumCircuit(n,n)
# creating superposition of all the inputs
for i in range(n):
qc.h(i)
qc.barrier()
# Grovers function is implemented for m times as it is basically a rotation function applied for m times.
# m calculated by finding approximately the angle of the total superposition with the "B" set and the number
#of times the superposition has to be rotated by twice of that angle to reach the "A" state.
m=int(np.round(np.pi*np.sqrt(2**n)/4 - 0.5))
for i in range(m):
# applying the oracle that has the funciton encoded in it to the circuit
qc.append(oracle, range(n))
qc.barrier()
# applying the second set of hadamard gates
for i in range(n):
qc.h(i)
# implementing the Z_0 gate (all x followed by one hadamard followed by mcx
#followed by hadamard followed by all x)
for i in range(n):
qc.x(i)
qc.h(0)
qubit=[]
for i in range(n-1):
qubit.append(i+1)
qc.mcx(qubit, 0)
qc.h(0)
for i in range(n):
qc.x(i)
#applying the hadamard gates again to collapse the superposition to one state that has the final result
#encoded in it.
for i in range(n):
qc.h(i)
# measuring the input qubits to find the final result.
qc.measure(range(n),range(n))
return (qc)
# Function for generating a general grover's oracle (Zf) for n qubits and
# inp: input string such that f(inp) = 1
def Grover_oracle(n, inp):
cir = QuantumCircuit(n)
# Applying X gate where ever the string is zero to convert the whole string to n 1's and then applying
# controlled z gate to phase flip the particular state
for i in range(n):
if inp[i]=='0':
cir.x(n-i-1)
# Multiple controlled Z gate using MCX
cir.h(0)
cir.mcx([i for i in range(1,n)], 0)
cir.h(0)
# Applying X gates to reverse the effect of above applied X gates
for i in range(len(inp)):
if inp[i]=='0':
cir.x(n-i-1)
return cir
# Testing the algorithm for n=3 and f('101') = 1
n = 3
oracle = Grover_oracle(n, '101')
oracle.draw('mpl')
q1 = Grover_function(oracle, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Testing the algorithm
n = 5
oracle = Grover_oracle(n, '10101')
oracle.draw('mpl')
q1 = Grover_function(oracle, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
|
https://github.com/MetalKyubit/Quantum-Algorithms-in-Qiskit
|
MetalKyubit
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import *
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
from qiskit.providers.fake_provider import FakeJakarta
from qiskit.providers.fake_provider import FakeNairobi
#defining a function to create the Simon's Algorithm circuit. Function takes in the oracle and number of qubits
# and ouputs the quantum circuit
def Simons_algo(oracle,n):
# n input qubits and n helper qubit
qc = QuantumCircuit(2*n,n)
# creating superposition of all the inputs
for i in range(n):
qc.h(i)
qc.barrier()
# applying the oracle that has the funciton and the secret string encoded in it to the circuit
qc.append(oracle, range(2*n))
qc.barrier()
#applying the hadamard gates again to collapse the superposition to one state that has the final result
#encoded in it.
for i in range(n):
qc.h(i)
# measuring the input qubits to find the final result.
qc.measure(range(n),range(n))
return (qc)
a = '10'
n = len(a)
ora = simon_oracle(a)
ora.draw('mpl')
q1 = Simons_algo(ora, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend, shots=1024)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
a = '101'
n = len(a)
ora = simon_oracle(a)
ora.draw('mpl')
q1 = Simons_algo(ora, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend, shots=1024)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
|
https://github.com/soccertes123/QiskitGroverDinnerParty
|
soccertes123
|
from qiskit import BasicAer
from qiskit.aqua.algorithms import Grover
from qiskit.aqua.components.oracles import LogicalExpressionOracle
from qiskit.tools.visualization import plot_histogram
log_expr = '[(Olivia & Abe) | (Jin & Amira)] & -(Abe & Amira)'
algorithm = Grover(LogicalExpressionOracle(log_expr))
backend = BasicAer.get_backend('qasm_simulator')
result = algorithm.run(backend)
plot_histogram(result['measurement'], title='Possible Party Combinations', bar_labels=True)
|
https://github.com/soccertes123/QiskitGroverDinnerParty
|
soccertes123
|
#initialization
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, assemble, transpile
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.providers.ibmq import least_busy
# import basic plot tools
from qiskit.visualization import plot_histogram
# general diffuser copied from https://qiskit.org/textbook/ch-algorithms/grover.html#2qubits-simulation
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
return qc
# THIS IS THE MAIN IMPORTANT PART OF THE IMPLEMENTATION
# we made lots of stubs for unimportant but time-consuming functions
# After putting around 10-15 hours in to the project, we realized it would take way too much time to hammer in every
# single function.
def oracle(nqubits, expressions):
# iterate over expressions and define circuit
qc = QuantumCircuit(nqubits + len(expressions))
x_reset_target_indices = [] # list of target qubits which have x gates that need to be reversed
for i, exp in enumerate(expressions):
# if OR: apply X gates
if (exp[0] == "OR"):
for variable in exp[1:]:
qubit_index = int(variable[1]) # each variable is in format xi where i is the qubit index
qc.x(qubit_index)
# apply multi qubit toffoli
control_indices = []
x_reset_input_indices = [] # indices to be reset if we apply x gates
for variable in exp[1:]:
if (variable[0] == "x"):
qubit_index = int(variable[1])
control_indices.append(qubit_index)
else:
# variable[0] = "e" -> the qubit index is the target qubit from the prior expression ei
qubit_index = nqubits + int(variable[1]) # this references the target qubit after evaluating expression ei
control_indices.append(qubit_index)
if (variable[len(variable-1)] == "~"):
qc.x(qubit_index)
x_reset_indices.append(qubit_index)
target_index = nqubits + i
qc = multi_qubit_toffoli(qc, control_indices, target_index)
for index in x_reset_input_indices:
# reset the inputs if we applied x gates
qc.x(index)
# if OR: apply X gate on target qubit for logic and X gates on control qubits to reset input
if (exp[0] == "OR"):
qc.x(target_index)
x_reset_target_indices.append(i) # append to this list so that we can reset the circuit at end of oracle
for variable in exp[1:]:
qubit_index = int(variable[1])
qc.x(qubit_index)
for index in x_reset_target_indices:
# reset the rest of the circuit
qc.x(index)
return qc
def multi_qubit_toffoli(qc, control_indices, target_index):
# perform the multi qubit toffoli gate on the quantum circuit and return the circuit
return qc
def init(nqubits):
qc = QuantumCircuit(nqubits)
for i in range(nqubits):
qc.h(i)
return qc
def parse_exp(exp):
# returns something like [e1=["OR", "x0", "x1~"], e2=["AND", "e1", "x2"], e3=[...], ...]
# where each expression ei is connected by a series of ANDs
# make sure that any negations get distributed
# We will write our expressions as ei=["AND", "x0", "x1~"] so that the last character is "~" if the variable has negation
li = []
return li
def check_solution(boolean_list, expression):
# boolean list would represent the variables in the expression by index
return false
expression = "((x0 & x1) & (x1 & ~x2) & x3)"
nqubits = 2
circuit = init(nqubits)
oracle_qc = oracle(nqubits, expression)
diffuser_qc = diffuser(nqubits)
# now join the circuits together
solved = false
boolean_list
while (solved):
# add oracle and diffuser on our circuit
circuit = circuit + oracle_qc + diffuser_qc
# measure result
results = circuit.measure_all().counts()
boolean_list = results
# check solution with expression
solved = checks_solution(boolean_list, expression)
print(boolean_list)
|
https://github.com/soccertes123/QiskitGroverDinnerParty
|
soccertes123
|
#initialization
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, assemble, transpile
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.providers.ibmq import least_busy
# import basic plot tools
from qiskit.visualization import plot_histogram
# general diffuser copied from https://qiskit.org/textbook/ch-algorithms/grover.html#2qubits-simulation
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
return qc
# THIS IS THE MAIN IMPORTANT PART OF THE IMPLEMENTATION
# we made lots of stubs for unimportant but time-consuming functions
# After putting around 10-15 hours in to the project, we realized it would take way too much time to hammer in every
# single function.
def oracle(nqubits, expressions):
# iterate over expressions and define circuit
qc = QuantumCircuit(nqubits + len(expressions))
x_reset_target_indices = [] # list of target qubits which have x gates that need to be reversed
for i, exp in enumerate(expressions):
# if OR: apply X gates
if (exp[0] == "OR"):
for variable in exp[1:]:
qubit_index = int(variable[1]) # each variable is in format xi where i is the qubit index
qc.x(qubit_index)
# apply multi qubit toffoli
control_indices = []
x_reset_input_indices = [] # indices to be reset if we apply x gates
for variable in exp[1:]:
if (variable[0] == "x"):
qubit_index = int(variable[1])
control_indices.append(qubit_index)
else:
# variable[0] = "e" -> the qubit index is the target qubit from the prior expression ei
qubit_index = nqubits + int(variable[1]) # this references the target qubit after evaluating expression ei
control_indices.append(qubit_index)
if (variable[len(variable-1)] == "~"):
qc.x(qubit_index)
x_reset_indices.append(qubit_index)
target_index = nqubits + i
qc = multi_qubit_toffoli(qc, control_indices, target_index)
for index in x_reset_input_indices:
# reset the inputs if we applied x gates
qc.x(index)
# if OR: apply X gate on target qubit for logic and X gates on control qubits to reset input
if (exp[0] == "OR"):
qc.x(target_index)
x_reset_target_indices.append(i) # append to this list so that we can reset the circuit at end of oracle
for variable in exp[1:]:
qubit_index = int(variable[1])
qc.x(qubit_index)
for index in x_reset_target_indices:
# reset the rest of the circuit
qc.x(index)
return qc
def multi_qubit_toffoli(qc, control_indices, target_index):
# perform the multi qubit toffoli gate on the quantum circuit and return the circuit
return qc
def init(nqubits):
qc = QuantumCircuit(nqubits)
for i in range(nqubits):
qc.h(i)
return qc
def parse_exp(exp):
# returns something like [e1=["OR", "x0", "x1~"], e2=["AND", "e1", "x2"], e3=[...], ...]
# where each expression ei is connected by a series of ANDs
# make sure that any negations get distributed
# We will write our expressions as ei=["AND", "x0", "x1~"] so that the last character is "~" if the variable has negation
li = []
return li
def check_solution(boolean_list, expression):
# boolean list would represent the variables in the expression by index
return false
expression = "((x0 & x1) & (x1 & ~x2) & x3)"
nqubits = 2
circuit = init(nqubits)
oracle_qc = oracle(nqubits, expression)
diffuser_qc = diffuser(nqubits)
# now join the circuits together
solved = false
boolean_list
while (solved):
# add oracle and diffuser on our circuit
circuit = circuit + oracle_qc + diffuser_qc
# measure result
results = circuit.measure_all().counts()
boolean_list = results
# check solution with expression
solved = checks_solution(boolean_list, expression)
print(boolean_list)
|
https://github.com/mousepad01/qiskit_POCs
|
mousepad01
|
import numpy as np
import random
from copy import deepcopy
import matplotlib.pyplot as plt
from qiskit import *
from qiskit.visualization import plot_state_city, plot_histogram
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import random_statevector
from qiskit.quantum_info.operators import Operator
from qiskit.circuit.library import XGate
backend_statevector = Aer.get_backend('statevector_simulator')
backend_sim = Aer.get_backend('qasm_simulator')
with open('t.txt', "r") as token_f:
TOKEN = token_f.read()
# ===========================
# convert "endianess" of qubit order
def qiskit_tensor_conversion(t: np.array, n: int):
def _conv(x: int):
x_ = 0
for i in range(n):
x_ |= ((x >> i) & 0x01) << (n - i - 1)
return x_
if type(t) == list:
t = np.array(t)
t_ = deepcopy(t)
for i in range(t.shape[0]):
for j in range(t.shape[1]):
t_[i][j] = t[_conv(i)][_conv(j)]
return t_
# simulation for state vector
def get_statevector(circuit: QuantumCircuit):
return backend_statevector.run(circuit).result().get_statevector(circuit, decimals=2)
def plot_statevector(circuit: QuantumCircuit):
plot_state_city(get_statevector(circuit))
# simulation for measurement outputs
def simulate_runs(circuit: QuantumCircuit, runs: int = 1024):
return backend_sim.run(transpile(circuit, backend_sim), shots=runs).result().get_counts()
def plot_simulated_runs(circuit: QuantumCircuit, runs: int = 1024):
plot_histogram(simulate_runs(circuit, runs))
# real run on IBM 5 qubit quantum computers (measurement outputs)
def real_runs(circuit: QuantumCircuit, runs: int = 1024):
IBMQ.enable_account(TOKEN)
provider = IBMQ.get_provider(hub='ibm-q')
backend_q = least_busy(provider.backends(filters = lambda x: x.configuration().n_qubits == 5
and not x.configuration().simulator
and x.status().operational == True))
return backend_q.run(transpile(circuit, backend_q, optimization_level=3), shots=runs).result().get_counts()
def plot_runs(circuit: QuantumCircuit, runs: int = 1024):
plot_histogram(real_runs(circuit, runs))
# ===========================
def example():
c = QuantumCircuit(3, 3)
c.h(0)
c.cx(0, 1)
c.cx(1, 2)
mes = QuantumCircuit(3, 3)
mes.measure(range(3), range(3))
cmes = c.compose(mes)
plot_statevector(c)
plot_simulated_runs(cmes)
plt.show()
def superdense_coding_v0(a, b):
a = [0, 1] if a == 1 else [1, 0]
b = [0, 1] if b == 1 else [1, 0]
qc_init = QuantumCircuit(4, 2)
qc_alicebob = QuantumCircuit(4, 2)
qc_init.h(2)
qc_init.cx(2, 3)
qc_init.initialize(a, 0)
qc_init.initialize(b, 1)
qc_alicebob.cx(1, 2)
qc_alicebob.cz(0, 2)
qc_alicebob.cx(2, 3)
qc_alicebob.h(2)
qc_alicebob.measure(2, 0)
qc_alicebob.measure(3, 1)
superdense_coding_qc = qc_init.compose(qc_alicebob)
#superdense_coding_qc.draw('mpl')
plot_simulated_runs(superdense_coding_qc)
plt.show()
def superdense_coding(a, b):
def _init_bell_pair():
bell_state = QuantumCircuit(2)
bell_state.h(0)
bell_state.cx(0, 1)
return bell_state
def _encode(qc, qubit, b0, b1):
if b0 not in [0, 1] or b1 not in [0, 1]:
raise RuntimeError(f'invalid bytes {b0} {b1}')
if b0 == 1:
qc.x(qubit)
if b1 == 1:
qc.z(qubit)
return qc
def _decode(qc):
qc.cx(0, 1)
qc.h(0)
qc.measure_all()
return qc
bell_pair = _init_bell_pair()
bell_pair = _encode(bell_pair, 0, a, b)
bell_pair = _decode(bell_pair)
plot_simulated_runs(bell_pair)
bell_pair.draw('mpl')
plt.show()
def superdense_coding_real(a, b):
def _init_bell_pair():
bell_state = QuantumCircuit(2)
bell_state.h(0)
bell_state.cx(0, 1)
return bell_state
def _encode(qc, qubit, b0, b1):
if b0 not in [0, 1] or b1 not in [0, 1]:
raise RuntimeError(f'invalid bytes {b0} {b1}')
if b0 == 1:
qc.x(qubit)
if b1 == 1:
qc.z(qubit)
return qc
def _decode(qc):
qc.cx(0, 1)
qc.h(0)
qc.measure_all()
return qc
bell_pair = _init_bell_pair()
bell_pair = _encode(bell_pair, 0, a, b)
bell_pair = _decode(bell_pair)
plot_runs(bell_pair)
bell_pair.draw('mpl')
plt.show()
def quantum_teleportation(p0, p1):
qc = QuantumRegister(3)
a, b, psi_measured = ClassicalRegister(1), ClassicalRegister(1), ClassicalRegister(1)
qc_teleportation = QuantumCircuit(qc, a, b, psi_measured)
def _init_psi():
qc_teleportation.initialize([p0, p1], 0)
def _init_bell_state():
qc_teleportation.h(1)
qc_teleportation.cx(1, 2)
qc_teleportation.barrier()
def _entangle_psi():
qc_teleportation.cx(0, 1)
qc_teleportation.h(0)
qc_teleportation.barrier()
def _measure():
qc_teleportation.measure(0, a)
qc_teleportation.measure(1, b)
qc_teleportation.barrier()
def _apply_xz():
qc_teleportation.x(2).c_if(b, 1)
qc_teleportation.z(2).c_if(a, 1)
qc_teleportation.barrier()
def _measure_psi():
qc_teleportation.measure(2, psi_measured)
_init_psi()
_init_bell_state()
_entangle_psi()
_measure()
_apply_xz()
_measure_psi()
qc_teleportation.draw('mpl')
psi_cnts = {'0': 0, '1': 0}
cnts = simulate_runs(qc_teleportation)
for state, fr in cnts.items():
psi_cnts[state[0]] += fr
plot_histogram(psi_cnts)
plt.show()
def equiv_test():
def _test(a, b, c, d):
q0_init_state = random_statevector(2)
q1_init_state = random_statevector(2)
qc_fst = QuantumCircuit(2)
qc_fst.initialize(q0_init_state, 0)
qc_fst.initialize(q1_init_state, 0)
qc_fst.cx(0, 1)
if a == 1:
qc_fst.x(0)
if b == 1:
qc_fst.z(0)
if c == 1:
qc_fst.x(1)
if d == 1:
qc_fst.z(1)
qc_fst.cx(0, 1)
qc_fst.barrier()
qc_fst.measure_all()
qc_snd = QuantumCircuit(2)
qc_snd.initialize(q0_init_state, 0)
qc_snd.initialize(q1_init_state, 0)
a_ = a
d_ = d
c_ = (1 - a) * c + a * (1 - c)
b_ = (1 - d) * b + d * (1 - b)
if a_ == 1:
qc_snd.x(0)
if b_ == 1:
qc_snd.z(0)
if c_ == 1:
qc_snd.x(1)
if d_ == 1:
qc_snd.z(1)
qc_snd.barrier()
qc_snd.measure_all()
plot_simulated_runs(qc_fst)
plot_simulated_runs(qc_snd)
plt.show()
for a in [0, 1]:
for b in [0, 1]:
for c in [0, 1]:
for d in [0, 1]:
_test(a, b, c, d)
def deutsch_josza():
'''
n = 4
uses random generated functions that are either constant or balanced
'''
# build the Uf operator
n = 4
ct = random.randint(0, 1)
Uf = [[0 for _ in range(1 << (n + 1))] for _ in range(1 << (n + 1))]
if random.randint(0, 1) == 1:
constant = True
for x in range(1 << (n + 1)):
Uf[x][x] = 1
else:
constant = False
f = {x: (ct if x < (1 << (n - 1)) else 1 - ct) for x in range(1 << n)}
for x in range((1 << n) - 1):
x_ = random.randint(x + 1, (1 << n) - 1)
aux = f[x]
f[x] = f[x_]
f[x_] = aux
#print(f)
cnt_ = 0
for x in range(1 << n):
if f[x] == 1:
cnt_ += 1
assert(cnt_ == (1 << (n - 1)))
for x in range(1 << (n + 1)):
Uf[x ^ f[x >> 1]][x] = 1
print(f'function is constant? {constant}')
#print(Uf)
#q_uf = Operator(Uf)
#print(q_uf)
Uf = qiskit_tensor_conversion(Uf, n + 1)
#print(Uf)
q_uf = Operator(Uf)
#print(q_uf)
qc = QuantumCircuit(n + 1, n)
for x in range(n):
qc.initialize([1, 0], x)
qc.h(x)
qc.initialize([0, 1], n)
qc.h(n)
qc.append(q_uf, [x for x in range(n + 1)])
for x in range(n):
qc.h(x)
qc.measure(x, x)
qc.draw('mpl')
plot_simulated_runs(qc, runs=128)
#print(get_statevector(qc))
plt.show()
def simon_alg():
'''
n = 4
probabilistic version (ends after n + 3 runs)
it only checks for orthogonality of the returned values wrt s
'''
# build the Uf operator
n = 4
s = random.randint(1, (1 << n) - 1)
f_values = [x for x in range(1 << n)]
f = {x: None for x in range(1 << n)}
for x in range(1 << n):
if f[x] is None:
f[x] = random.choice(f_values)
f[x ^ s] = f[x]
f_values.remove(f[x])
print(f"secret {s}, f {f}")
Uf = [[0 for _ in range(1 << (n * 2))] for _ in range(1 << (n * 2))]
for k in range(1 << (n * 2)):
Uf[k ^ f[k >> n]][k] = 1
Uf = qiskit_tensor_conversion(Uf, n * 2)
q_uf = Operator(Uf)
qc = QuantumCircuit(n * 2, n * 2)
for x in range(n * 2):
qc.initialize([1, 0], x)
for x in range(n):
qc.h(x)
qc.append(q_uf, [x for x in range(n * 2)])
# sanity check
v = get_statevector(qc).to_dict()
for k, _ in v.items():
x, fx = k[n: 2 * n], k[:n]
x, fx = int(x[::-1], 2), int(fx[::-1], 2)
assert(fx == f[x])
# --------
for x in range(n, n * 2):
qc.measure(x, x)
#v = get_statevector(qc).to_dict()
#print(v)
for x in range(n):
qc.h(x)
qc.measure(x, x)
qc.draw('mpl')
for _ in range(n + 3):
for res in simulate_runs(qc, runs = 1).keys():
w = res[n: 2 * n]
w = int(w[::-1], 2)
break
# solving the system manually
# here just checking for s * w = 0
dot_prod = s & w
s_ = 0
while dot_prod > 0:
s_ ^= dot_prod & 0x01
dot_prod >>= 1
assert(s_ == 0)
plot_simulated_runs(qc, runs=128)
#print(get_statevector(qc))
plt.show()
def grover_alg():
'''
n = 4\n
generates random f: {0, 1}^n -> {0, 1} with exactly one x s.t. f(x) = 1
'''
n = 4
def _init_uniform_superposition():
# also adds ancilla qubit initialized to |->
unif = QuantumCircuit(n + 1)
unif.initialize([0, 1], n)
unif.h([qb for qb in range(n + 1)])
return unif
def _get_random_Uf():
x_1 = random.randint(0, (1 << n) - 1)
f = {x: 0 for x in range(1 << n)}
f[x_1] = 1
print(f"f({x_1}) = 1")
Uf = [[0 for _ in range(1 << (n + 1))] for _ in range(1 << (n + 1))]
for k in range(1 << (n + 1)):
Uf[k ^ f[k >> 1]][k] = 1
Uf = qiskit_tensor_conversion(Uf, n + 1)
q_uf = Operator(Uf)
return q_uf
def _get_U0():
U0 = [[0 for _ in range(1 << n)] for _ in range(1 << n)]
for k in range(1 << n):
U0[k][k] = -1
U0[0][0] = 1
U0 = qiskit_tensor_conversion(U0, n)
q_u0 = Operator(U0)
return q_u0
def _get_grover_iterate(q_uf, q_u0):
g = QuantumCircuit(n + 1)
g.append(q_uf, [qb for qb in range(n + 1)])
g.h([qb for qb in range(n)])
g.append(q_u0, [qb for qb in range(n)])
g.h([qb for qb in range(n)])
return g
def _measure_output(qc: QuantumCircuit):
qc.add_register(ClassicalRegister(n))
for qb in range(n):
qc.measure(qb, qb)
plot_simulated_runs(qc)
qc = _init_uniform_superposition()
q_uf = _get_random_Uf()
q_u0 = _get_U0()
for _ in range(int(np.floor(np.sqrt(n)))):
qc.append(_get_grover_iterate(q_uf, q_u0), [qb for qb in range(n + 1)])
#qc.draw('mpl')
_measure_output(qc)
plt.show()
def start():
#example()
#superdense_coding_real(1, 1)
#quantum_teleportation(np.sqrt(3) / 2, 0.5)
#equiv_test()
#deutsch_josza()
#simon_alg()
grover_alg()
return
if __name__ == "__main__":
start()
|
https://github.com/WerWojtas/Quantum_algorithms
|
WerWojtas
|
from qiskit.circuit.library import PhaseOracle
from qiskit import QuantumCircuit
from qiskit.circuit.library import GroverOperator
from qiskit import Aer, transpile
sat_problem = [
[1],
[4,5,6],
[7],
[-3,-6],
[-2,4,-5]]
def save_to_dimacs(file_path, clauses,number_of_bits,number_of_clauses):
with open(file_path, 'w') as file:
file.write("p cnf " + str(number_of_bits) + " " + str(number_of_clauses) + "\n")
for clause in clauses:
file.write(" ".join(map(str, clause)) + " 0\n")
save_to_dimacs("formula.dimacs", sat_problem,7,len(sat_problem)
def Grovers_algorithm(number_of_qubits):
oracle = PhaseOracle.from_dimacs_file('formula.dimacs')
circuit = QuantumCircuit(number_of_qubits)
for i in range(number_of_qubits):
circuit.h(i)
grover = GroverOperator(oracle)
qc = circuit.compose(grover_operator)
qc.measure_all()
sim = Aer.get_backend('aer_simulator')
transpile_qc = transpile(qc, sim)
sim.run(transpile_qc).result().get_counts()
Grovers_algorithm(7)
|
https://github.com/Fabiha-Noshin/Quantum-Algorithms-with-Qiskit
|
Fabiha-Noshin
|
# Importing necessary libraries:
import qiskit as q
from random import getrandbits
%matplotlib inline
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Defining the constant and balanced oracle:
def constant_oraclen(n, x, qc):
if x == '0':
pass
elif x == '1':
for i in range(int(n)):
qc.x(i+1)
def balanced_oraclen(n, x, qc):
if x == '0':
for i in range(int(n)):
qc.cx(i, int(n))
elif x == '1':
for i in range(int(n)):
qc.x(i)
qc.cx(i, int(n))
# Testing oracles:
qc= QuantumCircuit(3,1)
constant_oraclen(2, '1', qc)
qc.draw()
def random_oraclen(n, qc): # Selectiong type of oracle
if str(getrandbits(1)) == '0':
constant_oraclen(n, str(getrandbits(1)), qc)
elif str(getrandbits(1)) == '1':
balanced_oraclen(n, str(getrandbits(1)), qc)
def make_circuitn(n): # Constructiong function to produce n qubit circuit
qc= QuantumCircuit(int(n+1),1) # with required oracle (constant/balanced)
for i in range(int(n+1)):
if i > 0:
qc.x(i)
for i in range(int(n+1)):
qc.h(i)
qc.barrier()
random_oraclen(n, qc)
qc.barrier()
for i in range(int(n+1)):
qc.h(i)
qc.measure(0,0)
return qc
# An example of 5 qubit circuit:
q1= QuantumCircuit()
q1= make_circuitn(5)
q1.draw('mpl')
# Running in qasm simulator:
backend= Aer.get_backend('qasm_simulator')
job= execute(q1, backend, shots= 3000)
results= job.result()
counts= results.get_counts()
graph= plot_histogram(counts)
display(graph)
print(counts)
|
https://github.com/Fabiha-Noshin/Quantum-Algorithms-with-Qiskit
|
Fabiha-Noshin
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ, execute, assemble
from qiskit.providers.ibmq import least_busy
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
## Creating function for Equal Superposition states of two qubits:
def initialize(qc):
qc.h(0) # Applying H gates to both qubits
qc.h(1) # and initializing grover circuit
qc.barrier()
grover_circuit = QuantumCircuit(2)
initialize(grover_circuit)
grover_circuit.draw('mpl')
# Let's try to find the position of |11>:
def oracle_11(qc): # Apply a controlled Z gate
qc.cz(0,1)
qc.barrier()
oracle_11(grover_circuit)
grover_circuit.draw('mpl')
# Creating Grover's Diffusion operator:
def u_g(qc):
qc.h(0)
qc.h(1)
qc.x(0)
qc.x(1)
qc.h(1)
qc.cx(0,1)
qc.x(0)
qc.h(1)
qc.h(0)
qc.x(1)
qc.h(1)
qc.barrier()
u_g(grover_circuit) # temporary circuit just to see what U_s looks like
grover_circuit.draw('mpl')
# Finally we measure the circuit:
grover_circuit.measure_all()
grover_circuit.draw('mpl')
# Simulating the Circuit:
backend = Aer.get_backend('qasm_simulator')
job = execute(grover_circuit, backend, shots = 1024)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
# Experimenting with real device:
IBMQ.load_account()
# Getting the least busy backend
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 2
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
# Running the circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_grover_circuit = transpile(grover_circuit, backend, optimization_level=3)
qobj = assemble(transpiled_grover_circuit)
job = backend.run(qobj)
job_monitor(job, interval=2)
# Getting the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
|
https://github.com/Fabiha-Noshin/Quantum-Algorithms-with-Qiskit
|
Fabiha-Noshin
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ, QuantumRegister
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
from qiskit.aqua.algorithms import Grover
from qiskit.aqua import QuantumInstance
from qiskit.quantum_info.operators import Operator
required_state = ['00100'] # The state that I want to find
# Creating oracle for 5 qubits and according to required state
oracle_matrix = np.array([[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,-1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1]])
controls = QuantumRegister(5)
oracle = QuantumCircuit(controls)
oracle_circuit = Operator(oracle_matrix)
oracle.unitary(oracle_circuit, [0,1,2,3,4], label='oracle')
oracle.draw('mpl')
# Applying the required oracle to the grover circuit:
grover_circuit = Grover(oracle=oracle, good_state=required_state)
grover_circuit.grover_operator.draw('mpl')
# Running the whole circuit in a similator:
simulator = Aer.get_backend('qasm_simulator')
result = grover_circuit.run(quantum_instance=simulator)
print('Result type: ',type(result))
print('Success!' if result.oracle_evaluation else 'Failure!')
print('Top measurement: ', result.top_measurement)
# Running the whole circuit in a real quantum device:
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
shots = 256
# Load local account information
IBMQ.load_account()
# Get the least busy backend
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 5
and not x.configuration().simulator
and x.status().operational==True))
print("least busy backend: ", backend)
result = grover_circuit.run(quantum_instance=backend, shots=8000)
print('Result type: ',type(result))
print('Success!' if result.oracle_evaluation else 'Failure!')
print('Top measurement: ', result.top_measurement)
|
https://github.com/rainmaker29/QuantumComputing-qiskit
|
rainmaker29
|
import qiskit as q
%matplotlib inline
# Creating a quantum circuit with 3 qbits
circuit = q.QuantumCircuit(2,2)
#Adding a NOT gate to 0th qbit which flips the input
circuit.x(0)
#Adding a 'Controlled NOT' gate between 0th,1st qbits
#CNOT Gate operation : The second bit is flipped if the first bit is 1
circuit.cx(0,1)
#Mapping the value of qbit to classical bits (collapse)
circuit.measure([0,1],[0,1])
circuit.draw()
circuit.draw(output="mpl")
from qiskit import IBMQ
IBMQ.save_account("e870e2997e01a21385263381f81495beff826d71a12d646658a7a15ffc5400dbbefa30e9ce0d2e65b872b30170038db21cdf8482e422510d62ef16297ad5c8a2")
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider("ibm-q")
# In QC practice,a simulator or a quantum computer is referred to as 'backend'
for backend in provider.backends():
try:
qubit_count = len(backend.properties().qubits)
except :
qubit_count = "simulated"
print(backend.name(),"has",backend.status().pending_jobs," queued and ",qubit_count,"qubits")
from qiskit.tools.monitor import job_monitor
backend = provider.get_backend("ibmqx2") #Since it has0 queued
job = q.execute(circuit,backend=backend,shots=500)
job_monitor(job)
# Now our circuit has been successfully run on IBM Cloud's IBMQX2 machine
from qiskit.visualization import plot_histogram
result = job.result()
counts = result.get_counts(circuit)
plot_histogram([counts],legend=['Device'])
circuit = q.QuantumCircuit(2,2)
# Hadamard gate to the first qbit
circuit.h(0)
# The same good old CNOT gate
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
circuit.draw(output="mpl")
# Let's execute this circuit
# This cell isn't much needed yet we'll use it as a revision cell
for backend in provider.backends():
try:
qubit_count = len(backend.properties().qubits)
except:
qubit_count = "simulated"
print(backend.name(),"has ",backend.status().pending_jobs,"queued and",qubit_count,"qubits")
# let's choose ibmqx2
backend = provider.get_backend("ibmqx2")
job = q.execute(circuit,backend = backend,shots=500)
job_monitor(job) # Gives the status of our job
result = job.result()
counts = result.get_counts(circuit)
plot_histogram([counts],legend=['Device '])
from qiskit import Aer
for backend in Aer.backends():
print(backend)
#Let's use qasm_simulator
sim_backend = Aer.get_backend('qasm_simulator')
job = q.execute(circuit,backend=sim_backend,shots=500)
job_monitor(job)
result = job.result()
counts = result.get_counts(circuit)
plot_histogram([counts],legend=['Device'])
import qiskit as q
from qiskit.tools.visualization import plot_bloch_multivector
%matplotlib inline
statevec_simulator = q.Aer.get_backend("statevector_simulator")
qasm_sim = q.Aer.get_backend('qasm_simulator')
def do_job(circuit):
job = q.execute(circuit,backend=statevec_simulator)
result = job.result()
statevec = result.get_statevector()
n_qubits = circuit.n_qubits
circuit.measure([i for i in range(n_qubits)],[i for i in range(n_qubits)])
qasm_job = q.execute(circuit,backend=qasm_sim,shots=1024).result()
counts = qasm_job.get_counts()
return statevec,counts
circuit = q.QuantumCircuit(2,2)
statevec,counts=do_job(circuit)
plot_bloch_multivector(statevec)
# Let's see how superposition looks like in bloch sphere
circuit = q.QuantumCircuit(2,2)
circuit.h(0)
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
# The qubit 0 is under superposition . So, it lies between 1 and 0 states in the space
#Let's entangle the qubits
circuit = q.QuantumCircuit(2,2)
circuit.h(0)
circuit.cx(0,1)
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
from qiskit.visualization import plot_histogram
plot_histogram([counts],legend=['Device'])
#Let's take 3 qubits and control the last qubit by the first two qubits
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.cx(0,2)
circuit.cx(1,2)
circuit.draw(output="mpl")
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
plot_histogram([counts],legend=['Device'])
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.draw(output="mpl")
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
plot_histogram([counts],legend=['Device'])
circuit = q.QuantumCircuit(3,1)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.measure([2],[0])
result = q.execute(circuit,backend=qasm_sim,shots=1024).result()
counts = result.get_counts()
plot_histogram([counts],legend=['Device'])
import math
circuit = q.QuantumCircuit(3,1)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.rx(math.pi/2,2)
circuit.draw(output="mpl")
circuit.measure([2],[0])
result = q.execute(circuit,backend=qasm_sim,shots=1024).result()
counts = result.get_counts()
plot_histogram([counts],legend=['output'])
#Rotate X by 45 deg
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.rx(math.pi/4,2)
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
plot_histogram([counts],legend=['output'])
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.rx(math.pi/4, 2)
circuit.rz(math.pi, 2)
circuit.ry(math.pi, 2)
statevec, counts = do_job(circuit)
plot_bloch_multivector(statevec)
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.x(2)
circuit.crz(math.pi,1,2)
circuit.draw(output="mpl")
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
|
https://github.com/rainmaker29/QuantumComputing-qiskit
|
rainmaker29
|
import qiskit as q
%matplotlib inline
# Creating a quantum circuit with 3 qbits
circuit = q.QuantumCircuit(2,2)
#Adding a NOT gate to 0th qbit which flips the input
circuit.x(0)
#Adding a 'Controlled NOT' gate between 0th,1st qbits
#CNOT Gate operation : The second bit is flipped if the first bit is 1
circuit.cx(0,1)
#Mapping the value of qbit to classical bits (collapse)
circuit.measure([0,1],[0,1])
circuit.draw()
circuit.draw(output="mpl")
from qiskit import IBMQ
IBMQ.save_account("e870e2997e01a21385263381f81495beff826d71a12d646658a7a15ffc5400dbbefa30e9ce0d2e65b872b30170038db21cdf8482e422510d62ef16297ad5c8a2")
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider("ibm-q")
# In QC practice,a simulator or a quantum computer is referred to as 'backend'
for backend in provider.backends():
try:
qubit_count = len(backend.properties().qubits)
except :
qubit_count = "simulated"
print(backend.name(),"has",backend.status().pending_jobs," queued and ",qubit_count,"qubits")
from qiskit.tools.monitor import job_monitor
backend = provider.get_backend("ibmqx2") #Since it has0 queued
job = q.execute(circuit,backend=backend,shots=500)
job_monitor(job)
# Now our circuit has been successfully run on IBM Cloud's IBMQX2 machine
from qiskit.visualization import plot_histogram
result = job.result()
counts = result.get_counts(circuit)
plot_histogram([counts],legend=['Device'])
circuit = q.QuantumCircuit(2,2)
# Hadamard gate to the first qbit
circuit.h(0)
# The same good old CNOT gate
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
circuit.draw(output="mpl")
# Let's execute this circuit
# This cell isn't much needed yet we'll use it as a revision cell
for backend in provider.backends():
try:
qubit_count = len(backend.properties().qubits)
except:
qubit_count = "simulated"
print(backend.name(),"has ",backend.status().pending_jobs,"queued and",qubit_count,"qubits")
# let's choose ibmqx2
backend = provider.get_backend("ibmqx2")
job = q.execute(circuit,backend = backend,shots=500)
job_monitor(job) # Gives the status of our job
result = job.result()
counts = result.get_counts(circuit)
plot_histogram([counts],legend=['Device '])
from qiskit import Aer
for backend in Aer.backends():
print(backend)
#Let's use qasm_simulator
sim_backend = Aer.get_backend('qasm_simulator')
job = q.execute(circuit,backend=sim_backend,shots=500)
job_monitor(job)
result = job.result()
counts = result.get_counts(circuit)
plot_histogram([counts],legend=['Device'])
import qiskit as q
from qiskit.tools.visualization import plot_bloch_multivector
%matplotlib inline
statevec_simulator = q.Aer.get_backend("statevector_simulator")
qasm_sim = q.Aer.get_backend('qasm_simulator')
def do_job(circuit):
job = q.execute(circuit,backend=statevec_simulator)
result = job.result()
statevec = result.get_statevector()
n_qubits = circuit.n_qubits
circuit.measure([i for i in range(n_qubits)],[i for i in range(n_qubits)])
qasm_job = q.execute(circuit,backend=qasm_sim,shots=1024).result()
counts = qasm_job.get_counts()
return statevec,counts
circuit = q.QuantumCircuit(2,2)
statevec,counts=do_job(circuit)
plot_bloch_multivector(statevec)
# Let's see how superposition looks like in bloch sphere
circuit = q.QuantumCircuit(2,2)
circuit.h(0)
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
# The qubit 0 is under superposition . So, it lies between 1 and 0 states in the space
#Let's entangle the qubits
circuit = q.QuantumCircuit(2,2)
circuit.h(0)
circuit.cx(0,1)
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
from qiskit.visualization import plot_histogram
plot_histogram([counts],legend=['Device'])
#Let's take 3 qubits and control the last qubit by the first two qubits
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.cx(0,2)
circuit.cx(1,2)
circuit.draw(output="mpl")
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
plot_histogram([counts],legend=['Device'])
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.draw(output="mpl")
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
plot_histogram([counts],legend=['Device'])
circuit = q.QuantumCircuit(3,1)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.measure([2],[0])
result = q.execute(circuit,backend=qasm_sim,shots=1024).result()
counts = result.get_counts()
plot_histogram([counts],legend=['Device'])
import math
circuit = q.QuantumCircuit(3,1)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.rx(math.pi/2,2)
circuit.draw(output="mpl")
circuit.measure([2],[0])
result = q.execute(circuit,backend=qasm_sim,shots=1024).result()
counts = result.get_counts()
plot_histogram([counts],legend=['output'])
#Rotate X by 45 deg
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.rx(math.pi/4,2)
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
plot_histogram([counts],legend=['output'])
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.ccx(0,1,2)
circuit.rx(math.pi/4, 2)
circuit.rz(math.pi, 2)
circuit.ry(math.pi, 2)
statevec, counts = do_job(circuit)
plot_bloch_multivector(statevec)
circuit = q.QuantumCircuit(3,3)
circuit.h(0)
circuit.h(1)
circuit.x(2)
circuit.crz(math.pi,1,2)
circuit.draw(output="mpl")
statevec,counts = do_job(circuit)
plot_bloch_multivector(statevec)
|
https://github.com/riachakraborty/Algorithms-
|
riachakraborty
|
# useful additional packages
#%%
import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl
%matplotlib inline
# importing Qiskit
from qiskit import Aer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, compile
#from qiskit.tools.monitor import job_monitor, backend_monitor, backend_overview
backend = Aer.get_backend('statevector_simulator')
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# Load our saved IBMQ accounts
IBMQ.load_accounts()
n = 12 # the length of the first register for querying the oracle
# Choose a type of oracle at random. With probability half it is constant,
# and with the same probability it is balanced
oracleType, oracleValue = np.random.randint(2), np.random.randint(2)
if oracleType == 0:
print("The oracle returns a constant value ", oracleValue)
else:
print("The oracle returns a balanced function")
a = np.random.randint(1,2**n) # this is a hidden parameter for balanced oracle.
# Creating registers
# n qubits for querying the oracle and one qubit for storing the answer
qr = QuantumRegister(n+1) #all qubits are initialized to zero
# for recording the measurement on the first register
cr = ClassicalRegister(n)
circuitName = "DeutschJozsa"
djCircuit = QuantumCircuit(qr, cr)
# Create the superposition of all input queries in the first register by applying the Hadamard gate to each qubit.
for i in range(n):
djCircuit.h(qr[i])
# Flip the second register and apply the Hadamard gate.
djCircuit.x(qr[n])
djCircuit.h(qr[n])
# Apply barrier to mark the beginning of the oracle
djCircuit.barrier()
if oracleType == 0:#If the oracleType is "0", the oracle returns oracleValue for all input.
if oracleValue == 1:
djCircuit.x(qr[n])
else:
djCircuit.iden(qr[n])
else: # Otherwise, it returns the inner product of the input with a (non-zero bitstring)
for i in range(n):
if (a & (1 << i)):
djCircuit.cx(qr[i], qr[n])
# Apply barrier to mark the end of the oracle
djCircuit.barrier()
# Apply Hadamard gates after querying the oracle
for i in range(n):
djCircuit.h(qr[i])
# Measurement
djCircuit.barrier()
for i in range(n):
djCircuit.measure(qr[i], cr[i])
#draw the circuit
#djCircuit.draw(output='mpl')
backend = Aer.get_backend('qasm_simulator')
shots = 1000
job = execute(djCircuit, backend=backend, shots=shots)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/samihatashin/QC-Algorithms-with-Qiskit
|
samihatashin
|
# Importing standard Qiskit libraries:
from qiskit import *
from qiskit.providers.ibmq import least_busy
from qiskit.tools.jupyter import *
from qiskit.visualization import *
%matplotlib inline
circuit = QuantumCircuit(7+1,7)
circuit.draw("mpl")
circuit.h([0,1,2,3,4,5,6])
circuit.x(7)
circuit.h(7)
circuit.barrier()
circuit.draw("mpl")
circuit.cx(6,7)
circuit.cx(3,7)
circuit.cx(2,7)
circuit.cx(0,7)
circuit.barrier()
circuit.draw("mpl")
circuit.h([0,1,2,3,4,5,6])
circuit.barrier()
circuit.measure([0,1,2,3,4,5,6],[0,1,2,3,4,5,6])
circuit.draw("mpl")
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
plot_histogram(counts)
secret_number = input("Input a Binary String of your choice ")
## Not more than 4 bits if you want to run on a real quantum device later on
bv_circ = QuantumCircuit(len(secret_number)+1,len(secret_number))
bv_circ.h(range(len(secret_number)))
bv_circ.x(len(secret_number))
bv_circ.h(len(secret_number))
bv_circ.barrier()
bv_circ.draw("mpl")
for digit, query in enumerate(reversed(secret_number)):
if query == "1":
bv_circ.cx(digit, len(secret_number))
bv_circ.barrier()
bv_circ.draw("mpl")
bv_circ.h(range(len(secret_number)))
bv_circ.barrier()
bv_circ.measure(range(len(secret_number)),range(len(secret_number)))
bv_circ.draw("mpl")
simulator = Aer.get_backend("qasm_simulator")
result = execute(bv_circ, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
plot_histogram(counts)
# Enabling our IBMQ accounts to get the least busy backend device with less than or equal to 5 qubits
IBMQ.enable_account('IBM Q API Token')
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits <= 5 and
x.configuration().n_qubits >= 2 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
exp = execute(bv_circ, backend, shots = 1024)
result_exp = exp.result()
counts_exp = result_exp.get_counts()
plot_histogram([counts_exp,counts])
|
https://github.com/samihatashin/QC-Algorithms-with-Qiskit
|
samihatashin
|
my_list = [1,3,5,2,4,2,5,8,0,7,6]
#classical computation method
def oracle(my_input):
winner =7
if my_input is winner:
response = True
else:
response = False
return response
for index, trial_number in enumerate(my_list):
if oracle(trial_number) is True:
print("Winner is found at index %i" %index)
print("%i calls to the oracle used " %(index +1))
break
#quantum implemenation
from qiskit import *
import matplotlib.pyplot as plt
import numpy as np
from qiskit.tools import job_monitor
# oracle circuit
oracle = QuantumCircuit(2, name='oracle')
oracle.cz(0,1)
oracle.to_gate()
oracle.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit, backend=backend)
result= job.result()
sv= result.get_statevector()
np.around(sv,2)
#amplitude amplification
reflection = QuantumCircuit(2, name='reflection')
reflection.h([0,1])
reflection.z([0,1])
reflection.cz(0,1)
reflection.h([0,1])
reflection.to_gate()
reflection.draw(output='mpl')
#testing circuit on simulator
simulator = Aer.get_backend('qasm_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.append(reflection, [0,1])
grover_circuit.barrier()
grover_circuit.measure([0,1],[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit,backend=simulator,shots=1)
result=job.result()
result.get_counts()
#testing on real backend system
IBMQ.load_account()
provider= IBMQ.get_provider('ibm-q')
qcomp= provider.get_backend('ibmq_manila')
job = execute(grover_circuit,backend=qcomp)
job_monitor(job)
result=job.result()
counts=result.get_counts(grover_circuit)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
counts['11']
|
https://github.com/PayalSolanki2906/Quantum_algorithms_using_Qiskit
|
PayalSolanki2906
|
from qiskit import QuantumCircuit
qc=QuantumCircuit()
from qiskit import QuantumRegister
qr = QuantumRegister(2,'a')
qc.add_register(qr)
qc.qregs ## qc.qregs is for displaying
qc.draw()
qc.h(qr[0]) ## applying Hadamard gate on the first qubit
qc.draw()
#qc.x(qr[0]) ## applying Hadamard gate on the first qubit
#qc.draw()
qc.cx(qr[1], qr[0])
qc.draw()
from qiskit import Aer
sv_sim = Aer.get_backend('aer_simulator') ##it is simulator for showing output
for backend in Aer.backends():
print(backend)
from qiskit import assemble
qc.save_statevector() ## this converts output in to state vector
qobj = assemble(qc) ## this assembles quantum circuit
job = sv_sim.run(qobj) ## this is for running the job
ket = job.result().get_statevector()
for amplitude in ket:
print(amplitude)
new_qc = QuantumCircuit(qr)
new_qc.initialize(ket, qr)
new_qc.x(qr[0])
from qiskit import assemble
new_qc.save_statevector() ## this converts output in to state vector
qobj = assemble(new_qc) ## this assembles quantum circuit
job = sv_sim.run(qobj)
ket = job.result().get_statevector()
for amplitude in ket:
print(amplitude)
from qiskit import ClassicalRegister
cr = ClassicalRegister(2,'creg')
qc.add_register(cr)
qc.measure(qr[0],cr[0]) ##measuring first quibit on first classical register
qc.measure(qr[1],cr[1]) ##measuring second quibit on second classical register
qc.draw()
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(qc, shots=100) ##shots is the number of experiments
job = aer_sim.run(qobj, memory=True) ##.run is for running the experiments
hist = job.result().get_counts()
print(hist)
from qiskit.visualization import plot_histogram
plot_histogram(hist)
samples = job.result().get_memory() #to get result of each experiment as a result
print(samples)
qubit = QuantumRegister(8)
bit = ClassicalRegister(8)
qc_2 = QuantumCircuit(qubit,bit)
qc_2.x(qubit[7])
qc_2.measure(qubit,bit) # this is a way to do all the qc.measure(qr8[j],cr8[j]) at once
qobj = assemble(qc_2, shots=8192)
aer_sim.run(qobj).result().get_counts()
qc = QuantumCircuit(2,1) ## where first arguments is corresponding to number of quantum regsiter and second
##argument is corresponding to the number of classical register.
qc.h(0)
qc.cx(0,1)
qc.measure(1,0)
qc.draw()
sub_circuit = QuantumCircuit(3, name='toggle_cx')
sub_circuit.cx(0,1)
sub_circuit.cx(1,2)
sub_circuit.cx(0,1)
sub_circuit.cx(1,2)
sub_circuit.draw()
toggle_cx = sub_circuit.to_instruction() ##we convert this circuit to the custom gate
qr = QuantumRegister(4)
new_qc = QuantumCircuit(qr)
new_qc.append(toggle_cx, [qr[1],qr[2],qr[3] ])
new_qc.draw()
|
https://github.com/PayalSolanki2906/Quantum_algorithms_using_Qiskit
|
PayalSolanki2906
|
from qiskit import QuantumCircuit, Aer, assemble
import numpy as np
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.visualization import array_to_latex
qc = QuantumCircuit(3)
# Apply H-gate to each qubit:
for qubit in range(3):
qc.h(qubit)
# See the circuit:
qc.draw()
# Let's see the result
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
# In Jupyter Notebooks we can display this nicely using Latex.
# If not using Jupyter Notebooks you may need to remove the
# array_to_latex function and use print(final_state) instead.
array_to_latex(final_state, prefix="\\text{Statevector} = ")
qc = QuantumCircuit(2)
qc.x(0)
qc.draw()
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector} = ")
qc = QuantumCircuit(2)
qc.h(0)
qc.draw()
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector} = ")
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
qc.draw()
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector} = ")
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.h(1)
qc.draw()
svsim = Aer.get_backend('aer_simulator')
qc.save_statevector()
qobj = assemble(qc)
final_state = svsim.run(qobj).result().get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector} = ")
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.draw()
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(1)
qc.x(0)
qc.z(0)
qc.h(0)
qc.draw()
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(3)
qc.x(2)
qc.z(1)
qc.h(0)
qc.draw()
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
qc = QuantumCircuit(2)
# Apply H-gate to the first:
qc.h(0)
# Apply a CNOT:
qc.cx(0,1)
qc.draw()
# Let's get the result:
qc.save_statevector()
qobj = assemble(qc)
result = svsim.run(qobj).result()
# Print the statevector neatly:
final_state = result.get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector = }")
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
# Apply H-gate to the first:
qc.h(0)
qc.draw()
# Let's get the result:
qc.save_statevector()
qobj = assemble(qc)
result = svsim.run(qobj).result()
# Print the statevector neatly:
final_state = result.get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector = }")
plot_bloch_multivector(final_state)
qc = QuantumCircuit(2)
# Apply H-gate to the first:
qc.x(0)
qc.h(1)
qc.cx(1,0)
qc.draw()
# Let's get the result:
qc.save_statevector()
qobj = assemble(qc)
result = svsim.run(qobj).result()
# Print the statevector neatly:
final_state = result.get_statevector()
array_to_latex(final_state, prefix="\\text{Statevector = }")
qc = QuantumCircuit(2)
# Apply H-gate to the first:
qc.x(0)
qc.h(1)
qc.cx(1,0)
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{Circuit = }\n")
|
https://github.com/PayalSolanki2906/Quantum_algorithms_using_Qiskit
|
PayalSolanki2906
|
from qiskit import QuantumCircuit
import numpy as np
from qiskit import QuantumCircuit, assemble, Aer
def deutsch_problem(seed=None):
"""Returns a circuit that carries out the function
from Deutsch's problem.
Args:
seed (int): If set, then returned circuit will
always be the same for the same seed.
Returns: QuantumCircuit
"""
np.random.seed(seed)
problem = QuantumCircuit(2)
if np.random.randint(2):
print("Function is balanced.")
problem.cx(0, 1)
else:
print("Function is constant.")
if np.random.randint(2):
problem.x(1)
return problem
def deutsch(problem):
"""Implements Deutsch's algorithm.
Args:
function (QuantumCircuit): Deutsch function to solve.
Must be a 2-qubit circuit, and either balanced,
or constant.
Returns:
bool: True if the circuit is balanced, otherwise False.
"""
qc=QuantumCircuit(2,1)
qc.x(1)
qc.h([0,1])
qc.draw()
qc.append(problem.to_gate(label='f'),[0,1])
qc.h(0)
qc.measure(0,0)
qc = qc.decompose('f')
display(qc.draw())
sim = Aer.get_backend('aer_simulator')
state = sim.run(qc).result().get_counts() # Execute the circuit and get the count
state=list(state.keys())[0] ## fetch the bit from the Dictionary
if state=='1':
return('balanced')
if state=='0':
return('constant')
problem=deutsch_problem()
print(deutsch(problem))
|
https://github.com/PayalSolanki2906/Quantum_algorithms_using_Qiskit
|
PayalSolanki2906
|
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
qc=QuantumCircuit(4,2) ## for adder we need four quantum register and 2 classical register
qc.barrier()
# use cnots to write the XOR of the inputs on qubit 2
qc.cx(0,2)
qc.cx(1,2)
qc.ccx(0,1,3)
qc.barrier()
# extract outputs
qc.measure(2,0) # extract XOR value
qc.measure(3,1)
qc.draw()
from qiskit import Aer
sim = Aer.get_backend('aer_simulator')
from qiskit import assemble
qobj = assemble(qc)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
from qiskit import QuantumCircuit
qc1=QuantumCircuit(4,2) ## for adder we need four quantum register and 2 classical register
qc1.x(1)
qc1.barrier()
# use cnots to write the XOR of the inputs on qubit 2
qc1.cx(0,2)
qc1.cx(1,2)
qc1.ccx(0,1,3)
qc1.barrier()
# extract outputs
qc1.measure(2,0) # extract XOR value
qc1.measure(3,1)
qc1.draw()
from qiskit import Aer
sim = Aer.get_backend('aer_simulator')
from qiskit import assemble
qobj = assemble(qc1)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
from qiskit import QuantumCircuit
qc2=QuantumCircuit(4,2) ## for adder we need four quantum register and 2 classical register
qc2.x(0)
qc2.barrier()
# use cnots to write the XOR of the inputs on qubit 2
qc2.cx(0,2)
qc2.cx(1,2)
qc2.ccx(0,1,3)
qc2.barrier()
# extract outputs
qc2.measure(2,0) # extract XOR value
qc2.measure(3,1)
qc2.draw()
from qiskit import Aer
sim = Aer.get_backend('aer_simulator')
from qiskit import assemble
qobj = assemble(qc2)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
from qiskit import QuantumCircuit
qc3=QuantumCircuit(4,2) ## for adder we need four quantum register and 2 classical register
qc3.x(0)
qc3.x(1)
qc3.barrier()
# use cnots to write the XOR of the inputs on qubit 2
qc3.cx(0,2)
qc3.cx(1,2)
qc3.ccx(0,1,3)
qc3.barrier()
# extract outputs
qc3.measure(2,0) # extract XOR value
qc3.measure(3,1)
qc3.draw()
from qiskit import Aer
sim = Aer.get_backend('aer_simulator')
from qiskit import assemble
qobj = assemble(qc3)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
|
https://github.com/PayalSolanki2906/Quantum_algorithms_using_Qiskit
|
PayalSolanki2906
|
from qiskit import QuantumCircuit, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector
from cmath import sqrt, pi, exp
sim = Aer.get_backend('aer_simulator')
qc = QuantumCircuit(1) # Create a quantum circuit with one qubit
initial_state = [0,1]
qc.initialize(initial_state, 0)
sim = Aer.get_backend('aer_simulator')
qc.save_statevector() ## this converts output in to state vector
qobj = assemble(qc) ## this assembles quantum circuit
job = sim.run(qobj) ## this is for running the job
ket = job.result().get_statevector()
print(ket)
qc.measure_all()
qc.draw()
qobj = assemble(qc)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
qc1 = QuantumCircuit(1) # Create a quantum circuit with one qubit
initial_state = [1/sqrt(2),1/sqrt(2)] # Define initial_state as |1>
qc1.initialize(initial_state, 0) # Apply initialisation operation to the 0th qubit
qc1.draw() # Let's view our circuit
sim = Aer.get_backend('aer_simulator')
qc1.save_statevector() ## this converts output in to state vector
qobj = assemble(qc1) ## this assembles quantum circuit
job = sim.run(qobj) ## this is for running the job
ket = job.result().get_statevector()
print(ket)
qc1.measure_all()
qc1.draw()
qobj = assemble(qc1)
counts = sim.run(qobj).result().get_counts()
plot_histogram(counts)
state1 = [1/sqrt(3),sqrt(2/3)]
i=complex(0,1)
state2 = [exp(-i*pi)*1/sqrt(3),exp(-i*pi)*sqrt(2/3)] ## adding a global phase never changes the probabilities.
initial_state = state1 # Define state |q_0>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialize the 0th qubit in the state `initial_state`
qc.save_statevector() # Save statevector
qobj = assemble(qc)
results = sim.run(qobj).result().get_counts()
plot_histogram(results)
initial_state = state2 # Define state |q_0>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialize the 0th qubit in the state `initial_state`
qc.save_statevector() # Save statevector
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector() # Execute the circuit
print(state) # Print the result
qobj = assemble(qc)
results = sim.run(qobj).result().get_counts()
plot_histogram(results)
from qiskit_textbook.widgets import plot_bloch_vector_spherical
coords = [pi/2,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
from qiskit_textbook.widgets import plot_bloch_vector_spherical
coords = [2*pi,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
from qiskit_textbook.widgets import plot_bloch_vector_spherical
coords = [pi,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
from qiskit_textbook.widgets import plot_bloch_vector_spherical
coords = [pi/2,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
from qiskit_textbook.widgets import plot_bloch_vector_spherical
coords = [pi/2,-pi/2,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
|
https://github.com/PayalSolanki2906/Quantum_algorithms_using_Qiskit
|
PayalSolanki2906
|
from qiskit import QuantumCircuit, assemble, Aer
from math import pi, sqrt, exp
from qiskit.visualization import plot_bloch_multivector, plot_histogram
sim = Aer.get_backend('aer_simulator')
qc = QuantumCircuit(1)
qc.x(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.y(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.z(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.h(0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.p(pi/4, 0)
qc.draw()
qc = QuantumCircuit(1)
qc.s(0) # Apply S-gate to qubit 0
qc.sdg(0) # Apply Sdg-gate to qubit 0
qc.draw()
qc = QuantumCircuit(1)
qc.t(0) # Apply T-gate to qubit 0
qc.tdg(0) # Apply Tdg-gate to qubit 0
qc.draw()
qc = QuantumCircuit(1)
qc.u(pi/2, 0, pi, 0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
initial_state =[1/sqrt(2), -1/sqrt(2)] # Define state |q_0>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialize the 0th qubit in the state `initial_state`
qc.save_statevector() # Save statevector
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector() # Execute the circuit
print(state) # Print the result
qobj = assemble(qc)
results = sim.run(qobj).result().get_counts()
plot_histogram(results)
initial_state =[1/sqrt(2), 1/sqrt(2)] # Define state |q_0>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialize the 0th qubit in the state `initial_state`
qc.save_statevector() # Save statevector
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector() # Execute the circuit
print(state) # Print the result
qobj = assemble(qc)
results = sim.run(qobj).result().get_counts()
plot_histogram(results)
# Create the Y-measurement function:
def x_measurement(qc, qubit, cbit):
"""Measure 'qubit' in the X-basis, and store the result in 'cbit'"""
qc.s(qubit)
qc.h(qubit)
qc.measure(qubit, cbit)
return qc
initial_state = [1/sqrt(2), -complex(0,1)/sqrt(2)]
# Initialize our qubit and measure it
qc = QuantumCircuit(1,1)
qc.initialize(initial_state, 0)
x_measurement(qc, 0, 0) # measure qubit 0 to classical bit 0
qc.draw()
qobj = assemble(qc) # Assemble circuit into a Qobj that can be run
counts = sim.run(qobj).result().get_counts() # Do the simulation, returning the state vector
plot_histogram(counts) # Display the output on measurement of state vector
|
https://github.com/aniket1905-del/Quantum_computation
|
aniket1905-del
|
import cirq
import numpy as np
from qiskit import QuantumCircuit, execute, Aer
import seaborn as sns
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = (15,10)
q0, q1, q2 = [cirq.LineQubit(i) for i in range(3)]
circuit = cirq.Circuit()
#entagling the 2 quibits in different laboratories
#and preparing the qubit to send
circuit.append(cirq.H(q0))
circuit.append(cirq.H(q1))
circuit.append(cirq.CNOT(q1, q2))
#entangling the qubit we want to send to the one in the first laboratory
circuit.append(cirq.CNOT(q0, q1))
circuit.append(cirq.H(q0))
#measurements
circuit.append(cirq.measure(q0, q1))
#last transformations to obtain the qubit information
circuit.append(cirq.CNOT(q1, q2))
circuit.append(cirq.CZ(q0, q2))
#measure of the qubit in the receiving laboratory along z axis
circuit.append(cirq.measure(q2, key = 'Z'))
circuit
#starting simulation
sim = cirq.Simulator()
results = sim.run(circuit, repetitions=100)
sns.histplot(results.measurements['Z'], discrete = True)
100 - np.count_nonzero(results.measurements['Z']), np.count_nonzero(results.measurements['Z'])
#in qiskit the qubits are integrated in the circuit
qc = QuantumCircuit(3, 1)
#entangling
qc.h(0)
qc.h(1)
qc.cx(1, 2)
qc.cx(0, 1)
#setting for measurment
qc.h(0)
qc.measure([0,1], [0,0])
#transformation to obtain qubit sent
qc.cx(1, 2)
qc.cz(0, 2)
qc.measure(2, 0)
print(qc)
#simulation
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=100)
res = job.result().get_counts(qc)
plt.bar(res.keys(), res.values())
res
|
https://github.com/chinsu70802/quantum_teleportation
|
chinsu70802
|
!pip install qiskit
!pip install pylatexenc
!pip install qiskit-aer
from qiskit import QuantumCircuit
mycircuit = QuantumCircuit(1)
mycircuit.draw('mpl')
from qiskit.quantum_info import Statevector
sv = Statevector.from_label('0')
sv
sv.data
new_sv = sv.evolve(mycircuit)
new_sv
from qiskit.quantum_info import state_fidelity
state_fidelity(sv, new_sv)
from qiskit.visualization import plot_state_qsphere
plot_state_qsphere(sv.data)
mycircuit = QuantumCircuit(1)
mycircuit.x(0)
mycircuit.draw('mpl')
sv = Statevector.from_label('0')
new_sv = sv.evolve(mycircuit)
new_sv
state_fidelity(sv, new_sv)
plot_state_qsphere(new_sv.data)
sv = Statevector.from_label('0')
mycircuit = QuantumCircuit(1)
mycircuit.h(0)
mycircuit.draw('mpl')
new_sv = sv.evolve(mycircuit)
print(new_sv)
plot_state_qsphere(new_sv.data)
sv = Statevector.from_label('1')
mycircuit = QuantumCircuit(1)
mycircuit.h(0)
new_sv = sv.evolve(mycircuit)
print(new_sv)
plot_state_qsphere(new_sv.data)
sv = Statevector.from_label('00')
plot_state_qsphere(sv.data)
mycircuit = QuantumCircuit(2)
mycircuit.h(0)
mycircuit.cx(0,1)
mycircuit.draw('mpl')
new_sv = sv.evolve(mycircuit)
print(new_sv)
plot_state_qsphere(new_sv.data)
counts = new_sv.sample_counts(shots=1000)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
sv = Statevector.from_label('10')
mycircuit.draw('mpl')
new_sv = sv.evolve(mycircuit)
new_sv
sv = Statevector.from_label('11')
mycircuit.draw('mpl')
new_sv = sv.evolve(mycircuit)
new_sv
mycircuit = QuantumCircuit(2, 2)
mycircuit.h(0)
mycircuit.cx(0,1)
mycircuit.measure([0,1], [0,1])
mycircuit.draw('mpl')
from qiskit import Aer, execute
simulator = Aer.get_backend('qasm_simulator')
result = execute(mycircuit, simulator, shots=10000).result()
counts = result.get_counts(mycircuit)
plot_histogram(counts)
def initialize_qubit(given_circuit, qubit_index):
import numpy as np
### WRITE YOUR CODE BETWEEN THESE LINES - START
given_circuit.initialize([np.sqrt(0.7),np.sqrt(0.3)],qubit_index)
### WRITE YOUR CODE BETWEEN THESE LINES - END
return given_circuit
def entangle_qubits(given_circuit, qubit_Alice, qubit_Bob):
### WRITE YOUR CODE BETWEEN THESE LINES - START
given_circuit.h(qubit_Alice)
given_circuit.cx(qubit_Alice, qubit_Bob)
### WRITE YOUR CODE BETWEEN THESE LINES - END
return given_circuit
def bell_meas_Alice_qubits(given_circuit, qubit1_Alice, qubit2_Alice, clbit1_Alice, clbit2_Alice):
### WRITE YOUR CODE BETWEEN THESE LINES - START
given_circuit.cx(qubit1_Alice,qubit2_Alice)
given_circuit.h(qubit1_Alice)
given_circuit.barrier()
given_circuit.measure([qubit1_Alice,qubit2_Alice],[clbit1_Alice,clbit2_Alice])
### WRITE YOUR CODE BETWEEN THESE LINES - END
return given_circuit
def controlled_ops_Bob_qubit(given_circuit, qubit_Bob, clbit1_Alice, clbit2_Alice):
### WRITE YOUR CODE BETWEEN THESE LINES - START
if clbit1_Alice == 1 and clbit2_Alice == 0:
given_circuit.z(qubit_Bob)
elif clbit1_Alice == 0 and clbit2_Alice == 1:
given_circuit.x(qubit_Bob)
elif clbit1_Alice == 1 and clbit2_Alice == 1:
given_circuit.x(qubit_Bob)
given_circuit.z(qubit_Bob)
### WRITE YOUR CODE BETWEEN THESE LINES - END
return given_circuit
### imports
from qiskit import QuantumRegister, ClassicalRegister
### set up the qubits and classical bits
all_qubits_Alice = QuantumRegister(2)
all_qubits_Bob = QuantumRegister(1)
creg1_Alice = ClassicalRegister(1)
creg2_Alice = ClassicalRegister(1)
### quantum teleportation circuit here
# Initialize
mycircuit = QuantumCircuit(all_qubits_Alice, all_qubits_Bob, creg1_Alice, creg2_Alice)
initialize_qubit(mycircuit, 0)
mycircuit.barrier()
# Entangle
entangle_qubits(mycircuit, 1, 2)
mycircuit.barrier()
# Do a Bell measurement
bell_meas_Alice_qubits(mycircuit, all_qubits_Alice[0], all_qubits_Alice[1], creg1_Alice[0], creg2_Alice[0])
mycircuit.barrier()
# Apply classically controlled quantum gates
controlled_ops_Bob_qubit(mycircuit, all_qubits_Bob[0], creg1_Alice, creg2_Alice)
### Look at the complete circuit
mycircuit.draw('mpl')
mycircuit.measure_all()
from qiskit import Aer, execute
simulator = Aer.get_backend('qasm_simulator')
result = execute(mycircuit, simulator, shots=10000).result()
counts = result.get_counts(mycircuit)
plot_histogram(counts)
|
https://github.com/108mk/Quantum_Algorithms_and_Qiskit
|
108mk
|
import qiskit
qiskit.__qiskit_version__
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# Load our saved IBMQ accounts.
IBMQ.load_account()
nQubits = 14 # number of physical qubits
a = 101 # the hidden integer whose bitstring is 1100101
# make sure that a can be represented with nQubits
a = a % 2**(nQubits)
# Creating registers
# qubits for querying the oracle and finding the hidden integer
qr = QuantumRegister(nQubits)
# for recording the measurement on qr
cr = ClassicalRegister(nQubits)
circuitName = "BernsteinVazirani"
bvCircuit = QuantumCircuit(qr, cr)
# Apply Hadamard gates before querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier so that it is not optimized by the compiler
bvCircuit.barrier()
# Apply the inner-product oracle
for i in range(nQubits):
if (a & (1 << i)):
bvCircuit.z(qr[i])
else:
bvCircuit.iden(qr[i])
# Apply barrier
bvCircuit.barrier()
#Apply Hadamard gates after querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Measurement
bvCircuit.barrier(qr)
bvCircuit.measure(qr, cr)
bvCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1000
results = execute(bvCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
backend = IBMQ.get_backend('ibmq_16_melbourne')
shots = 1000
bvCompiled = transpile(bvCircuit, backend=backend, optimization_level=1)
job_exp = execute(bvCircuit, backend=backend, shots=shots)
job_monitor(job_exp)
results = job_exp.result()
answer = results.get_counts(bvCircuit)
threshold = int(0.01 * shots) #the threshold of plotting significant measurements
filteredAnswer = {k: v for k,v in answer.items() if v >= threshold} #filter the answer for better view of plots
removedCounts = np.sum([ v for k,v in answer.items() if v < threshold ]) #number of counts removed
filteredAnswer['other_bitstrings'] = removedCounts #the removed counts is assigned to a new index
plot_histogram(filteredAnswer)
print(filteredAnswer)
|
https://github.com/108mk/Quantum_Algorithms_and_Qiskit
|
108mk
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, assemble, transpile
# import basic plot tools
from qiskit.visualization import plot_histogram
import matplotlib as mpl
# set the length of the n-bit input string.
n = 2 #----------This was the original case considered by David Duetzch-----------#
# set the length of the n-bit input string.
const_oracle = QuantumCircuit(n+1)
output = np.random.randint(2)
if output == 1:
const_oracle.x(n)
const_oracle.draw("mpl")
balanced_oracle = QuantumCircuit(n+1)
#------input a 2-bit string as of your choice!!!!!!!!
b_str = "11"
balanced_oracle = QuantumCircuit(n+1)
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
balanced_oracle.draw("mpl")
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
balanced_oracle.draw("mpl")
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Show oracle
balanced_oracle.draw("mpl")
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.draw("mpl")
# Add oracle
dj_circuit = QuantumCircuit.compose(dj_circuit,balanced_oracle)
dj_circuit.draw("mpl")
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
# Display circuit
dj_circuit.draw("mpl")
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(dj_circuit, aer_sim)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
#---------CONCLUDING REMARKS----------------
###--------THE ABOVE ALGORITHM CAN BE EXTENDED TO N-VARAIBLE CASE. IT IS CALLED DUETZCH-JOZSA ALGORITHM-----
|
https://github.com/108mk/Quantum_Algorithms_and_Qiskit
|
108mk
|
#!conda deactivate
!conda update anaconda-navigator
!conda update conda
!conda update conda
!conda update anaconda
import numpy as np
a = np.array([[ 1., 0., 0., 0.],
[ 0., 1., 0., 0.],
[ 0., 0., 0., 1.],
[ 0., 0., 1., 0.]])
p = q =r= s = 1
b = np.array([[ p, 0., q, 0.],
[ 0., 0., 0., 0.],
[ r, 0., s, 0.],
[ 0., 0., 0., 0.]])
a@b
a@b@a
|
https://github.com/108mk/Quantum_Algorithms_and_Qiskit
|
108mk
|
#initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
nQubits = 4 # number of physical qubits
a = 11 #DECIMAL----the hidden integer whose bitstring is 1011 in BINARY
# make sure that a can be represented with nQubits
a = a % 2**(nQubits)
# Creating registers
# qubits for querying the oracle and finding the hidden integer
qr = QuantumRegister(nQubits)
# for recording the measurement on qr
cr = ClassicalRegister(nQubits)
circuitName = "BernsteinVazirani"
bvCircuit = QuantumCircuit(qr, cr)
# Apply Hadamard gates before querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier so that it is not optimized by the compiler
bvCircuit.barrier()
# Apply the inner-product oracle
for i in range(nQubits):
if (a & (1 << i)):
bvCircuit.z(qr[i])
else:
bvCircuit.id(qr[i])
# Apply barrier
bvCircuit.barrier()
#Apply Hadamard gates after querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Measurement
bvCircuit.barrier(qr)
bvCircuit.measure(qr, cr)
bvCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1000
results = execute(bvCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
from qiskit import IBMQ
IBMQ.save_account('87e81a3de8a45f8a9ee4b2ccdb65b7b1d60dceec51f8541ac31f74fcec029dc63ec26a70a3d6ee88184bfe4719aa82eed0eca8a396e364c28b727ea8f42c4ec3', overwrite=True)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
provider.backends()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend('ibm_oslo')
shots = 1000
bvCompiled = transpile(bvCircuit, backend=backend, optimization_level=1)
job_exp = execute(bvCircuit, backend=backend, shots=shots)
job_monitor(job_exp)
results = job_exp.result()
answer = results.get_counts(bvCircuit)
threshold = int(0.01 * shots) #the threshold of plotting significant measurements
filteredAnswer = {k: v for k,v in answer.items() if v >= threshold} #filter the answer for better view of plots
removedCounts = np.sum([ v for k,v in answer.items() if v < threshold ]) #number of counts removed
filteredAnswer['other_bitstrings'] = removedCounts #the removed counts is assigned to a new index
plot_histogram(filteredAnswer)
print(filteredAnswer)
#-----unable to run on actual IBMQ device-----
|
https://github.com/108mk/Quantum_Algorithms_and_Qiskit
|
108mk
|
import qiskit
qiskit.__qiskit_version__
import qiskit
qiskit.__qiskit_version__
# useful additional packages
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
'''# Load our saved IBMQ accounts
IBMQ.load_account()'''
n = 13 # the length of the first register for querying the oracle
# Choose a type of oracle at random. With probability half it is constant,
# and with the same probability it is balanced
oracleType, oracleValue = np.random.randint(2), np.random.randint(2)
if oracleType == 0:
print("The oracle returns a constant value ", oracleValue)
else:
print("The oracle returns a balanced function")
a = np.random.randint(1,2**n) # this is a hidden parameter for balanced oracle.
# Creating registers
# n qubits for querying the oracle and one qubit for storing the answer
qr = QuantumRegister(n+1) #all qubits are initialized to zero
# for recording the measurement on the first register
cr = ClassicalRegister(n)
circuitName = "DeutschJozsa"
djCircuit = QuantumCircuit(qr, cr)
# Create the superposition of all input queries in the first register by applying the Hadamard gate to each qubit.
for i in range(n):
djCircuit.h(qr[i])
# Flip the second register and apply the Hadamard gate.
djCircuit.x(qr[n])
djCircuit.h(qr[n])
# Apply barrier to mark the beginning of the oracle
djCircuit.barrier()
if oracleType == 0:#If the oracleType is "0", the oracle returns oracleValue for all input.
if oracleValue == 1:
djCircuit.x(qr[n])
else:
djCircuit.iden(qr[n])
else: # Otherwise, it returns the inner product of the input with a (non-zero bitstring)
for i in range(n):
if (a & (1 << i)):
djCircuit.cx(qr[i], qr[n])
# Apply barrier to mark the end of the oracle
djCircuit.barrier()
# Apply Hadamard gates after querying the oracle
for i in range(n):
djCircuit.h(qr[i])
# Measurement
djCircuit.barrier()
for i in range(n):
djCircuit.measure(qr[i], cr[i])
#draw the circuit
djCircuit.draw(output='mpl',scale=0.5)
backend = BasicAer.get_backend('qasm_simulator')
shots = 1000
job = execute(djCircuit, backend=backend, shots=shots)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
backend = IBMQ.get_backend('ibmq_16_melbourne')
djCompiled = transpile(djCircuit, backend=backend, optimization_level=1)
djCompiled.draw(output='mpl',scale=0.5)
job = execute(djCompiled, backend=backend, shots=1024)
job_monitor(job)
results = job.result()
answer = results.get_counts()
threshold = int(0.01 * shots) # the threshold of plotting significant measurements
filteredAnswer = {k: v for k,v in answer.items() if v >= threshold} # filter the answer for better view of plots
removedCounts = np.sum([ v for k,v in answer.items() if v < threshold ]) # number of counts removed
filteredAnswer['other_bitstrings'] = removedCounts # the removed counts are assigned to a new index
plot_histogram(filteredAnswer)
print(filteredAnswer)
|
https://github.com/108mk/Quantum_Algorithms_and_Qiskit
|
108mk
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, assemble, transpile
# import basic plot tools
from qiskit.visualization import plot_histogram
import matplotlib as mpl
# set the length of the n-bit input string.
n = 2 #----------This was the original case considered by David Duetzch-----------#
# set the length of the n-bit input string.
const_oracle = QuantumCircuit(n+1)
output = np.random.randint(2)
if output == 1:
const_oracle.x(n)
const_oracle.draw("mpl")
balanced_oracle = QuantumCircuit(n+1)
#------input a 2-bit string as of your choice!!!!!!!!
b_str = "11"
balanced_oracle = QuantumCircuit(n+1)
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
balanced_oracle.draw("mpl")
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
balanced_oracle.draw("mpl")
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Show oracle
balanced_oracle.draw("mpl")
dj_circuit = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj_circuit.h(qubit)
# Put qubit in state |->
dj_circuit.x(n)
dj_circuit.h(n)
dj_circuit.draw("mpl")
# Add oracle
dj_circuit = QuantumCircuit.compose(dj_circuit,balanced_oracle)
dj_circuit.draw("mpl")
# Repeat H-gates
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.barrier()
# Measure
for i in range(n):
dj_circuit.measure(i, i)
# Display circuit
dj_circuit.draw("mpl")
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(dj_circuit, aer_sim)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
#---------CONCLUDING REMARKS----------------
###--------THE ABOVE ALGORITHM CAN BE EXTENDED TO N-VARAIBLE CASE. IT IS CALLED DUETZCH-JOZSA ALGORITHM-----
|
https://github.com/Raunak-Singh-Inventor/quantum_algorithms_in_qiskit
|
Raunak-Singh-Inventor
|
from qiskit import *
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
secretnumber = "101001"
circuit = QuantumCircuit(6+1, 6)
circuit.h([0, 1, 2, 3, 4, 5])
circuit.x(6)
circuit.h(6)
circuit.barrier()
circuit.cx(5, 6)
circuit.cx(3, 6)
circuit.cx(0, 6)
circuit.barrier()
circuit.h([0, 1, 2, 3, 4, 5])
circuit.barrier()
circuit.measure([0,1,2,3,4,5], [0,1,2,3,4,5])
circuit.draw("mpl")
simulator = Aer.get_backend("qasm_simulator")
result = execute(circuit, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/Raunak-Singh-Inventor/quantum_algorithms_in_qiskit
|
Raunak-Singh-Inventor
|
import numpy as np
def grovers_dist(num_qubits, marked_item, n_iterations):
dist = {}
for i in range(2**num_qubits):
key = bin(i)[2:].zfill(num_qubits)
theta = np.arcsin(1/np.sqrt(2 ** num_qubits))
if i == marked_item:
dist[key] = np.sin((2*n_iterations+1)*theta)**2
else:
dist[key] = (np.cos((2*n_iterations+1)*theta)/(np.sqrt(2 ** num_qubits - 1)))**2
return dist
num_qubits = 4
marked_item = 6
n_iterations = int(np.pi * np.sqrt(2 ** num_qubits) / 4)
grovers_dist(num_qubits, marked_item, n_iterations)
|
https://github.com/Raunak-Singh-Inventor/quantum_algorithms_in_qiskit
|
Raunak-Singh-Inventor
|
from qiskit import *
%matplotlib inline
from qiskit.tools.visualization import plot_histogram
secretnumber = "101001"
circuit = QuantumCircuit(6+1, 6)
circuit.h([0, 1, 2, 3, 4, 5, 6])
circuit.draw("mpl")
|
https://github.com/Raunak-Singh-Inventor/quantum_algorithms_in_qiskit
|
Raunak-Singh-Inventor
|
my_list = [1, 3, 5, 6, 7, 9, 10, 3]
def the_oracle(my_input):
winner = 7
return my_input is winner
for index, trial_number in enumerate(my_list):
if the_oracle(trial_number) is True:
print("Winner found at index: %i"%index)
print("%i calls to the Oracle used"%(index+1))
break
from qiskit import *
import matplotlib.pyplot as plt
import numpy as np
# define the oracle circuit
oracle = QuantumCircuit(2, name="oracle")
oracle.cz(0,1)
oracle.to_gate()
oracle.draw()
backend = Aer.get_backend("statevector_simulator")
grover_circ = QuantumCircuit(2, 2)
grover_circ.h([0, 1])
grover_circ.append(oracle, [0, 1])
grover_circ.draw()
job = execute(grover_circ, backend)
result = job.result()
sv = result.get_statevector()
np.around(sv, 2)
reflection = QuantumCircuit(2, name="reflection")
reflection.h([0, 1])
reflection.z([0, 1])
reflection.cz(0, 1)
reflection.h([0, 1])
reflection.to_gate()
reflection.draw()
backend = Aer.get_backend("qasm_simulator")
grover_circ = QuantumCircuit(2,2)
grover_circ.h([0, 1])
grover_circ.append(oracle, [0, 1])
grover_circ.append(reflection, [0, 1])
grover_circ.measure([0, 1], [0, 1])
grover_circ.draw()
job = execute(grover_circ, backend, shots = 10000)
result = job.result()
result.get_counts()
|
https://github.com/PAYAL980/Four-Algorithms-in-Qiskit
|
PAYAL980
|
# Importing libraries
from qiskit import *
import numpy as np
import math
import random
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta, FakeNairobi
""" Defining a general oracle for the algorithm
Input: secret_num - the secret string(to be encoded as black box)
which is to be deteremined from the Bernstein-Vazirani algorithm"""
def oracle(secret_num):
qc = QuantumCircuit(len(secret_num)+1)
for iz, val in enumerate(reversed(secret_num)): # Reversing the secret number to match the order of
# qiskit's qubits
if(val=='1'):
qc.cx(iz, len(secret_num)) # Applying cx to the qubit corresponding to 1 in secret number
return qc
# Checking the oracle function for bitstring '1101'
secret_num = '1101'
cir = oracle(secret_num)
cir.draw('mpl')
""" Defining a function for Bernstein-Vazirani algorithm
Input: N - Length of the secret bitstring to be determined
oracle1- black box encoding the secret number
Output: qc - the quantum circuit to be run on a simulator to get the final output """
def bv_algo_gen(N, oracle):
# Creating a quantum circuit of 'N+1' qubits where N is the number of bits in the input bitstring
qc = QuantumCircuit(N+1, N)
# Applying X gate on the helper qubit to change it's state from 0 to 1
qc.x(N)
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates on all qubits to create superposition and access all the possible cases at same time
qc.h(range(0,N+1))
qc.barrier() # Barrier for better visualization
# Applying the oracle for the funtion to the quantum circuit
qc.append(oracle, range(N+1))
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates to all qubits
qc.h(range(N+1))
qc.barrier() # Barrier for better visualization
# Measuring first N qubits to find if the function is constant or balanced
qc.measure(range(N), range(N))
return qc
# Testing the algorithm for '1101'
secret_num = '1101'
ora = oracle(secret_num)
N = len(secret_num)
q1 = bv_algo_gen(N, ora)
q1.draw('mpl')
# Running on non-noisy simulator 1
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on non-noisy simulator 2
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 1
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 2
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Defining a function that gives the output directly without running many cells
# secret_num - the secret string(to be encoded as black box)
# sim: simulator on which you want to run the algorithm
#. - 1: non-noisy aer simulator
# 2: non-noisy qasm simulator
# 3: noisy simulator FakeJakarta
# 4: noisy simulator FakeNairobi
# Output: counts, maximum number of counts are obtained for the secret string
def run(secret_num, sim):
oracle_1 = oracle(secret_num)
N = len(secret_num)
q1 = bv_algo_gen(N, oracle_1)
count = 0
if sim==1:
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 2:
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 3:
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
else:
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
return count
# Testing the algorithm for '10101' on all 4 simulators
plot_histogram(run('10101', 1))
plot_histogram(run('10101', 2))
plot_histogram(run('10101', 3))
plot_histogram(run('10101', 4))
# Testing the algorithm for '10101001' on all 4 simulators
plot_histogram(run('10101001', 1))
plot_histogram(run('10101001', 2))
plot_histogram(run('10101001', 3))
plot_histogram(run('10101001', 4))
|
https://github.com/PAYAL980/Four-Algorithms-in-Qiskit
|
PAYAL980
|
# Importing libraries and necessary tools
from qiskit import *
import numpy as np
import math
import random
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta, FakeBelem
""" Defining an almost general oracle for the algorithm"""
def oracle(N, case):
# Creating a quantum circuit with N input qubits and 1 helper qubits
qc = QuantumCircuit(N+1)
# Create an oracle based on the type of the function
m = random.randint(0,1) # Creating a random bit to make the decision process random
if(case == 'balanced') and (m == 0):
for iz in range(N):
qc.cx(iz,N) # Balanced function type 1
elif (case == 'balanced') and (m == 1):
qc.x(0)
for iz in range(N):
qc.cx(iz,N) # Balanced oracle flips helper qubit when the 0th qubit is 0
qc.x(0) # Balanced function type 2
elif (case == 'constant') and (m == 0):
qc.x(N) # Applying X gate on the (N+1)th qubit
# Constant function type 1
else:
qc.i(N) # Applying identity on the (N+1)th qubit
# Constant function type 1
return qc
# Checking the oracle function for 2 bits and type of function equal to balanced
cir = oracle(2, 'balanced')
cir.draw('mpl')
""" Defining a function for Deutsch-Jozsa algorithm
Input: N - Number of bits in the input string for the function to be determined
oracle1- black box encoding the function to be determined
Output: qc - the quantum circuit to be run on a simulator to get the final output """
def DJ_algo_gen(N, oracle1):
# Create a quantum circuit of 'N+1' qubits where N is the number of bits in the input bitstring
qc = QuantumCircuit(N+1, N)
# Apply X gate on the helper qubit to change it's state from 0 to 1
qc.x(N)
qc.barrier() # Barrier for better visualization
# Apply Hadamard gates on all qubits to create superposition and access all the possible cases at same time
qc.h(range(0,N+1))
qc.barrier() # Barrier for better visualization
# Apply the oracle for the funtion to the quantum circuit
qc.append(oracle1, range(N+1))
qc.barrier() # Barrier for better visualization
# Apply Hadamard gates to all qubits
qc.h(range(N+1))
qc.barrier() # Barrier for better visualization
# Measure first N qubits to find if the function is constant or balanced
qc.measure(range(N), range(N))
return qc
# Testing the algorithm for n=2 and constant function
ora = oracle(2, 'constant')
q1 = DJ_algo_gen(2, ora)
q1.draw('mpl')
# Running on non-noisy simulator 1
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on non-noisy simulator 2
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 1
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 2
backend = FakeBelem()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Defining a function that gives the output directly without running many cells
# N - number of bits in input bit string
# case - type of function to be given as a string either 'constant' or 'balanced'
# sim: simulator on which you want to run the algorithm
#. - 1: non-noisy aer simulator
# 2: non-noisy qasm simulator
# 3: noisy simulator FakeJakarta
# 4: noisy simulator FakeBelem
# Output: counts, if maximum counts is for '0'*N, the function is constant
# if maximum counts is for '1'*N, the function is balanced
def run(N, case, sim):
oracle_1 = oracle(N, case)
q1 = DJ_algo_gen(N, oracle_1)
count = 0
if sim==1:
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 2:
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 3:
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
else:
backend = FakeBelem()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
return count
# Testing the algorithm for N=3 and balanced function on all 4 simulators
plot_histogram(run(3, 'balanced', 1))
plot_histogram(run(3, 'balanced', 2))
plot_histogram(run(3, 'balanced', 3))
plot_histogram(run(3, 'balanced', 4))
# Testing the algorithm for N=6 and Balanced functon on noisy simulator
plot_histogram(run(6, 'balanced', 3))
# Testing the algorithm for N=6 and Balanced functon on non - noisy simulator
plot_histogram(run(6, 'balanced', 2))
plot_histogram(run(6, 'balanced', 4))
plot_histogram(run(8, 'balanced', 3))
plot_histogram(run(8, 'balanced', 1))
plot_histogram(run(1000, 'balanced', 1))
plot_histogram(run(1000, 'balanced', 2))
|
https://github.com/PAYAL980/Four-Algorithms-in-Qiskit
|
PAYAL980
|
# Import libraries and necessary tools
from qiskit import *
import numpy as np
import math
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta, FakeNairobi
""" Defining Diffuser (Z0) for N qubits"""
def diffuser(N):
cir = QuantumCircuit(N)
# Applying anti controlled Z gate
cir.x(range(N))
cir.h(0)
cir.mcx([iz for iz in range(1,N)], 0)
cir.h(0)
cir.x(range(N))
return cir
# Checking the diffuser function for 3 qubits
q2 = diffuser(3)
q2.draw('mpl')
""" Defining the oracle(Zf) for N qubits and inp: input string such that f(inp) = 1"""
def oracle(N, inp):
cir = QuantumCircuit(N)
# Checking the positions of '0' in the input string and applying X gate for the application of
# anti-controlled Z gate
for iz in range(N):
if inp[iz]=='0':
cir.x(N-iz-1)
# Multiple controlled Z gate
cir.h(0)
cir.mcx([iz for iz in range(1,N)], 0)
cir.h(0)
# Applying X gates to reverse the effect of above applied X gates
for iz in range(len(inp)):
if inp[iz]=='0':
cir.x(N-iz-1)
return cir
# Checking the oracle function for 3 qubits and input string '001'
q2 = oracle(3, '001')
q2.draw('mpl')
""" Defining Grover's Algorithm """
def grovers_algo_gen(N, oracle_1):
# calculating number of iterations for the Grover's operator
m = int(np.round(np.pi*np.sqrt(2**N)/4 - 0.5))
# Creating a quantum circuit of 'N' qubits
qc = QuantumCircuit(N, N)
# Applying Hadamard gates to all qubits to create superposition
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Iterating the Grover's operator 'm' times
for iz in range(m):
# Appending the oracle
qc.append(oracle_1, range(N))
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates on all qubits
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Appending the diffuser to the quantum circuit
qc.append(diffuser(N), range(N))
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates to all qubits
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Measuring all N qubits to find the desired output
qc.measure(range(N), range(N))
return qc
# Testing the algorithm for N=3 and f('101') = 1
N = 3
ora = oracle(N, '101')
ora.draw('mpl')
q1 = grovers_algo_gen(N, ora)
q1.draw('mpl')
# Running on non-noisy simulator 1
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on non-noisy simulator 2
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 1
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 1
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Defining a function that gives the output directly without running many cells
# inp_str - the input string corresponding to f(x) = 1
# sim: simulator on which you want to run the algorithm
#. - 1: non-noisy aer simulator
# 2: non-noisy qasm simulator
# 3: noisy simulator FakeJakarta
# 4: noisy simulator FakeBelem
# Output: counts, maximum number of counts are obtained for the secret string
def run(inp_str, sim):
N = len(inp_str)
oracle_1 = oracle(N, inp_str)
q1 = grovers_algo_gen(N, oracle_1)
count = 0
if sim==1:
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 2:
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 3:
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
else:
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
return counts
# Testing the algorithm for '10' on all 4 simulators
plot_histogram(run('10', 1))
plot_histogram(run('10', 2))
plot_histogram(run('10', 3))
plot_histogram(run('10', 4))
# Testing the algorithm for '1010' on all 4 simulators
plot_histogram(run('1010', 1))
plot_histogram(run('1010', 2))
plot_histogram(run('1010', 3))
plot_histogram(run('1010', 4))
# Testing the algorithm for a string of 6 bits on noisy simulator
plot_histogram(run('101011', 4))
|
https://github.com/PAYAL980/Four-Algorithms-in-Qiskit
|
PAYAL980
|
# Importing libraries and necessary tools
from qiskit import *
import numpy as np
import math
import random
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta, FakeNairobi
from qiskit_textbook.tools import simon_oracle
""" Simon oracle has been imported from qiskit textbook to be used in the algorithm"""
oracle = simon_oracle('00')
oracle.draw('mpl')
oracle = simon_oracle('01')
oracle.draw('mpl')
oracle = simon_oracle('10')
oracle.draw('mpl')
oracle = simon_oracle('11')
oracle.draw('mpl')
""" Defining a function for Simon's algorithm
Input: N - Length of the bitstring 'a'
oracle1- black box encoding the function
Output: qc - the quantum circuit to be run on a simulator to get the final output """
def Simon(oracle, N):
# Creating the quantum circuit of '2N' qubits where N is the number of bits in the input bitstring
qc = QuantumCircuit(N*2, N)
# Applying Hadamard gates on all qubits to create superposition
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Appending the oracle for the funtion to the quantum circuit
qc.append(oracle, range(2*N))
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates to all the input qubits
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Measuring input qubits to find the linearly independent strings
qc.measure(range(N), range(N))
return qc
# Testing the algorithm for a = '10'
a = '10'
N = len(a)
ora = simon_oracle(a)
q1 = Simon(ora, N)
q1.draw('mpl')
# Running on non-noisy simulator 1
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend, shots=1024)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
""" Getting the output strings in form of a list to find 'a' classically"""
res = list(counts.keys())
res
# Running on non-noisy simulator 2
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend, shots=1024)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 1
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 2
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Defining a function that gives the output directly without running many cells
# a - the bitstring(to be encoded as black box)
# sim: simulator on which you want to run the algorithm
#. - 1: non-noisy aer simulator
# 2: non-noisy qasm simulator
# 3: noisy simulator FakeJakarta
# 4: noisy simulator FakeNairobi
# Output: counts, maximum number of counts are obtained for the linearly independent strings
def run(a, sim):
oracle_1 = simon_oracle(a)
N = len(a)
q1 = Simon(oracle_1, N)
count = 0
if sim==1:
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 2:
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 3:
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
else:
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
return count
# Testing the algorithm for '110' on all 4 simulators
a = '110'
plot_histogram(run(a, 1))
plot_histogram(run(a, 2))
plot_histogram(run(a, 3))
plot_histogram(run(a, 4))
# Testing the algorithm for '1101' on all 4 simulators
a = '1101'
plot_histogram(run(a, 1))
plot_histogram(run(a, 2))
plot_histogram(run(a, 3))
plot_histogram(run(a, 4))
|
https://github.com/deveshq/QC-with-qiskit
|
deveshq
|
# Importing some important libraries
import numpy as np
from numpy import math
from qiskit import *
from numpy import pi as pi
from math import asin, sqrt
import qiskit.quantum_info as qi
from qiskit import QuantumCircuit, transpile, Aer, IBMQ, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from numpy.random import seed
import IPython
from IPython.display import display,Latex,Markdown
# Defining a function which flip the sign of the marked state, in the superpositon of all the states.
def orc(d):
op = np.identity(2**n)
for i in d:
op[i][i] = op[i][i]*(-1)
display(i)
return op
# Defining another function which flip all the states about the average.
def dif():
op = np.identity(2**n)
for i in range(2**n):
if ( i != 0):
op[i][i] = op[i][i]*(-1)
#display(op)
return op
# Taking vector of integer number as input.
display(Latex(r'Expected a vector of length $2^n$ as input!'))
n = int(input('Enter n: '))
a = []
print('Enter the vector:')
for i in range(2**n):
a.append(int(input()))
print(f'a = {a}')
#Extracting the indices of the input for which two adjacent bits will always have different values.
d = []
b_d = []
c = len('{0:b}'.format(max(a))) #number of bits in binary form of highest number in a.
def cd(x):
b = '{0:0{d}b}'.format(x,d=c)
return all(b[i] != b[i+1] for i in range(c-1) )
for i in range(len(a)):
if cd(a[i]) is True:
d.append(i)
b_d.append('{0:0{d}b}'.format(a[i],d=c))
print(f'Indices: {d}, Numbers: {b_d}')
if (n<3):
if (len(d)>1):
n = 3 #Because this program requires atleast three qubits to deal with more than one targets.
else:
n = n
#Initiating a quantum circuit
qc = QuantumCircuit(n,n)
qc.h(range(n))
qc.draw()
#To find the number of repetition.
theta = asin(1/sqrt(2**n))
t = int((pi/(2*theta) - 1)/2)
#Finally applying all the component on the circuit.
for i in range(t):
qc.unitary(orc(d), range(n))
qc.h(range(n))
qc.unitary(dif(), range(n))
qc.h(range(n))
qc.draw()
#To print the statevector.
s_qc = qi.Statevector.from_instruction(qc)
#s_qc.draw('latex', prefix='State = ')
print(s_qc)
#Applying the measurements.
qc.measure(range(n),range(n))
qc.draw()
#Simulating the circuit
qasm_sim = Aer.get_backend('aer_simulator')
tqc = transpile(qc, basis_gates=['u', 'cx'], optimization_level=3)
print(f"circuit depth: {tqc.depth()}")
print(f"circuit contains {tqc.count_ops()['cx']} CNOTs")
#Getting final state probabilities.
counts = qasm_sim.run(tqc).result().get_counts()
print(counts)
plot_histogram(counts)
|
https://github.com/deveshq/QC-with-qiskit
|
deveshq
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
from qiskit.quantum_info import Statevector
#Defining Quantum circuit
bell0 = QuantumCircuit(2)
#Creating Bell state
bell0.h(0)
bell0.cx(0,1)
#Extracting statevector
sv = Statevector.from_label('00')
sv_ev = sv.evolve(bell0)
sv_ev.draw('latex')
sv_ev.draw('qsphere')
#Defining Quantum circuit
bell1 = QuantumCircuit(2)
#Creating Bell state
bell1.h(0)
bell1.cx(0,1)
#Extracting statevector
sv1 = Statevector.from_label('01')
sv_ev1 = sv1.evolve(bell1)
sv_ev1.draw('latex')
sv_ev1.draw('qsphere')
#Defining Quantum circuit
bell2 = QuantumCircuit(2)
#Creating Bell state
bell2.x(1)
bell2.h(0)
bell2.cx(0,1)
#Extracting statevector
sv_ev2 = sv.evolve(bell2)
sv_ev2.draw('latex')
sv_ev2.draw('qsphere')
#Defining Quantum circuit
bell3 = QuantumCircuit(2)
#Creating Bell state
bell3.x(0)
bell3.x(1)
bell3.h(0)
bell3.cx(0,1)
#Extracting statevector
sv_ev3 = sv.evolve(bell3)
sv_ev3.draw('latex')
sv_ev3.draw('qsphere')
bell3.draw('text')
qc_ghz = QuantumCircuit(3)
qc_ghz.h(0)
qc_ghz.cx([0,0],[1,2])
qc_ghz.draw('text')
qc_ghz.draw()
sv = Statevector.from_label('000')
sv_ev = sv.evolve(qc_ghz)
sv_ev.draw('latex')
sv = Statevector.from_int(0,2**3)
sv_ev = sv.evolve(qc_ghz)
sv_ev.draw('latex')
BasicAer.backends()
ghz_backend = Aer.get_backend('statevector_simulator')
job = execute(qc_ghz, ghz_backend, shots = 1000)
result = job.result()
sv_ghz2 = result.get_statevector(qc_ghz)
plot_state_qsphere(sv_ghz2)
plot_state_city(sv_ghz2, title = 'GHZ')
plot_state_hinton(sv_ghz2, title = 'GHZ')
plot_state_paulivec(sv_ghz2, title = 'GHZ')
plot_bloch_multivector(sv_ghz2, title = 'GHZ')
plot_bloch_vector([0,0.5,1])
q_a = QuantumRegister(1, 'q_a')
q_b = QuantumRegister(1, 'q_b')
qc = QuantumCircuit(q_a,q_b)
qc.h(0)
qc.z(0)
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend, shots = 1000)
res = job.result()
sv = res.get_statevector()
#sv.draw('latex')
plot_bloch_multivector(sv)
plot_state_city(sv, color = ['orange', 'black'])
qc.measure_all()
backend = Aer.get_backend('qasm_simulator')
res = execute(qc, backend, shots = 1000).result()
counts = res.get_counts()
plot_histogram(counts)
meas = QuantumCircuit(3,3)
meas.barrier()
meas.measure([0,1,2],[0,1,2])
circ = meas.compose(qc_ghz, range(3), front = True )
circ.draw()
backend = Aer.get_backend('qasm_simulator')
res = backend.run(circ, shots = 1000).result()
counts = res.get_counts()
print(counts)
res2 = execute(circ, backend, shots = 1000).result()
counts2 = res2.get_counts()
print(counts2)
legend = ['Count-1', 'Count-2']
colour = ['teal', 'black']
plot_histogram([counts,counts2], legend=legend, sort='asc', color=colour) #, bar_labels = False)
provider.backends()
from qiskit.tools import job_monitor
import qiskit.tools.jupyter
#%qiskit_job_watcher
quito = provider.get_backend('ibmq_quito')
job = execute(circ, quito, shots = 1000)
job_monitor(job)
counts3 = job.result().get_counts()
plot_histogram(counts3)
from qiskit.quantum_info import Operator
U = Operator(qc_ghz)
U.data
np.around(U.data, 3)
uni_backend = Aer.get_backend('unitary_simulator')
U = execute(qc_ghz, uni_backend).result().get_unitary(decimals=3)
U
q = QuantumRegister(2, 'q_reg')
c = ClassicalRegister(2, 'c_reg')
qc = QuantumCircuit(q,c)
qc.h([0,1])
qc.cx(q[0],q[1])
qc.draw('mpl')
U_bell = Operator(qc)
np.around(U_bell, 3)
uni_backend = Aer.get_backend('unitary_simulator')
U = execute(qc, uni_backend).result().get_unitary(decimals=3)
U
a = 1/np.sqrt(3)
desired_state = [a, np.sqrt(1-a**2)]
q = QuantumRegister(1, 'q')
qc = QuantumCircuit(q)
qc.initialize(desired_state,0)
qc.draw('mpl')
qc.decompose().draw()
qc.measure_all()
qc.draw()
backend = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1000).result().get_counts()
plot_histogram(counts)
back_sv = BasicAer.get_backend('statevector_simulator')
result = execute(qc, back_sv).result()
qc_sv = result.get_statevector()
qc_sv
from qiskit.quantum_info import state_fidelity
state_fidelity(desired_state, qc_sv)
# Gate and prrocess fidility
from qiskit.circuit.library import XGate
from qiskit.quantum_info import Operator, average_gate_fidelity, process_fidelity
op_a = Operator(XGate())
op_b = np.exp(1j / 2) * op_a
#these differ only by a phase so the gate and process
#fidelities are expected to be 1
a = average_gate_fidelity(op_a,op_b)
a
b = process_fidelity(op_a, op_b)
a == b
back = Aer.get_backend('unitary_simulator')
result = execute(qc, back).result()
U_qc = result.get_unitary(decimals = 3)
U_qc
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0,1)
qc.cx(1,2)
qc.draw()
qc_gate = qc.to_gate()
qc_gate.name = 'Bell State Gate'
circ = QuantumCircuit(3)
circ.append(qc_gate, [0,1,2])
circ.draw()
circ.decompose().draw()
c_qc_gate = qc.to_gate().control(2)
c_qc_gate.name = 'C-Bell State Gate'
circ2 = QuantumCircuit(5)
circ2.append(c_qc_gate, [0,4,1,2,3])
circ2.draw()
circ2.decompose().draw()
#going back to our simpler circuit!
qc = QuantumCircuit(3)
qc.mct([0,1],2)
qc.cx(0,2)
qc.h(1)
qc.z(0)
qc.draw(scale = 1.5, style = {'backgroundcolor': 'lightpink'})
trans = transpile(qc, basis_gates = ['u3','cx','s'])
trans.draw('mpl')
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(qc, output='text')
qc.measure_all()
qasm_str = qc.qasm() #returning a qasm string, THIS SIMPLE
qasm_str
circ = QuantumCircuit.from_qasm_str(qasm_str) #you got to be kidding!
circ.draw()
qc.depth()
qiskit.__version__
#this is your tool to get all the information on all the hardware available, check it for yourself!
import qiskit.tools.jupyter
%qiskit_backend_overview
#that's not a problem!
from qiskit.visualization import plot_gate_map
backend = provider.get_backend('ibmq_manila')
plot_gate_map(backend, plot_directed=True) #check other things you can do in this within docs!
plot_error_map(backend)
qc = QuantumCircuit(3)
qc.h([0,1,2])
qc.measure_all()
sim = BasicAer.get_backend('qasm_simulator')
couple_map = [[0,2],[1,2]] #specify some linear connection
job = execute(qc, sim, shots=1000, coupling_map=couple_map) #here is how you take that in execute also!
result = job.result()
counts = result.get_counts()
print(counts)
|
https://github.com/deveshq/QC-with-qiskit
|
deveshq
|
#some necessary imports libraries
import numpy as np
from numpy import pi
import qiskit
from qiskit import *
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_gate_map, plot_circuit_layout, array_to_latex
from qiskit.providers.aer import noise
from qiskit.quantum_info import Operator
import matplotlib.pyplot as plt
%matplotlib inline
IBMQ.load_account()
backend = Aer.get_backend('qasm_simulator')
# Creating circuit
def ev_circ(qc,J,t):
#qc.h(qr[0])
#qc.barrier()
psi = J*t
for i in range(1):
#sigma_x sigma_x term
qc.ry(pi/2, qr[i])
qc.ry(pi/2, qr[i+1])
qc.cx(qr[i],qr[i+1])
qc.rz(2*psi, qr[i+1])
qc.cx(qr[i],qr[i+1])
qc.ry(-pi/2, qr[i+1])
qc.ry(-pi/2, qr[i])
qc.barrier()
#sigma_y sigma_y term
qc.rx(pi/2, qr[i])
qc.rx(pi/2, qr[i+1])
qc.cx(qr[i],qr[i+1])
qc.rz(2*psi, qr[i+1])
qc.cx(qr[i],qr[i+1])
qc.rx(-pi/2, qr[i+1])
qc.rx(-pi/2, qr[i])
qc.barrier()
#sigma_z sigma_z term
qc.cx(qr[i],qr[i+1])
qc.rz(2*psi, qr[i+1])
qc.cx(qr[i],qr[i+1])
return qc
#Simulating circuit
def sim(i):
[circ2[j].measure(qr[i],cr[0]) for j in range(len(circ2))]
result_sim = execute(circ2, backend, shots=1024).result()
a = result_sim.get_counts()
p0 = []
p1 = []
for k in range(len(a)):
if '0' in a[k]:
p0.append(a[k]['0'])
else:
p0.append(0)
if '1' in a[k]:
p1.append(a[k]['1'])
else:
p1.append(0)
p = (np.array(p0)-np.array(p1))/(2*1024)
return p
qc = QuantumCircuit(qr,cr)
t = 1
circ = ev_circ(qc,J,t)
circ.draw('mpl')
J = 0.01183898*2
total_t = 100
del_t = 1
num_steps = int(total_t/del_t)
qr = QuantumRegister(2, 'q')
cr = ClassicalRegister(1, 'c')
circ2 = []
d = []
for step in range(0, num_steps+1):
qc = QuantumCircuit(qr,cr)
t = (step)*del_t
d.append(J*t)
circ2.append(ev_circ(qc,J,t))
circ2[2].draw('mpl')
prob = {}
for i in range(2):
p = sim(i)
prob['q'+str(i)] = p
fig = plt.figure(figsize=[10,6])
plt.plot(d,prob['q0'])
plt.plot(d,prob['q1'])
#plt.title('')
plt.xlabel(rf'Jt $\longrightarrow$',fontsize=15)
plt.ylabel(rf'Magnetisation $\longrightarrow$',fontsize=15)
plt.legend(['q0','q1'])
plt.show()
|
https://github.com/deveshq/QC-with-qiskit
|
deveshq
|
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
qc.h(2)
qc.cp(pi/2, 1, 2)
qc.cp(pi/4, 0, 2)
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0, 2)
qc.draw()
def qft_rotations(circuit, n):
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw()
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5 (101 in binary)
qc.x(0)
qc.x(2)
qc.draw()
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qft(qc, 3)
qc.draw()
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/deveshq/QC-with-qiskit
|
deveshq
|
#initialization
import matplotlib.pyplot as plt
import numpy as np
import math
# importing Qiskit
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
# import basic plot tools
from qiskit.visualization import plot_histogram
qpe = QuantumCircuit(4, 3)
qpe.x(3)
#Apply Hadamard gate
for qubit in range(3):
qpe.h(qubit)
qpe.draw()
repetitions = 1
for counting_qubit in range(3):
for i in range(repetitions):
qpe.cp(math.pi/4, counting_qubit, 3); # This is CU # we use 2*pi*(1/theta)
repetitions *= 2
qpe.draw()
def qft_dagger(qc, n):
"""n-qubit QFTdagger the first n qubits in circ"""
# Don't forget the Swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-math.pi/float(2**(j-m)), m, j)
qc.h(j)
qpe.barrier()
# Apply inverse QFT
qft_dagger(qpe, 3)
# Measure
qpe.barrier()
for n in range(3):
qpe.measure(n,n)
qpe.draw()
aer_sim = Aer.get_backend('aer_simulator')
shots = 2048
t_qpe = transpile(qpe, aer_sim)
qobj = assemble(t_qpe, shots=shots)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
# Create and set up circuit
qpe2 = QuantumCircuit(4, 3)
# Apply H-Gates to counting qubits:
for qubit in range(3):
qpe2.h(qubit)
# Prepare our eigenstate |psi>:
qpe2.x(3)
# Do the controlled-U operations:
angle = 2*math.pi/3
repetitions = 1
for counting_qubit in range(3):
for i in range(repetitions):
qpe2.cp(angle, counting_qubit, 3);
repetitions *= 2
# Do the inverse QFT:
qft_dagger(qpe2, 3)
# Measure of course!
for n in range(3):
qpe2.measure(n,n)
qpe2.draw()
# Let's see the results!
aer_sim = Aer.get_backend('aer_simulator')
shots = 4096
t_qpe2 = transpile(qpe2, aer_sim)
qobj = assemble(t_qpe2, shots=shots)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
# Create and set up circuit
qpe3 = QuantumCircuit(6, 5)
# Apply H-Gates to counting qubits:
for qubit in range(5):
qpe3.h(qubit)
# Prepare our eigenstate |psi>:
qpe3.x(5)
# Do the controlled-U operations:
angle = 2*math.pi/3
repetitions = 1
for counting_qubit in range(5):
for i in range(repetitions):
qpe3.cp(angle, counting_qubit, 5);
repetitions *= 2
# Do the inverse QFT:
qft_dagger(qpe3, 5)
# Measure of course!
qpe3.barrier()
for n in range(5):
qpe3.measure(n,n)
qpe3.draw()
# Let's see the results!
aer_sim = Aer.get_backend('aer_simulator')
shots = 4096
t_qpe3 = transpile(qpe3, aer_sim)
qobj = assemble(t_qpe3, shots=shots)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/deveshq/QC-with-qiskit
|
deveshq
|
import numpy as np
#Importing standard Qiskit libraries
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.providers import *
from qiskit.circuit import Parameter
import matplotlib.pyplot as plt
#Loading IBM Quantum account(s)
provider = IBMQ.load_account()
q = QuantumRegister(1,'q')
e = QuantumRegister(1,'e')
c = ClassicalRegister(1,'c')
def damp_M(steps):
qc = QuantumCircuit(q,e,c)
theta = np.pi/8
qc.x(q)
qc.barrier()
for i in range(steps):
if (i>0):
qc.reset(e)
qc.cry(theta,q,e)
qc.cx(e,q)
qc.measure(e,c)
qc.barrier()
qc.measure(q,c)
sim = Aer.get_backend('qasm_simulator')
job = execute(qc, sim, shots=1024)
res = job.result()
counts = res.get_counts()
return counts
qc = damp_M(1)
qc.draw('mpl')
steps = np.linspace(0,150,51)
prob0 = []
for st in steps:
co = damp_M(int(st))
if '1' in co:
prob0.append(co['1']/1024)
else:
prob0.append(0)
fig = plt.figure(figsize=(8,5))
plt.scatter(steps,prob0)
plt.plot(steps,prob0)
plt.xticks(size=12)
plt.yticks(size=12)
plt.title('\nMarkovian amplitude damping of a qubit', size=14)
plt.xlabel(r'Steps $\longrightarrow$', size=13)
plt.ylabel(r'Population density $\longrightarrow$', size=13)
plt.show()
q = QuantumRegister(1,'q')
e = QuantumRegister(3,'e')
c = ClassicalRegister(1,'c')
def damp_NM(steps):
qc = QuantumCircuit(q,e,c)
t1 = np.pi/8
t2 = 5*np.pi/6
t3 = np.pi
qc.x(q)
qc.barrier()
for i in range(steps):
qc.cry(t1,q,e[0])
qc.cry(t2,q,e[1])
qc.cry(t3,q,e[2])
qc.cx(e[0],q[0])
qc.measure(e[0],c)
qc.reset(e[0])
qc.swap(e[0],e[1])
qc.swap(e[1],e[2])
qc.barrier()
qc.measure(q,c)
sim = Aer.get_backend('qasm_simulator')
job = execute(qc, sim, shots=1024)
res = job.result()
counts = res.get_counts()
return counts
qc = damp_NM(1)
qc.draw('mpl')
steps = np.linspace(0,150,51)
prob0_NM = []
for st in steps:
co = damp_NM(int(st))
if '1' in co:
prob0_NM.append(co['1']/1024)
else:
prob0_NM.append(0)
fig = plt.figure(figsize=(8,5))
plt.scatter(steps,prob0_NM)
plt.plot(steps,prob0_NM)
plt.xticks(size=12)
plt.yticks(size=12)
plt.title('\nNon-Markovian amplitude damping of a qubit', size=14)
plt.xlabel(r'Steps $\longrightarrow$', size=13)
plt.ylabel(r'Population density $\longrightarrow$', size=13)
plt.show()
fig = plt.figure(figsize=(8,5))
plt.plot(steps,prob0)
#plt.scatter(steps,prob0)
plt.plot(steps,prob0_NM)
#plt.scatter(steps,prob0_NM)
plt.xticks(size=12)
plt.yticks(size=12)
plt.legend(['Markovian','Non-Markovian'])
plt.title('\nDamping of a qubit', size=14)
plt.xlabel(r'Steps $\longrightarrow$', size=13)
plt.ylabel(r'Population density $\longrightarrow$', size=13)
plt.show()
|
https://github.com/deveshq/QC-with-qiskit
|
deveshq
|
import numpy as np
#Importing standard Qiskit libraries
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.providers import *
from qiskit.circuit import Parameter
import matplotlib.pyplot as plt
#Loading IBM Quantum account(s)
provider = IBMQ.load_account()
q = QuantumRegister(1,'q') #System register
e = QuantumRegister(1,'e') #Environment register
c = ClassicalRegister(1,'c')
def dephasing_M(steps):
qc = QuantumCircuit(q,e,c)
theta = np.pi/5
qc.h(0)
qc.barrier()
for i in range(steps):
if (i>0):
qc.reset(e)
qc.ry(theta,1)
qc.cz(0,1)
qc.measure(e,c)
qc.barrier()
qc.h(q)
qc.measure(q,c)
sim = Aer.get_backend('qasm_simulator')
job = execute(qc, sim, shots=1024)
res = job.result()
counts = res.get_counts()['0']/1024
return counts
qc = dephasing_M(1)
qc.draw('mpl')
steps = np.linspace(0,100,21)
prob0 = []
for st in steps:
prob0.append(dephasing_M(int(st)))
fig = plt.figure(figsize=(8,5))
plt.scatter(steps,prob0)
plt.plot(steps,prob0)
plt.xticks(size=12)
plt.yticks(size=12)
plt.title('\nDephasing of a qubit', size=14)
plt.xlabel(r'Steps $\longrightarrow$', size=13)
plt.ylabel(r'Population in Hadamard basis $\longrightarrow$', size=13)
plt.show()
q = QuantumRegister(1,'q') #System register
e = QuantumRegister(3,'e') #Environment register
c = ClassicalRegister(1,'c')
def dephasingNM(steps):
qc = QuantumCircuit(q,e,c)
t1 = np.pi/5
t2 = np.pi/4
t3 = np.pi/2
qc.h(0)
qc.barrier()
for i in range(steps):
qc.ry(t1,e[0])
qc.ry(t2,e[1])
qc.ry(t3,e[2])
qc.cz(q[0],e[0])
qc.measure(e[0],c)
qc.reset(e[0])
qc.swap(e[0],e[1])
qc.swap(e[1],e[2])
qc.barrier()
qc.h(q)
qc.measure(q,c)
sim = Aer.get_backend('qasm_simulator')
job = execute(qc, sim, shots=1024)
res = job.result()
counts = res.get_counts()['0']/1024
return counts
qc = dephasingNM(1)
qc.draw('mpl')
steps = np.linspace(0,100,21)
prob0_NM = []
for st in steps:
prob0_NM.append(dephasingNM(int(st)))
fig = plt.figure(figsize=(8,5))
plt.scatter(steps,prob0_NM)
plt.plot(steps,prob0_NM)
plt.xticks(size=12)
plt.yticks(size=12)
plt.title('\nDephasing of a qubit', size=14)
plt.xlabel(r'Steps $\longrightarrow$', size=13)
plt.ylabel(r'Population in Hadamard basis $\longrightarrow$', size=13)
plt.show()
fig = plt.figure(figsize=(8,5))
plt.plot(steps,prob0)
plt.plot(steps,prob0_NM)
plt.xticks(size=12)
plt.yticks(size=12)
plt.legend(['Markovian','Non-Markovian'])
plt.title('\nDephasing of a qubit', size=14)
plt.xlabel(r'Steps $\longrightarrow$', size=13)
plt.ylabel(r'Population in Hadamard basis $\longrightarrow$', size=13)
plt.show()
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
#setup.py
import numpy as np
from scipy.linalg import expm
from qiskit.extensions import UnitaryGate
from qiskit.circuit.add_control import add_control
from qiskit import Aer
import circuit
import hhl
import tools
#참고 논문 :Low Complexity Quantum Matrix Inversion A기gorithm for non-Hermitian Matrices
def main(A,b,backend,shots,t,n_l,delta):
#Check if Hermitian
if np.allclose(A,A.T) == False:
print("Given A matrice is not Hermitian.")
print("Given Matrices will be transformed into Hermitian formation.")
A = np.vstack((np.hstack((np.zeros_like(A),A)),np.hstack((A.T, np.zeros_like(A))))) # Hermitian의 꼴로 바꿈
b = np.hstack((b,np.zeros_like((np.shape(A)[0]-np.shape(b)[0],1))))
#A의 shape와 동일한 zero array를 생성하고, A의 왼쪽에 배치, horizontal 방향도 마찬가지.
i = complex(0,1) #complex(real part, imaginary part)
U = expm(i*A*t) #여기서 A가 행렬로 주어졌기 때문에, 행렬을 exp에 올리기 위해서는 expm이라는 scipy 패키지가 필요함.
U_gate = UnitaryGate(U) #위에서 구성한 U라는 행렬로써 Unitary gate를 구성할 수 있음. (4*4) 행렬
CU = add_control(U_gate,1,ctrl_state=None, label="CU")
#CU라는 게이트 이름을 label에 저장
#control 되는 경우의 state를 지정 -> 해당사항 없음
#두번째 인자는 컨트롤 큐빗의 개수를 지정함.
n_b = int(np.log2(U.shape[0]))
#Ax =b의 꼴이고, b는 4*1의 shape이므로, A의 행의 개수와 동일함. 따라서, U의 행렬의 행의 개수와 동일함.
#행의 개수에 log2를 취하면 필요한 n_b의 값을 구할 수 있음.
My_HHL_result = hhl.My_HHL(CU,b,n_l,n_b,backend,delta,shots,A,details = True,chevyshev = False)
print("\n")
qiskit_result = hhl.qiskit_HHL(A,b,backend)
print("\n")
classical_result = hhl.classical_HHL(A,b)
print("\n")
#For normalized answer
print("<Un - normalized Case Comparision>")
print('Qiskit Error : {0}'.format(np.linalg.norm(qiskit_result[1]-classical_result[1])))
print('My HHL Error : {0}'.format(np.linalg.norm(My_HHL_result[1]-classical_result[1])))
print("\n")
print("<Normalized Case Comparision>")
print('Qiskit Error : {0}'.format(np.linalg.norm(qiskit_result[0]-classical_result[0])))
print('My HHL Error : {0}'.format(np.linalg.norm(My_HHL_result[0]-classical_result[0])))
if __name__ == "__main__":
#setups
A = np.array([[2,-1],[1,4]]) #non-Hermitian인 경우의 행렬에 대한 저장
b = np.array([1,1])
backend = Aer.get_backend('aer_simulator')
shots = 8192
t = np.pi*2/16
n_l = 3 #QPE 상에서 n_ㅣ는 하다마드로 초기화 되는 부분
delta = 1/16*(2**(n_l-1))
main(A,b,backend,shots,t,n_l,delta)
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
#circuit_parts.py
from qiskit.circuit.library.arithmetic.exact_reciprocal import ExactReciprocal
from qiskit.circuit.library.arithmetic.piecewise_chebyshev import PiecewiseChebyshev
from qiskit import QuantumCircuit, QuantumRegister,Aer
import numpy as np
def qft_dagger(n_l):
# <qft를 구현하는 과정에 있어서 SWAP gate에 대한 참고사항>
# SWAP 게이트를 걸어주는 목적은 qiskit은 qubit을 반대방향으로 읽기 때문임.
# 하지만, SWAP 게이트를 위와 같은 이유로 걸어주게 된다고 하면,
# HHL 알고리즘 상에서 Eigeninversion 단계에서 문제가 생기게 됨.
# 즉, Eigeninversion에서는 SWAP이 된 상태를 인지하지 못하고 연산을 실시하여 잘못된 연산이 나오게 됨.
"""n-qubit QFTdagger the first n qubits in circ"""
nl_rg = QuantumRegister(n_l, "l")
qc = QuantumCircuit(nl_rg)
# Don't forget the Swaps!
#QFT의 역연산은 곧 QFT_dagger임을 기억하자.
for j in reversed(range(n_l)):
qc.h(j)
for m in reversed(range(j)):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.name = "QFT†"
#display(qc.draw(output = 'mpl'))
return qc
def QPE(n_l,n_b,CU):
#circuit initialization for HHL
nl_rg = QuantumRegister(n_l, "l")
nb_rg = QuantumRegister(n_b, "b")
#QuantumRegister(size=None, name=None, bits=None)
qc = QuantumCircuit(nl_rg,nb_rg)
#display(qc.draw(output = 'mpl'))
qc.h(nl_rg)
qc.barrier(nl_rg[:]+nb_rg[:])
for l in range(n_l):
for power in range(2**(l)):
qc.append(CU, [nl_rg[l],nb_rg[0],nb_rg[1]])
#첫번째 큐비트는 2^0번, 이후 2^n꼴로 돌아가게 설계됨.
#https://qiskit.org/documentation/stubs/qiskit.circuit.ControlledGate.html append의 예제.
#즉, append의 첫번째 인자는 gate, 두번쨰 인자의 첫번째 요소는 control qubit, 이후 인자의 요소는 target qubit.
qc.barrier(nl_rg[:]+nb_rg[:])
qc.append(qft_dagger(n_l),nl_rg[:])
qc.barrier(nl_rg[:]+nb_rg[:])
qc.name = "QPE"
#display(qc.draw(output = 'mpl'))
return qc
def QPE_dagger(n_l,n_b,CU):
qc = QPE(n_l,n_b,CU)
qc = qc.inverse()
#여기서 inverse함수는 모든 rotation 각도까지도 반대로 입력해줌을 확인하였음.
#QPE dagger는 그저, QPE의 역과정이라고 생각하면 된다. 단, 각도는 반대방향이어야 함.
#따라서 여기서 inverse함수를 이용하여 QPE의 역과정, 즉, QPE dagger를 실시하였음
qc.name = 'QPE†'
return qc
def Eigenvalue_inversion(n_l,delta,chevyshev = False):
#Chevyshev 근사를 이용한 풀이방법.
#Qiskit에서 제공한 HHL 알고리즘 상에서는 Chevyshev 근사를 이용한 부분이 있었다.
#일단 Chevyshev 근사를 이용하는 경우, 기존 Taylor 근사보다 훨씬 빠르게 급수에 수렴한다는 장점이 있다.
#참고 문헌 : https://freshrimpsushi.github.io/posts/chebyshev-expansion/
#여기서는 위의 표현한 cos(theta)에 대한 표현을 Chevyshev근사를 이용해 theta값을 알아내겠다는 접근방법이다.
#하지만, 근사결과가 좋지 못하다는 점 때문에 Chevyshev 근사를 이용하는 대신에 직접 exact한 theta값을 알아내는 ExactReciprocal을 이용하였다.
if chevyshev == True:
print("Maybe using Chevyshev approximation is not accurate.")
#Using Chebychev Approx. (not recommended!)
nl_rg = QuantumRegister(n_l, "l")
na_rg = QuantumRegister(n_l, "a")
nf_rg = QuantumRegister(1, "f")
qc = QuantumCircuit(nl_rg, na_rg, nf_rg)
f_x, degree, breakpoints, num_state_qubits = lambda x: np.arcsin(1 / x), 2, [1,2,3,4], n_l
#degree : 함수를 polynomial로 근사할 떄, 최고차항 정의
#breakpoints는 구간을 나누는 느낌. : 근사를 할 떄, 다항식을 어떤 구간에서 나눠서 사용할 지
#l : eigenvalue를 표현
#f : rotation
#a : ancila
pw_approximation = PiecewiseChebyshev(f_x, degree, breakpoints, num_state_qubits)
pw_approximation._build()
qc.append(pw_approximation,nl_rg[:]+[nf_rg[0]]+na_rg[:]) #range(nl*2+1))
qc.name = 'Chevyshev_inversion'
return qc
else:
qc = ExactReciprocal(n_l, delta, neg_vals = True)
qc.name = 'Reciprocal_inversion'
return qc
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
#measurement.py
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.visualization import plot_histogram
def measurement(qc,n_l,n_b,CU,backend,shots):
t = transpile(qc, backend)
qobj = assemble(t, shots=shots)
results = backend.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer, title="Output Histogram").savefig('./outputs/output_histogram.png',facecolor='#eeeeee')
return answer
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
#run.py
'''
참고 논문 :Low Complexity Quantum Matrix Inversion A기gorithm for non-Hermitian Matrices
해당 논문에서, non-Hermitian인 경우에 Hermitian으로 바꾸기 위해서 2*2의 행렬을 4*4 행렬로 바꾸었다.
밑의 주어진 코드를 통해 이해해보도록하자.
A = np.array([[2,-1],[1,4]])의 꼴로 주어진 A는 non-Hermitian의 꼴이다.
그러므로, 이를 def main - #Check if Hermitian 파트에서 다음과 같은 코드로 아래와 같은 Hermitian으로 바꾸게 된다.
(코드) A = np.vstack((np.hstack((np.zeros_like(A),A)),np.hstack((A.T, np.zeros_like(A)))))
이에 맞게 나머지 x와 b의 행렬의 형태도 4*1의 형태로 바꾸어주어야 한다.
즉, x = [ 0, 0, x1, x2]의 꼴로, 그리고 b는 [1 1 0 0]의 꼴로 바꾸어야 한다.
(결과)
[[ 0 0 2 -1]
[ 0 0 1 4]
[ 2 1 0 0]
[-1 4 0 0]]
'''
import numpy as np
from scipy.linalg import expm
from qiskit.extensions import UnitaryGate
from qiskit.circuit.add_control import add_control
from qiskit import Aer
import circuit
import hhl
import tools
def main(A,b,backend,shots,t,n_l,delta):
#Check if Hermitian
#위에서 언급한 바대로 non-Hermitian matrice인 A에 대해서 Hermitian으로 바꿔주는 과정
if np.allclose(A,A.T) == False:
print("Given A matrice is not Hermitian.")
print("Given Matrices will be transformed into Hermitian formation.")
A = np.vstack((np.hstack((np.zeros_like(A),A)),np.hstack((A.T, np.zeros_like(A))))) # Hermitian의 꼴로 바꿈
#A의 shape와 동일한 zero array를 생성하고, A의 왼쪽에 배치, horizontal 방향도 마찬가지.
b = np.hstack((b,np.zeros_like((np.shape(A)[0]-np.shape(b)[0],1))))
i = complex(0,1) #complex(real part, imaginary part)
U = expm(i*A*t) #여기서 A가 행렬로 주어졌기 때문에, 행렬을 exp에 올리기 위해서는 expm이라는 scipy 패키지가 필요함.
U_gate = UnitaryGate(U) #위에서 구성한 U라는 행렬로써 Unitary gate를 구성할 수 있음. (4*4) 행렬
CU = add_control(U_gate,1,ctrl_state=None, label="CU")
#CU라는 게이트 이름을 label에 저장
#control 되는 경우의 state를 지정 -> 해당사항 없음
#두번째 인자는 컨트롤 큐빗의 개수를 지정함.
n_b = int(np.log2(U.shape[0]))
#Ax =b의 꼴이고, b는 4*1의 shape이므로, A의 행의 개수와 동일함. 따라서, U의 행렬의 행의 개수와 동일함.
#행의 개수에 log2를 취하면 필요한 n_b의 값을 구할 수 있음.
#각각 HHL 알고리즘이 구현된 방식으로 결과를 얻는다
My_HHL_result = hhl.My_HHL(CU,b,n_l,n_b,backend,delta,shots,A,details = True,chevyshev = False)
print("\n")
qiskit_result = hhl.qiskit_HHL(A,b)
print("\n")
classical_result = hhl.classical_HHL(A,b)
print("\n")
#For normalized answer
print("<Un - normalized Case Comparision>")
print('Qiskit Error : {0}'.format(np.linalg.norm(qiskit_result[1]-classical_result[1])))
print('My HHL Error : {0}'.format(np.linalg.norm(My_HHL_result[1]-classical_result[1])))
print("\n")
print("<Normalized Case Comparision>")
print('Qiskit Error : {0}'.format(np.linalg.norm(qiskit_result[0]-classical_result[0])))
print('My HHL Error : {0}'.format(np.linalg.norm(My_HHL_result[0]-classical_result[0])))
if __name__ == "__main__":
#setups
A = np.array([[2,-1],[1,4]]) #non-Hermitian인 경우의 행렬에 대한 저장
b = np.array([1,1])
backend = Aer.get_backend('aer_simulator')
shots = 8192
t = np.pi*2/16
n_l = 3 #QPE 상에서 n_ㅣ는 하다마드로 초기화 되는 부분
delta = 1/16*(2**(n_l-1))
main(A,b,backend,shots,t,n_l,delta)
#my_hhl.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import numpy as np
import circuit as circ
import tools
def My_HHL(CU,b,n_l,n_b,backend,delta,shots,A,details = True,chevyshev = False):
#circuit initialization
#qubit의 개수들을 정의한다.
n_f = 1
nb = int(np.log2(b.shape))
#정의된 qubit의 개수들을 기반으로 양자 레지스터들을 생성한다.
nl_rg = QuantumRegister(n_l, "l")
nb_rg = QuantumRegister(n_b, "b")
na_rg = QuantumRegister(n_l, "a")
nf_rg = QuantumRegister(n_f, "f")
#고전 레지스터들을 생성한다.
cf = ClassicalRegister(n_f, "classical_f")
cb = ClassicalRegister(n_b, "classical_b")
#생성된 레지스터들을 기반으로 비어있는 양자회로를 설치한다.
qc = QuantumCircuit(nf_rg,nl_rg, nb_rg, na_rg, cf, cb)
#isometry 패키지를 이용해서 normalized 된 b 행렬을 양자회로에 인코딩한다.
#즉. isometry라는 메서드는 어떤 행렬을 양자회로에 업로드 해주는 역할을 한다.
qc.isometry(b/np.linalg.norm(b), list(range(nb)), None)
qc.barrier(nf_rg,nl_rg,nb_rg)
#details는 양자 회로의 어떠한 instruction들을 세부적으로 표현할 것인지 아닌지에 대한 설정이다.
if details == True:
#compose를 이용해서 위에서 생성한 레지스터에 붙이는 경우, instruction 내의 모든 회로가 다 보임.
#또한, 더 많은 register들이 있는 회로에 적은 register들이 있는 회로를 가져다 붙이기 위해서는 compose에 인자로써 register가 적용될 순서를 명시해주어야함.
#구성한 circ 패키지 내에 있는 회로들을 compose를 이용해 가져다 붙이는 과정
#QPE -> Eigenvalue_inversion -> QPE_dagger 순으로 회로를 가져다 붙임
qc = qc.compose(circ.QPE(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc = qc.compose(circ.Eigenvalue_inversion(n_l,delta,chevyshev),[nl_rg[2]]+[nl_rg[1]]+[nl_rg[0]]+nf_rg[:])
qc = qc.compose(circ.QPE_dagger(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
else:
qc.append(circ.QPE(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.append(circ.Eigenvalue_inversion(n_l),[nl_rg[2]]+[nl_rg[1]]+[nl_rg[0]]+nf_rg[:])
qc.append(circ.QPE_dagger(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.barrier(nf_rg[:]+nl_rg[:]+nb_rg[:]) #레지스터의 이름과 그 안에 있는 큐비트들의 순서들을 조합하여 한번에 barrier를 세울 수 있음.
#측정 실시 파트
qc.measure(nf_rg,cf)
qc.measure(nb_rg,cb)
answer = circ.measurement(qc,n_l,n_b,CU,backend,shots)
qc.draw(output = 'mpl').savefig('./outputs/qc_HHL')
#Obtaining Normalized answer
normalized_result = tools.normalize_vector(answer, n_b)
#Obtaining Real Answer
'''
즉, normalized된 x값을 집어넣고, Ax = b 꼴에서 좌변을 계산한 후에 b와 몇배 차이인가를 알아내는 과정
여기서 몇배 차이를 나타내는게 constant임.
constant는 b와 같은 shape를 갖게 되고, ensemble로 얻어지는 양자회로의 특성상 explicit한 결과가 주어지지 않는다.
따라서, constant 벡터의 모든 요소들의 평균으로서 몇배 차이인지를 나타낸다.
'''
constant = b/(A @ normalized_result)
constant = (constant[0]+constant[1])/2
constant = np.mean(constant)
#결과 출력 파트
print('<My_HHL>')
print('Normalized Answer : {0}'.format(normalized_result))
print('Un-normalized Answer : {0}'.format(normalized_result * constant))
print('Normalize Constant: ' ,constant)
return [normalized_result,normalized_result * constant]
#classical_hhl.py
from qiskit.algorithms.linear_solvers.numpy_linear_solver import NumPyLinearSolver
import numpy as np
def classical_HHL(A,b):
#NumpyLinearSolver를 이용해서 주어진 행렬방정식을 풀어낸다.
'''
참고로, 여기선 un-normalized된 해로써 결과값이 나온다는 사실은 자명하다.
하지만 여기서 나온 해를 normalize를 통해서 my_hhl과 qiskit_hhl에서 내놓은 normalized된 해와의 차이를 분석하기 위해서
normalized Answer 또한 작성했다.
'''
sol = NumPyLinearSolver().solve(A, b)
sol_state = sol.state
norm_state = sol_state/np.linalg.norm(sol_state)
print('<Classical case using Numpy>')
if np.shape(b)[0] == 2:
sol_state = np.pad(sol_state,(2,0))
norm_state = np.pad(norm_state,(2,0))
print('Un-normalized Classical Numpy answer : {0}'.format(sol_state,(2,0)))
print('Normalized Classical Numpy answer : {0}'.format(norm_state,(2,0)))
return [norm_state,sol_state]
#qiskit_hhl.py
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer
from qiskit.quantum_info import Statevector
from qiskit.algorithms.linear_solvers.hhl import HHL
import numpy as np
def qiskit_HHL(A,b):
#해당 내용은 https://qiskit.org/textbook/ch-applications/hhl_tutorial.html의 solving 과정을 참고하였음
backend = Aer.get_backend('aer_simulator')
#qiskit HHL 코드를 불러옴
hhl = HHL(quantum_instance=backend)
#A, b에 대해서 HHL 회로를 구성
solution = hhl.solve(A, b)
#만들어진 회로를 그림으로 저장
solution.state.draw("mpl").savefig("./outputs/HHL_circuit_qiskit.png")
#연산된 상태를 상태 벡터의 형태로 결과를 얻음
naive_sv = Statevector(solution.state).data
#qubit수를 확인
num_qubit = solution.state.num_qubits
#상태 벡터에서 필요한 상태만을 골라서 저장함
naive_full_vector = np.array([naive_sv[2**(num_qubit-1)+i] for i in range(len(b))])
#실수 부분만 취함
naive_full_vector = np.real(naive_full_vector)
#얻어진 벡터를 normalize하여 반환
normalized_result = naive_full_vector/np.linalg.norm(naive_full_vector)
#마찬가지로 주어진 해를 통해 constant를 구함.
constant = b/(A @ normalized_result)
constant = (constant[0]+constant[1])/2
constant = np.mean(constant)
print('<Qiskit_HHL>')
print('Normalized Qiskit Answer : {0}'.format(normalized_result))
print('Un-normalized Qiskit Answer : {0}'.format(normalized_result * constant))
print('Normalize Constant: ' ,constant)
return [normalized_result,normalized_result * constant]
#circuit_parts.py
from qiskit.circuit.library.arithmetic.exact_reciprocal import ExactReciprocal
from qiskit.circuit.library.arithmetic.piecewise_chebyshev import PiecewiseChebyshev
from qiskit import QuantumCircuit, QuantumRegister,Aer
import numpy as np
def qft_dagger(n_l):
# <qft를 구현하는 과정에 있어서 SWAP gate에 대한 참고사항> - issue 해결에 대한 report 2022-09-02
# SWAP 게이트를 걸어주는 목적은 qiskit은 qubit을 반대방향으로 읽기 때문임.
# 하지만, SWAP 게이트를 위와 같은 이유로 걸어주게 된다고 하면,
# HHL 알고리즘 상에서 Eigeninversion 단계에서 문제가 생기게 됨.
# 즉, Eigeninversion에서는 SWAP이 된 상태를 인지하지 못하고 연산을 실시하여 잘못된 연산이 나오게 됨.
"""n-qubit QFTdagger the first n qubits in circ"""
nl_rg = QuantumRegister(n_l, "l")
qc = QuantumCircuit(nl_rg)
# Don't forget the Swaps!
#QFT의 역연산은 곧 QFT_dagger임을 기억하자.
for j in reversed(range(n_l)):
qc.h(j)
for m in reversed(range(j)):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.name = "QFT†"
#display(qc.draw(output = 'mpl'))
return qc
def QPE(n_l,n_b,CU):
#circuit initialization for HHL
nl_rg = QuantumRegister(n_l, "l")
nb_rg = QuantumRegister(n_b, "b")
#QuantumRegister(size=None, name=None, bits=None)
qc = QuantumCircuit(nl_rg,nb_rg)
#display(qc.draw(output = 'mpl'))
qc.h(nl_rg)
qc.barrier(nl_rg[:]+nb_rg[:])
for l in range(n_l):
for power in range(2**(l)):
qc.append(CU, [nl_rg[l],nb_rg[0],nb_rg[1]])
#첫번째 큐비트는 2^0번, 이후 2^n꼴로 돌아가게 설계됨.
#https://qiskit.org/documentation/stubs/qiskit.circuit.ControlledGate.html append의 예제.
#즉, append의 첫번째 인자는 gate, 두번쨰 인자의 첫번째 요소는 control qubit, 이후 인자의 요소는 target qubit.
qc.barrier(nl_rg[:]+nb_rg[:])
qc.append(qft_dagger(n_l),nl_rg[:])
qc.barrier(nl_rg[:]+nb_rg[:])
qc.name = "QPE"
#display(qc.draw(output = 'mpl'))
return qc
def QPE_dagger(n_l,n_b,CU):
qc = QPE(n_l,n_b,CU)
qc = qc.inverse()
#여기서 inverse함수는 모든 rotation 각도까지도 반대로 입력해줌을 확인하였음.
#QPE dagger는 그저, QPE의 역과정이라고 생각하면 된다. 단, 각도는 반대방향이어야 함.
#따라서 여기서 inverse함수를 이용하여 QPE의 역과정, 즉, QPE dagger를 실시하였음
qc.name = 'QPE†'
return qc
def Eigenvalue_inversion(n_l,delta,chevyshev = False):
#Chevyshev 근사를 이용한 풀이방법.
#Qiskit에서 제공한 HHL 알고리즘 상에서는 Chevyshev 근사를 이용한 부분이 있었다.
#일단 Chevyshev 근사를 이용하는 경우, 기존 Taylor 근사보다 훨씬 빠르게 급수에 수렴한다는 장점이 있다.
#참고 문헌 : https://freshrimpsushi.github.io/posts/chebyshev-expansion/
#여기서는 위의 표현한 cos(theta)에 대한 표현을 Chevyshev근사를 이용해 theta값을 알아내겠다는 접근방법이다.
#하지만, 근사결과가 좋지 못하다는 점 때문에 Chevyshev 근사를 이용하는 대신에 직접 exact한 theta값을 알아내는 ExactReciprocal을 이용하였다.
if chevyshev == True:
print("Maybe using Chevyshev approximation is not accurate.")
#Using Chebychev Approx. (not recommended!)
nl_rg = QuantumRegister(n_l, "l")
na_rg = QuantumRegister(n_l, "a")
nf_rg = QuantumRegister(1, "f")
qc = QuantumCircuit(nl_rg, na_rg, nf_rg)
f_x, degree, breakpoints, num_state_qubits = lambda x: np.arcsin(1 / x), 2, [1,2,3,4], n_l
#degree : 함수를 polynomial로 근사할 떄, 최고차항 정의
#breakpoints는 구간을 나누는 느낌. : 근사를 할 떄, 다항식을 어떤 구간에서 나눠서 사용할 지
#l : eigenvalue를 표현
#f : rotation
#a : ancila
pw_approximation = PiecewiseChebyshev(f_x, degree, breakpoints, num_state_qubits)
pw_approximation._build()
qc.append(pw_approximation,nl_rg[:]+[nf_rg[0]]+na_rg[:]) #range(nl*2+1))
qc.name = 'Chevyshev_inversion'
return qc
else:
qc = ExactReciprocal(n_l, delta, neg_vals = True)
qc.name = 'Reciprocal_inversion'
return qc
#measurement.py
'''
주어진 회로에 대해 backend를 가지고서 시뮬레이션을 하기 위한 모듈
'''
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.visualization import plot_histogram
def measurement(qc,n_l,n_b,CU,backend,shots):
t = transpile(qc, backend)
qobj = assemble(t, shots=shots)
results = backend.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer, title="Output Histogram").savefig('./outputs/output_histogram.png',facecolor='#eeeeee')
return answer
#normalization.py
import numpy as np
#양자 회로를 통해서 얻어진 결과(dictionary)를 통해서 normalize된 결과 벡터 x를 구하는 함수
def normalize_vector(answer, nb):
#nb register에서 얻어질 수 있는 상태들을 dictionary의 key의 형태로 만들어 저장한다.
possible_states = [] #가능한 모든 상태들을 저장하기 위한 list
for s in range(2**(nb)):
possible_states.append(format(s, "b").zfill(nb)) #nb만큼의 자릿수에 대해서 binary의 형태로 모든 경우의 수를 생성.
#print(answer)
#flag register를 측정한 결과가 1이 나온 경우에 대해서 nb register의 결과를 순서대로 추가한다.
available_result = []
for i in possible_states:
for key in answer.keys(): #정답의 key 즉, 상태들을 받아옴.
if key[0:2] == i: #얻은 상태들이 가능한 상태에 존재한다면,
if int(key[-1]) == 1: #그리고 마지막 자릿수, f_register가 1의 값을 갖는다면,
available_result.append(answer[key]) #avaliable_result에 f가 1인 상태들이 나온 횟수를 append 하자.
else:
pass
else:
pass
#확률 분포를 상태 벡터의 형식으로 바꾸기 위해서 제곱근을 취한다.
available_result = np.sqrt(np.array(available_result)) #확률 진폭은 계수의 제곱의 형태로 나오기 때문.
#벡터의 크기가 1이 되도록 normalize해준다.
normalized_result = available_result/np.linalg.norm(available_result)
return normalized_result
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import numpy as np
import circuit as circ
import tools
def My_HHL(CU,b,n_l,n_b,backend,delta,shots,A,details = True,chevyshev = False):
#b_sol = np.hstack((b,np.zeros_like((np.shape(A)[0]-np.shape(b)[0],1))))
#circuit initialization
n_f = 1
nb = int(np.log2(b.shape))
nl_rg = QuantumRegister(n_l, "l")
nb_rg = QuantumRegister(n_b, "b")
na_rg = QuantumRegister(n_l, "a")
nf_rg = QuantumRegister(n_f, "f")
cf = ClassicalRegister(n_f, "classical_f")
cb = ClassicalRegister(n_b, "classical_b")
qc = QuantumCircuit(nf_rg,nl_rg, nb_rg, na_rg, cf, cb)
qc.isometry(b/np.linalg.norm(b), list(range(nb)), None)
#qc.h(nb_rg[0])
qc.barrier(nf_rg,nl_rg,nb_rg)
if details == True:
qc = qc.compose(circ.QPE(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc = qc.compose(circ.Eigenvalue_inversion(n_l,delta,chevyshev),[nl_rg[2]]+[nl_rg[1]]+[nl_rg[0]]+nf_rg[:])
qc = qc.compose(circ.QPE_dagger(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.barrier(nf_rg[:]+nl_rg[:]+nb_rg[:])
qc.measure(nf_rg,cf)
qc.measure(nb_rg,cb)
answer = circ.measurement(qc,n_l,n_b,CU,backend,shots)
qc.draw(output = 'mpl').savefig('./outputs/qc_HHL')
else:
qc.append(circ.QPE(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.append(circ.Eigenvalue_inversion(n_l),[nl_rg[2]]+[nl_rg[1]]+[nl_rg[0]]+nf_rg[:])
qc.append(circ.QPE_dagger(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.barrier(nf_rg[:]+nl_rg[:]+nb_rg[:])
qc.measure(nf_rg,cf)
qc.measure(nb_rg,cb)
answer = circ.measurement(qc,n_l,n_b,CU,backend,shots)
qc.draw(output = 'mpl').savefig('./outputs/qc_HHL')
#Obtaining Normalized answer
normalized_result = tools.normalize_vector(answer, n_b)
#Obtaining Real Answer
constant = b/(A @ normalized_result)
constant = (constant[0]+constant[1])/2
constant = np.mean(constant)
print('<My_HHL>')
print('Normalized Answer : {0}'.format(normalized_result))
print('Un-normalized Answer : {0}'.format(normalized_result * constant))
print('Normalize Constant: ' ,constant)
return [normalized_result,normalized_result * constant]
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer
from qiskit.quantum_info import Statevector
from qiskit.algorithms.linear_solvers.hhl import HHL
import numpy as np
def qiskit_HHL(A,b):
backend = Aer.get_backend('aer_simulator')
#qiskit HHL 코드를 불러옴
hhl = HHL(quantum_instance=backend)
#A, b에 대해서 HHL 회로를 구성
solution = hhl.solve(A, b)
#만들어진 회로를 그림으로 저장
solution.state.draw("mpl").savefig("./outputs/HHL_circuit_qiskit.png")
#연산된 상태를 상태 벡터의 형태로 결과를 얻음
naive_sv = Statevector(solution.state).data
#qubit수를 확인
num_qubit = solution.state.num_qubits
#상태 벡터에서 필요한 상태만을 골라서 저장함
naive_full_vector = np.array([naive_sv[2**(num_qubit-1)+i] for i in range(len(b))])
#실수 부분만 취함
naive_full_vector = np.real(naive_full_vector)
#얻어진 벡터를 normalize하여 반환
normalized_result = naive_full_vector/np.linalg.norm(naive_full_vector)
constant = b/(A @ normalized_result)
constant = (constant[0]+constant[1])/2
constant = np.mean(constant)
print('<Qiskit_HHL>')
print('Normalized Qiskit Answer : {0}'.format(normalized_result))
print('Un-normalized Qiskit Answer : {0}'.format(normalized_result * constant))
print('Normalize Constant: ' ,constant)
return [normalized_result,normalized_result * constant]
|
https://github.com/klebermagno/Quantum-Algorithm
|
klebermagno
|
from qiskit import ClassicalRegister, QuantumRegister
from qiskit import QuantumCircuit, execute
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.cx(q[0], q[1])
qc.measure(q, c)
job_sim = execute(qc, "local_qasm_simulator")
sim_result = job_sim.result()
print(sim_result.get_counts(qc))
|
https://github.com/dnnagy/qintro
|
dnnagy
|
import math
import numpy as np
import matplotlib as mpl
from matplotlib import pyplot as plt
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_bloch_vector
from qiskit.visualization import plot_histogram
qbackend = Aer.get_backend('qasm_simulator')
sbackend = Aer.get_backend('statevector_simulator')
ubackend = Aer.get_backend('unitary_simulator')
qiskit.__version__
import torch
torch.__version__
import strawberryfields as sf
sf.__version__
help(sf)
import cirq
cirq.__version__
|
https://github.com/dnnagy/qintro
|
dnnagy
|
import numpy as np
from qiskit import *
import matplotlib
qr = QuantumRegister(2)
#measurements from quantum bits = use classical register
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr)
circuit.draw()
# adding quantum gates to create entanglement (Hadamart gate)
circuit.h(qr[0])
%matplotlib inline
circuit.draw(output='mpl')
#two qubit operation control X (logical if)
circuit.cx(qr[0], qr[1])
circuit.draw(output='mpl') #entanglement achieved
#measurement, storing measurements into computational register
circuit.measure(qr,cr)
circuit.draw(output='mpl')
#performance simulations
simulator = Aer.get_backend('qasm_simulator')
execute(circuit, backend = simulator)
result = execute(circuit, backend = simulator).result()
#plotting results
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(circuit))
#running circuit on quantum computer
IBMQ.load_account()
provider= IBMQ.get_provider('ibm-q')
qcomp = provider.get_backend('ibmq_manila')
job= execute(circuit, backend=qcomp)
from qiskit.tools import job_monitor
job_monitor(job)
result = job.result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(circuit), title='Performance metric on Quantum Computer')
|
https://github.com/dnnagy/qintro
|
dnnagy
|
import math
import numpy as np
import matplotlib as mpl
from matplotlib import pyplot as plt
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_bloch_vector
from qiskit.visualization import plot_histogram
qbackend = Aer.get_backend('qasm_simulator')
sbackend = Aer.get_backend('statevector_simulator')
ubackend = Aer.get_backend('unitary_simulator')
qiskit.__version__
import torch
torch.__version__
import strawberryfields as sf
sf.__version__
help(sf)
import cirq
cirq.__version__
|
https://github.com/dnnagy/qintro
|
dnnagy
|
import math
import numpy as np
import matplotlib as mpl
from matplotlib import pyplot as plt
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from qiskit.visualization import plot_bloch_multivector
from qiskit.visualization import plot_bloch_vector
from qiskit.visualization import plot_histogram
qbackend = Aer.get_backend('qasm_simulator')
sbackend = Aer.get_backend('statevector_simulator')
ubackend = Aer.get_backend('unitary_simulator')
qiskit.__version__
qreg = QuantumRegister(1)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg,creg)
circ.measure(0,0)
circ.draw(output='mpl')
job = execute( circ, qbackend, shots=1000 )
counts = job.result().get_counts()
fig, ax = plt.subplots()
plot_histogram(counts, ax = ax)
n_shots=1000
measure_psi = QuantumCircuit(1,1)
amps_psi = (1.0/np.sqrt(2))*np.array([1.0+0.0j, 0.0+1.0j])
measure_psi.initialize(amps_psi, 0)
measure_psi.measure(0,0)
job_psi = execute( measure_psi, qbackend, shots=n_shots )
counts_psi = job_psi.result().get_counts()
print("counts_psi =", counts_psi)
measure_phi = QuantumCircuit(1,1)
amps_phi = (1.0/np.sqrt(2))*np.array([0.0+1.0j, -1.0+0.0j])
measure_phi.initialize(amps_phi, 0)
measure_phi.measure(0,0)
job_phi = execute( measure_phi, qbackend, shots=n_shots )
counts_phi = job_phi.result().get_counts()
print("counts_phi =", counts_phi)
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(12,5), dpi=96)
plot_histogram(counts_psi, ax=axes[0])
axes[0].set_title(r'$\psi$')
plot_histogram(counts_phi, ax=axes[1])
axes[1].set_title(r'$\phi$');
n_shots=10000
measure_psi = QuantumCircuit(1,1)
amps_psi = [np.sqrt(0.45), np.sqrt(0.55)]
measure_psi.initialize(amps_psi, 0)
measure_psi.measure(0,0)
job_psi = execute( measure_psi, qbackend, shots=n_shots )
counts_psi = job_psi.result().get_counts()
print("counts_psi =", counts_psi)
measure_phi = QuantumCircuit(1,1)
amps_phi = [np.sqrt(0.5), np.sqrt(0.5)]
measure_phi.initialize(amps_phi, 0)
measure_phi.measure(0,0)
job_phi = execute( measure_phi, qbackend, shots=n_shots )
counts_phi = job_phi.result().get_counts()
print("counts_phi =", counts_phi)
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(12,5), dpi=96)
plot_histogram(counts_psi, ax=axes[0])
axes[0].set_title(r'$\psi$')
plot_histogram(counts_phi, ax=axes[1])
axes[1].set_title(r'$\phi$');
qreg = QuantumRegister(1)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg,creg)
# Apply gates
circ.x(0)
# Measure
circ.barrier(qreg)
circ.measure(0,0)
circ.draw(output='mpl')
job = execute( circ, qbackend, shots=10000 )
state = job.result().get_counts()
print("Counts:", state)
plot_histogram(state)
qreg = QuantumRegister(1)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg,creg)
# Apply gates
circ.h(0)
# Measure
circ.barrier(qreg)
circ.measure(0,0)
circ.draw(output='mpl')
job = execute( circ, qbackend, shots=10000 )
state = job.result().get_counts()
print("Counts:", state)
plot_histogram(state)
qreg = QuantumRegister(1)
creg = ClassicalRegister(1)
circ = QuantumCircuit(qreg,creg)
# Apply gates
circ.z(0)
circ.x(0)
circ.h(0)
# Measure
circ.barrier(qreg)
circ.measure(0,0)
circ.draw(output='mpl')
job = execute( circ, qbackend, shots=10000 )
state = job.result().get_counts()
print("Counts:", state)
plot_histogram(state)
ps = np.array([0.1, 0.2, .5, .2])
amplitudes = np.sqrt(ps)
qreg = QuantumRegister(2)
creg = ClassicalRegister(2)
circ = QuantumCircuit(qreg,creg)
circ.initialize(amplitudes, qreg)
circ.measure(qreg,creg)
circ.draw(output='mpl')
job = execute( circ, qbackend, shots=10000 )
state = job.result().get_counts()
print("Counts:", state)
plot_histogram(state)
# Random 4-qubit state
ps = np.random.randint(0, 255, 16)
ps = ps/ps.sum()
amplitudes = np.sqrt(ps)
# Setup
qreg = QuantumRegister(4)
creg = ClassicalRegister(4)
circ = QuantumCircuit(qreg,creg)
circ.initialize(amplitudes, qreg)
# Measure
m = QuantumCircuit(qreg, creg)
m.measure(qreg, creg)
job = execute( circ+m, qbackend, shots=10000 )
counts = job.result().get_counts()
m.draw(output='mpl')
plot_histogram(counts)
qreg = QuantumRegister(2)
creg = ClassicalRegister(2)
circ = QuantumCircuit(qreg,creg)
circ.x(0)
circ.h(0)
circ.cx(0,1)
circ.barrier(qreg)
circ.measure(qreg,creg)
circ.draw(output='mpl')
job = execute( circ, qbackend, shots=10000 )
counts = job.result().get_counts()
plot_histogram(counts)
# Create the quantum circuit with 2 qubits and 2 classical bits
qc = QuantumCircuit(2, 2)
qc.barrier()
# First generate the entangled pair between Alice and Bob (Remember: Hadamard followed by CX generates a Bell pair)
# At this point, qubit 1 goes to Bob and qubit 2 goes to Alice
qc.h(0)
qc.cx(0, 1)
qc.barrier()
# Next, Alice encodes her message. First, we need to prepare the state Alice will like to send,
# In this tutorial, Alice is sending 11:
qc.x(0)
qc.z(0)
qc.barrier()
# Alice then sends her qubit to Bob.
# After recieving qubit 0, Bob applies the recovery protocol:
qc.cx(0, 1)
qc.h(0)
# Let's take a measurement to see which classical bit of information Bob receives:
qc.barrier()
qc.measure(0, 0)
qc.measure(1, 1)
# Draw our output
qc.draw(output = "mpl")
job = execute( qc, qbackend, shots=10000 )
counts = job.result().get_counts()
plot_histogram(counts)
q1 = QuantumCircuit(1,1)
q1.x(0)
q1.measure(0,0)
q1.draw(output = 'mpl')
q2 = QuantumCircuit(1,1)
q2.h(0)
q2.measure(0,0)
q2.draw(output = 'mpl')
q = q1 + q2
q.draw(output = 'mpl')
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
%matplotlib inline
secretnumber = '11100011'
circuit = QuantumCircuit(len(secretnumber)+1,len(secretnumber))
circuit.h(range(len(secretnumber)))
circuit.x(len(secretnumber))
circuit.h(len(secretnumber))
circuit.barrier()
for ii, yesno in enumerate(reversed(secretnumber)):
if yesno == '1':
circuit.cx(ii,len(secretnumber))
circuit.barrier()
circuit.h(range(len(secretnumber)))
circuit.barrier()
circuit.measure(range(len(secretnumber)),range(len(secretnumber)))
circuit.draw(output = 'mpl')
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
#Qiskit Categories
#Terra - Foundation, where we build and test our circuit
#Aer - Simulator, simulation of circuit theoretically
#Ignis - Masks noise, helps understand/mitigate error
#energy relaxation - scenario - leave qbit in energized state, will eventually relax to zero state
#Measurement error mitigation
from qiskit import *
nqubits = 3
circuit = QuantumCircuit(nqubits, nqubits)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(1,2)
circuit.measure([0,1,2], [0,1,2])
%matplotlib inline
circuit.draw(output='mpl')
#Aer Simulaton
simulator = Aer.get_backend('qasm_simulator')
sim_result = execute(circuit, backend=simulator, shots=1024).result()
from qiskit.visualization import plot_histogram
plot_histogram(sim_result.get_counts(circuit))
#Terra Real Hardware Execution
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
device = provider.get_backend('ibm_oslo')
job = execute(circuit, backend=device, shots=1024)
print(job.job_id())
from qiskit.tools.monitor import job_monitor
job_monitor(job)
device_result = job.result()
plot_histogram(device_result.get_counts(circuit))
#Ignis Error Mitigation
from qiskit.ignis.mitigation.measurement import (complete_meas_cal, CompleteMeasFitter)
cal_circuits, state_labels = complete_meas_cal(qr = circuit.qregs[0], circlabel='measerrormitigationcal')
cal_circuits[2].draw(output='mpl')
len(cal_circuits)
cal_job = execute(cal_circuits,
backend = device,
shots = 1024,
optimization_level = 0
)
print(cal_job.job_id())
job_monitor(cal_job)
cal_results = cal_job.result()
plot_histogram(
cal_results.get_counts(cal_circuits[3])
)
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
meas_fitter.plot_calibration()
meas_filter = meas_fitter.filter
mitigated_result = meas_filter.apply(device_result)
device_counts = device_result.get_counts(circuit)
mitigated_counts = mitigated_result.get_counts(circuit)
plot_histogram([device_counts, mitigated_counts], legend =['device, noisy', 'device, mitigated'])
#Another example using a different circuit
circuit2 = QuantumCircuit(3,3)
circuit2.x(1)
circuit2.h(0)
circuit2.cx(0,1)
circuit2.cx(1,2)
circuit2.measure([0,1,2],[0,1,2])
circuit2.draw(output = 'mpl')
plot_histogram(
execute(circuit2, backend=simulator, shots = 1024).result().get_counts(circuit2)
)
device_counts_2 = execute(circuit2, backend = device, shots=1024).result().get_counts(circuit2)
plot_histogram(device_counts_2)
device_mitigated_counts_2 = meas_filter.apply(device_counts_2)
plot_histogram(device_mitigated_counts_2)
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
#Building our first Algorithm
#Data to input
#Circuit for calcs
#Output
#Fourier Checking Algorithm (built-in)
#checks how related the Fourier transform of the f function is related with the g function
import qiskit.quantum_info as qi
from qiskit.circuit.library import FourierChecking
from qiskit.visualization import plot_histogram
f=[1,-1,-1,-1]
g=[1,1,-1,-1]
circ = FourierChecking(f=f, g=g)
circ.draw()
zero = qi.Statevector.from_label('00')
sv = zero.evolve(circ)
probs = sv.probabilities_dict()
plot_histogram(probs)
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
# X gate
# X|0> = |1>
# X|1> = |0>
# moving from q0 to q1
from qiskit import *
from qiskit.tools.visualization import plot_bloch_multivector
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuit, backend=simulator).result()
statevector = result.get_statevector()
print(statevector)
%matplotlib inline
circuit.draw(output='mpl')
plot_bloch_multivector(statevector)
circuit.measure([0], [0])
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit,backend=backend, shots = 1024).result()
counts = result.get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
circuit = QuantumCircuit(1,1)
circuit.x(0)
simulator = Aer.get_backend('unitary_simulator')
result = execute(circuit, backend=simulator).result()
unitary = result.get_unitary()
print(unitary)
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
my_list = [1,3,5,2,4,2,5,8,0,7,6]
#classical computation method
def oracle(my_input):
winner =7
if my_input is winner:
response = True
else:
response = False
return response
for index, trial_number in enumerate(my_list):
if oracle(trial_number) is True:
print("Winner is found at index %i" %index)
print("%i calls to the oracle used " %(index +1))
break
#quantum implemenation
from qiskit import *
import matplotlib.pyplot as plt
import numpy as np
from qiskit.tools import job_monitor
# oracle circuit
oracle = QuantumCircuit(2, name='oracle')
oracle.cz(0,1)
oracle.to_gate()
oracle.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit, backend=backend)
result= job.result()
sv= result.get_statevector()
np.around(sv,2)
#amplitude amplification
reflection = QuantumCircuit(2, name='reflection')
reflection.h([0,1])
reflection.z([0,1])
reflection.cz(0,1)
reflection.h([0,1])
reflection.to_gate()
reflection.draw(output='mpl')
#testing circuit on simulator
simulator = Aer.get_backend('qasm_simulator')
grover_circuit = QuantumCircuit(2,2)
grover_circuit.h([0,1])
grover_circuit.append(oracle,[0,1])
grover_circuit.append(reflection, [0,1])
grover_circuit.barrier()
grover_circuit.measure([0,1],[0,1])
grover_circuit.draw(output='mpl')
job= execute(grover_circuit,backend=simulator,shots=1)
result=job.result()
result.get_counts()
#testing on real backend system
IBMQ.load_account()
provider= IBMQ.get_provider('ibm-q')
qcomp= provider.get_backend('ibmq_manila')
job = execute(grover_circuit,backend=qcomp)
job_monitor(job)
result=job.result()
counts=result.get_counts(grover_circuit)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
counts['11']
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
#Extending Grover's Algorithm to cover the Satisfiability Problem
#Satifiability Problem Ex
#Ordering food
# Satisfiability Constraints
# Open, Nearby, Deliver, Thai Food
#For a reasonable # of resturants, classical comp is fine
#However for big datasets, we can use a quantum speedup
#recast problem into search problem
#Grover's Dinner Party
#Invite as many friends over as possible while everyone gets along
#Grover's search can be used for boolean satisfiability problems
#((Olivia & Abe) | (Jin & Amira)) & ~(Abe & Amira)
#((A & B) | (C & D)) & ~(A & D)
from qiskit import BasicAer
#Deprecation of Aqua
#from qiskit.aqua.algorithms import Grover
#from qiskit.aqua.components.oracles import LogicalExpressionOracle
from qiskit.circuit.library import PhaseOracle
from qiskit.algorithms import Grover, AmplificationProblem
from qiskit.utils import QuantumInstance
from qiskit.tools.visualization import plot_histogram
log_expr = '((Olivia & Abe) | (Jin & Amira)) & ~(Abe & Amira)'
oracle = PhaseOracle(log_expr)
problem = AmplificationProblem(oracle=oracle)
backend = BasicAer.get_backend('qasm_simulator')
qinstance = QuantumInstance(backend, shots = 1000)
grover = Grover(quantum_instance = qinstance)
#algorithm = Grover(oracle)
result = grover.amplify(problem)
print('Top measurement:', result.top_measurement)
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
import qiskit
qiskit.__qiskit_version__
from qiskit import IBMQ
IBMQ.save_account('46fd3c15ef48cd5f5d6e4a8ae48748af512d2a57b1647282d61d7e98fda97a54d4be4ab8ff433fccd6613f9e30b3819a1aef9d6262f4980804cb2cd3952f7850')
IBMQ.load_account()
from qiskit import *
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr,cr)
%matplotlib inline
circuit.draw()
circuit.h(qr[0]) #hadamard gate
circuit.draw(output = 'mpl')
circuit.cx(qr[0],qr[1]) #controlled X gate
circuit.draw(output = 'mpl')
circuit.measure(qr,cr)
circuit.draw(output = 'mpl')
#setting up simulator
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(circuit))
provider = IBMQ.get_provider('ibm-q')
# Get a list of available backends
backends = provider.backends()
# Print the names of available backends
print("Available Backends:", [backend.name() for backend in backends])
qcomp = provider.get_backend('ibm_osaka')
job = execute(circuit, backend = qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
results = job.result()
plot_histogram(results.get_counts(circuit))
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
import qiskit
qiskit.__qiskit_version__
from qiskit import IBMQ
IBMQ.save_account('d3d29913a9b505c699f877ab1ade9d7729ee46bf49670047e44a106ff692c5efec8ff03873c1fe6f1d4e76e090e6177ab37bd7c5beb08c2fa1096316c0dc1006')
IBMQ.load_account()
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
### Creating 3 qubit and 2 classical bits in each separate register
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(1)
teleportation_circuit = QuantumCircuit(qr, crz, crx)
### A third party eve helps to create an entangled state
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, a, b):
qc.cx(a, b)
qc.h(a)
teleportation_circuit.barrier()
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
teleportation_circuit.barrier()
measure_and_send(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
teleportation_circuit.barrier()
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit.extensions import Initialize
import math
qc = QuantumCircuit(1)
initial_state = [0,1]
init_gate = Initialize(initial_state)
# qc.append(initialize_qubit, [0])
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
from qiskit import IBMQ
IBMQ.save_account('### IMB TOKEN ')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute, Aer
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
# import basic plot tools
from qiskit.visualization import plot_histogram
def initialize(circuit, n, m):
circuit.h(range(n)) # Hadamard transform on measurment register
circuit.x(n+m-1) # X gate on last qubit
def c_amod15(a, x):
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13") # remember that a needs to be co-prime with N
unitary = QuantumCircuit(4)
for iteration in range(x):
# bitwise arithmetic to represent modular exponentiation function
if a in [2,13]:
unitary.swap(0,1)
unitary.swap(1,2)
unitary.swap(2,3)
if a in [7,8]:
unitary.swap(2,3)
unitary.swap(1,2)
unitary.swap(0,1)
if a == 11:
unitary.swap(1,3)
unitary.swap(0,2)
if a in [7,11,13]:
for q in range(4):
unitary.x(q)
unitary = unitary.to_gate()
unitary.name = "%i^%i mod 15" % (a, x)
# But we need to make it a controlled operation for phase kickback
c_unitary = unitary.control()
return c_unitary
def modular_exponentiation(circuit, n, m, a):
for exp in range(n):
exponent = 2**exp
circuit.append(a_x_mod15(a, exponent), [exp] + list(range(n, n+m)))
from qiskit.circuit.library import QFT
def apply_iqft(circuit, measurement_qubits):
circuit.append(QFT( len(measurement_qubits), do_swaps=False).inverse(), measurement_qubits)
def shor_algo(n, m, a):
# set up the circuit
circ = QuantumCircuit(n+m, n)
# initialize the registers
initialize(circ, n, m)
circ.barrier()
# map modular exponentiation problem onto qubits
modular_exponentiation(circ, n, m, a)
circ.barrier()
# apply inverse QFT -- expose period
apply_iqft(circ, range(n))
# measure the measurement register
circ.measure(range(n), range(n))
return circ
n = 4; m = 4; a = 11
mycircuit = shor_algo(n, m, a)
mycircuit.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
counts = execute(mycircuit, backend=simulator, shots=1024).result().get_counts(mycircuit)
plot_histogram(counts)
for measured_value in counts:
print(f"Measured {int(measured_value[::-1], 2)}")
from math import gcd
from math import sqrt
from itertools import count, islice
for measured_value in counts:
measured_value_decimal = int(measured_value[::-1], 2)
print(f"Measured {measured_value_decimal}")
if measured_value_decimal % 2 != 0:
print("Failed. Measured value is not an even number")
continue
x = int((a ** (measured_value_decimal/2)) % 15)
if (x + 1) % 15 == 0:
print("Failed. x + 1 = 0 (mod N) where x = a^(r/2) (mod N)")
continue
guesses = gcd(x + 1, 15), gcd(x - 1, 15)
print(guesses)
def is_prime(n):
return n > 1 and all(n % i for i in islice(count(2), int(sqrt(n)-1)))
if is_prime(guesses[0]) and is_prime(guesses[1]):
print(f"**The prime factors are {guesses[0]} and {guesses[1]}**")
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
#imports
import matplotlib.pyplot as plt
import numpy as np
from qiskit import *
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
clause_list = [[0,1],
[0,2],
[1,3],
[2,3]]
def XOR(qc, a, b, output):
qc.cx(a, output)
qc.cx(b, output)
# We will use separate registers to name the bits
in_qubits = QuantumRegister(2, name='input')
out_qubit = QuantumRegister(1, name='output')
qc = QuantumCircuit(in_qubits, out_qubit)
XOR(qc, in_qubits[0], in_qubits[1], out_qubit)
qc.draw()
# Create separate registers to name bits
var_qubits = QuantumRegister(4, name='v') # variable bits
clause_qubits = QuantumRegister(4, name='c') # bits to store clause-checks
# Create quantum circuit
qc = QuantumCircuit(var_qubits, clause_qubits)
# Use XOR gate to check each clause
i = 0
for clause in clause_list:
XOR(qc, clause[0], clause[1], clause_qubits[i])
i += 1
qc.draw()
# Create separate registers to name bits
var_qubits = QuantumRegister(4, name='v')
clause_qubits = QuantumRegister(4, name='c')
output_qubit = QuantumRegister(1, name='out')
qc = QuantumCircuit(var_qubits, clause_qubits, output_qubit)
# Compute clauses
i = 0
for clause in clause_list:
XOR(qc, clause[0], clause[1], clause_qubits[i])
i += 1
# Flip 'output' bit if all clauses are satisfied
qc.mct(clause_qubits, output_qubit)
qc.draw()
var_qubits = QuantumRegister(4, name='v')
clause_qubits = QuantumRegister(4, name='c')
output_qubit = QuantumRegister(1, name='out')
cbits = ClassicalRegister(4, name='cbits')
qc = QuantumCircuit(var_qubits, clause_qubits, output_qubit, cbits)
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
def sudoku_oracle(qc, clause_list, clause_qubits):
# Compute clauses
i = 0
for clause in clause_list:
XOR(qc, clause[0], clause[1], clause_qubits[i])
i += 1
# Flip 'output' bit if all clauses are satisfied
qc.mct(clause_qubits, output_qubit)
# Uncompute clauses to reset clause-checking bits to 0
i = 0
for clause in clause_list:
XOR(qc, clause[0], clause[1], clause_qubits[i])
i += 1
sudoku_oracle(qc, clause_list, clause_qubits)
qc.draw()
var_qubits = QuantumRegister(4, name='v')
clause_qubits = QuantumRegister(4, name='c')
output_qubit = QuantumRegister(1, name='out')
cbits = ClassicalRegister(4, name='cbits')
qc = QuantumCircuit(var_qubits, clause_qubits, output_qubit, cbits)
# Initialize 'out0' in state |->
qc.initialize([1, -1]/np.sqrt(2), output_qubit)
# Initialize qubits in state |s>
qc.h(var_qubits)
qc.barrier() # for visual separation
## First Iteration
# Apply our oracle
sudoku_oracle(qc, clause_list, clause_qubits)
qc.barrier() # for visual separation
# Apply our diffuser
qc.append(diffuser(4), [0,1,2,3])
## Second Iteration
sudoku_oracle(qc, clause_list, clause_qubits)
qc.barrier() # for visual separation
# Apply our diffuser
qc.append(diffuser(4), [0,1,2,3])
# Measure the variable qubits
qc.measure(var_qubits, cbits)
qc.draw(fold=-1)
# Simulate and plot results
backend = Aer.get_backend('aer_simulator')
#provider = IBMQ.load_account()
#backend = provider.get_backend('ibm_oslo')
job = execute(qc, backend=backend, shots=1024)
print("job id:", job.job_id())
job_monitor(job)
result = job.result()
plot_histogram(result.get_counts())
|
https://github.com/AlphaMiyaL/Qiskit-Quantum-Journey
|
AlphaMiyaL
|
%matplotlib inline
#Imports
from qiskit import QuantumCircuit, execute, Aer, IBMQ, ClassicalRegister, QuantumRegister
from qiskit.compiler import transpile, assemble
import numpy as np
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import json
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
from qiskit.tools.monitor import job_monitor
def block_idx(x, y):
if x<2 and y<2:
return 0
if x<2:
return 1
if y<2:
return 2
return 3
def apply_cands(matrix):
cands = []
for i in range(len(matrix)):
for j in range(len(matrix[0])):
if matrix[i][j] != 0:
continue
temp = []
for k in range(4):
f = True
for row in range(4):
if matrix[row][j] == k + 1:
f = False
for col in range(4):
if matrix[i][col] == k + 1:
f = False
for x in range(4):
for y in range(4):
if block_idx(i, j) != block_idx(x, y):
continue
if matrix[x][y] == k + 1:
f = False
if f:
temp.append(k+1)
cands.append(temp)
return cands
def one_cand_op(qc, q0, q1, cands):
#print(q0, q1)
if cands[0] == 1:
pass
elif cands[0] == 2:
qc.x(q1)
elif cands[0] == 3:
qc.x(q0)
else:
qc.x(q0)
qc.x(q1)
def one_cand_op_inverse(qc, q0, q1, cands):
if cands[0] == 1:
pass
elif cands[0] == 2:
qc.x(q1)
elif cands[0] == 3:
qc.x(q0)
else:
qc.x(q1)
qc.x(q0)
def two_cand_op(qc, q0, q1, cands):
#print(q0, q1, cands[0], cands[1])
product = cands[0]*cands[1]
#1 + 2
if product == 2:
qc.h(q1)
#1 + 3
elif product == 3:
qc.h(q0)
#1 + 4
elif product == 4:
qc.h(q0)
qc.cx(q0, q1)
#2 + 3
elif product == 6:
qc.x(q1)
qc.h(q0)
qc.cx(q0, q1)
#2 + 4
elif product == 8:
qc.x(q1)
qc.h(q0)
#3 + 4
else:
qc.h(q1)
qc.x(q0)
def two_cand_op_inverse(qc, q0, q1, cands):
product = cands[0]*cands[1]
#1 + 2
if product == 2:
qc.h(q1)
#1 + 3
elif product == 3:
qc.h(q0)
#1 + 4
elif product == 4:
qc.cx(q0, q1)
qc.h(q0)
#2 + 3
elif product == 6:
qc.cx(q0, q1)
qc.h(q0)
qc.x(q1)
#2 + 4
elif product == 8:
qc.h(q0)
qc.x(q1)
#3 + 4
else:
qc.h(q1)
qc.x(q0)
def init_blanks(qc, qr, matrix):
cands = apply_cands(matrix)
# print(cands)
for i in range(len(cands)):
if len(cands[i]) == 1:
one_cand_op(qc, qr[2*i], qr[2*i+1], cands[i])
else:
two_cand_op(qc, qr[2*i], qr[2*i+1], cands[i])
def init_blanks_inverse(qc, qr, matrix):
cands = apply_cands(matrix)
for i in range(len(cands)-1, -1, -1):
if len(cands[i]) == 1:
one_cand_op_inverse(qc, qr[2*i], qr[2*i+1], cands[i])
else:
two_cand_op_inverse(qc, qr[2*i], qr[2*i+1], cands[i])
# if v1 != v2 (number) then target = 1 else target = 0
def compare_vertex(qc, qr, v1, v2, target):
qc.x(qr[2*v2])
qc.x(qr[2*v2+1])
qc.ccx(qr[2*v1], qr[2*v1+1], target)
qc.ccx(qr[2*v1+1], qr[2*v2], target)
qc.ccx(qr[2*v2], qr[2*v2+1], target)
qc.ccx(qr[2*v1], qr[2*v2+1], target)
qc.x(qr[2*v2+1])
qc.x(qr[2*v2])
qc.x(qr[target])
def compare_vertex_inverse(qc, qr, v1, v2, target):
qc.x(qr[target])
qc.x(qr[2*v2])
qc.x(qr[2*v2+1])
qc.ccx(qr[2*v1], qr[2*v2+1], target)
qc.ccx(qr[2*v2], qr[2*v2+1], target)
qc.ccx(qr[2*v1+1], qr[2*v2], target)
qc.ccx(qr[2*v1], qr[2*v1+1], target)
qc.x(qr[2*v2+1])
qc.x(qr[2*v2])
# Edge constraint oracle
def oracle(qc, qr):
# vs = [0, 1, 2, 3, 4, 5, 6, 7]
list1 = [[0, 1], [2, 3], [4, 5], [6, 7], [2, 6], [0, 4]]
list2 = [[1, 5], [3, 7], [0, 2], [1, 3], [4, 6], [5, 7]]
target = 16
temp1 = 30
temp2 = 31
for elm in list1:
assert(len(elm)==2)
compare_vertex(qc, qr, elm[0], elm[1], target)
target+=1
qc.mct(qr[16:target], qr[temp1], qr[22:29], mode='basic')
for elm in (reversed(list1)):
target-=1
compare_vertex_inverse(qc, qr, elm[0], elm[1], target)
for elm in list2:
assert(len(elm)==2)
compare_vertex(qc, qr, elm[0], elm[1], target)
target+=1
qc.mct(qr[16:target], qr[temp2], qr[22:29], mode='basic')
for elm in (reversed(list2)):
target-=1
compare_vertex_inverse(qc, qr, elm[0], elm[1], target)
dest = 29
qc.ccx(qr[temp1], qr[temp2], qr[dest])
for elm in list2:
assert(len(elm)==2)
compare_vertex(qc, qr, elm[0], elm[1], target)
target+=1
qc.mct(qr[16:target], qr[temp2], qr[22:29], mode='basic')
for elm in (reversed(list2)):
target-=1
compare_vertex_inverse(qc, qr, elm[0], elm[1], target)
for elm in list1:
assert(len(elm)==2)
compare_vertex(qc, qr, elm[0], elm[1], target)
target+=1
qc.mct(qr[16:target], qr[temp1], qr[22:29], mode='basic')
for elm in (reversed(list1)):
target-=1
compare_vertex_inverse(qc, qr, elm[0], elm[1], target)
""" diffusion (inversion about the mean) circuit. """
def diffusion(circuit, qr, matrix):
# circuit.h(qr)
init_blanks_inverse(circuit, qr[:16], matrix) # inverse of unitary op of initial state preparation
circuit.x(qr[:16])
# apply multi-control CZ
circuit.h(qr[15])
# circuit.mct(qr[:-1], qr[-1], anc, mode='basic')
circuit.mct(qr[:15], qr[15], qr[16:29], mode='basic')
circuit.h(qr[15])
circuit.x(qr[:16])
# circuit.h(qr)
init_blanks(circuit, qr[:16], matrix)
qr = QuantumRegister(32)
cr = ClassicalRegister(16)
qc = QuantumCircuit(qr, cr)
matrix = np.array([4, 0, 2, 0, 0, 1, 0, 4, 1, 0, 4, 0, 0, 4, 0, 2]).reshape(4, 4)
print(matrix)
print(apply_cands(matrix))
def grover(iter):
init_blanks(qc, qr, matrix)
for _ in range(iter):
oracle(qc, qr)
print("oracle done")
diffusion(qc, qr, matrix)
print("diffusion done")
qc.measure(qr[0:16], cr[0:16])
print("measure done")
#print("drawing start")
#qc.draw()
grover(3)
# Unroll the circuit
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
# obtain gates
gates=new_circuit.count_ops()
print(gates)
cost=gates['u3'] + 10*gates['cx']
print(cost)
# shots = 8000
shots = 1024
print("shots:", shots)
## Run on Aer Simulator
backend = Aer.get_backend('qasm_simulator')
## Run on Quantum Hardware(does not techically work however since we need 32 qbits but free only give 7)
## Can run the 2x2 to show that the Sudoku solving does work on a Quantum Computer however
#provider = IBMQ.load_account()
#backend = provider.get_backend('ibm_oslo')
print("execute start")
job = execute(qc, backend=backend, shots=shots, seed_simulator=12345, backend_options={"fusion_enable":True})
print("job id:", job.job_id())
job_monitor(job)
result = job.result()
count = result.get_counts()
print(count)
print(len(count))
score_sorted = sorted(count.items(), key=lambda x:x[1], reverse=True)
final_score = score_sorted[0:15]
final_score
count_sorted = sorted(count.items(), key=lambda x:x[1], reverse=True)
# collect answers with Top 7 probability
ans_list = count_sorted[:12]
# reverse ans_list
ans_reversed = []
for i in ans_list:
ans_temp=[i[0][::-1],i[1]]
ans_reversed.append(ans_temp)
# convert each 2 bits into corresponding color. Add node0(0),node3(1),node8(2) and node11(3)
ans_shaped = []
for j in ans_reversed:
ans_temp=j[0]
node0 = int(ans_temp[0] + ans_temp[1], 2)
node1 = int(ans_temp[2] + ans_temp[3], 2)
node2 = int(ans_temp[4] + ans_temp[5], 2)
node3 = int(ans_temp[6] + ans_temp[7], 2)
node4 = int(ans_temp[8] + ans_temp[9], 2)
node5 = int(ans_temp[10] + ans_temp[11], 2)
node6 = int(ans_temp[12] + ans_temp[13], 2)
node7 = int(ans_temp[14] + ans_temp[15], 2)
nodes_color = str(node0) + str(node1) + str(node2) + str(node3) + str(node4) + str(node5) + str(node6) + str(node7)
ans_shaped.append([nodes_color,j[1]])
sorted(ans_shaped)
# Converting to decimal, 1-4 (since this is a 4x4 matrix)
def convert_to_decimal(str_bin):
str_bin = ''.join(list(reversed(str_bin))) # cbitに格納されるときに順番逆になっていることに注意
list_dec = [str(int(str_bin[2*i:2*i+2], 2)+1) for i in range(len(str_bin)//2)]
str_dec = ''.join(list_dec)
return str_dec
# histogram plot (decimal representation)
count_decimal = {}
for key, value in count.items():
count_decimal[convert_to_decimal(key)] = value
print(count_decimal)
plot_histogram(count_decimal)
def replace_matrix_vals(matrix):
new_matrix = []
replace_idx = 0
#first sol from above
replacements = [int(x) for x in str(convert_to_decimal(next(iter(count.items()))[0]))]
for list in matrix:
for num in list:
if num == 0:
new_matrix.append(replacements[replace_idx])
replace_idx+=1
else:
new_matrix.append(num)
return np.array(new_matrix).reshape(4,4)
filled_sudoku = replace_matrix_vals(matrix)
print(filled_sudoku)
|
https://github.com/Rishwi/Beyond-Classical-a-quantum-computing-crash-course-using-qiskit
|
Rishwi
|
#pip install qiskit
from qiskit import *
from qiskit.tools.visualization import plot_histogram
stt="Hello world"
res = ''.join(format(ord(i), 'b') for i in stt)
print(res)
s = res
n = len(s)
circuit = QuantumCircuit(n+1,n)
circuit.x(n)
circuit.barrier()
circuit.h(range(n+1))
circuit.barrier()
for i, tf in enumerate(reversed(s)):
if tf == '1':
circuit.cx(i, n)
circuit.barrier()
circuit.h(range(n+1))
circuit.barrier()
circuit.measure(range(n), range(n))
%matplotlib inline
circuit.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend=simulator, shots=1).result()
from qiskit.visualization import plot_histogram
plot_histogram(result.get_counts(circuit))
kk=result.get_counts()
kkk=list(kk.keys())
strrr=kkk[0]
print(strrr)
res=strrr #i'm changing res variable, so, now i don't know what's in res
i=0
mainstr=[]
while i<len(res):
if res[i:i+6] != '100000':
sk=res[i:i+7]
i=i+7
ssk=int(sk, base=2)
print(ssk)
mainstr.append(chr(ssk))
elif res[i:i+6] == '100000':
i=i+6
mainstr.append(" ")
print(''.join(mainstr))
|
https://github.com/Rishwi/Beyond-Classical-a-quantum-computing-crash-course-using-qiskit
|
Rishwi
|
# -*- coding: utf-8 -*-
"""Bernstein_Vazirani_forStrings.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/14Uww12SEbmiNPfWr5udfr3tL-393ge7N
"""
#pip install qiskit
# Commented out IPython magic to ensure Python compatibility.
from qiskit import *
from qiskit.tools.visualization import plot_histogram
stt="Hello world"
res = ''.join(format(ord(i), 'b') for i in stt)
print(res)
s = res
n = len(s)
circuit = QuantumCircuit(n+1,n)
circuit.x(n)
circuit.barrier()
circuit.h(range(n+1))
circuit.barrier()
for i, tf in enumerate(reversed(s)):
if tf == '1':
circuit.cx(i, n)
circuit.barrier()
circuit.h(range(n+1))
circuit.barrier()
circuit.measure(range(n), range(n))
# %matplotlib inline
circuit.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend=simulator, shots=1).result()
plot_histogram(result.get_counts(circuit))
kk=result.get_counts()
kkk=list(kk.keys())
strrr=kkk[0]
print(strrr)
res=strrr #i'm changing res variable, so, now i don't know what's in res
i=0
mainstr=[]
while i<len(res):
if res[i:i+6] != '100000':
sk=res[i:i+7]
i=i+7
ssk=int(sk, base=2)
print(ssk)
mainstr.append(chr(ssk))
elif res[i:i+6] == '100000':
i=i+6
mainstr.append(" ")
print(''.join(mainstr))
|
https://github.com/Rishwi/Beyond-Classical-a-quantum-computing-crash-course-using-qiskit
|
Rishwi
|
pip install qiskit
from qiskit import *
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr , cr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
circuit.measure(qr,cr)
circuit.draw(output='mpl')
from qiskit.visualization import plot_histogram
backend=Aer.get_backend('qasm_simulator')
counts = execute(circuit, backend= backend, shots= 1024).result().get_counts()
plot_histogram(counts)
IBMQ.save_account('copy your token here')
IBMQ.load_account()
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor #used to monitor the job process
provider = IBMQ.get_provider('ibm-q')
qcomp = provider.get_backend('ibmq_16_melbourne')
job=execute(circuit, backend=qcomp)
job_monitor(job)
rishwi=job.result()
plot_histogram(rishwi.get_counts(circuit))
|
https://github.com/Soumyo2121/Basic-Quantum-Algorithms
|
Soumyo2121
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
%matplotlib inline
secretnumber = '11100011'
circuit = QuantumCircuit(len(secretnumber)+1,len(secretnumber))
circuit.h(range(len(secretnumber)))
circuit.x(len(secretnumber))
circuit.h(len(secretnumber))
circuit.barrier()
for ii, yesno in enumerate(reversed(secretnumber)):
if yesno == '1':
circuit.cx(ii,len(secretnumber))
circuit.barrier()
circuit.h(range(len(secretnumber)))
circuit.barrier()
circuit.measure(range(len(secretnumber)),range(len(secretnumber)))
circuit.draw(output = 'mpl')
|
https://github.com/Soumyo2121/Basic-Quantum-Algorithms
|
Soumyo2121
|
import numpy as np
import math
from qiskit.circuit import Parameter
from qiskit import *
from math import pi,cos,sin,tan,atan
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.providers.aer import QasmSimulator
def execute_circuit_sv(quantum_circuit):
statevector_simulator = Aer.get_backend('statevector_simulator')
result = execute(quantum_circuit, statevector_simulator).result()
statevector_results = result.get_statevector(quantum_circuit)
circuit_diagram = quantum_circuit.draw('mpl')
b_sphere = plot_bloch_multivector(statevector_results)
return statevector_results, circuit_diagram, b_sphere
param_theta = Parameter('θ')
n = int(input("Enter the number of qubits(Max no. 5): "))
bell = QuantumCircuit(n, name='entanglement')
rot = int(input("Press 1 to select RX gate, 2 for RY gate"))
if rot==1:
bell.rx(param_theta,0)
elif rot==2:
bell.ry(param_theta,0)
else:
print("Please Enter the correct option")
control = int(input("Press 1 to use CNOT gate and 2 for CY gate"))
if control==1:
for i in range (0,n-1):
bell.cx(i,i+1)
elif control==2:
for j in range(0,n-1):
bell.cy(j,j+1)
else:
print("Please press the correct option")
import numpy as np
from math import pi,cos,sin,tan,atan
x = float(input("Enter the angle multiplier: "))
bell = bell.bind_parameters({param_theta: (x * np.pi)})
result, img, bsphere = execute_circuit_sv(bell)
img
bsphere
print(result)
from qiskit.quantum_info import DensityMatrix
D = DensityMatrix(bell)
print(D)
from qiskit.quantum_info import entropy
vn_entropy = entropy(D, base=2)
print(vn_entropy)
r = x / 0.5
if x % 0.5 == 0 and r % 2 != 0:
print("Maximal Entanglement")
else:
print("Partial Entanglement")
|
https://github.com/Soumyo2121/Basic-Quantum-Algorithms
|
Soumyo2121
|
from qiskit import *
from qiskit.visualization import plot_histogram
qc = QuantumCircuit(3,3)
qc.h(0)
qc.cx(0,1)
qc.cx(1,2)
qc.measure([0,1,2],[0,1,2])
qc.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1024).result()
plot_histogram(result.get_counts(qc))
from qiskit import IBMQ
IBMQ.save_account('a9783f33a64e88d038689c3d3a67cb4235d7715268ca95f986cf1e3e514cd601c77d52d8d8cffda397c63ad4f4cd488a6e907452415bf854dd028ae21c78c927')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
device = provider.get_backend('ibmqx2')
job = execute(qc, backend = device, shots = 1024)
print(job.job_id())
from qiskit.tools.monitor import job_monitor
job_monitor(job)
device_result = job.result()
plot_histogram(device_result.get_counts(qc))
from qiskit.ignis.mitigation.measurement import (complete_meas_cal, CompleteMeasFitter)
cal_circuits, state_labels = complete_meas_cal(qr = qc.qregs[0], circlabel = 'measerrormitigationcal')
cal_circuits[2].draw('mpl')
len(cal_circuits)
cal_job = execute(cal_circuits, backend = device, shots = 1024, optimization_level = 0)
print(cal_job.job_id())
job_monitor(cal_job)
cal_results = cal_job.result()
plot_histogram(cal_results.get_counts(cal_circuits[3]))
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
meas_fitter.plot_calibration()
meas_filter = meas_fitter.filter
mitigated_result = meas_filter.apply(device_result)
device_counts = device_result.get_counts(qc)
mitigated_counts = mitigated_result.get_counts(qc)
plot_histogram([device_counts,mitigated_counts], legend = ['device, noisy', 'device,mitigated'])
circuit = QuantumCircuit(3,3)
circuit.x(1)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(1,2)
circuit.measure([0,1,2],[0,1,2])
circuit.draw('mpl')
plot_histogram(execute(circuit, backend = simulator, shots = 1024).result().get_counts(circuit))
device_counts_1 = execute(circuit, backend = device,shots = 1024).result().get_counts(circuit)
plot_histogram(device_counts_1)
device_mitigated_counts_1 = meas_filter.apply(device_counts_1)
plot_histogram(device_mitigated_counts_1)
|
https://github.com/Soumyo2121/Basic-Quantum-Algorithms
|
Soumyo2121
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
### Creating 3 qubit and 2 classical bits in each separate register
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(1)
teleportation_circuit = QuantumCircuit(qr, crz, crx)
### A third party eve helps to create an entangled state
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, a, b):
qc.cx(a, b)
qc.h(a)
teleportation_circuit.barrier()
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
teleportation_circuit.barrier()
measure_and_send(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
teleportation_circuit.barrier()
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit.extensions import Initialize
import math
qc = QuantumCircuit(1)
initial_state = [0,1]
init_gate = Initialize(initial_state)
# qc.append(initialize_qubit, [0])
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
from qiskit import IBMQ
IBMQ.save_account('### IMB TOKEN ')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/Soumyo2121/Basic-Quantum-Algorithms
|
Soumyo2121
|
import qiskit
from qiskit import *
n = int(input("Enter the length of binry string: "))
n_q = n
n_c = n
qc = QuantumCircuit(n_q,n_c)
for i in range(n):
qc.h(i)
qc.measure(i,i)
qc.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/Soumyo2121/Basic-Quantum-Algorithms
|
Soumyo2121
|
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver
import numpy as np
import pylab
import copy
from qiskit import BasicAer
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.aqua.components.optimizers import COBYLA, SPSA, SLSQP
from qiskit.aqua.operators import Z2Symmetries
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.core import Hamiltonian,QubitMappingType
from qiskit.aqua import QuantumInstance, aqua_globals
molecule = 'H .0 .0 -{0}; Li .0 .0 {0}'
distances = np.arange(0.5,4.25,0.25)
vqe_energies = []
hf_energies = [] # initial guess from Hartree-Fock
exact_energies = []
for i,d in enumerate(distances):
print('step',i)
# set up experiment
driver = PySCFDriver(molecule.format(d/2), basis = 'sto3g')
qmolecule = driver.run()
operator = Hamiltonian(qubit_mapping=QubitMappingType.PARITY,
two_qubit_reduction=True,
freeze_core=True,
orbital_reduction=[-3,-2])
qubit_op, aux_ops = operator.run(qmolecule)
# exact classical result
exact_result = NumPyMinimumEigensolver(qubit_op, aux_operators=aux_ops).run()
exact_result = operator.process_algorithm_result(exact_result)
# VQE
optimizer = SLSQP(maxiter=1000)
initial_state = HartreeFock(operator.molecule_info['num_orbitals'],
operator.molecule_info['num_particles'],
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
var_form = UCCSD(num_orbitals=operator.molecule_info['num_orbitals'],
num_particles=operator.molecule_info['num_particles'],
initial_state=initial_state,
qubit_mapping=operator._qubit_mapping,
two_qubit_reduction=operator._two_qubit_reduction)
algo=VQE(qubit_op, var_form, optimizer, aux_operators=aux_ops)
vqe_result=algo.run(QuantumInstance(BasicAer.get_backend('statevector_simulator')))
vqe_result=operator.process_algorithm_result(vqe_result)
exact_energies.append(exact_result.energy)
vqe_energies.append(vqe_result.energy)
hf_energies.append(vqe_result.hartree_fock_energy)
pylab.plot(distances,hf_energies, label='Hartree_Fock')
pylab.plot(distances, vqe_energies, 'o', label='VQE')
pylab.plot(distances, exact_energies, '^', label='Exact')
pylab.xlabel('Interatomic Distance')
pylab.ylabel('Energy')
pylab.title('LiH Ground State Energy')
pylab.legend()
|
https://github.com/Glebegor/Quantum-programming-algorithms
|
Glebegor
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/Glebegor/Quantum-programming-algorithms
|
Glebegor
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/Glebegor/Quantum-programming-algorithms
|
Glebegor
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.