repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
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)
|
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)
|
https://github.com/Glebegor/Quantum-programming-algorithms
|
Glebegor
|
import time
from qiskit_ibm_runtime import QiskitRuntimeService
import qiskit
import qiskit_ibm_runtime
import qiskit_aer
import numpy as np
import random as rand
import os
# Projecting Quantum class
class Quantum:
def __init__(self, gStack, qbCount):
self.id = 0
self.qiskitVersion = qiskit.__version__
self.imagesPath = "./Images" # Folder to Images
self.loggerPath = "./Logger" # Folder to Loggs
self.gatesStack = gStack # Stack of the gates
self.qubitsCount = qbCount # count of the qubits
# Registers
self.regQ = qiskit.QuantumRegister(self.qubitsCount, "QRegister") # Quantum
self.regC = qiskit.ClassicalRegister(self.qubitsCount, "CRegister") # Classic
self.circuit = qiskit.QuantumCircuit(self.regQ, self.regC) # Circuit
self.gates = ["h", "x", "z", "ry", "cx", "cu3", "ccx"]
# Ibm connection
def connIBMService(self):
QiskitRuntimeService.save_account(
channel="channel",
name="name",
token="token",
set_as_default=True
)
return QiskitRuntimeService()
def connectBack(self, serviceIBM):
print(serviceIBM)
return serviceIBM.backend("quantum device")
# Logic
def findId(self):
self.id += 1
return time.ctime().replace(" ", "_").replace(":", "-") + "_" + str(self.id)
def saveImage(self, name):
self.circuit.draw(output='mpl', filename=self.imagesPath + "/" + name)
def loggCircuit(self, name):
file_path = os.path.join(self.loggerPath, f"{name}.txt")
fd = os.open(file_path, os.O_WRONLY | os.O_CREAT | os.O_TRUNC, 0o666)
try:
with os.fdopen(fd, 'w') as openedFile:
for el in self.gatesStack:
newRow = ""
for row in el:
newRow += str(row) + ", "
openedFile.write(newRow + '\n') # Add a newline after each row for better readability
except Exception as e:
raise e
def isInCircuit(self, qubitIdList):
for qubitId in qubitIdList:
if not (qubitId > 0 and qubitId < self.qubitsCount):
return False
return True
# Using of the gates
def useGate(self, gateElement):
gate = gateElement[0]
if (gate == "h"):
if len(gateElement) != 2:
print("Gate h has 1 param.")
return
self.isInCircuit(gateElement[1:])
self.circuit.h(self.regQ[gateElement[1]]) # ("h", 1,)
elif (gate == "x"):
if len(gateElement) != 2:
print("Gate x has 1 param.")
return
self.isInCircuit(gateElement[1:])
self.circuit.h(self.regQ[gateElement[1]]) # ("x", 1,)
elif (gate == "z"):
if len(gateElement) != 2:
print("Gate z has 1 param.")
return
self.isInCircuit(gateElement[1:])
self.circuit.h(self.regQ[gateElement[1]]) # ("z", 1,)
elif (gate == "ry"):
if len(gateElement) != 3:
print("Gate ry has 2 params.")
return
self.isInCircuit(gateElement[1:2])
self.circuit.ry(2*gateElement[2], self.regQ[gateElement[1]]) # ("ry", 1, 45)
elif (gate == "cx"):
if len(gateElement) != 3:
print("Gate cx has 2 params.")
return
self.isInCircuit(gateElement[1:3])
self.circuit.cx(self.regQ[gateElement[1]], self.regQ[gateElement[2]]) # ("cx", 1, 2)
elif (gate == "cu3"):
if len(gateElement) != 4:
print("Gate cu3 has 3 params.")
return
self.isInCircuit(gateElement[1:3])
self.circuit.cu3(self.regQ[gateElement[3]], 0, 0, self.regQ[gateElement[1]], self.regQ[gateElement[2]]) # ("cu3", 1, 2, 45)
elif (gate == "ccx"):
if len(gateElement) != 4:
print("Gate ccx has 3 params.")
return
self.isInCircuit(gateElement[1:4])
self.circuit.ccx(self.regQ[gateElement[1]], self.regQ[gateElement[2]], self.regQ[gateElement[3]]) # ("ccx", 1, 2, 3)
else:
print("Doesn't found gate: " + gate)
return None
return gate
def run(self):
self.regQ = qiskit.QuantumRegister(self.qubitsCount, "QRegister") # Quantum
self.regC = qiskit.ClassicalRegister(self.qubitsCount, "CRegister") # Classic
self.circuit = qiskit.QuantumCircuit(self.regQ, self.regC)
for el in self.gatesStack:
result = self.useGate(el)
if result == None:
return
else:
# print("Operator - " + result + " - used.")
pass
self.build()
def build(self):
self.circuit.measure(self.regQ, self.regC)
print("Circuit was measured.")
idOfJob = self.findId()
print("Created job: " + idOfJob)
self.saveImage(idOfJob)
self.loggCircuit(idOfJob)
job = qiskit_aer.AerSimulator(method='automatic').run(self.circuit, shots=1024)
# get the result
counts = job.result().get_counts(self.circuit)
print(counts)
def setupNewStack(self, newGatesStack):
self.gatesStack = newGatesStack
stackOfGates = [["h", 1],["h", 2],["h", 3],["ccx", 4, 1, 2]]
quantum = Quantum(stackOfGates, 5)
quantum.run()
quantum.setupNewStack([["h", 1],["h", 2],["h", 2],["ccx", 0, 1, 4]])
quantum.run()
quantum.run()
|
https://github.com/kafurakami/quantum_algorithms
|
kafurakami
|
pip install qiskit
from qiskit import assemble, Aer, QuantumCircuit, __qiskit_version__, execute
from qiskit.visualization import plot_histogram
__qiskit_version__
circ = QuantumCircuit(4,2) #4 qubits, 2 measurements
circ.x(0)#Comment this out if q0 is 0
circ.x(1)#Comment this out if q1 is 0
circ.barrier()
circ.cx(0,2)#cnot between q0 and q2;0 is the control bit, 2 is target
circ.cx(1,2)#cnot between q1 and q2;1 is the control bit, 2 is target
#if both inputs are same, then cnot will return final measurement 0;
#if both inputs are different, then cnot will return final mes 1;
#Basically, the above statements achieve a XOR gate on q0 and q1, with
#output on q2
circ.ccx(0,1,3)#Toffoli gate with q0,q1 as controls, q3 as target
#basically an AND gate between q0 and q1, with output on q3
#this is necessary because in the case we add 1+1, we get 10,i.e. we need a one on the left bit, and this will
#return one if both the inputs are 1
circ.barrier()
circ.measure(2,0)#Measuring XOR output of qubit 2 on bit 1
circ.measure(3,1)#Measuring AND output of qubit 3 on bit 2
circ.draw('mpl')
#simulator = Aer.get_backend('qasm_simulator') Initialising backend
#job = assemble(circ) Assembling the circuit
#results = simulator.run(circ).result() finding results
#counts = results.get_counts() obtaining the counts
#much better way to do this using execute
backend = Aer.get_backend('qasm_simulator')#Same as simulator above
job = execute(circ, backend)#no need to assemble
result = job.result()
status = job.status()
print(status)
counts = result.get_counts()
plot_histogram(counts)
#Note - bits printed from right to left, i.e. if q2 is bit a and q3 is bit b, then printed in the order ba, NOT ab
#in the above case, q2 is 0 and q3 is 1, so the output is 10, NOT 01(as bits printed in reverse order; would have changed if measurement of 2 taken on bit2 instead of bit1, then the output would be normal ab instead of ba)
|
https://github.com/ka-us-tubh/quantum-computing-qiskit-
|
ka-us-tubh
|
from ibm_quantum_widgets import CircuitComposer
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
qreg_q = QuantumRegister(4, 'q')
creg_c = ClassicalRegister(4, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
circuit.x(qreg_q[3])
circuit.barrier(qreg_q[0], qreg_q[1], qreg_q[2], qreg_q[3])
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.h(qreg_q[2])
circuit.h(qreg_q[3])
circuit.barrier(qreg_q[0], qreg_q[1], qreg_q[2], qreg_q[3])
circuit.cx(qreg_q[2], qreg_q[3])
circuit.cx(qreg_q[0], qreg_q[3])
circuit.barrier(qreg_q[0], qreg_q[1], qreg_q[2], qreg_q[3])
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.h(qreg_q[2])
circuit.measure(qreg_q[0], creg_c[0])
circuit.measure(qreg_q[1], creg_c[1])
circuit.measure(qreg_q[2], creg_c[2])
editor = CircuitComposer(circuit=circuit)
editor
|
https://github.com/ka-us-tubh/quantum-computing-qiskit-
|
ka-us-tubh
|
from ibm_quantum_widgets import CircuitComposer
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
qreg_q = QuantumRegister(4, 'q')
creg_c = ClassicalRegister(4, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
circuit.x(qreg_q[3])
circuit.barrier(qreg_q[3], qreg_q[0], qreg_q[1], qreg_q[2])
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.h(qreg_q[2])
circuit.h(qreg_q[3])
circuit.barrier(qreg_q[3], qreg_q[0], qreg_q[1], qreg_q[2])
circuit.cx(qreg_q[0], qreg_q[3])
circuit.cx(qreg_q[1], qreg_q[3])
circuit.cx(qreg_q[2], qreg_q[3])
circuit.barrier(qreg_q[3], qreg_q[0], qreg_q[1], qreg_q[2])
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.h(qreg_q[2])
circuit.measure(qreg_q[0], creg_c[0])
circuit.measure(qreg_q[1], creg_c[1])
circuit.measure(qreg_q[2], creg_c[2])
editor = CircuitComposer(circuit=circuit)
editor
|
https://github.com/ka-us-tubh/quantum-computing-qiskit-
|
ka-us-tubh
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
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 import assemble
import numpy as np
import matplotlib.pyplot as plt
n=4
grover_ckt=QuantumCircuit(n+1,n)
marked=[1,0,1,1]#1101 marked =13
def apply_oracle(n,marked,ckt):
controlO=[i for i in range(n) if not marked[i]]
ckt.x(controlO)
ckt.mct(list(range(n)),n)
ckt.x(controlO)
ckt.draw()
def reflect_uniform(ckt,n):
ckt.h(list(range(n)))
ckt.x(list(range(n)))
ckt.mct(list(range(n)),n)
ckt.x(list(range(n+1)))
ckt.h(list(range(n)))
grover_ckt.x(n)
grover_ckt.barrier()
grover_ckt.h(list(range(n+1)))
grover_ckt.draw()
svsim= Aer.get_backend('statevector_simulator')
qobj=assemble(grover_ckt)
result=svsim.run(qobj).result()
#statevector=result.data()["statevector"]
statevector=result.get_statevector()
statevector=np.array(statevector)
#statevector.dtype
statevector.shape
print(statevector)
statevector=statevector[:2**n]
statevector.shape
#print(np.array([i for i in range(2**n)]))
#statevector = statevector(dims=[i for i in range(2**n)])
marked=[1,0,1,1]
ket_a=np.zeros(2**n)
ket_a[13]=1
ket_e=(np.ones(2**n)-ket_a)/np.sqrt(2**n-1)
ket_a
ket_e
def get_projection(psi,e,a):
proj=[np.real(np.vdot(e,psi)),np.real(np.vdot(a,psi))]
return proj
def plt_vector(proj,axes=[0.0,1.0,0.0,1.0]):
x_pos=0
y_pos=0
x_direct=proj[0]
y_direct=proj[1]
fig,ax =plt.subplots()
ax.quiver(x_pos,y_pos,x_direct,y_direct,scale=1.0)
ax.axis(axes)
plt.show()
proj =get_projection(statevector,ket_e,ket_a)
plt_vector(proj)
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
grover_ckt.draw()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
grover_ckt.draw()
svsim= Aer.get_backend('statevector_simulator')
qobj=assemble(grover_ckt)
result=svsim.run(qobj).result()
#statevector=result.data()["statevector"]
statevector=result.get_statevector()
statevector=np.array(statevector)
statevector=statevector[:2**n]
proj =get_projection(statevector,ket_e,ket_a)
plt_vector(proj)
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
grover_ckt.draw()
svsim= Aer.get_backend('statevector_simulator')
qobj=assemble(grover_ckt)
result=svsim.run(qobj).result()
#statevector=result.data()["statevector"]
statevector=result.get_statevector()
statevector=np.array(statevector)
statevector=statevector[:2**n]
proj =get_projection(statevector,ket_e,ket_a)
plt_vector(proj)
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
grover_ckt.draw()
svsim= Aer.get_backend('statevector_simulator')
qobj=assemble(grover_ckt)
result=svsim.run(qobj).result()
#statevector=result.data()["statevector"]
statevector=result.get_statevector()
statevector=np.array(statevector)
statevector=statevector[:2**n]
proj =get_projection(statevector,ket_e,ket_a)
plt_vector(proj,axes=[-1.0,1.0,-1.0,1.0])
import math
thetaO=math.asin(1/math.sqrt(2**n))
print(thetaO)
T=0
angle=thetaO
print(angle)
while(angle+(2*thetaO)<=(math.pi/2)and angle>=0):
T+=1
angle=angle+(2*thetaO)
print(angle)
#print(T)
n=4
grover_ckt=QuantumCircuit(n+1,n)
marked=[1,0,1,1]#1101 marked =13
grover_ckt.x(n)
grover_ckt.barrier()
grover_ckt.h(list(range(n+1)))
grover_ckt.barrier()
for _ in range(int(np.floor(T))):
apply_oracle(4,marked,grover_ckt)
grover_ckt.barrier()
reflect_uniform(grover_ckt,n)
grover_ckt.barrier()
for j in range(n):
grover_ckt.measure(j,j)
grover_ckt.draw()
sim=Aer.get_backend("qasm_simulator")
qobj=assemble(grover_ckt)
result=sim.run(qobj).result()
result
counts=result.get_counts(grover_ckt)
plot_histogram(counts)
|
https://github.com/ka-us-tubh/quantum-computing-qiskit-
|
ka-us-tubh
|
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 *
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
qr=QuantumRegister(2)
cr=ClassicalRegister(2)
circuit=QuantumCircuit(cr,qr)
%matplotlib inline
circuit.draw()
circuit.h(qr[0])
circuit.draw()
circuit.cx(qr[0],qr[1])
circuit.draw()
circuit.measure(qr,cr)
circuit.draw()
simulator = Aer.get_backend('qasm_simulator')
result=execute(circuit,backend= simulator).result()
plot_histogram(result.get_counts(circuit))
provider=IBMQ.get_provider('ibm-q')
qcomp=provider.get_backend('ibmq_quito')
|
https://github.com/ka-us-tubh/quantum-computing-qiskit-
|
ka-us-tubh
|
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
from qiskit.extensions import Initialize
from qiskit_textbook.tools import random_state
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
qr =QuantumRegister(3,name='q')
crz=ClassicalRegister(1,name='crz')
crx =ClassicalRegister(1,name='crx')
qc=QuantumCircuit(qr,crz,crx)
def create_bell_pair(qc,a,b):
qc.h(a)
qc.cx(a,b)
def alice_gates(qc,psi,a):
qc.cx(psi,a)
qc.h(psi)
def measure_and_send(qr,a,b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
def bob_gates(qc,qubit,crz,crx):
qc.x(qubit).c_if(crx,1)
qc.z(qubit).c_if(crz,1)
psi =random_state(1)
display(array_to_latex(psi,prefix="|\\psi\\rangle="))
plot_bloch_multivector(psi)
init_gate=Initialize(psi)
init_gate.label='init'
qc.append(init_gate,[0])
qc.barrier()
create_bell_pair(qc,1,2)
qc.barrier()
alice_gates(qc,0,1)
measure_and_send(qc,0,1)
bob_gates(qc,2,crz,crx)
qc.draw()
sim=Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector=sim.run(qc).result().get_statevector()
plot_bloch_multivector(out_vector)
#usinng qasm sim
inverse_init_gate=init_gate.gates_to_uncompute()
qc.append(init_gate,[0])
qc.barrier()
create_bell_pair(qc,1,2)
qc.barrier()
alice_gates(qc,0,1)
measure_and_send(qc,0,1)
bob_gates(qc,2,crz,crx)
qc.append(inverse_init_gate,[2])
cr_result=ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
t_qc=transpile(qc,sim)
t_qc.save_statevector()
counts =sim.run(t_qc).result().get_counts()
plot_histogram(counts)
def new_bob_gates(qc,a,b,c):
qc.cx(b,c)
qc.cz(a,c)
qc=QuantumCircuit(3,1)
qc.append(init_gate,[0])
qc.barrier()
create_bell_pair(qc,1,2)
qc.barrier()
alice_gates(qc,0,1)
qc.barrier()
#measure_and_send(qc,0,1)
new_bob_gates(qc,0,1,2)
qc.append(inverse_init_gate,[2])
#cr_result=ClassicalRegister(1)
#qc.add_register(cr_result)
qc.measure(2,0)
qc.draw()
IBMQ.load_account()
provider=IBMQ.get_provider(hub="ibm-q")
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
backend=least_busy(provider.backends(filters=lambda b:b.configuration().n_qubits>=3 and
not b.configuration().simulator and b.status().operational==True))
t_qc =transpile(qc,backend,optimization_level=3)
job=backend.run(t_qc)
job_monitor(job)
exp_result=job.result()
exp_counts =exp_result.get_counts(qc)
print(exp_counts)
plot_histogram(exp_counts)
|
https://github.com/ka-us-tubh/quantum-computing-qiskit-
|
ka-us-tubh
|
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
from qiskit.extensions import Initialize
from qiskit_textbook.tools import random_state
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
qr =QuantumRegister(3,name='q')
crz=ClassicalRegister(1,name='crz')
crx =ClassicalRegister(1,name='crx')
qc=QuantumCircuit(qr,crz,crx)
def create_bell_pair(qc,a,b):
qc.h(a)
qc.cx(a,b)
def alice_gates(qc,psi,a):
qc.cx(psi,a)
qc.h(psi)
def measure_and_send(qr,a,b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
def bob_gates(qc,qubit,crz,crx):
qc.x(qubit).c_if(crx,1)
qc.z(qubit).c_if(crz,1)
psi =random_state(1)
display(array_to_latex(psi,prefix="|\\psi\\rangle="))
plot_bloch_multivector(psi)
init_gate=Initialize(psi)
init_gate.label='init'
qc.append(init_gate,[0])
qc.barrier()
create_bell_pair(qc,1,2)
qc.barrier()
alice_gates(qc,0,1)
measure_and_send(qc,0,1)
bob_gates(qc,2,crz,crx)
qc.draw()
sim=Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector=sim.run(qc).result().get_statevector()
plot_bloch_multivector(out_vector)
#usinng qasm sim
inverse_init_gate=init_gate.gates_to_uncompute()
qc.append(init_gate,[0])
qc.barrier()
create_bell_pair(qc,1,2)
qc.barrier()
alice_gates(qc,0,1)
measure_and_send(qc,0,1)
bob_gates(qc,2,crz,crx)
qc.append(inverse_init_gate,[2])
cr_result=ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
t_qc=transpile(qc,sim)
t_qc.save_statevector()
counts =sim.run(t_qc).result().get_counts()
plot_histogram(counts)
|
https://github.com/SultanMS/Qiskit_Tutorial
|
SultanMS
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
import qiskit as q
import math # for Pi and other math functions
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qasm_sim= q.Aer.get_backend("qasm_simulator") #Choose to run the code on a simulator or a real quantum computer
statevec_sim = q.Aer.get_backend("statevector_simulator")
print("done setup")
# This circuit to practice Qiskit (gives hints to HW5)
c = q.QuantumCircuit(4,3) # create a circuit with 4 qubits and 3 cbits. The cbits are needed to store the measerued qubits values.
c.rx(math.pi/2, 0) # Rotate qbit-0 90 degrees on X
c.ry(math.pi/4, 1) # Rorate qbit-1 45 degrees on Y
c.h(2) # apply H gate on qbit-2
c.cnot(0,3) # apply CNot gate on qubits (0 and 1)
c.cnot(1,3) # apply CNot gate on qubits (1 and 3)
c.cnot(2,3) # apply CNot gate on qubits (2 and 3)
c.rz(math.pi/4, 2) # Rotate qbit-2 45 degrees on Z
c.h(2) # Apply H gate again on qbit-2
c.measure([0,1,2], [0,1,2]) # measure qubits [0,1,2] and store the results in cbit [0,1,2]
psi0 = q.execute(c,backend=statevec_sim).result().get_statevector()
print("Done.. Draw circuit:")
c.draw()
plot_bloch_multivector(psi0)
count1 = q.execute(c,backend=qasm_sim, shots=1024).result().get_counts()
plot_histogram([count1], legend=['counts'] )
|
https://github.com/akashktesla/qiskit_testing
|
akashktesla
|
from qiskit import QuantumCircuit
import matplotlib.pyplot as plt
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
# qc.draw('mpl',style='iqp')
# plt.show()
from qiskit.quantum_info import Pauli
ZZ = Pauli('ZZ')
ZI = Pauli('ZI')
IZ = Pauli('IZ')
XX = Pauli('XX')
XI = Pauli('XI')
IX = Pauli('IX')
observables = [ZZ,ZI,IZ,XX,XI,IX]
#execute
from qiskit_aer.primitives import Estimator
estimator = Estimator()
job = estimator.run([qc]*len(observables),observables)
# print(job.result())
#plotting
data = ['ZZ', 'ZI', 'IZ', 'XX', 'XI', 'IX']
values = job.result().values
plt.plot(data,values,'-o')
plt.xlabel('Observables')
plt.ylabel('Expected values')
plt.show()
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
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/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
# initialization
import numpy as np
import matplotlib
# importing Qiskit
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer, assemble, transpile
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
# set the length of the n-bit input string.
n = 3
# set the length of the n-bit input string.
n = 3
const_oracle = QuantumCircuit(n+1)
output = np.random.randint(2)
if output == 1:
const_oracle.x(n)
const_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
balanced_oracle.draw(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# 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(output='mpl', style=style)
balanced_oracle = QuantumCircuit(n+1)
b_str = "101"
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(n):
balanced_oracle.cx(qubit, n)
balanced_oracle.barrier()
# Place X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
balanced_oracle.x(qubit)
# Show oracle
balanced_oracle.draw(output='mpl', style=style)
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(output='mpl', style=style)
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)
# Add oracle
dj_circuit += balanced_oracle
dj_circuit.draw(output='mpl', style=style)
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)
# Add oracle
dj_circuit += balanced_oracle
# 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(output='mpl', style=style)
# 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)
def dj_oracle(case, n):
# We need to make a QuantumCircuit object to return
# This circuit has n+1 qubits: the size of the input,
# plus one output qubit
oracle_qc = QuantumCircuit(n+1)
# First, let's deal with the case in which oracle is balanced
if case == "balanced":
# First generate a random number that tells us which CNOTs to
# wrap in X-gates:
b = np.random.randint(1,2**n)
print(b)
print(str(n))
b=7
# Next, format 'b' as a binary string of length 'n', padded with zeros:
b_str = format(b, '0'+str(n)+'b')
print(b_str)
# Next, we place the first X-gates. Each digit in our binary string
# corresponds to a qubit, if the digit is 0, we do nothing, if it's 1
# we apply an X-gate to that qubit:
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Do the controlled-NOT gates for each qubit, using the output qubit
# as the target:
for qubit in range(n):
oracle_qc.cx(qubit, n)
# Next, place the final X-gates
for qubit in range(len(b_str)):
if b_str[qubit] == '1':
oracle_qc.x(qubit)
# Case in which oracle is constant
if case == "constant":
# First decide what the fixed output of the oracle will be
# (either always 0 or always 1)
output = np.random.randint(2)
if output == 1:
oracle_qc.x(n)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "Oracle" # To show when we display the circuit
return oracle_gate
def dj_algorithm(oracle, n):
dj_circuit = QuantumCircuit(n+1, n)
# Set up the output qubit:
dj_circuit.x(n)
dj_circuit.h(n)
# And set up the input register:
for qubit in range(n):
dj_circuit.h(qubit)
# Let's append the oracle gate to our circuit:
dj_circuit.append(oracle, range(n+1))
# Finally, perform the H-gates again and measure:
for qubit in range(n):
dj_circuit.h(qubit)
for i in range(n):
dj_circuit.measure(i, i)
return dj_circuit
n = 4
oracle_gate = dj_oracle('balanced', n)
dj_circuit = dj_algorithm(oracle_gate, n)
dj_circuit.draw(output='mpl', style=style)
transpiled_dj_circuit = transpile(dj_circuit, aer_sim)
qobj = assemble(transpiled_dj_circuit)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
from qiskit import QuantumCircuit
from qiskit.tools.visualization import circuit_drawer
import numpy as np
from matplotlib import pyplot as plt
n=5
qc = QuantumCircuit(n)
qc.x(1)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
qc.x(1)
qc.draw('mpl')
def phase_oracle(n, name = 'Uf'):
qc = QuantumCircuit(n, name = name)
qc.x(1)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
qc.x(1)
return qc
n=5
qc = QuantumCircuit(n)
for i in range(n-2):
qc.x(i)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
for i in range(n-2):
qc.x(i)
qc.draw('mpl')
def diffuser(n, name= 'V'):
qc = QuantumCircuit(n, name =name)
for qb in range(n-2): # First layer of Hadamards in diffuser
qc.h(qb)
for i in range(n-2):
qc.x(i)
qc.ccx(0, 1, 3)
qc.ccx(2, 3, 4)
qc.ccx(0, 1, 3)
for i in range(n-2):
qc.x(i)
for qb in range(n-2): # Second layer of Hadamards in diffuser
qc.h(qb)
return qc
n=5
gr = QuantumCircuit(n, n-2)
mu = 1 #number of solutions
r = int(np.floor(np.pi/4*np.sqrt(2**(n-2)/mu))) #determine r
print('r = ',r)
gr.h(range(n-2)) #step1: apply Hadamard gates on all working qubits
#put ancilla in state |->
gr.x(n-1)
gr.h(n-1)
#step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr.append(phase_oracle(n), range(n))
gr.append(diffuser(n), range(n))
gr.measure(range(n-2), range(n-2)) #step 3: measure all qubits
gr.draw('mpl')
from qiskit import BasicAer, Aer, execute, IBMQ
from qiskit.visualization import plot_histogram
simulator = Aer.get_backend('qasm_simulator')
result = execute(gr, backend = simulator, shots = 1024).result()
counts = result.get_counts()
plot_histogram(counts)
from qiskit import IBMQ
IBMQ.save_account('e19ab1a54fb68a1937a725b48b02eafb8af0db9189107e78762686e5bf12dff5642e1597470d966ea9d2e121cc86f4a0f08bea5d5e760de66c7be7be04fd2974')
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q')
device = provider.get_backend('ibmq_qasm_simulator')
job = execute(gr, 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(gr))
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
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/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector, plot_bloch_vector, plot_histogram
from qiskit.compiler import transpile, assemble
from qiskit.tools.monitor import job_monitor
from qiskit.providers.ibmq import least_busy
import matplotlib
import numpy as np
%pylab inline
qc = QuantumCircuit(4,3)
qc.x(3)
qc.h(range(3))
reps = 1
for count in range(3):
for i in range (reps):
qc.cp(pi/4, count, 3)
reps *= 2
qc.barrier()
qc.draw('mpl')
def inv_qft(qc, n):
for qubit in range (n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-pi/(2*(j-m)), m, j)
qc.h(j)
inv_qft(qc, 3)
qc.barrier()
qc.measure(range(3), range(3))
qc.draw('mpl')
qasm_sim = Aer.get_backend('qasm_simulator')
shots = 1
qobj = assemble(qc, qasm_sim)
results = qasm_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 4 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
shots = 1024
transpiled_circuit = transpile(qc, backend)
qobj = assemble(transpiled_circuit, shots=shots)
job = backend.run(qobj)
job_monitor(job, interval=2)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.providers.ibmq import least_busy
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.extensions import Initialize
from qiskit_textbook.tools import random_state, array_to_latex
import matplotlib.pyplot
%pylab inline
#Defining srtucture of the circuit
circuit = QuantumCircuit(3,1)
#Creating a qubit in random state
psi = random_state(1)
# Display it nicely
array_to_latex(psi, pretext="|\\psi\\rangle =")
# Show it on a Bloch sphere
plot_bloch_multivector(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
#append inti gate to the qc
circuit.append(init_gate, [0])
circuit.barrier()
#Creating entanglement in q1 and q2
circuit.h(1)
circuit.cx(1,2)
circuit.barrier()
#Defining gates for sender
circuit.cx(0,1)
circuit.h(0)
circuit.barrier()
#reciever gates (different as no operations can be performed after measuring on hardware)
circuit.cx(1,2)
circuit.cz(0,2)
circuit.barrier()
#to measure the 3rd qubit
inverse_init_gate = init_gate.gates_to_uncompute()
circuit.append(inverse_init_gate, [2])
#measure
circuit.measure(2,0)
circuit.draw('mpl')
#Using Quasm Simulator
qasm_sim = Aer.get_backend('qasm_simulator')
t_qc = transpile(circuit, qasm_sim)
qobj = assemble(t_qc)
counts = qasm_sim.run(qobj).result().get_counts()
plot_histogram(counts)
IBMQ.load_account()
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)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
shots = 1024
transpiled_circuit = transpile(circuit, backend)
qobj = assemble(transpiled_circuit, shots=shots)
job = backend.run(qobj)
job_monitor(job, interval=2)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.extensions import Initialize
from qiskit_textbook.tools import random_state, array_to_latex
import matplotlib.pyplot
%pylab inline
#Defining srtucture of the circuit
qr = QuantumRegister(3, name="q")
crz = ClassicalRegister(1, name="crz")
crx = ClassicalRegister(1, name="crx")
circuit = QuantumCircuit(qr, crz, crx)
#Creating a qubit in random state
psi = random_state(1)
# Display it nicely
array_to_latex(psi, pretext="|\\psi\\rangle =")
# Show it on a Bloch sphere
plot_bloch_multivector(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
#append inti gate to the qc
circuit.append(init_gate, [0])
circuit.barrier()
#Creating entanglement in q1 and q2
circuit.h(1)
circuit.cx(1,2)
circuit.barrier()
#Defining gates for sender
circuit.cx(0,1)
circuit.h(0)
circuit.barrier()
#Measuring the bits and sending it to classical bits
circuit.measure((0,1), (0,1))
#reciever gates
circuit.x(2).c_if(crx, 1)
circuit.z(2).c_if(crz, 1)
circuit.draw('mpl')
#Using Statevector simuator
sv_sim = Aer.get_backend('statevector_simulator')
qobj = assemble(circuit)
out_vector = sv_sim.run(qobj).result().get_statevector()
plot_bloch_multivector(out_vector)
#To check the gates followed in order to confirm teleportation
circuit.barrier()
inverse_init_gate = init_gate.gates_to_uncompute()
circuit.append(inverse_init_gate, [2])
#To measure the third qubit
result_cb = ClassicalRegister(1)
circuit.add_register(result_cb)
circuit.measure(2,2)
circuit.draw('mpl')
#Using Quasm Simulator
qasm_sim = Aer.get_backend('qasm_simulator')
t_qc = transpile(circuit, qasm_sim)
qobj = assemble(t_qc)
counts = qasm_sim.run(qobj).result().get_counts()
plot_histogram(counts)
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
# 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/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
# Importing Packages
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble, QuantumRegister, ClassicalRegister
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
bb = input("Enter the input string:\n")
### Using in-built "simon_oracle" from QISKIT
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
n = len(bb)
simon_circuit = QuantumCircuit(n*2, n)
# Apply Hadamard gates before querying the oracle
simon_circuit.h(range(n))
# Apply barrier for visual separation
simon_circuit.barrier()
simon_circuit += simon_oracle(bb)
# Apply barrier for visual separation
simon_circuit.barrier()
# Apply Hadamard gates to the input register
simon_circuit.h(range(n))
# Measure qubits
simon_circuit.measure(range(n), range(n))
simon_circuit.draw(output="mpl")
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(simon_circuit, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Calculate the dot product of the results
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
for z in counts:
print( '{}.{} = {} (mod 2)'.format(b, z, bdotz(b,z)) )
b = input("Enter a binary string:\n")
# Actual b = 011
b_rev = b[::-1]
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
qc.measure(q1,c1)
qc.draw("mpl")
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(qc, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Actual b = 011
b="1"
b_rev = "1"
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
# qc.measure(q1,c1)
# qc.draw("mpl")
# Simulate the unitary
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
# Display the results:
array_to_latex(unitary, prefix="\\text{Circuit = } ")
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
# Importing Packages
from qiskit import QuantumCircuit
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
def encode(qc, qubit, msg):
if len(msg) != 2 or not set(msg).issubset({"0","1"}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
# Circuit for Superdense coding
qc = QuantumCircuit(2)
# Generating entangled state
qc.h(1)
qc.cx(1, 0)
qc.barrier()
# Encoding message
message = '11'
qc = encode(qc, 1, message)
qc.barrier()
# Decoding Message
qc.cx(1, 0)
qc.h(1)
# Measuring qubits
qc.measure_all()
qc.draw(output="mpl", style=style)
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(qc)
result = aer_sim.run(qobj).result()
counts = result.get_counts(qc)
print(counts)
plot_histogram(counts)
|
https://github.com/drithidavuluri/Implementation-of-Algorithm-using-Qiskit
|
drithidavuluri
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
# import basic plot tools
from qiskit.visualization import plot_histogram
def dj_oracle(case, n):
# Making a quantum circuit with n+1 qubit(size of input + output)
oracle_qc = QuantumCircuit(n+1)
# oracle is balanced
if case == "balanced":
# apply controlled-not gate for each qubit using output qubit as the target
for qubit in range(n):
oracle_qc.cx(qubit, n) # acts as parity checker(even number of 1s = 0, odd = 1), to make sure half of the input map to zero and half maps to 1.
# oracle is constant
if case == "constant":
# decide a random integer between 0 or 1
output = np.random.randint(2)
if output == 1:
oracle_qc.x(n)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "Oracle"
return oracle_gate
def dj_algorithm(n, case = 'random'):
dj_circuit = QuantumCircuit(n+1, n) # n+1 qubit, n calssical bits
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.x(n)
dj_circuit.h(n)
if case == 'random':
random = np.random.randint(2)
if random == 0:
case = 'constant'
else:
case = 'balanced'
oracle = dj_oracle(case, n)
dj_circuit.append(oracle, range(n+1))
for i in range(n):
dj_circuit.h(i)
dj_circuit.measure(i,i)
return dj_circuit
n = 4
dj_circuit = dj_algorithm(n)
dj_circuit.draw("mpl")
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
dj_circuit = dj_algorithm(n, 'constant')
results = execute(dj_circuit, backend=backend, shots=1).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/drithidavuluri/Implementation-of-Algorithm-using-Qiskit
|
drithidavuluri
|
import qiskit.quantum_info as qi #this is used to do calculations
from qiskit.circuit.library import FourierChecking
from qiskit.visualization import plot_histogram
f=[1,-1,-1,-1]
g=[1,1,-1,-1]
circuit = FourierChecking(f=f,g=g)
circuit.draw()
zero = qi.Statevector.from_label('00')
sv = zero.evolve(circuit)
probs = sv.probabilities_dict()
plot_histogram(probs)
print(probs)
|
https://github.com/drithidavuluri/Implementation-of-Algorithm-using-Qiskit
|
drithidavuluri
|
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/drithidavuluri/Implementation-of-Algorithm-using-Qiskit
|
drithidavuluri
|
# Importing Libraries
import torch
from torch import cat, no_grad, manual_seed
from torch.utils.data import DataLoader
from torchvision import transforms
import torch.optim as optim
from torch.nn import (
Module,
Conv2d,
Linear,
Dropout2d,
NLLLoss
)
import torch.nn.functional as F
import numpy as np
import matplotlib.pyplot as plt
from qiskit_machine_learning.neural_networks import EstimatorQNN
from qiskit_machine_learning.connectors import TorchConnector
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit import QuantumCircuit
from qiskit.visualization import circuit_drawer
# Imports for CIFAR-10s
from torchvision.datasets import CIFAR10
from torchvision import transforms
def prepare_data(X, labels_to_keep, batch_size):
# Filtering out labels (originally 0-9), leaving only labels 0 and 1
filtered_indices = [i for i in range(len(X.targets)) if X.targets[i] in labels_to_keep]
X.data = X.data[filtered_indices]
X.targets = [X.targets[i] for i in filtered_indices]
# Defining dataloader with filtered data
loader = DataLoader(X, batch_size=batch_size, shuffle=True)
return loader
# Set seed for reproducibility
manual_seed(42)
# CIFAR-10 data transformation
transform = transforms.Compose([
transforms.ToTensor(), # convert the images to tensors
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # Normalization usign mean and std.
])
labels_to_keep = [0, 1]
batch_size = 1
# Preparing Train Data
X_train = CIFAR10(root="./data", train=True, download=True, transform=transform)
train_loader = prepare_data(X_train, labels_to_keep, batch_size)
# Preparing Test Data
X_test = CIFAR10(root="./data", train=False, download=True, transform=transform)
test_loader = prepare_data(X_test, labels_to_keep, batch_size)
print(f"Training dataset size: {len(train_loader.dataset)}")
print(f"Test dataset size: {len(test_loader.dataset)}")
# Defining and creating QNN
def create_qnn():
feature_map = ZZFeatureMap(2) # ZZFeatureMap with 2 bits, entanglement between qubits based on the pairwise product of input features.
ansatz = RealAmplitudes(2, reps=1) # parameters (angles, in the case of RealAmplitudes) that are adjusted during the training process to optimize the quantum model for a specific task.
qc = QuantumCircuit(2)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
qnn = EstimatorQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
input_gradients=True,
)
return qnn
qnn = create_qnn()
# Visualizing the QNN circuit
circuit_drawer(qnn.circuit, output='mpl')
# Defining torch NN module
class Net(Module):
def __init__(self, qnn):
super().__init__()
self.conv1 = Conv2d(3, 16, kernel_size=3, padding=1)
self.conv2 = Conv2d(16, 32, kernel_size=3, padding=1)
self.dropout = Dropout2d()
self.fc1 = Linear(32 * 8 * 8, 64)
self.fc2 = Linear(64, 2) # 2-dimensional input to QNN
self.qnn = TorchConnector(qnn)
self.fc3 = Linear(1, 1) # 1-dimensional output from QNN
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = self.dropout(x)
x = x.view(x.shape[0], -1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = self.qnn(x)
x = self.fc3(x)
return cat((x, 1 - x), -1)
# Creating model
model = Net(qnn)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model.to(device)
# Defining model, optimizer, and loss function
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = NLLLoss()
# Starting training
epochs = 10
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
data, target = data.to(device), target.to(device) # Move data to GPU
optimizer.zero_grad(set_to_none=True)
output = model(data)
loss = loss_func(output, target)
loss.backward()
optimizer.step()
total_loss.append(loss.item())
loss_list.append(sum(total_loss) / len(total_loss))
print("Training [{:.0f}%]\tLoss: {:.4f}".format(100.0 * (epoch + 1) / epochs, loss_list[-1]))
# Plotting loss convergence
plt.plot(loss_list)
plt.title("Hybrid NN Training Convergence")
plt.xlabel("Training Iterations")
plt.ylabel("Neg. Log Likelihood Loss")
plt.show()
# Saving the model
torch.save( model.state_dict(), "model_cifar10_10EPOCHS.pt")
# Loading the model
qnn_cifar10 = create_qnn()
model_cifar10 = Net(qnn_cifar10)
model_cifar10.load_state_dict(torch.load("model_cifar10.pt"))
correct = 0
total = 0
model_cifar10.eval()
with torch.no_grad():
for data, target in test_loader:
output = model_cifar10(data)
_, predicted = torch.max(output.data, 1)
total += target.size(0)
correct += (predicted == target).sum().item()
# Calculating and print test accuracy
test_accuracy = correct / total * 100
print(f"Test Accuracy: {test_accuracy:.2f}%")
# Plotting predicted labels
n_samples_show = 6
count = 0
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
model_cifar10.eval()
with no_grad():
for batch_idx, (data, target) in enumerate(test_loader):
if count == n_samples_show:
break
output = model_cifar10(data)
if len(output.shape) == 1:
output = output.reshape(1, *output.shape)
pred = output.argmax(dim=1, keepdim=True)
axes[count].imshow(np.transpose(data[0].numpy(), (1, 2, 0)))
axes[count].set_xticks([])
axes[count].set_yticks([])
axes[count].set_title("Predicted {0}\n Actual {1}".format(pred.item(), target.item()))
count += 1
plt.show()
|
https://github.com/drithidavuluri/Implementation-of-Algorithm-using-Qiskit
|
drithidavuluri
|
# 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/mvicenzi/grover-qiskit
|
mvicenzi
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
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.circuit.library.standard_gates import XGate, HGate
from operator import *
n = 3
N = 8 #2**n
index_colour_table = {}
colour_hash_map = {}
index_colour_table = {'000':"yellow", '001':"red", '010':"blue", '011':"red", '100':"green", '101':"blue", '110':"orange", '111':"red"}
colour_hash_map = {"yellow":'100', "red":'011', "blue":'000', "green":'001', "orange":'010'}
def database_oracle(index_colour_table, colour_hash_map):
circ_database = QuantumCircuit(n + n)
for i in range(N):
circ_data = QuantumCircuit(n)
idx = bin(i)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
# qiskit maps the rightmost bit as the 0th qubit -> qn, ..., q0
# we therefore reverse the index string -> q0, ..., qn
data_gate = circ_data.to_gate(label=colour).control(num_ctrl_qubits=n, ctrl_state=idx, label="index-"+colour)
circ_database.append(data_gate, list(range(n+n)))
return circ_database
# drawing the database oracle circuit
print("Database Encoding")
database_oracle(index_colour_table, colour_hash_map).draw()
circ_data = QuantumCircuit(n)
m = 4
idx = bin(m)[2:].zfill(n) # removing the "0b" prefix appended by the bin() funtion
colour = index_colour_table[idx]
colour_hash = colour_hash_map[colour][::-1]
for j in range(n):
if colour_hash[j] == '1':
circ_data.x(j)
print("Internal colour encoding for the colour green (as an example)");
circ_data.draw()
def oracle_grover(database, data_entry):
circ_grover = QuantumCircuit(n + n + 1)
circ_grover.append(database, list(range(n+n)))
target_reflection_gate = XGate().control(num_ctrl_qubits=n, ctrl_state=colour_hash_map[data_entry], label="Reflection of " + "\"" + data_entry + "\" Target")
# control() missing 1 required positional argument: 'self' .... if only 'XGate' used instead of 'XGate()'
# The “missing 1 required positional argument: 'self'” error is raised when you do not instantiate an object of a class before calling a class method. This error is also raised when you incorrectly instantiate a class.
circ_grover.append(target_reflection_gate, list(range(n, n+n+1)))
circ_grover.append(database, list(range(n+n)))
return circ_grover
print("Grover Oracle (target example: orange)")
oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), "orange").decompose().draw()
def mcz_gate(num_qubits):
num_controls = num_qubits - 1
mcz_gate = QuantumCircuit(num_qubits)
target_mcz = QuantumCircuit(1)
target_mcz.z(0)
target_mcz = target_mcz.to_gate(label="Z_Gate").control(num_ctrl_qubits=num_controls, ctrl_state=None, label="MCZ")
mcz_gate.append(target_mcz, list(range(num_qubits)))
return mcz_gate.reverse_bits()
print("Multi-controlled Z (MCZ) Gate")
mcz_gate(n).decompose().draw()
def diffusion_operator(num_qubits):
circ_diffusion = QuantumCircuit(num_qubits)
qubits_list = list(range(num_qubits))
# Layer of H^n gates
circ_diffusion.h(qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of Multi-controlled Z (MCZ) Gate
circ_diffusion = circ_diffusion.compose(mcz_gate(num_qubits), qubits_list)
# Layer of X^n gates
circ_diffusion.x(qubits_list)
# Layer of H^n gates
circ_diffusion.h(qubits_list)
return circ_diffusion
print("Diffusion Circuit")
diffusion_operator(n).draw()
# Putting it all together ... !!!
item = "green"
print("Searching for the index of the colour", item)
circuit = QuantumCircuit(n + n + 1, n)
circuit.x(n + n)
circuit.barrier()
circuit.h(list(range(n)))
circuit.h(n+n)
circuit.barrier()
unitary_oracle = oracle_grover(database_oracle(index_colour_table, colour_hash_map).to_gate(label="Database Encoding"), item).to_gate(label="Oracle Operator")
unitary_diffuser = diffusion_operator(n).to_gate(label="Diffusion Operator")
M = countOf(index_colour_table.values(), item)
Q = int(np.pi * np.sqrt(N/M) / 4)
for i in range(Q):
circuit.append(unitary_oracle, list(range(n + n + 1)))
circuit.append(unitary_diffuser, list(range(n)))
circuit.barrier()
circuit.measure(list(range(n)), list(range(n)))
circuit.draw()
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(circuit, backend_sim), shots=1024)
result_sim = job_sim.result()
counts = result_sim.get_counts(circuit)
if M==1:
print("Index of the colour", item, "is the index with most probable outcome")
else:
print("Indices of the colour", item, "are the indices the most probable outcomes")
from qiskit.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/mvicenzi/grover-qiskit
|
mvicenzi
|
#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
n = 2
grover_circuit = QuantumCircuit(n)
def initialize_s(qc, qubits):
"""Apply a H-gate to 'qubits' in qc"""
for q in qubits:
qc.h(q)
return qc
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
grover_circuit = initialize_s(grover_circuit, [0,1])
grover_circuit.draw(output="mpl")
grover_circuit.cz(0,1) # Oracle
grover_circuit.draw(output="mpl")
# Diffusion operator (U_s)
grover_circuit.append(diffuser(n),[0,1])
grover_circuit.draw(output="mpl")
sim = Aer.get_backend('aer_simulator')
# we need to make a copy of the circuit with the 'save_statevector'
# instruction to run on the Aer simulator
grover_circuit_sim = grover_circuit.copy()
grover_circuit_sim.save_statevector()
qobj = assemble(grover_circuit_sim)
result = sim.run(qobj).result()
statevec = result.get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
grover_circuit.measure_all()
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(grover_circuit)
result = aer_sim.run(qobj).result()
counts = result.get_counts()
plot_histogram(counts)
nqubits = 4
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)
qc.barrier()
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
qc.barrier()
# 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)
qc.draw(output="mpl")
from qiskit.circuit import classical_function, Int1
# define a classical function f(x): this returns 1 for the solutions of the problem
# in this case, the solutions are 1010 and 1100
@classical_function
def f(x1: Int1, x2: Int1, x3: Int1, x4: Int1) -> Int1:
return (x1 and not x2 and x3 and not x4) or (x1 and x2 and not x3 and not x4)
nqubits = 4
Uf = f.synth() # turn it into a circuit
oracle = QuantumCircuit(nqubits+1)
oracle.compose(Uf, inplace=True)
oracle.draw(output="mpl")
# We will return the diffuser as a gate
#U_f = oracle.to_gate()
# U_f.name = "U$_f$"
# return U_f
|
https://github.com/anishrverma/Hybrid-Quantum-Endowment-Portfolio-Optimization
|
anishrverma
|
# %pip install --upgrade pip
# %pip install -r requirements.txt
import seaborn as sn
import matplotlib.pyplot as plt
from qiskit.visualization import plot_histogram
from datetime import datetime
import numpy as np
from itertools import permutations
from qiskit_finance.data_providers import YahooDataProvider
import json # Necessary for YahooDataProvider
import http.client # Necessary for YahooDataProvider
import pandas as pd
import pandas_datareader as web
import os
from docplex.mp.model import Model
from qiskit_optimization.translators import from_docplex_mp
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit.algorithms import NumPyMinimumEigensolver
from qiskit_optimization.converters import LinearEqualityToPenalty
from qiskit.circuit.library import TwoLocal # For Ansatz
from qiskit.algorithms.optimizers import COBYLA, ADAM, NELDER_MEAD, POWELL, SPSA, QNSPSA
from qiskit.opflow import CVaRExpectation
from qiskit.opflow import PauliExpectation
from qiskit.algorithms import VQE
from qiskit.algorithms import QAOA
from qiskit import Aer
dfMonthlyReturns = pd.read_csv('data/Equity-Benchmarks-Monthly-Return.csv',parse_dates=["Date"],index_col=0)
dfMonthlyReturnsRiskScaled = pd.read_csv('data/Equity-Benchmarks-Monthly-Risk-Scaled.csv',parse_dates=["Date"],index_col=0)
assets = dfMonthlyReturns.columns.to_list()
numAssets = len(assets)
print("We have " + str(numAssets) + " Assets:\n")
[print(asset + " ") for asset in assets];
q = 0.5 # risk apetite
B = 5 # budget
#Whole Period
startDate=datetime(2001, 1, 31)
endDate=datetime(2021, 12, 31)
# #Pre 2008
# startDate=datetime(2001, 1, 31)
# endDate=datetime(2008, 6, 30)
# #QE Era
# startDate=datetime(2010, 1, 31)
# endDate=datetime(2019, 12, 31)
# #Pandemic
# startDate=datetime(2020, 6, 30)
# endDate=datetime(2021, 12, 31)
startStr = str(startDate.date())
endStr = str(endDate.date())
backend = Aer.get_backend('statevector_simulator') # statevector_simulator, qasm_simulator, aer_simulator_statevector
maxIter = 10000
# fidelity = QNSPSA.get_fidelity(ansatz) # only for QNSPSA
optimizer = SPSA(maxiter=500)
# Classical optimizer – COBYLA(maxiter=maxIter), ADAM(maxiter=maxIter), NELDER_MEAD(maxiter=maxIter),
# POWELL(maxiter=maxIter), SPSA(maxiter=100), QNSPSA(fidelity,maxiter=100)
penalty = numAssets # scaling of penalty term. This can be changed at your discretion.
mu = dfMonthlyReturns[startDate:endDate].mean().to_numpy()
sigma = dfMonthlyReturns[startDate:endDate].cov().to_numpy()
muRisk = dfMonthlyReturnsRiskScaled[startDate:endDate].mean().to_numpy()
sigmaRisk = dfMonthlyReturnsRiskScaled[startDate:endDate].cov().to_numpy()
covHeatmap = sn.heatmap(sigma,cmap="mako")
covHeatmap.set(xticklabels=assets,yticklabels=assets)
plt.yticks(rotation='horizontal')
plt.xticks(rotation='vertical')
plt.title("Covariance of Monthly Returns\n"+startStr+" to " +endStr)
plt.show()
covHeatmapRisk = sn.heatmap(sigmaRisk,cmap="mako")
covHeatmapRisk.set(xticklabels=assets,yticklabels=assets)
plt.yticks(rotation='horizontal')
plt.xticks(rotation='vertical')
plt.title("Covariance of Monthly Returns (Risk Scaled)\n"+startStr+" to " +endStr)
plt.show()
covHeatmap = sn.heatmap(sigma,cmap="mako",vmin=0,vmax=0.004)
covHeatmap.set(xticklabels=assets,yticklabels=assets)
plt.yticks(rotation='horizontal')
plt.xticks(rotation='vertical')
plt.title("Covariance of Monthly Returns\n"+startStr+" to " +endStr)
plt.show()
fig = covHeatmap.get_figure()
fig.savefig("figures/CovarianceMonthlyReturns-" + startStr + "-to-" + endStr + ".pdf",bbox_inches='tight')
covHeatmapRisk = sn.heatmap(sigmaRisk,cmap="mako",vmin=0,vmax=0.00011)
covHeatmapRisk.set(xticklabels=assets,yticklabels=assets)
plt.yticks(rotation='horizontal')
plt.xticks(rotation='vertical')
plt.title("Covariance of Monthly Returns (Risk Scaled)\n"+startStr+" to " +endStr)
plt.show()
figRisk = covHeatmapRisk.get_figure()
figRisk.savefig("figures/CovarianceMonthlyReturnsRisk-" + startStr + "-to-" + endStr + ".pdf",bbox_inches='tight')
mdl = Model("Non-Scaled") # You can input a string into the argument if you want to name the model.
x = mdl.binary_var_list('x{}'.format(i) for i in range(numAssets)) # binary decision variables
# Objective Function to be maximized
objective = mdl.sum([mu[i]*x[i] for i in range(numAssets)])
objective -= q * mdl.sum([sigma[i,j]*x[i]*x[j] for i in range(numAssets) for j in range(numAssets)])
mdl.maximize(objective)
mdl.add_constraint(mdl.sum(x[i] for i in range(numAssets)) == B) # Adding the budget constraint
qp = from_docplex_mp(mdl) # Conversion to a quadratic program
qp
mdlRisk = Model("Risk-Scaled") # You can input a string into the argument if you want to name the model.
y = mdlRisk.binary_var_list('y{}'.format(i) for i in range(numAssets)) # binary decision variables
# Objective Function to be maximized
objectiveRisk = mdlRisk.sum([muRisk[i]*y[i] for i in range(numAssets)])
objectiveRisk -= q * mdlRisk.sum([sigmaRisk[i,j]*y[i]*y[j] for i in range(numAssets) for j in range(numAssets)])
mdlRisk.maximize(objectiveRisk)
mdlRisk.add_constraint(mdlRisk.sum(y[i] for i in range(numAssets)) == B) # Adding the budget constraint
qpRisk = from_docplex_mp(mdlRisk) # Conversion to a quadratic program
qpRisk
classicalResult = MinimumEigenOptimizer(NumPyMinimumEigensolver()).solve(qp)
# classicalResultEigenstate = (classicalResult.min_eigen_solver_result.eigenstate._primitive.data.real).tolist()
classicalResultEigenstate = classicalResult.min_eigen_solver_result.eigenstate.to_dict_fn().primitive
classicalResult
# making the labels for plotting
# labels = []
# for i in range(2**numAssets):
# labels.append(format(i,'0'+str(numAssets)+'b'))
# fig = plot_histogram(dict(zip(labels, classicalResultEigenstate)),figsize=(60,10))
fig = plot_histogram(classicalResultEigenstate,figsize=(60,10))
fig.savefig("figures/ClassicalEigensolver-"+startStr+"-"+endStr+".pdf")
# fig
classicalResultRisk = MinimumEigenOptimizer(NumPyMinimumEigensolver()).solve(qpRisk)
#classicalResultRiskEigenstate = (classicalResultRisk.min_eigen_solver_result.eigenstate._primitive.data.real).tolist()
classicalResultRiskEigenstate = classicalResultRisk.min_eigen_solver_result.eigenstate.to_dict_fn().primitive
classicalResultRisk
# making the labels for plotting
# labels = []
# for i in range(2**numAssets):
# labels.append(format(i,'0'+str(numAssets)+'b'))
# fig = plot_histogram(dict(zip(labels, classicalResultRiskEigenstate)),figsize=(60,10))
fig = plot_histogram(classicalResultRiskEigenstate,figsize=(60,10))
fig.savefig("figures/ClassicalEigensolverRisk-"+startStr+"-"+endStr+".pdf")
# fig
linearToPenalty = LinearEqualityToPenalty(penalty=penalty)
qubo = linearToPenalty.convert(qp)
quboRisk = linearToPenalty.convert(qpRisk)
qubo
quboRisk
reps = 2
ansatz = TwoLocal(num_qubits=numAssets, rotation_blocks='rx', entanglement_blocks= 'cz', reps=reps, entanglement='full')
ansatz.decompose().draw()
maxIter = 10000
# fidelity = QNSPSA.get_fidelity(ansatz) # only for QNSPSA
optimizer = SPSA(maxiter=500)
# Classical optimizer – COBYLA(maxiter=maxIter), ADAM(maxiter=maxIter), NELDER_MEAD(maxiter=maxIter),
# POWELL(maxiter=maxIter), SPSA(maxiter=100), QNSPSA(fidelity,maxiter=100)
def pauliDict(H):
tempKey = []
tempVal = []
tempDict = {}
for i in range(len(H)):
tempDict[H.primitive.to_list()[i][0]] = H.primitive.to_list()[i][1]
return tempDict
H, offset = qubo.to_ising()
pauliDict(H)
HRisk, offsetRisk = quboRisk.to_ising()
pauliDict(HRisk)
def getCountDictStateVecSim(vqeResult):
tempState = []
tempProb = []
for sample in vqeResult.samples:
tempProb.append(sample.probability)
tempStr = ''
for stateElement in reversed(sample.x):
tempStr += str(int(stateElement))
tempState.append(tempStr)
return dict(zip(tempState, tempProb))
vqeInit = VQE(ansatz=ansatz,optimizer=optimizer, quantum_instance=backend)
vqe = MinimumEigenOptimizer(vqeInit)
vqeResult = vqe.solve(qubo)
if backend.name() == 'qasm_simulator':
counts = vqeResult.min_eigen_solver_result.eigenstate
elif backend.name() == 'statevector_simulator':
counts = getCountDictStateVecSim(vqeResult)
#endif
vqeResult
vqeFig = plot_histogram(counts,figsize=(60,10))
vqeFig.savefig("figures/VQE"+startStr+"-"+endStr+".pdf")
vqeFig
## ALTERNATIVE PLOT SCHEME
# samples_for_plot = {
# " ".join(f"{vqeResult.variables[i].name}={int(v)}" for i, v in enumerate(sample.x)): sample.probability
# for sample in vqeResult.samples
# }
# plot_histogram(samples_for_plot,figsize=(60,5))
vqeRiskInit = VQE(ansatz=ansatz,optimizer=optimizer, quantum_instance=backend)
vqeRisk = MinimumEigenOptimizer(vqeRiskInit)
vqeRiskResult = vqeRisk.solve(quboRisk)
if backend.name() == 'qasm_simulator':
countsRisk = vqeRiskResult.min_eigen_solver_result.eigenstate
elif backend.name() == 'statevector_simulator':
countsRisk = getCountDictStateVecSim(vqeRiskResult)
#endif
vqeRiskResult
vqeRiskFig = plot_histogram(countsRisk,figsize=(60,10))
vqeRiskFig.savefig("figures/VQERisk"+startStr+"-"+endStr+".pdf")
vqeRiskFig
qaoaInit = QAOA(optimizer=optimizer, reps=reps, quantum_instance=backend)
qaoa = MinimumEigenOptimizer(qaoaInit)
qaoaResult = qaoa.solve(qubo)
if backend.name() == 'qasm_simulator':
counts = qaoaResult.min_eigen_solver_result.eigenstate
elif backend.name() == 'statevector_simulator':
counts = getCountDictStateVecSim(qaoaResult)
#endif
qaoaResult
qaoaFig = plot_histogram(counts,figsize=(60,10))
qaoaFig.savefig("figures/QAOA-"+startStr+"-"+endStr+".pdf")
qaoaFig
qaoaRiskInit = QAOA(optimizer=optimizer, reps=reps, quantum_instance=backend)
qaoaRisk = MinimumEigenOptimizer(qaoaRiskInit)
qaoaRiskResult = qaoaRisk.solve(quboRisk)
if backend.name() == 'qasm_simulator':
countsRisk = qaoaRiskResult.min_eigen_solver_result.eigenstate
elif backend.name() == 'statevector_simulator':
countsRisk = getCountDictStateVecSim(qaoaRiskResult)
#endif
qaoaRiskResult
qaoaRiskFig = plot_histogram(countsRisk,figsize=(60,10))
qaoaRiskFig.savefig("figures/QAOARisk-"+startStr+"-"+endStr+".pdf")
qaoaRiskFig
classicalResult
vqeResult
qaoaResult
classicalResultRisk
vqeRiskResult
qaoaRiskResult
def getCombinations(inputVal):
combinations = []
if type(inputVal) == str:
for perm in set(permutations(inputVal)):
combinations.append(''.join(perm))
#endFor
elif type(inputVal) == list:
for i in range(len(inputVal)):
inputVal[i] = int(inputVal[i])
#endFor
for perm in set(permutations(inputVal)):
combinations.append(list(perm))
#endFor
else:
print("Input a string or list of ones and zeroes")
return combinations
def countNonZeroElemInList(inputList):
numNonZeroElem = 0.
for x in inputList:
if x != 0:
numNonZeroElem += 1
else:
numNonZeroElem += 0
#endIf
#endFor
return numNonZeroElem
def assetTotalPortfolioGrowth(initialPortfolioValue,selectedAssets,testDF):
amountSplit = initialPortfolioValue/countNonZeroElemInList(selectedAssets)
assetGrowth = []
for i in range(len(selectedAssets)):
if selectedAssets[i] == 1:
tempDF = testDF.iloc[:,i]
amountTemp = amountSplit
for pctChg in tempDF:
amountTemp += pctChg*amountTemp
assetGrowth.append(amountTemp)
else:
assetGrowth.append(0.)
#endIf
#endFor
return assetGrowth
def assetGrowthTimeSeries(initialPortfolioValue,selectedAssets,testDF):
amountSplit = initialPortfolioValue/countNonZeroElemInList(selectedAssets)
assetGrowthTS = []
for i in range(len(selectedAssets)):
if selectedAssets[i] == 1:
tempVec = []
tempDF = testDF.iloc[:,i]
amountTemp = amountSplit
for pctChg in tempDF:
amountTemp += pctChg*amountTemp
tempVec.append(amountTemp)
assetGrowthTS.append(tempVec)
else:
tempVec = []
tempDF = testDF.iloc[:,i]
for pctChg in tempDF:
tempVec.append(0.0)
assetGrowthTS.append(tempVec)
#endIf
#endFor
return assetGrowthTS
def assetGrowthTimeSeriesWeighted(initialPortfolioValue,selectedAssets,testDF,weights):
assetGrowthTS = []
for i in range(len(selectedAssets)):
if selectedAssets[i] == 1:
tempVec = []
tempDF = testDF.iloc[:,i]
amountTemp = initialPortfolioValue*weights[i]
for pctChg in tempDF:
amountTemp += pctChg*amountTemp
tempVec.append(amountTemp)
assetGrowthTS.append(tempVec)
else:
tempVec = []
tempDF = testDF.iloc[:,i]
for pctChg in tempDF:
tempVec.append(0.0)
assetGrowthTS.append(tempVec)
#endIf
#endFor
return assetGrowthTS
def portfolioGrowthTimeSeries(portfolioTS):
portfolioValueTS = []
for i in range(len(portfolioTS[0])):
tempVal = 0.0
for j in range(len(portfolioTS)):
tempVal += portfolioTS[j][i]
portfolioValueTS.append(tempVal)
return portfolioValueTS
assetTest = qaoaRiskResult.x.tolist()
amountInit = 1000
allAssetCombinations = getCombinations(assetTest)
dateList = dfMonthlyReturns.index
# # Gives total number of chosen assets, AKA budget. More of a sanity check.
# numAssetsChosen = countNonZeroElemInList(assetTest)
# # Gives each selected asset's total final value in a list
# finalAssetValues = assetTotalPortfolioGrowth(amountInit,assetTest,dfMonthlyReturns)
# # Gives the time series of each portfolio element as a list of lists. In each list,
# # the final element is the final value of the held asset.
# chosenAssetsTimeSeries = assetGrowthTimeSeries(amountInit,assetTest,dfMonthlyReturns)
# # Gives the time series for the total portfolio value. The final element is the final portfolio value.
# portfolioTimeSeries = portfolioGrowthTimeSeries(chosenAssetsTimeSeries)
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
for i in range(len(allAssetCombinations)):
chosenAssetsTimeSeries = assetGrowthTimeSeries(amountInit,allAssetCombinations[i],dfMonthlyReturns)
portfolioTimeSeries = portfolioGrowthTimeSeries(chosenAssetsTimeSeries)
label = ''
for element in allAssetCombinations[i]:
label+=str(element)
#endFor
ax.plot(dateList,portfolioTimeSeries,color='blue',linestyle='--',alpha=0.1,linewidth=0.5)
#endFor
winningAssetCombination = assetTest
winningAssetTimeSeries = assetGrowthTimeSeries(amountInit,winningAssetCombination,dfMonthlyReturns)
winningPortfolioTimeSeries = portfolioGrowthTimeSeries(winningAssetTimeSeries)
label = ''
for element in winningAssetCombination:
label+=str(element)
#endFor
ax.plot(dateList,winningPortfolioTimeSeries,label=label,color='red',alpha=1,linewidth=2)
plt.xlim(startDate,endDate)
plt.ylabel('Total Portfolio Value')
plt.xlabel('Date')
plt.legend()#bbox_to_anchor=(1.02, 1), loc='upper left', borderaxespad=0)
plt.show()
fig.savefig('figures/portfolio-'+label+'risk-'+str(q)+'-'+startStr+"-"+endStr+'.pdf',bbox_inches='tight')
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
for i in range(len(allAssetCombinations)):
chosenAssetsTimeSeries = assetGrowthTimeSeries(amountInit,allAssetCombinations[i],dfMonthlyReturns)
portfolioTimeSeries = portfolioGrowthTimeSeries(chosenAssetsTimeSeries)
label = ''
for element in allAssetCombinations[i]:
label+=str(element)
#endFor
ax.plot(dateList,portfolioTimeSeries,color='blue',linestyle='--',alpha=0.1,linewidth=0.5)
#endFor
winningAssetCombination = assetTest
winningAssetTimeSeries = assetGrowthTimeSeries(amountInit,winningAssetCombination,dfMonthlyReturns)
winningPortfolioTimeSeries = portfolioGrowthTimeSeries(winningAssetTimeSeries)
label = ''
for element in winningAssetCombination:
label+=str(element)
#endFor
label += ' equally weighted'
ax.plot(dateList,winningPortfolioTimeSeries,label=label,color='red',alpha=1,linewidth=2)
portfolioWeights = [0.223214286,0.233800935,0.2042007,0.0,0.0,0.0,0.172583826,0.165250236]
weightedWinningAssetTimeSeries = assetGrowthTimeSeriesWeighted(amountInit,assetTest,dfMonthlyReturns,portfolioWeights)
weightedWinningPortfolioTimeSeries = portfolioGrowthTimeSeries(weightedWinningAssetTimeSeries)
label = ''
for element in winningAssetCombination:
label+=str(element)
#endFor
label += ' risk-parity weighted'
ax.plot(dateList,weightedWinningPortfolioTimeSeries,label=label,color='purple',alpha=1,linewidth=2)
plt.xlim(startDate,endDate)
plt.ylabel('Total Portfolio Value')
plt.xlabel('Date')
plt.legend()#bbox_to_anchor=(1.02, 1), loc='upper left', borderaxespad=0)
plt.show()
fig.savefig('figures/weighted-comparison-portfolio-'+label+'risk-'+str(q)+'-'+startStr+"-"+endStr+'.pdf',bbox_inches='tight')
from qiskit import QuantumCircuit, assemble, Aer
from math import pi, sqrt
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_bloch_vector
sim = Aer.get_backend('aer_simulator')
qc = QuantumCircuit(1)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
plot_bloch_multivector(state)
qc = QuantumCircuit(1)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
fig=plot_bloch_multivector(state)
fig.savefig('figures/bloch-no-rotate.pdf', bbox_inches='tight')
qc = QuantumCircuit(1)
qc.rx(theta=pi/2,qubit=0)
qc.draw()
qc.save_statevector()
qobj = assemble(qc)
state = sim.run(qobj).result().get_statevector()
fig=plot_bloch_multivector(state)
fig.savefig('figures/bloch-pi-over-two-x-rotate.pdf', bbox_inches='tight')
|
https://github.com/DarrenNA/Bernstein-Vazirani_Algorithm_function
|
DarrenNA
|
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/Wasiq-Malik/MaxCut-QAOA
|
Wasiq-Malik
|
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
import random
from scipy.optimize import minimize
try:
import cirq
except ImportError:
print("installing cirq...")
!pip install --quiet cirq
import cirq
print("installed cirq.")
# Utility function to print a graph
def draw_graph(G, colors, pos):
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, 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)
n=5 # Number of nodes in graph
# create a graph of n nodes
G=nx.Graph()
G.add_nodes_from(np.arange(0,n,1))
# edge are in the form (vertex u, vertex v, edge weight)
edges=[(0,1,1.0),(0,2,5.0),(1,2,7.0),(1,3,2.0),(2,3,4.0), (3,4,3.0)]
G.add_weighted_edges_from(edges) # create weighted edges in the graph
# setup an example graph
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
draw_graph(G, colors, pos)
# Computing the weight matrix for the example graph
weight_matrix = np.zeros([n,n])
for i in range(n):
for j in range(n):
edge = G.get_edge_data(i,j,default=0)
if edge != 0:
weight_matrix[i,j] = edge['weight']
# running the brute force algorithm to find the max cut for the example graph
best_cost_brute = best_sol_brute = 0
for bit_string in range(2**n):
solution = [int(t) for t in reversed(list(bin(bit_string)[2:].zfill(n)))] # generate bit strings representing the possible cuts
cost = 0
# calculate the cut value for current cut set
for i in range(n):
for j in range(n):
cost = cost + weight_matrix[i,j]*solution[i]*(1-solution[j])
# if better solution found, save it
if best_cost_brute < cost:
best_cost_brute = cost
best_sol_brute = solution
print('bit string = ' + str(solution) + ' cut value = ' + str(cost))
# display the max cut solution
colors = ['r' if best_sol_brute[i] == 0 else 'c' for i in range(n)]
draw_graph(G, colors, pos)
print('\nBest solution = ' + str(best_sol_brute) + ' cost = ' + str(best_cost_brute))
n=5 # Number of nodes in graph
qubits = [cirq.GridQubit(0, i) for i in range(0, n)]
G=nx.Graph()
G.add_nodes_from(qubits)
edges=[(qubits[0],qubits[1],1.0),(qubits[0],qubits[2],5.0),(qubits[1],qubits[2],7.0),(qubits[1],qubits[3],2.0),(qubits[2],qubits[3],4.0), (qubits[3],qubits[4],3.0)]
G.add_weighted_edges_from(edges)
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
draw_graph(G, colors, pos)
from cirq.contrib.svg import SVGCircuit
import sympy
# Depth for the QAOA
m=2
# Number of qubits
n=5
# repitions count for running the circuit
rep=10_000
def create_circuit(params):
m = len(params)//2
alphas = params[0:m]
betas = params[m::]
# Prepare equal superposition of qubits
qaoa_circuit = cirq.Circuit(cirq.H.on_each(G.nodes()))
# iterate over depth factor for qaoa
for i in range(m):
# insert the cost unitary
for u, v, w in G.edges(data=True):
qaoa_circuit.append(cirq.ZZ(u, v) ** (alphas[i] * w['weight']))
# insert the mixer unitary
qaoa_circuit.append(cirq.Moment(cirq.X(qubit) ** betas[i] for qubit in G.nodes()))
# apply measurements at the end of the circuit
for qubit in G.nodes():
qaoa_circuit.append(cirq.measure(qubit))
return qaoa_circuit
# create a circuit with random parameters
qaoa_circuit = create_circuit(params=[float(random.randint(-314, 314))/float(100) for i in range(0, m*2)])
# display the qaoa circuit
SVGCircuit(qaoa_circuit)
from cirq.contrib.svg import SVGCircuit
import sympy
# Symbols for the rotation angles in the QAOA circuit.
alpha = sympy.Symbol('alpha')
beta = sympy.Symbol('beta')
qaoa_circuit = cirq.Circuit(
# Prepare equal superposition of qubits
cirq.H.on_each(G.nodes()),
# Do ZZ operations between neighbors u, v in the graph. Here, u is a qubit,
# v is its neighboring qubit, and w is the weight between these qubits.
(cirq.ZZ(u, v) ** (alpha * w['weight']) for (u, v, w) in G.edges(data=True)),
# Apply X operations along all nodes of the graph. Again working_graph's
# nodes are the working_qubits. Note here we use a moment
# which will force all of the gates into the same line.
cirq.Moment(cirq.X(qubit) ** beta for qubit in G.nodes()),
# All relevant things can be computed in the computational basis.
(cirq.measure(qubit) for qubit in G.nodes()),
)
SVGCircuit(qaoa_circuit)
def estimate_cost(graph, samples):
"""Estimate the cost function of the QAOA on the given graph using the
provided computational basis bitstrings."""
cost_value = 0.0
# Loop over edge pairs and compute contribution.
for u, v, w in graph.edges(data=True):
u_samples = samples[str(u)]
v_samples = samples[str(v)]
# Determine if it was a +1 or -1 eigenvalue.
u_signs = (-1)**u_samples
v_signs = (-1)**v_samples
term_signs = u_signs * v_signs
# Add scaled term to total cost.
term_val = np.mean(term_signs) * w['weight']
cost_value += term_val
return -cost_value
alpha_value = np.pi / 4
beta_value = np.pi / 2
sim = cirq.Simulator()
sample_results = sim.sample(
qaoa_circuit,
params={alpha: alpha_value, beta: beta_value},
repetitions=20_000
)
print(f'Alpha = {round(alpha_value, 3)} Beta = {round(beta_value, 3)}')
print(f'Estimated cost: {estimate_cost(G, sample_results)}')
# Set the grid size = number of points in the interval [0, 2π).
grid_size = 5
exp_values = np.empty((grid_size, grid_size))
par_values = np.empty((grid_size, grid_size, 2))
for i, alpha_value in enumerate(np.linspace(0, 2 * np.pi, grid_size)):
for j, beta_value in enumerate(np.linspace(0, 2 * np.pi, grid_size)):
samples = sim.sample(
qaoa_circuit,
params={alpha: alpha_value, beta: beta_value},
repetitions=20000
)
exp_values[i][j] = estimate_cost(G, samples)
par_values[i][j] = alpha_value, beta_value
def output_cut(S_partition):
"""Plot and output the graph cut information."""
# Generate the colors.
coloring = []
for node in G:
if node in S_partition:
coloring.append('blue')
else:
coloring.append('red')
# Get the weights
edges = G.edges(data=True)
weights = [w['weight'] for (u,v, w) in edges]
nx.draw_circular(
G,
node_color=coloring,
node_size=1000,
with_labels=True,
width=weights)
plt.show()
size = nx.cut_size(G, S_partition, weight='weight')
print(f'Cut size: {size}')
best_exp_index = np.unravel_index(np.argmax(exp_values), exp_values.shape)
best_parameters = par_values[best_exp_index]
print(f'Best control parameters: {best_parameters}')
# Number of candidate cuts to sample.
num_cuts = 100
candidate_cuts = sim.sample(
qaoa_circuit,
params={alpha: best_parameters[0], beta: best_parameters[1]},
repetitions=num_cuts
)
# Variables to store best cut partitions and cut size.
best_qaoa_S_partition = set()
best_qaoa_T_partition = set()
best_qaoa_cut_size = -np.inf
# Analyze each candidate cut.
for i in range(num_cuts):
candidate = candidate_cuts.iloc[i]
one_qubits = set(candidate[candidate==1].index)
S_partition = set()
T_partition = set()
for node in G:
if str(node) in one_qubits:
# If a one was measured add node to S partition.
S_partition.add(node)
else:
# Otherwise a zero was measured so add to T partition.
T_partition.add(node)
cut_size = nx.cut_size(
G, S_partition, T_partition, weight='weight')
# If you found a better cut update best_qaoa_cut variables.
if cut_size > best_qaoa_cut_size:
best_qaoa_cut_size = cut_size
best_qaoa_S_partition = S_partition
best_qaoa_T_partition = T_partition
best_random_S_partition = set()
best_random_T_partition = set()
best_random_cut_size = -9999
# Randomly build candidate sets.
for i in range(num_cuts):
S_partition = set()
T_partition = set()
for node in G:
if random.random() > 0.5:
# If we flip heads add to S.
S_partition.add(node)
else:
# Otherwise add to T.
T_partition.add(node)
cut_size = nx.cut_size(
G, S_partition, T_partition, weight='weight')
# If you found a better cut update best_random_cut variables.
if cut_size > best_random_cut_size:
best_random_cut_size = cut_size
best_random_S_partition = S_partition
best_random_T_partition = T_partition
print('-----QAOA-----')
output_cut(best_qaoa_S_partition)
print('\n\n-----RANDOM-----')
output_cut(best_random_S_partition)
|
https://github.com/Javihaus/Quantum-Machinel-Leaning
|
Javihaus
|
# MatplotlibDrawer needs pylatexenc. You need to install it:
#pip install pylatexenc
import numpy as np
import seaborn as sns
from qiskit import *
from qiskit.tools.jupyter import *
import matplotlib.pyplot as plt
import pylatexenc
from scipy.optimize import minimize
from sklearn.preprocessing import Normalizer, normalize, binarize, Binarizer
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, MinMaxScaler
from sklearn.decomposition import PCA, KernelPCA, LatentDirichletAllocation
import pandas as pd
import gc as gc
backend = BasicAer.get_backend('qasm_simulator') # for using a quantum simulator
#Using other quantum processors from IBM
#from qiskit import IBMQ
#IBMQ.save_account('c42be77bc7bcc969263dd866c03b2a05fefd1d203ae6aedc6765543cae8ac3d862c8fcdff5aca2f486c0ba36f764393e76718d54bc679c1aeeec78ff32bab7dd')
#provider = IBMQ.load_account()
# You can check in IBM site the cues in different backend processors.
# You can choose processors with lower cues to speed up your work.
#backend = provider.backends.ibmq_london
#from qiskit.tools.monitor import job_monitor
#shots = 1024
#max_credits = 3
#job_exp = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
#job_monitor(job_exp)
gc.collect()
data = pd.read_csv("General.csv")
data = data.drop(columns=['Unnamed: 0',
'reconocimiento medico', 'seguro medico', 'revision medica',
'cobertura medica' , 'fecha', 'BlobText_seguro'])
# Removing outliers for a better accuracy. As alterntive you can apply a
# RobustScaler algortihm.
Q1 = data.quantile(0.1)
Q3 = data.quantile(0.9)
IQR = Q3 - Q1
data = data[~((data < (Q1 - 1.5 * IQR)) |(data > (Q3 + 1.5 * IQR))).any(axis=1)]
# Using Random Forest to gain insights on Feature Importance
data['Vader_gimnasio'] =(data['Vader_gimnasio'] > -0.050).astype(int)
from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
clf = RandomForestClassifier()
clf.fit(data.drop(columns='Vader_gimnasio'),data.Vader_gimnasio)
plt.style.use('seaborn-whitegrid')
importance = clf.feature_importances_
importance = pd.DataFrame(importance, index=data.drop(columns='Vader_gimnasio').columns, columns=["Importance"])
importance.sort_values(by='Importance', ascending=True).plot(kind='barh', figsize=(20,len(importance)/2));
importance.sort_values(by='Importance', ascending=False) > 0.07
class_labels = ['Interés bajo', 'Interés alto']
# We choose only the relevant features and remove the rest
X = data.drop(columns=['Vader_gimnasio', 'salud', 'Vader_trabajo', 'Vader_salbe', 'Vader_salbien',
'Afiliacion', 'consumo electrico', 'ICC', 'Tendencia prevista ICC', 'Vader_seguro',
'Situación económica de los hogares', 'DG ECFIN Business and Consumer Survey', 'Vader_recon1'])
Y = data.Vader_gimnasio
Y = np.array(Y)
#scale value from 0 to 1 (so we remove negative values)
scaler = MinMaxScaler().fit(X)
X = scaler.transform(X)
n_dim = 2
# I use linear Kernel PCA to reduce the number of dimensions of the dataset to n_dim = 2
pca = KernelPCA(n_components=n_dim).fit(X)
X = pca.transform(X)
scaler = MinMaxScaler().fit(X)
X = scaler.transform(X)
def get_angles(x):
beta0 = 2 * np.arcsin(np.sqrt(x[1]) ** 2 / np.sqrt(x[0] ** 2 + x[1] ** 2 + 1e-12))
beta1 = 2 * np.arcsin(np.sqrt(x[3]) ** 2 / np.sqrt(x[2] ** 2 + x[3] ** 2 + 1e-12))
beta2 = 2 * np.arcsin(
np.sqrt(x[2] ** 2 + x[3] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2)
)
return np.array([beta2, -beta1 / 2, beta1 / 2, -beta0 / 2, beta0 / 2])
print("First X sample (original) :", X[0])
# pad the vectors to size 2^2 with constant values
padding = 0.3 * np.ones((len(X), 1))
X_pad = np.c_[np.c_[X, padding], np.zeros((len(X), 1))]
print("First X sample (padded) :", X_pad[0])
# normalize each input
normalization = np.sqrt(np.sum(X_pad ** 2, -1))
X_norm = (X_pad.T / normalization).T
print("First X sample (normalized):", X_norm[0])
# angles for state preparation are new features
features = np.array([get_angles(x) for x in X_norm])
print("First features sample :", features[0])
def statepreparation(a, circuit, target):
a = 2*a
circuit.ry(a[0], target[0])
circuit.cx(target[0], target[1])
circuit.ry(a[1], target[1])
circuit.cx(target[0], target[1])
circuit.ry(a[2], target[1])
circuit.x(target[0])
circuit.cx(target[0], target[1])
circuit.ry(a[3], target[1])
circuit.cx(target[0], target[1])
circuit.ry(a[4], target[1])
circuit.x(target[0])
return circuit
x = X_norm[0]
ang = get_angles(x)
q = QuantumRegister(2)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit = statepreparation(ang, circuit, [0,1])
circuit.draw(output='mpl')
def u_gate(param, circuit, target):
'''Return the quantum circuit with u3 gate applied on qubit target with param as an iterable'''
circuit.u3(param[0],param[1],param[2],target)
return circuit
def cu_gate(param, circuit, control, target):
'''Return the quantum circuit with cu3 gate applied on qubit target with param as an iterable wrt control'''
circuit.cu3(param[0],param[1],param[2], control, target)
return circuit
def circuit_block(param, circuit, target, same_order_x=True):
'''Return the block applied on qubits target from the circuit circuit
- param : array parameters for the two u gate
- target : array of integer the numero of qubits for the u gates to be applied
- if same_order_x == True : cx(target[0], target[1])
else: cx(target[1], target[0])'''
circuit = u_gate(param[0], circuit, target[0])
circuit = u_gate(param[1], circuit, target[1])
if same_order_x:
circuit.cx(target[0], target[1])
else:
circuit.cx(target[1], target[0])
return circuit
def c_circuit_block(param, circuit, control, target, same_order_x=True):
'''Return the controlled block applied on qubits target from the circuit circuit
- param : array parameters for the two u gate
- target : array of integer the numero of qubits for the u gates to be applied
- if same_order_x == True : cx(target[0], target[1])
else: cx(target[1], target[0])'''
circuit = cu_gate(param[0], circuit, control, target[0])
circuit = cu_gate(param[1], circuit, control, target[1])
if same_order_x:
circuit.ccx(control, target[0], target[1])
else:
circuit.ccx(control, target[1], target[0])
return circuit
def create_circuit(param, circuit, target):
order = True
for i in range(param.shape[0]):
circuit = circuit_block(param[i], circuit, target, order)
order = not order
return circuit
def create_c_circuit(param, circuit, control, target):
order = True
for i in range(param.shape[0]):
circuit = c_circuit_block(param[i], circuit, control, target, order)
order = not order
return circuit
x = np.array([0.53896774, 0.79503606, 0.27826503, 0.0])
ang = get_angles(x)
params = np.array([[[np.pi/3,np.pi/3,np.pi/4],
[np.pi/6,np.pi/4,np.pi/6]],
[[np.pi/6,np.pi/4,np.pi/4],
[np.pi/3,np.pi/7,np.pi/6]],
[[np.pi/3,np.pi/3,np.pi/4],
[np.pi/6,np.pi/4,np.pi/6]],
[[np.pi/6,np.pi/4,np.pi/4],
[np.pi/3,np.pi/7,np.pi/6]]])
q = QuantumRegister(2)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit = statepreparation(ang, circuit, [0,1])
circuit = create_circuit(params, circuit, [0,1])
circuit.measure(0,c)
circuit.draw(output='mpl')
def execute_circuit(params, angles=None, x=None, use_angles=True, bias=0, shots=1000):
if not use_angles:
angles = get_angles(x)
q = QuantumRegister(2)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit = statepreparation(angles, circuit, [0,1])
circuit = create_circuit(params, circuit, [0,1])
circuit.measure(0,c)
result = execute(circuit,backend,shots=shots).result()
counts = result.get_counts(circuit)
result=np.zeros(2)
for key in counts:
result[int(key,2)]=counts[key]
result/=shots
return result[1] + bias
execute_circuit(params, ang, bias=0.02)
def predict(probas):
return (probas>=0.5)*1
def binary_crossentropy(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
loss = loss - l * np.log(np.max([p,1e-8]))
loss = loss / len(labels)
return loss
def square_loss(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
loss = loss + (l - p) ** 2
loss = loss / len(labels)
return loss
def cost(params, features, labels):
predictions = [execute_circuit(params, angles=f) for f in features]
return binary_crossentropy(labels, predictions)
def accuracy(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
if abs(l - p) < 1e-5:
loss = loss + 1
loss = loss / len(labels)
return loss
def real(param1, param2, angles, shots=1000):
"""Returns Re{<circuit(param2)|sigma_z|circuit(param1)>}"""
q = QuantumRegister(3)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit.h(q[0])
circuit = statepreparation(angles, circuit, [1,2])
circuit = create_c_circuit(param1, circuit, 0, [1,2])
circuit.cz(q[0], q[1])
circuit.x(q[0])
circuit = create_c_circuit(param2, circuit, 0, [1,2])
circuit.x(q[0])
circuit.h(q[0])
circuit.measure(q[0],c)
result = execute(circuit,backend,shots=shots).result()
counts = result.get_counts(circuit)
result=np.zeros(2)
for key in counts:
result[int(key,2)]=counts[key]
result/=shots
return (2*result[0]-1)
def imaginary(param1, param2, angles, shots=1000):
"""Returns Im{<circuit(param2)|sigma_z|circuit(param1)>}"""
q = QuantumRegister(3)
c = ClassicalRegister(1)
circuit = QuantumCircuit(q,c)
circuit.h(q[0])
circuit = statepreparation(angles, circuit, [1,2])
circuit = create_c_circuit(param1, circuit, 0, [1,2])
circuit.cz(q[0], q[1])
circuit.x(q[0])
circuit = create_c_circuit(param2, circuit, 0, [1,2])
circuit.x(q[0])
circuit.u1(np.pi/2, q[0])
circuit.h(q[0])
circuit.measure(q[0],c)
result = execute(circuit,backend,shots=shots).result()
counts = result.get_counts(circuit)
result=np.zeros(2)
for key in counts:
result[int(key,2)]=counts[key]
result/=shots
return -(2*result[0]-1)
def gradients(params, angles, label, bias=0):
grads = np.zeros_like(params)
imag = imaginary(params, params, angles)
for i in range(params.shape[0]):
for j in range(params.shape[1]):
params_bis = np.copy(params)
params_bis[i,j,0]+=np.pi
grads[i,j,0] = -0.5 * real(params, params_bis, angles)
params_bis[i,j,0]-=np.pi
params_bis[i,j,1]+=np.pi
grads[i,j,1] = 0.5 * (imaginary(params, params_bis, angles) - imag)
params_bis[i,j,1]-=np.pi
params_bis[i,j,2]+=np.pi
grads[i,j,2] = 0.5 * (imaginary(params, params_bis, angles) - imag)
params_bis[i,j,2]-=np.pi
p = execute_circuit(params, angles, bias=bias)
grad_bias = (p - label) / (p * (1 - p))
grads *= grad_bias
return grads, grad_bias
np.random.seed(0)
num_data = len(Y)
num_train = int(0.75 * num_data)
index = np.random.permutation(range(num_data))
feats_train = features[index[:num_train]]
Y_train = Y[index[:num_train]]
feats_val = features[index[num_train:]]
Y_val = Y[index[num_train:]]
# We need these later for plotting
X_train = X[index[:num_train]]
X_val = X[index[num_train:]]
layers = 6
params_init = np.random.randn(layers,2,3) * 0.01
bias_init = 0.01
batch_size = 5
learning_rate = 0.01
momentum = 0.9
var = np.copy(params_init)
bias = bias_init
v = np.zeros_like(var)
v_bias = 0
for it in range(15):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, num_train, (batch_size,))
feats_train_batch = feats_train[batch_index]
Y_train_batch = Y_train[batch_index]
grads = np.zeros_like(var)
grad_bias = 0
var_corrected = var + momentum * v
bias_corrected = bias + momentum * v_bias
for j in range(batch_size):
g, g_bias = gradients(var_corrected, feats_train_batch[j], Y_train_batch[j], bias)
grads += g / batch_size
grad_bias +=g_bias / batch_size
v = momentum * v - learning_rate * grads
v_bias = momentum * v_bias - learning_rate * grad_bias
var += v
bias += v_bias
# Compute predictions on train and validation set
probas_train = np.array([execute_circuit(var, angles=f, bias=bias) for f in feats_train])
probas_val = np.array([execute_circuit(var, angles=f, bias=bias) for f in feats_val])
predictions_train = predict(probas_train)
predictions_val = predict(probas_val)
# Compute accuracy on train and validation set
acc_train = accuracy(Y_train, predictions_train)
acc_val = accuracy(Y_val, predictions_val)
print(
"Iter: {:5d} | Loss: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} "
"".format(it + 1, cost(var, features, Y), acc_train, acc_val)
)
gc.collect()
plt.figure(figsize=(16,8))
cm = plt.cm.RdBu
# make data for decision regions
xx, yy = np.meshgrid(np.linspace(0.0, 1, 20), np.linspace(0.0, 1, 20))
X_grid = [np.array([x, y]) for x, y in zip(xx.flatten(), yy.flatten())]
# preprocess grid points like data inputs above
padding = 0.3 * np.ones((len(X_grid), 1))
X_grid = np.c_[np.c_[X_grid, padding], np.zeros((len(X_grid), 1))] # pad each input
normalization = np.sqrt(np.sum(X_grid ** 2, -1))
X_grid = (X_grid.T / normalization).T # normalize each input
features_grid = np.array(
[get_angles(x) for x in X_grid]
)
# angles for state preparation are new features
predictions_grid = [execute_circuit(var, angles=f, bias=bias, shots=10000) for f in features_grid]
Z = np.reshape(predictions_grid, xx.shape)
# plot decision regions
cnt = plt.contourf(xx, yy, Z, levels=np.arange(0, 1.1, 0.1), cmap=cm, alpha=0.8, extend="both")
plt.contour(xx, yy, Z, levels=[0.0], colors=("black",), linestyles=("--",), linewidths=(0.8,))
plt.colorbar(cnt, ticks=[0, 0, 1])
# plot data
ce = cost(var, features, Y)
plt.title("$p$, probability the model guesses for the correct class = {:0.7f}"
"".format(np.e**(-ce)))
plt.scatter(
X_val[:, 0][Y_val == 1],
X_val[:, 1][Y_val == 1],
c="b",
marker="o",
edgecolors="k",
label="Interés por el gimnasio alto",
)
plt.scatter(
X_train[:, 0][Y_train == 1],
X_train[:, 1][Y_train == 1],
c="b",
marker="o",
edgecolors="k",
alpha=0.5,
label="Interés por el gimnasio alto - train",
)
plt.scatter(
X_val[:, 0][Y_val == 0],
X_val[:, 1][Y_val == 0],
c="r",
marker="o",
edgecolors="k",
label="Interés por el gimansio bajo ",
)
plt.scatter(
X_train[:, 0][Y_train == 0],
X_train[:, 1][Y_train == 0],
c="r",
marker="o",
edgecolors="k",
alpha=0.5,
label="Interés por el gimnasio bajo -train",
)
plt.xlabel('Component 1')
plt.ylabel('Component 2')
plt.ylim(0,1)
plt.xlim(0,1)
plt.legend()
plt.savefig('/Users/javiermarin/desktop/Grafica4-o.png')
plt.show()
plt.figure(figsize=(16,6))
# Binnary cross-entropy loss
def cross_entropy(p):
return -np.log(p)
ps = np.linspace(0.005, 1, 100)
ces = [cross_entropy(p) for p in ps]
ce = cost(var, features, Y)
plt.plot(ps, ces, lw=3)
plt.title("$H$, Cross Entropy Loss = {:0.7f}"
"".format(ce))
plt.suptitle("$p$, Probability = {:0.7f}"
"".format(np.e**(-ce)))
plt.ylabel('$H$, Cross-Entropy Loss - binary')
plt.xlabel('$p$, probability the model guesses for the correct class')
plt.hlines((cost(var, features, Y)), 0, 1, colors='red', lw=2, linestyles='dotted')
plt.vlines(np.e**(-ce), 0, 5, colors='red', lw=2, linestyles='dotted')
plt.xlim(0,1)
plt.ylim(0,5)
plt.show()
|
https://github.com/Javihaus/Quantum-Machinel-Leaning
|
Javihaus
|
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram
from qiskit_textbook.widgets import binary_widget
binary_widget(nbits=5)
n = 8
n_q = n
n_b = n
qc_output = QuantumCircuit(n_q,n_b)
for j in range(n):
qc_output.measure(j,j)
qc_output.draw(output='mpl')
counts = execute(qc_output,Aer.get_backend('qasm_simulator')).result().get_counts()
plot_histogram(counts)
qc_encode = QuantumCircuit(n)
qc_encode.x(7)
qc_encode.draw(output='mpl')
qc = qc_encode + qc_output
qc.draw(output='mpl',justify='none')
counts = execute(qc,Aer.get_backend('qasm_simulator')).result().get_counts()
plot_histogram(counts)
qc_encode = QuantumCircuit(n)
qc_encode.x(1)
qc_encode.x(5)
qc_encode.draw(output='mpl')
qc_cnot = QuantumCircuit(2)
qc_cnot.cx(0,1)
qc_cnot.draw(output='mpl')
qc = QuantumCircuit(2,2)
qc.x(0)
qc.cx(0,1)
qc.measure(0,0)
qc.measure(1,1)
qc.draw(output='mpl')
qc_ha = QuantumCircuit(4,2)
# encode inputs in qubits 0 and 1
qc_ha.x(0) # For a=0, remove this line. For a=1, leave it.
qc_ha.x(1) # For b=0, remove this line. For b=1, leave it.
qc_ha.barrier()
# use cnots to write the XOR of the inputs on qubit 2
qc_ha.cx(0,2)
qc_ha.cx(1,2)
qc_ha.barrier()
# extract outputs
qc_ha.measure(2,0) # extract XOR value
qc_ha.measure(3,1)
qc_ha.draw(output='mpl')
qc_ha = QuantumCircuit(4,2)
# encode inputs in qubits 0 and 1
qc_ha.x(0) # For a=0, remove the this line. For a=1, leave it.
qc_ha.x(1) # For b=0, remove the this line. For b=1, leave it.
qc_ha.barrier()
# use cnots to write the XOR of the inputs on qubit 2
qc_ha.cx(0,2)
qc_ha.cx(1,2)
# use ccx to write the AND of the inputs on qubit 3
qc_ha.ccx(0,1,3)
qc_ha.barrier()
# extract outputs
qc_ha.measure(2,0) # extract XOR value
qc_ha.measure(3,1) # extract AND value
qc_ha.draw(outpu='mpl')
counts = execute(qc_ha,Aer.get_backend('qasm_simulator')).result().get_counts()
plot_histogram(counts)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/JayantiSingh/Quant_co_Qiskit
|
JayantiSingh
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
#NOT gate = X gate
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.x(q[0])
qc.measure(q[0], c[0])
qc.draw(output='mpl')
# AND gate = output t of CCX gate
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.ccx(q[0], q[1], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
# NAND gate= AND+NOT= CCX+X gate
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.ccx(q[0], q[1], q[2])
qc.x(q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
# OR gate= cx+cx+CCX gate
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.ccx(q[0], q[1], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
# XOR gate = cx+cx
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
# NOR gate= cx+cx+CCX+X
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.ccx(q[0], q[1], q[2])
qc.x(q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
|
https://github.com/JayantiSingh/Quant_co_Qiskit
|
JayantiSingh
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
q = QuantumRegister(6)
c = ClassicalRegister(2)
qc = QuantumCircuit(q,c)
#half adder
qc.ccx(q[1],q[2],q[4])
qc.cx(q[1],q[2])
qc.barrier(q)
#half adder
qc.ccx(q[0],q[2],q[3])
qc.cx(q[0],q[2])
qc.barrier(q)
#or
qc.cx(q[4], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[3], q[4], q[5])
qc.barrier(q)
#measure
qc.measure(q[2], c[0])
qc.measure(q[5], c[1])
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
qc.count_ops()
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
#now let's check the quantum cost of this circuit by using the Unroller.
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
new_circuit.draw(output='mpl')
new_circuit.count_ops()
q = QuantumRegister(6)
c = ClassicalRegister(2)
qc = QuantumCircuit(q,c)
#prepare inputs for testing
inputdata = [0,0,0]
if inputdata[0] == 0:
print('0')
else:
qc.x(q[0])
print('1')
if inputdata[1] == 0:
print('0')
else:
qc.x(q[1])
print('1')
if inputdata[2] == 0:
print('0')
else:
qc.x(q[2])
print('1')
#half adder
qc.ccx(q[1],q[2],q[4])
qc.cx(q[1],q[2])
qc.barrier(q)
#half adder
qc.ccx(q[0],q[2],q[3])
qc.cx(q[0],q[2])
qc.barrier(q)
#or
qc.cx(q[4], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[3], q[4], q[5])
qc.barrier(q)
#measure
qc.measure(q[2], c[0])
qc.measure(q[5], c[1])
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
q = QuantumRegister(6)
c = ClassicalRegister(2)
qc = QuantumCircuit(q,c)
#prepare inputs for testing
inputdata = [1,1,1]
if inputdata[0] == 0:
print('0')
else:
qc.x(q[0])
print('1')
if inputdata[1] == 0:
print('0')
else:
qc.x(q[1])
print('1')
if inputdata[2] == 0:
print('0')
else:
qc.x(q[2])
print('1')
#half adder
qc.ccx(q[1],q[2],q[4])
qc.cx(q[1],q[2])
qc.barrier(q)
#half adder
qc.ccx(q[0],q[2],q[3])
qc.cx(q[0],q[2])
qc.barrier(q)
#or
qc.cx(q[4], q[5])
qc.cx(q[3], q[5])
qc.ccx(q[3], q[4], q[5])
qc.barrier(q)
#measure
qc.measure(q[2], c[0])
qc.measure(q[5], c[1])
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
|
https://github.com/JayantiSingh/Quant_co_Qiskit
|
JayantiSingh
|
# X-gate the quantum equivalent of the NOT gate /bit-flip gate
q = QuantumRegister (1)
qc = QuantumCircuit (q)
qc.x(q[0])
qc.draw(output='mpl')
# Z-gate /Phase-shift gate
q = QuantumRegister (1)
qc = QuantumCircuit (q)
qc.z(q[0])
qc.draw(output='mpl')
# H-gate a measurement will have equal probabilities to become 1 or 0 creating a 'superposition' of states /Hadamard gate
q = QuantumRegister (1)
qc = QuantumCircuit (q)
qc.h(q[0])
qc.draw(output='mpl')
# CX-gate performs the NOT operation (equivalent to applying an X gate) on the second qubit only when the first qubit is |1>, and otherwise leaves it unchanged./CNOT gate
q = QuantumRegister (2)
qc = QuantumCircuit (q)
qc.cx(q[0],q[1])
qc.draw(output='mpl')
# CZ-gate It flips the sign of the target qubit if and only if the control qubit is |1>.
q = QuantumRegister (2)
qc = QuantumCircuit (q)
qc.cz(q[0],q[1])
qc.draw(output='mpl')
# CZ-gate costructed from CX-gate and H-gate
q = QuantumRegister (2)
qc = QuantumCircuit (q)
qc.h(q[1])
qc.cx(q[0],q[1])
qc.h(q[1])
qc.draw(output='mpl')
|
https://github.com/JayantiSingh/Quant_co_Qiskit
|
JayantiSingh
|
# useful additional packages
from qiskit import IBMQ, BasicAer, execute
from qiskit import Aer
from qiskit.aqua.components.oracles import LogicalExpressionOracle
from qiskit.aqua.algorithms import Grover
from qiskit.aqua.algorithms import VQE, ExactEigensolver
from qiskit.tools.visualization import plot_histogram
from qiskit.aqua import Operator, run_algorithm
from qiskit.aqua.input import EnergyInput
from qiskit.aqua.translators.ising import max_cut, tsp
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua.components.variational_forms import RY
from qiskit.aqua import QuantumInstance
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
# setup aqua logging
import logging
from qiskit.aqua._logging import set_logging_config, build_logging_config
# set_logging_config(build_logging_config(logging.DEBUG)) # choose INFO, DEBUG to see the log
# ignoring deprecation errors on matplotlib
import warnings
import matplotlib.cbook
warnings.filterwarnings("ignore",category=matplotlib.cbook.mplDeprecation)
# Generating a graph of 4 nodes
n = 4
num_qubits = n ** 2
ins = tsp.random_tsp(n)
G = nx.Graph()
G.add_nodes_from(np.arange(0, n, 1))
colors = ['r' for node in G.nodes()]
pos = {k: v for k, v in enumerate(ins.coord)}
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
print('distance\n', ins.w)
from itertools import permutations
def brute_force_tsp(w, N):
a=list(permutations(range(1,N)))
last_best_distance = 1e10
for i in a:
distance = 0
pre_j = 0
for j in i:
distance = distance + w[j,pre_j]
pre_j = j
distance = distance + w[pre_j,0]
order = (0,) + i
if distance < last_best_distance:
best_order = order
last_best_distance = distance
print('order = ' + str(order) + ' Distance = ' + str(distance))
return last_best_distance, best_order
best_distance, best_order = brute_force_tsp(ins.w, ins.dim)
print('Best order from brute force = ' + str(best_order) + ' with total distance = ' + str(best_distance))
def draw_tsp_solution(G, order, colors, pos):
G2 = G.copy()
n = len(order)
for i in range(n):
j = (i + 1) % n
G2.add_edge(order[i], order[j])
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G2, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
draw_tsp_solution(G, best_order, colors, pos)
qubitOp, offset = tsp.get_tsp_qubitops(ins)
algo_input = EnergyInput(qubitOp)
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = ExactEigensolver(qubitOp, k=1)
result = ee.run()
"""
algorithm_cfg = {
'name': 'ExactEigensolver',
}
params = {
'problem': {'name': 'ising'},
'algorithm': algorithm_cfg
}
result = run_algorithm(params,algo_input)
"""
x = tsp.sample_most_likely(result['eigvecs'][0])
print('energy:', result['energy'])
#print('tsp objective:', result['energy'] + offset)
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
draw_tsp_solution(G, z, colors, pos)
seed = 10598
spsa = SPSA(max_trials=300)
ry = RY(qubitOp.num_qubits, depth=5, entanglement='linear')
vqe = VQE(qubitOp, ry, spsa)
backend = BasicAer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)
result = vqe.run(quantum_instance)
"""
algorithm_cfg = {
'name': 'VQE'
}
optimizer_cfg = {
'name': 'SPSA',
'max_trials': 300
}
var_form_cfg = {
'name': 'RY',
'depth': 5,
'entanglement': 'linear'
}
params = {
'problem': {'name': 'ising', 'random_seed': seed},
'algorithm': algorithm_cfg,
'optimizer': optimizer_cfg,
'variational_form': var_form_cfg,
'backend': {'provider': 'qiskit.Aer', 'name': 'statevector_simulator'}
}
result = run_algorithm(parahms,algo_input)
"""
print('energy:', result['energy'])
print('time:', result['eval_time'])
#print('tsp objective:', result['energy'] + offset)
x = tsp.sample_most_likely(result['eigvecs'][0])
print('feasible:', tsp.tsp_feasible(x))
z = tsp.get_tsp_solution(x)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
draw_tsp_solution(G, z, colors, pos)
|
https://github.com/JayantiSingh/Quant_co_Qiskit
|
JayantiSingh
|
import pennylane as qml
from pennylane import numpy as np
from pennylane.optimize import NesterovMomentumOptimizer
import qiskit
import matplotlib.pyplot as plt
from qiskit.tools.visualization import matplotlib_circuit_drawer as draw
dev = qml.device("default.qubit", wires=2)
def get_angles(x):
beta0 = 2 * np.arcsin(np.sqrt(x[1] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + 1e-12))
beta1 = 2 * np.arcsin(np.sqrt(x[3] ** 2) / np.sqrt(x[2] ** 2 + x[3] ** 2 + 1e-12))
beta2 = 2 * np.arcsin(
np.sqrt(x[2] ** 2 + x[3] ** 2) / np.sqrt(x[0] ** 2 + x[1] ** 2 + x[2] ** 2 + x[3] ** 2)
)
return np.array([beta2, -beta1 / 2, beta1 / 2, -beta0 / 2, beta0 / 2])
def statepreparation(a):
qml.RY(a[0], wires=0)
qml.CNOT(wires=[0, 1])
qml.RY(a[1], wires=1)
qml.CNOT(wires=[0, 1])
qml.RY(a[2], wires=1)
qml.PauliX(wires=0)
qml.CNOT(wires=[0, 1])
qml.RY(a[3], wires=1)
qml.CNOT(wires=[0, 1])
qml.RY(a[4], wires=1)
qml.PauliX(wires=0)
def layer(W):
qml.Rot(W[0, 0], W[0, 1], W[0, 2], wires=0)
qml.Rot(W[1, 0], W[1, 1], W[1, 2], wires=1)
qml.CNOT(wires=[0, 1])
@qml.qnode(dev)
def circuit(weights, angles=None):
statepreparation(angles)
for W in weights:
layer(W)
return qml.expval(qml.PauliZ(0))
def variational_classifier(var, angles=None):
weights = var[0]
bias = var[1]
return circuit(weights, angles=angles) + bias
def square_loss(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
loss = loss + (l - p) ** 2
loss = loss / len(labels)
return loss
def cost(weights, features, labels):
predictions = [variational_classifier(weights, angles=f) for f in features]
return square_loss(labels, predictions)
def accuracy(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
if abs(l - p) < 1e-5:
loss = loss + 1
loss = loss / len(labels)
return loss
data = np.loadtxt('iris_classes1and2_scaled.txt')
X = data[:, 0:2]
print("First X sample (original) :", X[0])
padding = 0.3 * np.ones((len(X), 1))
X_pad = np.c_[np.c_[X, padding], np.zeros((len(X), 1))]
print("First X sample (padded) :", X_pad[0])
normalization = np.sqrt(np.sum(X_pad ** 2, -1))
X_norm = (X_pad.T / normalization).T
print("First X sample (normalized):", X_norm[0])
features = np.array([get_angles(x) for x in X_norm])
print("First features sample :", features[0])
Y = data[:, -1]
import matplotlib.pyplot as plt
plt.figure()
plt.scatter(X[:, 0][Y == 1], X[:, 1][Y == 1], c="r", marker="o", edgecolors="k")
plt.scatter(X[:, 0][Y == -1], X[:, 1][Y == -1], c="b", marker="o", edgecolors="k")
plt.title("Original data")
plt.show()
plt.figure()
dim1 = 0
dim2 = 1
plt.scatter(X_norm[:, dim1][Y == 1], X_norm[:, dim2][Y == 1], c="r", marker="o", edgecolors="k")
plt.scatter(X_norm[:, dim1][Y == -1], X_norm[:, dim2][Y == -1], c="b", marker="o", edgecolors="k")
plt.title("Padded and normalised data (dims {} and {})".format(dim1, dim2))
plt.show()
plt.figure()
dim1 = 0
dim2 = 3
plt.scatter(features[:, dim1][Y == 1], features[:, dim2][Y == 1], c="r", marker="o", edgecolors="k")
plt.scatter(
features[:, dim1][Y == -1], features[:, dim2][Y == -1], c="b", marker="o", edgecolors="k"
)
plt.title("Feature vectors (dims {} and {})".format(dim1, dim2))
plt.show()
np.random.seed(0)
num_data = len(Y)
num_train = int(0.75 * num_data)
index = np.random.permutation(range(num_data))
feats_train = features[index[:num_train]]
Y_train = Y[index[:num_train]]
feats_val = features[index[num_train:]]
Y_val = Y[index[num_train:]]
X_train = X[index[:num_train]]
X_val = X[index[num_train:]]
num_qubits = 2
num_layers = 6
var_init = (0.01 * np.random.randn(num_layers, num_qubits, 3), 0.0)
opt = NesterovMomentumOptimizer(0.01)
batch_size = 5
var = var_init
for it in range(60):
batch_index = np.random.randint(0, num_train, (batch_size,))
feats_train_batch = feats_train[batch_index]
Y_train_batch = Y_train[batch_index]
var = opt.step(lambda v: cost(v, feats_train_batch, Y_train_batch), var)
predictions_train = [np.sign(variational_classifier(var, angles=f)) for f in feats_train]
predictions_val = [np.sign(variational_classifier(var, angles=f)) for f in feats_val]
acc_train = accuracy(Y_train, predictions_train)
acc_val = accuracy(Y_val, predictions_val)
print(
"Iter: {:5d} | Cost: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} "
"".format(it + 1, cost(var, features, Y), acc_train, acc_val)
)
plt.figure()
cm = plt.cm.RdBu
xx, yy = np.meshgrid(np.linspace(0.0, 1.5, 20), np.linspace(0.0, 1.5, 20))
X_grid = [np.array([x, y]) for x, y in zip(xx.flatten(), yy.flatten())]
padding = 0.3 * np.ones((len(X_grid), 1))
X_grid = np.c_[np.c_[X_grid, padding], np.zeros((len(X_grid), 1))]
normalization = np.sqrt(np.sum(X_grid ** 2, -1))
X_grid = (X_grid.T / normalization).T
features_grid = np.array(
[get_angles(x) for x in X_grid]
)
predictions_grid = [variational_classifier(var, angles=f) for f in features_grid]
Z = np.reshape(predictions_grid, xx.shape)
cnt = plt.contourf(xx, yy, Z, levels=np.arange(-1, 1.1, 0.1), cmap=cm, alpha=0.8, extend="both")
plt.contour(xx, yy, Z, levels=[0.0], colors=("black",), linestyles=("--",), linewidths=(0.8,))
plt.colorbar(cnt, ticks=[-1, 0, 1])
plt.scatter(
X_train[:, 0][Y_train == 1],
X_train[:, 1][Y_train == 1],
c="b",
marker="o",
edgecolors="k",
label="class 1 train",
)
plt.scatter(
X_val[:, 0][Y_val == 1],
X_val[:, 1][Y_val == 1],
c="b",
marker="^",
edgecolors="k",
label="class 1 validation",
)
plt.scatter(
X_train[:, 0][Y_train == -1],
X_train[:, 1][Y_train == -1],
c="r",
marker="o",
edgecolors="k",
label="class -1 train",
)
plt.scatter(
X_val[:, 0][Y_val == -1],
X_val[:, 1][Y_val == -1],
c="r",
marker="^",
edgecolors="k",
label="class -1 validation",
)
plt.legend()
plt.show()
|
https://github.com/adityakhannaadk/qasm_py_quantum
|
adityakhannaadk
|
"""
This module contains the Quantum Fourier Transform class.
"""
from numpy import pi
from qiskit import QuantumCircuit, Aer, transpile, assemble
class QuantumFourierTransform:
"""Class for operations of the Quantum Fourier Transform."""
@staticmethod
def simulate(state: int) -> dict:
"""Simulate the QFT and iQFT.
Parameters
----------
state (int): The state to simulate.
Returns
-------
dict: The simulated state.
"""
# Get the number of qubits.
qubit_count = state.bit_length()
# Create the circuit.
circuit = QuantumCircuit(qubit_count, qubit_count)
# Apply the initial state.
for qubit in range(qubit_count):
if state & (1 << qubit):
circuit.x(qubit)
# Apply the QFT.
circuit = QuantumFourierTransform.qft(circuit)
# Apply the inverse QFT.
circuit = QuantumFourierTransform.iqft(circuit)
# Append the measurement.
circuit.measure(range(qubit_count), range(qubit_count))
# Run the simulation.
simulator = Aer.get_backend("aer_simulator")
circuit = transpile(circuit, simulator)
job = simulator.run(assemble(circuit))
result = job.result().get_counts()
answer_as_list = list(result.keys())
answer_int = int(answer_as_list[0], 2)
return {"result": answer_int}
@staticmethod
def qft(circuit: QuantumCircuit) -> QuantumCircuit:
"""Apply QFT to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the QFT to.
Returns
-------
QuantumCircuit: The circuit with the QFT applied.
"""
# Apply the QFT to the circuit.
circuit = QuantumFourierTransform._qft_append_circuit(
circuit, circuit.num_qubits - 1
)
# Apply the swaps to the circuit.
circuit = QuantumFourierTransform._qft_append_swaps(circuit)
return circuit
@staticmethod
def qft_circuit(qubit_count: int) -> QuantumCircuit:
"""Create a QFT circuit with given Qubit count.
Parameters
----------
qubit_count : int
The number of qubits to use in the circuit.
Returns
-------
QuantumCircuit
The QFT circuit.
"""
return QuantumFourierTransform.qft(QuantumCircuit(qubit_count))
@staticmethod
def iqft_circuit(qubit_count: int) -> QuantumCircuit:
"""Create a iQFT circuit with given Qubit count.
Parameters
----------
qubit_count : int
The number of qubits to use in the circuit.
Returns
-------
QuantumCircuit
The iQFT circuit.
"""
return QuantumFourierTransform.iqft(QuantumCircuit(qubit_count))
@staticmethod
def iqft(circuit: QuantumCircuit) -> QuantumCircuit:
"""Apply inverse QFT to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the IQFT to.
Returns
-------
QuantumCircuit: The circuit with the iQFT applied.
"""
# Apply the swaps to the circuit.
circuit = QuantumFourierTransform._qft_append_swaps(circuit, inverse=True)
circuit.barrier()
# Apply the QFT to the circuit.
circuit = QuantumFourierTransform._iqft_append_circuit(circuit, 0)
return circuit
@staticmethod
def _qft_append_circuit(circuit: QuantumCircuit, qubit: int) -> QuantumCircuit:
"""Apply a rotation to a qubit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the rotation to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the rotation applied.
"""
# Recursive stop condition.
if qubit < 0:
return circuit
# Construct the minimal QFT circuit.
circuit.h(qubit)
for qubit_line in reversed(range(qubit)):
circuit.cp(pi / 2 ** (qubit - qubit_line), qubit_line, qubit)
circuit.barrier()
# Recursively apply the QFT to the next qubit.
return QuantumFourierTransform._qft_append_circuit(circuit, qubit - 1)
@staticmethod
def _iqft_append_circuit(circuit: QuantumCircuit, qubit: int) -> QuantumCircuit:
"""Apply a rotation to a qubit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the rotation to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the rotation applied.
"""
# Recursive stop condition.
if qubit >= circuit.num_qubits:
return circuit
# Construct the minimal QFT circuit.
for qubit_line in range(qubit):
circuit.cp(-pi / 2 ** (qubit - qubit_line), qubit_line, qubit)
circuit.h(qubit)
circuit.barrier()
# Recursively apply the QFT to the next qubit.
return QuantumFourierTransform._iqft_append_circuit(circuit, qubit + 1)
@staticmethod
def _qft_append_swaps(
circuit: QuantumCircuit, inverse: bool = False
) -> QuantumCircuit:
"""Apply swaps to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the swaps to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the swaps applied.
"""
qubit_count = circuit.num_qubits
qubits_list = (
reversed(range(qubit_count // 2))
if not inverse
else range(qubit_count // 2)
)
for qubit in qubits_list:
circuit.swap(qubit, qubit_count - qubit - 1)
return circuit
if __name__ == "__main__":
print("===================================")
print("Quantum Fourier Transform Simulator")
print("===================================")
# Get the input state as integer decimal.
state_int = int(input("> Enter the state as decimal integer: "))
# Run the algorithm.
result = QuantumFourierTransform.simulate(state_int)
print(f"iQFT result: {result['result']}")
|
https://github.com/GiacomoFrn/QuantumTeleportation
|
GiacomoFrn
|
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/a-giovagnoli/QAOA-Qiskit
|
a-giovagnoli
|
#In case you don't have qiskit, install it now
%pip install qiskit --quiet
#Installing/upgrading pylatexenc seems to have fixed my mpl issue
#If you try this and it doesn't work, try also restarting the runtime/kernel
%pip install pylatexenc --quiet
!pip install -Uqq ipdb
!pip install qiskit_optimization
import networkx as nx
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity
from qiskit.extensions.hamiltonian_gate import HamiltonianGate
from qiskit.extensions import RXGate, XGate, CXGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
import numpy as np
from qiskit.visualization import plot_histogram
import ipdb
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#quadratic optimization
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
%pdb on
# def ApplyCost(qc, gamma):
# Ix = np.array([[1,0],[0,1]])
# Zx= np.array([[1,0],[0,-1]])
# Xx = np.array([[0,1],[1,0]])
# Temp = (Ix-Zx)/2
# T = Operator(Temp)
# I = Operator(Ix)
# Z = Operator(Zx)
# X = Operator(Xx)
# FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
# ham = HamiltonianGate(FinalOp,gamma)
# qc.append(ham,[0,1,2])
task = QuadraticProgram(name = 'QUBO on QC')
task.binary_var(name = 'x')
task.binary_var(name = 'y')
task.binary_var(name = 'z')
task.minimize(linear = {"x":-1,"y":2,"z":-3}, quadratic = {("x", "z"): -2, ("y", "z"): -1})
qubo = QuadraticProgramToQubo().convert(task) #convert to QUBO
operator, offset = qubo.to_ising()
print(operator)
# ham = HamiltonianGate(operator,0)
# print(ham)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
ham = HamiltonianGate(FinalOp,0)
print(ham)
#define PYBIND11_DETAILED_ERROR_MESSAGES
def compute_expectation(counts):
"""
Computes expectation value based on measurement results
Args:
counts: dict
key as bitstring, val as count
G: networkx graph
Returns:
avg: float
expectation value
"""
avg = 0
sum_count = 0
for bitstring, count in counts.items():
x = int(bitstring[2])
y = int(bitstring[1])
z = int(bitstring[0])
obj = -2*x*z-y*z-x+2*y-3*z
avg += obj * count
sum_count += count
return avg/sum_count
# We will also bring the different circuit components that
# build the qaoa circuit under a single function
def create_qaoa_circ(theta):
"""
Creates a parametrized qaoa circuit
Args:
G: networkx graph
theta: list
unitary parameters
Returns:
qc: qiskit circuit
"""
nqubits = 3
n,m=3,3
p = len(theta)//2 # number of alternating unitaries
qc = QuantumCircuit(nqubits,nqubits)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(Z^I^Z)-(I^Z^Z)-(Z^I^I)+2*(I^Z^I)-3*(I^I^Z)
beta = theta[:p]
gamma = theta[p:]
# initial_state
for i in range(0, nqubits):
qc.h(i)
for irep in range(0, p):
#ipdb.set_trace(context=6)
# problem unitary
# for pair in list(G.edges()):
# qc.rzz(2 * gamma[irep], pair[0], pair[1])
#ApplyCost(qc,2*0)
ham = HamiltonianGate(operator,2 * gamma[irep])
qc.append(ham,[0,1,2])
# mixer unitary
for i in range(0, nqubits):
qc.rx(2 * beta[irep], i)
qc.measure(qc.qubits[:n],qc.clbits[:m])
return qc
# Finally we write a function that executes the circuit on the chosen backend
def get_expectation(shots=512):
"""
Runs parametrized circuit
Args:
G: networkx graph
p: int,
Number of repetitions of unitaries
"""
backend = Aer.get_backend('qasm_simulator')
backend.shots = shots
def execute_circ(theta):
qc = create_qaoa_circ(theta)
# ipdb.set_trace(context=6)
counts = {}
job = execute(qc, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc)
return compute_expectation(counts)
return execute_circ
from scipy.optimize import minimize
expectation = get_expectation()
res = minimize(expectation, [1, 1], method='COBYLA')
expectation = get_expectation()
res = minimize(expectation, res.x, method='COBYLA')
res
from qiskit.visualization import plot_histogram
backend = Aer.get_backend('aer_simulator')
backend.shots = 512
qc_res = create_qaoa_circ(res.x)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc_res, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc_res)
plot_histogram(counts)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
# ! pip install qiskit
# ! pip install numpy
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit.quantum_info import Statevector
import numpy as np
ground_state = np.array([1, 0])
excited_state = np.array([0, 1])
# Making an arbitary state
alpha = 2+ 4j
beta = -2
normalization_factor = np.sqrt(abs(alpha**2)+ abs(beta**2))
arbitrary_state = np.array([alpha, beta]) / normalization_factor
print("ground_state=", ground_state)
print("excited_state=", excited_state)
print("Arbitary_state=", arbitrary_state)
plot_bloch_multivector(ground_state)
plot_bloch_multivector(excited_state)
plot_bloch_multivector(arbitrary_state)
# Defining the matrices
I_matrix = np.identity(2)
Pauli_x = np.array([[0, 1], [1, 0]])
Pauli_y = np.array([[0, -1j], [1j, 0]])
Pauli_z = np.array([[1, 0], [0, 1]])
Hadamard_transform = np.sqrt(1/2) * np.array([[1, 1], [1, -1]])
print("\n Identity Matrix \n" , I_matrix )
print("\n Pauli X \n" , Pauli_x )
print("\n Pauli Y \n" , Pauli_y )
print("\n Pauli Z \n" , Pauli_z )
print("\n Hadamard Transform \n" , Hadamard_transform )
plus_state = np.dot(Hadamard_transform, ground_state)
plot_bloch_multivector(plus_state)
# Defining the Quantum Circuit with a Quantum Register of size 1
quantum_circuit = QuantumCircuit(1)
# Applyign the hadamrad gate to the first Qubit
quantum_circuit.h(0)
# Measuring the Circuit
#quantum_circuit.measure(0,0)
# DRwaing the quantum circuit
quantum_circuit.draw('mpl')
initial_state = Statevector.from_label('0')
plot_bloch_multivector(initial_state)
evolved_state = initial_state.evolve(quantum_circuit)
plot_bloch_multivector(evolved_state)
backend=Aer.get_backend('qasm_simulator')
counts = execute(quantum_circuit,backend, shots = 10).result().get_counts()
plot_histogram(counts)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
# ! pip install numpy
# ! pip install qiskit
# ! pip install matplotlib
from qiskit import QuantumCircuit, execute, Aer, BasicAer
from qiskit.visualization import plot_histogram
import numpy as np
n = 2
f1 = QuantumCircuit(n+1, name='f1')
# Applying the x gate to ancilla for when f_1 = 1
f1.cx(1,2)
display(f1.draw())
f2 = QuantumCircuit(n+1, name='f2')
# Applying the x gate to ancilla for when f_1 = 1
f2.cx(0,2)
f2.cx(1,2)
f2.ccx(0,1,2)
display(f2.draw())
dj = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj.h(qubit)
# Put ancilia qubit in state |->
dj.x(n)
dj.h(n)
dj.barrier()
# Add oracle corresponding to the fucntion
dj.append(f1, [*range(n+1)])
dj.barrier()
# Repeat H-gates
for qubit in range(n):
dj.h(qubit)
dj.barrier()
# Measure
for i in range(n):
dj.measure(i, i)
# Display circuit
dj.draw('mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(dj, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Since we measure the state |00> with probability 0, the funciton is balanced as expected
dj = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj.h(qubit)
# Put ancilia qubit in state |->
dj.x(n)
dj.h(n)
dj.barrier()
# Add oracle corresponding to the fucntion
dj.append(f2, [*range(n+1)])
dj.barrier()
# Repeat H-gates
for qubit in range(n):
dj.h(qubit)
dj.barrier()
# Measure
for i in range(n):
dj.measure(i, i)
# Display circuit
dj.draw('mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(dj, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Since we measure the state |00> with probability ~0.25, the function is biased as expected
dj = QuantumCircuit(n+1, n)
# Apply H-gates
for qubit in range(n):
dj.h(qubit)
# Put ancilia qubit in state |->
dj.x(n)
dj.h(n)
dj.barrier()
# Add oracle corresponding to the function
dj.append(f1, [*range(n+1)])
dj.append(f2, [*range(n+1)])
dj.barrier()
# Repeat H-gates
for qubit in range(n):
dj.h(qubit)
dj.barrier()
# Measure
for i in range(n):
dj.measure(i, i)
# Display circuit
dj.draw('mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(dj, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
# ! pip install numpy
# ! pip install qiskit
# ! pip install matplotlib
from qiskit import QuantumCircuit, Aer ,BasicAer, execute
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere
from qiskit.quantum_info import Statevector
import matplotlib.pyplot as plt
import numpy as np
def phase_oracle(name = 'Of'):
qc = QuantumCircuit(3, name=name)
qc.x(1)
qc.cx(1,2)
qc.x(1)
return qc
def diffuser( name='V'):
qc = QuantumCircuit(3, name=name)
for qb in range(2): #first layer of Hadamards in diffuser
qc.h(qb)
for i in range(2):
qc.x(i)
qc.ccx(0,1,2)
for i in range(2):
qc.x(i)
for qb in range(2): #second layer of Hadamards in diffuser
qc.h(qb)
return qc
n = 2
gr = QuantumCircuit(n+1, 2)
m = 2 # Number of solutions
r = int(np.floor(np.pi/4*np.sqrt(2**(n)/m))) # Determine r
gr.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr.x(n)
gr.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr.append(phase_oracle(), range(n+1))
gr.append(diffuser(), range(n+1))
gr.measure(0, 0)
gr.measure(1, 1) # step 3: measure all qubits
gr.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr, backend=simulator, shots=1000)
counts = job.result().get_counts()
plot_histogram(counts)
# Probability og finding the state p(|m>) = p(00)+ p(10)
n = 2
prob_marked = []
# Returns probability of success
def probability(counts):
key_sol1 = '00'
key_sol2 = '10'
val_sol = counts[key_sol1] + counts[key_sol2]
val_total = sum(counts.values())
prob_of_success = val_sol/val_total
return prob_of_success
gr0 = QuantumCircuit(n+1, n)
r = 0
gr0.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr0.x(n)
gr0.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr1.append(phase_oracle(n+1), range(n+1))
gr1.append(diffuser(n+1), range(n+1))
gr0.measure(range(n), range(n)) # step 3: measure all qubits
gr0.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr0, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr1 = QuantumCircuit(n+1, n)
r = 1
gr1.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr1.x(n)
gr1.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr1.append(phase_oracle(), range(n+1))
gr1.append(diffuser(), range(n+1))
gr1.measure(range(n), range(n)) # step 3: measure all qubits
gr1.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr1, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr2 = QuantumCircuit(n+1, n)
r = 2
gr2.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr2.x(n)
gr2.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr2.append(phase_oracle(), range(n+1))
gr2.append(diffuser(), range(n+1))
gr2.measure(range(n), range(n)) # step 3: measure all qubits
gr2.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr2, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr3 = QuantumCircuit(n+1, n)
r = 3
gr3.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr3.x(n)
gr3.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr3.append(phase_oracle(), range(n+1))
gr3.append(diffuser(), range(n+1))
gr3.measure(range(n), range(n)) # step 3: measure all qubits
gr3.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr3, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr4 = QuantumCircuit(n+1, n)
r = 4
gr4.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr4.x(n)
gr4.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr4.append(phase_oracle(), range(n+1))
gr4.append(diffuser(), range(n+1))
gr4.measure(range(n), range(n)) # step 3: measure all qubits
gr4.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr4, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
r = [0,1,2,3,4]
plt.plot(r, prob_marked, 'o-')
plt.xlabel("Grover Iterations (r)")
plt.ylabel("Probability of Marked State")
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
from qiskit import QuantumCircuit, execute, Aer, BasicAer
from qiskit.visualization import plot_histogram
from qiskit.quantum_info import Statevector, state_fidelity
import numpy as np
pi = np.pi
from qiskit.visualization import plot_state_qsphere, plot_histogram, plot_bloch_multivector
# For n qubit system
n = 4
N = 2**n
w = np.exp(2*pi*(1j)/N)
# Initiliaing the qft matrix and assigning it values
qft = np.zeros((N,N),dtype = 'complex_')
for i in range(N):
for j in range(N):
qft[i][j] = pow(w,(i*j))/n
print(qft)
# Initializing the input state
in_state = np.zeros(N,dtype = 'complex_')
# State |0010> in vector form has third element non zero
in_state[2] = 1j /pow(2, 0.5)
# State |0011> in vector form has fourth element non zero
in_state[3] = 1 /pow(2, 0.5)
#print(in_state)
# Output state
out_state = np.matmul(qft, in_state)
# Making a state_vector
matrix_output = Statevector(out_state, dims=(2, 2, 2, 2))
print(out_state)
# Checking if output state is normalized
norm = pow(np.matmul(out_state.conjugate(), out_state), 0.5)
print("Norm = ", norm)
n=4
qftn=QuantumCircuit(n,n,name='QFT')
for i in range(n-1,-1,-1):
# Puttign each qubit in unifrom superposition
qftn.h(i)
# Adding the relevent rotation gate
p=0
for j in range(i):
p+=1
qftn.cp(pi/(2**(p)),i-j-1,i)
qftn.barrier()
# Swapping the output qubits
for i in range(int(n/2)):
qftn.swap(i,n-1-i)
qftn.draw('mpl')
# Perparing the inout state for the quntum circuit
sv1 = Statevector.from_label('0011')
sv2 = Statevector.from_label('0010')
sv = (sv1 + 1j* sv2)/pow(2,0.5)
# Representing the input state on the block sphere
plot_bloch_multivector(sv)
# Evolovinf the state and representing the output state on the block sphere
circuit_output = sv.evolve(qftn)
plot_bloch_multivector(circuit_output)
# Verifying that the circuit and matrix give the same results
#print(matrix_output)
#print(circuit_output)
fidelity = state_fidelity(matrix_output, circuit_output)
print("Fidelity =", fidelity)
# The QFT inverse circuit
n=4
iqftn=QuantumCircuit(n,n,name='IQFT')
for i in range(int(n/2)):
iqftn.swap(i,n-1-i)
iqftn.barrier()
for i in range(n):
p=i+1
for j in range(i):
p-=1
iqftn.cp(-pi/(2**(p)),j,i)
iqftn.h(i)
iqftn.barrier()
iqftn.draw('mpl')
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
# ! pip install qiskit
# ! pip install numpy
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere
from qiskit.quantum_info import Statevector
import numpy as np
ent_qc=QuantumCircuit(2)
ent_qc.h(0)
ent_qc.cx(0,1) # params = (Controll Qubit, Target Qubit)
ent_qc.draw('mpl')
initial_state = Statevector.from_label('01')
plot_bloch_multivector(initial_state)
evolved_state = initial_state.evolve(ent_qc)
print(evolved_state)
plot_bloch_multivector(evolved_state)
plot_state_qsphere(evolved_state)
# Starting with Unifrom Superposition Initialization
quantum_register = 3
us_qc=QuantumCircuit(quantum_register)
us_qc.x(quantum_register-1)
us_qc.barrier()
for i in range(quantum_register):
us_qc.h(i)
us_qc.barrier()
us_qc.draw('mpl')
# Toffoli gate and a CNOT gate
mark_qc=QuantumCircuit(quantum_register)
mark_qc.ccx(0,1,2) # params = (Controll Qubit, Controll Qubit, Target Qubit)
mark_qc.cx(1,2)
mark_qc.draw('mpl')
full_qc=QuantumCircuit(quantum_register, quantum_register)
full_qc.compose(us_qc, inplace=True)
full_qc.compose(mark_qc, inplace=True)
full_qc.barrier()
for i in range(quantum_register-1):
full_qc.measure(i,i)
full_qc.draw('mpl')
backend=Aer.get_backend('qasm_simulator')
counts = execute(full_qc,backend, shots = 1000).result().get_counts()
plot_histogram(counts)
multi_qc=QuantumCircuit(4, 4)
multi_qc.barrier()
#multi_qc.x()
multi_qc.barrier()
multi_qc.mcx([0,1,2],3)
multi_qc.barrier()
multi_qc.ccx(0,1,2)
multi_qc.ccx(1,2,3)
multi_qc.ccx(0,1,2)
multi_qc.barrier()
for i in range(4):
multi_qc.measure(i,i)
multi_qc.draw('mpl')
backend=Aer.get_backend('qasm_simulator')
counts = execute(multi_qc,backend, shots = 1000).result().get_counts()
plot_histogram(counts)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
! pip install numpy
! pip install qiskit
! pip install matplotlib
from qiskit import QuantumCircuit, Aer ,BasicAer, execute
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere
from qiskit.quantum_info import Statevector
import matplotlib.pyplot as plt
import numpy as np
alpha = 0.5
beta = 0.5j
normalization_factor = np.sqrt(abs(alpha**2)+ abs(beta**2))
special_state = np.array([alpha, beta]) / normalization_factor
plot_bloch_multivector(special_state)
teleportation_circuit = QuantumCircuit(3, 1)
# Initializing the special state
teleportation_circuit.initialize(special_state,0)
teleportation_circuit.barrier()
# Entanger circuit
teleportation_circuit.h(1)
teleportation_circuit.cx(1,2)
teleportation_circuit.barrier()
# Dis-Entanger circuit
teleportation_circuit.cx(0,1)
teleportation_circuit.h(0)
teleportation_circuit.barrier()
# Controlled note gates based on Alice's Results
teleportation_circuit.cx(1,2)
teleportation_circuit.cz(0,2)
teleportation_circuit.barrier()
# Measuing Bob's Qubit
teleportation_circuit.measure(2,0)
teleportation_circuit.draw('mpl')
shots_fired = 1000
backend=Aer.get_backend('qasm_simulator')
result = execute(teleportation_circuit,backend, shots = shots_fired).result()
plot_histogram(result.get_counts())
print(" Probability(0) =", abs((alpha/normalization_factor)**2))
print(" Probability(1) =", abs((beta/normalization_factor)**2))
from qiskit import IBMQ
IBMQ.save_account('Add the IBM token here', overwrite=True)
provider=IBMQ.load_account()
backend=provider.get_backend('ibm_nairobi')
from qiskit.tools import job_monitor
job = execute(teleportation_circuit, backend=backend, shots=shots_fired)
counts=job.result().get_counts()
job_monitor(job)
plot_histogram(counts)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
! pip install numpy
! pip install qiskit
! pip install matplotlib
from qiskit import QuantumCircuit, Aer ,BasicAer, execute
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere
from qiskit.quantum_info import Statevector
import matplotlib.pyplot as plt
import numpy as np
def phase_oracle(n,name = 'Of'):
qc = QuantumCircuit(n, name=name)
qc.mct(list(range(n-1)), n-1)
return qc
def diffuser(n, name='V'):
qc = QuantumCircuit(n, name=name)
for qb in range(n-1): #first layer of Hadamards in diffuser
qc.h(qb)
for i in range(n-1):
qc.x(i)
qc.mct(list(range(n-1)), n-1)
for i in range(n-1):
qc.x(i)
for qb in range(n-1): #second layer of Hadamards in diffuser
qc.h(qb)
return qc
n = 2
gr = QuantumCircuit(n+1, n)
r = int(np.floor(np.pi/4*np.sqrt(2**(n)))) # Determine r
gr.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr.x(n)
gr.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr.append(phase_oracle(n+1), range(n+1))
gr.append(diffuser(n+1), range(n+1))
gr.measure(range(n), range(n)) # step 3: measure all qubits
gr.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr, backend=simulator, shots=1000)
counts = job.result().get_counts()
plot_histogram(counts)
n = 4
prob_marked = []
# Returns probability of success
def probability(counts):
key_sol = '1111'
val_sol = counts[key_sol]
val_total = sum(counts.values())
prob_of_success = val_sol/val_total
return prob_of_success
gr0 = QuantumCircuit(n+1, n)
r = 0
gr0.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr0.x(n)
gr0.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr1.append(phase_oracle(n+1), range(n+1))
gr1.append(diffuser(n+1), range(n+1))
gr0.measure(range(n), range(n)) # step 3: measure all qubits
gr0.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr0, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr1 = QuantumCircuit(n+1, n)
r = 1
gr1.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr1.x(n)
gr1.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr1.append(phase_oracle(n+1), range(n+1))
gr1.append(diffuser(n+1), range(n+1))
gr1.measure(range(n), range(n)) # step 3: measure all qubits
gr1.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr1, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr2 = QuantumCircuit(n+1, n)
r = 2
gr2.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr2.x(n)
gr2.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr2.append(phase_oracle(n+1), range(n+1))
gr2.append(diffuser(n+1), range(n+1))
gr2.measure(range(n), range(n)) # step 3: measure all qubits
gr2.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr2, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr3 = QuantumCircuit(n+1, n)
r = 3
gr3.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr3.x(n)
gr3.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr3.append(phase_oracle(n+1), range(n+1))
gr3.append(diffuser(n+1), range(n+1))
gr3.measure(range(n), range(n)) # step 3: measure all qubits
gr3.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr3, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
gr4 = QuantumCircuit(n+1, n)
r = 4
gr4.h(range(n)) # step 1: apply Hadamard gates on all working qubits
# put ancilla in state |->
gr4.x(n)
gr4.h(n)
# step 2: apply r rounds of the phase oracle and the diffuser
for j in range(r):
gr4.append(phase_oracle(n+1), range(n+1))
gr4.append(diffuser(n+1), range(n+1))
gr4.measure(range(n), range(n)) # step 3: measure all qubits
gr4.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
job = execute(gr4, backend=simulator, shots=1000)
counts = job.result().get_counts()
prob_marked.append(probability(counts))
plot_histogram(counts)
r = [0,1,2,3,4]
plt.plot(r, prob_marked, 'o-')
plt.xlabel("Grover Iterations (r)")
plt.ylabel("Probability of Marked State")
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
from qiskit import Aer, execute
from qiskit.visualization import plot_histogram
import numpy as np
pi = np.pi
n=5
qc=QuantumCircuit(n+1,n)
for qubit in range(n):
qc.h(qubit)
init_st=[0, 1]
qc.initialize(init_st,n)
theta=0.9
for x in range(n):
exponent = 2**(n-x-1)
qc.cp(2*pi*theta*exponent, x, n)
qc.append(QFT(n).inverse(), range(n))
for i in range(n):
qc.measure(i,i)
qc.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend=simulator, shots=10000).result().get_counts()
plot_histogram(counts)
import operator
highest_probability_outcome = max(counts.items(), key=operator.itemgetter(1))[0][::-1]
highest_probability_outcome
measured_theta = int(highest_probability_outcome, 2)/2**n
print("Using ", n, " qubits with theta = ",theta, ", measured_theta = ", measured_theta)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
from qiskit import *
from qiskit.circuit.library import *
from qiskit.tools.visualization import *
from qiskit.providers.aer import *
from qiskit.providers.aer.noise import *
import matplotlib.pyplot as plt
import numpy as np
pi = np.pi
import pandas as pd
import statistics
from statsmodels.stats.weightstats import DescrStatsW
# The grover oracle which contains the phase oracle and the diffuser operators
def grover_oracle(n,name = 'G' ): #
qc = QuantumCircuit(n, name=name) #
# giving them n solutions
qc.mct(list(range(n-1)), n-1)
for qb in range(n-1): #first layer of Hadamards in diffuser
qc.h(qb)
for i in range(n-1):
qc.x(i)
qc.mct(list(range(n-1)), n-1)
for i in range(n-1):
qc.x(i)
for qb in range(n-1): #second layer of Hadamards in diffuser
qc.h(qb)
return qc
counting_n = 5
searching_n = counting_n
tn = counting_n + searching_n
qc = QuantumCircuit(tn, counting_n)
# initialize the last wire to the eigenvector of U
qc.x(tn-1)
qc.barrier()
# Setting the counting and searching qubits to superposition states
for i in range(tn):
qc.h(i)
# Making the grover oracel into a controlled oracle
con_grover = grover_oracle(counting_n).control(1)
# Applying the grover oracel onto the searching qubits using the counting qubits
iterations= 1
for x in range(counting_n):
for i in range(iterations):
qc.append(con_grover , [x] + [*range(counting_n, tn)] ) # [x] is control and [5,6,7..tn] are target qubits
iterations = 2*iterations
# appling Inverse QFT
qc.append(QFT(counting_n).inverse(), range(counting_n))
# measuring the counting qubits
for i in range(counting_n):
qc.measure(i,i)
qc.draw('mpl')
# Simulating the Quantum COunting Circuit
simulator = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend=simulator, shots=10000).result().get_counts()
plot_histogram(counts)
# Identifying the state with maximum output
highest_probability_outcome = max(counts, key = counts.get)
print(highest_probability_outcome)
# Calculating the angle encoded in the counting qubtis
theta = int(highest_probability_outcome, 2)*(pi*2)/(2**counting_n)
N = 2**(searching_n-1)
M = N* (np.sin(theta/2)**2)
# Calculating the number of solutions along with error
solutions = N-M
print("Using =", counting_n, ", \nNumber of solutions = ", solutions)
m = counting_n-1
err = (np.sqrt(2*M*N) + N/(2**(counting_n)))*(2**(-m))
print("With error=", err)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
#! pip install numpy
#! pip install qiskit
#! pip install matplotlib
from qiskit import QuantumCircuit, Aer ,BasicAer, execute
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere
from qiskit.quantum_info import Statevector
import matplotlib.pyplot as plt
import numpy as np
GHZ_circuit = QuantumCircuit(3)
GHZ_circuit.h(0)
GHZ_circuit.cx(0, 1)
GHZ_circuit.cx(1, 2)
GHZ_circuit.draw('mpl')
initial = ["000", "001", "010", "011", "100", "101", "110", "111"]
initial_states = []
for label in initial:
initial_states.append(Statevector.from_label(label))
#print(initial_states)
evolved_states = []
for state in initial_states:
evolved_states.append(state.evolve(GHZ_circuit))
#print(evolved_states)
matrix = np.zeros((2**3, 2**3), dtype = "complex_")
for i in range(2**3):
for j in range(2**3):
matrix[i][j] = evolved_states[i][j]
matrix = matrix.T
print("Matrix form of the GHZ entangler = ")
print(matrix)
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
# ! pip install numpy
# ! pip install qiskit
# ! pip install matplotlib
from qiskit import QuantumCircuit, Aer ,BasicAer, execute, transpile
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere
from qiskit.quantum_info import Statevector, partial_trace, state_fidelity
import matplotlib.pyplot as plt
import numpy as np
from pprint import pprint
from qiskit.providers.aer.noise import NoiseModel, amplitude_damping_error
alice_state = Statevector.from_label("+")
teleportation_circuit = QuantumCircuit(3, 1)
# Making the state alice wants to communicate
teleportation_circuit.h(0)
teleportation_circuit.barrier()
# Entanger circuit
teleportation_circuit.h(1)
teleportation_circuit.cx(1,2)
teleportation_circuit.barrier()
# Dis-Entanger circuit
teleportation_circuit.cx(0,1)
teleportation_circuit.h(0)
teleportation_circuit.barrier()
# Controlled not gates based on Alice's Results
teleportation_circuit.cx(1,2)
teleportation_circuit.cz(0,2)
teleportation_circuit.barrier()
#teleportation_circuit.measure(2,0)
teleportation_circuit.snapshot("final", snapshot_type='statevector', qubits=[2])
teleportation_circuit.draw('mpl')
from qiskit.providers.aer.noise import NoiseModel, noise_model
from qiskit.providers.aer.noise.errors import pauli_error
def noisy_simulator(p):
noise_model = NoiseModel()
# Using the Bit-flip noise channel
error_meas = pauli_error([('X',p), ('I', 1 - p)])
noise_model.add_all_qubit_quantum_error(error_meas, "measure")
return noise_model
# Initlaizing the quantum simulator and decomposing the circuit interms of the basic gates
simulator =Aer.get_backend('qasm_simulator')
basis_gates = ['rz', 'sx', 'x', 'id' ,"cx"]
quantum_circ = transpile(teleportation_circuit, basis_gates=basis_gates)
# Making list of noise (probability of failure) under whichwe want to teleport the state
# Making a list of fidelity to store the accuracy of our teleportations
p_noise = [0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6]
fidelity = []
for p in p_noise:
#Simualting the circuit for each value of noise
noisy_results = execute(quantum_circ, backend=simulator, shots=10000, noise_model=noisy_simulator(p)).result()
# get the state of of the circuit after teleportations circuit has been traversed
state = noisy_results.data(0)['snapshots']['statevector']['final']
# encode this state as a statevector
state_ac = Statevector(state[0], dims=(2, 2, 2))
# take a partial trace to get the reduced matric rho bob has
bob_state = partial_trace(state_ac, [0,1]).to_statevector()
# find fidelity of state alice was to communicate and bob has recieved
fidelity.append(state_fidelity(alice_state, bob_state))
plt.plot(p_noise, fidelity, 'o-')
plt.ylabel("Fidelity")
plt.xlabel("Noise (p)")
|
https://github.com/MAI-cyber/QIT
|
MAI-cyber
|
from qiskit import QuantumCircuit
from qiskit.circuit.library import QFT
from qiskit import Aer, execute
from qiskit.visualization import plot_histogram
import numpy as np
import math
# For factorizign the number, N= 15
N = 15
n = 4
m = 4
#Using, period root
a = 7
# Making the unitary U = 7^(1) mod 15
U= QuantumCircuit(m)
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
U.barrier()
for q in range(4):
U.x(q)
U.draw('mpl')
# Making the controlled gate con_U = 7^(1) mod 15 ... or 8^(1) mod 15
def con_amodN(m):
U = QuantumCircuit(m)
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
for q in range(m):
U.x(q) # Comment out for a = 8
U = U.to_gate()
U.name = "U"
con_U = U.control()
return con_U
# Shors algorithm
qc = QuantumCircuit(n+m, n)
#Initialiaing the proper states
qc.h(range(n))
#qc.x(range(n, n+m))
qc.x(n+m-1)
qc.barrier()
# Applyign the Unitary U for a = 7
for i in range(n):
for j in range(2**i):
qc.append(con_amodN(m), [i] + [*range(n, n+m)]) # [i] is the contol qubit and [4,5,6.. n+m] are the target qubits
# Applying inverse of Fourier
qc.append(QFT(n, do_swaps= False).inverse(), range(n))
#Measurining the controll qubits
for i in range(n):
qc.measure(i,i)
qc.draw('mpl')
# Simulating the circuit
simulator = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend=simulator, shots=10000).result().get_counts()
plot_histogram(counts)
# USing the ststaes measured, finding the periodic roots (r)
for i in counts:
measured_value = int(i[::-1], 2)
if measured_value % 2 != 0:
#print("Measured value not even")
continue #measured value should be even as we are doing a^(r/2) mod N and r/2 should be int
x = int((a ** (measured_value/2)) % N)
if (x + 1) % N == 0:
continue
# FInding the factors using gcd arguments
factor_one = math.gcd(x + 1, N)
factor_two = math.gcd(x - 1, N)
# removing trivial factors
if factor_one == N:
continue
if factor_two == N:
continue
if factor_one == 1 and factor_two == 1:
continue
if factor_one != 1:
factor_two = N//factor_one
if factor_two != 1:
factor_one = N//factor_two
print("Measured value = ", measured_value, " leads to the factors =", factor_one, factor_two)
# Refer to QCI pg 235
|
https://github.com/ritamsarmah/cs239
|
ritamsarmah
|
from qiskit import QuantumCircuit
from QCLG_lvl3.oracles.secret_number_oracle import SecretNUmberOracle
class BernsteinVazirani:
@classmethod
def bernstein_vazirani(cls, random_binary, eval_mode: bool) -> QuantumCircuit:
# Construct secret number oracle
secret_number_oracle = SecretNUmberOracle.create_secret_number_oracle(random_binary=random_binary, eval_mode=eval_mode)
num_of_qubits = secret_number_oracle.num_qubits
# Construct circuit according to the length of the number
dj_circuit = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
dj_circuit_before_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Apply H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_before_oracle.h(qubit)
# Put output qubit in state |->
dj_circuit_before_oracle.x(num_of_qubits - 1)
dj_circuit_before_oracle.h(num_of_qubits - 1)
dj_circuit += dj_circuit_before_oracle
# Add oracle
dj_circuit += secret_number_oracle
dj_circuit_after_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Repeat H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_after_oracle.h(qubit)
dj_circuit_after_oracle.barrier()
# Measure
for i in range(num_of_qubits - 1):
dj_circuit_after_oracle.measure(i, i)
dj_circuit += dj_circuit_after_oracle
if not eval_mode:
print("Circuit before the oracle\n")
print(QuantumCircuit.draw(dj_circuit_before_oracle))
print("Circuit after the oracle\n")
print(QuantumCircuit.draw(dj_circuit_after_oracle))
print(dj_circuit)
return dj_circuit
|
https://github.com/ritamsarmah/cs239
|
ritamsarmah
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 19 19:13:26 2023
@author: abdullahalshihry
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 18 19:15:12 2023
@author: abdullahalshihry
"""
import qiskit as qs
import qiskit.visualization as qv
import random
import qiskit.circuit as qf
def Deutsch_Jozsa(circuit):
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qc.x(qr[4])
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.h(qr[4])
qc.barrier(range(5))
qc = qc.compose(circuit)
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.barrier(range(5))
qc.measure(0,0)
qc.measure(1,1)
qc.measure(2,2)
qc.measure(3,3)
job1 = qs.execute(qc, qs.Aer.get_backend('aer_simulator'), shots = 1024)
output1 = job1.result().get_counts()
print(output1)
qc.draw('mpl')
def Oracle():
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qq = qs.QuantumCircuit(5,name='Uf')
v = random.randint(1, 2)
if v == 1:
qc.cx(0,4)
qc.cx(1,4)
qc.cx(2,4)
qc.cx(3,4)
print('Balanced (1)')
elif v == 2:
qq.i(qr[0])
qq.i(qr[1])
qq.i(qr[2])
qq.i(qr[3])
print('Constant (0)')
qq =qq.to_gate()
qc.append(qq,[0,1,2,3,4])
return qc
Deutsch_Jozsa(Oracle())
|
https://github.com/ritamsarmah/cs239
|
ritamsarmah
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/ritamsarmah/cs239
|
ritamsarmah
|
"""Qiskit code for running Simon's algorithm on quantum hardware for 2 qubits and b = '11' """
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
#set b equal to '11'
b = '11'
#1) initialize qubits
n = 2
simon_circuit_2 = QuantumCircuit(n*2, n)
#2) Apply Hadamard gates before querying the oracle
simon_circuit_2.h(range(n))
#3) Query oracle
simon_circuit_2 += simon_oracle(b)
#5) Apply Hadamard gates to the input register
simon_circuit_2.h(range(n))
#3) and 6) Measure qubits
simon_circuit_2.measure(range(n), range(n))
# Load saved IBMQ accounts and get the least busy backend device
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= n and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Execute and monitor the job
from qiskit.tools.monitor import job_monitor
shots = 1024
job = execute(simon_circuit_2, backend=backend, shots=shots, optimization_level=3)
job_monitor(job, interval = 2)
# Get results and plot counts
device_counts = job.result().get_counts()
plot_histogram(device_counts)
#additionally, function for calculating dot product of results
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
print('b = ' + b)
for z in device_counts:
print( '{}.{} = {} (mod 2) ({:.1f}%)'.format(b, z, bdotz(b,z), device_counts[z]*100/shots))
#the most significant results are those for which b dot z=0(mod 2).
'''b = 11
11.00 = 0 (mod 2) (45.0%)
11.01 = 1 (mod 2) (6.2%)
11.10 = 1 (mod 2) (6.4%)
11.11 = 0 (mod 2) (42.4%)'''
|
https://github.com/a24l/Quantum-Computations-and-Algorithms
|
a24l
|
import numpy as np
#import matplotlib as plt
import random
from matplotlib import pyplot as plt
# Importing standard Qiskit libraries
from qiskit import *
from qiskit.tools import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.visualization import plot_histogram
from qiskit import IBMQ
# IBMQ.save_account(TOKEN)
IBMQ.load_account() # Load account from disk
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
provider.backends()
#Load the necessary backend (unitary simulator)
backend = Aer.get_backend('unitary_simulator')
#make the quantum circuit
qc = QuantumCircuit(1,1)
qc.x(0) # add the X gate
print(qc) #print the circuit
#send the job to the simulator to retrieve the unitary
job = execute(qc, backend, shots=1024)
result = job.result()
unitary = result.get_unitary(qc) #this gets the matrix of the unitary gate
print('X=\n',unitary) #print out the matrix of the X gate
#similary now use HZH
qc1 = QuantumCircuit(1,1)
qc1.h(0)
qc1.z(0)
qc1.h(0)
print(qc1)
#send the job to the simulator to retrieve the unitary
job = execute(qc1, backend, shots=1024)
result = job.result()
unitary = result.get_unitary(qc1, decimals=2) #this gets the matrix of the unitary gate
print('thus HZH=X=\n',unitary) #print out the matrix of the HZH gate
#similary now use CNOT gate (with control at q_0 and target at q_1 qubits respectively)
qc2 = QuantumCircuit(2,2)
qc2.cnot(0,1)
print(qc2)
#send the job to the simulator to retrieve the unitary
job = execute(qc2, backend, shots=1024)
result = job.result()
unitary = result.get_unitary(qc2, decimals=2) #this gets the matrix of the unitary gate
print('CNOT_01=\n',unitary) #print out the matrix of the CNOT_01 gate
#similary now use CNOT gate (with control at q_1 and target at q_0 qubits respectively) with Hadamard gate
#make the quantum circuit
qc3 = QuantumCircuit(2,2)
qc3.h(0)
qc3.h(1)
qc3.cnot(1,0)
qc3.h(0)
qc3.h(1)
print(qc3) #print the circuit
#send the job to the simulator to retrieve the unitary
job = execute(qc3, backend, shots=1024)
result = job.result()
unitary = result.get_unitary(qc3, decimals=2) #this gets the matrix of the unitary gate
print('equivalent CNOT_01=\n',unitary) #print out the matrix of the CNOT_01 gate equivalence
#similary now use SWAP gate
qc4 = QuantumCircuit(2,2)
qc4.swap(0,1)
print(qc4)
#send the job to the simulator to retrieve the unitary
job = execute(qc4, backend, shots=1024)
result = job.result()
unitary = result.get_unitary(qc4, decimals=2) #this gets the matrix of the unitary gate
print('SWAP=\n',unitary) #print out the matrix of the SWAP gate
#similary now use combination of CNOT gates to show SWAP equivalence
#make the quantum circuit
qc5 = QuantumCircuit(2,2)
qc5.cx(0,1)
qc5.cx(1,0)
qc5.cx(0,1)
print(qc5) #print the circuit
#send the job to the simulator to retrieve the unitary
job = execute(qc5, backend, shots=1024)
result = job.result()
unitary = result.get_unitary(qc5, decimals=2) #this gets the matrix of the unitary gate
print('equivalent SWAP=\n',unitary) #print out the matrix of the SWAP gate equivalence
#make the increment circuit
# define the required registers
p_1 = QuantumRegister(1, name='p1')
a_1 = QuantumRegister(1, name='a1')
p_2 = QuantumRegister(1, name='p2')
a_2 = QuantumRegister(1, name='a2')
p_3 = QuantumRegister(1, name='p3')
a_3 = QuantumRegister(1, name='a3')
p_4 = QuantumRegister(1, name='p4')
#inout the registers into the quantum circuit
incq = QuantumCircuit(p_1, a_1, p_2, a_2, p_3, a_3, p_4)
incq.cx(0,1)
incq.ccx(1,2,3)
incq.ccx(3,4,5)
incq.cx(5,6)
incq.ccx(3,4,5)
incq.cx(3,4)
incq.ccx(1,2,3)
incq.cx(1,2)
incq.cx(0,1)
incq.x(0)
#draw the incrementer circuit
incq.draw()
inc_gate = incq.to_gate(label=' (inc)') #turn the above increment circuit to a gate
#make a new circuit
new_inc = QuantumCircuit(7)
new_inc.append(inc_gate, [0,1,2,3,4,5,6]) #append the gate in to the circuit
new_inc.draw() #increment gate is embedded in to the circuit now
# Define the required registers
p_1 = QuantumRegister(1, name='p1')
a_1 = QuantumRegister(1, name='a1')
p_2 = QuantumRegister(1, name='p2')
a_2 = QuantumRegister(1, name='a2')
p_3 = QuantumRegister(1, name='p3')
a_3 = QuantumRegister(1, name='a3')
p_4 = QuantumRegister(1, name='p4')
# Input the registers into the quantum circuit
decq = QuantumCircuit(p_1, a_1, p_2, a_2, p_3, a_3, p_4)
# Apply the operations in reverse order to "uncompute" the increment circuit
decq.x(0)
decq.cx(0, 1)
decq.cx(1, 2)
decq.ccx(1, 2, 3)
decq.cx(3, 4)
decq.ccx(3, 4, 5)
decq.cx(5, 6)
decq.ccx(3,4,5)
decq.ccx(1, 2, 3)
decq.cx(0,1)
# Draw the decrementer circuit
decq.draw()
dec_gate = decq.to_gate(label=' (dec)') #turn the above decrementer circuit to a gate
#make a new circuit
new_dec = QuantumCircuit(7)
new_dec.append(dec_gate, [0,1,2,3,4,5,6]) #append the gate in to the circuit
new_dec.draw() #decrement gate is embedded into the circuit now
#make the controlled L gate first
L = new_inc.to_gate(label= ' (c-inc)').control(1,ctrl_state='0')
#make the controlled R gate
R = new_dec.to_gate(label= ' (c-dec)').control(1)
#design the circuit to hold the above to gates and make a basic walker (condition-shift)
shift= QuantumCircuit(8)
shift.append(L, [0,1,2,3,4,5,6,7]) #input the L gate
#shift.x(0)
shift.append(R, [0,1,2,3,4,5,6,7]) #input the R gate
shift.draw('mpl')
#make the shift operator gate by converting the above inc-dec circuit to gate
shift_gate = shift.to_gate( label= ' S = shift operator')
#design the step circuit with coin
shift_op = QuantumCircuit(8)
shift_op.h(0) #this is the coin
shift_op.append(shift_gate, [0,1,2,3,4,5,6,7]) #append the shift gate
shift_op.draw('mpl') #the step circuit is ready
#convert the step circuit to gate
step_gate = shift_op.to_gate(label='step_gate')
#design our first step circuit for walk
step_op = QuantumCircuit(8)
step_op.append(step_gate,[0,1,2,3,4,5,6,7])
step_op.draw() #walk-step operator gate is now ready
#prepare the random walk step circuit
qWalk = QuantumCircuit(8,4)
#inout the above initial state|13>
qWalk.x(1)
qWalk.x(3)
n=5 # performs number of steps for quantum walk
for i in range(n):
qWalk.append(step_gate,[0,1,2,3,4,5,6,7]) #append the step gate for number of desired walks
#measure the p-qubits only
qWalk.measure(1,0)
qWalk.measure(3,1)
qWalk.measure(5,2)
qWalk.measure(7,3)
#QRW is now ready
qWalk.draw()
#make the measurement of the above circuit
simulator = Aer.get_backend('aer_simulator')
result = execute(qWalk, backend=simulator, shots=2048).result()
bit_count = result.get_counts()
print("binary counts", bit_count) #print the counts
bit_list = list(bit_count.keys()) # get the keys of the binary dictionary
count_list= list(bit_count.values()) # get the values of the binary dictionary
#print(count_list)
decimal_list = [] #make an empty decimal list to store the values of decimal count
for binary_string in bit_list:
decimal = int(binary_string, 2) # Convert binary string to decimal
decimal_list.append(decimal) # insert the decimal values to decimal_list
print("Decimal list:", decimal_list)
dec_string_list = [str(decimal) for decimal in decimal_list]
#print(dec_string_list)
dec_count = dict(zip(dec_string_list,count_list)) #make the dictionary for decimal count
print("decimal counts", dec_count)
#plot the measurement
plot_histogram(dec_count, color='midnightblue', title='plot for QRW circuit for shots =2048', figsize = (12,8))
#transpiler to decompose the circuit
basis = ['h','cx','rz'] # use the basis gates as given
result = transpile(step_op,basis_gates = basis)
print(result) #transpiled circuit
# define a particular random walk
def randomwalk1D(n):
x, y = 0, 3 #start with the initial state
# Generate the time points [1, 2, 3, ... , n]
timepoints = np.arange(n + 1)
positions = [y]
directions = ["UP", "DOWN"]
for i in range(1, n + 1):
# Randomly select either UP or DOWN
step = random.choice(directions)
# Move the object up or down
if step == "UP":
y += 1
elif step == "DOWN":
y -= 1
# Keep track of the positions
positions.append(y)
final = y
return final
n = 1000 #choose repititions
positions = np.zeros(n) #create a position space for storing our walk positions
walkstep = 5 #choose the number of random walk steps
for i in range(n):
positions[i] = randomwalk1D(walkstep)
#print(positions)
# Plotting
unique, counts = np.unique(positions, return_counts=True) # generates - bit-string, counts
unique[0]= 14
#convert the integer to string format for plotting later
points = list(map(str, unique.astype(int)))
#print(points)
#lists the counts of corresponsing bit strings
plot = dict(zip(points, counts))
print(plot)
#plot_histogram(plot)
legend = ['QRW', 'Classical']
plot_histogram([dec_count, plot], legend=legend, color=['crimson','midnightblue'],
title="QRW vs Classical random walk comparison, shots = 1000", figsize = (12,8))
oracle = QuantumCircuit(4)
oracle.cx(0,3)
oracle.cx(2,3)
oracle.draw()
bv = QuantumCircuit(4,3) #make the quantum Circuit
#input the Hadamards
bv.x(3)
for i in range(4):
bv.h(i)
bv.barrier()
#input the oracle from the avove cell
bv.cx(0,3)
bv.cx(2,3)
bv.barrier()
#complete it with Hadamard
for i in range(3):
bv.h(i)
bv.barrier()
#make the measurement
for i in range(3):
bv.measure(i,i)
bv.draw()
#for plotting: choose a required simulator
simulator = Aer.get_backend("qasm_simulator")
result = execute(bv, backend = simulator, shots = 1000).result() #execute the circuit to get measurements
counts = result.get_counts() #get the counts for each measurement
print(counts)
plot_histogram(counts, color='midnightblue', title='B-V Algorithm for secret string a ',figsize = (12,8)) #plot the histogram
def decimalToBinary(n):
''' converts a decimal interger to binary '''
return "{0:b}".format(int(n))
#ask to choose a decimal input
a_deci = int(input('Choose a number between 0 to 7 :'))
# 3bit binary string equivalent
a = decimalToBinary(a_deci)
print(a) #converts the decimal string to binary bits
#make the B-V circuit
bv_circ = QuantumCircuit(len(a)+1,len(a))
#first insert all the hadamards
bv_circ.h(range(len(a)))
bv_circ.x(len(a))
bv_circ.h(len(a))
bv_circ.barrier()
#make the oracle
for i, query in enumerate(reversed(a)): #cause qiskit uses a reverse ordering LSB-MSB
if query == "1":
bv_circ.cx(i, len(a))
bv_circ.barrier()
#again insert the hadamards
bv_circ.h(range(len(a)))
bv_circ.barrier()
#measure the circuit
bv_circ.measure(range(len(a)),range(len(a)))
bv_circ.draw("mpl")
#follow rthe similar procedure from the above cells for measurement plotting
simulator = Aer.get_backend("qasm_simulator")
result = execute(bv_circ, backend = simulator, shots = 1000).result() #run the circuit
counts = result.get_counts() # get the counts
print(counts)
plot_histogram(counts, color='midnightblue', title='B-V Algorithm for a chosen string ',figsize = (12,8)) #plot Histogram
circuit = QuantumCircuit(4)
circuit.cx(1,2)
circuit.cx(0,1)
circuit.h(2)
circuit.cx(0,3)
circuit.measure_all()
circuit.draw()
#make the measurement of the above circuit
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend=simulator, shots=1000).result() #run the circuit
counts_old = result.get_counts() # get the counts
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts_old, color='midnightblue', title='Measurement plot for circuit 2.4a) ',figsize = (12,8))
#transpiler to decompose the circuit
result = transpile(circuit, basis_gates=['h', 'cz'], optimization_level=3)
result.draw(output='mpl') #draw the circuit
#making the transpiled Circuit
#insert all the gates with reference to the transpiled circuit and build it.
circuit1 = QuantumCircuit(4)
circuit1.h(2)
circuit1.h(3)
circuit1.cz(1,2)
circuit1.h(1)
circuit1.cz(0,1)
circuit1.h(1)
circuit1.cz(0,3)
circuit1.h(3)
print('the transpiled circuit \n')
circuit1.measure_all()
circuit1.draw()
#make the measurement of the transpiled circuit
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit1, backend=simulator, shots=1000).result()
counts_new = result.get_counts()
legend = ['old', 'new (transpiled)']
plot_histogram([counts_old, counts_new], legend=legend, color=['crimson','midnightblue'],
title="Measurement comparison for old vs transpiled circuit, shots =1000", figsize = (12,8))
basis_gates = ["cx", "id", "rz", "sx", "x"]
adjacency_matrix = [[0,1],[1,0],[1,2],[2,1],[1,3],[3,1],[3,5],[5,3],[4,5],[5,4],[5,6],[6,5]]
result = transpile(circuit, basis_gates = basis_gates, coupling_map = adjacency_matrix)
result.draw('mpl')
from qiskit.providers.fake_provider import FakeMontrealV2 #import the fakebackends to get the topology of 'montreal'
backend = FakeMontrealV2()
new_circuit = transpile(circuit, backend=backend) #transpile
new_circuit.draw()
|
https://github.com/adlantz/QiskitSG
|
adlantz
|
# initialization
import itertools as it
import os
from typing import List
# importing Qiskit
from qiskit import (
Aer,
QuantumCircuit,
ClassicalRegister,
QuantumRegister,
transpile,
)
# import basic plot tools
from qiskit.visualization import plot_histogram
import pprint
LOOP_DICT = {3: 6, 4: 6, 5: 24}
def main():
# Get number of spins
while True:
N = int(input("Number of spins/qubits: "))
if N in LOOP_DICT:
break
print(
f"Unable to calculate for this size. Possible sizes: {list(LOOP_DICT.keys())}"
)
bond_list = bond_list_maker(N)
num_of_bonds = len(bond_list)
# Build requisite quantum and classical registers
spin_qubits = QuantumRegister(N, name="spin")
bond_qubits = QuantumRegister(num_of_bonds, name="bond")
multi_control_qubit = QuantumRegister(1, name="multi")
cbits = ClassicalRegister(num_of_bonds, name="cbit")
qc = QuantumCircuit(spin_qubits, bond_qubits, multi_control_qubit, cbits)
# Initialize multi control qubit to |-> state
qc.x(multi_control_qubit)
qc.h(multi_control_qubit)
qc.barrier() # for visual separation
# Initialise spin and bond qubits in state |++...+> (equal superposition)
qc.h(spin_qubits)
qc.h(bond_qubits)
qc.barrier()
# We don't know how many solutions there are so we can't calculate the optimal number of loops
# TODO: Implement quantum counting to find number of solutions
# Until we implement the above, we just use the LOOP_DICT dictionary I made from trial and error
loop_number = LOOP_DICT[N]
for _ in range(loop_number):
# Add the oracle - this adds a negative phase only to solutions
SG_oracle(qc, bond_list, bond_qubits, multi_control_qubit)
qc.barrier()
# Add the diffuser, this "reflects" the state vector around the equal superposition vector
# We make this a gate for legibility
qc.append(diffuser(num_of_bonds), bond_qubits)
# print(qc.draw())
# Measure the variable qubits
# qc.measure(bond_qubits, cbits)
# Print/Save circuit interface
while True:
prntqc = input("Print Circuit? (y/n)")
if prntqc == "y" or prntqc == "yes":
print(qc.draw())
break
elif prntqc.lower() in ("n", "no"):
break
else:
print("invalid input")
while True:
sveqc = input("Save circuit as png? (y/n)")
if sveqc == "y" or sveqc == "yes":
print("saving to " + str(os.getcwd()))
qc.draw(output="mpl", filename="N" + str(N) + "_frust_qc.png", style="iqp")
break
elif sveqc.lower() in ("n", "no"):
break
else:
print("invalid input")
print("Simulating quantum circuit...")
# Send circuit to backend to get exact mathematical state of circuit before measuring
backend = Aer.get_backend("aer_simulator_statevector")
qc.save_statevector()
result = backend.run(transpile(qc, backend)).result()
final_state_vector = result.get_statevector(qc)
# Get probabilities of each bond + spin state combo
probabilities_dict = final_state_vector.probabilities_dict(
[i for i in range(N + num_of_bonds)]
)
# Consolidate most probable bonds and their solution spin states
output_obj = {}
for key in probabilities_dict:
if probabilities_dict[key] > 0.0001:
bond_state = key[:num_of_bonds]
spin_sate = key[0 - N :]
if bond_state not in output_obj:
output_obj[bond_state] = {
"probability": probabilities_dict[key],
"spin_states": [spin_sate],
}
else:
output_obj[bond_state]["probability"] += probabilities_dict[key]
output_obj[bond_state]["spin_states"].append(spin_sate)
print(
"Here are the bond states with no frustration and the spin states that solve them"
)
pprint.PrettyPrinter(indent=4).pprint(output_obj)
# Give the option to visualize bond configurations using SGViz.py
while True:
bond_config = input(
f"Input bond configuration from keys of object above (Example: {list(output_obj.keys())[0]}) to visualize (q to to quit): "
)
if bond_config.lower() in ("q", "quit"):
print("Goodbye!")
break
if bond_config in output_obj:
os.system("python3 SGViz.py -loadBC -BC " + bond_config + " -N " + str(N))
else:
print("not a valid input")
def bond_list_maker(N: int) -> List[List[int]]:
# Given a set of spins, an ordered list of the form [ [a,b], [a,c], ...] where
# the ith element is a list of the two spins connected by the ith bond
return [list(c) for c in it.combinations([i for i in range(N)], 2)]
def diffuser(nqubits: int):
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.mcx(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 the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "$U_s$"
return U_s
def XOR(qc, a, b, output):
qc.cx(a, output)
qc.cx(b, output)
qc.barrier()
def SG_oracle(
qc: QuantumCircuit,
bond_list: List[List[int]],
bond_qubits: QuantumRegister,
multi_control_qubit: QuantumRegister,
):
# Add an XOR to each bond qubit such that if bond_i connects spin_a
# and spin_b, the bond_i qubit will become spin_a XOR spin_b
for i, clause in enumerate(bond_list):
XOR(qc, clause[0], clause[1], bond_qubits[i])
# Apply X gate to 'multicontrol' qubit if all clauses are satisfied
# This adds a negative phase to solution items only
qc.mcx(bond_qubits, multi_control_qubit)
# Add the exact same XOR gates to "uncompute" and return bonds to original state
for i, clause in enumerate(bond_list):
XOR(qc, clause[0], clause[1], bond_qubits[i])
i += 1
if __name__ == "__main__":
main()
|
https://github.com/antonioscardace/Practical-Quantum-ESM
|
antonioscardace
|
# Practical Implementation of a Quantum String Matching Algorithm
# S. Faro, F.P. Marino, and A. Scardace
# QUASAR 2024
%%capture
!pip install ibm-cloud-sdk-core==3.18.2
!pip install qiskit==0.45.1
!pip install qiskit-aer==0.13.1
!pip install pylatexenc==2.10
from numpy import log2, sqrt
from numpy import pi
from qiskit.tools.visualization import plot_histogram
from qiskit.circuit.gate import Gate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer
from qiskit import transpile
def run(circuit: QuantumCircuit, shots: int) -> dict:
simulator = Aer.get_backend('aer_simulator')
compiled_circuit = transpile(circuit, simulator)
job = simulator.run(compiled_circuit, shots=shots)
result = job.result()
return result.get_counts(compiled_circuit)
def init_register(bin_str: str) -> QuantumCircuit:
data_qr = QuantumRegister(len(bin_str), 'data')
qc = QuantumCircuit(data_qr)
for i, bit in enumerate(bin_str):
if bit == '1':
qc.x(data_qr[i])
return qc
classical_value = '1001'
init_register(classical_value).draw(fold=255)
def rot(n: int, s: int) -> QuantumCircuit:
y_qr = QuantumRegister(n, 'y')
qc = QuantumCircuit(y_qr, name='ROT_' + str(s))
for i in range(1, (int(log2(n)) - int(log2(s)) + 2)):
for j in range(int(n / (s * (2**i)))):
for q in range(j * s * (2**i), s * (j*2 ** i+1)):
qc.swap(n - 1 - (q+s), n - 1 - (q+2 ** (i-1) * s + s))
return qc
num_qubits = 8
shift_value = 2
rot(num_qubits, shift_value).draw(fold=255)
def rot_gate(n: int, s: int) -> Gate:
rot_circuit = rot(n, s)
return rot_circuit.to_gate(label='ROT_' + str(s))
def parameterized_rot(n: int) -> QuantumCircuit:
j_qr = QuantumRegister(int(log2(n)), 'j')
y_qr = QuantumRegister(n, 'y')
qc = QuantumCircuit(j_qr, y_qr)
for i in range(int(log2(n))):
crot = rot_gate(n, 2**i).control(1)
qc = qc.compose(crot, [j_qr[i]] + y_qr[:])
return qc
num_qubits = 8
parameterized_rot(num_qubits).draw(fold=255)
text = '10110001'
text_length = len(text)
shift_qr = QuantumRegister(int(log2(text_length)), 'shift')
text_qr = QuantumRegister(text_length, 'text')
output_cr = ClassicalRegister(text_length, 'output_classic')
circ = QuantumCircuit(shift_qr, text_qr, output_cr)
circ.h(shift_qr)
circ.append(init_register(text), text_qr[:])
circ.append(parameterized_rot(text_length), shift_qr[:] + text_qr[:])
circ.measure(text_qr, output_cr)
counts = run(circ, 100)
plot_histogram(counts, title='Rotate ' + text + ' Leftward in Superposition')
def match(m: int) -> QuantumCircuit:
x_qr = QuantumRegister(m, 'x')
y_qr = QuantumRegister(m, 'y')
out_qr = QuantumRegister(1, 'out')
qc = QuantumCircuit(x_qr, y_qr, out_qr)
for i in range(m):
qc.cx(x_qr[i], y_qr[i])
qc.x(y_qr[i])
qc.mcx(y_qr[:], out_qr)
for i in reversed(range(m)):
qc.x(y_qr[i])
qc.cx(x_qr[i], y_qr[i])
return qc
pattern_length = 4
match(pattern_length).draw(fold=255)
text = '1011'
text_length = len(text)
pattern_qr = QuantumRegister(text_length, 'pattern')
text_qr = QuantumRegister(text_length, 'text')
output_qr = QuantumRegister(1, 'output')
output_cr = ClassicalRegister(text_length + 1, 'output_classic')
circ = QuantumCircuit(pattern_qr, text_qr, output_qr, output_cr)
circ.h(pattern_qr)
circ.append(init_register(text), text_qr[:])
circ.append(match(text_length), pattern_qr[:] + text_qr[:] + output_qr[:])
circ.measure(pattern_qr, output_cr[:-1])
circ.measure(output_qr, output_cr[-1])
counts = run(circ, 100)
plot_histogram(counts, title='Matching ' + text)
def match_gate(m: int) -> Gate:
match_circuit = match(m)
return match_circuit.to_gate(label='MATCH')
def esm(m: int, n: int) -> QuantumCircuit:
j_qr = QuantumRegister(int(log2(n)), 'j')
x_qr = QuantumRegister(m, 'x')
y_qr = QuantumRegister(n, 'y')
out = QuantumRegister(1, 'out')
qc = QuantumCircuit(
j_qr,
x_qr,
y_qr,
out
)
qc = qc.compose(parameterized_rot(n), j_qr[:] + y_qr[:])
qc = qc.compose(match_gate(m), x_qr[:] + y_qr[:m] + out[:])
qc = qc.compose(parameterized_rot(n).inverse(), j_qr[:] + y_qr[:])
return qc
pattern_length = 2
text_length = 4
esm(pattern_length, text_length).draw(fold=255)
def esm_oracle(m: int, n: int):
esm_circuit = esm(m, n)
return esm_circuit.to_gate(label='ESMO')
def diffuser(n: int) -> Gate:
qc = QuantumCircuit(n)
qc.h(range(n))
qc.x(range(n))
qc.h(n-1)
qc.mcx(list(range(n-1)), n-1)
qc.h(n-1)
qc.x(range(n))
qc.h(range(n))
return qc.to_gate(label='DIFF')
def grover(esmo: Gate, t: int, x: str, y: str) -> QuantumCircuit:
n = len(y)
m = len(x)
logn = int(log2(n))
num_iterations = int(pi/4 * sqrt(n/t))
j_qr = QuantumRegister(logn, 'j')
x_qr = QuantumRegister(m, 'x')
y_qr = QuantumRegister(n, 'y')
out_qr = QuantumRegister(2, 'out')
out_cr = ClassicalRegister(logn+1, 'c')
qc = QuantumCircuit(j_qr, x_qr, y_qr, out_qr, out_cr)
qc.h(j_qr)
qc.x(out_qr[0])
qc.h(out_qr[0])
qc = qc.compose(init_register(x), x_qr[:])
qc = qc.compose(init_register(y), y_qr[:])
for _ in range(num_iterations):
qc = qc.compose(esmo)
qc = qc.compose(diffuser(logn))
qc.measure(j_qr, out_cr[:-1])
qc = qc.compose(esmo, j_qr[:] + x_qr[:] + y_qr[:] + [out_qr[1]])
qc.measure(out_qr[1], out_cr[-1])
return qc
x = '11'
y = '10101100'
esmo = esm_oracle(len(x), len(y))
grover(esmo, 1, x, y).draw(fold=255)
x = '00'
y = '01010101'
esmo = esm_oracle(len(x), len(y))
counts = run(grover(esmo, 1, x, y), 100)
plot_histogram(counts, title=f'Search for {x} in {y} - 0 occurrence(s)')
x = '00'
y = '11010011'
esmo = esm_oracle(len(x), len(y))
counts = run(grover(esmo, 1, x, y), 100)
plot_histogram(counts, title=f'Search for {x} in {y} - 1 occurrence(s)')
x = '00'
y = '00111001'
esmo = esm_oracle(len(x), len(y))
counts = run(grover(esmo, 2, x, y), 100)
plot_histogram(counts, title=f'Search for {x} in {y} - 2 occurrence(s)')
def search(x: str, y: str) -> int:
m = len(x)
n = len(y)
esmo = esm_oracle(m, n)
for t in range(1, int(n/2) + 1):
print('Trying with t =', t)
results = run(grover(esmo, t, x, y), 1)
results = list(results.keys())[0]
outcome = int(results[0])
position = int(results[1:], 2)
if outcome: return position
else: print('Pattern not found in position', position)
return -1
x = input('Enter the value of x: ')
y = input('Enter the value of y: ')
if len(x) > len(y):
raise Exception('The length of x must be shorter than the length of y.')
if x.count('0') + x.count('1') < len(x):
raise Exception('The pattern must be a binary string.')
if y.count('0') + y.count('1') < len(y):
raise Exception('The text must be a binary string.')
print('')
position = search(x, y)
if position >= 0: print('Pattern occurrence found in position', str(position))
else: print('Pattern occurrence not found.')
|
https://github.com/AasthaShayla/Qiskit-Teleportation
|
AasthaShayla
|
from qiskit import*
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
qc=QuantumCircuit(1,1)
from qiskit.tools.visualization import plot_bloch_multivector
qc.x(0)
sim=Aer.get_backend('statevector_simulator')
result=execute(qc,backend=sim).result()
sv=result.get_statevector()
print(sv)
qc.draw()
plot_bloch_multivector(sv)
qc.measure(range(1),range(1))
backend=Aer.get_backend('qasm_simulator')
result=execute(qc,backend=backend).result()
count=result.get_counts()
from qiskit.tools.visualization import plot_histogram
plot_histogram(count)
s=Aer.get_backend('unitary_simulator')
result=execute(qc,backend=s).result()
unitary=result.get_unitary()
print(unitary)
|
https://github.com/AasthaShayla/Qiskit-Teleportation
|
AasthaShayla
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/AasthaShayla/Qiskit-Teleportation
|
AasthaShayla
|
from qiskit import *
IBMQ.load_account()
cr=ClassicalRegister(2)
qr=QuantumRegister(2)
circuit=QuantumCircuit(qr,cr)
%matplotlib inline
circuit.draw()
circuit.h(qr[0])
circuit.draw(output='mpl')
circuit.cx(qr[0],qr[1])
circuit.draw(output='mpl')
circuit.measure(qr,cr)
circuit.draw()
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))
from qiskit.visualization import plot_state_qsphere
from qiskit.visualization import plot_bloch_multivector
statevector_simulator = Aer.get_backend('statevector_simulator')
result=execute(circuit,statevector_simulator).result()
statevector_results=result.get_statevector(circuit)
plot_bloch_multivector(statevector_results)
plot_state_qsphere(statevector_results)
|
https://github.com/AasthaShayla/Qiskit-Teleportation
|
AasthaShayla
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import IBMQ, Aer, transpile, assemble
from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex
from qiskit.extensions import Initialize
from qiskit.ignis.verification import marginal_counts
from qiskit.quantum_info import random_statevector
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
## SETUP
# Protocol uses 3 qubits and 2 classical bits in 2 different registers
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical bits
crx = ClassicalRegister(1, name="crx") # in 2 different registers
teleportation_circuit = QuantumCircuit(qr, crz, crx)
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a,b)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, psi, a):
qc.cx(psi, a)
qc.h(psi)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
## STEP 1
create_bell_pair(teleportation_circuit, 1, 2)
## STEP 2
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
"""Measures qubits a & b and 'sends' the results to Bob"""
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
measure_and_send(teleportation_circuit, 0 ,1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1) # Apply gates if the registers
qc.z(qubit).c_if(crz, 1) # are in the state '1'
qr = QuantumRegister(3, name="q")
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx")
teleportation_circuit = QuantumCircuit(qr, crz, crx)
## STEP 1
create_bell_pair(teleportation_circuit, 1, 2)
## STEP 2
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
## STEP 3
measure_and_send(teleportation_circuit, 0, 1)
## STEP 4
teleportation_circuit.barrier() # Use barrier to separate steps
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
# Create random 1-qubit state
psi = random_statevector(2)
# Display it nicely
display(array_to_latex(psi, prefix="|\\psi\\rangle ="))
# Show it on a Bloch sphere
plot_bloch_multivector(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
## SETUP
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical registers
crx = ClassicalRegister(1, name="crx")
qc = QuantumCircuit(qr, crz, crx)
## STEP 0
# First, let's initialize Alice's q0
qc.append(init_gate, [0])
qc.barrier()
## STEP 1
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
## STEP 2
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
## STEP 3
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
## STEP 4
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
# Display the circuit
qc.draw()
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(out_vector)
|
https://github.com/AasthaShayla/Qiskit-Teleportation
|
AasthaShayla
|
from qiskit import *
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
circuit = QuantumCircuit(3,3)
%matplotlib inline
circuit.x(0)
circuit.barrier()
circuit.h(1)
circuit.cx(1,2)
circuit.barrier()
circuit.cx(0,1)
circuit.h(0)
circuit.barrier()
circuit.measure([0, 1], [0, 1])
circuit.barrier()
circuit.cx(1, 2)
circuit.cz(0, 2)
circuit.measure([2], [2])
circuit.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend=simulator, shots=1024).result()
from qiskit.visualization import plot_histogram
plot_histogram(result.get_counts(circuit))
print(circuit.qasm())
statevector_simulator = Aer.get_backend('statevector_simulator')
result=execute(circuit,statevector_simulator).result()
statevector_results=result.get_statevector(circuit)
plot_bloch_multivector(statevector_results)
plot_state_qsphere(statevector_results)
|
https://github.com/AasthaShayla/Qiskit-Teleportation
|
AasthaShayla
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit,execute, transpile, Aer, IBMQ
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.visualization import plot_state_qsphere
from qiskit.visualization import plot_bloch_multivector
qc=QuantumCircuit(1)
statevector_simulator = Aer.get_backend('statevector_simulator')
result=execute(qc,statevector_simulator).result()
statevector_results=result.get_statevector(qc)
plot_bloch_multivector(statevector_results)
plot_state_qsphere(statevector_results)
qc.x(0)
result=execute(qc,statevector_simulator).result()
statevector_results=result.get_statevector(qc)
plot_bloch_multivector(statevector_results)
plot_state_qsphere(statevector_results)
qc.h(0)
result=execute(qc,statevector_simulator).result()
statevector_results=result.get_statevector(qc)
plot_bloch_multivector(statevector_results)
plot_state_qsphere(statevector_results)
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import*
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
import matplotlib.pyplot as plt
quantum_register = QuantumRegister(2) # Linhas do circuito / numeros de Qbit no circuito
""" Para medir, em mecanica quântica, ao medir um Qbit nós destruimos a informação daquele estado
e armazenamos ela em um bit clássico """
classic_register = ClassicalRegister(2)
first_circuit = QuantumCircuit(quantum_register, classic_register) # Constrói o circuito
first_circuit.draw(output = 'mpl') # Desenha o circuito, funciona no app da IBM
first_circuit.h(quantum_register[0]) # Aplicando a primeira gate no primeira linha, gate hadarmat
# Aplicando a porta CNOT
###
first_circuit.draw(output = 'mpl')
###
first_circuit.cx(quantum_register[0], quantum_register[1]) #CNOT faz operação tensorial entre o Qbit
#de controle na linha zero, e o outro é o Qbit alvo
###
first_circuit.draw(output = 'mpl')
###
first_circuit.measure(quantum_register, classic_register) # para extrair a medida
###
first_circuit.draw(output = 'mpl')
###
simulator = QasmSimulator() # Simulador que vai realizar os calculos para nós
result = execute(first_circuit, backend= simulator).result()
counts = result.get_counts(first_circuit)
first_circuit.draw(output='mpl')
plot_histogram(counts)
plt.ylabel(counts)
plt.show()
"""
IBMQ.load_account()
host = IBMQ.get_provider('ibm-q')
quantum_computer = host.get_backend('ibmq_belem')
result_qcomputer = execute(first_circuit, backend= quantum_computer)
job_monitor(result_qcomputer)
result = result_qcomputer.result()
plot_histogram(result.get_counts(first_circuit))
plt.ylabel(counts)
plt.show()
"""
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import*
from qiskit import circuit
import matplotlib.pyplot as plt
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.visualization import plot_bloch_multivector
qr = QuantumRegister(2) #Registrador quântico de 2bits
cr = ClassicalRegister(2) #vai ser utilizado para fazer medições
circuit = QuantumCircuit(qr,cr)
circuit.h(qr[0])
circuit.cx(qr[0],qr[1])
circuit.measure(qr,cr)
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator).result()
plot_histogram(result.get_counts(circuit))
plt.show()
simulator = Aer.get_backend('statevector_simulator')
result = execute(circuit, backend = simulator).result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import QuantumCircuit
from QCLG_lvl3.oracles.secret_number_oracle import SecretNUmberOracle
class BernsteinVazirani:
@classmethod
def bernstein_vazirani(cls, random_binary, eval_mode: bool) -> QuantumCircuit:
# Construct secret number oracle
secret_number_oracle = SecretNUmberOracle.create_secret_number_oracle(random_binary=random_binary, eval_mode=eval_mode)
num_of_qubits = secret_number_oracle.num_qubits
# Construct circuit according to the length of the number
dj_circuit = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
dj_circuit_before_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Apply H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_before_oracle.h(qubit)
# Put output qubit in state |->
dj_circuit_before_oracle.x(num_of_qubits - 1)
dj_circuit_before_oracle.h(num_of_qubits - 1)
dj_circuit += dj_circuit_before_oracle
# Add oracle
dj_circuit += secret_number_oracle
dj_circuit_after_oracle = QuantumCircuit(num_of_qubits, num_of_qubits - 1)
# Repeat H-gates
for qubit in range(num_of_qubits - 1):
dj_circuit_after_oracle.h(qubit)
dj_circuit_after_oracle.barrier()
# Measure
for i in range(num_of_qubits - 1):
dj_circuit_after_oracle.measure(i, i)
dj_circuit += dj_circuit_after_oracle
if not eval_mode:
print("Circuit before the oracle\n")
print(QuantumCircuit.draw(dj_circuit_before_oracle))
print("Circuit after the oracle\n")
print(QuantumCircuit.draw(dj_circuit_after_oracle))
print(dj_circuit)
return dj_circuit
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import *
import matplotlib.pyplot as plt
from qiskit.circuit import QuantumCircuit
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
qc = QuantumCircuit(2,2)
# Bell Gate
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0,1)
bell.to_gate()
bell.name = 'Bell state'
# Measure Bell
measure = QuantumCircuit(2)
measure.cx(0,1)
measure.h(0)
measure.to_gate()
measure.name = 'Measure in Bell state'
qc.append(bell,[0,1])
qc.append(measure,[0,1])
qc.measure([0,1], [0,1])
bell.draw(output='mpl')
measure.draw(output='mpl')
qc.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator).result()
plot_histogram(result.get_counts(qc))
plt.show()
IBMQ.load_account()
host = IBMQ.get_provider('ibm-q')
quantum_computer = host.get_backend('ibmq_santiago')
result_qcomputer = execute(qc, backend= quantum_computer)
job_monitor(result_qcomputer)
result_qcomputer = result_qcomputer.result()
plot_histogram(result_qcomputer)
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit.providers.aer import QasmSimulator
from multiprocessing import Barrier
from qiskit import*
from qiskit import circuit
import matplotlib.pyplot as plt
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
circuit = QuantumCircuit(2,2)
circuit.h([0,1])
circuit.barrier()
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
result = execute(circuit, backend= QasmSimulator()).result()
counts = result.get_counts(circuit)
IBMQ.load_account()
host = IBMQ.get_provider('ibm-q')
quantum_computer = host.get_backend('ibmq_belem')
result_qcomputer = execute(circuit, backend= quantum_computer)
print(result_qcomputer.job_id())
job_monitor(result_qcomputer)
result = result_qcomputer.result()
plot_histogram(result.get_counts(circuit))
plt.ylabel(counts)
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
import qiskit.quantum_info as qi
from qiskit.circuit.library import FourierChecking
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
f = [0,0,0,0]
g = [1,1,1,-1]
circuit = FourierChecking(f=f, g=g)
circuit.draw(output='mpl')
zero = qi.Statevector.from_label('00')
sv = zero.evolve(circuit)
probs = sv.probabilities_dict()
plot_histogram(probs)
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit.providers.aer import QasmSimulator
from multiprocessing import Barrier
from qiskit import*
from qiskit import circuit
import matplotlib.pyplot as plt
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
circuit = QuantumCircuit(2)
circuit.cx(0,1)
circuit.draw(output='mpl')
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import *
import matplotlib.pyplot as plt
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import PhaseOracle
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
# Criando o circuito grover #
def reflection(n):
qc = QuantumCircuit(n)
qc.h(list(range(0,n)))
qc.x(list(range(0,n)))
# A porta Multi-controladora-Z
qc.h(n-1)
qc.mct(list(range(n-1)), n-1) # Multi-controladora toff
qc.h(n-1)
qc.x(list(range(0,n)))
qc.h(list(range(0,n)))
return qc
# Porta Oraculo
n = 4
expr = '(a & ~b & ~c) | (~a & ~b & d) | ~(a | d & c) & (a|~d |~c) | (a & b & ~c)'
oracle = PhaseOracle(expr)
oracle.to_gate()
# Porta de Grover
g = reflection(n)
g.to_gate()
g.name = 'G'
backend = Aer.get_backend('qasm_simulator')
grover_circuit = QuantumCircuit(n,n)
grover_circuit.h(list(range(0,n)))
grover_circuit.append(oracle, list(range(0,n)))
grover_circuit.append(g, list(range(0,n)))
grover_circuit.measure(list(range(0,n)),list(range(0,n)))
grover_circuit.draw(output='mpl')
oracle.draw(output='mpl')
g.draw(output='mpl')
job = execute(grover_circuit, backend, shots = 1024)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
plt.show()
IBMQ.load_account()
host = IBMQ.get_provider('ibm-q')
quantum_computer = host.get_backend('ibmq_lima')
result_qcomputer = execute(grover_circuit, backend= quantum_computer)
job_monitor(result_qcomputer)
result_qcomputer = result_qcomputer.result()
plot_histogram([result_qcomputer.get_counts(grover_circuit), counts], legend=["Qcumputer","simulated"], bar_labels=True)
plt.ylabel("probabilidades")
plt.xlabel("Possíveis Combinações")
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import *
import matplotlib.pyplot as plt
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from qiskit import IBMQ
from qiskit.ignis.mitigation.measurement import (complete_meas_cal, CompleteMeasFitter)
IBMQ.load_account()
nqbit = 3
circuit = QuantumCircuit(nqbit, nqbit)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(1,2)
circuit.measure(range(nqbit), range(nqbit))
simulator = Aer.get_backend('qasm_simulator')
sim_result = execute(circuit, backend= simulator, shots = 1024).result()
plot_histogram(sim_result.get_counts(circuit))
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
device = provider.get_backend('ibmq_lima')
job = execute(circuit, backend = device, shots = 1024)
print(job.job_id())
job_monitor(job)
device_result = job.result()
plot_histogram(device_result.get_counts(circuit))
cal_circuits,state_labels = complete_meas_cal(qr = circuit.qregs[0], circlabel = 'measerrormitigationcal')
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_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 = ['dispositivo , ruido', 'dispositivo, mitigado'])
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])
sim_counts = 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,sim_counts])
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import*
import matplotlib.pyplot as plt
from qiskit.extensions import Initialize
from qiskit.tools.visualization import plot_bloch_multivector
from qiskit_textbook.tools import random_state
circuit = QuantumCircuit(3,2)
psi = random_state(1)
plot_bloch_multivector(psi)
init_gate = Initialize(psi)
print(f'\psi = {psi}')
init_gate.label = 'Estado inicial'
circuit.append(init_gate, [0])
circuit.barrier()
circuit.h(1)
circuit.cx(1,2)
circuit.barrier()
circuit.cx(0,1)
circuit.h(0)
circuit.barrier()
circuit.measure([0,1], [0,1]) # fazer as medidas de q0 e q1 e armazenar nos bits 0 e 1
circuit.barrier()
circuit.cx(1,2)
circuit.cz(0,2)
circuit.draw(output ='mpl')
simulator = Aer.get_backend('qasm_simulator')
circuit.save_statevector()
result = simulator.run(circuit).result().get_statevector()
plot_bloch_multivector(result)
plt.show()
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import *
import matplotlib.pyplot as plt
from qiskit.tools.visualization import plot_histogram
secretnumber = '10000100001'
circuit = QuantumCircuit(len(secretnumber) + 1,len(secretnumber))
circuit.h(range(len(secretnumber)))
circuit.x(len(secretnumber))
circuit.h(len(secretnumber))
# circuit.draw(output ='mpl')
# plt.show()
circuit.barrier()
# circuit.draw(output ='mpl')
# plt.show()
for i in range(len(secretnumber)):
if secretnumber[i] == '1':
circuit.cx(len(secretnumber) - 1 - i, len(secretnumber))
# circuit.draw(output ='mpl')
# plt.show()
circuit.barrier()
circuit.h(range(len(secretnumber)))
# circuit.draw(output ='mpl')
# plt.show()
circuit.barrier()
circuit.measure(range(len(secretnumber)),range(len(secretnumber)))
circuit.draw(output ='mpl')
plt.show()
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit import *
from qiskit.tools.visualization import plot_bloch_multivector
import matplotlib.pyplot as plt
from qiskit.visualization.gate_map import plot_coupling_map, plot_gate_map
from qiskit.visualization.state_visualization import plot_bloch_vector, plot_state_city, plot_state_paulivec
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)
simulator2 = Aer.get_backend('unitary_simulator')
result = execute(circuit, backend= simulator2).result()
unitary = result.get_unitary()
print(unitary)
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
"""
Test Script
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
from src.clonk.backend_utils.topology_visualization import pretty_print
from src.clonk.backend_utils.mock_backends import FakeModular
pb = FakeModular(module_size=5, children=4, total_levels=2)
pretty_print(pb)
from qiskit.quantum_info.random import random_unitary
from qiskit import QuantumCircuit
from src.clonk.utils.riswap_gates.riswap import RiSwapGate
from src.clonk.utils.transpiler_passes.weyl_decompose import RootiSwapWeylDecomposition
from qiskit.transpiler.passes import CountOps
from qiskit.transpiler import PassManager
from tqdm import tqdm
N = 2000
basis_gate = RiSwapGate(0.5)
pm0 = PassManager()
pm0.append(RootiSwapWeylDecomposition(basis_gate=basis_gate))
pm0.append(CountOps())
res = 0
for _ in tqdm(range(N)):
qc = QuantumCircuit(2)
qc.append(random_unitary(dims=4), [0, 1])
pm0.run(qc)
res += pm0.property_set["count_ops"]["riswap"]
print("Haar score:", res / N)
from src.clonk.benchmark_suite.backend_suite_v3 import simple_backends_v3
print([backend.label for backend in simple_backends_v3])
from src.clonk.benchmark_suite.circuit_suite import circuits
q_size = 4
circuits["QAOA_Vanilla"].circuit_lambda(q_size).decompose().draw()
"""Example:"""
from src.clonk.benchmark_suite.main_plotting import benchmark, plot_wrap
for circuit_gen in circuits.values():
benchmark(
backends=simple_backends_v3,
circuit_generator=circuit_gen,
q_range=[4, 6, 8, 12, 14, 16],
continuously_save=1,
overwrite=0, # NOTE: turn this to 1 if you want to scrap the saved data and recollect a new batch
repeat=1,
)
# NOTE when plotting use motivation = 1 to plot SWAP counts, and motivation = 0 to plot gate durations
plot_wrap(simple_backends_v3, circuits.keys(), motivation=True, plot_average=True)
"""Fig 4"""
from src.clonk.benchmark_suite.backend_suite_v2 import motivation_backends
for circuit_gen in circuits.values():
benchmark(
backends=motivation_backends,
circuit_generator=circuit_gen,
q_range=motivation_backends[0].q_range,
continuously_save=True,
overwrite=False,
repeat=1,
)
plot_wrap(motivation_backends, circuits.keys(), motivation=True, plot_average=True)
"""Fig 10"""
from src.clonk.benchmark_suite.backend_suite_v2 import small_results_backends
for circuit_gen in circuits.values():
benchmark(
backends=small_results_backends,
circuit_generator=circuit_gen,
q_range=small_results_backends[0].q_range,
continuously_save=True,
overwrite=False,
repeat=1,
)
plot_wrap(small_results_backends, circuits.keys(), motivation=True, plot_average=True)
# """Fig 12"""
from src.clonk.benchmark_suite.backend_suite_v2 import results_backends
for circuit_gen in circuits.values():
benchmark(
backends=results_backends,
circuit_generator=circuit_gen,
q_range=results_backends[0].q_range,
continuously_save=True,
overwrite=False,
repeat=1,
)
plot_wrap(results_backends, circuits.keys(), motivation=True, plot_average=True)
"""Fig 13"""
from src.clonk.benchmark_suite.backend_suite_v2 import small_results_part2_backends
for circuit_gen in circuits.values():
benchmark(
backends=small_results_part2_backends,
circuit_generator=circuit_gen,
q_range=small_results_part2_backends[0].q_range,
continuously_save=True,
overwrite=False,
repeat=1,
)
plot_wrap(
small_results_part2_backends, circuits.keys(), motivation=False, plot_average=True
)
"""Fig 14"""
plot_wrap(results_backends, circuits.keys(), motivation=False, plot_average=True)
from src.clonk.benchmark_suite.backend_suite_v2 import small_results_part2_backendsv2
from qiskit.converters import circuit_to_dag
import numpy as np
ignore = ["u"]
for circuit_gen in circuits.values(): # [circuits['Quantum_Volume']]:
print(circuit_gen.label)
qc = circuit_gen.circuit_lambda(16)
for backend in small_results_part2_backendsv2:
print(backend.label)
c = backend.pass_manager.run(qc) # transpile :)
d = circuit_to_dag(c)
w = d.qubits # if use wires error bc returns classical bits
qubit_wire_counts = np.zeros(20)
for i, wi in enumerate(w):
for node in d.nodes_on_wire(wi, only_ops=True):
if node.name in ignore:
continue
# count the 2Q ops
if node.name in ["cx", "fSim", "riswap"]:
qubit_wire_counts[i] += 1
# print(qubit_wire_counts)
print(sum(qubit_wire_counts))
from src.clonk.benchmark_suite.nuop_script import create_plot2, collect_random2q_data
N = 20
base_fidelity_list = [0.97, 0.98, 1 - 10e-3, 1 - 5e-3, 1 - 10e-4, 1]
filename = f"src/clonk/benchmark_suite/data-archive2/data1_random.h5" # NOTE preloaded, change name of file to recollect
gate_error, decomp_error, fidelity_error = collect_random2q_data(
1 - 10e-3, N=N, mode="random", fn=filename
)
create_plot2(gate_error, decomp_error, fidelity_error, plot_bool=0, fn=filename);
create_plot2(gate_error, decomp_error, fidelity_error, plot_bool=1, fn=filename);
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
import sys
sys.path.append("..")
# from benchmark_suite.backend_suite import backends
# from clonk.backend_utils.backend_analysis_pass import TopologyAnalysis
# from qiskit.transpiler.passmanager import PassManager
# from qiskit import QuantumCircuit
# qc = QuantumCircuit(1)
# for backend_label, backend_obj in backends.items():
# print(backend_label)
# pm1 = PassManager(TopologyAnalysis(backend_obj.backend))
# pm1.run(qc)
# #FIXME, just save the property_set dictionary directly
# for key, value in pm1.property_set.items():
# backend_obj.save_data(parameter=key, data=value)
# backend_obj.save_json()
# hypercube analsis
from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager
from clonk.backend_utils.backend_analysis_pass import TopologyAnalysis
qc = QuantumCircuit(1)
import sys
sys.path.append("..")
from clonk.backend_utils.mock_backends import FakeHyperCubeV2, FakeHyperCubeSnail
backend_list = [
FakeHyperCubeSnail(corral_skip_pattern=(0, 0)),
FakeHyperCubeSnail(corral_skip_pattern=(0, 1)),
]
max_connectivity = 0
min_distance = 100
best = None
for i in range(6):
for j in range(6):
backend = FakeHyperCubeSnail(corral_skip_pattern=(i, j))
print(backend.name[:-3])
try:
pm1 = PassManager(TopologyAnalysis(backend))
pm1.run(qc)
except Exception:
continue
# coupling error
# print(f"Num qubits {backend.num_qubits}")
connectivity = pm1.property_set["Avg_Connectivity"]
distance = pm1.property_set["Avg_Distance"]
if distance <= min_distance:
if distance < min_distance or connectivity > max_connectivity:
best = backend.name[:-3]
min_distance = distance
max_connectivity = connectivity
degree = pm1.property_set["Degree"]
diameter = pm1.property_set["Diameter"]
# if connectivity >= max_connectivity:
# if connectivity > max_connectivity or distance < min_distance:
# best = backend.name[:-3]
# min_distance = distance
# max_connectivity = connectivity
print(f"best: {best}")
print(min_distance)
print(max_connectivity)
print(degree)
print(diameter)
from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager
import sys
sys.path.append("..")
from clonk.backend_utils.backend_analysis_pass import TopologyAnalysis
qc = QuantumCircuit(1)
# from mock_backends.ibm import *
# from mock_backends import *
# backend_list = [PenguinV1(), PenguinV2(), PenguinV3(), PenguinV4(), FakeHeavyHex()] #FalconR4()]
from benchmark_suite.backend_suite_v2 import (
small_motivation_backends,
hpca_modular_backends,
hpca_corral_backends,
)
backend_list = hpca_corral_backends
for backend in backend_list:
print(backend.label)
pm1 = PassManager(TopologyAnalysis(backend.backend))
pm1.run(qc)
print(f"Num qubits {backend.backend.num_qubits}")
# just save the property_set dictionary directly
backend.data.update(dict(pm1.property_set))
backend.save_json()
# then print it
for key, value in pm1.property_set.items():
print(key, str(round(value, 2)))
print()
from clonk.backend_utils.mock_backends import FakeModular
backend_list = [FakeModular(module_size=4, children=4, total_levels=3)]
for backend in backend_list:
print(backend.name)
pm1 = PassManager(TopologyAnalysis(backend))
pm1.run(qc)
print(f"Num qubits {backend.num_qubits}")
# then print it
for key, value in pm1.property_set.items():
print(key, str(round(value, 2)))
print()
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
import sys
sys.path.append("..")
from mock_backends.ibm import *
import itertools
from qiskit.circuit.library import CXGate
from clonk.backend_utils.configurable_backend_v2 import ConfigurableFakeBackendV2
import rustworkx as rx
from abc import ABC, abstractmethod
class AbstractModularBackend(ConfigurableFakeBackendV2, ABC):
"""A mock backendv2, tailored for a tree structure with modular connectivity."""
def __init__(self, module_size=4, children=4, total_levels=3):
# Validate children for root module
assert (
1 < children <= module_size
), "Children must be between 2 and the module size, inclusive for the root module."
self.c_map = [] # To hold all edges
self.modules = {} # Maps module ID to its qubits
self.module_depths = {} # Maps module ID to its depth
self.module_size = module_size
self.children = children # Max children for the root module
self.total_levels = total_levels
self.long_edges = []
# Construct the modular system
self._construct_system()
# Remove duplicate edges and filter to keep only edges from lower to higher qubit IDs
self.c_map = list(set(self.c_map))
self.c_map = [edge for edge in self.c_map if edge[0] < edge[1]]
# Configure gates and measurements based on the generated system
gate_configuration = {CXGate: [(i, j) for i, j in self.c_map]}
measurable_qubits = list(range(max(max(pair) for pair in self.c_map) + 1))
super().__init__(
name=f"Modular{module_size}-{children}-{total_levels}",
description="A mock backend with modular architecture",
n_qubits=len(measurable_qubits),
gate_configuration=gate_configuration,
measurable_qubits=measurable_qubits,
gate_durations={CXGate: 1},
parameterized_gates={},
)
def add_long_edges(self, num_long_edges=1):
G = rx.PyGraph()
for node in range(self.num_qubits):
G.add_node(node)
for edge in self.c_map:
G.add_edge(edge[0], edge[1], 1)
long_edge_endpoints = set() # Track qubits that are endpoints of long-edges
for _ in range(num_long_edges):
all_pairs_lengths = rx.all_pairs_dijkstra_path_lengths(
G, edge_cost_fn=lambda x: 1
)
max_length = 0
candidates = []
for source, paths in all_pairs_lengths.items():
for target, length in paths.items():
if source < target and length > max_length:
# Check if either qubit is already an endpoint of a long-edge
if (
source not in long_edge_endpoints
and target not in long_edge_endpoints
):
max_length = length
candidates = [(source, target)]
# If candidates are found, select the first one as the new long-edge
if candidates:
long_edge = candidates[0]
self.long_edges.append(long_edge)
G.add_edge(long_edge[0], long_edge[1], 1)
long_edge_endpoints.update([long_edge[0], long_edge[1]])
def _find_module_by_qubit(self, qubit):
"""Find the module ID that a given qubit belongs to."""
for module_id, qubits in self.modules.items():
if qubit in qubits:
return module_id
return None
@abstractmethod
def _construct_system(self):
"""
Subclasses should implement this method to construct
the modular system based on their specific scheme.
"""
pass
class TreeModular(AbstractModularBackend):
def _construct_system(self):
# Implement the construction logic specific to the Tree scheme
# Start the recursive construction of the system
self._recursive_foo(
qubit_counter=0, current_level=1, parent_id=None, parent_qubit=None, depth=0
)
def _recursive_foo(
self, qubit_counter, current_level, parent_id, parent_qubit, depth
):
module_id = len(self.modules) # Unique ID for each module
self.module_depths[module_id] = depth
qubits = list(range(qubit_counter, qubit_counter + self.module_size))
self.modules[module_id] = qubits
# Create all-to-all connectivity within the module
edges = list(itertools.permutations(qubits, 2))
self.c_map.extend(edges)
# Connect this module to its parent module (if applicable)
if parent_qubit is not None:
self.c_map.append(
(parent_qubit, qubits[0])
) # Connection from parent to this module
self.c_map.append((qubits[0], parent_qubit)) # And vice versa
qubit_counter += self.module_size
if current_level < self.total_levels:
child_count = self.children if current_level == 1 else self.children - 1
for i in range(child_count):
qubit_counter = self._recursive_foo(
qubit_counter,
current_level + 1,
module_id,
qubits[i] if i < child_count - 1 else qubits[-1],
depth + 1,
)
return qubit_counter
class CorralModular(AbstractModularBackend):
def __init__(self, num_snails=8, corral_skip_pattern=(0, 0)):
self.num_snails = num_snails
self.corral_skip_pattern = corral_skip_pattern
# Initialize the modules dictionary to track which SNAIL neighborhood (module)
# each qubit is primarily associated with.
self.qubit_to_snail_map = {} # Maps qubits to their primary SNAIL (module)
super().__init__(
module_size=4, children=2, total_levels=2
) # Example values, adjust as needed
def _assign_qubit_to_module(self, qubit, snail):
# Assign a qubit to its first encountered SNAIL neighborhood if it hasn't been assigned yet.
if qubit not in self.qubit_to_snail_map:
self.qubit_to_snail_map[qubit] = snail
# Ensure the module entry exists for the SNAIL
if snail not in self.modules:
self.modules[snail] = []
self.modules[snail].append(qubit)
def _corral(self, num_snails, skip_pattern):
num_levels = 2
assert len(skip_pattern) == num_levels
snail_edge_list = []
for snail0, snail1 in zip(range(num_snails), range(1, num_snails + 1)):
for i in range(num_levels):
snail_edge_list.append(
(snail0, (skip_pattern[i] + snail1) % num_snails)
)
return snail_edge_list
def _snail_to_connectivity(self, snail_edge_list):
edge_list = []
for qubit, snail_edge in enumerate(snail_edge_list):
# Attempt to assign the qubit to a module based on its SNAIL edge
self._assign_qubit_to_module(qubit, snail_edge[0])
for temp_qubit, temp_snail_edge in enumerate(snail_edge_list):
if qubit != temp_qubit and (
snail_edge[0] in temp_snail_edge or snail_edge[1] in temp_snail_edge
):
edge_list.append((qubit, temp_qubit))
return edge_list
def _construct_system(self):
self.snail_edge_list = self._corral(self.num_snails, self.corral_skip_pattern)
self.c_map = self._snail_to_connectivity(self.snail_edge_list)
# Each SNAIL is treated as a module for depth purposes, though this could be adjusted
self.module_depths = {
snail: snail for snail in range(self.num_snails)
} # Example depth assignment
# Example usage
fake_modular = TreeModular(module_size=3, children=3, total_levels=3)
print("Modules:", fake_modular.modules)
print("Coupling Map:", fake_modular.c_map)
import matplotlib.pyplot as plt
import networkx as nx
def pretty_print_with_networkx(pb, label_text):
G = nx.Graph()
# Define colors for different levels
level_colors = [
"tab:blue",
"tab:orange",
"tab:green",
"tab:red",
"tab:purple",
"tab:brown",
"tab:pink",
"tab:gray",
]
# Module information for coloring and labeling
modules, module_depths = pb.modules, pb.module_depths
# Node colors and labels based on modules
node_colors = []
node_labels = {}
for module_id, qubits in modules.items():
depth = module_depths[module_id]
color = level_colors[depth % len(level_colors)]
for qubit in qubits:
node_colors.append(color)
node_labels[qubit] = f"Q{qubit}"
# Add nodes and edges (regular edges)
G.add_nodes_from([qubit for _, qubits in modules.items() for qubit in qubits])
G.add_edges_from(list(pb.coupling_map))
# Generate layout
pos = nx.kamada_kawai_layout(G)
fig, ax = plt.subplots(figsize=(8, 6)) # Adjust figure size as needed
# Draw the graph without long edges
nx.draw_networkx_nodes(
G, pos, node_size=400, node_color=node_colors, alpha=0.6, ax=ax
) # Adjust node_size here
nx.draw_networkx_labels(
G, pos, labels=node_labels, font_size=8, ax=ax
) # Adjust font_size if necessary
nx.draw_networkx_edges(
G,
pos,
edgelist=list(pb.coupling_map),
width=2,
edge_color="gray",
style="solid",
ax=ax,
)
# Draw long edges on top of the existing layout, if present
if hasattr(pb, "long_edges"):
nx.draw_networkx_edges(
G,
pos,
edgelist=pb.long_edges,
width=5,
edge_color="red",
style="dashed",
ax=ax,
)
ax.set_title(label_text)
ax.axis("off") # Turn off the axis
plt.close(
fig
) # Prevent it from displaying immediately in Jupyter or similar environments
return fig
pretty_print = pretty_print_with_networkx
# Example usage
fake_modular = TreeModular(module_size=4, children=3, total_levels=3)
fake_modular.add_long_edges(num_long_edges=1) # Example: Add 2 long-edges
print("Modules:", fake_modular.modules)
print("Coupling Map:", fake_modular.c_map)
print("Long Edges:", fake_modular.long_edges)
# Then, visualize
label_text = "Example Visualization with Long-Edges"
image = pretty_print(fake_modular, label_text)
# Display the image
# set image to active figure of plt
display(image)
# Generate the images with varying numbers of long edges
figures = []
# Adjusted loop to include iteration over number of long edges
for i in range(3, 6): # Module sizes
for k in range(1, 6): # Total levels
for j in range(i, i + 1): # Children
if k == 1 and j != 2:
continue # Skip configurations that don't make sense
try:
# Create a new instance for each configuration of i, j, k
pb = TreeModular(module_size=i, children=j, total_levels=k)
num_qubits = pb.num_qubits
# Determine the maximum number of long edges for this configuration
max_long_edges = 3 if k > 1 else 0 # At most 4, and 0 if levels=1
for x in range(max_long_edges + 1): # Iterate from 0 to max_long_edges
if num_qubits <= 64:
# Update long edges for the current configuration
pb.add_long_edges(num_long_edges=x)
label_text = f"Module Size: {i}, Children: {j}, Total Levels: {k}, Num Qubits: {num_qubits}, Long Edges: {x}"
print(label_text)
# Generate and store the figure for the current configuration
fig = pretty_print_with_networkx(pb, label_text)
figures.append(fig)
# Reset long edges for the next iteration
pb.long_edges = [] # Clear existing long edges before next addition
except AssertionError:
pass
from PIL import Image
import io
# Create an animation from the figures
# Assuming 'figures' is a list of matplotlib.figure.Figure objects generated from your loop
images = [] # This will hold the PIL Image objects
for fig in figures:
buf = io.BytesIO() # Create an in-memory buffer
fig.savefig(buf, format="png") # Save the figure to the buffer in PNG format
buf.seek(0) # Rewind the buffer to the beginning so we can read from it
img = Image.open(buf) # Open the image from the in-memory buffer
images.append(img) # Append the PIL Image to the list
plt.close(fig) # Close the figure to free memory
gif_path = "networkx_graph_animation.gif"
images[0].save(
gif_path,
save_all=True,
append_images=images[1:],
optimize=False,
duration=1500,
loop=0,
)
# Example usage
corral_modular = CorralModular(num_snails=8, corral_skip_pattern=(0, 0))
corral_modular.add_long_edges(num_long_edges=1) # Example: Add 2 long-edges
print("Modules:", corral_modular.modules)
print("Coupling Map:", corral_modular.c_map)
print("Long Edges:", corral_modular.long_edges)
# Then, visualize
label_text = "Example Visualization with Long-Edges"
image = pretty_print(corral_modular, label_text)
# Display the image
# set image to active figure of plt
display(image)
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
def pretty_print_snails_3d(corral_modular):
fig = plt.figure(figsize=(10, 7))
ax = fig.add_subplot(111, projection="3d")
num_snails = corral_modular.num_snails
snail_edge_list = corral_modular._corral(
num_snails, corral_modular.corral_skip_pattern
)
snail_colors = [
"tab:blue",
"tab:orange",
"tab:green",
"tab:red",
"tab:purple",
"tab:brown",
"tab:pink",
"tab:gray",
]
# Parameters for the SNAIL posts and slats
post_height = 0.5 # Height of the SNAIL posts
post_radius = 0.05 # Radius of the SNAIL posts
z_offset = post_height / 4
z_lower = np.zeros(num_snails) + z_offset # Lower rung positioned at the base
z_upper = np.ones(num_snails) * 0.25 + z_offset # Upper rung
long_edge_height = (z_lower + z_upper) / 2 # Position long edges in between
# SNAIL positions
theta = np.linspace(0, 2 * np.pi, num_snails, endpoint=False)
x = np.cos(theta)
y = np.sin(theta)
# Draw the SNAIL posts
for i in range(num_snails):
color = snail_colors[corral_modular.module_depths[i] % len(snail_colors)]
ax.plot(
[x[i], x[i]],
[y[i], y[i]],
[0, post_height],
color=color,
lw=6,
solid_capstyle="round",
)
# Function to draw a slat between two points
def draw_slat(point1, point2, z_height, color="black", linestyle="-"):
ax.plot(
[point1[0], point2[0]],
[point1[1], point2[1]],
[z_height, z_height],
color=color,
lw=4,
linestyle=linestyle,
solid_capstyle="round",
)
# Divide the edge list into upper and lower rungs
# Take every second edge starting from the first
upper_rung_edges = snail_edge_list[::2]
# Take every second edge starting from the second
lower_rung_edges = snail_edge_list[1::2]
# Draw the upper rung slats
for snail0, snail1 in upper_rung_edges:
draw_slat((x[snail0], y[snail0]), (x[snail1], y[snail1]), z_upper[snail0])
# Draw the lower rung slats
for snail0, snail1 in lower_rung_edges:
draw_slat((x[snail0], y[snail0]), (x[snail1], y[snail1]), z_lower[snail0])
# Draw the long edges
for edge in corral_modular.long_edges:
# get the snail index for the qubits in the edge
snail0 = corral_modular._find_module_by_qubit(edge[0])
snail1 = corral_modular._find_module_by_qubit(edge[1])
draw_slat(
(x[snail0], y[snail0]),
(x[snail1], y[snail1]),
long_edge_height[edge[0]],
color="red",
linestyle="--",
)
# Set the aspect ratio and the viewing angle
ax.set_aspect("auto")
ax.view_init(elev=30.0, azim=-120)
# Hide the axes
ax.set_axis_off()
return fig
# Example usage:
corral_modular = CorralModular(num_snails=8, corral_skip_pattern=(0, 1))
corral_modular.add_long_edges(num_long_edges=1) # Example: Add 2 long-edges
corral_modular.module_depths = {i: i for i in range(8)} # Example module depths
fig = pretty_print_snails_3d(corral_modular)
from PIL import Image
def combine_images(image1, image2):
# Combine two images side by side
dst = Image.new(
"RGB", (image1.width + image2.width, max(image1.height, image2.height))
)
dst.paste(image1, (0, 0))
dst.paste(image2, (image1.width, 0))
return dst
# Generate the images with varying numbers of long edges for Corral configurations
paired_images = []
for num_snails in range(4, 9, 2): # Example range for number of snails
for skip_step in range(0, 3): # Example range for skip pattern steps
corral_skip_pattern = (0, skip_step) # Define skip pattern based on skip_step
try:
pb = CorralModular(
num_snails=num_snails, corral_skip_pattern=corral_skip_pattern
)
max_long_edges = min(4, num_snails // 2 - 1)
for x in range(max_long_edges + 1):
pb.add_long_edges(num_long_edges=x)
label_text = f"Num Snails: {num_snails}, Skip Pattern: {corral_skip_pattern}, Num Qubits: {num_qubits}, Long Edges: {x}"
print(label_text)
# Generate the figure for the 3D SNAIL visualization
fig_3d = pretty_print_snails_3d(pb)
buf_3d = io.BytesIO()
fig_3d.savefig(buf_3d, format="png")
buf_3d.seek(0)
img_3d = Image.open(buf_3d)
plt.close(fig_3d)
# Generate the figure for the network graph visualization
fig_networkx = pretty_print_with_networkx(pb, label_text)
buf_networkx = io.BytesIO()
fig_networkx.savefig(buf_networkx, format="png")
buf_networkx.seek(0)
img_networkx = Image.open(buf_networkx)
plt.close(fig_networkx)
# Combine the two images side by side
paired_img = combine_images(img_3d, img_networkx)
paired_images.append(paired_img)
pb.long_edges = [] # Clear existing long edges before next addition
except AssertionError:
pass
# Create the GIF from the paired images
gif_path = "corral_snails_and_networkx.gif"
paired_images[0].save(
gif_path,
save_all=True,
append_images=paired_images[1:],
optimize=False,
duration=1500,
loop=0,
)
print(f"GIF saved to {gif_path}")
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
from qiskit.transpiler.coupling import CouplingMap
def pretty_print(edge_list, simple=False):
if simple:
temp = list(edge_list)
temp2 = []
for i, j in temp:
if not (j, i) in temp2:
temp2.append((i, j))
edge_list = temp2
x = CouplingMap(edge_list)
# black magic errors when I modify the draw function directly in the CouplingMap file so Im just copying the code here to make it work
import pydot
from PIL import Image
import io
formatter2 = lambda _: dict(dir="none")
dot_str = x.graph.to_dot(edge_attr=formatter2, graph_attr={"size": "0"})
dot = pydot.graph_from_dot_data(dot_str)[0]
png = dot.create_png(prog="sfdp")
pdf = dot.create_pdf(prog="sfdp")
# png = dot.create_png(prog="neato")
return Image.open(io.BytesIO(png))
def snail_to_connectivity(snail_edge_list):
# Convert snail edge list where nodes are snails and edges are qubits
# To connectivity edge list where nodes are qubits and edges are coupling
edge_list = []
# qubits are coupled to a snail edge if they are both adjacent to a snail node
for qubit, snail_edge in enumerate(snail_edge_list):
for temp_qubit, temp_snail_edge in enumerate(snail_edge_list):
if qubit != temp_qubit and (
snail_edge[0] in temp_snail_edge or snail_edge[1] in temp_snail_edge
):
edge_list.append((qubit, temp_qubit))
return edge_list
snail_edge_list = [
(0, 1),
(0, 1),
(0, 2),
(0, 3),
(1, 2),
(1, 4),
(2, 3),
(2, 4),
(3, 4),
(3, 4),
]
pretty_print(snail_edge_list)
edge_list = snail_to_connectivity(snail_edge_list)
pretty_print(edge_list, simple=True)
# define corral
def corral(skip_pattern):
num_snails = 32
num_levels = 2
assert len(skip_pattern) == num_levels
snail_edge_list = []
for snail0, snail1 in zip(range(num_snails), range(1, num_snails + 1)):
for i in range(num_levels):
snail_edge_list.append((snail0, (skip_pattern[i] + snail1) % num_snails))
return snail_edge_list
snail_edge_list = corral((0, 0))
# some manual modifications for spanning across
snail_edge_list.remove((0, 1))
snail_edge_list.append((0, 16))
snail_edge_list.remove((16, 17))
snail_edge_list.append((0, 16))
pretty_print(snail_edge_list)
edge_list = snail_to_connectivity(snail_edge_list)
pretty_print(edge_list, simple=True)
snail_edge_list = corral((0, 0))
offset = 1 + max([el[1] for el in snail_edge_list])
snail_edge_list_2 = [(offset + el[0], offset + el[1]) for el in corral((0, 0))]
pretty_print(snail_edge_list_2)
# delete edges
snail_edge_list.remove((7, 0))
snail_edge_list.remove((0, 1))
snail_edge_list_2.remove((15, 8))
snail_edge_list_2.remove((8, 9))
# joining edges
snail_edge_list = snail_edge_list + snail_edge_list_2
snail_edge_list = [
(el[0], 0) if el[1] == 8 else (el[0], el[1]) for el in snail_edge_list
]
snail_edge_list = [
(0, el[1]) if el[0] == 8 else (el[0], el[1]) for el in snail_edge_list
]
pretty_print(snail_edge_list)
edge_list = snail_to_connectivity(snail_edge_list)
pretty_print(edge_list, simple=True)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
"""Define circuits to test."""
from supermarq.benchmarks.ghz import GHZ
from supermarq.benchmarks.hamiltonian_simulation import HamiltonianSimulation
from supermarq.benchmarks.qaoa_vanilla_proxy import QAOAVanillaProxy
from supermarq.converters import cirq_to_qiskit
class CircuitTranspilerBenchmark:
# TODO: circuit_lambda could take multiple params if desired
def __init__(self, circuit_lambda, q_range, label):
self.circuit_lambda = circuit_lambda
# self.q_range = q_range
self.label = label
# FIXME should this be a class, q_range is a parameter, instead of dict use get methods
circuits = {}
depth = 10
q_range = None # deprecated, move to backendbenchmark object
# Random
# from qiskit.circuit.random import random_circuit
# random_lambda = lambda q: random_circuit(q, depth, measure=False, max_operands=2)
# label = "Randomized_QC"
# circuits[label] = CircuitTranspilerBenchmark(random_lambda, q_range, label=label)
# # Quantum Volume
from qiskit.circuit.library import QuantumVolume
def qv_lambda(q):
return QuantumVolume(num_qubits=q, depth=q)
label = "Quantum_Volume"
circuits[label] = CircuitTranspilerBenchmark(qv_lambda, q_range, label=label)
# QFT
from qiskit.circuit.library.basis_change import QFT
def qft_lambda(q):
return QFT(q)
label = "QFT"
circuits[label] = CircuitTranspilerBenchmark(qft_lambda, q_range, label=label)
# # Inverse QFT
# inverse_qft_lambda = lambda q: QFT(q, inverse=True)
# label = "IQFT"
# circuits[label] = CircuitTranspilerBenchmark(inverse_qft_lambda, q_range, label=label)
# QAOA, takes a long time to generate - consider capping max size before 20
# qaoa_lambda = lambda q: cirq_to_qiskit(QAOAFermionicSwapProxy(q).circuit())
# label = "QAOA_Fermionic_Swap"
# circuits[label] = CircuitTranspilerBenchmark(qaoa_lambda, q_range, label=label)
# # QAOA vanilla
def qaoa_vanilla_lambda(q):
return cirq_to_qiskit(QAOAVanillaProxy(q).circuit())
label = "QAOA_Vanilla"
circuits[label] = CircuitTranspilerBenchmark(qaoa_vanilla_lambda, q_range, label=label)
# VQE - very slow to generate
# vqe_lambda = lambda q: cirq_to_qiskit(VQEProxy(q, 4).circuit()[0])
# label = "VQE"
# circuits[label] = CircuitTranspilerBenchmark(vqe_lambda, q_range, label=label)
# Simulation
def hamiltonian_lambda(q):
return cirq_to_qiskit(HamiltonianSimulation(q, 1 / depth, 0.5).circuit())
label = "TIM_Hamiltonian"
circuits[label] = CircuitTranspilerBenchmark(hamiltonian_lambda, q_range, label=label)
from qiskit import QuantumCircuit
# weighted adder or ripple carry adder
from qiskit.circuit.library.arithmetic.adders.cdkm_ripple_carry_adder import (
CDKMRippleCarryAdder,
)
# using trick of composing into an empty circuit so that it builds everything into a single quantumregister
def adder_lambda(q):
return (
QuantumCircuit(q)
.compose(CDKMRippleCarryAdder(num_state_qubits=int((q - 1) / 2)), inplace=False)
.decompose()
.decompose()
.decompose()
)
label = "Adder"
circuits[label] = CircuitTranspilerBenchmark(adder_lambda, q_range, label=label)
# multiplier
# from qiskit.circuit.library.arithmetic.multipliers import RGQFTMultiplier
# multiplier_lambda = (
# lambda q: QuantumCircuit(q)
# .compose(RGQFTMultiplier(num_state_qubits=int(q / 4)), inplace=False)
# .decompose()
# .decompose()
# .decompose()
# )
# label = "Multiplier"
# circuits[label] = CircuitTranspilerBenchmark(multiplier_lambda, q_range, label=label)
# # GHZ
def ghz_lambda(q):
return cirq_to_qiskit(GHZ(q).circuit())
label = "GHZ"
circuits[label] = CircuitTranspilerBenchmark(ghz_lambda, q_range, label=label)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
from backend_suite import backends, large_backends
from circuit_suite import circuits
qc = circuits["QAOA_Vanilla"].circuit_lambda(4)
qc.remove_final_measurements()
qc.draw(output="mpl")
from qiskit.converters import circuit_to_dag
from qiskit.visualization import dag_drawer
new_qc = backends["Hatlab-Large-Riswap-Shuffle"].pass_manager.run(qc)
dag = circuit_to_dag(new_qc)
dag_drawer(dag)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager
import sys
sys.path.append("..")
from clonk.backend_utils.backend_analysis_pass import TopologyAnalysis
qc = QuantumCircuit(1)
from clonk.backend_utils.mock_backends.ibm import *
backend_list = [PenguinV1(), PenguinV2(), PenguinV3(), PenguinV4(), FalconR4()]
for backend in backend_list:
print(backend.name)
pm1 = PassManager(TopologyAnalysis(backend))
pm1.run(qc)
# FIXME, just save the property_set dictionary directly
for key, value in pm1.property_set.items():
print(key, value)
print()
# from clonk.utils.transpiler_passes import level_0_pass_manager
# pm_lattice = level_0_pass_manager(PenguinV1(), basis_gate="CR")
# qc = QuantumCircuit(2)
# qc.cx(0,1)
# transp = pm_lattice.run(qc)
# transp.draw(output='mpl')
import sys
sys.path.append("..")
from clonk.backend_utils.mock_backends import FakeHeavyHex
from circuit_suite import circuits
circuit_lambdas = [v.circuit_lambda(10) for k, v in circuits.items()]
circuit_labels = [v.label for k, v in circuits.items()]
backend_list = [
PenguinV1(),
PenguinV2(),
PenguinV3(),
PenguinV4(),
FakeHeavyHex(),
] # FalconR4()]
import matplotlib.pyplot as plt
import numpy as np
labels = [backend.name for backend in backend_list]
circuit_depth_list = []
for circuit in circuit_lambdas:
circuit_depth_temp = []
for backend in backend_list:
from clonk.utils.transpiler_passes import level_0_pass_manager
pm = level_0_pass_manager(backend, basis_gate="CR")
pm.run(circuit)
circuit_depth_temp.append(pm.property_set["depth"])
circuit_depth_list.append(circuit_depth_temp)
x = np.arange(len(labels)) # the label locations
width = 0.5 / (len(labels) - 1) # the width of the bars
fig, ax = plt.subplots()
count = 0
for circuit_depth, label in zip(circuit_depth_list, circuit_labels):
rects1 = ax.bar(x + width * count, circuit_depth, width, label=label)
ax.bar_label(rects1, padding=3)
count += 1
# Add some text for labels, title and custom x-axis tick labels, etc.
ax.set_ylabel("Depth")
ax.set_title("IBM Topologies on Circuit Benchmark")
ax.set_xticks(x, labels)
ax.legend()
fig.tight_layout()
plt.show()
from qiskit import QuantumCircuit
import sys
sys.path.append("..")
qc = QuantumCircuit(2)
qc.swap(0, 1)
from clonk.utils.transpiler_passes import level_0_pass_manager
from clonk.backend_utils.mock_backends import *
pm = level_0_pass_manager(PenguinV1(), "CR", decompose_1q=False)
transp = pm.run(qc)
transp.draw(output="mpl")
# from qiskit.quantum_info import Operator
# Operator(transp).equiv(Operator(qc))
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
from qiskit import QuantumCircuit
import sys
sys.path.append("..")
from clonk.utils.riswap_gates.riswap import RiSwapGate
qc = QuantumCircuit(3)
# qc.u(0, 0, 0,0)
# qc.u(0, 0, 0,1)
# qc.append(RiSwapGate(0.5), [0,1])
# qc.u(0, 0, 0,0)
# qc.u(0, 0, 0,1)
# qc.append(RiSwapGate(0.5), [0,1])
# qc.u(0, 0, 0,0)
# qc.u(0, 0, 0,1)
qc.cswap(2, 0, 1)
qc.cswap(1, 0, 2)
qc.swap(0, 1)
qc.swap(0, 2)
print(qc.draw(output="latex_source", with_layout=False))
qc.draw(output="mpl")
from qiskit.quantum_info import Operator
Operator(qc).data
from qiskit import QuantumCircuit, QuantumRegister
from numpy import pi as pi
from qiskit.circuit.library.standard_gates import *
q = QuantumRegister(3, "q")
cx_to_zx90 = QuantumCircuit(3, global_phase=pi / 4)
for inst, qargs, cargs in [
(RZXGate(pi / 2), [q[0], q[2]], []),
(SdgGate(), [q[0]], []),
(SXdgGate(), [q[2]], []),
]:
cx_to_zx90.append(inst, qargs, cargs)
print(cx_to_zx90.draw(output="latex_source"))
cx_to_zx90.draw(output="mpl")
from qiskit.circuit.library.basis_change import QFT
qc = QFT(4)
qc.decompose().draw(output="mpl")
# print(qc.decompose().draw(output='latex_source'))
import numpy as np
print(np.array(CPhaseGate(pi / 2, 0, 1)))
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
%%capture
%pip install qiskit
%pip install qiskit_ibm_provider
%pip install qiskit-aer
# Importing standard Qiskit libraries
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, QuantumCircuit, transpile, Aer
from qiskit_ibm_provider import IBMProvider
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.circuit.library import C3XGate
# Importing matplotlib
import matplotlib.pyplot as plt
# Importing Numpy, Cmath and math
import numpy as np
import os, math, cmath
from numpy import pi
# Other imports
from IPython.display import display, Math, Latex
# Specify the path to your env file
env_file_path = 'config.env'
# Load environment variables from the file
os.environ.update(line.strip().split('=', 1) for line in open(env_file_path) if '=' in line and not line.startswith('#'))
# Load IBM Provider API KEY
IBMP_API_KEY = os.environ.get('IBMP_API_KEY')
# Loading your IBM Quantum account(s)
IBMProvider.save_account(IBMP_API_KEY, overwrite=True)
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
qc_b1 = QuantumCircuit(2, 2)
qc_b1.h(0)
qc_b1.cx(0, 1)
qc_b1.draw(output='mpl', style="iqp")
sv = backend.run(qc_b1).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^+\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.x(0)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b2 = QuantumCircuit(2, 2)
qc_b2.h(0)
qc_b2.cx(0, 1)
qc_b2.z(0)
qc_b2.draw(output='mpl', style="iqp")
sv = backend.run(qc_b2).result().get_statevector()
sv.draw(output='latex', prefix = "|\Phi^-\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.x(1)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b3 = QuantumCircuit(2, 2)
qc_b3.h(0)
qc_b3.cx(0, 1)
qc_b3.x(0)
qc_b3.draw(output='mpl', style="iqp")
sv = backend.run(qc_b3).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^+\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.x(0)
qc_b4.h(0)
qc_b4.x(1)
qc_b4.cx(0, 1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
qc_b4 = QuantumCircuit(2, 2)
qc_b4.h(0)
qc_b4.cx(0, 1)
qc_b4.x(0)
qc_b4.z(1)
qc_b4.draw(output='mpl', style="iqp")
sv = backend.run(qc_b4).result().get_statevector()
sv.draw(output='latex', prefix = "|\Psi^-\\rangle = ")
def sv_latex_from_qc(qc, backend):
sv = backend.run(qc).result().get_statevector()
return sv.draw(output='latex')
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(0)
qc_ej2.x(1)
qc_ej2.x(2)
sv_latex_from_qc(qc_ej2, backend)
qc_ej2 = QuantumCircuit(4, 4)
qc_ej2.x(3)
sv_latex_from_qc(qc_ej2, backend)
def circuit_adder (num):
if num<1 or num>8:
raise ValueError("Out of range") ## El enunciado limita el sumador a los valores entre 1 y 8. Quitar esta restricción sería directo.
# Definición del circuito base que vamos a construir
qreg_q = QuantumRegister(4, 'q')
creg_c = ClassicalRegister(1, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
qbit_position = 0
for element in reversed(np.binary_repr(num)):
if (element=='1'):
circuit.barrier()
match qbit_position:
case 0: # +1
circuit.append(C3XGate(), [qreg_q[0], qreg_q[1], qreg_q[2], qreg_q[3]])
circuit.ccx(qreg_q[0], qreg_q[1], qreg_q[2])
circuit.cx(qreg_q[0], qreg_q[1])
circuit.x(qreg_q[0])
case 1: # +2
circuit.ccx(qreg_q[1], qreg_q[2], qreg_q[3])
circuit.cx(qreg_q[1], qreg_q[2])
circuit.x(qreg_q[1])
case 2: # +4
circuit.cx(qreg_q[2], qreg_q[3])
circuit.x(qreg_q[2])
case 3: # +8
circuit.x(qreg_q[3])
qbit_position+=1
return circuit
add_3 = circuit_adder(3)
add_3.draw(output='mpl', style="iqp")
qc_test_2 = QuantumCircuit(4, 4)
qc_test_2.x(1)
qc_test_2_plus_3 = qc_test_2.compose(add_3)
qc_test_2_plus_3.draw(output='mpl', style="iqp")
sv_latex_from_qc(qc_test_2_plus_3, backend)
qc_test_7 = QuantumCircuit(4, 4)
qc_test_7.x(0)
qc_test_7.x(1)
qc_test_7.x(2)
qc_test_7_plus_8 = qc_test_7.compose(circuit_adder(8))
sv_latex_from_qc(qc_test_7_plus_8, backend)
#qc_test_7_plus_8.draw()
theta = 6.544985
phi = 2.338741
lmbda = 0
alice_1 = 0
alice_2 = 1
bob_1 = 2
qr_alice = QuantumRegister(2, 'Alice')
qr_bob = QuantumRegister(1, 'Bob')
cr = ClassicalRegister(3, 'c')
qc_ej3 = QuantumCircuit(qr_alice, qr_bob, cr)
qc_ej3.barrier(label='1')
qc_ej3.u(theta, phi, lmbda, alice_1);
qc_ej3.barrier(label='2')
qc_ej3.h(alice_2)
qc_ej3.cx(alice_2, bob_1);
qc_ej3.barrier(label='3')
qc_ej3.cx(alice_1, alice_2)
qc_ej3.h(alice_1);
qc_ej3.barrier(label='4')
qc_ej3.measure([alice_1, alice_2], [alice_1, alice_2]);
qc_ej3.barrier(label='5')
qc_ej3.x(bob_1).c_if(alice_2, 1)
qc_ej3.z(bob_1).c_if(alice_1, 1)
qc_ej3.measure(bob_1, bob_1);
qc_ej3.draw(output='mpl', style="iqp")
result = backend.run(qc_ej3, shots=1024).result()
counts = result.get_counts()
plot_histogram(counts)
sv_0 = np.array([1, 0])
sv_1 = np.array([0, 1])
def find_symbolic_representation(value, symbolic_constants={1/np.sqrt(2): '1/√2'}, tolerance=1e-10):
"""
Check if the given numerical value corresponds to a symbolic constant within a specified tolerance.
Parameters:
- value (float): The numerical value to check.
- symbolic_constants (dict): A dictionary mapping numerical values to their symbolic representations.
Defaults to {1/np.sqrt(2): '1/√2'}.
- tolerance (float): Tolerance for comparing values with symbolic constants. Defaults to 1e-10.
Returns:
str or float: If a match is found, returns the symbolic representation as a string
(prefixed with '-' if the value is negative); otherwise, returns the original value.
"""
for constant, symbol in symbolic_constants.items():
if np.isclose(abs(value), constant, atol=tolerance):
return symbol if value >= 0 else '-' + symbol
return value
def array_to_dirac_notation(array, tolerance=1e-10):
"""
Convert a complex-valued array representing a quantum state in superposition
to Dirac notation.
Parameters:
- array (numpy.ndarray): The complex-valued array representing
the quantum state in superposition.
- tolerance (float): Tolerance for considering amplitudes as negligible.
Returns:
str: The Dirac notation representation of the quantum state.
"""
# Ensure the statevector is normalized
array = array / np.linalg.norm(array)
# Get the number of qubits
num_qubits = int(np.log2(len(array)))
# Find indices where amplitude is not negligible
non_zero_indices = np.where(np.abs(array) > tolerance)[0]
# Generate Dirac notation terms
terms = [
(find_symbolic_representation(array[i]), format(i, f"0{num_qubits}b"))
for i in non_zero_indices
]
# Format Dirac notation
dirac_notation = " + ".join([f"{amplitude}|{binary_rep}⟩" for amplitude, binary_rep in terms])
return dirac_notation
def array_to_matrix_representation(array):
"""
Convert a one-dimensional array to a column matrix representation.
Parameters:
- array (numpy.ndarray): The one-dimensional array to be converted.
Returns:
numpy.ndarray: The column matrix representation of the input array.
"""
# Replace symbolic constants with their representations
matrix_representation = np.array([find_symbolic_representation(value) or value for value in array])
# Return the column matrix representation
return matrix_representation.reshape((len(matrix_representation), 1))
def array_to_dirac_and_matrix_latex(array):
"""
Generate LaTeX code for displaying both the matrix representation and Dirac notation
of a quantum state.
Parameters:
- array (numpy.ndarray): The complex-valued array representing the quantum state.
Returns:
Latex: A Latex object containing LaTeX code for displaying both representations.
"""
matrix_representation = array_to_matrix_representation(array)
latex = "Matrix representation\n\\begin{bmatrix}\n" + \
"\\\\\n".join(map(str, matrix_representation.flatten())) + \
"\n\\end{bmatrix}\n"
latex += f'Dirac Notation:\n{array_to_dirac_notation(array)}'
return Latex(latex)
sv_b1 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b1 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b1)
sv_b2 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) + np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b2 = (np.kron(sv_0, sv_0) - np.kron(sv_1, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b2)
sv_b3 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b3 = (np.kron(sv_0, sv_1) + np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b3)
sv_b4 = np.kron(sv_0, sv_0)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = np.kron(sv_0, sv_1)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_0) - np.kron(sv_0, sv_1)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
sv_b4 = (np.kron(sv_0, sv_1) - np.kron(sv_1, sv_0)) / np.sqrt(2)
array_to_dirac_and_matrix_latex(sv_b4)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
# %%
# %%
# make a plot :)
import matplotlib.pyplot as plt
# plt.style.use(["science", "ieee"])
# plt.plot([0,0], [1,1]);
# plt.style.use(["science", "ieee"])
# I'm not sure why but theon't get updated until after running twice, so monkey fix like this?? styles d
def benchmark(
backends,
circuit_generator,
q_range=None,
continuously_save=False,
overwrite=False,
repeat=3,
):
for iteration in range(repeat):
benchmark_foo(
iteration,
backends,
circuit_generator,
q_range,
continuously_save,
overwrite,
)
def benchmark_foo(
i,
backends,
circuit_generator,
q_range=None,
continuously_save=False,
overwrite=False,
):
iteration = str(i)
# override qrange if provided
if q_range is None:
q_range = circuit_generator.q_range
# check if data dicts are empty
for backend in backends:
if iteration not in backend.data.keys():
backend.data[iteration] = {}
if circuit_generator.label not in backend.data[iteration].keys():
backend.data[iteration][circuit_generator.label] = {}
backend.data[iteration][circuit_generator.label]["duration"] = {}
backend.data[iteration][circuit_generator.label]["preswap_gate_count"] = {}
backend.data[iteration][circuit_generator.label]["gate_count"] = {}
backend.data[iteration][circuit_generator.label][
"preswap_gate_count_crit"
] = {}
backend.data[iteration][circuit_generator.label]["layout_score"] = {}
backend.data[iteration][circuit_generator.label]["edge_frequency"] = {}
print(f"Starting benchmark for {circuit_generator.label}")
# outer loop over circuit since this may take long time to generate
for q in q_range:
# create new variable sized lambda circuit
# wait to build circuit (may be costly), if we end up not needing it for any backend
qc = None
if overwrite:
qc = circuit_generator.circuit_lambda(q)
for backend in backends:
# condition to skip
if not overwrite:
# convert to int because if loaded from json key will be a string
if q in [
int(k)
for k in backend.data[iteration][circuit_generator.label][
"preswap_gate_count"
].keys()
]:
continue
# another condition to skip if size is invalid
if backend.backend.num_qubits < q:
continue
# resolve wait
if qc is None:
qc = circuit_generator.circuit_lambda(q)
# logging.info(f"Transpiler qc{q} for {backend.label}")
print(f"Transpiler qc{q} for {backend.label}")
backend.pass_manager.run(qc)
# save data to dict
# might be empty if not decomposing swaps, this comment is deprecated
# if (
# "duration_longest_path_length"
# in backend.pass_manager.property_set.keys()
# ):
# switch to using standard count ops method now w/o pulse normalization arg
duration = backend.pass_manager.property_set["count_ops_longest_path"]
backend.data[iteration][circuit_generator.label]["duration"][
str(q)
] = duration
gate_count = backend.pass_manager.property_set["preswap_count_ops"]
backend.data[iteration][circuit_generator.label]["preswap_gate_count"][
str(q)
] = gate_count
gate_count_critical_path = backend.pass_manager.property_set[
"preswap_count_ops_longest_path"
]
backend.data[iteration][circuit_generator.label]["preswap_gate_count_crit"][
str(q)
] = gate_count_critical_path
gate_count_post_decomp = backend.pass_manager.property_set["count_ops"]
backend.data[iteration][circuit_generator.label]["gate_count"][
str(q)
] = gate_count_post_decomp
layout_score = backend.pass_manager.property_set["layout_score"]
backend.data[iteration][circuit_generator.label]["layout_score"][
str(q)
] = float(layout_score)
frequency_list = backend.pass_manager.property_set["edge_frequency"]
backend.data[iteration][circuit_generator.label]["edge_frequency"][
str(q)
] = frequency_list
# for long tests, may want to save more regularly in case exit early
if continuously_save:
backend.save_json()
for backend in backends:
# save dict to json
backend.save_json()
# %%
# !pip install SciencePlots
# import matplotlib.pyplot as plt
# plt.style.reload_library()
# plt.style.use(['science','no-latex'])
# %%
def plot_wrap(backends, circuit_label_list, motivation=False, plot_average=True):
# fig, axs = plt.subplots(len(circuit_label_list),4, figsize=(24,24))
height = 5
if 1 or motivation:
height = 2.5
fig = plt.figure(constrained_layout=True, figsize=(7.16, height))
# fig = plt.figure(constrained_layout=True, figsize=(4.5, 3.75))
# plt.style.use(["science"])
SMALL_SIZE = 4
MEDIUM_SIZE = 6
plt.rc("font", size=SMALL_SIZE) # controls default text sizes
plt.rc("axes", titlesize=MEDIUM_SIZE) # fontsize of the axes title
plt.rc("axes", labelsize=MEDIUM_SIZE + 4) # fontsize of the x and y labels
plt.rc("xtick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
plt.rc("ytick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
plt.rc("legend", fontsize=MEDIUM_SIZE + 2) # legend fontsize
plt.rc("figure", titlesize=MEDIUM_SIZE + 4) # fontsize of the figure title
plt.rc("lines", markersize=1.8, linewidth=0.75)
if 1 or motivation:
nrows = 2
else:
nrows = 4
axs = fig.subplots(ncols=len(circuit_label_list), nrows=nrows)
i = 0
for circuit_label in circuit_label_list:
ax = plot(
backends,
circuit_label,
duration=2,
subfig=axs,
first=(i == 0),
index=i,
motivation=motivation,
plot_average=plot_average
# last=(i + 1 == len(circuit_label_list)),
)
i += 1
circuit_label = circuit_label.replace("_", " ")
if circuit_label == "QAOA Vanilla":
circuit_label = "QAOA"
ax.set_xlabel(f"{circuit_label}", y=0)
# for ax, row in zip(ax[:,0], subfigs):
# ax.set_ylabel(row, rotation=0, size='large')
fig.align_ylabels(axs)
handles, labels = ax.get_legend_handles_labels()
# patch labels
def fix_labels(labels):
for index, label in enumerate(labels):
if "small" in label:
label = label[:-6]
if label == "Heavy-Hex-cx":
labels[index] = "Heavy-Hex" + ("-CX" if not motivation else "")
if label == "Hex-Lattice-cx":
labels[index] = "Hex-Lattice" + ("-CX" if not motivation else "")
if label == "Lattice+AltDiagonals-cx":
labels[index] = "Lattice+AltDiagonals" + (
"-CX" if not motivation else ""
)
if label == "Square-Lattice-syc":
labels[index] = "Square-Lattice" + ("-SYC" if not motivation else "")
if label == "Modular-riswap":
labels[index] = "Tree" + (r"-$\sqrt{iSWAP}$" if not motivation else "")
if label == "Modular-RR3-riswap":
labels[index] = "Tree-I" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if label == "Hypercube-riswap":
labels[index] = "Hypercube" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if label == "HypercubeSNAIL-(0, 0)-riswap":
labels[index] = "Corral$_{1,1}$" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if label == "HypercubeSNAIL-(0, 1)-riswap":
labels[index] = "Corral$_{1,2}$" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if label == "Corral-8-(0, 0)-riswap":
labels[index] = "Corral$_{1,1}$" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if label == "Corral-8-(0, 1)-riswap":
labels[index] = "Corral$_{1,2}$" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if label == "Corral-42-(0, 0)-riswap":
labels[index] = "Corral$_{1,1}$" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if label == "Corral-42-(0, 1)-riswap":
labels[index] = "Corral$_{1,2}$" + (
r"-$\sqrt{iSWAP}$" if not motivation else ""
)
if "Non-Swap Gate Count" in labels:
temp_index = labels.index("Non-Swap Gate Count")
temp_handle = handles.pop(temp_index)
handles.insert(0, temp_handle)
temp_label = labels.pop(temp_index)
labels.insert(0, temp_label)
return labels
labels = fix_labels(labels)
fig.legend(
handles,
labels,
loc="upper center",
ncol=4,
bbox_to_anchor=(0.5, -0.01),
markerscale=2,
)
# savefig
# filename = f"images/data1"
# import os
# i = 0
# while os.path.exists("{}{:d}.pdf".format(filename, i)):
# i += 1
# #fig.savefig("{}{:d}.pdf".format(filename, i), format="pdf", facecolor="white")
# fig.savefig("{}{:d}.svg".format(filename, i), format="svg", facecolor='None')
# %%
import numpy as np
def plot(
backends,
circuit_label,
duration=0,
subfig=None,
first=False,
index=0,
motivation=False,
plot_average=True,
):
def mark(backend_label):
if "Modular" in backend_label:
if "RR" in backend_label:
return "p"
return "*"
if "Google" in backend_label or "Square" in backend_label:
return "s"
if "IBM" in backend_label or "Heavy" in backend_label:
return "h"
if "Hex-Lattice" in backend_label:
return "^"
if "AltDiagonals" in backend_label:
return "x"
if "SNAIL" in backend_label or "Corral" in backend_label:
if "(0, 1)" in backend_label:
return "D"
return "8"
if "Hypercube" in backend_label:
return "o"
pass
def color_map(backend_label):
if "Modular" in backend_label:
if "RR" in backend_label:
return "tab:olive"
return "tab:green"
if "Google" in backend_label or "Square" in backend_label:
return "tab:red"
if "IBM" in backend_label or "Heavy" in backend_label:
return "tab:blue"
if "Hex-Lattice" in backend_label:
return "tab:cyan"
if "AltDiagonals" in backend_label:
return "tab:orange"
if "SNAIL" in backend_label or "Corral" in backend_label:
if "(0, 1)" in backend_label:
return "tab:pink"
if "(0, 2)" in backend_label:
return "tab:gray"
if "(1, 2)" in backend_label or "split" in backend_label:
return "black"
return "tab:purple"
if "Hypercube" in backend_label:
return "tab:brown"
pass
if subfig is None:
if duration == 2:
fig, (ax2, ax3, ax4, ax1) = plt.subplots(1, 4, figsize=(24, 8))
else:
raise NotImplementedError
else:
# axs = subfig.subplots(nrows=4, ncols=1)
ax2 = subfig[0][index]
ax3 = subfig[1][index]
if not motivation:
pass
# ax4 = subfig[2][index]
# ax1 = subfig[3][index]
if 1 or motivation:
ax_list = [ax2, ax3]
else:
ax_list = [ax2, ax3, ax4, ax1]
for ax in ax_list:
# ax.xaxis.set_major_locator(plt.MaxNLocator(3))
ax.yaxis.set_major_locator(plt.MaxNLocator(3))
ax.ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# elif duration==1:
# fig, (ax1) = plt.subplots(1,1, figsize=(12,8))
# else:
# fig, (ax2, ax3) = plt.subplots(1,2, figsize=(24,8))
for backend_i, backend in enumerate(backends):
if circuit_label in backend.data["0"].keys():
if motivation:
# total swap gates
x = backend.data["0"][circuit_label]["preswap_gate_count"].keys()
x = [int(el) for el in list(x)]
y_best = np.ones(len(x)) * np.inf
y_average = np.zeros(len(x))
# XXX monkey patch :(
# for iter_key in backend.data.keys():
keys = [el for el in backend.data.keys() if el.isdigit()]
for iter_key in keys:
y = backend.data[iter_key][circuit_label][
"preswap_gate_count"
].values()
x, y = zip(*zip(x, y))
y = [el["swap"] if "swap" in el.keys() else 0 for el in y]
# XXX monkey patch
x = list(x)
y = list(y)
if len(x) > 10:
for val in [4, 6, 10, 12, 14]:
if val in x:
del_index = x.index(val)
x.pop(del_index)
y.pop(del_index)
x, y = zip(*sorted(zip(x, y)))
for index, el in enumerate(y):
if y_best[index] > el:
y_best[index] = el
y_average[index] += el
y_average /= len(keys)
y_average = y_average[0 : len(x)]
if plot_average:
y = y_average
else:
y = y_best
ax2.plot(
x,
y,
marker=mark(backend.label),
label=backend.label,
color=color_map(backend.label),
)
if backend_i == 0:
pass
# skip for now
# monkey patch in a thing which prints the non swap gates
# from qiskit import transpile
# from circuit_suite import circuits
# y = [transpile(circuits[circuit_label].circuit_lambda(xi), basis_gates=['u', 'cx']).count_ops()['cx'] for xi in x]
# ax2.plot(x, y, marker='.', linestyle='-.', label="Non-Swap Gate Count", color='black')
# ax2.set_ylabel("Total SWAP Count")
# if last:
# ax2.set_xlabel("Num Qubits")
if not duration == 2:
ax2.legend()
if first:
ax2.set_ylabel("Total SWAP Count") # vs Num Qubits")
if motivation:
# critical path swap gates
x = backend.data["0"][circuit_label]["preswap_gate_count_crit"].keys()
x = [int(el) for el in list(x)]
y_best = np.ones(len(x)) * np.inf
y_average = np.zeros(len(x))
keys = [el for el in backend.data.keys() if el.isdigit()]
for iter_key in keys:
y = backend.data[iter_key][circuit_label][
"preswap_gate_count_crit"
].values()
x, y = zip(*zip(x, y))
y = [el["swap"] if "swap" in el.keys() else 0 for el in y]
# XXX monkey patch
x = list(x)
y = list(y)
if len(x) > 10:
for val in [4, 6, 10, 12, 14]:
if val in x:
del_index = x.index(val)
x.pop(del_index)
y.pop(del_index)
x, y = zip(*sorted(zip(x, y)))
for index, el in enumerate(y):
if y_best[index] > el:
y_best[index] = el
y_average[index] += el
y_average /= len(keys)
y_average = y_average[0 : len(x)]
if plot_average:
y = y_average
else:
y = y_best
ax3.plot(
x,
y,
marker=mark(backend.label),
label=backend.label,
color=color_map(backend.label),
)
if backend_i == 0:
# skip for now
pass
# monkey patch in a thing which prints the non swap gates
# from qiskit import transpile
# from qiskit.converters import circuit_to_dag
# from circuit_suite import circuits
# y = [circuit_to_dag(transpile(circuits[circuit_label].circuit_lambda(xi), basis_gates=['u', 'cx'])).count_ops_longest_path()['cx'] for xi in x]
# ax3.plot(x, y, marker='.', linestyle='--', label="Non-Swap Gate Count", color='black')
# ax3.set_ylabel("Critical Path SWAP Count")
# if last:
# ax3.set_xlabel("Num Qubits")
if first:
ax3.set_ylabel("Critical Path SWAPs") # vs Num Qubits")
if not duration == 2:
ax3.legend()
if not motivation:
# critical path swap gates
x = backend.data["0"][circuit_label]["gate_count"].keys()
x = [int(el) for el in list(x)]
y_best = np.ones(len(x)) * np.inf
y_average = np.zeros(len(x))
keys = [el for el in backend.data.keys() if el.isdigit()]
for iter_key in keys:
y = backend.data[iter_key][circuit_label]["gate_count"].values()
x, y = zip(*zip(x, y))
twoqgate_list = ["rzx", "riswap", "cx", "syc", "fSim"]
for twoqgate in twoqgate_list:
temp = [
el[twoqgate] if twoqgate in el.keys() else 0 for el in y
]
if temp[-1] != 0:
y = temp
break
# XXX monkey patch
x = list(x)
y = list(y)
if len(x) > 10:
for val in [4, 6, 10, 12, 14]:
if val in x:
del_index = x.index(val)
x.pop(del_index)
y.pop(del_index)
x, y = zip(*sorted(zip(x, y)))
for index, el in enumerate(y):
if y_best[index] > el:
y_best[index] = el
y_average[index] += el
y_average /= len(keys)
y_average = y_average[0 : len(x)]
if plot_average:
y = y_average
else:
y = y_best
ax2.plot(
x,
y,
marker=mark(backend.label),
label=backend.label,
color=color_map(backend.label),
)
# ax4.set_ylabel("Total 2Q Gate Count")
# if last:
# ax4.set_xlabel("Num Qubits")
if first:
ax2.set_ylabel("Total 2Q Count") # vs Num Qubits")
if not duration == 2:
ax2.legend()
# #duration
if not motivation:
x = backend.data["0"][circuit_label]["duration"].keys()
x = [int(el) for el in list(x)]
y_best = np.ones(len(x)) * np.inf
y_average = np.zeros(len(x))
keys = [el for el in backend.data.keys() if el.isdigit()]
for iter_key in keys:
y = backend.data[iter_key][circuit_label]["duration"].values()
# XXX monkey patch
x = list(x)
y = list(y)
if len(x) > 10:
for val in [4, 6, 10, 12, 14]:
if val in x:
del_index = x.index(val)
x.pop(del_index)
y.pop(del_index)
x, y = zip(*zip(x, y))
twoqgate_list = ["rzx", "riswap", "cx", "syc", "fSim"]
for twoqgate in twoqgate_list:
temp = [
el[twoqgate] if twoqgate in el.keys() else 0 for el in y
]
if temp[-1] != 0:
y = temp
break
for index, el in enumerate(y):
if y_best[index] > el:
y_best[index] = el
y_average[index] += el
y_average /= len(keys)
y_average = y_average[0 : len(x)]
if plot_average:
y = y_average
else:
y = y_best
ax3.plot(
x,
y,
marker=mark(backend.label),
label=backend.label,
color=color_map(backend.label),
)
# ax1.set_ylabel("Critical Path 2Q Pulse Duration")
# if last:
# ax1.set_xlabel("Num Qubits")
if first:
ax3.set_ylabel("Pulse Duration") # vs Num Qubits")
if 1 or motivation:
return ax3
return ax1
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
import numpy as np
import qiskit
from qiskit import QuantumCircuit
sys.path.append("..")
from external.NuOp.parallel_two_qubit_gate_decomposition import *
from external.NuOp.gates_numpy import (
cnot_gate,
fsim_gate,
cphase_gate,
xy_gate,
get_gate_unitary_qiskit,
iswap,
fsim,
)
from itertools import product
from qiskit.transpiler import PassManager
import sys
from clonk.utils.riswap_gates.riswap import RiSwapGate
import h5py
from tqdm import tqdm
# test
qc = QuantumCircuit(2)
from qiskit.quantum_info import random_unitary
qc.append(random_unitary(dims=(2, 2)), [0, 1])
# qc.draw(output='mpl')
from qiskit.converters import circuit_to_dag, dag_to_circuit
dag = circuit_to_dag(qc)
base_fidelity = 1 - 5e-3
alpha_range = [2, 3, 5, 7]
gate_range = range(2, 9)
qc = QuantumCircuit(2)
from qiskit.circuit.library.standard_gates import SwapGate
qc.append(SwapGate(), [0, 1])
dag = circuit_to_dag(qc)
# alpha_range = [2,3,4,5,6,7]
# # alpha_range = [5]
# gate_range = range(2,11)#9
# don't change, would break previous data collection
# XXX
alpha_range = [2, 3, 4, 5, 6, 7]
# # alpha_range = [5]
# gate_range = range(2,11)#9
# alpha_range = [1,2,3,4,5,6]
gate_range = range(2, 9) # 11
from qiskit.quantum_info import random_unitary
def collect_random2q_data(base_fidelity, N=15, mode="swap"):
# alpha_range = [2,3,4,5,6,7]
# # alpha_range = [5]
# gate_range = range(2,9)#11
base_fidelity = base_fidelity
empty_flag = 0
filename = f"data-archive2/data1_{mode}.h5" # f'data-archive2/data1_{mode}.h5' #f'data-archive/data1_{mode}.h5', #archive2 uses 2-7, archive3 uses 1-6
# filename = f'src/clonk/benchmark_suite/data/data5_{mode}.h5'
# load in previous data
try:
with h5py.File(filename, "r") as h5f:
# gate_error = h5f['random2q_gate_error'][:]
decomp_error = h5f["decomp_error"][:]
# fidelity_error = h5f['random2q_fidelity_error'][:]
# backfill data
gate_error = np.zeros(
shape=(len(decomp_error), len(alpha_range), len(gate_range))
)
fidelity_error = np.zeros(
shape=(len(decomp_error), len(alpha_range), len(gate_range))
)
for i in range(len(decomp_error)):
for alpha_index, alpha in enumerate(alpha_range):
alpha = 1 / alpha
for gate_index, gate_count in enumerate(gate_range):
gate_error[i][alpha_index][gate_index] = (
1 - (alpha * (1 - base_fidelity))
) ** gate_count
fidelity_error[i][alpha_index][gate_index] = (
decomp_error[i][alpha_index][gate_index]
) * gate_error[i][alpha_index][gate_index]
except Exception:
# case where data doesn't already exist
empty_flag = 1
decomp_error = []
for n in tqdm(range(N - len(decomp_error))):
# if not empty_flag and len(gate_error) >= N:
# break
qc = QuantumCircuit(2)
if mode == "random":
qc.append(random_unitary(dims=(2, 2)), [0, 1])
else:
qc.append(SwapGate(), [0, 1])
dag = circuit_to_dag(qc)
# new data for this iteration
temp_gate_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
temp_decomp_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
temp_fidelity_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
for alpha_index, alpha in enumerate(alpha_range):
alpha = 1 / alpha
for gate_index, gate_count in enumerate(gate_range):
params = [[alpha]]
gate_labels = [f"$iSwap^{alpha}$"]
gate_defs = [RiSwapGate]
temp_gate_error[0][alpha_index][gate_index] = (
1 - (alpha * (1 - base_fidelity))
) ** gate_count
# run perfect if it doesn't already exist
fid_2q = {(0, 1): [1]}
pgrp = ParallelGateReplacementPass(
gate_defs,
params,
fid_2q,
fidelity_list_1q_gate=[1 for _ in range(54)],
tol=1e-10,
force_gate_count=gate_count,
)
approx = pgrp.run(dag)
temp_decomp_error[0][alpha_index][gate_index] = pgrp.property_set[
"best_fid"
]
temp_fidelity_error[0][alpha_index][gate_index] = (
temp_gate_error[0][alpha_index][gate_index]
) * temp_decomp_error[0][alpha_index][gate_index]
# run noisy
# fid_2q = {(0,1):[1-alpha*(1-base_fidelity)]}
# pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# approx = pgrp.run(dag)
# temp_fidelity_error[0][alpha_index][gate_index] = (pgrp.property_set["best_fid"])
# these are equivalent - save some time and just calculate it using the previous values
# print(f"{gate_error[-1]}, {decomp_error[-1]}, {fidelity_error[-1]}")
# update data
if empty_flag:
gate_error = temp_gate_error
decomp_error = temp_decomp_error
fidelity_error = temp_fidelity_error
empty_flag = 0
else:
gate_error = np.append(gate_error, temp_gate_error, axis=0)
decomp_error = np.append(decomp_error, temp_decomp_error, axis=0)
fidelity_error = np.append(fidelity_error, temp_fidelity_error, axis=0)
# write back data after each iteration in case we end early
with h5py.File(filename, "a") as h5f:
print(f"saving iter {n}")
# delete old, differently sized dataset
try:
del h5f["gate_error"]
del h5f["decomp_error"]
del h5f["fidelity_error"]
except Exception:
# don't need to delete if they don't exist
pass
h5f.create_dataset("gate_error", data=gate_error)
h5f.create_dataset("decomp_error", data=decomp_error)
h5f.create_dataset("fidelity_error", data=fidelity_error)
return gate_error, decomp_error, fidelity_error
# #don't change, would break previous data collection
# from qiskit.quantum_info import random_unitary
# def fooo(base_fidelity, N=15, mode="swap"):
# #XXX
# alpha_range = [1]
# # alpha_range = [5]
# gate_range = range(2,4)#9
# base_fidelity = base_fidelity
# empty_flag = 0
# filename = f'data-archive2/data_fooo{mode}.h5' #f'data-archive/data1_{mode}.h5'
# # filename = f'data/data5_{mode}.h5'
# #load in previous data
# try:
# with h5py.File(filename, 'r') as h5f:
# #gate_error = h5f['random2q_gate_error'][:]
# decomp_error = h5f['decomp_error'][:]
# #fidelity_error = h5f['random2q_fidelity_error'][:]
# #backfill data
# gate_error = np.zeros(shape=(len(decomp_error), len(alpha_range), len(gate_range)))
# fidelity_error = np.zeros(shape=(len(decomp_error), len(alpha_range), len(gate_range)))
# for i in range(len(decomp_error)):
# for alpha_index, alpha in enumerate(alpha_range):
# alpha = 1/alpha
# for gate_index, gate_count in enumerate(gate_range):
# gate_error[i][alpha_index][gate_index] = ((1-(alpha*(1-base_fidelity)))**gate_count)
# fidelity_error[i][alpha_index][gate_index] = (decomp_error[i][alpha_index][gate_index])*gate_error[i][alpha_index][gate_index]
# except Exception:
# #case where data doesn't already exist
# empty_flag = 1
# decomp_error = []
# for n in range(N-len(decomp_error)):
# # if not empty_flag and len(gate_error) >= N:
# # break
# qc = QuantumCircuit(2)
# if mode == "random":
# qc.append(random_unitary(dims=(2,2)),[0,1])
# else:
# qc.append(SwapGate(), [0,1])
# dag = circuit_to_dag(qc)
# #new data for this iteration
# temp_gate_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
# temp_decomp_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
# temp_fidelity_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
# for alpha_index, alpha in enumerate(alpha_range):
# alpha = 1/alpha
# for gate_index, gate_count in enumerate(gate_range):
# params = [[alpha]]
# gate_labels = [f'$iSwap^{alpha}$']
# gate_defs = [RiSwapGate]
# temp_gate_error[0][alpha_index][gate_index] = ((1-(alpha*(1-base_fidelity)))**gate_count)
# #run perfect if it doesn't already exist
# fid_2q = {(0,1):[1]}
# pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# approx = pgrp.run(dag)
# temp_decomp_error[0][alpha_index][gate_index] = (pgrp.property_set["best_fid"])
# temp_fidelity_error[0][alpha_index][gate_index] = (temp_gate_error[0][alpha_index][gate_index])*temp_decomp_error[0][alpha_index][gate_index]
# #run noisy
# # fid_2q = {(0,1):[1-alpha*(1-base_fidelity)]}
# # pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# # approx = pgrp.run(dag)
# # temp_fidelity_error[0][alpha_index][gate_index] = (pgrp.property_set["best_fid"])
# #these are equivalent - save some time and just calculate it using the previous values
# # print(f"{gate_error[-1]}, {decomp_error[-1]}, {fidelity_error[-1]}")
# #update data
# if empty_flag:
# gate_error = temp_gate_error
# decomp_error = temp_decomp_error
# fidelity_error = temp_fidelity_error
# empty_flag = 0
# else:
# gate_error = np.append(gate_error, temp_gate_error, axis=0)
# decomp_error = np.append(decomp_error, temp_decomp_error, axis=0)
# fidelity_error = np.append(fidelity_error, temp_fidelity_error, axis=0)
# #write back data after each iteration in case we end early
# with h5py.File(filename, 'a') as h5f:
# print(f"saving iter {n}")
# # delete old, differently sized dataset
# try:
# del h5f['gate_error']
# del h5f['decomp_error']
# del h5f['fidelity_error']
# except Exception:
# #don't need to delete if they don't exist
# pass
# h5f.create_dataset('gate_error', data=gate_error)
# h5f.create_dataset('decomp_error', data=decomp_error)
# h5f.create_dataset('fidelity_error', data=fidelity_error)
# return gate_error, decomp_error, fidelity_error
# collect_random2q_data(.99, N=15, mode="random")
# qc = QuantumCircuit(2)
# from qiskit.quantum_info import random_unitary
# qc.append(random_unitary(dims=(2,2)),[0,1])
# dag = circuit_to_dag(qc)
# qc.decompose().draw(output='mpl')
# alpha = 1/2
# gate_count = 3
# params = [[alpha]]
# gate_labels = [f'$iSwap^{alpha}$']
# gate_defs = [RiSwapGate]
# #temp_gate_error[0][alpha_index][gate_index] = ((1-(alpha*(1-base_fidelity)))**gate_count)
# #run perfect if it doesn't already exist
# fid_2q = {(0,1):[1]}
# pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# approx = pgrp.run(dag)
# from qiskit.converters import dag_to_circuit
# print(pgrp.property_set["best_fid"])
# dag_to_circuit(approx).draw(output='mpl')
# alpha = 1/2
# gate_count = 3
# params = [[alpha]]
# gate_labels = [f'$iSwap^{alpha}$']
# gate_defs = [RiSwapGate]
# #temp_gate_error[0][alpha_index][gate_index] = ((1-(alpha*(1-base_fidelity)))**gate_count)
# #run perfect if it doesn't already exist
# fid_2q = {(0,1):[1]}
# pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# approx = pgrp.run(dag)
# from qiskit.converters import dag_to_circuit
# print(pgrp.property_set["best_fid"])
# dag_to_circuit(approx).draw(output='mpl')
from scipy.stats import sem
# import h5py
# with h5py.File('data.h5', 'r') as h5f:
# gate_error = h5f['random2q_gate_error'][:]
# decomp_error = h5f['random2q_decomp_error'][:]
# fidelity_error = h5f['random2q_fidelity_error'][:]
import matplotlib.pyplot as plt
plt.style.use(["science", "no-latex"])
def create_plot(gate_error, decomp_error, fidelity_error):
fig, axs = plt.subplots(
1, len(gate_error[0]), sharey=True, sharex=True, figsize=(12, 4)
)
for alpha_index in range(len(gate_error[0])):
alpha = 1 / alpha_range[alpha_index]
gate_unit_time = [el * alpha for el in gate_range]
axs[alpha_index].plot(
gate_unit_time,
np.average(gate_error, axis=0)[alpha_index],
label="Gate Error",
linestyle="--",
marker="o",
)
axs[alpha_index].errorbar(
gate_unit_time,
np.average(decomp_error, axis=0)[alpha_index],
yerr=sem(decomp_error, axis=0)[alpha_index],
label="Decomp Error",
linestyle="--",
marker="s",
)
axs[alpha_index].errorbar(
gate_unit_time,
np.average(fidelity_error, axis=0)[alpha_index],
yerr=sem(fidelity_error, axis=0)[alpha_index],
label="Total Fidelity",
marker="^",
)
axs[alpha_index].set_xlabel("Gate Unit Time")
axs[alpha_index].set_title(f"iSwap^(1/{1/alpha})")
# for i, key in enumerate(np.max(np.average(fidelity_error, axis=0),axis=1)):
# axs[i].annotate(key, (i, frequency_list[key]))
# if i >= 3:
# break
axs[-1].legend()
axs[0].set_ylabel("Avg Fidelity")
axs[0].set_yscale("logit")
fig.tight_layout()
fig.show()
filename = "nuop_experiment"
fig.savefig("{}.pdf".format(filename), format="pdf", facecolor="white")
# gate_error, decomp_error, fidelity_error = collect_random2q_data(1-5e-2, N=25, mode="random")
# create_plot(gate_error, decomp_error, fidelity_error)
from scipy.stats import sem
def get_max(fidelity_error):
max_list = []
sem_list = []
for alpha_index in range(len(fidelity_error[0])):
best_over_templatelength = 0
sem_temp = []
for template_length_index in range(len(fidelity_error[0][0])):
best_temp_average = []
for n_repetition in range(len(fidelity_error)):
best_temp_average.append(
fidelity_error[n_repetition][alpha_index][template_length_index]
)
val = np.sum(best_temp_average) / len(fidelity_error)
if val > best_over_templatelength:
best_over_templatelength = val
sem_temp = sem(best_temp_average)
# print(best_over_templatelength)
sem_list.append(sem_temp)
max_list.append(best_over_templatelength)
return max_list, sem_list
gate_error, decomp_error, fidelity_error = collect_random2q_data(
0.90, N=20, mode="random"
)
get_max(fidelity_error)
b = get_max(fidelity_error)
print((1 - b[0][1]) / (1 - b[0][1])) # 1/2
print((1 - b[0][1]) / (1 - b[0][2])) # 1/3
print((1 - b[0][1]) / (1 - b[0][3])) # 1/4
print((1 - b[0][1]) / (1 - b[0][4])) # 1/5
# gate_error, decomp_error, fidelity_error = fooo(.99, mode="random")
# # get_max(fidelity_error)
# get_max(fidelity_error)
# (1-.9874641583423502)/(1-0.9886633054798327)
N = 20
import itertools
marker = itertools.cycle(("o", "^", "s", "d", "v", "*"))
color = itertools.cycle(
(
"tab:blue",
"tab:olive",
"tab:purple",
"tab:red",
"tab:green",
"tab:pink",
"tab:orange",
"tab:cyan",
)
)
# color = itertools.cycle(("tab:green", "tab:pink", "tab:orange", "tab:cyan"))
base_fidelity_list = [0.97, 0.98, 1 - 10e-3, 1 - 5e-3, 1 - 10e-4, 1]
gate_error, decomp_error, fidelity_error = collect_random2q_data(
1 - 10e-3, N=N, mode="random"
)
from scipy.stats import sem
def create_plot2(gate_error, decomp_error, fidelity_error, plot_bool):
plt.style.use(["science"]) # , 'ieee'])
SMALL_SIZE = 4
MEDIUM_SIZE = 6
BIGGER_SIZE = 12
plt.rc("font", size=MEDIUM_SIZE + 2) # controls default text sizes
plt.rc("axes", titlesize=MEDIUM_SIZE + 2) # fontsize of the axes title
plt.rc("axes", labelsize=MEDIUM_SIZE + 1) # fontsize of the x and y labels
plt.rc("xtick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
plt.rc("ytick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
plt.rc("legend", fontsize=MEDIUM_SIZE) # legend fontsize
plt.rc("figure", titlesize=MEDIUM_SIZE + 2) # fontsize of the figure title
plt.rc("lines", markersize=1.2, linewidth=0.65)
# fig = plt.figure()
# gs = fig.add_gridspec(2,2)
# ax1 = fig.add_subplot(gs[0, 0])
# ax2 = fig.add_subplot(gs[0, 1])
# ax3 = fig.add_subplot(gs[1, :])
# axs = [ax1,ax2,ax3]
if plot_bool:
fig, axs = plt.subplots(
1, 2, figsize=(2, 1.25), sharey=True, gridspec_kw={"width_ratios": [1, 2]}
)
for alpha_index in range(len(gate_error[0])):
alpha = 1 / alpha_range[alpha_index]
set_color = next(color)
set_marker = next(marker)
#
gate_unit_time = gate_range
c = len([el for el in gate_unit_time if el <= 8])
axs[0].errorbar(
gate_unit_time[:c],
[1 - el for el in np.average(decomp_error, axis=0)[alpha_index][:c]],
yerr=sem(decomp_error, axis=0)[alpha_index][:c],
capsize=1.5,
elinewidth=0.5,
ecolor=set_color,
label=r"$\sqrt[" + str(int(1 / alpha)) + r"]{iSwap}$",
marker=set_marker,
color=set_color,
)
#
gate_unit_time = [el * alpha for el in gate_range]
# gate_unit_time = gate_range
# axs[1].plot(gate_unit_time, np.average(gate_error, axis=0)[alpha_index], label=f"Gate Error {alpha}", linestyle='--', marker='o')
# cutting off values past 2 to make pulse duration plot look nicer
c = len([el for el in gate_unit_time if el <= 2])
c_bottom = len(gate_unit_time) - len(
[el for el in gate_unit_time if el >= 0]
)
# c = len(gate_unit_time)
axs[1].errorbar(
gate_unit_time[c_bottom:c],
[
1 - el
for el in np.average(decomp_error, axis=0)[alpha_index][c_bottom:c]
],
yerr=sem(decomp_error, axis=0)[alpha_index][c_bottom:c],
capsize=1.5,
elinewidth=0.5,
ecolor=set_color,
label=r"$\sqrt[" + str(int(1 / alpha)) + r"]{iSwap}$",
marker=set_marker,
color=set_color,
)
# axs.errorbar(gate_unit_time, np.average(fidelity_error, axis=0)[alpha_index], yerr=sem(fidelity_error, axis=0)[alpha_index], label=f"Total Fidelity{alpha}", marker='^')
# axs[alpha_index].set_xlabel("Gate Unit Time")
# axs[alpha_index].set_title(f"iSwap^(1/{1/alpha})")
# for i, key in enumerate(np.max(np.average(fidelity_error, axis=0),axis=1)):
# axs[i].annotate(key, (i, frequency_list[key]))
# if i >= 3:
# break
axs[0].set_yscale("log")
# axs[1].set_xscale('log')
axs[0].set_xlabel(r"Gate Count ($k$)")
axs[1].set_xlabel(r"Pulse Duration ($k/n$)")
fig.suptitle(r"$\sqrt[n]{iSwap}$ Expected Decomp Fidelity")
# axs[0].legend(bbox_to_anchor=(2,-.2), ncol=2)
handles, labels = axs[0].get_legend_handles_labels()
# fig.legend(handles,labels,bbox_to_anchor=(.95,-.08),ncol=3)
# axs[0].legend(bbox_to_anchor=(1.0,-.2), ncol=2)
# axs[0].yaxis.set_major_locator(plt.LogitLocator(3))
# axs[0].ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# axs[-1].legend()
axs[0].set_ylabel(r"Avg Infidelity ($1-F_d$)")
axs[0].set_xticks(range(2, 9))
axs[0].minorticks_on()
axs[0].xaxis.set_tick_params(which="minor", bottom=False, top=False)
else: # if plot_bool:
fig, axs = plt.subplots(1, 1, figsize=(2, 1.15), sharey=True)
ydata = []
ysem = []
base_fidelity_list = np.arange(0.9, 1, 0.01)
for bf in base_fidelity_list:
gate_error, decomp_error, fidelity_error = collect_random2q_data(
bf, N=N, mode="random"
)
ydata.append(get_max(fidelity_error)[0])
ysem.append(get_max(fidelity_error)[1])
# axs.errorbar([bf]*len(alpha_range), get_max(fidelity_error)[0], yerr=get_max(fidelity_error)[1], capsize=1.5, elinewidth=.5, ecolor='black', linestyle="-", marker=next(marker), label=bf,color=next(color))
for i, n in enumerate(range(len(gate_error[0]))):
alpha = 1 / alpha_range[i]
set_color = next(color)
axs.errorbar(
base_fidelity_list,
[el[i] for el in ydata],
yerr=[el[i] for el in ysem],
capsize=1,
elinewidth=0.5,
ecolor=set_color,
linestyle="-",
marker=next(marker),
label=r"$\sqrt[" + str(int(1 / alpha)) + r"]{iSwap}$",
color=set_color,
)
# axs.set_xlabel(r"$\sqrt[x]{iSwap}$")
axs.set_xlabel(r"$F_b(\texttt{iSwap})$")
axs.invert_xaxis()
axs.set_yscale("linear")
axs.minorticks_on()
axs.xaxis.set_tick_params(which="minor", bottom=False, top=False)
# # axs[1].set_ylabel("Avg fidelity")
# # legend = axs[1].legend(title="iSwap Fidelity", bbox_to_anchor=(1.25,-.22), ncol=2)
axs.legend(bbox_to_anchor=(1.0, -0.22), ncol=3)
# # legend._legend_box.align = "bottoms"
# axs.yaxis.set_major_locator(plt.MaxNLocator(4))
axs.set_xticks(np.linspace(0.9, 1, 5))
# #axs[0].xaxis.set_major_locator(plt.MaxNLocator(integer=True))
# axs[1].ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# # axs[1].set_title(f"Random 2Q Fidelity vs nth root iswap")
# axs.set_yscale('log')
axs.set_ylabel(r"Avg Total Fidelity $F_t$")
# axs.set_ylabel("Average Fidelity")
axs.set_title(r"$\sqrt[n]{iSwap}$ Expected Total Fidelity")
# axs.minorticks_off()
# axs.set_ylabel("Average Infidelity")
# axs.set_xticks = [2,3,4,5,6,7,8]
# axs.minorticks_off()
# fig.suptitle(f"Random 2Q Fidelity (N={N})")
# plt.axes().xaxis.set_major_locator(plt.MaxNLocator(integer=True))
# fig.tight_layout()
fig.show()
filename = "nuop_experiment"
fig.savefig("{}.svg".format(filename), format="svg", facecolor=None)
create_plot2(gate_error, decomp_error, fidelity_error, plot_bool=0);
%matplotlib widget
print(np.array(fidelity_error).shape)
# base_fidelity_list = [1-10e-3,1-5e-3, 1-10e-4]
# fig, axs = plt.subplots(1, 1, sharey=True))
# for bf in base_fidelity_list:
# gate_error, decomp_error, fidelity_error = collect_random2q_data(bf, N=25, mode="random")
# axs.plot(alpha_range, np.max(np.average(fidelity_error, axis=0),axis=1), '-o', label=bf)
# axs.set_xlabel("nth root iswap")
# axs.set_ylabel("Avg fidelity")
# axs.set_title(f"Random 2Q Fidelity vs nth root iswap")
# axs.set_yscale('logit')
# fig.legend(loc='upper center', bbox_to_anchor=(0.5,0), ncol=3)
# fig.tight_layout()
# gate_error, decomp_error, fidelity_error = collect_random2q_data(1-5e-2, N=5, mode="swap")
# create_plot(gate_error, decomp_error, fidelity_error)
# base_fidelity_list = [1-10e-3,1-5e-3, 1-10e-4]
# fig, axs = plt.subplots(1, 1, sharey=True, figsize=(4, 4))
# for bf in base_fidelity_list:
# gate_error, decomp_error, fidelity_error = collect_random2q_data(bf, N=5, mode="swap")
# axs.plot(alpha_range, np.max(np.average(fidelity_error, axis=0),axis=1), '-o', label=bf)
# axs.set_xlabel("nth root iswap")
# axs.set_ylabel("max average fidelity")
# axs.set_title(f"Max fidelity vs nth root iswap")
# axs.set_yscale('logit')
# fig.legend()
# fig.tight_layout()
# #modify nuop so works with trotterization constraint - such that there is only U1 and U2 1Q gate solutions that are interleaved
# #eliminate gate_range parameter, beacuse now we must force the number of template reptetitions to be exactly n for nriswap
# #XXX
# from qiskit.converters import dag_to_circuit
# alpha_range = range(2,11)
# # alpha_range = [5]
# from qiskit.quantum_info import random_unitary
# def collect_trotterization_data(base_fidelity, N=15, mode="swap"):
# base_fidelity = base_fidelity
# empty_flag = 0
# filename = f'data/trotter_{mode}.h5'
# # filename = f'data/data5_{mode}.h5'
# #load in previous data
# try:
# with h5py.File(filename, 'r') as h5f:
# #gate_error = h5f['random2q_gate_error'][:]
# decomp_error = h5f['decomp_error'][:]
# #fidelity_error = h5f['random2q_fidelity_error'][:]
# #backfill data
# gate_error = np.zeros(shape=(len(decomp_error), len(alpha_range)))
# fidelity_error = np.zeros(shape=(len(decomp_error), len(alpha_range)))
# for i in range(len(decomp_error)):
# for alpha_index, alpha in enumerate(alpha_range):
# gate_count = alpha #constraint enforced by trotterization
# alpha = 1/alpha
# gate_error[i][alpha_index] = ((1-(alpha*(1-base_fidelity)))**gate_count)
# fidelity_error[i][alpha_index] = (decomp_error[i][alpha_index])*gate_error[i][alpha_index]
# except Exception:
# #case where data doesn't already exist
# empty_flag = 1
# decomp_error = []
# for n in range(N-len(decomp_error)):
# # if not empty_flag and len(gate_error) >= N:
# # break
# qc = QuantumCircuit(2)
# if mode == "random":
# qc.append(random_unitary(dims=(2,2)),[0,1])
# else:
# qc.append(SwapGate(), [0,1])
# dag = circuit_to_dag(qc)
# #new data for this iteration
# temp_gate_error = np.zeros(shape=(1, len(alpha_range)))
# temp_decomp_error = np.zeros(shape=(1, len(alpha_range)))
# temp_fidelity_error = np.zeros(shape=(1, len(alpha_range)))
# for alpha_index, alpha in enumerate(alpha_range):
# gate_count = alpha #constraint enforced by trotterization
# alpha = 1/alpha
# params = [[alpha]]
# gate_labels = [f'$iSwap^{alpha}$']
# gate_defs = [RiSwapGate]
# temp_gate_error[0][alpha_index] = ((1-(alpha*(1-base_fidelity)))**gate_count)
# #run perfect if it doesn't already exist
# fid_2q = {(0,1):[1]}
# pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count,trotterization=True)
# approx = pgrp.run(dag)
# #print(dag_to_circuit(approx).draw(fold=-1))
# print(f"Completed iter{n}, gate {alpha}...")
# temp_decomp_error[0][alpha_index] = (pgrp.property_set["best_fid"])
# temp_fidelity_error[0][alpha_index] = (temp_gate_error[0][alpha_index])*temp_decomp_error[0][alpha_index]
# #run noisy
# # fid_2q = {(0,1):[1-alpha*(1-base_fidelity)]}
# # pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# # approx = pgrp.run(dag)
# # temp_fidelity_error[0][alpha_index][gate_index] = (pgrp.property_set["best_fid"])
# #these are equivalent - save some time and just calculate it using the previous values
# # print(f"{gate_error[-1]}, {decomp_error[-1]}, {fidelity_error[-1]}")
# #update data
# if empty_flag:
# gate_error = temp_gate_error
# decomp_error = temp_decomp_error
# fidelity_error = temp_fidelity_error
# empty_flag = 0
# else:
# gate_error = np.append(gate_error, temp_gate_error, axis=0)
# decomp_error = np.append(decomp_error, temp_decomp_error, axis=0)
# fidelity_error = np.append(fidelity_error, temp_fidelity_error, axis=0)
# #write back data after each iteration in case we end early
# with h5py.File(filename, 'a') as h5f:
# print(f"saving iter {n}")
# # delete old, differently sized dataset
# try:
# del h5f['gate_error']
# del h5f['decomp_error']
# del h5f['fidelity_error']
# except Exception:
# #don't need to delete if they don't exist
# pass
# h5f.create_dataset('gate_error', data=gate_error)
# h5f.create_dataset('decomp_error', data=decomp_error)
# h5f.create_dataset('fidelity_error', data=fidelity_error)
# return gate_error, decomp_error, fidelity_error
# gate_error, decomp_error, fidelity_error = collect_trotterization_data(base_fidelity, N=1, mode="swap")
# gate_error.shape
# decomp_error
# gate_count = 3 #constraint enforced by trotterization
# alpha = 1/gate_count
# from qiskit.circuit.library.standard_gates import *
# qc = QuantumCircuit(2)
# mode = "swap"
# if mode == "random":
# qc.append(random_unitary(dims=(2,2)),[0,1])
# else:
# #qc.append(SwapGate(), [0,1])
# qc.append(CXGate(), [0,1])
# dag = circuit_to_dag(qc)
# params = [[alpha]]
# gate_labels = [r"$\sqrt[" + str(int(1/alpha))+ r"]{iSwap}$"]
# gate_defs = [RiSwapGate]
# fid_2q = {(0,1):[1]}
# pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# approx = pgrp.run(dag)
# print(f"Completed iter, gate {alpha}...")
# t = (pgrp.property_set["best_fid"])
# print(t)
# print(dag_to_circuit(approx).draw(output='mpl'))
# gate = Operator(dag_to_circuit(approx)).data
# gate = Operator(CXGate()).data
# import weylchamber
# c1, c2, c3 = weylchamber.c1c2c3(gate)
# print(c1,c2,c3)
# import itertools
# marker = itertools.cycle(('o', '^', 's', 'd'))
# color = itertools.cycle(("tab:blue", "tab:olive", "tab:purple", "tab:red", "tab:green", "tab:pink", "tab:orange", "tab:cyan"))
# #color = itertools.cycle(("tab:green", "tab:pink", "tab:orange", "tab:cyan"))
# base_fidelity_list = [1-10e-3,1-5e-3, 1-10e-4, 1]
# gate_error, decomp_error, fidelity_error = collect_trotterization_data(base_fidelity, N=1, mode="swap")
# from scipy.stats import sem
# def create_plot3(gate_error, decomp_error, fidelity_error):
# plt.style.use(['science', 'ieee'])
# SMALL_SIZE = 4
# MEDIUM_SIZE = 6
# BIGGER_SIZE = 12
# plt.rc("font", size=MEDIUM_SIZE+2) # controls default text sizes
# plt.rc("axes", titlesize=MEDIUM_SIZE+2) # fontsize of the axes title
# plt.rc("axes", labelsize=MEDIUM_SIZE + 1) # fontsize of the x and y labels
# plt.rc("xtick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
# plt.rc("ytick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
# plt.rc("legend", fontsize=MEDIUM_SIZE + 2) # legend fontsize
# plt.rc("figure", titlesize=MEDIUM_SIZE + 4) # fontsize of the figure title
# plt.rc("lines", markersize=2, linewidth=.75)
# fig, axs = plt.subplots(1,1, figsize=(2,1.75))
# if True:
# for alpha_index in range(len(gate_error[0])):
# alpha = 1/alpha_range[alpha_index]
# gate_unit_time = [el*alpha for el in gate_range]
# gate_unit_time = gate_range
# #axs[1].plot(gate_unit_time, np.average(gate_error, axis=0)[alpha_index], label=f"Gate Error {alpha}", linestyle='--', marker='o')
# axs.errorbar(gate_unit_time, [1-el for el in np.average(decomp_error, axis=0)[alpha_index]], yerr=sem(decomp_error, axis=0)[alpha_index], capsize=1.5, elinewidth=.5, ecolor='black', label=r"$\sqrt[" + str(int(1/alpha))+ r"]{iSwap}$", marker=next(marker), color=next(color))
# #axs.errorbar(gate_unit_time, np.average(fidelity_error, axis=0)[alpha_index], yerr=sem(fidelity_error, axis=0)[alpha_index], label=f"Total Fidelity{alpha}", marker='^')
# # axs[alpha_index].set_xlabel("Gate Unit Time")
# #axs[alpha_index].set_title(f"iSwap^(1/{1/alpha})")
# # for i, key in enumerate(np.max(np.average(fidelity_error, axis=0),axis=1)):
# # axs[i].annotate(key, (i, frequency_list[key]))
# # if i >= 3:
# # break
# axs.set_yscale('log')
# axs.set_xlabel("2Q Gate Count")
# axs.set_title("Decomp Infidelity")
# axs.legend(bbox_to_anchor=(1.2,-.2), ncol=2)
# axs.legend(bbox_to_anchor=(1.0,-.2), ncol=2)
# # axs[0].yaxis.set_major_locator(plt.LogitLocator(3))
# # axs[0].ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# # axs[-1].legend()
# axs.set_ylabel("Avg Fidelity")
# else:
# for bf in base_fidelity_list:
# gate_error, decomp_error, fidelity_error = collect_random2q_data(bf, N=N, mode="random")
# x_axis = alpha_range
# axs.errorbar(x_axis, get_max(fidelity_error)[0], yerr=get_max(fidelity_error)[1], capsize=1.5, elinewidth=.5, ecolor='black', linestyle="-", marker=next(marker), label=bf,color=next(color))
# axs.set_xlabel(r"$\sqrt[x]{iSwap}$")
# # # axs[1].set_ylabel("Avg fidelity")
# # # legend = axs[1].legend(title="iSwap Fidelity", bbox_to_anchor=(1.25,-.22), ncol=2)
# axs.legend(bbox_to_anchor=(1.25,-.22), ncol=2)
# # # legend._legend_box.align = "bottoms"
# # axs.yaxis.set_major_locator(plt.MaxNLocator(4))
# axs.xaxis.set_major_locator(plt.MaxNLocator(integer=True))
# # #axs[0].xaxis.set_major_locator(plt.MaxNLocator(integer=True))
# # axs[1].ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# # # axs[1].set_title(f"Random 2Q Fidelity vs nth root iswap")
# #axs.set_yscale('log')
# axs.set_ylabel("Avg Infidelity")
# #axs.set_ylabel("Average Fidelity")
# axs.set_title("Best Total Fidelity")
# #axs.minorticks_off()
# #axs.set_ylabel("Average Infidelity")
# #axs.set_xticks = [2,3,4,5,6,7,8]
# #axs.minorticks_off()
# #fig.suptitle(f"Random 2Q Fidelity (N={N})")
# #plt.axes().xaxis.set_major_locator(plt.MaxNLocator(integer=True))
# #fig.tight_layout()
# fig.show()
# filename = "nuop_experiment"
# fig.savefig('{}.pdf'.format(filename), format="pdf", facecolor='white')
# create_plot2(gate_error, decomp_error, fidelity_error)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
# %%
import h5py
import numpy as np
from qiskit import QuantumCircuit
from tqdm import tqdm
from external.NuOp.parallel_two_qubit_gate_decomposition import *
from clonk.utils.riswap_gates.riswap import RiSwapGate
# test
# %%
# don't change, would break previous data collection
# XXX
alpha_range = [2, 3, 4, 5, 6, 7]
# # alpha_range = [5]
# gate_range = range(2,11)#9
# alpha_range = [1,2,3,4,5,6]
gate_range = range(2, 9) # 11
from qiskit.quantum_info import random_unitary
def collect_random2q_data(base_fidelity, N=15, mode="swap", fn=None):
# alpha_range = [2,3,4,5,6,7]
# # alpha_range = [5]
# gate_range = range(2,9)#11
base_fidelity = base_fidelity
empty_flag = 0
filename = f"data-archive2/data1_{mode}.h5" # f'data-archive2/data1_{mode}.h5' #f'data-archive/data1_{mode}.h5', #archive2 uses 2-7, archive3 uses 1-6
# filename = f'src/clonk/benchmark_suite/data/data5_{mode}.h5'
if fn is not None:
filename = fn
# load in previous data
try:
with h5py.File(filename, "r") as h5f:
# gate_error = h5f['random2q_gate_error'][:]
decomp_error = h5f["decomp_error"][:]
# fidelity_error = h5f['random2q_fidelity_error'][:]
# backfill data
gate_error = np.zeros(
shape=(len(decomp_error), len(alpha_range), len(gate_range))
)
fidelity_error = np.zeros(
shape=(len(decomp_error), len(alpha_range), len(gate_range))
)
for i in range(len(decomp_error)):
for alpha_index, alpha in enumerate(alpha_range):
alpha = 1 / alpha
for gate_index, gate_count in enumerate(gate_range):
gate_error[i][alpha_index][gate_index] = (
1 - (alpha * (1 - base_fidelity))
) ** gate_count
fidelity_error[i][alpha_index][gate_index] = (
decomp_error[i][alpha_index][gate_index]
) * gate_error[i][alpha_index][gate_index]
except Exception:
# case where data doesn't already exist
empty_flag = 1
decomp_error = []
for n in tqdm(range(N - len(decomp_error))):
# if not empty_flag and len(gate_error) >= N:
# break
qc = QuantumCircuit(2)
if mode == "random":
qc.append(random_unitary(dims=(2, 2)), [0, 1])
else:
raise ValueError()
# qc.append(SwapGate(), [0,1])
dag = circuit_to_dag(qc)
# new data for this iteration
temp_gate_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
temp_decomp_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
temp_fidelity_error = np.zeros(shape=(1, len(alpha_range), len(gate_range)))
for alpha_index, alpha in enumerate(alpha_range):
alpha = 1 / alpha
for gate_index, gate_count in enumerate(gate_range):
params = [[alpha]]
gate_defs = [RiSwapGate]
temp_gate_error[0][alpha_index][gate_index] = (
1 - (alpha * (1 - base_fidelity))
) ** gate_count
# run perfect if it doesn't already exist
fid_2q = {(0, 1): [1]}
pgrp = ParallelGateReplacementPass(
gate_defs,
params,
fid_2q,
fidelity_list_1q_gate=[1 for _ in range(54)],
tol=1e-10,
force_gate_count=gate_count,
)
pgrp.run(dag)
temp_decomp_error[0][alpha_index][gate_index] = pgrp.property_set[
"best_fid"
]
temp_fidelity_error[0][alpha_index][gate_index] = (
temp_gate_error[0][alpha_index][gate_index]
) * temp_decomp_error[0][alpha_index][gate_index]
# run noisy
# fid_2q = {(0,1):[1-alpha*(1-base_fidelity)]}
# pgrp = ParallelGateReplacementPass(gate_defs, params ,fid_2q, fidelity_list_1q_gate=[1 for _ in range(54)], tol=1e-10, force_gate_count=gate_count)
# approx = pgrp.run(dag)
# temp_fidelity_error[0][alpha_index][gate_index] = (pgrp.property_set["best_fid"])
# these are equivalent - save some time and just calculate it using the previous values
# print(f"{gate_error[-1]}, {decomp_error[-1]}, {fidelity_error[-1]}")
# update data
if empty_flag:
gate_error = temp_gate_error
decomp_error = temp_decomp_error
fidelity_error = temp_fidelity_error
empty_flag = 0
else:
gate_error = np.append(gate_error, temp_gate_error, axis=0)
decomp_error = np.append(decomp_error, temp_decomp_error, axis=0)
fidelity_error = np.append(fidelity_error, temp_fidelity_error, axis=0)
# write back data after each iteration in case we end early
with h5py.File(filename, "a") as h5f:
print(f"saving iter {n}")
# delete old, differently sized dataset
try:
del h5f["gate_error"]
del h5f["decomp_error"]
del h5f["fidelity_error"]
except Exception:
# don't need to delete if they don't exist
pass
h5f.create_dataset("gate_error", data=gate_error)
h5f.create_dataset("decomp_error", data=decomp_error)
h5f.create_dataset("fidelity_error", data=fidelity_error)
return gate_error, decomp_error, fidelity_error
import matplotlib.pyplot as plt
# %%
from scipy.stats import sem
# import h5py
# with h5py.File('data.h5', 'r') as h5f:
# gate_error = h5f['random2q_gate_error'][:]
# decomp_error = h5f['random2q_decomp_error'][:]
# fidelity_error = h5f['random2q_fidelity_error'][:]
plt.style.use(["science", "no-latex"])
def create_plot(gate_error, decomp_error, fidelity_error):
fig, axs = plt.subplots(
1, len(gate_error[0]), sharey=True, sharex=True, figsize=(12, 4)
)
for alpha_index in range(len(gate_error[0])):
alpha = 1 / alpha_range[alpha_index]
gate_unit_time = [el * alpha for el in gate_range]
axs[alpha_index].plot(
gate_unit_time,
np.average(gate_error, axis=0)[alpha_index],
label="Gate Error",
linestyle="--",
marker="o",
)
axs[alpha_index].errorbar(
gate_unit_time,
np.average(decomp_error, axis=0)[alpha_index],
yerr=sem(decomp_error, axis=0)[alpha_index],
label="Decomp Error",
linestyle="--",
marker="s",
)
axs[alpha_index].errorbar(
gate_unit_time,
np.average(fidelity_error, axis=0)[alpha_index],
yerr=sem(fidelity_error, axis=0)[alpha_index],
label="Total Fidelity",
marker="^",
)
axs[alpha_index].set_xlabel("Gate Unit Time")
axs[alpha_index].set_title(f"iSwap^(1/{1/alpha})")
# for i, key in enumerate(np.max(np.average(fidelity_error, axis=0),axis=1)):
# axs[i].annotate(key, (i, frequency_list[key]))
# if i >= 3:
# break
axs[-1].legend()
axs[0].set_ylabel("Avg Fidelity")
axs[0].set_yscale("logit")
fig.tight_layout()
fig.show()
filename = "nuop_experiment"
fig.savefig("{}.pdf".format(filename), format="pdf", facecolor="white")
# %%
# gate_error, decomp_error, fidelity_error = collect_random2q_data(1-5e-2, N=25, mode="random")
# create_plot(gate_error, decomp_error, fidelity_error)
# %%
from scipy.stats import sem
def get_max(fidelity_error):
max_list = []
sem_list = []
for alpha_index in range(len(fidelity_error[0])):
best_over_templatelength = 0
sem_temp = []
for template_length_index in range(len(fidelity_error[0][0])):
best_temp_average = []
for n_repetition in range(len(fidelity_error)):
best_temp_average.append(
fidelity_error[n_repetition][alpha_index][template_length_index]
)
val = np.sum(best_temp_average) / len(fidelity_error)
if val > best_over_templatelength:
best_over_templatelength = val
sem_temp = sem(best_temp_average)
# print(best_over_templatelength)
sem_list.append(sem_temp)
max_list.append(best_over_templatelength)
return max_list, sem_list
# %%
import itertools
marker = itertools.cycle(("o", "^", "s", "d", "v", "*"))
color = itertools.cycle(
(
"tab:blue",
"tab:olive",
"tab:purple",
"tab:red",
"tab:green",
"tab:pink",
"tab:orange",
"tab:cyan",
)
)
# color = itertools.cycle(("tab:green", "tab:pink", "tab:orange", "tab:cyan"))
# base_fidelity_list = [.97, .98, 1-10e-3,1-5e-3, 1-10e-4, 1]
# gate_error, decomp_error, fidelity_error = collect_random2q_data(1-10e-3, N=20, mode="random")
from scipy.stats import sem
def create_plot2(gate_error, decomp_error, fidelity_error, plot_bool, N=20, fn=None):
plt.style.use(["science"]) # , 'ieee'])
SMALL_SIZE = 4
MEDIUM_SIZE = 6
plt.rc("font", size=MEDIUM_SIZE + 2) # controls default text sizes
plt.rc("axes", titlesize=MEDIUM_SIZE + 2) # fontsize of the axes title
plt.rc("axes", labelsize=MEDIUM_SIZE + 1) # fontsize of the x and y labels
plt.rc("xtick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
plt.rc("ytick", labelsize=SMALL_SIZE + 2) # fontsize of the tick labels
plt.rc("legend", fontsize=MEDIUM_SIZE) # legend fontsize
plt.rc("figure", titlesize=MEDIUM_SIZE + 2) # fontsize of the figure title
plt.rc("lines", markersize=1.2, linewidth=0.65)
# fig = plt.figure()
# gs = fig.add_gridspec(2,2)
# ax1 = fig.add_subplot(gs[0, 0])
# ax2 = fig.add_subplot(gs[0, 1])
# ax3 = fig.add_subplot(gs[1, :])
# axs = [ax1,ax2,ax3]
if plot_bool:
fig, axs = plt.subplots(
1, 2, figsize=(2, 1.25), sharey=True, gridspec_kw={"width_ratios": [1, 2]}
)
for alpha_index in range(len(gate_error[0])):
alpha = 1 / alpha_range[alpha_index]
set_color = next(color)
set_marker = next(marker)
#
gate_unit_time = gate_range
c = len([el for el in gate_unit_time if el <= 8])
axs[0].errorbar(
gate_unit_time[:c],
[1 - el for el in np.average(decomp_error, axis=0)[alpha_index][:c]],
yerr=sem(decomp_error, axis=0)[alpha_index][:c],
capsize=1.5,
elinewidth=0.5,
ecolor=set_color,
label=r"$\sqrt[" + str(int(1 / alpha)) + r"]{iSwap}$",
marker=set_marker,
color=set_color,
)
#
gate_unit_time = [el * alpha for el in gate_range]
# gate_unit_time = gate_range
# axs[1].plot(gate_unit_time, np.average(gate_error, axis=0)[alpha_index], label=f"Gate Error {alpha}", linestyle='--', marker='o')
# cutting off values past 2 to make pulse duration plot look nicer
c = len([el for el in gate_unit_time if el <= 2])
c_bottom = len(gate_unit_time) - len(
[el for el in gate_unit_time if el >= 0]
)
# c = len(gate_unit_time)
axs[1].errorbar(
gate_unit_time[c_bottom:c],
[
1 - el
for el in np.average(decomp_error, axis=0)[alpha_index][c_bottom:c]
],
yerr=sem(decomp_error, axis=0)[alpha_index][c_bottom:c],
capsize=1.5,
elinewidth=0.5,
ecolor=set_color,
label=r"$\sqrt[" + str(int(1 / alpha)) + r"]{iSwap}$",
marker=set_marker,
color=set_color,
)
# axs.errorbar(gate_unit_time, np.average(fidelity_error, axis=0)[alpha_index], yerr=sem(fidelity_error, axis=0)[alpha_index], label=f"Total Fidelity{alpha}", marker='^')
# axs[alpha_index].set_xlabel("Gate Unit Time")
# axs[alpha_index].set_title(f"iSwap^(1/{1/alpha})")
# for i, key in enumerate(np.max(np.average(fidelity_error, axis=0),axis=1)):
# axs[i].annotate(key, (i, frequency_list[key]))
# if i >= 3:
# break
axs[0].set_yscale("log")
# axs[1].set_xscale('log')
axs[0].set_xlabel(r"Gate Count ($k$)")
axs[1].set_xlabel(r"Pulse Duration ($k/n$)")
fig.suptitle(r"$\sqrt[n]{iSwap}$ Expected Decomp Fidelity")
# axs[0].legend(bbox_to_anchor=(2,-.2), ncol=2)
handles, labels = axs[0].get_legend_handles_labels()
# fig.legend(handles,labels,bbox_to_anchor=(.95,-.08),ncol=3)
# axs[0].legend(bbox_to_anchor=(1.0,-.2), ncol=2)
# axs[0].yaxis.set_major_locator(plt.LogitLocator(3))
# axs[0].ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# axs[-1].legend()
axs[0].set_ylabel(r"Avg Infidelity ($1-F_d$)")
axs[0].set_xticks(range(2, 9))
axs[0].minorticks_on()
axs[0].xaxis.set_tick_params(which="minor", bottom=False, top=False)
else: # if plot_bool:
fig, axs = plt.subplots(1, 1, figsize=(2, 1.15), sharey=True)
ydata = []
ysem = []
base_fidelity_list = np.arange(0.9, 1, 0.01)
for bf in base_fidelity_list:
gate_error, decomp_error, fidelity_error = collect_random2q_data(
bf, N=N, mode="random", fn=fn
)
ydata.append(get_max(fidelity_error)[0])
ysem.append(get_max(fidelity_error)[1])
# axs.errorbar([bf]*len(alpha_range), get_max(fidelity_error)[0], yerr=get_max(fidelity_error)[1], capsize=1.5, elinewidth=.5, ecolor='black', linestyle="-", marker=next(marker), label=bf,color=next(color))
for i, n in enumerate(range(len(gate_error[0]))):
alpha = 1 / alpha_range[i]
set_color = next(color)
axs.errorbar(
base_fidelity_list,
[el[i] for el in ydata],
yerr=[el[i] for el in ysem],
capsize=1,
elinewidth=0.5,
ecolor=set_color,
linestyle="-",
marker=next(marker),
label=r"$\sqrt[" + str(int(1 / alpha)) + r"]{iSwap}$",
color=set_color,
)
# axs.set_xlabel(r"$\sqrt[x]{iSwap}$")
axs.set_xlabel(r"$F_b(\texttt{iSwap})$")
axs.invert_xaxis()
axs.set_yscale("linear")
axs.minorticks_on()
axs.xaxis.set_tick_params(which="minor", bottom=False, top=False)
# # axs[1].set_ylabel("Avg fidelity")
# # legend = axs[1].legend(title="iSwap Fidelity", bbox_to_anchor=(1.25,-.22), ncol=2)
axs.legend(bbox_to_anchor=(1.0, -0.22), ncol=3)
# # legend._legend_box.align = "bottoms"
# axs.yaxis.set_major_locator(plt.MaxNLocator(4))
axs.set_xticks(np.linspace(0.9, 1, 5))
# #axs[0].xaxis.set_major_locator(plt.MaxNLocator(integer=True))
# axs[1].ticklabel_format(axis="y", style="sci", scilimits=(0, 0))
# # axs[1].set_title(f"Random 2Q Fidelity vs nth root iswap")
# axs.set_yscale('log')
axs.set_ylabel(r"Avg Total Fidelity $F_t$")
# axs.set_ylabel("Average Fidelity")
axs.set_title(r"$\sqrt[n]{iSwap}$ Expected Total Fidelity")
# axs.minorticks_off()
# axs.set_ylabel("Average Infidelity")
# axs.set_xticks = [2,3,4,5,6,7,8]
# axs.minorticks_off()
# fig.suptitle(f"Random 2Q Fidelity (N={N})")
# plt.axes().xaxis.set_major_locator(plt.MaxNLocator(integer=True))
# fig.tight_layout()
fig.show()
filename = "nuop_experiment"
fig.savefig("{}.svg".format(filename), format="svg", facecolor=None)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
import sys
sys.path.append("..")
from qiskit import transpile
from qiskit.converters import circuit_to_dag, dag_to_circuit
from circuit_suite import circuits
circuit_label = "QFT"
qsize = 3
qc = transpile(circuits[circuit_label].circuit_lambda(qsize)).decompose()
qc.draw(output="mpl")
# from qiskit import transpile
# from qiskit.converters import circuit_to_dag, dag_to_circuit
# from circuit_suite import circuits
# circuit_label="QFT"
# c = transpile(circuits[circuit_label].circuit_lambda(qsize), basis_gates=['u', 'cx'])
# c.draw(output='mpl')
dag = circuit_to_dag(qc)
def weight_fn(source_node, target_node, weight):
if dag._multi_graph[source_node].name is None:
return 0
else:
return 1
import retworkx
longest_path = retworkx.dag_longest_path(dag._multi_graph, weight_fn=weight_fn)
dlp = [dag._multi_graph[index] for index in longest_path]
for node in dag.op_nodes():
if not node in dlp:
dag.remove_op_node(node)
qc_t = dag_to_circuit(dag)
qc_t.draw(output="mpl")
x = [qsize]
y = [
circuit_to_dag(
transpile(circuits[circuit_label].circuit_lambda(xi), basis_gates=["u", "cx"])
).count_ops_longest_path()["cx"]
for xi in x
]
z = [
circuit_to_dag(
transpile(circuits[circuit_label].circuit_lambda(xi), basis_gates=["u", "cx"])
).count_ops()["cx"]
for xi in x
]
print(y, z)
c = transpile(circuits[circuit_label].circuit_lambda(qsize), basis_gates=["u", "cx"])
d = circuit_to_dag(c)
w = d._wires
for wi in w:
print([node.name for node in d.nodes_on_wire(wi, only_ops=True)])
c.draw(output="mpl")
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.circuit.library.basis_change import QFT
inverse_qft_lambda = lambda q: QFT(q, inverse=True)
qc = inverse_qft_lambda(qsize)
qc.decompose().draw(output="mpl")
# replace every R_z with a Riswap?
# can e made a transformation pass if wanted to
from qiskit.circuit.library.standard_gates import iSwapGate
from clonk.utils.riswap_gates.riswap import RiSwapGate
dag = circuit_to_dag(qc.decompose())
for node in dag.op_nodes():
# if we hit a Rz gate then replace it
if node.op.name in ["cp"]:
# get the rotation angle
angle = node.op.params[0]
replacement = QuantumCircuit(2)
# replacement.append(RiSwapGate(angle/np.pi), [0,1])
replacement.append(iSwapGate().power(angle / np.pi), [0, 1])
# replacement.draw(output='mpl')
dag.substitute_node_with_dag(node, circuit_to_dag(replacement))
# print(angle)
qc_modified = dag_to_circuit(dag)
qc_modified.draw(output="mpl")
nqubits = 3
number = 3
prep = QuantumCircuit(qsize)
for qubit in range(qsize):
prep.h(qubit)
prep.p(number * pi / 4, 0)
prep.p(number * pi / 2, 1)
prep.p(number * pi, 2)
prep.draw()
qc = prep + qc_modified
qc.draw(output="mpl")
# now simulate the qft to get a histogram
backend = sim = Aer.get_backend("aer_simulator")
qc.measure_all()
transpiled_qc = transpile(qc, backend, optimization_level=3, basis_gates=["u", "cx"])
job = backend.run(transpiled_qc, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
plot_histogram(counts)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
"""Define circuits to test"""
lambda_list = []
from supermarq.benchmarks import *
from supermarq.features import cirq_to_qiskit
# Random
# from qiskit.circuit.random import random_circuit
# random_lambda = lambda q: random_circuit(num_qubits=q, depth=q, measure=False, max_operands=2)
# lambda_list.append(random_lambda)
# # Quantum Volume
from qiskit.circuit.library import QuantumVolume
qv_lambda = lambda q: QuantumVolume(num_qubits=q, depth=q)
lambda_list.append(qv_lambda)
# QFT
from qiskit.circuit.library.basis_change import QFT
qft_lambda = lambda q: QFT(q)
lambda_list.append(qft_lambda)
# # Inverse QFT
# inverse_qft_lambda = lambda q: QFT(q, inverse=True)
# label = "IQFT"
# circuits[label] = CircuitTranspilerBenchmark(inverse_qft_lambda, q_range, label=label)
# QAOA, takes a long time to generate - consider capping max size before 20
# qaoa_lambda = lambda q: cirq_to_qiskit(QAOAFermionicSwapProxy(q).circuit())
# label = "QAOA_Fermionic_Swap"
# circuits[label] = CircuitTranspilerBenchmark(qaoa_lambda, q_range, label=label)
# # QAOA vanilla
qaoa_vanilla_lambda = lambda q: cirq_to_qiskit(QAOAVanillaProxy(q).circuit())
lambda_list.append(qaoa_vanilla_lambda)
# VQE - very slow to generate
# vqe_lambda = lambda q: cirq_to_qiskit(VQEProxy(q, 4).circuit()[0])
# label = "VQE"
# circuits[label] = CircuitTranspilerBenchmark(vqe_lambda, q_range, label=label)
# Simulation
hamiltonian_lambda = lambda q: cirq_to_qiskit(
HamiltonianSimulation(q, 1 / 10, 0.5).circuit()
)
lambda_list.append(hamiltonian_lambda)
# weighted adder or ripple carry adder
from qiskit.circuit.library.arithmetic.adders.cdkm_ripple_carry_adder import (
CDKMRippleCarryAdder,
)
from qiskit import QuantumCircuit
# using trick of composing into an empty circuit so that it builds everything into a single quantumregister
adder_lambda = (
lambda q: QuantumCircuit(q)
.compose(CDKMRippleCarryAdder(num_state_qubits=int((q - 1) / 2)), inplace=False)
.decompose()
.decompose()
.decompose()
)
lambda_list.append(adder_lambda)
# multiplier
from qiskit.circuit.library.arithmetic.multipliers import RGQFTMultiplier
multiplier_lambda = (
lambda q: QuantumCircuit(q)
.compose(RGQFTMultiplier(num_state_qubits=int(q / 4)), inplace=False)
.decompose()
.decompose()
.decompose()
)
lambda_list.append(multiplier_lambda)
# # GHZ
ghz_lambda = lambda q: cirq_to_qiskit(GHZ(q).circuit())
lambda_list.append(ghz_lambda)
import weylchamber
from qiskit.converters import circuit_to_dag
from qiskit import transpile
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import ConsolidateBlocks, Collect2qBlocks
from qiskit.quantum_info import Operator
# # Random
# from qiskit.circuit.random import random_circuit
# random_lambda = lambda q: random_circuit(num_qubits=q, depth=q, measure=False, max_operands=2)
# lambda_list = [random_lambda]
coordinate_list = []
for lambda_item in lambda_list:
circuit = lambda_item(16)
pm = PassManager()
pm.append(Collect2qBlocks())
pm.append(ConsolidateBlocks(force_consolidate=True))
transp_circuit = pm.run(circuit)
dag = circuit_to_dag(transp_circuit)
for gate in dag.collect_2q_runs():
assert len(gate) == 1
d = Operator(gate[0].op).data
coordinate_list.append(weylchamber.c1c2c3(d))
coordinate_freq = {i: coordinate_list.count(i) for i in set(coordinate_list)}
import matplotlib.pyplot as plt
plt.close()
fig = plt.figure()
ax = fig.add_subplot(111, projection="3d")
from weylchamber import WeylChamber
w = WeylChamber()
##
for k, v in coordinate_freq.items():
w.scatter(*k, s=0.6 * v)
##
w.labels = {}
w.render(ax)
plt.savefig("weyl.svg", format="svg", facecolor="None")
fig.show()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.