repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-docstring,invalid-name,no-member
# pylint: disable=attribute-defined-outside-init
import itertools
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.circuit import Parameter
def build_circuit(width, gates):
qr = QuantumRegister(width)
qc = QuantumCircuit(qr)
while len(qc) < gates:
for k in range(width):
qc.h(qr[k])
for k in range(width - 1):
qc.cx(qr[k], qr[k + 1])
return qc
class CircuitConstructionBench:
params = ([1, 2, 5, 8, 14, 20], [8, 128, 2048, 8192, 32768, 131072])
param_names = ["width", "gates"]
timeout = 600
def setup(self, width, gates):
self.empty_circuit = build_circuit(width, 0)
self.sample_circuit = build_circuit(width, gates)
def time_circuit_construction(self, width, gates):
build_circuit(width, gates)
def time_circuit_extend(self, _, __):
self.empty_circuit.extend(self.sample_circuit)
def time_circuit_copy(self, _, __):
self.sample_circuit.copy()
def build_parameterized_circuit(width, gates, param_count):
params = [Parameter("param-%s" % x) for x in range(param_count)]
param_iter = itertools.cycle(params)
qr = QuantumRegister(width)
qc = QuantumCircuit(qr)
while len(qc) < gates:
for k in range(width):
param = next(param_iter)
qc.u2(0, param, qr[k])
for k in range(width - 1):
param = next(param_iter)
qc.crx(param, qr[k], qr[k + 1])
return qc, params
class ParameterizedCircuitConstructionBench:
params = ([20], [8, 128, 2048, 8192, 32768, 131072], [8, 128, 2048, 8192, 32768, 131072])
param_names = ["width", "gates", "number of params"]
timeout = 600
def setup(self, _, gates, params):
if params > gates:
raise NotImplementedError
def time_build_parameterized_circuit(self, width, gates, params):
build_parameterized_circuit(width, gates, params)
class ParameterizedCircuitBindBench:
params = ([20], [8, 128, 2048, 8192, 32768, 131072], [8, 128, 2048, 8192, 32768, 131072])
param_names = ["width", "gates", "number of params"]
timeout = 600
def setup(self, width, gates, params):
if params > gates:
raise NotImplementedError
self.circuit, self.params = build_parameterized_circuit(width, gates, params)
def time_bind_params(self, _, __, ___):
self.circuit.bind_parameters({x: 3.14 for x in self.params})
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.timeline import draw, IQXSimple
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc = transpile(qc, FakeBoeblingen(), scheduling_method='alap', layout_method='trivial')
draw(qc, style=IQXSimple())
|
https://github.com/VGGatGitHub/2020-QISKit-Summer-Jam
|
VGGatGitHub
|
import warnings
#warnings.filterwarnings('ignore', 'DeprecationWarning')
warnings.filterwarnings('once')
#%pip uninstall qiskit
#%pip install qiskit #==0.16
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit import Aer
from qiskit.tools.visualization import plot_histogram
#VGG todo 1: the equivalent run_algorithm and EnergyInput versions updates
#from qiskit.aqua.translators.ising import max_cut, tsp
#from qiskit.aqua import run_algorithm
#from qiskit.aqua.input import EnergyInput
#old v0.16# from qiskit.optimization.ising import max_cut, tsp
#old v0.16# from qiskit.optimization.ising.common import sample_most_likely
#older# from qiskit.optimization.ising import docplex
from qiskit.optimization.applications.ising import max_cut, tsp
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.optimization.applications.ising import docplex
from qiskit.aqua.algorithms import VQE
from qiskit.aqua.algorithms import NumPyEigensolver as ExactEigensolver
from qiskit.aqua.components.optimizers import SPSA
#from qiskit.aqua.components.variational_forms import RY #RealAmplitudes
from qiskit.circuit.library import RealAmplitudes as RY
from qiskit.aqua import QuantumInstance
# setup aqua logging
import logging
from qiskit.aqua import set_qiskit_aqua_logging
# set_qiskit_aqua_logging(logging.DEBUG) # choose INFO, DEBUG to see the log
from qiskit import IBMQ
provider = IBMQ.load_account()
#VGG select the backend for coupling_map
try:
backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex')
#backend = provider.get_backend('ibmq_london')#'ibmq_16_melbourne')#'ibmq_essex')
#backend = provider.get_backend('ibmq_5_yorktown')#'ibmq_london')#'ibmq_16_melbourne')#'ibmq_essex')
except:
backend = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
coupling_map = backend.configuration().coupling_map
print(coupling_map)
#VGG we will generate a diferent coupling_map for the graph
#coupling_map=None
from typing import List, Tuple
seed = 19120623
np.random.seed(seed)
#VGG: function adopted from the Rigetti's MaxCutQAOA.ipynb
def generate_ising_graph(edges: List[Tuple[int, int]]) -> nx.Graph:
graph = nx.from_edgelist(edges)
weights: np.ndarray = np.random.rand(graph.number_of_edges()) #VGG the old [-1,1] range into [0,1]
weights /= np.linalg.norm(weights)
nx.set_edge_attributes(graph, {e: {'weight': w} for e, w in zip(graph.edges, weights)})
return graph
if coupling_map != None:
G=generate_ising_graph(coupling_map)
n=G.number_of_nodes()
print(n)
# Generating a graph if there were no coupling_map
if coupling_map== None:
#define the edges / coupling_map
#'ibmq_16_melbourne'
elist=[[0, 1], [0, 14], [1, 0], [1, 2], [1, 13], [2, 1], [2, 3], [2, 12],
[3, 2], [3, 4], [3, 11], [4, 3], [4, 5], [4, 10], [5, 4], [5, 6],
[5, 9], [6, 5], [6, 8], [7, 8], [8, 6], [8, 7], [8, 9], [9, 5], [9, 8],
[9, 10], [10, 4], [10, 9], [10, 11], [11, 3], [11, 10], [11, 12], [12, 2],
[12, 11], [12, 13], [13, 1], [13, 12], [13, 14], [14, 0], [14, 13]]
#elist=[[0,1],[0,2],[0,3],[1,2],[2,3],[0,4],[0,2], [4, 3],[1,5],[3,5]]
elist=[[0,1],[0,2],[0,3],[1,2],[2,3],[0,4],[0,2], [4, 3]]
G=generate_ising_graph(elist)
n=G.number_of_nodes()
#other ways to define the graph
#n=5 # Number of nodes in graph
#G=nx.Graph()
#G.add_nodes_from(np.arange(0,n,1))
#ewlist=[(0,1,1.),(0,2,.5),(0,3,0),(1,2,1.0),(0,3,1.0)]
#G1 = nx.from_edgelist(elist)
#G1.add_weighted_edges_from(ewlist)
coupling_map = backend.configuration().coupling_map
#Visulaize
print(G.number_of_nodes(),G.number_of_edges())
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
nx.drawing.nx_pylab.draw(G)
elist=G.edges()
print("elist=",elist)
ewlist=[(i,j,G.get_edge_data(i,j,default=0)['weight']) for i,j in G.edges()]
print('ewlist=',ewlist)
def issymmetric(Matrix):
dim=Matrix.shape[0]
if Matrix.shape[1] != dim:
print("Shape Error!")
return False
for i in range(dim):
for j in range(i,dim):
if Matrix[i,j]!=Matrix[j,i]:
print("Shape Error:",(i,j),Matrix[i,j],Matrix[j,i],"difference:",Matrix[i,j]-Matrix[j,i])
return False
return True
# Computing the weight matrix from the random graph
w = np.zeros([n,n])
w = np.eye(n)
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i,j,default=0)
if temp != 0:
w[i,j] = temp['weight']
w/=np.linalg.det(w)**(1/n)
print("Symmetric:",issymmetric(w),"Norm:",np.linalg.norm(w))
print("Eignvlues:",np.linalg.eigvals(w),"det:",np.linalg.det(w))
print(w)
np.sum(w)/4 #the offset value
def Max_Cut_BF(W,*x0):
best_cost_brute = 0
xbest_brute=np.array([1]*n)
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]
cost = 0
for h in x0:
cost -= np.dot(h,x)/n #VGG don't give free samples to those with h==1
for i in range(n):
cost +=(2-np.dot(x,x))/n/2 #VGG try to favor fewer free samples
for j in range(n):
cost += W[i,j]*x[i]*(1-x[j])
if np.isclose(cost,best_cost_brute):
if sum(x)<sum(xbest_brute):
best_cost_brute = cost
xbest_brute = x
else:
if best_cost_brute < cost:
best_cost_brute = cost
xbest_brute = x
if 1==2:
print('case = ' + str(x)+ ' cost = ' + str(cost))
return best_cost_brute, xbest_brute
%%time
if n < 10:
best_cost_brute, xbest_brute = Max_Cut_BF(w)
colors = ['r' if xbest_brute[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos)
print('\nBest solution = ' + str(xbest_brute) + ' cost = ' + str(best_cost_brute))
np.set_printoptions(precision=3)
print(w)
def market_simulations(m,*opt):
free_samples=0
boughten=0
Mw2 = np.zeros([n,n])+w
relations=np.zeros([n,n])
x_free_samples=np.int_(np.zeros(n))
np.set_printoptions(precision=2)
if 'q' in opt:
print("Using Max_Cut option:",'q')
print("submiting for results using:",backend)
elif 'dcplx' in opt:
print("Using Max_Cut option:",'Docplex')
else:
print("Using Max_Cut_BF")
if n > 10 :
print("It may take too long to do Brute Force Calulations - skiping!")
return
print("day"," [free samples]"," [buyers distribution]"," [to be used as constrain]"," the two totals"," w-det")
for i in range(m):
if sum(x_free_samples)>n*2/3:
#VGG In the future one can consider giving out to these who have not recived yet!
x_free_samples = np.array([1]*n)-np.int_(x_free_samples!=0)
if (x_free_samples==0).all:
x=np.array([0]*n)
xbest_brute=np.array([0]*n)
tmp1=Mw2/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,]) #sum probaility contributions
else:
x=x_free_samples
free_samples+=sum(x)
tmp1=Mw2[x==1]/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,],(np.array([1]*n)-x)) #sum probaility contributions
tmp-=np.array([1]*n) #push to negative those with free samples
else:
if 'q' in opt:
best_cost_brute, xbest_brute = Max_Cut_IBMQ(Mw2,x_free_samples)
elif 'dcplx' in opt:
best_cost_brute, xbest_brute = Max_Cut_Dcplx(Mw2,x_free_samples)
else:
best_cost_brute, xbest_brute = Max_Cut_BF(Mw2,x_free_samples)
x=np.array(xbest_brute)
x_free_samples+=x
free_samples+=sum(x)
tmp1=Mw2[x==1]/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,],(np.array([1]*n)-x)) #sum probaility contributions
tmp-=np.array([1]*n) #push to negative those with free samples
#print(tmp)
ab=sum(tmp[tmp > 0])
for j in range(n):
test=np.random.uniform()*ab/2
if tmp[j] > test: #buy the product
x[j]+=1
boughten+=1
x0=np.array(xbest_brute)
x-=x0
relation_today=x.reshape(n,1) @ x0.reshape(1,n)
relation_today+=relation_today.T
relations+=relation_today
#print(x0,x,"\n",relation_today)
#print(x0,x,x_free_samples,tmp)
print(i,x0,x,x_free_samples,free_samples, boughten,'{:6.4f}'.format(np.linalg.det(Mw2)))
if i%4==0 : #weekely updates of the w matrix
Mw2+=(np.eye(n)+relations)/n/100 #update the w matrix
relations=np.zeros([n,n])
if issymmetric(Mw2) and np.linalg.det(Mw2)>0.:
Mw2/=np.linalg.det(Mw2)**(1/n)
else:
Mw2/=np.linalg.norm(Mw2,ord='fro')
print("\nlast day configuration record:\n")
print(x0,tmp)
print()
print(x,free_samples, boughten, '{:6.4f}'.format(np.linalg.norm(Mw2)),'{:6.4f}'.format(np.linalg.det(Mw2)))
print()
print(Mw2)
return
%time market_simulations(10)
#VGG qubitOp, offset = max_cut.get_max_cut_qubitops(w)
qubitOp, offset = max_cut.get_operator(w)
#algo_input = EnergyInput(qubitOp)
offset
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = ExactEigensolver(qubitOp, k=3)
result = ee.run()
print("energys:",result['eigenvalues'].real)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstates'][0])
print('energy:', result['eigenvalues'][0],', offset:',offset)
print('max-cut objective:', result['eigenvalues'][0] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
#VGG note that the other runs had implemeneted soft constrains!
from docplex.mp.model import Model
#VGG from qiskit.aqua.translators.ising import docplex
#older# from qiskit.optimization.ising import docplex
# Create an instance of a model and variables.
mdl = Model(name='max_cut')
y = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
# Object function
#VGG added y[i]/100 term to split the degenerate 1<->0 states in favor of less free samples
max_cut_func = mdl.sum(y[i]/50+w[i,j]* y[i] * ( 1 - y[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
# No constraints for Max-Cut problems.
qubitOp_docplex, offset_docplex = docplex.get_operator(mdl)
offset_docplex
#VGG define the above as a function
def set_up_Dcplx_model(W,*c_x0):
mdl = Model(name='max_cut')
y = {i: mdl.binary_var(name='y_{0}'.format(i)) for i in range(n)}
#VGG try to favor fewer free samples using (2-np.dot(x,x))/n/2
#VGG split the degenerate 1<->0 states in favor of less free samples using x[i]/n**2
max_cut_func=mdl.sum((-1)*(2-y[i])*0.5+(-0)*y[i]/100 for i in range(n))
#VGG don't give free samples to those with h==1
max_cut_func+=mdl.sum(h[i]*y[i]*0.55 for i in range(n) for h in c_x0)
max_cut_func+=mdl.sum(W[i,j]* y[i] * ( 1 - y[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
qubitOp, offset = docplex.get_operator(mdl)
return qubitOp, offset
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w)
print(offset_docplex,x)
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = ExactEigensolver(qubitOp_docplex, k=3)
result = ee.run()
print("energys:",result['eigenvalues'].real)
x = sample_most_likely(result['eigenstates'][0])
print('energy:', result['eigenvalues'][0].real)
print('max-cut objective:', result['eigenvalues'][0].real + offset_docplex)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
x=max_cut.get_graph_solution(x).tolist()
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
#VGG note if you keep executing this cell you can see diferent configurations
#VGG define the above as a function
def Max_Cut_Dcplx(W,*c_x0):
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W)
for h in c_x0:
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W,h)
ee = ExactEigensolver(qubitOp_docplex,k=3)
result = ee.run()
x=sample_most_likely(result['eigenstates'][0])
x_dcplx=max_cut.get_graph_solution(x).tolist()
cost_dcplx=result['eigenvalues'][0].real
#cost_dcplx=max_cut.max_cut_value(x, W)
return cost_dcplx, x_dcplx
%time market_simulations(10,'dcplx')
warnings.filterwarnings('once')
model=qubitOp_docplex
#model=qubitOp
backend1 = Aer.get_backend('statevector_simulator')
backend2 = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
seed = 10598
spsa = SPSA(max_trials=10)
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
#VGG backend1 = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend2, seed_simulator=seed, seed_transpiler=seed)
print(backend2)
result = vqe.run(quantum_instance)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
x=max_cut.get_graph_solution(x).tolist()
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
#warnings.filterwarnings('ignore', 'DeprecationWarning')
warnings.filterwarnings('once')
# run quantum algorithm with shots
seed = 10598
spsa = SPSA(max_trials=30)
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
backend2 = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
quantum_instance = QuantumInstance(backend2, shots=1024, seed_simulator=seed, seed_transpiler=seed)
print(backend2)
result = vqe.run(quantum_instance)
"""declarative approach, update the param from the previous cell.
params['backend']['provider'] = 'qiskit.BasicAer'
params['backend']['name'] = 'qasm_simulator'
params['backend']['shots'] = 1024
result = run_algorithm(params, algo_input)
"""
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
plot_histogram(result['eigenstate'])
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
x=max_cut.get_graph_solution(x).tolist()
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
plot_histogram(result['eigenstate'])
backend_old=backend
#backend=backend2
#warnings.filterwarnings('ignore', 'DeprecationWarning')
# run quantum algorithm with shots
seed = 10598
spsa = SPSA(max_trials=10) #VGG 300
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
#backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)
print("submiting for results using:",backend)
result = vqe.run(quantum_instance)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
plot_histogram(result['eigenstate'])
#VGG define the above as a function
def Max_Cut_IBMQ(W,*c_x0):
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W)
for h in c_x0:
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W,h)
model=qubitOp_docplex
spsa = SPSA(max_trials=10) #VGG 300
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)
result = vqe.run(quantum_instance)
x = sample_most_likely(result['eigenstate'])
cost_vqe=max_cut.max_cut_value(x, W)
x_vqe =np.int_(max_cut.get_graph_solution(x)).tolist()
return cost_vqe, x_vqe
%time market_simulations(10)
%time market_simulations(10,'dcplx')
print(backend)
backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = Aer.get_backend('statevector_simulator')
print(backend)
backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = Aer.get_backend('statevector_simulator')
%time market_simulations(10,'q')
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# You can show the phase of each state and use
# degrees instead of radians
from qiskit.quantum_info import DensityMatrix
import numpy as np
from qiskit import QuantumCircuit
from qiskit.visualization import plot_state_qsphere
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0,1)
qc.ry(np.pi/3, 0)
qc.rx(np.pi/5, 1)
qc.z(1)
matrix = DensityMatrix(qc)
plot_state_qsphere(matrix,
show_state_phases = True, use_degrees = True)
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import numpy as np
from qiskit import compiler, BasicAer, QuantumRegister
from qiskit.converters import circuit_to_dag
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
def convert_to_basis_gates(circuit):
# unroll the circuit using the basis u1, u2, u3, cx, and id gates
unroller = Unroller(basis=['u1', 'u2', 'u3', 'cx', 'id'])
pm = PassManager(passes=[unroller])
qc = compiler.transpile(circuit, BasicAer.get_backend('qasm_simulator'), pass_manager=pm)
return qc
def is_qubit(qb):
# check if the input is a qubit, which is in the form (QuantumRegister, int)
return isinstance(qb, tuple) and isinstance(qb[0], QuantumRegister) and isinstance(qb[1], int)
def is_qubit_list(qbs):
# check if the input is a list of qubits
for qb in qbs:
if not is_qubit(qb):
return False
return True
def summarize_circuits(circuits):
"""Summarize circuits based on QuantumCircuit, and four metrics are summarized.
Number of qubits and classical bits, and number of operations and depth of circuits.
The average statistic is provided if multiple circuits are inputed.
Args:
circuits (QuantumCircuit or [QuantumCircuit]): the to-be-summarized circuits
"""
if not isinstance(circuits, list):
circuits = [circuits]
ret = ""
ret += "Submitting {} circuits.\n".format(len(circuits))
ret += "============================================================================\n"
stats = np.zeros(4)
for i, circuit in enumerate(circuits):
dag = circuit_to_dag(circuit)
depth = dag.depth()
width = dag.width()
size = dag.size()
classical_bits = dag.num_cbits()
op_counts = dag.count_ops()
stats[0] += width
stats[1] += classical_bits
stats[2] += size
stats[3] += depth
ret = ''.join([ret, "{}-th circuit: {} qubits, {} classical bits and {} operations with depth {}\n op_counts: {}\n".format(
i, width, classical_bits, size, depth, op_counts)])
if len(circuits) > 1:
stats /= len(circuits)
ret = ''.join([ret, "Average: {:.2f} qubits, {:.2f} classical bits and {:.2f} operations with depth {:.2f}\n".format(
stats[0], stats[1], stats[2], stats[3])])
ret += "============================================================================\n"
return ret
|
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from docplex.mp.model import Model
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import CobylaOptimizer, MinimumEigenOptimizer
from qiskit_optimization.algorithms.admm_optimizer import ADMMParameters, ADMMOptimizer
from qiskit_optimization.translators import from_docplex_mp
# If CPLEX is installed, you can uncomment this line to import the CplexOptimizer.
# CPLEX can be used in this tutorial to solve the convex continuous problem,
# but also as a reference to solve the QUBO, or even the full problem.
#
# from qiskit.optimization.algorithms import CplexOptimizer
# define COBYLA optimizer to handle convex continuous problems.
cobyla = CobylaOptimizer()
# define QAOA via the minimum eigen optimizer
qaoa = MinimumEigenOptimizer(QAOA(sampler=Sampler(), optimizer=COBYLA()))
# exact QUBO solver as classical benchmark
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver()) # to solve QUBOs
# in case CPLEX is installed it can also be used for the convex problems, the QUBO,
# or as a benchmark for the full problem.
#
# cplex = CplexOptimizer()
# construct model using docplex
mdl = Model("ex6")
v = mdl.binary_var(name="v")
w = mdl.binary_var(name="w")
t = mdl.binary_var(name="t")
u = mdl.continuous_var(name="u")
mdl.minimize(v + w + t + 5 * (u - 2) ** 2)
mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
# load quadratic program from docplex model
qp = from_docplex_mp(mdl)
print(qp.prettyprint())
admm_params = ADMMParameters(
rho_initial=1001, beta=1000, factor_c=900, maxiter=100, three_block=True, tol=1.0e-6
)
# define QUBO optimizer
qubo_optimizer = exact
# qubo_optimizer = cplex # uncomment to use CPLEX instead
# define classical optimizer
convex_optimizer = cobyla
# convex_optimizer = cplex # uncomment to use CPLEX instead
# initialize ADMM with classical QUBO and convex optimizer
admm = ADMMOptimizer(
params=admm_params, qubo_optimizer=qubo_optimizer, continuous_optimizer=convex_optimizer
)
# run ADMM to solve problem
result = admm.solve(qp)
print(result.prettyprint())
plt.plot(result.state.residuals)
plt.xlabel("Iterations")
plt.ylabel("Residuals")
plt.show()
# define QUBO optimizer
qubo_optimizer = qaoa
# define classical optimizer
convex_optimizer = cobyla
# convex_optimizer = cplex # uncomment to use CPLEX instead
# initialize ADMM with quantum QUBO optimizer and classical convex optimizer
admm_q = ADMMOptimizer(
params=admm_params, qubo_optimizer=qubo_optimizer, continuous_optimizer=convex_optimizer
)
# run ADMM to solve problem
result_q = admm_q.solve(qp)
print(result.prettyprint())
plt.clf()
plt.plot(result_q.state.residuals)
plt.xlabel("Iterations")
plt.ylabel("Residuals")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
# 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(circuit)
circuit.draw()
# Matplotlib Drawing
circuit.draw(output='mpl')
# 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(output='mpl')
# Draw the circuit with reversed bit order
circuit.draw(output='mpl', reverse_bits=True)
# Draw the circuit without barriers
circuit.draw(output='mpl', plot_barriers=False)
# Draw the circuit without barriers and reverse bit order
circuit.draw(output='mpl', plot_barriers=False, reverse_bits=True)
# Set line length to 80 for above circuit
circuit.draw(output='text')
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
circuit.draw(output='mpl', style=style)
# Scale the mpl output to 1/2 the normal size
circuit.draw(output='mpl', scale=0.5)
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(circuit, output='mpl', plot_barriers=False)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.transpiler.passes import RemoveBarriers
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.barrier()
circuit.h(0)
circuit = RemoveBarriers()(circuit)
circuit.draw('mpl')
|
https://github.com/Qottmann/Quantum-anomaly-detection
|
Qottmann
|
import time
import numpy as np
import qiskit
from qiskit.opflow import X,Z,I
from qiskit.opflow.state_fns import StateFn, CircuitStateFn
import matplotlib.pyplot as plt
from scipy import sparse
import scipy.sparse.linalg.eigen.arpack as arp
%matplotlib inline
# copypaste niccolo's code
def QNKron(N,op1,op2,pos):
'''
Tensor product operator (Qiskit Pauli operators)
returns tensor product of op1,op2 on sites pos,pos+1 and identity on remaining sites
N:number of sites
op1,op2: Pauli operators on neighboring sites
pos: site to insert op1
'''
temp=np.array([I]*(N))
temp[pos]=op1
if pos!=(N-1):
temp[pos+1]=op2
mat=1
for j in range(N):
mat=mat^temp[j]
return mat
def QHIsing(N,lam,p):
'''
Quantum Ising Hamiltonian (1D) with transverse field (Qiskit Pauli operators)
N:number of sites
lam: transverse field)
'''
H=-QNKron(N,Z,Z,0)-lam*QNKron(N,X,I,0)-p*QNKron(N,Z,I,0)
for i in range(1,N-1):
H=H-QNKron(N,Z,Z,i)-lam*QNKron(N,X,I,i)-p*QNKron(N,Z,I,i)
H=H-lam*QNKron(N,X,I,N-1)-p*QNKron(N,Z,I,N-1)
return H
def NKron(N,op1,op2,pos):
'''
Tensor product operator
returns tensor product of op1,op2 on sites pos,pos+1 and identity on remaining sites
N:number of sites
op1,op2: Pauli operators on neighboring sites
pos: site to insert op1
'''
ide=np.eye(2)
temp=np.array([ide]*(N),dtype=np.complex128)
temp[pos,:,:]=op1
# if pos!=(N-1):
temp[(pos+1)%N,:,:]=op2
mat=1
for j in range(N):
mat=np.kron(mat,temp[j])
return mat
def Mag(N): #magnetization operator (numpy array)
sz=np.array([[1,0],[0,-1]])
M=np.zeros((2**N,2**N))
for i in range(N):
M=M+NKron(N,sz,np.eye(2),i)
return M/N
def QMag(N): #magnetization operator (Qiskit operator)
M=QNKron(N,Z,I,0)
for i in range(1,N):
M=M+QNKron(N,Z,I,i)
return M/N
def ising_groundstate(L, J, g, p):
"""For comparison: obtain ground state energy from exact diagonalization.
Exponentially expensive in L, only works for small enough `L` <~ 20.
"""
if L >= 20:
warnings.warn("Large L: Exact diagonalization might take a long time!")
# get single site operaors
sx = sparse.csr_matrix(np.array([[0., 1.], [1., 0.]]))
sz = sparse.csr_matrix(np.array([[1., 0.], [0., -1.]]))
id = sparse.csr_matrix(np.eye(2))
sx_list = [] # sx_list[i] = kron([id, id, ..., id, sx, id, .... id])
sz_list = []
for i_site in range(L):
x_ops = [id] * L
z_ops = [id] * L
x_ops[i_site] = sx
z_ops[i_site] = sz
X = x_ops[0]
Z = z_ops[0]
for j in range(1, L):
X = sparse.kron(X, x_ops[j], 'csr')
Z = sparse.kron(Z, z_ops[j], 'csr')
sx_list.append(X)
sz_list.append(Z)
H_zz = sparse.csr_matrix((2**L, 2**L))
H_x = sparse.csr_matrix((2**L, 2**L))
for i in range(L - 1):
H_zz = H_zz + J*sz_list[i] * sz_list[(i + 1) % L]
for i in range(L):
H_x = H_x + g*sx_list[i] +p*sz_list[i]
H = - H_zz - H_x
E, V = arp.eigsh(H, k=1, which='SA', return_eigenvectors=True, ncv=20)
return V[:,0], E[0], H
def sort_vals(vals):
""" vals is (unsorted) dictionary of parameters from VQE ansatz circuit, this returns sorted values as list """
indices = np.array([_.index for _ in vals]) # unordered list of indices from the ParameterVectorElement(Theta(INDEX))
vals_sorted = np.array([vals[_] for _ in vals]) # unordered list of values (but same ordering as indices)
return vals_sorted[np.argsort(indices)]
def init_vqe(vals):
return qiskit.circuit.library.EfficientSU2(L, reps=3).assign_parameters(sort_vals(vals))
L = 6
VQE_vals = np.load(f'params_VQE_ising_N{L}.npy', allow_pickle=True).item()
lambdas = np.array([_ for _ in VQE_vals]) # list of lambda values (the items in the dictionary)
# note that Rike calls them gs
mag = QMag(L) #magnetization operator (Qiskit)
Smag=Mag(L) #magnetization operator (numpy)
# the ~ is the adjoint, but also it turns the is_measurement attribute to True
~StateFn(mag)
# state is technically a circuit, that prepares the ground state via VQE circuit
#state.draw() # uncomment to see, but is very long
Qen=np.zeros(len(lambdas)); Sen=np.zeros(len(lambdas)) #energies
Qmags=np.zeros(len(lambdas)); Smags=np.zeros(len(lambdas)) #magnetizations
for j,lambda0 in enumerate(lambdas):
print(lambda0)
H = QHIsing(L,np.float32(lambda0),1e-4) # build Hamiltonian Op
state = init_vqe(VQE_vals[lambda0])
StateFn(state)
meas_outcome = ~StateFn(mag) @ StateFn(state)
Qmags[j]=meas_outcome.eval()
e_outcome = ~StateFn(H) @ StateFn(state)
Qen[j]=e_outcome.eval()
init_state, E, ham = ising_groundstate(L, 1., np.float(lambda0),1e-4)
Sen[j]=E
Smags[j]=init_state.T.conj()@Smag@init_state #Magnetization with Numpy results
lambdas = np.array([_ for _ in VQE_vals],dtype=np.float) # list of lambda values (the items in the dictionary)
plt.figure(1,dpi=220)
plt.scatter(lambdas,Sen)
plt.scatter(lambdas,Qen)
plt.xscale("log")
plt.ylabel("GS energy")
plt.xlabel("Mag. field")
plt.legend(["Sparse","Qiskit"])
plt.grid()
print(Sen,Qen)
plt.figure(2,dpi=220)
plt.scatter(lambdas,Smags)
plt.scatter(lambdas,Qmags)
plt.xscale('log')
plt.ylabel("Magnetization")
plt.xlabel("Mag. field")
plt.legend(["Sparse","Qiskit"])
plt.grid()
print(Smags,Qmags)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/ionq-samples/getting-started
|
ionq-samples
|
%%capture
# First, we install the essential libraries to our current Python runtime.
# "%%capture" (above) captures and in this case, hides the output of this
# cell, so you can comment it out if you need help debugging this step.
%pip install pennylane pennylane-ionq
import pennylane as qml
import os
from getpass import getpass
# Before you begin, get your API key from https://cloud.ionq.com/settings/keys
# If your API key is stored as "IONQ_API_KEY" in your local environment, this
# should find it. Otherwise you'll be prompted to enter your API key manually.
api_key = os.getenv('IONQ_API_KEY') or getpass('Enter your IonQ API key: ')
# We need to specify the device where the circuit will be executed. In
# this case we're using the `ionq.simulator`, but if you have QPU access you
# can specify it here to run the job on a QPU directly.
dev = qml.device(
'ionq.simulator',
api_key=api_key,
wires=2,
)
@qml.qnode(dev)
def circuit():
qml.Hadamard(wires=0)
qml.CNOT(wires=[0, 1])
return qml.counts()
fig, ax = qml.draw_mpl(circuit, style='sketch')()
results = circuit()
print({k: v.item() for k, v in results.items()})
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector, plot_bloch_vector, plot_histogram
from qiskit.compiler import transpile, assemble
from qiskit.tools.monitor import job_monitor
from qiskit.providers.ibmq import least_busy
import matplotlib
import numpy as np
%pylab inline
qc = QuantumCircuit(4,3)
qc.x(3)
qc.h(range(3))
reps = 1
for count in range(3):
for i in range (reps):
qc.cp(pi/4, count, 3)
reps *= 2
qc.barrier()
qc.draw('mpl')
def inv_qft(qc, n):
for qubit in range (n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-pi/(2*(j-m)), m, j)
qc.h(j)
inv_qft(qc, 3)
qc.barrier()
qc.measure(range(3), range(3))
qc.draw('mpl')
qasm_sim = Aer.get_backend('qasm_simulator')
shots = 1
qobj = assemble(qc, qasm_sim)
results = qasm_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 4 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
shots = 1024
transpiled_circuit = transpile(qc, backend)
qobj = assemble(transpiled_circuit, shots=shots)
job = backend.run(qobj)
job_monitor(job, interval=2)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.algorithms import AmplificationProblem
# 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 that is used in running the algorithm
# (Algorithm circuits are wrapped in a gate to appear in composition as a block
# so we have to decompose() the op to see it expanded into its component gates.)
problem.grover_operator.decompose().draw(output='mpl')
from qiskit.algorithms import Grover
from qiskit.primitives import Sampler
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
print('Result type:', type(result))
print()
print('Success!' if result.oracle_evaluation else 'Failure!')
print('Top measurement:', result.top_measurement)
from qiskit.quantum_info import Statevector
oracle = Statevector.from_label('11')
problem = AmplificationProblem(oracle, is_good_state=['11'])
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
print('Result type:', type(result))
print()
print('Success!' if result.oracle_evaluation else 'Failure!')
print('Top measurement:', result.top_measurement)
problem.grover_operator.oracle.decompose().draw(output='mpl')
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)
display(problem.grover_operator.oracle.decompose().draw(output='mpl'))
except MissingOptionalLibraryError as ex:
print(ex)
import numpy as np
# Specifying `state_preparation`
# to prepare a superposition of |01>, |10>, and |11>
oracle = QuantumCircuit(3)
oracle.ccz(0, 1, 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 being in state 1, thus add both possibilities for the last qubit
problem = AmplificationProblem(oracle, state_preparation=state_preparation, is_good_state=['110', '111'])
# state_preparation
print('state preparation circuit:')
problem.grover_operator.state_preparation.draw(output='mpl')
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
print('Success!' if result.oracle_evaluation else 'Failure!')
print('Top measurement:', result.top_measurement)
oracle = QuantumCircuit(5)
oracle.ccz(0, 1, 2)
oracle.draw(output='mpl')
from qiskit.circuit.library import GroverOperator
grover_op = GroverOperator(oracle, insert_barriers=True)
grover_op.decompose().draw(output='mpl')
grover_op = GroverOperator(oracle, reflection_qubits=[0, 1, 2], insert_barriers=True)
grover_op.decompose().draw(output='mpl')
# a 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(problem.is_good_state('11'))
# a list of integer good state
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
good_state = [0, 1]
problem = AmplificationProblem(oracle, is_good_state=good_state)
print(problem.is_good_state('11'))
from qiskit.quantum_info import Statevector
# `Statevector` good state
oracle = QuantumCircuit(2)
oracle.cz(0, 1)
good_state = Statevector.from_label('11')
problem = AmplificationProblem(oracle, is_good_state=good_state)
print(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=good_state)
print(problem.is_good_state('11'))
# 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)
iterations = Grover.optimal_num_iterations(num_solutions=1, num_qubits=8)
iterations
def to_DIAMACS_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_DIAMACS_CNF_format)
problem.post_processing([1, 0, 1])
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import numpy as np
from qiskit import Aer
from qiskit_aqua import run_algorithm
from qiskit_aqua.input import EnergyInput
from qiskit_aqua.translators.ising import graphpartition
from qiskit_aqua.algorithms import ExactEigensolver
np.random.seed(100)
num_nodes = 4
w = graphpartition.random_graph(num_nodes, edge_prob=0.8, weight_range=10)
print(w)
def brute_force():
# use the brute-force way to generate the oracle
def bitfield(n, L):
result = np.binary_repr(n, L)
return [int(digit) for digit in result] # [2:] to chop off the "0b" part
L = num_nodes
max = 2**L
minimal_v = np.inf
for i in range(max):
cur = bitfield(i, L)
how_many_nonzero = np.count_nonzero(cur)
if how_many_nonzero * 2 != L: # not balanced
continue
cur_v = graphpartition.objective_value(np.array(cur), w)
if cur_v < minimal_v:
minimal_v = cur_v
return minimal_v
sol = brute_force()
print("objective value computed by the brute-force method is", sol)
qubit_op, offset = graphpartition.get_graphpartition_qubitops(w)
algo_input = EnergyInput(qubit_op)
params = {
'problem': {'name': 'ising'},
'algorithm': {'name': 'ExactEigensolver'}
}
result = run_algorithm(params, algo_input)
x = graphpartition.sample_most_likely(result['eigvecs'][0])
# check against the oracle
ising_sol = graphpartition.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 0, 1])
print("objective value computed by ExactEigensolver is", graphpartition.objective_value(x, w))
algo = ExactEigensolver(algo_input.qubit_op, k=1, aux_operators=[])
result = algo.run()
x = graphpartition.sample_most_likely(result['eigvecs'][0])
# check against the oracle
ising_sol = graphpartition.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [0, 1, 0, 1])
print("objective value computed by the ExactEigensolver is", graphpartition.objective_value(x, w))
algorithm_cfg = {
'name': 'VQE',
'operator_mode': 'matrix'
}
optimizer_cfg = {
'name': 'SPSA',
'max_trials': 300
}
var_form_cfg = {
'name': 'RY',
'depth': 5,
'entanglement': 'linear'
}
params = {
'problem': {'name': 'ising', 'random_seed': 10598},
'algorithm': algorithm_cfg,
'optimizer': optimizer_cfg,
'variational_form': var_form_cfg
}
backend = Aer.get_backend('statevector_simulator')
result = run_algorithm(params, algo_input, backend=backend)
x = graphpartition.sample_most_likely(result['eigvecs'][0])
# check against the oracle
ising_sol = graphpartition.get_graph_solution(x)
np.testing.assert_array_equal(ising_sol, [1, 0, 0, 1])
print("objective value computed by VQE is", graphpartition.objective_value(x, w))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
|
https://github.com/matteoacrossi/oqs-jupyterbook
|
matteoacrossi
|
import numpy as np
from bokeh.layouts import row, column
from bokeh.models import ColumnDataSource, Slider, CustomJS, Text
from bokeh.plotting import Figure, show
from bokeh.io import output_notebook
def c1t(t, lam = 1., R = .25, c10 = 1.):
expt = lam * t / 2
if R == .5:
output = c10 * np.exp(-expt) * (1 + expt)
#elif R == 0:
# output = c10 * np.exp(-expt) * (np.cosh(expt * sqt) + np.sinh(expt*sqt) / sqt)
elif R < .5:
sqt = np.sqrt(1-2*R)
output = c10 * np.exp(-expt) * (np.cosh(expt * sqt) + np.sinh(expt*sqt) / sqt)
elif R > .5:
sqt = np.sqrt(-1+2*R)
output = c10 * np.exp(-expt) * (np.cos(expt * sqt) + np.sin(expt*sqt) / sqt)
return output
def lorentzian_J(w, R = .25, omega_0 = 0.):
# assume gamma_0 = 1
if R == 0.:
return 1
lam = 1. / R
output = 1/(2*np.pi) * lam**2 / ((omega_0 - w)**2 + lam**2)
return output
len(Rrange)
ts = [t*0.02 for t in range(0, 500)]
Rrange = [r*.02 for r in range(0,int(1/.02))] + [r * .1 for r in range(10,100)] + [r for r in range(10,100+1)]
Rrange = np.array(Rrange)
Rrange_str = [str(i) for i in range(len(Rrange))]
Rrange_str_R = ['R = {:.2f}'.format(R) for R in Rrange] # truncate to two decimals
# make a dictionary of form {'0': 0.0, '1': 0.2, .. }
Rrange_dict = {Rrange_str[i]:Rrange.round(2)[i] for i,_ in enumerate(Rrange)} # rounding to two decimals
ys = {r_str:[c1t(t, R = Rrange[int(r_str)])**2 for t in ts] for r_str in Rrange_str}
#ys = {r_str:[c1t(t, R = Rrange_dict[r_str])**2 for t in ts] for r_str in Rrange_str}
initial_r = Rrange_str[1]
ys
ws = [t*0.02 for t in range(-250, 250)]
js = {r_str:[lorentzian_J(w, R = Rrange[int(r_str)]) for w in ws] for r_str in Rrange_str}
rs = {Rrange_str[i] : [Rrange_str_R[i]] for i,_ in enumerate(Rrange)}
# Wrap the data in two ColumnDataSources
source_visible = ColumnDataSource(data=dict(
x = ts, y = ys[initial_r]))
source_available = ColumnDataSource(data=ys)
# Wrap the data in two ColumnDataSources
source_visible2 = ColumnDataSource(data=dict(
x = ws, y = js[initial_r]))
source_available2 = ColumnDataSource(data=js)
# Define plot elements
plot = Figure(plot_width=400, plot_height=400, x_range=(-.1, 10), y_range=(-.01, 1))
plot.line('x', 'y', source=source_visible, legend_label="ρ₁₁", line_width=3, line_alpha=0.6)
plot2 = Figure(plot_width=400, plot_height=400, x_range=(-5, 5), y_range=(-.001, .2))
plot2.line('x', 'y', source=source_visible2, legend_label="J(omega)",
line_width=3, line_alpha=0.6, line_color="#f01001")
# Add text
text_source = ColumnDataSource({'r_value': ['%s' % Rrange_str_R[1]]})
r_available = ColumnDataSource(data=rs)
text = Text(x=9.5, y=.8, text='r_value', text_font_size='15pt', text_align='right')
plot.add_glyph(text_source, text)
# Add slider
slider = Slider(value=int(initial_r),
start=np.min([int(i) for i in ys.keys()]),
end=np.max([int(i) for i in ys.keys()]),
step=1,
show_value = False,
title = 'R')
# Define CustomJS callback, which updates the plot based on selected function
# by updating the source_visible ColumnDataSource.
slider.callback = CustomJS(
args=dict(source_visible=source_visible,
source_available=source_available,
source_visible2=source_visible2,
source_available2=source_available2,
text_source = text_source,
r_available = r_available), code="""
var r_idx = cb_obj.value;
// Get the data from the data sources
var data_visible = source_visible.data;
var data_available = source_available.data;
var data_visible2 = source_visible2.data;
var data_available2 = source_available2.data;
// Change y-axis data according to the selected value
data_visible.y = data_available[r_idx];
data_visible2.y = data_available2[r_idx];
// text
text_source.data = {'r_value': [String(r_available.data[r_idx])]};
// Update the plot
source_visible.change.emit();
source_visible2.change.emit();
""")
layout = row(column(plot,slider), plot2)
output_notebook()
show(layout)
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test the optimize-1q-gate pass"""
import unittest
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Optimize1qGates, Unroller
from qiskit.converters import circuit_to_dag
from qiskit.test import QiskitTestCase
from qiskit.circuit import Parameter
from qiskit.circuit.library import U1Gate, U2Gate, U3Gate, UGate, PhaseGate
from qiskit.transpiler.exceptions import TranspilerError
from qiskit.transpiler.target import Target
class TestOptimize1qGates(QiskitTestCase):
"""Test for 1q gate optimizations."""
def test_dont_optimize_id(self):
"""Identity gates are like 'wait' commands.
They should never be optimized (even without barriers).
See: https://github.com/Qiskit/qiskit-terra/issues/2373
"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.i(qr)
circuit.i(qr)
dag = circuit_to_dag(circuit)
pass_ = Optimize1qGates()
after = pass_.run(dag)
self.assertEqual(dag, after)
def test_optimize_h_gates_pass_manager(self):
"""Transpile: qr:--[H]-[H]-[H]-- == qr:--[u2]--"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.h(qr[0])
circuit.h(qr[0])
expected = QuantumCircuit(qr)
expected.append(U2Gate(0, np.pi), [qr[0]])
passmanager = PassManager()
passmanager.append(Unroller(["u2"]))
passmanager.append(Optimize1qGates())
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_1q_gates_collapse_identity_equivalent(self):
"""test optimize_1q_gates removes u1(2*pi) rotations.
See: https://github.com/Qiskit/qiskit-terra/issues/159
"""
# ┌───┐┌───┐┌────────┐┌───┐┌─────────┐┌───────┐┌─────────┐┌───┐ ┌─┐»
# qr_0: ┤ H ├┤ X ├┤ U1(2π) ├┤ X ├┤ U1(π/2) ├┤ U1(π) ├┤ U1(π/2) ├┤ X ├─────────┤M├»
# └───┘└─┬─┘└────────┘└─┬─┘└─────────┘└───────┘└─────────┘└─┬─┘┌───────┐└╥┘»
# qr_1: ───────■──────────────■───────────────────────────────────■──┤ U1(π) ├─╫─»
# └───────┘ ║ »
# cr: 2/═══════════════════════════════════════════════════════════════════════╩═»
# 0 »
# «
# «qr_0: ────────────
# « ┌───────┐┌─┐
# «qr_1: ┤ U1(π) ├┤M├
# « └───────┘└╥┘
# «cr: 2/══════════╩═
# « 1
qr = QuantumRegister(2, "qr")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.append(U1Gate(2 * np.pi), [qr[0]])
qc.cx(qr[1], qr[0])
qc.append(U1Gate(np.pi / 2), [qr[0]]) # these three should combine
qc.append(U1Gate(np.pi), [qr[0]]) # to identity then
qc.append(U1Gate(np.pi / 2), [qr[0]]) # optimized away.
qc.cx(qr[1], qr[0])
qc.append(U1Gate(np.pi), [qr[1]])
qc.append(U1Gate(np.pi), [qr[1]])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
dag = circuit_to_dag(qc)
simplified_dag = Optimize1qGates().run(dag)
num_u1_gates_remaining = len(simplified_dag.named_nodes("u1"))
self.assertEqual(num_u1_gates_remaining, 0)
def test_optimize_1q_gates_collapse_identity_equivalent_phase_gate(self):
"""test optimize_1q_gates removes u1(2*pi) rotations.
See: https://github.com/Qiskit/qiskit-terra/issues/159
"""
# ┌───┐┌───┐┌───────┐┌───┐┌────────┐┌──────┐┌────────┐┌───┐ ┌─┐»
# qr_0: ┤ H ├┤ X ├┤ P(2π) ├┤ X ├┤ P(π/2) ├┤ P(π) ├┤ P(π/2) ├┤ X ├────────┤M├»
# └───┘└─┬─┘└───────┘└─┬─┘└────────┘└──────┘└────────┘└─┬─┘┌──────┐└╥┘»
# qr_1: ───────■─────────────■────────────────────────────────■──┤ P(π) ├─╫─»
# └──────┘ ║ »
# cr: 2/══════════════════════════════════════════════════════════════════╩═»
# 0 »
# «
# «qr_0: ───────────
# « ┌──────┐┌─┐
# «qr_1: ┤ P(π) ├┤M├
# « └──────┘└╥┘
# «cr: 2/═════════╩═
# « 1
qr = QuantumRegister(2, "qr")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.cx(qr[1], qr[0])
qc.append(PhaseGate(2 * np.pi), [qr[0]])
qc.cx(qr[1], qr[0])
qc.append(PhaseGate(np.pi / 2), [qr[0]]) # these three should combine
qc.append(PhaseGate(np.pi), [qr[0]]) # to identity then
qc.append(PhaseGate(np.pi / 2), [qr[0]]) # optimized away.
qc.cx(qr[1], qr[0])
qc.append(PhaseGate(np.pi), [qr[1]])
qc.append(PhaseGate(np.pi), [qr[1]])
qc.measure(qr[0], cr[0])
qc.measure(qr[1], cr[1])
dag = circuit_to_dag(qc)
simplified_dag = Optimize1qGates(["p", "u2", "u", "cx", "id"]).run(dag)
num_u1_gates_remaining = len(simplified_dag.named_nodes("p"))
self.assertEqual(num_u1_gates_remaining, 0)
def test_ignores_conditional_rotations(self):
"""Conditional rotations should not be considered in the chain.
qr0:--[U1]-[U1]-[U1]-[U1]- qr0:--[U1]-[U1]-
|| || || ||
cr0:===.================== == cr0:===.====.===
|| ||
cr1:========.============= cr1:========.===
"""
qr = QuantumRegister(1, "qr")
cr = ClassicalRegister(2, "cr")
circuit = QuantumCircuit(qr, cr)
circuit.append(U1Gate(0.1), [qr]).c_if(cr, 1)
circuit.append(U1Gate(0.2), [qr]).c_if(cr, 3)
circuit.append(U1Gate(0.3), [qr])
circuit.append(U1Gate(0.4), [qr])
dag = circuit_to_dag(circuit)
expected = QuantumCircuit(qr, cr)
expected.append(U1Gate(0.1), [qr]).c_if(cr, 1)
expected.append(U1Gate(0.2), [qr]).c_if(cr, 3)
expected.append(U1Gate(0.7), [qr])
pass_ = Optimize1qGates()
after = pass_.run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_ignores_conditional_rotations_phase_gates(self):
"""Conditional rotations should not be considered in the chain.
qr0:--[U1]-[U1]-[U1]-[U1]- qr0:--[U1]-[U1]-
|| || || ||
cr0:===.================== == cr0:===.====.===
|| ||
cr1:========.============= cr1:========.===
"""
qr = QuantumRegister(1, "qr")
cr = ClassicalRegister(2, "cr")
circuit = QuantumCircuit(qr, cr)
circuit.append(PhaseGate(0.1), [qr]).c_if(cr, 1)
circuit.append(PhaseGate(0.2), [qr]).c_if(cr, 3)
circuit.append(PhaseGate(0.3), [qr])
circuit.append(PhaseGate(0.4), [qr])
dag = circuit_to_dag(circuit)
expected = QuantumCircuit(qr, cr)
expected.append(PhaseGate(0.1), [qr]).c_if(cr, 1)
expected.append(PhaseGate(0.2), [qr]).c_if(cr, 3)
expected.append(PhaseGate(0.7), [qr])
pass_ = Optimize1qGates(["p", "u2", "u", "cx", "id"])
after = pass_.run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_in_the_back(self):
"""Optimizations can be in the back of the circuit.
See https://github.com/Qiskit/qiskit-terra/issues/2004.
qr0:--[U1]-[U1]-[H]-- qr0:--[U1]-[H]--
"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U1Gate(0.3), [qr])
circuit.append(U1Gate(0.4), [qr])
circuit.h(qr)
dag = circuit_to_dag(circuit)
expected = QuantumCircuit(qr)
expected.append(U1Gate(0.7), [qr])
expected.h(qr)
pass_ = Optimize1qGates()
after = pass_.run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_in_the_back_phase_gate(self):
"""Optimizations can be in the back of the circuit.
See https://github.com/Qiskit/qiskit-terra/issues/2004.
qr0:--[U1]-[U1]-[H]-- qr0:--[U1]-[H]--
"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(PhaseGate(0.3), [qr])
circuit.append(PhaseGate(0.4), [qr])
circuit.h(qr)
dag = circuit_to_dag(circuit)
expected = QuantumCircuit(qr)
expected.append(PhaseGate(0.7), [qr])
expected.h(qr)
pass_ = Optimize1qGates(["p", "u2", "u", "cx", "id"])
after = pass_.run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_single_parameterized_circuit(self):
"""Parameters should be treated as opaque gates."""
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
theta = Parameter("theta")
qc.append(U1Gate(0.3), [qr])
qc.append(U1Gate(0.4), [qr])
qc.append(U1Gate(theta), [qr])
qc.append(U1Gate(0.1), [qr])
qc.append(U1Gate(0.2), [qr])
dag = circuit_to_dag(qc)
expected = QuantumCircuit(qr)
expected.append(U1Gate(theta + 1.0), [qr])
after = Optimize1qGates().run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_parameterized_circuits(self):
"""Parameters should be treated as opaque gates."""
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
theta = Parameter("theta")
qc.append(U1Gate(0.3), [qr])
qc.append(U1Gate(0.4), [qr])
qc.append(U1Gate(theta), [qr])
qc.append(U1Gate(0.1), [qr])
qc.append(U1Gate(0.2), [qr])
qc.append(U1Gate(theta), [qr])
qc.append(U1Gate(0.3), [qr])
qc.append(U1Gate(0.2), [qr])
dag = circuit_to_dag(qc)
expected = QuantumCircuit(qr)
expected.append(U1Gate(2 * theta + 1.5), [qr])
after = Optimize1qGates().run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_parameterized_expressions_in_circuits(self):
"""Expressions of Parameters should be treated as opaque gates."""
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
theta = Parameter("theta")
phi = Parameter("phi")
sum_ = theta + phi
product_ = theta * phi
qc.append(U1Gate(0.3), [qr])
qc.append(U1Gate(0.4), [qr])
qc.append(U1Gate(theta), [qr])
qc.append(U1Gate(phi), [qr])
qc.append(U1Gate(sum_), [qr])
qc.append(U1Gate(product_), [qr])
qc.append(U1Gate(0.3), [qr])
qc.append(U1Gate(0.2), [qr])
dag = circuit_to_dag(qc)
expected = QuantumCircuit(qr)
expected.append(U1Gate(2 * theta + 2 * phi + product_ + 1.2), [qr])
after = Optimize1qGates().run(dag)
self.assertEqual(circuit_to_dag(expected), after)
def test_global_phase_u3_on_left(self):
"""Check proper phase accumulation with instruction with no definition."""
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
u1 = U1Gate(0.1)
u1.definition.global_phase = np.pi / 2
qc.append(u1, [0])
qc.global_phase = np.pi / 3
qc.append(U3Gate(0.1, 0.2, 0.3), [0])
dag = circuit_to_dag(qc)
after = Optimize1qGates().run(dag)
self.assertAlmostEqual(after.global_phase, 5 * np.pi / 6, 8)
def test_global_phase_u_on_left(self):
"""Check proper phase accumulation with instruction with no definition."""
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
u1 = U1Gate(0.1)
u1.definition.global_phase = np.pi / 2
qc.append(u1, [0])
qc.global_phase = np.pi / 3
qc.append(UGate(0.1, 0.2, 0.3), [0])
dag = circuit_to_dag(qc)
after = Optimize1qGates(["u1", "u2", "u", "cx"]).run(dag)
self.assertAlmostEqual(after.global_phase, 5 * np.pi / 6, 8)
class TestOptimize1qGatesParamReduction(QiskitTestCase):
"""Test for 1q gate optimizations parameter reduction, reduce n in Un"""
def test_optimize_u3_to_u2(self):
"""U3(pi/2, pi/3, pi/4) -> U2(pi/3, pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, np.pi / 3, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U2Gate(np.pi / 3, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates())
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_to_u2_round(self):
"""U3(1.5707963267948961, 1.0471975511965971, 0.7853981633974489) -> U2(pi/3, pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(1.5707963267948961, 1.0471975511965971, 0.7853981633974489), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U2Gate(np.pi / 3, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates())
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_to_u1(self):
"""U3(0, 0, pi/4) -> U1(pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U1Gate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates())
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_to_phase_gate(self):
"""U3(0, 0, pi/4) -> U1(pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(PhaseGate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["p", "u2", "u", "cx", "id"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_to_u1_round(self):
"""U3(1e-16, 1e-16, pi/4) -> U1(pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(1e-16, 1e-16, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U1Gate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates())
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_to_phase_round(self):
"""U3(1e-16, 1e-16, pi/4) -> U1(pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(1e-16, 1e-16, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(PhaseGate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["p", "u2", "u", "cx", "id"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
class TestOptimize1qGatesBasis(QiskitTestCase):
"""Test for 1q gate optimizations parameter reduction with basis"""
def test_optimize_u3_basis_u3(self):
"""U3(pi/2, pi/3, pi/4) (basis[u3]) -> U3(pi/2, pi/3, pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, np.pi / 3, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u3"]))
result = passmanager.run(circuit)
self.assertEqual(circuit, result)
def test_optimize_u3_basis_u(self):
"""U3(pi/2, pi/3, pi/4) (basis[u3]) -> U(pi/2, pi/3, pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, np.pi / 3, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u"]))
result = passmanager.run(circuit)
expected = QuantumCircuit(qr)
expected.append(UGate(np.pi / 2, np.pi / 3, np.pi / 4), [qr[0]])
self.assertEqual(expected, result)
def test_optimize_u3_basis_u2(self):
"""U3(pi/2, 0, pi/4) -> U2(0, pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U2Gate(0, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_basis_u2_with_target(self):
"""U3(pi/2, 0, pi/4) -> U2(0, pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U2Gate(0, np.pi / 4), [qr[0]])
target = Target(num_qubits=1)
target.add_instruction(U2Gate(Parameter("theta"), Parameter("phi")))
passmanager = PassManager()
passmanager.append(Optimize1qGates(target=target))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u_basis_u(self):
"""U(pi/2, pi/3, pi/4) (basis[u3]) -> U(pi/2, pi/3, pi/4)"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(UGate(np.pi / 2, np.pi / 3, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u"]))
result = passmanager.run(circuit)
self.assertEqual(circuit, result)
def test_optimize_u3_basis_u2_cx(self):
"""U3(pi/2, 0, pi/4) -> U2(0, pi/4). Basis [u2, cx]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, 0, np.pi / 4), [qr[0]])
circuit.cx(qr[0], qr[1])
expected = QuantumCircuit(qr)
expected.append(U2Gate(0, np.pi / 4), [qr[0]])
expected.cx(qr[0], qr[1])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2", "cx"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u_basis_u2_cx(self):
"""U(pi/2, 0, pi/4) -> U2(0, pi/4). Basis [u2, cx]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(UGate(np.pi / 2, 0, np.pi / 4), [qr[0]])
circuit.cx(qr[0], qr[1])
expected = QuantumCircuit(qr)
expected.append(U2Gate(0, np.pi / 4), [qr[0]])
expected.cx(qr[0], qr[1])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2", "cx"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u1_basis_u2_u3(self):
"""U1(pi/4) -> U3(0, 0, pi/4). Basis [u2, u3]."""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U1Gate(np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2", "u3"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u1_basis_u2_u(self):
"""U1(pi/4) -> U3(0, 0, pi/4). Basis [u2, u3]."""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U1Gate(np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(UGate(0, 0, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2", "u"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u1_basis_u2(self):
"""U1(pi/4) -> Raises. Basis [u2]"""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U1Gate(np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2"]))
with self.assertRaises(TranspilerError):
_ = passmanager.run(circuit)
def test_optimize_u3_basis_u2_u1(self):
"""U3(pi/2, 0, pi/4) -> U2(0, pi/4). Basis [u2, u1]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U2Gate(0, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2", "u1"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_basis_u2_phase_gate(self):
"""U3(pi/2, 0, pi/4) -> U2(0, pi/4). Basis [u2, p]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(np.pi / 2, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U2Gate(0, np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u2", "p"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_basis_u1(self):
"""U3(0, 0, pi/4) -> U1(pi/4). Basis [u1]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U1Gate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u1"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_basis_phase_gate(self):
"""U3(0, 0, pi/4) -> p(pi/4). Basis [p]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(U3Gate(0, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(PhaseGate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["p"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u_basis_u1(self):
"""U(0, 0, pi/4) -> U1(pi/4). Basis [u1]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(UGate(0, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(U1Gate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["u1"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u_basis_phase_gate(self):
"""U(0, 0, pi/4) -> p(pi/4). Basis [p]."""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.append(UGate(0, 0, np.pi / 4), [qr[0]])
expected = QuantumCircuit(qr)
expected.append(PhaseGate(np.pi / 4), [qr[0]])
passmanager = PassManager()
passmanager.append(Optimize1qGates(["p"]))
result = passmanager.run(circuit)
self.assertEqual(expected, result)
def test_optimize_u3_with_parameters(self):
"""Test correct behavior for u3 gates."""
phi = Parameter("φ")
alpha = Parameter("α")
qr = QuantumRegister(1, "qr")
qc = QuantumCircuit(qr)
qc.ry(2 * phi, qr[0])
qc.ry(alpha, qr[0])
qc.ry(0.1, qr[0])
qc.ry(0.2, qr[0])
passmanager = PassManager([Unroller(["u3"]), Optimize1qGates()])
result = passmanager.run(qc)
expected = QuantumCircuit(qr)
expected.append(U3Gate(2 * phi, 0, 0), [qr[0]])
expected.append(U3Gate(alpha, 0, 0), [qr[0]])
expected.append(U3Gate(0.3, 0, 0), [qr[0]])
self.assertEqual(expected, result)
if __name__ == "__main__":
unittest.main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
dc = pulse.DriveChannel
d0, d1, d2, d3, d4 = dc(0), dc(1), dc(2), dc(3), dc(4)
with pulse.build(name='pulse_programming_in') as pulse_prog:
pulse.play([1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1], d0)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d1)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0], d2)
pulse.play([1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0], d3)
pulse.play([1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0], d4)
pulse_prog.draw()
|
https://github.com/Qiskit-Extensions/qiskit-ibm-experiment
|
Qiskit-Extensions
|
from qiskit import IBMQ
provider = IBMQ.load_account()
service = provider.experiment
experiment_data = service.experiment(experiment_id = '5524b504-2f59-11ed-a7c7-bc97e15b08d0')
print(experiment_data['creation_datetime'])
print(experiment_data['metadata']['user'])
from qiskit_ibm_experiment import IBMExperimentService
service = IBMExperimentService()
experiment_data = service.experiment(experiment_id = '5524b504-2f59-11ed-a7c7-bc97e15b08d0')
print(experiment_data.creation_datetime)
print(experiment_data.metadata['user'])
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
import pickle
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.ignis.mitigation import expectation_value
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("./")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
scale_factors = [1.0, 2.0, 3.0]
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="lq")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder_init110(qc, targets=[0, 1, 2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = zne_wrapper(t3_st_qcs, scale_factors=scale_factors)
print("created zne_qcs (length:", len(zne_qcs), ")")
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
t3_zne_qcs[-3].draw("mpl")
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
# print("provider:", provider)
# backend = provider.get_backend("ibmq_jakarta")
shots = 1 << 13
reps = 1 # unused
# Number of trotter steps
print("trotter step: ", num_steps)
# execute: reps = 1
job = execute(t3_zne_qcs, backend, shots=shots) # 毎回チェック: ここちゃんと変えた？
print('Job ID', job.job_id())
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
mit_results = meas_fitter.filter.apply(job.result())
zne_expvals = zne_decoder(num_qubits, mit_results)
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
rho = expvals_to_valid_rho(num_qubits, zne_expvals)
fidelity = state_fidelity(rho, target_state)
print(fidelity)
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
from qiskit import *
from oracle_generation import generate_oracle
get_bin = lambda x, n: format(x, 'b').zfill(n)
def gen_circuits(min,max,size):
circuits = []
secrets = []
ORACLE_SIZE = size
for i in range(min,max+1):
cur_str = get_bin(i,ORACLE_SIZE-1)
(circuit, secret) = generate_oracle(ORACLE_SIZE,False,3,cur_str)
circuits.append(circuit)
secrets.append(secret)
return (circuits, secrets)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import QuantumCircuit
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import NormalDistribution
# can be used in case a principal component analysis has been done to derive the uncertainty model, ignored in this example.
A = np.eye(2)
b = np.zeros(2)
# specify the number of qubits that are used to represent the different dimenions of the uncertainty model
num_qubits = [2, 2]
# specify the lower and upper bounds for the different dimension
low = [0, 0]
high = [0.12, 0.24]
mu = [0.12, 0.24]
sigma = 0.01 * np.eye(2)
# construct corresponding distribution
bounds = list(zip(low, high))
u = NormalDistribution(num_qubits, mu, sigma, bounds)
# plot contour of probability density function
x = np.linspace(low[0], high[0], 2 ** num_qubits[0])
y = np.linspace(low[1], high[1], 2 ** num_qubits[1])
z = u.probabilities.reshape(2 ** num_qubits[0], 2 ** num_qubits[1])
plt.contourf(x, y, z)
plt.xticks(x, size=15)
plt.yticks(y, size=15)
plt.grid()
plt.xlabel("$r_1$ (%)", size=15)
plt.ylabel("$r_2$ (%)", size=15)
plt.colorbar()
plt.show()
# specify cash flow
cf = [1.0, 2.0]
periods = range(1, len(cf) + 1)
# plot cash flow
plt.bar(periods, cf)
plt.xticks(periods, size=15)
plt.yticks(size=15)
plt.grid()
plt.xlabel("periods", size=15)
plt.ylabel("cashflow ($)", size=15)
plt.show()
# estimate real value
cnt = 0
exact_value = 0.0
for x1 in np.linspace(low[0], high[0], pow(2, num_qubits[0])):
for x2 in np.linspace(low[1], high[1], pow(2, num_qubits[1])):
prob = u.probabilities[cnt]
for t in range(len(cf)):
# evaluate linear approximation of real value w.r.t. interest rates
exact_value += prob * (
cf[t] / pow(1 + b[t], t + 1)
- (t + 1) * cf[t] * np.dot(A[:, t], np.asarray([x1, x2])) / pow(1 + b[t], t + 2)
)
cnt += 1
print("Exact value: \t%.4f" % exact_value)
# specify approximation factor
c_approx = 0.125
# create fixed income pricing application
from qiskit_finance.applications.estimation import FixedIncomePricing
fixed_income = FixedIncomePricing(
num_qubits=num_qubits,
pca_matrix=A,
initial_interests=b,
cash_flow=cf,
rescaling_factor=c_approx,
bounds=bounds,
uncertainty_model=u,
)
fixed_income._objective.draw()
fixed_income_circ = QuantumCircuit(fixed_income._objective.num_qubits)
# load probability distribution
fixed_income_circ.append(u, range(u.num_qubits))
# apply function
fixed_income_circ.append(fixed_income._objective, range(fixed_income._objective.num_qubits))
fixed_income_circ.draw()
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
# construct amplitude estimation
problem = fixed_income.to_estimation_problem()
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (fixed_income.interpret(result)))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### added x gate ###
qc.x(qubit)
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = Statevector(qc)
plot_state_qsphere(state)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from IPython.display import HTML
HTML('<div align="center"><iframe width="560" height="315" align="centre" src="https://www.youtube.com/embed/hOlOY7NyMfs?start=75&end=126" frameborder="0" allowfullscreen></iframe></div>')
# Brute force period finding algorithm
def find_period_classical(x, N):
n = 1
t = x
while t != 1:
t *= x
t %= N
n += 1
return n
import random, itertools
# Sieve of Eratosthenes algorithm
def sieve( ):
D = { }
yield 2
for q in itertools.islice(itertools.count(3), 0, None, 2):
p = D.pop(q, None)
if p is None:
D[q*q] = q
yield q
else:
x = p + q
while x in D or not (x&1):
x += p
D[x] = p
# Creates a list of prime numbers up to the given argument
def get_primes_sieve(n):
return list(itertools.takewhile(lambda p: p<n, sieve()))
def get_semiprime(n):
primes = get_primes_sieve(n)
l = len(primes)
p = primes[random.randrange(l)]
q = primes[random.randrange(l)]
return p*q
N = get_semiprime(1000)
print("semiprime N =",N)
import math
def shors_algorithm_classical(N):
x = random.randint(0,N) # step one
if(math.gcd(x,N) != 1): # step two
return x,0,math.gcd(x,N),N/math.gcd(x,N)
r = find_period_classical(x,N) # step three
while(r % 2 != 0):
r = find_period_classical(x,N)
p = math.gcd(x**int(r/2)+1,N) # step four, ignoring the case where (x^(r/2) +/- 1) is a multiple of N
q = math.gcd(x**int(r/2)-1,N)
return x,r,p,q
x,r,p,q = shors_algorithm_classical(N)
print("semiprime N = ",N,", coprime x = ",x,", period r = ",r,", prime factors = ",p," and ",q,sep="")
from qiskit import Aer
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, register, get_backend, compile
from qiskit.tools.visualization import plot_histogram, circuit_drawer
# qc = quantum circuit, qr = quantum register, cr = classical register, a = 2, 7, 8, 11 or 13
def circuit_amod15(qc,qr,cr,a):
if a == 2:
qc.cswap(qr[4],qr[3],qr[2])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[1],qr[0])
elif a == 7:
qc.cswap(qr[4],qr[1],qr[0])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[3],qr[2])
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[1])
qc.cx(qr[4],qr[0])
elif a == 8:
qc.cswap(qr[4],qr[1],qr[0])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[3],qr[2])
elif a == 11: # this is included for completeness
qc.cswap(qr[4],qr[2],qr[0])
qc.cswap(qr[4],qr[3],qr[1])
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[1])
qc.cx(qr[4],qr[0])
elif a == 13:
qc.cswap(qr[4],qr[3],qr[2])
qc.cswap(qr[4],qr[2],qr[1])
qc.cswap(qr[4],qr[1],qr[0])
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[1])
qc.cx(qr[4],qr[0])
# qc = quantum circuit, qr = quantum register, cr = classical register, a = 2, 7, 8, 11 or 13
def circuit_aperiod15(qc,qr,cr,a):
if a == 11:
circuit_11period15(qc,qr,cr)
return
# Initialize q[0] to |1>
qc.x(qr[0])
# Apply a**4 mod 15
qc.h(qr[4])
# controlled identity on the remaining 4 qubits, which is equivalent to doing nothing
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[0])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply a**2 mod 15
qc.h(qr[4])
# controlled unitary
qc.cx(qr[4],qr[2])
qc.cx(qr[4],qr[0])
# feed forward
if cr[0] == 1:
qc.u1(math.pi/2.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[1])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply a mod 15
qc.h(qr[4])
# controlled unitary.
circuit_amod15(qc,qr,cr,a)
# feed forward
if cr[1] == 1:
qc.u1(math.pi/2.,qr[4])
if cr[0] == 1:
qc.u1(math.pi/4.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[2])
def circuit_11period15(qc,qr,cr):
# Initialize q[0] to |1>
qc.x(qr[0])
# Apply a**4 mod 15
qc.h(qr[4])
# controlled identity on the remaining 4 qubits, which is equivalent to doing nothing
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[0])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply a**2 mod 15
qc.h(qr[4])
# controlled identity on the remaining 4 qubits, which is equivalent to doing nothing
# feed forward
if cr[0] == 1:
qc.u1(math.pi/2.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[1])
# reinitialise q[4] to |0>
qc.reset(qr[4])
# Apply 11 mod 15
qc.h(qr[4])
# controlled unitary.
qc.cx(qr[4],qr[3])
qc.cx(qr[4],qr[1])
# feed forward
if cr[1] == 1:
qc.u1(math.pi/2.,qr[4])
if cr[0] == 1:
qc.u1(math.pi/4.,qr[4])
qc.h(qr[4])
# measure
qc.measure(qr[4],cr[2])
q = QuantumRegister(5, 'q')
c = ClassicalRegister(5, 'c')
shor = QuantumCircuit(q, c)
circuit_aperiod15(shor,q,c,7)
backend = Aer.get_backend('qasm_simulator')
sim_job = execute([shor], backend)
sim_result = sim_job.result()
sim_data = sim_result.get_counts(shor)
plot_histogram(sim_data)
|
https://github.com/Harcipan/QAI_GroverSim
|
Harcipan
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Kraus, SuperOp
from qiskit.visualization import plot_histogram
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_aer import AerSimulator
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (
NoiseModel,
QuantumError,
ReadoutError,
depolarizing_error,
pauli_error,
thermal_relaxation_error,
)
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = service.backend("ibm_brisbane")
noise_model = NoiseModel.from_backend(backend)
# Construct a 1-qubit bit-flip and phase-flip errors
p_error = 0.05
bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])
phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])
print(bit_flip)
print(phase_flip)
# Compose two bit-flip and phase-flip errors
bitphase_flip = bit_flip.compose(phase_flip)
print(bitphase_flip)
# Tensor product two bit-flip and phase-flip errors with
# bit-flip on qubit-0, phase-flip on qubit-1
error2 = phase_flip.tensor(bit_flip)
print(error2)
# Convert to Kraus operator
bit_flip_kraus = Kraus(bit_flip)
print(bit_flip_kraus)
# Convert to Superoperator
phase_flip_sop = SuperOp(phase_flip)
print(phase_flip_sop)
# Convert back to a quantum error
print(QuantumError(bit_flip_kraus))
# Check conversion is equivalent to original error
QuantumError(bit_flip_kraus) == bit_flip
# Measurement misassignment probabilities
p0given1 = 0.1
p1given0 = 0.05
ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])
# Create an empty noise model
noise_model = NoiseModel()
# Add depolarizing error to all single qubit u1, u2, u3 gates
error = depolarizing_error(0.05, 1)
noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])
# Print noise model info
print(noise_model)
# Create an empty noise model
noise_model = NoiseModel()
# Add depolarizing error to all single qubit u1, u2, u3 gates on qubit 0 only
error = depolarizing_error(0.05, 1)
noise_model.add_quantum_error(error, ['u1', 'u2', 'u3'], [0])
# Print noise model info
print(noise_model)
# System Specification
n_qubits = 4
circ = QuantumCircuit(n_qubits)
# Test Circuit
circ.h(0)
for qubit in range(n_qubits - 1):
circ.cx(qubit, qubit + 1)
circ.measure_all()
print(circ)
# Ideal simulator and execution
sim_ideal = AerSimulator()
result_ideal = sim_ideal.run(circ).result()
plot_histogram(result_ideal.get_counts(0))
# Example error probabilities
p_reset = 0.03
p_meas = 0.1
p_gate1 = 0.05
# QuantumError objects
error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])
error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])
error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])
error_gate2 = error_gate1.tensor(error_gate1)
# Add errors to noise model
noise_bit_flip = NoiseModel()
noise_bit_flip.add_all_qubit_quantum_error(error_reset, "reset")
noise_bit_flip.add_all_qubit_quantum_error(error_meas, "measure")
noise_bit_flip.add_all_qubit_quantum_error(error_gate1, ["u1", "u2", "u3"])
noise_bit_flip.add_all_qubit_quantum_error(error_gate2, ["cx"])
print(noise_bit_flip)
# Create noisy simulator backend
sim_noise = AerSimulator(noise_model=noise_bit_flip)
# Transpile circuit for noisy basis gates
passmanager = generate_preset_pass_manager(optimization_level=3, backend=sim_noise)
circ_tnoise = passmanager.run(circ)
# Run and get counts
result_bit_flip = sim_noise.run(circ_tnoise).result()
counts_bit_flip = result_bit_flip.get_counts(0)
# Plot noisy output
plot_histogram(counts_bit_flip)
# T1 and T2 values for qubits 0-3
T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
T2s = np.random.normal(70e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
# Truncate random T2s <= T1s
T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])
# Instruction times (in nanoseconds)
time_u1 = 0 # virtual gate
time_u2 = 50 # (single X90 pulse)
time_u3 = 100 # (two X90 pulses)
time_cx = 300
time_reset = 1000 # 1 microsecond
time_measure = 1000 # 1 microsecond
# QuantumError objects
errors_reset = [thermal_relaxation_error(t1, t2, time_reset)
for t1, t2 in zip(T1s, T2s)]
errors_measure = [thermal_relaxation_error(t1, t2, time_measure)
for t1, t2 in zip(T1s, T2s)]
errors_u1 = [thermal_relaxation_error(t1, t2, time_u1)
for t1, t2 in zip(T1s, T2s)]
errors_u2 = [thermal_relaxation_error(t1, t2, time_u2)
for t1, t2 in zip(T1s, T2s)]
errors_u3 = [thermal_relaxation_error(t1, t2, time_u3)
for t1, t2 in zip(T1s, T2s)]
errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(
thermal_relaxation_error(t1b, t2b, time_cx))
for t1a, t2a in zip(T1s, T2s)]
for t1b, t2b in zip(T1s, T2s)]
# Add errors to noise model
noise_thermal = NoiseModel()
for j in range(4):
noise_thermal.add_quantum_error(errors_reset[j], "reset", [j])
noise_thermal.add_quantum_error(errors_measure[j], "measure", [j])
noise_thermal.add_quantum_error(errors_u1[j], "u1", [j])
noise_thermal.add_quantum_error(errors_u2[j], "u2", [j])
noise_thermal.add_quantum_error(errors_u3[j], "u3", [j])
for k in range(4):
noise_thermal.add_quantum_error(errors_cx[j][k], "cx", [j, k])
print(noise_thermal)
# Run the noisy simulation
sim_thermal = AerSimulator(noise_model=noise_thermal)
# Transpile circuit for noisy basis gates
passmanager = generate_preset_pass_manager(optimization_level=3, backend=sim_thermal)
circ_tthermal = passmanager.run(circ)
# Run and get counts
result_thermal = sim_thermal.run(circ_tthermal).result()
counts_thermal = result_thermal.get_counts(0)
# Plot noisy output
plot_histogram(counts_thermal)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import BasicAer, transpile, QuantumRegister, ClassicalRegister, QuantumCircuit
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.measure(0, 0)
qc.x(0).c_if(cr, 0)
qc.measure(0, 0)
qc.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.library import MCXGate
gate = MCXGate(4)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(5)
circuit.append(gate, [0, 1, 4, 2, 3])
circuit.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import FakeVigoV2
backend = FakeVigoV2()
qc = QuantumCircuit(2, 1)
qc.h(0)
qc.x(1)
qc.cp(np.pi/4, 0, 1)
qc.h(0)
qc.measure([0], [0])
qc.draw(output='mpl')
|
https://github.com/Interlin-q/diskit
|
Interlin-q
|
from qiskit import BasicAer
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
N = 15
shor = Shor(N)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
ret = shor.run(quantum_instance)
print("The list of factors of {} as computed by the Shor's algorithm is {}.".format(N, ret['factors'][0]))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import sympy
from sympy import *
import numpy as np
from numpy import random
import math
import scipy
init_printing(use_unicode=True)
from matplotlib import pyplot as plt
%matplotlib inline
from sympy.physics.quantum.dagger import Dagger
from sympy.physics.quantum import TensorProduct as tp
from mpmath import factorial as fact
import io
import base64
#from IPython.core.display import display, HTML, clear_output
from IPython import *
from ipywidgets import interactive, interact, fixed, interact_manual, widgets
import csv
import importlib
import scipy.interpolate
from mpl_toolkits.mplot3d import Axes3D, proj3d
from itertools import product, combinations
from matplotlib.patches import FancyArrowPatch
from matplotlib import cm, colors
from sympy.functions.special.tensor_functions import KroneckerDelta
from scipy.linalg import polar, lapack
import mpmath
# constantes físicas
e = 1.60217662*10**-19 # C (carga elementar)
k = 8.9875517923*10**9 # Nm^2/C^2 (constante de Coulomb)
eps0 = 8.8541878128*10**-12 #F/m (permissividade do vácuo)
mu0 = 1.25663706212*10**-6 # N/A^2 (permeabilidade do vácuo)
h = 6.626069*10**-34 # Js (constante de Planck)
heV = h/e # em eV
hb = h/(2*math.pi) # hbar
hbeV = hb/e # em eV
c = 2.99792458*10**8 # m/s (velocidade da luz no vácuo)
G = 6.6742*10**-11 # Nm^2/kg^2 (constante gravitacional)
kB = 1.38065*10**-23 # J/K (constante de Boltzmann)
me = 9.109382*10**-31 # kg (massa do elétron)
mp = 1.6726219*10**-27 # kg (massa do próton)
mn = 1.67492749804*10**-27 # kg (massa do nêutron)
mT = 5.9722*10**24 # kg (massa da Terra)
mS = 1.98847*10**30 # kg (massa do Sol)
u = 1.660538921*10**-27 # kg (unidade de massa atômica)
dTS = 1.496*10**11 # m (distância Terra-Sol)
rT = 6.3781*10**6 # m (raio da Terra)
sSB = 5.670374419*10**-8 # W⋅m−2⋅K−4 (constante de Stefan-Boltzmann)
Ri = 10973734.848575922 # m^-1 (constante de Rydberg)
al = (k*e**2)/(hb*c) # ~1/137.035999084 (constante de estrutura fina)
a0=(hb**2)/(me*k*e**2) # ~ 0.52917710^-10 m (raio de Bohr)
ge = 2 # (fator giromagnetico do eletron)
gp = 5.58 # (fator giromagnetico do proton)
def id(n):
'''retorna a matriz identidade nxn'''
id = zeros(n,n)
for j in range(0,n):
id[j,j] = 1
return id
#id(2)
def pauli(j):
'''retorna as matrizes de Pauli'''
if j == 1:
return Matrix([[0,1],[1,0]])
elif j == 2:
return Matrix([[0,-1j],[1j,0]])
elif j == 3:
return Matrix([[1,0],[0,-1]])
#pauli(1), pauli(2), pauli(3)
def tr(A):
'''retorna o traço de uma matriz'''
d = A.shape[0]
tr = 0
for j in range(0,d):
tr += A[j,j]
return tr
#tr(pauli(1))
def comm(A,B):
'''retorna a função comutador'''
return A*B-B*A
#comm(pauli(1),pauli(2))
def acomm(A,B):
'''retorna a função anti-comutador'''
return A*B+B*A
#acomm(pauli(1),pauli(2))
def cb(n,j):
'''retorna um vetor da base padrão de C^n'''
vec = zeros(n,1)
vec[j] = 1
return vec
#cb(2,0)
def proj(psi):
'''retorna o projeto no vetor psi'''
d = psi.shape[0]
P = zeros(d,d)
for j in range(0,d):
for k in range(0,d):
P[j,k] = psi[j]*conjugate(psi[k])
return P
#proj(cb(2,0))
def bell(j,k):
if j == 0 and k == 0:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,0))+tp(cb(2,1),cb(2,1)))
elif j == 0 and k == 1:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,1))+tp(cb(2,1),cb(2,0)))
elif j == 1 and k == 0:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,1))-tp(cb(2,1),cb(2,0)))
elif j == 1 and k == 1:
return (1/sqrt(2))*(tp(cb(2,0),cb(2,0))-tp(cb(2,1),cb(2,1)))
#bell(0,0), bell(0,1), bell(1,0), bell(1,1)
def inner_product(v,w):
d = len(v); ip = 0
for j in range(0,d):
ip += conjugate(v[j])*w[j]
return ip
#a,b,c,d = symbols("a b c d"); v = [b,a]; w = [c,d]; inner_product(v,w)
def norm(v):
d = len(v)
return sqrt(inner_product(v,v))
#v = [2,2]; norm(v)
def tp(x,y):
return tensorproduct(x,y)
A = tp(pauli(3),pauli(1)); A
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(12)
for idx in range(5):
qc.h(idx)
qc.cx(idx, idx+5)
qc.cx(1, 7)
qc.x(8)
qc.cx(1, 9)
qc.x(7)
qc.cx(1, 11)
qc.swap(6, 11)
qc.swap(6, 9)
qc.swap(6, 10)
qc.x(6)
qc.draw('mpl')
|
https://github.com/DavidFitzharris/EmergingTechnologies
|
DavidFitzharris
|
import pennylane as qml
import numpy as np
from pennylane.optimize import AdamOptimizer
import matplotlib.pyplot as plt
def loadData(filename):
return_data = []
return_label = []
with open(filename, 'r') as file:
for row in file:
data = row.split(' ')[:-1]
data = [ float(d) for d in data ]
label = int(row.split(' ')[-1])
return_data.append(data)
return_label.append(label)
return np.array(return_data), np.array(return_label)
X_train, Y_train = loadData('./data/training_set.txt')
X_test, Y_test = loadData('./data/testing_set.txt')
print(X_train[:10])
print(Y_train[:10])
plt.scatter(X_train[:, 0], X_train[:, 1], c=Y_train)
plt.show()
print(f'total datas: {len(X_train)}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
def rotateDatas(X, Y):
gen_X = []
gen_Y = []
for i, data in enumerate(X):
gen_X.append(list(reversed(data)))
gen_Y.append(Y[i])
return np.array(gen_X), np.array(gen_Y)
X_train_rotate, Y_train_rotate = rotateDatas(X_train, Y_train)
plt.scatter(X_train_rotate[:, 0], X_train_rotate[:, 1], c=Y_train_rotate)
plt.show()
# Concat datas
X_temp = np.zeros((X_train.shape[0] * 2, len(X_train[0])))
X_temp[0:40,:] = X_train
X_temp[40:80,] = X_train_rotate
Y_temp = np.zeros((Y_train.shape[0] * 2))
Y_temp[0:40] = Y_train
Y_temp[40:80] = Y_train_rotate
plt.scatter(X_temp[:, 0], X_temp[:, 1], c=Y_temp)
plt.show()
X_train = X_temp
Y_train = Y_temp
print(f'total datas: {len(X_train)}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2) ** 0.5
# Z_train = (X_train[:, 0] ** 2 + X_train[:, 1] ** 2)
temp = np.zeros((X_train.shape[0], len(X_train[0]) + 1))
temp[:, :-1] = X_train
temp[:, -1] = Z_train
X_train2 = temp
print(X_train2[:10])
Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2) ** 0.5
# Z_test = (X_test[:, 0] ** 2 + X_test[:, 1] ** 2)
temp = np.zeros((X_test.shape[0], len(X_test[0]) + 1))
temp[:, :-1] = X_test
temp[:, -1] = Z_test
X_test2 = temp
print(X_test2[:10])
def plot3D(X, Y):
fig = plt.figure(figsize=(10, 10))
ax = fig.add_subplot(111, projection='3d')
ax.scatter(
X[:, 0], X[:, 1], X[:, 2],
zdir='z', s=30, c=Y, depthshade=True
)
plt.show()
plot3D(X_train2, Y_train)
print(f'total datas: {len(X_train2)}')
print(f'label 0 datas: {len(list(filter(lambda x: x==0, Y_train)))}')
print(f'label 0 datas: {len(list(filter(lambda x: x==1, Y_train)))}')
qubits_num = 3
layers_num = 2
dev = qml.device("default.qubit",wires=qubits_num)
class VQC:
def __init__(self):
# 3 => U3(theta, phi, lambda)
self.params = (0.01 * np.random.randn(layers_num, qubits_num, 3))
self.bestparams = self.params
self.bestcost = 10
self.opt = AdamOptimizer(0.205)
self.weights = []
self.costs = []
self.accuracies = []
def fit(self, X_train, Y_train, epoch=300):
batch_size = 20
for turn in range(epoch):
# Update the weights by one optimizer step
batch_index = np.random.randint(0, len(X_train), (batch_size,))
X_train_batch = X_train[batch_index]
Y_train_batch = Y_train[batch_index]
self.params = self.opt.step(lambda v: cost(v, X_train_batch, Y_train_batch), self.params)
cost_now = cost(self.params, X_train, Y_train)
acc_now = accuracy(self.params, X_train, Y_train)
if cost_now < self.bestcost:
self.bestcost = cost_now
self.bestparams = self.params
self.weights.append(self.params)
self.costs.append(cost_now)
self.accuracies.append(acc_now)
print(
"Turn: {:5d} | Cost: {:0.7f} | Accuracy: {:0.2f}% ".format(
turn + 1, cost_now, acc_now * 100
))
def score(self, X_test, Y_test):
predictions = [ predict(self.bestparams, data) for data in X_test ]
acc = accuracy(self.bestparams, X_test, Y_test)
print("FINAL ACCURACY: {:0.2f}%".format(acc * 100))
@qml.qnode(dev)
def circuit(params, data):
angles = [ i * np.pi for i in data ]
for i in range(qubits_num):
qml.RX(angles[i], wires=i)
qml.Rot( *params[0, i], wires=i )
qml.CZ(wires=[1, 0])
qml.CZ(wires=[1, 2])
qml.CZ(wires=[0, 2])
for i in range(qubits_num):
qml.Rot( *params[1, i], wires=i )
# PauliZ measure => 1 -> |0> while -1 -> |1>
return qml.expval(qml.PauliZ(0)), qml.expval(qml.PauliZ(1)), qml.expval(qml.PauliZ(2))
import qiskit
import numpy as np
from qiskit import QuantumCircuit
from qiskit import Aer, execute
unitary_backend = Aer.get_backend('unitary_simulator')
qasm_backend = Aer.get_backend('qasm_simulator')
def predict(params, data):
qcircuit = QuantumCircuit(3, 3)
qubits = qcircuit.qubits
for i, d in enumerate(data):
qcircuit.rx(d * np.pi, qubits[i])
for i in range(qubits_num):
qcircuit.u3(*params[0][i], qubits[i])
qcircuit.cz(qubits[0], qubits[1])
qcircuit.cz(qubits[1], qubits[2])
qcircuit.cz(qubits[0], qubits[2])
for i in range(qubits_num):
qcircuit.u3(*params[1][i], qubits[i])
# the measurement
qcircuit.measure([0, 1, 2], [0, 1, 2])
# job execution
shots = 1000
job_sim = execute(qcircuit, qasm_backend, shots=shots)
result_sim = job_sim.result()
counts = result_sim.get_counts(qcircuit)
p1 = (counts.get('100', 0) + counts.get('111', 0) + counts.get('101', 0) + counts.get('110',0)) / shots
if p1 > 0.5:
return 1
else:
return 0
def cost(weights, datas, labels):
loss = 0
for i, data in enumerate(datas):
# like [-1, 1, 1]
measured = circuit(weights, data)
p = measured[2]
if labels[i] == 0:
loss += (1 - p) ** 2
else:
loss += (-1 - p) ** 2
return loss / len(datas)
def accuracy(weights, datas, labels):
predictions = [ predict(weights, data) for data in datas ]
acc = 0
for i, p in enumerate(predictions):
if p == labels[i]:
acc += 1
return acc / len(predictions)
vqc = VQC()
vqc.fit(X_train2, Y_train, epoch=200)
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added h gate ###
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/unitaryfund/mitiq
|
unitaryfund
|
# Copyright (C) Unitary Fund
#
# This source code is licensed under the GPL license (v3) found in the
# LICENSE file in the root directory of this source tree.
"""Unit tests for scaling noise by unitary folding."""
import numpy as np
import pytest
from cirq import (
Circuit,
GridQubit,
InsertStrategy,
LineQubit,
equal_up_to_global_phase,
inverse,
ops,
ry,
rz,
testing,
)
from pyquil import Program, gates
from pyquil.quilbase import Pragma
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.quantum_info.operators import Operator
from sympy import Symbol
from mitiq.interface import (
CircuitConversionError,
convert_from_mitiq,
convert_to_mitiq,
)
from mitiq.utils import _equal
from mitiq.zne.scaling.folding import (
UnfoldableCircuitError,
_apply_fold_mask,
_create_fold_mask,
_create_weight_mask,
_default_weight,
_fold_all,
_squash_moments,
fold_all,
fold_gates_at_random,
fold_global,
)
def test_squash_moments_two_qubits():
"""Tests squashing moments in a two-qubit circuit with 'staggered' single
qubit gates.
"""
# Test circuit:
# 0: ───────H───────H───────H───────H───────H───
#
# 1: ───H───────H───────H───────H───────H───────
# Get the test circuit
d = 10
qreg = LineQubit.range(2)
circuit = Circuit()
for i in range(d):
circuit.insert(0, ops.H.on(qreg[i % 2]), strategy=InsertStrategy.NEW)
assert len(circuit) == d
# Squash the moments
squashed = _squash_moments(circuit)
assert len(squashed) == d // 2
def test_squash_moments_returns_new_circuit_and_doesnt_modify_input_circuit():
"""Tests that squash moments returns a new circuit and doesn't modify the
input circuit.
"""
qbit = GridQubit(0, 0)
circ = Circuit(ops.H.on(qbit))
squashed = _squash_moments(circ)
assert len(squashed) == 1
assert circ is not squashed
assert _equal(circ, Circuit(ops.H.on(qbit)))
def test_squash_moments_never_increases_moments():
"""Squashes moments for several random circuits and ensures the squashed
circuit always <= # moments as the input circuit.
"""
for _ in range(50):
circuit = testing.random_circuit(
qubits=5, n_moments=8, op_density=0.75
)
squashed = _squash_moments(circuit)
assert len(squashed) <= len(circuit)
@pytest.mark.parametrize("scale_factor", (1, 3, 5))
@pytest.mark.parametrize("with_measurements", (True, False))
def test_fold_all(scale_factor, with_measurements):
# Test circuit
# 0: ───H───@───@───
# │ │
# 1: ───H───X───@───
# │
# 2: ───H───X───X───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.X.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
if with_measurements:
circ.append(ops.measure_each(*qreg))
folded = fold_all(circ, scale_factor=scale_factor)
correct = Circuit(
[ops.H.on_each(*qreg)] * scale_factor,
[ops.CNOT.on(qreg[0], qreg[1])] * scale_factor,
[ops.X.on(qreg[2])] * scale_factor,
[ops.TOFFOLI.on(*qreg)] * scale_factor,
)
if with_measurements:
correct.append(ops.measure_each(*qreg))
assert _equal(folded, correct, require_qubit_equality=True)
def test_fold_all_exclude_with_gates():
circuit = Circuit(
[ops.H(LineQubit(0))],
[ops.CNOT(*LineQubit.range(2))],
[ops.TOFFOLI(*LineQubit.range(3))],
)
folded = fold_all(circuit, scale_factor=3.0, exclude={ops.H})
correct = Circuit(
[ops.H(LineQubit(0))],
[ops.CNOT(*LineQubit.range(2))] * 3,
[ops.TOFFOLI(*LineQubit.range(3))] * 3,
)
assert _equal(folded, correct, require_qubit_equality=True)
folded = fold_all(circuit, scale_factor=3.0, exclude={ops.CNOT})
correct = Circuit(
[ops.H(LineQubit(0))] * 3,
[ops.CNOT(*LineQubit.range(2))],
[ops.TOFFOLI(*LineQubit.range(3))] * 3,
)
assert _equal(folded, correct, require_qubit_equality=True)
folded = fold_all(circuit, scale_factor=5.0, exclude={ops.H, ops.TOFFOLI})
correct = Circuit(
[ops.H(LineQubit(0))],
[ops.CNOT(*LineQubit.range(2))] * 5,
[ops.TOFFOLI(*LineQubit.range(3))],
)
assert _equal(folded, correct, require_qubit_equality=True)
def test_fold_all_exclude_with_strings():
circuit = Circuit(
[ops.H(LineQubit(0))],
[ops.CNOT(*LineQubit.range(2))],
[ops.TOFFOLI(*LineQubit.range(3))],
)
folded = fold_all(circuit, scale_factor=3.0, exclude={"single"})
correct = Circuit(
[ops.H(LineQubit(0))],
[ops.CNOT(*LineQubit.range(2))] * 3,
[ops.TOFFOLI(*LineQubit.range(3))] * 3,
)
assert _equal(folded, correct, require_qubit_equality=True)
folded = fold_all(circuit, scale_factor=3.0, exclude={"double"})
correct = Circuit(
[ops.H(LineQubit(0))] * 3,
[ops.CNOT(*LineQubit.range(2))],
[ops.TOFFOLI(*LineQubit.range(3))] * 3,
)
assert _equal(folded, correct, require_qubit_equality=True)
folded = fold_all(circuit, scale_factor=5.0, exclude={"single", "triple"})
correct = Circuit(
[ops.H(LineQubit(0))],
[ops.CNOT(*LineQubit.range(2))] * 5,
[ops.TOFFOLI(*LineQubit.range(3))],
)
assert _equal(folded, correct, require_qubit_equality=True)
@pytest.mark.parametrize("skip", (frozenset((0, 1)), frozenset((0, 3, 7))))
def test_fold_all_skip_moments(skip):
circuit = testing.random_circuit(
qubits=3,
n_moments=7,
op_density=1,
random_state=1,
gate_domain={ops.H: 1, ops.X: 1, ops.CNOT: 2},
)
folded = _fold_all(circuit, skip_moments=skip)
correct = Circuit()
for i, moment in enumerate(circuit):
times_to_add = 3 * (i not in skip) + (i in skip)
for _ in range(times_to_add):
correct += moment
assert _equal(
_squash_moments(folded),
_squash_moments(correct),
require_qubit_equality=True,
)
def test_folding_with_bad_scale_factor():
for fold_function in (
fold_all,
fold_gates_at_random,
):
with pytest.raises(ValueError, match="Requires scale_factor >= 1"):
fold_function(Circuit(), scale_factor=0.0)
def test_create_mask_with_bad_scale_factor():
with pytest.raises(ValueError, match="Requires scale_factor >= 1"):
_create_fold_mask([1], scale_factor=0.999)
def test_fold_all_bad_exclude():
with pytest.raises(ValueError, match="Do not know how to parse"):
fold_all(
Circuit(),
scale_factor=1.0,
exclude=frozenset(("not a gate name",)),
)
with pytest.raises(ValueError, match="Do not know how to exclude"):
fold_all(Circuit(), scale_factor=1.0, exclude=frozenset((7,)))
@pytest.mark.parametrize(
"fold_method",
[
fold_gates_at_random,
fold_global,
],
)
def test_fold_with_intermediate_measurements_raises_error(fold_method):
"""Tests local folding functions raise an error on circuits with
intermediate measurements.
"""
qbit = LineQubit(0)
circ = Circuit([ops.H.on(qbit)], [ops.measure(qbit)], [ops.T.on(qbit)])
with pytest.raises(
UnfoldableCircuitError,
match="Circuit contains intermediate measurements",
):
fold_method(circ, scale_factor=3.0)
@pytest.mark.parametrize(
"fold_method",
[
fold_gates_at_random,
fold_global,
],
)
def test_fold_with_channels_raises_error(fold_method):
"""Tests local folding functions raise an error on circuits with
non-invertible channels (which are not measurements).
"""
qbit = LineQubit(0)
circ = Circuit(
ops.H.on(qbit), ops.depolarize(p=0.1).on(qbit), ops.measure(qbit)
)
with pytest.raises(
UnfoldableCircuitError, match="Circuit contains non-invertible"
):
fold_method(circ, scale_factor=3.0)
@pytest.mark.parametrize(
"fold_method",
[
fold_gates_at_random,
fold_global,
],
)
def test_parametrized_circuit_folding(fold_method):
"""Checks if the circuit is folded as expected when the circuit operations
have a valid inverse.
"""
theta = Symbol("theta")
q = LineQubit(0)
ansatz_circ = Circuit(ry(theta).on(q))
folded_circ = fold_method(ansatz_circ, scale_factor=3.0)
expected_circ = Circuit(ry(theta).on(q), ry(-theta).on(q), ry(theta).on(q))
assert _equal(folded_circ, expected_circ)
@pytest.mark.parametrize(
"fold_method",
[
fold_gates_at_random,
fold_global,
],
)
def test_parametrized_circuit_folding_terminal_measurement(fold_method):
"""Checks if the circuit with a terminal measurement is folded as expected
when the circuit operations have a valid inverse.
"""
theta = Symbol("theta")
q = LineQubit(0)
ansatz_circ = Circuit(ry(theta).on(q), ops.measure(q))
folded_circ = fold_method(ansatz_circ, scale_factor=3.0)
expected_circ = Circuit(
ry(theta).on(q), ry(-theta).on(q), ry(theta).on(q), ops.measure(q)
)
assert _equal(folded_circ, expected_circ)
@pytest.mark.parametrize(
"fold_method",
[
fold_gates_at_random,
fold_global,
],
)
def test_errors_raised_parametrized_circuits(fold_method):
"""Checks if proper error is raised in a symbolic circuit when it cannot
be folded.
"""
theta = Symbol("theta")
q = LineQubit(0)
ansatz_circ = Circuit(ry(theta).on(q), ops.measure(q), rz(theta).on(q))
with pytest.raises(
UnfoldableCircuitError,
match="Circuit contains intermediate measurements",
):
fold_method(ansatz_circ, scale_factor=3.0)
qbit = LineQubit(0)
circ = Circuit(
ry(theta).on(q), ops.depolarize(p=0.1).on(qbit), ops.measure(qbit)
)
with pytest.raises(
UnfoldableCircuitError, match="Circuit contains non-invertible"
):
fold_method(circ, scale_factor=3.0)
def test_fold_gates_at_random_no_stretch():
"""Tests folded circuit is identical for a scale factor of one."""
circuit = testing.random_circuit(qubits=3, n_moments=10, op_density=0.99)
folded = fold_gates_at_random(circuit, scale_factor=1, seed=None)
assert _equal(folded, _squash_moments(circuit))
def test_fold_gates_at_random_seed_one_qubit():
"""Test for folding gates at random on a one qubit circuit with a seed for
repeated behavior.
"""
qubit = LineQubit(0)
circuit = Circuit([ops.X.on(qubit), ops.Y.on(qubit), ops.Z.on(qubit)])
# Small scale
folded = fold_gates_at_random(circuit, scale_factor=1.4, seed=3)
correct = Circuit(
[ops.X.on(qubit)], [ops.Y.on(qubit)] * 3, [ops.Z.on(qubit)]
)
assert _equal(folded, correct)
# Medium scale, fold two gates
folded = fold_gates_at_random(circuit, scale_factor=2.5, seed=2)
correct = Circuit(
[ops.X.on(qubit)],
[ops.Y.on(qubit)] * 3,
[ops.Z.on(qubit)] * 3,
)
assert _equal(folded, correct)
# Max scale, fold three gates
folded = fold_gates_at_random(circuit, scale_factor=3, seed=3)
correct = Circuit(
[ops.X.on(qubit)] * 3,
[ops.Y.on(qubit)] * 3,
[ops.Z.on(qubit)] * 3,
)
assert _equal(folded, correct)
def test_fold_random_min_stretch():
"""Tests that folding at random with min scale returns a copy of the
input circuit.
"""
# Test circuit
# 0: ───H───@───@───
# │ │
# 1: ───H───X───@───
# │
# 2: ───H───T───X───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
folded = fold_gates_at_random(circ, scale_factor=1, seed=1)
assert _equal(folded, circ)
assert folded is not circ
def test_fold_random_max_stretch():
"""Tests that folding at random with max scale folds all gates on a
multi-qubit circuit.
"""
# Test circuit
# 0: ───H───@───@───
# │ │
# 1: ───H───X───@───
# │
# 2: ───H───T───X───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
folded = fold_gates_at_random(circ, scale_factor=3, seed=1)
correct = Circuit(
[ops.H.on_each(*qreg)] * 3,
[ops.CNOT.on(qreg[0], qreg[1])] * 3,
[ops.T.on(qreg[2]), ops.T.on(qreg[2]) ** -1, ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)] * 3,
)
assert _equal(folded, correct)
def test_fold_random_scale_factor_larger_than_three():
"""Folds at random with a scale_factor larger than three."""
qreg = LineQubit.range(2)
circuit = Circuit([ops.SWAP.on(*qreg)], [ops.CNOT.on(*qreg)])
folded = fold_gates_at_random(circuit, scale_factor=6.0, seed=0)
correct = Circuit([ops.SWAP.on(*qreg)] * 5, [ops.CNOT.on(*qreg)] * 7)
assert len(folded) == 12
assert _equal(folded, correct)
def test_fold_random_no_repeats():
"""Tests folding at random to ensure that no gates are folded twice and
folded gates are not folded again.
"""
# Test circuit:
# 0: ───H───@───Y───@───
# │ │
# 1: ───────X───X───@───
# Note that each gate only occurs once and is self-inverse.
# This allows us to check that no gates are folded more than once
qreg = LineQubit.range(2)
circ = Circuit(
[ops.H.on_each(qreg[0])],
[ops.CNOT.on(*qreg)],
[ops.X.on(qreg[1])],
[ops.Y.on(qreg[0])],
[ops.CZ.on(*qreg)],
)
circuit_ops = set(circ.all_operations())
for scale in np.linspace(1.0, 3.0, 5):
folded = fold_gates_at_random(circ, scale_factor=scale, seed=1)
gates = list(folded.all_operations())
counts = {gate: gates.count(gate) for gate in circuit_ops}
assert all(count <= 3 for count in counts.values())
def test_fold_random_with_terminal_measurements_min_stretch():
"""Tests folding from left with terminal measurements."""
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
[ops.measure_each(*qreg)],
)
folded = fold_gates_at_random(circ, scale_factor=1.0)
correct = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
[ops.measure_each(*qreg)],
)
assert _equal(folded, correct)
def test_fold_random_with_terminal_measurements_max_stretch():
"""Tests folding from left with terminal measurements."""
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
[ops.measure_each(*qreg)],
)
folded = fold_gates_at_random(circ, scale_factor=3.0)
correct = Circuit(
[ops.H.on_each(*qreg)] * 3,
[ops.CNOT.on(qreg[0], qreg[1])] * 3,
[ops.T.on(qreg[2]), ops.T.on(qreg[2]) ** -1, ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)] * 3,
[ops.measure_each(*qreg)],
)
assert _equal(folded, correct)
def test_global_fold_min_stretch():
"""Tests that global fold with scale = 1 is the same circuit."""
# Test circuit
# 0: ───H───@───@───
# │ │
# 1: ───H───X───@───
# │
# 2: ───H───T───X───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
folded = fold_global(circ, 1.0)
assert _equal(folded, circ)
assert folded is not circ
def test_global_fold_min_stretch_with_terminal_measurements():
"""Tests that global fold with scale = 1 is the same circuit."""
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
[ops.measure_each(*qreg)],
)
folded = fold_global(circ, scale_factor=1.0)
assert _equal(folded, circ)
assert folded is not circ
def test_global_fold_stretch_factor_of_three():
"""Tests global folding with the scale as a factor of 3."""
# Test circuit
# 0: ───H───@───@───
# │ │
# 1: ───H───X───@───
# │
# 2: ───H───T───X───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
folded = fold_global(circ, scale_factor=3.0)
correct = Circuit(circ, inverse(circ), circ)
assert _equal(folded, correct)
def test_global_fold_stretch_factor_of_three_with_terminal_measurements():
"""Tests global folding with the scale as a factor of 3 for a circuit
with terminal measurements.
"""
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
meas = Circuit([ops.measure_each(*qreg)])
folded = fold_global(circ + meas, scale_factor=3.0)
correct = Circuit(circ, inverse(circ), circ, meas)
assert _equal(folded, correct)
# Test the number of moments too
assert len(folded) == len(correct)
def test_global_fold_stretch_factor_nine_with_terminal_measurements():
"""Tests global folding with the scale as a factor of 9 for a circuit
with terminal measurements.
"""
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
meas = Circuit([ops.measure_each(*qreg)])
folded = fold_global(circ + meas, scale_factor=9.0)
correct = Circuit([circ, inverse(circ)] * 4, [circ], [meas])
assert _equal(folded, correct)
def test_global_fold_stretch_factor_eight_terminal_measurements():
"""Tests global folding with a scale factor not a multiple of three so
that local folding is also called.
"""
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
meas = Circuit(ops.measure_each(*qreg))
folded = fold_global(circ + meas, scale_factor=3.5)
correct = Circuit(
circ,
inverse(circ),
circ,
inverse(
Circuit(
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
)
),
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
meas,
)
assert _equal(folded, correct)
def test_global_fold_moment_structure_maintained_full_scale_factors():
"""Tests global folding maintains the input circuit's moment structure."""
# Test circuit 1
# 0: ───H───────────────
# 1: ───────Z───────────
# 2: ───────────S───────
# 3: ───────────────T───
qreg = LineQubit.range(4)
gate_list1 = [ops.H, ops.Z, ops.S, ops.T]
circuit1 = Circuit(gate_list1[0](qreg[0]))
for i in range(1, 4):
circuit1 += Circuit(gate_list1[i](qreg[i]))
folded = fold_global(circuit1, scale_factor=3)
correct = Circuit(
circuit1,
inverse(circuit1),
circuit1,
)
assert _equal(folded, correct)
# Test Circuit 2
# 0: ───H───@───────@───
# │ |
# 1: ───H───X───────@───
# │
# 2: ───H───────T───X───
qreg = LineQubit.range(3)
gate_list = [
ops.CNOT.on(qreg[0], qreg[1]),
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
]
circ = Circuit([ops.H.on_each(*qreg)])
for i in range(len(gate_list)):
circ += Circuit(gate_list[i])
folded = fold_global(circ, scale_factor=3)
correct = Circuit(
circ,
inverse(circ),
circ,
)
assert _equal(folded, correct)
def test_global_fold_moment_structure_maintained_partial_scale_factors():
"""Tests global folding maintains the input circuit's moment structure."""
# Test circuit 1
# 0: ───H───────────────
# 1: ───────Z───────────
# 2: ───────────S───────
# 3: ───────────────T───
qreg = LineQubit.range(4)
gate_list1 = [ops.H, ops.Z, ops.S, ops.T]
circuit1 = Circuit(gate_list1[0](qreg[0]))
for i in range(1, 4):
circuit1 += Circuit(gate_list1[i](qreg[i]))
folded1 = fold_global(circuit1, scale_factor=1.5)
correct1 = Circuit(circuit1, inverse(circuit1)[0], circuit1[-1])
assert _equal(folded1, correct1)
folded2 = fold_global(circuit1, scale_factor=2.5)
correct2 = Circuit(circuit1, inverse(circuit1)[0:3], circuit1[1:])
assert _equal(folded2, correct2)
folded3 = fold_global(circuit1, scale_factor=2.75)
correct3 = Circuit(circuit1, inverse(circuit1), circuit1)
assert _equal(folded3, correct3)
def test_convert_to_from_mitiq_qiskit():
"""Basic test for converting a Qiskit circuit to a Cirq circuit."""
# Test Qiskit circuit:
# ┌───┐
# q0_0: |0>┤ H ├──■──
# └───┘┌─┴─┐
# q0_1: |0>─────┤ X ├
# └───┘
qiskit_qreg = QuantumRegister(2)
qiskit_circuit = QuantumCircuit(qiskit_qreg)
qiskit_circuit.h(qiskit_qreg[0])
qiskit_circuit.cx(*qiskit_qreg)
# Convert to a mitiq circuit
mitiq_circuit, input_circuit_type = convert_to_mitiq(qiskit_circuit)
assert isinstance(mitiq_circuit, Circuit)
# Check correctness
mitiq_qreg = LineQubit.range(2)
correct_mitiq_circuit = Circuit(
ops.H.on(mitiq_qreg[0]), ops.CNOT.on(*mitiq_qreg)
)
assert _equal(
mitiq_circuit, correct_mitiq_circuit, require_qubit_equality=False
)
# Convert back to original circuit type
original_circuit = convert_from_mitiq(mitiq_circuit, input_circuit_type)
assert isinstance(original_circuit, QuantumCircuit)
def test_fold_at_random_with_qiskit_circuits():
"""Tests folding at random with Qiskit circuits."""
# Test Qiskit circuit:
# ┌───┐
# q0_0: |0>┤ H ├──■────■──
# ├───┤┌─┴─┐ │
# q0_1: |0>┤ H ├┤ X ├──■──
# ├───┤├───┤┌─┴─┐
# q0_2: |0>┤ H ├┤ T ├┤ X ├
# └───┘└───┘└───┘
qiskit_qreg = QuantumRegister(3)
qiskit_creg = ClassicalRegister(3)
qiskit_circuit = QuantumCircuit(qiskit_qreg, qiskit_creg)
qiskit_circuit.h(qiskit_qreg)
qiskit_circuit.cx(qiskit_qreg[0], qiskit_qreg[1])
qiskit_circuit.t(qiskit_qreg[2])
qiskit_circuit.ccx(*qiskit_qreg)
qiskit_circuit.measure(qiskit_qreg, qiskit_creg)
folded_circuit = fold_gates_at_random(
qiskit_circuit, scale_factor=1.0, return_mitiq=True
)
qreg = LineQubit.range(3)
correct_folded_circuit = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
[ops.measure_each(*qreg)],
)
assert isinstance(folded_circuit, Circuit)
assert _equal(folded_circuit, correct_folded_circuit)
# Keep the input type
qiskit_folded_circuit = fold_gates_at_random(
qiskit_circuit, scale_factor=1.0
)
assert isinstance(qiskit_folded_circuit, QuantumCircuit)
assert qiskit_folded_circuit.qregs == qiskit_circuit.qregs
assert qiskit_folded_circuit.cregs == qiskit_circuit.cregs
def test_fold_global_with_qiskit_circuits():
"""Tests _fold_local with input Qiskit circuits."""
# Test Qiskit circuit:
# ┌───┐
# q0_0: |0>┤ H ├──■────■──
# ├───┤┌─┴─┐ │
# q0_1: |0>┤ H ├┤ X ├──■──
# ├───┤├───┤┌─┴─┐
# q0_2: |0>┤ H ├┤ T ├┤ X ├
# └───┘└───┘└───┘
qiskit_qreg = QuantumRegister(3)
qiskit_creg = ClassicalRegister(3)
qiskit_circuit = QuantumCircuit(qiskit_qreg, qiskit_creg)
qiskit_circuit.h(qiskit_qreg)
qiskit_circuit.cx(qiskit_qreg[0], qiskit_qreg[1])
qiskit_circuit.t(qiskit_qreg[2])
qiskit_circuit.ccx(*qiskit_qreg)
qiskit_circuit.measure(qiskit_qreg, qiskit_creg)
# Return mitiq circuit
folded_circuit = fold_global(
qiskit_circuit,
scale_factor=2.71828,
fold_method=fold_gates_at_random,
return_mitiq=True,
)
assert isinstance(folded_circuit, Circuit)
# Return input circuit type
folded_qiskit_circuit = fold_global(
qiskit_circuit, scale_factor=2.0, fold_method=fold_gates_at_random
)
assert isinstance(folded_qiskit_circuit, QuantumCircuit)
assert folded_qiskit_circuit.qregs == qiskit_circuit.qregs
assert folded_qiskit_circuit.cregs == qiskit_circuit.cregs
def test_fold_global_with_qiskit_circuits_and_idle_qubits():
"""Tests _fold_local with input Qiskit circuits where idle qubits are
interspered.
"""
# Test Qiskit circuit:
# ┌───┐ ┌─┐
# q4_0: |0>┤ H ├──■────■──┤M├──────
# └───┘ │ │ └╥┘
# q4_1: |0>───────┼────┼───╫───────
# ┌───┐┌─┴─┐ │ ║ ┌─┐
# q4_2: |0>┤ H ├┤ X ├──■───╫─┤M├───
# └───┘└───┘ │ ║ └╥┘
# q4_3: |0>────────────┼───╫──╫────
# ┌───┐┌───┐┌─┴─┐ ║ ║ ┌─┐
# q4_4: |0>┤ H ├┤ T ├┤ X ├─╫──╫─┤M├
# └───┘└───┘└───┘ ║ ║ └╥┘
# c4: 5/════════════════╩══╩══╩═
# 0 2 4
qiskit_qreg = QuantumRegister(5)
qiskit_creg = ClassicalRegister(5)
qiskit_circuit = QuantumCircuit(qiskit_qreg, qiskit_creg)
qiskit_circuit.h(qiskit_qreg[0])
qiskit_circuit.h(qiskit_qreg[2])
qiskit_circuit.h(qiskit_qreg[4])
qiskit_circuit.cx(qiskit_qreg[0], qiskit_qreg[2])
qiskit_circuit.t(qiskit_qreg[4])
qiskit_circuit.ccx(qiskit_qreg[0], qiskit_qreg[2], qiskit_qreg[4])
qiskit_circuit.measure(qiskit_qreg[0], qiskit_creg[0])
qiskit_circuit.measure(qiskit_qreg[2], qiskit_creg[2])
qiskit_circuit.measure(qiskit_qreg[4], qiskit_creg[4])
# Return mitiq circuit
folded_circuit = fold_global(
qiskit_circuit,
scale_factor=2.71828,
fold_method=fold_gates_at_random,
return_mitiq=True,
)
assert isinstance(folded_circuit, Circuit)
# Return input circuit type
folded_qiskit_circuit = fold_global(
qiskit_circuit, scale_factor=2.0, fold_method=fold_gates_at_random
)
assert isinstance(folded_qiskit_circuit, QuantumCircuit)
assert folded_qiskit_circuit.qregs == qiskit_circuit.qregs
assert folded_qiskit_circuit.cregs == qiskit_circuit.cregs
def test_fold_left_squash_moments():
"""Tests folding from left with kwarg squash_moments."""
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
[ops.measure_each(*qreg)],
)
folded_not_squashed = fold_gates_at_random(
circ, scale_factor=3, squash_moments=False
)
folded_and_squashed = fold_gates_at_random(
circ, scale_factor=3, squash_moments=True
)
correct = Circuit(
[ops.H.on_each(*qreg)] * 3,
[ops.CNOT.on(qreg[0], qreg[1])] * 3,
[ops.T.on(qreg[2]), ops.T.on(qreg[2]) ** -1, ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)] * 3,
[ops.measure_each(*qreg)],
)
assert _equal(folded_and_squashed, folded_not_squashed)
assert _equal(folded_and_squashed, correct)
assert len(folded_and_squashed) == 10
def test_fold_and_squash_max_stretch():
"""Tests folding and squashing a two-qubit circuit."""
# Test circuit:
# 0: ───────H───────H───────H───────H───────H───
#
# 1: ───H───────H───────H───────H───────H───────
# Get the test circuit
d = 10
qreg = LineQubit.range(2)
circuit = Circuit()
for i in range(d):
circuit.insert(0, ops.H.on(qreg[i % 2]), strategy=InsertStrategy.NEW)
folded_not_squashed = fold_gates_at_random(
circuit, scale_factor=3.0, squash_moments=False
)
folded_and_squashed = fold_gates_at_random(
circuit, scale_factor=3.0, squash_moments=True
)
folded_with_squash_moments_not_specified = fold_gates_at_random(
circuit, scale_factor=3.0
) # Checks that the default is to squash moments
assert len(folded_not_squashed) == 30
assert len(folded_and_squashed) == 15
assert len(folded_with_squash_moments_not_specified) == 15
def test_fold_and_squash_random_circuits_random_stretches():
"""Tests folding and squashing random circuits and ensures the number of
moments in the squashed circuits is never greater than the number of
moments in the un-squashed circuit.
"""
rng = np.random.RandomState(seed=1)
for trial in range(5):
circuit = testing.random_circuit(
qubits=8, n_moments=8, op_density=0.75
)
scale = 2 * rng.random() + 1
folded_not_squashed = fold_gates_at_random(
circuit,
scale_factor=scale,
squash_moments=False,
seed=trial,
)
folded_and_squashed = fold_gates_at_random(
circuit,
scale_factor=scale,
squash_moments=True,
seed=trial,
)
assert len(folded_and_squashed) <= len(folded_not_squashed)
def test_default_weight():
"""Tests default weight of an n-qubit gates is 0.99**n."""
qreg = LineQubit.range(3)
assert np.isclose(_default_weight(ops.H.on(qreg[0])), 0.99)
assert np.isclose(_default_weight(ops.CZ.on(qreg[0], qreg[1])), 0.9801)
assert np.isclose(_default_weight(ops.TOFFOLI.on(*qreg[:3])), 0.970299)
@pytest.mark.parametrize("qiskit", [True, False])
def test_fold_local_with_fidelities(qiskit):
qreg = LineQubit.range(3)
circ = Circuit(
ops.H.on_each(*qreg),
ops.CNOT.on(qreg[0], qreg[1]),
ops.T.on(qreg[2]),
ops.TOFFOLI.on(*qreg),
)
if qiskit:
circ = convert_from_mitiq(circ, "qiskit")
# Only fold the Toffoli gate
fidelities = {"H": 1.0, "T": 1.0, "CNOT": 1.0, "TOFFOLI": 0.95}
folded = fold_gates_at_random(
circ, scale_factor=3.0, fidelities=fidelities
)
correct = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)] * 3,
)
if qiskit:
folded, _ = convert_to_mitiq(folded)
assert equal_up_to_global_phase(folded.unitary(), correct.unitary())
else:
assert _equal(folded, correct)
@pytest.mark.parametrize("qiskit", [True, False])
def test_fold_local_with_single_qubit_gates_fidelity_one(qiskit):
"""Tests folding only two-qubit gates by using
fidelities = {"single": 1.}.
"""
qreg = LineQubit.range(3)
circ = Circuit(
ops.H.on_each(*qreg),
ops.CNOT.on(qreg[0], qreg[1]),
ops.T.on(qreg[2]),
ops.TOFFOLI.on(*qreg),
)
if qiskit:
circ = convert_from_mitiq(circ, "qiskit")
folded = fold_gates_at_random(
circ,
scale_factor=3.0,
fidelities={"single": 1.0, "CNOT": 0.99, "TOFFOLI": 0.95},
)
correct = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])] * 3,
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)] * 3,
)
if qiskit:
assert folded.qregs == circ.qregs
assert folded.cregs == circ.cregs
folded, _ = convert_to_mitiq(folded)
assert equal_up_to_global_phase(folded.unitary(), correct.unitary())
else:
assert _equal(folded, correct)
@pytest.mark.parametrize("qiskit", [True, False])
def test_all_gates_folded_at_max_scale_with_fidelities(qiskit):
"""Tests that all gates are folded regardless of the input fidelities when
the scale factor is three.
"""
rng = np.random.RandomState(1)
qreg = LineQubit.range(3)
circ = Circuit(
ops.H.on_each(*qreg),
ops.CNOT.on(qreg[0], qreg[1]),
ops.T.on(qreg[2]),
ops.TOFFOLI.on(*qreg),
)
ngates = len(list(circ.all_operations()))
if qiskit:
circ = convert_from_mitiq(circ, "qiskit")
folded = fold_gates_at_random(
circ,
scale_factor=3.0,
fidelities={
"H": rng.rand(),
"T": rng.rand(),
"CNOT": rng.rand(),
"TOFFOLI": rng.rand(),
},
)
correct = Circuit(
[ops.H.on_each(*qreg)] * 3,
[ops.CNOT.on(qreg[0], qreg[1])] * 3,
[ops.T.on(qreg[2]), ops.T.on(qreg[2]) ** -1, ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)] * 3,
)
if qiskit:
assert folded.qregs == circ.qregs
assert folded.cregs == circ.cregs
folded, _ = convert_to_mitiq(folded)
assert equal_up_to_global_phase(folded.unitary(), correct.unitary())
else:
assert _equal(folded, correct)
assert len(list(folded.all_operations())) == 3 * ngates
def test_fold_local_raises_error_with_bad_fidelities():
with pytest.raises(ValueError, match="Fidelities should be"):
fold_gates_at_random(
Circuit(), scale_factor=1.21, fidelities={"H": -1.0}
)
with pytest.raises(ValueError, match="Fidelities should be"):
fold_gates_at_random(
Circuit(), scale_factor=1.21, fidelities={"CNOT": 0.0}
)
with pytest.raises(ValueError, match="Fidelities should be"):
fold_gates_at_random(
Circuit(), scale_factor=1.21, fidelities={"triple": 1.2}
)
@pytest.mark.parametrize("conversion_type", ("qiskit", "pyquil"))
def test_convert_from_mitiq_circuit_conversion_error(conversion_type):
circuit = testing.random_circuit(qubits=5, n_moments=5, op_density=0.99)
noisy = circuit.with_noise(ops.depolarize(p=0.1))
with pytest.raises(
CircuitConversionError, match="Circuit could not be converted from"
):
convert_from_mitiq(noisy, conversion_type)
def test_convert_qiskit_to_mitiq_circuit_conversion_error():
# Custom gates are not supported in conversions
gate = Operator([[0.0, 1.0], [-1.0, 0.0]])
qreg = QuantumRegister(1)
circ = QuantumCircuit(qreg)
circ.unitary(gate, [0])
with pytest.raises(
CircuitConversionError, match="Circuit could not be converted to"
):
convert_to_mitiq(circ)
def test_convert_pyquil_to_mitiq_circuit_conversion_error():
# Pragmas are not supported in conversions
prog = Program(Pragma("INITIAL_REWIRING", ['"Partial"']))
with pytest.raises(
CircuitConversionError, match="Circuit could not be converted to"
):
convert_to_mitiq(prog)
@pytest.mark.parametrize(
"fold_method",
(
fold_gates_at_random,
fold_global,
),
)
def test_folding_circuit_conversion_error_qiskit(fold_method):
# Custom gates are not supported in conversions
gate = Operator([[0.0, 1.0], [-1.0, 0.0]])
qreg = QuantumRegister(1)
circ = QuantumCircuit(qreg)
circ.unitary(gate, [0])
with pytest.raises(
CircuitConversionError, match="Circuit could not be converted to"
):
fold_method(circ, scale_factor=2.0)
@pytest.mark.parametrize(
"fold_method",
(
fold_gates_at_random,
fold_global,
),
)
def test_folding_circuit_conversion_error_pyquil(fold_method):
# Pragmas are not supported in conversions
prog = Program(Pragma("INITIAL_REWIRING", ['"Partial"']))
with pytest.raises(
CircuitConversionError, match="Circuit could not be converted to"
):
fold_method(prog, scale_factor=2.0)
@pytest.mark.parametrize("scale", [1, 3, 5, 9])
def test_fold_fidelity_large_scale_factor_only_twoq_gates(scale):
qreg = LineQubit.range(2)
circuit = Circuit(ops.H(qreg[0]), ops.CNOT(*qreg))
folded = fold_gates_at_random(
circuit, scale_factor=scale, fidelities={"single": 1.0}
)
correct = Circuit(ops.H(qreg[0]), [ops.CNOT(*qreg)] * scale)
assert _equal(folded, correct)
def test_folding_keeps_measurement_order_with_qiskit():
qreg, creg = QuantumRegister(2), ClassicalRegister(2)
circuit = QuantumCircuit(qreg, creg)
circuit.h(qreg[0])
circuit.measure(qreg, creg)
folded = fold_gates_at_random(circuit, scale_factor=1.0)
assert folded == circuit
def test_create_weight_mask_with_fidelities():
qreg = LineQubit.range(3)
circ = Circuit(
ops.H.on_each(*qreg),
ops.CNOT.on(qreg[0], qreg[1]),
ops.T.on(qreg[2]),
ops.ISWAP.on(qreg[1], qreg[0]),
ops.TOFFOLI.on(*qreg),
ops.measure_each(*qreg),
)
# Measurement gates should be ignored
fidelities = {
"H": 0.9,
"CNOT": 0.8,
"T": 0.7,
"TOFFOLI": 0.6,
"ISWAP": 0.5,
}
weight_mask = _create_weight_mask(circ, fidelities)
assert np.allclose(weight_mask, [0.1, 0.1, 0.1, 0.2, 0.3, 0.5, 0.4])
fidelities = {"single": 1.0, "double": 0.5, "triple": 0.1}
weight_mask = _create_weight_mask(circ, fidelities)
assert np.allclose(weight_mask, [0.0, 0.0, 0.0, 0.5, 0.0, 0.5, 0.9])
fidelities = {
"single": 1.0,
"double": 1.0,
"H": 0.1,
"CNOT": 0.2,
"TOFFOLI": 0.3,
}
weight_mask = _create_weight_mask(circ, fidelities)
assert np.allclose(weight_mask, [0.9, 0.9, 0.9, 0.8, 0.0, 0.0, 0.7])
fidelities = {"waitgate": 1.0, "H": 0.1}
with pytest.warns(UserWarning, match="don't currently support"):
weight_mask = _create_weight_mask(circ, fidelities)
def test_create_fold_mask_with_real_scale_factors_at_random():
fold_mask = _create_fold_mask(
weight_mask=[0.1, 0.2, 0.3, 0.0],
scale_factor=1.0,
seed=1,
)
assert fold_mask == [0, 0, 0, 0]
fold_mask = _create_fold_mask(
weight_mask=[0.1, 0.1, 0.1, 0.1, 0.0],
scale_factor=1.5,
seed=2,
)
assert fold_mask == [0, 0, 1, 0, 0]
fold_mask = _create_fold_mask(
weight_mask=[1, 1, 1, 1],
scale_factor=2,
seed=3,
)
assert fold_mask == [0, 1, 0, 1]
fold_mask = _create_fold_mask(
weight_mask=[1, 1, 1, 1],
scale_factor=3.9,
seed=7,
)
assert fold_mask == [1, 2, 2, 1]
def test_create_fold_mask_approximates_well():
"""Check _create_fold_mask well approximates the scale factor."""
rnd_state = np.random.RandomState(seed=0)
for scale_factor in [1, 1.5, 1.7, 2.7, 6.7, 18.7, 19.0, 31]:
weight_mask = [rnd_state.rand() for _ in range(100)]
seed = rnd_state.randint(100)
fold_mask = _create_fold_mask(
weight_mask,
scale_factor,
seed=seed,
)
out_weights = [w + 2 * n * w for w, n in zip(weight_mask, fold_mask)]
actual_scale = sum(out_weights) / sum(weight_mask)
# Less than 1% error
assert np.isclose(scale_factor / actual_scale, 1.0, atol=0.01)
def test_apply_fold_mask():
# Test circuit
# 0: ───H───@───@───M───
# │ │
# 1: ───H───X───@───M───
# │
# 2: ───H───T───X───M───
qreg = LineQubit.range(3)
circ = Circuit(
[ops.H.on_each(*qreg)],
[ops.CNOT.on(qreg[0], qreg[1])],
[ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)],
[ops.measure_each(*qreg)],
)
folded = _apply_fold_mask(circ, [0, 0, 0, 0, 0, 0])
assert _equal(folded, circ)
folded = _apply_fold_mask(circ, [1, 1, 1, 0, 0, 0])
correct = Circuit([ops.H.on_each(*qreg)] * 2) + circ
assert _equal(folded, correct)
folded = _apply_fold_mask(circ, [0, 0, 0, 0, 0, 2])
correct = circ[:-1] + Circuit([ops.TOFFOLI.on(*qreg)] * 4) + circ[-1]
assert _equal(folded, correct)
folded = _apply_fold_mask(circ, [0, 3, 0, 0, 0, 0])
correct = Circuit([ops.H.on(qreg[1])] * 6) + circ
assert _equal(folded, _squash_moments(correct))
folded = _apply_fold_mask(circ, [0, 0, 1, 0, 0, 0])
correct = Circuit([ops.H.on(qreg[2])] * 2 + circ)
assert _equal(folded, _squash_moments(correct))
folded = _apply_fold_mask(circ, [1, 1, 1, 1, 1, 1])
correct = Circuit(
[ops.H.on_each(*qreg)] * 3,
[ops.CNOT.on(qreg[0], qreg[1])] * 3,
[ops.T.on(qreg[2]), inverse(ops.T.on(qreg[2])), ops.T.on(qreg[2])],
[ops.TOFFOLI.on(*qreg)] * 3,
[ops.measure_each(*qreg)],
)
assert _equal(folded, correct)
def test_apply_fold_mask_wrong_size():
qreg = LineQubit(0)
circ = Circuit(ops.H(qreg))
with pytest.raises(ValueError, match="have incompatible sizes"):
_ = _apply_fold_mask(circ, [1, 1])
def test_apply_fold_mask_with_squash_moments_option():
# Test circuit:
# 0: ───T────────
#
# 1: ───T────H───
q = LineQubit.range(2)
circ = Circuit(
[ops.T.on_each(*q), ops.H(q[1])],
)
folded = _apply_fold_mask(circ, [1, 0, 0], squash_moments=False)
# 0: ───T───T^-1───T───────
#
# 1: ───T──────────────H───
correct = Circuit(
[ops.T.on_each(*q), inverse(ops.T(q[0])), ops.T(q[0])],
) + Circuit(ops.H(q[1]))
assert _equal(folded, correct)
# If 2 gates of the same moment are folded,
# only 2 moments should be created and not 4.
folded = _apply_fold_mask(circ, [1, 1, 0], squash_moments=False)
# 0: ───T───T^-1───T───────
#
# 1: ───T───T^-1───T────H───
correct = Circuit(
[
ops.T.on_each(*q),
inverse(ops.T.on_each(*q)),
ops.T.on_each(*q),
ops.H(q[1]),
],
)
assert _equal(folded, correct)
folded = _apply_fold_mask(circ, [1, 0, 0], squash_moments=True)
# 0: ───T───T^-1───T───
#
# 1: ───T───H──────────
correct = Circuit(
[ops.T.on_each(*q), inverse(ops.T(q[0])), ops.T(q[0]), ops.H(q[1])],
)
assert _equal(folded, correct)
@pytest.mark.parametrize(
"fold_method",
(
fold_gates_at_random,
fold_global,
),
)
def test_scaling_with_pyquil_retains_declarations(fold_method):
program = Program()
theta = program.declare("theta", memory_type="REAL")
_ = program.declare("beta", memory_type="REAL")
program += gates.RY(theta, 0)
scaled = fold_method(program, 1)
assert scaled.declarations == program.declarations
|
https://github.com/hkhetawat/QArithmetic
|
hkhetawat
|
""" This file allows to test the Multiplication blocks Ua. This blocks, when put together as explain in
the report, do the exponentiation.
The user can change N, n, a and the input state, to create the circuit:
up_reg |+> ---------------------|----------------------- |+>
|
|
|
-------|---------
------------ | | ------------
down_reg |x> ------------ | Mult | ------------ |(x*a) mod N>
------------ | | ------------
-----------------
Where |x> has n qubits and is the input state, the user can change it to whatever he wants
This file uses as simulator the local simulator 'statevector_simulator' because this simulator saves
the quantum state at the end of the circuit, which is exactly the goal of the test file. This simulator supports sufficient
qubits to the size of the QFTs that are going to be used in Shor's Algorithm because the IBM simulator only supports up to 32 qubits
"""
""" Imports from qiskit"""
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute, IBMQ, BasicAer
""" Imports to Python functions """
import math
import time
""" Local Imports """
from qfunctions import create_QFT, create_inverse_QFT
from qfunctions import cMULTmodN
""" Function to properly get the final state, it prints it to user """
""" This is only possible in this way because the program uses the statevector_simulator """
def get_final(results, number_aux, number_up, number_down):
i=0
""" Get total number of qubits to go through all possibilities """
total_number = number_aux + number_up + number_down
max = pow(2,total_number)
print('|aux>|top_register>|bottom_register>\n')
while i<max:
binary = bin(i)[2:].zfill(total_number)
number = results.item(i)
number = round(number.real, 3) + round(number.imag, 3) * 1j
""" If the respective state is not zero, then print it and store the state of the register where the result we are looking for is.
This works because that state is the same for every case where number !=0 """
if number!=0:
print('|{0}>|{1}>|{2}>'.format(binary[0:number_aux],binary[number_aux:(number_aux+number_up)],binary[(number_aux+number_up):(total_number)]),number)
if binary[number_aux:(number_aux+number_up)]=='1':
store = binary[(number_aux+number_up):(total_number)]
i=i+1
print(' ')
return int(store, 2)
""" Main program """
if __name__ == '__main__':
""" Select number N to do modN"""
N = int(input('Please insert integer number N: '))
print(' ')
""" Get n value used in QFT, to know how many qubits are used """
n = math.ceil(math.log(N,2))
""" Select the value for 'a' """
a = int(input('Please insert integer number a: '))
print(' ')
""" Please make sure the a and N are coprime"""
if math.gcd(a,N)!=1:
print('Please make sure the a and N are coprime. Exiting program.')
exit()
print('Total number of qubits used: {0}\n'.format(2*n+3))
print('Please check source file to change input quantum state. By default is |2>.\n')
ts = time.time()
""" Create quantum and classical registers """
aux = QuantumRegister(n+2)
up_reg = QuantumRegister(1)
down_reg = QuantumRegister(n)
aux_classic = ClassicalRegister(n+2)
up_classic = ClassicalRegister(1)
down_classic = ClassicalRegister(n)
""" Create Quantum Circuit """
circuit = QuantumCircuit(down_reg , up_reg , aux, down_classic, up_classic, aux_classic)
""" Initialize with |+> to also check if the control is working"""
circuit.h(up_reg[0])
""" Put the desired input state in the down quantum register. By default we put |2> """
circuit.x(down_reg[1])
""" Apply multiplication"""
cMULTmodN(circuit, up_reg[0], down_reg, aux, int(a), N, n)
""" show results of circuit creation """
create_time = round(time.time()-ts, 3)
if n < 8: print(circuit)
print(f"... circuit creation time = {create_time}")
ts = time.time()
""" Simulate the created Quantum Circuit """
simulation = execute(circuit, backend=BasicAer.get_backend('statevector_simulator'),shots=1)
""" Get the results of the simulation in proper structure """
sim_result=simulation.result()
""" Get the statevector of the final quantum state """
outputstate = sim_result.get_statevector(circuit, decimals=3)
""" Show the final state after the multiplication """
after_exp = get_final(outputstate, n+2, 1, n)
""" show execution time """
exec_time = round(time.time()-ts, 3)
print(f"... circuit execute time = {exec_time}")
""" Print final quantum state to user """
print('When control=1, value after exponentiation is in bottom quantum register: |{0}>'.format(after_exp))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# You can make the bars more transparent to better see the ones that are behind
# if they overlap.
import numpy as np
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_city
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0,1)
qc.ry(np.pi/3, 0)
qc.rx(np.pi/5, 1)
state = Statevector(qc)
plot_state_city(state, alpha=0.6)
|
https://github.com/gustavomirapalheta/Quantum-Computing-with-Qiskit
|
gustavomirapalheta
|
# Setup Acesso do Google Colab aos sistemas IBM Quantum
from google.colab import userdata
ibm_token = userdata.get("IBM_TOKEN")
# As of 2024/01/25 it is not necessary to install qutip anymore for qiskit
# graphical circuit display to function properly.
!pip install qiskit-ibm-provider -q
!pip install qiskit -q
!pip install qiskit[visualization] -q
!pip install qiskit-aer
!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src -q
import numpy as np
np.set_printoptions(precision=3, suppress=True)
from matplotlib import pyplot as plt
%matplotlib inline
import pandas as pd
import sklearn as sk
import qiskit as qk
# Remember that qiskit has to be already installed in the Python environment.
# Otherwise the import command will fail
import qiskit as qk
# A circuit composed of just one qubit
qc = qk.QuantumCircuit(1)
qc.draw('mpl', style = 'clifford', scale = 1)
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl', style = 'clifford', scale = 1)
import qiskit as qk
# A qubit initialized in |0> and a measurement
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.measure_all()
qc.draw('mpl', style = 'clifford')
import qiskit as qk
import qiskit_aer
# A list of possible measurements. The results of measurements are obtained
# by executing an object called backend - As of 16/02/2024 the line below
# was giving an error. Need to understand how to list possible backends in
# qiskit now.
a = [print(i) for i in qk.aer.backends()]
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
# Let's choose a Aer backend with the statevector simulator
backend = qk.Aer.get_backend('statevector_simulator')
# And execute the circuit qc in the simulator backend
# getting as final result the counts from 1.000 measures
# of the qubit state
result = qk.execute(qc, backend, shots=1000).result().get_counts()
result
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_distribution(result)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.measure(0,0)
qc.draw('mpl', style = 'clifford')
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_distribution(result)
import numpy as np
v0 = np.array([[1],[0]]);v0
v1 = np.array([[0],[1]]); v1
X = np.array([[0,1],[1,0]]); X
X.dot(v0)
X.dot(v1)
import qiskit as qk
qr = qk.QuantumRegister(1,"q0")
cr = qk.ClassicalRegister(1,"c0")
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.measure(qr[0], cr[0])
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, backend, shots=1000).result().get_counts()
results
qk.visualization.plot_distribution(results)
import numpy as np
# Notice that we are creating the v0 matrix using the transpose operation
v0 = np.array([[1,0]]).T; v0
# Here it is created again de X matrix
X = np.array([[0,1],[1,0]]); X
# Multiplying v0 by the X matrix twice you get again v0
X.dot(X).dot(v0)
# Multiplying the X matrix by itself you get the Identity matrix
X.dot(X)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.x(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl', style = "clifford")
# The result of 1000 measures of the qubit above gives the |0> state as result
# in all measures
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
results
qk.visualization.plot_distribution(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,2**-0.5],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
v0 = np.array([[1,0]]).T; v0
H = np.array([[1,1],[1,-1]])/np.sqrt(2); H
H.dot(v0)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.h(qr[0])
qc.measure(qr[0],cr[0])
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, backend, shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl', style = 'clifford')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.h(0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl', style = 'clifford')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
# First let's start with the qubit in the state |psi> = (|0> - |1>)/sqrt(2)
psi = np.array([[1,-1]]).T/(2**0.5); psi
H = np.array([[1,1],[1,-1]])/2**0.5; H
# Now let's pass the qubit Psi through an Hadamard gate.
# The result is a qubit in the state |1>
H.dot(psi)
# Let's start with a qubit in the state |1>, pass it through a
# a hadamard gate twice and check the result
v0 = np.array([[0,1]]).T; v0
H.dot(H).dot(v0)
# This means that if we multiply the H gate by itself the result
# will be an Identity matrix. Let's check it.
H.dot(H)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.measure(qr,cr)
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
psi1 = np.array([[1,0]]).T; psi1
psi2 = np.array([[1,0]]).T; psi2
# In numpy the tensor product is calculated with the function kron
np.kron(psi1,psi2)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.h(1)
qc.measure(qr,cr)
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
psi1 = np.array([[1,0]]).T;psi1
psi2 = np.array([[1,0]]).T;psi2
H = np.array([[1,1],[1,-1]])/2**0.5;H
# When we want to combine two vector states or gate matrices we tensor product them.
psi3 = np.kron(psi1,psi2);psi3
H2 = np.kron(H,H);H2
# When we want to pass a vetor through a gate we calculate the dot product
# of the total gate matrix with the total vector.
# As we have predicted, the resulting vector state has a=b=c=d=1/2
psi4 = H2.dot(psi3); psi4
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.measure(qr,cr)
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
psi1 = np.array([[0,1]]).T;psi1
psi2 = np.array([[0,1]]).T;psi2
H = np.array([[1,1],[1,-1]])/2**0.5;H
# When we want to combine two vector states or gate matrices we tensor product them.
psi3 = np.kron(psi1,psi2);psi3
H2 = np.kron(H,H);H2
# When we want to pass a vetor through a gate we calculate the dot product
# of the total gate matrix with the total vector.
# As we have predicted, the resulting vector state has a=b=c=d=1/2
psi4 = H2.dot(psi3); psi4
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.cx(0,1)
qc.measure(qr,cr)
qc.draw('mpl', style = "clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, backend, shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v00 = np.array([[1,0,0,0]]).T;v00
# C.v00 = v00
C.dot(v00)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.cx(0,1)
qc.measure(qr,cr)
qc.draw('mpl', style = 'clifford')
# Please notice that Qiskit's qubits presentation order is reversed.
# Therefore 10 in the histogram's x axis should be read as 01 (from
# inside out or right to left).
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, backend, shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v01 = np.array([[0,1,0,0]]).T;v01
# C.v01 = v01
C.dot(v01)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([1,0],1)
qc.cx(0,1)
qc.measure(qr,cr)
qc.draw('mpl', style = 'clifford')
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, backend, shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v10 = np.array([[0,0,1,0]]).T; v10
# C.v10 = v11
C.dot(v10)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([0,1],1)
qc.cx(0,1)
qc.measure(qr,cr)
qc.draw('mpl', style = 'clifford')
# Again remember to read qiskit qubits state presentation order
# from right to left. Therefore 01 in the x axis is in fact 10
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, backend, shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v11 = np.array([[0,0,0,1]]).T; v11
# C.v11 = v10
C.dot(v11)
import qiskit as qk
qr = qk.QuantumRegister(2, 'q')
cr = qk.ClassicalRegister(2, 'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.measure(qr, cr)
qc.draw('mpl', style = 'clifford')
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
va = np.array([[1,0]]).T; va
vb = np.array([[1,0]]).T; vb
H = np.array([[1,1],[1,-1]])/2**0.5;H
vaH = H.dot(va); vaH
vaHvb = np.kron(vaH,vb); vaHvb
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
vout = C.dot(vaHvb); vout
import qiskit as qk
qr = qk.QuantumRegister(2, 'q')
cr = qk.ClassicalRegister(2, 'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([0,1],0)
qc.initialize([1,0],1)
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.measure(qr, cr)
qc.draw('mpl', style = 'clifford')
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
import numpy as np
va = np.array([[0,1]]).T; va
vb = np.array([[1,0]]).T; vb
H = np.array([[1,1],[1,-1]])/2**0.5;H
vaH = H.dot(va); vaH
vaHvb = np.kron(vaH,vb); vaHvb
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
vout = C.dot(vaHvb); vout
# Get the IBM API key in: https://quantum-computing.ibm.com
# ibm_token is saved as a Google Secret in this notebook
from qiskit_ibm_provider import IBMProvider
IBMProvider.save_account(token=ibm_token, overwrite=True)
# Load the account in the active session
provider = IBMProvider(token=ibm_token,
instance='ibm-q-education/fgv-1/ml-business-app')
provider.backends()
backend = provider.get_backend("ibmq_qasm_simulator")
backend
# With n Qubits we can generate a random number from 0 to 2^n - 1
n = 3
qr = qk.QuantumRegister(n,'q')
cr = qk.ClassicalRegister(n,'c')
qc = qk.QuantumCircuit(qr, cr)
# Applying a Hadamard to each of the three qubits
for i in range(n):
qc.h(qr[i])
# Measuring the three qubits
qc.measure(qr,cr)
# Visualizing the circuit
qc.draw('mpl', style='clifford')
# qk.execute envia para o backend. Conferindo no iqmq explorer aparece o job
new_job = qk.execute(qc, backend, shots=1)
# this result is stored on the local machine. However, it will only be available
# after the job has been executed. It returns a python dictionary.
new_job.result().get_counts()
int(list(new_job.result().get_counts().keys())[0],2)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0,1)
circuit.measure([0,1], [0,1])
display(circuit.draw('mpl', style='clifford'))
backend = qk.Aer.get_backend('aer_simulator')
print(backend.run(circuit, shots=1000).result().get_counts())
print(backend.run(circuit, shots=1000).result().get_counts())
from qiskit import QuantumCircuit
circuito = QuantumCircuit(3,3)
for i in range(3):
circuito.h(i)
circuito.measure(i,i)
display(circuito.draw('mpl', style='clifford'))
backend = qk.Aer.get_backend('aer_simulator')
backend.run(circuito, shots = 1000).result().get_counts()
from qiskit import QuantumCircuit
qc = QuantumCircuit(4,4)
qc.x([0,1])
qc.cx([0,1],[2,2])
qc.ccx(0,1,3)
qc.measure([0,1,2,3],[0,1,2,3])
display(qc.draw(output='mpl', style="clifford"))
backend = qk.Aer.get_backend('aer_simulator')
qk.execute(qc, backend, shots = 10000).result().get_counts()
import qiskit as qk
qr = qk.QuantumRegister(1,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
print("Circuit 1 - Registers Only")
display(qc.draw('mpl', style="clifford"))
qc.x(qr)
print("Circuit 1 - Quantum Register with a Gate X ")
display(qc.draw('mpl', style="clifford"))
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('statevector_simulator'))
result = job.result().get_statevector()
print("Quantum Register Vector State")
from qiskit.tools.visualization import plot_bloch_multivector
display(plot_bloch_multivector(result))
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('unitary_simulator'))
#WARNING:qiskit_aer.backends.aerbackend:Simulation failed and returned the
# following error message:
#ERROR: [Experiment 0] Circuit circuit-293 contains invalid instructions
# {"instructions": {save_unitary}} for "statevector" method.Circuit
# circuit-293 contains invalid parameters for "statevector" method.
#result = job.result().get_unitary()
print("Transformation Matrix (up to this stage)")
print(result)
qc.measure(qr, cr)
print()
print("Circuit 1 - Registers, Gate X and Quantum Register Measure")
display(qc.draw('mpl', style="clifford"))
print("Quantum Register Thousand Measures")
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('statevector_simulator'),
shots = 1000)
print(job.result().get_counts())
print()
print("Result's Histogram")
from qiskit.tools.visualization import plot_distribution
plot_distribution(data = job.result().get_counts())
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([1,0],2)
display(qc.draw('mpl', style="clifford"))
sv = Statevector.from_label('000')
state_data = lambda qc,sv: np.round(np.asarray(sv.evolve(qc).data),4)
state_bloch = lambda qc,sv: plot_bloch_multivector(sv.evolve(qc).data, reverse_bits=True)
print(state_data(qc,sv))
state_bloch(qc,sv)
qc.x(0)
qc.barrier()
display(qc.draw('mpl', style="clifford"))
print(state_data(qc,sv))
display(state_bloch(qc,sv))
qc.h(1)
display(qc.draw('mpl', style="clifford"))
print(state_data(qc,sv))
state_bloch(qc,sv)
qc.cx(1,2)
display(qc.draw("mpl", style="clifford"))
state_data(qc,sv)
state_bloch(qc,sv)
qc.cx(0,1)
display(qc.draw('mpl', style="clifford"))
state_data(qc,sv)
qc.h(0)
qc.barrier()
display(qc.draw('mpl', style="clifford"))
state_data(qc,sv)
qc.measure(0,0)
qc.measure(1,1)
qc.barrier()
qc.cx(1,2)
qc.cz(0,2)
qc.measure(2,2)
display(qc.draw('mpl', style='clifford'))
simulador = qk.Aer.get_backend('statevector_simulator')
resultado = qk.execute(qc, simulador, shots=10000).result()
qk.visualization.plot_distribution(resultado.get_counts())
import numpy as np
V = np.array([[3+2j],[4-2j]])
modV = np.real(V.T.conjugate().dot(V)[0,0])**0.5
Vn = V/modV; Vn
v0 = np.array([[1,0]]).T
v1 = np.array([[0,1]]).T
Vn[0,0]*v0 + Vn[1,0]*v1
import qiskit as qk
qr = qk.QuantumRegister(1,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([Vn[0,0],Vn[1,0]],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl', style="clifford")
backend = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,backend,shots=10000).result().get_counts()
qk.visualization.plot_distribution(results)
Vn[0,0].conjugate()*Vn[0,0]
Vn[1,0].conjugate()*Vn[1,0]
import numpy as np
CNOT = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]])
CNOT.dot(CNOT)
import numpy as np
H = np.array([[1,1],[1,-1]])/2**0.5
H.dot(H)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.cnot(qr[0],qr[1])
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.cnot(qr[0],qr[1])
qc.h(0)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
X = np.array([[0,1],
[1,0]])
X
X.conj().T.dot(X)
Y = np.array([[0,-1j],
[1j,0]])
Y
Y.conj().T.dot(Y)
Z = np.array([[1,0],
[0,-1]])
Z
Z.conj().T.dot(Z)
H = (X+Z)/np.sqrt(2); H
H.dot(Z).dot(H)
H.dot(X).dot(H)
-H.dot(Y).dot(H)
import numpy as np
S = np.array([[1,0],
[0,1j]])
S
S.conj().T.dot(S)
T = np.array([[1,0],
[0,np.exp(1j*np.pi/4)]])
T
T.conj().T.dot(T)
S = np.array([[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]]); S
S.dot(v00)
S.dot(v01)
S.dot(v10)
S.dot(v11)
C = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]]);C
C_ = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]]);C_
C.dot(C_).dot(C)
v = v0 + v1; v
n = np.array([[0,0],[0,1]]); n
n.dot(v)
n_ = np.array([[1,0],[0,0]]);n_
I2 = np.identity(2); I2
I2 - n
n_.dot(v)
n.dot(n)
n_.dot(n_)
n.dot(n_)
n_.dot(n)
n+n_
n.dot(X)
X.dot(n_)
import numpy as np
n = np.array([[0,0],[0,1]]); n
n_ = np.array([[1,0],[0,0]]);n_
# ni nj operam em bits distintos. Como cada operador n atua em um vetor de
# 2 dimensões, ni nj é um operador de 4 dimensões. Sendo assim, fica implícito
# pelos subscritos que ni nj é um produto tensorial.
np.kron(n,n)
# O mesmo vale para n'i n'j
np.kron(n_,n_)
# Para ni n'j
np.kron(n,n_)
# E para n'i nj
np.kron(n_,n)
# Xi Xj são dois operadores 2x2 de inversão, cada um atuando em um bit
# distinto. Sendo assim, fazemos o produto tensorial entre ambos
# para obter XiXj
np.kron(X,X)
# No caso da expressão XiXj(ninj' + ni'nj) temos entre parênteses duas
# matrizes 4x4 (ninj'+ni'nj) e fora dos parênteses uma matriz 4x4 (XiXj)
# Sendo assim fazemos neste caso o produto matricial normal para
# calcular esta expressão.
np.kron(X,X).dot(np.kron(n,n_)+np.kron(n_,n))
# E por último somamos com o resultado inicial de ninj + ni'nj'
# Como pode-se ver, esta expressão gera o operador de SWAP
np.kron(n,n) + np.kron(n_,n_) + np.kron(X,X).dot(np.kron(n,n_)+np.kron(n_,n))
# É importante observar que ninj forma um operador que projeta um vetor de
# 4 dimensões (00, 01, 10, 11) em sua componente 11
np.kron(n,n)
# De maneira similar ni'nj' projeta um vetor de 4 dimensões em sua componente 00
np.kron(n_,n_)
# ni'nj projeta em 01
np.kron(n_,n)
# Assim como ninj' projeta em 10
np.kron(n,n_)
# E por último vemos que ni'nj' + ni'nj + ninj' + ninj = I
nn = np.kron(n,n)
nn_ = np.kron(n,n_)
n_n = np.kron(n_,n)
n_n_ = np.kron(n_,n_)
nn + nn_ + n_n + n_n_
import numpy as np
n = np.array([[0,0],[0,1]]); n
n_ = np.array([[1,0],[0,0]]);n_
# (n x n).(n_ x n_)
np.kron(n,n).dot(np.kron(n_,n_))
# Faz sentido que (ni x nj).(ni_ x nj_) seja o vetor nulo pois:
# ni_ x nj_ é um operador que recebe um vetor de 4 dimensões e
# produz como resultado apenas sua componente |00>. Por sua
# vez ni x nj é um operador que recebe um vetor de 4 dimensões
# e produz como resultado apenas sua componente |11>. Esta
# componente foi zerada pelo primeiro operador, logo o resultado
# será nulo. Isto vai acontecer sempre que a componente não
# zerada do primeiro operador for diferente da do segundo em
# outras palavras sempre que ij do primeiro for diferente de ij
# do segundo.
np.kron(n,n).dot(np.kron(n_,n_))
# Outra forma de entender é transformar (n x n).(n_ x n_) em
# (n.n_) x (n.n_). Como n é ortogonal a n_, a projeção de n
# em n_ dará zero também.
np.kron(n.dot(n_),n.dot(n_))
nn.dot(n_n_)
# (n_ x n).(n x n_)
np.kron(n_,n).dot(np.kron(n,n_))
n_n.dot(nn_)
# (n x n_).(n_ x n)
np.kron(n, n_).dot(np.kron(n_,n))
nn_.dot(n_n)
# (n_ x n_).(n x n)
np.kron(n_, n_).dot(np.kron(n, n))
n_n_.dot(nn)
NOT = np.array([[0,1],[1,0]]); NOT
NOT.dot(D0)
NOT.dot(D1)
AND = np.array([[1,1,1,0],[0,0,0,1]]); AND
AND.dot(np.kron(D0,D0))
AND.dot(np.kron(D0,D1))
AND.dot(np.kron(D1,D0))
AND.dot(np.kron(D1,D1))
OR = np.array([[1,0,0,0],[0,1,1,1]]); OR
OR.dot(np.kron(D0,D0))
OR.dot(np.kron(D0,D1))
OR.dot(np.kron(D1,D0))
OR.dot(np.kron(D1,D1))
NAND = np.array([[0,0,0,1],[1,1,1,0]]); NAND
NOT.dot(AND)
NOR = np.array([[0,1,1,1],[1,0,0,0]]);NOR
NOT.dot(OR)
np.kron(NOT,AND)
OR.dot(np.kron(NOT,AND))
NOT.dot(AND).dot(np.kron(NOT,NOT))
OR
NOT.dot(OR).dot(np.kron(NOT,NOT))
AND
import numpy as np
k = np.kron
XOR = np.array([[1,0,0,1],
[0,1,1,0]])
AND = np.array(([1,1,1,0],
[0,0,0,1]))
k(XOR,AND)
def criaCompat(nbits,nvezes):
nlins = 2**(nbits*nvezes)
ncols = 2**nbits
compat = np.zeros(nlins*ncols).reshape(nlins,ncols)
for i in range(ncols):
formato = "0" + str(nbits) + "b"
binario = format(i,formato)*nvezes
decimal = int(binario,2)
compat[decimal,i] = 1
return(compat)
criaCompat(2,2)
k(XOR,AND).dot(criaCompat(2,2))
import numpy as np
k = np.kron
def criaCompat(nbits,nvezes):
nlins = 2**(nbits*nvezes)
ncols = 2**nbits
compat = np.zeros(nlins*ncols).reshape(nlins,ncols)
for i in range(ncols):
formato = "0" + str(nbits) + "b"
binario = format(i,formato)*nvezes
decimal = int(binario,2)
compat[decimal,i] = 1
return(compat)
criaCompat(2,2)
NOT = np.array([[0,1],
[1,0]])
AND3 = np.array([[1,1,1,1,1,1,1,0],
[0,0,0,0,0,0,0,1]])
OR4 = np.array([[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]])
I2 = np.array([[1,0],
[0,1]])
t1z = k(NOT,k(NOT,I2))
t2z = k(NOT,k(I2,NOT))
t3z = k(I2,k(NOT,NOT))
t4z = k(I2,k(I2,I2))
ORz = k(AND3,k(AND3,k(AND3,AND3)))
ORz = OR4.dot(ORz).dot(k(t1z,k(t2z,k(t3z,t4z))))
t1c = k(NOT,k(I2,I2))
t2c = k(I2,k(NOT,I2))
t3c = k(I2,k(I2,NOT))
t4c = k(I2,k(I2,I2))
ORc = k(AND3,k(AND3,k(AND3,AND3)))
ORc = OR4.dot(ORc).dot(k(t1c,k(t2c,k(t3c,t4c))))
compat = criaCompat(3,8)
k(ORz,ORc).dot(compat)
import numpy as np
TOFFOLI = np.array([[1,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1],
[0,0,0,0,0,0,1,0]])
TOFFOLI.dot(TOFFOLI)
Z1 = np.array([[0,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,1]])
Z1
Z1I4 = np.array([[0,0,0,0],
[1,0,0,0],
[0,0,0,0],
[0,1,0,0],
[0,0,0,0],
[0,0,1,0],
[0,0,0,0],
[0,0,0,1]])
TOFFOLI.dot(ZpY).dot(TOFFOLI).dot(Z1I4)
ZpY = np.zeros([8,8])
ZpY[0,0] = 1; ZpY[1,2] = 1; ZpY[2,1] = 1; ZpY[3,3] = 1
ZpY[4,4] = 1; ZpY[5,6] = 1; ZpY[6,5] = 1; ZpY[7,7] = 1
ZpY
Zfim = np.array([[1,0,1,0,1,0,1,0],
[0,1,0,1,0,1,0,1]])
Zfim.dot(TOFFOLI).dot(ZpY).dot(TOFFOLI).dot(Z1I4)
import numpy as np
fred = np.identity(8)
fred[5,5] = 0; fred[5,6] = 1
fred[6,5] = 1; fred[6,6] = 0
fred
fred.dot(fred)
import numpy as np
Fy0 = np.zeros([8,4])
Fy0[0,0] = 1; Fy0[1,1] = 1; Fy0[4,2] = 1; Fy0[5,3] = 1
Fy0
xYz = np.array([[1,1,0,0,1,1,0,0],
[0,0,1,1,0,0,1,1]])
xYz.dot(fred).dot(Fy0)
import numpy as np
q0 = np.array([[1,0]]).T; q0
q1 = np.array([[0,1]]).T; q1
q01 = np.kron(q0,q1); q01
H = np.array([[1,1],[1,-1]])/np.sqrt(2); H
H2 = np.kron(H,H); H2
H2.dot(q01)
I4 = np.eye(4); I4
I4.dot(H2).dot(q01)
I2 = np.eye(2); I2
HI2 = np.kron(H,I2); HI2
HI2.dot(I4).dot(H2).dot(q01)
X = np.array([[0,1],[1,0]]); X
I2 = np.eye(2); I2
I2X = np.kron(I2,X); I2X
HI2.dot(I2X).dot(H2).dot(q01)
CNOT = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]])
CNOT
HI2.dot(CNOT).dot(H2).dot(q01)
X = np.array([[0,1],[1,0]]); X
I2 = np.eye(2); I2
XI2 = np.kron(X,I2); XI2
CNOT = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]])
CNOT
CNOT.dot(XI2)
HI2.dot(CNOT).dot(XI2).dot(H2).dot(q01)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.x(1)
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.cx(0,1)
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.x(0)
qc.cx(0,1)
qc.barrier()
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.barrier()
qc.cnot(1,2)
qc.barrier()
qc.draw('mpl')
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.initialize([0,0,0,0,1,0,0,0],[0,1,2])
qc.h([0,1,2])
qc.barrier()
qc.cnot(1,2)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
qc.draw('mpl')
def histograma(qc):
import qiskit as qk
from qiskit.visualization import plot_histogram
simulador = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulador,shots=10000).result().get_counts()
grafico = plot_histogram(results)
return(grafico)
histograma(qc)
import numpy as np
x1 = np.array([[1,0]]).T
x0 = np.array([[1,0]]).T
y = np.array([[0,1]]).T
psi0 = np.kron(y,np.kron(x1,x0)); psi0.T
import numpy as np
H = np.array([[1, 1],
[1,-1]])/np.sqrt(2)
H3 = np.kron(H,np.kron(H,H)); np.round(H3,3)
psi0 = np.array([[0,0,0,0,1,0,0,0]]).T
psi1 = H3.dot(psi0); psi1.T
CNOTsm = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]])
I2 = np.array([[1,0],
[0,1]])
CNOTsm_I2 = np.kron(CNOTsm,I2)
psi0 = np.array([[0,0,0,0,1,0,0,0]]).T
CNOTsm_I2.dot(H3).dot(psi0).T
psi = np.array([[1,1,-1,-1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.initialize([0,0,0,0,1,0,0,0],[0,1,2])
qc.h([0,1,2])
qc.barrier()
qc.cnot(0,2)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
display(qc.draw('mpl'))
histograma(qc)
import numpy as np
v0 = np.array([[0,0,0,0,1,0,0,0]]).T; v0.T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H); H3 = np.kron(H2,H)
H3.dot(v0).T
CNOTs_I_m = np.array([[1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1],
[0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,0,0,0,0,1,0],
[0,0,0,1,0,0,0,0]])
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
CNOTs_I_m.dot(H3).dot(v0).T
psi = np.array([[+1,-1,+1,-1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
qc = qk.QuantumCircuit(3,3)
qc.initialize([0,0,0,0,1,0,0,0],[0,1,2])
qc.h([0,1,2])
qc.barrier()
qc.cnot(0,1)
qc.cnot(1,2)
qc.cnot(0,1)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
display(qc.draw('mpl'))
histograma(qc)
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H); H3 = np.kron(H2,H)
H3.dot(v0).T
CNOT_CNOT = np.array([[1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,1,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1]])
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H); H3 = np.kron(H2,H)
CNOT_CNOT.dot(H3).dot(v0).T
psi = np.array([[+1,-1,-1,+1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import numpy as np
CNOTsm = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]])
I = np.array([[1,0],
[0,1]])
ISM = np.kron(I,CNOTsm)
SMI = np.kron(CNOTsm,I)
H = np.array([[1, 1],
[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H3 = np.kron(H2,H)
IH2 = np.kron(I,H2)
v0 = np.array([[0,0,0,0,1,0,0,0]]).T
IH2.dot(ISM).dot(SMI).dot(ISM).dot(H3).dot(v0).round(3)
CNOT_CNOT = np.array([[1,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,1,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,1]])
ISM.dot(SMI).dot(ISM)
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([0,1],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.barrier()
qc.h(0)
qc.h(1)
qc.measure(0,0)
qc.measure(1,1)
display(qc.draw('mpl'))
histograma(qc)
psi = np.array([[1,1,1,1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([0,1],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.x(2)
qc.barrier()
qc.h(0)
qc.h(1)
qc.measure(0,0)
qc.measure(1,1)
display(qc.draw('mpl'))
histograma(qc)
psi = np.array([[1,1,1,1]]).T/2
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H2.dot(psi)
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([0,1],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.barrier()
qc.ccx(0,1,2)
qc.barrier()
qc.h(0)
qc.h(1)
qc.measure(0,0)
qc.measure(1,1)
display(qc.draw('mpl'))
histograma(qc)
import qiskit as qk
qrx = qk.QuantumRegister(2,'x')
qry = qk.QuantumRegister(2,'y')
qc = qk.QuantumCircuit(qrx,qry)
qc.barrier()
qc.cx(0,2)
qc.cx(0,3)
qc.cx(1,2)
qc.cx(1,3)
qc.barrier()
qc.draw('mpl')
def histograma(qc):
simulador = qk.Aer.get_backend('statevector_simulator')
resultado = qk.execute(qc,simulador,shots=10000).result()
contagens = resultado.get_counts()
grafico = qk.visualization.plot_histogram(contagens)
return(grafico)
def simon(initial_y, initial_x):
import qiskit as qk
qrx = qk.QuantumRegister(2,'x')
crx = qk.ClassicalRegister(4,'c')
qry = qk.QuantumRegister(2,'y')
qc = qk.QuantumCircuit(qrx,qry,crx)
qc.initialize(initial_x,qrx)
qc.initialize(initial_y,qry)
qc.barrier()
qc.cx(0,2)
qc.cx(0,3)
qc.cx(1,2)
qc.cx(1,3)
qc.barrier()
qc.measure([0,1,2,3],[0,1,2,3])
display(qc.draw('mpl'))
grafico = histograma(qc)
return(grafico)
simon([1,0,0,0],[1,0,0,0])
simon([1,0,0,0],[0,0,0,1])
simon([1,0,0,0],[0,1,0,0])
simon([1,0,0,0],[0,0,1,0])
import qiskit as qk
qrx = qk.QuantumRegister(2,'x')
crx = qk.ClassicalRegister(2,'c')
qry = qk.QuantumRegister(2,'y')
qc = qk.QuantumCircuit(qrx,qry,crx)
qc.initialize([1,0,0,0],qrx)
qc.initialize([1,0,0,0],qry)
qc.h([0,1])
qc.barrier()
qc.cx(0,2)
qc.cx(0,3)
qc.cx(1,2)
qc.cx(1,3)
qc.barrier()
qc.h([0,1])
qc.measure([0,1],[0,1])
display(qc.draw('mpl'))
histograma(qc)
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
x1x0 = np.kron(x1,x0)
y0 = np.array([[1,0]]).T
y1 = np.array([[1,0]]).T
y1y0 = np.kron(y1,y0)
psi0 = np.kron(y1y0,x1x0)
psi0.T
H = np.array([[1,1],[1,-1]],dtype='int')
H2 = np.kron(H,H)
I2 = np.eye(4)
I2H2 = np.kron(I2,H2)
psi1 = I2H2.dot(psi0)/(np.sqrt(2)*np.sqrt(2))
I2H2.dot(psi0).T
Tf1_2 = np.eye(16)
Tf1_2 = Tf1_2[:,[0,5,2,7,4,1,6,3,8,9,10,11,12,13,14,15]]
psi2 = Tf1_2.dot(psi1); psi2.T*2
Tf2_3 = np.eye(16)
Tf2_3 = Tf2_3[:,[0,1,2,3,4,13,6,15,8,9,10,11,12,5,14,7]]
psi3 = Tf2_3.dot(psi2); psi3.T*2
Tf3_4 = np.eye(16)
Tf3_4 = Tf3_4[:,[0,1,6,3,4,5,2,7,8,9,10,15,12,13,14,11]]
psi4 = Tf3_4.dot(psi3); psi4.T*2
Tf4_5 = np.eye(16)
Tf4_5 = Tf4_5[:,[0,1,2,11,4,5,14,7,8,9,10,3,12,13,6,15]]
psi5 = Tf4_5.dot(psi4); psi5.T*2
I2 = np.eye(4)
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
I2H2 = np.kron(I2,H2)
psi6 = I2H2.dot(psi5)
print(psi6.T*2)
import numpy as np
I2 = np.eye(4, dtype='int');
H2 = np.array([[1, 1, 1, 1],
[1,-1, 1,-1],
[1, 1,-1,-1],
[1,-1,-1, 1]])/2;
I2H2 = np.kron(I2,H2);
print(I2H2*2)
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
x2 = np.array([[1,0]]).T
x2x1x0 = np.kron(x2,np.kron(x1,x0))
x2x1x0.T
y0 = np.array([[1,0]]).T
y1 = np.array([[1,0]]).T
y2 = np.array([[1,0]]).T
y2y1y0 = np.kron(y2,np.kron(y1,y0))
y2y1y0.T
psi0 = np.kron(y2y1y0,x2x1x0)
psi0.T
I3 = np.eye(2**3)
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H3 = np.kron(H,H2)
I3H3 = np.kron(I3,H3)
psi1 = I3H3.dot(psi0)
psi1.T.round(2)
n = 2*3 # 2 números de 3 digitos cada
Uf = np.eye(2**n) # 2^6 = 64 posições
Uf = Uf[:,[ 0, 9,18,27,12, 5,30,23,
8, 1,10,11, 4,13,14,15,
16,17, 2,19,20,21,22, 7,
24,25,26, 3,28,29, 6,31,
32,33,34,35,36,37,38,39,
40,41,42,43,44,45,46,47,
48,49,50,51,52,53,54,55,
56,57,58,59,60,61,62,63]]
psi5 = Uf.dot(psi1)
psi5.T.round(2)
psi6 = I3H3.dot(psi5)
psi6.T
np.where(psi6 > 0)[0]
[format(i,'#08b')[2:] for i in np.where(psi6 > 0)[0]]
import numpy as np
CCNOT = np.eye(8)
CCNOT = CCNOT[:,[0,1,2,7,4,5,6,3]]
CCNOT.dot(CCNOT)
import qiskit as qk
def qNAND(y0,x0):
x = qk.QuantumRegister(1,"x")
y = qk.QuantumRegister(1,"y")
z = qk.QuantumRegister(1,"z")
u = qk.QuantumRegister(1,"u")
c = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(x,y,z,u,c)
# Put qubits u and z in state |0>
qc.initialize([1,0],z)
qc.initialize([1,0],u)
qc.initialize(y0,y)
qc.initialize(x0,x)
# Perform computation
qc.barrier()
qc.ccx(x,y,z)
qc.x(z)
# Copy CLASSICALY state of z to u
qc.cx(z,u)
qc.barrier()
# Reverse computation
qc.x(z)
qc.ccx(x,y,z)
qc.barrier()
# Measure results
qc.measure(x,c[0])
qc.measure(y,c[1])
qc.measure(u,c[2])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
grafico = qk.visualization.plot_histogram(results)
return(grafico)
print("0 NAND 0 = 1")
qNAND([1,0],[1,0])
print("0 NAND 1 = 1")
qNAND([1,0],[0,1])
print("1 NAND 0 = 1")
qNAND([0,1],[1,0])
print("1 NAND 1 = 0")
qNAND([0,1],[0,1])
import qiskit as qk
def qOR(y0,x0):
x = qk.QuantumRegister(1,"x")
y = qk.QuantumRegister(1,"y")
z = qk.QuantumRegister(1,"z")
u = qk.QuantumRegister(1,"u")
c = qk.ClassicalRegister(3,'c')
# Initialize qubits
qc = qk.QuantumCircuit(x,y,z,u,c)
qc.initialize(x0,x)
qc.initialize(y0,y)
qc.initialize([1,0],z)
qc.initialize([1,0],u)
# Compute function
qc.barrier()
qc.x(x)
qc.x(y)
qc.ccx(x,y,z)
qc.x(z)
qc.cx(z,u)
qc.barrier()
# Reverse computation
qc.x(z)
qc.ccx(x,y,z)
qc.x(y)
qc.x(x)
qc.barrier()
# Measure results
qc.measure(x,c[0])
qc.measure(y,c[1])
qc.measure(u,c[2])
display(qc.draw('mpl'))
# Simulate circuit
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
grafico = qk.visualization.plot_histogram(results)
return(grafico)
qOR([1,0],[1,0])
qOR([1,0],[0,1])
qOR([0,1],[1,0])
qOR([0,1],[0,1])
import qiskit as qk
def qNXOR(y0,x0,calc=True,show=False):
##################################################
# Create registers #
##################################################
# Base registers
x = qk.QuantumRegister(1,"x")
y = qk.QuantumRegister(1,"y")
# Auxiliary register (for x and y)
z = qk.QuantumRegister(1,"z")
# Auxiliary register (to store x AND y)
a1 = qk.QuantumRegister(1,"a1")
# Auxiliary register (to store NOT(x) AND NOT(y))
a2 = qk.QuantumRegister(1,"a2")
# Auxiliary register (for a1 and a2)
b1 = qk.QuantumRegister(1,"b1")
# Auxiliary register (to store a1 OR a2)
b2 = qk.QuantumRegister(1,"b2")
# Classical Registers to store x,y and final measurement
c = qk.ClassicalRegister(3,"c")
##################################################
# Create Circuit #
##################################################
qc = qk.QuantumCircuit(x,y,z,a1,a2,b1,b2,c)
##################################################
# Initialize registers #
##################################################
qc.initialize(x0,x)
qc.initialize(y0,y)
qc.initialize([1,0],z)
qc.initialize([1,0],a1)
qc.initialize([1,0],a2)
qc.initialize([1,0],b1)
qc.initialize([1,0],b2)
###################################################
# Calculate x AND y. Copy result to a1. Reverse z #
###################################################
qc.barrier()
qc.ccx(x,y,z)
qc.cx(z,a1)
qc.ccx(x,y,z)
qc.barrier()
#########################################################
# Calc. NOT(x) AND NOT(y). Copy result to a2. Reverse z #
#########################################################
qc.barrier()
qc.x(x)
qc.x(y)
qc.ccx(x,y,z)
qc.cx(z,a2)
qc.ccx(x,y,z)
qc.x(y)
qc.x(x)
qc.barrier()
#################################################
# Calc. a1 OR a2. Copy result to b2. Reverse b1 #
#################################################
qc.barrier()
qc.x(a1)
qc.x(a2)
qc.ccx(a1,a2,b1)
qc.x(b1)
qc.cx(b1,b2)
qc.x(b1)
qc.ccx(a1,a2,b1)
qc.barrier()
#################################################
# Measure b2 #
#################################################
qc.measure(x,c[0])
qc.measure(y,c[1])
qc.measure(b2,c[2])
#################################################
# Draw circuit #
#################################################
if show:
display(qc.draw("mpl"))
#################################################
# Run circuit. Collect results #
#################################################
if calc:
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
grafico = qk.visualization.plot_histogram(results)
return(grafico)
else:
return()
qNXOR([1,0],[1,0],False,True)
qNXOR([1,0],[1,0])
qNXOR([1,0],[0,1])
qNXOR([0,1],[1,0])
qNXOR([0,1],[0,1])
x0 = np.array([1,1])/np.sqrt(2)
y0 = np.array([1,1])/np.sqrt(2)
qNXOR(y0,x0)
import qiskit as qk
from qiskit.quantum_info.operators import Operator
qr = qk.QuantumRegister(6,"q")
cr = qk.ClassicalRegister(6,"c")
qc = qk.QuantumCircuit(qr,cr)
for i in range(6):
qc.initialize([1,0],i)
for i in range(3):
qc.h(i)
oracle = np.eye(2**6)
oracle[:,[ 0, 0]] = oracle[:,[ 0, 0]]
oracle[:,[ 1, 9]] = oracle[:,[ 9, 1]]
oracle[:,[ 2, 18]] = oracle[:,[ 18, 2]]
oracle[:,[ 3, 27]] = oracle[:,[ 27, 3]]
oracle[:,[ 4, 12]] = oracle[:,[ 12, 4]]
oracle[:,[ 5, 5]] = oracle[:,[ 5, 5]]
oracle[:,[ 6, 30]] = oracle[:,[ 30, 6]]
oracle[:,[ 7, 23]] = oracle[:,[ 23, 7]]
oracle = Operator(oracle)
qc.append(oracle,qr)
for i in range(3):
qc.h(i)
qc.barrier()
for i in range(3):
qc.measure(i,i)
display(qc.draw("mpl"))
simulator = qk.Aer.get_backend("statevector_simulator")
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
oracle = np.eye(8)
oracle[:,[2,6]] = oracle[:,[6,2]]
oracle
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
psi0 = np.kron(x1,x0)
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
psi1 = H2.dot(psi0)
psi1.T
# Initialize a qubit y in state |1>
y = np.array([[0,1]]).T
# Pass it through a Hadamard gate and obtain state psi2a
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
psi2a = H.dot(y)
psi2a.T
psi2 = np.kron(psi2a,psi1)
psi2.T
oracle = np.eye(8)
oracle[:,[2,6]] = oracle[:,[6,2]]
oracle
psi3 = oracle.dot(psi2)
psi3.T
v0 = np.array([[10,20,-30,40,50]]).T
mu = np.mean(v0)
v0.T, mu
D = v0 - mu
D.T
v1 = 2*np.mean(v0)-v0
v1.T
import numpy as np
A = np.ones(5**2).reshape(5,5)
A = A/5
I = np.eye(5)
R = 2*A-I
R
R.dot(R)
n = 4
I = np.eye(n)
A = np.ones(n**2).reshape(n,n)/n
R = 2*A-I
R
I2 = np.eye(2)
I2R = np.kron(I2,R)
I2R
psi4 = I2R.dot(psi3)
psi4.T
import qiskit as qk
import numpy as np
from qiskit.quantum_info.operators import Operator
q = qk.QuantumRegister(3,'q')
c = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(q,c)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.h(1)
qc.initialize([0,1],2)
qc.h(2)
qc.barrier()
oracle = np.eye(8)
oracle[:,[2,6]] = oracle[:,[6,2]]
oracle = Operator(oracle)
qc.append(oracle,q)
# n = 2 (two digits number to look for)
A = np.ones(4*4).reshape(4,4)/4
I4 = np.eye(4)
R = 2*A - I4
I2 = np.eye(2)
boost = np.kron(I2,R)
boost = Operator(boost)
qc.append(boost,q)
qc.barrier()
qc.measure(q[:2],c[:2])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
x0 = np.array([[1,0]]).T
x1 = np.array([[1,0]]).T
x2 = np.array([[1,0]]).T
x2x1x0 = np.kron(x2,np.kron(x1,x0))
x2x1x0.T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
H2 = np.kron(H,H)
H3 = np.kron(H,H2)
x = H3.dot(x2x1x0)
x.T
y0 = np.array([[0,1]]).T
y0.T
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
y = H.dot(y0)
y.T
psi0 = np.kron(y,x)
psi0.T
oracle = np.eye(16)
oracle[:,[5,13]] = oracle[:,[13,5]]
psi1 = oracle.dot(psi0)
psi1.T
# n = 8
A = np.ones(8*8).reshape(8,8)/8
I8 = np.eye(8)
R = 2*A-I8
R
I2 = np.eye(2)
I2R = np.kron(I2,R)
psi2 = I2R.dot(psi1)
psi2.T
0.625**2 + 0.625**2
psi3 = I2R.dot(oracle).dot(psi2)
psi3.T
0.687**2 + 0.687**2
I2R.dot(oracle).dot(psi3).T
T = I2R.dot(oracle)
psi = psi1
prob = []
for i in range(25):
prob.append(psi[5,0]**2 + psi[13,0]**2)
psi = T.dot(psi)
from matplotlib import pyplot as plt
plt.plot(list(range(25)), prob);
import qiskit as qk
import numpy as np
from qiskit.quantum_info.operators import Operator
q = qk.QuantumRegister(4,'q')
c = qk.ClassicalRegister(4,'c')
qc = qk.QuantumCircuit(q,c)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([1,0],2)
qc.h(0)
qc.h(1)
qc.h(2)
qc.initialize([0,1],3)
qc.h(3)
qc.barrier()
# Create oracle matrix
oracle = np.eye(16)
oracle[:,[5,13]] = oracle[:,[13,5]]
# Create rotation about the mean matrix
# n = 3 (three digits number to look for)
A = np.ones(8*8).reshape(8,8)/8
I8 = np.eye(8)
R = 2*A - I8
# Identity matrix to leave fourth qubit undisturbed
I2 = np.eye(2)
# Create second transformation matrix
boost = np.kron(I2,R)
# Combine oracle with second transformation matrix in
# an unique operator
T = boost.dot(oracle)
T = Operator(T)
# Apply operator twice (2 phase inversions and
# rotations about the mean)
qc.append(T,q)
qc.append(T,q)
qc.barrier()
qc.measure(q[:3],c[:3])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
import numpy as np
from qiskit.quantum_info.operators import Operator
q = qk.QuantumRegister(5,'q')
c = qk.ClassicalRegister(5,'c')
qc = qk.QuantumCircuit(q,c)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([1,0],2)
qc.initialize([1,0],3)
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
qc.initialize([0,1],4)
qc.h(4)
qc.barrier()
# Create oracle matrix
oracle = np.eye(32)
oracle[:,[13,29]] = oracle[:,[29,13]]
# Create rotation about the mean matrix
# n = 4 (four digits number to look for)
A = np.ones(16*16).reshape(16,16)/16
I16 = np.eye(16)
R = 2*A - I16
# Identity matrix to leave fifth qubit undisturbed
I2 = np.eye(2)
# Create second transformation matrix
boost = np.kron(I2,R)
# Combine oracle with second transformation matrix in
# an unique operator
T = boost.dot(oracle)
# n = 4. Therefore it will be necessary 4 T operations
# to get maximum probability.
Tn = T.dot(T).dot(T)
Tn = Operator(Tn)
# Apply operator Tn once (n phase inversions and
# rotations about the mean)
qc.append(Tn,q)
qc.barrier()
qc.measure(q[:4],c[:4])
display(qc.draw('mpl'))
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
import pandas as pd
N = 35; a = 6
GCD = pd.DataFrame({'N':[N], 'a':[a], 'N-a':[N-a]})
while GCD.iloc[-1,2] != 0:
temp = GCD.iloc[-1].values
temp = np.sort(temp); temp[-1] = temp[-2] - temp[-3]
temp = pd.DataFrame(data = temp.reshape(-1,3), columns = ['N','a','N-a'])
GCD = GCD.append(temp, ignore_index=True)
GCD
import numpy as np
import pandas as pd
N = 15; a = 9
GCD = pd.DataFrame({'N':[N], 'a':[a], 'N-a':[N-a]})
while GCD.iloc[-1,2] != 0:
temp = GCD.iloc[-1].values
temp = np.sort(temp); temp[-1] = temp[-2] - temp[-3]
temp = pd.DataFrame(data = temp.reshape(-1,3), columns = ['N','a','N-a'])
GCD = GCD.append(temp, ignore_index=True)
GCD
import numpy as np
np.gcd(6,35), np.gcd(9,15)
import numpy as np
np.gcd(215,35), np.gcd(217,35)
20 % 7
import numpy as np
f = lambda x,a,N: a**x % N
[f(x,2,15) for x in range(10)]
import numpy as np
(13*35)%11, ((2%11)*(24%11))%11
import numpy as np
def f(x,a,N):
a0 = 1
for i in range(x):
a0 = ((a%N)*(a0))%N
return(a0)
[f(x,2,371) for x in range(8)]
[f(x,2,371) for x in range(154,159)]
[f(x,24,371) for x in range(77,81)]
import numpy as np
def fr(a,N):
ax = ((a%N)*(1))%N
x = 1
while ax != 1:
ax = ((a%N)*(ax))%N
x = x+1
return(x)
fr(2,371), fr(6,371), fr(24,371)
import numpy as np
def fr(a,N):
a0 = 1
a0 = ((a%N)*a0)%N
x = 2
find = False
while find==False:
a0 = ((a%N)*(a0))%N
if a0 == 1:
find = True
x = x+1
return(x-1)
N = 35
a = 2
fr(a,N)
2**(12/2)-1, 2**(12/2)+1
np.gcd(63,35), np.gcd(65,35)
import numpy as np
# Function to calculate the period of f(x) = a^x MOD N
def fr(a,N):
a1 = ((a%N)*(1))%N
x = 1
while a1 != 1:
a1 = ((a%N)*a1)%N
x = x+1
return(x)
# Function to factor N based on a
def factor(N, a=2):
r = fr(a,N)
g1 = a**(int(r/2)) - 1
g2 = a**(int(r/2)) + 1
f1 = np.gcd(g1,N)
f2 = np.gcd(g2,N)
return(f1,f2, f1*f2)
factor(247)
factor(1045)
import numpy as np
N = 15 # number to be factored
n = 4 # number of bits necessary to represent N
m = 8 # number of bits necessary to represent N^2
x = np.zeros(2**m).reshape(-1,1)
x[0,0] = 1
x.shape # since x is a 2^8 = 256 positions vector it will not be showed here
y = np.zeros(2**n).reshape(-1,1)
y[0,0] = 1; y.T # y is a 2^4 = 16 positions vector shown below
psi0 = np.kron(y,x)
psi0.shape # psi0 is a 256 x 16 = 4.096 positions vector
In = np.eye(2**n); In.shape
H = np.array([[1,1],[1,-1]])/np.sqrt(2)
Hm = H.copy()
for i in range(1,m):
Hm = np.kron(Hm,H)
Hm.shape
psi1 = np.kron(In,Hm).dot(psi0); psi1.shape
|
https://github.com/jenglick/scipy22-qiskit-runtime-tutorial
|
jenglick
|
# import functionality from qiskit for building and running circuits
from qiskit import QuantumCircuit, BasicAer, transpile
# here we'll create a GHZ state
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cnot(0,1)
circuit.cnot(1,2)
circuit.measure_all()
print(circuit.draw())
# select a quantum backend and run the circuit
backend = BasicAer.get_backend('qasm_simulator')
shots = 2**13
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
from qiskit.visualization import plot_histogram
plot_histogram(counts)
# defining the state |1>
import numpy as np
a = 0
b = 1
state = np.array([a,b])
norm = np.linalg.norm(state)
normalized_state_ONE = state/norm
print(normalized_state_ONE)
# define the state |+>
a = 0.70710678 # 1/sqrt(2)
b = 0.70710678
state = np.array([a,b])
norm = np.linalg.norm(state)
normalized_state_PLUS = state/norm
print(normalized_state_PLUS)
# define the Pauli X operator
x = np.array([[0, 1],
[1, 0]])
from qiskit.visualization import plot_state_city, plot_bloch_multivector
x_eigenvals, x_eigenvecs = np.linalg.eigh(x)
print('\nEigensystem of X:')
print(x_eigenvals)
print(x_eigenvecs)
plot_bloch_multivector(x_eigenvecs[:,1])
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_ONE)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_PLUS)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_ONE)
circuit.sdg(0)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
circuit = QuantumCircuit(1)
circuit.initialize(normalized_state_PLUS)
circuit.sdg(0)
circuit.h(0)
circuit.measure_all()
print(circuit)
job = backend.run(transpile(circuit, backend), shots=shots)
result = job.result()
counts = result.get_counts()
print(counts)
expval = (counts.get('0',0)-counts.get('1',0)) / shots
print('expectation value: {}'.format(expval))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
circ = QuantumCircuit(2, 2)
circ.h(0)
circ.cx(0, 1)
circ.measure([0, 1], [0, 1])
circ.draw("mpl")
from qiskit import transpile, schedule as build_schedule
from qiskit.providers.fake_provider import FakeHanoi
backend = FakeHanoi()
transpiled_circ = transpile(circ, backend) # Undefined Hadamard is replaced by U1
schedule = build_schedule(transpiled_circ, backend)
schedule.draw()
from qiskit import pulse
with pulse.build() as h_q0:
pulse.play(pulse.library.Gaussian(duration=256, amp=0.2, sigma=50, name='custom'),
pulse.DriveChannel(0))
circ.add_calibration('h', [0], h_q0)
schedule = build_schedule(circ, backend)
schedule.draw()
circ = QuantumCircuit(2, 2)
circ.x(0)
circ.x(0)
circ.x(1)
circ.measure([0, 1], [0, 1])
circ.draw("mpl")
schedule = build_schedule(circ, backend, method="as_late_as_possible")
schedule.filter(channels=[pulse.DriveChannel(0), pulse.DriveChannel(1)]).draw()
schedule = build_schedule(circ, backend, method="as_soon_as_possible")
schedule.filter(channels=[pulse.DriveChannel(0), pulse.DriveChannel(1)]).draw()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_circuit_layout
from qiskit.providers.fake_provider import FakeVigo
backend = FakeVigo()
ghz = QuantumCircuit(3, 3)
ghz.h(0)
ghz.cx(0,range(1,3))
ghz.barrier()
ghz.measure(range(3), range(3))
new_circ_lv0 = transpile(ghz, backend=backend, optimization_level=0)
plot_circuit_layout(new_circ_lv0, backend)
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests ClassicalFunction as a gate."""
import unittest
from qiskit.test import QiskitTestCase
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import XGate
from qiskit.utils.optionals import HAS_TWEEDLEDUM
if HAS_TWEEDLEDUM:
from . import examples
from qiskit.circuit.classicalfunction import classical_function as compile_classical_function
@unittest.skipUnless(HAS_TWEEDLEDUM, "Tweedledum is required for these tests.")
class TestOracleDecomposition(QiskitTestCase):
"""Tests ClassicalFunction.decomposition."""
def test_grover_oracle(self):
"""grover_oracle.decomposition"""
oracle = compile_classical_function(examples.grover_oracle)
quantum_circuit = QuantumCircuit(5)
quantum_circuit.append(oracle, [2, 1, 0, 3, 4])
expected = QuantumCircuit(5)
expected.append(XGate().control(4, ctrl_state="1010"), [2, 1, 0, 3, 4])
self.assertEqual(quantum_circuit.decompose(), expected)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/quantumjim/qreative
|
quantumjim
|
import numpy as np
import matplotlib.pyplot as plt
import random
import sys
sys.path.append('../')
from CreativeQiskit import random_grid
grid = random_grid(4,4)
grid_stats,grid_data = grid.get_samples(shots=1,noisy=0.2)
print(grid_data)
def string2array (string):
grid_list = []
for line in string.split('\n'):
grid_list.append( [int(char) for char in line] )
return np.array(grid_list)
print( string2array( '1000\n0010\n0000\n0000' ) )
def random_map (size=(4,4),cell=(4,4),seeds=1,sweeps=1,axes=['x','y'],frac=1,shots=1,noisy=False):
cell_maps = [ [] for _ in range(shots) ]
# loop over all cells, and
for Y in range(size[1]):
cell_lines = [ [] for _ in range(shots) ]
for X in range(size[0]):
grid = random_grid(cell[0],cell[1])
# place the seeds
if seeds>=1:
for seed in range(int(seeds)):
coords = (random.randrange(cell[0]),random.randrange(cell[1]))
grid.NOT( coords )
elif random.random()<seeds:
coords = (random.randrange(cell[0]),random.randrange(cell[1]))
grid.NOT( coords )
# sweep over qubits in cell and apply cnots to neighbours
for sweep in range(sweeps):
for y in range(cell[1]):
# in each sweep, half the qubits act as controls to the cnots, and half as targets
# they then alternate roles from one sweep to the next
# the dividing of qubits into two groups is on in 'checkerboard pattern
for x in range((y+sweep)%2,cell[0],2): # sweeps
for (xx,yy) in [(x+1,y),(x-1,y),(x,y+1),(x,y-1)]:
if (xx in range(cell[0]) and (yy in range(cell[1]))):
axis = random.choice(axes)
grid.CNOT((x,y),(xx,yy),frac=frac,axis=axis)
# collect the results
_,grid_data = grid.get_samples(shots=shots,noisy=noisy)
for sample in range(shots):
cell_lines[sample].append( string2array(grid_data[sample]) )
for sample in range(shots):
cell_maps[sample].append( cell_lines[sample] )
# create the final grid
maps = []
for cell_map in cell_maps:
maps.append( np.block(cell_map) )
return maps
maps = random_map(size=(7,7),cell=(4,4),seeds=0,sweeps=1,frac=0.5,shots=5,noisy=0.015)
for map_sample in maps:
plt.imshow(map_sample,cmap='gray')
plt.axis('off')
plt.show()
|
https://github.com/Chibikuri/qwopt
|
Chibikuri
|
import sys
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
import copy
sys.path.append('../')
from qwopt.compiler import composer
from qwopt.benchmark import fidelity as fid
from numpy import pi
from qiskit import transpile
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
from qiskit import Aer, execute
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors import depolarizing_error
from tqdm import tqdm, trange
from mpl_toolkits.mplot3d import Axes3D
import warnings
warnings.simplefilter('ignore')
alpha = 0.85
target_graph = np.array([[0, 1, 0, 1],
[0, 0, 1, 0],
[0, 1, 0, 1],
[0, 0, 1, 0]])
E = np.array([[1/4, 1/2, 0, 1/2],
[1/4, 0, 1/2, 0],
[1/4, 1/2, 0, 1/2],
[1/4, 0, 1/2, 0]])
# use google matrix
prob_dist = alpha*E + ((1-alpha)/4)*np.ones((4, 4))
init_state = 1/2*np.array([np.sqrt(prob_dist[j][i]) for i in range(4) for j in range(4)])
# Circuit
def four_node(opt, step):
rotation = np.radians(31.788)
cq = QuantumRegister(2, 'control')
tq = QuantumRegister(2, 'target')
c = ClassicalRegister(2, 'classical')
if opt:
anc = QuantumRegister(2, 'ancilla')
qc = QuantumCircuit(cq, tq, anc, c)
else:
qc = QuantumCircuit(cq, tq, c)
# initialize with probability distribution matrix
initial = 1/2*np.array([np.sqrt(prob_dist[j][i]) for i in range(4) for j in range(4)])
qc.initialize(initial, [*cq, *tq])
for t in range(step):
# Ti operation
qc.x(cq[1])
qc.ccx(cq[0], cq[1], tq[1])
qc.x(cq[1])
qc.barrier()
# Kdg operation
if opt:
qc.x(cq)
qc.rccx(cq[0], cq[1], anc[0])
qc.barrier()
qc.ch(anc[0], tq[0])
qc.ch(anc[0], tq[1])
qc.x(anc[0])
qc.cry(-rotation, anc[0], tq[1])
qc.ch(anc[0], tq[0])
qc.barrier()
else:
qc.x(cq)
qc.mcry(-pi/2, cq, tq[0], None)
qc.mcry(-pi/2, cq, tq[1], None)
qc.x(cq)
qc.barrier()
# qc.x(cq[1])
# qc.mcry(-pi/2, cq, tq[0], None)
# qc.mcry(-rotation, cq, tq[1], None)
# qc.x(cq[1])
# qc.barrier()
qc.x(cq[0])
qc.mcry(-pi/2, cq, tq[0], None)
qc.mcry(-rotation, cq, tq[1], None)
qc.x(cq[0])
qc.barrier()
qc.cry(-pi/2, cq[0], tq[0])
qc.cry(-rotation, cq[0], tq[1])
qc.barrier()
# qc.mcry(-pi/2, cq, tq[0], None)
# qc.mcry(-rotation, cq, tq[1], None)
# qc.barrier()
# D operation
qc.x(tq)
qc.cz(tq[0], tq[1])
qc.x(tq)
qc.barrier()
# K operation
if opt:
qc.ch(anc[0], tq[0])
qc.cry(rotation, anc[0], tq[1])
qc.x(anc[0])
qc.ch(anc[0], tq[1])
qc.ch(anc[0], tq[0])
qc.rccx(cq[0], cq[1], anc[0])
qc.x(cq)
qc.barrier()
else:
# previous, and naive imple
# qc.mcry(pi/2, cq, tq[0], None)
# qc.mcry(rotation, cq, tq[1], None)
# qc.barrier()
qc.cry(pi/2, cq[0], tq[0])
qc.cry(rotation, cq[0], tq[1])
qc.barrier()
qc.x(cq[0])
qc.mcry(pi/2, cq, tq[0], None)
qc.mcry(rotation, cq, tq[1], None)
qc.x(cq[0])
qc.barrier()
# qc.x(cq[1])
# qc.mcry(pi/2, cq, tq[0], None)
# qc.mcry(rotation, cq, tq[1], None)
# qc.x(cq[1])
# qc.barrier()
qc.x(cq)
qc.mcry(pi/2, cq, tq[0], None)
qc.mcry(pi/2, cq, tq[1], None)
qc.x(cq)
qc.barrier()
# Tidg operation
qc.x(cq[1])
qc.ccx(cq[0], cq[1], tq[1])
qc.x(cq[1])
qc.barrier()
# swap
qc.swap(tq[0], cq[0])
qc.swap(tq[1], cq[1])
qc.measure(tq, c)
return qc
qc = four_node(True, 1)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend=backend, shots=10000)
count = job.result().get_counts(qc)
print(count)
qc.draw(output='mpl')
ex1_cx = []
ex1_u3 = []
ex2_cx = []
ex2_u3 = []
ex3_cx = []
ex3_u3 = []
ex4_cx = []
ex4_u3 = []
for step in trange(1, 11):
opt_qc = transpile(four_node(True, step), basis_gates=['cx', 'u3'], optimization_level=0)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex1_cx.append(ncx)
ex1_u3.append(nu3)
# ex2
opt_qc = transpile(four_node(True, step), basis_gates=['cx', 'u3'], optimization_level=3)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex2_cx.append(ncx)
ex2_u3.append(nu3)
# ex3
opt_qc = transpile(four_node(False, step), basis_gates=['cx', 'u3'], optimization_level=3)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex3_cx.append(ncx)
ex3_u3.append(nu3)
# ex4
nopt_qc = transpile(four_node(False, step), basis_gates=['cx', 'u3'], optimization_level=0)
ncx = nopt_qc.count_ops().get('cx', 0)
nu3 = nopt_qc.count_ops().get('u3', 0) + nopt_qc.count_ops().get('u2', 0) + nopt_qc.count_ops().get('u1', 0)
ex4_cx.append(ncx)
ex4_u3.append(nu3)
cx = [ex1_cx, ex2_cx, ex3_cx, ex4_cx]
u3 = [ex1_u3, ex2_u3, ex3_u3, ex4_u3]
# color = ['#C23685', '#E38692', '#6BBED5', '#3EBA2B']
# labels = ['with my optimizations', 'with my and qiskit optimizations', 'with qiskit optimizations', 'without optimizations']
steps = range(1, 11)
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(111)
sns.set()
plt.xlabel('the number of steps', fontsize=30)
plt.xticks([i for i in range(11)])
plt.ylabel('the number of operations', fontsize=30)
plt.title('the nuber of operations over steps', fontsize=30)
plt.tick_params(labelsize=20)
plt.plot(steps, ex4_cx, color='#3EBA2B', label='# of CX without optimizations', linewidth=3)
plt.plot(steps, ex4_u3, color='#6BBED5', label='# of single qubit operations without optimizations', linewidth=3)
plt.legend(fontsize=25)
cx = [ex1_cx, ex2_cx, ex3_cx, ex4_cx]
u3 = [ex1_u3, ex2_u3, ex3_u3, ex4_u3]
color = ['#C23685', '#E38692', '#6BBED5', '#3EBA2B']
labels = ['with my optimizations', 'with my and qiskit optimizations', 'with qiskit optimizations', 'without optimizations']
steps = range(1, 11)
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(111)
sns.set()
plt.xlabel('the number of steps', fontsize=30)
plt.xticks([i for i in range(11)])
plt.ylabel('the number of cx', fontsize=30)
plt.title('the nuber of operations over steps', fontsize=30)
plt.tick_params(labelsize=20)
print(list(steps))
for cs, col, lab in zip(cx, color, labels):
plt.plot(steps, cs, color=col, label=lab, linewidth=3)
plt.legend(fontsize=25)
import warnings
warnings.simplefilter('ignore')
qasm_sim = Aer.get_backend('qasm_simulator')
def KL_divergence(p, q, torelance=10e-9):
'''
p: np.array or list
q: np.array or list
'''
parray = np.array(p) + torelance
qarray = np.array(q) + torelance
divergence = np.sum(parray*np.log(parray/qarray))
return divergence
def get_error(qc, ideal, err_model, nq, type='KL', shots=10000):
bins = [format(i, '0%db'%nq) for i in range(2**nq)]
job = execute(qc, backend=qasm_sim, shots=shots, noise_model=err_model)
counts = job.result().get_counts(qc)
prob = np.array([counts.get(b, 0)/shots for b in bins])
id_prob = np.array(ideal)
# l2_error = np.sum([(i-j)**2 for i, j in zip(id_prob, prob)])
KL_error = KL_divergence(id_prob, prob)
return KL_error
def theoretical_prob(initial, step, ptran, nq):
Pi_op = Pi_operator(ptran)
swap = swap_operator(nq)
operator = (2*Pi_op) - np.identity(len(Pi_op))
Szegedy = np.dot(operator, swap)
Szegedy_n = copy.deepcopy(Szegedy)
if step == 0:
init_prob = np.array([abs(i)**2 for i in initial], dtype=np.float)
return init_prob
elif step == 1:
prob = np.array([abs(i)**2 for i in np.dot(Szegedy, initial)],
dtype=np.float)
return prob
else:
for n in range(step-1):
Szegedy_n = np.dot(Szegedy_n, Szegedy)
probs = np.array([abs(i)**2 for i in np.dot(Szegedy_n, initial)],
dtype=np.float)
return probs
def swap_operator(n_qubit):
q1 = QuantumRegister(n_qubit//2)
q2 = QuantumRegister(n_qubit//2)
qc = QuantumCircuit(q1, q2)
for c, t in zip(q1, q2):
qc.swap(c, t)
# FIXME
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend=backend)
swap = job.result().get_unitary(qc)
return swap
def Pi_operator(ptran):
'''
This is not a quantum operation,
just returning matrix
'''
lg = len(ptran)
psi_op = []
count = 0
for i in range(lg):
psi_vec = [0 for _ in range(lg**2)]
for j in range(lg):
psi_vec[count] = np.sqrt(ptran[j][i])
count += 1
psi_op.append(np.kron(np.array(psi_vec).T,
np.conjugate(psi_vec)).reshape((lg**2, lg**2)))
Pi = psi_op[0]
for i in psi_op[1:]:
Pi = np.add(Pi, i)
return Pi
# circuit verifications
# for step in range(1, 11):
# opt_qc1 = transpile(four_node(True, step), basis_gates=['cx', 'u3'], optimization_level=0)
# opt_qc2 = transpile(four_node(True, step), basis_gates=['cx', 'u3'], optimization_level=3)
# opt_qc3 = transpile(four_node(False, step), basis_gates=['cx', 'u3'], optimization_level=3)
# nopt_qc = transpile(four_node(False, step), basis_gates=['cx', 'u3'], optimization_level=0)
# job1 = execute(opt_qc1, backend=qasm_sim, shots=10000)
# job2 = execute(opt_qc2, backend=qasm_sim, shots=10000)
# job3 = execute(opt_qc3, backend=qasm_sim, shots=10000)
# job4 = execute(nopt_qc, backend=qasm_sim, shots=10000)
# count1 = job1.result().get_counts()
# count2 = job2.result().get_counts()
# count3 = job3.result().get_counts()
# count4 = job4.result().get_counts()
# print(count1.get('00'), count2.get('00'), count3.get('00'), count4.get('00'))
ex1_mean = []
ex1_std = []
ex2_mean = []
ex2_std = []
ex3_mean = []
ex3_std = []
ex4_mean = []
ex4_std = []
extime = 10
u3_error = depolarizing_error(0.001, 1)
qw_step = range(1, 11)
gate_error = np.arange(0, 0.03, 0.001)
# errors, steps= np.meshgrid(gate_error, qw_step)
bins = [format(i, '02b') for i in range(2**2)]
step = 5
opt_qc = four_node(True, step)
job = execute(opt_qc, backend=qasm_sim, shots=100000)
count = job.result().get_counts(opt_qc)
ideal_prob = [count.get(i, 0)/100000 for i in bins]
for cxerr in tqdm(gate_error):
# noise model
error_model = NoiseModel()
cx_error = depolarizing_error(cxerr, 2)
error_model.add_all_qubit_quantum_error(u3_error, ['u3', 'u2'])
error_model.add_all_qubit_quantum_error(cx_error, ['cx'])
# ex1
errors = []
for i in range(extime):
opt_qc = transpile(four_node(True, step), basis_gates=['cx', 'u3'], optimization_level=0)
error = get_error(opt_qc, ideal_prob, error_model, 2)
errors.append(error)
ex1_mean.append(np.mean(errors))
ex1_std.append(np.std(errors))
# ex2
errors = []
for i in range(extime):
opt_qc = transpile(four_node(True, step), basis_gates=['cx', 'u3'], optimization_level=3)
error = get_error(opt_qc, ideal_prob, error_model, 2)
errors.append(error)
ex2_mean.append(np.mean(errors))
ex2_std.append(np.std(errors))
# ex3
errors = []
for i in range(extime):
opt_qc = transpile(four_node(False, step), basis_gates=['cx', 'u3'], optimization_level=3)
error = get_error(opt_qc, ideal_prob, error_model, 2)
errors.append(error)
ex3_mean.append(np.mean(errors))
ex3_std.append(np.std(errors))
# ex4
errors=[]
for i in range(extime):
nopt_qc = transpile(four_node(False, step), basis_gates=['cx', 'u3'], optimization_level=0)
error = get_error(nopt_qc, ideal_prob, error_model, 2)
errors.append(error)
ex4_mean.append(np.mean(errors))
ex4_std.append(np.std(errors))
fig = plt.figure(figsize=(20, 10))
# plt.errorbar(gate_error, ex1_mean, yerr=ex1_std, label='With my optimizations')
# # plt.errorbar(gate_error, ex2_mean, yerr=ex2_std, label='With my and qiskit optimizations')
# # plt.errorbar(gate_error, ex3_mean, yerr=ex3_std, label='With qiskit optimizations')
plt.errorbar(gate_error, ex4_mean, yerr=ex4_std, label='Without optimizations')
plt.title('error investigation of %dstep Quantum Walk'%step, fontsize=30)
plt.xlabel('cx error rate', fontsize=30)
plt.ylabel('KL divergence', fontsize=30)
plt.tick_params(labelsize=20)
plt.legend(fontsize=20)
plt.show()
# ex1_mean = []
# ex1_std = []
# ex2_mean = []
# ex2_std = []
# ex3_mean = []
# ex3_std = []
# ex4_mean = []
# ex4_std = []
# extime = 10
# u3_error = depolarizing_error(0, 1)
# qw_step = range(1,6)
# gate_error = np.arange(0, 0.1, 0.01)
# errors, steps= np.meshgrid(gate_error, qw_step)
# bins = [format(i, '02b') for i in range(2**2)]
# for ce, st in tqdm(zip(errors, steps)):
# opt_qc = four_node(True, st[0])
# job = execute(opt_qc, backend=qasm_sim, shots=100000)
# count = job.result().get_counts(opt_qc)
# ideal_prob = [count.get(i, 0)/100000 for i in bins]
# for cxerr, step in zip(ce, st):
# # noise model
# error_model = NoiseModel()
# cx_error = depolarizing_error(cxerr, 2)
# error_model.add_all_qubit_quantum_error(u3_error, ['u3', 'u2'])
# error_model.add_all_qubit_quantum_error(cx_error, ['cx'])
# # ex1
# qcs1 = [four_node(True, step) for i in range(extime)]
# opt_qc1 = transpile(qcs1, basis_gates=['cx', 'u3'], optimization_level=0)
# errors = get_error(opt_qc1, ideal_prob, error_model, 2)
# ex1_mean.append(np.mean(errors))
# ex1_std.append(np.std(errors))
# # ex2
# qcs2 = [four_node(True, step) for i in range(extime)]
# opt_qc2 = transpile(qcs2, basis_gates=['cx', 'u3'], optimization_level=3)
# errors = get_error(opt_qc2, ideal_prob, error_model, 2)
# ex2_mean.append(np.mean(errors))
# ex2_std.append(np.std(errors))
# # ex3
# qcs3 = [four_node(False, step) for i in range(extime)]
# opt_qc3 = transpile(qcs3, basis_gates=['cx', 'u3'], optimization_level=3)
# errors = get_error(opt_qc, ideal_prob, error_model, 2)
# ex3_mean.append(np.mean(errors))
# ex3_std.append(np.std(errors))
# # ex4
# qcs4 = [four_node(False, step) for i in range(extime)]
# nopt_qc = transpile(qcs4, basis_gates=['cx', 'u3'], optimization_level=0)
# error = get_error(nopt_qc, ideal_prob, error_model, 2)
# ex4_mean.append(np.mean(errors))
# ex4_std.append(np.std(errors))
res1 = np.array(ex1_mean).reshape(10, 10)
res2 = np.array(ex2_mean).reshape(10, 10)
res3 = np.array(ex3_mean).reshape(10, 10)
res4 = np.array(ex4_mean).reshape(10, 10)
# fig = plt.figure(figsize=(20, 10))
# ax = Axes3D(fig)
# ax.plot_wireframe(errors, steps, res1, color='#E6855E', linewidth=2, label='With my optimization')
# ax.plot_wireframe(errors, steps, res2, color='#F9DB57', linewidth=2, label='With my and qiskit optimizations')
# ax.plot_wireframe(errors, steps, res3, color='#3DB680', linewidth=2, label='With qiskit optimizations')
# ax.plot_wireframe(errors, steps, res4, color='#6A8CC7', linewidth=2, label='Without optimizations')
# ax.set_xlabel('Cx error rate', labelpad=30, fontsize=30)
# ax.set_ylabel('The number of steps', labelpad=30, fontsize=30)
# ax.set_zlabel('Error', labelpad=30, fontsize=30)
# plt.tick_params(labelsize=20)
# plt.legend(fontsize=20)
# plt.show()
# In this case, we're gonna investigate matrix that has just one partition
alpha = 0.85
target_graph = np.array([[0, 1, 0, 0, 0, 0, 0, 1],
[0, 0, 1, 0, 0, 0, 0, 0],
[0, 1, 0, 1, 0, 0, 0, 0],
[0, 0, 1, 0, 1, 0, 0, 0],
[0, 0, 0, 1, 0, 1, 0, 0],
[0, 0, 0, 0, 1, 0, 1, 0],
[0, 0, 0, 0, 0, 1, 0, 1],
[0, 0, 0, 0, 0, 0, 1, 0]])
E = np.array([[1/8, 1/2, 0, 0, 0, 0, 0, 1/2],
[1/8, 0, 1/2, 0, 0, 0, 0, 0],
[1/8, 1/2, 0, 1/2, 0, 0, 0, 0],
[1/8, 0, 1/2, 0, 1/2, 0, 0, 0],
[1/8, 0, 0, 1/2, 0, 1/2, 0, 0],
[1/8, 0, 0, 0, 1/2, 0, 1/2, 0],
[1/8, 0, 0, 0, 0, 1/2, 0, 1/2],
[1/8, 0, 0, 0, 0, 0, 1/2, 0]])
# use google matrix
lt = len(target_graph)
prob_dist = alpha*E + ((1-alpha)/lt)*np.ones((lt, lt))
init_state_eight = 1/np.sqrt(8)*np.array([np.sqrt(prob_dist[j][i]) for i in range(lt) for j in range(lt)])
# Circuit
def eight_node(opt, step, initial, hardopt=False):
rotation1 = np.radians(31.788)
rotation2 = np.radians(90)
rotation3 = np.radians(23.232)
cq = QuantumRegister(3, 'control')
tq = QuantumRegister(3, 'target')
# ancilla for mct gates
anc = QuantumRegister(3, 'mct anc')
c = ClassicalRegister(3, 'classical')
if opt:
opt_anc = QuantumRegister(2, 'ancilla')
qc = QuantumCircuit(cq, tq, anc, opt_anc, c)
else:
qc = QuantumCircuit(cq, tq, anc, c)
# initialize with probability distribution matrix
if initial is not None:
qc.initialize(initial, [*cq, *tq])
for t in range(step):
# Ti operation
# T1
qc.x(cq[0])
qc.x(cq[2])
qc.mct(cq, tq[2], anc)
qc.x(cq[0])
qc.x(cq[2])
qc.barrier()
# T2
qc.x(cq[0])
qc.mct(cq, tq[1], anc)
qc.x(cq[0])
qc.barrier()
# T3
qc.x(cq[1:])
qc.mct(cq, tq[1], anc)
qc.mct(cq, tq[2], anc)
qc.x(cq[1:])
qc.barrier()
# T4
qc.x(cq[1])
qc.mct(cq, tq[0], anc)
qc.x(cq[1])
qc.barrier()
# T5
qc.x(cq[2])
qc.mct(cq, tq[0], anc)
qc.mct(cq, tq[2], anc)
qc.x(cq[2])
qc.barrier()
# T6
qc.x(tq[2])
qc.mct([*cq, *tq[1:]], tq[0], anc)
qc.x(tq[2])
qc.barrier()
# # Kdg operation
if opt:
qc.x(cq[:])
# qc.rcccx(cq[0], cq[1], cq[2], opt_anc[0])
qc.mct(cq, opt_anc[0], anc)
qc.x(cq[:])
for ryq in tq:
qc.cry(-pi/2, opt_anc[0], ryq)
if hardopt:
raise Exception('under_construction')
else:
qc.x(opt_anc[0])
qc.x(tq[0])
qc.mcry(-rotation3, [opt_anc[0], tq[0]], tq[2], anc)
qc.x(tq[0])
qc.mcry(3/2*pi, [opt_anc[0], tq[0]], tq[1], anc)
qc.mcry(3/2*pi, [opt_anc[0], tq[0]], tq[2], anc)
qc.x(tq[0])
qc.mcry(-rotation2, [opt_anc[0], tq[0]], tq[1], anc)
qc.x(tq[0])
qc.cry(-rotation1, opt_anc[0], tq[0])
qc.x(opt_anc[0])
else:
qc.x(cq[:])
for ryq in tq:
qc.mcry(-pi/2, cq, ryq, anc)
qc.barrier()
qc.x(cq[:])
for i in range(1, 8):
bins = list(format(i, '03b'))
for ib, b in enumerate(bins):
if b == '0':
qc.x(cq[ib])
qc.x(tq[0])
qc.mcry(-rotation3, [*cq, tq[0]], tq[2], anc)
qc.x(tq[0])
qc.mcry(3/2*pi, [*cq, tq[0]], tq[1], anc)
qc.mcry(3/2*pi, [*cq, tq[0]], tq[2], anc)
qc.x(tq[0])
qc.mcry(-rotation2, [*cq, tq[0]], tq[1], anc)
qc.x(tq[0])
qc.mcry(-rotation1, cq, tq[0], anc)
for ib, b in enumerate(bins):
if b == '0':
qc.x(cq[ib])
# D operation
qc.x(tq)
qc.h(tq[2])
qc.ccx(tq[0], tq[1], tq[2])
qc.h(tq[2])
qc.x(tq)
qc.barrier()
# # K operation
if opt:
if hardopt:
raise Exception('under...')
else:
qc.x(opt_anc[0])
qc.cry(rotation1, opt_anc[0], tq[0])
qc.x(tq[0])
qc.mcry(rotation2, [opt_anc[0], tq[0]], tq[1], anc)
qc.x(tq[0])
qc.mcry(3/2*pi, [opt_anc[0], tq[0]], tq[1], anc)
qc.mcry(3/2*pi, [opt_anc[0], tq[0]], tq[2], anc)
qc.x(tq[0])
qc.mcry(rotation3, [opt_anc[0], tq[0]], tq[2], anc)
qc.x(tq[0])
qc.x(opt_anc[0])
for anq in tq:
qc.cry(pi/2, opt_anc[0], anq)
qc.barrier()
qc.x(cq[:])
qc.mct(cq, opt_anc[0], anc)
qc.x(cq[:])
else:
for i in range(1, 8):
bins = list(format(i, '03b'))
for ib, b in enumerate(bins):
if b == '0':
qc.x(cq[ib])
qc.mcry(rotation1, cq, tq[0], anc)
qc.x(tq[0])
qc.mcry(rotation2, [*cq, tq[0]], tq[1], anc)
qc.x(tq[0])
qc.mcry(3/2*pi, [*cq, tq[0]], tq[2], anc)
qc.mcry(3/2*pi, [*cq, tq[0]], tq[1], anc)
qc.x(tq[0])
qc.mcry(rotation3, [*cq, tq[0]], tq[2], anc)
qc.x(tq[0])
for ib, b in enumerate(bins):
if b == '0':
qc.x(cq[ib])
qc.x(cq[:])
for anq in tq:
qc.mcry(pi/2, cq, anq, anc)
qc.x(cq[:])
# # Tidg operation
# T6
qc.x(tq[2])
qc.mct([*cq, *tq[1:]], tq[0], anc)
qc.x(tq[2])
qc.barrier()
# T5
qc.x(cq[2])
qc.mct(cq, tq[0], anc)
qc.mct(cq, tq[2], anc)
qc.x(cq[2])
qc.barrier()
# T4
qc.x(cq[1])
qc.mct(cq, tq[0], anc)
qc.x(cq[1])
qc.barrier()
# T3
qc.x(cq[1:])
qc.mct(cq, tq[1], anc)
qc.mct(cq, tq[2], anc)
qc.x(cq[1:])
qc.barrier()
# T2
qc.x(cq[0])
qc.mct(cq, tq[1], anc)
qc.x(cq[0])
qc.barrier()
# T1
qc.x(cq[0])
qc.x(cq[2])
qc.mct(cq, tq[2], anc)
qc.x(cq[0])
qc.x(cq[2])
qc.barrier()
# swap
for cont, targ in zip(cq, tq):
qc.swap(cont, targ)
qc.measure(cq, c)
return qc
# circuit verifications
qasm_sim = Aer.get_backend("qasm_simulator")
for step in range(1, 11):
opt_qc1 = transpile(eight_node(True, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=0)
opt_qc2 = transpile(eight_node(True, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=3)
opt_qc3 = transpile(eight_node(False, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=3)
nopt_qc = transpile(eight_node(False, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=0)
job1 = execute(opt_qc1, backend=qasm_sim, shots=10000)
job2 = execute(opt_qc2, backend=qasm_sim, shots=10000)
job3 = execute(opt_qc3, backend=qasm_sim, shots=10000)
job4 = execute(nopt_qc, backend=qasm_sim, shots=10000)
count1 = job1.result().get_counts()
count2 = job2.result().get_counts()
count3 = job3.result().get_counts()
count4 = job4.result().get_counts()
print(count1.get('000'), count2.get('000'), count3.get('000'), count4.get('000'))
ex1_cx = []
ex1_u3 = []
ex2_cx = []
ex2_u3 = []
ex3_cx = []
ex3_u3 = []
ex4_cx = []
ex4_u3 = []
for step in trange(1, 11):
opt_qc = transpile(eight_node(True, step, None), basis_gates=['cx', 'u3'], optimization_level=0)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex1_cx.append(ncx)
ex1_u3.append(nu3)
# ex2
opt_qc = transpile(eight_node(True, step, None), basis_gates=['cx', 'u3'], optimization_level=3)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex2_cx.append(ncx)
ex2_u3.append(nu3)
# ex3
opt_qc = transpile(eight_node(False, step, None), basis_gates=['cx', 'u3'], optimization_level=3)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex3_cx.append(ncx)
ex3_u3.append(nu3)
# ex4
nopt_qc = transpile(eight_node(False, step, None), basis_gates=['cx', 'u3'], optimization_level=0)
ncx = nopt_qc.count_ops().get('cx', 0)
nu3 = nopt_qc.count_ops().get('u3', 0) + nopt_qc.count_ops().get('u2', 0) + nopt_qc.count_ops().get('u1', 0)
ex4_cx.append(ncx)
ex4_u3.append(nu3)
steps = range(1, 11)
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(111)
sns.set()
plt.xlabel('the number of steps', fontsize=30)
plt.ylabel('the number of cx', fontsize=30)
plt.title('the nuber of operations over steps', fontsize=30)
plt.tick_params(labelsize=20)
plt.xticks([i for i in range(11)])
# for cs, col, lab in zip(cx, color, labels):
plt.plot(steps, ex4_cx, color= '#3EBA2B', label= '# of CX without optimizations', linewidth=3)
plt.plot(steps, ex4_u3, color= '#6BBED5', label= '# of single qubit operations without optimizations', linewidth=3)
plt.legend(fontsize=25)
cx = [ex1_cx, ex2_cx, ex3_cx, ex4_cx]
u3 = [ex1_u3, ex2_u3, ex3_u3, ex4_u3]
color = ['#C23685', '#E38692', '#6BBED5', '#3EBA2B']
labels = ['with my optimizations', 'with my and qiskit optimizations', 'with qiskit optimizations', 'without optimizations']
steps = range(1, 11)
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(111)
sns.set()
plt.xlabel('the number of steps', fontsize=30)
plt.ylabel('the number of cx', fontsize=30)
plt.title('the nuber of operations over steps', fontsize=30)
plt.tick_params(labelsize=20)
for cs, col, lab in zip(cx, color, labels):
plt.plot(steps, cs, color=col, label=lab, linewidth=3)
plt.legend(fontsize=25)
ex1_mean = []
ex1_std = []
ex2_mean = []
ex2_std = []
ex3_mean = []
ex3_std = []
ex4_mean = []
ex4_std = []
extime = 100
u3_error = depolarizing_error(0, 1)
qw_step = range(1, 11)
gate_error = np.arange(0, 0.03, 0.001)
# errors, steps= np.meshgrid(gate_error, qw_step)
bins = [format(i, '03b') for i in range(2**3)]
step = 3
opt_qc = eight_node(True, step, init_state_eight)
job = execute(opt_qc, backend=qasm_sim, shots=100000)
count = job.result().get_counts(opt_qc)
ideal_prob = [count.get(i, 0)/100000 for i in bins]
for cxerr in tqdm(gate_error, desc="error"):
# noise model
error_model = NoiseModel()
cx_error = depolarizing_error(cxerr, 2)
error_model.add_all_qubit_quantum_error(u3_error, ['u3', 'u2'])
error_model.add_all_qubit_quantum_error(cx_error, ['cx'])
# ex1
# opt_qc = [transpile(eight_node(True, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=0) for i in range(extime)]
# errors = []
# for eqc in opt_qc:
# errors.append(get_error(eqc, ideal_prob, error_model, 3))
# ex1_mean.append(np.mean(errors))
# ex1_std.append(np.std(errors))
# # ex2
# errors = []
# opt_qc = [transpile(eight_node(True, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=3) for i in range(extime)]
# for eqc in opt_qc:
# errors.append(get_error(eqc, ideal_prob, error_model, 3))
# ex2_mean.append(np.mean(errors))
# ex2_std.append(np.std(errors))
# # ex3
# errors = []
# opt_qc = [transpile(eight_node(False, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=3)for i in range(extime)]
# for eqc in opt_qc:
# errors.append(get_error(eqc, ideal_prob, error_model, 3))
# ex3_mean.append(np.mean(errors))
# ex3_std.append(np.std(errors))
# ex4
errors = []
nopt_qc = [transpile(eight_node(False, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=0) for i in range(extime)]
for eqc in nopt_qc:
errors.append(get_error(eqc, ideal_prob, error_model, 3))
ex4_mean.append(np.mean(errors))
ex4_std.append(np.std(errors))
fig = plt.figure(figsize=(20, 10))
sns.set()
# plt.errorbar(gate_error, ex1_mean, yerr=ex1_std, label='With my optimizations')
# # plt.errorbar(gate_error, ex2_mean, yerr=ex2_std, label='With my and qiskit optimizations')
# # plt.errorbar(gate_error, ex3_mean, yerr=ex3_std, label='With qiskit optimizations')
plt.errorbar(gate_error, ex4_mean, yerr=ex4_std, label='Without optimizations')
plt.title('error investigation of %dstep Quantum Walk'%step, fontsize=30)
plt.xlabel('cx error rate', fontsize=30)
plt.ylabel('KL divergence', fontsize=30)
plt.tick_params(labelsize=20)
plt.legend(fontsize=20)
plt.show()
# 1step
fig = plt.figure(figsize=(20, 10))
plt.plot(gate_error, ex1_mean, label='ex1')
plt.plot(gate_error, ex2_mean, label='ex2')
plt.plot(gate_error, ex3_mean, label='ex3')
plt.plot(gate_error, ex4_mean, label='ex4')
plt.tick_params(labelsize=20)
plt.legend(fontsize=20)
plt.show()
# res1 = np.array(ex1_mean).reshape(10, 10)
# res2 = np.array(ex2_mean).reshape(10, 10)
# res3 = np.array(ex3_mean).reshape(10, 10)
# res4 = np.array(ex4_mean).reshape(10, 10)
# fig = plt.figure(figsize=(20, 10))
# ax = Axes3D(fig)
# ax.plot_wireframe(errors, steps, res1, color='#E6855E', linewidth=2, label='With my optimization')
# ax.plot_wireframe(errors, steps, res2, color='#F9DB57', linewidth=2, label='With my and qiskit optimizations')
# ax.plot_wireframe(errors, steps, res3, color='#3DB680', linewidth=2, label='With qiskit optimizations')
# ax.plot_wireframe(errors, steps, res4, color='#6A8CC7', linewidth=2, label='Without optimizations')
# ax.set_xlabel('Cx error rate', labelpad=30, fontsize=30)
# ax.set_ylabel('The number of steps', labelpad=30, fontsize=30)
# ax.set_zlabel('Error', labelpad=30, fontsize=30)
# plt.tick_params(labelsize=20)
# plt.legend(fontsize=20)
# plt.show()
alpha = 0.85
target_graph = np.array([[0, 0, 0, 1, 1, 0, 0, 0],
[1, 0, 0, 0, 1, 0, 0, 0],
[0, 1, 0, 0, 0, 1, 0, 0],
[0, 0, 1, 0, 0, 1, 0, 0],
[0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 1, 1],
[0, 0, 0, 0, 0, 0, 1, 1]])
E = np.array([[0, 0, 0, 1, 1/2, 0, 0, 0],
[1, 0, 0, 0, 1/2, 0, 0, 0],
[0, 1, 0, 0, 0, 1/2, 0, 0],
[0, 0, 1, 0, 0, 1/2, 0, 0],
[0, 0, 0, 0, 0, 0, 1/4, 1/4],
[0, 0, 0, 0, 0, 0, 1/4, 1/4],
[0, 0, 0, 0, 0, 0, 1/4, 1/4],
[0, 0, 0, 0, 0, 0, 1/4, 1/4]])
# use google matrix
prob_dist = alpha*E + ((1-alpha)/8)*np.ones((8, 8))
init_state_eight = 1/np.sqrt(8)*np.array([np.sqrt(prob_dist[j][i]) for i in range(8) for j in range(8)])
def mch(qc, controls, target, anc, tganc):
# multi control hadamard gate
if len(controls) == 1:
qc.ch(*controls, target)
elif len(controls) == 2:
qc.ccx(controls[0], controls[1], tganc[0])
qc.ch(tganc[0], target)
qc.ccx(controls[0], controls[1], tganc[0])
elif len(controls) > 2:
qc.mct(controls, tganc[0], anc)
for tg in target:
qc.ch(tganc[0], tg)
qc.mct(controls, tganc[0], anc)
return qc
qasm_sim = Aer.get_backend("qasm_simulator")
q = QuantumRegister(6)
anc = QuantumRegister(3)
tganc = QuantumRegister(1)
c = ClassicalRegister(10)
qc = QuantumCircuit(q, anc, tganc, c)
mch(qc, [q[0], q[3]], [q[4], q[5]], anc, tganc)
qc.barrier()
qc.draw(output='mpl')
qc.measure(q, c[:6])
qc.measure(anc, c[6:9])
qc.measure(tganc, c[9])
job = execute(qc, backend=qasm_sim, shots=1024)
count = job.result().get_counts(qc)
print(count)
qc.draw(output='mpl')
# Circuit
def eight_node_multi(opt, step, initial, hardopt=False):
rotation11 = np.radians(31.788)
rotation12 = np.radians(23.231)
rotation13 = np.radians(163.285)
rotation21 = np.radians(31.788)
rotation22 = np.radians(23.231)
rotation31 = np.radians(148.212)
# for multi qubit hadamrd gate
hs = QuantumCircuit.ch
cq = QuantumRegister(3, 'control')
tq = QuantumRegister(3, 'target')
# ancilla for mct gates
anc = QuantumRegister(3, 'mct anc')
tganc = QuantumRegister(1, 'tgancila')
c = ClassicalRegister(3, 'classical')
if opt:
opt_anc = QuantumRegister(2, 'ancilla')
qc = QuantumCircuit(cq, tq, anc, opt_anc, tganc, c)
else:
qc = QuantumCircuit(cq, tq, anc,tganc, c)
# initialize with probability distribution matrix
if initial is not None:
qc.initialize(initial, [*cq, *tq])
for t in range(step):
# Ti operation(opt)
# T11
qc.x(cq[1])
qc.ccx(cq[1], cq[2], tq[1])
qc.x(cq[1])
qc.barrier()
# T12
qc.x(cq[0])
qc.x(cq[2])
qc.mct(cq, tq[1], anc)
qc.x(cq[0])
qc.x(cq[2])
qc.barrier()
# T21
qc.x(cq[0])
qc.ccx(cq[0], cq[2], tq[2])
qc.x(cq[0])
qc.barrier()
# # Kdg operation
if opt:
if hardopt:
raise Exception('under const')
else:
# K1dg
qc.x(cq[0]) # s1
qc.x(tq[0]) # s2
mch(qc, [cq[0], tq[0], tq[1]], [tq[2]], anc, tganc)
qc.x(tq[1]) # s3
qc.mcry(-rotation13, [cq[0], tq[0], tq[1]], tq[2], anc)
qc.x(tq[1]) # e3
qc.x(tq[0]) # e2
mch(qc, [cq[0], tq[0]], [tq[1], tq[2]], anc, tganc)
qc.x(tq[0]) # s4
qc.mcry(-rotation12, [cq[0], tq[0]], tq[1], anc)
qc.x(tq[0]) # e4
qc.cry(-rotation11, cq[0], tq[0])
qc.x(cq[0]) # e1
qc.barrier
# K2dg
# map
qc.x(cq[1])
qc.ccx(cq[1], cq[0], opt_anc[0])
qc.x(cq[1])
# op
qc.ch(opt_anc[0], tq[2])
mch(qc, [opt_anc[0], tq[0]], tq[1], anc, tganc)
qc.x(tq[0])# s1
qc.mcry(-rotation22, [opt_anc[0], tq[0]], tq[1], anc)
qc.x(tq[0]) # e1
qc.cry(-rotation21, opt_anc[0], tq[0])
qc.barrier
# K3dg
#map
qc.ccx(cq[1], cq[0], opt_anc[1])
# op
qc.ch(opt_anc[1], tq[2])
qc.ch(opt_anc[1], tq[1])
qc.cry(-rotation31, opt_anc[1], tq[0])
qc.barrier
else:
# K1dg
qc.x(cq[0]) # s1
qc.x(tq[0]) # s2
mch(qc, [cq[0], tq[0], tq[1]], [tq[2]], anc, tganc)
qc.x(tq[1]) # s3
qc.mcry(-rotation13, [cq[0], tq[0], tq[1]], tq[2], anc) # rotation 3 dg
qc.x(tq[1]) # e3
qc.x(tq[0]) # e2
mch(qc, [cq[0], tq[0]], [tq[1], tq[2]], anc, tganc)
qc.x(tq[0]) # s4
qc.mcry(-rotation12, [cq[0], tq[0]], tq[1], anc)
qc.x(tq[0]) # e4
qc.cry(-rotation11, cq[0], tq[0])
qc.x(cq[0]) # e1
# K2dg
qc.x(cq[1]) # s1
qc.x(tq[0]) # s2
mch(qc, [cq[0], cq[1], tq[0]], [tq[2]], anc, tganc)
qc.x(tq[0]) # e2
mch(qc, [cq[0], cq[1], tq[0]], [tq[1], tq[2]], anc, tganc)
qc.x(tq[0]) # s3
qc.mcry(-rotation22, [cq[0], cq[1], tq[0]], tq[1], anc)
qc.x(tq[0]) # e3
qc.mcry(-rotation21, [cq[0], cq[1]], tq[0], anc)
qc.x(cq[1])
# K3dg
mch(qc, [cq[0], cq[1]], [tq[1], tq[2]], anc, tganc)
qc.mcry(-rotation31, [cq[0], cq[1]], tq[0], anc)
# D operation
qc.x(tq)
qc.h(tq[2])
qc.ccx(tq[0], tq[1], tq[2])
qc.h(tq[2])
qc.x(tq)
qc.barrier()
# # K operation
if opt:
if hardopt:
raise Exception('under')
else:
# K3
qc.cry(rotation31, opt_anc[1], tq[0])
qc.ch(opt_anc[1], tq[1])
qc.ch(opt_anc[1], tq[2])
#unmap
qc.ccx(cq[1], cq[0], opt_anc[1])
qc.barrier()
# K2
qc.cry(rotation21, opt_anc[0], tq[0])
qc.x(tq[0]) # s1
qc.mcry(rotation22, [opt_anc[0], tq[0]], tq[1], anc)
qc.x(tq[0])
mch(qc, [opt_anc[0], tq[0]], tq[1], anc, tganc)
qc.ch(opt_anc[0], tq[2])
# unmap
qc.x(cq[1])
qc.ccx(cq[1], cq[0], opt_anc[0])
qc.x(cq[1])
# op
qc.barrier
# K1
qc.x(cq[0]) # s1
qc.cry(rotation11, cq[0], tq[0])
qc.x(tq[0]) # s2
qc.mcry(rotation12, [cq[0], tq[0]], tq[1], anc)
qc.x(tq[0]) # e2
mch(qc, [cq[0], tq[0]], [tq[1], tq[2]], anc, tganc)
qc.x(tq[0]) #s3
qc.x(tq[1]) # s4
qc.mcry(rotation13, [cq[0], tq[0], tq[1]], tq[2], anc)
qc.x(tq[1]) # 4
mch(qc, [cq[0], tq[0], tq[1]], [tq[2]], anc, tganc)
qc.x(tq[0]) # e3
qc.x(cq[0]) # e1
qc.barrier
else:
# K3
qc.mcry(rotation31, [cq[0], cq[1]], tq[0], anc)
mch(qc, [cq[0], cq[1]], [tq[1], tq[2]], anc, tganc)
# K2
qc.x(cq[1])
qc.mcry(rotation21, [cq[0], cq[1]], tq[0], anc)
qc.x(tq[0]) # e3
qc.mcry(rotation22, [cq[0], cq[1], tq[0]], tq[1], anc)
qc.x(tq[0]) # s3
mch(qc, [cq[0], cq[1], tq[0]], [tq[1], tq[2]], anc, tganc)
qc.x(tq[0]) # e2
mch(qc, [cq[0], cq[1], tq[0]], [tq[2]], anc, tganc)
qc.x(tq[0]) # s2
qc.x(cq[0])
qc.x(cq[1]) # s1
# K1
qc.cry(rotation11, cq[0], tq[0])
qc.x(tq[0]) # e4
qc.mcry(rotation12, [cq[0], tq[0]], tq[1], anc)
qc.x(tq[0]) # s4
mch(qc, [cq[0], tq[0]], [tq[1], tq[2]], anc, tganc)
qc.x(tq[0]) # e2
qc.x(tq[1]) # e3
qc.mcry(rotation13, [cq[0], tq[0], tq[1]], tq[2], anc) # rotation 3 dg
qc.x(tq[1]) # s3
mch(qc, [cq[0], tq[0], tq[1]], [tq[2]], anc, tganc)
qc.x(tq[0]) # s2
qc.x(cq[0]) # s1
# T21 dg
qc.x(cq[0])
qc.ccx(cq[0], cq[2], tq[2])
qc.x(cq[0])
qc.barrier()
# T12dg
qc.x(cq[0])
qc.x(cq[2])
qc.mct(cq, tq[1], anc)
qc.x(cq[0])
qc.x(cq[2])
qc.barrier()
# T11 dg
qc.x(cq[1])
qc.ccx(cq[0], cq[1], tq[1])
qc.x(cq[1])
# swap
for cont, targ in zip(cq, tq):
qc.swap(cont, targ)
qc.measure(cq, c)
return qc
qc = eight_node_multi(True, 1, None)
qc.draw(output='mpl')
# circuit verifications
qasm_sim = Aer.get_backend('qasm_simulator')
init_state = [np.sqrt(1/64) for i in range(64)]
for step in range(1, 11):
opt_qc1 = transpile(eight_node_multi(True, step, init_state), basis_gates=['cx', 'u3'], optimization_level=0)
opt_qc2 = transpile(eight_node_multi(True, step, init_state), basis_gates=['cx', 'u3'], optimization_level=3)
opt_qc3 = transpile(eight_node_multi(False, step, init_state), basis_gates=['cx', 'u3'], optimization_level=3)
nopt_qc = transpile(eight_node_multi(False, step, init_state), basis_gates=['cx', 'u3'], optimization_level=0)
job1 = execute(opt_qc1, backend=qasm_sim, shots=10000)
job2 = execute(opt_qc2, backend=qasm_sim, shots=10000)
job3 = execute(opt_qc3, backend=qasm_sim, shots=10000)
job4 = execute(nopt_qc, backend=qasm_sim, shots=10000)
count1 = job1.result().get_counts()
count2 = job2.result().get_counts()
count3 = job3.result().get_counts()
count4 = job4.result().get_counts()
print(count1.get('000'), count2.get('000'), count3.get('000'), count4.get('000'))
ex1_cx = []
ex1_u3 = []
ex2_cx = []
ex2_u3 = []
ex3_cx = []
ex3_u3 = []
ex4_cx = []
ex4_u3 = []
for step in trange(1, 11):
opt_qc = transpile(eight_node_multi(True, step, None), basis_gates=['cx', 'u3'], optimization_level=0)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex1_cx.append(ncx)
ex1_u3.append(nu3)
# ex2
opt_qc = transpile(eight_node_multi(True, step, None), basis_gates=['cx', 'u3'], optimization_level=3)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex2_cx.append(ncx)
ex2_u3.append(nu3)
# ex3
opt_qc = transpile(eight_node_multi(False, step, None), basis_gates=['cx', 'u3'], optimization_level=3)
ncx = opt_qc.count_ops().get('cx', 0)
nu3 = opt_qc.count_ops().get('u3', 0) + opt_qc.count_ops().get('u2', 0) + opt_qc.count_ops().get('u1', 0)
ex3_cx.append(ncx)
ex3_u3.append(nu3)
# ex4
nopt_qc = transpile(eight_node_multi(False, step, None), basis_gates=['cx', 'u3'], optimization_level=0)
ncx = nopt_qc.count_ops().get('cx', 0)
nu3 = nopt_qc.count_ops().get('u3', 0) + nopt_qc.count_ops().get('u2', 0) + nopt_qc.count_ops().get('u1', 0)
ex4_cx.append(ncx)
ex4_u3.append(nu3)
qc = eight_node_multi(False, 1, None)
print(qc.depth())
qc = eight_node_multi(False, 2, None)
print(qc.depth())
cx = [ex1_cx, ex4_cx]
u3 = [ex1_u3, ex4_u3]
color = ['#C23685', '#6BBED5', '#3EBA2B']
labels = ['with my optimizations', 'related works[6]']
steps = range(1, 11)
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(111)
sns.set()
plt.xlabel('the number of steps', fontsize=30)
plt.yticks(range(0, 9000, 500))
plt.xticks(range(0, 11, 1))
plt.ylabel('the number of cx', fontsize=30)
plt.title('the nuber of operations over steps', fontsize=30)
plt.tick_params(labelsize=20)
plt.plot(steps, ex4_cx, color= '#3EBA2B', label="# of CX paper circuit", linewidth=3)
plt.plot(steps, ex4_u3, color= '#6BBED5', label="# of single qubit gates of paper circuit", linewidth=3)
plt.legend(fontsize=25)
cx = [ex1_cx, ex4_cx]
u3 = [ex1_u3, ex4_u3]
color = ['#C23685', '#6BBED5', '#3EBA2B']
labels = ['with my optimizations', 'related works[6]']
steps = range(1, 11)
fig = plt.figure(figsize=(20, 10))
ax = fig.add_subplot(111)
sns.set()
plt.xlabel('the number of steps', fontsize=30)
plt.yticks(range(0, 4600, 200))
plt.xticks(range(0, 11, 1))
plt.ylabel('the number of cx', fontsize=30)
plt.title('the nuber of operations over steps', fontsize=30)
plt.tick_params(labelsize=20)
for cs, col, lab in zip(cx, color, labels):
plt.plot(steps, cs, color=col, label=lab, linewidth=3)
plt.legend(fontsize=25)
ex1_mean = []
ex1_std = []
ex4_mean = []
ex4_std = []
extime = 10
u3_error = depolarizing_error(0, 1)
gate_error = np.arange(0, 0.03, 0.001)
# errors, steps= np.meshgrid(gate_error, qw_step)
bins = [format(i, '03b') for i in range(2**3)]
step = 5
opt_qc = eight_node_multi(False, step, init_state_eight)
job = execute(opt_qc, backend=qasm_sim, shots=100000)
count = job.result().get_counts(opt_qc)
ideal_prob = [count.get(i, 0)/100000 for i in bins]
for cxerr in tqdm(gate_error):
# noise model
error_model = NoiseModel()
cx_error = depolarizing_error(cxerr, 2)
error_model.add_all_qubit_quantum_error(u3_error, ['u3', 'u2'])
error_model.add_all_qubit_quantum_error(cx_error, ['cx'])
# ex1
opt_qc = transpile(eight_node_multi(True, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=0)
errors = []
for i in range(extime):
error = get_error(opt_qc, ideal_prob, error_model, 3)
errors.append(error)
ex1_mean.append(np.mean(errors))
ex1_std.append(np.std(errors))
# ex4
nopt_qc = transpile(eight_node_multi(False, step, init_state_eight), basis_gates=['cx', 'u3'], optimization_level=0)
for i in range(extime):
error = get_error(nopt_qc, ideal_prob, error_model, 3)
errors.append(error)
ex4_mean.append(np.mean(errors))
ex4_std.append(np.std(errors))
fig = plt.figure(figsize=(20, 10))
sns.set()
# plt.errorbar(gate_error, ex1_mean, yerr=ex1_std, label='With my optimizations')
plt.errorbar(gate_error, ex4_mean, yerr=ex4_std, label='Without optimizations')
plt.title('error investigation of %dstep Quantum Walk'%step, fontsize=30)
plt.xlabel('cx error rate', fontsize=30)
plt.ylabel('KL divergence', fontsize=30)
plt.tick_params(labelsize=20)
plt.legend(fontsize=20)
plt.show()
q = QuantumRegister(1)
qc = QuantumCircuit(q)
rotation12 = np.radians(23.231)
qc.u3(pi/2+rotation12, 0, pi, q[0])
unit = Aer.get_backend('unitary_simulator')
job = execute(qc, backend=unit)
uni = job.result().get_unitary()
print(uni)
q = QuantumRegister(1)
qc = QuantumCircuit(q)
rotation12 = np.radians(23.231)
qc.u3(pi/2, 0, pi, q[0])
qc.ry(rotation12, q[0])
unit = Aer.get_backend('unitary_simulator')
job = execute(qc, backend=unit)
uni = job.result().get_unitary()
print(uni)
q = QuantumRegister(3,'qr')
anc = QuantumRegister(2, 'anc')
qc = QuantumCircuit(q, anc)
qc.mcmt([q[0], q[1]], anc, QuantumCircuit.ch, [q[2]])
qc.draw(output='mpl')
q = QuantumRegister(6)
qc = QuantumCircuit(q)
qc.initialize(init_state, q)
nqc = transpile(qc, basis_gates=['cx', 'h', 'x', 'u3'])
nqc.draw(output='mpl')
|
https://github.com/Morcu/Qiskit_Hands-on-lab
|
Morcu
|
from qiskit import *
#Comando para que las graficas se vean en el notebook
%matplotlib inline
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr)
circuit.draw()
circuit.draw(output='mpl')
qr = QuantumRegister(2, 'quantum')
cr = ClassicalRegister(2, 'classical')
circuit.draw()
circuit.draw(output='mpl')
circuit.h(qr[0])
circuit.draw(output='mpl')
circuit.cx(qr[0], qr[1])
circuit.draw(output='mpl')
circuit.measure(qr, cr)
circuit.draw(output='mpl')
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend=backend).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(circuit))
'''
El IMB_TOKEN se puede obtener en: https://quantum-computing.ibm.com/account
'''
#IBMQ.save_account('IMB_TOKEN', overwrite=True)
IBMQ.load_account()
provider = IBMQ.get_provider(group='open')
provider.backends()
provider = IBMQ.get_provider('ibm-q')
qcomp = provider.get_backend('ibmqx2')
job = execute(circuit, backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result = job.result()
plot_histogram(result.get_counts(circuit))
|
https://github.com/Glebegor/Quantum-programming-algorithms
|
Glebegor
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier, VQC
from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor, VQR
from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN
algorithm_globals.random_seed = 42
num_inputs = 2
num_samples = 20
X = 2 * algorithm_globals.random.random([num_samples, num_inputs]) - 1
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()
# construct QNN
qc = QuantumCircuit(2)
feature_map = ZZFeatureMap(2)
ansatz = RealAmplitudes(2)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
qc.draw(output="mpl")
estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# QNN maps inputs to [-1, +1]
estimator_qnn.forward(X[0, :], algorithm_globals.random.random(estimator_qnn.num_weights))
# callback function that draws a live plot when the .fit() method is called
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
# construct neural network classifier
estimator_classifier = NeuralNetworkClassifier(
estimator_qnn, optimizer=COBYLA(maxiter=60), callback=callback_graph
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
estimator_classifier.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
estimator_classifier.score(X, y)
# evaluate data points
y_predict = estimator_classifier.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y, y_predict):
if y_target == 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()
estimator_classifier.weights
# construct feature map
feature_map = ZZFeatureMap(num_inputs)
# construct ansatz
ansatz = RealAmplitudes(num_inputs, reps=1)
# construct quantum circuit
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
sampler_qnn = SamplerQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=output_shape,
)
# construct classifier
sampler_classifier = NeuralNetworkClassifier(
neural_network=sampler_qnn, optimizer=COBYLA(maxiter=30), callback=callback_graph
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
sampler_classifier.fit(X, y01)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
sampler_classifier.score(X, y01)
# evaluate data points
y_predict = sampler_classifier.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y01, y_predict):
if y_target == 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()
sampler_classifier.weights
# construct feature map, ansatz, and optimizer
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
# construct variational quantum classifier
vqc = VQC(
feature_map=feature_map,
ansatz=ansatz,
loss="cross_entropy",
optimizer=COBYLA(maxiter=30),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
vqc.fit(X, y_one_hot)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
vqc.score(X, y_one_hot)
# evaluate data points
y_predict = vqc.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y_one_hot, y_predict):
if y_target[0] == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
if not np.all(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()
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
X, y = make_classification(
n_samples=10,
n_features=2,
n_classes=3,
n_redundant=0,
n_clusters_per_class=1,
class_sep=2.0,
random_state=algorithm_globals.random_seed,
)
X = MinMaxScaler().fit_transform(X)
plt.scatter(X[:, 0], X[:, 1], c=y)
y_cat = np.empty(y.shape, dtype=str)
y_cat[y == 0] = "A"
y_cat[y == 1] = "B"
y_cat[y == 2] = "C"
print(y_cat)
vqc = VQC(
num_qubits=2,
optimizer=COBYLA(maxiter=30),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
vqc.fit(X, y_cat)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
vqc.score(X, y_cat)
predict = vqc.predict(X)
print(f"Predicted labels: {predict}")
print(f"Ground truth: {y_cat}")
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
X_ = np.linspace(lb, ub, num=50).reshape(50, 1)
f = lambda x: np.sin(x)
X = (ub - lb) * algorithm_globals.random.random([num_samples, 1]) + lb
y = f(X[:, 0]) + eps * (2 * algorithm_globals.random.random(num_samples) - 1)
plt.plot(X_, f(X_), "r--")
plt.plot(X, y, "bo")
plt.show()
# construct simple feature map
param_x = Parameter("x")
feature_map = QuantumCircuit(1, name="fm")
feature_map.ry(param_x, 0)
# construct simple ansatz
param_y = Parameter("y")
ansatz = QuantumCircuit(1, name="vf")
ansatz.ry(param_y, 0)
# construct a circuit
qc = QuantumCircuit(1)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
# construct QNN
regression_estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# construct the regressor from the neural network
regressor = NeuralNetworkRegressor(
neural_network=regression_estimator_qnn,
loss="squared_error",
optimizer=L_BFGS_B(maxiter=5),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit to data
regressor.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score the result
regressor.score(X, y)
# plot target function
plt.plot(X_, f(X_), "r--")
# plot data
plt.plot(X, y, "bo")
# plot fitted line
y_ = regressor.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()
regressor.weights
vqr = VQR(
feature_map=feature_map,
ansatz=ansatz,
optimizer=L_BFGS_B(maxiter=5),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit regressor
vqr.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score result
vqr.score(X, y)
# plot target function
plt.plot(X_, f(X_), "r--")
# plot data
plt.plot(X, y, "bo")
# plot fitted line
y_ = vqr.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/alexyev/quantum_options_pricing
|
alexyev
|
#!pip install qiskit
#!pip install qiskit_finance
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_finance.circuit.library import LogNormalDistribution
# Since we're still modelling the same underlying with the same spot price,
# we use the same probability loading
num_uncertainty_qubits = 3
spot = 3.0
vol = 0.2 #volatility
rate = 0.05 #annual interest rate
T = 100 / 365 #100 days until expiry
# returns are log-normally distributed, values relating to this distribution shown here
mu = (rate - 0.5 * vol ** 2) * T + np.log(spot)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma ** 2 / 2)
variance = (np.exp(sigma ** 2) - 1) * np.exp(2 * mu + sigma ** 2)
stddev = np.sqrt(variance)
# setting the lowest and highest values considered by our model
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# loading the option's probability distribution onto the quantum computer
uncertainty_model = LogNormalDistribution(
num_uncertainty_qubits, mu=mu, sigma=sigma ** 2, bounds=(low, high)
)
# visualize the encoded probability distribution on the quantum computer
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel("Spot Price at Maturity $S_T$ (\$)", size=15)
plt.ylabel("Probability ($\%$)", size=15)
plt.show()
# Now that we're using a put option,
# we compute the payoff if the function falls below the strike
# set the strike price
strike_price = 3.40
# scalar that determines accuracy of final output
# the lower the better
rescaling_factor = 0.25
# setup piecewise linear function that only pays
# if price falls below our strike
breakpoints = [low, strike_price]
slopes = [-1, 0]
offsets = [strike_price - low, 0]
f_min = 0
f_max = strike_price - low
european_put_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
rescaling_factor=rescaling_factor,
)
european_put = european_put_objective.compose(uncertainty_model, front=True)
# visualize the behaviour of the payoff function
x = uncertainty_model.values
y = np.maximum(0, strike_price - x)
plt.plot(x, y, "ro-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Spot Price", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# find the exact expected value of the option classically
exact_value = np.dot(uncertainty_model.probabilities, y)
print("exact expected value:\t%.4f" % exact_value)
epsilon = 0.01
alpha = 0.05
qi = QuantumInstance(Aer.get_backend("aer_simulator"), shots=100)
problem = EstimationProblem(
state_preparation=european_put,
objective_qubits=[num_uncertainty_qubits],
post_processing=european_put_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon, alpha=alpha, quantum_instance=qi)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (result.estimation_processed))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
|
https://github.com/quantastica/qiskit-toaster
|
quantastica
|
import unittest
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute
from qiskit.providers.aer import AerSimulator
from math import pi
try:
from . import common
except Exception:
import common
class TestToasterBackend(common.TestToasterBase):
def test_bell_counts(self):
shots = 256
qc = TestToasterBackend.get_bell_qc()
stats = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(), qc, shots
)
self.assertTrue(stats["statevector"] is None)
self.assertEqual(len(stats["counts"]), 2)
self.assertEqual(stats["totalcounts"], shots)
def test_bell_counts_with_seed(self):
shots = 1024
qc = TestToasterBackend.get_bell_qc()
stats1 = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(), qc, shots, seed=1
)
stats2 = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(), qc, shots, seed=1
)
stats3 = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(), qc, shots, seed=2
)
self.assertTrue(stats1["statevector"] is None)
self.assertEqual(len(stats1["counts"]), 2)
self.assertEqual(stats1["totalcounts"], shots)
self.assertEqual(stats1["counts"], stats2["counts"])
self.assertNotEqual(stats1["counts"], stats3["counts"])
def test_teleport_counts(self):
shots = 256
qc = TestToasterBackend.get_teleport_qc()
stats = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(), qc, shots
)
self.assertTrue(stats["statevector"] is None)
self.assertEqual(stats["totalcounts"], shots)
self.assertEqual(len(stats["counts"]), 4)
def test_bell_state_vector(self):
"""
This is test for statevector which means that
even with shots > 1 it should execute only one shot
"""
shots = 256
qc = TestToasterBackend.get_bell_qc()
stats = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(backend_name="statevector_simulator"),
qc,
shots,
)
self.assertEqual(len(stats["statevector"]), 4)
self.assertEqual(len(stats["counts"]), 1)
self.assertEqual(stats["totalcounts"], 1)
def test_teleport_state_vector(self):
"""
This is test for statevector which means that
even with shots > 1 it should execute only one shot
"""
shots = 256
qc = TestToasterBackend.get_teleport_qc()
"""
Let's first run the aer simulation to get statevector
and counts so we can compare those results against forest's
"""
qc_for_aer = qc.copy()
qc_for_aer.save_state()
stats_aer = TestToasterBackend.execute_and_get_stats(
AerSimulator(method="statevector"), qc_for_aer, shots
)
"""
Now execute toaster backend
"""
stats = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(backend_name="statevector_simulator"),
qc,
shots,
)
self.assertEqual(len(stats["counts"]), 1)
self.assertEqual(stats["totalcounts"], 1)
self.assertEqual(
len(stats["statevector"]), len(stats_aer["statevector"])
)
"""
Let's verify that tests are working as expected
by running fail case
"""
stats = TestToasterBackend.execute_and_get_stats(
self.toaster_backend(), qc, shots
)
self.assertTrue(stats["statevector"] is None)
def test_multiple_jobs(self):
qc = self.get_bell_qc()
backend = self.toaster_backend()
jobs = []
for i in range(1, 50):
jobs.append(execute(qc, backend=backend, shots=1))
for job in jobs:
result = job.result()
counts = result.get_counts(qc)
self.assertEqual(len(counts), 1)
def test_multiple_experiments(self):
backend = self.toaster_backend()
qc_list = [self.get_bell_qc(), self.get_teleport_qc()]
job_info = backend.run(qc_list)
bell_counts = job_info.result().get_counts("Bell")
tel_counts = job_info.result().get_counts("Teleport")
self.assertEqual(len(bell_counts), 2)
self.assertEqual(len(tel_counts), 4)
def test_too_many_qubits(self):
qc = QuantumCircuit(name="TooManyQubits")
q = QuantumRegister(100, "q")
qc.add_register(q)
with self.assertRaises(RuntimeError):
TestToasterBackend.execute_and_get_stats(
self.toaster_backend(), qc, 1
)
def test_larger_circuit_statevector(self):
n = 19
qc = QuantumCircuit()
q = QuantumRegister(n, 'q')
#c = ClassicalRegister(n, 'c')
qc.add_register(q)
#qc.add_register(c)
for i in range(n):
qc.h(i)
TestToasterBackend.execute_and_get_stats(
self.toaster_backend('statevector_simulator'), qc, 1
)
@classmethod
def execute_and_get_stats(cls, backend, qc, shots, seed=None):
job = execute(qc, backend=backend, shots=shots, seed_simulator=seed)
job_result = job.result()
counts = job_result.get_counts(qc)
total_counts = 0
for c in counts:
total_counts += counts[c]
try:
state_vector = job_result.get_statevector(qc)
except Exception:
state_vector = None
ret = dict()
ret["counts"] = counts
ret["statevector"] = state_vector
ret["totalcounts"] = total_counts
return ret
@staticmethod
def get_bell_qc():
qc = QuantumCircuit(name="Bell")
q = QuantumRegister(2, "q")
c = ClassicalRegister(2, "c")
qc.add_register(q)
qc.add_register(c)
qc.h(q[0])
qc.cx(q[0], q[1])
qc.measure(q[0], c[0])
qc.measure(q[1], c[1])
return qc
@staticmethod
def get_teleport_qc():
qc = QuantumCircuit(name="Teleport")
q = QuantumRegister(3, "q")
c0 = ClassicalRegister(1, "c0")
c1 = ClassicalRegister(1, "c1")
qc.add_register(q)
qc.add_register(c0)
qc.add_register(c1)
qc.rx(pi / 4, q[0])
qc.h(q[1])
qc.cx(q[1], q[2])
qc.cx(q[0], q[1])
qc.h(q[0])
qc.measure(q[1], c1[0])
qc.x(q[2]).c_if(c1, 1)
qc.measure(q[0], c0[0])
qc.z(q[2]).c_if(c0, 1)
return qc
if __name__ == "__main__":
unittest.main()
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-docstring
import unittest
import os
from unittest.mock import patch
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.test import QiskitTestCase
from qiskit.utils import optionals
from qiskit import visualization
from qiskit.visualization.circuit import text
from qiskit.visualization.exceptions import VisualizationError
if optionals.HAS_MATPLOTLIB:
from matplotlib import figure
if optionals.HAS_PIL:
from PIL import Image
_latex_drawer_condition = unittest.skipUnless(
all(
(
optionals.HAS_PYLATEX,
optionals.HAS_PIL,
optionals.HAS_PDFLATEX,
optionals.HAS_PDFTOCAIRO,
)
),
"Skipped because not all of PIL, pylatex, pdflatex and pdftocairo are available",
)
class TestCircuitDrawer(QiskitTestCase):
def test_default_output(self):
with patch("qiskit.user_config.get_config", return_value={}):
circuit = QuantumCircuit()
out = visualization.circuit_drawer(circuit)
self.assertIsInstance(out, text.TextDrawing)
@unittest.skipUnless(optionals.HAS_MATPLOTLIB, "Skipped because matplotlib is not available")
def test_user_config_default_output(self):
with patch("qiskit.user_config.get_config", return_value={"circuit_drawer": "mpl"}):
circuit = QuantumCircuit()
out = visualization.circuit_drawer(circuit)
self.assertIsInstance(out, figure.Figure)
def test_default_output_with_user_config_not_set(self):
with patch("qiskit.user_config.get_config", return_value={"other_option": True}):
circuit = QuantumCircuit()
out = visualization.circuit_drawer(circuit)
self.assertIsInstance(out, text.TextDrawing)
@unittest.skipUnless(optionals.HAS_MATPLOTLIB, "Skipped because matplotlib is not available")
def test_kwarg_priority_over_user_config_default_output(self):
with patch("qiskit.user_config.get_config", return_value={"circuit_drawer": "latex"}):
circuit = QuantumCircuit()
out = visualization.circuit_drawer(circuit, output="mpl")
self.assertIsInstance(out, figure.Figure)
@unittest.skipUnless(optionals.HAS_MATPLOTLIB, "Skipped because matplotlib is not available")
def test_default_backend_auto_output_with_mpl(self):
with patch("qiskit.user_config.get_config", return_value={"circuit_drawer": "auto"}):
circuit = QuantumCircuit()
out = visualization.circuit_drawer(circuit)
self.assertIsInstance(out, figure.Figure)
def test_default_backend_auto_output_without_mpl(self):
with patch("qiskit.user_config.get_config", return_value={"circuit_drawer": "auto"}):
with optionals.HAS_MATPLOTLIB.disable_locally():
circuit = QuantumCircuit()
out = visualization.circuit_drawer(circuit)
self.assertIsInstance(out, text.TextDrawing)
@_latex_drawer_condition
def test_latex_unsupported_image_format_error_message(self):
with patch("qiskit.user_config.get_config", return_value={"circuit_drawer": "latex"}):
circuit = QuantumCircuit()
with self.assertRaises(VisualizationError, msg="Pillow could not write the image file"):
visualization.circuit_drawer(circuit, filename="file.spooky")
@_latex_drawer_condition
def test_latex_output_file_correct_format(self):
with patch("qiskit.user_config.get_config", return_value={"circuit_drawer": "latex"}):
circuit = QuantumCircuit()
filename = "file.gif"
visualization.circuit_drawer(circuit, filename=filename)
with Image.open(filename) as im:
if filename.endswith("jpg"):
self.assertIn(im.format.lower(), "jpeg")
else:
self.assertIn(im.format.lower(), filename.split(".")[-1])
os.remove(filename)
def test_wire_order(self):
"""Test wire_order
See: https://github.com/Qiskit/qiskit-terra/pull/9893"""
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(4, "c")
cr2 = ClassicalRegister(2, "ca")
circuit = QuantumCircuit(qr, cr, cr2)
circuit.h(0)
circuit.h(3)
circuit.x(1)
circuit.x(3).c_if(cr, 10)
expected = "\n".join(
[
" ",
" q_2: ────────────",
" ┌───┐ ┌───┐ ",
" q_3: ┤ H ├─┤ X ├─",
" ├───┤ └─╥─┘ ",
" q_0: ┤ H ├───╫───",
" ├───┤ ║ ",
" q_1: ┤ X ├───╫───",
" └───┘┌──╨──┐",
" c: 4/═════╡ 0xa ╞",
" └─────┘",
"ca: 2/════════════",
" ",
]
)
result = visualization.circuit_drawer(circuit, wire_order=[2, 3, 0, 1])
self.assertEqual(result.__str__(), expected)
def test_wire_order_cregbundle(self):
"""Test wire_order with cregbundle=True
See: https://github.com/Qiskit/qiskit-terra/pull/9893"""
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(4, "c")
cr2 = ClassicalRegister(2, "ca")
circuit = QuantumCircuit(qr, cr, cr2)
circuit.h(0)
circuit.h(3)
circuit.x(1)
circuit.x(3).c_if(cr, 10)
expected = "\n".join(
[
" ",
" q_2: ────────────",
" ┌───┐ ┌───┐ ",
" q_3: ┤ H ├─┤ X ├─",
" ├───┤ └─╥─┘ ",
" q_0: ┤ H ├───╫───",
" ├───┤ ║ ",
" q_1: ┤ X ├───╫───",
" └───┘┌──╨──┐",
" c: 4/═════╡ 0xa ╞",
" └─────┘",
"ca: 2/════════════",
" ",
]
)
result = visualization.circuit_drawer(circuit, wire_order=[2, 3, 0, 1], cregbundle=True)
self.assertEqual(result.__str__(), expected)
def test_wire_order_raises(self):
"""Verify we raise if using wire order incorrectly."""
circuit = QuantumCircuit(3, 3)
circuit.x(1)
with self.assertRaisesRegex(VisualizationError, "should not have repeated elements"):
visualization.circuit_drawer(circuit, wire_order=[2, 1, 0, 3, 1, 5])
with self.assertRaisesRegex(VisualizationError, "cannot be set when the reverse_bits"):
visualization.circuit_drawer(circuit, wire_order=[0, 1, 2, 5, 4, 3], reverse_bits=True)
with self.assertWarnsRegex(RuntimeWarning, "cregbundle set"):
visualization.circuit_drawer(circuit, cregbundle=True, wire_order=[0, 1, 2, 5, 4, 3])
def test_reverse_bits(self):
"""Test reverse_bits should not raise warnings when no classical qubits:
See: https://github.com/Qiskit/qiskit-terra/pull/8689"""
circuit = QuantumCircuit(3)
circuit.x(1)
expected = "\n".join(
[
" ",
"q_2: ─────",
" ┌───┐",
"q_1: ┤ X ├",
" └───┘",
"q_0: ─────",
" ",
]
)
result = visualization.circuit_drawer(circuit, output="text", reverse_bits=True)
self.assertEqual(result.__str__(), expected)
@unittest.skipUnless(optionals.HAS_PYLATEX, "needs pylatexenc for LaTeX conversion")
def test_no_explict_cregbundle(self):
"""Test no explicit cregbundle should not raise warnings about being disabled
See: https://github.com/Qiskit/qiskit-terra/issues/8690"""
inner = QuantumCircuit(1, 1, name="inner")
inner.measure(0, 0)
circuit = QuantumCircuit(2, 2)
circuit.append(inner, [0], [0])
expected = "\n".join(
[
" ┌────────┐",
"q_0: ┤0 ├",
" │ │",
"q_1: ┤ inner ├",
" │ │",
"c_0: ╡0 ╞",
" └────────┘",
"c_1: ══════════",
" ",
]
)
result = circuit.draw("text")
self.assertEqual(result.__str__(), expected)
# Extra tests that no cregbundle (or any other) warning is raised with the default settings
# for the other drawers, if they're available to test.
circuit.draw("latex_source")
if optionals.HAS_MATPLOTLIB and optionals.HAS_PYLATEX:
circuit.draw("mpl")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_city
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
# plot using a DensityMatrix
state = DensityMatrix(qc)
plot_state_city(state)
|
https://github.com/GBisi/QiskitFallFest2023
|
GBisi
| |
https://github.com/Tojarieh97/VQE
|
Tojarieh97
|
%load_ext autoreload
%autoreload 2
import nbimporter
from typing import Dict, Tuple, List
import numpy as np
from tqdm import tqdm
QUBITS_NUM = 4
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
NUM_ITERATIONS = 100
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
seed = 50
algorithm_globals.random_seed = seed
simulator_backend = Aer.get_backend('qasm_simulator')
from scipy.optimize import minimize
from linear_entangelment_and_full_entangelment_ansatz_circuits import *
def get_ansatz_state(thetas, ansatz_entangelment, input_state):
if ansatz_entangelment=="full":
return get_full_entangelment_ansatz(QUBITS_NUM, thetas, input_state)
if ansatz_entangelment=="linear":
return get_linear_entangelment_ansatz(QUBITS_NUM, thetas, input_state)
def transfrom_hamiltonian_into_pauli_strings(hamiltonian) -> List:
pauli_operators = hamiltonian.to_pauli_op().settings['oplist']
pauli_coeffs = list(map(lambda pauli_operator: pauli_operator.coeff, pauli_operators))
pauli_strings = list(map(lambda pauli_operator: pauli_operator.primitive, pauli_operators))
return pauli_coeffs, pauli_strings
from qiskit.circuit.library.standard_gates import HGate, SGate
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
reducing_to_pauli_z_mapping = {
'I': 'I',
'Z': 'Z',
'X': 'Z',
'Y': 'Z'
}
def reduce_pauli_matrixes_into_sigma_z(pauli_string) -> str:
reduced_pauli_string = ""
for matrix_index in range(QUBITS_NUM):
pauli_matrix = str(pauli_string[matrix_index])
reduced_pauli_matrix = reducing_to_pauli_z_mapping[pauli_matrix]
reduced_pauli_string = reduced_pauli_matrix + reduced_pauli_string
return reduced_pauli_string
def add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string, quantum_circuit):
quantum_registers = QuantumRegister(QUBITS_NUM, name="qubit")
additional_circuit_layer = QuantumCircuit(quantum_registers)
for quantum_register_index, pauli_matrix in enumerate(pauli_string):
if pauli_matrix == "X":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
if pauli_string == "Y":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
additional_circuit_layer.append(SGate(), [quantum_registers[quantum_register_index]])
extended_quantum_circuit = quantum_circuit.compose(additional_circuit_layer)
return extended_quantum_circuit
def get_probability_distribution(counts: Dict) -> Dict:
proba_distribution = {state: (count / NUM_SHOTS) for state, count in counts.items()}
return proba_distribution
def calculate_probabilities_of_measurments_in_computational_basis(quantum_state_circuit) -> Dict:
quantum_state_circuit.measure_all()
transpiled_quantum_state_circuit = transpile(quantum_state_circuit, simulator_backend)
Qobj = assemble(transpiled_quantum_state_circuit)
result = simulator_backend.run(Qobj).result()
counts = result.get_counts(quantum_state_circuit)
return get_probability_distribution(counts)
def sort_probas_dict_by_qubits_string_keys(proba_distribution: Dict) -> Dict:
return dict(sorted(proba_distribution.items()))
def reset_power_of_minus_1(power_of_minus_1):
power_of_minus_1 = 0
return power_of_minus_1
def convert_pauli_string_into_str(pauli_string) -> str:
return str(pauli_string)
def calculate_expectation_value_of_pauli_string_by_measurments_probas(pauli_string, ansatz_circuit):
pauli_string_expectation_value = 0
power_of_minus_1 = 0
pauli_string_str = convert_pauli_string_into_str(pauli_string)
extended_ansatz_circuit = add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string_str, ansatz_circuit)
probas_distribution = calculate_probabilities_of_measurments_in_computational_basis(extended_ansatz_circuit)
reduced_pauli_string = reduce_pauli_matrixes_into_sigma_z(pauli_string)
sorted_probas_distribuition = sort_probas_dict_by_qubits_string_keys(probas_distribution)
for qubits_string, proba in sorted_probas_distribuition.items():
for string_index in range(QUBITS_NUM):
if(str(qubits_string[string_index])=="1" and str(reduced_pauli_string[string_index])=="Z"):
power_of_minus_1 += 1
pauli_string_expectation_value += pow(-1, power_of_minus_1)*proba
power_of_minus_1 = reset_power_of_minus_1(power_of_minus_1)
return pauli_string_expectation_value
def get_expectation_value(ansatz_circuit, pauli_coeffs, pauli_strings):
total_expection_value = 0
for pauli_coeff, pauli_string in zip(pauli_coeffs, pauli_strings):
total_expection_value += pauli_coeff*calculate_expectation_value_of_pauli_string_by_measurments_probas(
pauli_string, ansatz_circuit)
return total_expection_value
from qiskit import assemble, transpile
def cost_function(thetas, hamiltonian, ansatz_entangelment):
initial_eigenvector = np.identity(N)[0]
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
ansatz_state = get_ansatz_state(thetas, ansatz_entangelment, initial_eigenvector)
L = get_expectation_value(ansatz_state, pauli_coeffs, pauli_strings)
insert_approximated_energy_to_list_of_all_approximated_energies(L)
return L
def get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian, ansatz_entangelment):
initial_thetas = np.random.uniform(low=0, high=2*np.pi, size=PARAMS_NUM)
optimizer_result = minimize(cost_function,
x0=initial_thetas,
args=(hamiltonian, ansatz_entangelment),
method="POWELL",
options={"maxiter":NUM_ITERATIONS,
"return_all": True,
"disp": True})
optimal_thetas = optimizer_result.x
return optimal_thetas
def get_approximated_eigenvalue_of_hamiltonian(hamiltonian, ansatz_entangelment):
optimal_thetas = get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian, ansatz_entangelment)
print(optimal_thetas)
initial_eigenvector = np.identity(N)[0]
optimal_ansatz_state = get_ansatz_state(optimal_thetas, ansatz_entangelment, initial_eigenvector)
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
approximated_eigenvalue = get_expectation_value(optimal_ansatz_state, pauli_coeffs, pauli_strings)
return approximated_eigenvalue
from numpy import linalg as LA
def get_approximation_error(exact_eigenvalue, approximated_eigenvalue):
return abs(abs(exact_eigenvalue)-abs(approximated_eigenvalue))/abs(exact_eigenvalue)
def get_minimum_exact_eigenvalue_of_hamiltonian(hamiltonian):
eigen_values = LA.eigvals(hamiltonian.to_matrix())
print(sorted(eigen_values))
return min(sorted(eigen_values))
def compare_exact_and_approximated_eigenvalue(hamiltonian, approximated_eigenvalue):
exact_eigenvalue = get_minimum_exact_eigenvalue_of_hamiltonian(hamiltonian)
print("Exact Eigenvalue:")
print(exact_eigenvalue)
print("\nApproximated Eigenvalue:")
print(approximated_eigenvalue)
print("\nApproximation Error")
print(get_approximation_error(exact_eigenvalue, approximated_eigenvalue))
plot_convergence_of_optimization_process(approximated_energies, exact_eigenvalue, margin=3)
approximated_energies = []
def insert_approximated_energy_to_list_of_all_approximated_energies(energy):
approximated_energies.append(energy)
import matplotlib.pyplot as plt
def plot_convergence_of_optimization_process(approximated_energies, exact_eigenvalue, margin):
plt.title("convergence of optimization process to the exact eigenvalue")
plt.margins(0, margin)
plt.plot(approximated_energies[-NUM_ITERATIONS])
plt.axhline(y = exact_eigenvalue, color = 'r', linestyle = '-')
plt.grid()
plt.xlabel("# of iterations")
plt.ylabel("Energy")
def plot_fidelity():
plt.plot(LiH_approximated_energies)
plt.xlabel("# of iterations")
plt.ylabel("Energy")
from qiskit.opflow import X, Z, I, H, Y
LiH_molecule_4_qubits = -7.49894690201071*(I^I^I^I) + \
-0.0029329964409502266*(X^X^Y^Y) + \
0.0029329964409502266*(X^Y^Y^X) + \
0.01291078027311749*(X^Z^X^I) + \
-0.0013743761078958677*(X^Z^X^Z) + \
0.011536413200774975*(X^I^X^I) + \
0.0029329964409502266*(Y^X^X^Y) + \
-0.0029329964409502266*(Y^Y^X^X) + \
0.01291078027311749*(Y^Z^Y^I) + \
-0.0013743761078958677*(Y^Z^Y^Z) + \
0.011536413200774975*(Y^I^Y^I) + \
0.16199475388004184*(Z^I^I^I) + \
0.011536413200774975*(Z^X^Z^X) + \
0.011536413200774975*(Z^Y^Z^Y) + \
0.12444770133137588*(Z^Z^I^I) + \
0.054130445793298836*(Z^I^Z^I) + \
0.05706344223424907*(Z^I^I^Z) + \
0.012910780273117487*(I^X^Z^X) + \
-0.0013743761078958677*(I^X^I^X) + \
0.012910780273117487*(I^Y^Z^Y) + \
-0.0013743761078958677*(I^Y^I^Y) + \
0.16199475388004186*(I^Z^I^I) + \
0.05706344223424907*(I^Z^Z^I) + \
0.054130445793298836*(I^Z^I^Z) + \
-0.013243698330265966*(I^I^Z^I) + \
0.08479609543670981*(I^I^Z^Z) + \
-0.013243698330265952*(I^I^I^Z)
%%time
LiH_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(LiH_molecule_4_qubits, "linear")
compare_exact_and_approximated_eigenvalue(LiH_molecule_4_qubits, LiH_approximated_eigenvalue)
%%time
LiH_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(LiH_molecule_4_qubits, "full")
compare_exact_and_approximated_eigenvalue(LiH_molecule_4_qubits, LiH_approximated_eigenvalue)
H2_molecule_Hamiltonian_4_qubits = -0.8105479805373279 * (I^I^I^I) \
+ 0.1721839326191554 * (I^I^I^Z) \
- 0.22575349222402372 * (I^I^Z^I) \
+ 0.17218393261915543 * (I^Z^I^I) \
- 0.2257534922240237 * (Z^I^I^I) \
+ 0.12091263261776627 * (I^I^Z^Z) \
+ 0.16892753870087907 * (I^Z^I^Z) \
+ 0.045232799946057826 * (Y^Y^Y^Y) \
+ 0.045232799946057826 * (X^X^Y^Y) \
+ 0.045232799946057826 * (Y^Y^X^X) \
+ 0.045232799946057826 * (X^X^X^X) \
+ 0.1661454325638241 * (Z^I^I^Z) \
+ 0.1661454325638241 * (I^Z^Z^I) \
+ 0.17464343068300453 * (Z^I^Z^I) \
+ 0.12091263261776627 * (Z^Z^I^I)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_4_qubits, "linear")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_4_qubits, H2_approximated_eigenvalue)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_4_qubits, "full")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_4_qubits, H2_approximated_eigenvalue)
transverse_ising_4_qubits = 0.0 * (I^I^I^I) \
+ 0.8398088405253477 * (X^I^I^I) \
+ 0.7989496312070936 * (I^X^I^I) \
+ 0.38189710487113193 * (Z^Z^I^I) \
+ 0.057753122422666725 * (I^I^X^I) \
+ 0.5633292636970458 * (Z^I^Z^I) \
+ 0.3152740621483513 * (I^Z^Z^I) \
+ 0.07209487981989715 * (I^I^I^X) \
+ 0.17892334004292654 * (Z^I^I^Z) \
+ 0.2273896497668042 * (I^Z^I^Z) \
+ 0.09762902934216211 * (I^I^Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_4_qubits, "linear")
compare_exact_and_approximated_eigenvalue(transverse_ising_4_qubits, TI_approximated_eigenvalue)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_4_qubits, "full")
compare_exact_and_approximated_eigenvalue(transverse_ising_4_qubits, TI_approximated_eigenvalue)
QUBITS_NUM = 3
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
from qiskit.opflow import X, Z, I
transverse_ising_3_qubits = 0.0 * (I^I^I) \
+ 0.012764169333459807 * (X^I^I) \
+ 0.7691573729160869 * (I^X^I) \
+ 0.398094746026449 * (Z^Z^I) \
+ 0.15250261906586637 * (I^I^X) \
+ 0.2094051920882264 * (Z^I^Z) \
+ 0.5131291860752999 * (I^Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_3_qubits, "linear")
compare_exact_and_approximated_eigenvalue(transverse_ising_3_qubits, TI_approximated_eigenvalue)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_3_qubits, "full")
compare_exact_and_approximated_eigenvalue(transverse_ising_3_qubits, TI_approximated_eigenvalue)
QUBITS_NUM = 2
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
transverse_ising_2_qubits = 0.13755727363376802 * (I^X) \
+ 0.43305656297810435 * (X^I) \
+ 0.8538597608997253 * (Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_2_qubits, "linear")
compare_exact_and_approximated_eigenvalue(transverse_ising_2_qubits, TI_approximated_eigenvalue)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_2_qubits, "full")
compare_exact_and_approximated_eigenvalue(transverse_ising_2_qubits, TI_approximated_eigenvalue)
from qiskit.opflow import X, Z, I
H2_molecule_Hamiltonian_2_qubits = -0.5053051899926562*(I^I) + \
-0.3277380754984016*(Z^I) + \
0.15567463610622564*(Z^Z) + \
-0.3277380754984016*(I^Z)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_2_qubits, "linear")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_2_qubits, H2_approximated_eigenvalue)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_2_qubits, "full")
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_2_qubits, H2_approximated_eigenvalue)
|
https://github.com/Juan-Varela11/BNL_2020_Summer_Internship
|
Juan-Varela11
|
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.aqua.components.optimizers.cobyla import COBYLA
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.core import Hamiltonian, TransformationType, QubitMappingType
from qiskit.aqua.algorithms.adaptive.vqe.vqe import VQE
from qiskit.chemistry import FermionicOperator
from qiskit import Aer, IBMQ
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit import execute
from qiskit.aqua import QuantumInstance
from qiskit.chemistry.algorithms.q_equation_of_motion.q_equation_of_motion import QEquationOfMotion
from qiskit.providers.aer import noise
from qiskit.aqua.algorithms import ExactEigensolver
from qiskit.quantum_info import Pauli
import numpy as np
import os
import logging
import copy
qasm_simulator = Aer.get_backend('qasm_simulator')
sv_simulator = Aer.get_backend('statevector_simulator')
def spin_operator(num_qubits):
pauli_list = []
for i in range(num_qubits):
if i < num_qubits:
c = 1/2
else:
c = -1/2
a_z = np.asarray([0] * i + [1] + [0] * (num_qubits - i - 1), dtype=np.bool)
a_x = np.asarray([0] * i + [0] + [0] * (num_qubits - i - 1), dtype=np.bool)
pauli_list.append([c, Pauli(a_z, a_x)])
op = WeightedPauliOperator(pauli_list)
return op
def number_operator(num_qubits):
h1 = np.identity(num_qubits)
op = FermionicOperator(h1)
num_op = op.mapping('jordan_wigner')
return num_op
def exact_eigenstates(hamiltonian, num_particles, num_spin):
num_qubits = hamiltonian.num_qubits
exact_eigensolver = ExactEigensolver(hamiltonian, k=1<<num_qubits)
exact_results = exact_eigensolver.run()
results = [[],[]]
number_op = number_operator(num_qubits)
spin_op = spin_operator(num_qubits)
for i in range(len(exact_results['eigvals'])):
particle = round(number_op.evaluate_with_statevector(exact_results['eigvecs'][i])[0],1)
spin = round(spin_op.evaluate_with_statevector(exact_results['eigvecs'][i])[0],1)
if particle != num_particles or spin != num_spin:
continue
results[0].append(exact_results['eigvals'][i])
results[1].append(exact_results['eigvecs'][i])
return results
two_qubit_reduction = False
qubit_mapping = 'jordan_wigner'
distance = 0.75
pyscf_driver = PySCFDriver(atom='H .0 .0 {}; H .0 .0 .0'.format(distance),
unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g')
molecule = pyscf_driver.run()
core = Hamiltonian(transformation=TransformationType.FULL,
qubit_mapping=QubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=two_qubit_reduction,
freeze_core=False,
orbital_reduction=[])
algo_input = core.run(molecule)
hamiltonian = algo_input[0]
num_orbitals = core.molecule_info['num_orbitals']
num_particles = core.molecule_info['num_particles']
init_state = HartreeFock(hamiltonian.num_qubits, num_orbitals, num_particles,
qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction)
depth = 1
var_form = UCCSD(hamiltonian.num_qubits, depth, num_orbitals, num_particles, initial_state=init_state,
qubit_mapping=qubit_mapping, two_qubit_reduction=two_qubit_reduction)
optimizer = COBYLA(maxiter = 5000)
algo = VQE(hamiltonian, var_form, optimizer)
results = algo.run(sv_simulator)
print(results)
energy = results['energy']
opt_params = results['opt_params']
ground_state = results['min_vector']
eom = QEquationOfMotion(hamiltonian, num_orbitals, num_particles, qubit_mapping=qubit_mapping,
two_qubit_reduction=two_qubit_reduction)
excitation_energies, eom_matrices = eom.calculate_excited_states(ground_state)
print(excitation_energies)
qeom_energies = [energy]
for gap_i in excitation_energies:
qeom_energies.append(energy+gap_i)
reference = exact_eigenstates(hamiltonian, 2, 0) #returns only the states with 2 electrons and singlet spin state.
exact_energies = []
tmp = 1000
for i in range(len(reference[0])):
if np.abs(reference[0][i]-tmp)>1e-5:
exact_energies.append(np.real(reference[0][i]))
tmp = reference[0][i]
for i in range(4):
print('State {} -> exact energy={} , qeom energy={}'.format(i, exact_energies[i], qeom_energies[i]))
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-internal',group='dev-qiskit')
provider.backends()
device = provider.get_backend('ibmq_boeblingen')
properties = device.properties()
coupling_map = device.configuration().coupling_map
noise_model = noise.device.basic_device_noise_model(properties)
basis_gates = noise_model.basis_gates
shots = 10000
quantum_instance = QuantumInstance(qasm_simulator, shots=shots, basis_gates=basis_gates,
coupling_map=coupling_map, noise_model=noise_model)
wave_function = var_form.construct_circuit(opt_params)
excitation_energies, eom_matrices = eom.calculate_excited_states(wave_function, quantum_instance = quantum_instance)
qeom_energies_noisy = [energy]
for gap_i in excitation_energies:
qeom_energies_noisy.append(energy+gap_i)
for i in range(4):
print('State {} -> exact energy={} , qeom energy={}'.format(i, exact_energies[i], qeom_energies_noisy[i]))
|
https://github.com/qclib/qclib
|
qclib
|
# Copyright 2021 qclib project.
# 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.
""" Test qclib.gate.mcg.LdMcSpecialUnitary """
from unittest import TestCase
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, transpile
from qiskit.circuit.library import RXGate
from qiskit.quantum_info import Operator
from qclib.gates.multitargetmcsu2 import MultiTargetMCSU2
class TestCMcSpecialUnitary(TestCase):
"""
Test cases for the decomposition of
Multicontrolled Special Unitary with linear depth
https://arxiv.org/pdf/2302.06377.pdf
"""
def _build_qiskit_circ(
self,
num_controls
):
""""default mode: target = controls"""
controls_list = list(range(num_controls))
target = num_controls
qiskit_circ = QuantumCircuit(num_controls + 3)
qiskit_circ.mcrx(0.7, controls_list, target)
qiskit_circ.mcrx(0.13, controls_list, target+1)
qiskit_circ.mcrx(0.5, controls_list, target+2)
return qiskit_circ
def _build_ldmcsu_circ(self, unitary_list, num_controls):
""""
default mode: target = controls
"""
controls_list = list(range(num_controls))
target = num_controls
ldmcsu_circ = QuantumCircuit(num_controls + 3)
MultiTargetMCSU2.multi_target_mcsu2(ldmcsu_circ, unitary_list[0], controls_list, target)
MultiTargetMCSU2.multi_target_mcsu2(ldmcsu_circ, unitary_list[1], controls_list, target + 1)
MultiTargetMCSU2.multi_target_mcsu2(ldmcsu_circ, unitary_list[2], controls_list, target + 2)
return ldmcsu_circ
def _build_cldmcsu_circ(self, unitary_list, num_controls):
""""
default mode: target = controls
"""
controls = QuantumRegister(num_controls)
target = QuantumRegister(len(unitary_list))
cldmcsu_circ = QuantumCircuit(controls, target)
MultiTargetMCSU2.multi_target_mcsu2(cldmcsu_circ, unitary_list, controls, target)
return cldmcsu_circ
def test_clcmcsu_3targets(self):
"""
Test for comparison of a cascade uf 3 multi-controlled SU(2) using
qiskit and cldmcsu implementations.
"""
num_controls = 7
unitary_list = [RXGate(0.7).to_matrix(), RXGate(0.13).to_matrix(), RXGate(0.5).to_matrix()]
qiskit_circ = self._build_qiskit_circ(num_controls)
cldmcsu_circ = self._build_cldmcsu_circ(unitary_list, num_controls)
qiskitt = transpile(qiskit_circ, basis_gates=['u', 'cx'], optimization_level=3)
cldmcsut = transpile(cldmcsu_circ, basis_gates=['u', 'cx'], optimization_level=3)
qiskit_ops = qiskitt.count_ops()
qclib_ops = cldmcsut.count_ops()
self.assertTrue(qiskit_ops['cx'] > qclib_ops['cx'])
cldmcsu_op = Operator(cldmcsu_circ).data
qiskit_op = Operator(qiskit_circ).data
self.assertTrue(np.allclose(cldmcsu_op, qiskit_op))
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=no-member,invalid-name,missing-docstring,no-name-in-module
# pylint: disable=attribute-defined-outside-init,unsubscriptable-object
import os
from qiskit.compiler import transpile
from qiskit import QuantumCircuit
from qiskit.transpiler import InstructionDurations
from qiskit.providers.fake_provider import FakeMelbourne
from .utils import build_qv_model_circuit
class TranspilerLevelBenchmarks:
params = [0, 1, 2, 3]
param_names = ["transpiler optimization level"]
timeout = 600
def setup(self, _):
self.rochester_coupling_map = [
[0, 5],
[0, 1],
[1, 2],
[1, 0],
[2, 3],
[2, 1],
[3, 4],
[3, 2],
[4, 6],
[4, 3],
[5, 9],
[5, 0],
[6, 13],
[6, 4],
[7, 16],
[7, 8],
[8, 9],
[8, 7],
[9, 10],
[9, 8],
[9, 5],
[10, 11],
[10, 9],
[11, 17],
[11, 12],
[11, 10],
[12, 13],
[12, 11],
[13, 14],
[13, 12],
[13, 6],
[14, 15],
[14, 13],
[15, 18],
[15, 14],
[16, 19],
[16, 7],
[17, 23],
[17, 11],
[18, 27],
[18, 15],
[19, 20],
[19, 16],
[20, 21],
[20, 19],
[21, 28],
[21, 22],
[21, 20],
[22, 23],
[22, 21],
[23, 24],
[23, 22],
[23, 17],
[24, 25],
[24, 23],
[25, 29],
[25, 26],
[25, 24],
[26, 27],
[26, 25],
[27, 26],
[27, 18],
[28, 32],
[28, 21],
[29, 36],
[29, 25],
[30, 39],
[30, 31],
[31, 32],
[31, 30],
[32, 33],
[32, 31],
[32, 28],
[33, 34],
[33, 32],
[34, 40],
[34, 35],
[34, 33],
[35, 36],
[35, 34],
[36, 37],
[36, 35],
[36, 29],
[37, 38],
[37, 36],
[38, 41],
[38, 37],
[39, 42],
[39, 30],
[40, 46],
[40, 34],
[41, 50],
[41, 38],
[42, 43],
[42, 39],
[43, 44],
[43, 42],
[44, 51],
[44, 45],
[44, 43],
[45, 46],
[45, 44],
[46, 47],
[46, 45],
[46, 40],
[47, 48],
[47, 46],
[48, 52],
[48, 49],
[48, 47],
[49, 50],
[49, 48],
[50, 49],
[50, 41],
[51, 44],
[52, 48],
]
self.basis_gates = ["u1", "u2", "u3", "cx", "id"]
self.qv_50_x_20 = build_qv_model_circuit(50, 20, 0)
self.qv_14_x_14 = build_qv_model_circuit(14, 14, 0)
self.qasm_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "qasm"))
large_qasm_path = os.path.join(self.qasm_path, "test_eoh_qasm.qasm")
self.large_qasm = QuantumCircuit.from_qasm_file(large_qasm_path)
self.melbourne = FakeMelbourne()
self.durations = InstructionDurations(
[
("u1", None, 0),
("id", None, 160),
("u2", None, 160),
("u3", None, 320),
("cx", None, 800),
("measure", None, 3200),
],
dt=1e-9,
)
def time_quantum_volume_transpile_50_x_20(self, transpiler_level):
transpile(
self.qv_50_x_20,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
)
def track_depth_quantum_volume_transpile_50_x_20(self, transpiler_level):
return transpile(
self.qv_50_x_20,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
).depth()
def time_transpile_from_large_qasm(self, transpiler_level):
transpile(
self.large_qasm,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
)
def track_depth_transpile_from_large_qasm(self, transpiler_level):
return transpile(
self.large_qasm,
basis_gates=self.basis_gates,
coupling_map=self.rochester_coupling_map,
seed_transpiler=0,
optimization_level=transpiler_level,
).depth()
def time_transpile_from_large_qasm_backend_with_prop(self, transpiler_level):
transpile(
self.large_qasm, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
)
def track_depth_transpile_from_large_qasm_backend_with_prop(self, transpiler_level):
return transpile(
self.large_qasm, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
).depth()
def time_transpile_qv_14_x_14(self, transpiler_level):
transpile(
self.qv_14_x_14, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
)
def track_depth_transpile_qv_14_x_14(self, transpiler_level):
return transpile(
self.qv_14_x_14, self.melbourne, seed_transpiler=0, optimization_level=transpiler_level
).depth()
def time_schedule_qv_14_x_14(self, transpiler_level):
transpile(
self.qv_14_x_14,
self.melbourne,
seed_transpiler=0,
optimization_level=transpiler_level,
scheduling_method="alap",
instruction_durations=self.durations,
)
# limit optimization levels to reduce time
time_schedule_qv_14_x_14.params = [0, 1]
|
https://github.com/qiskit-community/qiskit-aqt-provider
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright Alpine Quantum Technologies GmbH 2023
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Simple number partition problem solving.
This example shows how to solve problems covered by the application
domains in the qiskit_optimization package.
Number partition: given a set of positive integers, determine whether
it can be split into two non-overlapping sets that have the same sum.
"""
from dataclasses import dataclass
from typing import Final, Union
import qiskit_algorithms
from qiskit_algorithms.minimum_eigensolvers import QAOA
from qiskit_algorithms.optimizers import COBYLA
from qiskit_optimization.algorithms import MinimumEigenOptimizer, OptimizationResultStatus
from qiskit_optimization.applications import NumberPartition
from qiskit_aqt_provider import AQTProvider
from qiskit_aqt_provider.primitives import AQTSampler
RANDOM_SEED: Final = 0
@dataclass(frozen=True)
class Success:
"""Solution of a partition problem."""
# type would be better as tuple[set[int], set[int]] but
# NumberPartition.interpret returns list[list[int]].
partition: list[list[int]]
def is_valid(self) -> bool:
"""Evaluate whether the stored partition is valid.
A partition is valid if both sets have the same sum.
"""
a, b = self.partition
return sum(a) == sum(b)
class Infeasible:
"""Marker for unsolvable partition problems."""
def solve_partition_problem(num_set: set[int]) -> Union[Success, Infeasible]:
"""Solve a partition problem.
Args:
num_set: set of positive integers to partition into two distinct subsets
with the same sum.
Returns:
Success: solutions to the problem exist and are returned
Infeasible: the given set cannot be partitioned.
"""
problem = NumberPartition(list(num_set))
qp = problem.to_quadratic_program()
meo = MinimumEigenOptimizer(
min_eigen_solver=QAOA(sampler=AQTSampler(backend), optimizer=COBYLA())
)
result = meo.solve(qp)
if result.status is OptimizationResultStatus.SUCCESS:
return Success(partition=problem.interpret(result))
if result.status is OptimizationResultStatus.INFEASIBLE:
return Infeasible()
raise RuntimeError("Unexpected optimizer status") # pragma: no cover
if __name__ == "__main__":
backend = AQTProvider("token").get_backend("offline_simulator_no_noise")
# fix the random seeds such that the example is reproducible
qiskit_algorithms.utils.algorithm_globals.random_seed = RANDOM_SEED
backend.simulator.options.seed_simulator = RANDOM_SEED
num_set = {1, 3, 4}
result = solve_partition_problem(num_set)
assert isinstance(result, Success) # noqa: S101
assert result.is_valid() # noqa: S101
print(f"Partition for {num_set}:", result.partition)
num_set = {1, 2}
result = solve_partition_problem(num_set)
assert isinstance(result, Infeasible) # noqa: S101
print(f"No partition possible for {num_set}.")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import qiskit.qasm3
program = """
OPENQASM 3.0;
include "stdgates.inc";
input float[64] a;
qubit[3] q;
bit[2] mid;
bit[3] out;
let aliased = q[0:1];
gate my_gate(a) c, t {
gphase(a / 2);
ry(a) c;
cx c, t;
}
gate my_phase(a) c {
ctrl @ inv @ gphase(a) c;
}
my_gate(a * 2) aliased[0], q[{1, 2}][0];
measure q[0] -> mid[0];
measure q[1] -> mid[1];
while (mid == "00") {
reset q[0];
reset q[1];
my_gate(a) q[0], q[1];
my_phase(a - pi/2) q[1];
mid[0] = measure q[0];
mid[1] = measure q[1];
}
if (mid[0]) {
let inner_alias = q[{0, 1}];
reset inner_alias;
}
out = measure q;
"""
circuit = qiskit.qasm3.loads(program)
circuit.draw("mpl")
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.x(1)
qc.draw("mpl")
|
https://github.com/RQC-QApp/Seminars
|
RQC-QApp
|
from pyquil.quil import Program
from pyquil.gates import H, CNOT
from pyquil.api import QVMConnection
# Создаём объект для квантовой программы.
p = Program()
# "Мутирование" квантовой программы под действием оператора `H(0)` - гейт Адамара, который
# действует на нулевой кубит.
p.inst(H(0))
# Добавление CNOT гейта, который использует нулевой кубит как управляющий, а первый кубит как таргет.
p.inst(CNOT(0, 1))
# Объект "квантовой виртуальной машины" - создаёт соединение с облачным бэкэндом.
qvm = QVMConnection()
# Запускаем квантовую программу `p` на бэкэнде.
result = qvm.wavefunction(p)
# Посмотреть на результаты программы в виде "{'00': p1, '01': p2, ...}", где p1, p2, ... - вероятности
# соответствующих исходов.
print(result.get_outcome_probs())
# Построим гистограмму исходов.
result.plot()
# Ещё один способ представить состояние.
result.pretty_print()
import numpy as np
from pyquil.gates import I
quantum_simulator = QVMConnection()
# Создаём квантовую программу, которая использует один кубит и применяет к нему тождественное преобразование.
p = Program(I(0))
# После запуска программы на квантовом симуляторе вернётся состояние системы после применения к
# кубитам всех операторов из `p`.
wavefunction = quantum_simulator.wavefunction(p)
# `wavefunction` содержит в себе список амплитуд каждого из базисных состояний.
print(wavefunction.amplitudes)
alpha, beta = wavefunction
print("Соответственно наш кубит в состоянии: alpha={}, beta={}".format(alpha, beta))
print("Вероятность исхода 0: {}".format(abs(alpha)**2))
print("Вероятность исхода 1: {}".format(abs(beta)**2))
from pyquil.gates import X
# Пишем программу, которая состоит из одного оператора - NOT.
p = Program(X(0))
wavefunc = quantum_simulator.wavefunction(p)
alpha, beta = wavefunc
print("Волновая функция после применения X к |0>: {}".format(wavefunc))
# Посмотреть на вероятности исходов.
print(wavefunc.get_outcome_probs())
from pyquil.gates import CNOT
# Соответствует применению CNOT к состоянию |00>.
p = Program(CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|00> =", wavefunction)
# Соответствует применению CNOT к состоянию |01>.
p = Program(X(0), CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|01> =", wavefunction)
# Соответствует применению CNOT к состоянию |10>.
p = Program(X(1), CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|10> =", wavefunction)
# Соответствует применению CNOT к состоянию |11>.
p = Program(X(0), X(1), CNOT(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("CNOT|11> =", wavefunction)
from pyquil.gates import SWAP
# Соответствует применению SWAP к состоянию |00>.
p = Program(SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|00> = ", wavefunction)
# Соответствует применению SWAP к состоянию |01>.
p = Program(X(0), SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|01> = ", wavefunction)
# Соответствует применению SWAP к состоянию |10>.
p = Program(X(1), SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|10> = ", wavefunction)
# Соответствует применению SWAP к состоянию |11>.
p = Program(X(0), X(1), SWAP(0, 1))
wavefunction = quantum_simulator.wavefunction(p)
print("SWAP|11> = ", wavefunction)
# Указываем индексы классических регистров для записи.
classical_reg_index_0 = 0
classical_reg_index_1 = 1
# Указываем индексы квантовых регистров для измерения.
quantum_reg_index_0 = 0
quantum_reg_index_1 = 1
# Создаём простую программу, результаты измерений записываем в соответствующие регистры.
p = Program(I(0), X(1))
p.measure(quantum_reg_index_0, classical_reg_index_0)
p.measure(quantum_reg_index_1, classical_reg_index_1)
# Указываем классические регистры, состояние которых нам интересно после завершения программы.
classical_regs = [0, 1]
# Запускаем программу на квантовом симуляторе.
print(quantum_simulator.run(p, classical_regs, trials=4))
from pyquil.gates import H
program = Program(H(0))
wavefunction = quantum_simulator.wavefunction(program)
print("H|0> = ", wavefunction)
print("Вероятности исходов:", wavefunction.get_outcome_probs())
# Запустим на симуляторе.
program = Program(H(0)).measure(0, 0)
result = quantum_simulator.run(program, [0], trials=10)
print(result)
print(program)
# DON'T HAVE ACCESS TO 19Q CHIP :(
# from pyquil.api import get_devices
# for device in get_devices():
# if device.is_online():
# print('Device {} is online'.format(device.name))
# DON'T HAVE ACCESS TO 19Q CHIP :(
# from pyquil.quil import Program
# import pyquil.api as api
# from pyquil.gates import *
# qpu = api.QPUConnection('19Q-Acorn')
# p = Program(H(0), CNOT(0, 1), MEASURE(0, 0), MEASURE(1, 1))
# qpu.run_and_measure(p, [0, 1], 1000)
# Первая цепь.
program = Program()
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0)
result = quantum_simulator.run(program, classical_addresses=[0], trials=10)
print(result)
# Вторая цепь.
program = Program(X(0))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0)
result = quantum_simulator.run(program, classical_addresses=[0], trials=10)
print(result)
# Третья цепь.
program = Program(H(0))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0)
result = quantum_simulator.run(program, classical_addresses=[0], trials=10)
print(result)
# Четвёртая цепь.
# управляющий------v v----таргет
program = Program(X(0), X(1), CNOT(0, 1))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0).measure(1, 1)
result = quantum_simulator.run(program, classical_addresses=[0, 1], trials=10)
print(result)
# Пятая цепь.
# управляющий------v v----таргет
program = Program(H(0), X(1), CNOT(0, 1))
result = qvm.wavefunction(program)
result.plot()
program.measure(0, 0).measure(1, 1)
result = quantum_simulator.run(program, classical_addresses=[0, 1], trials=10)
print(result)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeVigoV2
from qiskit.visualization import plot_circuit_layout
from qiskit.tools.monitor import job_monitor
from qiskit.providers.fake_provider import FakeVigoV2
import matplotlib.pyplot as plt
ghz = QuantumCircuit(3, 3)
ghz.h(0)
for idx in range(1,3):
ghz.cx(0,idx)
ghz.measure(range(3), range(3))
backend = FakeVigoV2()
new_circ_lv3 = transpile(ghz, backend=backend, optimization_level=3)
plot_circuit_layout(new_circ_lv3, backend)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeAuckland
backend = FakeAuckland()
ghz = QuantumCircuit(15)
ghz.h(0)
ghz.cx(0, range(1, 15))
depths = []
for _ in range(100):
depths.append(
transpile(
ghz,
backend,
layout_method='trivial' # Fixed layout mapped in circuit order
).depth()
)
plt.figure(figsize=(8, 6))
plt.hist(depths, align='left', color='#AC557C')
plt.xlabel('Depth', fontsize=14)
plt.ylabel('Counts', fontsize=14);
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
# Importing standard Qiskit libraries and configuring account
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import scipy
import numpy as np
from IPython.display import display, Math, Latex
import qiskit.quantum_info as qi
%matplotlib inline
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.unitary_circuit import *
U = get_unitary()
print(U.shape)
fig, (ax1, ax2) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax1.imshow(np.real(U)) #plot real parts of each element
ax2.imshow(np.imag(U)) #plot imaginary parts of each element
fig, (ax3, ax4) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax3.imshow(np.abs(U)) #plot the absolute values of each element
ax4.imshow(np.angle(U)) #plot the phase angles of each element
qc = QuantumCircuit(4)
qc.unitary(U, range(4))
matrix = qi.Operator(qc).data
print(matrix)
#
#
#Your code here
#
#
# qc = transpile(qc,basis_gates=['cx','u3'],optimization_level=3)
# qc.draw('mpl')
#Run this cell for getting your circuit checked
check_circuit(qc)
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import re
import itertools
import numpy as np
import random
random.seed(42)
import mitiq
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.ignis.mitigation import expectation_value
# Pauli Twirling
def pauli_twirling(circ: QuantumCircuit) -> QuantumCircuit:
"""
[internal function]
This function takes a quantum circuit and return a new quantum circuit with Pauli Twirling around the CNOT gates.
Args:
circ: QuantumCircuit
Returns:
QuantumCircuit
"""
def apply_pauli(num: int, qb: int) -> str:
if (num == 0):
return f''
elif (num == 1):
return f'x q[{qb}];\n'
elif (num == 2):
return f'y q[{qb}];\n'
else:
return f'z q[{qb}];\n'
paulis = [(i,j) for i in range(0,4) for j in range(0,4)]
paulis.remove((0,0))
paulis_map = [(0, 1), (3, 2), (3, 3), (1, 1), (1, 0), (2, 3), (2, 2), (2, 1), (2, 0), (1, 3), (1, 2), (3, 0), (3, 1), (0, 2), (0, 3)]
new_circ = ''
ops = circ.qasm().splitlines(True) #! split the quantum circuit into qasm operators
for op in ops:
if (op[:2] == 'cx'): # add Pauli Twirling around the CNOT gate
num = random.randrange(len(paulis))
qbs = re.findall('q\[(.)\]', op)
new_circ += apply_pauli(paulis[num][0], qbs[0])
new_circ += apply_pauli(paulis[num][1], qbs[1])
new_circ += op
new_circ += apply_pauli(paulis_map[num][0], qbs[0])
new_circ += apply_pauli(paulis_map[num][1], qbs[1])
else:
new_circ += op
return QuantumCircuit.from_qasm_str(new_circ)
def zne_wrapper(qcs, scale_factors = [1.0, 2.0, 3.0], pt = False):
"""
This function outputs the circuit list for zero-noise extrapolation.
Args:
qcs: List[QuantumCircuit], the input quantum circuits.
scale_factors: List[float], to what extent the noise scales are investigated.
pt: bool, whether add Pauli Twirling or not.
Returns:
folded_qcs: List[QuantumCircuit]
"""
folded_qcs = [] #! ZNE用の回路
for qc in qcs:
folded_qcs.append([mitiq.zne.scaling.fold_gates_at_random(qc, scale) for scale in scale_factors]) #! ここでmitiqを使用
folded_qcs = list(itertools.chain(*folded_qcs)) #! folded_qcsを平坦化
if pt:
folded_qcs = [pauli_twirling(circ) for circ in folded_qcs]
return folded_qcs
def make_stf_basis(n, basis_elements = ["X","Y","Z"]):
"""
[internal function]
This function outputs all the combinations of length n string for given basis_elements.
When basis_elements is X, Y, and Z (default), the output becomes the n-qubit Pauli basis.
Args:
n: int
basis_elements: List[str]
Returns:
basis: List[str]
"""
if n == 1:
return basis_elements
basis = []
for i in basis_elements:
sub_basis = make_stf_basis(n - 1, basis_elements)
basis += [i + j for j in sub_basis]
return basis
def reduce_hist(hist, poses):
"""
[internal function]
This function returns the reduced histogram to the designated positions.
Args:
hist: Dict[str, float]
poses: List[int]
Returns:
ret_hist: Dict[str, float]
"""
n = len(poses)
ret_hist = {format(i, "0" + str(n) + "b"): 0 for i in range(1 << n)}
for k, v in hist.items():
pos = ""
for i in range(n):
pos += k[poses[i]]
ret_hist[pos] += v
return ret_hist
def make_stf_expvals(n, stf_hists):
"""
[internal function]
This function create the expectations under expanded basis, which are used to reconstruct the density matrix.
Args:
n: int, the size of classical register in the measurement results.
stf_hists: List[Dict[str, float]], the input State Tomography Fitter histograms.
Returns:
st_expvals: List[float], the output State Tomography expectation values.
"""
assert len(stf_hists) == 3 ** n
stf_basis = make_stf_basis(n, basis_elements=["X","Y","Z"])
st_basis = make_stf_basis(n, basis_elements=["I","X","Y","Z"])
stf_hists_dict = {basis: hist for basis, hist in zip(stf_basis, stf_hists)}
st_hists_dict = {basis: stf_hists_dict.get(basis, None) for basis in st_basis}
# remaining
for basis in sorted(set(st_basis) - set(stf_basis)):
if basis == "I" * n:
continue
reduction_poses = []
reduction_basis = ""
for i, b in enumerate(basis):
if b != "I":
reduction_poses.append(n - 1 - i) # big endian
reduction_basis += b # こっちはそのまま(なぜならラベルはlittle endianだから)
else:
reduction_basis += "Z"
st_hists_dict[basis] = reduce_hist(stf_hists_dict[reduction_basis], reduction_poses)
st_expvals = dict()
for basis, hist in st_hists_dict.items():
if basis == "I" * n:
st_expvals[basis] = 1.0
continue
st_expvals[basis], _ = expectation_value(hist)
return st_expvals
def zne_decoder(n, result, scale_factors=[1.0, 2.0, 3.0], fac_type="lin"):
"""
This function applies the zero-noise extrapolation to the measured results and output the mitigated zero-noise expectation values.
Args:
n: int, the size of classical register in the measurement results.
result: Result, the returned results from job.
scale_factors: List[float], this should be the same as the zne_wrapper.
fac_type: str, "lin" or "exp", whether to use LinFactory option or ExpFactory option in mitiq, to extrapolate the expectation values.
Returns:
zne_expvals: List[float], the mitigated zero-noise expectation values.
"""
hists = result.get_counts()
num_scale_factors = len(scale_factors)
assert len(hists) % num_scale_factors == 0
scale_wise_expvals = [] # num_scale_factors * 64
for i in range(num_scale_factors):
scale_wise_hists = [hists[3 * j + i] for j in range(len(hists) // num_scale_factors)]
st_expvals = make_stf_expvals(n, scale_wise_hists)
scale_wise_expvals.append( list(st_expvals.values()) )
scale_wise_expvals = np.array(scale_wise_expvals)
linfac = mitiq.zne.inference.LinearFactory(scale_factors)
expfac = mitiq.zne.ExpFactory(scale_factors)
zne_expvals = []
for i in range(4 ** n):
if fac_type == "lin":
zne_expvals.append( linfac.extrapolate(scale_factors, scale_wise_expvals[:, i]) )
else:
zne_expvals.append( expfac.extrapolate(scale_factors, scale_wise_expvals[:, i]) )
return zne_expvals
|
https://github.com/rigetti/qiskit-rigetti
|
rigetti
|
from qiskit import (
QuantumCircuit,
QuantumRegister,
ClassicalRegister,
execute
)
from qiskit_rigetti import RigettiQCSProvider
provider = RigettiQCSProvider()
backend = provider.get_simulator(num_qubits=2, noisy=True) # or provider.get_backend(name="Aspen-9") when running via QCS
circuit = QuantumCircuit(QuantumRegister(2, "q"), ClassicalRegister(2, "ro"))
circuit.h(0)
circuit.cx(0, 1)
circuit.measure([0, 1], [0, 1])
circuit.draw()
job = execute(circuit, backend, shots=1000)
result = job.result()
counts = result.get_counts()
print("Counts for experiment:", counts)
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# construct circuit for uncertainty model
uncertainty_model = LogNormalDistribution(
num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high)
)
# plot probability distribution
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel("Spot Price at Maturity $S_T$ (\$)", size=15)
plt.ylabel("Probability ($\%$)", size=15)
plt.show()
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price_1 = 1.438
strike_price_2 = 2.584
# set the approximation scaling for the payoff function
rescaling_factor = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price_1, strike_price_2]
slopes = [0, 1, 0]
offsets = [0, 0, strike_price_2 - strike_price_1]
f_min = 0
f_max = strike_price_2 - strike_price_1
bull_spread_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
rescaling_factor=rescaling_factor,
)
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
bull_spread = bull_spread_objective.compose(uncertainty_model, front=True)
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.minimum(np.maximum(0, x - strike_price_1), strike_price_2 - strike_price_1)
plt.plot(x, y, "ro-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Spot Price", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value (normalized to the [0, 1] interval)
exact_value = np.dot(uncertainty_model.probabilities, y)
exact_delta = sum(
uncertainty_model.probabilities[np.logical_and(x >= strike_price_1, x <= strike_price_2)]
)
print("exact expected value:\t%.4f" % exact_value)
print("exact delta value: \t%.4f" % exact_delta)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=bull_spread,
objective_qubits=[num_uncertainty_qubits],
post_processing=bull_spread_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value:\t%.4f" % result.estimation_processed)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price_1, strike_price_2]
slopes = [0, 0, 0]
offsets = [0, 1, 0]
f_min = 0
f_max = 1
bull_spread_delta_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
) # no approximation necessary, hence no rescaling factor
# construct the A operator by stacking the uncertainty model and payoff function together
bull_spread_delta = bull_spread_delta_objective.compose(uncertainty_model, front=True)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=bull_spread_delta, objective_qubits=[num_uncertainty_qubits]
)
# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result_delta = ae_delta.estimate(problem)
conf_int = np.array(result_delta.confidence_interval)
print("Exact delta: \t%.4f" % exact_delta)
print("Estimated value:\t%.4f" % result_delta.estimation)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019, 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
CNOTDihedral operator class.
"""
from __future__ import annotations
import itertools
import numpy as np
from qiskit.exceptions import QiskitError
from qiskit.quantum_info.operators.base_operator import BaseOperator
from qiskit.quantum_info.operators.operator import Operator
from qiskit.quantum_info.operators.symplectic.pauli import Pauli
from qiskit.quantum_info.operators.scalar_op import ScalarOp
from qiskit.quantum_info.operators.mixins import generate_apidocs, AdjointMixin
from qiskit.circuit import QuantumCircuit, Instruction
from .dihedral_circuits import _append_circuit
from .polynomial import SpecialPolynomial
class CNOTDihedral(BaseOperator, AdjointMixin):
"""An N-qubit operator from the CNOT-Dihedral group.
The CNOT-Dihedral group is generated by the quantum gates,
:class:`~qiskit.circuit.library.CXGate`, :class:`~qiskit.circuit.library.TGate`,
and :class:`~qiskit.circuit.library.XGate`.
**Representation**
An :math:`N`-qubit CNOT-Dihedral operator is stored as an affine function and a
phase polynomial, based on the convention in references [1, 2].
The affine function consists of an :math:`N \\times N` invertible binary matrix,
and an :math:`N` binary vector.
The phase polynomial is a polynomial of degree at most 3,
in :math:`N` variables, whose coefficients are in the ring Z_8 with 8 elements.
.. code-block::
from qiskit import QuantumCircuit
from qiskit.quantum_info import CNOTDihedral
circ = QuantumCircuit(3)
circ.cx(0, 1)
circ.x(2)
circ.t(1)
circ.t(1)
circ.t(1)
elem = CNOTDihedral(circ)
# Print the CNOTDihedral element
print(elem)
.. parsed-literal::
phase polynomial =
0 + 3*x_0 + 3*x_1 + 2*x_0*x_1
affine function =
(x_0,x_0 + x_1,x_2 + 1)
**Circuit Conversion**
CNOTDihedral operators can be initialized from circuits containing *only* the
following gates: :class:`~qiskit.circuit.library.IGate`,
:class:`~qiskit.circuit.library.XGate`, :class:`~qiskit.circuit.library.YGate`,
:class:`~qiskit.circuit.library.ZGate`,
:class:`~qiskit.circuit.library.TGate`, :class:`~qiskit.circuit.library.TdgGate`
:class:`~qiskit.circuit.library.SGate`, :class:`~qiskit.circuit.library.SdgGate`,
:class:`~qiskit.circuit.library.CXGate`, :class:`~qiskit.circuit.library.CZGate`,
:class:`~qiskit.circuit.library.CSGate`, :class:`~qiskit.circuit.library.CSdgGate`,
:class:`~qiskit.circuit.library.SwapGate`, :class:`~qiskit.circuit.library.CCZGate`.
They can be converted back into a :class:`~qiskit.circuit.QuantumCircuit`,
or :class:`~qiskit.circuit.Gate` object using the :meth:`~CNOTDihedral.to_circuit`
or :meth:`~CNOTDihderal.to_instruction` methods respectively. Note that this
decomposition is not necessarily optimal in terms of number of gates
if the number of qubits is more than two.
CNOTDihedral operators can also be converted to
:class:`~qiskit.quantum_info.Operator` objects using the
:meth:`to_operator` method. This is done via decomposing to a circuit,
and then simulating the circuit as a unitary operator.
References:
1. Shelly Garion and Andrew W. Cross, *Synthesis of CNOT-Dihedral circuits
with optimal number of two qubit gates*, `Quantum 4(369), 2020
<https://quantum-journal.org/papers/q-2020-12-07-369/>`_
2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta,
*Scalable randomised benchmarking of non-Clifford gates*,
npj Quantum Inf 2, 16012 (2016).
"""
def __init__(
self,
data: CNOTDihedral | QuantumCircuit | Instruction | None = None,
num_qubits: int | None = None,
validate: bool = True,
):
"""Initialize a CNOTDihedral operator object.
Args:
data (CNOTDihedral or QuantumCircuit or ~qiskit.circuit.Instruction):
Optional, operator to initialize.
num_qubits (int): Optional, initialize an empty CNOTDihedral operator.
validate (bool): if True, validates the CNOTDihedral element.
Raises:
QiskitError: if the type is invalid.
QiskitError: if validate=True and the CNOTDihedral element is invalid.
"""
if num_qubits:
# initialize n-qubit identity
self._num_qubits = num_qubits
# phase polynomial
self.poly = SpecialPolynomial(self._num_qubits)
# n x n invertible matrix over Z_2
self.linear = np.eye(self._num_qubits, dtype=np.int8)
# binary shift, n coefficients in Z_2
self.shift = np.zeros(self._num_qubits, dtype=np.int8)
# Initialize from another CNOTDihedral by sharing the underlying
# poly, linear and shift
elif isinstance(data, CNOTDihedral):
self.linear = data.linear
self.shift = data.shift
self.poly = data.poly
# Initialize from ScalarOp as N-qubit identity discarding any global phase
elif isinstance(data, ScalarOp):
if not data.is_unitary() or set(data._input_dims) != {2} or data.num_qubits is None:
raise QiskitError("Can only initialize from N-qubit identity ScalarOp.")
self._num_qubits = data.num_qubits
# phase polynomial
self.poly = SpecialPolynomial(self._num_qubits)
# n x n invertible matrix over Z_2
self.linear = np.eye(self._num_qubits, dtype=np.int8)
# binary shift, n coefficients in Z_2
self.shift = np.zeros(self._num_qubits, dtype=np.int8)
# Initialize from a QuantumCircuit or Instruction object
elif isinstance(data, (QuantumCircuit, Instruction)):
self._num_qubits = data.num_qubits
elem = self._from_circuit(data)
self.poly = elem.poly
self.linear = elem.linear
self.shift = elem.shift
elif isinstance(data, Pauli):
self._num_qubits = data.num_qubits
elem = self._from_circuit(data.to_instruction())
self.poly = elem.poly
self.linear = elem.linear
self.shift = elem.shift
else:
raise QiskitError("Invalid input type for CNOTDihedral class.")
# Initialize BaseOperator
super().__init__(num_qubits=self._num_qubits)
# Validate the CNOTDihedral element
if validate and not self._is_valid():
raise QiskitError("Invalid CNOTDihedral element.")
@property
def name(self):
"""Unique string identifier for operation type."""
return "cnotdihedral"
@property
def num_clbits(self):
"""Number of classical bits."""
return 0
def _z2matmul(self, left, right):
"""Compute product of two n x n z2 matrices."""
prod = np.mod(np.dot(left, right), 2)
return prod
def _z2matvecmul(self, mat, vec):
"""Compute mat*vec of n x n z2 matrix and vector."""
prod = np.mod(np.dot(mat, vec), 2)
return prod
def _dot(self, other):
"""Left multiplication self * other."""
if self.num_qubits != other.num_qubits:
raise QiskitError("Multiplication on different number of qubits.")
result = CNOTDihedral(num_qubits=self.num_qubits)
result.shift = [
(x[0] + x[1]) % 2 for x in zip(self._z2matvecmul(self.linear, other.shift), self.shift)
]
result.linear = self._z2matmul(self.linear, other.linear)
# Compute x' = B1*x + c1 using the p_j identity
new_vars = []
for i in range(self.num_qubits):
support = np.arange(self.num_qubits)[np.nonzero(other.linear[i])]
poly = SpecialPolynomial(self.num_qubits)
poly.set_pj(support)
if other.shift[i] == 1:
poly = -1 * poly
poly.weight_0 = (poly.weight_0 + 1) % 8
new_vars.append(poly)
# p' = p1 + p2(x')
result.poly = other.poly + self.poly.evaluate(new_vars)
return result
def _compose(self, other):
"""Right multiplication other * self."""
if self.num_qubits != other.num_qubits:
raise QiskitError("Multiplication on different number of qubits.")
result = CNOTDihedral(num_qubits=self.num_qubits)
result.shift = [
(x[0] + x[1]) % 2 for x in zip(self._z2matvecmul(other.linear, self.shift), other.shift)
]
result.linear = self._z2matmul(other.linear, self.linear)
# Compute x' = B1*x + c1 using the p_j identity
new_vars = []
for i in range(self.num_qubits):
support = np.arange(other.num_qubits)[np.nonzero(self.linear[i])]
poly = SpecialPolynomial(self.num_qubits)
poly.set_pj(support)
if self.shift[i] == 1:
poly = -1 * poly
poly.weight_0 = (poly.weight_0 + 1) % 8
new_vars.append(poly)
# p' = p1 + p2(x')
result.poly = self.poly + other.poly.evaluate(new_vars)
return result
def __eq__(self, other):
"""Test equality."""
return (
isinstance(other, CNOTDihedral)
and self.poly == other.poly
and (self.linear == other.linear).all()
and (self.shift == other.shift).all()
)
def _append_cx(self, i, j):
"""Apply a CX gate to this element.
Left multiply the element by CX(i, j).
"""
if not 0 <= i < self.num_qubits or not 0 <= j < self.num_qubits:
raise QiskitError("CX qubits are out of bounds.")
self.linear[j] = (self.linear[i] + self.linear[j]) % 2
self.shift[j] = (self.shift[i] + self.shift[j]) % 2
def _append_phase(self, k, i):
"""Apply an k-th power of T to this element.
Left multiply the element by T_i^k.
"""
if not 0 <= i < self.num_qubits:
raise QiskitError("phase qubit out of bounds.")
# If the kth bit is flipped, conjugate this gate
if self.shift[i] == 1:
k = (7 * k) % 8
# Take all subsets \alpha of the support of row i
# of weight up to 3 and add k*(-2)**(|\alpha| - 1) mod 8
# to the corresponding term.
support = np.arange(self.num_qubits)[np.nonzero(self.linear[i])]
subsets_2 = itertools.combinations(support, 2)
subsets_3 = itertools.combinations(support, 3)
for j in support:
value = self.poly.get_term([j])
self.poly.set_term([j], (value + k) % 8)
for j in subsets_2:
value = self.poly.get_term(list(j))
self.poly.set_term(list(j), (value + -2 * k) % 8)
for j in subsets_3:
value = self.poly.get_term(list(j))
self.poly.set_term(list(j), (value + 4 * k) % 8)
def _append_x(self, i):
"""Apply X to this element.
Left multiply the element by X(i).
"""
if not 0 <= i < self.num_qubits:
raise QiskitError("X qubit out of bounds.")
self.shift[i] = (self.shift[i] + 1) % 2
def __str__(self):
"""Return formatted string representation."""
out = "phase polynomial = \n"
out += str(self.poly)
out += "\naffine function = \n"
out += " ("
for row in range(self.num_qubits):
wrote = False
for col in range(self.num_qubits):
if self.linear[row][col] != 0:
if wrote:
out += " + x_" + str(col)
else:
out += "x_" + str(col)
wrote = True
if self.shift[row] != 0:
out += " + 1"
if row != self.num_qubits - 1:
out += ","
out += ")\n"
return out
def to_circuit(self):
"""Return a QuantumCircuit implementing the CNOT-Dihedral element.
Return:
QuantumCircuit: a circuit implementation of the CNOTDihedral object.
References:
1. Shelly Garion and Andrew W. Cross, *Synthesis of CNOT-Dihedral circuits
with optimal number of two qubit gates*, `Quantum 4(369), 2020
<https://quantum-journal.org/papers/q-2020-12-07-369/>`_
2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta,
*Scalable randomised benchmarking of non-Clifford gates*,
npj Quantum Inf 2, 16012 (2016).
"""
from qiskit.synthesis.cnotdihedral import synth_cnotdihedral_full
return synth_cnotdihedral_full(self)
def to_instruction(self):
"""Return a Gate instruction implementing the CNOTDihedral object."""
return self.to_circuit().to_gate()
def _from_circuit(self, circuit):
"""Initialize from a QuantumCircuit or Instruction.
Args:
circuit (QuantumCircuit or ~qiskit.circuit.Instruction):
instruction to initialize.
Returns:
CNOTDihedral: the CNOTDihedral object for the circuit.
Raises:
QiskitError: if the input instruction is not CNOTDihedral or contains
classical register instruction.
"""
if not isinstance(circuit, (QuantumCircuit, Instruction)):
raise QiskitError("Input must be a QuantumCircuit or Instruction")
# Initialize an identity CNOTDihedral object
elem = CNOTDihedral(num_qubits=self._num_qubits)
_append_circuit(elem, circuit)
return elem
def __array__(self, dtype=None):
if dtype:
return np.asarray(self.to_matrix(), dtype=dtype)
return self.to_matrix()
def to_matrix(self):
"""Convert operator to Numpy matrix."""
return self.to_operator().data
def to_operator(self) -> Operator:
"""Convert to an Operator object."""
return Operator(self.to_instruction())
def compose(
self, other: CNOTDihedral, qargs: list | None = None, front: bool = False
) -> CNOTDihedral:
if qargs is not None:
raise NotImplementedError("compose method does not support qargs.")
if self.num_qubits != other.num_qubits:
raise QiskitError("Incompatible dimension for composition")
if front:
other = self._dot(other)
else:
other = self._compose(other)
other.poly.weight_0 = 0 # set global phase
return other
def _tensor(self, other, reverse=False):
"""Returns the tensor product operator."""
if not isinstance(other, CNOTDihedral):
raise QiskitError("Tensored element is not a CNOTDihderal object.")
if reverse:
elem0 = self
elem1 = other
else:
elem0 = other
elem1 = self
result = CNOTDihedral(num_qubits=elem0.num_qubits + elem1.num_qubits)
linear = np.block(
[
[elem0.linear, np.zeros((elem0.num_qubits, elem1.num_qubits), dtype=np.int8)],
[np.zeros((elem1.num_qubits, elem0.num_qubits), dtype=np.int8), elem1.linear],
]
)
result.linear = linear
shift = np.block([elem0.shift, elem1.shift])
result.shift = shift
for i in range(elem0.num_qubits):
value = elem0.poly.get_term([i])
result.poly.set_term([i], value)
for j in range(i):
value = elem0.poly.get_term([j, i])
result.poly.set_term([j, i], value)
for k in range(j):
value = elem0.poly.get_term([k, j, i])
result.poly.set_term([k, j, i], value)
for i in range(elem1.num_qubits):
value = elem1.poly.get_term([i])
result.poly.set_term([i + elem0.num_qubits], value)
for j in range(i):
value = elem1.poly.get_term([j, i])
result.poly.set_term([j + elem0.num_qubits, i + elem0.num_qubits], value)
for k in range(j):
value = elem1.poly.get_term([k, j, i])
result.poly.set_term(
[k + elem0.num_qubits, j + elem0.num_qubits, i + elem0.num_qubits], value
)
return result
def tensor(self, other: CNOTDihedral) -> CNOTDihedral:
return self._tensor(other, reverse=True)
def expand(self, other: CNOTDihedral) -> CNOTDihedral:
return self._tensor(other, reverse=False)
def adjoint(self):
circ = self.to_instruction()
result = self._from_circuit(circ.inverse())
return result
def conjugate(self):
circ = self.to_instruction()
new_circ = QuantumCircuit(self.num_qubits)
bit_indices = {bit: index for index, bit in enumerate(circ.definition.qubits)}
for instruction in circ.definition:
new_qubits = [bit_indices[tup] for tup in instruction.qubits]
if instruction.operation.name == "p":
params = 2 * np.pi - instruction.operation.params[0]
instruction.operation.params[0] = params
new_circ.append(instruction.operation, new_qubits)
elif instruction.operation.name == "t":
instruction.operation.name = "tdg"
new_circ.append(instruction.operation, new_qubits)
elif instruction.operation.name == "tdg":
instruction.operation.name = "t"
new_circ.append(instruction.operation, new_qubits)
elif instruction.operation.name == "s":
instruction.operation.name = "sdg"
new_circ.append(instruction.operation, new_qubits)
elif instruction.operation.name == "sdg":
instruction.operation.name = "s"
new_circ.append(instruction.operation, new_qubits)
else:
new_circ.append(instruction.operation, new_qubits)
result = self._from_circuit(new_circ)
return result
def transpose(self):
circ = self.to_instruction()
result = self._from_circuit(circ.reverse_ops())
return result
def _is_valid(self):
"""Return True if input is a CNOTDihedral element."""
if (
self.poly.weight_0 != 0
or len(self.poly.weight_1) != self.num_qubits
or len(self.poly.weight_2) != int(self.num_qubits * (self.num_qubits - 1) / 2)
or len(self.poly.weight_3)
!= int(self.num_qubits * (self.num_qubits - 1) * (self.num_qubits - 2) / 6)
):
return False
if (
(self.linear).shape != (self.num_qubits, self.num_qubits)
or len(self.shift) != self.num_qubits
or not np.allclose((np.linalg.det(self.linear) % 2), 1)
):
return False
if (
not (set(self.poly.weight_1.flatten())).issubset({0, 1, 2, 3, 4, 5, 6, 7})
or not (set(self.poly.weight_2.flatten())).issubset({0, 2, 4, 6})
or not (set(self.poly.weight_3.flatten())).issubset({0, 4})
):
return False
if not (set(self.shift.flatten())).issubset({0, 1}) or not (
set(self.linear.flatten())
).issubset({0, 1}):
return False
return True
# Update docstrings for API docs
generate_apidocs(CNOTDihedral)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit.library.arithmetic.piecewise_chebyshev import PiecewiseChebyshev
f_x, degree, breakpoints, num_state_qubits = lambda x: np.arcsin(1 / x), 2, [2, 4], 2
pw_approximation = PiecewiseChebyshev(f_x, degree, breakpoints, num_state_qubits)
pw_approximation._build()
qc = QuantumCircuit(pw_approximation.num_qubits)
qc.h(list(range(num_state_qubits)))
qc.append(pw_approximation.to_instruction(), qc.qubits)
qc.draw(output='mpl')
|
https://github.com/mathelatics/QGSS-2023-From-Theory-to-Implementations
|
mathelatics
|
import qiskit
qiskit.__qiskit_version__
#initialization
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# Load the saved IBMQ accounts
IBMQ.load_account()
s = "010101" # the hidden bitstring
assert 1 < len(s) < 20, "The length of s must be between 2 and 19"
for c in s:
assert c == "0" or c == "1", "s must be a bitstring of '0' and '1'"
n = len(s) #the length of the bitstring
# Step 1
# Creating registers
# qubits for querying the oracle and recording its output
qr = QuantumRegister(2*n)
# for recording the measurement on the first register of qr
cr = ClassicalRegister(n)
circuitName = "Simon"
simonCircuit = QuantumCircuit(qr, cr)
# Step 2
# Apply Hadamard gates before querying the oracle
for i in range(n):
simonCircuit.h(qr[i])
# Apply barrier to mark the beginning of the blackbox function
simonCircuit.barrier()
# Step 3 query the blackbox function
# copy the content of the first register to the second register
for i in range(n):
simonCircuit.cx(qr[i], qr[n+i])
# get the least index j such that s_j is "1"
j = -1
for i, c in enumerate(s):
if c == "1":
j = i
break
# Creating 1-to-1 or 2-to-1 mapping with the j-th qubit of x as control to XOR the second register with s
for i, c in enumerate(s):
if c == "1" and j >= 0:
simonCircuit.cx(qr[j], qr[n+i]) #the i-th qubit is flipped if s_i is 1
# get random permutation of n qubits
perm = list(np.random.permutation(n))
#initial position
init = list(range(n))
i = 0
while i < n:
if init[i] != perm[i]:
k = perm.index(init[i])
simonCircuit.swap(qr[n+i], qr[n+k]) #swap qubits
init[i], init[k] = init[k], init[i] #marked swapped qubits
else:
i += 1
# randomly flip the qubit
for i in range(n):
if np.random.random() > 0.5:
simonCircuit.x(qr[n+i])
# Apply the barrier to mark the end of the blackbox function
simonCircuit.barrier()
# Step 4 apply Hadamard gates to the first register
for i in range(n):
simonCircuit.h(qr[i])
# Step 5 perform measurement on the first register
for i in range(n):
simonCircuit.measure(qr[i], cr[i])
#draw the circuit
simonCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend("qasm_simulator")
# the number of shots is twice the length of the bitstring
shots = 2*n
job = execute(simonCircuit, backend=backend, shots=shots)
answer = job.result().get_counts()
plot_histogram(answer)
# Post-processing step
# Constructing the system of linear equations Y s = 0
# By k[::-1], we reverse the order of the bitstring
lAnswer = [ (k[::-1],v) for k,v in answer.items() if k != "0"*n ] #excluding the trivial all-zero
#Sort the basis by their probabilities
lAnswer.sort(key = lambda x: x[1], reverse=True)
Y = []
for k, v in lAnswer:
Y.append( [ int(c) for c in k ] )
#import tools from sympy
from sympy import Matrix, pprint, MatrixSymbol, expand, mod_inverse
Y = Matrix(Y)
#pprint(Y)
#Perform Gaussian elimination on Y
Y_transformed = Y.rref(iszerofunc=lambda x: x % 2==0) # linear algebra on GF(2)
#to convert rational and negatives in rref of linear algebra on GF(2)
def mod(x,modulus):
numer, denom = x.as_numer_denom()
return numer*mod_inverse(denom,modulus) % modulus
Y_new = Y_transformed[0].applyfunc(lambda x: mod(x,2)) #must takecare of negatives and fractional values
#pprint(Y_new)
print("The hidden bistring s[ 0 ], s[ 1 ]....s[",n-1,"] is the one satisfying the following system of linear equations:")
rows, cols = Y_new.shape
for r in range(rows):
Yr = [ "s[ "+str(i)+" ]" for i, v in enumerate(list(Y_new[r,:])) if v == 1 ]
if len(Yr) > 0:
tStr = " + ".join(Yr)
print(tStr, "= 0")
#Use one of the available backends
backend = IBMQ.get_backend("ibmq_16_melbourne")
# show the status of the backend
print("Status of", backend, "is", backend.status())
shots = 10*n #run more experiments to be certain
max_credits = 3 # Maximum number of credits to spend on executions.
simonCompiled = transpile(simonCircuit, backend=backend, optimization_level=1)
job_exp = execute(simonCompiled, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job_exp)
results = job_exp.result()
answer = results.get_counts(simonCircuit)
plot_histogram(answer)
# Post-processing step
# Constructing the system of linear equations Y s = 0
# By k[::-1], we reverse the order of the bitstring
lAnswer = [ (k[::-1][:n],v) for k,v in answer.items() ] #excluding the qubits that are not part of the inputs
#Sort the basis by their probabilities
lAnswer.sort(key = lambda x: x[1], reverse=True)
Y = []
for k, v in lAnswer:
Y.append( [ int(c) for c in k ] )
Y = Matrix(Y)
#Perform Gaussian elimination on Y
Y_transformed = Y.rref(iszerofunc=lambda x: x % 2==0) # linear algebra on GF(2)
Y_new = Y_transformed[0].applyfunc(lambda x: mod(x,2)) #must takecare of negatives and fractional values
#pprint(Y_new)
print("The hidden bistring s[ 0 ], s[ 1 ]....s[",n-1,"] is the one satisfying the following system of linear equations:")
rows, cols = Y_new.shape
for r in range(rows):
Yr = [ "s[ "+str(i)+" ]" for i, v in enumerate(list(Y_new[r,:])) if v == 1 ]
if len(Yr) > 0:
tStr = " + ".join(Yr)
print(tStr, "= 0")
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests for pass manager visualization tool."""
import unittest
import os
from qiskit.transpiler import CouplingMap, Layout
from qiskit.transpiler.passmanager import PassManager
from qiskit import QuantumRegister
from qiskit.transpiler.passes import GateDirection, Unroller
from qiskit.transpiler.passes import CheckMap
from qiskit.transpiler.passes import SetLayout
from qiskit.transpiler.passes import TrivialLayout
from qiskit.transpiler.passes import BarrierBeforeFinalMeasurements
from qiskit.transpiler.passes import FullAncillaAllocation
from qiskit.transpiler.passes import EnlargeWithAncilla
from qiskit.transpiler.passes import RemoveResetInZeroState
from qiskit.utils import optionals
from .visualization import QiskitVisualizationTestCase, path_to_diagram_reference
@unittest.skipUnless(optionals.HAS_GRAPHVIZ, "Graphviz not installed.")
@unittest.skipUnless(optionals.HAS_PYDOT, "pydot not installed")
@unittest.skipUnless(optionals.HAS_PIL, "Pillow not installed")
class TestPassManagerDrawer(QiskitVisualizationTestCase):
"""Qiskit pass manager drawer tests."""
def setUp(self):
super().setUp()
coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]]
coupling_map = CouplingMap(couplinglist=coupling)
basis_gates = ["u1", "u3", "u2", "cx"]
qr = QuantumRegister(7, "q")
layout = Layout({qr[i]: i for i in range(coupling_map.size())})
# Create a pass manager with a variety of passes and flow control structures
self.pass_manager = PassManager()
self.pass_manager.append(SetLayout(layout))
self.pass_manager.append(TrivialLayout(coupling_map), condition=lambda x: True)
self.pass_manager.append(FullAncillaAllocation(coupling_map))
self.pass_manager.append(EnlargeWithAncilla())
self.pass_manager.append(Unroller(basis_gates))
self.pass_manager.append(CheckMap(coupling_map))
self.pass_manager.append(BarrierBeforeFinalMeasurements(), do_while=lambda x: False)
self.pass_manager.append(GateDirection(coupling_map))
self.pass_manager.append(RemoveResetInZeroState())
def test_pass_manager_drawer_basic(self):
"""Test to see if the drawer draws a normal pass manager correctly"""
filename = "current_standard.dot"
self.pass_manager.draw(filename=filename, raw=True)
try:
self.assertFilesAreEqual(
filename, path_to_diagram_reference("pass_manager_standard.dot")
)
finally:
os.remove(filename)
def test_pass_manager_drawer_style(self):
"""Test to see if the colours are updated when provided by the user"""
# set colours for some passes, but leave others to take the default values
style = {
SetLayout: "cyan",
CheckMap: "green",
EnlargeWithAncilla: "pink",
RemoveResetInZeroState: "grey",
}
filename = "current_style.dot"
self.pass_manager.draw(filename=filename, style=style, raw=True)
try:
self.assertFilesAreEqual(filename, path_to_diagram_reference("pass_manager_style.dot"))
finally:
os.remove(filename)
if __name__ == "__main__":
unittest.main(verbosity=2)
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests for all BasicAer simulators."""
import io
from logging import StreamHandler, getLogger
import sys
from qiskit import BasicAer
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from qiskit.compiler import assemble
from qiskit.qobj import QobjHeader
from qiskit.test import QiskitTestCase
class StreamHandlerRaiseException(StreamHandler):
"""Handler class that will raise an exception on formatting errors."""
def handleError(self, record):
raise sys.exc_info()
class TestBasicAerQobj(QiskitTestCase):
"""Tests for all the Terra simulators."""
def setUp(self):
super().setUp()
logger = getLogger()
self.addCleanup(logger.setLevel, logger.level)
logger.setLevel("DEBUG")
self.output = io.StringIO()
logger.addHandler(StreamHandlerRaiseException(self.output))
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
self.qc1 = QuantumCircuit(qr, cr, name="circuit0")
self.qc1.h(qr[0])
def test_qobj_headers_in_result(self):
"""Test that the qobj headers are passed onto the results."""
custom_qobj_header = {"x": 1, "y": [1, 2, 3], "z": {"a": 4}}
for backend in BasicAer.backends():
with self.subTest(backend=backend):
new_circ = transpile(self.qc1, backend=backend)
qobj = assemble(new_circ, shots=1024)
# Update the Qobj header.
qobj.header = QobjHeader.from_dict(custom_qobj_header)
# Update the Qobj.experiment header.
qobj.experiments[0].header.some_field = "extra info"
result = backend.run(qobj).result()
self.assertEqual(result.header.to_dict(), custom_qobj_header)
self.assertEqual(result.results[0].header.some_field, "extra info")
|
https://github.com/nahumsa/volta
|
nahumsa
|
import sys
sys.path.append('../../')
# Python imports
import numpy as np
import matplotlib.pyplot as plt
# Qiskit
from qiskit import BasicAer, Aer
from qiskit.aqua.components.optimizers import COBYLA, SPSA
from qiskit.circuit.library import TwoLocal
# VOLTA
from volta.vqd import VQD
from volta.utils import classical_solver
from volta.hamiltonians import BCS_hamiltonian
%load_ext autoreload
%autoreload 2
EPSILONS = [3., 3.]
V = -2
hamiltonian = BCS_hamiltonian(EPSILONS, V)
print(hamiltonian)
eigenvalues, eigenvectors = classical_solver(hamiltonian)
print(f"Eigenvalues: {eigenvalues}")
from qiskit.providers.aer.noise import depolarizing_error
from qiskit.providers.aer.noise import thermal_relaxation_error
from qiskit.providers.aer.noise import NoiseModel
# Defining noise model
# T1 and T2 values for qubits 0-n
n_qubits = 2*len(EPSILONS)
# T1s = np.random.normal(50e3, 10e3, n_qubits) # Sampled from normal distribution mean 50 microsec
# T2s = np.random.normal(70e3, 10e3, n_qubits) # Sampled from normal distribution mean 50 microsec
T1s = [30e3]*n_qubits
T2s = [20e3]*n_qubits
# Truncate random T2s <= T1s
T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(n_qubits)])
# Instruction times (in nanoseconds)
time_u1 = 0 # virtual gate
time_u2 = 50 # (single X90 pulse)
time_u3 = 100 # (two X90 pulses)
time_cx = 300
time_reset = 1000 # 1 microsecond
time_measure = 1000 # 1 microsecond
# QuantumError objects
errors_reset = [thermal_relaxation_error(t1, t2, time_reset)
for t1, t2 in zip(T1s, T2s)]
errors_measure = [thermal_relaxation_error(t1, t2, time_measure)
for t1, t2 in zip(T1s, T2s)]
errors_u1 = [thermal_relaxation_error(t1, t2, time_u1)
for t1, t2 in zip(T1s, T2s)]
errors_u2 = [thermal_relaxation_error(t1, t2, time_u2)
for t1, t2 in zip(T1s, T2s)]
errors_u3 = [thermal_relaxation_error(t1, t2, time_u3)
for t1, t2 in zip(T1s, T2s)]
errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(
thermal_relaxation_error(t1b, t2b, time_cx))
for t1a, t2a in zip(T1s, T2s)]
for t1b, t2b in zip(T1s, T2s)]
# Add errors to noise model
noise_thermal = NoiseModel()
for j in range(n_qubits):
noise_thermal.add_quantum_error(errors_reset[j], "reset", [j])
noise_thermal.add_quantum_error(errors_measure[j], "measure", [j])
noise_thermal.add_quantum_error(errors_u1[j], "u1", [j])
noise_thermal.add_quantum_error(errors_u2[j], "u2", [j])
noise_thermal.add_quantum_error(errors_u3[j], "u3", [j])
for k in range(n_qubits):
noise_thermal.add_quantum_error(errors_cx[j][k], "cx", [j, k])
print(noise_thermal)
from tqdm import tqdm
from qiskit.aqua import QuantumInstance
# Parameters Variables
n_trials = 50
max_depth = 7
# Auxiliary Variables
solution_dict = {}
# Define Optimizer
#optimizer = COBYLA()
optimizer = SPSA(maxiter=250, c1=1.5, last_avg=25)
# Define Backend
backend = QuantumInstance(backend= Aer.get_backend('qasm_simulator'),
noise_model=noise_thermal,
shots=10000)
for depth in range(1,max_depth):
# Ansatz with diferent depth
ansatz = TwoLocal(hamiltonian.num_qubits, ['ry','rz'], 'cx', reps=depth)
es_1 = []
es_2 = []
for _ in tqdm(range(n_trials), desc=f"Depth {depth}"):
# Run algorithm
Algo = VQD(hamiltonian=hamiltonian,
ansatz=ansatz,
n_excited_states=2,
beta=10.,
optimizer=optimizer,
backend=backend)
Algo.run(0)
vqd_energies = Algo.energies
es_1.append(vqd_energies[1])
es_2.append(vqd_energies[2])
es_1 = np.array(es_1)
es_2 = np.array(es_2)
# Maybe use a pd.dataframe
solution_dict[depth] = {'mean':np.mean(es_2 - es_1), 'std':np.std(es_2 - es_1)}
mean = []
std = []
for i in range(1,max_depth):
mean.append(solution_dict[i]['mean'])
std.append(solution_dict[i]['std'])
solution_dict
import seaborn as sns
sns.set()
from matplotlib.ticker import MaxNLocator
x_axis = [i for i in range(1,max_depth)]
plt.errorbar(x_axis,
np.array(mean)/2,
yerr=np.array(std)/2,
fmt='ro', ecolor='green')
plt.hlines(y=2, xmin=0.5, xmax=6.5,
label='Expected value',color='b')
plt.title('Varying Depth', size=18)
plt.xlabel('Depth', size= 14)
plt.ylabel('Gap', size=14)
plt.xticks(x_axis)
plt.legend()
plt.show()
spsa_dict = {1: {'mean': 4.540763883482028, 'std': 0.2166500619449026},
2: {'mean': 3.6292261939489365, 'std': 1.3793621699692478},
3: {'mean': 3.5182758038620277, 'std': 0.8910628276050163},
4: {'mean': 3.292976405037763, 'std': 1.3966224263108362},
5: {'mean': 3.5144598497611055, 'std': 1.0963827019837287},
6: {'mean': 2.6975338496665677, 'std': 1.3507496759669415}}
cobyla_dict = {1: {'mean': 2.3633300482974127, 'std': 2.1367566366817043},
2: {'mean': 4.113586221793872, 'std': 0.7316145547992721},
3: {'mean': 4.321305470168272, 'std': 0.4919574179280678},
4: {'mean': 4.3014277420825975, 'std': 0.4023952320110141},
5: {'mean': 4.157595644181709, 'std': 0.33724862839247316},
6: {'mean': 3.968890438601869, 'std': 0.29850260762472425}}
mean_spsa = []
std_spsa = []
mean_cobyla = []
std_cobyla = []
for i in range(1,max_depth):
mean_spsa.append(spsa_dict[i]['mean'])
std_spsa.append(spsa_dict[i]['std'])
mean_cobyla.append(cobyla_dict[i]['mean'])
std_cobyla.append(cobyla_dict[i]['std'])
from matplotlib.ticker import MaxNLocator
x_axis = [i for i in range(1,max_depth)]
plt.errorbar(x_axis,
np.array(mean_spsa)/2,
yerr=np.array(std_spsa)/2,
fmt='o', color='black',
ecolor='gray', elinewidth=2,
label='SPSA')
plt.errorbar(x_axis,
np.array(mean_cobyla)/2,
yerr=np.array(std_cobyla)/2,
fmt='o', color='red',
ecolor='green', elinewidth=2,
label='COBYLA')
plt.hlines(y=2, xmin=0.5, xmax=6.5,
label='Expected value',color='b')
plt.title('Varying Depth', size=18)
plt.xlabel('Depth', size= 14)
plt.ylabel('Gap', size=14)
plt.ylim(0., 4.5)
plt.xticks(x_axis)
plt.legend()
plt.savefig('Depth.png')
plt.show()
|
https://github.com/Qiskit/qiskit-transpiler-service
|
Qiskit
|
# -*- coding: utf-8 -*-
# (C) Copyright 2024 IBM. All Rights Reserved.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Unit-testing routing_ai"""
import pytest
from qiskit import QuantumCircuit
from qiskit.transpiler import PassManager
from qiskit.transpiler.exceptions import TranspilerError
from qiskit_transpiler_service.ai.routing import AIRouting
@pytest.mark.parametrize("layout_mode", ["KEEP", "OPTIMIZE", "IMPROVE"])
@pytest.mark.parametrize("optimization_level", [1, 2, 3])
def test_qv_routing(optimization_level, layout_mode, backend, qv_circ):
pm = PassManager(
[
AIRouting(
optimization_level=optimization_level,
layout_mode=layout_mode,
backend_name=backend,
)
]
)
circuit = pm.run(qv_circ)
assert isinstance(circuit, QuantumCircuit)
@pytest.mark.parametrize("optimization_level", [0, 4, 5])
def test_qv_routing_wrong_opt_level(optimization_level, backend, qv_circ):
pm = PassManager(
[AIRouting(optimization_level=optimization_level, backend_name=backend)]
)
with pytest.raises(TranspilerError):
pm.run(qv_circ)
@pytest.mark.parametrize("layout_mode", ["RECREATE", "BOOST"])
def test_qv_routing_wrong_layout_mode(layout_mode, backend, qv_circ):
with pytest.raises(ValueError):
PassManager([AIRouting(layout_mode=layout_mode, backend_name=backend)])
|
https://github.com/Anastasia-Sim/PoW-QCSA-fa22
|
Anastasia-Sim
|
!pip install qiskit matplotlib
import qiskit
import matplotlib
from qiskit import QuantumCircuit, assemble, Aer, circuit, QuantumRegister, ClassicalRegister, transpile
from qiskit.visualization import plot_histogram
from qiskit.quantum_info.operators import Operator
def hash_operator():
hash_gate = Operator([
[0,0,1,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,1,0],
[0,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,1,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1],
[0,0,0,1,0,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,1,0,0,0,0,0],
[0,0,0,0,0,0,0,0,1,0,0,0,0,0,0,0],
[0,0,0,0,0,0,1,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,1,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,1,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0,0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0,0,0,0,0,0,1,0,0],
[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]
])
hash_gate.name = "Hash Gate"
return hash_gate
def dehash_operator():
hash_dagger = hash_operator().conjugate().transpose()
hash_dagger.name = "Hash Dagger"
return hash_dagger
def oracle():
qreg_q = QuantumRegister(4, 'q')
oracle = QuantumCircuit(qreg_q, name='oracle')
oracle.x(qreg_q[2:4])
oracle.cz(qreg_q[2], qreg_q[3])
oracle.x(qreg_q[2:4])
oracle_op = oracle.to_gate()
oracle_op.name = 'oracle'
return oracle
oracle().draw()
# diffuser from https://qiskit.org/textbook/ch-algorithms/grover.html
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "diffusor"
return U_s
n_qubits = 4
controls = QuantumRegister(n_qubits)
circuit = QuantumCircuit(controls)
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
#circuit.measure_all()
circuit.draw()
n_qubits = 4
controls = QuantumRegister(n_qubits)
circuit = QuantumCircuit(controls)
#input 0
circuit.i(3)
#Create uniform superposition of possible nonces
circuit.h([0,1,2])
#Run Grover's 2^(4/2) times
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.measure_all()
circuit.draw()
sim = Aer.get_backend('aer_simulator')
# We run the simulator with sim.run(QUANTUM CIRCUIT),
# And we get the resulting values with .result()
transpiled_grover_circuit = transpile(circuit, sim)
qobj = assemble(transpiled_grover_circuit)
result = sim.run(qobj).result()
# We then collect the results using .get_counts()
counts = result.get_counts()
# Visualization
plot_histogram(counts)
n_qubits = 4
controls = QuantumRegister(n_qubits)
circuit = QuantumCircuit(controls)
#input 1
circuit.x(3)
#Create uniform superposition of possible nonces
circuit.h([0,1,2])
#Run Grover's 2^(4/2) times
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.append(hash_operator(), [0, 1, 2, 3])
circuit.append(oracle(), [0, 1, 2, 3])
circuit.append(dehash_operator(), [0, 1, 2, 3])
circuit.append(diffuser(n_qubits), [0, 1, 2, 3])
circuit.measure_all()
circuit.draw()
sim = Aer.get_backend('aer_simulator')
# We run the simulator with sim.run(QUANTUM CIRCUIT),
# And we get the resulting values with .result()
transpiled_grover_circuit = transpile(circuit, sim)
qobj = assemble(transpiled_grover_circuit)
result = sim.run(qobj).result()
# We then collect the results using .get_counts()
counts = result.get_counts()
# Visualization
plot_histogram(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B
from qiskit.circuit import Parameter
from qiskit.circuit.library import RealAmplitudes, ZZFeatureMap
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier, VQC
from qiskit_machine_learning.algorithms.regressors import NeuralNetworkRegressor, VQR
from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN
algorithm_globals.random_seed = 42
num_inputs = 2
num_samples = 20
X = 2 * algorithm_globals.random.random([num_samples, num_inputs]) - 1
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()
# construct QNN
qc = QuantumCircuit(2)
feature_map = ZZFeatureMap(2)
ansatz = RealAmplitudes(2)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
qc.draw(output="mpl")
estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# QNN maps inputs to [-1, +1]
estimator_qnn.forward(X[0, :], algorithm_globals.random.random(estimator_qnn.num_weights))
# callback function that draws a live plot when the .fit() method is called
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
# construct neural network classifier
estimator_classifier = NeuralNetworkClassifier(
estimator_qnn, optimizer=COBYLA(maxiter=60), callback=callback_graph
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
estimator_classifier.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
estimator_classifier.score(X, y)
# evaluate data points
y_predict = estimator_classifier.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y, y_predict):
if y_target == 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()
estimator_classifier.weights
# construct feature map
feature_map = ZZFeatureMap(num_inputs)
# construct ansatz
ansatz = RealAmplitudes(num_inputs, reps=1)
# construct quantum circuit
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
sampler_qnn = SamplerQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=output_shape,
)
# construct classifier
sampler_classifier = NeuralNetworkClassifier(
neural_network=sampler_qnn, optimizer=COBYLA(maxiter=30), callback=callback_graph
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
sampler_classifier.fit(X, y01)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
sampler_classifier.score(X, y01)
# evaluate data points
y_predict = sampler_classifier.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y01, y_predict):
if y_target == 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()
sampler_classifier.weights
# construct feature map, ansatz, and optimizer
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
# construct variational quantum classifier
vqc = VQC(
feature_map=feature_map,
ansatz=ansatz,
loss="cross_entropy",
optimizer=COBYLA(maxiter=30),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
vqc.fit(X, y_one_hot)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
vqc.score(X, y_one_hot)
# evaluate data points
y_predict = vqc.predict(X)
# plot results
# red == wrongly classified
for x, y_target, y_p in zip(X, y_one_hot, y_predict):
if y_target[0] == 1:
plt.plot(x[0], x[1], "bo")
else:
plt.plot(x[0], x[1], "go")
if not np.all(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()
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
X, y = make_classification(
n_samples=10,
n_features=2,
n_classes=3,
n_redundant=0,
n_clusters_per_class=1,
class_sep=2.0,
random_state=algorithm_globals.random_seed,
)
X = MinMaxScaler().fit_transform(X)
plt.scatter(X[:, 0], X[:, 1], c=y)
y_cat = np.empty(y.shape, dtype=str)
y_cat[y == 0] = "A"
y_cat[y == 1] = "B"
y_cat[y == 2] = "C"
print(y_cat)
vqc = VQC(
num_qubits=2,
optimizer=COBYLA(maxiter=30),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
vqc.fit(X, y_cat)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
vqc.score(X, y_cat)
predict = vqc.predict(X)
print(f"Predicted labels: {predict}")
print(f"Ground truth: {y_cat}")
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
X_ = np.linspace(lb, ub, num=50).reshape(50, 1)
f = lambda x: np.sin(x)
X = (ub - lb) * algorithm_globals.random.random([num_samples, 1]) + lb
y = f(X[:, 0]) + eps * (2 * algorithm_globals.random.random(num_samples) - 1)
plt.plot(X_, f(X_), "r--")
plt.plot(X, y, "bo")
plt.show()
# construct simple feature map
param_x = Parameter("x")
feature_map = QuantumCircuit(1, name="fm")
feature_map.ry(param_x, 0)
# construct simple ansatz
param_y = Parameter("y")
ansatz = QuantumCircuit(1, name="vf")
ansatz.ry(param_y, 0)
# construct a circuit
qc = QuantumCircuit(1)
qc.compose(feature_map, inplace=True)
qc.compose(ansatz, inplace=True)
# construct QNN
regression_estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# construct the regressor from the neural network
regressor = NeuralNetworkRegressor(
neural_network=regression_estimator_qnn,
loss="squared_error",
optimizer=L_BFGS_B(maxiter=5),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit to data
regressor.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score the result
regressor.score(X, y)
# plot target function
plt.plot(X_, f(X_), "r--")
# plot data
plt.plot(X, y, "bo")
# plot fitted line
y_ = regressor.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()
regressor.weights
vqr = VQR(
feature_map=feature_map,
ansatz=ansatz,
optimizer=L_BFGS_B(maxiter=5),
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit regressor
vqr.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score result
vqr.score(X, y)
# plot target function
plt.plot(X_, f(X_), "r--")
# plot data
plt.plot(X, y, "bo")
# plot fitted line
y_ = vqr.predict(X_)
plt.plot(X_, y_, "g-")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import execute, Aer, QuantumCircuit, IBMQ
class SingleQubitSuperposition:
@classmethod
def run(cls):
# Use Aer's qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# Create a Quantum Circuit acting on the q register
circuit = QuantumCircuit(1, 1)
# Add a H gate on qubit 0
circuit.h(0)
# Map the quantum measurement to the classical bits
circuit.measure(0, 0)
# 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 0 and 1 are:", counts)
provider = IBMQ.load_account()
backend = provider.backends.ibmq_valencia
# Execute the circuit on a real device
job = execute(circuit, backend=backend, shots=1000)
# Grab results from the job
result = job.result()
# Returns counts
counts = result.get_counts(circuit)
print("\nTotal count for 0 and 1 are:", counts)
# Draw the circuit
print(circuit)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021, 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""An algorithm to implement a Trotterization real time-evolution."""
from __future__ import annotations
from qiskit import QuantumCircuit
from qiskit_algorithms.time_evolvers.time_evolution_problem import TimeEvolutionProblem
from qiskit_algorithms.time_evolvers.time_evolution_result import TimeEvolutionResult
from qiskit_algorithms.time_evolvers.real_time_evolver import RealTimeEvolver
from qiskit_algorithms.observables_evaluator import estimate_observables
from qiskit.opflow import PauliSumOp
from qiskit.circuit.library import PauliEvolutionGate
from qiskit.circuit.parametertable import ParameterView
from qiskit.primitives import BaseEstimator
from qiskit.quantum_info import Pauli, SparsePauliOp
from qiskit.synthesis import ProductFormula, LieTrotter
class TrotterQRTE(RealTimeEvolver):
"""Quantum Real Time Evolution using Trotterization.
Type of Trotterization is defined by a ``ProductFormula`` provided.
Examples:
.. code-block:: python
from qiskit.opflow import PauliSumOp
from qiskit.quantum_info import Pauli, SparsePauliOp
from qiskit import QuantumCircuit
from qiskit_algorithms import TimeEvolutionProblem
from qiskit_algorithms.time_evolvers import TrotterQRTE
from qiskit.primitives import Estimator
operator = PauliSumOp(SparsePauliOp([Pauli("X"), Pauli("Z")]))
initial_state = QuantumCircuit(1)
time = 1
evolution_problem = TimeEvolutionProblem(operator, time, initial_state)
# LieTrotter with 1 rep
estimator = Estimator()
trotter_qrte = TrotterQRTE(estimator=estimator)
evolved_state = trotter_qrte.evolve(evolution_problem).evolved_state
"""
def __init__(
self,
product_formula: ProductFormula | None = None,
estimator: BaseEstimator | None = None,
num_timesteps: int = 1,
) -> None:
"""
Args:
product_formula: A Lie-Trotter-Suzuki product formula. If ``None`` provided, the
Lie-Trotter first order product formula with a single repetition is used. ``reps``
should be 1 to obtain a number of time-steps equal to ``num_timesteps`` and an
evaluation of :attr:`.TimeEvolutionProblem.aux_operators` at every time-step. If ``reps``
is larger than 1, the true number of time-steps will be ``num_timesteps * reps``.
num_timesteps: The number of time-steps the full evolution time is devided into
(repetitions of ``product_formula``)
estimator: An estimator primitive used for calculating expectation values of
``TimeEvolutionProblem.aux_operators``.
"""
self.product_formula = product_formula
self.num_timesteps = num_timesteps
self.estimator = estimator
@property
def product_formula(self) -> ProductFormula:
"""Returns a product formula."""
return self._product_formula
@product_formula.setter
def product_formula(self, product_formula: ProductFormula | None):
"""Sets a product formula. If ``None`` provided, sets the Lie-Trotter first order product
formula with a single repetition."""
if product_formula is None:
product_formula = LieTrotter()
self._product_formula = product_formula
@property
def estimator(self) -> BaseEstimator | None:
"""
Returns an estimator.
"""
return self._estimator
@estimator.setter
def estimator(self, estimator: BaseEstimator) -> None:
"""
Sets an estimator.
"""
self._estimator = estimator
@property
def num_timesteps(self) -> int:
"""Returns the number of timesteps."""
return self._num_timesteps
@num_timesteps.setter
def num_timesteps(self, num_timesteps: int) -> None:
"""
Sets the number of time-steps.
Raises:
ValueError: If num_timesteps is not positive.
"""
if num_timesteps <= 0:
raise ValueError(
f"Number of time steps must be positive integer, {num_timesteps} provided"
)
self._num_timesteps = num_timesteps
@classmethod
def supports_aux_operators(cls) -> bool:
"""
Whether computing the expectation value of auxiliary operators is supported.
Returns:
``True`` if ``aux_operators`` expectations in the ``TimeEvolutionProblem`` can be
evaluated, ``False`` otherwise.
"""
return True
def evolve(self, evolution_problem: TimeEvolutionProblem) -> TimeEvolutionResult:
"""
Evolves a quantum state for a given time using the Trotterization method
based on a product formula provided. The result is provided in the form of a quantum
circuit. If auxiliary operators are included in the ``evolution_problem``, they are
evaluated on the ``init_state`` and on the evolved state at every step (``num_timesteps``
times) using an estimator primitive provided.
Args:
evolution_problem: Instance defining evolution problem. For the included Hamiltonian,
``Pauli`` or ``PauliSumOp`` are supported by TrotterQRTE.
Returns:
Evolution result that includes an evolved state as a quantum circuit and, optionally,
auxiliary operators evaluated for a resulting state on an estimator primitive.
Raises:
ValueError: If ``t_param`` is not set to ``None`` in the ``TimeEvolutionProblem``
(feature not currently supported).
ValueError: If ``aux_operators`` provided in the time evolution problem but no estimator
provided to the algorithm.
ValueError: If the ``initial_state`` is not provided in the ``TimeEvolutionProblem``.
ValueError: If an unsupported Hamiltonian type is provided.
"""
evolution_problem.validate_params()
if evolution_problem.aux_operators is not None and self.estimator is None:
raise ValueError(
"The time evolution problem contained ``aux_operators`` but no estimator was "
"provided. The algorithm continues without calculating these quantities. "
)
# ensure the hamiltonian is a sparse pauli op
hamiltonian = evolution_problem.hamiltonian
if not isinstance(hamiltonian, (Pauli, PauliSumOp, SparsePauliOp)):
raise ValueError(
f"TrotterQRTE only accepts Pauli | PauliSumOp | SparsePauliOp, {type(hamiltonian)} "
"provided."
)
if isinstance(hamiltonian, PauliSumOp):
hamiltonian = hamiltonian.primitive * hamiltonian.coeff
elif isinstance(hamiltonian, Pauli):
hamiltonian = SparsePauliOp(hamiltonian)
t_param = evolution_problem.t_param
free_parameters = hamiltonian.parameters
if t_param is not None and free_parameters != ParameterView([t_param]):
raise ValueError(
f"Hamiltonian time parameters ({free_parameters}) do not match "
f"evolution_problem.t_param ({t_param})."
)
# make sure PauliEvolutionGate does not implement more than one Trotter step
dt = evolution_problem.time / self.num_timesteps
if evolution_problem.initial_state is not None:
initial_state = evolution_problem.initial_state
else:
raise ValueError("``initial_state`` must be provided in the ``TimeEvolutionProblem``.")
evolved_state = QuantumCircuit(initial_state.num_qubits)
evolved_state.append(initial_state, evolved_state.qubits)
if evolution_problem.aux_operators is not None:
observables = []
observables.append(
estimate_observables(
self.estimator,
evolved_state,
evolution_problem.aux_operators,
None,
evolution_problem.truncation_threshold,
)
)
else:
observables = None
if t_param is None:
# the evolution gate
single_step_evolution_gate = PauliEvolutionGate(
hamiltonian, dt, synthesis=self.product_formula
)
for n in range(self.num_timesteps):
# if hamiltonian is time-dependent, bind new time-value at every step to construct
# evolution for next step
if t_param is not None:
time_value = (n + 1) * dt
bound_hamiltonian = hamiltonian.assign_parameters([time_value])
single_step_evolution_gate = PauliEvolutionGate(
bound_hamiltonian,
dt,
synthesis=self.product_formula,
)
evolved_state.append(single_step_evolution_gate, evolved_state.qubits)
if evolution_problem.aux_operators is not None:
observables.append(
estimate_observables(
self.estimator,
evolved_state,
evolution_problem.aux_operators,
None,
evolution_problem.truncation_threshold,
)
)
evaluated_aux_ops = None
if evolution_problem.aux_operators is not None:
evaluated_aux_ops = observables[-1]
return TimeEvolutionResult(evolved_state, evaluated_aux_ops, observables)
|
https://github.com/jdanielescanez/quantum-solver
|
jdanielescanez
|
import qiskit
from .common_gates import *
import random
def superdense_coding_circuit(msg):
qc = qiskit.QuantumCircuit(2)
phi_plus = phi_plus_gate()
qc.append(phi_plus, [0, 1])
qc.barrier()
if msg[1] == '1':
qc.z(0)
if msg[0] == '1':
qc.x(0)
qc.barrier()
qc.append(phi_plus.inverse(), [0, 1])
qc.name = "SC"
return qc
def superdense_coding_example():
msg = random.choice(["00", "01", "10", "11"])
qc = qiskit.QuantumCircuit(2, 2)
sc_qc = superdense_coding_circuit(msg)
qc.append(sc_qc, [0, 1])
if msg[0] == '1':
qc.x(1)
if msg[1] == '1':
qc.x(0)
qc.measure([0, 1], [0, 1])
print(msg)
print(qc.draw(output="text"))
return qc
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit,execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
import math
qc = QuantumCircuit(2,2)
qc.h(0)
qc.h(1)
qc.measure([0,1],[0,1])
print("This is |++>:")
print(qc)
simulator=AerSimulator()
job=execute(qc, backend=simulator, shots=1000)
result=job.result()
counts=result.get_counts(qc)
print("Counts:",counts)
plot_histogram(counts)
|
https://github.com/peiyong-addwater/Hackathon-QNLP
|
peiyong-addwater
|
import tarfile
from urllib.request import urlretrieve
from depccg.instance_models import MODEL_DIRECTORY
URL = 'https://qnlp.cambridgequantum.com/models/tri_headfirst.tar.gz'
print('Please consider using Bobcat, the parser included with lambeq,\n'
'instead of depccg.')
def print_progress(chunk: int, chunk_size: int, size: int) -> None:
percentage = chunk * chunk_size / size
mb_size = size / 10**6
print(f'\rDownloading model... {percentage:.1%} of {mb_size:.1f} MB',
end='')
print(MODEL_DIRECTORY)
print('Downloading model...', end='')
download, _ = urlretrieve(URL, reporthook=print_progress)
print('\nExtracting model...')
tarfile.open(download).extractall(MODEL_DIRECTORY)
print('Download successful')
|
https://github.com/BryceFuller/qiskit_camp
|
BryceFuller
|
%matplotlib inline
import xarray as xr
import seaborn as sns
import matplotlib.pyplot as plt
get_ipython().run_line_magic('pylab', 'inline')
#sns.set_style("darkgrid")
pylab.rcParams['figure.figsize'] = (16, 8)
pylab.rcParams.update({'font.size': 10})
df = xr.open_dataset("../experiment_results/experiments_20190301-052407.h5").squeeze()
df
sns.lineplot(x='iteration', y='fidelity', hue='n_layers', data=df.fidelity.sel(n_shots=1000).to_dataframe().reset_index())
plt.legend(df.n_layers.values)
plt.title("Fidelity improvement with optimiser iterations. (Two determinants with four qubits)")
df.fidelity.max(dim="iteration").mean(dim='run')#.mean(dim='n_layers')
sns.boxenplot(orient='h', x='fidelity', y='n_layers', data=df.fidelity.max(dim='iteration').squeeze().to_dataframe().reset_index())
df.fidelity.max(dim='iteration').squeeze()
|
https://github.com/qiskit-community/qiskit-aqt-provider
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019, Alpine Quantum Technologies GmbH 2022.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from numpy import pi
from qiskit import QuantumCircuit
from typing_extensions import assert_never
from qiskit_aqt_provider import api_models, api_models_generated
def qiskit_to_aqt_circuit(circuit: QuantumCircuit) -> api_models.Circuit:
"""Convert a Qiskit `QuantumCircuit` into a payload for AQT's quantum_circuit job type.
Args:
circuit: Qiskit circuit to convert.
Returns:
AQT API circuit payload.
"""
ops: list[api_models.OperationModel] = []
num_measurements = 0
for instruction in circuit.data:
if instruction.operation.name != "measure" and num_measurements > 0:
raise ValueError(
"Measurement operations can only be located at the end of the circuit."
)
if instruction.operation.name == "rz":
(phi,) = instruction.operation.params
(qubit,) = instruction.qubits
ops.append(
api_models.Operation.rz(
phi=float(phi) / pi,
qubit=circuit.find_bit(qubit).index,
)
)
elif instruction.operation.name == "r":
theta, phi = instruction.operation.params
(qubit,) = instruction.qubits
ops.append(
api_models.Operation.r(
phi=float(phi) / pi,
theta=float(theta) / pi,
qubit=circuit.find_bit(qubit).index,
)
)
elif instruction.operation.name == "rxx":
(theta,) = instruction.operation.params
q0, q1 = instruction.qubits
ops.append(
api_models.Operation.rxx(
theta=float(theta) / pi,
qubits=[circuit.find_bit(q0).index, circuit.find_bit(q1).index],
)
)
elif instruction.operation.name == "measure":
num_measurements += 1
elif instruction.operation.name == "barrier":
continue
else:
raise ValueError(
f"Operation '{instruction.operation.name}' not in basis gate set: {{rz, r, rxx}}"
)
if not num_measurements:
raise ValueError("Circuit must have at least one measurement operation.")
ops.append(api_models.Operation.measure())
return api_models.Circuit(root=ops)
def aqt_to_qiskit_circuit(circuit: api_models.Circuit, number_of_qubits: int) -> QuantumCircuit:
"""Convert an AQT API quantum circuit payload to an equivalent Qiskit representation.
Args:
circuit: payload to convert
number_of_qubits: size of the quantum register to use for the converted circuit.
Returns:
A :class:`QuantumCircuit <qiskit.circuit.quantumcircuit.QuantumCircuit>` equivalent
to the passed circuit payload.
"""
qiskit_circuit = QuantumCircuit(number_of_qubits)
for operation in circuit.root:
if isinstance(operation.root, api_models_generated.GateRZ):
qiskit_circuit.rz(operation.root.phi * pi, operation.root.qubit)
elif isinstance(operation.root, api_models_generated.GateR):
qiskit_circuit.r(
operation.root.theta * pi,
operation.root.phi * pi,
operation.root.qubit,
)
elif isinstance(operation.root, api_models_generated.GateRXX):
qiskit_circuit.rxx(
operation.root.theta * pi, *[mod.root for mod in operation.root.qubits]
)
elif isinstance(operation.root, api_models_generated.Measure):
qiskit_circuit.measure_all()
else:
assert_never(operation.root) # pragma: no cover
return qiskit_circuit
def circuits_to_aqt_job(circuits: list[QuantumCircuit], shots: int) -> api_models.SubmitJobRequest:
"""Convert a list of circuits to the corresponding AQT API job request payload.
Args:
circuits: circuits to execute
shots: number of repetitions per circuit.
Returns:
JobSubmission: AQT API payload for submitting the quantum circuits job.
"""
return api_models.SubmitJobRequest(
job_type="quantum_circuit",
label="qiskit",
payload=api_models.QuantumCircuits(
circuits=[
api_models.QuantumCircuit(
repetitions=shots,
quantum_circuit=qiskit_to_aqt_circuit(circuit),
number_of_qubits=circuit.num_qubits,
)
for circuit in circuits
]
),
)
|
https://github.com/qiskit-community/qiskit_rng
|
qiskit-community
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# (C) Copyright CQC 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the Programs
# directory of this source or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Module for random number generator."""
import logging
import pickle
import uuid
import os
from itertools import product
from typing import List, Tuple, Callable, Optional, Any, Union
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.providers.basebackend import BaseBackend
from qiskit.providers.basejob import BaseJob
from qiskit.providers.ibmq.ibmqbackend import IBMQBackend
from qiskit.providers.ibmq.managed.ibmqjobmanager import IBMQJobManager, ManagedJobSet
from qiskit.providers.ibmq.accountprovider import AccountProvider
from .generator_job import GeneratorJob
from .utils import generate_wsr
try:
from qiskit.providers.backend import Backend
HAS_V2_BACKEND = True
except ImportError:
HAS_V2_BACKEND = False
logger = logging.getLogger(__name__)
class Generator:
"""Class for generating random numbers.
You can use the :meth:`sample` method to run quantum circuits on a backend
to generate random bits. When the circuit jobs finish and their results
processed, you can examine the generated random bits as well as the
bell values. An example of this flow::
from qiskit import IBMQ
from qiskit_rng import Generator
provider = IBMQ.load_account()
generator = Generator(backend=provider.backends.ibmq_valencia)
output = generator.sample(num_raw_bits=1024).block_until_ready()
print("Mermin correlator value is {}".format(output.mermin_correlator))
print("first 8 raw bits are {}".format(output.raw_bits[:8]))
Note that due to the way the circuits are constructed and executed, the resulting
size of ``raw_bits`` might be slightly larger than the input ``num_raw_bits``.
The bits generated by the :meth:`sample` method are only weakly random. You
will need to apply a randomness extractor to this output in order to obtain
a more uniformly distributed string of random bits.
"""
_file_prefix = "qiskit_rng"
_job_tag = 'qiskit_rng'
def __init__(
self,
backend: BaseBackend,
wsr_generator: Optional[Callable] = None,
noise_model: Any = None,
save_local: bool = False
) -> None:
"""Generator constructor.
Args:
backend: Backend to use for generating random numbers.
wsr_generator: Function used to generate WSR. It must take the
number of bits as the input and a list of random bits (0s and 1s)
as the output. If ``None``, :func:`qiskit_rng.generate_wsr` is used.
noise_model: Noise model to use. Only applicable if `backend` is a
simulator.
save_local: If ``True``, the generated WSR and other metadata is
saved into a pickle file in the local directory. The file can
be used to recover and resume a sampling if needed.
The file name will be in the format of
``qiskit_rng_<backend>_<num_raw_bits>_<id>``.
The file will be deleted automatically when the corresponding
:meth:`GeneratorJob.block_until_ready()` method is invoked.
Only supported if `backend` is an ``IBMQBackend``.
"""
self.backend = backend
self.job_manager = IBMQJobManager()
self.wsr_generator = wsr_generator or generate_wsr
self.noise_model = noise_model
self.save_local = save_local
def sample(
self,
num_raw_bits: int
) -> GeneratorJob:
"""Use the target system to generate raw bit strings.
Args:
num_raw_bits: Number of raw bits to sample. Note that the raw
bits are only weakly random and needs to go through extraction
to generate highly random output.
Returns:
A :class:`GeneratorJob` instance that contains all the information
needed to extract randomness.
Raises:
ValueError: If an input argument is invalid.
"""
if not isinstance(self.backend, BaseBackend) and \
(HAS_V2_BACKEND and not isinstance(self.backend, Backend)):
raise ValueError("Backend needs to be a Qiskit `BaseBackend` or `Backend` instance.")
max_shots = self.backend.configuration().max_shots
num_raw_bits_qubit = int((num_raw_bits + 2)/3)
if num_raw_bits_qubit <= max_shots:
shots = num_raw_bits_qubit
num_circuits = 1
else:
num_circuits = int((num_raw_bits_qubit + max_shots - 1)/max_shots)
shots = int((num_raw_bits_qubit + num_circuits - 1)/num_circuits)
logger.debug("Using %s circuits with %s shots each", num_circuits, shots)
initial_wsr = self.wsr_generator(num_circuits * 3)
wsr_bits = self._get_wsr(num_circuits, initial_wsr)
circuits = self._generate_all_circuits(num_circuits, wsr_bits)
job = self._run_circuits(circuits, shots)
saved_fn = None
if self.save_local and isinstance(self.backend, IBMQBackend):
saved_fn = self._save_local(num_raw_bits, wsr_bits, job, shots)
return GeneratorJob(
initial_wsr=initial_wsr,
wsr=wsr_bits,
job=job,
shots=shots,
saved_fn=saved_fn
)
def _run_circuits(
self,
circuits: List[QuantumCircuit],
shots: int
) -> Union[ManagedJobSet, BaseJob]:
"""Run circuits on a backend.
Args:
circuits: Circuits to run.
shots: Number of shots.
Returns:
An IBMQ managed job set or a job.
"""
transpiled = transpile(circuits, backend=self.backend, optimization_level=2)
transpiled = [transpiled] if not isinstance(transpiled, list) else transpiled
if isinstance(self.backend, IBMQBackend):
job = self.job_manager.run(transpiled, backend=self.backend, shots=shots,
job_tags=[self._job_tag], memory=True)
logger.info("Jobs submitted to %s. Job set ID is %s.", self.backend, job.job_set_id())
else:
job = self.backend.run(assemble(transpiled, backend=self.backend, shots=shots,
memory=True, noise_model=self.noise_model))
logger.info("Jobs submitted to %s. Job ID is %s.", self.backend, job.job_id())
return job
def _get_wsr(self, num_circuits: int, initial_wsr: List[int]) -> List:
"""Obtain the weak source of randomness bits used to generate circuits.
Args:
num_circuits: Number of circuits.
initial_wsr: Raw WSR bits used to generate the output WSR.
Returns:
A list the size of `num_circuits`. Each element in the
list is another list of 3 binary numbers.
For example,
[ [1, 0, 0], [0, 1, 1], [1, 1, 0], ...]
"""
output_wsr = []
for i in range(num_circuits):
output_wsr.append(
[int(initial_wsr[3*i]), int(initial_wsr[3*i+1]), int(initial_wsr[3*i+2])])
return output_wsr
def _generate_circuit(self, label: Tuple[int, int, int]) -> QuantumCircuit:
"""Generate a circuit based on the input label.
The size of the input label determines the number of qubits.
An ``sdg`` is added to the circuit for the qubit if the corresponding
label value is a ``1``.
Args:
label: Label used to determine how the circuit is to be constructed.
A tuple of 1s and 0s.
Returns:
Constructed circuit.
"""
num_qubit = len(label)
qc = QuantumCircuit(num_qubit, num_qubit)
qc.h(0)
for i in range(1, num_qubit):
qc.cx(0, i)
qc.s(0)
qc.barrier()
for i in range(num_qubit):
if label[i] == 1:
qc.sdg(i)
for i in range(num_qubit):
qc.h(i)
qc.measure(qc.qregs[0], qc.cregs[0])
return qc
def _generate_all_circuits(self, num_circuits: int, wsr_bits: List) -> List[QuantumCircuit]:
"""Generate all circuits based on input WSR bits.
Args:
num_circuits: Number of circuits to generate.
wsr_bits: WSR bits used to determine which circuits to use.
Returns:
A list of generated circuits.
"""
# Generate 3-qubit circuits for each of the 8 permutations.
num_qubits = 3
labels = list(product([0, 1], repeat=num_qubits))
# Generate base circuits.
circuits = []
for label in labels:
circuits.append(self._generate_circuit(label))
# Construct final circuits using input WSR bits.
final_circuits = []
for i in range(num_circuits):
wsr_set = wsr_bits[i] # Get the 3-bit value.
final_circuits.append(circuits[labels.index(tuple(wsr_set))])
return final_circuits
def _save_local(
self,
num_raw_bits: int,
wsr_bits: List,
job: Union[ManagedJobSet, BaseJob],
shots: int
) -> str:
"""Save context information for the sampling.
Args:
num_raw_bits: Number of raw bits requested.
wsr_bits: WSR bits to save.
job: Job whose ID is to be saved.
shots: Number of shots.
Returns:
Name of the file with saved data.
"""
file_prefix = "{}_{}_{}_".format(
self._file_prefix, self.backend.name(), num_raw_bits)
file_name = file_prefix + str(uuid.uuid4())[:4]
while os.path.exists(file_name):
file_name = file_prefix + str(uuid.uuid4())[:4]
data = {"wsr": wsr_bits, "shots": shots}
if isinstance(job, ManagedJobSet):
data["job_id"] = job.job_set_id()
data["job_type"] = "jobset"
else:
data["job_id"] = job.job_id()
data["job_type"] = "job"
with open(file_name, 'wb') as file:
pickle.dump(data, file)
return file_name
@classmethod
def recover(cls, file_name: str, provider: AccountProvider) -> GeneratorJob:
"""Recover a previously saved sampling run.
Args:
file_name: Name of the file containing saved context.
provider: Provider used to do the sampling.
Returns:
Recovered output of the original :meth:`sample` call.
"""
with open(file_name, 'rb') as file:
data = pickle.load(file)
job_id = data['job_id']
job_type = data['job_type']
if job_type == "jobset":
job = IBMQJobManager().retrieve_job_set(job_id, provider)
else:
job = provider.backends.retrieve_job(job_id)
return GeneratorJob(
initial_wsr=[],
wsr=data['wsr'],
job=job,
shots=data["shots"],
saved_fn=file_name
)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit.optimization import QuadraticProgram
from docplex.mp.advmodel import AdvModel
from docplex.mp.model_reader import ModelReader
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from dwave.plugins.qiskit import DWaveMinimumEigensolver
from dwave.system import DWaveCliqueSampler, LeapHybridSampler
import numpy as np
model = ModelReader.read(filename='BURKARDT_DATA/BINARY/reid.lp',model_name = "Test_Bin_reid", model_class=AdvModel)
qp = QuadraticProgram()
qp.from_docplex(model)
dwave_solver_hybrid = DWaveMinimumEigensolver(sampler = LeapHybridSampler())
optimizer = MinimumEigenOptimizer(dwave_solver_hybrid)
result = optimizer.solve(qp) # Problem ID : 8f677f6a-7c23-481c-ad1e-e2887cc8758f
result
print(qp.export_as_lp_string())
# Use D-Wave QPU as a minimum eigen solver
# See https://github.com/dwavesystems/dwave-qiskit-plugin
num_reads = 1000
cliqueSampler = DWaveCliqueSampler()
dwave_solver_clique = DWaveMinimumEigensolver(sampler = cliqueSampler, num_reads = num_reads)
optimizer = MinimumEigenOptimizer(dwave_solver_clique)
result = optimizer.solve(qp) # Problem ID : 74108957-e013-40d5-a7ff-e88c9c552ab2
result
result.min_eigen_solver_result.sampleset.to_pandas_dataframe()
model = ModelReader.read(filename='BURKARDT_DATA/BINARY/two_by_four.lp',model_name = "Test_Bin_16", model_class=AdvModel)
qp = QuadraticProgram()
qp.from_docplex(model)
optimizer_hybrid = MinimumEigenOptimizer(dwave_solver_hybrid)
result = optimizer_hybrid.solve(qp) # Problem ID : 1270f318-2655-4417-a2de-5daf6c4e017a
result
result = optimizer.solve(qp) # Problem ID : 93df81b0-9ca4-450e-a921-edf22bd6b5ee
result
result.min_eigen_solver_result.sampleset.to_pandas_dataframe()
model.solve()
|
https://github.com/ahkatlio/QHSO_Basics_of_Qiskit
|
ahkatlio
|
#Assign these values as per your requirements.
global min_qubits,max_qubits,skip_qubits,max_circuits,num_shots,Noise_Inclusion
min_qubits=3
max_qubits=31
skip_qubits=1
max_circuits=2
num_shots=1000
method=1 #Use method=2 for another approach of Benchmarking (default->1)
num_resets = 2 # Variable for number of resets to perform after mid circuit measurements (default->1) Only for method-2
input_value=None #assign any number to it to perform benchmark for that number.(Default->None)
Noise_Inclusion = False
saveplots = False
Memory_utilization_plot = True
gate_counts_plots = True
Type_of_Simulator = "built_in" #Inputs are "built_in" or "FAKE" or "FAKEV2"
backend_name = "FakeGuadalupeV2"
#Change your Specification of Simulator in Declaring Backend Section
#By Default : built_in -> qasm_simulator and FAKE -> FakeSantiago() and FAKEV2 -> FakeSantiagoV2()
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, transpile, execute
import time
import matplotlib.pyplot as plt
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (NoiseModel, QuantumError, ReadoutError,pauli_error, depolarizing_error, thermal_relaxation_error,reset_error)
benchmark_name = "Bernstein-Vazirani"
# Selection of basis gate set for transpilation
# Note: selector 1 is a hardware agnostic gate set
basis_selector = 1
basis_gates_array = [
[],
['rx', 'ry', 'rz', 'cx'], # a common basis set, default
['cx', 'rz', 'sx', 'x'], # IBM default basis set
['rx', 'ry', 'rxx'], # IonQ default basis set
['h', 'p', 'cx'], # another common basis set
['u', 'cx'] # general unitaries basis gates
]
np.random.seed(0)
def get_QV(backend):
import json
# Assuming backend.conf_filename is the filename and backend.dirname is the directory path
conf_filename = backend.dirname + "/" + backend.conf_filename
# Open the JSON file
with open(conf_filename, 'r') as file:
# Load the JSON data
data = json.load(file)
# Extract the quantum_volume parameter
QV = data.get('quantum_volume', None)
return QV
def checkbackend(backend_name,Type_of_Simulator):
if Type_of_Simulator == "built_in":
available_backends = []
for i in Aer.backends():
available_backends.append(i.name)
if backend_name in available_backends:
platform = backend_name
return platform
else:
print(f"incorrect backend name or backend not available. Using qasm_simulator by default !!!!")
print(f"available backends are : {available_backends}")
platform = "qasm_simulator"
return platform
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2":
import qiskit.providers.fake_provider as fake_backends
if hasattr(fake_backends,backend_name) is True:
print(f"Backend {backend_name} is available for type {Type_of_Simulator}.")
backend_class = getattr(fake_backends,backend_name)
backend_instance = backend_class()
return backend_instance
else:
print(f"Backend {backend_name} is not available or incorrect for type {Type_of_Simulator}. Executing with FakeSantiago!!!")
if Type_of_Simulator == "FAKEV2":
backend_class = getattr(fake_backends,"FakeSantiagoV2")
else:
backend_class = getattr(fake_backends,"FakeSantiago")
backend_instance = backend_class()
return backend_instance
if Type_of_Simulator == "built_in":
platform = checkbackend(backend_name,Type_of_Simulator)
#By default using "Qasm Simulator"
backend = Aer.get_backend(platform)
QV_=None
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"backend version is {backend.backend_version}")
elif Type_of_Simulator == "FAKE":
basis_selector = 0
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.properties().backend_name +"-"+ backend.properties().backend_version #Replace this string with the backend Provider's name as this is used for Plotting.
max_qubits=backend.configuration().n_qubits
print(f"{platform} device is capable of running {backend.configuration().n_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
elif Type_of_Simulator == "FAKEV2":
basis_selector = 0
if "V2" not in backend_name:
backend_name = backend_name+"V2"
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.name +"-" +backend.backend_version
max_qubits=backend.num_qubits
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
else:
print("Enter valid Simulator.....")
# saved circuits for display
QC_ = None
Uf_ = None
############### Circuit Definition
def create_oracle(num_qubits, input_size, secret_int):
# Initialize first n qubits and single ancilla qubit
qr = QuantumRegister(num_qubits)
qc = QuantumCircuit(qr, name="Uf")
# perform CX for each qubit that matches a bit in secret string
s = ('{0:0' + str(input_size) + 'b}').format(secret_int)
print("s = ",s)
print("input size in oracle =",input_size)
for i_qubit in range(input_size):
if s[input_size - 1 - i_qubit] == '1':
qc.cx(qr[i_qubit], qr[input_size])
return qc
def BersteinVazirani (num_qubits, secret_int, method = 1):
# size of input is one less than available qubits
input_size = num_qubits - 1
if method == 1:
# allocate qubits
qr = QuantumRegister(num_qubits); cr = ClassicalRegister(input_size)
qc = QuantumCircuit(qr, cr, name=f"bv({method})-{num_qubits}-{secret_int}")
# put ancilla in |1> state
qc.x(qr[input_size])
# start with Hadamard on all qubits, including ancilla
for i_qubit in range(num_qubits):
qc.h(qr[i_qubit])
qc.barrier()
#generate Uf oracle
Uf = create_oracle(num_qubits, input_size, secret_int)
qc.append(Uf,qr)
qc.barrier()
# start with Hadamard on all qubits, including ancilla
for i_qubit in range(num_qubits):
qc.h(qr[i_qubit])
# uncompute ancilla qubit, not necessary for algorithm
qc.x(qr[input_size])
qc.barrier()
# measure all data qubits
for i in range(input_size):
qc.measure(i, i)
global Uf_
if Uf_ == None or num_qubits <= 6:
if num_qubits < 9: Uf_ = Uf
elif method == 2:
# allocate qubits
qr = QuantumRegister(2); cr = ClassicalRegister(input_size); qc = QuantumCircuit(qr, cr, name="main")
# put ancilla in |-> state
qc.x(qr[1])
qc.h(qr[1])
qc.barrier()
# perform CX for each qubit that matches a bit in secret string
s = ('{0:0' + str(input_size) + 'b}').format(secret_int)
for i in range(input_size):
if s[input_size - 1 - i] == '1':
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.h(qr[0])
qc.measure(qr[0], cr[i])
# Perform num_resets reset operations
qc.reset([0]*num_resets)
# save smaller circuit example for display
global QC_
if QC_ == None or num_qubits <= 6:
if num_qubits < 9: QC_ = qc
# return a handle on the circuit
return qc
# Create an empty noise model
noise_parameters = NoiseModel()
if Type_of_Simulator == "built_in":
# Add depolarizing error to all single qubit gates with error rate 0.05% and to all two qubit gates with error rate 0.5%
depol_one_qb_error = 0.05
depol_two_qb_error = 0.005
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_two_qb_error, 2), ['cx'])
# Add amplitude damping error to all single qubit gates with error rate 0.0% and to all two qubit gates with error rate 0.0%
amp_damp_one_qb_error = 0.0
amp_damp_two_qb_error = 0.0
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_two_qb_error, 2), ['cx'])
# Add reset noise to all single qubit resets
reset_to_zero_error = 0.005
reset_to_one_error = 0.005
noise_parameters.add_all_qubit_quantum_error(reset_error(reset_to_zero_error, reset_to_one_error),["reset"])
# Add readout error
p0given1_error = 0.000
p1given0_error = 0.000
error_meas = ReadoutError([[1 - p1given0_error, p1given0_error], [p0given1_error, 1 - p0given1_error]])
noise_parameters.add_all_qubit_readout_error(error_meas)
#print(noise_parameters)
elif Type_of_Simulator == "FAKE"or"FAKEV2":
noise_parameters = NoiseModel.from_backend(backend)
#print(noise_parameters)
## Uniform distribution function commonly used
def rescale_fidelity(fidelity, floor_fidelity, new_floor_fidelity):
"""
Linearly rescales our fidelities to allow comparisons of fidelities across benchmarks
fidelity: raw fidelity to rescale
floor_fidelity: threshold fidelity which is equivalent to random guessing
new_floor_fidelity: what we rescale the floor_fidelity to
Ex, with floor_fidelity = 0.25, new_floor_fidelity = 0.0:
1 -> 1;
0.25 -> 0;
0.5 -> 0.3333;
"""
rescaled_fidelity = (1-new_floor_fidelity)/(1-floor_fidelity) * (fidelity - 1) + 1
# ensure fidelity is within bounds (0, 1)
if rescaled_fidelity < 0:
rescaled_fidelity = 0.0
if rescaled_fidelity > 1:
rescaled_fidelity = 1.0
return rescaled_fidelity
def uniform_dist(num_state_qubits):
dist = {}
for i in range(2**num_state_qubits):
key = bin(i)[2:].zfill(num_state_qubits)
dist[key] = 1/(2**num_state_qubits)
return dist
### Analysis methods to be expanded and eventually compiled into a separate analysis.py file
import math, functools
def hellinger_fidelity_with_expected(p, q):
""" p: result distribution, may be passed as a counts distribution
q: the expected distribution to be compared against
References:
`Hellinger Distance @ wikipedia <https://en.wikipedia.org/wiki/Hellinger_distance>`_
Qiskit Hellinger Fidelity Function
"""
p_sum = sum(p.values())
q_sum = sum(q.values())
if q_sum == 0:
print("ERROR: polarization_fidelity(), expected distribution is invalid, all counts equal to 0")
return 0
p_normed = {}
for key, val in p.items():
p_normed[key] = val/p_sum
# if p_sum != 0:
# p_normed[key] = val/p_sum
# else:
# p_normed[key] = 0
q_normed = {}
for key, val in q.items():
q_normed[key] = val/q_sum
total = 0
for key, val in p_normed.items():
if key in q_normed.keys():
total += (np.sqrt(val) - np.sqrt(q_normed[key]))**2
del q_normed[key]
else:
total += val
total += sum(q_normed.values())
# in some situations (error mitigation) this can go negative, use abs value
if total < 0:
print(f"WARNING: using absolute value in fidelity calculation")
total = abs(total)
dist = np.sqrt(total)/np.sqrt(2)
fidelity = (1-dist**2)**2
return fidelity
def polarization_fidelity(counts, correct_dist, thermal_dist=None):
"""
Combines Hellinger fidelity and polarization rescaling into fidelity calculation
used in every benchmark
counts: the measurement outcomes after `num_shots` algorithm runs
correct_dist: the distribution we expect to get for the algorithm running perfectly
thermal_dist: optional distribution to pass in distribution from a uniform
superposition over all states. If `None`: generated as
`uniform_dist` with the same qubits as in `counts`
returns both polarization fidelity and the hellinger fidelity
Polarization from: `https://arxiv.org/abs/2008.11294v1`
"""
num_measured_qubits = len(list(correct_dist.keys())[0])
#print(num_measured_qubits)
counts = {k.zfill(num_measured_qubits): v for k, v in counts.items()}
# calculate hellinger fidelity between measured expectation values and correct distribution
hf_fidelity = hellinger_fidelity_with_expected(counts,correct_dist)
# to limit cpu and memory utilization, skip noise correction if more than 16 measured qubits
if num_measured_qubits > 16:
return { 'fidelity':hf_fidelity, 'hf_fidelity':hf_fidelity }
# if not provided, generate thermal dist based on number of qubits
if thermal_dist == None:
thermal_dist = uniform_dist(num_measured_qubits)
# set our fidelity rescaling value as the hellinger fidelity for a depolarized state
floor_fidelity = hellinger_fidelity_with_expected(thermal_dist, correct_dist)
# rescale fidelity result so uniform superposition (random guessing) returns fidelity
# rescaled to 0 to provide a better measure of success of the algorithm (polarization)
new_floor_fidelity = 0
fidelity = rescale_fidelity(hf_fidelity, floor_fidelity, new_floor_fidelity)
return { 'fidelity':fidelity, 'hf_fidelity':hf_fidelity }
from matplotlib.patches import Rectangle
import matplotlib.cm as cm
from matplotlib.colors import ListedColormap, LinearSegmentedColormap, Normalize
from matplotlib.patches import Circle
############### Color Map functions
# Create a selection of colormaps from which to choose; default to custom_spectral
cmap_spectral = plt.get_cmap('Spectral')
cmap_greys = plt.get_cmap('Greys')
cmap_blues = plt.get_cmap('Blues')
cmap_custom_spectral = None
# the default colormap is the spectral map
cmap = cmap_spectral
cmap_orig = cmap_spectral
# current cmap normalization function (default None)
cmap_norm = None
default_fade_low_fidelity_level = 0.16
default_fade_rate = 0.7
# Specify a normalization function here (default None)
def set_custom_cmap_norm(vmin, vmax):
global cmap_norm
if vmin == vmax or (vmin == 0.0 and vmax == 1.0):
print("... setting cmap norm to None")
cmap_norm = None
else:
print(f"... setting cmap norm to [{vmin}, {vmax}]")
cmap_norm = Normalize(vmin=vmin, vmax=vmax)
# Remake the custom spectral colormap with user settings
def set_custom_cmap_style(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
#print("... set custom map style")
global cmap, cmap_custom_spectral, cmap_orig
cmap_custom_spectral = create_custom_spectral_cmap(
fade_low_fidelity_level=fade_low_fidelity_level, fade_rate=fade_rate)
cmap = cmap_custom_spectral
cmap_orig = cmap_custom_spectral
# Create the custom spectral colormap from the base spectral
def create_custom_spectral_cmap(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
# determine the breakpoint from the fade level
num_colors = 100
breakpoint = round(fade_low_fidelity_level * num_colors)
# get color list for spectral map
spectral_colors = [cmap_spectral(v/num_colors) for v in range(num_colors)]
#print(fade_rate)
# create a list of colors to replace those below the breakpoint
# and fill with "faded" color entries (in reverse)
low_colors = [0] * breakpoint
#for i in reversed(range(breakpoint)):
for i in range(breakpoint):
# x is index of low colors, normalized 0 -> 1
x = i / breakpoint
# get color at this index
bc = spectral_colors[i]
r0 = bc[0]
g0 = bc[1]
b0 = bc[2]
z0 = bc[3]
r_delta = 0.92 - r0
#print(f"{x} {bc} {r_delta}")
# compute saturation and greyness ratio
sat_ratio = 1 - x
#grey_ratio = 1 - x
''' attempt at a reflective gradient
if i >= breakpoint/2:
xf = 2*(x - 0.5)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (yf + 0.5)
else:
xf = 2*(0.5 - x)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (0.5 - yf)
'''
grey_ratio = 1 - math.pow(x, 1/fade_rate)
#print(f" {xf} {yf} ")
#print(f" {sat_ratio} {grey_ratio}")
r = r0 + r_delta * sat_ratio
g_delta = r - g0
b_delta = r - b0
g = g0 + g_delta * grey_ratio
b = b0 + b_delta * grey_ratio
#print(f"{r} {g} {b}\n")
low_colors[i] = (r,g,b,z0)
#print(low_colors)
# combine the faded low colors with the regular spectral cmap to make a custom version
cmap_custom_spectral = ListedColormap(low_colors + spectral_colors[breakpoint:])
#spectral_colors = [cmap_custom_spectral(v/10) for v in range(10)]
#for i in range(10): print(spectral_colors[i])
#print("")
return cmap_custom_spectral
# Make the custom spectral color map the default on module init
set_custom_cmap_style()
# Arrange the stored annotations optimally and add to plot
def anno_volumetric_data(ax, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True):
# sort all arrays by the x point of the text (anno_offs)
global x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos
all_annos = sorted(zip(x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos))
x_anno_offs = [a for a,b,c,d,e in all_annos]
y_anno_offs = [b for a,b,c,d,e in all_annos]
anno_labels = [c for a,b,c,d,e in all_annos]
x_annos = [d for a,b,c,d,e in all_annos]
y_annos = [e for a,b,c,d,e in all_annos]
#print(f"{x_anno_offs}")
#print(f"{y_anno_offs}")
#print(f"{anno_labels}")
for i in range(len(anno_labels)):
x_anno = x_annos[i]
y_anno = y_annos[i]
x_anno_off = x_anno_offs[i]
y_anno_off = y_anno_offs[i]
label = anno_labels[i]
if i > 0:
x_delta = abs(x_anno_off - x_anno_offs[i - 1])
y_delta = abs(y_anno_off - y_anno_offs[i - 1])
if y_delta < 0.7 and x_delta < 2:
y_anno_off = y_anno_offs[i] = y_anno_offs[i - 1] - 0.6
#x_anno_off = x_anno_offs[i] = x_anno_offs[i - 1] + 0.1
ax.annotate(label,
xy=(x_anno+0.0, y_anno+0.1),
arrowprops=dict(facecolor='black', shrink=0.0,
width=0.5, headwidth=4, headlength=5, edgecolor=(0.8,0.8,0.8)),
xytext=(x_anno_off + labelpos[0], y_anno_off + labelpos[1]),
rotation=labelrot,
horizontalalignment='left', verticalalignment='baseline',
color=(0.2,0.2,0.2),
clip_on=True)
if saveplots == True:
plt.savefig("VolumetricPlotSample.jpg")
# Plot one group of data for volumetric presentation
def plot_volumetric_data(ax, w_data, d_data, f_data, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True, w_max=18, do_label=False, do_border=True,
x_size=1.0, y_size=1.0, zorder=1, offset_flag=False,
max_depth=0, suppress_low_fidelity=False):
# since data may come back out of order, save point at max y for annotation
i_anno = 0
x_anno = 0
y_anno = 0
# plot data rectangles
low_fidelity_count = True
last_y = -1
k = 0
# determine y-axis dimension for one pixel to use for offset of bars that start at 0
(_, dy) = get_pixel_dims(ax)
# do this loop in reverse to handle the case where earlier cells are overlapped by later cells
for i in reversed(range(len(d_data))):
x = depth_index(d_data[i], depth_base)
y = float(w_data[i])
f = f_data[i]
# each time we star a new row, reset the offset counter
# DEVNOTE: this is highly specialized for the QA area plots, where there are 8 bars
# that represent time starting from 0 secs. We offset by one pixel each and center the group
if y != last_y:
last_y = y;
k = 3 # hardcoded for 8 cells, offset by 3
#print(f"{i = } {x = } {y = }")
if max_depth > 0 and d_data[i] > max_depth:
#print(f"... excessive depth (2), skipped; w={y} d={d_data[i]}")
break;
# reject cells with low fidelity
if suppress_low_fidelity and f < suppress_low_fidelity_level:
if low_fidelity_count: break
else: low_fidelity_count = True
# the only time this is False is when doing merged gradation plots
if do_border == True:
# this case is for an array of x_sizes, i.e. each box has different width
if isinstance(x_size, list):
# draw each of the cells, with no offset
if not offset_flag:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size[i], y_size=y_size, zorder=zorder))
# use an offset for y value, AND account for x and width to draw starting at 0
else:
ax.add_patch(box_at((x/2 + x_size[i]/4), y + k*dy, f, type=type, fill=fill, x_size=x+ x_size[i]/2, y_size=y_size, zorder=zorder))
# this case is for only a single cell
else:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size, y_size=y_size))
# save the annotation point with the largest y value
if y >= y_anno:
x_anno = x
y_anno = y
i_anno = i
# move the next bar down (if using offset)
k -= 1
# if no data rectangles plotted, no need for a label
if x_anno == 0 or y_anno == 0:
return
x_annos.append(x_anno)
y_annos.append(y_anno)
anno_dist = math.sqrt( (y_anno - 1)**2 + (x_anno - 1)**2 )
# adjust radius of annotation circle based on maximum width of apps
anno_max = 10
if w_max > 10:
anno_max = 14
if w_max > 14:
anno_max = 18
scale = anno_max / anno_dist
# offset of text from end of arrow
if scale > 1:
x_anno_off = scale * x_anno - x_anno - 0.5
y_anno_off = scale * y_anno - y_anno
else:
x_anno_off = 0.7
y_anno_off = 0.5
x_anno_off += x_anno
y_anno_off += y_anno
# print(f"... {xx} {yy} {anno_dist}")
x_anno_offs.append(x_anno_off)
y_anno_offs.append(y_anno_off)
anno_labels.append(label)
if do_label:
ax.annotate(label, xy=(x_anno+labelpos[0], y_anno+labelpos[1]), rotation=labelrot,
horizontalalignment='left', verticalalignment='bottom', color=(0.2,0.2,0.2))
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# init arrays to hold annotation points for label spreading
def vplot_anno_init ():
global x_annos, y_annos, x_anno_offs, y_anno_offs, anno_labels
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# Number of ticks on volumetric depth axis
max_depth_log = 22
# average transpile factor between base QV depth and our depth based on results from QV notebook
QV_transpile_factor = 12.7
# format a number using K,M,B,T for large numbers, optionally rounding to 'digits' decimal places if num > 1
# (sign handling may be incorrect)
def format_number(num, digits=0):
if isinstance(num, str): num = float(num)
num = float('{:.3g}'.format(abs(num)))
sign = ''
metric = {'T': 1000000000000, 'B': 1000000000, 'M': 1000000, 'K': 1000, '': 1}
for index in metric:
num_check = num / metric[index]
if num_check >= 1:
num = round(num_check, digits)
sign = index
break
numstr = f"{str(num)}"
if '.' in numstr:
numstr = numstr.rstrip('0').rstrip('.')
return f"{numstr}{sign}"
# Return the color associated with the spcific value, using color map norm
def get_color(value):
# if there is a normalize function installed, scale the data
if cmap_norm:
value = float(cmap_norm(value))
if cmap == cmap_spectral:
value = 0.05 + value*0.9
elif cmap == cmap_blues:
value = 0.00 + value*1.0
else:
value = 0.0 + value*0.95
return cmap(value)
# Return the x and y equivalent to a single pixel for the given plot axis
def get_pixel_dims(ax):
# transform 0 -> 1 to pixel dimensions
pixdims = ax.transData.transform([(0,1),(1,0)])-ax.transData.transform((0,0))
xpix = pixdims[1][0]
ypix = pixdims[0][1]
#determine x- and y-axis dimension for one pixel
dx = (1 / xpix)
dy = (1 / ypix)
return (dx, dy)
############### Helper functions
# return the base index for a circuit depth value
# take the log in the depth base, and add 1
def depth_index(d, depth_base):
if depth_base <= 1:
return d
if d == 0:
return 0
return math.log(d, depth_base) + 1
# draw a box at x,y with various attributes
def box_at(x, y, value, type=1, fill=True, x_size=1.0, y_size=1.0, alpha=1.0, zorder=1):
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Rectangle((x - (x_size/2), y - (y_size/2)), x_size, y_size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5*y_size,
zorder=zorder)
# draw a circle at x,y with various attributes
def circle_at(x, y, value, type=1, fill=True):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Circle((x, y), size/2,
alpha = 0.7, # DEVNOTE: changed to 0.7 from 0.5, to handle only one cell
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5)
def box4_at(x, y, value, type=1, fill=True, alpha=1.0):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.3,0.3,0.3)
ec = fc
return Rectangle((x - size/8, y - size/2), size/4, size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.1)
# Draw a Quantum Volume rectangle with specified width and depth, and grey-scale value
def qv_box_at(x, y, qv_width, qv_depth, value, depth_base):
#print(f"{qv_width} {qv_depth} {depth_index(qv_depth, depth_base)}")
return Rectangle((x - 0.5, y - 0.5), depth_index(qv_depth, depth_base), qv_width,
edgecolor = (value,value,value),
facecolor = (value,value,value),
fill=True,
lw=1)
def bkg_box_at(x, y, value=0.9):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (value,value,value),
fill=True,
lw=0.5)
def bkg_empty_box_at(x, y):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (1.0,1.0,1.0),
fill=True,
lw=0.5)
# Plot the background for the volumetric analysis
def plot_volumetric_background(max_qubits=11, QV=32, depth_base=2, suptitle=None, avail_qubits=0, colorbar_label="Avg Result Fidelity"):
if suptitle == None:
suptitle = f"Volumetric Positioning\nCircuit Dimensions and Fidelity Overlaid on Quantum Volume = {QV}"
QV0 = QV
qv_estimate = False
est_str = ""
if QV == 0: # QV = 0 indicates "do not draw QV background or label"
QV = 2048
elif QV < 0: # QV < 0 indicates "add est. to label"
QV = -QV
qv_estimate = True
est_str = " (est.)"
if avail_qubits > 0 and max_qubits > avail_qubits:
max_qubits = avail_qubits
max_width = 13
if max_qubits > 11: max_width = 18
if max_qubits > 14: max_width = 20
if max_qubits > 16: max_width = 24
if max_qubits > 24: max_width = 33
#print(f"... {avail_qubits} {max_qubits} {max_width}")
plot_width = 6.8
plot_height = 0.5 + plot_width * (max_width / max_depth_log)
#print(f"... {plot_width} {plot_height}")
# define matplotlib figure and axis; use constrained layout to fit colorbar to right
fig, ax = plt.subplots(figsize=(plot_width, plot_height), constrained_layout=True)
plt.suptitle(suptitle)
plt.xlim(0, max_depth_log)
plt.ylim(0, max_width)
# circuit depth axis (x axis)
xbasis = [x for x in range(1,max_depth_log)]
xround = [depth_base**(x-1) for x in xbasis]
xlabels = [format_number(x) for x in xround]
ax.set_xlabel('Circuit Depth')
ax.set_xticks(xbasis)
plt.xticks(xbasis, xlabels, color='black', rotation=45, ha='right', va='top', rotation_mode="anchor")
# other label options
#plt.xticks(xbasis, xlabels, color='black', rotation=-60, ha='left')
#plt.xticks(xbasis, xlabels, color='black', rotation=-45, ha='left', va='center', rotation_mode="anchor")
# circuit width axis (y axis)
ybasis = [y for y in range(1,max_width)]
yround = [1,2,3,4,5,6,7,8,10,12,15] # not used now
ylabels = [str(y) for y in yround] # not used now
#ax.set_ylabel('Circuit Width (Number of Qubits)')
ax.set_ylabel('Circuit Width')
ax.set_yticks(ybasis)
#create simple line plot (not used right now)
#ax.plot([0, 10],[0, 10])
log2QV = math.log2(QV)
QV_width = log2QV
QV_depth = log2QV * QV_transpile_factor
# show a quantum volume rectangle of QV = 64 e.g. (6 x 6)
if QV0 != 0:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.87, depth_base))
else:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.91, depth_base))
# the untranspiled version is commented out - we do not show this by default
# also show a quantum volume rectangle un-transpiled
# ax.add_patch(qv_box_at(1, 1, QV_width, QV_width, 0.80, depth_base))
# show 2D array of volumetric cells based on this QV_transpiled
# DEVNOTE: we use +1 only to make the visuals work; s/b without
# Also, the second arg of the min( below seems incorrect, needs correction
maxprod = (QV_width + 1) * (QV_depth + 1)
for w in range(1, min(max_width, round(QV) + 1)):
# don't show VB squares if width greater than known available qubits
if avail_qubits != 0 and w > avail_qubits:
continue
i_success = 0
for d in xround:
# polarization factor for low circuit widths
maxtest = maxprod / ( 1 - 1 / (2**w) )
# if circuit would fail here, don't draw box
if d > maxtest: continue
if w * d > maxtest: continue
# guess for how to capture how hardware decays with width, not entirely correct
# # reduce maxtext by a factor of number of qubits > QV_width
# # just an approximation to account for qubit distances
# if w > QV_width:
# over = w - QV_width
# maxtest = maxtest / (1 + (over/QV_width))
# draw a box at this width and depth
id = depth_index(d, depth_base)
# show vb rectangles; if not showing QV, make all hollow (or less dark)
if QV0 == 0:
#ax.add_patch(bkg_empty_box_at(id, w))
ax.add_patch(bkg_box_at(id, w, 0.95))
else:
ax.add_patch(bkg_box_at(id, w, 0.9))
# save index of last successful depth
i_success += 1
# plot empty rectangle after others
d = xround[i_success]
id = depth_index(d, depth_base)
ax.add_patch(bkg_empty_box_at(id, w))
# Add annotation showing quantum volume
if QV0 != 0:
t = ax.text(max_depth_log - 2.0, 1.5, f"QV{est_str}={QV}", size=12,
horizontalalignment='right', verticalalignment='center', color=(0.2,0.2,0.2),
bbox=dict(boxstyle="square,pad=0.3", fc=(.9,.9,.9), ec="grey", lw=1))
# add colorbar to right of plot
plt.colorbar(cm.ScalarMappable(cmap=cmap), cax=None, ax=ax,
shrink=0.6, label=colorbar_label, panchor=(0.0, 0.7))
return ax
# Function to calculate circuit depth
def calculate_circuit_depth(qc):
# Calculate the depth of the circuit
depth = qc.depth()
return depth
def calculate_transpiled_depth(qc,basis_selector):
# use either the backend or one of the basis gate sets
if basis_selector == 0:
qc = transpile(qc, backend)
else:
basis_gates = basis_gates_array[basis_selector]
qc = transpile(qc, basis_gates=basis_gates, seed_transpiler=0)
transpiled_depth = qc.depth()
return transpiled_depth,qc
def plot_fidelity_data(fidelity_data, Hf_fidelity_data, title):
avg_fidelity_means = []
avg_Hf_fidelity_means = []
avg_num_qubits_values = list(fidelity_data.keys())
# Calculate the average fidelity and Hamming fidelity for each unique number of qubits
for num_qubits in avg_num_qubits_values:
avg_fidelity = np.average(fidelity_data[num_qubits])
avg_fidelity_means.append(avg_fidelity)
avg_Hf_fidelity = np.mean(Hf_fidelity_data[num_qubits])
avg_Hf_fidelity_means.append(avg_Hf_fidelity)
return avg_fidelity_means,avg_Hf_fidelity_means
list_of_gates = []
def list_of_standardgates():
import qiskit.circuit.library as lib
from qiskit.circuit import Gate
import inspect
# List all the attributes of the library module
gate_list = dir(lib)
# Filter out non-gate classes (like functions, variables, etc.)
gates = [gate for gate in gate_list if isinstance(getattr(lib, gate), type) and issubclass(getattr(lib, gate), Gate)]
# Get method names from QuantumCircuit
circuit_methods = inspect.getmembers(QuantumCircuit, inspect.isfunction)
method_names = [name for name, _ in circuit_methods]
# Map gate class names to method names
gate_to_method = {}
for gate in gates:
gate_class = getattr(lib, gate)
class_name = gate_class.__name__.replace('Gate', '').lower() # Normalize class name
for method in method_names:
if method == class_name or method == class_name.replace('cr', 'c-r'):
gate_to_method[gate] = method
break
# Add common operations that are not strictly gates
additional_operations = {
'Measure': 'measure',
'Barrier': 'barrier',
}
gate_to_method.update(additional_operations)
for k,v in gate_to_method.items():
list_of_gates.append(v)
def update_counts(gates,custom_gates):
operations = {}
for key, value in gates.items():
operations[key] = value
for key, value in custom_gates.items():
if key in operations:
operations[key] += value
else:
operations[key] = value
return operations
def get_gate_counts(gates,custom_gate_defs):
result = gates.copy()
# Iterate over the gate counts in the quantum circuit
for gate, count in gates.items():
if gate in custom_gate_defs:
custom_gate_ops = custom_gate_defs[gate]
# Multiply custom gate operations by the count of the custom gate in the circuit
for _ in range(count):
result = update_counts(result, custom_gate_ops)
# Remove the custom gate entry as we have expanded it
del result[gate]
return result
dict_of_qc = dict()
custom_gates_defs = dict()
# Function to count operations recursively
def count_operations(qc):
circuit_traverser(qc)
operations = dict()
operations = dict_of_qc[qc.name]
del dict_of_qc[qc.name]
# print("operations :",operations)
# print("dict_of_qc :",dict_of_qc)
for keys in operations.keys():
if keys not in list_of_gates:
for k,v in dict_of_qc.items():
if k in operations.keys():
custom_gates_defs[k] = v
operations=get_gate_counts(operations,custom_gates_defs)
custom_gates_defs.clear()
return operations
def circuit_traverser(qc):
dict_of_qc[qc.name]=dict(qc.count_ops())
for i in qc.data:
if str(i.operation.name) not in list_of_gates:
qc_1 = i.operation.definition
circuit_traverser(qc_1)
def get_memory():
import resource
usage = resource.getrusage(resource.RUSAGE_SELF)
max_mem = usage.ru_maxrss/1024 #in MB
return max_mem
def analyzer(num_qubits,s_int):
input_size = num_qubits-1
secret_int = int(s_int)
# create the key that is expected to have all the measurements (for this circuit)
key = format(secret_int, f"0{input_size}b")
# correct distribution is measuring the key 100% of the time
correct_dist = {key: 1.0}
return correct_dist
def run (min_qubits=min_qubits, max_qubits=max_qubits, skip_qubits=skip_qubits,
max_circuits=max_circuits, num_shots=num_shots):
creation_times = []
elapsed_times = []
quantum_times = []
circuit_depths = []
transpiled_depths = []
fidelity_data = {}
Hf_fidelity_data = {}
numckts = []
mem_usage = []
algorithmic_1Q_gate_counts = []
algorithmic_2Q_gate_counts = []
transpiled_1Q_gate_counts = []
transpiled_2Q_gate_counts = []
print(f"{benchmark_name} Benchmark Program - {platform}")
#defining all the standard gates supported by qiskit in a list
if gate_counts_plots == True:
list_of_standardgates()
# validate parameters (smallest circuit is 3 qubits)
max_qubits = max(3, max_qubits)
min_qubits = min(max(3, min_qubits), max_qubits)
skip_qubits = max(1, skip_qubits)
# Variable for new qubit group ordering if using mid_circuit measurements
mid_circuit_qubit_group = []
# If using mid_circuit measurements, set transform qubit group to true
transform_qubit_group = True if method ==2 else False
global max_ckts
max_ckts = max_circuits
global min_qbits,max_qbits,skp_qubits
min_qbits = min_qubits
max_qbits = max_qubits
skp_qubits = skip_qubits
print(f"min, max qubits = {min_qubits} {max_qubits}")
# Execute Benchmark Program N times for multiple circuit sizes
for num_qubits in range(min_qubits, max_qubits + 1, skip_qubits):
input_size = num_qubits - 1
fidelity_data[num_qubits] = []
Hf_fidelity_data[num_qubits] = []
num_circuits = min(2**(input_size), max_circuits)
print(f"Executing [{num_circuits}] circuits with num_qubits = {num_qubits}")
numckts.append(num_circuits)
# determine range of secret strings to loop over
if 2**(input_size) <= max_circuits:
s_range = list(range(num_circuits))
else:
s_range = np.random.choice(2**(input_size), num_circuits, False)
for s_int in s_range:
print("*********************************************")
if input_value is not None:
s_int = input_value
# If mid circuit, then add 2 to new qubit group since the circuit only uses 2 qubits
if method == 2:
mid_circuit_qubit_group.append(2)
print(f"qc of {num_qubits} qubits with secret integer {s_int}")
#creation of Quantum Circuit.
ts = time.time()
qc = BersteinVazirani(num_qubits, s_int, method)
#creation time
creation_time = time.time() - ts
creation_times.append(creation_time)
#print(qc)
print(f"creation time = {creation_time*1000} ms")
# Calculate gate count for the algorithmic circuit (excluding barriers and measurements)
if gate_counts_plots == True:
operations = count_operations(qc)
n1q = 0; n2q = 0
if operations != None:
for key, value in operations.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c") or key.startswith("mc"):
n2q += value
else:
n1q += value
algorithmic_1Q_gate_counts.append(n1q)
algorithmic_2Q_gate_counts.append(n2q)
# collapse the sub-circuit levels used in this benchmark (for qiskit)
qc=qc.decompose()
#print(qc)
# Calculate circuit depth
depth = calculate_circuit_depth(qc)
circuit_depths.append(depth)
# Calculate transpiled circuit depth
transpiled_depth,qc = calculate_transpiled_depth(qc,basis_selector)
transpiled_depths.append(transpiled_depth)
#print(qc)
print(f"Algorithmic Depth = {depth} and Normalized Depth = {transpiled_depth}")
if gate_counts_plots == True:
# Calculate gate count for the transpiled circuit (excluding barriers and measurements)
tr_ops = qc.count_ops()
#print("tr_ops = ",tr_ops)
tr_n1q = 0; tr_n2q = 0
if tr_ops != None:
for key, value in tr_ops.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c"): tr_n2q += value
else: tr_n1q += value
transpiled_1Q_gate_counts.append(tr_n1q)
transpiled_2Q_gate_counts.append(tr_n2q)
print(f"Algorithmic 1Q gates = {n1q} ,Algorithmic 2Q gates = {n2q}")
print(f"Normalized 1Q gates = {tr_n1q} ,Normalized 2Q gates = {tr_n2q}")
#execution
if Type_of_Simulator == "built_in":
#To check if Noise is required
if Noise_Inclusion == True:
noise_model = noise_parameters
else:
noise_model = None
ts = time.time()
job = execute(qc, backend, shots=num_shots, noise_model=noise_model)
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2" :
ts = time.time()
job = backend.run(qc,shots=num_shots, noise_model=noise_parameters)
#retrieving the result
result = job.result()
#print(result)
#calculating elapsed time
elapsed_time = time.time() - ts
elapsed_times.append(elapsed_time)
# Calculate quantum processing time
quantum_time = result.time_taken
quantum_times.append(quantum_time)
print(f"Elapsed time = {elapsed_time*1000} ms and Quantum Time = {quantum_time *1000} ms")
#counts in result object
counts = result.get_counts()
#Correct distribution to compare with counts
correct_dist = analyzer(num_qubits, s_int)
#fidelity calculation comparision of counts and correct_dist
fidelity_dict = polarization_fidelity(counts, correct_dist)
fidelity_data[num_qubits].append(fidelity_dict['fidelity'])
Hf_fidelity_data[num_qubits].append(fidelity_dict['hf_fidelity'])
#maximum memory utilization (if required)
if Memory_utilization_plot == True:
max_mem = get_memory()
print(f"Maximum Memory Utilized: {max_mem} MB")
mem_usage.append(max_mem)
print("*********************************************")
# print a sample circuit
print("Sample Circuit:"); print(QC_ if QC_ != None else " ... too large!")
if method == 1: print("\nQuantum Oracle 'Uf' ="); print(Uf_ if Uf_ != None else " ... too large!")
return (creation_times, elapsed_times, quantum_times, circuit_depths, transpiled_depths,
fidelity_data, Hf_fidelity_data, numckts , algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts,
transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage)
# Execute the benchmark program, accumulate metrics, and calculate circuit depths
(creation_times, elapsed_times, quantum_times, circuit_depths,transpiled_depths, fidelity_data, Hf_fidelity_data, numckts,
algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts, transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage) = run()
# Define the range of qubits for the x-axis
num_qubits_range = range(min_qbits, max_qbits+1,skp_qubits)
print("num_qubits_range =",num_qubits_range)
# Calculate average creation time, elapsed time, quantum processing time, and circuit depth for each number of qubits
avg_creation_times = []
avg_elapsed_times = []
avg_quantum_times = []
avg_circuit_depths = []
avg_transpiled_depths = []
avg_1Q_algorithmic_gate_counts = []
avg_2Q_algorithmic_gate_counts = []
avg_1Q_Transpiled_gate_counts = []
avg_2Q_Transpiled_gate_counts = []
max_memory = []
start = 0
for num in numckts:
avg_creation_times.append(np.mean(creation_times[start:start+num]))
avg_elapsed_times.append(np.mean(elapsed_times[start:start+num]))
avg_quantum_times.append(np.mean(quantum_times[start:start+num]))
avg_circuit_depths.append(np.mean(circuit_depths[start:start+num]))
avg_transpiled_depths.append(np.mean(transpiled_depths[start:start+num]))
if gate_counts_plots == True:
avg_1Q_algorithmic_gate_counts.append((np.mean(algorithmic_1Q_gate_counts[start:start+num])))
avg_2Q_algorithmic_gate_counts.append((np.mean(algorithmic_2Q_gate_counts[start:start+num])))
avg_1Q_Transpiled_gate_counts.append((np.mean(transpiled_1Q_gate_counts[start:start+num])))
avg_2Q_Transpiled_gate_counts.append((np.mean(transpiled_2Q_gate_counts[start:start+num])))
if Memory_utilization_plot == True:max_memory.append(np.max(mem_usage[start:start+num]))
start += num
# Calculate the fidelity data
avg_f, avg_Hf = plot_fidelity_data(fidelity_data, Hf_fidelity_data, "Fidelity Comparison")
# Plot histograms for average creation time, average elapsed time, average quantum processing time, and average circuit depth versus the number of qubits
# Add labels to the bars
def autolabel(rects,ax,str='{:.3f}',va='top',text_color="black"):
for rect in rects:
height = rect.get_height()
ax.annotate(str.format(height), # Formatting to two decimal places
xy=(rect.get_x() + rect.get_width() / 2, height / 2),
xytext=(0, 0),
textcoords="offset points",
ha='center', va=va,color=text_color,rotation=90)
bar_width = 0.3
# Determine the number of subplots and their arrangement
if Memory_utilization_plot and gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6, ax7) = plt.subplots(7, 1, figsize=(18, 30))
# Plotting for both memory utilization and gate counts
# ax1, ax2, ax3, ax4, ax5, ax6, ax7 are available
elif Memory_utilization_plot:
fig, (ax1, ax2, ax3, ax6, ax7) = plt.subplots(5, 1, figsize=(18, 30))
# Plotting for memory utilization only
# ax1, ax2, ax3, ax6, ax7 are available
elif gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6) = plt.subplots(6, 1, figsize=(18, 30))
# Plotting for gate counts only
# ax1, ax2, ax3, ax4, ax5, ax6 are available
else:
fig, (ax1, ax2, ax3, ax6) = plt.subplots(4, 1, figsize=(18, 30))
# Default plotting
# ax1, ax2, ax3, ax6 are available
fig.suptitle(f"General Benchmarks : {platform} - {benchmark_name}", fontsize=16)
for i in range(len(avg_creation_times)): #converting seconds to milli seconds by multiplying 1000
avg_creation_times[i] *= 1000
ax1.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax1.bar(num_qubits_range, avg_creation_times, color='deepskyblue')
autolabel(ax1.patches, ax1)
ax1.set_xlabel('Number of Qubits')
ax1.set_ylabel('Average Creation Time (ms)')
ax1.set_title('Average Creation Time vs Number of Qubits',fontsize=14)
ax2.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
for i in range(len(avg_elapsed_times)): #converting seconds to milli seconds by multiplying 1000
avg_elapsed_times[i] *= 1000
for i in range(len(avg_quantum_times)): #converting seconds to milli seconds by multiplying 1000
avg_quantum_times[i] *= 1000
Elapsed= ax2.bar(np.array(num_qubits_range) - bar_width / 2, avg_elapsed_times, width=bar_width, color='cyan', label='Elapsed Time')
Quantum= ax2.bar(np.array(num_qubits_range) + bar_width / 2, avg_quantum_times,width=bar_width, color='deepskyblue',label ='Quantum Time')
autolabel(Elapsed,ax2,str='{:.1f}')
autolabel(Quantum,ax2,str='{:.1f}')
ax2.set_xlabel('Number of Qubits')
ax2.set_ylabel('Average Time (ms)')
ax2.set_title('Average Time vs Number of Qubits')
ax2.legend()
ax3.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized = ax3.bar(np.array(num_qubits_range) - bar_width / 2, avg_transpiled_depths, color='cyan', label='Normalized Depth', width=bar_width) # Adjust width here
Algorithmic = ax3.bar(np.array(num_qubits_range) + bar_width / 2,avg_circuit_depths, color='deepskyblue', label='Algorithmic Depth', width=bar_width) # Adjust width here
autolabel(Normalized,ax3,str='{:.2f}')
autolabel(Algorithmic,ax3,str='{:.2f}')
ax3.set_xlabel('Number of Qubits')
ax3.set_ylabel('Average Circuit Depth')
ax3.set_title('Average Circuit Depth vs Number of Qubits')
ax3.legend()
if gate_counts_plots == True:
ax4.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_1Q_counts = ax4.bar(np.array(num_qubits_range) - bar_width / 2, avg_1Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_1Q_counts = ax4.bar(np.array(num_qubits_range) + bar_width / 2, avg_1Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_1Q_counts,ax4,str='{}')
autolabel(Algorithmic_1Q_counts,ax4,str='{}')
ax4.set_xlabel('Number of Qubits')
ax4.set_ylabel('Average 1-Qubit Gate Counts')
ax4.set_title('Average 1-Qubit Gate Counts vs Number of Qubits')
ax4.legend()
ax5.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_2Q_counts = ax5.bar(np.array(num_qubits_range) - bar_width / 2, avg_2Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_2Q_counts = ax5.bar(np.array(num_qubits_range) + bar_width / 2, avg_2Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_2Q_counts,ax5,str='{}')
autolabel(Algorithmic_2Q_counts,ax5,str='{}')
ax5.set_xlabel('Number of Qubits')
ax5.set_ylabel('Average 2-Qubit Gate Counts')
ax5.set_title('Average 2-Qubit Gate Counts vs Number of Qubits')
ax5.legend()
ax6.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Hellinger = ax6.bar(np.array(num_qubits_range) - bar_width / 2, avg_Hf, width=bar_width, label='Hellinger Fidelity',color='cyan') # Adjust width here
Normalized = ax6.bar(np.array(num_qubits_range) + bar_width / 2, avg_f, width=bar_width, label='Normalized Fidelity', color='deepskyblue') # Adjust width here
autolabel(Hellinger,ax6,str='{:.2f}')
autolabel(Normalized,ax6,str='{:.2f}')
ax6.set_xlabel('Number of Qubits')
ax6.set_ylabel('Average Value')
ax6.set_title("Fidelity Comparison")
ax6.legend()
if Memory_utilization_plot == True:
ax7.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax7.bar(num_qubits_range, max_memory, color='turquoise', width=bar_width, label="Memory Utilizations")
autolabel(ax7.patches, ax7)
ax7.set_xlabel('Number of Qubits')
ax7.set_ylabel('Maximum Memory Utilized (MB)')
ax7.set_title('Memory Utilized vs Number of Qubits',fontsize=14)
plt.tight_layout(rect=[0, 0, 1, 0.96])
if saveplots == True:
plt.savefig("ParameterPlotsSample.jpg")
plt.show()
# Quantum Volume Plot
Suptitle = f"Volumetric Positioning - {platform}"
appname=benchmark_name
if QV_ == None:
QV=2048
else:
QV=QV_
depth_base =2
ax = plot_volumetric_background(max_qubits=max_qbits, QV=QV,depth_base=depth_base, suptitle=Suptitle, colorbar_label="Avg Result Fidelity")
w_data = num_qubits_range
# determine width for circuit
w_max = 0
for i in range(len(w_data)):
y = float(w_data[i])
w_max = max(w_max, y)
d_tr_data = avg_transpiled_depths
f_data = avg_f
plot_volumetric_data(ax, w_data, d_tr_data, f_data, depth_base, fill=True,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, w_max=w_max)
anno_volumetric_data(ax, depth_base,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, fill=False)
|
https://github.com/qcware/qusetta
|
qcware
|
"""Test the translation functionality.
Phases and exact gates may be different in the circuit, but the
resulting probability distribution is the same; that's all we care about.
"""
import cirq
import qiskit
import quasar
import qusetta as qs
from math import pi
import numpy as np
import random
class Simulator:
cirq_backend = cirq.Simulator(dtype=np.complex128)
qiskit_backend = qiskit.BasicAer.get_backend('statevector_simulator')
quasar_backend = quasar.QuasarSimulatorBackend()
@staticmethod
def cirq(circuit: cirq.Circuit) -> np.ndarray:
return Simulator.cirq_backend.simulate(circuit).final_state
@staticmethod
def qiskit(circuit: qiskit.QuantumCircuit) -> np.ndarray:
return qiskit.execute(
circuit, Simulator.qiskit_backend
).result().get_statevector()
@staticmethod
def quasar(circuit: quasar.Circuit) -> np.ndarray:
return Simulator.quasar_backend.run_statevector(circuit)
def assert_equal(c0, c1, simulator0, simulator1=None):
simulator1 = simulator1 or simulator0
np.testing.assert_allclose(
np.abs(simulator0(c0)) ** 2,
np.abs(simulator1(c1)) ** 2
)
# begin test functions that work on arbitrary circuits
def cirq_vs_qusetta(cirq_circuit, qusetta_circuit):
assert_equal(
cirq_circuit,
qs.Cirq.from_qusetta(qusetta_circuit),
Simulator.cirq
)
assert_equal(
cirq_circuit,
qs.Cirq.from_qusetta(qs.Cirq.to_qusetta(cirq_circuit)),
Simulator.cirq
)
def qiskit_vs_qusetta(qiskit_circuit, qusetta_circuit):
assert_equal(
qiskit_circuit,
qs.Qiskit.from_qusetta(qusetta_circuit),
Simulator.qiskit
)
assert_equal(
qiskit_circuit,
qs.Qiskit.from_qusetta(qs.Qiskit.to_qusetta(qiskit_circuit)),
Simulator.qiskit
)
def quasar_vs_qusetta(quasar_circuit, qusetta_circuit):
assert_equal(
quasar_circuit,
qs.Quasar.from_qusetta(qusetta_circuit),
Simulator.quasar
)
assert_equal(
quasar_circuit,
qs.Quasar.from_qusetta(qs.Quasar.to_qusetta(quasar_circuit)),
Simulator.quasar
)
def cirq_vs_qiskit(cirq_circuit, qiskit_circuit):
assert_equal(
cirq_circuit,
qiskit_circuit,
Simulator.cirq,
Simulator.qiskit
)
assert_equal(
cirq_circuit,
qs.Qiskit.to_cirq(qiskit_circuit),
Simulator.cirq
)
assert_equal(
cirq_circuit,
qs.Cirq.from_qiskit(qiskit_circuit),
Simulator.cirq
)
assert_equal(
qs.Qiskit.from_cirq(cirq_circuit),
qiskit_circuit,
Simulator.qiskit
)
assert_equal(
qs.Cirq.to_qiskit(cirq_circuit),
qiskit_circuit,
Simulator.qiskit
)
assert_equal(
qiskit_circuit,
qs.Qiskit.from_cirq(qs.Qiskit.to_cirq(qiskit_circuit)),
Simulator.qiskit
)
assert_equal(
cirq_circuit,
qs.Cirq.from_qiskit(qs.Cirq.to_qiskit(cirq_circuit)),
Simulator.cirq
)
def cirq_vs_quasar(cirq_circuit, quasar_circuit):
assert_equal(
cirq_circuit,
quasar_circuit,
Simulator.cirq,
Simulator.quasar
)
assert_equal(
cirq_circuit,
qs.Quasar.to_cirq(quasar_circuit),
Simulator.cirq
)
assert_equal(
cirq_circuit,
qs.Cirq.from_quasar(quasar_circuit),
Simulator.cirq
)
assert_equal(
qs.Quasar.from_cirq(cirq_circuit),
quasar_circuit,
Simulator.quasar
)
assert_equal(
qs.Cirq.to_quasar(cirq_circuit),
quasar_circuit,
Simulator.quasar
)
assert_equal(
quasar_circuit,
qs.Quasar.from_cirq(qs.Quasar.to_cirq(quasar_circuit)),
Simulator.quasar
)
assert_equal(
cirq_circuit,
qs.Cirq.from_quasar(qs.Cirq.to_quasar(cirq_circuit)),
Simulator.cirq
)
def qiskit_vs_quasar(qiskit_circuit, quasar_circuit):
assert_equal(
qiskit_circuit,
quasar_circuit,
Simulator.qiskit,
Simulator.quasar
)
assert_equal(
qiskit_circuit,
qs.Quasar.to_qiskit(quasar_circuit),
Simulator.qiskit
)
assert_equal(
qiskit_circuit,
qs.Qiskit.from_quasar(quasar_circuit),
Simulator.qiskit
)
assert_equal(
qs.Quasar.from_qiskit(qiskit_circuit),
quasar_circuit,
Simulator.quasar
)
assert_equal(
qs.Qiskit.to_quasar(qiskit_circuit),
quasar_circuit,
Simulator.quasar
)
assert_equal(
quasar_circuit,
qs.Quasar.from_qiskit(qs.Quasar.to_qiskit(quasar_circuit)),
Simulator.quasar
)
assert_equal(
qiskit_circuit,
qs.Qiskit.from_quasar(qs.Qiskit.to_quasar(qiskit_circuit)),
Simulator.qiskit
)
# begin explicit tests with explicit circuits
def all_tests(qusetta_circuit, cirq_circuit, qiskit_circuit, quasar_circuit):
cirq_vs_qusetta(cirq_circuit, qusetta_circuit)
qiskit_vs_qusetta(qiskit_circuit, qusetta_circuit)
quasar_vs_qusetta(quasar_circuit, qusetta_circuit)
cirq_vs_qiskit(cirq_circuit, qiskit_circuit)
cirq_vs_quasar(cirq_circuit, quasar_circuit)
qiskit_vs_quasar(qiskit_circuit, quasar_circuit)
def test_circuit_0():
qusetta_circuit = [
"H(0)", "H(1)", "CX(0, 1)", "CX(1, 0)", "CZ(2, 0)",
"I(1)", "SWAP(0, 3)", "RY(PI)(1)", "X(2)", "S(0)",
"Z(2)", "Y(3)", "RX(0.4*PI)(0)", "T(2)", "RZ(-0.3*PI)(2)",
"CCX(0, 1, 2)"
]
cirq_circuit = cirq.Circuit()
q = [cirq.LineQubit(i) for i in range(4)]
cirq_circuit.append(cirq.H(q[0]))
cirq_circuit.append(cirq.H(q[1]))
cirq_circuit.append(cirq.CX(q[0], q[1]))
cirq_circuit.append(cirq.CX(q[1], q[0]))
cirq_circuit.append(cirq.CZ(q[2], q[0]))
cirq_circuit.append(cirq.I(q[1]))
cirq_circuit.append(cirq.SWAP(q[0], q[3]))
cirq_circuit.append(cirq.ry(pi)(q[1]))
cirq_circuit.append(cirq.X(q[2]))
cirq_circuit.append(cirq.S(q[0]))
cirq_circuit.append(cirq.Z(q[2]))
cirq_circuit.append(cirq.Y(q[3]))
cirq_circuit.append(cirq.rx(.4*pi)(q[0]))
cirq_circuit.append(cirq.T(q[2]))
cirq_circuit.append(cirq.rz(-.3*pi)(q[2]))
cirq_circuit.append(cirq.CCX(q[0], q[1], q[2]))
# ibm is weird so we flip all of the qubits here
qiskit_circuit = qiskit.QuantumCircuit(4)
qiskit_circuit.h(3-0)
qiskit_circuit.h(3-1)
qiskit_circuit.cx(3-0, 3-1)
qiskit_circuit.cx(3-1, 3-0)
qiskit_circuit.cz(3-2, 3-0)
qiskit_circuit.i(3-1)
qiskit_circuit.swap(3-0, 3-3)
qiskit_circuit.ry(pi, 3-1)
qiskit_circuit.x(3-2)
qiskit_circuit.s(3-0)
qiskit_circuit.z(3-2)
qiskit_circuit.y(3-3)
qiskit_circuit.rx(.4*pi, 3-0)
qiskit_circuit.t(3-2)
qiskit_circuit.rz(-.3*pi, 3-2)
qiskit_circuit.ccx(3-0, 3-1, 3-2)
quasar_circuit = quasar.Circuit()
quasar_circuit.H(0)
quasar_circuit.H(1)
quasar_circuit.CX(0, 1)
quasar_circuit.CX(1, 0)
quasar_circuit.CZ(2, 0)
quasar_circuit.I(1)
quasar_circuit.SWAP(0, 3)
quasar_circuit.Ry(1, pi)
quasar_circuit.X(2)
quasar_circuit.S(0)
quasar_circuit.Z(2)
quasar_circuit.Y(3)
quasar_circuit.Rx(0, .2*pi)
quasar_circuit.T(2)
quasar_circuit.Rz(2, -.15*pi)
quasar_circuit.CCX(0, 1, 2)
# tests
all_tests(qusetta_circuit, cirq_circuit, qiskit_circuit, quasar_circuit)
def test_circuit_1():
# test qiskit's u1, u2, and u3 gates
qiskit_circuit = qiskit.QuantumCircuit(4)
qiskit_circuit.h(0)
qiskit_circuit.h(2)
qiskit_circuit.u1(pi/6, 1)
qiskit_circuit.u2(1, 2, 0)
qiskit_circuit.ccx(1, 0, 3)
qiskit_circuit.ccx(0, 1, 2)
qiskit_circuit.u3(1, 2, 3, 1)
qiskit_circuit.rx(pi/3, 1)
qiskit_circuit.u3(1.56, 1.24, 1.69, 2)
qiskit_circuit.u2(1.2, 5.1, 1)
qiskit_circuit.u1(6.542, 0)
qusetta_circuit = qs.Qiskit.to_qusetta(qiskit_circuit)
cirq_circuit = qs.Cirq.from_qusetta(qusetta_circuit)
quasar_circuit = qs.Quasar.from_qusetta(qusetta_circuit)
# tests
all_tests(qusetta_circuit, cirq_circuit, qiskit_circuit, quasar_circuit)
def test_circuit_2():
# test that we ignore measurement gates
qusetta_circuit = ["H(0)"]
q = cirq.LineQubit(0)
cirq_circuit = cirq.Circuit(cirq.H(q), cirq.measure(q))
cirq_circuit = qs.Cirq.from_qusetta(qs.Cirq.to_qusetta(cirq_circuit))
qiskit_circuit = qiskit.QuantumCircuit(1, 1)
qiskit_circuit.h(0)
qiskit_circuit.measure(0, 0)
qiskit_circuit = qs.Qiskit.from_qusetta(
qs.Qiskit.to_qusetta(qiskit_circuit)
)
quasar_circuit = quasar.Circuit()
quasar_circuit.H(0)
quasar_circuit = qs.Quasar.from_qusetta(
qs.Quasar.to_qusetta(quasar_circuit)
)
# tests
all_tests(qusetta_circuit, cirq_circuit, qiskit_circuit, quasar_circuit)
|
https://github.com/abbarreto/qiskit3
|
abbarreto
|
%run init.ipynb
def pf(t,r):
f = (1-r**t)/(1-r) - t
return f
from mpl_toolkits import mplot3d
def pf_3d(th,ph):
import matplotlib
matplotlib.rcParams.update({'font.size':12});
#plt.figure(figsize = (6,4,4), dpi = 100)
x = np.linspace(0, 1, 20)
y = np.linspace(0, 1, 20)
X, Y = np.meshgrid(x, y)
Z = pf(X,Y)
fig = plt.figure();
ax = plt.axes(projection="3d")
ax.plot_wireframe(X, Y, Z, color='blue')
ax.set_xlabel(r'$\lambda$')
ax.set_ylabel(r'$t$'); ax.set_zlabel(r'$r$')
ax.view_init(th, ph)
fig.tight_layout()
plt.show()
interactive(pf_3d, th = (0,90,10), ph = (0,360,10))
import numpy as np
import math
from matplotlib import pyplot as plt
x = np.arange(0.1,5,0.1) # d tau/dt
y = np.log(np.sinh(x/2)/math.sinh(1/2)) #faz beta*hbat*omega/2 = 1
plt.plot(x,y)
plt.show()
x = np.arange(0,10,0.1) # x = hb*omega, kT=1
y1 = np.exp(-x) # dtau/dt = 1
y2 = np.exp(-0.5*x) # dtau/dt = 0.5
y3 = np.exp(-1.5*x) # dtau/dt = 1.5
plt.plot(x,y1,label='1')
plt.plot(x,y2,label='0.5')
plt.plot(x,y3,label='1.5')
plt.legend()
plt.show()
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=no-member,invalid-name,missing-docstring,no-name-in-module
# pylint: disable=attribute-defined-outside-init,unsubscriptable-object
from qiskit import transpile
from qiskit.transpiler import CouplingMap
from .utils import build_ripple_adder_circuit
class RippleAdderConstruction:
params = ([10, 50, 100, 200, 500],)
param_names = ["size"]
version = 1
timeout = 600
def time_build_ripple_adder(self, size):
build_ripple_adder_circuit(size)
class RippleAdderTranspile:
params = ([10, 20], [0, 1, 2, 3])
param_names = ["size", "level"]
version = 1
timeout = 600
def setup(self, size, _):
edge_len = int((2 * size + 2) ** 0.5) + 1
self.coupling_map = CouplingMap.from_grid(edge_len, edge_len)
self.circuit = build_ripple_adder_circuit(size)
def time_transpile_square_grid_ripple_adder(self, _, level):
transpile(
self.circuit,
coupling_map=self.coupling_map,
basis_gates=["u1", "u2", "u3", "cx", "id"],
optimization_level=level,
seed_transpiler=20220125,
)
def track_depth_transpile_square_grid_ripple_adder(self, _, level):
return transpile(
self.circuit,
coupling_map=self.coupling_map,
basis_gates=["u1", "u2", "u3", "cx", "id"],
optimization_level=level,
seed_transpiler=20220125,
).depth()
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute, Aer
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
# import basic plot tools
from qiskit.visualization import plot_histogram
def initialize(circuit, n, m):
circuit.h(range(n)) # Hadamard transform on measurment register
circuit.x(n+m-1) # X gate on last qubit
def c_amod15(a, x):
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13") # remember that a needs to be co-prime with N
unitary = QuantumCircuit(4)
for iteration in range(x):
# bitwise arithmetic to represent modular exponentiation function
if a in [2,13]:
unitary.swap(0,1)
unitary.swap(1,2)
unitary.swap(2,3)
if a in [7,8]:
unitary.swap(2,3)
unitary.swap(1,2)
unitary.swap(0,1)
if a == 11:
unitary.swap(1,3)
unitary.swap(0,2)
if a in [7,11,13]:
for q in range(4):
unitary.x(q)
unitary = unitary.to_gate()
unitary.name = "%i^%i mod 15" % (a, x)
# But we need to make it a controlled operation for phase kickback
c_unitary = unitary.control()
return c_unitary
def modular_exponentiation(circuit, n, m, a):
for exp in range(n):
exponent = 2**exp
circuit.append(a_x_mod15(a, exponent), [exp] + list(range(n, n+m)))
from qiskit.circuit.library import QFT
def apply_iqft(circuit, measurement_qubits):
circuit.append(QFT( len(measurement_qubits), do_swaps=False).inverse(), measurement_qubits)
def shor_algo(n, m, a):
# set up the circuit
circ = QuantumCircuit(n+m, n)
# initialize the registers
initialize(circ, n, m)
circ.barrier()
# map modular exponentiation problem onto qubits
modular_exponentiation(circ, n, m, a)
circ.barrier()
# apply inverse QFT -- expose period
apply_iqft(circ, range(n))
# measure the measurement register
circ.measure(range(n), range(n))
return circ
n = 4; m = 4; a = 11
mycircuit = shor_algo(n, m, a)
mycircuit.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
counts = execute(mycircuit, backend=simulator, shots=1024).result().get_counts(mycircuit)
plot_histogram(counts)
for measured_value in counts:
print(f"Measured {int(measured_value[::-1], 2)}")
from math import gcd
from math import sqrt
from itertools import count, islice
for measured_value in counts:
measured_value_decimal = int(measured_value[::-1], 2)
print(f"Measured {measured_value_decimal}")
if measured_value_decimal % 2 != 0:
print("Failed. Measured value is not an even number")
continue
x = int((a ** (measured_value_decimal/2)) % 15)
if (x + 1) % 15 == 0:
print("Failed. x + 1 = 0 (mod N) where x = a^(r/2) (mod N)")
continue
guesses = gcd(x + 1, 15), gcd(x - 1, 15)
print(guesses)
def is_prime(n):
return n > 1 and all(n % i for i in islice(count(2), int(sqrt(n)-1)))
if is_prime(guesses[0]) and is_prime(guesses[1]):
print(f"**The prime factors are {guesses[0]} and {guesses[1]}**")
|
https://github.com/qiskit-community/prototype-entanglement-forging
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Execution subroutines."""
import time
import numpy as np
from qiskit import assemble
from qiskit.providers.ibmq.job import (
IBMQJobFailureError,
IBMQJobApiError,
IBMQJobInvalidStateError,
)
from entanglement_forging.utils.legacy.common import measure_pauli_z, covariance
def compute_pauli_means_and_cov_for_one_basis(paulis, counts):
"""Compute Pauli means and cov for one basis."""
means = np.array([measure_pauli_z(counts, pauli) for pauli in paulis])
cov = np.array(
[
[
covariance(counts, pauli_1, pauli_2, avg_1, avg_2)
for pauli_2, avg_2 in zip(paulis, means)
]
for pauli_1, avg_1 in zip(paulis, means)
]
)
return means, cov
def execute_with_retry(circuits, backend, shots, rep_delay=None, noise_model=None):
"""Executes job with retry."""
global result # pylint: disable=global-variable-undefined,invalid-name
trials = 0
ran_job_ok = False
while not ran_job_ok:
try:
if backend.name() in [
"statevector_simulator",
"aer_simulator_statevector",
]:
job = backend.run(
circuits,
seed_simulator=42,
)
elif backend.name() == "qasm_simulator":
job = backend.run(circuits, shots=shots, noise_model=noise_model)
else:
job = backend.run(circuits, shots=shots, rep_delay=rep_delay)
result = job.result()
ran_job_ok = True
except (IBMQJobFailureError, IBMQJobApiError, IBMQJobInvalidStateError) as err:
print("Error running job, will retry in 5 mins.")
print("Error:", err)
# Wait 5 mins and try again. Hopefully this handles network outages etc,
# and also if user cancels a (stuck) job through IQX.
# Add more error types to the exception as new ones crop up (as appropriate).
time.sleep(300)
trials += 1
# pylint: disable=raise-missing-from
if trials > 100:
raise RuntimeError(
"Timed out trying to run job successfully (100 attempts)"
)
return result
def reduce_bitstrings(bitstrings, orbitals_to_reduce):
"""Returns reduced bitstrings."""
return np.delete(bitstrings, orbitals_to_reduce, axis=-1).tolist()
|
https://github.com/hugosc/quantum-phase-estimation
|
hugosc
|
from qiskit import ClassicalRegister , QuantumCircuit, QuantumRegister
import numpy as np
qr = QuantumRegister(2)
cr = ClassicalRegister(3) #For tree classicals bites
qc = QuantumCircuit(qr , cr)
qc.h(qr[0]) #auxiliary qubit
qc.x(qr[1]) # eigenvector
#qc.cp((3/2)*np.pi , qr[0] , qr[1])
qc.cp(3*np.pi , qr[0] , qr[1])
qc.h(qr[0])
qc.measure(qr[0] , cr[0]) # this is the controlled-U^(2^n-1) operator for determine phi_n
qc.draw("mpl")
qc.reset(qr[0])
qc.h(qr[0])
# la valeur du bit du poids le plus faible est dans cr[0].
#Si cr[0] = 1 on enléve le bit de poids le plus faible en fesant la rotation alpha_2
#et on continu le bit n-1 devient le bit le bit de poids le plus faible
#si cr[0] est à 0 alors on peut appliquer directement la matrice unitaire associé sans avoir
#à faire de rotation inverse alpha_k
with qc.if_test((cr[0] , 1)) as else_:
qc.p(-np.pi/2 , qr[0])
#qc.cp((3/8)*np.pi , qr[0] ,qr[1])
qc.cp((3/2)*np.pi , qr[0] ,qr[1])
qc.h(qr[0]) # For make measure in X basis {|0> , |1>}
qc.measure(qr[0] , cr[1])
qc.draw("mpl")
qc.reset(qr[0])
qc.h(qr[0])
# la valeur du bit du poids le plus faible est dans cr[0].
#Si cr[0] = 1 on enléve le bit de poids le plus faible en fesant la rotation alpha_2
#et on continu le bit n-1 devient le bit le bit de poids le plus faible
#si cr[0] est à 0 alors on peut appliquer directement la matrice unitaire associé sans avoir
#à faire de rotation inverse alpha_k
with qc.if_test((cr[1] , 1)) as else_:
qc.p(-(3/4)*np.pi , qr[0])
qc.cp((3/4)*np.pi , qr[0] ,qr[1])
qc.h(qr[0]) # For make measure in X basis {|0> , |1>}
qc.measure(qr[0] , cr[2])
qc.draw("mpl")
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
counts
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/grossiM/Qiskit_workshop1019
|
grossiM
|
# initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
nQubits = 2 # number of physical qubits used to represent s
s = 3 # the hidden integer
# make sure that a can be represented with nqubits
s = s % 2**(nQubits)
# Creating registers
# qubits for querying the oracle and finding the hidden integer
qr = QuantumRegister(nQubits)
# bits for recording the measurement on qr
cr = ClassicalRegister(nQubits)
bvCircuit = QuantumCircuit(qr, cr)
barriers = True
# Apply Hadamard gates before querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
# Apply the inner-product oracle
for i in range(nQubits):
if (s & (1 << i)):
bvCircuit.z(qr[i])
else:
bvCircuit.iden(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
#Apply Hadamard gates after querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
# Measurement
bvCircuit.measure(qr, cr)
bvCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(bvCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to 5 qubits
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')provider.backends()
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits <= 5 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
shots = 1024
job = execute(bvCircuit, backend=backend, shots=shots)
job_monitor(job, interval = 2)
# Get the results from the computation
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.library import RealAmplitudes
from qiskit.algorithms.optimizers import COBYLA
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver, SamplingVQE
from qiskit.primitives import Sampler
from qiskit_optimization.converters import LinearEqualityToPenalty
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.translators import from_docplex_mp
from qiskit.utils import algorithm_globals
import numpy as np
import matplotlib.pyplot as plt
from docplex.mp.model import Model
algorithm_globals.random_seed = 123456
# prepare problem instance
n = 6 # number of assets
q = 0.5 # risk factor
budget = n // 2 # budget
penalty = 2 * n # scaling of penalty term
# instance from [1]
mu = np.array([0.7313, 0.9893, 0.2725, 0.8750, 0.7667, 0.3622])
sigma = np.array(
[
[0.7312, -0.6233, 0.4689, -0.5452, -0.0082, -0.3809],
[-0.6233, 2.4732, -0.7538, 2.4659, -0.0733, 0.8945],
[0.4689, -0.7538, 1.1543, -1.4095, 0.0007, -0.4301],
[-0.5452, 2.4659, -1.4095, 3.5067, 0.2012, 1.0922],
[-0.0082, -0.0733, 0.0007, 0.2012, 0.6231, 0.1509],
[-0.3809, 0.8945, -0.4301, 1.0922, 0.1509, 0.8992],
]
)
# or create random instance
# mu, sigma = portfolio.random_model(n, seed=123) # expected returns and covariance matrix
# create docplex model
mdl = Model("portfolio_optimization")
x = mdl.binary_var_list(range(n), name="x")
objective = mdl.sum([mu[i] * x[i] for i in range(n)])
objective -= q * mdl.sum([sigma[i, j] * x[i] * x[j] for i in range(n) for j in range(n)])
mdl.maximize(objective)
mdl.add_constraint(mdl.sum(x[i] for i in range(n)) == budget)
# case to
qp = from_docplex_mp(mdl)
# solve classically as reference
opt_result = MinimumEigenOptimizer(NumPyMinimumEigensolver()).solve(qp)
print(opt_result.prettyprint())
# we convert the problem to an unconstrained problem for further analysis,
# otherwise this would not be necessary as the MinimumEigenSolver would do this
# translation automatically
linear2penalty = LinearEqualityToPenalty(penalty=penalty)
qp = linear2penalty.convert(qp)
_, offset = qp.to_ising()
# set classical optimizer
maxiter = 100
optimizer = COBYLA(maxiter=maxiter)
# set variational ansatz
ansatz = RealAmplitudes(n, reps=1)
m = ansatz.num_parameters
# set sampler
sampler = Sampler()
# run variational optimization for different values of alpha
alphas = [1.0, 0.50, 0.25] # confidence levels to be evaluated
# dictionaries to store optimization progress and results
objectives = {alpha: [] for alpha in alphas} # set of tested objective functions w.r.t. alpha
results = {} # results of minimum eigensolver w.r.t alpha
# callback to store intermediate results
def callback(i, params, obj, stddev, alpha):
# we translate the objective from the internal Ising representation
# to the original optimization problem
objectives[alpha].append(np.real_if_close(-(obj + offset)))
# loop over all given alpha values
for alpha in alphas:
# initialize SamplingVQE using CVaR
vqe = SamplingVQE(
sampler=sampler,
ansatz=ansatz,
optimizer=optimizer,
aggregation=alpha,
callback=lambda i, params, obj, stddev: callback(i, params, obj, stddev, alpha),
)
# initialize optimization algorithm based on CVaR-SamplingVQE
opt_alg = MinimumEigenOptimizer(vqe)
# solve problem
results[alpha] = opt_alg.solve(qp)
# print results
print("alpha = {}:".format(alpha))
print(results[alpha].prettyprint())
print()
# plot resulting history of objective values
plt.figure(figsize=(10, 5))
plt.plot([0, maxiter], [opt_result.fval, opt_result.fval], "r--", linewidth=2, label="optimum")
for alpha in alphas:
plt.plot(objectives[alpha], label="alpha = %.2f" % alpha, linewidth=2)
plt.legend(loc="lower right", fontsize=14)
plt.xlim(0, maxiter)
plt.xticks(fontsize=14)
plt.xlabel("iterations", fontsize=14)
plt.yticks(fontsize=14)
plt.ylabel("objective value", fontsize=14)
plt.show()
# evaluate and sort all objective values
objective_values = np.zeros(2**n)
for i in range(2**n):
x_bin = ("{0:0%sb}" % n).format(i)
x = [0 if x_ == "0" else 1 for x_ in reversed(x_bin)]
objective_values[i] = qp.objective.evaluate(x)
ind = np.argsort(objective_values)
# evaluate final optimal probability for each alpha
for alpha in alphas:
probabilities = np.fromiter(
results[alpha].min_eigen_solver_result.eigenstate.binary_probabilities().values(),
dtype=float,
)
print("optimal probability (alpha = %.2f): %.4f" % (alpha, probabilities[ind][-1:]))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.