repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
!pip install qulacs
from qulacs import QuantumState,QuantumCircuit, Observable, PauliOperator
from qulacs.gate import X,Z,RX,RY,RZ,CNOT,merge,DenseMatrix,add
from qulacs.state import inner_product
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
# 量子ビットの数
nqubits = 4
# ダイナミクスをシミュレーションする時間
t = 10
# トロッター分解の分割数
M = 1000
# 時間の刻み幅
delta = t/M
## 横磁場の強さ
h = 1000
## 初期状態(nquibitsに合わせて変更)
state = QuantumState(nqubits)
initial_states = [0b0000, 0b1101, 0b1010]
## 全磁化に対応するオブザーバブルを準備しておく
magnetization_obs = Observable(nqubits)
for i in range(nqubits):
magnetization_obs.add_operator(PauliOperator("Z "+str(i), 1.0/nqubits))
## 時間と磁化を記録するリスト
x = [i*delta for i in range(M+1)]
ylist = []
# トロッター分解の1回分、
# e^{iZ_1Z_2*delta}*e^{iZ_2Z_3*delta}*...e^{iZ_nZ_1*delta} * e^{i X_1*delta}*...*e^{i X_n*delta} を量子ゲートに変換
circuit_trotter_transIsing = QuantumCircuit(nqubits)
for i in range(nqubits):
circuit_trotter_transIsing.add_CNOT_gate(i,(i+1)%(nqubits))
circuit_trotter_transIsing.add_RZ_gate((i+1)%nqubits,-2*delta)
circuit_trotter_transIsing.add_CNOT_gate(i,(i+1)%(nqubits))
circuit_trotter_transIsing.add_RX_gate(i, -2*delta*h)
for i in range(len(initial_states)):
y = []
state.set_computational_basis(initial_states[i])
#t=0の時の全磁化のみ先に計算
y.append( magnetization_obs.get_expectation_value(state) )
#t=0以降の全磁化を計算
for i in range(M):
# delta=t/Mだけ時間発展
circuit_trotter_transIsing.update_quantum_state(state)
# 磁化を計算して記録
y.append(magnetization_obs.get_expectation_value(state))
ylist.append(y)
#グラフの描画
plt.xlabel("time")
plt.ylabel("Value of magnetization")
plt.title("Dynamics of Ising model")
plt.ylim(-1.1, 1.1)
for i in range(len(initial_states)):
plt.plot(x, ylist[i], "-",label=bin(initial_states[i])[2:].ljust(nqubits, '0'))
plt.legend()
plt.show()
## 初期状態
state_trotter = QuantumState(nqubits)
state_trotter.set_computational_basis(initial_states[0])
state_exact = QuantumState(nqubits)
state_exact.set_computational_basis(initial_states[0])
# トロッター分解の1回分、
# e^{iZ_1Z_2*delta}*e^{iZ_2Z_3*delta}*...e^{iZ_nZ_1*delta} * e^{i X_1*delta}*...*e^{i X_n*delta} を量子ゲートに変換
circuit_trotter_transIsing = QuantumCircuit(nqubits)
for i in range(nqubits):
circuit_trotter_transIsing.add_CNOT_gate(i,(i+1)%(nqubits))
circuit_trotter_transIsing.add_RZ_gate((i+1)%nqubits,-2*delta) ## RZ(a)=exp(i*a/2*Z)に注意
circuit_trotter_transIsing.add_CNOT_gate(i,(i+1)%(nqubits))
circuit_trotter_transIsing.add_RX_gate(i, -2*delta*h) ## RX(a)=exp(i*a/2*X)に注意
# e^{-iHt}を直接対角化する。Hの行列表現を得るために、gateを生成してそのmatrixを取得する
zz_matrix = -np.array([[1,0,0,0],[0,-1,0,0],[0,0,-1,0],[0,0,0,1]]) ## Z_i*Z_{i+1}の行列表示
hx_matrix = -h*np.array( [ [0,1], [1,0] ] )
zz = DenseMatrix([0,1], zz_matrix) ## 0~1間の相互作用
hx = DenseMatrix(0, hx_matrix) ## 0サイトへの横磁場
## qulacs.gate.addを用いて、1以降のサイトの相互作用と横磁場を足していく
for i in range(1, nqubits):
zz = add(zz, DenseMatrix([i,(i+1)%nqubits], zz_matrix))
hx = add(hx, DenseMatrix(i, hx_matrix) )
## 最終的なハミルトニアン
ham = add(zz, hx)
matrix = ham.get_matrix() #行列の取得
eigenvalue, P = np.linalg.eigh(np.array(matrix)) #取得した行列の固有値、固有ベクトルを取得
## e^{-i*H*delta}を行列として作る
e_iHdelta = np.diag(np.exp(-1.0j*eigenvalue*delta))
e_iHdelta = np.dot(P, np.dot(e_iHdelta, P.T))
## 回路に変換
circuit_exact_transIsing = QuantumCircuit(nqubits)
circuit_exact_transIsing.add_dense_matrix_gate( np.arange(nqubits), e_iHdelta)
## 時間と磁化を記録するリスト
x = [i*delta for i in range(M+1)]
y_trotter = []
y_exact = []
#t=0の時の全磁化のみ先に計算
y_trotter.append( magnetization_obs.get_expectation_value(state_trotter) )
y_exact.append( magnetization_obs.get_expectation_value(state_exact) )
#t=0以降の全磁化を計算
for i in range(M):
# delta=t/Mだけ時間発展
circuit_trotter_transIsing.update_quantum_state(state_trotter)
circuit_exact_transIsing.update_quantum_state(state_exact)
# 磁化を計算して記録
y_trotter.append( magnetization_obs.get_expectation_value(state_trotter) )
y_exact.append( magnetization_obs.get_expectation_value(state_exact) )
#グラフの描画
plt.xlabel("time")
plt.ylabel("Value of magnetization")
plt.title("Dynamics of transverse Ising model")
plt.plot(x, y_trotter, "-", label="Trotter")
plt.plot(x, y_exact, "-", label="exact")
plt.ylim(-1.1, 1.1)
plt.legend()
plt.show()
#エラーの描画
plt.xlabel("time")
plt.ylabel("Value of magnetization")
plt.title("Error")
plt.plot(x, np.abs(np.array(y_trotter) - np.array(y_exact)), "-", label="Trotter")
plt.legend()
plt.show()
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
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/daimurat/qiskit-implementation
|
daimurat
|
from qiskit import Aer
from qiskit.circuit.library import QFT
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.quantum_info import state_fidelity
from qiskit.aqua.algorithms import HHL, NumPyLSsolver
from qiskit.aqua.components.eigs import EigsQPE
from qiskit.aqua.components.reciprocals import LookupRotation
from qiskit.aqua.operators import MatrixOperator
from qiskit.aqua.components.initial_states import Custom
import numpy as np
def create_eigs(matrix, num_ancillae, num_time_slices, negative_evals):
ne_qfts = [None, None]
if negative_evals:
num_ancillae += 1
# The QFT and IQFT circuits for handling negative eigenvalues
ne_qfts = [QFT(num_ancillae - 1), QFT(num_ancillae - 1).inverse()]
"""
Specifically, this class is based on PhaseEstimationCircuit with no measurements
and has additional handling of negative eigenvalues
"""
return EigsQPE(MatrixOperator(matrix=matrix),
QFT(num_ancillae).inverse(),
num_time_slices=num_time_slices,
num_ancillae=num_ancillae,
expansion_mode='suzuki',
expansion_order=2,
evo_time=None, # This is t, can set to: np.pi*3/4
negative_evals=negative_evals,
ne_qfts=ne_qfts)
# 信頼度
def fidelity(hhl, ref):
solution_hhl_normed = hhl / np.linalg.norm(hhl)
solution_ref_normed = ref / np.linalg.norm(ref)
fidelity = state_fidelity(solution_hhl_normed, solution_ref_normed)
print("Fidelity:\t\t %f" % fidelity)
matrix = [[1, -1/3], [-1/3, 1]]
vector = [1, 0]
orig_size = len(vector)
# 行列Aがハミルトニアンでない場合はtrancate_hermitian利用
matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize(matrix, vector)
# Initialize eigenvalue finding module
eigs = create_eigs(matrix, 3, 50, False)
num_q, num_a = eigs.get_register_sizes()
# Initialize initial state module
init_state = Custom(num_q, state_vector=vector)
# Initialize reciprocal rotation module
reci = LookupRotation(negative_evals=eigs._negative_evals, evo_time=eigs._evo_time)
"""
Args:
matrix: The input matrix of linear system of equations
vector: The input vector of linear system of equations
truncate_powerdim: Flag indicating expansion to 2**n matrix to be truncated
truncate_hermitian: Flag indicating expansion to hermitian matrix to be truncated
eigs: The eigenvalue estimation instance
init_state: The initial quantum state preparation
reciprocal: The eigenvalue reciprocal and controlled rotation instance
num_q: Number of qubits required for the matrix Operator instance
num_a: Number of ancillary qubits for Eigenvalues instance
orig_size: The original dimension of the problem (if truncate_powerdim)
quantum_instance: Quantum Instance or Backend
"""
algo = HHL(matrix, vector, truncate_powerdim, truncate_hermitian, eigs,
init_state, reci, num_q, num_a, orig_size)
result = algo.run(QuantumInstance(Aer.get_backend('statevector_simulator')))
print("Solution:\t\t", np.round(result['solution'], 5))
result_ref = NumPyLSsolver(matrix, vector).run()
print("Classical Solution:\t", np.round(result_ref['solution'], 5))
print("Probability:\t\t %f" % result['probability_result'])
fidelity(result['solution'], result_ref['solution'])
algo = HHL(matrix, vector)
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
# Import requisite modules
import math
import operator
import logging
import traceback
import datetime
import sys
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# Import Qiskit packages
import qiskit
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
# setup aqua 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
# The data providers of stock-market data
from qiskit.finance.data_providers import *
from qiskit.finance.applications.ising import portfolio_diversification
# Generate a pairwise time-series similarity matrix
n = 3
stocks = [("TICKER%s" % i) for i in range(n)]
## if loading fails, a constant matrix instead
# rho = np.ones((n,n))
# rho[0,1] = 0.8
# rho[1,0] = 0.8
data = RandomDataProvider(tickers = stocks,
start = datetime.datetime(2016,1,1),
end = datetime.datetime(2016,1,30))
data.run()
rho = data.get_similarity_matrix() # using dynamic time warping
# Actually, we consider the additive inverse to invert the direction of optimisation.
rho = -1 * rho
plt.imshow(rho)
plt.show()
print(rho)
print("The underlying evolution of stock prices:")
for (cnt, s) in enumerate(data._tickers):
plt.plot(data._data[cnt], label=s)
plt.legend()
plt.show()
q = 1 # q less or equal than n
class ClassicalOptimizer:
def __init__(self, rho, n, q):
self.rho = rho
self.n = n # number of inner variables
self.q = q # number of required selection
def compute_allowed_combinations(self):
f = math.factorial
return int(f(self.n) / f(self.q) / f(self.n - self.q))
def cplex_solution(self):
# refactoring
rho = self.rho
n = self.n
q = self.q
my_obj = list(rho.reshape(1, n ** 2)[0]) + [0. for x in range(0, n)]
my_ub = [1 for x in range(0, n ** 2 + n)]
my_lb = [0 for x in range(0, n ** 2 + n)]
my_ctype = "".join(['I' for x in range(0, n ** 2 + n)])
my_rhs = [q] + [1 for x in range (0, n)] +[0 for x in range (0, n)] + [0.1 for x in range(0, n ** 2)]
my_sense = "".join(['E' for x in range(0, 1+n)]) + "".join(['E' for x in range(0, n)]) + "".join(
['L' for x in range(0, n ** 2)])
try:
my_prob = cplex.Cplex()
self.populatebyrow(my_prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs)
my_prob.solve()
except CplexError as exc:
print(exc)
return
x = my_prob.solution.get_values()
x = np.array(x)
cost = my_prob.solution.get_objective_value()
return x, cost
def populatebyrow(self, prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs):
n = self.n
prob.objective.set_sense(prob.objective.sense.minimize)
prob.variables.add(obj=my_obj, lb=my_lb, ub=my_ub, types=my_ctype)
prob.set_log_stream(None)
prob.set_error_stream(None)
prob.set_warning_stream(None)
prob.set_results_stream(None)
rows = []
col = [x for x in range(n**2, n**2+n)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
for ii in range(0, n):
col = [x for x in range(0+n*ii, n+n*ii)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
for ii in range(0, n):
col = [ii * n + ii, n ** 2 + ii]
coef = [1, -1]
rows.append([col, coef])
for ii in range(0, n):
for jj in range(0, n):
col = [ii*n + jj, n ** 2 + jj]
coef = [1, -1]
rows.append([col, coef])
prob.linear_constraints.add(lin_expr=rows, senses=my_sense, rhs=my_rhs)
# Instantiate the classical optimizer class
classical_optimizer = ClassicalOptimizer(rho, n, q)
# Compute the number of feasible solutions:
print('Number of feasible combinations= ' + str(classical_optimizer.compute_allowed_combinations()))
# Compute the total number of possible combinations (feasible + unfeasible)
print('Total number of combinations= ' + str(2 ** (n*(n+1))))
# Visualize the solution
def visualize_solution(xc, yc, x, C, n, K, title_str):
plt.figure()
# 各銘柄の座標
plt.scatter(xc, yc, s=200)
for i in range(len(xc)):
plt.annotate(i, (xc[i] + 0.015, yc[i]), size=16, color='r')
plt.grid()
# y_j : which stocks j are in the index fund
for ii in range(n ** 2, n **2 + n):
if x[ii] > 0:
# plot coordinate of the stocks in the index fund
plt.plot(xc[ii-n**2], yc[ii-n**2], 'r*', ms=20)
# x_ij
for ii in range(0, n ** 2):
if x[ii] > 0:
iy = ii // n # i
ix = ii % n # j
plt.plot([xc[ix], xc[iy]], [yc[ix], yc[iy]], 'C2')
plt.title(title_str +' cost = ' + str(int(C * 100) / 100.))
plt.show()
from qiskit.aqua.operators import StateFn
class QuantumOptimizer:
def __init__(self, rho, n, q):
self.rho = rho
self.n = n
self.q = q
# Obtains the least eigenvalue of the Hamiltonian classically
def exact_solution(self):
qubitOp = portfolio_diversification.get_operator(self.rho, self.n, self.q)
result = NumPyMinimumEigensolver(qubitOp).run()
return self.decode_result(result)
def vqe_solution(self):
qubitOp = portfolio_diversification.get_operator(self.rho, self.n, self.q)
backend = Aer.get_backend('statevector_simulator')
seed = 50
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cz', reps=5, entanglement='full')
vqe = VQE(qubitOp, ry, cobyla)
vqe.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
result = vqe.run(quantum_instance)
return self.decode_result(result)
def qaoa_solution(self):
qubitOp = portfolio_diversification.get_operator(self.rho, self.n, self.q)
backend = Aer.get_backend('statevector_simulator')
seed = 50
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
qaoa = QAOA(qubitOp, cobyla, 3, 'matrix')
qaoa.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
result = qaoa.run(quantum_instance)
return self.decode_result(result)
def get_portfoliodiversification_solution(self, n, result):
v = result.eigenstate
if isinstance(v, StateFn):
v = v.to_matrix()
N = n ** 2 + n
index_value = [x for x in range(len(v)) if v[x] == max(v)][0]
string_value = "{0:b}".format(index_value)
while len(string_value) < N:
string_value = '0' + string_value
x_state = list()
for elements in string_value:
if elements == '0':
x_state.append(0)
else:
x_state.append(1)
x_state = np.flip(x_state, axis=0)
return x_state
def decode_result(self, result, offset = 0):
quantum_solution = self.get_portfoliodiversification_solution(self.n, result)
ground_level = portfolio_diversification.get_portfoliodiversification_value(self.rho, self.n, self.q, quantum_solution)
return quantum_solution, ground_level
# Instantiate the quantum optimizer class with parameters:
quantum_optimizer = QuantumOptimizer(rho, n, q)
# Check if the binary representation is correct. This requires CPLEX
try:
import cplex
#warnings.filterwarnings('ignore')
quantum_solution, quantum_cost = quantum_optimizer.exact_solution()
classical_solution, classical_cost = classical_optimizer.cplex_solution()
print(quantum_cost, classical_cost)
if np.abs(quantum_cost - classical_cost) < 0.01:
print('Binary formulation is correct')
else: print('Error in the formulation of the Hamiltonian')
except Exception as ex:
print(ex)
ground_state, ground_level = quantum_optimizer.exact_solution()
print(ground_state, ground_level)
try:
if np.abs(ground_level - classical_cost)<0.01:
print('Ising Hamiltonian in Z basis is correct')
else: print('Error in the Ising Hamiltonian formulation')
except Exception as ex:
print(ex)
vqe_state, vqe_level = quantum_optimizer.vqe_solution()
print(vqe_state, vqe_level)
try:
if np.linalg.norm(ground_state - vqe_state)<0.01:
print('VQE produces the same solution as the exact eigensolver.')
else: print('VQE does not produce the same solution as the exact eigensolver, but that is to be expected.')
except Exception as ex:
print(ex)
# qaoa_state, qaoa_level = quantum_optimizer.qaoa_solution()
# print(qaoa_state)
# try:
# if np.linalg.norm(ground_state - qaoa_state)<0.01:
# print('QAOA produces the same solution as the exact eigensolver.')
# else: print('QAOA does not produce the same solution as the exact eigensolver, but that is to be expected.')
# except Exception as ex:
# print(ex)
xc, yc = data.get_coordinates() # generate random coordinate
visualize_solution(xc, yc, ground_state, ground_level, n, q, 'Classical')
visualize_solution(xc, yc, vqe_state, vqe_level, n, q, 'VQE')
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
from qiskit import Aer
from qiskit.circuit.library import TwoLocal
from qiskit.aqua import QuantumInstance
from qiskit.finance import QiskitFinanceError
from qiskit.finance.applications.ising import portfolio
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.finance.data_providers import *
from qiskit.aqua.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import COBYLA
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import datetime
import pandas as pd
import pandas_datareader.data as web
from pandas.plotting import register_matplotlib_converters
import warnings
warnings.filterwarnings("ignore", category=DeprecationWarning)
register_matplotlib_converters()
# set number of assets (= number of qubits)
num_assets = 4
# # Generate expected return and covariance matrix from (random) time-series
# stocks = [("TICKER%s" % i) for i in range(num_assets)]
# data = RandomDataProvider(tickers=stocks,
# start=datetime.datetime(2016,1,1),
# end=datetime.datetime(2016,1,30))
# data.run()
# mu = data.get_period_return_mean_vector() # 平均期待リターン
# sigma = data.get_period_return_covariance_matrix() # 共分散行列
# print(mu)
# print(sigma)
# print("The underlying evolution of stock prices:")
# for (cnt, s) in enumerate(data._tickers):
# plt.plot(data._data[cnt], label=s)
# plt.legend()
# plt.xticks(rotation=90)
# plt.show()
# for (cnt, s) in enumerate(data._tickers):
# time_data = [(data._data[cnt][i] - data._data[cnt][i-1])/data._data[cnt][i-1] for i in range(1, len(data._data[cnt]))]
# print(sum(time_data)/len(data._data[cnt]))
stocks = ["GOOG", "AAPL", "FB", "AMZN"]
token = "" # API KEYを入れる
try:
wiki = WikipediaDataProvider(
token = token,
tickers = stocks,
start = datetime.datetime(2016,1,1),
end = datetime.datetime(2016,1,30))
wiki.run()
except QiskitFinanceError as ex:
print(ex)
print("Error retrieving data.")
if wiki._data:
if wiki._n <= 1:
print("Not enough wiki data to plot covariance or time-series similarity. Please use at least two tickers.")
else:
mu = wiki.get_period_return_mean_vector()
print("A return mean vector:")
print(mu)
sigma = wiki.get_covariance_matrix()
print("A covariance matrix:")
print(sigma)
plt.imshow(sigma)
plt.show()
else:
print('No wiki data loaded.')
if wiki._data:
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 6))
print("The underlying evolution of stock prices:")
for (cnt, s) in enumerate(stocks):
axis = 0 if s in ("GOOG","AMZN") else 1
wiki._data[cnt].plot(ax=axes[axis], label=s, legend=True)
else:
print('No wiki data loaded.')
q = 0.5 # set risk factor
budget = num_assets // 2 # set budget (the number of assets to be selected out of n)
penalty = num_assets # set parameter to scale the budget penalty term
qubitOp, offset = portfolio.get_operator(mu, sigma, q, budget, penalty)
def index_to_selection(i, num_assets):
s = "{0:b}".format(i).rjust(num_assets)
x = np.array([1 if s[i]=='1' else 0 for i in reversed(range(num_assets))])
return x
def print_result(result):
selection = sample_most_likely(result.eigenstate)
value = portfolio.portfolio_value(selection, mu, sigma, q, budget, penalty)
np.set_printoptions(formatter={'float': '{:.4f}'.format})
print('Optimal: selection {}, value {}'.format(selection, value))
eigenvector = result.eigenstate if isinstance(result.eigenstate, np.ndarray) else result.eigenstate.to_matrix()
probabilities = np.abs(eigenvector)**2
i_sorted = reversed(np.argsort(probabilities))
print('\n----------------- Full result ---------------------')
print('selection\tvalue\t\tprobability')
print('---------------------------------------------------')
for i in i_sorted:
x = index_to_selection(i, num_assets)
value = portfolio.portfolio_value(x, mu, sigma, q, budget, penalty)
probability = probabilities[i]
print('%10s\t%.4f\t\t%.4f' %(x, value, probability))
exact_eigensolver = NumPyMinimumEigensolver(qubitOp)
result_classical = exact_eigensolver.run()
print_result(result_classical)
backend = Aer.get_backend('statevector_simulator')
seed = 50
cobyla = COBYLA()
cobyla.set_options(maxiter=500)
ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cz', reps=3, entanglement='full')
vqe = VQE(qubitOp, ry, cobyla)
vqe.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
result_vqe = vqe.run(quantum_instance)
print_result(result_vqe)
backend = Aer.get_backend('statevector_simulator')
seed = 50
cobyla = COBYLA()
cobyla.set_options(maxiter=250)
qaoa = QAOA(qubitOp, cobyla, 3)
qaoa.random_seed = seed
quantum_instance = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
result_qaoa = qaoa.run(quantum_instance)
print_result(result_qaoa)
try:
wiki = WikipediaDataProvider(
token = token,
tickers = stocks,
start = datetime.datetime(2016,1,31),
end = datetime.datetime(2016,12,31))
wiki.run()
except QiskitFinanceError as ex:
print(ex)
print("Error retrieving data.")
if wiki._data:
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 6))
print("The underlying evolution of stock prices:")
for (cnt, s) in enumerate(stocks):
axis = 0 if s in ("GOOG","AMZN") else 1
wiki._data[cnt].plot(ax=axes[axis], label=s, legend=True)
else:
print('No wiki data loaded.')
selection_classical = sample_most_likely(result_classical.eigenstate)
selection_vqe = sample_most_likely(result_vqe.eigenstate)
selection_qaoa = sample_most_likely(result_qaoa.eigenstate)
selection_cheat = [0,0,0,1]
selection_all = {'classical':selection_classical, 'VQE':selection_vqe, 'QAOA':selection_qaoa, 'cheat':selection_cheat}
if wiki._data:
print("back test")
for label, selection in selection_all.items():
total_price = 0
initial_price = 0
for (cnt, s) in enumerate(stocks):
if selection[cnt] == 1:
total_price += wiki._data[cnt]
initial_price += wiki._data[cnt][0]
plt.plot(total_price/initial_price, label=label)
plt.legend()
plt.xticks(rotation=90)
plt.show()
else:
print('No wiki data loaded.')
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
# データ取得に必要なpandas, pandas_datareaderのインストール
!pip install pandas pandas_datareader
import numpy as np
import pandas as pd
import pandas_datareader.data as web
import datetime
import matplotlib.pyplot as plt
from qiskit import Aer
from qiskit.circuit.library import QFT
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.quantum_info import state_fidelity
from qiskit.aqua.algorithms import HHL, NumPyLSsolver
from qiskit.aqua.components.eigs import EigsQPE
from qiskit.aqua.components.reciprocals import LookupRotation
from qiskit.aqua.operators import MatrixOperator
from qiskit.aqua.components.initial_states import Custom
# 銘柄選択
codes = ["GOOG", 'AAPL', 'FB', 'AMZN'] # GAFA
# 2017年の1年間のデータを使用
start = datetime.datetime(2017, 1, 1)
end = datetime.datetime(2017, 12, 31)
# Yahoo! Financeから日次の株価データを取得
data = web.DataReader(codes, 'yahoo', start, end)
df = data['Adj Close']
## 直近のデータの表示
display(df.tail())
## 株価をプロットしてみる
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 6))
df.loc[:,['AAPL', 'FB']].plot(ax=axes[0])
df.loc[:,['GOOG', 'AMZN']].plot(ax=axes[1])
daily_return = df.pct_change()
display(daily_return.tail())
expected_return = daily_return.dropna(how='all').mean() * 252 # 年率換算のため年間の営業日数252を掛ける
print(expected_return)
cov = daily_return.dropna(how='all').cov() * 252 # 年率換算のため
display(cov)
R = expected_return.values
Pi = np.ones(4)
S = cov.values
row1 = np.append(np.zeros(2), R).reshape(1,-1)
row2 = np.append(np.zeros(2), Pi).reshape(1,-1)
row3 = np.concatenate([R.reshape(-1,1), Pi.reshape(-1,1), S], axis=1)
W = np.concatenate([row1, row2, row3])
np.set_printoptions(linewidth=200)
print(W)
mu = 0.1 # ポートフォリオのリターン
xi = 1.0
mu_xi_0 = np.append(np.array([mu, xi]), np.zeros_like(R))
print(mu_xi_0)
matrix, vector, truncate_powerdim, truncate_hermitian = HHL.matrix_resize(W, mu_xi_0)
# 2**3=8次元の行列になっているか確認
print(matrix)
def create_eigs(matrix, num_ancillae, num_time_slices, negative_evals):
ne_qfts = [None, None]
if negative_evals:
num_ancillae += 1
# The QFT and IQFT circuits for handling negative eigenvalues
ne_qfts = [QFT(num_ancillae - 1), QFT(num_ancillae - 1).inverse()]
"""
Specifically, this class is based on PhaseEstimationCircuit with no measurements
and has additional handling of negative eigenvalues
"""
return EigsQPE(MatrixOperator(matrix=matrix), # The Hamiltonian Operator object
QFT(num_ancillae).inverse(),
num_time_slices=num_time_slices,
num_ancillae=num_ancillae,
expansion_mode='trotter',
expansion_order=2, # The suzuki expansion order, has a minimum value of 1
evo_time=None, # This is t, can set to: np.pi*3/4
negative_evals=negative_evals, # Set True to indicate negative eigenvalues need to be handled
ne_qfts=ne_qfts)
# 扱う問題の次元
orig_size = len(vector)
# 固有値探索の初期化
eigs = create_eigs(matrix, 7, 50, True)
num_q, num_a = eigs.get_register_sizes()
# 制御回転の初期化
c = 0.5*(2 * np.pi * (1. / 2**(num_a) ))
reci = LookupRotation(scale=c, negative_evals=eigs._negative_evals, evo_time=eigs._evo_time)
# 初期状態の設定
init_state = Custom(num_q, state_vector=vector)
algo = HHL(
matrix,
vector,
truncate_powerdim,
truncate_hermitian,
eigs, # The eigenvalue estimation instance
init_state, # The initial quantum state preparation
reci, # The eigenvalue reciprocal and controlled rotation instance
num_q, # Number of qubits required for the matrix Operator instance
num_a, # Number of ancillary qubits for Eigenvalues instance
orig_size # The original dimension of the problem (if truncate_powerdim)
)
## 結果
x_HHL = algo.run(QuantumInstance(Aer.get_backend('statevector_simulator')))
## 厳密解
# x_exact = np.linalg.lstsq(matrix, vector, rcond=0)[0]
x_exact = NumPyLSsolver(matrix, vector).run()
# 解の信頼度を求める
def fidelity(hhl, ref):
solution_hhl_normed = hhl / np.linalg.norm(hhl)
solution_ref_normed = ref / np.linalg.norm(ref)
fidelity = state_fidelity(solution_hhl_normed, solution_ref_normed)
print("Fidelity:\t\t %f" % fidelity)
fidelity(x_HHL.solution, x_exact.solution)
# the number of qubits required
print("circuit_width:\t", x_HHL['circuit_info']['width'])
# the maximum number of gates
print("circuit_depth:\t", x_HHL['circuit_info']['depth'])
# To verify whether running the circuit on current real hardware is feasible
print("CNOT gates:\t", x_HHL['circuit_info']['operations']['cx'])
w_opt_HHL = x_HHL.solution[2:6]
w_opt_exact = x_exact.solution[2:6]
w_opt = pd.DataFrame(np.vstack([w_opt_exact, w_opt_HHL]).T, index=df.columns, columns=['exact', 'HHL'])
w_opt
w_opt.plot.bar()
# 2018年の1年間のデータを使用
start = datetime.datetime(2017, 12, 30)
end = datetime.datetime(2018, 12, 31)
# Yahoo! Financeから日次の株価データを取得
data = web.DataReader(codes, 'yahoo', start, end)
df2018 = data['Adj Close']
display(df2018.tail())
## 株価をプロットしてみる
fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 6))
df2018.loc[:,['AAPL', 'FB']].plot(ax=axes[0])
df2018.loc[:,['GOOG', 'AMZN']].plot(ax=axes[1])
# ポートフォリオの資産価値の推移
pf_value = df2018.dot(w_opt)
pf_value.head()
# exact と HHLで初期金額が異なることがありうるので、期初の値で規格化したリターンをみる。
pf_value.exact = pf_value.exact / pf_value.exact[0]
pf_value.HHL = pf_value.HHL / pf_value.HHL[0]
print(pf_value.tail())
pf_value.plot(figsize=(9, 6))
pf_value.pct_change().std() * np.sqrt(252) ## 年率換算
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
from qiskit import *
from qiskit import Aer
from qiskit.aqua.operators import StateFn
from qiskit.circuit import Parameter, QuantumCircuit
from qiskit.quantum_info import Operator
from functools import reduce
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
######## パラメータ #############
nqubit = 3 ## qubitの数
c_depth = 3 ## circuitの深さ
# 横磁場イジングモデルのパラメーター
time_step = 0.77 ## ランダムハミルトニアンによる時間発展の経過時間
h = 3 # 外部磁場
#### 教師データを準備
## [x_min, x_max]でランダムにnum_x_train個の点を生成
x_min = - 1.; x_max = 1.;
num_x_train = 50
## 学習したい1変数関数
func_to_learn = lambda x: np.sin(x*np.pi)
random_seed = 0 ## 乱数のシード
np.random.seed(random_seed) ## 乱数発生器の初期化
x_train = x_min + (x_max - x_min) * np.random.rand(num_x_train)
y_train = func_to_learn(x_train)
# 現実のデータを用いる場合を想定しノイズを付加
mag_noise = 0.05
y_train = y_train + mag_noise * np.random.randn(num_x_train)
plt.plot(x_train, y_train, "o"); plt.show()
# 初期状態の準備
q = QuantumCircuit(nqubit)
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
# xをエンコード
def U_in(x):
U = QuantumCircuit(nqubit)
angle_y = np.arcsin(x)
angle_z = np.arccos(x**2)
for i in range(nqubit):
U.ry(angle_y, i)
U.rz(angle_z, i)
return U
## 基本ゲート
backend = Aer.get_backend('unitary_simulator')
I_mat = np.eye(2, dtype=complex)
q = QuantumCircuit(1)
q.x(0)
job = execute(q, backend)
X_mat = job.result().get_unitary(q, decimals=3)
q = QuantumCircuit(1)
q.z(0)
job = execute(q, backend)
Z_mat = job.result().get_unitary(q, decimals=3)
##### quantum native dojoから引用 #####
## fullsizeのgateをつくる関数.
def make_fullgate(list_SiteAndOperator, nqubit):
'''
list_SiteAndOperator = [ [i_0, O_0], [i_1, O_1], ...] を受け取り,
関係ないqubitにIdentityを挿入して
I(0) * ... * O_0(i_0) * ... * O_1(i_1) ...
という(2**nqubit, 2**nqubit)行列をつくる.
'''
list_Site = [SiteAndOperator[0] for SiteAndOperator in list_SiteAndOperator]
list_SingleGates = [] ## 1-qubit gateを並べてnp.kronでreduceする
cnt = 0
for i in range(nqubit):
if (i in list_Site):
list_SingleGates.append( list_SiteAndOperator[cnt][1] )
cnt += 1
else: ## 何もないsiteはidentity
list_SingleGates.append(I_mat)
return reduce(np.kron, list_SingleGates)
##### quantum native dojoから引用 #####
ham = np.zeros((2**nqubit,2**nqubit), dtype = complex)
for i in range(nqubit): ## i runs 0 to nqubit-1
Jx = -1. + 2.*np.random.rand() ## -1~1の乱数
ham += Jx * make_fullgate( [ [i, X_mat] ], nqubit)
for j in range(i+1, nqubit):
J_ij = -1. + 2.*np.random.rand()
ham += J_ij * make_fullgate ([ [i, Z_mat], [j, Z_mat]], nqubit)
## 対角化して時間発展演算子をつくる. H*P = P*D <-> H = P*D*P^dagger
diag, eigen_vecs = np.linalg.eigh(ham)
time_evol_op = np.dot(np.dot(eigen_vecs, np.diag(np.exp(-1j*time_step*diag))), eigen_vecs.T.conj()) # e^-iHT
## 時間発展演算子が2**3=8次の行列であることを確認
time_evol_op.shape
## 変分量子回路U(\theta)の構築
def U_out(param_list):
qc = QuantumCircuit(nqubit)
for d in range(c_depth):
# 時間発展演算子を回路に組み込む
qc.unitary(Operator(time_evol_op), range(nqubit), label="time_evol")
# パラメーター回転ゲートを導入
for i in range(nqubit):
qc.rx(-2*param_list[3*i], i)
qc.rz(-2*param_list[3*i+1], i)
qc.rx(-2*param_list[3*i+2], i)
return qc
# モデルの出力
# 出力状態において最初の量子ビットのZでの期待値を計算
from qiskit.aqua.operators import Z, I
def qcl_pred(x, param_list):
# 回路を一つにまとめる
qcl_cirq = U_in(x) + U_out(param_list)
obs = Z ^ I ^ I
psi = StateFn(qcl_cirq)
expectation_value = (~psi @ obs @ psi).eval()
return expectation_value.real
# コスト関数Lを計算
def cost_func(theta):
# num_x_train個のデータについて計算
y_pred = [qcl_pred(x, theta) for x in x_train]
# quadratic loss
L = ((y_pred - y_train)**2).mean()
return L
# パラメータthetaの初期値theta_initにおけるコスト関数の値
# theta: 長さc_depth * nqubit * 3のndarray
theta_init = [2.0 * np.pi * np.random.rand() for i in range(c_depth*nqubit*3)]
cost_func(theta_init)
# パラメータthetaの初期値のもとでのグラフ
xlist = np.arange(x_min, x_max, 0.02)
y_init = [qcl_pred(x, theta_init) for x in xlist]
plt.plot(xlist, y_init)
from scipy.optimize import minimize
# 学習(注意:数時間かかりました)
result = minimize(cost_func, theta_init, method='Nelder-Mead')
theta_opt = result.x
print(theta_opt)
# プロット
plt.figure(figsize=(10, 6))
xlist = np.arange(x_min, x_max, 0.02)
# 教師データ
plt.plot(x_train, y_train, "o", label='Teacher')
# パラメータθの初期値のもとでのグラフ
plt.plot(xlist, y_init, '--', label='Initial Model Prediction', c='gray')
# モデルの予測値
y_pred = np.array([qcl_pred(x, theta_opt) for x in xlist])
plt.plot(xlist, y_pred, label='Final Model Prediction')
plt.legend()
plt.show()
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
from qiskit import *
from qiskit.circuit import ParameterVector, QuantumCircuit
from qiskit.aqua import QuantumInstance
from qiskit.aqua.operators import I, Z
from qiskit.aqua.operators.state_fns import StateFn, CircuitStateFn
from qiskit.aqua.operators.expectations import PauliExpectation, AerPauliExpectation
from qiskit.aqua.operators.converters import CircuitSampler
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline
######## パラメータ #############
nqubit = 3 ## qubitの数
c_depth = 3 ## circuitの深さ
## [x_min, x_max]のうち, ランダムにnum_x_train個の点をとって教師データとする.
x_min = - 1.; x_max = 1.;
num_x_train = 50
## 学習したい1変数関数
func_to_learn = lambda x: np.sin(x*np.pi)
## 乱数のシード
random_seed = 0
## 乱数発生器の初期化
np.random.seed(random_seed)
x_train = x_min + (x_max - x_min) * np.random.rand(num_x_train)
y_train = func_to_learn(x_train)
# 現実のデータを用いる場合を想定しノイズを付加
mag_noise = 0.05
y_train = y_train + mag_noise * np.random.randn(num_x_train)
plt.plot(x_train, y_train, "o"); plt.show()
def get_expectation_val(psi, op):
# define your backend or quantum instance
backend = Aer.get_backend('qasm_simulator')
q_instance = QuantumInstance(backend, shots=1024)
# define the state to sample
measurable_expression = StateFn(op, is_measurement=True).compose(psi)
# convert to expectation value
expectation = PauliExpectation().convert(measurable_expression)
# expectation = AerPauliExpectation().convert(measurable_expression)
# get state sampler (you can also pass the backend directly)
sampler = CircuitSampler(q_instance).convert(expectation)
# evaluate
return sampler.eval().real
def U_in(x):
U = QuantumCircuit(nqubit)
angle_y = np.arcsin(x)
angle_z = np.arccos(x**2)
for i in range(nqubit):
U.ry(angle_y, i)
U.rz(angle_z, i)
return U
# 横磁場イジングモデルのパラメーター
time_step = 0.77 # ランダムハミルトニアンによる時間発展の経過時間
M = 2 # トロッター分解の分割数
delta = time_step/M # 時間の刻み幅
h = 3 # 外部磁場
# 回転ゲートのパラメーター
param_list = ParameterVector('theta', c_depth*nqubit*3)
def U_out():
qc = QuantumCircuit(nqubit)
for d in range(c_depth):
for s in range(M):
# トロッター分解の1回分、
for i in range(nqubit):
qc.cx(i,(i+1)%nqubit)
qc.rz(-2*delta,(i+1)%nqubit)
qc.cx(i,(i+1)%nqubit)
qc.rx(-2*delta*h, i)
# 回転ゲートを導入
for i in range(nqubit):
qc.rx(-2*param_list[3*(nqubit*d+i)], i)
qc.rz(-2*param_list[3*(nqubit*d+i)+1], i)
qc.rx(-2*param_list[3*(nqubit*d+i)+2], i)
return qc
# モデルの出力
# 出力状態において最初の量子ビットのZでの期待値を計算
from qiskit.aqua.operators import Z, I
def qcl_pred(x, param_dict):
qcl_cirq = U_in(x) + U_out()
qcl_cirq.assign_parameters(param_dict, inplace=True)
op = Z ^ I ^ I
psi = StateFn(qcl_cirq)
return 2 * get_expectation_val(psi, op)
# cost function Lを計算
def cost_func(theta_list):
param_dict = dict(zip(param_list.params, theta_list))
# num_x_train個のデータについて計算
y_pred = [qcl_pred(x, param_dict) for x in x_train]
# quadratic loss
L = ((y_pred - y_train)**2).mean()
return L
# パラメータthetaの初期値theta_initにおけるコスト関数の値
# theta: 長さc_depth * nqubit * 3のndarray
theta_init = [2.0 * np.pi * np.random.rand() for i in range(c_depth*nqubit*3)]
cost_func(theta_init)
# パラメータthetaの初期値のもとでのグラフ
xlist = np.arange(x_min, x_max, 0.02)
theta_init_dict = dict(zip(param_list.params, theta_init))
y_init = [qcl_pred(x, theta_init_dict) for x in xlist]
plt.plot(xlist, y_init)
from scipy.optimize import minimize
# 学習(注意:2.5時間かかりました)
result = minimize(cost_func, theta_init, method='Nelder-Mead')
theta_opt = result.x
print(theta_opt)
# プロット
plt.figure(figsize=(10, 6))
xlist = np.arange(x_min, x_max, 0.02)
# 教師データ
plt.plot(x_train, y_train, "o", label='Teacher')
# パラメータθの初期値のもとでのグラフ
plt.plot(xlist, y_init, '--', label='Initial Model Prediction', c='gray')
# モデルの予測値
theta_opt_dict = dict(zip(param_list.params, theta_opt))
y_pred = np.array([qcl_pred(x, theta_opt_dict) for x in xlist])
plt.plot(xlist, y_pred, label='Final Model Prediction')
plt.legend()
plt.show()
20:57 23:30
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import matplotlib.pyplot as plt
import numpy as np
# ランダムシードの指定
np.random.seed(1)
# 標準正規分布に従う乱数の生成
X_xor = np.random.randn(200, 2)
y_xor = np.logical_xor(X_xor[:, 0] > 0, X_xor[:, 1] > 0)
# 真の場合は1、偽の場合は-1
y_xor = np.where(y_xor, 1, -1)
#データのプロット
plt.scatter(X_xor[y_xor==1, 0], X_xor[y_xor==1, 1], c='b', marker='x', label='1')
plt.scatter(X_xor[y_xor==-1, 0], X_xor[y_xor==-1, 1], c='r', marker='s', label='-1')
plt.xlim([-3, 3])
plt.ylim([-3, 3])
plt.legend(loc='best')
plt.tight_layout()
plt.show()
from qiskit.circuit.library import ZZFeatureMap
map_zz = ZZFeatureMap(feature_dimension=2, reps=2)
## カーネルの定義(手組)
from qiskit import BasicAer
from qiskit_machine_learning.kernels import QuantumKernel
from sklearn.svm import SVC
# Create the quantum feature map
map_zz = ZZFeatureMap(feature_dimension=2,
reps=2,
entanglement='linear')
# Create the quantum kernel
adhoc_kernel = QuantumKernel(feature_map=map_zz,
quantum_instance=BasicAer.get_backend('statevector_simulator'))
# Set the SVC algorithm to use our custom kernel
model = SVC(kernel=adhoc_kernel.evaluate)
model.fit(X_xor, y_xor)
# 決定境界の可視化
from matplotlib.colors import ListedColormap
def plot_decision_regisons(X, y, classifier, resolution=0.2):
markers = ('s', 'x', 'o', '^', 'v')
colors = ('red', 'blue', 'lightgreen', 'gray', 'cyan')
cmap = ListedColormap(colors[:len(np.unique(y))])
# 決定境界のプロット
x1_min, x1_max = X[:, 0].min() - 1 , X[:, 0].max() + 1
x2_min, x2_max = X[:, 1].min() - 1 , X[:, 1].max() + 1
xx1, xx2 = np.meshgrid(np.arange(x1_min, x1_max, resolution), np.arange(x2_min, x2_max, resolution))
# 各特徴量を1次元配列に変換して予測を実行
Z = classifier.predict(np.array([xx1.ravel(), xx2.ravel()]).T)
Z = Z.reshape(xx1.shape)
# グリッドポイントの等高線プロット
plt.contourf(xx1, xx2, Z, alpha=0.3, cmap=cmap)
plt.xlim(xx1.min(), xx1.max())
plt.ylim(xx2.min(), xx2.max())
for idx, cl in enumerate(np.unique(y)):
plt.scatter(x=X[y==cl, 0], y=X[y==cl, 1], alpha=0.8, c=colors[idx], marker=markers[idx], label=cl, edgecolors='black')
plot_decision_regisons(X_xor, y_xor, classifier=model)
plt.legend(loc='upper left')
plt.tight_layout()
plt.show()
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter, ParameterVector
from qiskit.opflow import StateFn, PauliSumOp, Gradient
def generate_random_qnn(qubits, depth):
"""Generate random QNN's with the same structure from McClean et al."""
param = Parameter('theta')
circuit = QuantumCircuit(qubits)
for qubit in range(qubits):
circuit.ry(np.pi / 4.0, qubit)
circuit.barrier()
for d in range(depth):
# Add a series of single qubit rotations.
for qubit in range(qubits):
random_n = np.random.uniform()
random_rot = np.random.uniform() * 2.0 * np.pi if qubit != 0 or d != 0 else param
if random_n > 2. / 3.:
# Add a Z.
circuit.rz(random_rot, qubit)
elif random_n > 1. / 3.:
# Add a Y.
circuit.ry(random_rot, qubit)
else:
# Add a X.
circuit.rx(random_rot, qubit)
circuit.barrier()
# Add CZ ladder.
for src, dest in zip(range(qubits), range(qubits)[1:]):
circuit.cz(src, dest)
circuit.barrier()
return circuit
# 生成される回路の確認(例:3量子ビット)
n_qubits = 3
d = 2
qc_test = generate_random_qnn(n_qubits, d)
qc_test.draw('mpl')
# 勾配の計算
def calc_gradient(qc, hamiltonian, params):
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(qc)
state_grad = Gradient().convert(expectation)
value_dict = dict(zip(qc.parameters, params))
result = state_grad.assign_parameters(value_dict).eval()
return np.round(np.array(result), 10)
# # テスト勾配計算
# test_hamiltonian = PauliSumOp.from_list([('Z', 1.0), ('X', 1.0)])
# test_params = np.random.uniform(0, np.pi, qc_test.num_parameters)
# calc_gradient(qc_test, test_hamiltonian, test_params)
n_qubits = [2 * i for i in range(2, 7)]
depth = 30
n_circuits = 100
hamiltonian = PauliSumOp.from_list([('Z', 1.0), ('X', 1.0)])
theta_vars = []
for n in n_qubits:
grads = []
# Generate the random circuits and observable for the given n.
qc = generate_random_qnn(n, depth)
for _ in range(n_circuits):
params = np.random.uniform(0, np.pi, qc.num_parameters)
grad = calc_gradient(qc, hamiltonian, params)
grads.append(grad)
theta_vars.append(np.var(grads))
plt.semilogy(n_qubits, theta_vars)
plt.title('Gradient Variance in QNNs')
plt.xlabel('n_qubits')
plt.ylabel('$\\partial \\theta$ variance')
plt.show()
def generate_2qubit_qnn(label):
circuit = QuantumCircuit(2)
circuit.ry(np.pi / 4.0, 0)
circuit.ry(np.pi / 4.0, 1)
circuit.barrier()
for i in range(2):
if label[i] == 'x':
circuit.rx(Parameter('theta'+str(i)), i)
elif label[i] == 'y':
circuit.ry(Parameter('theta'+str(i)), i)
elif label[i] == 'z':
circuit.rz(Parameter('theta'+str(i)), i)
circuit.barrier()
# Add CZ ladder.
circuit.cz(0, 1)
return circuit
qc_test = generate_2qubit_qnn('xy')
qc_test.draw('mpl')
# 期待値の計算
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.opflow import CircuitSampler
from qiskit.opflow.expectations import AerPauliExpectation
def calculate_exp_val(qc, hamiltonian, params):
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(qc)
test_expectation = AerPauliExpectation().convert(expectation)
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
shots = 32768)
sampler = CircuitSampler(quantum_instance)
value_dict = dict(zip(qc.parameters, params))
result = sampler.convert(test_expectation, params=value_dict).eval()
return np.real(result)
hamiltonian = PauliSumOp.from_list([('X', 1.0)])
X = np.linspace(0, 2*np.pi, 30)
Y = np.linspace(0, 2*np.pi, 30)
Z = np.array([[calculate_exp_val(qc_test, hamiltonian, [x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))
xx, yy = np.meshgrid(X, Y)
fig = plt.figure(figsize=plt.figaspect(0.3))
ax = fig.add_subplot(projection="3d")
surf = ax.plot_surface(xx, yy, Z)
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import numpy as np
import matplotlib.pyplot as plt
from qiskit import Aer, QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.opflow import StateFn, PauliSumOp, AerPauliExpectation, Gradient
from qiskit.utils import QuantumInstance
from qiskit.algorithms.optimizers import COBYLA
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
expval = AerPauliExpectation()
gradient = Gradient()
qi_sv = QuantumInstance(Aer.get_backend('statevector_simulator'))
qi_qasm = QuantumInstance(Aer.get_backend('qasm_simulator'), shots=1000)
from qiskit_machine_learning.neural_networks import CircuitQNN
num_qubits = 3
qc = RealAmplitudes(num_qubits, entanglement='linear', reps=1)
qc.draw(output='mpl')
# specify circuit QNN
qnn = CircuitQNN(qc, [], qc.parameters, sparse=True, sampling=False, quantum_instance=qi_qasm)
# define (random) input and weights
input = np.random.rand(qnn.num_inputs)
weights = np.random.rand(qnn.num_weights)
# QNN forward pass
# sampling=True: sample
# sampling=False: probability
qnn.forward(input, weights).todense() # returned as ab sparse matrix
meas = QuantumCircuit(num_qubits)
meas.measure_all()
qc.assign_parameters(weights, inplace=True)
qc_sampling = meas.compose(qc, front=True) # frontをTrueにしないと測定が先に来てしまう
qi_qasm.execute(qc_sampling).get_counts()
# QNN backward pass, returns a tuple of sparse matrices
# sampling=True: None
# sampling=False: probability gradient
result = qnn.backward(input, weights)
result[1].todense()
# specify circuit QNN
parity = lambda x: '{:b}'.format(x).count('1') % 2 # バイナリ表現で1の数/2
output_shape = 2 # this is required in case of a callable with dense output
qnn6 = CircuitQNN(qc, [], qc.parameters, sparse=False, interpret=parity, output_shape=output_shape,
quantum_instance=qi_qasm)
# define (random) input and weights
input6 = np.random.rand(qnn6.num_inputs)
weights6 = np.random.rand(qnn6.num_weights)
# QNN forward pass
qnn6.forward(input6, weights6)
# QNN backward pass
qnn6.backward(input6, weights6)
num_inputs = 2
num_samples = 20
X = 2*np.random.rand(num_samples, num_inputs) - 1 # num_sample x num_inpuutsの配列
y01 = 1*(np.sum(X, axis=1) >= 0) # in { 0, 1}
y = 2*y01-1 # in {-1, +1}
y_one_hot = np.zeros((num_samples, 2))
for i in range(num_samples):
y_one_hot[i, y01[i]] = 1
for x, y_target in zip(X, y):
if y_target == 1:
plt.plot(x[0], x[1], 'bo')
else:
plt.plot(x[0], x[1], 'go')
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
# 量子回路の準備
num_inputs = 2
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
qc = QuantumCircuit(num_inputs)
qc.append(feature_map, range(num_inputs))
qc.append(ansatz, range(num_inputs))
qc.decompose().draw(output='mpl')
# parity maps bitstrings to 0 or 1
def parity(x):
return '{:b}'.format(x).count('1') % 2
output_shape = 2 # corresponds to the number of classes, possible outcomes of the (parity) mapping.
# construct QNN
circuit_qnn = CircuitQNN(circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=output_shape,
quantum_instance=qi_qasm)
# construct classifier
circuit_classifier = NeuralNetworkClassifier(neural_network=circuit_qnn,
optimizer=COBYLA())
circuit_classifier.fit(X, y01)
circuit_classifier.score(X, y01)
# 評価用のデータを生成
num_samples_test = 100
X_test = 2*np.random.rand(num_samples_test, num_inputs) - 1 # num_sample x num_inpuutsの配列
y01_test = 1*(np.sum(X_test, axis=1) >= 0) # in { 0, 1}
y_test = 2*y01_test-1 # in {-1, +1}
# evaluate data points
y_predict = circuit_classifier.predict(X_test)
# plot results
for x, y_target, y_p in zip(X_test, y01_test, y_predict):
if y_p == 1:
plt.plot(x[0], x[1], 'bo')
else:
plt.plot(x[0], x[1], 'go')
if y_target != y_p:
plt.scatter(x[0], x[1], s=200, facecolors='none', edgecolors='r', linewidths=2)
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import numpy as np
import matplotlib.pyplot as plt
from qiskit import Aer, QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.opflow import StateFn, PauliSumOp, AerPauliExpectation, Gradient
from qiskit.utils import QuantumInstance
from qiskit.algorithms.optimizers import COBYLA
expval = AerPauliExpectation()
gradient = Gradient()
qi_sv = QuantumInstance(Aer.get_backend('statevector_simulator'))
qi_qasm = QuantumInstance(Aer.get_backend('qasm_simulator'), shots=1000)
from qiskit_machine_learning.neural_networks import OpflowQNN
# 演算子の定義
params1 = [Parameter('input1'), Parameter('weight1')]
qc1 = QuantumCircuit(1)
qc1.h(0)
qc1.ry(params1[0], 0)
qc1.rx(params1[1], 0)
qc_sfn1 = StateFn(qc1)
H1 = StateFn(PauliSumOp.from_list([('Z', 1.0), ('X', 1.0)]))
op1 = ~H1 @ qc_sfn1
qc1.draw('mpl')
qnn1 = OpflowQNN(op1, [params1[0]], [params1[1]], expval, gradient, qi_sv)
input1 = np.random.rand(qnn1.num_inputs)
weight1 = np.random.rand(qnn1.num_weights)
qnn1.forward(input1, weight1)
# 順伝播計算は演算子の期待値を出力していることを確認
from qiskit.opflow.converters import CircuitSampler
param_dict = dict(zip(params1, [input1[0], weight1[0]]))
op1_binded = op1.assign_parameters(param_dict)
expectation = expval.convert(op1_binded)
sampler = CircuitSampler(qi_qasm).convert(expectation)
sampler.eval().real
# output: input gradiend, weight gradient
qnn1.backward(input1, weight1)
# 逆伝播計算は演算子の期待値関数の入力と重みに対する微分計算であることを確認
state_grad = Gradient(grad_method="param_shift").convert(operator=op1, params=params1)
result = state_grad.assign_parameters(param_dict).eval()
np.array(result).real
from qiskit_machine_learning.neural_networks import TwoLayerQNN
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
num_inputs = 2
num_samples = 20
X = 2*np.random.rand(num_samples, num_inputs) - 1 # num_sample x num_inpuutsの配列
y01 = 1*(np.sum(X, axis=1) >= 0) # in { 0, 1}
y = 2*y01-1 # in {-1, +1}
y_one_hot = np.zeros((num_samples, 2))
for i in range(num_samples):
y_one_hot[i, y01[i]] = 1
for x, y_target in zip(X, y):
if y_target == 1:
plt.plot(x[0], x[1], 'bo')
else:
plt.plot(x[0], x[1], 'go')
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
# default observable: Z^n
opflow_qnn = TwoLayerQNN(num_inputs, quantum_instance=qi_qasm)
opflow_classifier = NeuralNetworkClassifier(opflow_qnn, optimizer=COBYLA())
# QNNを構成している量子回路を確認する
opflow_qnn.circuit.draw('mpl')
opflow_qnn.feature_map.draw('mpl')
opflow_qnn.ansatz.draw('mpl')
opflow_classifier.fit(X, y)
opflow_classifier.score(X, y)
# 評価用のデータを生成
num_samples_test = 100
X_test = 2*np.random.rand(num_samples_test, num_inputs) - 1 # num_sample x num_inpuutsの配列
y01_test = 1*(np.sum(X_test, axis=1) >= 0) # in { 0, 1}
y_test = 2*y01_test-1 # in {-1, +1}
# plot results
def plot_predict_result(X_test, y_test, y_predict):
for x, y_target, y_p in zip(X_test, y_test, y_predict):
if y_p == 1:
plt.plot(x[0], x[1], 'bo')
else:
plt.plot(x[0], x[1], 'go')
if y_target != y_p:
plt.scatter(x[0], x[1], s=200, facecolors='none', edgecolors='r', linewidths=2)
plt.plot([-1, 1], [1, -1], '--', color='black')
plt.show()
# evaluate data points
y_predict = opflow_classifier.predict(X_test)
plot_predict_result(X_test, y_test, y_predict)
num_samples = 200
X2 = 2*np.random.rand(num_samples, num_inputs) - 1 # num_sample x num_inpuutsの配列
y01_2 = 1*(np.sum(X2, axis=1) >= 0) # in { 0, 1}
y2 = 2*y01_2-1 # in {-1, +1}
opflow_classifier.fit(X2, y2)
opflow_classifier.score(X2, y2)
# evaluate data points
y_predict = opflow_classifier.predict(X_test)
plot_predict_result(X_test, y_test, y_predict)
params2 = [Parameter('test1'), Parameter('test2')]
simple_feature_map = QuantumCircuit(num_inputs)
for i in range(num_inputs):
simple_feature_map.ry(params2[i], [i])
opflow_qnn2= TwoLayerQNN(num_inputs, feature_map=simple_feature_map, quantum_instance=qi_qasm)
opflow_classifier2 = NeuralNetworkClassifier(opflow_qnn2, optimizer=COBYLA())
opflow_classifier2.fit(X, y)
opflow_classifier2.score(X, y)
# evaluate data points
y_predict2 = opflow_classifier2.predict(X_test)
# plot results
plot_predict_result(X_test, y_test, y_predict2)
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import numpy as np
import matplotlib.pyplot as plt
%matplotlib notebook
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
def generate_2qubit_qnn(label):
circuit = QuantumCircuit(2)
circuit.ry(np.pi / 4.0, 0)
circuit.ry(np.pi / 4.0, 1)
circuit.barrier()
for i in range(2):
if label[i] == 'x':
circuit.rx(Parameter('theta'+str(i)), i)
elif label[i] == 'y':
circuit.ry(Parameter('theta'+str(i)), i)
elif label[i] == 'z':
circuit.rz(Parameter('theta'+str(i)), i)
circuit.barrier()
# Add CZ ladder.
circuit.cz(0, 1)
return circuit
qc_test = generate_2qubit_qnn('xy')
qc_test.draw('mpl')
# 期待値の計算
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.opflow import CircuitSampler, StateFn, PauliSumOp
from qiskit.opflow.expectations import PauliExpectation
hamiltonian = PauliSumOp.from_list([('X', 1.0)])
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(qc_test)
aerpauli_basis = PauliExpectation().convert(expectation)
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
shots = 32768)
sampler = CircuitSampler(quantum_instance)
# 期待値の評価
def calculate_exp_val(params):
value_dict = dict(zip(qc_test.parameters, params))
result = sampler.convert(aerpauli_basis, params=value_dict).eval()
return np.real(result)
X = np.linspace(0, 2*np.pi, 30)
Y = np.linspace(0, 2*np.pi, 30)
Z = np.array([[calculate_exp_val([x, y]) for x in X] for y in Y]).reshape(len(Y), len(X))
xx, yy = np.meshgrid(X, Y)
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.plot_surface(xx, yy, Z, cmap=plt.cm.jet)
ax.set_xlabel('theta_1')
ax.set_ylabel('theta_2')
ax.set_zlabel('loss')
plt.show()
from qiskit.opflow import Gradient
gradient = Gradient().convert(expectation)
gradient_in_pauli_basis = PauliExpectation().convert(gradient)
# 勾配の評価
def calculate_gradient(params):
value_dict = dict(zip(qc_test.parameters, params))
result = sampler.convert(gradient_in_pauli_basis, params=value_dict).eval()
return np.real(result)
from qiskit.opflow import NaturalGradient
ng = NaturalGradient().convert(expectation)
ng_in_pauli_basis = PauliExpectation().convert(ng)
def calculate_natural_gradient(params):
value_dict = dict(zip(qc_test.parameters, params))
result = sampler.convert(ng_in_pauli_basis, params=value_dict).eval()
return np.real(result)
initial_point = np.array([np.pi, np.pi])
from qiskit.algorithms.optimizers import GradientDescent
gd_loss= []
xx_op= []
yy_op= []
def gd_callback(nfevs, x, fx, stepsize):
gd_loss.append(fx)
xx_op.append(x[0])
yy_op.append(x[1])
gd = GradientDescent(maxiter=50,learning_rate=0.1, callback=gd_callback)
x_opt, fx_opt, nfevs = (
gd.optimize(initial_point.size,
calculate_exp_val,
gradient_function=calculate_gradient,
initial_point=initial_point)
)
ngd_loss= []
xx_op_ng= []
yy_op_ng= []
def ngd_callback(nfevs, x, fx, stepsize):
ngd_loss.append(fx)
xx_op_ng.append(x[0])
yy_op_ng.append(x[1])
qng = GradientDescent(maxiter=50,learning_rate=0.1, callback=ngd_callback)
x_opt_ng, fx_opt_ng, nfevs_ng = (
qng.optimize(initial_point.size,
calculate_exp_val,
gradient_function=calculate_natural_gradient,
initial_point=initial_point)
)
from matplotlib.animation import FuncAnimation
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.plot_surface(xx, yy, Z, cmap=plt.cm.jet, alpha=0.6)
gd, = ax.plot([], [], [], '.-k', label='vanilla gradient descent')
ngd, = ax.plot([], [], [], '.-r', label='natural gradient descent')
ax.set_xlabel('theta_1')
ax.set_ylabel('theta_2')
ax.set_zlabel('loss')
def update(f):
gd.set_data(xx_op[:f], yy_op[:f])
gd.set_3d_properties(gd_loss[:f])
ngd.set_data(xx_op_ng[:f], yy_op_ng[:f])
ngd.set_3d_properties(ngd_loss[:f])
anim = FuncAnimation(fig, update, interval=200)
plt.legend(loc='upper left')
plt.show()
anim.save("ngd.gif")
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import numpy as np
import matplotlib as plt
%matplotlib inline
input_param=[1, 0.5, -0.765, 0.1, 0, -0.654]
exp_output=[0, 0, 0, 0, -0.4553474723, 0]
from qiskit.circuit import QuantumCircuit, ParameterVector
n = 3
qc = QuantumCircuit(n)
param_list = ParameterVector('Parameter', 2*n)
for i in range(len(param_list)//n):
qc.rx(param_list[3*i], 0)
qc.ry(param_list[3*i+1], 1)
qc.rz(param_list[3*i+2], 2)
qc.cnot(0, 1)
qc.cnot(1, 2)
qc.cnot(2, 0)
qc.draw(output='mpl')
from qiskit.opflow import I, X, Y, Z
hamiltonian = Z ^ I ^ Y
from qiskit.opflow import StateFn, AerPauliExpectation
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(qc)
pauli_basis = AerPauliExpectation().convert(expectation)
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.opflow import CircuitSampler
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
# we'll set a seed for reproducibility
shots = 32768, seed_simulator = 2718,
seed_transpiler = 2718)
sampler = CircuitSampler(quantum_instance)
def evaluate_expectation(params):
value_dict = dict(zip(qc.parameters, params))
result = sampler.convert(pauli_basis, params=value_dict).eval()
return np.real(result)
def calc_gradient(params):
gradient = np.zeros_like(params)
for i in range(len(params)):
shifted = params.copy()
shifted[i] += np.pi/2
forward = evaluate_expectation(shifted)
shifted[i] -= np.pi
backward = evaluate_expectation(shifted)
gradient[i] = 0.5 * (forward - backward)
return np.round(gradient, 10)
calc_gradient(input_param)
from qiskit.opflow import Gradient
def calc_gradient_with_framework(params):
state_grad = Gradient(grad_method="param_shift").convert(operator=expectation)
value_dict = dict(zip(qc.parameters, params))
result = state_grad.assign_parameters(value_dict).eval()
return np.round(np.array(result).real, 10)
calc_gradient_with_framework(input_param)
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import numpy as np
import matplotlib.pyplot as plt
# %matplotlib notebook
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.opflow import StateFn, PauliSumOp
def generate_2qubit_qnn(label):
circuit = QuantumCircuit(2)
circuit.ry(np.pi / 4.0, 0)
circuit.ry(np.pi / 4.0, 1)
circuit.barrier()
for i in range(2):
if label[i] == 'x':
circuit.rx(Parameter('theta'+str(i)), i)
elif label[i] == 'y':
circuit.ry(Parameter('theta'+str(i)), i)
elif label[i] == 'z':
circuit.rz(Parameter('theta'+str(i)), i)
circuit.barrier()
# Add CZ ladder.
circuit.cz(0, 1)
return circuit
# # RealAmplitudesの場合
# from qiskit.circuit.library import RealAmplitudes
# qc_test = RealAmplitudes(num_qubits=2, reps=1,
# entanglement='linear').decompose()
qc_test = generate_2qubit_qnn('xy')
qc_test.draw('mpl')
# 期待値の計算
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.opflow import CircuitSampler
from qiskit.opflow.expectations import PauliExpectation
hamiltonian = PauliSumOp.from_list([('ZZ', 1.0)])
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(qc_test)
aerpauli_basis = PauliExpectation().convert(expectation)
quantum_instance = QuantumInstance(Aer.get_backend('qasm_simulator'),
shots = 32768)
sampler = CircuitSampler(quantum_instance)
# 期待値の評価
def calculate_exp_val(params):
value_dict = dict(zip(qc_test.parameters, params))
result = sampler.convert(aerpauli_basis, params=value_dict).eval()
return np.real(result)
# コスト関数の可視化
X = np.linspace(0, 2*np.pi, 30)
Y = np.linspace(0, 2*np.pi, 30)
Z = np.array([[calculate_exp_val([x, y]) for x in X] for y in Y]).reshape(len(X), len(Y))
xx, yy = np.meshgrid(X, Y)
fig = plt.figure(figsize=plt.figaspect(1))
ax = fig.add_subplot(projection="3d")
ax.plot_surface(xx, yy, Z, cmap=plt.cm.jet)
plt.show()
from qiskit.opflow import Gradient
gradient = Gradient().convert(expectation)
gradient_in_pauli_basis = PauliExpectation().convert(gradient)
# 勾配の評価
def calculate_gradient(params):
value_dict = dict(zip(qc_test.parameters, params))
result = sampler.convert(gradient_in_pauli_basis, params=value_dict).eval()
return np.real(result)
# initial_point = 2*np.pi*np.random.random(qc_test.num_parameters)
# アニメーション用初期値
initial_point = np.array([np.pi, 2.0])
from qiskit.algorithms.optimizers import GradientDescent
gd_loss= []
xx_op= []
yy_op= []
def gd_callback(nfevs, x, fx, stepsize):
gd_loss.append(fx)
xx_op.append(x[0])
yy_op.append(x[1])
gd = GradientDescent(maxiter=100,learning_rate=0.05, callback=gd_callback)
x_opt, fx_opt, nfevs = (
gd.optimize(initial_point.size,
calculate_exp_val,
gradient_function=calculate_gradient,
initial_point=initial_point)
)
from qiskit.algorithms.optimizers import SPSA
spsa_loss= []
xx_op_spsa= []
yy_op_spsa= []
# コールバック処理の定義
def spsa_callback(nfevs, x, fx, stepsize, accepted):
spsa_loss.append(fx)
xx_op_spsa.append(x[0])
yy_op_spsa.append(x[1])
# インスタンス化
spsa = SPSA(maxiter=100,learning_rate=0.05,perturbation=0.05, callback=spsa_callback)
# 最適化処理の実行
x_opt_spsa, fx_opt_spsa, nfevs_spsa = (
spsa.optimize(initial_point.size,
calculate_exp_val,
initial_point=initial_point)
)
# from qiskit.opflow import NaturalGradient
# ng = NaturalGradient().convert(expectation)
# ng_in_pauli_basis = PauliExpectation().convert(ng)
# def calculate_natural_gradient(params):
# value_dict = dict(zip(qc_test.parameters, params))
# result = sampler.convert(ng_in_pauli_basis, params=value_dict).eval()
# return np.real(result)
# ngd_loss= []
# xx_op_ng= []
# yy_op_ng= []
# def ngd_callback(nfevs, x, fx, stepsize):
# ngd_loss.append(fx)
# xx_op_ng.append(x[0])
# yy_op_ng.append(x[1])
# qng = GradientDescent(maxiter=50,learning_rate=0.1, callback=ngd_callback)
# x_opt_ng, fx_opt_ng, nfevs_ng = (
# qng.optimize(initial_point.size,
# calculate_exp_val,
# gradient_function=calculate_natural_gradient,
# initial_point=initial_point)
# )
# from qiskit.algorithms.optimizers import QNSPSA
# qnspsa_loss = []
# xx_op_qnspsa= []
# yy_op_qnspsa= []
# def qnspsa_callback(nfev, x, fx, stepsize, accepted):
# qnspsa_loss.append(fx)
# xx_op_qnspsa.append(x[0])
# yy_op_qnspsa.append(x[1])
# fidelity = QNSPSA.get_fidelity(qc_test,
# quantum_instance,
# expectation=PauliExpectation())
# qnspsa = QNSPSA(fidelity, maxiter=50, learning_rate=0.1,
# perturbation=0.1,
# callback=qnspsa_callback)
# x_opt_qnspsa, fx_opt_qnspsa, nfevs = qnspsa.optimize(initial_point.size,
# calculate_exp_val,
# initial_point=initial_point)
from matplotlib.animation import FuncAnimation
fig = plt.figure()
ax = fig.add_subplot(projection="3d")
ax.plot_surface(xx, yy, Z, cmap=plt.cm.jet, alpha=0.6)
gd, = ax.plot([], [], [], '.-k', label='Gradient Descent')
spsa, = ax.plot([], [], [], '.-r', label='SPSA')
# ngd, = ax.plot([], [], [], '.-b', label='Quantum Natural Gradient')
# spsa_ngd, = ax.plot([], [], [], '.-y', label='QN-SPSA')
ax.set_xlabel('theta_1')
ax.set_ylabel('theta_2')
ax.set_zlabel('loss')
def update(f):
gd.set_data(xx_op[:f], yy_op[:f])
gd.set_3d_properties(gd_loss[:f])
spsa.set_data(xx_op_spsa[:f], yy_op_spsa[:f])
spsa.set_3d_properties(spsa_loss[:f])
# ngd.set_data(xx_op_ng[:f], yy_op_ng[:f])
# ngd.set_3d_properties(ngd_loss[:f])
# spsa_ngd.set_data(xx_op_qnspsa[:f], yy_op_qnspsa[:f])
# spsa_ngd.set_3d_properties(qnspsa_loss[:f])
anim = FuncAnimation(fig, update, interval=200)
plt.legend(loc='upper left')
plt.show()
# 結果のプロット
plt.figure(figsize=(7, 3))
plt.plot(gd_loss, 'C0', label='vanilla gradient descent')
plt.plot(spsa_loss, 'C0', ls='--', label='SPSA')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plt.show()
anim.save("spsa.gif")
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
# スピン多重度
multiplicity = 1
# 全電荷
charge = 0
# 原子核配置
distance = 0.977
geometry = [["H", [0, 0, 0]], ["H", [0, 0, distance]]]
!pip install qulacs pyscf openfermion openfermionpyscf
from openfermion.transforms import get_fermion_operator, jordan_wigner
from openfermion.hamiltonians import MolecularData
from openfermionpyscf import run_pyscf
from pyscf import fci
# 分子軌道を表現するための基底関数(Slator Type Orbital - 3 gaussian)
basis = "sto-3g"
# 計算結果の保存場所
description = "tmp"
molecule = MolecularData(geometry, basis, multiplicity, charge, description)
molecule = run_pyscf(molecule, run_scf=1, run_fci=1)
n_qubit = molecule.n_qubits
n_electron = molecule.n_electrons
# get_molecular_hamiltonianで第二量子化形式のハミルトニアンを計算
fermionic_hamiltonian = get_fermion_operator(
molecule.get_molecular_hamiltonian())
# Jordan-Wigner変換によりハミルトニアンをパウリ行列のテンソル積形式に変換
jw_hamiltonian = jordan_wigner(fermionic_hamiltonian)
print(jw_hamiltonian)
from qiskit.chemistry.drivers import PySCFDriver, UnitsType, Molecule
from qiskit.chemistry.transformations import FermionicTransformation,FermionicTransformationType, FermionicQubitMappingType
basis = "sto3g"
molecule = Molecule(geometry=geometry, charge=charge, multiplicity=multiplicity)
driver = PySCFDriver(molecule = molecule, unit=UnitsType.ANGSTROM, basis=basis)
transformation = FermionicTransformation(
transformation=FermionicTransformationType.FULL,
qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=False)
qubit_op, _ = transformation.transform(driver)
print(qubit_op)
|
https://github.com/daimurat/qiskit-implementation
|
daimurat
|
import sys
sys.path.append('../../')
import numpy as np
from qiskit import QuantumCircuit
from qiskit.opflow import I, X, Y, Z
import matplotlib.pyplot as plt
from volta.observables import sample_hamiltonian
from volta.hamiltonians import BCS_hamiltonian
EPSILONS = [3, 3]
V = -2
hamiltonian = BCS_hamiltonian(EPSILONS, V)
print(hamiltonian)
eigenvalues, _ = np.linalg.eigh(hamiltonian.to_matrix())
print(f"Eigenvalues: {eigenvalues}")
def create_circuit(n: int) -> list:
return [QuantumCircuit(n) for _ in range(2)]
n = hamiltonian.num_qubits
init_states = create_circuit(n)
def copy_unitary(list_states: list) -> list:
out_states = []
for state in list_states:
out_states.append(state.copy())
return out_states
import textwrap
def apply_initialization(list_states: list) -> None:
for ind, state in enumerate(list_states):
b = bin(ind)[2:]
if len(b) != n:
b = '0'*(n - len(b)) + b
spl = textwrap.wrap(b, 1)
for qubit, val in enumerate(spl):
if val == '1':
state.x(qubit)
apply_initialization(init_states)
initialization = copy_unitary(init_states)
from qiskit.circuit.library import TwoLocal
ansatz = TwoLocal(hamiltonian.num_qubits, ['ry','rz'], 'cx', reps=2)
def apply_ansatz(ansatz: QuantumCircuit, list_states: list) -> None:
for states in list_states:
states.append(ansatz, range(n))
apply_ansatz(ansatz, init_states)
init_states[1].draw('mpl')
w = np.arange(n, 0, -1)
w
def _apply_varform_params(ansatz, params: list):
"""Get an hardware-efficient ansatz for n_qubits
given parameters.
"""
# Define variational Form
var_form = ansatz
# Get Parameters from the variational form
var_form_params = sorted(var_form.parameters, key=lambda p: p.name)
# Check if the number of parameters is compatible
assert len(var_form_params) == len(params), "The number of parameters don't match"
# Create a dictionary with the parameters and values
param_dict = dict(zip(var_form_params, params))
# Assing those values for the ansatz
wave_function = var_form.assign_parameters(param_dict)
return wave_function
from qiskit import BasicAer
from qiskit.utils import QuantumInstance
def cost_function(params:list) -> float:
backend = BasicAer.get_backend('qasm_simulator')
backend = QuantumInstance(backend, shots=10000)
cost = 0
# Define Ansatz
for i, state in enumerate(init_states):
qc = _apply_varform_params(state, params)
# Hamiltonian
hamiltonian_eval = sample_hamiltonian(hamiltonian=hamiltonian,
ansatz=qc,
backend=backend)
cost += w[i] * hamiltonian_eval
return cost
from qiskit.aqua.components.optimizers import COBYLA
optimizer = COBYLA(maxiter=1000)
n_parameters = len(init_states[0].parameters)
params = np.random.rand(n_parameters)
optimal_params, mean_energy, n_iters = optimizer.optimize(num_vars=n_parameters,
objective_function=cost_function,
initial_point=params)
mean_energy
# Optimized first ansatz
ansatz_1 = _apply_varform_params(ansatz, optimal_params)
ansatz_1.name = 'U(θ)'
apply_ansatz(ansatz_1, init_states)
init_states[2].draw()
from qiskit.aqua import QuantumInstance
def cost_function_ind(ind: int, params:list) -> float:
backend = BasicAer.get_backend('qasm_simulator')
backend = QuantumInstance(backend, shots=10000)
cost = 0
# Define Ansatz
qc = _apply_varform_params(init_states[ind], params)
# Hamiltonian
hamiltonian_eval = sample_hamiltonian(hamiltonian=hamiltonian,
ansatz=qc,
backend=backend)
cost += hamiltonian_eval
return - cost
from functools import partial
cost = partial(cost_function_ind, 2)
n_parameters = len(init_states[0].parameters)
params = np.random.rand(n_parameters)
optimal_params, energy_gs, n_iters = optimizer.optimize(num_vars=n_parameters,
objective_function=cost,
initial_point=params)
energy_gs
eigenvalues
# Optimized second ansatz
ansatz_2 = _apply_varform_params(ansatz, optimal_params)
ansatz_2.name = 'V(ϕ)'
|
https://github.com/qctrl/python-qiskit
|
qctrl
|
# General
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
# Q-CTRL Open Controls
from qctrlopencontrols import new_quadratic_sequence, new_ramsey_sequence
# Q-CTRL Qiskit Adapter
from qctrlqiskit import convert_dds_to_qiskit_quantum_circuit
# Q-CTRL Visualizer
from qctrlvisualizer import plot_sequences
# Qiskit
##To define a backend (simulated or real), transpile and assemble a circuit
from qiskit import BasicAer
from qiskit.compiler import transpile, assemble
##To plot the outcome
from qiskit.tools.visualization import plot_histogram
## To handle account information,find a suitable device and monitor a job
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
## Quadratic sequence, total duration: 20us
quadratic_sequence = new_quadratic_sequence(
duration=20e-6,
inner_offset_count=2,
outer_offset_count=2,
pre_post_rotation=True,
name="Quadratic sequence",
)
# Ramsey sequence, total duration: 20us
ramsey_sequence = new_ramsey_sequence(
duration=20e-6, pre_post_rotation=True, name="Ramsey sequence"
)
print(quadratic_sequence)
print(ramsey_sequence)
## Prepare the Qiskit related parameters
"""
target_qubits : list
A list of integers specifying the target qubits within the set of qubit registers
"""
target_qubits = [0]
"""
gate_time : float
Time delay (in seconds) introduced by identity gate
"""
gate_time = 0.4e-6
"""
add_measurement : bool
Indicates if the circuit requires a measurement step.
Required for 'qasm_simulator' and real device backends
"""
add_measurement = True
"""
circuit_name : str
An optional string as a name to the circuit
"""
circuit_name = "quadratic-sequence-circuit"
## convert the quadratic sequence to QuantumCircuit
quadratic_quantum_circuit = convert_dds_to_qiskit_quantum_circuit(
dynamic_decoupling_sequence=quadratic_sequence,
target_qubits=target_qubits,
gate_time=gate_time,
add_measurement=add_measurement,
circuit_name=circuit_name,
)
## convert the ramsey sequence to QuantumCircuit
circuit_name = "ramsey-sequence-circuit"
ramsey_quantum_circuit = convert_dds_to_qiskit_quantum_circuit(
dynamic_decoupling_sequence=ramsey_sequence,
target_qubits=target_qubits,
gate_time=gate_time,
add_measurement=add_measurement,
circuit_name=circuit_name,
)
formatted_plot_data = quadratic_sequence.export()
figure = plt.figure()
plt.suptitle("Quadratic Sequence")
plot_sequences(figure, formatted_plot_data)
formatted_plot_data = ramsey_sequence.export()
figure = plt.figure()
plt.suptitle("Ramsey Sequence")
plot_sequences(figure, formatted_plot_data)
##Drawing the Quadratic Circuit
quadratic_quantum_circuit.draw()
ramsey_quantum_circuit.draw()
print(ramsey_quantum_circuit.count_ops()["id"])
## Prepares the simulator backend
"""
backend : str
One of 'unitary_simulator', 'statevector_simulator' or 'qasm_simulator';
defaults to 'qasm_simulator'
"""
backend = "qasm_simulator"
backend_simulator = BasicAer.get_backend(backend)
"""
number_of_shots : int
Number of repeats the experiment has to be carried out;
defaults to 1
"""
number_of_shots = 1024
## Run the quadratic sequence circuit, Get the result (counts of state |1> and |0>), plot the histogram
# Transpile and assemble the circuits so that the identity gates are preserved
transpiled_quadratic_circuit = transpile(
quadratic_quantum_circuit, backend=backend_simulator, optimization_level=0
)
assembled_quadratic_circuit = assemble(
transpiled_quadratic_circuit, shots=number_of_shots
)
# run the circuit
job = backend_simulator.run(assembled_quadratic_circuit)
result = job.result()
counts = result.get_counts(quadratic_quantum_circuit)
plot_histogram(counts)
## Run the ramsey sequence circuit, Get the result (counts of state |1> and |0>), plot the histogram
# Transpile and assemble the circuits so that the identity gates are preserved
transpiled_ramsey_circuit = transpile(
ramsey_quantum_circuit, backend=backend_simulator, optimization_level=0
)
assembled_ramsey_circuit = assemble(transpiled_ramsey_circuit, shots=number_of_shots)
job = backend_simulator.run(assembled_ramsey_circuit)
result = job.result()
counts = result.get_counts(ramsey_quantum_circuit)
plot_histogram(counts)
# NBVAL_SKIP
"""
account_token : str
Token to enable IBM Q device access
"""
account_token = "insert-your-ibmq-token-here"
IBMQ.enable_account(account_token)
provider = IBMQ.get_provider(hub="ibm-q", group="open")
backends = provider.backends()
backends = [backend for backend in backends if backend.name() != "ibmq_qasm_simulator"]
backend = least_busy(backends)
print("Least busy device is {}".format(backend.name()))
# NBVAL_SKIP
job = backend.run(assembled_quadratic_circuit)
job_monitor(job)
result = job.result()
counts = result.get_counts(quadratic_quantum_circuit)
plot_histogram(counts)
# NBVAL_SKIP
job = backend.run(assembled_ramsey_circuit)
job_monitor(job)
result = job.result()
counts = result.get_counts(ramsey_quantum_circuit)
plot_histogram(counts)
# NBVAL_SKIP
IBMQ.disable_account()
|
https://github.com/qctrl/python-qiskit
|
qctrl
|
from qiskit import QuantumCircuit as QiskitQuantumCircuit
from qiskit.quantum_info import Operator, Statevector, DensityMatrix, StabilizerState
from qiskit import QuantumCircuit, AncillaRegister, ClassicalRegister, QuantumRegister
class QuantumCircuit(QiskitQuantumCircuit):
def get_unitary_matrix(self, input_dims=None, output_dims=None):
return Operator(self, input_dims, output_dims).data
def get_density_matrix(self, dims: int | tuple | list | None = None):
return DensityMatrix(self, dims)
def get_state_vector(self, dims: int | tuple | list | None = None):
return Statevector(self, dims)
def get_stabilizer_state(self, validate: bool = True):
return StabilizerState(self, validate)
@staticmethod
def from_qiskit_circuit(qiskit_circuit : QiskitQuantumCircuit):
custom_circuit = QuantumCircuit(qiskit_circuit.qubits)
custom_circuit.add_register(qiskit_circuit.clbits)
custom_circuit.data = qiskit_circuit.data.copy() # Copy the operations
custom_circuit.global_phase = qiskit_circuit.global_phase # Copy the global phase
custom_circuit.metadata = qiskit_circuit.metadata # Copy the metadata if any
return custom_circuit
if __name__ == "__main__":
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
for func in [qc.draw, qc.get_unitary_matrix, qc.get_density_matrix, qc.get_stabilizer_state, qc.get_state_vector]:
print(f"### Function : {func.__name__} ###")
print(func())
print()
qc = QiskitQuantumCircuit(5)
print(qc.draw())
qc = QuantumCircuit.from_qiskit_circuit(qc)
print(qc.draw())
# print(qc.draw())
# print(qc.get_unitary_matrix())
# print(qc.get_density_matrix())
# print(qc.get_state_vector())
# print(qc.get_stabilizer_state())
|
https://github.com/qctrl/python-qiskit
|
qctrl
|
# Copyright 2022 Q-CTRL
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""
Tests conversion to Qiskit Circuit
"""
import numpy as np
from qctrlopencontrols import (
new_carr_purcell_sequence,
new_cpmg_sequence,
new_periodic_sequence,
new_quadratic_sequence,
new_spin_echo_sequence,
new_uhrig_sequence,
new_walsh_sequence,
new_x_concatenated_sequence,
new_xy_concatenated_sequence,
)
from qiskit import (
BasicAer,
execute,
)
from qctrlqiskit import convert_dds_to_qiskit_quantum_circuit
_callable = {
"Spin echo": new_spin_echo_sequence,
"Carr-Purcell": new_carr_purcell_sequence,
"Carr-Purcell-Meiboom-Gill": new_cpmg_sequence,
"Uhrig single-axis": new_uhrig_sequence,
"periodic single-axis": new_periodic_sequence,
"quadratic": new_quadratic_sequence,
"Walsh single-axis": new_walsh_sequence,
"Quadratic": new_quadratic_sequence,
"X concatenated": new_x_concatenated_sequence,
"XY concatenated": new_xy_concatenated_sequence,
}
def _create_test_sequence(sequence_scheme, pre_post_rotation):
"""
Create a DD sequence of choice.
Parameters
----------
sequence_scheme : str
One of 'Spin echo', 'Carr-Purcell', 'Carr-Purcell-Meiboom-Gill',
'Uhrig single-axis', 'Periodic single-axis', 'Walsh single-axis',
'Quadratic', 'X concatenated',
'XY concatenated'
pre_post_rotation : bool
If True, adds a :math:`X_{\\pi/2}` gate on either ends
Returns
-------
DynamicDecouplingSequence
The Dynamical Decoupling Sequence instance built from supplied
schema information
"""
dd_sequence_params = {}
dd_sequence_params["duration"] = 4
dd_sequence_params["pre_post_rotation"] = pre_post_rotation
# 'spin_echo' does not need any additional parameter
if sequence_scheme in [
"Carr-Purcell",
"Carr-Purcell-Meiboom-Gill",
"Uhrig single-axis",
"periodic single-axis",
]:
dd_sequence_params["offset_count"] = 2
elif sequence_scheme in ["Walsh single-axis"]:
dd_sequence_params["paley_order"] = 5
elif sequence_scheme in ["quadratic"]:
dd_sequence_params["duration"] = 16
dd_sequence_params["outer_offset_count"] = 4
dd_sequence_params["inner_offset_count"] = 4
elif sequence_scheme in ["X concatenated", "XY concatenated"]:
dd_sequence_params["duration"] = 16
dd_sequence_params["concatenation_order"] = 2
sequence = _callable[sequence_scheme](**dd_sequence_params)
return sequence
def _check_circuit_unitary(pre_post_rotation, algorithm):
"""
Checks that the unitary of a dynamic decoupling operation is the identity.
"""
backend = "unitary_simulator"
number_of_shots = 1
backend_simulator = BasicAer.get_backend(backend)
for sequence_scheme in [
"Carr-Purcell",
"Carr-Purcell-Meiboom-Gill",
"Uhrig single-axis",
"periodic single-axis",
"Walsh single-axis",
"quadratic",
"X concatenated",
"XY concatenated",
]:
sequence = _create_test_sequence(sequence_scheme, pre_post_rotation)
quantum_circuit = convert_dds_to_qiskit_quantum_circuit(
dynamic_decoupling_sequence=sequence,
add_measurement=False,
algorithm=algorithm,
)
job = execute(quantum_circuit, backend_simulator, shots=number_of_shots)
result = job.result()
unitary = result.get_unitary(quantum_circuit)
assert np.isclose(np.abs(np.trace(unitary)), 2.0)
def test_identity_operation():
"""Tests if the Dynamic Decoupling Sequence gives rise to Identity
operation in Qiskit
"""
_check_circuit_unitary(False, "instant unitary")
_check_circuit_unitary(True, "instant unitary")
_check_circuit_unitary(False, "fixed duration unitary")
_check_circuit_unitary(True, "fixed duration unitary")
if __name__ == "__main__":
pass
|
https://github.com/derwind/qiskit_applications
|
derwind
|
import numpy as np
from qiskit.visualization import plot_bloch_vector
%matplotlib inline
I = np.array([
[1., 0.],
[0., 1.]
])
X = np.array([
[0., 1.],
[1., 0.]
])
Y = np.array([
[0., -1.j],
[1.j, 0.]
])
Z = np.array([
[1., 0.],
[0., -1.]
])
def Rx(theta):
return np.cos(theta/2) * I - 1.j * np.sin(theta/2) * X
def Ry(theta):
return np.cos(theta/2) * I - 1.j * np.sin(theta/2) * Y
def Rz(theta):
return np.cos(theta/2) * I - 1.j * np.sin(theta/2) * Z
def density_matrix(state):
if len(state.shape) == 1:
state = state.reshape(-1, 1)
return state * np.conjugate(state.T)
def state2bloch(state):
rho = density_matrix(state)
x, y, z = np.trace(X @ rho), np.trace(Y @ rho), np.trace(Z @ rho)
return np.real(np.array([x, y, z]))
def bloch2state(vec, epsilon = 1e-10):
x, y, z = np.real(vec)
cos = np.sqrt((1 + z)/2)
if z > 1 - epsilon: # theta = 0
return np.array([1., 0.])
elif z < -1 + epsilon: # theta = pi
return np.array([0., 1.])
else:
sin = np.sqrt(x**2 + y**2) / (2*cos)
if x < 0:
sin = -sin
if abs(x) < epsilon: # phi = pi/2, 3pi/2
if y >= 0:
phi = np.pi/2
else:
phi = 3 * np.pi/2
else:
phi = np.arctan(y/x)
return np.array([cos, np.exp(1.j*phi)*sin])
#print(state2bloch(np.array([1., 0.])))
#print(bloch2state(np.array([0., 0., 1.])))
init_vec = np.array([0., 0., 1.])
print(init_vec)
display(plot_bloch_vector(init_vec))
final_vec = state2bloch(Rx(np.pi/4) @ bloch2state(init_vec))
print(final_vec)
display(plot_bloch_vector(final_vec))
init_state = np.array([1., 0.])
final_state = Rx(np.pi/4) @ Ry(np.pi/4) @ init_state
final_vec = state2bloch(final_state)
print(final_vec)
display(plot_bloch_vector(final_vec))
def rot(theta):
return np.array([
[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)],
])
init_vec = np.array([0., 0., 1.])
vec = init_vec[:]
vec[[2,0]] = rot(np.pi/4)@vec[[2,0]] # rotate only 2:z, 0:x around Y-axis
vec[[1,2]] = rot(np.pi/4)@vec[[1,2]] # rotate only 1:y, 2:z around X-axis
print(vec)
display(plot_bloch_vector(vec))
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qc = QuantumCircuit(1)
# First, rotate around Y-axis
qc.ry(np.pi/4, 0)
state = Statevector.from_instruction(qc)
print('First, rotate around Y-axis...')
display(plot_bloch_multivector(state))
# Then, rotate around X-axis
qc.rx(np.pi/4, 0)
print('Then, rotate around X-axis.')
state = Statevector.from_instruction(qc)
display(plot_bloch_multivector(state))
|
https://github.com/derwind/qiskit_applications
|
derwind
|
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/OscarCharlieST/QISKIT_lab
|
OscarCharlieST
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.tools.visualization import circuit_drawer
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.measure(qr[0],cr[0])
circuit_drawer(circuit)
from qiskit import Aer
backend = Aer.get_backend('qasm_simulator')
job = execute(circuit, backend,shots=1024)
result=job.result()
result.get_counts(circuit)
expectation =(result.get_counts(circuit)['0']-result.get_counts(circuit)['1'])/(result.get_counts(circuit)['0']
+result.get_counts(circuit)['1'])
print(expectation)
|
https://github.com/OscarCharlieST/QISKIT_lab
|
OscarCharlieST
|
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.tools.visualization import circuit_drawer
import numpy as np
import time
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.h(qr[0])
circuit.measure(qr[0],cr[0])
backend = Aer.get_backend('qasm_simulator')
exponent = np.arange(2,20,1) # 2^25 iterations is as much as I can calulate in a reasonable amound of time.
expectation = []
for s in [2**n for n in exponent]:
job = execute(circuit, backend, shots=s)
result=job.result().get_counts(circuit)
expectation.append((result['0']-result['1'])/(result['0']+result['1']))
fig = plt.figure(figsize=(10,5))
ax = fig.add_subplot()
ax.scatter(exponent, expectation)
ax.plot(exponent, exponent*0, c=(0.7,.7,0.7))
ax.set_ylabel('<Z> expectation value')
ax.set_xlabel('log2(number of itterations)')
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.visualization import circuit_drawer
import numpy as np
import pandas as pd
import time
def measure_z(circuit, c_bit, shots=1024):
"""
Takes a circuit and a classical bit, and returns the expectation value of the Z operator.
"""
circuit.measure([0],c_bit)
job = execute(circuit, backend, shots=shots)
result = job.result().get_counts(circuit)
keys = list(result.keys())
if set(keys) == set(['0','1']):
return (result['0']-result['1'])/(result['0']+result['1'])
elif keys == ['0']:
return 1.0
elif keys == ['1']:
return -1.0
def measure_x(circuit, c_bit, shots=1024):
"""
Takes a circuit and a classical bit, and returns the expectation value of the X operator.
"""
circuit.h([0])
circuit.measure([0],c_bit)
job = execute(circuit, backend, shots=shots)
result = job.result().get_counts(circuit)
keys = list(result.keys())
if set(keys) == set(['0','1']):
return (result['0']-result['1'])/(result['0']+result['1'])
elif keys == ['0']:
return 1.0
elif keys == ['1']:
return -1.0
def measure_y(circuit, c_bit, shots=1024):
"""
Takes a circuit and a classical bit, and returns the expectation value of the Y operator.
"""
circuit.s([0])
circuit.s([0])
circuit.s([0]) # using S^-1 = S^3
circuit.h([0])
circuit.measure([0],c_bit)
job = execute(circuit, backend, shots=shots)
result = job.result().get_counts(circuit)
keys = list(result.keys())
if set(keys) == set(['0','1']):
return (result['0']-result['1'])/(result['0']+result['1'])
elif keys == ['0']:
return 1.0
elif keys == ['1']:
return -1.0
def measure_method_2(theta, circuit, cr, shots=1024):
"""
Takes a parameter for the matrix M, and an input state circuit with an attached a classical register, and returns <M>
via the standard VQE method.
"""
xcircuit = circuit.copy()
x = measure_x(xcircuit, cr[0], shots=shots)
ycircuit = circuit.copy()
circuit_drawer(ycircuit)
y = measure_y(ycircuit, cr[0], shots=shots)
M = np.cos(theta)*x + np.sin(theta)*y
return M
def measure_method_1(theta, circuit, cr, shots=1024):
"""
Takes a parameter for the matrix M, and an input state circuit with an attached a classical register, and returns <M>
via the unitary basis rotation method.
"""
zcircuit = circuit.copy()
zcircuit.p(-theta, [0])
zcircuit.h([0])
M = measure_z(zcircuit, cr[0], shots=shots)
return M
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
backend = Aer.get_backend('qasm_simulator')
shots = 2**0 # Number of shots to obtain expectation value
N = 2**9 # The number of iterations used to see statistics of method
# Method 1
zcircuit = QuantumCircuit(qr, cr)
M1_1 = []
start=time.time()
for i in range(N):
M1_1.append(measure_method_1(np.pi/4, zcircuit, cr, shots=shots))
t1_1 = time.time()-start
print(f'Method 1: \nTime elapsed for {N} iterations of {shots} shots: ', t1_1)
print('Mean:', np.mean(M1_1))
print('Std. dev.:', np.std(M1_1))
# Method 2
circuit = QuantumCircuit(qr, cr)
M2_1 = []
start=time.time()
for i in range(N):
M2_1.append(measure_method_2(np.pi/4, circuit, cr, shots=shots))
t2_1 = time.time()-start
print(f'Method 2: \nTime elapsed for {N} iterations of {shots} shots: ', t2_1)
print('Mean:', np.mean(M2_1))
print('Std. dev.:', np.std(M2_1))
fig1, ax1 = plt.subplots(figsize=(8,5))
bins=np.histogram(np.hstack((M1_1,M2_1)), bins=40)[1]
ax1.hist(M1_1, bins, color='b', alpha=0.5, label=f'method 1 ({round(t1/N*1000, 2)} ms/iter)')
ax1.hist(M2_1, bins, color='r', alpha=0.5, label=f'method 2 ({round(t2/N*1000, 2)} ms/iter)')
ax1.axvline(0.0, linestyle='-', c='g', label='True value')
ax1.set_xlabel(r'Estimate of $\langle M\rangle$')
ax1.set_ylabel('Frequency')
ax1.set_title(f'Results of {N} simulations of {shots} shots for '+r'$\theta=\pi/4, \phi=\pi/8$')
ax1.legend()
def init_circuit(phi, qr, cr):
circuit = QuantumCircuit(qr, cr)
circuit.h([0])
circuit.p(-2*phi, [0])
circuit.h([0]) # Ignoring global phase
return circuit
# Method 1
zcircuit = init_circuit(np.pi/4, qr, cr)
M1_2 = []
start=time.time()
for i in range(N):
M1_2.append(measure_method_1(np.pi/8, zcircuit, cr, shots=shots))
t1_2 = time.time()-start
print(f'Method 1: \nTime elapsed for {N} iterations of {shots} shots: ', t1_2)
print('Mean:', np.mean(M1_2))
print('Std. dev.:', np.std(M1_2))
# Method 2
circuit = init_circuit(np.pi/4, qr, cr)
M2_2 = []
start=time.time()
for i in range(N):
M2_2.append(measure_method_2(np.pi/8, circuit, cr, shots=shots))
t2_2 = time.time()-start
print(f'Method 2: \nTime elapsed for {N} iterations of {shots} shots: ', t2_2)
print('Mean:', np.mean(M2_2))
print('Std. dev.:', np.std(M2_2))
fig1, ax1 = plt.subplots(figsize=(8,5))
bins=np.histogram(np.hstack((M1_2,M2_2)), bins=40)[1]
ax1.hist(M1_2, bins, color='b', alpha=0.5, label=f'method 1 ({round(t1/N*1000, 2)} ms/iter)')
ax1.hist(M2_2, bins, color='r', alpha=0.5, label=f'method 2 ({round(t2/N*1000, 2)} ms/iter)')
ax1.axvline(0.3827, linestyle='-', c='g', label='True value')
ax1.set_xlabel(r'Estimate of $\langle M\rangle$')
ax1.set_ylabel('Frequency')
ax1.set_title(f'Results of {N} simulations of {shots} shots for '+r'$\theta=\pi/4, \phi=\pi/8$')
ax1.legend()
shots = np.arange(1000, 100000, 1000)
s_exps = np.linspace(7, 17, 200)
#shots = [(2**exp)//1 for exp in s_exps]
# Method 1
zcircuit = init_circuit(np.pi/4, qr, cr)
M1 = []
t1 = []
for s in shots:
start=time.time()
M1.append(measure_method_1(np.pi/8, zcircuit, cr, shots=s))
end=time.time()
t1.append(end-start)
# Method 2
circuit = init_circuit(np.pi/4, qr, cr)
M2 = []
t2 = []
for s in shots:
start=time.time()
M2.append(measure_method_2(np.pi/8, circuit, cr, shots=s))
end=time.time()
t2.append(end-start)
fig, axs = plt.subplots(1,2,figsize=(16,5))
axs[0].plot(shots,t1, label='method 1')
axs[0].plot(shots,t2, label='method 2')
axs[0].set_xlabel('Number of shots')
axs[0].set_ylabel('Time taken')
axs[0].legend()
axs[1].scatter(shots,M1, label='method 1')
axs[1].scatter(shots,M2, label='method 2')
axs[1].axhline(np.sin(np.pi/8), label='expected value', c=(.7,.7,.7))
#axs[1].set_xlabel(r'$log_2(shots)$')
axs[1].set_ylabel(r'$\langle M\rangle')
axs[1].legend()
tps_1 = np.mean(np.array(t1)/np.array(shots))
tps_2 = np.mean(np.array(t2)/np.array(shots))
print('Ratio of time taken (method 2:method 1) = ', round(tps_2/tps_1, 3))
#s_exps = np.linspace(7, 14, 10)
#shots = [(2**exp)//1 for exp in s_exps]
shots_std = np.linspace(500,2000,15)
N=50
# Method 1
zcircuit = init_circuit(np.pi/4, qr, cr)
std1 = []
for s in shots_std:
m = []
for i in range(N):
m.append(measure_method_1(np.pi/8, zcircuit, cr, shots=s))
std1.append(np.std(m))
# Method 2
circuit = init_circuit(np.pi/4, qr, cr)
std2=[]
for s in shots_std:
m=[]
for i in range(N):
m.append(measure_method_2(np.pi/8, circuit, cr, shots=s))
std2.append(np.std(m))
fig, axs = plt.subplots(1,2,figsize=(16,5))
axs[0].plot(shots,t1, label='method 1', c='r')
axs[0].plot(shots,t2, label='method 2', c='b')
axs[0].set_xlabel('Number of shots')
axs[0].set_ylabel('Time taken')
axs[0].legend()
rt_s = np.sqrt(1/np.array(shots_std))
axs[1].scatter(rt_s, std1, label='method 1', c='r')
axs[1].plot(rt_s, rt_s*np.polyfit(rt_s, std1,1)[0]+ np.polyfit(rt_s, std1,1)[1],
c='r', alpha=.5, label='m='+str(round(np.polyfit(rt_s, std1,1)[0],3)))
axs[1].scatter(rt_s, std2, label='method 2', c='b')
axs[1].plot(rt_s, rt_s*np.polyfit(rt_s, std2,1)[0]+ np.polyfit(rt_s, std2,1)[1],
c='b', alpha=.5, label='m='+str(round(np.polyfit(rt_s, std2,1)[0],3)))
axs[1].set_xlabel(r'shots$^{-1/2}$')
axs[1].set_ylabel(r'$\Delta\langle M\rangle$')
axs[1].legend()
|
https://github.com/OscarCharlieST/QISKIT_lab
|
OscarCharlieST
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, Aer
from qiskit.tools.visualization import circuit_drawer
from qiskit import Aer
import matplotlib.pyplot as plt
import math
import numpy as np
import time
import pandas as pd
from tqdm import tqdm
#Function that returns the expectation value of a measurement
def get_expectation(circuit,backend,logshots):
job = execute(circuit, backend,shots=2**logshots)
counts = job.result().get_counts(circuit)
runtime = job.result().time_taken
keys = list(counts.keys())
if set(keys) == set(['0','1']):
return (counts['0']-counts['1'])/(counts['0']+counts['1']) , runtime
elif keys == ['0']:
return 1.0, runtime
elif keys == ['1']:
return -1.0, runtime
#Given an angle phi determines the state in our defined set of states
def initial_state(phi):
state = math.cos(phi)*np.array([1,0]) + 1j*math.sin(phi)* np.array([0,1])
return state
#Given data as a csv file and shots, returns histogram comparing the results with the true value of the expectation
#value and the mean of each method
def exp_value_histogram(data, state, shots,backend, mean=0.0, save = False):
#data = pd.read_csv(f'{backend}_state_1.csv')
M1 = data['Method 1']
M2 = data['Method 2']
n_simulations = len(M1)
fig1, ax1 = plt.subplots(figsize=(8,5))
bins=np.histogram(np.hstack((M1,M2)), bins=40)[1]
ax1.hist(M1, bins, color='b', alpha=0.5, label=f'method 1')
ax1.hist(M2, bins, color='r', alpha=0.5, label=f'method 2')
ax1.axvline(mean, linestyle='-', c='g', label='True value')
ax1.axvline(np.mean(M1), linestyle='-', c='b', label='Method 1 mean')
ax1.axvline(np.mean(M2), linestyle='-', c='r', label='Method 2 mean')
ax1.set_xlabel(r'Estimate of $\langle M\rangle$')
ax1.set_ylabel('Frequency')
ax1.set_title(f'Results of {n_simulations} simulations of {2**shots} shots for {state} on {backend}')
ax1.legend()
if save == True:
fig1.savefig(f'figures/{state}_{backend}.png')
def time_benchmarking(M1,M2,t1,t2,shots,exp_value):
fig, axs = plt.subplots(1,2,figsize=(16,5))
axs[0].plot(shots,t1, label='method 1')
axs[0].plot(shots,t2, label='method 2')
axs[0].set_xlabel('Number of shots')
axs[0].set_ylabel('Time taken')
axs[0].legend()
axs[1].scatter(shots,M1, label='method 1')
axs[1].scatter(shots,M2, label='method 2')
axs[1].axhline(exp_value, label='expected value', c=(.7,.7,.7))
axs[1].set_xlabel('Number of shots (log_2 scale)')
axs[1].set_ylabel('Expectation value of M')
axs[1].set_ylim([min(M1+M2)-0.05,max(M1+M2)+0.05])
axs[1].legend()
# Method 1 - apply HU^dagger(theta) and measure Z
#Build the cirquit
def method_1_circuit(theta, phi):
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.initialize(initial_state(phi), qr[0])
circuit.p(-theta, qr[0])
circuit.h(qr[0])
circuit.measure(qr[0],cr[0])
return circuit
circuit_drawer(method_1_circuit(theta=math.pi/8, phi=math.pi/4))
# Method 2
# M(theta) = cos(theta)X + sin(theta)Y
# alpha = cos(theta) ; beta = sin(theta)
#Build the cirquits
#Measure X expectation value circuit
def method_2_X_circuit(theta,phi):
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.initialize(initial_state(phi), qr[0])
circuit.h(qr[0])
circuit.measure(qr[0],cr[0])
circuit_drawer(circuit)
return circuit
circuit_drawer(method_2_X_circuit(theta=math.pi/4, phi=0))
def method1(theta,phi,backend,shots):
circuit = method_1_circuit(theta, phi)
return get_expectation(circuit,backend,shots)
#Measure Y expectation value circuit
def method_2_Y_circuit(theta,phi):
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
circuit = QuantumCircuit(qr, cr)
circuit.initialize(initial_state(phi), qr[0])
circuit.p(-math.pi/2,qr[0])
circuit.h(qr[0])
circuit.measure(qr[0],cr[0])
circuit_drawer(circuit)
return circuit
circuit_drawer(method_2_Y_circuit(theta=math.pi/4, phi=0))
def method2(theta,phi,backend,shots):
'''
Output: expectation value, job status of circuit X, job status of circuit Y
'''
circuit_X = method_2_X_circuit(theta, phi)
expectation_X, runtime_X = get_expectation(circuit_X,backend,shots)
circuit_Y = method_2_Y_circuit(theta,phi)
expectation_Y, runtime_Y = get_expectation(circuit_Y,backend,shots)
expectation_M = math.cos(theta)*expectation_X + math.sin(theta)*expectation_Y
return expectation_M, runtime_X + runtime_Y
#Establish number of simulations, shots and backend simulator
n_simulations = 500
shots = 10 #log scale
backend = Aer.get_backend('qasm_simulator')
#State 1
theta_1=math.pi/4
phi_1=0
method_1_state_1 = []
runtime_method_1_state_1 = []
for n in tqdm(range(n_simulations)):
exp_value,runtime = method1(theta_1,phi_1,backend,shots)
method_1_state_1.append(exp_value)
runtime_method_1_state_1.append(runtime)
m1_dict = {'Method 1':method_1_state_1, 'Method 1 runtime':runtime_method_1_state_1}
pd.DataFrame(m1_dict).to_csv(f'{backend}_state_1.csv')
method_2_state_1 = []
runtime_method_2_state_1 = []
for n in tqdm(range(n_simulations)):
exp_value,runtime = method2(theta_1,phi_1,backend,shots)
method_2_state_1.append(exp_value)
runtime_method_2_state_1.append(runtime)
m1_dict.update({'Method 2':method_2_state_1, 'Method 2 runtime':runtime_method_2_state_1})
pd.DataFrame(m1_dict).to_csv(f'{backend}_state_1.csv')
#State 2
theta_2=math.pi/8
phi_2=math.pi/4
method_1_state_2 = []
runtime_method_1_state_2 = []
for n in tqdm(range(n_simulations)):
exp_value, runtime = method1(theta_2,phi_2,backend,shots)
method_1_state_2.append(exp_value)
runtime_method_1_state_2.append(runtime)
m2_dict = {'Method 1':method_1_state_2,'Method runtime':runtime_method_1_state_2}
pd.DataFrame(m2_dict).to_csv(f'{backend}_state_2.csv')
method_2_state_2 = []
runtime_method_2_state_2 = []
for n in tqdm(range(n_simulations)):
exp_value, runtime = method2(theta_2,phi_2,backend,shots)
method_2_state_2.append(exp_value)
runtime_method_2_state_2.append(runtime)
m2_dict.update({'Method 2':method_2_state_2,'Method 2 runtime':runtime_method_2_state_2})
pd.DataFrame(m2_dict).to_csv(f'{backend}_state_2.csv')
state_1_data = pd.read_csv(f'{backend}_state_1.csv')
state_1 = r'$\theta=\pi/4, \phi=0$'
exp_value_histogram(state_1_data, 'state_1', shots,backend, save = True)
state_2_data = pd.read_csv(f'{backend}_state_2.csv')
state_2 = r'$\theta=\pi/8, \phi=\pi/4$'
exp_value_histogram(state_2_data, 'state_2', shots,backend, mean=0.3827, save = True)
shots = np.arange(1000, 100000, 1000)
shots_log = list(map(lambda x: math.log(x,2), shots))
method_1_state_1 = []
runtime_method_1_state_1 = []
for s in tqdm(shots_log):
exp_value,runtime = method1(theta_1,phi_1,backend,s)
method_1_state_1.append(exp_value)
runtime_method_1_state_1.append(runtime)
method_2_state_1 = []
runtime_method_2_state_1 = []
for s in tqdm(shots_log):
exp_value,runtime = method2(theta_1,phi_1,backend,s)
method_2_state_1.append(exp_value)
runtime_method_2_state_1.append(runtime)
time_benchmarking(method_1_state_1, method_2_state_1,runtime_method_1_state_1,runtime_method_2_state_1,shots,0)
tps_1 = np.mean(np.array(runtime_method_1_state_1)/np.array(shots))
tps_2 = np.mean(np.array(runtime_method_2_state_1)/np.array(shots))
print('Ratio of time taken (method 2:method 1) = ', round(tps_2/tps_1, 3))
shots_std = np.linspace(500,2000,15)
shots_log = list(map(lambda x: math.log(x,2), shots_std))
n_simulations = 50
std1 = []
rt1 = []
for s in tqdm(shots_log):
method_1_state_1 = []
runtime_method_1_state_1 = []
for i in range(n_simulations):
exp_value,runtime = method1(theta_1,phi_1,backend,s)
method_1_state_1.append(exp_value)
runtime_method_1_state_1.append(runtime)
std1.append(np.std(method_1_state_1))
rt1.append(np.mean(runtime_method_1_state_1))
std2 = []
rt2 = []
for s in tqdm(shots_log):
method_2_state_1 = []
runtime_method_2_state_1 = []
for i in range(n_simulations):
exp_value,runtime = method2(theta_1,phi_1,backend,s)
method_2_state_1.append(exp_value)
runtime_method_2_state_1.append(runtime)
std2.append(np.std(method_2_state_1))
rt2.append(np.mean(runtime_method_2_state_1))
fig, axs = plt.subplots(1,2,figsize=(16,5))
axs[0].plot(shots_std,rt1, label='method 1', c='r')
axs[0].plot(shots_std,rt2, label='method 2', c='b')
axs[0].set_xlabel('Number of shots')
axs[0].set_ylabel('Mean time taken')
axs[0].legend()
rt_s = np.sqrt(1/np.array(shots_std))
axs[1].scatter(rt_s, std1, label='method 1', c='r')
axs[1].plot(rt_s, rt_s*np.polyfit(rt_s, std1,1)[0]+ np.polyfit(rt_s, std1,1)[1],
c='r', alpha=.5, label='m='+str(round(np.polyfit(rt_s, std1,1)[0],3)))
axs[1].scatter(rt_s, std2, label='method 2', c='b')
axs[1].plot(rt_s, rt_s*np.polyfit(rt_s, std2,1)[0]+ np.polyfit(rt_s, std2,1)[1],
c='b', alpha=.5, label='m='+str(round(np.polyfit(rt_s, std2,1)[0],3)))
axs[1].set_xlabel(r'shots$^{-1/2}$')
axs[1].set_ylabel(r'$\Delta\langle M\rangle$')
axs[1].legend()
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
mykey = 'd0db27e06149ec7280499124f8a6a11cf87d70d35c06147d3f70a8f9c0ae5a136f33ae887c14b0b44c10c1dc64e3249cc89aa7104fc3e01c940a3e1f1dead7fc'
IBMQ.save_account(mykey)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
small_devices = provider.backends(filters=lambda x: x.configuration().n_qubits == 5
and not x.configuration().simulator)
backend=least_busy(small_devices)
print(backend)
n_simulations = 20
shots = 10 #log scale
#State 1
theta_1=math.pi/4
phi_1=0
method_1_state_1 = []
runtime_method_1_state_1 = []
for n in tqdm(range(n_simulations)):
exp_value,runtime = method1(theta_1,phi_1,backend,shots)
method_1_state_1.append(exp_value)
runtime_method_1_state_1.append(runtime)
m1_dict = {'Method 1':method_1_state_1, 'Method 1 runtime':runtime_method_1_state_1}
pd.DataFrame(m1_dict).to_csv(f'{backend}_state_1.csv')
method_2_state_1 = []
runtime_method_2_state_1 = []
for n in tqdm(range(n_simulations)):
exp_value,runtime = method2(theta_1,phi_1,backend,shots)
method_2_state_1.append(exp_value)
runtime_method_2_state_1.append(runtime)
m1_dict.update({'Method 2':method_2_state_1, 'Method 2 runtime':runtime_method_2_state_1})
pd.DataFrame(m1_dict).to_csv(f'{backend}_state_1.csv')
#State 2
theta_2=math.pi/8
phi_2=math.pi/4
method_1_state_2 = []
runtime_method_1_state_2 = []
for n in tqdm(range(n_simulations)):
exp_value, runtime = method1(theta_2,phi_2,backend,shots)
method_1_state_2.append(exp_value)
runtime_method_1_state_2.append(runtime)
m2_dict = {'Method 1':method_2_state_1,'Method 1 runtime':runtime_method_1_state_2}
pd.DataFrame(m2_dict).to_csv(f'{backend}_state_2.csv')
method_2_state_2 = []
runtime_method_2_state_2 = []
for n in tqdm(range(n_simulations)):
exp_value, runtime = method2(theta_2,phi_2,backend,shots)
method_2_state_2.append(method2(exp_value))
runtime_method_2_state_2.append(runtime)
m2_dict.update({'Method 2':method_2_state_2,'Method 2 runtime':runtime_method_2_state_2})
pd.DataFrame(m2_dict).to_csv(f'{backend}_state_2.csv')
n_simulations = 20
shots = 10 #log scale
backend = 'ibmq_belem'
state_1_data = pd.read_csv(f'{backend}_state_1.csv')
state_1 = r'$\theta=\pi/4, \phi=0$'
exp_value_histogram(state_1_data, 'state_1', shots,backend, save = True)
state_2_data = pd.read_csv(f'{backend}_state_2.csv')
state_2 = r'$\theta=\pi/8, \phi=\pi/4$'
exp_value_histogram(state_2_data, 'state_2', shots,backend, mean=0.3827, save = True)
#State 1
runtime_method_1_state_1_mean = np.mean(state_1_data['Method 1 runtime'])
print(f'The mean runtime for method 1 for state 1 is: {runtime_method_1_state_1_mean} s')
runtime_method_2_state_1_mean = np.mean(state_1_data['Method 2 runtime'])
print(f'The mean runtime for method 2 for state 1 is: {runtime_method_2_state_1_mean} s')
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram as ph
%matplotlib inline
# Battleship Grid
## 0 1 2 3 4 5 6 7 8 9
#A - - - - - X X - - -
#B - - X - - - - X X X
#C - - X - - - - - - -
#D - - X - - X - - - -
#E - - - - - X - - - -
#F - - - - - X - - - -
#G - - - - - X - - - -
#H - - - - - - - - - -
#I - - - - - - - - - -
#J - - - - - X X X X X
#Acceptable solutions:
sol = [
'0000101',
'0000110',
'0001100',
'0010001',
'0010010',
'0010011',
'0010110',
'0100000',
'0101010',
'0101101',
'0110111',
'1000001',
'1001011',
'1101100',
'1101101',
'1101110',
'1101111'
]
tot = len(sol)
n = 7
s = []
for i in range(n-1):
s.append(i)
# 17 - 2 # 16 - 2 # 15 - 2 # 14 - 2 # 13 - 2
# 12 - 2 # 11 - 2 # 10 - 2 # 9 - 2
# 8 - 3 # 7 - 3 # 6 - 3 # 5 - 3
# 4 - 4 # 3 - 5 # 2 - 6 # 1 - 8
if tot > 8:
rep = 2
elif tot > 4:
rep = 3
elif tot == 4:
rep = 4
elif tot == 3:
rep = 5
elif tot == 2:
rep = 6
else:
rep = 8
def build_oracle(circuit, solutions):
for i in range(tot):
temp = solutions[i]
for j, yesno in enumerate(reversed(temp)):
if yesno == '0':
circuit.x(j)
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
for k, noyes in enumerate(reversed(temp)):
if noyes == '0':
circuit.x(k)
def amplify(circuit):
circuit.h(range(n))
circuit.x(range(n))
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
circuit.x(range(n))
circuit.h(range(n))
qc = QuantumCircuit(n)
qc.h(range(n))
for i in range(rep):
qc.barrier()
build_oracle(qc, sol)
qc.barrier()
amplify(qc)
qc.measure_all()
bknd = Aer.get_backend('qasm_simulator')
ph(execute(qc,backend=bknd,shots=1000000).result().get_counts())
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
class QuantComp:
def __init__(qboard, classical):
qboard.classical = classical
def convert(cboard):
ret = []
for i in range(len(cboard)):
if cboard[i] == 1:
hold = str(bin(i))
while(len(hold) < 7):
hold = '0' + hold
ret.append(hold)
return ret
def setup(array):
tot = len(array)
n = 7
s = []
for i in range(n-1):
s.append(i)
if tot > 8:
rep = 2
elif tot > 4:
rep = 3
elif tot == 4:
rep = 4
elif tot == 3:
rep = 5
elif tot == 2:
rep = 6
else:
rep = 8
return rep, n
def build_oracle(circuit, solutions, n):
for i in range(tot):
temp = solutions[i]
for j, yesno in enumerate(reversed(temp)):
if yesno == '0':
circuit.x(j)
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
for k, noyes in enumerate(reversed(temp)):
if noyes == '0':
circuit.x(k)
def amplify(circuit, n):
circuit.h(range(n))
circuit.x(range(n))
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
circuit.x(range(n))
circuit.h(range(n))
def guess(qboard):
sol = convert(qboard.classical)
rep, n = setup(sol)
qc = QuantumCircuit(n)
qc.h(range(n))
for i in range(rep):
build_oracle(qc, sol, n)
amplify(qc, n)
qc.measure_all()
simulator = Aer.get_backend('qasm_simulator')
return execute(qc, backend = simulator, shots = 1).result().get_counts()
q = QuantComp([0,0,0,0,0,1])
q.guess()
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
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/ncitron/qiskit-hack
|
ncitron
|
import os
import json
import asyncio
import websockets
import threading
from random import randint
from qiskit import *
from flask import Flask, send_from_directory
class Board:
def place(self):
arr = []
for i in range(100):
arr.append(0)
arr = self.ship(arr, 5)
arr = self.ship(arr, 4)
arr = self.ship(arr, 3)
arr = self.ship(arr, 3)
arr = self.ship(arr, 2)
return arr
def ship(self, array, length):
nope = True
while nope:
head = randint(0, 99)
orient = randint(0, 3)
truf = self.check(head, length, orient, array)
nope = not truf
array = self.put(head, length, orient, array)
return array
def check(self, h, l, o, a):
if a[h] != 0:
return False
if o == 0:
end = h+(l-1)
if (h - (h%10)) != (end - (end%10)):
return False
for i in range(l):
if a[h+i] != 0:
return False
elif o == 1:
end = h - 10*(l-1)
if end < 0:
return False
for i in range(l):
if a[h - 10*i] != 0:
return False
elif o == 2:
end = h-(l-1)
if (h - (h%10)) != (end - (end%10)):
return False
for i in range(l):
if a[h-i] != 0:
return False
elif o == 3:
end = h + 10*(l-1)
if end > 99:
return False
for i in range(l):
if a[h + 10*i] != 0:
return False
return True
def put(self, h, l, o, a):
if o == 0:
for i in range(l):
a[h+i] = 1
elif o == 1:
for i in range(l):
a[h-10*i] = 1
elif o == 2:
for i in range(l):
a[h-i] = 1
elif o == 3:
for i in range(l):
a[h+10*i] = 1
return a
class QuantComp:
def __init__(self):
print('created board')
def setBoard(self, classical):
self.classical = classical
def convert(self, cboard):
ret = []
for i in range(len(cboard)):
if cboard[i] == 1:
hold = str(bin(i).replace("0b",""))
while(len(hold) < 7):
hold = '0' + hold
ret.append(hold)
return ret
def setup(self, array):
tot = len(array)
n = 7
s = []
for i in range(n-1):
s.append(i)
if tot > 8:
rep = 2
elif tot > 4:
rep = 3
elif tot == 4:
rep = 4
elif tot == 3:
rep = 5
elif tot == 2:
rep = 6
else:
rep = 8
return rep, n, tot, s
def build_oracle(self, circuit, solutions, n, tot, s):
for i in range(tot):
temp = solutions[i]
for j, yesno in enumerate(reversed(temp)):
if yesno == '0':
circuit.x(j)
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
for k, noyes in enumerate(reversed(temp)):
if noyes == '0':
circuit.x(k)
def amplify(self, circuit, n, s):
circuit.h(range(n))
circuit.x(range(n))
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
circuit.x(range(n))
circuit.h(range(n))
def guess(self):
sol = self.convert(self.classical)
rep, n, tot, s = self.setup(sol)
qc = QuantumCircuit(n)
qc.h(range(n))
for i in range(rep):
self.build_oracle(qc, sol, n, tot, s)
self.amplify(qc, n, s)
qc.measure_all()
simulator = Aer.get_backend('qasm_simulator')
stng = list(execute(qc, backend = simulator, shots = 1).result().get_counts().keys())[0]
return int(stng, 2)
app = Flask(__name__, static_folder="./QuantumBattleship/build")
@app.route('/', defaults={'path': ''})
@app.route('/<path:path>')
def serve(path):
if path != "" and os.path.exists(app.static_folder + '/' + path):
return send_from_directory(app.static_folder, path)
else:
return send_from_directory(app.static_folder, 'index.html')
q = QuantComp()
async def websocket_server(websocket, path):
async for cmd in websocket:
cmdDict = json.loads(cmd)
print(cmdDict)
#quantum bot
if cmdDict['event'] == 'start':
sep = ', '
await websocket.send('{"event": "q-board", "quantumBoard": ' + str(Board().place()) + '}')
if cmdDict['event'] == 'p-board':
board = cmdDict['playerBoard']
for i in range(0, len(board)):
if board[i] == 3:
board[i] = 1
else:
board[i] = 0
q.setBoard(board)
if cmdDict['event'] == 'turn':
guess = q.guess()
q.classical[guess] = 0
await websocket.send('{"event": "guess", "target": ' + str(guess) + '}')
def thread():
app.run(use_reloader=False, port=8080, threaded=True)
if __name__ == '__main__':
threading.Thread(target=thread).start()
start_server = websockets.serve(websocket_server, "localhost", 8081)
asyncio.get_event_loop().run_until_complete(start_server)
asyncio.get_event_loop().run_forever()
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram as ph
%matplotlib inline
import math
#0 1 2
#3 4 5
#6 7 8
mat = [0,1,0,0,0,0,1,0,0]
circuit = QuantumCircuit(len(mat))
circuit.h(range(len(mat)))
circuit.barrier()
for i in range(len(mat)):
if mat[i] == 1:
circuit.y(i)
circuit.barrier()
circuit.h(range(len(mat)))
circuit.measure_all()
circuit.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots = 100).result()
counts = result.get_counts()
print(counts)
def oracle(circuit):
circuit.cz(0,2)
circuit.cz(1,2)
def diffuser(circuit):
"""Apply inversion about the average step of Grover's algorithm."""
qbits = circuit.qubits
nqbits = len(qbits)
for q in range(nqbits):
circuit.h(q)
circuit.x(q)
#Do controlled-Z
circuit.h(2)
circuit.ccx(0,1,2)
circuit.h(2)
for q in range(nqbits):
circuit.x(q)
circuit.h(q)
n=3
barriers = True
grover = QuantumCircuit(n)
for qb in range(n):
grover.h(qb)
if barriers:
grover.barrier()
oracle(grover)
if barriers:
grover.barrier()
diffuser(grover)
grover.measure_all()
grover.draw('mpl')
be = Aer.get_backend('qasm_simulator')
sh = 1024
ph(execute(grover,backend=be,shots=sh).result().get_counts())
from qiskit.quantum_info.operators import Operator
controls = QuantumRegister(2)
circuit = QuantumCircuit(controls)
dd = Operator([
[0, 0, 1, 0],
[0, 0, 0, 1],
[0, 1, 0, 0],
[1, 0, 0, 0]
])
circuit.unitary(dd, [0, 1], label='dd')
circuit.h(0)
circuit.draw('mpl')
# 4-qubit grover's algorithm
pi = math.pi
qc = QuantumCircuit(4)
shots = 2048
qc.h([0,1,2,3])
## Oracle for 0010 AND 1100 ##
qc.barrier()
qc.x([0,2,3])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,2,3])
qc.x([0,1])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,1])
qc.barrier()
## Amplification ##
qc.h([0,1,2,3])
qc.x([0,1,2,3])
#Start cccz
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
#end cccz
qc.x([0,1,2,3])
qc.h([0,1,2,3])
qc.barrier()
#### Repeat 1
## Oracle for 0010 AND 1100 ##
qc.x([0,2,3])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,2,3])
qc.x([0,1])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,1])
qc.barrier()
## Amplification ##
qc.h([0,1,2,3])
qc.x([0,1,2,3])
#Start cccz
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
#end cccz
qc.x([0,1,2,3])
qc.h([0,1,2,3])
qc.measure_all()
qc.draw('mpl')
bcn = Aer.get_backend('qasm_simulator')
ph(execute(qc,backend=bcn,shots=shots).result().get_counts())
# one acceptable answer (0010)
circ = QuantumCircuit(4)
circ.h([0,1,2,3])
circ.barrier()
circ.x([0,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,2,3])
circ.barrier()
circ.h([0,1,2,3])
circ.x([0,1,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,1,2,3])
circ.h([0,1,2,3])
circ.barrier()
circ.x([0,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,2,3])
circ.barrier()
circ.h([0,1,2,3])
circ.x([0,1,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,1,2,3])
circ.h([0,1,2,3])
circ.barrier()
circ.x([0,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,2,3])
circ.barrier()
circ.h([0,1,2,3])
circ.x([0,1,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,1,2,3])
circ.h([0,1,2,3])
circ.measure_all()
circ.draw('mpl')
bcnd = Aer.get_backend('qasm_simulator')
ph(execute(circ,backend=bcnd,shots=1024).result().get_counts())
# three acceptable answers (0101, 1111, 1000)
n = 7
s = []
for i in range(n-1):
s.append(i)
qcqc = QuantumCircuit(n)
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.measure_all()
qcqc.draw('mpl')
bknd = Aer.get_backend('qasm_simulator')
ph(execute(qcqc,backend=bknd,shots=1024).result().get_counts())
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram as ph
%matplotlib inline
# Battleship Grid
## 0 1 2 3 4 5 6 7 8 9
#A - - - - - X X - - -
#B - - X - - - - X X X
#C - - X - - - - - - -
#D - - X - - X - - - -
#E - - - - - X - - - -
#F - - - - - X - - - -
#G - - - - - X - - - -
#H - - - - - - - - - -
#I - - - - - - - - - -
#J - - - - - X X X X X
#Acceptable solutions:
sol = [
'0000101',
'0000110',
'0001100',
'0010001',
'0010010',
'0010011',
'0010110',
'0100000',
'0101010',
'0101101',
'0110111',
'1000001',
'1001011',
'1101100',
'1101101',
'1101110',
'1101111'
]
tot = len(sol)
n = 7
s = []
for i in range(n-1):
s.append(i)
# 17 - 2 # 16 - 2 # 15 - 2 # 14 - 2 # 13 - 2
# 12 - 2 # 11 - 2 # 10 - 2 # 9 - 2
# 8 - 3 # 7 - 3 # 6 - 3 # 5 - 3
# 4 - 4 # 3 - 5 # 2 - 6 # 1 - 8
if tot > 8:
rep = 2
elif tot > 4:
rep = 3
elif tot == 4:
rep = 4
elif tot == 3:
rep = 5
elif tot == 2:
rep = 6
else:
rep = 8
def build_oracle(circuit, solutions):
for i in range(tot):
temp = solutions[i]
for j, yesno in enumerate(reversed(temp)):
if yesno == '0':
circuit.x(j)
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
for k, noyes in enumerate(reversed(temp)):
if noyes == '0':
circuit.x(k)
def amplify(circuit):
circuit.h(range(n))
circuit.x(range(n))
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
circuit.x(range(n))
circuit.h(range(n))
qc = QuantumCircuit(n)
qc.h(range(n))
for i in range(rep):
qc.barrier()
build_oracle(qc, sol)
qc.barrier()
amplify(qc)
qc.measure_all()
bknd = Aer.get_backend('qasm_simulator')
ph(execute(qc,backend=bknd,shots=1000000).result().get_counts())
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
class QuantComp:
def __init__(qboard, classical):
qboard.classical = classical
def convert(cboard):
ret = []
for i in range(len(cboard)):
if cboard[i] == 1:
hold = str(bin(i))
while(len(hold) < 7):
hold = '0' + hold
ret.append(hold)
return ret
def setup(array):
tot = len(array)
n = 7
s = []
for i in range(n-1):
s.append(i)
if tot > 8:
rep = 2
elif tot > 4:
rep = 3
elif tot == 4:
rep = 4
elif tot == 3:
rep = 5
elif tot == 2:
rep = 6
else:
rep = 8
return rep, n
def build_oracle(circuit, solutions, n):
for i in range(tot):
temp = solutions[i]
for j, yesno in enumerate(reversed(temp)):
if yesno == '0':
circuit.x(j)
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
for k, noyes in enumerate(reversed(temp)):
if noyes == '0':
circuit.x(k)
def amplify(circuit, n):
circuit.h(range(n))
circuit.x(range(n))
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
circuit.x(range(n))
circuit.h(range(n))
def guess():
sol = convert(qboard.classical)
rep, n = setup(sol)
qc = QuantumCircuit(n)
qc.h(range(n))
for i in range(rep):
build_oracle(qc, sol, n)
amplify(qc, n)
qc.measure_all()
simulator = Aer.get_backend('qasm_simulator')
return execute(qc, backend = simulator, shots = 1).result().get_counts()
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram as ph
%matplotlib inline
import math
#0 1 2
#3 4 5
#6 7 8
mat = [0,1,0,0,0,0,1,0,0]
circuit = QuantumCircuit(len(mat))
circuit.h(range(len(mat)))
circuit.barrier()
for i in range(len(mat)):
if mat[i] == 1:
circuit.y(i)
circuit.barrier()
circuit.h(range(len(mat)))
circuit.measure_all()
circuit.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend = simulator, shots = 100).result()
counts = result.get_counts()
print(counts)
def oracle(circuit):
circuit.cz(0,2)
circuit.cz(1,2)
def diffuser(circuit):
"""Apply inversion about the average step of Grover's algorithm."""
qbits = circuit.qubits
nqbits = len(qbits)
for q in range(nqbits):
circuit.h(q)
circuit.x(q)
#Do controlled-Z
circuit.h(2)
circuit.ccx(0,1,2)
circuit.h(2)
for q in range(nqbits):
circuit.x(q)
circuit.h(q)
n=3
barriers = True
grover = QuantumCircuit(n)
for qb in range(n):
grover.h(qb)
if barriers:
grover.barrier()
oracle(grover)
if barriers:
grover.barrier()
diffuser(grover)
grover.measure_all()
grover.draw('mpl')
be = Aer.get_backend('qasm_simulator')
sh = 1024
ph(execute(grover,backend=be,shots=sh).result().get_counts())
from qiskit.quantum_info.operators import Operator
controls = QuantumRegister(2)
circuit = QuantumCircuit(controls)
dd = Operator([
[0, 0, 1, 0],
[0, 0, 0, 1],
[0, 1, 0, 0],
[1, 0, 0, 0]
])
circuit.unitary(dd, [0, 1], label='dd')
circuit.h(0)
circuit.draw('mpl')
# 4-qubit grover's algorithm
pi = math.pi
qc = QuantumCircuit(4)
shots = 2048
qc.h([0,1,2,3])
## Oracle for 0010 AND 1100 ##
qc.barrier()
qc.x([0,2,3])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,2,3])
qc.x([0,1])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,1])
qc.barrier()
## Amplification ##
qc.h([0,1,2,3])
qc.x([0,1,2,3])
#Start cccz
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
#end cccz
qc.x([0,1,2,3])
qc.h([0,1,2,3])
qc.barrier()
#### Repeat 1
## Oracle for 0010 AND 1100 ##
qc.x([0,2,3])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,2,3])
qc.x([0,1])
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.x([0,1])
qc.barrier()
## Amplification ##
qc.h([0,1,2,3])
qc.x([0,1,2,3])
#Start cccz
qc.cu1(pi/4, 0, 3)
qc.cx(0, 1)
qc.cu1(-pi/4, 1, 3)
qc.cx(0, 1)
qc.cu1(pi/4, 1, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
qc.cx(1, 2)
qc.cu1(-pi/4, 2, 3)
qc.cx(0, 2)
qc.cu1(pi/4, 2, 3)
#end cccz
qc.x([0,1,2,3])
qc.h([0,1,2,3])
qc.measure_all()
qc.draw('mpl')
bcn = Aer.get_backend('qasm_simulator')
ph(execute(qc,backend=bcn,shots=shots).result().get_counts())
# one acceptable answer (0010)
circ = QuantumCircuit(4)
circ.h([0,1,2,3])
circ.barrier()
circ.x([0,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,2,3])
circ.barrier()
circ.h([0,1,2,3])
circ.x([0,1,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,1,2,3])
circ.h([0,1,2,3])
circ.barrier()
circ.x([0,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,2,3])
circ.barrier()
circ.h([0,1,2,3])
circ.x([0,1,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,1,2,3])
circ.h([0,1,2,3])
circ.barrier()
circ.x([0,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,2,3])
circ.barrier()
circ.h([0,1,2,3])
circ.x([0,1,2,3])
circ.h(3)
circ.mct([0,1,2], 3)
circ.h(3)
circ.x([0,1,2,3])
circ.h([0,1,2,3])
circ.measure_all()
circ.draw('mpl')
bcnd = Aer.get_backend('qasm_simulator')
ph(execute(circ,backend=bcnd,shots=1024).result().get_counts())
# three acceptable answers (0101, 1111, 1000)
n = 7
s = []
for i in range(n-1):
s.append(i)
qcqc = QuantumCircuit(n)
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.barrier()
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([1,3])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x([0,1,2])
qcqc.barrier()
qcqc.h(range(n))
qcqc.x(range(n))
qcqc.h(n-1)
qcqc.mct(s, n-1)
qcqc.h(n-1)
qcqc.x(range(n))
qcqc.h(range(n))
qcqc.measure_all()
qcqc.draw('mpl')
bknd = Aer.get_backend('qasm_simulator')
ph(execute(qcqc,backend=bknd,shots=1024).result().get_counts())
|
https://github.com/alexao8/QC-Qiskit
|
alexao8
|
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, assemble, transpile
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.ibmq import least_busy
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Build
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(2, 2)
#Add a NOT gate on qubit 1
circuit.x(1)
# Add a H gate on qubit 0 and 1
circuit.h(0)
circuit.h(1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circuit.cx(0, 1)
# Add a H gate on qubit 0 and 1
circuit.h(0)
circuit.h(1)
# Map the quantum measurement to the classical bits
circuit.measure([0,1], [0,1])
circuit.draw(output = 'mpl')
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# Grab results from the job
result = job.result()
# Return counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
# Import draw_circuit, then use it to draw the circuit
from ibm_quantum_widgets import draw_circuit
draw_circuit(circuit)
# Analyze
#--------
# Plot a histogram
plot_histogram(counts)
# Load our saved IBMQ accounts and get the least busy backend device with greater than or equal to (n+1) qubits
n=2
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= (n+1) 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
transpiled_dj_circuit = transpile(circuit, backend, optimization_level=3)
job = backend.run(transpiled_dj_circuit)
job_monitor(job, interval=2)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/alexao8/QC-Qiskit
|
alexao8
|
#!/usr/bin/env python
# coding: utf-8
# In[1]:
get_ipython().run_line_magic('matplotlib', 'inline')
# Importing standard Qiskit libraries
from qiskit import *
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# In[2]:
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr)
# In[3]:
circuit.draw(output = 'mpl')
# In[4]:
circuit.h(qr[0])
# In[5]:
circuit.draw(output = 'mpl')
# In[6]:
circuit.cx(qr[0], qr[1])
# In[7]:
circuit.measure(qr,cr)
# In[8]:
circuit.draw(output = 'mpl')
# In[9]:
simulator = Aer.get_backend('qasm_simulator')
# In[10]:
result = execute(circuit, backend = simulator).result()
# In[11]:
plot_histogram(result.get_counts(circuit))
# In[12]:
provider = IBMQ.get_provider('ibm-q')
# In[14]:
qcomp = provider.get_backend('ibmq_16_melbourne')
# In[15]:
job = execute(circuit, backend = qcomp)
# In[ ]:
job_monitor(job)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
'''
helloworld.py
This file is intended as a simple template for qiskit files.
The code can be found at: https://qiskit.org/documentation/intro_tutorial1.html
'''
### 1. Import Packages
import numpy as np
from matplotlib import pyplot
from qiskit import QuantumCircuit, transpile # instructions of quantum system
from qiskit.providers.aer import QasmSimulator # Aer high performance circuit simulator
from qiskit.visualization import plot_histogram # creates histograms of circuit output
### 2. Initialize Variables
circuit = QuantumCircuit(2,2) # initialize the 2 qubits in zero state, and 2 classical bits set to 0
### 3. Add gates
circuit.h(0) # add Hadamard gate on qubit 0
circuit.cx(0, 1) # add CNOT gate with control qubit 0 and target qubit 1
circuit.measure([0,1], [0,1]) # Measure the two qubits and saves the result to the two classical bits
# Note: this circuit implements a simple Bell state, where there is equal chance of measuring |00> and |11>
### 4. Visualize the Circuit
circuit.draw(output='mpl') # draw the circuit as matplotlib figure
pyplot.show() # show the figure
### 5. Simulate the Experiment
simulator = QasmSimulator() # Create instance of Aer's qasm_simulator
compiled_circuit = transpile(circuit, simulator) # Compile the circuit down to low-level QASM instructions.
# Supported by the backend (not needed for simple circuits)
job = simulator.run(compiled_circuit, shots=1000) # Execute circuit on qasm simulator
result = job.result() # Fetch results
counts = result.get_counts(circuit) # Get the counts of outcomes from results
print("\nTotal count for 00 and 11 are:", counts) # Print total count for each outcome
### 6. Visualize the Results
plot_histogram(counts) # plots the results as a histogram
pyplot.show() # show the figure
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
from qiskit import QuantumCircuit
from matplotlib import pyplot
circ = QuantumCircuit(3)
# Create 3-qubit GHZ state: (1/sqrt(2))*(|000> + |111>)
circ.h(0)
circ.cx(0,1)
circ.cx(1,2)
### Visualize Circuit
circ.draw('mpl')
pyplot.show()
### Simulate Circuit
from qiskit.quantum_info import Statevector
state = Statevector.from_int(0,2**3)
state = state.evolve(circ)
lat = state.draw('latex') # This is not working in Pycharm - I think this needs to be a jupyter notebook
qsp = state.draw('qsphere')
hin = state.draw('hinton')
pyplot.show()
### Unitary Representation of Circuit
from qiskit.quantum_info import Operator
U = Operator(circ)
print(U.data) # show results
### OpenQASM Backend Simulation
meas = QuantumCircuit(3,3)
meas.barrier(range(3))
meas.measure(range(3), range(3))
qc = meas.compose(circ, range(3), front=True)
qc.draw('mpl')
pyplot.show()
from qiskit import transpile
from qiskit.providers.aer import QasmSimulator
backend = QasmSimulator()
qc_compiled = transpile(qc, backend)
job_sim = backend.run(qc_compiled, shots=1024)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc_compiled)
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
pyplot.show()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
from qiskit import *
from matplotlib import pyplot
# Initialize quantum circuit with 3 qubits (and no classical bits)
circ = QuantumCircuit(3)
# Set circuit into 3-qubit GHZ state
circ.h(0)
circ.cx(0,1)
circ.cx(0,2)
# Visualize circuit
circ.draw('mpl')
pyplot.show()
### Simulating circuits with Qiskit Aer
from qiskit import Aer
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
outputstate = result.get_statevector(circ, decimals=3)
print(outputstate)
from qiskit.visualization import plot_state_city
plot_state_city(outputstate)
pyplot.show()
### Unitary Backend
backend = Aer.get_backend('unitary_simulator')
job = execute(circ, backend)
result = job.result()
print(result.get_unitary(circ, decimals=3))
### Open QASM Backend
# New circuit with classical bits
meas = QuantumCircuit(3,3)
meas.barrier(range(3))
meas.measure(range(3),range(3))
qc = circ + meas
qc.draw('mpl')
pyplot.show()
# Simulate
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend_sim, shots=1024)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
print(counts)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
pyplot.show()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import *
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from matplotlib import pyplot
# Quanum ciruit to make a Bell state
bell = QuantumCircuit(2,2)
bell.h(0)
bell.cx(0,1)
meas = QuantumCircuit(2,2)
meas.measure([0,1],[0,1])
# execute quantum circuit
backend = BasicAer.get_backend('qasm_simulator')
circ = bell + meas
result = execute(circ,backend,shots=1000).result()
counts = result.get_counts(circ)
print(counts)
plot_histogram(counts).show() # don't need pyplot.show() anymore
# could also call .savefig('output.png') to save to file
second_result = execute(circ,backend, shots=1000).result()
second_counts = second_result.get_counts(circ)
legend = ['first execution', 'second execution']
plot_histogram([counts, second_counts], legend=legend, sort='desc', figsize=(15,12),
color=['orange', 'black'], bar_labels=False).savefig('histogram1.png')
### Advanced Visualizations
from qiskit.visualization import plot_state_city, plot_bloch_multivector
from qiskit.visualization import plot_state_paulivec, plot_state_hinton
from qiskit.visualization import plot_state_qsphere
# execute quantum circuit
backend = BasicAer.get_backend('statevector_simulator')
result = execute(bell,backend).result()
psi = result.get_statevector(bell)
plot_state_city(psi,
title = "My City",
color = ['black', 'orange']).show()
plot_state_hinton(psi,
title = "My Hinton").show()
plot_state_qsphere(psi).show()
plot_state_paulivec(psi,
title = "My Paulivec",
color = ['purple', 'orange', 'green']).show()
plot_bloch_multivector(psi,
title = "My Bloch Spheres").show()
# note: there is no vector in block multivector since system is in an entangled state
### Plotting Bloch Vectors
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector([0,1,0],
title = "My Bloch Sphere").show()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import matplotlib.pyplot as plt
import numpy as np
from math import pi
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
from qiskit.quantum_info import state_fidelity
from qiskit import BasicAer
backend = BasicAer.get_backend('unitary_simulator')
#### === Single Qubit Gates ===
q = QuantumRegister(1)
## general unitary gate
qc = QuantumCircuit(q)
theta = pi/2
phi = pi/2
lambd = pi/2
qc.u(theta,phi,lambd,q) # previously qc.u3
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("u gate:", res)
# u2 gate = u(pi/2, phi, lambda) is useful to create superpositions
qc = QuantumCircuit(q)
phi = pi/3
lambd = pi/4
qc.u(pi/2,phi,lambd,q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("u2 gate:", res)
# u1 gate = u3(0,0,lambda) is useful to apply a quantum phase
qc = QuantumCircuit(q)
lambd = pi/5
qc.p(lambd, q)# or, alternativley qc.u(0,0,lambd,q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("u1 gate:", res)
## Identity gate
qc = QuantumCircuit(q)
qc.id(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Identity gate:", res)
## Pauli gates
# X (bit-flip) gate = u(pi,0,pi)
qc = QuantumCircuit(q)
qc.x(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("X gate:", res)
# Y (bit- and phase-flip) gate = u(pi,pi/2,pi/2)
qc = QuantumCircuit(q)
qc.y(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Y gate:", res)
# Z (bit-flip) gate = u(pi,0,pi)
qc = QuantumCircuit(q)
qc.x(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Z gate", res)
## Clifford Gates
# Hadamard gate = u3(pi/2, 0, pi)
qc = QuantumCircuit(q)
qc.h(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Hadamard gate", res)
# S (sqrt(Z) phase) gate = u1(pi/2)
qc = QuantumCircuit(q)
qc.s(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("S gate", res)
# S-dagger (conjugate of sqrt(Z) phase) gate = u3(-pi/2)
qc = QuantumCircuit(q)
qc.sdg(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("S-dagger gate", res)
## C3 Gates
# T (sqrt(S)) gate = u1(pi/4)
qc = QuantumCircuit(q)
qc.t(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("T gate", res)
# T-dagger (conjugate of sqrt(S)) gate = u1(-pi/4)
qc = QuantumCircuit(q)
qc.tdg(q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("T-dagger gate", res)
## Standard Rotations
# Rotation around X-axis = u3(theta, -pi/2, pi/2)
qc = QuantumCircuit(q)
theta=pi/2
qc.rx(theta, q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("X-axis rotation gate", res)
# Rotation around Y-axis = u3(theta, 0, 0)
qc = QuantumCircuit(q)
theta=pi/2
qc.ry(theta, q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Y-axis rotation gate", res)
# Rotation around Z-axis = u1(phi)
qc = QuantumCircuit(q)
phi=pi/2
qc.rz(phi, q)
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Z-axis rotation gate", res)
#### === Multi-Qubit Gates ===
### Two-Qubit Gates
q= QuantumRegister(2)
## Controlled Pauli Gates
# Controled-X Gate
qc = QuantumCircuit(q)
qc.cx(q[0], q[1])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled-X gate", res)
# Controled-Y Gate
qc = QuantumCircuit(q)
qc.cy(q[0], q[1])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled-Y gate", res)
# Controled-Z Gate
qc = QuantumCircuit(q)
qc.cz(q[0], q[1])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled-Z gate", res)
## Controled Hadamard Gate
qc = QuantumCircuit(q)
qc.ch(q[0], q[1])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled Hadamard gate", res)
## Controlled Rotation Gates
# Controled-Z Rotation Gate
qc = QuantumCircuit(q)
lambd = pi/2
qc.crz(lambd, q[0], q[1])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled Rotation Around Z-axis gate", res)
# Controled-Phase Rotation Gate
qc = QuantumCircuit(q)
lambd = pi/2
qc.cp(lambd, q[0], q[1]) # previously qc.cu1
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled-Phase Roatation gate", res)
# Controled-u Rotation Gate
qc = QuantumCircuit(q)
theta = pi/2
phi = pi/2
lambd = pi/2
qc.cu(theta,phi,lambd, 0, q[0], q[1]) # previously qc.cu3
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled-u Rotation gate", res)
# SWAP Gate
qc = QuantumCircuit(q)
qc.swap(q[0], q[1])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("SWAP gate", res)
### Three-Qubit Gates
q= QuantumRegister(3)
## Toffoli Gate
qc = QuantumCircuit(q)
qc.ccx(q[0], q[1], q[2])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Toffoli gate", res)
## Controlled Swap (Fredkin) Gate
qc = QuantumCircuit(q)
qc.cswap(q[0], q[1], q[2])
qc.draw('mpl')
plt.show()
job = execute(qc, backend)
res = job.result().get_unitary(qc, decimals=3)
print("Controlled Swap gate", res)
#### === Non-Unitary Operations ===
q = QuantumRegister(1)
c = ClassicalRegister(1)
### Measurements
# qubit in state |0> only
qc = QuantumCircuit(q,c)
qc.measure(q,c)
qc.draw('mpl')
plt.show()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1024)
res = job.result().get_counts(qc)
print("Measurement Results: ", res)
# qubit in state |0> and |1> with equal probability
qc = QuantumCircuit(q,c)
qc.h(q)
qc.measure(q,c)
qc.draw('mpl')
plt.show()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1024)
res = job.result().get_counts(qc)
print("Measurement Results: ", res)
### Reset
# Resets all qubits to |0> state
qc = QuantumCircuit(q,c)
qc.h(q)
qc.reset(q[0])
qc.measure(q,c)
qc.draw('mpl')
plt.show()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1024)
res = job.result().get_counts(qc)
print("Measurement Results: ", res)
### Conditional Operators
# classical bit always takes value 0 so qubit state is always flipped
qc = QuantumCircuit(q,c)
qc.x(q[0]).c_if(c,0)
qc.measure(q,c)
qc.draw('mpl')
plt.show()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1024)
res = job.result().get_counts(qc)
print("Measurement Results: ", res)
# classical bit by first measurement is random, but conditional operation results in qubit being
# deterministically put to 1.
qc = QuantumCircuit(q,c)
qc.h(q)
qc.measure(q,c)
qc.x(q[0]).c_if(c,0)
qc.measure(q,c)
qc.draw('mpl')
plt.show()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1024)
res = job.result().get_counts(qc)
print("Measurement Results: ", res)
### Arbitrary Initialization
# Initialize qubit register to arbitrary state:
# |psi> = i/4|000> + 1/sqrt(8)|001> + (1+i)/4|010> + (1 + 2i)/sqrt(8)|101> + 1/4|110>
import math
desired_vector = [
1 / math.sqrt(16) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(16) * complex(1, 1),
0,
0,
1 / math.sqrt(8) * complex(1, 2),
1 / math.sqrt(16) * complex(1, 0),
0
]
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.initialize(desired_vector, [q[0],q[1],q[2]])
qc.draw('mpl')
plt.show()
backend = BasicAer.get_backend('statevector_simulator')
job = execute(qc, backend)
qc_state = job.result().get_statevector(qc)
print("QC state:", qc_state)
# you should check the Fidelity to ensure the state matches the desired vector
fid = state_fidelity(desired_vector, qc_state)
print("Fidelity: ", fid)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
from qiskit import *
from matplotlib import pyplot
### Opaque Gates
from qiskit.circuit import Gate
my_gate = Gate(name='my_gate', num_qubits=2, params=[])
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.append(my_gate, [qr[0], qr[1]])
circ.append(my_gate, [qr[1], qr[2]])
circ.draw('mpl')
pyplot.show()
### Composite Gates
# build a sub-circuit
sub_q = QuantumRegister(2)
sub_circ = QuantumCircuit(sub_q, name="sub_circ")
sub_circ.h(sub_q[0])
sub_circ.crz(1, sub_q[0], sub_q[1])
sub_circ.barrier()
sub_circ.id(sub_q[1])
sub_circ.u(1,2,-2, sub_q[0])
# convert to a gate and stick it into an arbitrary place in the bigger circuit
sub_inst = sub_circ.to_instruction()
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.cx(qr[1], qr[2])
circ.append(sub_inst, [qr[1], qr[2]])
circ.draw('mpl')
pyplot.show()
# decompose sub-circuit
decomposed_circ = circ.decompose()
decomposed_circ.draw('mpl')
pyplot.show()
### Parameterized Circuits
from qiskit.circuit import Parameter
theta = Parameter('θ')
n=5
qc = QuantumCircuit(n,1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(5))
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0,0)
qc.draw('mpl')
pyplot.show()
print(qc.parameters)
# binding parameters
import numpy as np
theta_range = np.linspace(0, 2*np.pi, 128)
circuits = [qc.bind_parameters({theta: theta_val}) for theta_val in theta_range]
circuits[-1].draw('mpl') # Last of 128 circuits
pyplot.show()
job = execute(qc,
backend=BasicAer.get_backend('qasm_simulator'),
parameter_binds=[{theta: theta_val} for theta_val in theta_range]
)
counts = job.result().get_counts()
print(len(counts))
# plot oscillation in qubit 0 as theta value changes
fig = pyplot.figure(figsize=(8,6))
ax = fig.add_subplot(111)
ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')
ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'],
fontsize = 14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
pyplot.show()
### Reducing Compilation Cost
import time
from itertools import combinations
from qiskit.compiler import assemble
from qiskit.test.mock import FakeVigo
# start with compiling over bound circuits
start = time.time()
qcs = []
theta_range = np.linspace(0, 2*np.pi, 32)
for n in theta_range:
qc = QuantumCircuit(5)
for k in range(8):
for i,j in combinations(range(5),2):
qc.cx(i,j)
qc.rz(n, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qcs.append(qc)
compiled_circuits = transpile(qcs, backend=FakeVigo())
qobj = assemble(compiled_circuits, backend=FakeVigo())
end = time.time()
print('Time compiling over set of bound circuits: ', end-start, 's')
# now, compile over parametrized circuits, then bind
start = time.time()
qc = QuantumCircuit(5)
theta = Parameter('theta')
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(theta, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
transpiled_qc = transpile(qc, backend = FakeVigo())
qobj = assemble([transpiled_qc.bind_parameters({theta: n})
for n in theta_range], backend=FakeVigo())
end = time.time()
print('Time compiling over parameterized circuit, then binding: ', end-start, 's')
### Composition
# Parameterized circuits can be composed like standard quantum circuits, but
# the parameter names in each circuit must be unique across all circuits, unless
# the circuits use the same parameter
phi = Parameter('phi')
sub_circ1 = QuantumCircuit(2, name='sc_1')
sub_circ1.rz(phi, 0)
sub_circ1.rx(phi, 1)
sub_circ2 = QuantumCircuit(2, name='sc_2')
sub_circ2.rz(phi, 0)
sub_circ2.rx(phi, 1)
qc = QuantumCircuit(4)
qr = qc.qregs[0]
qc.append(sub_circ1.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[2], qr[3]])
print(qc.draw())
# The following raises an error: "QiskitError: 'Name conflict on adding parameter: phi'"
# phi2 = Parameter('phi')
# qc.u(0.1, phi2, 0.3, 0)
# To insert a subcircuit under a different parameterization, the to_instruction method accepts an
# optional argument (parameter_map) which, when present, will generate instructions with the source parameter
# replaced by a new parameter.
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0,1)
qc.rz(p,1)
qc.cx(1, 2)
qc.rz(p, 2)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())
print(larger_qc.decompose().draw())
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity
from qiskit.extensions import RXGate, XGate, CXGate
### Operator Class
# Create two-qubit Pauli-XX operator
XX = Operator([[0,0,0,1], [0,0,1,0], [0,1,0,0], [1,0,0,0]])
# Show operator properties
print(XX)
print(XX.data)
input_dim, output_dim = XX.dim
print(input_dim, output_dim)
# See input and output dimensions
op = Operator(np.random.rand(2**1, 2**2))
print('Input dimensions: ', op.input_dims())
print('Output dimensions: ', op.output_dims())
# If input matrix is not divisible into qubit systems,
# it will be stored as single-qubit operator
op = Operator(np.random.rand(6, 6))
print('Input dimensions: ', op.input_dims())
print('Output dimensions: ', op.output_dims())
# The input and output can also be manually specified when initializing new operator
op = Operator(np.random.rand(2**1, 2**2), input_dims=[4])
print('Input dimensions: ', op.input_dims())
print('Output dimensions: ', op.output_dims())
op = Operator(np.random.rand(6, 6), # system is qubit and qutrit
input_dims=[2,3], output_dims=[2,3])
print('Input dimensions: ', op.input_dims())
print('Output dimensions: ', op.output_dims())
# extract input/output dimensions of subset of subsystem
print('Dimension of input system 0:', op.input_dims([0]))
print('Dimension of input system 1:', op.input_dims([1]))
### Converting Classes to Operators
# Create operator from a Pauli object
pauliXX = Pauli('XX')
op = Operator(pauliXX)
print(op)
# Create operator from a Gate object
op = Operator(CXGate())
print(op)
# Create operator from a parameterized Gate object
op = Operator(RXGate(np.pi/2))
print(op)
# Create operator from a QuantumCircuit object
circ = QuantumCircuit(10)
circ.h(0)
for j in range(1,10):
circ.cx(j-1, j)
op = Operator(circ) #converts circuit into operator by implicit unitary simulation
print(op)
### Using Operators in circuits
from matplotlib import pyplot
# Create new operator
XX = Operator(Pauli('XX'))
circ = QuantumCircuit(2,2)
circ.append(XX, [0,1])
circ.measure([0,1],[0,1])
circ.draw('mpl')
pyplot.show()
# Can also directly insert Pauli object into circuit, to convert into sequence of
# single-qubit Pauli gates
backend = BasicAer.get_backend('qasm_simulator')
job = execute(circ, backend, basis_gates=['u1','u2','u3','cx'])
job.result().get_counts(0)
circ2 = QuantumCircuit(2,2)
circ2.append(Pauli('XX'), [0,1])
circ2.measure([0,1],[0,1])
circ2.draw('mpl')
pyplot.show()
### Combining Operators
# Tensor Product
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
tens = A.tensor(B)
print(tens)
# Tensor Expansion
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
tens = A.expand(B)
print(tens)
# Composition (matrix multiplication B.A)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
comp = A.compose(B)
print(comp)
# Reverse order composition (matrix multiplication A.B)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
comp = A.compose(B, front=True)
print(comp)
# Subsystem Composition
# compose XZ with a 3-qubit identity operator
op = Operator(np.eye(2**3))
XZ = Operator(Pauli('XZ'))
combop = op.compose(XZ, qargs=[0,2])
print(combop)
# compose YX in front of the previous operator
op = Operator(np.eye(2**3))
YX = Operator(Pauli('YX'))
combop = op.compose(XZ, qargs=[0,2], front=True)
print(combop)
# Linear Combinations
XX = Operator(Pauli('XX'))
YY = Operator(Pauli('YY'))
ZZ = Operator(Pauli('ZZ'))
op = 0.5 * (XX + YY - 3* ZZ)
print(op)
print("Operator is unitary?: ", op.is_unitary())
# Implicit conversion to Operators
op = Operator(np.eye(2)).compose([[0,1], [1,0]])
print(op)
### Comparison of Operators
print(
Operator(Pauli('X')) == Operator(XGate())
)
# Unitaries that differ by a global phase are not considered equal
print(
Operator(XGate()) == np.exp(1j * 0.5) * Operator(XGate())
)
# Process Fidelity - information theoretic quantification of how close two quantum
# channels are to each other, does not depend on global phase (must both be unitary)
op_a = Operator(XGate())
op_b = np.exp(1j * 0.5) * Operator(XGate())
F = process_fidelity(op_a, op_b)
print('Process fidelity = ', F)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from qiskit.transpiler import PassManager
# Create simple circuit with toffoli gate
circ = QuantumCircuit(3)
circ.ccx(0,1,2)
circ.draw('mpl').show()
# Unroll circuit (show base gates)
from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u1', 'u2', 'u3', 'cx'])
pm = PassManager(pass_)
new_circ = pm.run(circ)
new_circ.draw('mpl').show()
# Show transpiler pass options
from qiskit.transpiler import passes
qis_passes = [pass_ for pass_ in dir(passes) if pass_[0].isupper()]
print(qis_passes)
### Different Variants of the Same Pass
from qiskit.transpiler import CouplingMap, Layout
from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
circuit = QuantumCircuit(7)
circuit.h(3)
circuit.cx(0, 6)
circuit.cx(6, 0)
circuit.cx(0, 1)
circuit.cx(3, 1)
circuit.cx(3, 0)
circuit.draw('mpl').show()
coupling_map = CouplingMap(couplinglist=coupling)
bs = BasicSwap(coupling_map=coupling_map)
pass_manager = PassManager(bs)
basic_circ = pass_manager.run(circuit)
basic_circ.draw('mpl').show()
ls = LookaheadSwap(coupling_map=coupling_map)
pass_manager = PassManager(ls)
lookahead_circ = pass_manager.run(circuit)
lookahead_circ.draw('mpl').show()
ss = StochasticSwap(coupling_map=coupling_map)
pass_manager = PassManager(ss)
stochastic_circ = pass_manager.run(circuit)
stochastic_circ.draw('mpl').show()
### Preset Pass Managers
# Optimizes circuit baed on 4 optimization levels (0-3)
import math
from qiskit.test.mock import FakeTokyo
backend = FakeTokyo()
qc = QuantumCircuit(10)
random_state = [
1 / math.sqrt(4) * complex(0,1),
1 / math.sqrt(8) * complex(0,1),
0,
0,
0,
0,
0,
0,
1 / math.sqrt(8) * complex(1,0),
1 / math.sqrt(8) * complex(0,1),
0,
0,
0,
0,
1 / math.sqrt(4) * complex(1,0),
1 / math.sqrt(8) * complex(1,0)
]
qc.initialize(random_state, range(4))
qc.draw('mpl').show()
# Map to 20 qubit Tokyo device with different optimization levels
optimized_0 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=0)
print('Optimization level: 0')
print('gates = ', optimized_0.count_ops())
print('depth = ', optimized_0.depth())
optimized_1 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=1)
print('Optimization level: 1')
print('gates = ', optimized_1.count_ops())
print('depth = ', optimized_1.depth())
optimized_2 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=2)
print('Optimization level: 2')
print('gates = ', optimized_2.count_ops())
print('depth = ', optimized_2.depth())
optimized_3 = transpile(qc, backend=backend, seed_transpiler=11, optimization_level=3)
print('Optimization level: 3')
print('gates = ', optimized_3.count_ops())
print('depth = ', optimized_3.depth())
##### Introducing the DAG #####
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c,2)
circ.draw('mpl').show()
# Show the DAG representation of circuit
from qiskit.converters import circuit_to_dag
from qiskit.tools.visualization import dag_drawer
dag = circuit_to_dag(circ)
dag_drawer(dag)
# Get all op nodes in DAG & examine Node details
op_nodes = dag.op_nodes()
print(op_nodes)
for i,node in enumerate(dag.op_nodes()):
print('node ', i)
print('node name: ', node.name)
print('node op: ', node.op)
print('node qargs: ', node.qargs)
print('node cargs: ', node.cargs)
print('node condition: ', node.condition)
# Add an operation to the back
from qiskit.circuit.library import HGate
dag.apply_operation_back(HGate(), qargs=[q[0]])
dag_drawer(dag)
# Add an operation to the front
from qiskit.circuit.library import CCXGate
dag.apply_operation_front(CCXGate(), qargs=[q[0], q[1], q[2]], cargs=[])
dag_drawer(dag)
# Substitute a node within a circuit
from qiskit.circuit.library import CHGate, U2Gate, CXGate
mini_dag = DAGCircuit()
p = QuantumRegister(2, "p")
mini_dag.add_qreg(p)
mini_dag.apply_operation_back(CHGate(), qargs=[p[0], p[1]])
mini_dag.apply_operation_back(U2Gate(0.1,0.2), qargs=[ p[1]])
# Substitute the cx node with above mini-dag
cx_node = dag.op_nodes(op=CXGate).pop()
dag.substitute_node_with_dag(node=cx_node, input_dag=mini_dag, wires=[p[0], p[1]])
dag_drawer(dag)
# Convert back to regular QuantumCircuit object
from qiskit.converters import dag_to_circuit
circuit = dag_to_circuit(dag)
circuit.draw('mpl').show()
### Implementing a BasicMapper Pass
from copy import copy
from qiskit.transpiler.basepasses import TransformationPass
from qiskit.transpiler import Layout
from qiskit.circuit.library import SwapGate
class BasicSwap(TransformationPass):
""" Maps (with minimum effort) a DAGCircuit onto a `coupling_map` adding swap gates."""
def __init__(self,
coupling_map,
initial_layout=None):
"""Maps a DAGCircuit onto a `coupling_map` using swap gates.
Args:
coupling_map (CouplingMap): Directed graph representing a coupling map.
initial_layout (Layout): initial layout of qubits in mapping.
"""
super().__init__()
self.coupling_map = coupling_map
self.initial_layout = initial_layout
def run(self,
dag):
"""Runs the BasicSwap pass on `dag`.
Args:
dag (DAGCircuit): DAG to map.
Returns:
DAGCircuit: A mapped DAG.
Raises:
TranspilerError: if the coupling map or the layout are not
compatible with the DAG.
"""
new_dag = DAGCircuit()
for qreg in dag.qregs.values():
new_dag.add_qreg(qreg)
for creg in dag.cregs.values():
new_dag.add_creg(creg)
if self.initial_layout is None:
if self.property_set["layout"]:
self.initial_layout = self.property_set["layout"]
else:
self.initial_layout = Layout.generate_trivial_layout(*dag.qregs.values())
if len(dag.qubits) != len(self.initial_layout):
raise TranspilerError("The layout does not match the amount of qubits in the DAG")
if len(self.coupling_map.physical_qubits) != len(self.initial_layout):
raise TranspilerError("Mappers require to have the layout to be the same size as the coupling map")
canonical_register = dag.qregs['q']
trivial_layout = Layout.generate_trivial_layout(canonical_register)
current_layout = trivial_layout.copy()
for layer in dag.serial_layers():
subdag = layer['graph']
for gate in subdag.two_qubit_ops():
physical_q0 = current_layout[gate.qargs[0]]
physical_q1 = current_layout[gate.qargs[1]]
if self.coupling_map.distance(physical_q0, physical_q1) != 1:
# Insert a new layer with the SWAP(s).
swap_layer = DAGCircuit()
swap_layer.add_qreg(canonical_register)
path = self.coupling_map.shortest_undirected_path(physical_q0,physical_q1)
for swap in range(len(path) - 2):
connected_wire_1 = path[swap]
connected_wire_2 = path[swap+1]
qubit_1 = current_layout[connected_wire_1]
qubit_2 = current_layout[connected_wire_2]
# create the swap operation
swap_layer.apply_operation_back(SwapGate(),
qargs=[qubit_1, qubit_2],
cargs=[])
# layer insertion
order = current_layout.reorder_bits(new_dag.qubits)
new_dag.compose(swap_layer, qubits=order)
# update current_layout
for swap in range(len(path) - 2):
current_layout.swap(path[swap], path[swap+1])
order = current_layout.reorder_bits(new_dag.qubits)
new_dag.compose(subdag, qubits=order)
return new_dag
### Test pass on example circuit
q = QuantumRegister(7, 'q')
in_circ = QuantumCircuit(q)
in_circ.h(q[0])
in_circ.cx(q[0], q[4])
in_circ.cx(q[2], q[3])
in_circ.cx(q[6], q[1])
in_circ.cx(q[5], q[0])
in_circ.rz(0.1, q[2])
in_circ.cx(q[5], q[0])
# Create pass manager, pass example circuit to it, and obtain transformed circuit
from qiskit.transpiler import PassManager
from qiskit.transpiler import CouplingMap
from qiskit import BasicAer
pm = PassManager()
coupling = [[0,1], [1,2], [2,3], [3,4], [4,5], [5,6]]
coupling_map = CouplingMap(couplinglist=coupling)
pm.append([BasicSwap(coupling_map)])
out_circ = pm.run(in_circ)
in_circ.draw('mpl').show()
out_circ.draw('mpl').show()
### Transpiler Logging
# Set up Python logging
import logging
logging.basicConfig(level='DEBUG')
# Make test circuit to see debug log statements
from qiskit.test.mock import FakeTenerife
log_circ = QuantumCircuit(2,2)
log_circ.h(0)
log_circ.h(1)
log_circ.h(1)
log_circ.x(1)
log_circ.cx(0,1)
log_circ.measure([0,1], [0,1])
backend = FakeTenerife()
transpile(log_circ,backend)
# Adjust log level for the transpiler
logging.getLogger('qiskit.transpiler').setLevel('INFO')
transpile(log_circ, backend)
# Setting up logging to deal with parallel execution (naieve way)
logging.getLogger('qiskit_transpiler').setLevel('DEBUG')
circuits = [log_circ, log_circ, log_circ]
transpile(circuits, backend)
# Format logging to deal with parallel execution better
formatter = logging.Formatter('%(name)s - %(processName)-10s - %(levelname)s: %(message)s')
handler = logging.getLogger().handlers[0]
handler.setFormatter(formatter)
transpile(circuits, backend)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from matplotlib import pyplot
### Drawing a Quantum Circuit
# Build a quantum circuit
circuit = QuantumCircuit(3,3)
circuit.x(1)
circuit.h(range(3))
circuit.cx(0,1)
circuit.measure(range(3), range(3))
# Print ASCII art version of circuit diagram to stdout
print(circuit)
### Alternative Renderers for Circuits
# Create matplotlib circuit diagram
circuit.draw('mpl')
pyplot.show()
# # Create matplotlib circuit diagram
# circuit.draw('latex')
# # TODO: this does not work - need to figure out why
### Customizing the Output
# Draw a new circuit with barriers and more registers
q_a = QuantumRegister(3, name='qa')
q_b = QuantumRegister(5, name='qb')
c_a = ClassicalRegister(3)
c_b = ClassicalRegister(5)
circuit = QuantumCircuit(q_a, q_b, c_a, c_b)
circuit.x(q_a[1])
circuit.x(q_b[1])
circuit.x(q_b[2])
circuit.x(q_b[4])
circuit.barrier()
circuit.h(q_a)
circuit.barrier(q_a)
circuit.h(q_b)
circuit.cswap(q_b[0], q_b[1], q_b[2])
circuit.cswap(q_b[2], q_b[3], q_b[4])
circuit.cswap(q_b[3], q_b[4], q_b[0])
circuit.barrier(q_b)
circuit.measure(q_a, c_a)
circuit.measure(q_b, c_b)
# Draw the circuit
circuit.draw('mpl')
pyplot.show()
# Draw the circuit with reversed bit order
circuit.draw('mpl', reverse_bits=True)
pyplot.show()
# Draw the circuit without barriers
circuit.draw('mpl', plot_barriers=False)
pyplot.show()
### Backend-specific Customizations
# Set the line length to 80 for above circuit
print(circuit)
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
circuit.draw('mpl', style=style)
pyplot.show()
# Scale the mpl output to 1/2 the normal size
circuit.draw('mpl', scale=0.5)
pyplot.show()
### Display using circuit_drawer() as function
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(circuit, output='mpl', plot_barriers=False)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import pylab
import numpy as np
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.tools.visualization import plot_histogram
from qiskit.algorithms import Grover, AmplificationProblem
from qiskit.circuit.library.phase_oracle import PhaseOracle
### Finding Solutions to 3-SAT Problems
input_3sat_instance = '''
c example DIMACS-CNF 3-SAT
p cnf 3 5
-1 -2 -3 0
1 -2 3 0
1 2 -3 0
1 -2 -3 0
-1 2 3 0
''' # example problem has 3 solutions: (1 -2 3), (-1 -2 -3), (1 2 -3)
# Create corresponding oracle for Grover search using PhaseOracle (supports DIMACS-CNF format strings)
import os
import tempfile
from qiskit.exceptions import MissingOptionalLibraryError
fp = tempfile.NamedTemporaryFile(mode='w+t', delete=False)
fp.write(input_3sat_instance)
file_name = fp.name
fp.close()
oracle = None
try:
oracle = PhaseOracle.from_dimacs_file(file_name)
except MissingOptionalLibraryError as ex:
print(ex)
finally:
os.remove(file_name)
# create Grover instance using oracle
problem = None
if oracle is not None:
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
# configure backend & run Grover instance to obtain result
backend = Aer.get_backend('aer_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
grover = Grover(quantum_instance=quantum_instance)
result = None
if problem is not None:
result = grover.amplify(problem)
print(result.assignment)
plot_histogram(result.circuit_results[0]).show()
### Boolean Logical Expressions
# Construct oracle using arbitrary Boolean logic expression
expression = '(w ^ x) & ~(y ^ z) & (x & y & z)'
try:
oracle = PhaseOracle(expression)
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
grover = Grover(quantum_instance=QuantumInstance(Aer.get_backend('aer_simulator'),
shots=1024))
result = grover.amplify(problem)
plot_histogram(result.circuit_results[0]).show()
except MissingOptionalLibraryError as ex:
print(ex)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import QuantumCircuit
from qiskit.algorithms import AmplificationProblem
### Specify oracle for Grover's algorithm circuit
# the state we desire to find is '11'
good_state = ['11']
# specify the oracle that marks the state '11' as a good solution
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
# define Grover's algorithm
problem = AmplificationProblem(oracle, is_good_state=good_state)
# now we can have a look at the Grover operator aht is used in running the algorithm
problem.grover_operator.draw(output='mpl').show()
### Specify backend and call run method of Grover with backend to execute circuits
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.algorithms import Grover
aer_simulator = Aer.get_backend('aer_simulator')
grover = Grover(quantum_instance=aer_simulator)
result = grover.amplify(problem)
print('Using QuantumCircuit as oracle')
print('Result type:', type(result))
print('Success!' if result.oracle_evaluation else 'Failure')
print(f'Top measurement: {result.top_measurement}')
### Using different types of classes as oracle for Grover's algorithm
# using statevector as oracle
from qiskit.quantum_info import Statevector
oracle = Statevector.from_label('11')
problem = AmplificationProblem(oracle, is_good_state=['11'])
grover = Grover(quantum_instance=aer_simulator)
result = grover.amplify(problem)
print('\nUsing Statevector as oracle')
print('Result type:', type(result))
print('Success!' if result.oracle_evaluation else 'Failure')
print(f'Top measurement: {result.top_measurement}')
problem.grover_operator.oracle.draw(output='mpl').show()
# using phase oracle
from qiskit.circuit.library.phase_oracle import PhaseOracle
from qiskit.exceptions import MissingOptionalLibraryError
# `Oracle` (`PhaseOracle`) as the `oracle` argument
expression = '(a & b)'
try:
oracle = PhaseOracle(expression)
problem = AmplificationProblem(oracle)
problem.grover_operator.oracle.draw(output='mpl').show()
except MissingOptionalLibraryError as ex:
print(ex)
### Amplitude Amplification
# specifying `state preparation` to prepare a superposition of |01>, |10>, and |11>
import numpy as np
oracle = QuantumCircuit(3)
oracle.h(2)
oracle.ccx(0,1,2)
oracle.h(2)
theta = 2 * np.arccos(1 / np.sqrt(3))
state_preparation = QuantumCircuit(3)
state_preparation.ry(theta, 0)
state_preparation.ch(0,1)
state_preparation.x(1)
state_preparation.h(2)
# we only care about the first two bits beign in state 1, thus add both possiblities for the last qubit
problem = AmplificationProblem(oracle, state_preparation=state_preparation,
is_good_state=['110','111'])
# state preperation
print('Printing state preperation circuit')
problem.grover_operator.state_preparation.draw(output='mpl').show()
# run circuit
grover = Grover(quantum_instance=aer_simulator)
result = grover.amplify(problem)
print('Success!' if result.oracle_evaluation else 'Failure :(')
print(f'Top measurement: {result.top_measurement}')
### Full Flexibility
# set good state as |111> but with 5 qubits
from qiskit.circuit.library import GroverOperator, ZGate
oracle = QuantumCircuit(5)
oracle.append(ZGate().control(2), [0,1,2])
oracle.draw(output='mpl').show()
# Grover operator implements zero reflection on all 5 qubits, as default
grover_op = GroverOperator(oracle, insert_barriers=True)
grover_op.draw(output='mpl').show()
# since we only need to consider first 3 qubits, set that as parameter to GroverOperator
grover_op = GroverOperator(oracle, reflection_qubits=[0,1,2], insert_barriers=True)
grover_op.draw(output='mpl').show()
### Specify good_state in different ways
# list of binary strings good state
oracle = QuantumCircuit(2)
oracle.cz(0,1)
good_state = ['11', '00']
problem = AmplificationProblem(oracle, is_good_state=good_state)
print('Binary strings good state')
print(f'State 11 is a good state: {problem.is_good_state("11")}')
# list of integers good state
oracle = QuantumCircuit(2)
oracle.cz(0,1)
good_state = [0, 1]
problem = AmplificationProblem(oracle, is_good_state=good_state)
print('Integer good state')
print(f'State 11 is a good state: {problem.is_good_state("11")}')
# `Statevector` good state
from qiskit.quantum_info import Statevector
oracle = QuantumCircuit(2)
oracle.cz(0,1)
good_state = Statevector.from_label('11')
problem = AmplificationProblem(oracle, is_good_state=good_state)
print('Statevector good state')
print(f'State 11 is a good state: {problem.is_good_state("11")}')
# Callable good state
def callable_good_state(bitstr):
if bitstr == '11':
return True
return False
oracle = QuantumCircuit(2)
oracle.cz(0,1)
problem = AmplificationProblem(oracle, is_good_state=callable_good_state)
print('Callable good state')
print(f'State 11 is a good state: {problem.is_good_state("11")}')
### Change number of iterations
# integer iteration
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
problem = AmplificationProblem(oracle, is_good_state=['11'])
grover = Grover(iterations=1)
# list iteration
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
problem = AmplificationProblem(oracle, is_good_state=['11'])
grover = Grover(iterations=[1,2,3])
# using sample_from_iterations
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
problem = AmplificationProblem(oracle, is_good_state=['11'])
grover = Grover(iterations=[1,2,3], sample_from_iterations=True)
# use optimal_num_iterations when number of solutions is known
iterations = Grover.optimal_num_iterations(num_solutions=1, num_qubits=8)
print(f'Optimal number of iterations: {iterations}')
### Apply post processing
# convert bit-representation of measurement to DIMACS CNF format
def to_DIMACS_CNF_format(bit_rep):
return [index+1 if val==1 else -1 * (index+1) for index, val in enumerate(bit_rep)]
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
problem = AmplificationProblem(oracle, is_good_state=['11'],
post_processing = to_DIMACS_CNF_format)
print("DIMACS CNF format: ", problem.post_processing([1, 0, 1]))
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
# Create VQE Optimizer circuit to find minimum eigenvalue
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
num_qubits = 2
ansatz = TwoLocal(num_qubits, 'ry', 'cz')
opt = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=opt)
ansatz.draw('mpl').show()
# Run algorithm on backend
from qiskit import Aer
backend = Aer.get_backend('aer_simulator_statevector')
from qiskit.utils import QuantumInstance
backend = Aer.get_backend('aer_simulator')
quantum_instance = QuantumInstance(backend=backend, shots=800, seed_simulator=99)
# vqe = VQE(ansatz, optimizer=opt, quantum_instance=quantum_instance)
# operator = #TODO: Figure out what operator is
# min_eigen = vqe.compute_minimum_eigenvalue(operator)
# print(min_eigen)
# Complete working example - create operator
from qiskit.opflow import X, Z, I
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
# run VQE and print result object it returns
from qiskit.utils import algorithm_globals
seed = 50
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
### Using VQE Setting QuantumInstance after Construciton
# Create VQE instance without quantum instance
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp)
vqe.quantum_instance = qi
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, assemble, Aer
from qiskit.tools.visualization import plot_histogram
from math import pi
import matplotlib.pyplot as plt
### Conditioned gates: the c_if method
# example: execute X gate if value of classical register is 0
q = QuantumRegister(1,'q')
c = ClassicalRegister(1,'c')
qc = QuantumCircuit(q,c)
qc.h(0)
qc.measure(0,0)
qc.x(0).c_if(c, 0)
qc.draw('mpl')#.show()
# example: perform bit flip on third qubit when measurement of q0 and q1 are both 1
q = QuantumRegister(3,'q')
c = ClassicalRegister(3,'c')
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.h(q[1])
qc.h(q[2])
qc.barrier()
qc.measure(q,c)
qc.x(2).c_if(c, 3) # for the 011 case
qc.x(2).c_if(c, 7) # for the 111 case
qc.draw('mpl')#.show()
### Iterative Phase Estimation (IPE)
nq = 2
m = 2
q = QuantumRegister(nq, 'q')
c = ClassicalRegister(m, 'c')
qc_S = QuantumCircuit(q,c)
## First iteration
# initialization
qc_S.h(0)
qc_S.x(1)
qc_S.draw('mpl')#.show()
# apply controlled-U gates
cu_circ = QuantumCircuit(2)
cu_circ.cp(pi/2,0,1)
cu_circ.draw('mpl')#.show()
for _ in range(2**(m-1)):
qc_S.cp(pi/2,0,1)
qc_S.draw('mpl')#.show()
# measure in X-basis
def x_measurement(qc, qubit, cbit):
"""Measures 'qubit' in the X-basis, and stores the result in 'cbit'"""
qc.h(qubit)
qc.measure(qubit, cbit)
x_measurement(qc_S, q[0], c[0])
qc_S.draw('mpl')#.show()
## Subsequent iterations
# initialization with reset
qc_S.reset(0)
qc_S.h(0)
qc_S.draw('mpl')#.show()
# phase correction
qc_S.p(-pi/2,0).c_if(c,1)
qc_S.draw('mpl')#.show()
# apply control-U gates and x measurement
for _ in range(2**(m-2)):
qc_S.cp(pi/2,0,1)
x_measurement(qc_S, q[0], c[1])
qc_S.draw('mpl')#.show()
## Execute circuit on simulator
sim = Aer.get_backend('qasm_simulator')
count0 = execute(qc_S, sim).result().get_counts()
key_new = [str(int(key,2)/2**m) for key in list(count0.keys())]
count1 = dict(zip(key_new, count0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(count0, ax=ax[0])
plot_histogram(count1, ax=ax[1])
plt.tight_layout()
plt.show()
### IPE example with a 2-qubit gate
# initialize circuit with 3 qubits
nq = 3 # number of qubits
m = 3 # number of classical bits
q = QuantumRegister(nq, 'q')
c = ClassicalRegister(m, 'c')
qc = QuantumCircuit(q,c)
## First Step
# initialization
qc.h(0)
qc.x([1,2])
qc.draw('mpl')#.show()
# apply controlled-U gates
cu_circ = QuantumCircuit(nq)
cu_circ.mcp(pi/4,[0,1], 2)
cu_circ.draw('mpl')#.show()
# apply 2^t times MCP(pi/4)
for _ in range(2**(m-1)):
qc.mcp(pi/4,[0,1],2)
qc.draw('mpl')#.show()
# measure in x basis
x_measurement(qc, q[0], c[0])
qc.draw('mpl')#.show()
## Second Step
# initialization with reset
qc.reset(0)
qc.h(0)
qc.draw('mpl')#.show()
# phase correction
qc.p(-pi/2,0).c_if(c,1)
qc.draw('mpl')#.show()
# apply Control-U gates and measure in x basis
for _ in range(2**(m-2)):
qc.mcp(pi/4, [0,1], 2)
x_measurement(qc, q[0], c[1])
qc.draw('mpl')#.show()
## Third Step
# initialization
qc.reset(0)
qc.h(0)
# phase correction
qc.p(-pi/4,0).c_if(c,1)
qc.p(-pi/2,0).c_if(c,2)
qc.p(-3*pi/4,0).c_if(c,3)
# controlled-U operations
for _ in range(2**(m-3)):
qc.mcp(pi/4,[0,1],2)
# X measurement
qc.h(0)
qc.measure(0,2)
qc.draw('mpl').show()
# execute circuit on simulator
count0 = execute(qc, sim).result().get_counts()
key_new = [str(int(key,2)/2**m) for key in list(count0.keys())]
count1 = dict(zip(key_new, count0.values()))
fig, ax = plt.subplots(1,2)
plot_histogram(count0, ax=ax[0])
plot_histogram(count1, ax=ax[1])
plt.tight_layout()
plt.show()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
import pylab
from qiskit import Aer
from qiskit.opflow import X, Z, I
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SLSQP
from qiskit.circuit.library import TwoLocal
# Create qubit operator of H2 molecule
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
# Show callback usage over set of optimizers
optimizers = [COBYLA(maxiter=80), L_BFGS_B(maxiter=60), SLSQP(maxiter=60)]
converge_cnts = np.empty([len(optimizers)], dtype=object)
converge_vals = np.empty([len(optimizers)], dtype=object)
for i, optimizer in enumerate(optimizers):
print('\rOptimizer: {} '.format(type(optimizer).__name__), end='')
algorithm_globals.random_seed = 50
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
vqe = VQE(ansatz,
optimizer,
callback=store_intermediate_result,
quantum_instance= QuantumInstance(
backend=Aer.get_backend('statevector_simulator')
))
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
converge_cnts[i] = np.asarray(counts)
converge_vals[i] = np.asarray(values)
print('\rOptimization complete ')
# plot energy value at each objective funciton call each optimizer makes
pylab.rcParams['figure.figsize'] = (12,8)
for i, optimizer in enumerate(optimizers):
pylab.plot(converge_cnts[i], converge_vals[i], label=type(optimizer).__name__)
pylab.xlabel('Eval count')
pylab.ylabel('Energy')
pylab.title('Energy convergence for variaous optimizers')
pylab.legend(loc='upper right')
pylab.show()
# Run classical algorithm to obtain reference solution
npme = NumPyMinimumEigensolver()
result = npme.compute_minimum_eigenvalue(operator=H2_op)
ref_value = result.eigenvalue.real
print(f'Reference value: {ref_value:.5f}')
# Plot difference from reference solution to optimizations
pylab.rcParams['figure.figsize'] = (12,8)
for i, optimizer in enumerate(optimizers):
pylab.plot(converge_cnts[i], abs(ref_value - converge_vals[i]), label=type(optimizer).__name__)
pylab.xlabel('Eval count')
pylab.ylabel('Energy difference from solution reference value')
pylab.title('Energy convergence for various optimizers')
pylab.yscale('log')
pylab.legend(loc='upper right')
pylab.show()
### Using Gradient framework
from qiskit.opflow.gradients import Gradient
algorithm_globals.random_seed = 50
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
optimizer = SLSQP(maxiter=60)
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
vqe = VQE(ansatz,
optimizer,
callback=store_intermediate_result,
gradient=Gradient(grad_method='fin_diff'),
quantum_instance=QuantumInstance(
backend=Aer.get_backend('statevector_simulator')
))
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f'Value using Gradient: {result.eigenvalue.real:.5f}')
pylab.rcParams['figure.figsize'] = (12,8)
pylab.plot(counts, values, label=type(optimizer).__name__)
pylab.xlabel('Eval count')
pylab.ylabel('Energy')
pylab.title('Energy convergence using Gradient')
pylab.legend(loc='upper right')
pylab.show()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
#------------------------------------------------------------------------------
# Qaoa.py
#
# Implementation of the Quantum Approximate Optimization Algorithm (QAOA) [1],[2]
# specifically tailored for solving the MaxCut problem on graphs [3].
# This class facilitates the creation of QAOA circuits with
# various types of mixer operators and allows execution on a quantum simulator
# backend provided by Qiskit.
#
# The `Qaoa` class provides methods to:
# - Initialize with QAOA parameters, graph instance, mixer type, and backend settings
# - Create cost operator and various mixer operators (x, xx, y, yy, xy)
# - Generate the complete QAOA circuit
#
# Initialization parameters include the number of QAOA layers, angles for the
# mixer and cost operators, and options for setting verbosity, measurement, and
# random seed. The class checks for consistency in the provided parameters and
# supports visualizing the graph and QAOA circuit.
#
# Refs.
# [1] https://arxiv.org/abs/1411.4028
# [2] https://learning.quantum.ibm.com/tutorial/quantum-approximate-optimization-algorithm
# [3] https://en.wikipedia.org/wiki/Maximum_cut
#
# © Leonardo Lavagna 2024
# @ NESYA https://github.com/NesyaLab
#------------------------------------------------------------------------------
import numpy as np
from matplotlib import pyplot as plt
from classes import Problems as P
from functions import qaoa_utilities as utils
from qiskit import QuantumCircuit
from qiskit_aer import Aer
from typing import List, Tuple
from networkx import Graph
from qiskit.circuit import ParameterVector
class Qaoa:
def __init__(self, p: int = 0, G: Graph = None, betas: List[float] = None, gammas: List[float] = None,
mixer: str = "x", backend = Aer.get_backend('qasm_simulator'), measure: bool = True,
seed: int = None, verbose: bool = True):
"""Initialize class QAOA.
Args:
p (int): Positive number of QAOA layers. The default is 0.
G (Graph): A graph created with the Problem class used as MaxCut problem instance. The default is None.
betas (float): Angles for the mixer operator.
gammas (float): Angles for the cost operator.
mixer (str): Type of mixer operator to be used. The default is "x".
backend (Qiskit backend): Qiskit backend to execute the code on a quantum simulator.
The default is Aer.get_backend('qasm_simulator').
measure (bool): If True measure the qaoa circuit. The default is True.
seed (int): Seed for a pseudo-random number generator. The default is None.
verbose (bool): If True enters in debugging mode. The default is True.
"""
# Setup
self.p = p
self.G = G
self.mixer = mixer
self.backend = backend
self.measure = measure
self.verbose = verbose
self.seed = seed
self.problems_class = P.Problems(p_type="custom", G=self.G)
if self.seed is not None:
np.random.seed(self.seed)
if self.G is None:
self.N = 0
self.w = [[]]
self.betas = []
self.gammas = []
if self.G is not None:
self.N = G.get_number_of_nodes()
self.w = G.get_adjacency_matrix()
if betas is None or gammas is None:
self.betas = utils.generate_parameters(n=self.p, k=1)
self.gammas = utils.generate_parameters(n=self.p, k=2)
if betas is not None and gammas is not None:
self.betas = betas
self.gammas = gammas
# Checking...
if self.problems_class.__class__.__name__ != self.G.__class__.__name__ and G is not None:
raise Exception("Invalid parameters. The graph G should be created with the Problems class.")
if (self.p == 0 and self.G is not None) or (self.p > 0 and G is None):
raise ValueError("If G is not the empty graph p should be a strictly positive integer, and viceversa.")
if len(self.betas) != p or len(self.gammas) != p or len(self.betas) != len(self.gammas):
raise ValueError("Invalid angles list. The length of betas and gammas should be equal to p.")
# Initializing...
if self.verbose is True:
print(" --------------------------- ")
print("| Intializing Qaoa class... |".upper())
print(" --------------------------- ")
print("-> Getting problem instance...".upper())
if self.G is not None:
self.G.get_draw()
plt.show()
if self.G is None:
print("\t * G = ø")
if self.betas is None and self.G is not None:
print("-> Beta angles not provided. Generating angles...".upper())
print(f"\t * betas = {self.betas}")
if self.gammas is None and self.G is not None:
print("-> Gamma angles not provided. Generating angles...".upper())
print(f"\t * gammas = {self.gammas}")
print("-> Getting the ansatz...".upper())
if self.G is not None:
print(self.get_circuit())
if self.G is None:
print("\t * Qaoa circuit = ø")
print("-> The Qaoa class was initialized with the following parameters.".upper())
print(f"\t * Number of layers: p = {self.p};")
if self.G is None:
print(f"\t * Graph: G = ø;")
if self.G is not None:
print(f"\t * Graph: G = {self.G.p_type};")
print("\t * Angles:")
print(f"\t\t - betas = {self.betas};")
print(f"\t\t - gammas = {self.gammas};")
print(f"\t * Mixer Hamiltonian type: '{self.mixer}';")
print(f"\t * Random seed: seed = {self.seed};")
print(f"\t * Measurement setting: measure = {self.measure}.")
def cost_operator(self, gamma: float) -> QuantumCircuit:
"""Create an instance of the cost operator with angle 'gamma'.
Args:
gamma (float): Angle for the cost operator.
Returns:
QuantumCircuit: Circuit representing the cost operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i,j in self.G.get_edges():
qc.cx(i, j)
qc.rz(gamma, j)
qc.cx(i, j)
return qc
def x_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the x-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for v in self.G.get_nodes():
qc.rx(beta, v)
return qc
def xx_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the xx-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.rxx(beta, i, j)
return qc
def y_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the y-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for v in self.G.get_nodes():
qc.ry(2 * beta, v)
return qc
def yy_mixer_operator(self, beta: float) -> QuantumCircuit:
"""Create an instance of the yy-mixer operator with angle 'beta'.
Args:
beta (float): Time-slice angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.ryy(beta / 2, i, j)
return qc
def xy_mixer_operator(self, phi: float, psi: float) -> QuantumCircuit:
"""Create an instance of the xy-mixer operator with angle 'beta'.
Args:
beta (float): Angle for the mixer operator.
Returns:
QuantumCircuit: Circuit representing the mixer operator.
"""
qc = QuantumCircuit(self.N, self.N)
# X_iX_j
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.rxx(phi / 2, i, j)
# Y_iY_j
for i, j in self.G.get_edges():
if self.w[i, j] > 0:
qc.ryy(psi / 2, i, j)
return qc
def get_circuit(self) -> QuantumCircuit:
"""Create an instance of the Qaoa circuit with given parameters.
Returns:
QuantumCircuit: Circuit representing the Qaoa.
"""
qc = QuantumCircuit(self.N, self.N)
params = ParameterVector("params", 2 * self.p)
betas = params[0 : self.p]
gammas = params[self.p : 2 * self.p]
qc.h(range(self.N))
qc.barrier(range(self.N))
for i in range(self.p):
qc = qc.compose(self.cost_operator(gammas[i]))
qc.barrier(range(self.N))
if self.mixer == "x":
qc = qc.compose(self.x_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "xx":
qc = qc.compose(self.xx_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "y":
qc = qc.compose(self.y_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "yy":
qc = qc.compose(self.yy_mixer_operator(betas[i]))
qc.barrier(range(self.N))
elif self.mixer == "xy":
qc = qc.compose(self.xy_mixer_operator(betas[i],betas[i]))
qc.barrier(range(self.N))
qc.barrier(range(self.N))
if self.measure:
qc.measure(range(self.N), range(self.N))
return qc
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import math
import numpy as np
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.algorithms import Shor
N = 15
backend = Aer.get_backend('aer_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
shor = Shor(quantum_instance=quantum_instance)
result = shor.factor(N)
print(f"The list of factors of {N} as computed by Shor's algorithm is {result.factors[0]}.")
print(f"Copmuted of qubits for circuit: {4 * math.ceil(math.log(N,2)) + 2}")
print(f"Actual number of qubits of circuit: {shor.construct_circuit(N).num_qubits}")
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import matplotlib as plt
import numpy as np
from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
from math import gcd
from numpy.random import randint
import pandas as pd
from fractions import Fraction
print("Imports Successful")
### Problem: Period Finding
# Builds circuit for operator U such that U|y> = |ay mod 15>
def c_amod15(a, power):
"""Controlled multiplication by a mod 15"""
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11, or 13")
U = QuantumCircuit(4)
for iteration in range(power):
if a in [2,13]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
if a in [7,8]:
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
if a == 11:
U.swap(1,3)
U.swap(0,2)
if a in [7,11,13]:
for q in range(4):
U.x(q)
U = U.to_gate()
U.name = "%i^%i mod 15" % (a, power)
c_U = U.control()
return c_U
# Specify variables
n_count = 8 # number of counting qubits
a = 7
# Import QFT circuit
def qft_dagger(n):
"""n-qubit QFTdagger the first n qubits in circuit"""
qc = QuantumCircuit(n)
# Don't forget the swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
qc.name = "QFTdagger"
return qc
# Create QuantumCircuit with n_count counting qubits plus 4 qubits for U to act on
qc = QuantumCircuit(n_count + 4, n_count)
# Initialize counting qubits in state |+>
for q in range(n_count):
qc.h(q)
# Add auxiliary register in state |1>
qc.x(3+n_count)
# Do controlled-U operations
for q in range(n_count):
qc.append(c_amod15(a, 2**q), [q] + [i+n_count for i in range(4)])
# Do inverse-QFT
qc.append(qft_dagger(n_count), range(n_count))
# Measure circuit
qc.measure(range(n_count), range(n_count))
qc.draw(output='mpl', fold=-1).show() # -1 means do not fold
# Show histogram results
aer_sim = Aer.get_backend('aer_simulator')
t_qc = transpile(qc, aer_sim)
qobj = assemble(t_qc)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts).show()
# Show text results
rows, measured_phases = [], []
for output in counts:
decimal = int(output, 2) # convert (base 2) string to decimal
phase = decimal/(2**n_count) # find corresponding eigenvalue
measured_phases.append(phase)
rows.append(
[f"{output}(bin) = {decimal:>3}(dec)",
f"{decimal}/{2**n_count} = {phase:.2f}"]
)# add these valeus to the rows in our table
headers=["Register Output", "Phase"]
df = pd.DataFrame(rows, columns=headers)
print(df)
# Find s and r using continuded fractions algorithm
rows = []
for phase in measured_phases:
frac = Fraction(phase).limit_denominator(15)
rows.append([phase, f"{frac.numerator}/{frac.denominator}", frac.denominator])
headers = ["Phase", "Fraction", "Guess for r"]
df = pd.DataFrame(rows, columns= headers)
print(df)
### Modular Exponentiation
# Use repeated squaring to calcualte exponential a^(2^j) mod N
def a2jmodN(a, j, N):
"""Compute a^(2^j) (mod N) by repeated squaring"""
for i in range(j):
a = np.mod(a**2, N)
return a
print(a2jmodN(7,2049, 53))
### Factoring and Period Finding
# Assume N is the product of two primes
N = 15
np.random.seed(1)
a = randint(2,15)
print("a=",a)
# Check a isn't already a non-trivial factor of N
from math import gcd
assert gcd(a,N) == 1
# Apply Shor's order finding algorithm for N=15
def qpe_amod15(a):
n_count = 8
qc = QuantumCircuit(4+n_count, n_count)
for q in range(n_count):
qc.h(q) # initialize counting qubits in state |+>
qc.x(3+n_count) # set auxiliary register in state |1>
for q in range(n_count): # do controlled-U operations
qc.append(c_amod15(a, 2**q),
[q] + [i+n_count for i in range(4)])
qc.append(qft_dagger(n_count), range(n_count)) # Do inverse-QFT
qc.measure(range(n_count), range(n_count))
# Simulate results
aer_sim = Aer.get_backend('aer_simulator')
t_qc = transpile(qc, aer_sim)
obj = assemble(t_qc, shots=1)
result = aer_sim.run(qobj, memory=True).result() # setting memory=True allows us to see list of each sequential reading
readings = result.get_memory()
print("Register Reading: ", readings[0])
phase = int(readings[0],2)/(2**n_count)
print("Corresponding Phase: %f" % phase)
return phase
# Find guess for r given phase
phase = qpe_amod15(a) # Phase = s/r
Fraction(phase).limit_denominator(15) # Denominator should tell us r
# Get fraction
frac = Fraction(phase).limit_denominator(15)
s, r = frac.numerator, frac.denominator
print(r)
# use r to guess factors of N
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
print("guesses:", guesses)
# repeat guess algorithm until at least one factor of 15 is found
a = 7
factor_found = False
attempt = 0
while not factor_found:
attempt += 1
print("\nAttempt %i:" % attempt)
phase = qpe_amod15(a) # Phase = s/r
frac = Fraction(phase).limit_denominator(N) # Denominator should tell us r
r = frac.denominator
print("Result: r = %i" % r)
if phase != 0:
# Guesses for factors are gcd(x^(r/2) +/- 1 , 15)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
print("Guessed Factors: %i and %i" % (guesses[0], guesses[1]))
for guess in guesses:
if guess not in [1,N] and (N % guess) == 0: # check to see if guess is factor
print("*** Non-trivial factor found: %i ***" % guess)
factor_found = True
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
import pylab
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit.library import TwoLocal
from qiskit.opflow import I, X, Z
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
print(f'Number of qubits: {H2_op.num_qubits}')
# Compute reference using classical method
npme = NumPyMinimumEigensolver()
result = npme.compute_minimum_eigenvalue(operator=H2_op)
ref_value = result.eigenvalue.real
print(f'Reference value: {ref_value:.5f}')
### Performance Without Noise
seed = 170
iterations = 125
algorithm_globals.random_seed = seed
backend = Aer.get_backend('aer_simulator')
qi = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed)
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
spsa = SPSA(maxiter=iterations)
vqe = VQE(ansatz, optimizer=spsa, callback=store_intermediate_result, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"VQE on Aer qasm simulator (no noise): {result.eigenvalue.real:.5f}")
print(f"Delta from reference energy value is: {(result.eigenvalue.real-ref_value):.5f}")
# Plot energy values
pylab.rcParams['figure.figsize'] = (12, 4)
pylab.plot(counts,values)
pylab.xlabel('Eval count')
pylab.ylabel('Energy')
pylab.title('Convergence without noise')
pylab.show()
### Performance With Noise
import os
from qiskit.providers.aer import QasmSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit.test.mock import FakeVigo
device_backend = FakeVigo()
backend = Aer.get_backend('aer_simulator')
counts1 = []
values1 = []
noise_model = None
device = QasmSimulator.from_backend(device_backend)
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
basis_gate = noise_model.basis_gates
print(noise_model)
print()
algorithm_globals.random_seed = seed
qi = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed,
coupling_map=coupling_map, noise_model=noise_model)
def store_intermediate_result1(eval_count, parameters, mean, std):
counts1.append(eval_count)
values1.append(mean)
var_form = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
spsa = SPSA(maxiter=iterations)
vqe = VQE(ansatz, optimizer=spsa, callback=store_intermediate_result1, quantum_instance=qi)
result1 = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"VQE on Aer qasm simulator (with noise): {result1.eigenvalue.real:.5f}")
print(f"Delta from reference energy value is: {(result1.eigenvalue.real-ref_value):.5f}")
# Plot energy values
if counts1 or values1:
pylab.rcParams['figure.figsize'] = (12, 4)
pylab.plot(counts1,values1)
pylab.xlabel('Eval count')
pylab.ylabel('Energy')
pylab.title('Convergence with noise')
pylab.show()
### Performance With Noise And Measurement Error Mitigation
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
counts2 = []
values2 = []
if noise_model is not None:
algorithm_globals.random_seed = seed
qi = QuantumInstance(backend=backend, seed_simulator=seed, seed_transpiler=seed,
coupling_map=coupling_map, noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
cals_matrix_refresh_period=30)
def store_intermediate_result2(eval_count, parameters, mean, std):
counts2.append(eval_count)
values2.append(mean)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
spsa = SPSA(maxiter=iterations)
vqe = VQE(ansatz, optimizer=spsa, callback=store_intermediate_result2, quantum_instance=qi)
result2 = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"VQE on Aer qasm simulator (with noise and measurement error mitigation): {result2.eigenvalue.real:.5f}")
print(f"Delta from reference energy value is: {(result2.eigenvalue.real - ref_value):.5f}")
# Plot energy values
if counts2 or values2:
pylab.rcParams['figure.figsize'] = (12, 4)
pylab.plot(counts2,values2)
pylab.xlabel('Eval count')
pylab.ylabel('Energy')
pylab.title('Convergence with noise and measurement error mitigation')
pylab.show()
# Summary
print('--------- Summary ---------')
print(f'Reference value: {ref_value:.5f}')
print(f"VQE on Aer qasm simulator (no noise): {result.eigenvalue.real:.5f}")
print(f"VQE on Aer qasm simulator (with noise): {result1.eigenvalue.real:.5f}")
print(f"VQE on Aer qasm simulator (with noise and measurement error mitigation): {result2.eigenvalue.real:.5f}")
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
### Pauli Operators
from qiskit.opflow import I, X, Y, Z # Pauli operators
print(I,X,Y,Z)
print(1.5*I) # can carry a coefficient
print(2.5*X)
print(X+2.0*Y) # can be used in a sum
print(X ^ Y ^ Z) # tensor products use ^
print(X @ Y @ Z) # composition uses @
# complicated objects
print((X + Y) ^ (Y + Z)) # composing two sums
print((X + Y) ^ (Y + Z)) # tensoring two sums
print(I, X)
print(2.0 * X^Y^Z)
print(1.1 * ((1.2 * X)^(Y + (1.3 * Z))))
### Part 1: State Functions and Measurements
from qiskit.opflow import (StateFn, Zero, One, Plus, Minus, H, DictStateFn,
VectorStateFn, CircuitStateFn, OperatorStateFn)
print(Zero, One) # states |0> and |1>, respectively
print(Plus, Minus) # states |+> = 1/sqrt(2)*(|0> + |1>) and |-> = 1/sqrt(2)*(|0> - |1>), respectively
# the eval method returns the coefficients of hte 0 and 1 basis states
print(Zero.eval('0'))
print(Zero.eval('1'))
print(One.eval('1'))
print(Plus.eval('0'))
print(Minus.eval('1'))
# the adjoint method gives the dual vector of the quantum state (the bra of the ket, or vice versa)
print(One.adjoint())
print(~One)
## Algebraic operations and predicates
print((2.0 + 3.0j) * Zero) # construct (2 + 3i)|0>
print(Zero + One) # adding two DictStateFn returns an object of the same type
# you must normalize states by hand
import math
v_zero_one = (Zero + One) / math.sqrt(2)
print(v_zero_one)
# symbolic representation of a sum
print(Plus + Minus)
# composition operator used to perform an inner product
print(~One @ One)
# symbolic expressions may be evaluated with the eval method
print((~One @ One).eval())
print((~v_zero_one @ v_zero_one).eval())
print((~Minus @ One).eval())
# the composition operator @ is equivalent to calling the compose method
print((~One).compose(One))
assert (~One).compose(One) == ~One @ One
# inner products may also be computed using the eval method directly
print((~One).eval(One))
# symbolic tensor products are constructed as follows
print(Zero ^ Plus) # |0> + |+>
print((Zero ^ Plus).to_circuit_op()) # represented as a simple CircuitStateFn
# tensor powers can be constructed using the ^ operator
print(600 * ((One ^ 5) + (Zero ^ 5))) # 600(|11111> + |00000>)
print((One ^ Zero) ^ 3) #|10>^3
# the method to_matrix_op converts to VectorStateFn
print(((Plus^Minus)^2).to_matrix_op())
print(((Plus^One)^2).to_matrix_op())
print(((Plus^Minus)^2).to_matrix_op().sample())
# StateFn class serves as a factory and can take any applicable primitive in its constructor
print(StateFn({'0':1}))
print(StateFn({'0':1}) == Zero)
print(StateFn([0,1,1,0]))
from qiskit.circuit.library import RealAmplitudes
print(StateFn(RealAmplitudes(2)))
### Part 2: PrimitiveOp's
# the basic operators are sublclasses of PrimitiveOp
# like StateFn, PrimitiveOp is a factory and can take any applicable primitive in its constructor
from qiskit.opflow import X, Y, Z, I, CX, T, H, S, PrimitiveOp
## Matrix elements
print(X)
print(X.eval('0'))
print(X.eval('0').eval('1'))
print(CX)
print(CX.to_matrix().real) # remove imaginary part
print(CX.eval('01'))
print(CX.eval('01').eval('11'))
## Applying an operator to a state vector
print(X @ One) # X|1> = |0>
print((X @ One).eval())
print(X.eval(One))
# composition and tensor products of operators are effected with @ and ^
print(((~One^2) @ (CX.eval('01'))).eval())
print(((H^5) @ ((CX^2)^I) @ (I^CX^2))**2)
print((((H^5) @ ((CX^2)^I) @ (I^CX^2))**2) @ (Minus^5))
print(((H^I^I)@(X^I^I)@Zero))
print(~One @ Minus)
### Part 3: ListOp and subclasses
# ListOp is a container for effectivley vectorizing operations over a list of operators and states
from qiskit.opflow import ListOp
print((~ListOp([One, Zero]) @ ListOp([One, Zero])))
# distribute over lists using simplification method reduce
print((~ListOp([One, Zero]) @ ListOp([One, Zero])).reduce())
## OperatorStateFn
# construct observable corresponding to Pauli Z operator
print(StateFn(Z).adjoint())
StateFn(Z).adjoint()
# compute <0|Z|0>, <1|Z|1>, and <+|Z|+>
print(StateFn(Z).adjoint().eval(Zero))
print(StateFn(Z).adjoint().eval(One))
print(StateFn(Z).adjoint().eval(Plus))
### Part 4: Converters
# converters manipulate operators and states and perform building blocks of algorithms
import numpy as np
from qiskit.opflow import (I, X, Y, Z, H, CX, Zero, ListOp, PauliExpectation,
PauliTrotterEvolution, CircuitSampler, MatrixEvolution, Suzuki)
from qiskit.circuit import Parameter
from qiskit import Aer
## Evolutions, exp_i(), and the EvolvedOP
# express hamiltonian as linear combination of multi-qubit Pauli operators
two_qubit_H2 = (-1.0523732 * I^I) + \
(0.39793742 * I^Z) + \
(-0.3979374 * Z^I) + \
(-0.0112801 * Z^Z) + \
(0.18093119 * X^X)
print(two_qubit_H2)
# multiply hamiltonian by a Parameter
evo_time = Parameter('θ')
evolution_op = (evo_time*two_qubit_H2).exp_i()
print(evolution_op) # Note: EvolvedOPs print as exponentiations
print(repr(evolution_op))
# construct observable for Hamiltonian
h2_measurement = StateFn(two_qubit_H2).adjoint()
print(h2_measurement)
# construct bell state via CX(H tensor I)|00>
bell = CX @ (I ^ H) @ Zero
print(bell)
# evolve bell state
evo_and_meas = h2_measurement @ evolution_op @ bell
print(evo_and_meas)
# approximate exponentiation with two-qubit gates using PauliTrotterEvolution
trotterized_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=2, reps=1)).convert(evo_and_meas)
print(trotterized_op)
# bind_parameters method traverses expression, binding values ot parameter names
bound = trotterized_op.bind_parameters({evo_time: .5})
bound[1].to_circuit().draw('mpl').show()
## Exppectations
# expectations are converters that enable the computation of expectation values and observables
# AerPauliExpectation converts an observable into a CircuitStateFn containin a special expectation snapshot
# which Aer can execute nativley with high performance
print(PauliExpectation(group_paulis=False).convert(h2_measurement))
# by default, group_paulis=True which uses the AbelianGrouper to convert the SummedOp into groups
# of mutually-qubit wise commuting Paulis, reducing circuit execution overhead
print(PauliExpectation().convert(h2_measurement))
# converters act recursivley, so we can convert our full evolution and measurement expression
diagonalized_meas_op = PauliExpectation().convert(trotterized_op)
print(diagonalized_meas_op)
evo_time_points = list(range(8))
h2_trotter_expectations = diagonalized_meas_op.bind_parameters({evo_time:evo_time_points})
print(h2_trotter_expectations.eval())
## Executing CircuitStateFn with the CircuitSampler
# CircuitSampler traverses an Operator and converts any CircuitStateFn into approximations of the
# resulting state function by a DictStateFn or VectorStateFn using a quantum backend.
sampler= CircuitSampler(backend=Aer.get_backend('aer_simulator'))
# sampler.quantum_instance.run_config.shots = 1000
sampled_trotter_exp_op = sampler.convert(h2_trotter_expectations)
sampled_trotter_energies = sampled_trotter_exp_op.eval()
print('Sampled Trotterized energies:\n{}'.format(np.real(sampled_trotter_energies)))
# note: circuits are replaced by dicts with square roots of the circuit sampling probablilities
print('Before:\n')
print(h2_trotter_expectations.reduce()[0][0])
print('After:\n')
print(sampled_trotter_exp_op.reduce()[0][0])
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
from qiskit.opflow import Z, X, I, StateFn, CircuitStateFn, SummedOp
from qiskit.opflow.gradients import Gradient, NaturalGradient, QFI, Hessian
from qiskit.circuit import (QuantumCircuit, QuantumRegister, Parameter,
ParameterVector, ParameterExpression)
from qiskit.circuit.library import EfficientSU2
### First Order Gradients
## Gradients with respect to Measurement Operator Parameters
# instantiate the quantum state
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# instantiate Hamiltonian observable
H = (2 * X) + Z
# combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# print the operator corresponding to the expectation value
print(op)
params = [a, b]
# define the values to be asigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi}
# convert the operator and the gradient target params into the respective operators
grad = Gradient().convert(operator= op, params= params)
# print the operator corresponding to the gradient
print(grad)
# assign the parameters and evaluate the gradient
grad_result = grad.assign_parameters(value_dict).eval()
print("Gradient", grad_result)
## Gradients with respect to State Parameters
# define the Hamiltonian with fixed coefficients
H = 0.5 * X - 1 * Z
# define the parameters w.r.t we want to compute the gradients
params = [a,b]
# define the values to be assigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi}
# combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# print the operator corresponding to the expectation value
print(op)
## Parameter Shift Gradients
# convert the expectation value into an operator corrsponding to the gradient w.r.t
# the state parameters using the parameter shift method
state_grad = Gradient(grad_method='param_shift').convert(operator=op, params=params)
# print the operator corresponding to the gradient
print(state_grad)
# assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with parameter shift', state_grad_result)
## Linear Combination of Unitaries Gradients
# convert the expectation value into an operator corresponding to the gradient w.r.t
# the state parameter using a linear combination of unitaries method
state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=params)
# print the operator corresponding to the gradient
print(state_grad)
# assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with the linear combination method', state_grad_result)
## Finite Difference Gradients
# while the previous methods were analytical, this is a numerical approximation method
# convert the expectation value into an operator corresponding to the gradient w.r.t
# the state parameter using the finite difference method
state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=params)
# print the operator corresponding to the gradient
print(state_grad)
# assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with the linear combination method', state_grad_result)
## Natural Gradients
# besides the method to compute the circuit gradients resp. QFI, a regularization method
# can be chosen: 'ridge' or 'lasso' with automatic parameter search or 'perturb_diag'
# or 'perturb_diag_elements', which perturb the diagonal elements of the QFI
nat_grad = NaturalGradient(grad_method='lin_comb', qfi_method='lin_comb_full',
regularization='ridge').convert(operator=op, params=params)
# assign the parameters and evaluate the gradient
nat_grad_result = nat_grad.assign_parameters(value_dict).eval()
print('Natural gradient computed with the linear combination of unitaries', nat_grad_result)
### Hessians (Second Order Gradients)
## Hessians w.r.t Measurement Operator Parameters
# instantiate the Hamiltonian observable
H = X
# instantiate the quantum state with two parameters
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# convert the operator and the Hessian target coefficients into the respective operator
hessian = Hessian().convert(operator=op, params=[a,b])
# define the values to be assigned to the parameters
value_dict = {a: np.pi/4, b: np.pi/4}
# assign the parameters and evaluate the Hessian w.r.t the Hamiltonian coefficients
hessian_result = hessian.assign_parameters(value_dict).eval()
print('Hessian \n', np.real(np.array(hessian_result)))
## Hessians w.r.t. State Parameters
# define parameters
params = [a, b]
# get the operator object representing the Hessian
state_hess = Hessian(hess_method='param_shift').convert(operator=op, params=params)
# assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print("Hessian computed using the parameter shift method\n", (np.array(hessian_result)))
# get the operator object representing the Hessian
state_hess = Hessian(hess_method='lin_comb').convert(operator=op, params=params)
# assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print("Hessian computed using the linear combination of unitaries method\n",
(np.array(hessian_result)))
# get the operator object representing the Hessian using finite difference
state_hess = Hessian(hess_method='fin_diff').convert(operator=op, params=params)
# assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print("Hessian computed using the finite difference method\n",
(np.array(hessian_result)))
### Quantum Fisher Information (QFI)
## Linear Combination Full QFI
# wrap the quantum circuit into a CircuitStateFn
state = CircuitStateFn(primitive=qc, coeff=1.)
# convert the state and the parameters into the operator object that represents the QFI
qfi = QFI(qfi_method='lin_comb_full').convert(operator=state, params=params)
# define the values for which the QFI is to be computed
values_dict = {a: np.pi/4, b: 0.1}
# assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('full QFI \n', np.real(np.array(qfi_result)))
## Block-diagonal and Diagonal Approximation
# convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'block_diagonal'
qfi = QFI(qfi_method='overlap_block_diag').convert(operator=state, params=params)
# assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Block-diagonal QFI \n', np.real(np.array(qfi_result)))
# convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'diagonal'
qfi = QFI(qfi_method='overlap_diag').convert(operator=state, params=params)
# assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Diagonal QFI \n', np.real(np.array(qfi_result)))
### Application Example: VQE with Gradient-Based Optimization
# execution imports
from qiskit import Aer
from qiskit.utils import QuantumInstance
# algorithm imports
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import CG
from qiskit.opflow import I, X , Z
from qiskit.circuit import QuantumCircuit, ParameterVector
from scipy.optimize import minimize
# initiate the system Hamiltonian
h2_hamiltonian = -1.05 * (I ^ I) + 0.39 * (I ^ Z) - 0.39 * (Z ^ I) - 0.01 * (Z ^ Z) + \
0.18 * (X ^ X)
# this is the target energy
h2_energy = -1.85727503
# define the Ansatz
wavefunction = QuantumCircuit(2)
params = ParameterVector('theta', length=8)
it = iter(params)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
wavefunction.cx(0, 1)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
# define the expectation value corresponding to the energy
op = ~StateFn(h2_hamiltonian) @ StateFn(wavefunction)
# choose wheither VQE should use Gradient or NaturalGradient
grad = Gradient(grad_method='lin_comb')
qi_sv = QuantumInstance(Aer.get_backend('aer_simulator_statevector'),
shots=1,
seed_simulator=2,
seed_transpiler=2)
# configure Gradient algorithm
optimizer = CG(maxiter=50)
# Gradient callable
vqe = VQE(wavefunction, optimizer=optimizer, gradient=grad, quantum_instance=qi_sv)
result = vqe.compute_minimum_eigenvalue(h2_hamiltonian)
print("Result:", result.optimal_value, 'Reference:', h2_energy)
# define QuantumInstance to execute quantum circuits and run algorithm
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import transpile, QuantumCircuit
import qiskit.quantum_info as qi
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.noise import NoiseModel, amplitude_damping_error
from qiskit.tools.visualization import plot_histogram
## Creating Matrix Operators
# CNOT matrix operator with qubit-0 as control and qubit-1 as target
cx_op = qi.Operator([
[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]
])
# iSWAP matrix operator
iswap_op = qi.Operator([
[1,0,0,0],
[0,0,1j,0],
[0,1j,0,0],
[0,0,0,1]
])
## Using Operators in Circuits
# CNOT in terms of iSWAP and single-qubit gates
cx_circ = QuantumCircuit(2, name='cx<iSWAP>')
cx_circ.sdg(1)
cx_circ.h(1)
cx_circ.sdg(0)
cx_circ.unitary(iswap_op, [0,1], label='iswap')
cx_circ.sdg(0)
cx_circ.h(0)
cx_circ.sdg(0)
cx_circ.unitary(iswap_op, [0,1], label='iswap')
cx_circ.s(1)
print(cx_circ)
# Simulate the unitary for the circuit using Operator:
unitary = qi.Operator(cx_circ)
print(unitary)
f_avg = qi.average_gate_fidelity(cx_op, unitary)
print("Average gate fidelity: F = {:f}".format(f_avg))
### Creating a Custom Unitary in a Noise Model
print('unitary' in AerSimulator().configuration().basis_gates)
# error parameters
param_q0 = 0.05 # damping parameter for qubit-0
param_q1 = 0.1 # damping parameter for qubit-1
# construct the error
qerror_q0 = amplitude_damping_error(param_q0)
qerror_q1 = amplitude_damping_error(param_q1)
iswap_error = qerror_q1.tensor(qerror_q0)
# Build the noise model by adding the error to the iSWAP gate
noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(iswap_error,'iswap')
noise_model.add_basis_gates(['unitary'])
print(noise_model.basis_gates)
## Simulating a Custom Unitary Noise Model
# Bell state circuit where iSWAPS should be placed at barrier locations
bell_circ = QuantumCircuit(2,2,name='bell')
bell_circ.h(0)
bell_circ.append(cx_circ,[0,1])
bell_circ.measure([0,1],[0,1])
print(bell_circ)
# create ideal simulator backend and transpile circuit
sim_ideal = AerSimulator()
tbell_circ = transpile(bell_circ,sim_ideal)
ideal_result = sim_ideal.run(tbell_circ).result()
ideal_counts = ideal_result.get_counts(0)
plot_histogram(ideal_counts, title='Ideal output for iSWAP bell-state preparation').show()
## Noisy Circuit Execution
# create noisy simulator and transpile circuit
sim_noise = AerSimulator(noise_model=noise_model)
tbell_circ_noise = transpile(bell_circ,sim_noise)
# run on the simulator with noise
noise_result = sim_noise.run(tbell_circ_noise).result()
noise_counts = noise_result.get_counts(0)
plot_histogram(noise_counts, title='Noisy output for iSWAP bell-state preparation').show()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import IBMQ, transpile
from qiskit import QuantumCircuit
from qiskit.providers.aer import AerSimulator
from qiskit.tools.visualization import plot_histogram
## Terra Mock Backends
from qiskit.test.mock import FakeVigo
device_backend = FakeVigo()
# Build test circuit
circ = QuantumCircuit(3,3)
circ.h(0)
circ.cx(0,1)
circ.cx(1,2)
circ.measure([0,1,2], [0,1,2])
sim_ideal = AerSimulator()
# Execute circuit and get counts
result = sim_ideal.run(transpile(circ,sim_ideal)).result()
counts = result.get_counts(0)
plot_histogram(counts, title="Ideal counts for 3-qubit GHZ state").show()
## Generate Simulator that Mimics Real Device
sim_vigo = AerSimulator.from_backend(device_backend)
# Run noisy simulation
tcirc = transpile(circ, sim_vigo)
result_noise = sim_vigo.run(tcirc).result()
counts_noise = result_noise.get_counts()
plot_histogram(counts_noise, title="Counts for 3-qubit GHZ state with noisy model").show()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
### Using the Matrix Product State Simulation Method
import numpy as np
# import qiskit
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import AerSimulator
# construct quantum circuit
circ = QuantumCircuit(2,2)
circ.h(0)
circ.cx(0,1)
circ.measure([0,1],[0,1])
# select the AerSimulator from the Aer provider
simulator = AerSimulator(method='matrix_product_state')
# run and get counts
tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
counts = result.get_counts(0)
print(counts)
# construct quantum circuit
circ = QuantumCircuit(2,2)
circ.h(0)
circ.cx(0,1)
# define a snapshot that shows the current state vector
circ.save_statevector(label='my_sv')
circ.save_matrix_product_state(label='my_mps')
circ.measure([0,1],[0,1])
# execute and get saved data
tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
data = result.data(0)
print(data)
### Testing Large EPR State Circuit
num_qubits_arr = [50, 100, 500]
for num_qubits in num_qubits_arr:
circ = QuantumCircuit(num_qubits, num_qubits)
# create EPR state
circ.h(0)
for i in range(0,num_qubits-1):
circ.cx(i,i+1)
# measure
circ.measure(range(num_qubits), range(num_qubits))
tcirc = transpile(circ, simulator)
result = simulator.run(tcirc).result()
print("\nFor {} qubits:".format(num_qubits))
print("\tTime taken: {}s".format(result.time_taken))
print("\tCounts: ", counts)
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import numpy as np
from pprint import pprint
# import Qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_state_city
import qiskit.quantum_info as qi
# show all possible backends
pprint(Aer.backends())
# use AerSimulator backend
sumulator = Aer.get_backend('aer_simulator')
## Simulating a quantum circuit
# create circuit consisting of a 2-qubit bell state |phi> = 1/2*(|00> + |11>)
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0,1)
circ.measure_all()
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
circ = transpile(circ,simulator)
# run simulation and get counts
result = simulator.run(circ).result()
counts = result.get_counts(circ)
plot_histogram(counts, title="Bell-State counts").show()
# save measurment outcomes
result = simulator.run(circ, shots=10, memory=True).result()
memory = result.get_memory(circ)
print(memory)
### Aer Simulation Options
## Simulation Method
# increase shots to reduce sampling variance
shots = 1000
# Stabilizer simulation method
sim_stabilizer = Aer.get_backend('aer_simulator_stabilizer')
job_stabilizer = sim_stabilizer.run(circ, shots=shots)
counts_stabilizer = job_stabilizer.result().get_counts(0)
# Statevector simulation method
sim_statevector = Aer.get_backend('aer_simulator_statevector')
job_statevector = sim_statevector.run(circ, shots=shots)
counts_statevector = job_statevector.result().get_counts(0)
# Density Matrix simulation method
sim_density = Aer.get_backend('aer_simulator_density_matrix')
job_density = sim_density.run(circ, shots=shots)
counts_density = job_density.result().get_counts(0)
# Matrix Product State simulation method
sim_mps = Aer.get_backend('aer_simulator_matrix_product_state')
job_mps = sim_mps.run(circ, shots=shots)
counts_mps = job_mps.result().get_counts(0)
# plot results
plot_histogram([counts_stabilizer,
counts_statevector,
counts_density,
counts_mps],
title="Counts for different simulation methods",
legend=['stabilizer', 'statevector', 'density_matrix',
'matrix_product_state']).show()
## GPU Simulation
from qiskit.providers.aer import AerError
# initialize a GPU backend - note that if the target machine does not have a GPU,
# this will raise an exception.
try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU')
except AerError as e:
print(e)
# the Aer provider will also contain preconfigured GPU simulator backends if Qiskit Aer was
# installed with GPU support on a compatible system:
# - aer_simulator_statevector_gpu
# - aer_simulator_density_matrix_gpu
# - aer_simulator_unitary_gpu
# Note: the GPU version of Aer can be installed using `pip install qiskit-aer-gpu`
## Simulation Precision
# configure a single-precision statevector simulator backend
simulator = Aer.get_backend('aer_simulator_statevector')
simulator.set_options(precision='single')
# run simulation and get counts
result = simulator.run(circ).result()
counts = result.get_counts(circ)
print(counts)
### Custom Simulator Instructions
## Saving the Simulator State
# see https://qiskit.org/documentation/tutorials/simulators/1_aer_provider.html#Saving-the-simulator-state
## Saving the Final Statevector
# construct quantum circuit wihtout measure
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc.save_statevector()
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
qc = transpile(qc,simulator)
# run simulation and get statevector
result = simulator.run(qc).result()
statevector = result.get_statevector(qc)
plot_state_city(statevector, title='Bell state').show()
## Saving the Circuit Unitary
# construct quantum circuit without measure
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc.save_unitary()
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
qc = transpile(qc, simulator)
# run simulation and get unitary
result = simulator.run(qc).result()
unitary = result.get_unitary(qc)
print("Circuit unitary:\n", unitary.round(5))
## Saving Multiple States
# construct quantum circuit without measure
steps = 5
qc = QuantumCircuit(1)
for i in range(steps):
qc.save_statevector(label=f'psi_{i}')
qc.rx(i * np.pi / steps, 0)
qc.save_statevector(label=f'psi_{steps}')
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
qc = transpile(qc, simulator)
# run simulation and get saved data
result = simulator.run(qc).result()
data = result.data(0)
pprint(data)
### Setting the Simulator to a Custom State
# see https://qiskit.org/documentation/tutorials/simulators/1_aer_provider.html#Setting-the-simulator-to-a-custom-state
## Setting a Custom Statevector
# generate a random statevector
num_qubits = 2
psi = qi.random_statevector(2 ** num_qubits, seed =100)
# set initial state to generated statevector
circ = QuantumCircuit(num_qubits)
circ.set_statevector(psi)
circ.save_state()
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
circ = transpile(circ, simulator)
# run simulation and get saved data
result = simulator.run(circ).result()
pprint(result.data(0))
## Use Initialize Instruction
# use intialize instruction to set initial state
circ = QuantumCircuit(num_qubits)
circ.initialize(psi, range(num_qubits))
circ.save_state()
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
circ = transpile(circ, simulator)
# run simulation and get results
result = simulator.run(circ).result()
pprint(result.data(0))
## Set Custom Density Matrix
num_qubits = 2
rho = qi.random_density_matrix(2 ** num_qubits, seed = 100)
circ = QuantumCircuit(num_qubits)
circ.set_density_matrix(rho)
circ.save_state()
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
circ = transpile(circ, simulator)
# run simulation and get saved data
result = simulator.run(circ).result()
pprint(result.data(0))
## Set Custom Unitary
# generates a random unitary
num_qubits = 2
unitary = qi.random_unitary(2** num_qubits, seed =100)
# set initial state to unitary
circ = QuantumCircuit(num_qubits)
circ.set_unitary(unitary)
circ.save_state()
# transpile for simulator
simulator = Aer.get_backend('aer_simulator')
circ = transpile(circ, simulator)
# run simulation and get saved data
result = simulator.run(circ).result()
pprint(result.data(0))
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
from qiskit import QuantumCircuit, transpile
from qiskit.providers.aer import AerSimulator
from qiskit.tools.visualization import plot_histogram
import random
circ = QuantumCircuit(40,40)
# initialize with a Hadamard layer
circ.h(range(40))
# apply some random CNOT and T gates
qubit_indicies = [i for i in range(40)]
for i in range(10):
control, target, t = random.sample(qubit_indicies,3)
circ.cx(control,target)
circ.t(t)
circ.measure(range(40), range(40))
# create statevector simulator
statevector_simulator = AerSimulator(method='statevector')
# transpile circuit for backend
tcirc = transpile(circ, statevector_simulator)
# try and run circuit
statevector_result = statevector_simulator.run(tcirc, shots=1).result()
print('This succeeded?: {}'.format(statevector_result.success))
print('Why not?: {}'.format(statevector_result.status))
# create an extended stablilizer method simulator
extended_stabilizer_simulator = AerSimulator(method='extended_stabilizer')
# transpile circuit for backend
tcirc = transpile(circ, extended_stabilizer_simulator)
# run circuit and get results
extended_stabilizer_result = extended_stabilizer_simulator.run(tcirc, shots=1).result()
print('This succeeded?: {}'.format(extended_stabilizer_result.success))
### Extended Stabilizer Only Gives Approximate Results
small_circ = QuantumCircuit(2,2)
small_circ.h(0)
small_circ.cx(0,1)
small_circ.t(0)
small_circ.measure([0,1],[0,1])
# the circuit should give 00 and 11 with equal probability
expected_results = {'00': 50, '11':50}
tsmall_circuit = transpile(small_circ, extended_stabilizer_simulator)
result = extended_stabilizer_simulator.run(
tsmall_circuit, shots=100).result()
counts = result.get_counts(0)
print('100 shots in {}s'.format(result.time_taken))
plot_histogram([expected_results, counts], legend=["Expected", "Extened Stabilizer"]).show()
## Add Runtime Options for Extended Stabilizer Simulator
opts = {"extended_stabilizer_approximation_error":0.03}
reduced_error_result = extended_stabilizer_simulator.run(
tsmall_circuit, shots=100, **opts).result()
reduced_error_counts = reduced_error_result.get_counts(0)
print('100 shots in {}s'.format(reduced_error_result.time_taken))
plot_histogram([expected_results, reduced_error_counts],
legend=["Expected", "Extened Stabilizer"]).show()
## Simulator Options
# if you expect your output will be concentrated on a few states, you can optimize the
# simulations by reducing the extended_stabilizer_simulator_mixing_time option
print("The circuit above, with 100 shots and precision 0.03 "
"and default mixing time, needed {}s".format(int(reduced_error_result.time_taken)))
opts = {"extended_stabilizer_approximation_error": 0.03,
"extended_stabilizer_simulator_mixing_time": 100}
optimized_result = extended_stabilizer_simulator.run(
tsmall_circuit, shots=100, **opts).result()
print('Dialing down the mixing time, the circuit completed in just {}s'.format(
optimized_result.time_taken))
# if your circuit has non-zero probability on all amplitudes (e.g. it is a random circuit),
# then you can avoid this expensive re-mixing step to take multiple shots from the output
# at once.
opts = {"extended_stabilizer_simulator_mixing_time": 100}
multishot = extended_stabilizer_simulator.run(
tcirc, shots=100, **opts).result()
print("100 shots took {}s".format(multishot.time_taken))
opts = {
'extended_stabilizer_measure_sampling': True,
'extended_stabilizer_mixing_time': 100
}
measure_sampling = extended_stabilizer_simulator.run(
tcirc, shots=100, **opts).result()
print("With the optimization, 100 shots took {}s".format(measure_sampling.time_taken))
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
import sys
# !conda install --yes --prefix {sys.prefix} numpy
# !conda install --yes --prefix {sys.prefix} qiskit
# !conda install --yes --prefix {sys.prefix} matplotlib
# !{sys.executable} -m pip install pyppeteer
import numpy as np
from qiskit import *
from matplotlib import pyplot
from math import pi
thetas = [i*pi/10 for i in range(0,11)]
shots = 100
import matplotlib.pyplot as plt
import numpy as np
def plot_results(counts_arr):
zeros_count = [count[0] for count in counts_arr] #+ [sum([count[0] for count in counts_arr])/len(counts_arr)]
ones_count = [count[1] for count in counts_arr] #+ [sum([count[1] for count in counts_arr])/len(counts_arr)]
ones_pct = [count/shots for count in ones_count]
fig, ax = plt.subplots()
labels = [f'{i}/10*pi' for i in range(len(thetas))] #+ ['Average']
x = np.arange(len(labels))
width=0.35
# c1 = ax.bar(x - width/2, zeros_count, width, label='Output = 0')
c2 = ax.bar(x + width/2, ones_pct, width, label='Output = 1')
ax.set_ylabel('Output 1 Average')
ax.set_xlabel('Theta')
ax.set_title('Output 1 Averages vs. Theta')
ax.set_xticks(x)
ax.set_xticklabels(labels)
ax.legend()
# ax.bar_label(c1, padding=3)
ax.bar_label(c2, padding=3)
fig.set_size_inches(12, 9)
plt.show()
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Build circuit
qc = QuantumCircuit(1,1)
qc.h(0)
qc.rz(theta,0)
qc.h(0)
qc.measure(0,0)
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots*100:.1f}%')
plot_results(counts_arr)
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Build circuit
qc = QuantumCircuit(1,1)
qc.h(0)
qc.rz(theta/2,0)
qc.x(0)
qc.rz(theta/2,0)
qc.x(0)
qc.h(0)
qc.measure(0,0)
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
deltas = [0.1, 0.2]
for delta in deltas:
counts_arr = [ [] for i in range(len(thetas)) ]
print(f"\n-----\nDelta: {delta}")
for i, theta in enumerate(thetas):
# Build circuit
qc = QuantumCircuit(1,1)
qc.h(0)
qc.rz(theta/2+delta,0)
qc.x(0)
qc.rz(theta/2-delta,0)
qc.x(0)
qc.h(0)
qc.measure(0,0)
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
from qiskit.quantum_info import Operator
from qiskit.extensions import HamiltonianGate
from qiskit.opflow import I, X, Y, Z
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Define operator in exponent
op = X + Y + Z
# Define coefficient in exponent
c = (theta/4)/2*((1/3)**(1/2))
# Create HamiltonianGate, which is defined as exp(-i*op*c)
V_gate = HamiltonianGate(op, c)
# Define circuit
qc = QuantumCircuit(1,1)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.x(0)
qc.measure(0,0)
# Draw circuit once
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
counts_arr = [ [] for i in range(len(thetas)) ]
for i, theta in enumerate(thetas):
# Define operator in exponent
op = X + Y + Z
# Define coefficient in exponent
c = (theta/4)/2*((1/3)**(1/2))
# Create HamiltonianGate, which is defined as exp(-i*op*c)
V_gate = HamiltonianGate(op, c)
# Define circuit
qc = QuantumCircuit(1,1)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.y(0)
qc.append(V_gate, [0])
qc.x(0)
qc.append(V_gate, [0])
qc.y(0)
qc.measure(0,0)
# Draw circuit once
if i==0:
qc.draw('mpl')
pyplot.show()
# Simulate circuit using Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
job_sim = backend_sim.run(transpile(qc, backend_sim), shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qc)
# collect counts of simulation output
counts_arr[i].append( counts['0'] if '0' in counts else 0 )
counts_arr[i].append( counts['1'] if '1' in counts else 0 )
print(f'theta={i}/10*pi\tcounts: {counts}\tavg: {counts_arr[i][1]/shots:.2f}%')
plot_results(counts_arr)
|
https://github.com/iamr0b0tx/qiskit_practice
|
iamr0b0tx
|
import numpy as np
# import qiskit libs
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute
from qiskit.tools.jupyter import *
API_KEY = 'c6f6569ab6b6f9ec1a437d4d1187b7c7ea2ac4bd91679613e204e7bb9728efd9639af14a86f840cbb05e60b6a249e532e3168c7dbff07edc4c37de9c4bb3e0b3'
try:
provider = IBMQ.enable_account(API_KEY)
except Exception as e:
print(e)
# qiskit plot tool
from qiskit.visualization import plot_histogram
def dj_oracle(case, n, draw=False):
oracle_qc = QuantumCircuit(n+1)
if case == "balanced":
for qubit in range(n):
oracle_qc.cx(qubit, n)
if case == "constant":
output = np.random.randint(2)
if output == 1:
oracle_qc.x(n)
if draw:
print(oracle_qc.draw())
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "Oracle"
return oracle_gate
dj_oracle("balanced", 4, True)
dj_oracle("constant", 4, True)
dj_oracle("constant", 4, True)
def dj_algorithm(n, case="random"):
dj_circuit = QuantumCircuit(n+1, n)
for qubit in range(n):
dj_circuit.h(qubit)
dj_circuit.x(n)
dj_circuit.h(n)
if case=="random":
random_case = np.random.randint(2)
if random_case == 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()
# using local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
dj_circuit = dj_algorithm(n, 'constant')
results = execute(dj_circuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/iamr0b0tx/qiskit_practice
|
iamr0b0tx
|
import numpy as np
# import qiskit libs
from qiskit import IBMQ, QuantumCircuit, Aer, execute
from qiskit.quantum_info import Operator
from qiskit.providers.ibmq import least_busy
from qiskit.tools.jupyter import *
API_KEY = 'c6f6569ab6b6f9ec1a437d4d1187b7c7ea2ac4bd91679613e204e7bb9728efd9639af14a86f840cbb05e60b6a249e532e3168c7dbff07edc4c37de9c4bb3e0b3'
try:
provider = IBMQ.enable_account(API_KEY)
except Exception as e:
print(e)
# qiskit plot tool
from qiskit.visualization import plot_histogram
def phase_oracle(n, indices_to_mark, name="Oracle"):
qc = QuantumCircuit(n, name=name)
oracle_matrix = np.identity(2**n)
for index_to_mark in indices_to_mark:
oracle_matrix[index_to_mark, index_to_mark] = -1
qc.unitary(Operator(oracle_matrix), range(n))
return qc
def diffuser(n):
qc = QuantumCircuit(n, name="Diffuser (V)")
qc.h(range(n))
qc.append(phase_oracle(n, [0]), range(n))
qc.h(range(n))
return qc
def grover(n, marked):
qc = QuantumCircuit(n, n)
r = int(np.round(np.pi / (4 * np.arcsin(np.sqrt(len(marked) / 2**n))) - 1/2))
print(f'{n} qubits, basis state {marked} marked, {r} rounds')
qc.h(range(n))
for _ in range(r):
qc.append(phase_oracle(n, marked), range(n))
qc.append(diffuser(n), range(n))
qc.measure(range(n), range(n))
return qc
n = 5
x = np.random.randint(2**n)
marked = [x]
qc = grover(n, marked)
qc.draw()
# using local simulator
backend = Aer.get_backend('qasm_simulator')
results = execute(qc, backend=backend, shots=10_000).result()
counts = results.get_counts(qc)
print(counts)
print(np.pi / (4 * np.arcsin(np.sqrt(len(marked) / 2**n))) - 1/2)
plot_histogram(counts)
x, bin(x)
|
https://github.com/iamr0b0tx/qiskit_practice
|
iamr0b0tx
|
import qiskit
|
https://github.com/EdoardoZappia/Qiskit-Primitive
|
EdoardoZappia
|
#!pip install qiskit
#import qiskit.tools.jupyter
#%qiskit_version_table
#%qiskit_copyright
#pip install qcircuit
#pip install pdflatex
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
import numpy as np
import qiskit.quantum_info as qi
import qiskit
from qiskit import Aer
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.visualization.circuit import *
from qiskit import transpile, assemble
import matplotlib.pyplot as plt
from qiskit.circuit import Parameter
# Supress warnings
import warnings
warnings.filterwarnings("ignore")
# Create a quantum circuit instance with one qubit
circuit = QuantumCircuit(2,0)
# Apply Hadamard Gate
circuit.h(0)
# Draw quantum circuit
circuit.draw(output = "mpl")
# Print all the available quantum simulators
Aer.backends()
# Load statevector simulator
simulator = Aer.get_backend("statevector_simulator")
# Create quatum job to execute
job = simulator.run(circuit)
# Execute the job
result = job.result()
state_ex=result.get_statevector(circuit) #if possible mantains phases as fractions
state = result.get_statevector(circuit, decimals = 4) #using parameter decimals, approximates the fractions
state_ex.draw(output='latex')
state.draw(output='latex')
state.draw(output = "bloch")
#to do statevector simulation more easily
def statevect_sim(circuit: QuantumCircuit):
simulator=Aer.get_backend("statevector_simulator")
state=simulator.run(circuit).result().get_statevector(circuit)
print(state)
return state.draw('latex')
# Apply RX / RY / S /T gates
circuit2=QuantumCircuit(1,0)
circuit2.rx(np.pi/2,0) #rx(theta, n) gate is a single-qubit gate rotation of angle theta around the x-axis of the qubit n
circuit2.draw(output='mpl')
statevect_sim(circuit2)
simulator.run(circuit2).result().get_statevector(circuit2).draw(output = "bloch")
circuit3=QuantumCircuit(1,0)
circuit3.ry(np.pi*3/2,0) #ry(theta, n) gate is a single-qubit gate rotation of angle theta around the y-axis of the qubit n
circuit3.draw(output='mpl')
#create the job
job3=simulator.run(circuit3)
#execute the job
result3=job3.result()
#create the state
state3_ex=result3.get_statevector(circuit3)
state3=result3.get_statevector(circuit3,decimals=4)
state3_ex.draw(output='latex')
state3.draw(output='latex')
#or we can just use
statevect_sim(circuit3)
state3.draw(output='bloch')
circuit4=QuantumCircuit(1,0)
circuit4.rx(np.pi/4,0)
circuit4.s(0) #s(n) gate is a single-qubit gate rotation of angle pi/2 around the z-axis of the qubit n
circuit4.draw(output='mpl')
statevect_sim(circuit4)
simulator.run(circuit4).result().get_statevector(circuit4).draw(output = "bloch")
circuit5=QuantumCircuit(1,0)
circuit5.h(0) #the state is in |+>
circuit5.t(0) #t(n) gate is a single-qubit gate rotation of angle pi/4 around the z-axis of the qubit n
circuit5.draw(output='mpl')
statevect_sim(circuit5)
simulator.run(circuit5).result().get_statevector(circuit5).draw(output = "bloch")
# Create quantum circuit with two quantum registers and two classical registers
circuit_bell = QuantumCircuit(2, 2)
# Create Bell state following the expression above
circuit_bell.h(0)
circuit_bell.cx(0,1)
statevect_sim(circuit_bell)
# Visualize the circuit
circuit_bell.draw(output = 'mpl')
circuit=QuantumCircuit(3)
circuit.x(0)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(1,2)
statevect_sim(circuit)
circuit.draw('mpl')
circuit=QuantumCircuit(2)
circuit.x(0)
circuit.h(0)
circuit.x(1)
circuit.cx(0,1)
circuit.draw('mpl')
circuit.swap(0,1) #qiskit visualization of qubits is reversed
statevect_sim(circuit)
#from qiskit.visualization import plot_state_city, plot_state_hinton, plot_state_qsphere, plot_histogram
state2=simulator.run(circuit2).result().get_statevector(circuit2)
state2.draw(output='latex')
plot_state_city(state2) #Plot two 3d bar graphs (two dimensional) of the real and imaginary part of the density matrix rho
plot_state_hinton(state2)
#seaborn package required
plot_state_qsphere(state2)
state=simulator.run(circuit).result().get_statevector(circuit)
state.draw('latex')
plot_state_city(state)
plot_state_hinton(state)
plot_state_qsphere(state)
state_bell=simulator.run(circuit_bell).result().get_statevector(circuit_bell)
state_bell.draw('latex')
plot_state_city(state_bell)
plot_state_hinton(state_bell)
plot_state_qsphere(state_bell)
# Run the quantum circuit on a unitary simulator backend
backend = Aer.get_backend('unitary_simulator') #Unitary Simulator is a simulator provided by Qiskit that calculates and returns the unitary matrix that represents the Quantum Circuit
# Create job and execute
job = backend.run(circuit_bell)
result = job.result()
# Show the results
print(result.get_unitary(circuit_bell, decimals=3))
# Initialize quantum and classical registers
qr = QuantumRegister(2)
cr = ClassicalRegister(2) #classical registers are needed to store the results of measurements (if we use the command measure(qr,cr))
# Build quantum circuit
circuit_qasm = QuantumCircuit(qr, cr)
#Create Bell state
circuit_qasm.h(0)
circuit_qasm.cx(0,1)
# Measure qubits
circuit_qasm.measure(qr, cr) #circuit_qasm.measure_all() memeasures all qubits, creates a new register to store the measurements and adds a barrier before the measurements
circuit_qasm.draw(output = 'mpl')
backend = Aer.get_backend("qasm_simulator")
shots = 1024 #1024 is the standard number of shots
job = execute(circuit_qasm, backend, shots = shots)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
qr=QuantumRegister(2)
cr=ClassicalRegister(2)
circ_bell=QuantumCircuit(qr,cr)
circ_bell.x(0)
circ_bell.h(0)
circ_bell.cx(0,1)
circ_bell.measure(qr,cr)
circ_bell.draw('mpl')
job_bell=execute(circ_bell,backend,shots=1024)
result_bell=job_bell.result()
counts_bell=result_bell.get_counts()
plot_histogram(counts_bell)
#Import the random circuit class
from qiskit.circuit.random import random_circuit
#Create two random circuits
qc1 = random_circuit(2,2) #2 qubits, 2 layers of gates (in this case one layer: two one-qubit gate or one two-qubits gate)
qc2 = random_circuit(2,4)
#Concatenate the two random circuits
qc = qc1.compose(qc2)
#Draw the circuit
qc.draw('mpl')
#Define function to print circuit properties:
def print_circuit_props(qc):
width = qc.width() #number of gates in the layer with the most gates ("control" operation is counted as a gate (Ex. cx(0,1) width=2, one gate on qubit 0 and one on qubit 1),
#also the idenity (do nothing) in the layer with the most gates is counted as one gate, see the next example)
depth = qc.depth() #number of layers in witch we can partition the circuit
num_operators = qc.count_ops() #gives the list of operations with their number of applications
circuit_size = qc.size() #number of gates of the circuit
print('Width = ',width)
print('Depth = ', depth)
print('Circuit size = ',circuit_size)
print('Number of operators = ', num_operators)
#Pass our quantum circuit to print out the circuit properties
print_circuit_props(qc)
qc = QuantumCircuit(3)
qc.cx(0,1)
print_circuit_props(qc)
qc.draw('mpl')
qc = QuantumCircuit(3)
qc.ccx(0,1,2)
#Print out the circuit properties
print_circuit_props(qc)
qc.draw('mpl')
qc.decompose().draw('mpl')
#Print out the circuit properties
print_circuit_props(qc.decompose())
#Create a custom two-qubit composite gate
#Create the quantum register
qr = QuantumRegister(2, name='qr_c') #name parameter gives a name to qubits
#Generate quantum circuit which will make up the composite gate
comp_qc = QuantumCircuit(qr, name='my-composite') #my-composite is the name of the circuit
#Add any gates you wish to your composite gate
comp_qc.h(0)
comp_qc.cx(0, 1)
#Create the composite instructions by converting the QuantumCircuit to a list of Instructions
composite_inst = comp_qc.to_instruction()
#Draw the circuit which will represent the composite gate
comp_qc.draw('mpl')
#Create another 3-qubit circuit
qr2 = QuantumRegister(3, 'qr')
#Create a quantum circuit using the quantum register
qc = QuantumCircuit(qr2)
#Add any arbitrary gates that would represent the function of the composite gate
qc.h(0)
qc.cx(0,1)
qc.cx(0,2)
#Draw the composite circuit
qc.draw('mpl')
#Append your composite gate to the specified qubits.
qc.append(composite_inst, [qr2[0], qr2[1]])
#Draw the complete circuit
qc.draw('mpl')
qr=QuantumRegister(2,'qr')
circ=QuantumCircuit(qr,name='bell_minus')
circ.x(0)
circ.h(0)
circ.cx(0,1)
bell_minus = circ.to_instruction()
circ.draw('mpl')
qr_new=QuantumRegister(2,'qr_new')
circ1=QuantumCircuit(qr_new)
circ1.append(bell_minus, [qr_new[0], qr_new[1]])
circ1.draw('mpl')
theta = Parameter('θ')
n = 5
qc = QuantumCircuit(5, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(5)) #theta is the angle of rotation range(5) is a way to apply rz to qubits from 0 to 4
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
theta_range = np.linspace(0, 2 * np.pi, 128) #returns a list of 128 values equispaced in[0, 2pi]
circuits = [qc.bind_parameters({theta: theta_val}) for theta_val in theta_range]
#circuits is a list in whitch each element is the qc circuit with the parameter substituted by a value of theta_range
#Ex. circuit[0] = qc with theta=0 circuit[-1] = qc with theta=2pi
circuits[-1].draw('mpl')
from qiskit import BasicAer, transpile
backend = BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(circuits, backend)) #we are running all the circuits contained in circuits list
#transpile(circ,syst) optimizes the circuit for the system
#Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device,
# and/or to optimize the circuit for execution on present day noisy quantum systems.
#Most circuits must undergo a series of transformations that make them compatible with a given target device,
# and optimize them to reduce the effects of noise on the resulting outcomes.
# Rewriting quantum circuits to match hardware constraints and optimizing for performance can be far from trivial.
# The flow of logic in the rewriting tool chain need not be linear, and can often have iterative sub-loops, conditional branches, and other complex behaviors.
#https://docs.quantum.ibm.com/api/qiskit/transpiler
counts = job.result().get_counts()
plot_histogram(counts) #this are the counts of measurement of the first qubit of all the elements of circuits list
job_zero = backend.run(transpile(circuits[0], backend)) #theta = 0
counts_zero = job_zero.result().get_counts()
plot_histogram(counts_zero)
job_20 = backend.run(transpile(circuits[20], backend)) #theta = 0.9894780011306435
counts_20 = job_20.result().get_counts()
plot_histogram(counts_20)
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111) #to create subplot of the figure fig
#The argument (111) is a shorthand for a subplot grid specification. In this case:
#The first digit represents the number of rows in the grid.
#The second digit represents the number of columns in the grid.
#The third digit represents the index of the subplot.
ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')
#lambda c:c.get('0',0), c is the input of the function, c.get('0',0) returns the value associated to the key '0', the other 0 is the default value
#The use of map() and lambda functions is one way to apply a function to each element of an iterable
#so map(lambda c: c.get('0', 0), counts) returns the number of '0' in each element of counts
ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'], fontsize=14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0, 1)
qc.rz(p, 1)
qc.cx(1, 2)
qc.rz(p, 2)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())
print(larger_qc.decompose().draw())
# Will execute the circuit on the state vector (sv) simulator
# Returns state vector results, circuit diagram, and Bloch sphere
from qiskit import Aer, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
def execute_circuit_sv(quantum_circuit):
#Create a state vector simulator
statevector_simulator = Aer.get_backend('statevector_simulator')
#Execute the circuit on the simulator
result = execute(quantum_circuit, statevector_simulator).result()
#Assign state vector results
statevector_results = result.get_statevector(quantum_circuit)
#Draw the circuit diagram
circuit_diagram = quantum_circuit.draw('mpl')
#Draw the Bloch sphere result
q_sphere = plot_state_qsphere(statevector_results)
#Return the results, circuit diagram, and Bloch sphere
return statevector_results, circuit_diagram, q_sphere
#H-gate
#Create the single qubit circuit
qc = QuantumCircuit(1)
#Add an H gate to the qubit
qc.h(0)
#Execute the circuit and capture all the results
result, img, qsphere = execute_circuit_sv(qc)
qsphere
#U3-gate
from math import pi
#Create a single qubit circuit
qc = QuantumCircuit(1)
#Add a U3 gate and rotate all parameters by pi/2, and apply it to the qubit
qc.u(pi/2, pi/2, pi/2, 0) #U3(theta, phi, lambda) executes a rotation of theta around x-axis, of phi around z-axis and pf lambda around y-axis
#Execute the circuit and capture all the results
result, img, qsphere = execute_circuit_sv(qc)
qsphere
import qiskit_ibm_provider
# Save you credential on disc
#IBMProvider.save_account("Your token", overwrite= True)
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider(token=<INSERT_IBM_QUANTUM_TOKEN>)
print(provider.backends())
# We use IBMQ ibm_brisbane
device_backend = provider.get_backend('ibm_brisbane')
# Display device configuration.
config = device_backend.configuration()
print("This backend is called {} (version {}) with {} qubit{}. "
"\nThe basis gates supported on this device are {}."
"".format(config.backend_name,
config.backend_version,
config.n_qubits,
'' if config.n_qubits == 1 else 's',
config.basis_gates))
#from qiskit.visualization import plot_coupling_map
#qubit_coordinates = [[0, 0], [0, 1], [0, 2], [1, 1], [2, 1]]
#plot_coupling_map(config.n_qubits, qubit_coordinates, config.coupling_map)
props = device_backend.properties()
def display_qubit_info(qubit, properties):
"""Print a string describing some of reported properties of the given qubit."""
# Conversion factors from standard SI units
us = 1e6
ns = 1e9
print("Qubit {0} has a \n"
" - T1 time of {1:.2f} microseconds\n"
" - T2 time of {2:.2f} microseconds\n"
" - U2 gate error of {3:.2e}\n"
" - Readout error of {4:.2e} ".format(
qubit,
properties.t1(qubit) * us,
properties.t2(qubit) * us,
properties.gate_error('sx', qubit),
properties.readout_error(qubit)))
display_qubit_info(0, props)
from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from qiskit.transpiler import PassManager
from qiskit.transpiler import CouplingMap, Layout
from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
circuit = QuantumCircuit(7)
circuit.h(3)
circuit.cx(0, 6)
circuit.cx(6, 0)
circuit.cx(0, 1)
circuit.cx(3, 1)
circuit.cx(3, 0)
coupling_map = CouplingMap(couplinglist=coupling)
bs = BasicSwap(coupling_map=coupling_map)
pass_manager = PassManager(bs)
basic_circ = pass_manager.run(circuit)
ls = LookaheadSwap(coupling_map=coupling_map)
pass_manager = PassManager(ls)
lookahead_circ = pass_manager.run(circuit)
ss = StochasticSwap(coupling_map=coupling_map)
pass_manager = PassManager(ss)
stochastic_circ = pass_manager.run(circuit)
circuit.draw(output='mpl')
lookahead_circ.draw(output='mpl')
import math
from qiskit.providers.fake_provider import FakeTokyo
backend = FakeTokyo()
optimized_0 = transpile(circuit, backend=backend, seed_transpiler=11, optimization_level=0)
optimized_0.draw('mpl')
qc = random_circuit(3,2)
qc.measure_all()
# Select a backend to run the circuit
backend = provider.get_backend('ibmq_qasm_simulator')
result = backend.run(transpile(qc, backend), shots=1000).result()
counts = result.get_counts(qc)
print(counts)
# Plot the result
plot_histogram(counts, color='green', title="New Histogram")
## Insert your code here
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram
#INSERT CODE HERE
## CHECK THE RESULT
from qiskit.visualization import plot_bloch_multivector, plot_histogram, array_to_latex
display(array_to_latex(Statevector.from_instruction(qc), prefix="\\text{Statevector} = "))
qc = QuantumCircuit(2,2) # this time, we not only want two qubits, but also two classical bits for the measurement
#INSERT CODE HERE
## WRITE YOUR CODE HERE:
#
#
#
#
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1000).result().get_counts() # we run the simulation and get the counts
counts
## WRITE YOUR CODE/calculation HERE:
#
#
#
#
# inverse circuit
#BONUS VISUALIZATION
gate_colours = {
"displaycolor": {
"x": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
"h": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
"cx": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
"ry": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
},
}
display(qci.draw('mpl',style=gate_colours))
from qiskit import QuantumCircuit
import qiskit.quantum_info as qi
qc_AB = QuantumCircuit(2)
qc_AB.h(0)
qc_AB.cx(0,1)
qc_AB.draw('mpl')
psi_AB = qi.Statevector.from_instruction(qc_AB)
psi_AB.draw('latex', prefix='|\\psi_{AB}\\rangle = ')
rho_AB = qi.DensityMatrix.from_instruction(qc_AB)
rho_AB.draw('latex', prefix='\\rho_{AB} = ')
from qiskit.visualization import plot_state_city
plot_state_city(rho_AB.data, title='Density Matrix')
import numpy as np
rho_p = qi.DensityMatrix.from_label('+')
display(rho_p.draw('latex', prefix='\\rho_p = '))
gamma_p = rho_p.purity()
print("State purity: ", np.round(np.real(gamma_p),3))
rho_m = 1/2*(qi.DensityMatrix.from_label('0') + qi.DensityMatrix.from_label('1'))
display(rho_m.draw('latex', prefix='\\rho_m = '))
gamma_m = rho_m.purity()
print("State purity: ", np.round(np.real(gamma_m),3))
rho_B = qi.partial_trace(rho_AB,[0])
rho_A = qi.partial_trace(rho_AB,[1])
display(rho_B.draw('latex', prefix=" \\rho_{B} = "),
rho_A.draw('latex', prefix=" \\rho_{A} = "))
qc_CD = QuantumCircuit(2)
qc_CD.ry(np.pi/3,0)
qc_CD.h(1)
qc_CD.cx(0,1)
qc_CD.cx(1,0)
qc_CD.draw("mpl", style="iqx")
from qiskit import *
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import partial_trace, entropy
import numpy as np
import math
nQubits = # <--- insert your code here
nClassicBits = 4
circuit.draw(output='mpl')
# Run the quantum circuit on a statevector simulator backend
backend = # <--- insert your code here
outputstate = # <--- insert your code here
print(outputstate)
list_check = [5,7,8,10]
for ind in list_check:
print(outputstate[ind])
def check_vn_entropy(vn_entropy):
if vn_entropy != 0.:
print("The state is a mixed state")
## insert your code here -->
check_vn_entropy(my_entropy)
|
https://github.com/EdoardoZappia/Qiskit-Primitive
|
EdoardoZappia
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
from qiskit.quantum_info import Statevector
import numpy as np
import matplotlib
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
qreg1 = QuantumRegister(2) # The quantum register of the qubits, in this case 2 qubits
register1 = ClassicalRegister(1)
qc = QuantumCircuit(qreg1, register1)
#qc.x(0)
qc.x(1)
qc.barrier()
qc.draw(output='mpl', style=style)
qc.h(0)
qc.h(1)
qc.barrier()
qc.draw(output='mpl', style=style)
qc.cx(0,1)
qc.barrier()
qc.draw(output='mpl', style=style)
qc.h(0)
qc.draw(output='mpl', style=style)
qc.measure(qreg1[0],register1)
qc.draw(output='mpl', style=style)
results = execute(qc, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
def oracleBalance1(qcir):
qcir.cx(0,1)
qcir.barrier()
return qcir
def oracleBalance2(qcir):
qcir.x(1)
qcir.cx(0,1)
qcir.barrier()
return qcir
def oracleConstant1(qcir):
qcir.x(1)
qcir.barrier()
return qcir
def oracleConstant2(qcir):
qcir.barrier()
return qcir
def deutsch(oracle):
Qreg = QuantumRegister(2)
Creg = ClassicalRegister(1)
qcirc = QuantumCircuit(Qreg, Creg)
qcirc.x(1)
qcirc.h(0)
qcirc.h(1)
qcirc.barrier()
qcirc = oracle(qcirc)
qcirc.h(0)
qcirc.barrier()
qcirc.measure(Qreg[0],Creg)
return qcirc
resultBalanced1 = deutsch(oracleBalance1)
resultBalanced1.draw(output='mpl', style=style)
resultsB1 = execute(resultBalanced1, backend=backend, shots=shots).result()
answerB1 = resultsB1.get_counts()
plot_histogram(answerB1)
resultBalanced2 = deutsch(oracleBalance1)
resultBalanced2.draw(output='mpl', style=style)
resultsB2 = execute(resultBalanced2, backend=backend, shots=shots).result()
answerB2 = resultsB2.get_counts()
plot_histogram(answerB2)
resultConstant1 = deutsch(oracleConstant1)
resultConstant1.draw(output='mpl', style=style)
resultsC1= execute(resultConstant1, backend=backend, shots=shots).result()
answerC1 = resultsC1.get_counts()
plot_histogram(answerC1)
resultConstant2 = deutsch(oracleConstant2)
resultConstant2.draw(output='mpl', style=style)
resultsC2= execute(resultConstant2, backend=backend, shots=shots).result()
answerC2 = resultsC2.get_counts()
plot_histogram(answerC2)
|
https://github.com/EdoardoZappia/Qiskit-Primitive
|
EdoardoZappia
|
!pip install qiskit==0.42.0
import qiskit.tools.jupyter
#%qiskit_version_table
#%qiskit_copyright
!pip install pylatexenc
!pip install qcircuit
!pip install pdflatex
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute
import numpy as np
import qiskit.quantum_info as qi
import qiskit
from qiskit import Aer
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.visualization.circuit import *
from qiskit import transpile, assemble
import matplotlib.pyplot as plt
from qiskit.circuit import Parameter
# Supress warnings
import warnings
warnings.filterwarnings("ignore")
# Create a quantum circuit instance with one qubit
circuit = QuantumCircuit(2,0)
# Apply Hadamard Gate
circuit.h(0)
# Draw quantum circuit
circuit.draw(output = "mpl")
# Print all the available quantum simulators
Aer.backends()
# Load statevector simulator
simulator = Aer.get_backend("statevector_simulator")
# Create quatum job to execute
job = simulator.run(circuit)
# Execute the job
result = job.result()
state_ex=result.get_statevector(circuit) #if possible mantains phases as fractions
state = result.get_statevector(circuit, decimals = 4) #using parameter decimals, approximates the fractions
state_ex.draw(output='latex')
state.draw(output='latex')
state.draw(output = "bloch")
#to do statevector simulation more easily
def statevect_sim(circuit: QuantumCircuit):
simulator=Aer.get_backend("statevector_simulator")
state=simulator.run(circuit).result().get_statevector(circuit)
print(state)
return state.draw('latex')
# Apply RX / RY / S / T gates
circuit2=QuantumCircuit(1,0)
circuit2.rx(np.pi/2,0) #rx(theta, n) gate is a single-qubit gate rotation of angle theta around the x-axis of the qubit n
circuit2.draw(output='mpl')
statevect_sim(circuit2)
simulator.run(circuit2).result().get_statevector(circuit2).draw(output = "bloch")
circuit3=QuantumCircuit(1,0)
circuit3.ry(np.pi*3/2,0) #ry(theta, n) gate is a single-qubit gate rotation of angle theta around the y-axis of the qubit n
circuit3.draw(output='mpl')
#create the job
job3=simulator.run(circuit3)
#execute the job
result3=job3.result()
#create the state
state3_ex=result3.get_statevector(circuit3)
state3=result3.get_statevector(circuit3,decimals=4)
state3_ex.draw(output='latex')
state3.draw(output='latex')
#or we can just use
statevect_sim(circuit3)
state3.draw(output='bloch')
circuit4=QuantumCircuit(1,0)
circuit4.rx(np.pi/4,0)
circuit4.s(0) #s(n) gate is a single-qubit gate rotation of angle pi/2 around the z-axis of the qubit n
circuit4.draw(output='mpl')
statevect_sim(circuit4)
simulator.run(circuit4).result().get_statevector(circuit4).draw(output = "bloch")
circuit5=QuantumCircuit(1,0)
circuit5.h(0) #the state is in |+>
circuit5.t(0) #t(n) gate is a single-qubit gate rotation of angle pi/4 around the z-axis of the qubit n
circuit5.draw(output='mpl')
statevect_sim(circuit5)
simulator.run(circuit5).result().get_statevector(circuit5).draw(output = "bloch")
# Create quantum circuit with two quantum registers and two classical registers
circuit_bell = QuantumCircuit(2, 0)
# Create Bell state following the expression above
circuit_bell.h(0)
circuit_bell.cx(0,1)
statevect_sim(circuit_bell)
# Visualize the circuit
circuit_bell.draw(output = 'mpl')
circuit=QuantumCircuit(3)
circuit.x(0)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(1,2)
statevect_sim(circuit)
circuit.draw('mpl')
circuit=QuantumCircuit(2)
circuit.x(0)
circuit.h(0)
circuit.x(1)
circuit.cx(0,1)
circuit.draw('mpl')
circuit.swap(0,1) #qiskit visualization of qubits is reversed
statevect_sim(circuit)
#from qiskit.visualization import plot_state_city, plot_state_hinton, plot_state_qsphere, plot_histogram
state2=simulator.run(circuit2).result().get_statevector(circuit2)
state2.draw(output='latex')
plot_state_city(state2) #Plot two 3d bar graphs (two dimensional) of the real and imaginary part of the density matrix rho
plot_state_hinton(state2)
#seaborn package required
plot_state_qsphere(state2)
state=simulator.run(circuit).result().get_statevector(circuit)
state.draw('latex')
plot_state_city(state)
plot_state_hinton(state)
plot_state_qsphere(state)
state_bell=simulator.run(circuit_bell).result().get_statevector(circuit_bell)
state_bell.draw('latex')
plot_state_city(state_bell)
plot_state_hinton(state_bell)
plot_state_qsphere(state_bell)
# Run the quantum circuit on a unitary simulator backend
backend = Aer.get_backend('unitary_simulator') #Unitary Simulator is a simulator provided by Qiskit that calculates and returns the unitary matrix that represents the Quantum Circuit
# Create job and execute
job = backend.run(circuit_bell)
result = job.result()
# Show the results
print(result.get_unitary(circuit_bell, decimals=3))
# Initialize quantum and classical registers
qr = QuantumRegister(2)
cr = ClassicalRegister(2) #classical registers are needed to store the results of measurements (if we use the command measure(qr,cr))
# Build quantum circuit
circuit_qasm = QuantumCircuit(qr, cr)
#Create Bell state
circuit_qasm.h(0)
circuit_qasm.cx(0,1)
# Measure qubits
circuit_qasm.measure(qr, cr) #circuit_qasm.measure_all() measures all qubits, creates a new register to store the measurements and adds a barrier before the measurements
circuit_qasm.draw(output = 'mpl')
backend = Aer.get_backend("qasm_simulator")
shots = 1024 #1024 is the standard number of shots
job = execute(circuit_qasm, backend, shots = shots)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
qr=QuantumRegister(2)
cr=ClassicalRegister(2)
circ_bell=QuantumCircuit(qr,cr)
circ_bell.x(0)
circ_bell.h(0)
circ_bell.cx(0,1)
circ_bell.measure(qr,cr)
circ_bell.draw('mpl')
job_bell=execute(circ_bell,backend,shots=1024)
result_bell=job_bell.result()
counts_bell=result_bell.get_counts()
plot_histogram(counts_bell)
#Import the random circuit class
from qiskit.circuit.random import random_circuit
#Create two random circuits
qc1 = random_circuit(2,2) #2 qubits, 2 layers of gates (in this case one layer: two one-qubit gate or one two-qubits gate)
qc2 = random_circuit(2,4)
#Concatenate the two random circuits
qc = qc1.compose(qc2)
#Draw the circuit
qc.draw('mpl')
#Define function to print circuit properties:
def print_circuit_props(qc):
width = qc.width() #number of gates in the layer with the most gates ("control" operation is counted as a gate (Ex. cx(0,1) width=2, one gate on qubit 0 and one on qubit 1),
#also the idenity (do nothing) in the layer with the most gates is counted as one gate, see the next example)
depth = qc.depth() #number of layers in witch we can partition the circuit
num_operators = qc.count_ops() #gives the list of operations with their number of applications
circuit_size = qc.size() #number of gates of the circuit
print('Width = ',width)
print('Depth = ', depth)
print('Circuit size = ',circuit_size)
print('Number of operators = ', num_operators)
#Pass our quantum circuit to print out the circuit properties
print_circuit_props(qc)
qc = QuantumCircuit(3)
qc.cx(0,1)
print_circuit_props(qc)
qc.draw('mpl')
qc = QuantumCircuit(3)
qc.ccx(0,1,2)
#Print out the circuit properties
print_circuit_props(qc)
qc.draw('mpl')
qc.decompose().draw('mpl')
#Print out the circuit properties
print_circuit_props(qc.decompose())
#Create a custom two-qubit composite gate
#Create the quantum register
qr = QuantumRegister(2, name='qr_c') #name parameter gives a name to qubits
#Generate quantum circuit which will make up the composite gate
comp_qc = QuantumCircuit(qr, name='my-composite') #my-composite is the name of the circuit
#Add any gates you wish to your composite gate
comp_qc.h(0)
comp_qc.cx(0, 1)
#Create the composite instructions by converting the QuantumCircuit to a list of Instructions
composite_inst = comp_qc.to_instruction()
#Draw the circuit which will represent the composite gate
comp_qc.draw('mpl')
#Create another 3-qubit circuit
qr2 = QuantumRegister(3, 'qr')
#Create a quantum circuit using the quantum register
qc = QuantumCircuit(qr2)
#Add any arbitrary gates that would represent the function of the composite gate
qc.h(0)
qc.cx(0,1)
qc.cx(0,2)
#Draw the composite circuit
qc.draw('mpl')
#Append your composite gate to the specified qubits.
qc.append(composite_inst, [qr2[0], qr2[1]])
#Draw the complete circuit
qc.draw('mpl')
qr=QuantumRegister(2,'qr')
circ=QuantumCircuit(qr,name='bell_minus')
circ.x(0)
circ.h(0)
circ.cx(0,1)
bell_minus = circ.to_instruction()
circ.draw('mpl')
qr_new=QuantumRegister(2,'qr_new')
circ1=QuantumCircuit(qr_new)
circ1.append(bell_minus, [qr_new[0], qr_new[1]])
circ1.draw('mpl')
theta = Parameter('θ')
n = 5
qc = QuantumCircuit(5, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(5)) #theta is the angle of rotation range(5) is a way to apply rz to qubits from 0 to 4
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
theta_range = np.linspace(0, 2 * np.pi, 128) #returns a list of 128 values equispaced in[0, 2pi]
circuits = [qc.bind_parameters({theta: theta_val}) for theta_val in theta_range]
#circuits is a list in which each element is the qc circuit with the parameter substituted by a value of theta_range
#Ex. circuit[0] = qc with theta=0 circuit[-1] = qc with theta=2pi
circuits[-1].draw('mpl')
from qiskit import BasicAer, transpile
backend = BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(circuits, backend)) #we are running all the circuits contained in circuits list
#transpile(circ,syst) optimizes the circuit for the system
#Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device,
# and/or to optimize the circuit for execution on present day noisy quantum systems.
#Most circuits must undergo a series of transformations that make them compatible with a given target device,
# and optimize them to reduce the effects of noise on the resulting outcomes.
# Rewriting quantum circuits to match hardware constraints and optimizing for performance can be far from trivial.
# The flow of logic in the rewriting tool chain need not be linear, and can often have iterative sub-loops, conditional branches, and other complex behaviors.
#https://docs.quantum.ibm.com/api/qiskit/transpiler
counts = job.result().get_counts()
plot_histogram(counts) #this are the counts of measurement of the first qubit of all the elements of circuits list
job_zero = backend.run(transpile(circuits[0], backend)) #theta = 0
counts_zero = job_zero.result().get_counts()
plot_histogram(counts_zero)
job_20 = backend.run(transpile(circuits[20], backend)) #theta = 0.9894780011306435
counts_20 = job_20.result().get_counts()
plot_histogram(counts_20)
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111) #to create subplot of the figure fig
#The argument (111) is a shorthand for a subplot grid specification. In this case:
#The first digit represents the number of rows in the grid.
#The second digit represents the number of columns in the grid.
#The third digit represents the index of the subplot.
ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')
#lambda c:c.get('0',0), c is the input of the function, c.get('0',0) returns the value associated to the key '0', the other 0 is the default value
#The use of map() and lambda functions is one way to apply a function to each element of an iterable
#so map(lambda c: c.get('0', 0), counts) returns the number of '0' in each element of counts
ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'], fontsize=14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0, 1)
qc.rz(p, 1)
qc.cx(1, 2)
qc.rz(p, 2)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())
print(larger_qc.decompose().draw())
# Will execute the circuit on the state vector (sv) simulator
# Returns state vector results, circuit diagram, and Bloch sphere
from qiskit import Aer, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
def execute_circuit_sv(quantum_circuit):
#Create a state vector simulator
statevector_simulator = Aer.get_backend('statevector_simulator')
#Execute the circuit on the simulator
result = execute(quantum_circuit, statevector_simulator).result()
#Assign state vector results
statevector_results = result.get_statevector(quantum_circuit)
#Draw the circuit diagram
circuit_diagram = quantum_circuit.draw('mpl')
#Draw the Bloch sphere result
q_sphere = plot_state_qsphere(statevector_results)
#Return the results, circuit diagram, and Bloch sphere
return statevector_results, circuit_diagram, q_sphere
#H-gate
#Create the single qubit circuit
qc = QuantumCircuit(1)
#Add an H gate to the qubit
qc.h(0)
#Execute the circuit and capture all the results
result, img, qsphere = execute_circuit_sv(qc)
qsphere
#U3-gate
from math import pi
#Create a single qubit circuit
qc = QuantumCircuit(1)
#Add a U3 gate and rotate all parameters by pi/2, and apply it to the qubit
qc.u(pi/2, pi/2, pi/2, 0) #U3(theta, phi, lambda) executes a rotation of theta around x-axis, of phi around z-axis and pf lambda around y-axis
#Execute the circuit and capture all the results
result, img, qsphere = execute_circuit_sv(qc)
qsphere
import qiskit_ibm_provider
# Save you credential on disc
#IBMProvider.save_account("Your token", overwrite= True)
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider(token=<INSERT_IBM_QUANTUM_TOKEN>)
print(provider.backends())
# We use IBMQ ibm_brisbane
device_backend = provider.get_backend('ibm_brisbane')
# Display device configuration.
config = device_backend.configuration()
print("This backend is called {} (version {}) with {} qubit{}. "
"\nThe basis gates supported on this device are {}."
"".format(config.backend_name,
config.backend_version,
config.n_qubits,
'' if config.n_qubits == 1 else 's',
config.basis_gates))
#from qiskit.visualization import plot_coupling_map
#qubit_coordinates = [[0, 0], [0, 1], [0, 2], [1, 1], [2, 1]]
#plot_coupling_map(config.n_qubits, qubit_coordinates, config.coupling_map)
props = device_backend.properties()
def display_qubit_info(qubit, properties):
"""Print a string describing some of reported properties of the given qubit."""
# Conversion factors from standard SI units
us = 1e6
ns = 1e9
print("Qubit {0} has a \n"
" - T1 time of {1:.2f} microseconds\n"
" - T2 time of {2:.2f} microseconds\n"
" - U2 gate error of {3:.2e}\n"
" - Readout error of {4:.2e} ".format(
qubit,
properties.t1(qubit) * us,
properties.t2(qubit) * us,
properties.gate_error('sx', qubit),
properties.readout_error(qubit)))
display_qubit_info(0, props)
from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from qiskit.transpiler import PassManager
from qiskit.transpiler import CouplingMap, Layout
from qiskit.transpiler.passes import BasicSwap, LookaheadSwap, StochasticSwap
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
circuit = QuantumCircuit(7)
circuit.h(3)
circuit.cx(0, 6)
circuit.cx(6, 0)
circuit.cx(0, 1)
circuit.cx(3, 1)
circuit.cx(3, 0)
coupling_map = CouplingMap(couplinglist=coupling)
bs = BasicSwap(coupling_map=coupling_map)
pass_manager = PassManager(bs)
basic_circ = pass_manager.run(circuit)
ls = LookaheadSwap(coupling_map=coupling_map)
pass_manager = PassManager(ls)
lookahead_circ = pass_manager.run(circuit)
ss = StochasticSwap(coupling_map=coupling_map)
pass_manager = PassManager(ss)
stochastic_circ = pass_manager.run(circuit)
circuit.draw(output='mpl')
lookahead_circ.draw(output='mpl')
import math
from qiskit.providers.fake_provider import FakeTokyo
backend = FakeTokyo()
optimized_0 = transpile(circuit, backend=backend, seed_transpiler=11, optimization_level=0)
optimized_0.draw('mpl')
qc = random_circuit(3,2)
qc.measure_all()
# Select a backend to run the circuit
backend = provider.get_backend('ibmq_qasm_simulator')
result = backend.run(transpile(qc, backend), shots=1000).result()
counts = result.get_counts(qc)
print(counts)
# Plot the result
plot_histogram(counts, color='green', title="New Histogram")
## Insert your code here
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram
#INSERT CODE HERE
## CHECK THE RESULT
from qiskit.visualization import plot_bloch_multivector, plot_histogram, array_to_latex
display(array_to_latex(Statevector.from_instruction(qc), prefix="\\text{Statevector} = "))
qc = QuantumCircuit(2,2) # this time, we not only want two qubits, but also two classical bits for the measurement
#INSERT CODE HERE
## WRITE YOUR CODE HERE:
#
#
#
#
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1000).result().get_counts() # we run the simulation and get the counts
counts
## WRITE YOUR CODE/calculation HERE:
#
#
#
#
# inverse circuit
#BONUS VISUALIZATION
gate_colours = {
"displaycolor": {
"x": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
"h": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
"cx": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
"ry": [ # gate name
"#da1e28", # box color (red)
"#FFFFFF" # box text color (white)
],
},
}
display(qci.draw('mpl',style=gate_colours))
from qiskit import QuantumCircuit
import qiskit.quantum_info as qi
qc_AB = QuantumCircuit(2)
qc_AB.h(0)
qc_AB.cx(0,1)
qc_AB.draw('mpl')
psi_AB = qi.Statevector.from_instruction(qc_AB)
psi_AB.draw('latex', prefix='|\\psi_{AB}\\rangle = ')
rho_AB = qi.DensityMatrix.from_instruction(qc_AB)
rho_AB.draw('latex', prefix='\\rho_{AB} = ')
from qiskit.visualization import plot_state_city
plot_state_city(rho_AB.data, title='Density Matrix')
import numpy as np
rho_p = qi.DensityMatrix.from_label('+')
display(rho_p.draw('latex', prefix='\\rho_p = '))
gamma_p = rho_p.purity()
print("State purity: ", np.round(np.real(gamma_p),3))
rho_m = 1/2*(qi.DensityMatrix.from_label('0') + qi.DensityMatrix.from_label('1'))
display(rho_m.draw('latex', prefix='\\rho_m = '))
gamma_m = rho_m.purity()
print("State purity: ", np.round(np.real(gamma_m),3))
rho_B = qi.partial_trace(rho_AB,[0])
rho_A = qi.partial_trace(rho_AB,[1])
display(rho_B.draw('latex', prefix=" \\rho_{B} = "),
rho_A.draw('latex', prefix=" \\rho_{A} = "))
qc_CD = QuantumCircuit(2)
qc_CD.ry(np.pi/3,0)
qc_CD.h(1)
qc_CD.cx(0,1)
qc_CD.cx(1,0)
qc_CD.draw("mpl", style="iqx")
from qiskit import *
from qiskit.circuit import QuantumCircuit
from qiskit.quantum_info import partial_trace, entropy
import numpy as np
import math
nQubits = # <--- insert your code here
nClassicBits = 4
circuit.draw(output='mpl')
# Run the quantum circuit on a statevector simulator backend
backend = # <--- insert your code here
outputstate = # <--- insert your code here
print(outputstate)
list_check = [5,7,8,10]
for ind in list_check:
print(outputstate[ind])
def check_vn_entropy(vn_entropy):
if vn_entropy != 0.:
print("The state is a mixed state")
## insert your code here -->
check_vn_entropy(my_entropy)
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import random
from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
%matplotlib inline
from qiskit import IBMQ
from qiskit.tools.monitor import job_monitor
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(group='open')
def counts_to_prob_1d(counts):
# Convert histogram counts to probability vector of size 1 x 2^n
states = list(counts.keys())
state_counts = list(counts.values())
nshots = sum(state_counts)
# Convert binary to integer index, reversing order as consistent w qiskit convention
states_x = [int(s[::-1],2) for s in states]
# Create array of probability values
probabilities = np.zeros(2**n)
probabilities[states_x] = state_counts
probabilities /= nshots
return probabilities
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
circuit.x(qcoin[0])
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin,cpos,simulatorType):
circuit.h(qcoin)
circuit.barrier()
increment_gate(circuit, qpos, qcoin)
circuit.barrier()
decrement_gate(circuit, qpos, qcoin)
circuit.barrier()
if simulatorType == 'classical':
circuit.measure(qpos,cpos)
def run(steps,simulatorType):
# steps = number of quantum walks steps
# simulatorType = 'sim', 'quantum' or 'classical'
if simulatorType == 'sim':
simulator = Aer.get_backend('qasm_simulator')
elif simulatorType == 'quantum':
simulator = provider.get_backend('ibmq_5_yorktown')
elif simulatorType == 'classical':
simulator = Aer.get_backend('qasm_simulator')
else:
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(n,'qc')
qcoin = QuantumRegister(1,'qanc')
cpos = ClassicalRegister(n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
for i in range(steps):
step(circuit, qpos, qcoin,cpos, simulatorType)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # monitor job
job_monitor(job)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
return counts
seed = 12
random.seed(seed)
np.random.seed(seed)
def plotCircleGraph(names,propabilities,color=[0,0,1]):
G = nx.Graph()
colorarray = []
# generate array of colors
numProp = len(propabilities)
for idx in range(numProp):
colorarray.append(color+[0.5*propabilities[idx]])
# generate graph
for idx in range(numProp-1):
G.add_edge(idx, idx+1)
# add last edge
G.add_edge(0,numProp-1)
# label nodes
labels = {}
for idx in range(numProp):
labels[idx] = names[idx]
nx.draw(G,
pos=nx.circular_layout(G),
node_color=colorarray,
cmap=plt.cm.Blues,
node_size=3000,
edge_color='k',
)
pos=nx.circular_layout(G)
labels = nx.draw_networkx_labels(G,pos,labels,font_size=16,
bbox=dict(facecolor='w', alpha=1, edgecolor='w')
)
# run and plot 1D walk
steps = 3
n=2
for i in range(steps+1):
#run classical random walk
countsClassical = run(i,'classical')
propClassical = counts_to_prob_1d(countsClassical)
#run quantum simulation
countsSim = run(i,'sim')
propSim = counts_to_prob_1d(countsSim)
#run the real thing
countsQuantum = run(i,'quantum')
propQuantum = counts_to_prob_1d(countsQuantum)
names = []
formatLabel = '{0:0'+str(n)+'b}'
for idx in range(2**n):
names.append('|' + formatLabel.format(idx) +'>')
#plotting
f, axs = plt.subplots(2,3,figsize=(13,8))
margin=0.4
f.subplots_adjust(margin, margin, 1.-margin, 1.-margin)
axs[0,0].set_title('classical random walk', fontsize=14)
plt.sca(axs[0,0])
plotCircleGraph(names,propClassical,color=[1,0,0])
plt.sca(axs[1,0])
plt.bar(names,propClassical,edgecolor='black', color=[1,0,0,.4], lw=2)
plt.ylim(0,1)
plt.xticks(rotation=45)
axs[0,1].set_title('simulated quantum walk', fontsize=14)
plt.sca(axs[0,1])
plotCircleGraph(names,propSim,color=[0.3,1,0])
plt.sca(axs[1,1])
plt.bar(names,propSim,edgecolor='black', color=[0.3,1,0,.4], lw=2)
plt.ylim(0,1)
plt.xticks(rotation=45)
axs[0,2].set_title('IBM quantum walk', fontsize=14)
plt.sca(axs[0,2])
plotCircleGraph(names,propQuantum,color=[0.1,0.3,1])
plt.sca(axs[1,2])
plt.bar(names,propQuantum,edgecolor='black', color=[0.1,0.3,1,.4], lw=2)
plt.ylim(0,1)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
from qiskit import IBMQ
from qiskit.tools.monitor import job_monitor
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(group='open') #check open servers
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import random
from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
from matplotlib import cm
%matplotlib inline
def counts_to_prob_2d(counts):
states = list(counts.keys())
state_counts = list(counts.values())
nshots = sum(state_counts)
n = int(len(states[0])/2)
def sep_xy(states):
# Separate x and y coordinates in state vector
states_x = [s[:n] for s in states]
states_y = [s[n:] for s in states]
states_x = np.array([int(s[::-1],2) for s in states_x])
states_y = np.array([int(s[::-1],2) for s in states_y])
return states_x, states_y
x,y = sep_xy(states)
# Create array of probability values
probabilities = np.zeros((2**n,2**n))
probabilities[x,y] = state_counts
probabilities /= nshots
return probabilities
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin, cpos, simulatorType):
circuit.h(qcoin)
circuit.barrier()
# y operations
increment_gate(circuit, qpos[len(qpos)//2:], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[len(qpos)//2:], qcoin)
# x operations
circuit.x(qcoin)
increment_gate(circuit, qpos[:len(qpos)//2], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[:len(qpos)//2:], qcoin)
circuit.barrier()
if simulatorType == 'classical':
circuit.measure(qpos,cpos)
def initialize_2D(circuit, n, pos):
# convert position to binary
formatLabel = '{0:0'+str(n)+'b}'
x = formatLabel.format(pos[0])
y = formatLabel.format(pos[1])
for i in range(len(x)):
if x[i]=='1':
circuit.x((n-i)-1)
for j in range(len(y)):
if y[j]=='1':
circuit.x((2*n-j)-1)
return circuit
def run(steps,simulatorType):
# steps = number of quantum walks steps
# simulatorType = 'sim', 'quantum' or 'classical'
if simulatorType == 'sim':
simulator = Aer.get_backend('qasm_simulator')
elif simulatorType == 'quantum':
simulator = provider.get_backend('ibmq_16_melbourne')
elif simulatorType == 'classical':
simulator = Aer.get_backend('qasm_simulator')
else:
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(2*n,'qc')
qcoin = QuantumRegister(2,'qanc')
cpos = ClassicalRegister(2*n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
circuit = initialize_2D(circuit, n, [round(n/2),round(n/2)])
for i in range(steps):
step(circuit, qpos, qcoin, cpos, simulatorType)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# monitor job
job_monitor(job)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
return counts
n=2
steps = 3
for i in range(steps+1):
#run classical random walk
countsClassical = run(i,'classical')
propClassical = counts_to_prob_2d(countsClassical)
#run quantum simulation
countsSim = run(i,'sim')
propSim = counts_to_prob_2d(countsSim)
#run the real thing
countsQuantum = run(i,'quantum')
propQuantum = counts_to_prob_2d(countsQuantum)
#plotting
names = []
values = []
formatLabel = '{0:0'+str(n)+'b}'
for idx in range(2**n):
names.append('|' + formatLabel.format(idx) +'>')
values.append(idx)
f, axs = plt.subplots(1,3,figsize=(13,8))
margin=0.4
f.subplots_adjust(margin, margin, 1.-margin, 1.-margin)
axs[0].set_title('classical random walk')
plt.sca(axs[0])
plt.imshow(propClassical,cmap=plt.get_cmap('Reds'))
plt.xticks(rotation=45)
axs[0].set_xticks(values)
axs[0].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[0].set_yticks(values)
axs[0].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
axs[1].set_title('simulated quantum walk')
plt.sca(axs[1])
plt.imshow(propSim,cmap=plt.get_cmap('Greens'))
plt.xticks(rotation=45)
axs[1].set_xticks(values)
axs[1].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[1].set_yticks(values)
axs[1].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
axs[2].set_title('IBM quantum walk')
plt.sca(axs[2])
plt.imshow(propQuantum,cmap=plt.get_cmap('Blues'))
plt.xticks(rotation=45)
axs[2].set_xticks(values)
axs[2].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[2].set_yticks(values)
axs[2].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
plt.tight_layout()
plt.show()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
# Library for implementing XOR
import qiskit
import numpy as np
from qiskit import(
IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute,
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram, plot_state_city
if __name__ == "__main__":
pass
def binary_it(alpha):
''' binary_it:
returns a list that is indexed according to power,
binaried[0] = is LSB.
'''
binaried = [int(x) for x in bin(alpha)[2:]]
binaried.reverse()
return binaried
def invert(alpha):
return [ 1 - x for x in alpha]
def xor_gate_v_each(circuit, a,b,r, v,c,a0):
''' xor_gate_v_each:
See paper 'An Example of the Difference Between Quantum and Classical Random Walks'
args:
circuit -- the py object that holds the quantum circuit.
a -- q. reg. for the vertex.
b -- q. reg. for holding neighbor vertex.
r -- q. reg. for checking valid edge.
f(c, a0) -- function that returns the neighboring
-- vertex of a0 using label c for the vertex label.
c -- label of the edge
a0 -- label of the vertex
'''
#vc = v(c,a0);
vc = 1
#build in the not's for the a0 check.
binaried = binary_it(a0)
#match binaried
if len(binaried) > len(a):
binaried = binaried[:len(a)]
elif len(a) > len(binaried):
for i in range(len(a)-len(binaried)):
binaried.append(0)
notMask = invert(binaried)
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
#build in the cnots for xoring b
binaried = binary_it(vc)
#match binaried
if len(binaried) > len(a):
binaried = binaried[:len(a)]
elif len(a) > len(binaried):
for i in range(len(a)-len(binaried)):
binaried.append(0)
for i in range(len(binaried)):
if binaried[i]:
circuit.mct(a,b[i], None, mode='noancilla')
#build in the not's for the a0 return.
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
def xor_gate_f_each(circuit, a,b,r, v,c,a0):
''' xor_gate_v_each:
See paper 'An Example of the Difference Between Quantum and Classical Random Walks'
args:
circuit -- the py object that holds the quantum circuit.
a -- q. reg. for the vertex.
b -- q. reg. for holding neighbor vertex.
r -- q. reg. for checking valid edge.
f(c, a0) -- function that returns the neighboring
-- vertex of a0 using label c for the vertex label.
c -- label of the edge
a0 -- label of the vertex
'''
#fc = f(c,a0);
fc = 1
#build in the not's for the a0 check.
binaried = binary_it(a0)
#match binaried
if len(binaried) > len(a):
binaried = binaried[:len(a)]
elif len(a) > len(binaried):
for i in range(len(a)-len(binaried)):
binaried.append(0)
notMask = invert(binaried)
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
#build in the cnots for xoring b
binaried = binary_it(fc)
#match binaried
if len(binaried) > len(r):
binaried = binaried[:len(r)]
elif len(r) > len(binaried):
for i in range(len(r)-len(binaried)):
binaried.append(0)
for i in range(len(binaried)):
if binaried[i]:
circuit.mct(a,r[i], None, mode='noancilla')
#build in the not's for the a0 return.
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
n = 2
simulator = Aer.get_backend('qasm_simulator')
a = QuantumRegister(n, 'a')
b = QuantumRegister(n, 'b')
r = QuantumRegister(1, 'r')
circuit = QuantumCircuit(a, b, r)
a0 = 1
xor_gate_v_each(circuit, a,b,r, 0,0,a0)
circuit.barrier()
a0 = 2
xor_gate_f_each(circuit, a,b,r, 0,0,a0)
circuit.draw()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
# 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/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import random
from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
%matplotlib qt
steps = 5
n=4
def counts_to_prob_1d(counts):
# Convert histogram counts to probability vector of size 1 x 2^n
states = list(counts.keys())
state_counts = list(counts.values())
nshots = sum(state_counts)
# Convert binary to integer index, reversing order as consistent w qiskit convention
states_x = [int(s[::-1],2) for s in states]
# Create array of probability values
probabilities = np.zeros(2**n)
probabilities[states_x] = state_counts
probabilities /= nshots
return probabilities
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
circuit.x(qcoin[0])
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin):
circuit.h(qcoin)
circuit.barrier()
increment_gate(circuit, qpos, qcoin)
circuit.barrier()
decrement_gate(circuit, qpos, qcoin)
circuit.barrier()
def run(steps):
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(n,'qc')
qcoin = QuantumRegister(1,'qanc')
cpos = ClassicalRegister(n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
for i in range(steps):
step(circuit, qpos, qcoin)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
return counts
seed = 12
random.seed(seed)
np.random.seed(seed)
def plotCircleGraph(propabilities):
G = nx.Graph()
colorarray = []
# generate array of colors
numProp = len(propabilities)
for idx in range(numProp):
colorarray.append([1-prop[idx],1-prop[idx],1])
# generate graph
for idx in range(numProp-1):
G.add_edge(idx, idx+1)
# add last edge
G.add_edge(0,numProp-1)
nx.draw(G,pos=nx.circular_layout(G),node_color = colorarray,cmap=plt.cm.Blues)
for i in range(steps+1):
counts = run(i)
prop = counts_to_prob_1d(counts)
plotCircleGraph(prop)
plt.pause(0.3)
plt.close()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
import numpy as np
from qiskit import(
IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute,
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram, plot_state_city
import matplotlib.pyplot as plt
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
circuit.x(qcoin[0])
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin):
circuit.h(qcoin)
circuit.barrier()
increment_gate(circuit, qpos, qcoin)
circuit.barrier()
decrement_gate(circuit, qpos, qcoin)
circuit.barrier()
n=2
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(n,'qc')
qcoin = QuantumRegister(1,'qanc')
cpos = ClassicalRegister(n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
step(circuit, qpos, qcoin)
step(circuit, qpos, qcoin)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
# Draw the circuit
circuit.draw(output='mpl')
# Plot a histogram
plot_histogram(counts)
counts
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import random
from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
%matplotlib inline
from qiskit import IBMQ
from qiskit.tools.monitor import job_monitor
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(group='open')
def counts_to_prob_1d(counts):
# Convert histogram counts to probability vector of size 1 x 2^n
states = list(counts.keys())
state_counts = list(counts.values())
nshots = sum(state_counts)
# Convert binary to integer index, reversing order as consistent w qiskit convention
states_x = [int(s[::-1],2) for s in states]
# Create array of probability values
probabilities = np.zeros(2**n)
probabilities[states_x] = state_counts
probabilities /= nshots
return probabilities
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
circuit.x(qcoin[0])
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin,cpos,simulatorType):
circuit.h(qcoin)
circuit.barrier()
increment_gate(circuit, qpos, qcoin)
circuit.barrier()
decrement_gate(circuit, qpos, qcoin)
circuit.barrier()
if simulatorType == 'classical':
circuit.measure(qpos,cpos)
def run(steps,simulatorType):
# steps = number of quantum walks steps
# simulatorType = 'sim', 'quantum' or 'classical'
if simulatorType == 'sim':
simulator = Aer.get_backend('qasm_simulator')
elif simulatorType == 'quantum':
simulator = provider.get_backend('ibmq_5_yorktown')
elif simulatorType == 'classical':
simulator = Aer.get_backend('qasm_simulator')
else:
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(n,'qc')
qcoin = QuantumRegister(1,'qanc')
cpos = ClassicalRegister(n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
for i in range(steps):
step(circuit, qpos, qcoin,cpos, simulatorType)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # monitor job
job_monitor(job)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
return counts
seed = 12
random.seed(seed)
np.random.seed(seed)
def plotCircleGraph(names,propabilities,color=[0,0,1]):
G = nx.Graph()
colorarray = []
# generate array of colors
numProp = len(propabilities)
for idx in range(numProp):
colorarray.append(color+[0.5*propabilities[idx]])
# generate graph
for idx in range(numProp-1):
G.add_edge(idx, idx+1)
# add last edge
G.add_edge(0,numProp-1)
# label nodes
labels = {}
for idx in range(numProp):
labels[idx] = names[idx]
nx.draw(G,
pos=nx.circular_layout(G),
node_color=colorarray,
cmap=plt.cm.Blues,
node_size=3000,
edge_color='k',
)
pos=nx.circular_layout(G)
labels = nx.draw_networkx_labels(G,pos,labels,font_size=16,
bbox=dict(facecolor='w', alpha=1, edgecolor='w')
)
# run and plot 1D walk
steps = 3
n=2
for i in range(steps+1):
#run classical random walk
countsClassical = run(i,'classical')
propClassical = counts_to_prob_1d(countsClassical)
#run quantum simulation
countsSim = run(i,'sim')
propSim = counts_to_prob_1d(countsSim)
#run the real thing
countsQuantum = run(i,'quantum')
propQuantum = counts_to_prob_1d(countsQuantum)
names = []
formatLabel = '{0:0'+str(n)+'b}'
for idx in range(2**n):
names.append('|' + formatLabel.format(idx) +'>')
#plotting
f, axs = plt.subplots(2,3,figsize=(13,8))
margin=0.4
f.subplots_adjust(margin, margin, 1.-margin, 1.-margin)
axs[0,0].set_title('classical random walk', fontsize=14)
plt.sca(axs[0,0])
plotCircleGraph(names,propClassical,color=[1,0,0])
plt.sca(axs[1,0])
plt.bar(names,propClassical,edgecolor='black', color=[1,0,0,.4], lw=2)
plt.ylim(0,1)
plt.xticks(rotation=45)
axs[0,1].set_title('simulated quantum walk', fontsize=14)
plt.sca(axs[0,1])
plotCircleGraph(names,propSim,color=[0.3,1,0])
plt.sca(axs[1,1])
plt.bar(names,propSim,edgecolor='black', color=[0.3,1,0,.4], lw=2)
plt.ylim(0,1)
plt.xticks(rotation=45)
axs[0,2].set_title('IBM quantum walk', fontsize=14)
plt.sca(axs[0,2])
plotCircleGraph(names,propQuantum,color=[0.1,0.3,1])
plt.sca(axs[1,2])
plt.bar(names,propQuantum,edgecolor='black', color=[0.1,0.3,1,.4], lw=2)
plt.ylim(0,1)
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import random
from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
%matplotlib qt
import os
print(os.environ.get('QT_API'))
n=3
steps = 8
def counts_to_prob_2d(counts):
states = list(counts.keys())
state_counts = list(counts.values())
nshots = sum(state_counts)
n = int(len(states[0])/2)
def sep_xy(states):
# Separate x and y coordinates in state vector
states_x = [s[:n] for s in states]
states_y = [s[n:] for s in states]
states_x = np.array([int(s[::-1],2) for s in states_x])
states_y = np.array([int(s[::-1],2) for s in states_y])
return states_x, states_y
x,y = sep_xy(states)
# Create array of probability values
probabilities = np.zeros((2**n,2**n))
probabilities[x,y] = state_counts
probabilities /= nshots
return probabilities
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin):
circuit.h(qcoin)
circuit.barrier()
# y operations
increment_gate(circuit, qpos[len(qpos)//2:], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[len(qpos)//2:], qcoin)
# x operations
circuit.x(qcoin)
increment_gate(circuit, qpos[:len(qpos)//2], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[:len(qpos)//2:], qcoin)
circuit.barrier()
def initialize_2D(circuit, n, pos):
# convert position to binary
x = "{:b}".format(pos[0])
y = "{:b}".format(pos[1])
for i in range(len(x)):
if x[i]=='1': circuit.x((n-i)-1)
for j in range(len(y)):
if y[j]=='1': circuit.x((2*n-j)-1)
return circuit
def run(steps):
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(2*n,'qc')
qcoin = QuantumRegister(2,'qanc')
cpos = ClassicalRegister(2*n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
circuit = initialize_2D(circuit, n, (3,3))
for i in range(steps):
step(circuit, qpos, qcoin)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
return counts
seed = 12
random.seed(seed)
np.random.seed(seed)
def plotSquareGraph(propMat):
colorarray = []
# generate array of colors
numProp = len(propMat)
for idx in range(numProp):
for jdx in range(numProp):
colorarray.append([1-propMat[idx][jdx],1-propMat[idx][jdx],1])
G = nx.grid_2d_graph(numProp, numProp) # 5x5 grid
# print the adjacency list
for line in nx.generate_adjlist(G):
pass
# write edgelist to grid.edgelist
nx.write_edgelist(G, path="grid.edgelist", delimiter=":")
nx.draw(G,node_color = colorarray,cmap=plt.cm.Blues)
plt.plot()
for i in range(steps+1):
counts = run(i)
prop = counts_to_prob_2d(counts)
plt.close()
plt.imshow(prop)
# plotSquareGraph(prop)
plt.pause(1/steps)
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
from qiskit import IBMQ
from qiskit.tools.monitor import job_monitor
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(group='open') #check open servers
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import random
from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
from matplotlib import cm
%matplotlib inline
def counts_to_prob_2d(counts):
states = list(counts.keys())
state_counts = list(counts.values())
nshots = sum(state_counts)
n = int(len(states[0])/2)
def sep_xy(states):
# Separate x and y coordinates in state vector
states_x = [s[:n] for s in states]
states_y = [s[n:] for s in states]
states_x = np.array([int(s[::-1],2) for s in states_x])
states_y = np.array([int(s[::-1],2) for s in states_y])
return states_x, states_y
x,y = sep_xy(states)
# Create array of probability values
probabilities = np.zeros((2**n,2**n))
probabilities[x,y] = state_counts
probabilities /= nshots
return probabilities
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin, cpos, simulatorType):
circuit.h(qcoin)
circuit.barrier()
# y operations
increment_gate(circuit, qpos[len(qpos)//2:], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[len(qpos)//2:], qcoin)
# x operations
circuit.x(qcoin)
increment_gate(circuit, qpos[:len(qpos)//2], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[:len(qpos)//2:], qcoin)
circuit.barrier()
if simulatorType == 'classical':
circuit.measure(qpos,cpos)
def initialize_2D(circuit, n, pos):
# convert position to binary
formatLabel = '{0:0'+str(n)+'b}'
x = formatLabel.format(pos[0])
y = formatLabel.format(pos[1])
for i in range(len(x)):
if x[i]=='1':
circuit.x((n-i)-1)
for j in range(len(y)):
if y[j]=='1':
circuit.x((2*n-j)-1)
return circuit
def run(steps,simulatorType):
# steps = number of quantum walks steps
# simulatorType = 'sim', 'quantum' or 'classical'
if simulatorType == 'sim':
simulator = Aer.get_backend('qasm_simulator')
elif simulatorType == 'quantum':
simulator = provider.get_backend('ibmq_16_melbourne')
elif simulatorType == 'classical':
simulator = Aer.get_backend('qasm_simulator')
else:
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(2*n,'qc')
qcoin = QuantumRegister(2,'qanc')
cpos = ClassicalRegister(2*n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
circuit = initialize_2D(circuit, n, [round(n/2),round(n/2)])
for i in range(steps):
step(circuit, qpos, qcoin, cpos, simulatorType)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# monitor job
job_monitor(job)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
return counts
n=2
steps = 3
for i in range(steps+1):
#run classical random walk
countsClassical = run(i,'classical')
propClassical = counts_to_prob_2d(countsClassical)
#run quantum simulation
countsSim = run(i,'sim')
propSim = counts_to_prob_2d(countsSim)
#run the real thing
countsQuantum = run(i,'quantum')
propQuantum = counts_to_prob_2d(countsQuantum)
#plotting
names = []
values = []
formatLabel = '{0:0'+str(n)+'b}'
for idx in range(2**n):
names.append('|' + formatLabel.format(idx) +'>')
values.append(idx)
f, axs = plt.subplots(1,3,figsize=(13,8))
margin=0.4
f.subplots_adjust(margin, margin, 1.-margin, 1.-margin)
axs[0].set_title('classical random walk')
plt.sca(axs[0])
plt.imshow(propClassical,cmap=plt.get_cmap('Reds'))
plt.xticks(rotation=45)
axs[0].set_xticks(values)
axs[0].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[0].set_yticks(values)
axs[0].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
axs[1].set_title('simulated quantum walk')
plt.sca(axs[1])
plt.imshow(propSim,cmap=plt.get_cmap('Greens'))
plt.xticks(rotation=45)
axs[1].set_xticks(values)
axs[1].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[1].set_yticks(values)
axs[1].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
axs[2].set_title('IBM quantum walk')
plt.sca(axs[2])
plt.imshow(propQuantum,cmap=plt.get_cmap('Blues'))
plt.xticks(rotation=45)
axs[2].set_xticks(values)
axs[2].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[2].set_yticks(values)
axs[2].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
plt.tight_layout()
plt.show()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
import numpy as np
from qiskit import(
IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute,
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram, plot_state_city
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin):
circuit.h(qcoin)
circuit.barrier()
# y operations
increment_gate(circuit, qpos[len(qpos)//2:], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[len(qpos)//2:], qcoin)
# x operations
circuit.x(qcoin)
increment_gate(circuit, qpos[:len(qpos)//2], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[:len(qpos)//2:], qcoin)
circuit.barrier()
simulator = Aer.get_backend('qasm_simulator')
n=3
qpos = QuantumRegister(2*n,'qc')
qcoin = QuantumRegister(2,'qanc')
cpos = ClassicalRegister(2*n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
step(circuit, qpos, qcoin)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
# Draw the circuit
# circuit.draw()
# Plot a histogram
plot_histogram(counts)
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
from qiskit import IBMQ
from qiskit.tools.monitor import job_monitor
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(group='open') #check open servers
import numpy as np
import time
import networkx as nx
import matplotlib.pyplot as plt
import random
from qiskit import (QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer)
from matplotlib import cm
%matplotlib inline
def counts_to_prob_2d(counts):
states = list(counts.keys())
state_counts = list(counts.values())
nshots = sum(state_counts)
n = int(len(states[0])/2)
def sep_xy(states):
# Separate x and y coordinates in state vector
states_x = [s[:n] for s in states]
states_y = [s[n:] for s in states]
states_x = np.array([int(s[::-1],2) for s in states_x])
states_y = np.array([int(s[::-1],2) for s in states_y])
return states_x, states_y
x,y = sep_xy(states)
# Create array of probability values
probabilities = np.zeros((2**n,2**n))
probabilities[x,y] = state_counts
probabilities /= nshots
return probabilities
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin, cpos, simulatorType):
circuit.h(qcoin)
circuit.barrier()
# y operations
increment_gate(circuit, qpos[len(qpos)//2:], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[len(qpos)//2:], qcoin)
# x operations
circuit.x(qcoin)
increment_gate(circuit, qpos[:len(qpos)//2], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[:len(qpos)//2:], qcoin)
circuit.barrier()
if simulatorType == 'classical':
circuit.measure(qpos,cpos)
def initialize_2D(circuit, n, pos):
# convert position to binary
formatLabel = '{0:0'+str(n)+'b}'
x = formatLabel.format(pos[0])
y = formatLabel.format(pos[1])
for i in range(len(x)):
if x[i]=='1':
circuit.x((n-i)-1)
for j in range(len(y)):
if y[j]=='1':
circuit.x((2*n-j)-1)
return circuit
def run(steps,simulatorType):
# steps = number of quantum walks steps
# simulatorType = 'sim', 'quantum' or 'classical'
if simulatorType == 'sim':
simulator = Aer.get_backend('qasm_simulator')
elif simulatorType == 'quantum':
simulator = provider.get_backend('ibmq_16_melbourne')
elif simulatorType == 'classical':
simulator = Aer.get_backend('qasm_simulator')
else:
simulator = Aer.get_backend('qasm_simulator')
qpos = QuantumRegister(2*n,'qc')
qcoin = QuantumRegister(2,'qanc')
cpos = ClassicalRegister(2*n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
circuit = initialize_2D(circuit, n, [round(n/2),round(n/2)])
for i in range(steps):
step(circuit, qpos, qcoin, cpos, simulatorType)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# monitor job
job_monitor(job)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
return counts
n=2
steps = 3
for i in range(steps+1):
#run classical random walk
countsClassical = run(i,'classical')
propClassical = counts_to_prob_2d(countsClassical)
#run quantum simulation
countsSim = run(i,'sim')
propSim = counts_to_prob_2d(countsSim)
#run the real thing
countsQuantum = run(i,'quantum')
propQuantum = counts_to_prob_2d(countsQuantum)
#plotting
names = []
values = []
formatLabel = '{0:0'+str(n)+'b}'
for idx in range(2**n):
names.append('|' + formatLabel.format(idx) +'>')
values.append(idx)
f, axs = plt.subplots(1,3,figsize=(13,8))
margin=0.4
f.subplots_adjust(margin, margin, 1.-margin, 1.-margin)
axs[0].set_title('classical random walk')
plt.sca(axs[0])
plt.imshow(propClassical,cmap=plt.get_cmap('Reds'))
plt.xticks(rotation=45)
axs[0].set_xticks(values)
axs[0].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[0].set_yticks(values)
axs[0].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
axs[1].set_title('simulated quantum walk')
plt.sca(axs[1])
plt.imshow(propSim,cmap=plt.get_cmap('Greens'))
plt.xticks(rotation=45)
axs[1].set_xticks(values)
axs[1].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[1].set_yticks(values)
axs[1].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
axs[2].set_title('IBM quantum walk')
plt.sca(axs[2])
plt.imshow(propQuantum,cmap=plt.get_cmap('Blues'))
plt.xticks(rotation=45)
axs[2].set_xticks(values)
axs[2].set_xticklabels(names)
plt.xlim(-0.5,values[-1]+0.5)
axs[2].set_yticks(values)
axs[2].set_yticklabels(names)
plt.ylim(-0.5,values[-1]+0.5)
plt.tight_layout()
plt.show()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
# Library for implementing XOR
import qiskit
import numpy as np
from qiskit import(
IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute,
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram, plot_state_city
if __name__ == "__main__":
pass
def binary_it(alpha):
''' binary_it:
returns a list that is indexed according to power,
binaried[0] = is LSB.
'''
binaried = [int(x) for x in bin(alpha)[2:]]
binaried.reverse()
return binaried
def invert(alpha):
return [ 1 - x for x in alpha]
def xor_gate_v_each(circuit, a,b,r, v,c,a0):
''' xor_gate_v_each:
See paper 'An Example of the Difference Between Quantum and Classical Random Walks'
args:
circuit -- the py object that holds the quantum circuit.
a -- q. reg. for the vertex.
b -- q. reg. for holding neighbor vertex.
r -- q. reg. for checking valid edge.
f(c, a0) -- function that returns the neighboring
-- vertex of a0 using label c for the vertex label.
c -- label of the edge
a0 -- label of the vertex
'''
#vc = v(c,a0);
vc = 1
#build in the not's for the a0 check.
binaried = binary_it(a0)
#match binaried
if len(binaried) > len(a):
binaried = binaried[:len(a)]
elif len(a) > len(binaried):
for i in range(len(a)-len(binaried)):
binaried.append(0)
notMask = invert(binaried)
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
#build in the cnots for xoring b
binaried = binary_it(vc)
#match binaried
if len(binaried) > len(a):
binaried = binaried[:len(a)]
elif len(a) > len(binaried):
for i in range(len(a)-len(binaried)):
binaried.append(0)
for i in range(len(binaried)):
if binaried[i]:
circuit.mct(a,b[i], None, mode='noancilla')
#build in the not's for the a0 return.
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
def xor_gate_f_each(circuit, a,b,r, v,c,a0):
''' xor_gate_v_each:
See paper 'An Example of the Difference Between Quantum and Classical Random Walks'
args:
circuit -- the py object that holds the quantum circuit.
a -- q. reg. for the vertex.
b -- q. reg. for holding neighbor vertex.
r -- q. reg. for checking valid edge.
f(c, a0) -- function that returns the neighboring
-- vertex of a0 using label c for the vertex label.
c -- label of the edge
a0 -- label of the vertex
'''
#fc = f(c,a0);
fc = 1
#build in the not's for the a0 check.
binaried = binary_it(a0)
#match binaried
if len(binaried) > len(a):
binaried = binaried[:len(a)]
elif len(a) > len(binaried):
for i in range(len(a)-len(binaried)):
binaried.append(0)
notMask = invert(binaried)
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
#build in the cnots for xoring b
binaried = binary_it(fc)
#match binaried
if len(binaried) > len(r):
binaried = binaried[:len(r)]
elif len(r) > len(binaried):
for i in range(len(r)-len(binaried)):
binaried.append(0)
for i in range(len(binaried)):
if binaried[i]:
circuit.mct(a,r[i], None, mode='noancilla')
#build in the not's for the a0 return.
for i in range(len(notMask)):
if notMask[i]:
circuit.x(a[i]);
n = 2
simulator = Aer.get_backend('qasm_simulator')
a = QuantumRegister(n, 'a')
b = QuantumRegister(n, 'b')
r = QuantumRegister(1, 'r')
circuit = QuantumCircuit(a, b, r)
a0 = 1
xor_gate_v_each(circuit, a,b,r, 0,0,a0)
circuit.barrier()
a0 = 2
xor_gate_f_each(circuit, a,b,r, 0,0,a0)
circuit.draw()
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
import numpy as np
from qiskit import(
IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute,
QuantumCircuit,
execute,
Aer)
from qiskit.visualization import plot_histogram, plot_state_city
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct(qcoin[:]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin):
circuit.h(qcoin)
circuit.barrier()
# y operations
increment_gate(circuit, qpos[len(qpos)//2:], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[len(qpos)//2:], qcoin)
# x operations
circuit.x(qcoin)
increment_gate(circuit, qpos[:len(qpos)//2], qcoin)
circuit.x(qcoin[0])
decrement_gate(circuit, qpos[:len(qpos)//2:], qcoin)
circuit.barrier()
simulator = Aer.get_backend('qasm_simulator')
n=3
qpos = QuantumRegister(2*n,'qc')
qcoin = QuantumRegister(2,'qanc')
cpos = ClassicalRegister(2*n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
step(circuit, qpos, qcoin)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
# # Execute the circuit on the qasm simulator
job = execute(circuit, simulator, shots=1000)
# # Grab results from the job
result = job.result()
# # Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 00 and 11 are:",counts)
# Draw the circuit
# circuit.draw()
# Plot a histogram
plot_histogram(counts)
counts
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import numpy as np
from qiskit import *
from qiskit.tools.visualization import plot_histogram, plot_state_city
import matplotlib.pyplot as plt
# 1D Graph
def increment_gate(circuit, qpos, qcoin):
n = len(qpos)
for i in range(n):
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
def decrement_gate(circuit, qpos, qcoin):
n = len(qpos)
circuit.x(qcoin[0])
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
def step(circuit, qpos, qcoin):
circuit.h(qcoin)
circuit.barrier()
increment_gate(circuit, qpos, qcoin)
circuit.barrier()
decrement_gate(circuit, qpos, qcoin)
circuit.barrier()
# Circuit drawing
n=2
qpos = QuantumRegister(n,'qc')
qcoin = QuantumRegister(1,'qanc')
cpos = ClassicalRegister(n,'cr')
circuit = QuantumCircuit(qpos, qcoin, cpos)
step(circuit, qpos, qcoin)
# # Map the quantum measurement to the classical bits
circuit.measure(qpos,cpos)
circuit.draw(output='mpl')
n=3
qpos = QuantumRegister(n,'qc')
# increment
def increment_only(circuit):
for i in range(n):
circuit.mct(qpos[i+1:], qpos[i], None, mode='noancilla')
circuit.barrier()
return circuit
# decrement
def decrement_only(circuit):
for i in range(n):
if i+1 < n: circuit.x(qpos[i+1:])
circuit.mct(qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: circuit.x(qpos[i+1:])
circuit.barrier()
# Increment gate
circuit = QuantumCircuit(qpos)
increment_only(circuit)
# increment_gate(circuit, qpos, qcoin)
circuit.draw(output='mpl')
# Decrement gate
circuit = QuantumCircuit(qpos)
decrement_only(circuit)
# decrement_gate(circuit, qpos, qcoin)
circuit.draw(output='mpl')
|
https://github.com/biswaroopmukherjee/Quantum-Waddle
|
biswaroopmukherjee
|
import qiskit
qiskit.__qiskit_version__
def cnx(qc, *qubits):
if len(qubits) >= 3:
last = qubits[-1]
# A matrix: (made up of a and Y rotation, lemma4.3)
qc.crz(np.pi/2, qubits[-2], qubits[-1])
qc.cu3(np.pi/2, 0, 0, qubits[-2],qubits[-1])
# Control not gate
cnx(qc,*qubits[:-2],qubits[-1])
# B matrix (pposite angle)
qc.cu3(-np.pi/2, 0, 0, qubits[-2], qubits[-1])
# Control
cnx(qc,*qubits[:-2],qubits[-1])
# C matrix (final rotation)
qc.crz(-np.pi/2,qubits[-2],qubits[-1])
elif len(qubits)==3:
qc.ccx(*qubits)
elif len(qubits)==2:
qc.cx(*qubits)
import numpy as np
from qiskit import IBMQ, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import plot_histogram, plot_state_city
n=3
IBMQ.load_accounts()
IBMQ.backends()
def increment_gate(qwc, q, subnode):
cnx(qwc, subnode[0], q[2], q[1], q[0])
cnx(qwc, subnode[0], q[2], q[1])
cnx(qwc, subnode[0], q[2])
qwc.barrier()
return qwc
def decrement_gate(qwc, q, subnode):
qwc.x(subnode[0])
qwc.x(q[2])
qwc.x(q[1])
cnx(qwc, subnode[0], q[2], q[1], q[0])
qwc.x(q[1])
cnx(qwc, subnode[0], q[2], q[1])
qwc.x(q[2])
cnx(qwc, subnode[0], q[2])
qwc.x(subnode[0])
return qwc
def ibmsim(circ):
ibmqBE = IBMQ.get_backend('ibmq_qasm_simulator')
return execute(circ,ibmqBE, shots=1000).result().get_counts(circ)
qnodes = QuantumRegister(n,'qc')
qsubnodes = QuantumRegister(1,'qanc')
csubnodes = ClassicalRegister(1,'canc')
cnodes = ClassicalRegister(n,'cr')
qwc = QuantumCircuit(qnodes, qsubnodes, cnodes, csubnodes)
def runQWC(qwc, times):
for i in range(times):
qwc.h(qsubnodes[0])
increment_gate(qwc, qnodes, qsubnodes[0])
decrement_gate(qwc,qnodes,qsubnodes[0])
qwc.measure(qnodes, cnodes)
return qwc
import matplotlib as mpl
step = 1
qwc = runQWC(qwc, step)
qwc.draw(output="mpl")
result = ibmsim(qwc)
print(result)
def runQWC(qwc, times):
for i in range(times):
qwc.h(qsubnodes[0])
increment_gate(qwc, qnodes, qsubnodes[0])
decrement_gate(qwc,qnodes,qsubnodes[0])
qwc.measure(qnodes, cnodes)
return qwc
result = ibmsim(qwc)
plot_histogram(result)
|
https://github.com/chaurasiyag/minor-project-quantum-computing
|
chaurasiyag
|
from qiskit import *
qr=QuantumRegister(1)
qc=ClassicalRegister(1)
cir=QuantumCircuit(qr,qc)
cir.draw()
cir.x(qr[0])
cir.draw()
cir.measure(qr,qc)
cir.draw()
simulator=BasicAer.get_backend("qasm_simulator")
res=execute(cir,backend=simulator).result()
print(res)
from qiskit.tools.visualization import plot_histogram
plot_histogram(res.get_counts(cir))
IBMQ.save_account('7cd5664973bf6ce405272fc6fa2bd7684625b387b768de3dd459fa38dd3cdc417387fa4c306562485e0bb6ddb46fd20fcd24da495248304d90d155b52011fd6f')
IBMQ.load_account()
provider=IBMQ.get_provider('ibm-q')
qcomp=provider.get_backend('ibmq_quito')
job=execute(cir,backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
res=job.result()
plot_histogram(res.get_counts(cir))
from qiskit import *
from math import pi
qr=QuantumRegister(1)
cr=ClassicalRegister(1)
qc=QuantumCircuit(qr,cr)
qc.draw()
qc.u3(pi,0,0,qr[0])
qc.measure(qr,cr)
qc.draw()
simulator=BasicAer.get_backend("qasm_simulator")
job=execute(qc,backend=simulator)
from qiskit.tools.visualization import plot_histogram
plot_histogram(job.result().get_counts())
plot_histogram(job.result().get_counts(qc))
qrr=QuantumRegister(1)
crr=ClassicalRegister(1)
qcc=QuantumCircuit(qrr,crr)
qcc.x(qrr[0])
qcc.z(qrr[0])
qcc.draw()
qcc.measure(qrr,crr)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qcc,backend=simu).result()
plot_histogram(result.get_counts(qcc))
qr2=QuantumRegister(2)
cr2=ClassicalRegister(2)
qc=QuantumCircuit(qr2,cr2)
qc.h(qr2[0])
qc.cx(qr2[0],qr2[1])
qc.draw()
qc.measure(qr2,cr2)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qc,backend=simu).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(qc))
IBMQ.save_account('7cd5664973bf6ce405272fc6fa2bd7684625b387b768de3dd459fa38dd3cdc417387fa4c306562485e0bb6ddb46fd20fcd24da495248304d90d155b52011fd6f',overwrite=True)
IBMQ.load_account()
pr=IBMQ.get_provider('ibm-q')
qcomp=pr.get_backend("ibmq_quito")
job=execute(qc,backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
res=job.result()
plot_histogram(res.get_counts(qc))
qiskit.tools
from qiskit import *
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
qr=QuantumRegister(2)
cr=ClassicalRegister(2)
qc=QuantumCircuit(qr,cr)
qc.x(qr[0])
qc.draw()
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.draw()
qc.measure(qr,cr)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qc,backend=simu).result()
plot_histogram(result.get_counts(qc))
IBMQ.save_account('c10fa12997ad898683c72c5496c720b9657d7b96ce93b3f443366854e87973466f32f0bd9d807b4c147a63ac230eb03987972bdf400193154e11bdd834503a58',overwrite=True)
IBMQ.load_account()
pr=IBMQ.get_provider("ibm-q")
qcomp=pr.get_backend("ibmq_manila")
job=execute(qc,backend=qcomp)
job_monitor(job)
result=job.result()
plot_histogram(result.get_counts(qc))
qr1=QuantumRegister(2)
cr1=ClassicalRegister(2)
qc1=QuantumCircuit(qr1,cr1)
qc1.h(qr1[0])
qc1.x(qr1[1])
qc1.cx(qr1[0],qr1[1])
qc1.measure(qr1,cr1)
simu=BasicAer.get_backend("qasm_simulator")
job=execute(qc1,backend=simu).result()
print(job.get_counts())
plot_histogram(job.get_counts(qc1))
qcomp1=pr.get_backend("ibmq_manila")
job1=execute(qc1,backend=qcomp1)
job_monitor(job1)
plot_histogram(job1.result().get_counts(q))
print(job1.result().get_counts())
from qiskit import *
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
qr2=QuantumRegister(2)
cr2=ClassicalRegister(2)
qc2=QuantumCircuit(qr2,cr2)
qc2.x(qr2[0])
qc2.x(qr2[1])
qc2.h(qr2[0])
qc2.cx(qr2[0],qr2[1])
qc2.draw()
simu=BasicAer.get_backend("qasm_simulator")
qc2.measure(qr2,cr2)
job3=execute(qc2,backend=simu)
print(job3.result().get_counts())
plot_histogram(job3.result().get_counts())
IBMQ.load_account()
pr=IBMQ.get_provider("ibm-q")
qcomp2=pr.get_backend("ibmq_manila")
job4=execute(qc2,backend=qcomp2)
job_monitor(job4)
print(job4.result().get_counts())
plot_histogram(job4.result().get_counts())
from qiskit import *
bell=QuantumCircuit(2,2)
bell.h(0)
bell.cx(0,1)
meas=QuantumCircuit(2,2)
meas.measure([0,1],[0,1])
backend=BasicAer.get_backend('qasm_simulator')
circ=bell.compose(meas)
result=backend.run(transpile(circ,backend)).result()
count=result.get_counts(circ)
print(count)
from qiskit.visualization import plot_bloch_multivector,plot_state_qsphere,plot_histogram,plot_bloch_vector
# bell=QuantumCircuit(1,1)
bell.h(0)
bell.y(0)
backend=BasicAer.get_backend('statevector_simulator')
result=backend.run(transpile(bell,backend)).result()
ps1=result.get_statevector(bell)
plot_bloch_multivector(ps1)
!pip install seaborn
# plot_state_qsphere(ps1)
# plot_bloch_vector(['00','11'])
q=QuantumCircuit(1,1)
q.y(0)
plot_bloch_multivector(q)
from qiskit_textbook.widgets import bloch_calc
!pip install qiskit_textbook
from qiskit_textbook.widgets import binary_widget
binary_widget(nbits=5)
print("Just adding for update automatically on github repo using shell script cronjob")
print("Added Second Line to Check Automatic Update")
print("third")
print($$$)
print(000)
print("Last")
print("Automatic Updates Successfully")
from qiskit import *
import numpy as np
pi=np.pi
def qft(no_of_qbit):
qc=QuantumCircuit(no_of_qbit)
for qbit in range(no_of_qbit):
qc.h(qbit)
for other_qbit in range(qbit+1,no_of_qbit):
qc.cu1(pi/(2**(other_qbit-qbit)),other_qbit,qbit)
return qc
display(qft(5).draw())
display(qft(4).draw())
display(qft(3).draw())
print(90)
|
https://github.com/chaurasiyag/minor-project-quantum-computing
|
chaurasiyag
|
from qiskit import *
qr=QuantumRegister(1)
qc=ClassicalRegister(1)
cir=QuantumCircuit(qr,qc)
cir.draw()
cir.x(qr[0])
cir.draw()
cir.measure(qr,qc)
cir.draw()
simulator=BasicAer.get_backend("qasm_simulator")
res=execute(cir,backend=simulator).result()
print(res)
from qiskit.tools.visualization import plot_histogram
plot_histogram(res.get_counts(cir))
IBMQ.save_account('7cd5664973bf6ce405272fc6fa2bd7684625b387b768de3dd459fa38dd3cdc417387fa4c306562485e0bb6ddb46fd20fcd24da495248304d90d155b52011fd6f')
IBMQ.load_account()
provider=IBMQ.get_provider('ibm-q')
qcomp=provider.get_backend('ibmq_quito')
job=execute(cir,backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
res=job.result()
plot_histogram(res.get_counts(cir))
from qiskit import *
from math import pi
qr=QuantumRegister(1)
cr=ClassicalRegister(1)
qc=QuantumCircuit(qr,cr)
qc.draw()
qc.u3(pi,0,0,qr[0])
qc.measure(qr,cr)
qc.draw()
simulator=BasicAer.get_backend("qasm_simulator")
job=execute(qc,backend=simulator)
from qiskit.tools.visualization import plot_histogram
plot_histogram(job.result().get_counts())
plot_histogram(job.result().get_counts(qc))
qrr=QuantumRegister(1)
crr=ClassicalRegister(1)
qcc=QuantumCircuit(qrr,crr)
qcc.x(qrr[0])
qcc.z(qrr[0])
qcc.draw()
qcc.measure(qrr,crr)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qcc,backend=simu).result()
plot_histogram(result.get_counts(qcc))
qr2=QuantumRegister(2)
cr2=ClassicalRegister(2)
qc=QuantumCircuit(qr2,cr2)
qc.h(qr2[0])
qc.cx(qr2[0],qr2[1])
qc.draw()
qc.measure(qr2,cr2)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qc,backend=simu).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(qc))
IBMQ.save_account('7cd5664973bf6ce405272fc6fa2bd7684625b387b768de3dd459fa38dd3cdc417387fa4c306562485e0bb6ddb46fd20fcd24da495248304d90d155b52011fd6f',overwrite=True)
IBMQ.load_account()
pr=IBMQ.get_provider('ibm-q')
qcomp=pr.get_backend("ibmq_quito")
job=execute(qc,backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
res=job.result()
plot_histogram(res.get_counts(qc))
qiskit.tools
from qiskit import *
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
qr=QuantumRegister(2)
cr=ClassicalRegister(2)
qc=QuantumCircuit(qr,cr)
qc.x(qr[0])
qc.draw()
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.draw()
qc.measure(qr,cr)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qc,backend=simu).result()
plot_histogram(result.get_counts(qc))
IBMQ.save_account('c10fa12997ad898683c72c5496c720b9657d7b96ce93b3f443366854e87973466f32f0bd9d807b4c147a63ac230eb03987972bdf400193154e11bdd834503a58',overwrite=True)
IBMQ.load_account()
pr=IBMQ.get_provider("ibm-q")
qcomp=pr.get_backend("ibmq_manila")
job=execute(qc,backend=qcomp)
job_monitor(job)
result=job.result()
plot_histogram(result.get_counts(qc))
qr1=QuantumRegister(2)
cr1=ClassicalRegister(2)
qc1=QuantumCircuit(qr1,cr1)
qc1.h(qr1[0])
qc1.x(qr1[1])
qc1.cx(qr1[0],qr1[1])
qc1.measure(qr1,cr1)
simu=BasicAer.get_backend("qasm_simulator")
job=execute(qc1,backend=simu).result()
print(job.get_counts())
plot_histogram(job.get_counts(qc1))
qcomp1=pr.get_backend("ibmq_manila")
job1=execute(qc1,backend=qcomp1)
job_monitor(job1)
plot_histogram(job1.result().get_counts(q))
print(job1.result().get_counts())
from qiskit import *
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
qr2=QuantumRegister(2)
cr2=ClassicalRegister(2)
qc2=QuantumCircuit(qr2,cr2)
qc2.x(qr2[0])
qc2.x(qr2[1])
qc2.h(qr2[0])
qc2.cx(qr2[0],qr2[1])
qc2.draw()
simu=BasicAer.get_backend("qasm_simulator")
qc2.measure(qr2,cr2)
job3=execute(qc2,backend=simu)
print(job3.result().get_counts())
plot_histogram(job3.result().get_counts())
IBMQ.load_account()
pr=IBMQ.get_provider("ibm-q")
qcomp2=pr.get_backend("ibmq_manila")
job4=execute(qc2,backend=qcomp2)
job_monitor(job4)
print(job4.result().get_counts())
plot_histogram(job4.result().get_counts())
from qiskit import *
bell=QuantumCircuit(2,2)
bell.h(0)
bell.cx(0,1)
meas=QuantumCircuit(2,2)
meas.measure([0,1],[0,1])
backend=BasicAer.get_backend('qasm_simulator')
circ=bell.compose(meas)
result=backend.run(transpile(circ,backend)).result()
count=result.get_counts(circ)
print(count)
from qiskit.visualization import plot_bloch_multivector,plot_state_qsphere,plot_histogram,plot_bloch_vector
# bell=QuantumCircuit(1,1)
bell.h(0)
bell.y(0)
backend=BasicAer.get_backend('statevector_simulator')
result=backend.run(transpile(bell,backend)).result()
ps1=result.get_statevector(bell)
plot_bloch_multivector(ps1)
!pip install seaborn
# plot_state_qsphere(ps1)
# plot_bloch_vector(['00','11'])
q=QuantumCircuit(1,1)
q.y(0)
plot_bloch_multivector(q)
from qiskit_textbook.widgets import bloch_calc
!pip install qiskit_textbook
from qiskit_textbook.widgets import binary_widget
binary_widget(nbits=5)
print("Just adding for update automatically on github repo using shell script cronjob")
print("Added Second Line to Check Automatic Update")
print("third")
print($$$)
print(000)
print("Last")
print("Automatic Updates Successfully")
from qiskit import *
import numpy as np
pi=np.pi
def qft(no_of_qbit):
qc=QuantumCircuit(no_of_qbit)
for qbit in range(no_of_qbit):
qc.h(qbit)
for other_qbit in range(qbit+1,no_of_qbit):
qc.cu1(pi/(2**(other_qbit-qbit)),other_qbit,qbit)
return qc
display(qft(5).draw())
display(qft(4).draw())
display(qft(3).draw())
print(90)
|
https://github.com/Alfaxad/IBM_QC_Africa_2021
|
Alfaxad
|
from qiskit import *
from qiskit.visualization import plot_histogram
import numpy as np
def NOT(inp):
"""An NOT gate.
Parameters:
inp (str): Input, encoded in qubit 0.
Returns:
QuantumCircuit: Output NOT circuit.
str: Output value measured from qubit 0.
"""
qc = QuantumCircuit(1, 1) # A quantum circuit with a single qubit and a single classical bit
qc.reset(0)
# We encode '0' as the qubit state |0⟩, and '1' as |1⟩
# Since the qubit is initially |0⟩, we don't need to do anything for an input of '0'
# For an input of '1', we do an x to rotate the |0⟩ to |1⟩
if inp=='1':
qc.x(0)
# barrier between input state and gate operation
qc.barrier()
# Now we've encoded the input, we can do a NOT on it using x
qc.x(0)
#barrier between gate operation and measurement
qc.barrier()
# Finally, we extract the |0⟩/|1⟩ output of the qubit and encode it in the bit c[0]
qc.measure(0,0)
qc.draw()
# We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp in ['0', '1']:
qc, out = NOT(inp)
print('NOT with input',inp,'gives output',out)
display(qc.draw())
print('\n')
def XOR(inp1,inp2):
"""An XOR gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 1.
"""
qc = QuantumCircuit(2, 1)
qc.reset(range(2))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
# barrier between input state and gate operation
qc.barrier()
# this is where your program for quantum XOR gate goes
qc.cx(0, 1)
# barrier between input state and gate operation
qc.barrier()
qc.measure(1,0) # output from qubit 1 is measured
#We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
#Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = XOR(inp1, inp2)
print('XOR with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def AND(inp1,inp2):
"""An AND gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(2))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum AND gate goes
qc.ccx(0,1,2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('qasm_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc, shots=1, memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = AND(inp1, inp2)
print('AND with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def NAND(inp1,inp2):
"""An NAND gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output NAND circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum NAND gate goes
qc.ccx(0,1,2)
if inp=='1':
qc.x(2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('aer_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc,shots=1,memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = NAND(inp1, inp2)
print('NAND with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
def OR(inp1,inp2):
"""An OR gate.
Parameters:
inpt1 (str): Input 1, encoded in qubit 0.
inpt2 (str): Input 2, encoded in qubit 1.
Returns:
QuantumCircuit: Output XOR circuit.
str: Output value measured from qubit 2.
"""
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
# this is where your program for quantum OR gate goes
qc.cx(0, 2)
qc.cx(1, 2)
qc.barrier()
qc.measure(2, 0) # output from qubit 2 is measured
# We'll run the program on a simulator
backend = Aer.get_backend('aer_simulator')
# Since the output will be deterministic, we can use just a single shot to get it
job = backend.run(qc,shots=1,memory=True)
output = job.result().get_memory()[0]
return qc, output
## Test the function
for inp1 in ['0', '1']:
for inp2 in ['0', '1']:
qc, output = OR(inp1, inp2)
print('OR with inputs',inp1,inp2,'gives output',output)
display(qc.draw())
print('\n')
from qiskit import IBMQ
#IBMQ.save_account("a68a35747d4eccd1d58f275e637909987c789ce5c0edd8a4f43014672bf0301b54b28b1b5f44ba8ff87500777429e1e4ceb79621a6ba248d6cca6bca0e233d23", overwrite=True)
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider('ibm-q')
provider.backends()
import qiskit.tools.jupyter
# run this cell
backend = provider.get_backend('ibmq_quito')
qc_and = QuantumCircuit(3)
qc_and.ccx(0,1,2)
print('AND gate')
display(qc_and.draw())
print('\n\nTranspiled AND gate with all the required connectivity')
qc_and.decompose().draw()
from qiskit.tools.monitor import job_monitor
# run the cell to define AND gate for real quantum system
def AND(inp1, inp2, backend, layout):
qc = QuantumCircuit(3, 1)
qc.reset(range(3))
if inp1=='1':
qc.x(0)
if inp2=='1':
qc.x(1)
qc.barrier()
qc.ccx(0, 1, 2)
qc.barrier()
qc.measure(2, 0)
qc_trans = transpile(qc, backend, initial_layout=layout, optimization_level=3)
job = backend.run(qc_trans, shots=8192)
print(job.job_id())
job_monitor(job)
output = job.result().get_counts()
return qc_trans, output
backend
layout = [0, 1, 2]
output_all = []
qc_trans_all = []
prob_all = []
worst = 1
best = 0
for input1 in ['0','1']:
for input2 in ['0','1']:
qc_trans, output = AND(input1, input2, backend, layout)
output_all.append(output)
qc_trans_all.append(qc_trans)
prob = output[str(int( input1=='1' and input2=='1' ))]/8192
prob_all.append(prob)
print('\nProbability of correct answer for inputs',input1,input2)
print('{:.2f}'.format(prob) )
print('---------------------------------')
worst = min(worst,prob)
best = max(best, prob)
print('')
print('\nThe highest of these probabilities was {:.2f}'.format(best))
print('The lowest of these probabilities was {:.2f}'.format(worst))
print('Transpiled AND gate circuit for ibmq_vigo with input 0 0')
print('\nThe circuit depth : {}'.format (qc_trans_all[0].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[0].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[0]) )
qc_trans_all[0].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 0 1')
print('\nThe circuit depth : {}'.format (qc_trans_all[1].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[1].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[1]) )
qc_trans_all[1].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 1 0')
print('\nThe circuit depth : {}'.format (qc_trans_all[2].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[2].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[2]) )
qc_trans_all[2].draw()
print('Transpiled AND gate circuit for ibmq_vigo with input 1 1')
print('\nThe circuit depth : {}'.format (qc_trans_all[3].depth()))
print('# of nonlocal gates : {}'.format (qc_trans_all[3].num_nonlocal_gates()))
print('Probability of correct answer : {:.2f}'.format(prob_all[3]) )
qc_trans_all[3].draw()
|
https://github.com/Alfaxad/IBM_QC_Africa_2021
|
Alfaxad
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.providers.aer import QasmSimulator
backend = Aer.get_backend('statevector_simulator')
qc1 = QuantumCircuit(4)
# perform gate operations on individual qubits
qc1.x(0)
qc1.y(1)
qc1.z(2)
qc1.s(3)
# Draw circuit
qc1.draw()
# Plot blochshere
out1 = execute(qc1,backend).result().get_statevector()
plot_bloch_multivector(out1)
qc2 = QuantumCircuit(4)
# initialize qubits
qc2.x(range(4))
# perform gate operations on individual qubits
qc2.x(0)
qc2.y(1)
qc2.z(2)
qc2.s(3)
# Draw circuit
qc2.draw()
# Plot blochshere
out2 = execute(qc2,backend).result().get_statevector()
plot_bloch_multivector(out2)
qc3 = QuantumCircuit(4)
# initialize qubits
qc3.h(range(4))
# perform gate operations on individual qubits
qc3.x(0)
qc3.y(1)
qc3.z(2)
qc3.s(3)
# Draw circuit
qc3.draw()
# Plot blochshere
out3 = execute(qc3,backend).result().get_statevector()
plot_bloch_multivector(out3)
qc4 = QuantumCircuit(4)
# initialize qubits
qc4.x(range(4))
qc4.h(range(4))
# perform gate operations on individual qubits
qc4.x(0)
qc4.y(1)
qc4.z(2)
qc4.s(3)
# Draw circuit
qc4.draw()
# Plot blochshere
out4 = execute(qc4,backend).result().get_statevector()
plot_bloch_multivector(out4)
qc5 = QuantumCircuit(4)
# initialize qubits
qc5.h(range(4))
qc5.s(range(4))
# perform gate operations on individual qubits
qc5.x(0)
qc5.y(1)
qc5.z(2)
qc5.s(3)
# Draw circuit
qc5.draw()
# Plot blochshere
out5 = execute(qc5,backend).result().get_statevector()
plot_bloch_multivector(out5)
qc6 = QuantumCircuit(4)
# initialize qubits
qc6.x(range(4))
qc6.h(range(4))
qc6.s(range(4))
# perform gate operations on individual qubits
qc6.x(0)
qc6.y(1)
qc6.z(2)
qc6.s(3)
# Draw circuit
qc6.draw()
# Plot blochshere
out6 = execute(qc6,backend).result().get_statevector()
plot_bloch_multivector(out6)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/Alfaxad/IBM_QC_Africa_2021
|
Alfaxad
|
from qiskit import *
import numpy as np
from numpy import linalg as la
from qiskit.tools.monitor import job_monitor
import qiskit.tools.jupyter
qc = QuantumCircuit(1)
#### your code goes here
# z measurement of qubit 0
measure_z = QuantumCircuit(1,1)
measure_z.measure(0,0)
# x measurement of qubit 0
measure_x = QuantumCircuit(1,1)
# your code goes here
# y measurement of qubit 0
measure_y = QuantumCircuit(1,1)
# your code goes here
shots = 2**14 # number of samples used for statistics
sim = Aer.get_backend('qasm_simulator')
bloch_vector_measure = []
for measure_circuit in [measure_x, measure_y, measure_z]:
# run the circuit with a the selected measurement and get the number of samples that output each bit value
counts = execute(qc+measure_circuit, sim, shots=shots).result().get_counts()
# calculate the probabilities for each bit value
probs = {}
for output in ['0','1']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
bloch_vector_measure.append( probs['0'] - probs['1'] )
# normalizing the bloch sphere vector
bloch_vector = bloch_vector_measure/la.norm(bloch_vector_measure)
print('The bloch sphere coordinates are [{0:4.3f}, {1:4.3f}, {2:4.3f}]'
.format(*bloch_vector))
from kaleidoscope.interactive import bloch_sphere
bloch_sphere(bloch_vector, vectors_annotation=True)
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector( bloch_vector )
# circuit for the state Tri1
Tri1 = QuantumCircuit(2)
# your code goes here
# circuit for the state Tri2
Tri2 = QuantumCircuit(2)
# your code goes here
# circuit for the state Tri3
Tri3 = QuantumCircuit(2)
# your code goes here
# circuit for the state Sing
Sing = QuantumCircuit(2)
# your code goes here
# <ZZ>
measure_ZZ = QuantumCircuit(2)
measure_ZZ.measure_all()
# <XX>
measure_XX = QuantumCircuit(2)
# your code goes here
# <YY>
measure_YY = QuantumCircuit(2)
# your code goes here
shots = 2**14 # number of samples used for statistics
A = 1.47e-6 #unit of A is eV
E_sim = []
for state_init in [Tri1,Tri2,Tri3,Sing]:
Energy_meas = []
for measure_circuit in [measure_XX, measure_YY, measure_ZZ]:
# run the circuit with a the selected measurement and get the number of samples that output each bit value
qc = state_init+measure_circuit
counts = execute(qc, sim, shots=shots).result().get_counts()
# calculate the probabilities for each computational basis
probs = {}
for output in ['00','01', '10', '11']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
Energy_meas.append( probs['00'] - probs['01'] - probs['10'] + probs['11'] )
E_sim.append(A * np.sum(np.array(Energy_meas)))
# Run this cell to print out your results
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E_sim[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E_sim[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E_sim[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E_sim[3]))
# reduced plank constant in (eV) and the speed of light(cgs units)
hbar, c = 4.1357e-15, 3e10
# energy difference between the triplets and singlet
E_del = abs(E_sim[0] - E_sim[3])
# frequency associated with the energy difference
f = E_del/hbar
# convert frequency to wavelength in (cm)
wavelength = c/f
print('The wavelength of the radiation from the transition\
in the hyperfine structure is : {:.1f} cm'.format(wavelength))
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_athens')
# run this cell to get the backend information through the widget
backend
# assign your choice for the initial layout to the list variable `initial_layout`.
initial_layout =
qc_all = [state_init+measure_circuit for state_init in [Tri1,Tri2,Tri3,Sing]
for measure_circuit in [measure_XX, measure_YY, measure_ZZ] ]
shots = 8192
job = execute(qc_all, backend, initial_layout=initial_layout, optimization_level=3, shots=shots)
print(job.job_id())
job_monitor(job)
# getting the results of your job
results = job.result()
## To access the results of the completed job
#results = backend.retrieve_job('job_id').result()
def Energy(results, shots):
"""Compute the energy levels of the hydrogen ground state.
Parameters:
results (obj): results, results from executing the circuits for measuring a hamiltonian.
shots (int): shots, number of shots used for the circuit execution.
Returns:
Energy (list): energy values of the four different hydrogen ground states
"""
E = []
A = 1.47e-6
for ind_state in range(4):
Energy_meas = []
for ind_comp in range(3):
counts = results.get_counts(ind_state*3+ind_comp)
# calculate the probabilities for each computational basis
probs = {}
for output in ['00','01', '10', '11']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
Energy_meas.append( probs['00'] - probs['01'] - probs['10'] + probs['11'] )
E.append(A * np.sum(np.array(Energy_meas)))
return E
E = Energy(results, shots)
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E[3]))
from qiskit.ignis.mitigation.measurement import *
# your code to create the circuits, meas_calibs, goes here
meas_calibs, state_labels =
# execute meas_calibs on your choice of the backend
job = execute(meas_calibs, backend, shots = shots)
print(job.job_id())
job_monitor(job)
cal_results = job.result()
## To access the results of the completed job
#cal_results = backend.retrieve_job('job_id').result()
# your code to obtain the measurement filter object, 'meas_filter', goes here
results_new = meas_filter.apply(results)
E_new = Energy(results_new, shots)
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E_new[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E_new[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E_new[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E_new[3]))
# results for the energy estimation from the simulation,
# execution on a quantum system without error mitigation and
# with error mitigation in numpy array format
Energy_exact, Energy_exp_orig, Energy_exp_new = np.array(E_sim), np.array(E), np.array(E_new)
# Calculate the relative errors of the energy values without error mitigation
# and assign to the numpy array variable `Err_rel_orig` of size 4
Err_rel_orig =
# Calculate the relative errors of the energy values with error mitigation
# and assign to the numpy array variable `Err_rel_new` of size 4
Err_rel_new =
np.set_printoptions(precision=3)
print('The relative errors of the energy values for four bell basis\
without measurement error mitigation : {}'.format(Err_rel_orig))
np.set_printoptions(precision=3)
print('The relative errors of the energy values for four bell basis\
with measurement error mitigation : {}'.format(Err_rel_new))
|
https://github.com/conradhaupt/Qiskit-Bayesian-Inference-Module-QCA19-
|
conradhaupt
|
# Import major packages
import qiskit as qk
import qinfer as qf
import numpy as np
import matplotlib as mpl
# Qiskit imports for IQPE
from qiskit import IBMQ
from qiskit.aqua.algorithms.single_sample import IQPE,QPE
from qiskit.aqua.components import iqfts
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.aqua.algorithms import ExactEigensolver
from qiskit.aqua.components.initial_states import Custom
from qiskit import Aer,execute
from qiskit.aqua import QuantumInstance
from qiskit.providers.aer import noise
# QInfer imports for modelling the IQPE algorithm
from qinfer import distributions
from qinfer.smc import SMCUpdater # The QInfer Sequantial Monte-Carlo Sampler
from qinfer import FiniteOutcomeModel
# Tertiary imports
import matplotlib.pyplot as plt
import time
# Intial setup
IBMQ.load_account()
ibmqx_provider = IBMQ.get_provider(hub='ibm-q-wits', group='internal', project='default')
mpl.rc('text', usetex=True)
# Function definitions for the entire notebook
EPS = 1e-15
def chop(value):
if np.abs(value) <= EPS:
return 0
else:
return value
def radiandiff(a,b):
FULL_ROTATION = 2 * np.pi
return np.min(np.abs([a - b, b - a, a - b + FULL_ROTATION, b - a + FULL_ROTATION]))
def complexfromangle(angle):
real = chop(np.real(np.exp(1.j * angle)))
imag = chop(np.imag(np.exp(1.j * angle)))
return real,imag
# Set-up unitary with specified phase
angle = 4 * np.pi / 5
real,imag = complexfromangle(angle)
PAULI_DICT_ZZ = {
'paulis': [
{"coeff": {"imag": imag, "real": real}, "label": "ZZ"}
]
}
QUBIT_OP_ZZ = WeightedPauliOperator.from_dict(PAULI_DICT_ZZ)
eigen_results = ExactEigensolver(QUBIT_OP_ZZ,4).run()
eigen_value = eigen_results['eigvals'][0]
eigen_vector = eigen_results['eigvecs'][0]
print('Eigenvalues',eigen_results['eigvals'])
print('Phase is %.4f radians' %(angle))
# Setup initial state as eigenvector
state_in = Custom(QUBIT_OP_ZZ.num_qubits, state_vector=eigen_vector)
# Use QASM Simulator for testing
simulator = Aer.get_backend('qasm_simulator')
# Construct IQPE circuit and simulate
iqpe_builder = IQPE(
QUBIT_OP_ZZ,
state_in,
num_iterations=1,
num_time_slices=1,
expansion_mode='suzuki',
expansion_order=1,
shallow_circuit_concat=True)
# This is required to setup iqpe_builder so we can call construct_circuit() later on
iqpe_results = iqpe_circ = iqpe_builder.run(simulator,shots=1)
# Extend the QInfer FiniteOutcomeModel as IQPE has only one bit per measure
class IQPEModel(FiniteOutcomeModel):
def __init__(self):
super(IQPEModel, self).__init__()
# Number of parameters overwhich to conduct the Bayesian Inference
@property
def n_modelparams(self):
# phi
return 1
# Number of parameters that are needed for the simulation but are known.
# i.e. do not need to be inferred
@property
def expparams_dtype(self):
return [('theta','float64'), ('m','int64')]
@property
def is_n_outcomes_constant(self):
return True
# This function will verify whether the new inferred model parameters are valid for our model.
@staticmethod
def are_models_valid(modelparams):
# NOTE: If T2 is included as a model parameter, restrict it to positive
return np.logical_and(modelparams[:] >= -2*np.pi, modelparams[:]<=2*np.pi, modelparams[:] > 0).all(axis=1)
def n_outcomes(self, expparams):
return 2
# This function implements our probability for reading a 0 or 1 on our IQPE circuit.
# These equations are taken from [1] and are used by the updater/sampler to modify the posterior
def likelihood(self, outcomes, modelparams, expparams):
super(IQPEModel, self).likelihood(outcomes, modelparams, expparams)
# Probability of getting 0 for IQPE is
# P(0) = (1 + cos(M(theta - phi)))/2
# P(1) = (1 - cos(M(theta - phi)))/2
# This is the probability of getting a 0 with T2 depolarisation noise from [1].
# Not currently used.
# pr0 = np.exp(-expparams['m'] / expparams['T2']) * (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2 + (1 - np.exp(-expparams['m'] / expparams['T2']))/2
pr0 = (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2
return FiniteOutcomeModel.pr0_to_likelihood_array(outcomes, pr0)
# As our model parameter is an angle, ensure we have the circular mean for the distribution so we allow
# for wraparound. This is done by converting angles to x,y points on a unit circle, averaging over
# x and y independently, and then combining the resulting average x and y values to create a new
# vector. If the resulting magnitude is 0, there is no circular average as all points are equi-distant.
# The resulting angle is approximately the circular average of the collection of angles/phases.
class PhaseSMCUpdater(SMCUpdater):
@staticmethod
def particle_mean(weights,locations):
locs = [complexfromangle(a) for a in locations.flatten()]
loc_x = []
loc_y = []
for x,y in locs:
loc_x.append(x)
loc_y.append(y)
avg_x = np.average(loc_x,weights=weights)
avg_y = np.average(loc_y,weights=weights)
avg_angle = np.angle(avg_x + 1.j*avg_y)
avg_mag = np.sqrt(avg_x**2 + avg_y**2)
return avg_angle
# Bayesien Inference Parameters
N_PARTICLES = 5000 # number of samples for PhaseSMCUpdater
N_EXP = 25 # Number of times to choose a new theta
USE_QISKIT_QASM_SIMULATOR = True # Toggle parameter if we don't want to run any circuit simulations
SIM_N_SHOTS=1024 # number of shots for the circuit execution
# DType list for experiment metric logging
performance_dtype = [
('outcome', 'i1'),
('est_mean', 'f8'), ('est_cov_mat', 'f8'),
('true_err', 'f8'), ('resample_count', 'i8'),
('elapsed_time', 'f8'),
('like_count', 'i8'), ('sim_count', 'i8'),
('bme', 'f8'),
('var', 'f8'),
('bme_err', 'f8')
]
performance = np.empty((N_EXP), dtype=performance_dtype)
# Set-up initial prior and QInfer model
# prior = distributions.UniformDistribution([0, 2 * np.pi])
prior = distributions.NormalDistribution(angle,np.pi/4)
model = IQPEModel()
# Use IBMQX Rochester as the base device for the partially ideal noise-model. We
backend_device = ibmqx_provider.get_backend('ibmq_rochester')
partially_ideal_model = noise.device.basic_device_noise_model(
backend_device.properties(),gate_error=False,readout_error=False,
thermal_relaxation=False,standard_gates=True)
data_backend = Aer.get_backend('qasm_simulator')
# Create a Bayesian Inference Updater
updater = PhaseSMCUpdater(model, N_PARTICLES, prior,zero_weight_policy='skip')
# Set-up initial experimental parameters
THETA = prior.sample()[0][0]
M = 1
T2 = 100
posterior_marginal = []
##############################################
# Run for each experiment we defined earlier #
##############################################
for idx_exp in range(N_EXP):
# Define experimental parameters
expparams = np.array([(M,THETA)], dtype=model.expparams_dtype)
# Simulate IQPE circuit and get results for inference
circuit = iqpe_builder.construct_circuit(k=M,omega=THETA,measurement=True)
results = execute(circuit,simulator,shots=SIM_N_SHOTS,memory=True,noise_model=ideal_model)
counts = results.result().get_counts()
memory = results.result().get_memory()
# Start by simulating and recording the data. #
# Retrieve the outcome of the simulation either from the circuit simulation or a model simulation
if USE_QISKIT_QASM_SIMULATOR:
outcomes = np.array([[int(m) for m in memory]])
else:
outcomes = model.simulate_experiment(np.array([[angle]]),expparams,repeat=SIM_N_SHOTS)
outcomes = outcomes.reshape((1,outcomes.shape[0]))
model._sim_count = 0
model._call_count = 0
# Time the update process
# tic = toc = None
# tic = time.time()
# Update the posterior particles using the result of the circuit simulation
updater.batch_update(outcomes, expparams)
# performance[idx_exp]['elapsed_time'] = time.time() - tic
# Record the performance of this updater.
est_mean = updater.est_mean()
performance[idx_exp]['est_mean'] = est_mean
performance[idx_exp]['true_err'] = radiandiff(est_mean,angle) ** 2
performance[idx_exp]['est_cov_mat'] = updater.est_covariance_mtx()
performance[idx_exp]['resample_count'] = updater.resample_count
performance[idx_exp]['like_count'] = model.call_count
performance[idx_exp]['sim_count'] = model.sim_count
# Log
print(idx_exp,'/',N_EXP,'[',M,THETA,est_mean,']')
# Re-evaluate experiment parameters
uniform_draw_01 = np.random.uniform(low=0.05,high=0.95)
# uniform_draw_01 = np.random.uniform()
cumsum_particles = np.cumsum(updater.particle_weights)
draw_index = (cumsum_particles<= uniform_draw_01).argmin()
THETA = updater.particle_locations[draw_index]
# current_variance = updater.est_covariance_mtx()[0][0]
# M=idx_exp % 6 + 1
posterior_marginal.append((updater.posterior_marginal()))
print('Inference completed')
# Plot for each iteration
print(angle)
fig_iter = plt.figure()
ax_iter = plt.subplot(111)
for x in posterior_marginal:
# print(x[0],x[1])
_ = ax_iter.plot(x[0],x[1])
ax_iter.vlines(angle,ymin=0,ymax=2)
_ = ax_iter.legend(['Iter ' + str(x) for x in range(len(posterior_marginal))])
_ = plt.grid()
_ = plt.ylabel('PDF')
_ = plt.xlabel(r'$\phi$')
_ = plt.title('Posterior Marginal for some iterations')
ax_qinfer = updater.plot_posterior_marginal(smoothing=0)
plt.vlines(angle,ymin=0,ymax=3)
plt.grid()
_ = plt.ylabel('PDF')
_ = plt.xlabel(r'$\phi$')
_ = plt.title('IQPE Posterior')
fig_true_err = plt.figure()
ax_true_err = plt.subplot(111)
ax_true_err.semilogy(performance['true_err'])
ax_true_err.grid()
_ = plt.xlabel('Iteration count')
_ = plt.ylabel('True Error')
_ = plt.title('True Error over each Iteration')
fig_est_mean = plt.figure()
ax_est_mean = plt.subplot(111)
ax_est_mean.plot(performance['est_mean'])
ax_est_mean.grid()
ax_est_mean.hlines(angle,xmin=0,xmax=N_EXP)
_ = plt.xlabel('Iteration count')
_ = plt.ylabel('Estimated $\phi$ (mean)')
_ = plt.title('Estimated Mean for each Iteration')
|
https://github.com/conradhaupt/Qiskit-Bayesian-Inference-Module-QCA19-
|
conradhaupt
|
# Import major packages
import qiskit as qk
import qinfer as qf
import numpy as np
import matplotlib as mpl
# Qiskit imports for IQPE
from qiskit import IBMQ
from qiskit.aqua.algorithms.single_sample import IQPE,QPE
from qiskit.aqua.components import iqfts
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.aqua.algorithms import ExactEigensolver
from qiskit.aqua.components.initial_states import Custom
from qiskit import Aer,execute
from qiskit.aqua import QuantumInstance
from qiskit.providers.aer import noise
# QInfer imports for modelling the IQPE algorithm
from qinfer import distributions
from qinfer.smc import SMCUpdater # The QInfer Sequantial Monte-Carlo Sampler
from qinfer import FiniteOutcomeModel
# Tertiary imports
import matplotlib.pyplot as plt
import time
# Intial setup
IBMQ.load_account()
ibmqx_provider = IBMQ.get_provider(hub='ibm-q-wits', group='internal', project='default')
mpl.rc('text', usetex=True)
# Function definitions for the entire notebook
EPS = 1e-15
def chop(value):
if np.abs(value) <= EPS:
return 0
else:
return value
def radiandiff(a,b):
FULL_ROTATION = 2 * np.pi
return np.min(np.abs([a - b, b - a, a - b + FULL_ROTATION, b - a + FULL_ROTATION]))
def complexfromangle(angle):
real = chop(np.real(np.exp(1.j * angle)))
imag = chop(np.imag(np.exp(1.j * angle)))
return real,imag
# Set-up unitary with specified phase
angle = 4 * np.pi / 5
real,imag = complexfromangle(angle)
PAULI_DICT_ZZ = {
'paulis': [
{"coeff": {"imag": imag, "real": real}, "label": "ZZ"}
]
}
QUBIT_OP_ZZ = WeightedPauliOperator.from_dict(PAULI_DICT_ZZ)
eigen_results = ExactEigensolver(QUBIT_OP_ZZ,4).run()
eigen_value = eigen_results['eigvals'][0]
eigen_vector = eigen_results['eigvecs'][0]
print('Eigenvalues',eigen_results['eigvals'])
print('Phase is %.4f radians' %(angle))
# Setup initial state as eigenvector
state_in = Custom(QUBIT_OP_ZZ.num_qubits, state_vector=eigen_vector)
# Use QASM Simulator for testing
simulator = Aer.get_backend('qasm_simulator')
# Construct IQPE circuit and simulate
iqpe_builder = IQPE(
QUBIT_OP_ZZ,
state_in,
num_iterations=1,
num_time_slices=1,
expansion_mode='suzuki',
expansion_order=1,
shallow_circuit_concat=True)
# This is required to setup iqpe_builder so we can call construct_circuit() later on
iqpe_results = iqpe_circ = iqpe_builder.run(simulator,shots=1)
# Extend the QInfer FiniteOutcomeModel as IQPE has only one bit per measure
class IQPEModel(FiniteOutcomeModel):
def __init__(self):
super(IQPEModel, self).__init__()
# Number of parameters overwhich to conduct the Bayesian Inference
@property
def n_modelparams(self):
# phi
return 1
# Number of parameters that are needed for the simulation but are known.
# i.e. do not need to be inferred
@property
def expparams_dtype(self):
return [('theta','float64'), ('m','int64')]
@property
def is_n_outcomes_constant(self):
return True
# This function will verify whether the new inferred model parameters are valid for our model.
@staticmethod
def are_models_valid(modelparams):
# NOTE: If T2 is included as a model parameter, restrict it to positive
return np.logical_and(modelparams[:] >= -2*np.pi, modelparams[:]<=2*np.pi, modelparams[:] > 0).all(axis=1)
def n_outcomes(self, expparams):
return 2
# This function implements our probability for reading a 0 or 1 on our IQPE circuit.
# These equations are taken from [1] and are used by the updater/sampler to modify the posterior
def likelihood(self, outcomes, modelparams, expparams):
super(IQPEModel, self).likelihood(outcomes, modelparams, expparams)
# Probability of getting 0 for IQPE is
# P(0) = (1 + cos(M(theta - phi)))/2
# P(1) = (1 - cos(M(theta - phi)))/2
# This is the probability of getting a 0 with T2 depolarisation noise from [1].
# Not currently used.
# pr0 = np.exp(-expparams['m'] / expparams['T2']) * (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2 + (1 - np.exp(-expparams['m'] / expparams['T2']))/2
pr0 = (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2
return FiniteOutcomeModel.pr0_to_likelihood_array(outcomes, pr0)
# As our model parameter is an angle, ensure we have the circular mean for the distribution so we allow
# for wraparound. This is done by converting angles to x,y points on a unit circle, averaging over
# x and y independently, and then combining the resulting average x and y values to create a new
# vector. If the resulting magnitude is 0, there is no circular average as all points are equi-distant.
# The resulting angle is approximately the circular average of the collection of angles/phases.
class PhaseSMCUpdater(SMCUpdater):
@staticmethod
def particle_mean(weights,locations):
locs = [complexfromangle(a) for a in locations.flatten()]
loc_x = []
loc_y = []
for x,y in locs:
loc_x.append(x)
loc_y.append(y)
avg_x = np.average(loc_x,weights=weights)
avg_y = np.average(loc_y,weights=weights)
avg_angle = np.angle(avg_x + 1.j*avg_y)
avg_mag = np.sqrt(avg_x**2 + avg_y**2)
return avg_angle
# Bayesien Inference Parameters
N_PARTICLES = 5000 # number of samples for PhaseSMCUpdater
N_EXP = 25 # Number of times to choose a new theta
USE_QISKIT_QASM_SIMULATOR = True # Toggle parameter if we don't want to run any circuit simulations
SIM_N_SHOTS=1024 # number of shots for the circuit execution
# DType list for experiment metric logging
performance_dtype = [
('outcome', 'i1'),
('est_mean', 'f8'), ('est_cov_mat', 'f8'),
('true_err', 'f8'), ('resample_count', 'i8'),
('elapsed_time', 'f8'),
('like_count', 'i8'), ('sim_count', 'i8'),
('bme', 'f8'),
('var', 'f8'),
('bme_err', 'f8')
]
performance = np.empty((N_EXP), dtype=performance_dtype)
# Set-up initial prior and QInfer model
# prior = distributions.UniformDistribution([0, 2 * np.pi])
prior = distributions.NormalDistribution(angle,np.pi/4)
model = IQPEModel()
# Use IBMQX Rochester as the base device for the partially ideal noise-model. We
backend_device = ibmqx_provider.get_backend('ibmq_rochester')
partially_ideal_model = noise.device.basic_device_noise_model(
backend_device.properties(),gate_error=False,readout_error=False,
thermal_relaxation=False,standard_gates=True)
data_backend = Aer.get_backend('qasm_simulator')
# Create a Bayesian Inference Updater
updater = PhaseSMCUpdater(model, N_PARTICLES, prior,zero_weight_policy='skip')
# Set-up initial experimental parameters
THETA = prior.sample()[0][0]
M = 1
T2 = 100
posterior_marginal = []
memory_list = []
theta_list = []
##############################################
# Run for each experiment we defined earlier #
##############################################
for idx_exp in range(N_EXP):
# Define experimental parameters
expparams = np.array([(M,THETA)], dtype=model.expparams_dtype)
# Simulate IQPE circuit and get results for inference
circuit = iqpe_builder.construct_circuit(k=M,omega=THETA,measurement=True)
results = execute(circuit,simulator,shots=SIM_N_SHOTS,memory=True,noise_model=ideal_model)
counts = results.result().get_counts()
memory = results.result().get_memory()
memory_list.append(memory)
theta_list.append(THETA.flatten())
# Start by simulating and recording the data. #
# Retrieve the outcome of the simulation either from the circuit simulation or a model simulation
if USE_QISKIT_QASM_SIMULATOR:
outcomes = np.array([[int(m) for m in memory]])
else:
outcomes = model.simulate_experiment(np.array([[angle]]),expparams,repeat=SIM_N_SHOTS)
outcomes = outcomes.reshape((1,outcomes.shape[0]))
model._sim_count = 0
model._call_count = 0
# Time the update process
# tic = toc = None
# tic = time.time()
# Update the posterior particles using the result of the circuit simulation
updater.batch_update(outcomes, expparams)
# performance[idx_exp]['elapsed_time'] = time.time() - tic
# Record the performance of this updater.
est_mean = updater.est_mean()
performance[idx_exp]['est_mean'] = est_mean
performance[idx_exp]['true_err'] = radiandiff(est_mean,angle) ** 2
performance[idx_exp]['est_cov_mat'] = updater.est_covariance_mtx()
performance[idx_exp]['resample_count'] = updater.resample_count
performance[idx_exp]['like_count'] = model.call_count
performance[idx_exp]['sim_count'] = model.sim_count
# Log
print(idx_exp,'/',N_EXP,'[',M,THETA,est_mean,']')
# Re-evaluate experiment parameters
uniform_draw_01 = np.random.uniform(low=0.05,high=0.95)
# uniform_draw_01 = np.random.uniform()
cumsum_particles = np.cumsum(updater.particle_weights)
draw_index = (cumsum_particles<= uniform_draw_01).argmin()
THETA = updater.particle_locations[draw_index]
# current_variance = updater.est_covariance_mtx()[0][0]
# M=idx_exp % 6 + 1
posterior_marginal.append((updater.posterior_marginal()))
print('Inference completed')
# Plot for each iteration
print(angle)
fig_iter = plt.figure()
ax_iter = plt.subplot(111)
for x in posterior_marginal:
# print(x[0],x[1])
_ = ax_iter.plot(x[0],x[1])
ax_iter.vlines(angle,ymin=0,ymax=2)
_ = ax_iter.legend(['Iter ' + str(x) for x in range(len(posterior_marginal[0:10]))])
_ = plt.grid()
_ = plt.ylabel('Posterior')
_ = plt.xlabel(r'$\phi$')
_ = plt.title('Posterior Marginal for some iterations')
plt.savefig('iterative_posterior.png',dpi=300)
ax_qinfer = updater.plot_posterior_marginal(smoothing=0)
plt.vlines(angle,ymin=0,ymax=3)
plt.grid()
_ = plt.ylabel('Posterior')
_ = plt.xlabel(r'$\phi$')
_ = plt.title('IQPE Posterior')
plt.savefig('final_posterior.png',dpi=300)
fig_true_err = plt.figure()
ax_true_err = plt.subplot(111)
ax_true_err.semilogy(performance['true_err'])
ax_true_err.grid()
_ = plt.xlabel('Iteration count')
_ = plt.ylabel('True Error')
_ = plt.title('True Error over each Iteration')
plt.savefig('true_error.png',dpi=300)
fig_est_mean = plt.figure()
ax_est_mean = plt.subplot(111)
ax_est_mean.plot(performance['est_mean'])
ax_est_mean.grid()
ax_est_mean.hlines(angle,xmin=0,xmax=N_EXP)
_ = plt.xlabel('Iteration count')
_ = plt.ylabel('Estimated $\phi$ (mean)')
_ = plt.title('Estimated Mean for each Iteration')
plt.savefig('mean.png',dpi=300)
# Calculate the naive prediction of the IQPE phase, phi
E_i = memory_list
# Convert to integers
theta_i = theta_list
phi_i = []
for i,E in enumerate(E_i):
# print(i,E)
e = [int(v) for v in E]
# Naive sum
sum = 0
for v in e:
sum += v
p_i = sum / len(E)
# Inverse naive phi approximation using expected value from experimental results
phi = theta_i[i][0] - (np.arccos(1 - (2 * p_i))) / M
phi_i.append(phi)
# Plot the naive phi estimate
plt.plot(phi_i)
plt.grid()
plt.hlines(angle,xmin=0,xmax=25)
_ = plt.xlabel('Iteration Count')
_ = plt.ylabel(r'$\phi$')
_ = plt.title('Naive $\phi$ estimation using expectation values of experimental runs')
plt.savefig('naive.png',dpi=300)
# Disable TeX text rendering
mpl.rc('text', usetex=False)
# Render the IQPE circuit for M=1 and the last Theta used
circuit = iqpe_builder.construct_circuit(k=1,omega=THETA,measurement=True)
circ_fig = circuit.draw(output='mpl')
circ_fig.savefig('iqpe_1.png',dpi=300)
# Render the IQPE circuit for M=2 and the last Theta used
circuit = iqpe_builder.construct_circuit(k=2,omega=THETA,measurement=True)
circ_fig = circuit.draw(output='mpl')
circ_fig.savefig('iqpe_2.png',dpi=300)
|
https://github.com/conradhaupt/Qiskit-Bayesian-Inference-Module-QCA19-
|
conradhaupt
|
import qiskit as qk
import qinfer as qf
from qiskit.aqua.algorithms.single_sample import IQPE,QPE
from qiskit.aqua.components import iqfts
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.aqua.algorithms import ExactEigensolver
from qiskit.aqua.components.initial_states import Custom
import numpy as np
from qiskit import Aer,execute
from qiskit.aqua import QuantumInstance
# We need distributions to model priors.
from qinfer import distributions
# The noisy coin model has already been implmented, so let's import it here.
from qinfer.test_models import NoisyCoinModel
# Next, we need to import the sequential Monte Carlo updater class.
from qinfer.smc import SMCUpdater
# We'll be demonstrating approximate likelihood evaluation (ALE) as well.
from qinfer import ale
from qinfer import FiniteOutcomeModel
import matplotlib.pyplot as plt
from scipy.stats import circmean
import time
EPS = 1e-15
def chop(value):
if np.abs(value) <= EPS:
return 0
else:
return value
def radiandiff(a,b):
FULL_ROTATION = 2 * np.pi
return np.min(np.abs([a - b, b - a, a - b + FULL_ROTATION, b - a + FULL_ROTATION]))
# Set-up unitary with specified phase
angle = np.pi / 3
real = chop(np.real(np.exp(1.j * angle)))
imag = chop(np.imag(np.exp(1.j * angle)))
PAULI_DICT_ZZ = {
'paulis': [
{"coeff": {"imag": imag, "real": real}, "label": "ZZ"}
]
}
QUBIT_OP_ZZ = WeightedPauliOperator.from_dict(PAULI_DICT_ZZ)
eigen_results = ExactEigensolver(QUBIT_OP_ZZ,4).run()
eigen_value = eigen_results['eigvals'][0]
eigen_vector = eigen_results['eigvecs'][0]
print('Eigenvalues',eigen_results['eigvals'])
print('Phase is %.4f radians' %(angle))
# Setup initial state as eigenvector
state_in = Custom(QUBIT_OP_ZZ.num_qubits, state_vector=eigen_vector)
# Use QASM Simulator for testing
simulator = Aer.get_backend('qasm_simulator')
# Construct IQPE circuit and simulate
iqpe_builder = IQPE(
QUBIT_OP_ZZ,
state_in,
num_iterations=1,
num_time_slices=1,
expansion_mode='suzuki',
expansion_order=1,
shallow_circuit_concat=True)
# This is required to setup iqpe_builder so we can call construct_circuit() later on
iqpe_results = iqpe_circ = iqpe_builder.run(simulator,shots=1)
class IQPEModel(FiniteOutcomeModel):
def __init__(self):
super(IQPEModel, self).__init__()
## PROPERTIES ##
@property
def n_modelparams(self):
# phi
return 1 # one for just phi, two for phi and T2
@property
def expparams_dtype(self):
return [('theta','float64'), ('m','int64')]
@property
def is_n_outcomes_constant(self):
return True
## METHODS ##
@staticmethod
def are_models_valid(modelparams):
# NOTE: If T2 is included as a model parameter, restrict it to positive
return np.logical_and(modelparams[:] >= 0, modelparams[:]<=2*np.pi).all(axis=1)
def n_outcomes(self, expparams):
return 2
def likelihood(self, outcomes, modelparams, expparams):
# We first call the superclass method, which basically
# just makes sure that call count diagnostics are properly
# logged.
super(IQPEModel, self).likelihood(outcomes, modelparams, expparams)
# Probability of getting 0 for IQPE is
# P(0) = (1 + cos(M(theta - phi)))/2
# pr0 = np.exp(-expparams['m'] / expparams['T2']) * (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2 + (1 - np.exp(-expparams['m'] / expparams['T2']))/2
pr0 = (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2
# Concatenate over outcomes.
return FiniteOutcomeModel.pr0_to_likelihood_array(outcomes, pr0)
class PhaseSMCUpdater(SMCUpdater):
@staticmethod
def particle_mean(weights,locations):
weighted_values = np.multiply(weights, locations)
return circmean(weighted_values)
N_PARTICLES = 5000
N_EXP = 20
USE_QISKIT_QASM_SIMULATOR = False
SIM_N_SHOTS=4096
performance_dtype = [
('outcome', 'i1'),
('est_mean', 'f8'), ('est_cov_mat', 'f8'),
('true_err', 'f8'), ('resample_count', 'i8'),
('elapsed_time', 'f8'),
('like_count', 'i8'), ('sim_count', 'i8'),
('bme', 'f8'),
('var', 'f8'),
('bme_err', 'f8')
]
performance = np.empty((N_EXP), dtype=performance_dtype)
# Set-up initial prior and QInfer model
prior = distributions.UniformDistribution([0, 2 * np.pi])
# prior = distributions.NormalDistribution(np.pi,0.5)
model = IQPEModel()
# Set-up initial experimental parameters
THETA = prior.sample()[0][0]
M = 3
data_backend = Aer.get_backend('qasm_simulator')
# Create a Bayesian Inference Updater
updater = PhaseSMCUpdater(model, N_PARTICLES, prior)
# For each experiment we defined earlier
for idx_exp in range(N_EXP):
# Define experimental parameters
expparams = np.array([(M,THETA)], dtype=model.expparams_dtype)
# Simulate IQPE circuit and get results for inference
circuit = iqpe_builder.construct_circuit(k=M,omega=THETA,measurement=True)
results = execute(circuit,simulator,shots=SIM_N_SHOTS,memory=True)
counts = results.result().get_counts()
memory = results.result().get_memory()
# Start by simulating and recording the data.
# Retrieve the outcome of the simulation either from the circuit simulation or a model simulation
if USE_QISKIT_QASM_SIMULATOR:
outcomes = np.array([[int(m) for m in memory]])
else:
outcomes = model.simulate_experiment(np.array([[angle]]),expparams,repeat=SIM_N_SHOTS)
outcomes = outcomes.reshape((1,outcomes.shape[0]))
# performance['outcome'][idx_exp] = [outcomes]
# Reset the like_count and sim_count
# properties so that we can count how many were used
# by this update. Note that this is a hack;
# an appropriate method should be added to
# Simulatable.
model._sim_count = 0
model._call_count = 0
# Time the update process
# tic = toc = None
# tic = time.time()
# Update the posterior particles using the result of the circuit simulation
updater.batch_update(outcomes, expparams)
# performance[idx_exp]['elapsed_time'] = time.time() - tic
# Record the performance of this updater.
est_mean = updater.est_mean()
performance[idx_exp]['est_mean'] = est_mean
performance[idx_exp]['true_err'] = radiandiff(est_mean,angle) ** 2
performance[idx_exp]['est_cov_mat'] = updater.est_covariance_mtx()
performance[idx_exp]['resample_count'] = updater.resample_count
performance[idx_exp]['like_count'] = model.call_count
performance[idx_exp]['sim_count'] = model.sim_count
# Re-evaluate experiment parameters
uniform_draw_01 = np.random.uniform()
cumsum_particles = np.cumsum(updater.particle_weights)
draw_index = (cumsum_particles<= uniform_draw_01).argmin()
THETA = updater.particle_locations[draw_index]
current_variance = updater.est_covariance_mtx()[0][0]
# M modification scheme
min_M = 8 - int(np.mod(idx_exp,10)/2)
# min_M = 4
M = int(np.max([min_M,np.ceil(1.25/np.sqrt(current_variance))]))
print(min_M,M,THETA)
print('Inference completed')
plot = updater.plot_posterior_marginal()
|
https://github.com/conradhaupt/Qiskit-Bayesian-Inference-Module-QCA19-
|
conradhaupt
|
import qiskit as qk
import qinfer as qf
from qiskit.aqua.algorithms.single_sample import IQPE,QPE
from qiskit.aqua.components import iqfts
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.aqua.algorithms import ExactEigensolver
from qiskit.aqua.components.initial_states import Custom
import numpy as np
from qiskit import Aer,execute
from qiskit.aqua import QuantumInstance
# We need distributions to model priors.
from qinfer import distributions
# The noisy coin model has already been implmented, so let's import it here.
from qinfer.test_models import NoisyCoinModel
# Next, we need to import the sequential Monte Carlo updater class.
from qinfer.smc import SMCUpdater
# We'll be demonstrating approximate likelihood evaluation (ALE) as well.
from qinfer import ale
from qinfer import FiniteOutcomeModel
import matplotlib.pyplot as plt
from scipy.stats import circmean
EPS = 1e-15
def chop(value):
if np.abs(value) <= EPS:
return 0
else:
return value
print(angle)
angle = np.pi / 3
real = chop(np.real(np.exp(1.j * angle)))
imag = chop(np.imag(np.exp(1.j * angle)))
PAULI_DICT_ZZ = {
'paulis': [
{"coeff": {"imag": imag, "real": real}, "label": "ZZ"}
]
}
QUBIT_OP_ZZ = WeightedPauliOperator.from_dict(PAULI_DICT_ZZ)
eigen_results = ExactEigensolver(QUBIT_OP_ZZ,4).run()
eigen_value = eigen_results['eigvals'][0]
eigen_vector = eigen_results['eigvecs'][0]
eigen_results
state_in = Custom(QUBIT_OP_ZZ.num_qubits, state_vector=eigen_vector)
simulator = Aer.get_backend('qasm_simulator')
iqpe_builder = IQPE(
QUBIT_OP_ZZ,
state_in,
num_iterations=6,
num_time_slices=1,
expansion_mode='suzuki',
expansion_order=3,
shallow_circuit_concat=True)
iqpe_results = iqpe_circ = iqpe_builder.run(simulator,shots=2048)
iqpe_results
output_results = iqpe_results['top_measurement_label']
output_results
iqpe_results
class IQPEModel(FiniteOutcomeModel):
def __init__(self):
super(IQPEModel, self).__init__()
## PROPERTIES ##
@property
def n_modelparams(self):
# phi
return 1
@property
def expparams_dtype(self):
# return [('theta','float64'), ('m','int64'),('T2','float64')]
return [('theta','float64'), ('m','int64')]
@property
def is_n_outcomes_constant(self):
return True
## METHODS ##
@staticmethod
def are_models_valid(modelparams):
return np.logical_and(modelparams[:] >= 0, modelparams[:]<=2*np.pi).all(axis=1)
def n_outcomes(self, expparams):
return 2
def likelihood(self, outcomes, modelparams, expparams):
# We first call the superclass method, which basically
# just makes sure that call count diagnostics are properly
# logged.
super(IQPEModel, self).likelihood(outcomes, modelparams, expparams)
# Probability of getting 0 for QPE is
# P(0) = (1 + cos(M(theta - phi)))/2
# pr0 = np.exp(-expparams['m'] / expparams['T2']) * (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2 + (1 - np.exp(-expparams['m'] / expparams['T2']))/2
pr0 = (1 + np.cos(expparams['m'] * (expparams['theta'] - modelparams[:]))) / 2
# Concatenate over outcomes.
return FiniteOutcomeModel.pr0_to_likelihood_array(outcomes, pr0)
N_PARTICLES = 5000
N_EXP = 20
N_TRIALS = 1
prior = distributions.UniformDistribution([0, 2 * np.pi])
# prior = distributions.NormalDistribution(np.pi,0.5)
model = IQPEModel()
performance_dtype = [
('outcome', 'i1'),
('est_mean', 'f8'), ('est_cov_mat', 'f8'),
('true_err', 'f8'), ('resample_count', 'i8'),
('elapsed_time', 'f8'),
('like_count', 'i8'), ('sim_count', 'i8'),
('bme', 'f8'),
('var', 'f8'),
('bme_err', 'f8')
]
performance = np.empty((N_TRIALS, N_EXP), dtype=performance_dtype)
true_params = np.empty((N_TRIALS, model.n_modelparams))
import time
def radiandiff(a,b):
FULL_ROTATION = 2 * np.pi
return np.min(np.abs([a - b, b - a, a - b + FULL_ROTATION, b - a + FULL_ROTATION]))
THETA = np.pi/3
# M = np.linspace(1,5)
# n = 2
# expected_bit = np.float64(output_results[-n])
M = 3
T2 = 100
# expparams = np.array([(M,THETA,T2)], dtype=model.expparams_dtype)
expparams = np.array([(M,THETA)], dtype=model.expparams_dtype)
class PhaseSMCUpdater(SMCUpdater):
@staticmethod
def particle_mean(weights,locations):
weighted_values = np.multiply(weights, locations)
return circmean(weighted_values)
simulator = Aer.get_backend('qasm_simulator')
for idx_trial in range(N_TRIALS):
# First, make new updaters using the constructors
# defined above.
updater = PhaseSMCUpdater(model, N_PARTICLES, prior)
# # Sample true set of modelparams.
# truemp = prior.sample()
# true_params[idx_trial, :] = truemp
# Now loop over experiments, updating each of the
# updaters with the same data, so that we can compare
# their estimation performance.
print(idx_trial)
circuit = iqpe_builder.construct_circuit(k=M,omega=THETA,measurement=True)
results = execute(circuit,simulator,shots=4096,memory=True)
counts = results.result().get_counts()
memory = results.result().get_memory()
print(counts)
for idx_exp in range(N_EXP):
# Make a short hand for indexing the current simulation
# and experiment.
idxs = np.s_[idx_trial, idx_exp]
# Start by simulating and recording the data.
#########################################
#########################################
#########################################
#########################################
#########################################
#########################################
#########################################
#########################################
USE_QISKIT_QASM_SIMULATOR = False
if USE_QISKIT_QASM_SIMULATOR:
outcome = int(memory[idx_exp])
else:
outcome = model.simulate_experiment(np.array([[angle]]),expparams)
#########################################
#########################################
#########################################
#########################################
#########################################
#########################################
#########################################
#########################################
performance['outcome'][idxs] = outcome
# print(outcome)
# Reset the like_count and sim_count
# properties so that we can count how many were used
# by this update. Note that this is a hack;
# an appropriate method should be added to
# Simulatable.
model._sim_count = 0
model._call_count = 0
# Time the actual update.
tic = toc = None
tic = time.time()
updater.update(outcome, expparams)
performance[idxs]['elapsed_time'] = time.time() - tic
# Record the performance of this updater.
# weighted_values = np.multiply(updater.particle_weights, updater.particle_locations)
# est_mean = circmean(weighted_values)
est_mean = updater.est_mean()
performance[idxs]['est_mean'] = est_mean
performance[idxs]['true_err'] = radiandiff(est_mean,angle) ** 2
# performance[idxs]['true_err'] = np.abs(est_mean - truemp) ** 2
performance[idxs]['est_cov_mat'] = updater.est_covariance_mtx()
performance[idxs]['resample_count'] = updater.resample_count
performance[idxs]['like_count'] = model.call_count
performance[idxs]['sim_count'] = model.sim_count
# Finally, record the ideal stats.
# performance[idxs]['bme'], performance[idxs]['var'] = exactBME(
# idx_exp + 1 - np.sum(performance[idxs]['outcome']), idx_exp + 1,
# ALPHA, BETA
# )
# performance[idxs]['bme'],
# performance[idxs]['bme_err'] = np.abs(performance[idxs]['bme'] - truemp) ** 2
print('Done!')
# plt.semilogy(np.mean(performance['true_err'],axis=0))
updater.plot_posterior_marginal()
counts
def averageofcounts(counts):
# print(dir(counts))
sum = 0
count = 0
for k,v in counts.items():
key_val = int(k)
sum += key_val * v
count += v
return sum / count
model = IQPEModel()
n_meas = 25
prior = distributions.UniformDistribution([0, 1])
updater = PhaseSMCUpdater(model, 2000, prior)
heuristic = qf.ExpSparseHeuristic(updater)
true_params = 1
est_hist = []
for m in range(25):
print('Infering for m=%d' % (m))
THETA = np.pi
M = 4
T2 = 100
experiment = np.array([(M,THETA,T2)], dtype=model.expparams_dtype)
# experiment = np.array([(m, n_meas)], dtype=model.expparams_dtype)
# datum = model.simulate_experiment(true_params, experiment)
circuit = iqpe_builder.construct_circuit(k=M,omega=THETA,measurement=True)
n_shots = 4096
results = execute(circuit,simulator,shots=n_shots)
counts = results.result().get_counts()
datum = averageofcounts(counts)
# print(datum)
updater.update(datum, experiment)
est_hist.append(updater.est_mean())
plt.plot(est_hist, label='Est.')
plt.hlines(true_params, 0, 20, label='True')
plt.legend(ncol=2)
plt.xlabel('# of Times Sampled (25 measurements/ea)')
plt.ylabel('Measured value')
|
https://github.com/junayed-hasan/Quantum-Machine-Learning-Qiskit-PyTorch
|
junayed-hasan
|
from qiskit import *
%matplotlib inline
import numpy as np
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.draw('mpl')
from qiskit.visualization import plot_state_hinton
sim = Aer.get_backend('statevector_simulator') # qasm_simulator, statevector_simulator, unitary_simulator
result = execute(qc, backend=sim).result()
state = result.get_statevector(qc)
plot_state_hinton(state)
from qiskit.visualization import *
from matplotlib import style
style.use('bmh')
style.use('dark_background')
plot_state_city(state)
plot_state_paulivec(result.get_statevector(qc))
from qiskit import IBMQ
IBMQ.load_account()
from qiskit.tools.monitor import job_monitor
provider = IBMQ.get_provider(hub='ibm-q', group='open')
backend = provider.get_backend('ibmq_santiago')
job = execute(qc, backend=backend, shots=8192)
job_monitor(job)
from qiskit.visualization import plot_histogram
result = job.result()
plot_histogram(result.get_counts(qc))
|
https://github.com/AntonSimen06/qGAN
|
AntonSimen06
|
from qiskit import *
from qiskit.visualization import *
import matplotlib.pyplot as plt
import numpy as np
import math
simulator = BasicAer.get_backend('qasm_simulator')
prob_distr = [8, 40, 35, 20, 15, 10, 5, 5]
#normalization
prob_distr = [k/sum(prob_distr) for k in prob_distr]
plt.bar(range(len(prob_distr)),prob_distr)
def ansatz(param, num_layers):
num_q = 3
qc = QuantumCircuit(num_q, num_q)
for j in range(num_layers):
for i in range(num_q):
qc.ry(param[i + j*num_q], i)
if j < num_layers-1:
qc.cx(0,1)
qc.cx(1,2)
qc.cx(2,0)
qc.barrier()
qc.measure(range(num_q), range(num_q))
return qc
ansatz(param = np.random.uniform(0, np.pi, 9), num_layers=3).draw('mpl',fold=-1)
num_layers = 5
def loss_function(params):
num_shots=1024
circ = ansatz(param=params, num_layers=num_layers)
counts = execute(circ, backend=simulator, shots=num_shots).result().get_counts(circ)
strings = ['000','001','010','011','100','101','110','111']
for i in strings:
if i not in counts:
counts[i] = 0
p = [counts[string]/num_shots for string in strings]
"""
cross_entropy = 0
for i in range(len(p)):
if p[i]>0:
cross_entropy -= prob_distr[i]*math.log2(p[i])
return cross_entropy
"""
return sum([(p[i] - prob_distr[i])**2 for i in range(len(prob_distr))])
#return sum([abs(p[i] - prob_distr[i]) for i in range(len(prob_distr))])
#return sum([ prob_distr[i]*math.log2(p[i]) for i in range(len(prob_distr))])
from qiskit.algorithms.optimizers import COBYLA,SLSQP,SPSA
optimizer = COBYLA(250)
ret = optimizer.optimize(num_vars=num_params, objective_function=loss_function, initial_point=np.ones(num_params))
num_shots = 1024
trained_circ = ansatz(param=ret[0], num_layers=num_layers)
counts = execute(trained_circ, backend=simulator, shots=num_shots).result().get_counts(trained_circ)
strings = ['000','001','010','011','100','101','110','111']
for k in strings:
if k not in counts:
counts[k]=0
counts = [counts[i]/1024 for i in strings]
plt.plot(range(len(counts)),counts, color='r')
plt.bar(range(len(prob_distr)), prob_distr)
plt.legend(["qGAN approx.", "Reference"])
plt.title("Probability distributions")
plt.grid()
|
https://github.com/mberna/qce23-qiskit-runtime-primitives-tutorial
|
mberna
|
# instantiate runtime service
from qiskit_ibm_runtime import QiskitRuntimeService
QiskitRuntimeService.save_account(channel="ibm_quantum", token="MY_IBM_QUANTUM_TOKEN")
service = QiskitRuntimeService(channel="ibm_quantum")
# import required libraries and instantiate runtime service
from qiskit_ibm_runtime import Session, Estimator, Options
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
# create circuits and observables
psi1 = RealAmplitudes(num_qubits=2, reps=2)
psi2 = RealAmplitudes(num_qubits=2, reps=3)
H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
H2 = SparsePauliOp.from_list([("IZ", 1)])
H3 = SparsePauliOp.from_list([("ZI", 1), ("ZZ", 1)])
psi1.decompose().draw(output='mpl')
psi2.decompose().draw(output='mpl')
import numpy as np
# generate random theta params
np.random.seed(0)
theta1 = np.random.rand(6) * np.pi
theta2 = np.random.rand(8) * np.pi
theta3 = np.random.rand(6) * np.pi
print(theta1)
print(theta2)
print(theta3)
options = Options()
options.execution.shots = 100
estimator = Estimator(backend="ibmq_qasm_simulator", options=options)
from qiskit_ibm_runtime import Options
options = Options(resilience_level=0)
options.execution.shots = 1024
estimator = Estimator(backend="ibmq_qasm_simulator", options=options)
# calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
psi1_H1 = estimator.run(circuits=[psi1], observables=[H1],
parameter_values=[theta1])
print(psi1_H1.result())
# You can invoke run() multiple times!
# calculate [ <psi1(theta1)|H2|psi1(theta1)>, <psi1(theta1)|H3|psi1(theta1)> ]
psi1_H23 = estimator.run(circuits=[psi1, psi1], observables=[H2, H3],
parameter_values=[theta1]*2)
print(psi1_H23.result())
# Ex. 1: Calculate [ <psi2(theta2)|H2|psi2(theta2)> ]
# psi2_H2 = ...
# Ex. 2 calculate [ <psi1(theta1)|H1|psi1(theta1)>,
# <psi2(theta2)|H2|psi2(theta2)>,
# <psi1(theta3)|H3|psi1(theta3)> ]
# psi12_H23 = ...
# Ex. 3: use optimization_level 3
options = Options()
# options... # hint: use autocomplete
with Session(service=service, backend="ibmq_qasm_simulator") as session:
estimator = Estimator(session=session, options=options)
theta4 = [0, 1, 1, 2, 3, 5]
# calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
psi1_H1 = estimator.run(circuits=[psi1], observables=[H1], parameter_values=[theta4])
print(psi1_H1.result())
# Ex. 4: Apply ZNE to the following example
# Remeber ZNE is enabled when resilience level is 2
options = Options()
# options... # hint: use autocomplete
estimator = Estimator(backend="ibmq_qasm_simulator", options=options)
theta4 = [0, 1, 1, 2, 3, 5]
psi1_H1 = estimator.run(circuits=[psi1], observables=[H1], parameter_values=[theta4])
print(psi1_H1.result())
from qiskit import QuantumCircuit
from qiskit_ibm_runtime import Sampler
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
sampler = Sampler(backend="ibmq_qasm_simulator") # Not passing any options, uses M3
job = sampler.run(circuits=bell)
print(job.result())
# You can invoke run() multiple times.
job = sampler.run(circuits=bell)
print(job.result())
|
https://github.com/mberna/qce23-qiskit-runtime-primitives-tutorial
|
mberna
|
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, Options
# Initialize service
service = QiskitRuntimeService(channel="ibm_quantum")
# Choose a backend to run on (you can change this to another backend that is available)
backend = service.get_backend("ibm_canberra")
from pprint import pprint
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
import qiskit.quantum_info as qi
# Specify a 1D chain of device qubits to use
initial_layout = [2, 3, 5, 8]
num_qubits = len(initial_layout)
# Parameterized Trotter layer
par_rx = Parameter("a")
par_rzz = Parameter("b")
trotter_layer = QuantumCircuit(num_qubits)
trotter_layer.rx(par_rx, range(num_qubits))
for i in range(num_qubits // 2):
trotter_layer.rzz(par_rzz, 2 * i, 1 + 2 * i)
for i in range(1, num_qubits // 2 + bool(num_qubits % 2)):
trotter_layer.rzz(par_rzz, 2 * i - 1, 2 * i)
# Run for 1 to 5 steps
trotter_steps = [1, 2, 3, 4, 5]
trotter_circuit_list = []
for i in trotter_steps:
trotter_circuit = QuantumCircuit(num_qubits)
for _ in range(i):
trotter_circuit = trotter_circuit.compose(trotter_layer)
trotter_circuit_list.append(trotter_circuit)
print(f'Trotter circuit with {i} Trotter steps')
display(trotter_circuit.draw(fold=-1))
import numpy as np
import qiskit.quantum_info as qi
# Hamiltonian parameters
params = [0.1, -0.2]
params_list = [params] * len(trotter_circuit_list)
# Observable
Zs = np.eye(num_qubits, dtype=bool)
Xs = np.zeros((num_qubits, num_qubits), dtype=bool)
obs = qi.SparsePauliOp(qi.PauliList.from_symplectic(Zs, Xs), 1/num_qubits)
obs_list = [obs]*len(trotter_circuit_list)
# If True run jobs, this can be set to false to avoid re-running jobs when re-running the notebok
# If you are loading saved jobs
run_sim_jobs = True
run_device_jobs = False
# Store all jobs
if run_sim_jobs or run_device_jobs:
jobs = {}
jobs_ids = {}
import numpy as np
import scipy.linalg as la
import qiskit.quantum_info as qi
from qiskit_aer.noise import NoiseModel, coherent_unitary_error
backend_simulator = service.get_backend("ibmq_qasm_simulator")
# Noise model with measure noise, depolarizing and thermal relaxation gate noise
noise_model_rodept1 = NoiseModel.from_backend(backend())
# Noise model without measure noise, with depolarizing and thermal relaxation gate noise
noise_model_dept1 = NoiseModel.from_backend(backend(), readout_error=False, gate_error=True, thermal_relaxation=True)
# Noise model with measure noise and with depolarizing gate noise
noise_model_rodep = NoiseModel.from_backend(backend(), readout_error=True, gate_error=True, thermal_relaxation=False)
# Noise model with only measure noise
noise_model_ro = NoiseModel.from_backend(backend(), readout_error=True, gate_error=False, thermal_relaxation=False)
# Noise model with only depolarizing gate noise
noise_model_dep = NoiseModel.from_backend(backend(), readout_error=False, gate_error=True, thermal_relaxation=False)
# Noise model with only coherent CX gate noise
noise_model_coh = NoiseModel.from_backend(backend(), readout_error=False, gate_error=False, thermal_relaxation=False)
# Noise model with measure noise and coherent CX gate noise
noise_model_rocoh = NoiseModel.from_backend(backend(), readout_error=True, gate_error=False, thermal_relaxation=False)
# Construct the coherent CX noise model errors based on the process fidelity so that they have the
# same process fidelity as the depolarizing errors of the depolarizing noise model
for qubits, error in noise_model_dep._local_quantum_errors['cx'].items():
cos2 = qi.process_fidelity(error)
theta = np.arccos(np.sqrt(cos2))
cx_err = coherent_unitary_error(la.expm(-1j * 0.05 * qi.Operator.from_label("ZZ")))
noise_model_coh.add_quantum_error(cx_err, "cx", qubits)
noise_model_rocoh.add_quantum_error(cx_err, "cx", qubits)
# Labels for noise models
noise_labels = [
"Ideal",
"Measure + Depol + Relax",
"Depol + Relax",
"Measure + Depol",
"Measure",
"Depol",
"Measure + Coherent",
"Coherent",
]
# List of labeled noise models
noise_models = [
None,
noise_model_rodept1,
noise_model_dept1,
noise_model_rodep,
noise_model_ro,
noise_model_dep,
noise_model_rocoh,
noise_model_coh,
]
# Label for option configuration
label_mit = "Unmitigated"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
# Run jobs
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX wo Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX w Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX, Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX wo Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE wo TREX, Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.twirling.measure = False
options.resilience.measure_noise_mitigation = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "PEC"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 3
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "Unmitigated"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX wo Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX w Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX, Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX wo Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE wo TREX, Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.twirling.measure = False
options.resilience.measure_noise_mitigation = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "PEC"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 3
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
pprint(jobs_ids)
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
# Configure MPL for plotting
plt.rcParams.update({"text.usetex": True})
plt.rcParams["figure.figsize"] = (6, 4)
mpl.rcParams["figure.dpi"] = 200
load_sim_jobs = True
load_device_jobs = True
from qiskit_ibm_runtime import QiskitRuntimeService
# Re-initialize service if note book has been restarted since jobs ran
service = QiskitRuntimeService(channel="ibm_quantum")
jobs_ids = # Paste job IDs dict here
# Load jobs from job ids
jobs = {}
for label_mit, jids in jobs_ids.items():
jobs[label_mit] = {}
for label_noise, jid in jids.items():
if (label_noise == "Real Device" and load_device_jobs) or (label_noise != "Real Device" and load_sim_jobs):
jobs[label_mit][label_noise] = service.job(jid)
# Extract expectation value means and standard errors
means_mit = {}
stderrs_mit = {}
for label_mit, jobs_mit in jobs.items():
means_mit[label_mit] = {}
stderrs_mit[label_mit] = {}
for label_noise, job in jobs_mit.items():
_means = None
_stderrs = None
if job.done():
result = job.result()
_means = np.array(result.values)
_stderrs = np.array([metadata["standard_error"] for metadata in result.metadata])
print(f"LOADED \t| {label_mit}\t| {label_noise}")
else:
print(f"{job.status().name}\t| {label_mit}\t| {label_noise}")
means_mit[label_mit][label_noise] = _means
stderrs_mit[label_mit][label_noise] = _stderrs
# Prefix for saving figures
fig_prefix = "estimator_trotter_6q"
# Organize mitigation method labels for plotting
labels_mit = [
'Unmitigated',
'Gate Twirling',
'TREX w Gate Twirling',
'TREX wo Gate Twirling',
'ZNE wo TREX, Gate Twirling',
'ZNE w TREX wo Gate Twirling',
'ZNE w TREX, Gate Twirling',
'PEC',
]
# Organize noise model labels for plotting
labels_noise = [
'Ideal',
'Real Device',
'Measure',
'Depol',
'Depol + Relax',
'Coherent',
'Measure + Depol',
'Measure + Depol + Relax',
'Measure + Coherent',
]
# Generate subplots
fig, axs = plt.subplots(3, 3, sharex=True, sharey=True, figsize=(10, 10))
# Flatten the array of axes for easy iteration
axs = axs.ravel()
# Add error bar plots to each subplot
for label_noise in labels_noise:
if label_noise == "Real Device":
axs[0].plot([5], [0], 's-', c="red", label=label_noise)
elif label_noise == "Ideal":
continue
else:
axs[0].plot([5], [0], 'o--', label=label_noise)
axs[0].legend()
for ax, label_mit in zip(axs[1:], labels_mit):
means = means_mit[label_mit]
stderrs = stderrs_mit[label_mit]
for label_noise in labels_noise:
if label_noise != "Ideal" and means[label_noise] is not None and means["Ideal"] is not None:
ys = means["Ideal"] - means[label_noise]
yerrs = stderrs["Ideal"] + stderrs[label_noise]
xs = 1 + np.arange(len(ys))
if label_noise == "Real Device":
ax.errorbar(xs, ys, yerrs, fmt = 's-', c="red", capsize=4, label=label_noise)
else:
ax.errorbar(xs, ys, yerrs, fmt = 'o--', capsize=4, label=label_noise)
ax.plot(xs, np.zeros_like(xs), ":", c="black")
ax.set_title(label_mit)
ax.set_xticks(xs)
plt.tight_layout()
plt.savefig(f"{fig_prefix}_mit_vs_noise.pdf")
plt.show()
# Generate subplots
fig, axs = plt.subplots(3, 3, sharex=True, sharey=True, figsize=(10, 10))
# Flatten the array of axes for easy iteration
axs = axs.ravel()
# Add error bar plots to each subplot
for ax, label_noise in zip(axs, labels_noise):
for label_mit in labels_mit:
means = means_mit[label_mit]
stderrs = stderrs_mit[label_mit]
if means[label_noise] is not None and means["Ideal"] is not None:
ys = means["Ideal"] - means[label_noise]
yerrs = stderrs["Ideal"] + stderrs[label_noise]
xs = 1 + np.arange(len(ys))
if label_mit == "Unmitigated":
ax.errorbar(xs, ys, yerrs, fmt = 's-', capsize=4, label=label_mit)
else:
ax.errorbar(xs, ys, yerrs, fmt = 'o--', capsize=4, label=label_mit)
ax.plot(xs, np.zeros_like(xs), ":", c="black")
if label_noise == "Real Device":
title = label_noise
else:
title = f"{label_noise} Sim"
ax.set_title(title)
ax.set_xticks(xs)
if label_noise == "Ideal":
ax.legend()
plt.tight_layout()
plt.savefig(f"{fig_prefix}_noise_vs_mit.pdf")
plt.show()
|
https://github.com/LFL-Lab/metal-library
|
LFL-Lab
|
# Qiskit Metal imports
import qiskit_metal as metal
from ... import OpenToGround
from ... import RouteMeander
# Custom Components imports
from metal_library.components.inductive_coupler import InductiveCoupler
class QubitCavity():
def __init__(self, design, options: dict component_name: str, )
TransmonCross(design, "transmon", options=options)
return design
|
https://github.com/LFL-Lab/metal-library
|
LFL-Lab
|
import metal_library as mlib
print(mlib.supported_components)
reader = mlib.Reader(component_name='TransmonCross')
print(reader)
reader.component_types
reader.get_characteristic_info(component_type="QubitOnly");
reader.get_characteristic_info(component_type="QubitCavity");
reader.get_characteristic_info(component_type="QubitDriveline");
reader = mlib.Reader(component_name='TransmonCross')
reader.read_library(component_type='QubitOnly')
#### REMINDER: don't skip the previous cell!
selector = mlib.Selector(reader)
print(selector)
# You can find the supported metrics here...
selector.__supported_metrics__
indexes, chars, best_geoms = selector.find_closest(target_params={"Qubit_Frequency_GHz": 5,
"Qubit_Anharmonicity_MHz": 200},
num_top=3,
metric="Euclidian",
display=True)
%load_ext autoreload
%autoreload 2
# Qiskit Metal imports
import qiskit_metal as metal
from qiskit_metal import designs, draw
from qiskit_metal import MetalGUI, Dict
design = designs.DesignPlanar()
gui = MetalGUI(design)
reader.component_name
from qiskit_metal.qlibrary.qubits.transmon_cross import TransmonCross
# Parsing the best geometries
best_options = best_geoms[0]
second_best_options = best_geoms[1]
third_best_options = best_geoms[2]
# and so on.. so on...
TransmonCross(design, "transmon", options=best_options)
gui.rebuild()
gui.zoom_on_components(['transmon'])
gui.screenshot()
reader = mlib.Reader(component_name='TransmonCross')
reader.read_library(component_type='QubitCavity') # Note, we've change it from "QubitOnly" -> "QubitCavity"
selector = mlib.Selector(reader)
indexes, chars, best_geoms = selector.find_closest(target_params={"Qubit_Frequency_GHz": 5,
"Qubit_Anharmonicity_MHz": 200,
"Cavity_Frequency_GHz": 7,
"Coupling_Strength_MHz": 70,
"Cavity_Wavelength": "half", # acceptable inputs ["half", "quarter"], refers to wavelength of resonator
"Feedline_Coupling": 'capacitive' #acceptable inputs ["capacitive", "inductive"], refers to
}
num_top=3,
metric="Euclidian",
display=True)
%load_ext autoreload
%autoreload 2
# Qiskit Metal imports
import qiskit_metal as metal
from qiskit_metal import designs, draw
from qiskit_metal import MetalGUI, Dict
design = designs.DesignPlanar()
gui = MetalGUI(design)
from metal_library.components import QubitCavity
# Parsing the best geometries
best_options = best_geoms[0]
second_best_options = best_geoms[1]
# and so on...
design = QubitCavity(design, options=best_options)
gui.rebuild()
gui.autoscale()
gui.screenshot()
|
https://github.com/LFL-Lab/metal-library
|
LFL-Lab
|
%load_ext autoreload
%autoreload 2
%config IPython.sys.argv=['-Xfrozen_modules=off']
from qiskit_metal.designs.design_multiplanar import MultiPlanar
import numpy as np
import qiskit_metal as metal
from qiskit_metal import designs, draw
from qiskit_metal import MetalGUI, Dict, open_docs
design = MultiPlanar(metadata={},
overwrite_enabled=True)
# Design variables
design._chips.main.size.size_x = '5mm'
design._chips.main.size.size_y = '5mm'
# Check if layer data is useable, if so launch GUI
ls_unique = design.ls.is_layer_data_unique()
if (ls_unique != True):
raise ValueError('Layer data in `MultiPlanar` design is not unique')
# gui = MetalGUI(design)
metal.__version__
# Transmon
from qiskit_metal.qlibrary.qubits.transmon_cross import TransmonCross
xmon_options = Dict(
connection_pads=Dict(
readout = Dict(connector_location = '180')),
)
# Create a new Transmon Cross object with name 'Q1'
TransmonCross(design, 'transmon', options=xmon_options)
# gui.rebuild() # rebuild the design and plot
# gui.autoscale() #resize GUI to see QComponent
from qiskit_metal.renderers.renderer_ansys_pyaedt.hfss_renderer_eigenmode_aedt import QHFSSEigenmodePyaedt
import pyEPR as epr
em1_aedt = QHFSSEigenmodePyaedt(design,
'Qubit_Sabrina_proj',
'Qubit_Sabrina_design',
initiate=True)
hfss_aedt = em1_aedt.current_app
def render_design():
em1_aedt.render_design()
def run_simulation():
#### Computer's variables
num_cores=16
num_gpu=1
#### Setup Name
setup_name = 'TransmonSetup'
# Change Silicon to Ultracold Silicon
hfss_aedt.materials['silicon'].permittivity = 11.45
# Add project variables
add_project_level_vars(em1_aedt)
# Clear setups
if len(hfss_aedt.setups) != 0:
hfss_aedt.setups[0].delete()
# Add Setup
setup_options = dict(
name= setup_name,
MinimumFrequency = 3, # GHz
NumModes= 1,
MaxDeltaFreq = 0.1,
MaximumPasses= 1,
MinimumPasses= None,
MinimumConvergedPasses= 2,
PercentRefinement= 30,
BasisOrder= None
)
em1_aedt.add_hfss_em_setup(**setup_options)
hfss_aedt.analyze_setup(name=setup_name,
num_cores=num_cores,
num_gpu=num_gpu)
# Make silicon ultra cold
hfss_aedt.materials['silicon'].permittivity = 11.45
def add_project_level_vars(renderer):
"""
Finds all names, inductances, and capacitances of Josephson Junctions rendered into ANSYS.
Args:
renderer (QHFSSEigenmodePyaedt)
"""
# Get all josephson junctions from rendered components table
geom_table = renderer.path_poly_and_junction_with_valid_comps
all_jjs = geom_table.loc[geom_table['name'].str.contains('rect_jj')]
all_jjs = all_jjs.reset_index(drop=True)
for i, row in all_jjs.iterrows():
### Parsing Data ###
component = str(row['component'])
name = str(row['name'])
inductance = row['aedt_hfss_inductance'] # Lj in Henries
capacitance = row['aedt_hfss_capacitance'] # Cj in Farads
# Get ANSYS > Model > Sheet corresponding to JJs
rect_name = 'JJ_rect_Lj_' + component + '_' + name
# Get ANSYS > Model > Lines corresponding to JJs
line_name = 'JJ_Lj_' + component + '_' + name + '_'
### Appending data ###
# Add global Lj and Cj variables to ANSYS (for EPR analysis)
ansys_Lj_name = f'Lj_{i}'
ansys_Cj_name = f'Cj_{i}'
renderer.set_variable(ansys_Lj_name, str(inductance * 1E9) + 'nH')
renderer.set_variable(ansys_Cj_name, str(capacitance * 1E15) + 'fF')
def run_analysis():
'''
After finishing simulation, analyze results
'''
em1_aedt.run_epr()
# Extract observables of int
observables = extract_observables(em1_aedt.epr_quantum_analysis)
return observables
def extract_observables(epra,
cos_trunc: int = 10,
fock_trunc: int = 15):
'''
Extract observables from EPR quantum analysis
Args:
epra (epr.QuantumAnalysis): Raw EPR Quanutm analysis class
cos_trunc (int, optional): amount of terms to consider in cosine expansion
fock_trunc (int, optional): size of fock space before truncation
Returns:
package (dict): simulated observables
'''
# Extraction of variables
omegas = epra.get_frequencies()
chis = epra.get_chis()
other_data = epra.data
package = dict(qubit_freq_MHz = omegas['0'][0],
qubit_anharmonicity_MHz = chis[0][0],
other_data = str(other_data))
return package
def run_single_design(): # this will be used as `custom_analysis`
render_design()
run_simulation()
package = run_analysis()
return package
from metal_library.sweeper import QSweeper
sweeper = QSweeper(design)
sweep_parameters = dict(
connection_pads = dict(
readout = dict(
connector_type = '0',
claw_length = ['185um', '195um', '205um', '215um'],
ground_spacing = ['4um', '5um', '7um', '9um', '10um'],
claw_gap = ['5.1um'],
claw_width = ['10um', '15um']
)
),
cross_width = ['30um'],
cross_length = ['185um', '195um', '205um', '215um', '225um', '235um'],
cross_gap = ['29um'],
aedt_hfss_inductance = [9.686E-9, 10.471E-9, 11.268E-9, 12.679-9, 13.816]
)
my_librarian = sweeper.run_single_component_sweep(component_name='transmon',
parameters = sweep_parameters,
custom_analysis = run_single_design,
parameters_slice=slice(1,2),
save_path="./Tutorial2_QubitOnly.csv")
|
https://github.com/Varary73/Visualising-Quantum-Time-Evolution-using-Qiskit
|
Varary73
|
# !pip install qiskit
# !pip install pylatexenc
from qiskit import *
import numpy as np
from matplotlib import pyplot as plt
from qiskit.visualization import plot_histogram
from qiskit.circuit.library import QFT
import pylatexenc
#Number of qubits
n=6
#Circuit
phi=0.1 #time step
iterations=30 #iterations
#Potential
V=1.75
#Spatial Grid
N=2**n #grid points
xMin=-4
xMax=4
x = np.linspace(xMin,xMax, num=N)
#Wavefunction
mu=-2.25
psi= (1/(np.sqrt(2*np.pi)*2*0.4)*np.exp(-(0.5*(x-mu)**2)/(2*0.016)))*np.exp(-300j*x)
psi/= np.sqrt(np.sum(np.abs(psi**2)))
plt.plot(x,psi)
qubits=QuantumRegister(n+1)
splitOp=QuantumCircuit(qubits,name="splitOp")
'''potential operator'''
splitOp.ccx(3,4,0)
splitOp.cp(V*phi,0,5)
splitOp.ccx(3,4,0)
splitOp.barrier()
'''momentum operator'''
splitOp.append(QFT(n),qubits[1:])
for i in range(n):
splitOp.p(phi/2**(n-3+i), n-i)
for i in range(n):
for j in range(i+1,n):
splitOp.cx(n-j,0)
splitOp.cx(n-i,0)
splitOp.p(phi*(2**(2-i-j)),0)
splitOp.cx(n-i,0)
splitOp.cx(n-j,0)
splitOp.append(QFT(n,inverse=True),qubits[1:])
splitOp.barrier()
splitOp.draw('mpl')
q=QuantumRegister(n+1)
c=ClassicalRegister(n)
circuit=QuantumCircuit(q,c)
'''initialization'''
circuit.initialize(psi,q[1:])
circuit.barrier()
'''time steps'''
for i in range(iterations):
circuit.append(splitOp,q[:])
'''measurement'''
for i in range(1,n+1):
circuit.measure(i,i-1)
#circuit.draw('mpl')
answer = execute(circuit, backend=BasicAer.get_backend('qasm_simulator'), shots=5000).result().get_counts()
for a in range(N):
s = bin(a)[2:]
while len(s)!=6:
s='0'+s
if s not in answer.keys():
answer[s] = 0
plot_histogram(answer, figsize = [20,10])
new_psi=np.zeros(N)
count=0
for key in sorted(answer.keys()):
new_psi[count]=answer[key]
count+=1
new_psi=new_psi/np.sqrt(np.sum(psi**2))
barrier=np.zeros(N)
barrier[14:16]=20000
print(np.sum(np.abs(psi**2)))
plt.plot(x,new_psi)
plt.plot(x,barrier)
plt.show()
|
https://github.com/Shashankaubaru/NISQ-TDA
|
Shashankaubaru
|
run test_rank.py
import test_rank
import importlib
importlib.reload(test_rank)
for j in range(2,20,2):
betti_BP = betti_boundary_projection(vit_vec, project_on_simplices, boundary_sum_matrix, num_vertices,j, nv, 0.3, 2)
for i in range(num_vertices):
print("Betti Bound_proj",i, " = ", betti_BP[i] , "with deg = ", j)
from scipy.sparse.linalg.eigen.arpack import eigsh as largest_eigsh
points = np.random.rand(7,4)
#points = [[0, 0, 0], [0, 1, 0], [1,0,0],[1,1,0], [0.5,0.5,1]]
vit_comp = vitoris_rips_complex(points, 0.4)
vit_vec = simplices_to_count_vector(vit_comp)
num_basis = len(vit_vec)
num_vertices = num_underlying_vertices_vector_length(num_basis)
boundary = boundary_operator(num_vertices)
boundary_matrix = matrix_from_pauli_operator(boundary)
#print("Boundary sum:")
boundary_sum = boundary_operator_hermitian(num_vertices)
boundary_sum_matrix = matrix_from_pauli_operator(boundary_sum)
project_on_simplices = np.zeros(np.shape(boundary_matrix)+(num_vertices,))
for i in range(num_vertices):
project_on_simplices[..., i] = np.array(np.diag(d_dim_simplices_mask(i,vit_vec)), dtype=float)
laplacian_restricted = np.zeros(np.shape(boundary_sum_matrix)+(num_vertices,))
dim_simplices = np.zeros(num_vertices+1)
for i in range(num_vertices):
dim_simplices[i] = np.sum(d_dim_simplices_mask(i,vit_vec))
if i>0:
project_up_down = project_on_simplices[...,i-1]
else:
project_up_down = np.zeros(np.shape(boundary_sum_matrix))
if i < num_vertices-1:
project_up_down += project_on_simplices[...,i+1]
laplacian_restricted[...,i] = \
project_on_simplices[...,i] \
@ boundary_sum_matrix \
@ project_up_down \
@ boundary_sum_matrix \
@ project_on_simplices[...,i] \
betti = np.zeros(num_vertices)
for i in range(num_vertices):
rows = d_dim_simplices_mask(i, vit_vec)
cols = rows
if np.any(rows) and np.any(cols):
tmp_mat = laplacian_restricted[..., i][rows][:,cols]
v, w = np.linalg.eig(tmp_mat)
print(tmp_mat.shape)
print(v)
from scipy.sparse.linalg.eigen.arpack import eigsh as largest_eigsh
points = np.random.rand(8,3)
#points = [[0, 0, 0], [0, 1, 0], [1,0,0],[1,1,0], [0.5,0.5,1]]
vit_comp = vitoris_rips_complex(points, 0.7)
vit_vec = simplices_to_count_vector(vit_comp)
num_basis = len(vit_vec)
num_vertices = num_underlying_vertices_vector_length(num_basis)
boundary = boundary_operator(num_vertices)
boundary_matrix = matrix_from_pauli_operator(boundary)
#print("Boundary sum:")
boundary_sum = boundary_operator_hermitian(num_vertices)
boundary_sum_matrix = matrix_from_pauli_operator(boundary_sum)
project_on_simplices = np.zeros(np.shape(boundary_matrix)+(num_vertices,))
for i in range(num_vertices):
project_on_simplices[..., i] = np.array(np.diag(d_dim_simplices_mask(i,vit_vec)), dtype=float)
for i in range(num_vertices):
i_dim_simplices = d_dim_simplices_mask(i,vit_vec)
i_minus_1_dim_simplices = d_dim_simplices_mask(i-1, vit_vec)
tmp_mat = project_on_simplices[...,i] @ (boundary_sum_matrix @ project_on_simplices[...,i-1])
tmp_mat = tmp_mat[i_minus_1_dim_simplices][:,i_dim_simplices]
v, w = np.linalg.eig(tmp_mat.T @ tmp_mat)
# e, vec = largest_eigsh(tmp_mat.T @ tmp_mat, 1, which ='LM')
print(tmp_mat.shape)
print(v)
for j in range(2,20,2):
betti_lap = betti_Laplacian_restricted(vit_vec, project_on_simplices, boundary_sum_matrix, num_vertices,j, nv, 0.2, 2)
for i in range(num_vertices):
print("Betti Bound_proj",i, " = ", betti_lap[i] , "with deg = ", j)
run classical_homology.py
points = np.random.rand(6,3)
points
a = range(10)
b = np.zeros(10)
A = np.diag(np.concatenate([a,b]))
rank_estimation(A, 10, 30, 0.1, 1)
LA.matrix_rank(A)
v = np.random.randn(20)
v= v/LA.norm(v)
mom = compute_moments(A, v, deg)
mom
import matplotlib.pyplot as plt
from rank_estimation import Chebyshev_step
from rank_estimation import compute_Chebyshev_moments
import numpy as np
deg = 3
x = np.linspace(0,1,num=100)
y= np.zeros(len(x))
y1= np.zeros(len(x))
cheb_mom = np.zeros((len(x), deg+1))
for i in range(len(x)):
xi = x[i]
mom = np.zeros(deg+1)
for j in range(deg+1):
if j == 0:
mom[j] = 1
else:
mom[j] = np.dot(xi, mom[j-1])
cheb_mom[i,:] = compute_Chebyshev_moments(mom)
mu = Chebyshev_step(deg, 0.1, 1)
y[i] = np.dot(mu,cheb_mom[i,:])
mu = Chebyshev_step(deg, 0.1, 2)
y1[i] = np.dot(mu,cheb_mom[i,:])
plt.plot(x,y)
plt.plot(x,y1)
A = boundary_matrix(10)
r = rank_estimation((A+A.transpose())/2, 4, 30, 0.01, 2)
int(r)
qiskit.__version__
np.zeros([2,2])
import numpy as np
points = [[0, 0], [1, 0.5], [0,1.5],[1,2]]
np.mean(points,0)
from scipy.stats import kurtosis
kurtosis(points,0)
np.var(points,0)
from scipy.stats import skew
skew(points,0)
A = np.array([[ 0., 1., 1., 0.],
[ 1., 0., 0., 1.],
[ 1., 0., 0., -1.],
[ 0., 1., -1., 0.]])
from numpy import linalg as LA
LA.matrix_rank(A)
B= A @ A
from classical_homology import one_skeleton_square, one_skeleton_unfilled_cube
from quantum_homology import expectation_over_random_hadamard_vecs
edges_in, num_ver= one_skeleton_unfilled_cube()
exp_value = expectation_over_random_hadamard_vecs(num_ver, edges_in, powers=range(2), num_samples=1)
exp_value
eps = 0.01
damp = 2
deg = 4
pwr = range(deg)
nv = 4
rank = np.zeros([nv,num_ver-1])
exp_tensor = expectation_over_random_hadamard_vecs(num_ver, edges_in, powers=pwr, num_samples=nv)
#exp_tensor = exp_value
for l in range(nv):
for k in range(num_ver-1):
# scal = num_ver**(k+1)
exp_value = np.append([1], exp_tensor[l,:,k])
cheb_mom = compute_Chebyshev_moments(exp_value)
mu = Chebyshev_step(deg, eps, damp)
rk = np.dot(cheb_mom, mu)
rank[l,k] = num_ver*rk
np.mean(rank,0)
for l in range(nv):
for k in range(num_ver-1):
#scal = num_ver**(k+1)
exp_value = np.append([1], exp_tensor[l,:,k])
cheb_mom = compute_Chebyshev_moments(exp_value)
print(exp_value)
mu = Chebyshev_step(deg, eps, damp)
rk = np.dot(cheb_mom, mu)
rank[l,k] = num_ver*rk
np.mean(rank,0)
from classical_homology import vitoris_rips_complex_from_one_skeleton, classical_laplacian_of_vit_vec, simplices_to_count_vector
vit_comp = vitoris_rips_complex_from_one_skeleton(num_ver, edges_in)
vit_vec = simplices_to_count_vector(vit_comp)
laplacian_restricted = classical_laplacian_of_vit_vec(vit_vec)
betti = np.zeros(num_ver)
for i in range(num_ver):
rows = d_dim_simplices_mask(i, vit_vec)
cols = rows
if np.any(rows) and np.any(cols):
tmp_mat = laplacian_restricted[..., i][rows][:, cols]
betti[i] = (rank_estimation(
(tmp_mat @ tmp_mat.T), deg, nv, eps, damp))
# np.sum(rows) equivalent to d_dim_simplices[i]
else:
betti[i] = 0
betti
import test.test_quantum_homology_advanced
mylaplace = test.test_quantum_homology_advanced.Expectation_of_Laplacian_TestCase()
mylaplace.setUp()
mylaplace.test_expectation_01()
#mylaplace.test_run_random()
from classical_homology import vitoris_rips_complex_from_one_skeleton, classical_laplacian_of_vit_vec, simplices_to_count_vector
from rank_estimation import expectation_hadamard
vit_comp = vitoris_rips_complex_from_one_skeleton(num_ver, edges_in)
vit_vec = simplices_to_count_vector(vit_comp)
laplacian_restricted = classical_laplacian_of_vit_vec(vit_vec)
for i in range(num_ver):
rows = d_dim_simplices_mask(i, vit_vec)
cols = rows
if np.any(rows) and np.any(cols):
tmp_mat = laplacian_restricted[..., i][rows][:, cols]
mom = (expectation_hadamard(
(tmp_mat @ tmp_mat.T), deg, nv, eps, damp))
print(mom)
else:
betti[i] = 0
!pip3 install qiskit-honeywell-provider
from qiskit.providers.honeywell import Honeywell
Honeywell.save_account('lhoresh@us.ibm.com')
Honeywell.load_account()
backends = Honeywell.backends()
device = 'HQS-LT-S2'
backend = Honeywell.get_backend(device)
job = backend.retrieve_job('c90c48da23c448dc97f6054bd9d45cee') # Substitute your own job_id here
result = job.result()
counts = result.get_counts()
import sys
stdoutOrigin=sys.stdout
sys.stdout = open("square_counts.txt", "w")
print(counts)
sys.stdout.close()
sys.stdout=stdoutOrigin
backends = Honeywell.backends()
device = 'HQS-LT-S2-SIM'
backend = Honeywell.get_backend(device)
job = backend.retrieve_job('a4a1b5e611834caeb36282d41000b827') # Substitute your own job_id here
result = job.result()
counts = result.get_counts()
stdoutOrigin=sys.stdout
sys.stdout = open("Count_square_sim_500_shots_deg3_vec4.txt", "w")
print(counts)
sys.stdout.close()
sys.stdout=stdoutOrigin
print(result)
with open('Count_cube_sim_1000_shots.txt') as f:
data = f.read()
print(data)
from qiskit.visualization import plot_histogram
!pip3 install qiskit-terra
from quantum_rank_estimation import quantum_rank_estimation, quantum_Betti_estimation
from classical_homology import one_skeleton_square, one_skeleton_unfilled_cube
eps = 0.01
damp = 2
deg = 5
nv = 1
pwr = range(deg)
edges_in, num_ver= one_skeleton_square()
#edges_in, num_ver = [[0,1]] , 2
#edges_in, num_ver= one_skeleton_unfilled_cube()
#dimHk = [ 8, 18, 12, 0, 0, 0, 0]
dimHk = [4, 4, 0]
#rank = quantum_rank_estimation(edges_in, num_ver, pwr, nv, eps, damp)
Betti = quantum_Betti_estimation(edges_in, num_ver, dimHk, pwr, nv, eps, damp, [0.00,0.0], expt_name = None, save = False)
Betti
No noise : array([1.39792841, 1.27119665, 0. ])
Noise (0.001): array([1.42281703, 1.35898137, 0. ])
Noise (0.005): array([1.45420094, 1.45964984, 0. ])
Noise (0.01): array([1.46864872, 1.41010404, 0. ])
Noise (0.05): array([1.58682813, 1.53805871, 0. ])
Noise (0.1): array([1.65800044, 1.67416625, 0. ])
from quantum_rank_estimation import quantum_rank_estimation, quantum_Betti_estimation
from classical_homology import one_skeleton_square, one_skeleton_unfilled_cube, one_skeleton_random
from classical_homology import complex_one_skeleton, one_skeleton_remap
import matplotlib.pyplot as plt
import numpy as np
# import json
# points = json.load(open('cmb_sample_points.json', "r"))
# epsilon = 15
# edges_in, num_ver = one_skeleton_remap(complex_one_skeleton(points[0:7], epsilon))
eps = 0.05
damp = 2
deg = 5
nv = 5
pwr = range(deg)
#edges_in, num_ver= one_skeleton_random()
edges_in, num_ver = [[0,1]] , 2
alpha = range(-2,3)
dimHk = [4,4,0]
#dimHk = [ 0, 0, 0, 0, 0, 0, 0]
#rank = quantum_rank_estimation(edges_in, num_ver, pwr, nv, eps, damp)
Betti = np.zeros((3, len(alpha)))
fig, axs = plt.subplots(3)
for idx, i in enumerate(alpha):
Betti[:,idx] = quantum_Betti_estimation(edges_in, num_ver, dimHk, pwr, nv, eps, damp, \
[0.001*(10**i),min(0.01*(10**i),0.1)], save = False)
#"edge-surf-"+str(idx)
true_betti = [1,1,0]
xval =['(0.00001,0.0001)','(0.0001,0.001)','(0.001,0.01)','(0.01,0.1)','(0.1,0.1)']
for k in range(3):
axs[k].plot(xval,Betti[k,:],'*-')
axs[k].plot(xval,np.tile(true_betti[k],len(alpha)),'k--')
#plt.savefig('random8_noise_lvl_quantum.png')
from quantum_rank_estimation import quantum_Betti_estimation_json
from classical_homology import one_skeleton_square, one_skeleton_unfilled_cube
eps = 0.05
damp = 0
deg = 5
nv = 5
pwr = range(deg)
#edges_in, num_ver= one_skeleton_square()
edges_in, num_ver= one_skeleton_unfilled_cube()
dimHk = [ 8, 18, 12, 0, 0, 0, 0]
#dimHk = [4, 4, 0]
Betti = quantum_Betti_estimation_json( num_ver, dimHk, pwr, nv, eps, damp, expt_name = "cube")
Betti
import numpy as np
import matplotlib.pyplot as plt
from quantum_rank_estimation import quantum_rank_estimation, quantum_Betti_estimation
from classical_homology import one_skeleton_square, one_skeleton_unfilled_cube
from classical_homology import complex_one_skeleton, one_skeleton_remap
eps = 0.005
damp = 0
deg = range(2,9)
nv = 10
num_vertices = 4
edges_in, num_ver= one_skeleton_square()
#edges_in, num_ver= one_skeleton_unfilled_cube()
#dimHk = [ 8, 18, 12, 0, 0, 0, 0]
dimHk = [4, 4, 0]
fig, axs = plt.subplots(3)
Betti = np.zeros([num_vertices-1,len(deg)])
for idx,i in enumerate(deg):
pwr= range(i)
# Betti[:,idx] = classical_betti_from_rank_estimation_of_laplacian(vit_vec, i, nv, eps, damp)
Betti[:,idx] = quantum_Betti_estimation(edges_in, num_ver, dimHk, pwr, nv, eps, damp, [0.000,0.000])
true_betti = [1,1,0]
for k in range(3):
axs[k].plot(deg,Betti[k,:],'*-')
axs[k].plot(deg,np.tile(true_betti[k],len(deg)),'k--')
plt.savefig('square_deg_quantum.png')
import numpy as np
import matplotlib.pyplot as plt
from quantum_rank_estimation import quantum_rank_estimation, quantum_Betti_estimation
from classical_homology import one_skeleton_square, one_skeleton_unfilled_cube
eps = 0.005
damp = 0
deg = 4
nv = range(5,31,5)
pwr= range(deg)
num_vertices = 4
edges_in, num_ver= one_skeleton_square()
#edges_in, num_ver= one_skeleton_unfilled_cube()
#dimHk = [ 8, 18, 12, 0, 0, 0, 0]
dimHk = [4, 4, 0]
fig, axs = plt.subplots(3)
Betti = np.zeros([num_vertices-1,len(nv)])
for idx,i in enumerate(nv):
# Betti[:,idx] = classical_betti_from_rank_estimation_of_laplacian(vit_vec, deg, i, eps, damp)
Betti[:,idx] = quantum_Betti_estimation(edges_in, num_ver, dimHk, pwr, i, eps, damp, [0.001,0.01])
true_betti = [1,1,0]
for k in range(3):
axs[k].plot(nv,Betti[k,:],'*-')
axs[k].plot(nv,np.tile(true_betti[k],len(nv)),'k--')
plt.savefig('square_nv_quantum_noisy.png')
Betti
import numpy as np
import matplotlib.pyplot as plt
from quantum_rank_estimation import quantum_rank_estimation, quantum_Betti_estimation
from classical_homology import complex_one_skeleton, one_skeleton_remap
import json
epsilon = 15
eps = 0.005
damp = 0
deg = 5
nv = 30
pwr = range(deg)
points = json.load(open('cmb_sample_points.json', "r"))
edges_in, num_ver = one_skeleton_remap(complex_one_skeleton(points[0:7], epsilon))
dimHk = [ 3, 0, 0, 0, 0, 0, 0]
Betti = quantum_Betti_estimation(edges_in, num_ver, dimHk, pwr, nv, eps, damp, [0.001,0.01], expt_name = "CMB_8_nv-", save = True)
Betti
from classical_homology import classical_betti_from_exact_kernel_of_boundary, vitoris_rips_complex_from_one_skeleton, simplices_to_count_vector
from classical_homology import complex_one_skeleton, one_skeleton_remap
import json
points = json.load(open('cmb_sample_points.json', "r"))
epsilon = 15
edges_in, num_ver = one_skeleton_remap(complex_one_skeleton(points[0:7], epsilon))
vit_comp = vitoris_rips_complex_from_one_skeleton(num_ver, edges_in)
vit_vec = simplices_to_count_vector(vit_comp)
true_betti = classical_betti_from_exact_kernel_of_boundary(vit_vec)
true_betti
#Betti =[[4.08669333, 4.08662073, 4.08645737, 4.08640292, 4.08665703],
# [9.19424321, 9.19522336, 9.19567259, 9.19473328, 9.19534588],
# [6.13028428, 6.13001277, 6.13020336, 6.1299311 , 6.1299311 ]]
Err = Betti[0:1,:] - np.tile(1.5,[2,5])
edge_error = np.sort(np.mean(np.abs(Err),0))
edge_error
Betti
import numpy as np
import json
from quantum_rank_estimation import Chebyshev_step, compute_Chebyshev_moments
eps = 0.005
damp = 0
deg = 5
nv = 30
num_ver = 7
dimHk = [ 3, 0, 0, 0, 0, 0, 0]
rank = np.zeros([nv,num_ver])
mu = Chebyshev_step(deg, eps, damp)
temp = np.loadtxt('resultsCMB_8_nv-.txt', dtype=float)
exp_tensor = temp.reshape(temp.shape[0], temp.shape[1] // num_ver, num_ver)
for l in range(nv):
for k in range(num_ver):
if np.sum(exp_tensor[l,:,k]) ==0:
rank[l,k] = 0
continue
exp_value = np.append([1], exp_tensor[l,:,k])
cheb_mom = compute_Chebyshev_moments(exp_value)
rank[l,k] = dimHk[k]*np.dot(cheb_mom, mu)
Betti = (dimHk - (np.mean(rank,0)))
Betti
from qiskit.quantum_info import hellinger_distance as compare_counts_hellinger
import glob
import numpy as np
from quantum_homology import merge_counts, calc_circuit_depths
names = ["edge","square","cube"]
dist = np.zeros([3,5])
for i in range(5):
no_noise_data = "edge-no-noisedegree0sample0.json"
noisy_data = "edge-noise-"+str(i)+"degree0sample0.json"
raw_data_globs = [no_noise_data, noisy_data]
dist[0,i] = compare_counts_hellinger(merge_counts(glob.glob(raw_data_globs[0])),merge_counts(glob.glob(raw_data_globs[1])))
no_noise_data = "square-no-noisedegree0sample0.json"
noisy_data = "square-noise-"+str(i)+"degree0sample0.json"
raw_data_globs = [no_noise_data, noisy_data]
dist[1,i] = compare_counts_hellinger(merge_counts(glob.glob(raw_data_globs[0])),merge_counts(glob.glob(raw_data_globs[1])))
no_noise_data = "cube-no-noisedegree0sample0.json"
noisy_data = "cube-noise-"+str(i)+"degree0sample0.json"
raw_data_globs = [no_noise_data, noisy_data]
dist[2,i] = compare_counts_hellinger(merge_counts(glob.glob(raw_data_globs[0])),merge_counts(glob.glob(raw_data_globs[1])))
id = np.nonzero(rank[:,0])
3.3-rank[id,0]
0.001*(10**-2)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.