repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_jakarta')
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
def bernstein_vazirani(s):
ls = len(s)
qc = QuantumCircuit(ls+1,ls)
qc.h(range(ls))
qc.x(ls)
qc.h(ls)
qc.barrier();
for ii, yesno in enumerate(reversed(s)): # the black box
if yesno == '1':
qc.cx(ii, ls);
qc.barrier();
qc.h(range(ls));
qc.barrier();
qc.measure(range(ls),range(ls))
return qc
s = '011' # secretnumber
qc = bernstein_vazirani(s)
qc.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
jobE = execute(qc, backend = device, shots = nshots)
job_monitor(jobE)
jobS = execute(qc, backend = simulator, shots = nshots)
plot_histogram([jobS.result().get_counts(0), jobE.result().get_counts(0)],
bar_labels = False, legend = ['sim', 'exp'])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibm_nairobi')
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
qr = QuantumRegister(4); cr = ClassicalRegister(4); qc = QuantumCircuit(qr,cr)
qc.h([0,1])
qc.barrier()
qc.cx(0,2); qc.cx(0,3); qc.cx(1,2); qc.cx(1,3) # oraculo
qc.barrier()
qc.measure([2,3],[2,3])
qc.barrier()
qc.h([0,1]); qc.measure([0,1],[0,1])
qc.draw(output='mpl')
jobS = execute(qc, backend = simulator, shots = nshots)
jobE = execute(qc, backend = device, shots = nshots)
job_monitor(jobE)
plot_histogram([jobS.result().get_counts(0), jobE.result().get_counts(0)],
bar_labels = False, legend = ['sim', 'exp'])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
2*acos(sqrt(2/3)), 2*asin(sqrt(1/3)).
cos(2*pi/3), sin(2*pi/3), cos(4*pi/3), sin(4*pi/3), cos(8*pi/3), sin(8*pi/3)
cos(2*pi/3), sin(2*pi/3), cos(4*pi/3), sin(4*pi/3), cos(8*pi/3), sin(8*pi/3)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
rx,ry,rz = symbols('r_x r_y r_z')
rho1qb = (1/2)*(id(2) + rx*pauli(1) + ry*pauli(2) + rz*pauli(3))
rho1qb
pI,pX,pZ,pY = symbols('p_I p_X p_Z p_Y')
K0 = sqrt(pI)*id(2); K1 = sqrt(pX)*pauli(1); K2 = sqrt(pZ)*pauli(3); K3 = sqrt(pY)*pauli(2)
rho_p = K0*rho1qb*K0 + K1*rho1qb*K1 + K2*rho1qb*K2 + K3*rho1qb*K3
simplify(rho_p)
p = symbols('p')
pI = (1+3*p)/4; pX = (1-p)/4; pY = pX; pZ = pX
rho_p = K0*rho1qb*K0 + K1*rho1qb*K1 + K2*rho1qb*K2 + K3*rho1qb*K3
simplify(rho_p)
import numpy as np
from matplotlib import pyplot as plt
p = np.arange(0,1.1,0.1) # PD channel
C = np.sqrt(1-p)
plt.plot(p,C)
plt.show()
from sympy import *
N,p = symbols('N p')
K0 = sqrt(1-N)*Matrix([[1,0],[0,sqrt(1-p)]])
K1 = sqrt(1-N)*Matrix([[0,sqrt(p)],[0,0]])
K2 = sqrt(N)*Matrix([[sqrt(1-p),0],[0,1]])
K3 = sqrt(N)*Matrix([[0,0],[sqrt(p),0]])
#K0
r00,r01,r10,r11 = symbols('r_{00} r_{01} r_{10} r_{11}')#; r00
rho = Matrix([[r00,r01],[r10,r11]])#; rho
rho_gad = K0*rho*K0 + K1*rho*K1.T + K2*rho*K2 + K3*rho*K3.T
simplify(rho_gad)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
cos(-2*pi/3), sin(-2*pi/3), cos(-4*pi/3), sin(-4*pi/3), cos(-8*pi/3), sin(-8*pi/3)
|
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/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
1 + cos(2*pi/3) + 1j*sin(2*pi/3) + cos(4*pi/3) + 1j*sin(4*pi/3)
1 + cos(4*pi/3) + 1j*sin(4*pi/3) + cos(8*pi/3) + 1j*sin(8*pi/3)
cos(2*pi/3), cos(4*pi/3)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_lima')
from qiskit.tools.visualization import plot_histogram
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
def qc_ent_dist():
qc = QuantumCircuit(2, name = 'E dist')
qc.h([0]); qc.cx(0, 1)
return qc
qc_ent_dist_ = qc_ent_dist(); qc_ent_dist_.draw(output = 'mpl')
def qc_bb_cb():
qc = QuantumCircuit(2, name = 'BB->CB')
qc.cx(0,1); qc.h(0)
return qc
qc_bb_cb_ = qc_bb_cb(); qc_bb_cb_.draw(output = 'mpl')
def qc_teleport(th, ph, lb):
qc = QuantumCircuit(3)
qc_ent_dist_ = qc_ent_dist(); qc.append(qc_ent_dist_, [1, 2]) # distribuição de emaranhamento
qc.barrier()
qc.u(th, ph, lb, [0]) # Preparação do estado a ser teletransportado
qc.barrier()
qc_bb_cb_ = qc_bb_cb(); qc.append(qc_bb_cb_, [0, 1]) # Base de Bell para base computacional
qc.barrier()
qc.cx(1, 2); qc.cz(0, 2) # infor clássica + unitária de Bob
return qc
qc_teleport_ = qc_teleport(0.1, 0.5, 0); qc_teleport_.decompose().draw(output = 'mpl')
import numpy as np
import math
th, ph, lb = 0, 0, 0;
rho_teo = np.array([[math.cos(th/2)**2, (math.cos(ph)+1j*math.sin(ph))*math.sin(th/2)*math.cos(th/2)],
[(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2)*math.cos(th/2), math.sin(th/2)**2]])
qc_teleport_ = qc_teleport(0.1, 0.5, 0)
qstc = state_tomography_circuits(qc_teleport_, [2])
# simulação
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho_sim = qstf.fit(method='lstsq')
print('rho_teo = ', rho_teo)
print('rho_sim = ', rho_sim)
# experimento
job = qiskit.execute(qstc, backend = device, shots = nshots)
job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc)
rho_exp = qstf.fit(method = 'lstsq')
print('rho_exp = ', rho_exp)
F = qiskit.quantum_info.state_fidelity(rho_teo, rho_exp); print('F = ', F)
# variar th em cos(th/2)|0>+exp(i*ph)sin(th/2)|1>
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
device = provider.get_backend('ibmq_bogota')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from qiskit.quantum_info import state_fidelity
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibm_nairobi')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
from qiskit.tools.visualization import plot_histogram
q0 = QuantumRegister(1); q1 = QuantumRegister(1); q2 = QuantumRegister(1); q3 = QuantumRegister(1)
c0 = ClassicalRegister(1); c1 = ClassicalRegister(1); c2 = ClassicalRegister(1); c3 = ClassicalRegister(1)
qc = QuantumCircuit(q0,q1,q2,q3,c0,c1,c2,c3)
# q0 e q1 estao com Alice, q2 com Charlies e q3 com Bob
qc.h(q1); qc.cx(q1,q2); qc.cx(q2,q3) # prepara o estado GHZ
qc.barrier()
#qc.sdg(q0); qc.h(q0) # prepara o estado a ser teletransportado (y+)
# prepara o estado |0>
qc.barrier()
qc.cx(q0,q1); qc.h(q0); qc.measure(q0,c0); qc.measure(q1,c1) # Medida de Alice na base de Bell
qc.h(q2); qc.measure(q2,c2) # medida de Charlie na base +,-
qc.barrier()
qc.z(q3).c_if(c0, 1) # acao de Bob condicionada no 1º cbit enviado por Alice
qc.x(q3).c_if(c1, 1) # acao de Bob condicionada no 2º cbit enviado por Alice
qc.z(q3).c_if(c2, 1) # acao de Bob condicionada no cbit enviado por Charlie
qc.barrier()
#qc.sdg(q3); qc.h(q3); qc.measure(q3,c3) # passa da base circular pra computacional
qc.measure(q3,c3) # mede na base computacional
qc.draw(output='mpl')
jobS = execute(qc, backend = simulator, shots = nshots)
plot_histogram(jobS.result().get_counts(qc))
jobE = execute(qc, backend = device, shots = nshots)
job_monitor(jobE)
tqc = transpile(qc, device)
jobE = device.run(tqc)
job_monitor(jobE)
plot_histogram([jobS.result().get_counts(0), jobE.result().get_counts(0)],
bar_labels = False, legend = ['sim', 'exp'])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
device = provider.get_backend('ibmq_lima')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from qiskit.quantum_info import state_fidelity
def qc_qft(n):
qr = QuantumRegister(n); qc = QuantumCircuit(qr, name = 'QFT')
for l in range(0, n):
qc.h(qr[l])
if l < n-1:
for q in range(l+1, n):
lb = 2*math.pi*2**(-q+l-1)
qc.cp(lb, qr[q], qr[l])
#qc.barrier()
#qc.barrier()
if n%2 == 0:
ul = n//2
else:
ul = (n-1)//2
for p in range(0, ul):
qc.swap(p, n-1-p)
return qc
n = 4; qc_qft_ = qc_qft(n); qc_qft_.draw(output='mpl')
def qc_iqft(n):
qr = QuantumRegister(n); qc = QuantumCircuit(qr, name = 'IQFT')
if n%2 == 0:
ul = n//2
else:
ul = (n-1)//2
for p in range(ul-1, -1, -1):
qc.swap(p, n-1-p)
#qc.barrier()
for l in range(n-1, -1, -1):
if l < n-1:
for q in range(n-1, l+1-1, -1):
lb = -2*math.pi*2**(-q+l-1)#; print(lb)
qc.cp(lb, qr[q], qr[l])
qc.h(qr[l])
#qc.barrier()
return qc
n = 4; qc_iqft_ = qc_iqft(n); qc_iqft_.draw(output='mpl')
#x0 = 1 + 0*1j; x1 = 0 + 0*1j # estado |0>
#x0 = 0 + 0*1j; x1 = 1 + 0*1j # estado |1>
x0 = 1/math.sqrt(2) + 0*1j; x1 = 1/math.sqrt(2) + 0*1j # estado |+>
mx0 = math.sqrt(x0.real**2 + x0.imag**2)
if x0.real != 0:
ph0 = math.atan(x0.imag/x0.real)
elif x0.real == 0 and x0.imag != 0:
ph0 = math.pi/2
elif x0.real == 0 and x0.imag == 0:
ph0 = 0
mx1 = math.sqrt(x1.real**2 + x1.imag**2)
if x1.real != 0:
ph1 = math.atan(x1.imag/x1.real)
elif x1.real == 0 and x1.imag != 0:
ph1 = math.pi/2
elif x1.real == 0 and x1.imag == 0:
ph1 = 0
print('|x0|=',mx0,', ph0=', ph0,', |x1|=', mx1,', ph1=', ph1)
th = 2*math.acos(mx1); ph = ph1-ph0+math.pi; lb = ph0-math.pi
print('th=',th,', ph=', ph,', lb=', lb)
n = 1
qr = QuantumRegister(n); qc = QuantumCircuit(qr)
qc.x(qr[0]); qc.u(th, ph, lb, qr[0]); qc.barrier()
qc_qft_ = qc_qft(n); qft = qc_qft_.to_gate(); qc.append(qft, [0])
qc.draw(output='mpl')
svsimulator = Aer.get_backend('statevector_simulator')
job = execute(qc, backend = svsimulator, shots = 1, memory = True)
print(job.result().get_statevector(qc))
def tfc(x): # classical discrete Fourier transform
d = len(x)
y = np.zeros(d, dtype = complex)
for k in range(0, d):
for j in range(0, d):
y[k] += x[j]*(math.cos(2*math.pi*j*k/d) + 1j*math.sin(2*math.pi*j*k/d))
return y/math.sqrt(d)
d = 4; x = np.zeros(d, dtype = complex);
#x = [1/2, 1/2, 1/2, 1/2]
x = [-1/2, -1/2, 1/2, 1/2]
y = tfc(x); print(y)
n = 2
qr = QuantumRegister(n); qc = QuantumCircuit(qr)
#qc.h([0,1]); qc.barrier() # ok
qc.x([0]); qc.h([0,1]); qc.barrier() # ok a menos de uma fase global de pi
qc_qft_ = qc_qft(n); qft = qc_qft_.to_gate(); qc.append(qft, [0,1])
qc.draw(output='mpl')
svsimulator = Aer.get_backend('statevector_simulator')
job = execute(qc, backend = svsimulator, shots = 1, memory = True)
print(job.result().get_statevector(qc)) # para >1 qubit tem a questao da ordem da bc
d = 4; x = np.zeros(d, dtype = complex);
x = [math.sqrt(1/6), math.sqrt(1/6), math.sqrt(2/3), 0]
y = tfc(x); print(y)
n = 3
qr = QuantumRegister(n); cr = ClassicalRegister(n); qc = QuantumCircuit(qr, cr)
qc.x([0,2]); qc.barrier()
qc_qft_ = qc_qft(n); qft = qc_qft_.to_gate(); qc.append(qft, [0,1,2]); qc.barrier()
qc_iqft_ = qc_iqft(n); iqft = qc_iqft_.to_gate(); qc.append(iqft, [0,1,2]); qc.barrier()
qc.measure([0,1,2],[0,1,2])
qc.draw(output='mpl')
job_sim = execute(qc, backend = simulator, shots = nshots)
job_exp = execute(qc, backend = device, shots = nshots)
job_monitor(job_exp)
plot_histogram([job_sim.result().get_counts(), job_exp.result().get_counts()],
legend = ['sim', 'exp'])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_jakarta')
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
def bernstein_vazirani(s):
ls = len(s)
qc = QuantumCircuit(ls+1,ls)
qc.h(range(ls))
qc.x(ls)
qc.h(ls)
qc.barrier();
for ii, yesno in enumerate(reversed(s)): # the black box
if yesno == '1':
qc.cx(ii, ls);
qc.barrier();
qc.h(range(ls));
qc.barrier();
qc.measure(range(ls),range(ls))
return qc
s = '011' # secretnumber
qc = bernstein_vazirani(s)
qc.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
jobE = execute(qc, backend = device, shots = nshots)
job_monitor(jobE)
jobS = execute(qc, backend = simulator, shots = nshots)
plot_histogram([jobS.result().get_counts(0), jobE.result().get_counts(0)],
bar_labels = False, legend = ['sim', 'exp'])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibm_nairobi')
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
qr = QuantumRegister(4); cr = ClassicalRegister(4); qc = QuantumCircuit(qr,cr)
qc.h([0,1])
qc.barrier()
qc.cx(0,2); qc.cx(0,3); qc.cx(1,2); qc.cx(1,3) # oraculo
qc.barrier()
qc.measure([2,3],[2,3])
qc.barrier()
qc.h([0,1]); qc.measure([0,1],[0,1])
qc.draw(output='mpl')
jobS = execute(qc, backend = simulator, shots = nshots)
jobE = execute(qc, backend = device, shots = nshots)
job_monitor(jobE)
plot_histogram([jobS.result().get_counts(0), jobE.result().get_counts(0)],
bar_labels = False, legend = ['sim', 'exp'])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
2*acos(sqrt(2/3)), 2*asin(sqrt(1/3)).
cos(2*pi/3), sin(2*pi/3), cos(4*pi/3), sin(4*pi/3), cos(8*pi/3), sin(8*pi/3)
cos(2*pi/3), sin(2*pi/3), cos(4*pi/3), sin(4*pi/3), cos(8*pi/3), sin(8*pi/3)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
cos(-2*pi/3), sin(-2*pi/3), cos(-4*pi/3), sin(-4*pi/3), cos(-8*pi/3), sin(-8*pi/3)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
list_bin = []
for j in range(0,2**4):
b = "{:04b}".format(j)
list_bin.append(b)
print(list_bin)
list_int = []
for j in range(0,2**4):
list_int.append(int(list_bin[j],2))
print(list_int)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
c00,c01,c10,c11 = symbols('c_{00} c_{01} c_{10} c_{11}')
psiAB = Matrix([[c00],[c01],[c10],[c11]]); psiAB
rhoAB = psiAB*conjugate(psiAB.T); rhoAB
rhoA = ptraceB(2,2,rhoAB); rhoB = ptraceA(2,2,rhoAB)
rhoA, rhoB
pauli(3)*pauli(1)*pauli(3), pauli(3)*pauli(2)*pauli(3), comm(pauli(3),pauli(1)), comm(pauli(3),pauli(2))
%run init.ipynb
def pTraceL_num(dl, dr, rhoLR):
rhoR = np.zeros((dr, dr), dtype=complex)
for j in range(0, dr):
for k in range(j, dr):
for l in range(0, dl):
rhoR[j,k] += rhoLR[l*dr+j,l*dr+k]
if j != k:
rhoR[k,j] = np.conj(rhoR[j,k])
return rhoR
def pTraceR_num(dl, dr, rhoLR):
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
def coh_l1(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
from numpy import linalg as LA
def Econc_(rho):
s2 = np.array([[0,-1j],[1j,0]])
R = rho@np.kron(s2,s2)@np.matrix.conjugate(rho)@np.kron(s2,s2)
w, v = LA.eig(R)
evm = max(abs(w[0]), abs(w[1]), abs(w[2]), abs(w[3]))
Ec = 2*math.sqrt(abs(evm)) - math.sqrt(abs(w[0])) - math.sqrt(abs(w[1]))\
- math.sqrt(abs(w[2])) - math.sqrt(abs(w[3]))
if Ec < 0.0:
Ec = 0.0
return Ec
import scipy.linalg.lapack as lapak
def Econc(rho):
s2 = np.array([[0,-1j],[1j,0]])
R = rho@np.kron(s2,s2)@np.matrix.conjugate(rho)@np.kron(s2,s2)
ev = lapak.zheevd(R)
evm = max(abs(ev[0][0]), abs(ev[0][1]), abs(ev[0][2]), abs(ev[0][3]))
Ec = 2*math.sqrt(abs(evm)) - math.sqrt(abs(ev[0][0])) - math.sqrt(abs(ev[0][1]))\
- math.sqrt(abs(ev[0][2])) - math.sqrt(abs(ev[0][3]))
if Ec < 0.0:
Ec = 0.0
return Ec
def concurrence_psi(rho):
rho_r = pTraceL_num(2,2,rho)
return math.sqrt(2*abs(1-np.matrix.trace(rho_r@rho_r)))
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
import qiskit
from qiskit import *
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_manila')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
E_sim_10 = np.zeros(N); C_sim_0 = np.zeros(N); P_sim_0 = np.zeros(N)
jobs_ids = []
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# tomografia
qstc = state_tomography_circuits(qc, [qr[1],qr[2]])
job_sim = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_10_sim = qstf_sim.fit(method='lstsq')
E_sim_10[j] = concurrence_psi(rho_10_sim)
rho_0_sim = pTraceL_num(2, 2, rho_10_sim)
C_sim_0[j] = coh_l1(rho_0_sim)
P_sim_0[j] = predict_jb(rho_0_sim)
qc.draw(output='mpl')
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
jobs_ids = []
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# tomografia
qstc = state_tomography_circuits(qc, [qr[1],qr[2]])
job_exp = qiskit.execute(qstc, backend = device, shots=nshots)
jobs_ids.append(job_exp.job_id())
print(job_exp.job_id())
job_monitor(job_exp)
print(jobs_ids)
f = open("jobs_ids_ES_pre_bbm.txt", "w")
f.write(str(jobs_ids))
f.close()
f = open("jobs_ids_ES_pre_bbm.txt","r")
#jobs_ids_list = f.read()
list_ids = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
list_ids[0]
print(list_ids)
print(jobs_ids_list)
len_ids = len('6368049443e1f0708afdaf73')
print(len_ids)
list_ids = []
for j in range(0,N):
s = 0
if j > 0:
s = 2
print(jobs_ids_list[(j*(len_ids+2+s)+2):(j+1)*(len_ids+2)+j*s])
list_ids.append(jobs_ids_list[(j*(len_ids+2+s)+2):(j+1)*(len_ids+2)+j*s])
list_ids[0]
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
E_exp_10 = np.zeros(N); C_exp_0 = np.zeros(N); P_exp_0 = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids[j])
qstf_exp = StateTomographyFitter(job.result(), qstc)
rho_10_exp = qstf_exp.fit(method='lstsq');
E_exp_10[j] = Econc_(rho_10_exp)
print(E_exp_10[j])
rho_0_exp = pTraceL_num(2, 2, rho_10_exp)
C_exp_0[j] = coh_l1(rho_0_exp)
P_exp[j] = predict_jb(rho_0_exp)
import matplotlib
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (7,5), dpi = 100)
q = np.arange(0,1.01,0.01)
Ei2 = 4*q*(1-q)
Ci2 = (2*q-1)**2
Pi2 = np.zeros(len(q))
Pm = 1-2*q*(1-q)
plt.plot(q, Ei2, '-', label=r'$E_{conc}(\xi_{AC})^2$')
plt.plot(q, Ci2, '--', label=r'$C_{l_1}(\xi_C)^2$')
plt.plot(q, Pi2, '-.', label=r'$P(\xi_C)^2$')
plt.plot(q, Ei2+Ci2, ':', label=r'$E_{conc}(\xi_{AC})^{2}+C_{l_{1}}(\xi_{C})^{2}+P(\xi_C)^2$')
plt.plot(q_exp, E_sim_10**2, 'X', label=r'$E_{conc}(\xi_{AC})^2_{sim}$')
plt.plot(q_exp, C_sim_0**2, 'h', label=r'$C_{l_1}(\xi_C)^2_{sim}$')
plt.plot(q_exp, P_sim_0**2, '>', label=r'$P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_sim_10**2+C_sim_0**2+P_sim_0**2, '*', label=r'$E_{conc}(\xi_{AC})^{2}_{sim}+C_{l_{1}}(\xi_{C})^{2}_{sim}+P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_exp_10**2, 's', label=r'$E_{conc}(\xi_{AC})^2_{exp}$')
plt.plot(q_exp, C_exp_0**2, 'o', label=r'$C_{l_1}(\xi_C)^2_{exp}$')
plt.plot(q_exp, P_exp_0**2, 'v', label=r'$P(\xi_C)^2_{exp}$')
plt.plot(q_exp, E_exp_10**2+C_exp_0**2+P_exp_0**2, 'd', label=r'$E_{conc}(\xi_{AC})^{2}_{exp}+C_{l_{1}}(\xi_{C})^{2}_{exp}+P(\xi_C)^2_{exp}$')
plt.legend(bbox_to_anchor=(1.75, 1.0), loc='upper right')
plt.xlabel(r'$q$')
plt.show()
# error mitigation
qr = QuantumRegister(5); qubit_list = [1,2]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('636d895d04e46a1feb6227a9')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
for j in range(0,N):
job = device.retrieve_job(list_ids[j])
mitigated_results = meas_fitter.filter.apply(job.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_10_exp = qstf_exp.fit(method='lstsq');
E_exp_10[j] = Econc_(rho_10_exp)
print(E_exp_10[j])
rho_0_exp = pTraceL_num(2, 2, rho_10_exp)
C_exp_0[j] = coh_l1(rho_0_exp)
P_exp[j] = predict_jb(rho_0_exp)
import matplotlib
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (7,5), dpi = 100)
q = np.arange(0,1.01,0.01)
Ei2 = 4*q*(1-q)
Ci2 = (2*q-1)**2
Pi2 = np.zeros(len(q))
Pm = 1-2*q*(1-q)
plt.plot(q, Ei2, '-', label=r'$E_{conc}(\xi_{AC})^2$')
plt.plot(q, Ci2, '--', label=r'$C_{l_1}(\xi_C)^2$')
plt.plot(q, Pi2, '-.', label=r'$P(\xi_C)^2$')
plt.plot(q, Ei2+Ci2, ':', label=r'$E_{conc}(\xi_{AC})^{2}+C_{l_{1}}(\xi_{C})^{2}+P(\xi_C)^2$')
plt.plot(q_exp, E_sim_10**2, 'X', label=r'$E_{conc}(\xi_{AC})^2_{sim}$')
plt.plot(q_exp, C_sim_0**2, 'h', label=r'$C_{l_1}(\xi_C)^2_{sim}$')
plt.plot(q_exp, P_sim_0**2, '>', label=r'$P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_sim_10**2+C_sim_0**2+P_sim_0**2, '*', label=r'$E_{conc}(\xi_{AC})^{2}_{sim}+C_{l_{1}}(\xi_{C})^{2}_{sim}+P(\xi_C)^2_{sim}$')
plt.plot(q_exp, E_exp_10**2, '^', label=r'$E_{conc}(\xi_{AC})^2_{exp}$')
plt.plot(q_exp, C_exp_0**2, 'o', label=r'$C_{l_1}(\xi_C)^2_{exp}$')
plt.plot(q_exp, P_exp_0**2, '.', label=r'$P(\xi_C)^2_{exp}$')
plt.plot(q_exp, E_exp_10**2+C_exp_0**2+P_exp_0**2, 'd', label=r'$E_{conc}(\xi_{AC})^{2}_{exp}+C_{l_{1}}(\xi_{C})^{2}_{exp}+P(\xi_C)^2_{exp}$')
plt.legend(bbox_to_anchor=(1.75, 1.0), loc='upper right')
plt.xlabel(r'$q$')
plt.savefig('fig_Eswap_pre_bbm.pdf')
plt.show()
qc.draw(output='mpl')
def pTrace_3_num(rho_abc, da, db, dc):
rho_ac = np.zeros(da*dc*da*dc, dtype=complex).reshape(da*dc,da*dc)
for j in range(0,da):
for l in range(0,dc):
cj = j*dc+l
ccj = j*db*dc+l
for m in range(0,da):
for o in range(0,dc):
ck = m*dc+o
cck = m*db*dc+o
for k in range(0,db):
rho_ac[cj,ck] = rho_ac[cj,ck] + rho_abc[ccj+k*dc,cck+k*dc]
return rho_ac
import numpy as np
import math
# projetores para a pos-seleção
I2 = np.array([[1,0],[0,1]], dtype=complex)
P00 = np.kron(np.kron(I2,np.array([[1,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,0]],dtype=complex)), I2) # PhiP
P01 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,1,0,0],[0,0,0,0],[0,0,0,0]],dtype=complex)), I2) # PsiP
P10 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,0,0,0],[0,0,1,0],[0,0,0,0]],dtype=complex)), I2) # PhiM
P11 = np.kron(np.kron(I2,np.array([[0,0,0,0],[0,0,0,0],[0,0,0,0],[0,0,0,1]],dtype=complex)), I2) # PsiM
#P00+P01+P10+P11
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
E_phiP_04_sim = np.zeros(N); E_psiM_04_sim = np.zeros(N)
E_psiP_04_sim = np.zeros(N); E_phiM_04_sim = np.zeros(N)
C2_sim = np.zeros(N)
for j in range(0,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[0])
qc.cx(qr[0],qr[1])
qc.h([qr[0],qr[1]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# BBM
qc.cx(qr[1],qr[3])
qc.h(qr[1])
# circuito para tomografia
qstc = state_tomography_circuits(qc, [qr[4],qr[3],qr[1],qr[0]])
# Simulacao
job_sim = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_4310_sim = qstf_sim.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_sim@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_sim@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_sim@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_sim@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_sim[j] = Econc_(rho_PhiP_04)
E_phiM_04_sim[j] = Econc_(rho_PhiM_04)
E_psiP_04_sim[j] = Econc_(rho_PsiP_04)
E_psiM_04_sim[j] = Econc_(rho_PsiM_04)
C2_sim[j] = 1 - 2*(pr_phiP+pr_psiP)
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_manila')
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
th_xi = np.zeros(N); th_xi = 2*np.arccos(np.sqrt(1-q_exp))
th_eta = np.zeros(N); th_eta = 2*np.arccos(np.sqrt(q_exp))
#jobs_ids2 = []
for j in range(N-1,N):
qr = QuantumRegister(5); qc = QuantumCircuit(qr)
# prepara xi
qc.u(th_xi[j],0,0,qr[1])
qc.cx(qr[1],qr[2])
qc.h([qr[1],qr[2]])
# prepara eta
qc.u(th_eta[j],0,0,qr[3])
qc.cx(qr[3],qr[4])
qc.h([qr[3],qr[4]])
# BBM
qc.cx(qr[2],qr[3])
qc.h(qr[2])
# circuito para tomografia
qstc = state_tomography_circuits(qc, [qr[4],qr[3],qr[2],qr[1]])
# Experimento
job_exp = qiskit.execute(qstc, backend = device, shots=nshots)
#jobs_ids2.append(job_exp.job_id())
print(job_exp.job_id())
job_monitor(job_exp)
jobs_ids2.append('636e2c8910cc1925ad755b77')
qc.draw(output='mpl')
f = open("jobs_ids_ES_post_bbm.txt", "w")
f.write(str(jobs_ids2))
f.close()
f = open("jobs_ids_ES_post_bbm.txt","r")
list_ids2 = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
print(list_ids2)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
E_phiP_04_exp = np.zeros(N); E_psiM_04_exp = np.zeros(N)
E_psiP_04_exp = np.zeros(N); E_phiM_04_exp = np.zeros(N)
C2_exp = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids2[j])
qstf_exp = StateTomographyFitter(job.result(), qstc)
rho_4310_exp = qstf_exp.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_exp@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_exp@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_exp@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_exp@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_exp[j] = Econc_(rho_PhiP_04)
E_phiM_04_exp[j] = Econc_(rho_PhiM_04)
E_psiP_04_exp[j] = Econc_(rho_PsiP_04)
E_psiM_04_exp[j] = Econc_(rho_PsiM_04)
C2_exp[j] = 1 - 2*(pr_phiP+pr_psiP)
print(C2_exp[j])
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (6,4), dpi = 100)
q = np.arange(0,1.01,0.01)
Ep = np.ones(len(q)); Em = (2*q*(1-q))/(1-2*q+2*q**2); C2 = 1-4*q*(1-q)
plt.plot(q, Ep, '-', label=r'$E(\hat{\phi}_+)=E(\hat{\psi}_+)$')
plt.plot(q, Em, '--', label=r'$E(\hat{\phi}_-)=E(\hat{\psi}_-)$')
plt.plot(q, C2, '-.', label=r'$1-2(Pr(\hat{\phi}_+)+Pr(\hat{\psi}_+))$')
plt.plot(q_exp, E_phiP_04_sim, 'o', label=r'$E(\hat{\phi}_+)_{sim}$')
plt.plot(q_exp, E_phiM_04_sim, '*', label=r'$E(\hat{\phi}_-)_{sim}$')
#plt.plot(q_exp, E_psiP_04_sim, 'X', label=r'$E(\hat{\psi}_+)_{sim}$')
#plt.plot(q_exp, E_psiM_04_sim, '.', label=r'$E(\hat{\psi}_-)_{sim}$')
plt.plot(q_exp, C2_sim, 'X', label=r'$1-2(Pr(\hat{\phi}_+)_{sim}+Pr(\hat{\psi}_+)_{sim})$')
plt.plot(q_exp, E_phiP_04_exp, '<', label=r'$E(\hat{\phi}_+)_{exp}$')
plt.plot(q_exp, E_phiM_04_exp, '>', label=r'$E(\hat{\phi}_-)_{exp}$')
#plt.plot(q_exp, E_psiP_04_exp, '^', label=r'$E(\hat{\psi}_+)_{exp}$')
#plt.plot(q_exp, E_psiM_04_exp, '.', label=r'$E(\hat{\psi}_-)_{exp}$')
plt.plot(q_exp, C2_exp, '^', label=r'$1-2(Pr(\hat{\phi}_+)_{exp}+Pr(\hat{\psi}_+)_{exp})$')
plt.xlabel(r'$q$')
plt.legend(bbox_to_anchor=(1.8, 1.0), loc='upper right')
plt.show()
# error mitigation
qr = QuantumRegister(5)#; qc = QuantumCircuit(qr)
qubit_list = [1,2,3,4]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('636e3407fb0a57272187586a')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
q_exp = np.arange(0,1.1,0.1); N = len(q_exp)
q_exp[0] = 0.03; q_exp[N-1] = 1-q_exp[0]
E_phiP_04_exp = np.zeros(N); E_psiM_04_exp = np.zeros(N)
E_psiP_04_exp = np.zeros(N); E_phiM_04_exp = np.zeros(N)
C2_exp = np.zeros(N)
for j in range(0,N):
job = device.retrieve_job(list_ids2[j])
mitigated_results = meas_fitter.filter.apply(job.result()) # error mitigation
qstf_exp = StateTomographyFitter(mitigated_results, qstc) # error mitigation
rho_4310_exp = qstf_exp.fit(method='lstsq')
# pos-selecao
rho_PhiP = P00@rho_4310_exp@P00
pr_phiP = np.real(np.trace(rho_PhiP))
rho_PhiP = (1/pr_phiP)*rho_PhiP
rho_PsiP = P01@rho_4310_exp@P01
pr_psiP = np.real(np.trace(rho_PsiP))
rho_PsiP = (1/pr_psiP)*rho_PsiP
rho_PhiM = P10@rho_4310_exp@P10
pr_phiM = np.real(np.trace(rho_PhiM))
rho_PhiM = (1/pr_phiM)*rho_PhiM
rho_PsiM = P11@rho_4310_exp@P11
pr_psiM = np.real(np.trace(rho_PsiM))
rho_PsiM = (1/pr_psiM)*rho_PsiM
# estados reduzidos
rho_PhiP_04 = pTrace_3_num(rho_PhiP,2,4,2)
rho_PsiP_04 = pTrace_3_num(rho_PsiP,2,4,2)
rho_PhiM_04 = pTrace_3_num(rho_PhiM,2,4,2)
rho_PsiM_04 = pTrace_3_num(rho_PsiM,2,4,2)
# emaranhamentos e probabilidades
E_phiP_04_exp[j] = Econc_(rho_PhiP_04)
E_phiM_04_exp[j] = Econc_(rho_PhiM_04)
E_psiP_04_exp[j] = Econc_(rho_PsiP_04)
E_psiM_04_exp[j] = Econc_(rho_PsiM_04)
C2_exp[j] = 1 - 2*(pr_phiP+pr_psiP)
print(C2_exp[j])
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':11}); plt.figure(figsize = (6,4), dpi = 100)
q = np.arange(0,1.01,0.01)
Ep = np.ones(len(q)); Em = (2*q*(1-q))/(1-2*q+2*q**2); C2 = 1-4*q*(1-q)
plt.plot(q, Ep, '-', label=r'$E(\hat{\phi}_+)=E(\hat{\psi}_+)$')
plt.plot(q, Em, '--', label=r'$E(\hat{\phi}_-)=E(\hat{\psi}_-)$')
plt.plot(q, C2, '-.', label=r'$1-2(Pr(\hat{\phi}_+)+Pr(\hat{\psi}_+))$')
plt.plot(q_exp, E_phiP_04_sim, 'o', label=r'$E(\hat{\phi}_+)_{sim}$')
plt.plot(q_exp, E_phiM_04_sim, '*', label=r'$E(\hat{\phi}_-)_{sim}$')
#plt.plot(q_exp, E_psiP_04_sim, 'X', label=r'$E(\hat{\psi}_+)_{sim}$')
#plt.plot(q_exp, E_psiM_04_sim, '.', label=r'$E(\hat{\psi}_-)_{sim}$')
plt.plot(q_exp, C2_sim, 'X', label=r'$1-2(Pr(\hat{\phi}_+)_{sim}+Pr(\hat{\psi}_+)_{sim})$')
plt.plot(q_exp, E_phiP_04_exp, '<', label=r'$E(\hat{\phi}_+)_{exp}$')
plt.plot(q_exp, E_phiM_04_exp, '>', label=r'$E(\hat{\phi}_-)_{exp}$')
#plt.plot(q_exp, E_psiP_04_exp, '^', label=r'$E(\hat{\psi}_+)_{exp}$')
#plt.plot(q_exp, E_psiM_04_exp, '.', label=r'$E(\hat{\psi}_-)_{exp}$')
plt.plot(q_exp, C2_exp, '^', label=r'$1-2(Pr(\hat{\phi}_+)_{exp}+Pr(\hat{\psi}_+)_{exp})$')
plt.xlabel(r'$q$')
plt.legend(bbox_to_anchor=(1.8, 1.0), loc='upper right')
plt.savefig('fig_Eswap_post_bbm.pdf')
plt.show()
C = np.arange(0,1.1,0.1);
E_PhiP = (1-C**2)/(1+C**2)
E_PhiM = np.ones(len(C))
plt.plot(C, E_PhiP, '*'); plt.plot(C, E_PhiM, '.')
plt.show()
from qiskit import *
qr = QuantumRegister(4);
%run init.ipynb
p,q = symbols('p q')
ket_xi = Matrix([[sqrt(p)],[sqrt((1-p)/2)],[sqrt((1-p)/2)],[0]])
ket_eta = Matrix([[sqrt(q)],[sqrt((1-q)/2)],[sqrt((1-q)/2)],[0]])
ket_xi, ket_eta
rho_xi = ket_xi*ket_xi.T
rho_eta = ket_eta*ket_eta.T
rho_xi, rho_eta
def ptraceA(da, db, rho):
rhoB = zeros(db,db)
for j in range(0, db):
for k in range(0, db):
for l in range(0, da):
rhoB[j,k] += rho[l*db+j,l*db+k]
return rhoB
def ptraceB(da, db, rho):
rhoA = zeros(da,da)
for j in range(0, da):
for k in range(0, da):
for l in range(0, db):
rhoA[j,k] += rho[j*db+l,k*db+l]
return rhoA
rho_xi_A = ptraceB(2,2,rho_xi); rho_xi_C = ptraceA(2,2,rho_xi)
rho_xi_A, rho_xi_C
rho_eta_Cp = ptraceB(2,2,rho_eta); rho_eta_B = ptraceA(2,2,rho_eta)
rho_eta_Cp, rho_eta_B
c00,c01,c10,c11 = symbols('c_{00} c_{01} c_{10} c_{11}')
d00,d01,d10,d11 = symbols('d_{00} d_{01} d_{10} d_{11}')
def two_qb_basis():
zz = Matrix([[1],[0],[0],[0]])
zu = Matrix([[0],[1],[0],[0]])
uz = Matrix([[0],[0],[1],[0]])
uu = Matrix([[0],[0],[0],[1]])
return zz,zu,uz,uu
zz,zu,uz,uu = two_qb_basis(); zz,zu,uz,uu
def psi_p(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d00+c01*d10)*zz + (c00*d01+c01*d11)*zu + (c10*d00+c11*d10)*uz + (c10*d01+c11*d11)*uu
return psi/sqrt(2)
def psi_m(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d00-c01*d10)*zz + (c00*d01-c01*d11)*zu + (c10*d00-c11*d10)*uz + (c10*d01-c11*d11)*uu
return psi/sqrt(2)
def phi_p(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d10+c01*d00)*zz + (c00*d11+c01*d01)*zu + (c10*d10+c11*d00)*uz + (c10*d11+c11*d01)*uu
return psi/sqrt(2)
def phi_m(c00,c01,c10,c11,d00,d01,d10,d11):
zz,zu,uz,uu = two_qb_basis()
psi = (c00*d10-c01*d00)*zz + (c00*d11-c01*d01)*zu + (c10*d10-c11*d00)*uz + (c10*d11-c11*d01)*uu
return psi/sqrt(2)
c00 = sqrt(p); c01 = sqrt((1-p)/2); c10 = sqrt((1-p)/2); c11 = 0
d00 = sqrt(q); d01 = sqrt((1-q)/2); d10 = sqrt((1-q)/2); d11 = 0
psip = psi_p(c00,c01,c10,c11,d00,d01,d10,d11);
psim = psi_m(c00,c01,c10,c11,d00,d01,d10,d11)
phip = phi_p(c00,c01,c10,c11,d00,d01,d10,d11);
phim = phi_m(c00,c01,c10,c11,d00,d01,d10,d11)
simplify(psip), simplify(psim), simplify(phip), simplify(phim)
psip_norm2 = psip.T*psip; simplify(psip_norm2)
psim_norm2 = psim.T*psim; simplify(psim_norm2)
phip_norm2 = phip.T*phip; simplify(phip_norm2)
phim_norm2 = phim.T*phim; simplify(phim_norm2)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
0.4*7.6
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit_ibm_runtime import QiskitRuntimeService
# Save an IBM Quantum account.
QiskitRuntimeService.save_account(channel='ibm_quantum',
#channel='ibm_cloud',
token='17efde49764005e8eeb00dd065d44bc208778be72d44b475e508d20504818786f842988b0e506515c78debdd1b0c4b570717863db5e4f85569fb43c4c8626b8a',
overwrite=True)
service = QiskitRuntimeService(
channel='ibm_quantum',
instance='ibm-q/open/main'
#instance='ibm-q-research-2/federal-uni-sant-1/main'
)
program_inputs = {'iterations': 1}
options = {"backend_name": "ibmq_qasm_simulator"}
job = service.run(program_id="hello-world",
options=options,
inputs=program_inputs
)
#print(f"job id: {job.job_id()}")
result = job.result()
print(result)
backend = service.get_backend("ibmq_qasm_simulator")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.primitives import Estimator
from qiskit import QuantumCircuit
#circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
circuit = QuantumCircuit(2)
circuit.x(0)
circuit.draw(output='mpl')
observable = SparsePauliOp("IZ") # ordem ...210
#options = {"backend_name": "ibmq_qasm_simulator"}
estimator = Estimator()#options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
import math
qc1 = QuantumCircuit(2); qc2 = QuantumCircuit(2)
qc1.h(1)
qc2.h(0); qc2.p(-math.pi/2, 0)
circuits = (
#random_circuit(2, 2, seed=0).decompose(reps=1),
#random_circuit(2, 2, seed=1).decompose(reps=1),
qc1, qc2
)
observables = (
SparsePauliOp("XZ"),
SparsePauliOp("IY"),
)
estimator = Estimator()
job = estimator.run(circuits, observables)
result = job.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Observables: {[obs.paulis for obs in observables]}")
print(f" > Expectation values: {result.values.tolist()}")
print(f" > Metadata: {result.metadata}")
circuits = (
random_circuit(2, 2, seed=0).decompose(reps=1),
random_circuit(2, 2, seed=1).decompose(reps=1),
)
observables = (
SparsePauliOp("XZ"),
SparsePauliOp("IY"),
)
estimator = Estimator()
job_0 = estimator.run(circuits[0], observables[0])
job_1 = estimator.run(circuits[1], observables[1])
result_0 = job_0.result()
result_1 = job_1.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Observables: {[obs.paulis for obs in observables]}")
print(f" > Expectation values [0]: {result_0.values.tolist()[0]}")
print(f" > Metadata [0]: {result_0.metadata[0]}")
print(f" > Expectation values [1]: {result_1.values.tolist()[0]}")
print(f" > Metadata [1]: {result_1.metadata[0]}")
from qiskit.circuit.library import RealAmplitudes
circuit = RealAmplitudes(num_qubits=2, reps=2).decompose(reps=1)
observable = SparsePauliOp("ZI")
parameter_values = [0, 1, 2, 3, 4, 5]
estimator = Estimator()
job = estimator.run(circuit, observable, parameter_values)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Parameter values: {parameter_values}")
print(f" > Expectation value: {result.values}")
print(f" > Metadata: {result.metadata[0]}")
circuit = RealAmplitudes(num_qubits=2, reps=1).decompose(reps=1)
display(circuit.draw("mpl"))
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Estimator, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
with Session(service=service, backend="ibmq_qasm_simulator") as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Estimator, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
with Session(service=service, backend="ibmq_belem") as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Session, Options
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
observable = SparsePauliOp("IY")
options = Options()
options.optimization_level = 2
options.resilience_level = 2
service = QiskitRuntimeService()
backend = service.get_backend("ibmq_belem")
with Session(service=service, backend=backend):
estimator = Estimator()
job = estimator.run(circuit, observable)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Observable: {observable.paulis}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit.primitives import Sampler
circuit = random_circuit(2, 2, seed=1).decompose(reps=1)
circuit.measure_all()
sampler = Sampler()
job = sampler.run(circuit)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
#print(f" > Metadata: {result.metadata[0]}")
#print(result.quasi_dists,result.quasi_dists[0][1])
print(result.quasi_dists[0][0]+result.quasi_dists[0][1]+result.quasi_dists[0][2]+result.quasi_dists[0][3])
from qiskit.circuit.random import random_circuit
from qiskit.primitives import Sampler
circuits = (
random_circuit(2, 2, seed=0).decompose(reps=1),
random_circuit(2, 2, seed=1).decompose(reps=1),
)
[c.measure_all() for c in circuits]
sampler = Sampler()
job = sampler.run(circuits)
result = job.result()
[display(cir.draw("mpl")) for cir in circuits]
print(f" > Quasi probability distributions: {result.quasi_dists}")
#print(f" > Metadata: {result.metadata}")
from qiskit.circuit.library import RealAmplitudes
# RealAmplitudes is one way to generate a parametrized circuit
from qiskit.primitives import Sampler
circuit = RealAmplitudes(num_qubits=2, reps=2).decompose(reps=1)
circuit.measure_all()
parameter_values = [0, 1, 2, 3, 4, 5]
sampler = Sampler()
job = sampler.run(circuit, parameter_values)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Parameter values: {parameter_values}")
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Options
backend = service.get_backend("ibmq_qasm_simulator")
circuit = random_circuit(2, 2, seed=2).decompose(reps=1)
circuit.measure_all()
options = Options()
options.optimization_level = 2
options.resilience_level = 0
service = QiskitRuntimeService()
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuit)
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.circuit.random import random_circuit
from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Options
backend = service.get_backend("ibmq_quito")
circuit = random_circuit(2, 2, seed=2).decompose(reps=1)
circuit.measure_all()
options = Options()
options.optimization_level = 2
options.resilience_level = 0
service = QiskitRuntimeService()
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuit)
print(job.job_id())
result = job.result()
display(circuit.draw("mpl"))
print(f" > Quasi probability distribution: {result.quasi_dists[0]}")
print(f" > Metadata: {result.metadata[0]}")
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
# tem algum problema com a funcao produto tensorial do sympy (implementar eu mesmo ...)
k000 = Matrix([1,0,0,0,0,0,0,0]); k001 = Matrix([0,1,0,0,0,0,0,0])
k010 = Matrix([0,0,1,0,0,0,0,0]); k011 = Matrix([0,0,0,1,0,0,0,0])
k100 = Matrix([0,0,0,0,1,0,0,0]); k101 = Matrix([0,0,0,0,0,1,0,0])
k110 = Matrix([0,0,0,0,0,0,1,0]); k111 = Matrix([0,0,0,0,0,0,0,1])
#k000,k001,k010,k011,k100,k101,k110,k111, k001*k001.T
p = symbols('p')
#p = 0
Psi0 = sqrt((4-3*p)/4)*k000 + sqrt(p/4)*(k101+k010+k111)
Psi1 = sqrt((4-3*p)/4)*k100 + sqrt(p/4)*(k001-k110-k011)
#Psi0.T, Psi1.T
r00,r01,r10,r11 = symbols('r_{00} r_{01} r_{10} r_{11}')
rhoA = Matrix([[r00,r01],[r10,r11]]); rhoA, rhoA[0,0]
#rhoA = Matrix([[2/3,1/3],[1/3,1/3]]); #rhoA, rhoA[0,0]
def rhoABt_s(rhoA,p):
Psi0 = sqrt((4-3*p)/4)*k000 + sqrt(p/4)*(k101+k010+k111)
Psi1 = sqrt((4-3*p)/4)*k100 + sqrt(p/4)*(k001-k110-k011)
return rhoA[0,0]*Psi0*Psi0.T + rhoA[0,1]*Psi0*Psi1.T + rhoA[1,0]*Psi1*Psi0.T + rhoA[1,1]*Psi1*Psi1.T
rhoABt_ = rhoABt_s(rhoA,p); rhoABt_
# não foi possivel diagonalizar com sympy
def ptraceB(da, db, rho):
rhoA = zeros(da,da)
for j in range(0, da):
for k in range(0, da):
for l in range(0, db):
rhoA[j,k] += rho[j*db+l,k*db+l]
return rhoA
rhoAt = ptraceB(2, 4, rhoABt_); simplify(rhoAt) # ok!
rhoA = Matrix([[2/3,1/3],[1/3,1/3]])
p = np.arange(0,1.1,0.1); N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoABt_ = rhoABt_s(rhoA,p[j])
rhoA_ = ptraceB(2, 4, rhoABt_)
Cl1[j] = coh_l1_s(rhoA_)
Pjb[j] = predict_jb_s(rhoA_)
# calculo feito a partir de rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
evv = rhoABt.eigenvects(); evv
def tp_vv_s(psi, csi): # tensor product, of vectors, symbolic
M = psi.shape[0]; N = csi.shape[0]
eta = zeros(M*N,1)
for j in range(0,M):
for k in range(0,N):
eta[j*N+k] = psi[j]*csi[k]
return eta
def cb(d,j): # estados da base computacional
v = zeros(d,1)
v[j] = 1
return v
cb(2,0)
def PhiABCt_s(rhoA,p):
rhoABt = rhoABt_s(rhoA,p)
eig = rhoABt.eigenvects()
d = rhoABt.shape[0]; Phi = zeros(d*d,1)
ne = 0; j = 0; l = -1
while ne < d:
mult = eig[j][1]; ne += mult
for k in range(0,mult):
l += 1
Phi += sqrt(abs(eig[j][0]))*tp_vv_s(eig[j][2][k],cb(d,l))
j += 1
for j in range(0,d*d):
if im(Phi[j]) < 10**-5:
Phi[j] = re(Phi[j])
return Phi
def coh_l1_s(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += abs(rho[j,k])
return 2*C
def predict_jb_s(rho):
return abs(rho[0,0]-rho[1,1])
def proj_s(psi): # simbolic projector
d = psi.shape[0]
proj = zeros(d,d)
for j in range(0,d):
for k in range(0,d):
proj[j,k] = psi[j]*conjugate(psi[k])
return proj
rhoA = Matrix([[2/3,1/3],[1/3,1/3]])
p = np.arange(0,1.1,0.1); N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
Phi = PhiABCt_s(rhoA,p[j]); PPhi = proj_s(Phi)#; print(PPhi)
rhoA_ = ptraceB(2, 2**5, PPhi)#; print(rhoA_[0,1])
Cl1[j] = coh_l1_s(rhoA_)
Pjb[j] = predict_jb_s(rhoA_)
# calculo feito a partir de PhiABC
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
def rho_AB_til(rhoA,p):
rhoAbc = np.zeros((2**3,2**3), dtype=complex)#; print(rhoAbc)
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]])#; print(ket0,ket1)
ket00 = np.kron(ket0,ket0); ket01 = np.kron(ket0,ket1); ket10 = np.kron(ket1,ket0)
ket11 = np.kron(ket1,ket1); #print(ket00,'',ket01,'',ket10,'',ket11)
ket000 = np.kron(ket0,ket00); ket100 = np.kron(ket1,ket00)
ket001 = np.kron(ket0,ket01); ket101 = np.kron(ket1,ket01)
ket010 = np.kron(ket0,ket10); ket110 = np.kron(ket1,ket10)
ket011 = np.kron(ket0,ket11); ket111 = np.kron(ket1,ket11)
Psi0 = math.sqrt((4-3*p)/4)*ket000 + math.sqrt(p/4)*(ket101+ket010+ket111)
Psi1 = math.sqrt((4-3*p)/4)*ket100 + math.sqrt(p/4)*(ket001-ket110-ket011)
rhoAbc = rhoA[0,0]*Psi0@Psi0.T + rhoA[0,1]*Psi0@Psi1.T\
+ rhoA[1,0]*Psi1@Psi0.T + rhoA[1,1]*Psi1@Psi1.T
return rhoAbc
def pTraceR_num(dl, dr, rhoLR):
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
rhoA = np.array([[2/3,1/3],[1/3,1/3]]); print(rhoA) # estado inicial
p = 0.
rhoAbc = rho_AB_til(rhoA,p)#; print(rhoAbc)
rhoA_ = pTraceR_num(2, 4, rhoAbc); print(rhoA_)
def coh_l1(rho):
d = rho.shape[0];
#d = rho.dims()[0]
C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
p = np.arange(0,1.1,0.1); #print(p)
N = len(p)#; print(N)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoAbc = rho_AB_til(rhoA,p[j])
rhoA_ = pTraceR_num(2, 4, rhoAbc)
Cl1[j] = coh_l1(rhoA_)
Pjb[j] = predict_jb(rhoA_)
# calculo feito a partir de rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
from numpy import linalg
w, v = linalg.eig(rhoAbc)
print(v[0][:])
print(np.shape(v[:][0]))
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]])
ket00 = np.kron(ket0,ket0); ket01 = np.kron(ket0,ket1)
ket10 = np.kron(ket1,ket0); ket11 = np.kron(ket1,ket1)
ket000 = np.kron(ket0,ket00); ket100 = np.kron(ket1,ket00)
ket001 = np.kron(ket0,ket01); ket101 = np.kron(ket1,ket01)
ket010 = np.kron(ket0,ket10); ket110 = np.kron(ket1,ket10)
ket011 = np.kron(ket0,ket11); ket111 = np.kron(ket1,ket11)
p = np.arange(0,1.1,0.1)
N = len(p)
Cl1 = np.zeros(N); Pjb = np.zeros(N)
for j in range(0,N):
rhoAbc = rho_AB_til(rhoA,p[j])
w, v = linalg.eig(rhoAbc); w = np.abs(w)
PhiAbcdef = math.sqrt(w[0])*np.kron(v.T[0],ket000) + math.sqrt(w[1])*np.kron(v.T[1],ket001)\
+ math.sqrt(w[2])*np.kron(v.T[2],ket010) + math.sqrt(w[3])*np.kron(v.T[3],ket011)\
+ math.sqrt(w[4])*np.kron(v.T[4],ket100) + math.sqrt(w[5])*np.kron(v.T[5],ket101)\
+ math.sqrt(w[6])*np.kron(v.T[6],ket110) + math.sqrt(w[7])*np.kron(v.T[7],ket111)
rhoAbcdef = np.outer(PhiAbcdef,np.conj(PhiAbcdef))#; print(np.shape(rhoAbcdef))
rhoA_ = pTraceR_num(2, 2**5, rhoAbcdef); print(rhoA_)#; print(np.shape(rhoA_))
Cl1[j] = coh_l1(rhoA_)
Pjb[j] = predict_jb(rhoA_)
# calculo feito a partir da purificacao rhoAB_til
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p,Cl1,label=r'$C_{l_1}$')
plt.plot(p,Pjb,label=r'$P_{jb}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
rho_A = Matrix([[2/3,1/3],[1/3,1/3]])
rho_A.eigenvects()
rho_A*Matrix([[0.85],[0.52]])/0.87, rho_A*Matrix([[-0.5257],[0.85]])/0.127
w, v = linalg.eig(rhoA) # os autovetores são as colunas de v
print(w, v, v.T[0], v.T[1], np.shape(v.T[1])) # nao pode usar
import qiskit
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_quito')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit_experiments.library import StateTomography
r00 = 2/3; r01 = 1.33/3; r10 = 1.33/3; r11 = 1/3 # initial state
r = math.sqrt((r00-r11)**2 + abs(2*r01)**2) # raio de Bloch
th = math.acos((r00-r11)/r)
ph = math.acos(re(2*r01)/(r*sin(th))) # angulos de Bloch
r0 = (1+r)/2.; r1 = (1-r)/2. # autovetores
print(r, th, ph, r0, r1)
pt = np.arange(0,1.01,0.01) # for the theoretical results
Ct = (1-pt)*(2*1.33/3)
Pt = (1-pt)*(1/3)
p = np.arange(0,1.1,0.1)
d = len(p)
Csim = np.zeros(d); Psim = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4 # depolarizing
# sequencia: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
# = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4)
qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[3],qr[2],qr[1],qr[0]])
job_sim = StateTomography(qc, measurement_qubits = [0])
data = job_sim.run(simulator, shots=nshots).block_for_results()
rho_sim = data.analysis_results(0).value
rho = rho_sim.to_operator().data
Csim[j] = coh_l1(rho)
Psim[j] = predict_jb(rho)
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4); qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[3],qr[2],qr[1],qr[0]])
qcst = StateTomography(qc, measurement_qubits = [0])
data = qcst.run(device)
print(data.experiment_id)
rho = data.block_for_results().analysis_results(0).value
rhoM = rho.to_operator().data
Cexp[j] = coh_l1(rhoM)
Pexp[j] = predict_jb(rhoM)
print(Cexp,Pexp)
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')
plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
plt.plot(p,Csim,'*',label=r'$C_{l_1}^{sim}$')
plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
plt.plot(p,Cexp,'^',label=r'$C_{l_1}^{exp}$')
plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
# para o chip quito, sem mitigacao de erro
# para o chip manila sem mitigacao de erro
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
pip install qiskit
pip install qiskit-ignis
import qiskit
qiskit.IBMQ.save_account('17efde49764005e8eeb00dd065d44bc208778be72d44b475e508d20504818786f842988b0e506515c78debdd1b0c4b570717863db5e4f85569fb43c4c8626b8a',
overwrite = True)
qiskit.IBMQ.load_account()
import numpy as np
import math
from qiskit import *
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_quito')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
def coh_l1(rho):
d = rho.shape[0]; C = 0
for j in range(0,d-1):
for k in range(j+1,d):
C += np.abs(rho[j,k])
return 2*C
def predict_jb(rho):
return abs(rho[0,0]-rho[1,1])
r00 = 2/3; r01 = 1.33/3; r10 = 1.33/3; r11 = 1/3 # initial state
r = math.sqrt((r00-r11)**2 + abs(2*r01)**2) # raio de Bloch
th = math.acos((r00-r11)/r)
ph = math.acos(2*r01.real/(r*math.sin(th))) # angulos de Bloch
r0 = (1+r)/2.; r1 = (1-r)/2. # autovetores
print(r, th, ph, r0, r1)
# simulation
p = np.arange(0,1.1,0.1)
d = len(p)
Csim = np.zeros(d); Psim = np.zeros(d)
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4 # depolarizing
# sequencia: 0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111
# = 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4)
qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[0],qr[3],qr[2],qr[1]])
qstc = state_tomography_circuits(qc, [qr[1]])
job = qiskit.execute(qstc, backend = simulator, shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho_sim = qstf.fit(method='lstsq')
Csim[j] = coh_l1(rho_sim)
Psim[j] = predict_jb(rho_sim)
# theoretical
pt = np.arange(0,1.01,0.01)
Ct = (1-pt)*(2*1.33/3)
Pt = (1-pt)*(1/3)
# experiment
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
jobs_ids = []
for j in range(0,d):
pI = (4-3*p[j])/4; pX = p[j]/4; pZ = p[j]/4; pY = p[j]/4
Phi_ABCD = [math.sqrt(r0*pI)*math.cos(th/2),
math.sqrt(r0*pX)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pZ)*math.cos(th/2),
-1j*math.sqrt(r0*pY)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r1*pI)*math.sin(th/2),
-math.sqrt(r1*pX)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pZ)*math.sin(th/2),
1j*math.sqrt(r1*pY)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r0*pI)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
math.sqrt(r0*pX)*math.cos(th/2),
-math.sqrt(r0*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.sin(th/2),
1j*math.sqrt(r0*pY)*math.cos(th/2),
-math.sqrt(r1*pI)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
math.sqrt(r1*pX)*math.sin(th/2),
math.sqrt(r1*pZ)*(math.cos(ph)+1j*math.sin(ph))*math.cos(th/2),
1j*math.sqrt(r1*pY)*math.sin(th/2)]
qr = QuantumRegister(4); qc = QuantumCircuit(qr)
qc.initialize(Phi_ABCD, [qr[0],qr[3],qr[2],qr[1]])
qstc = state_tomography_circuits(qc, [qr[1]])
job = qiskit.execute(qstc, backend = device, shots=nshots)
jobs_ids.append(job.job_id())
print(job.job_id())
job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc)
rho_exp = qstf.fit(method='lstsq')
Cexp[j] = coh_l1(rho_exp)
#Pexp[j] = predict_jb(rho_exp)
# sem mitigacao, chip quito, qr[1]
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')
#plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
plt.plot(p,Csim,'*',label=r'$C_{l_1}^{sim}$')
#plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
plt.plot(p,Cexp,'^',label=r'$C_{l_1}^{exp}$')
#plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.show()
# sem mitigacao, chip belem
# sem mitigacao, chip manila
# sem mitigacao, chip quito, qr[0]
f = open("jobs_ids_CS_rho.txt", "w")
f.write(str(jobs_ids))
f.close()
f = open("jobs_ids_CS_rho.txt","r")
list_ids = f.read().replace("'","").replace(" ","").replace("[","").replace("]","").split(",")
f.close()
print(list_ids)
# error mitigation
qr = QuantumRegister(4); qubit_list = [1]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots)
print(job.job_id())
job_monitor(job)
job = device.retrieve_job('63a124fa05888e2fcb99ab6e')
meas_fitter = CompleteMeasFitter(job.result(), state_labels)
p = np.arange(0,1.1,0.1); d = len(p)
Cexp = np.zeros(d); Pexp = np.zeros(d)
for j in range(0,d):
job = device.retrieve_job(list_ids[j])
mitigated_results = meas_fitter.filter.apply(job.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method='lstsq')
Cexp[j] = coh_l1(rho_exp)
Pexp[j] = predict_jb(rho_exp)
# com mitigacao, chip quito, qr[1]
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(pt,Ct,label=r'$C_{l_1}^{the}$')#,color='green')
plt.plot(p,Csim,'o',label=r'$C_{l_1}^{sim}$')#,color='blue')
plt.plot(p,Cexp,'*',label=r'$C_{l_1}^{exp}$')#,color='orange')
#plt.plot(pt,Pt,label=r'$P_{jb}^{the}$')
#plt.plot(p,Psim,'o',label=r'$P_{jb}^{sim}$')
#plt.plot(p,Pexp,'+',label=r'$P_{jb}^{exp}$')
plt.xlabel(r'$p$')
plt.legend()
plt.savefig('fig_QCS_mixed.pdf')
plt.show()
# com mitigacao, chip belem
# com mitigacao, chip manila
# com mitigacao, chip quito, qr[0]
# com mitigacao, chip quito
# sem mitigacao, chip quito
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%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/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/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from sympy import *
init_printing(use_unicode=True)
%matplotlib inline
p00,p01,p10,p11 = symbols('p_{00} p_{01} p_{10} p_{11}')
th,ph = symbols('theta phi')
Psi00 = Matrix([[cos(th)],[0],[0],[sin(th)]])
Psi01 = Matrix([[0],[sin(ph)],[cos(ph)],[0]])
Psi11 = Matrix([[0],[cos(ph)],[-sin(ph)],[0]])
Psi10 = Matrix([[-sin(th)],[0],[0],[cos(th)]])
#Psi00, Psi00.T, Psi00*Psi00.T
rhoX = p00*Psi00*Psi00.T + p01*Psi01*Psi01.T + p10*Psi10*Psi10.T + p11*Psi11*Psi11.T
simplify(rhoX)
def kp(x,y):
return KroneckerProduct(x,y)
I = Matrix([[1,0],[0,1]])
Y = Matrix([[0,-1j],[1j,0]])
Y = Matrix([[0,1],[1,0]])
Z = Matrix([[1,0],[0,-1]])
cxx,cyy,czz,az,bz = symbols('c_{xx} c_{yy} c_{zz} a_{z} b_{z}')
rhoX = (1/4)*(kp(I,I) + cxx*kp(X,X) + cyy*kp(Y,Y) + czz*kp(Z,Z) + az*kp(Z,I) + bz*kp(I,Z))
simplify(rhoX)
th,be,ga = symbols('theta beta gamma')
c00 = cos(th/2)*cos(be/2)*cos(ga/2) + sin(th/2)*sin(be/2)*sin(ga/2)
c01 = cos(th/2)*cos(be/2)*sin(ga/2) - sin(th/2)*sin(be/2)*cos(ga/2)
c10 = cos(th/2)*sin(be/2)*cos(ga/2) - sin(th/2)*cos(be/2)*sin(ga/2)
c11 = cos(th/2)*sin(be/2)*sin(ga/2) + sin(th/2)*cos(be/2)*cos(ga/2)
simplify(c00**2 + c01**2 + c10**2 + c11**2) # ok!
P0 = Matrix([[1,0],[0,0]])
P1 = Matrix([[0,0],[0,1]])
def Ry(th):
return cos(th/2)*I - 1j*sin(th/2)*Y
def Cx_ab():
return KroneckerProduct(P0,I) + KroneckerProduct(P1,X)
def Cx_ba():
return KroneckerProduct(I,P0) + KroneckerProduct(X,P1)
MB = Cx_ab()*KroneckerProduct(Ry(th-ph),I)*Cx_ba()*KroneckerProduct(Ry(th+ph),I) # mudanca de base
simplify(MB)
from qiskit import *
import numpy as np
import math
import qiskit
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# retorna o circuito quantico que prepara um certo estado real de 1 qubit
# coef = array com os 2 coeficientes reais do estado na base computacional
def qc_psi_1qb_real(coef):
qr = QuantumRegister(1)
qc = QuantumCircuit(qr, name='psir_1qb')
th = 2*math.acos(np.abs(coef[0]))
qc.ry(th, qr[0])
return qc
eigvals = [0.1,0.9]
coef = np.sqrt(eigvals)
print(coef)
qc_psi_1qb_real_ = qc_psi_1qb_real(coef)
qc_psi_1qb_real_.draw('mpl')
from qiskit.quantum_info import Statevector
sv = Statevector.from_label('0')
sv
sv = sv.evolve(qc_psi_1qb_real_)
sv
# retorna o circuito quantico que prepara um certo estado real de 2 qubits
# coef = array com os 4 coeficientes reais do estado na base computacional
def qc_psi_2qb_real(coef):
qr = QuantumRegister(2)
qc = QuantumCircuit(qr, name = 'psir_2qb')
xi = 2*math.acos(math.sqrt(coef[0]**2+coef[1]**2))
coef1 = [math.sqrt(coef[0]**2+coef[1]**2),math.sqrt(1-coef[0]**2-coef[1]**2)]
c_psi_1qb_real_ = qc_psi_1qb_real(coef1)
qc.append(c_psi_1qb_real_, [qr[0]])
th0 = 2*math.atan(np.abs(coef[1])/np.abs(coef[0]))
th1 = 2*math.atan(np.abs(coef[3])/np.abs(coef[2]))
qc.x(0)
qc.cry(th0, 0, 1)
qc.x(0)
qc.cry(th1, 0, 1)
return qc
eigvals = [0.1, 0.2, 0.3, 0.4]
coef = np.sqrt(eigvals)
print(coef)
qc_psi_2qb_real_ = qc_psi_2qb_real(coef)
qc_psi_2qb_real_.draw('mpl')
sv = Statevector.from_label('00')
sv
sv = sv.evolve(qc_psi_2qb_real_)
sv # note o ordenamento, o 2º qb é o 1º e o 1º é o 2º (00,10,01,11)
def qc_ry(th):
qr = QuantumRegister(1)
qc = QuantumCircuit(qr, name = 'RY')
qc.ry(th, 0)
return qc
# retorna o circuito quantico que prepara um certo estado real de 3 qubits
# coef = array com os 8 coeficientes reais do estado na base computacional
def qc_psi_3qb_real(coef):
qr = QuantumRegister(3)
qc = QuantumCircuit(qr, name = 'psir_3qb')
d = len(coef)
coef2 = np.zeros(d//2)
th = np.zeros(d//2)
for j in range(0,2):
for k in range(0,2):
coef2[int(str(j)+str(k),2)] = math.sqrt(coef[int(str(j)+str(k)+str(0),2)]**2+coef[int(str(j)+str(k)+str(1),2)]**2)
c_psi_2qb_real_ = qc_psi_2qb_real(coef2)
qc.append(c_psi_2qb_real_, [qr[0],qr[1]])
for j in range(0,2):
for k in range(0,2):
th[int(str(j)+str(k),2)] = 2*math.atan(np.abs(coef[int(str(j)+str(k)+str(1),2)])/np.abs(coef[int(str(j)+str(k)+str(0),2)]))
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
qc_ry_ = qc_ry(th[int(str(j)+str(k),2)])
ccry = qc_ry_.to_gate().control(2)
qc.append(ccry, [0,1,2])
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
return qc
list_bin = []
for j in range(0,2**3):
b = "{:03b}".format(j)
list_bin.append(b)
print(list_bin)
eigvals = [0.01,0.1,0.04,0.2,0.05,0.3,0.18,0.12]
coef = np.sqrt(eigvals)
print(coef)
qc_psi_3qb_real_ = qc_psi_3qb_real(coef)
qc_psi_3qb_real_.draw('mpl') # odernamento: '000', '001', '010', '011', '100', '101', '110', '111'
sv = Statevector.from_label('000')
sv
sv = sv.evolve(qc_psi_3qb_real_)
sv # ordenamento aqui: 000 100 010 110 001 101 011 111
# retorna o circuito quantico que prepara um certo estado real de 4 qubits
# coef = array com os 16 coeficientes reais do estado na base computacional
def qc_psi_4qb_real(coef):
qr = QuantumRegister(4)
qc = QuantumCircuit(qr, name = 'psir_4qb')
d = len(coef)
coef3 = np.zeros(d//2)
th = np.zeros(d//2)
for j in range(0,2):
for k in range(0,2):
for l in range(0,2):
coef3[int(str(j)+str(k)+str(l),2)] = math.sqrt(coef[int(str(j)+str(k)+str(l)+str(0),2)]**2+coef[int(str(j)+str(k)+str(l)+str(1),2)]**2)
c_psi_3qb_real_ = qc_psi_3qb_real(coef3)
qc.append(c_psi_3qb_real_, [qr[0],qr[1],qr[2]])
for j in range(0,2):
for k in range(0,2):
for l in range(0,2):
th[int(str(j)+str(k)+str(l),2)] = 2*math.atan(np.abs(coef[int(str(j)+str(k)+str(l)+str(1),2)])/np.abs(coef[int(str(j)+str(k)+str(l)+str(0),2)]))
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
if l == 0:
qc.x(2)
qc_ry_ = qc_ry(th[int(str(j)+str(k)+str(l),2)])
ccry = qc_ry_.to_gate().control(3)
qc.append(ccry, [0,1,2,3])
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
if l == 0:
qc.x(2)
return qc
list_bin = []
for j in range(0,2**4):
b = "{:04b}".format(j)
list_bin.append(b)
print(list_bin)
eigvals = np.zeros(2**4)
eigvals[0] = 0.008
for j in range(1,len(eigvals)-1):
eigvals[j] = eigvals[j-1]+0.005
#print(np.sum(eigvals))
eigvals[j+1] = 1 - np.sum(eigvals)
#print(eigvals)
#print(np.sum(eigvals))
coef = np.sqrt(eigvals)
print(coef)
qc_psi_4qb_real_ = qc_psi_4qb_real(coef)
qc_psi_4qb_real_.draw('mpl')
# '0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111'
sv = Statevector.from_label('0000')
sv
sv = sv.evolve(qc_psi_4qb_real_)
sv # ordenamento aqui: 0000 1000 0100 1100 0010 1010 0110 1110 0001 1001 0101 1101 0011 1011 0111 1111
sv[1]
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from sympy import *
init_printing(use_unicode=True)
mu_u = Matrix([[-1],[+1],[+1]]); mu_u
A_R = Matrix([[1,1,-1,-1],[1,-1,1,-1],[1,-1,-1,1]]); A_R
p1,p2,p3,p4 = symbols('p_1 p_2 p_3 p_4')
p4 = 1-p1-p2-p3
cl = A_R[:,0]*p1 + A_R[:,1]*p2 + A_R[:,2]*p3 + A_R[:,3]*p4
mu_u - cl
s1 = Matrix([[0,1],[1,0]])
s2 = Matrix([[0,-1j],[1j,0]])
s1*s2
import numpy as np
a = [] # gera uma lista com com todos os 512 estados ônticos
for j in range(-1,2,2):
for k in range(-1,2,2):
for l in range(-1,2,2):
for m in range(-1,2,2):
for n in range(-1,2,2):
for o in range(-1,2,2):
for p in range(-1,2,2):
for q in range(-1,2,2):
for r in range(-1,2,2):
a.append(np.array([j,k,l,m,n,o,p,q,r]))
a[10], a[10][5], len(a)
mu = [] # gera, a partir dos estados ônticos, uma lista com os 512 vetores de medida, muitos dos quais são iguais
for j in range(0,2**9):
r1 = a[j][0]*a[j][1]*a[j][2]
r2 = a[j][3]*a[j][4]*a[j][5]
r3 = a[j][6]*a[j][7]*a[j][8]
c1 = a[j][0]*a[j][3]*a[j][6]
c2 = a[j][1]*a[j][4]*a[j][7]
c3 = a[j][2]*a[j][5]*a[j][8]
mu.append([r1,r2,r3,c1,c2,c3])
mu[0], len(mu)
mu_ = [] # remove as repeticoes do vetor de medida
for j in range(0,2**6):
if mu[j] not in mu_:
mu_.append(mu[j])
mu_, len(mu_), mu_[1]
A_R = np.zeros((6,16))#; A_R
for j in range(0,16):
A_R[:,j] = mu_[j]
print(A_R)
print(A_R.shape)
def rpv_zhsl(d): # vetor de probabilidades aleatório
rn = np.zeros(d-1)
for j in range(0,d-1):
rn[j] = np.random.random()
rpv = np.zeros(d)
rpv[0] = 1.0 - rn[0]**(1.0/(d-1.0))
norm = rpv[0]
if d > 2:
for j in range(1,d-1):
rpv[j] = (1.0 - rn[j]**(1.0/(d-j-1)))*(1.0-norm)
norm = norm + rpv[j]
rpv[d-1] = 1.0 - norm
return rpv
rpv = rpv_zhsl(16)
print(rpv)
print(np.linalg.norm(rpv))
mu_Q = np.zeros((6,1)); mu_Q = np.array([1,1,1,1,1,-1]); print(mu_Q.shape)
p = np.zeros((16,1)); p = rpv_zhsl(16); print(p.shape)
vec = mu_Q - A_R@p
print(vec)
def objective(x):
mu_Q = np.array([1,1,1,1,1,-1])
vec = mu_Q - A_R@x
return np.linalg.norm(vec)
from scipy.optimize import minimize
# define o vinculo como sendo uma distribuicao de probabilidades
constraints = [{'type': 'eq', 'fun': lambda x: np.sum(x)-1},
{'type':'ineq', 'fun': lambda x: x},
{'type':'ineq', 'fun': lambda x: 1-x}]
# 'eq' quer dizer = 0 e 'ineq' quer dizer >=0
np.random.seed(130000)
x0 = rpv_zhsl(16)
print(x0)
result = minimize(objective, x0, constraints=constraints, method='trust-constr')
print('melhor distribuicao de probabilidades', result.x)
print(objective(result.x))
from qiskit import *
import numpy as np
import math
import qiskit
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_manila')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
#from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
#from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.visualization import plot_histogram
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.barrier() # mede XI
qc.h(0)
qc.cx(0,2)
qc.barrier() # mede IX
qc.h(1)
qc.cx(1,2)
qc.barrier() # mede XX
qc.cx(0,2)
qc.cx(1,2)
qc.barrier()
qc.measure(2,0)
qc.draw('mpl')
job_sim = execute(qc, backend=simulator, shots=nshots)
counts_sim = job_sim.result().get_counts(qc)
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts_exp = job_exp.result().get_counts(qc)
counts_exp
plot_histogram([counts_sim, counts_exp], legend=['sim', 'exp'])
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.barrier() # mede YI
qc.sdg(0)
qc.h(0)
qc.cx(0,2)
qc.barrier() # mede IY
qc.sdg(1)
qc.h(1)
qc.cx(1,2)
qc.barrier() # mede YY
qc.cx(0,2)
qc.cx(1,2)
qc.barrier()
qc.measure(2,0)
qc.draw('mpl')
job_sim = execute(qc, backend=simulator, shots=nshots)
counts_sim = job_sim.result().get_counts(qc)
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts_exp = job_exp.result().get_counts(qc)
counts_exp
plot_histogram([counts_sim, counts_exp], legend=['sim', 'exp'])
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.barrier()
qc.h(0)
qc.cx(0,2) # mede XI
qc.barrier()
qc.sdg(1)
qc.h(1)
qc.cx(1,2) # mede IX
qc.barrier()
qc.cx(0,2); qc.cx(1,2)
qc.barrier()
qc.measure(2,0)
qc.draw('mpl')
job_sim = execute(qc, backend=simulator, shots=nshots)
counts_sim = job_sim.result().get_counts(qc)
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts_exp = job_exp.result().get_counts(qc)
counts_exp
plot_histogram([counts_sim, counts_exp], legend=['sim', 'exp'])
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.barrier()
qc.sdg(0)
qc.h(0)
qc.cx(0,2) # mede XI
qc.barrier()
qc.h(1)
qc.cx(1,2) # mede IX
qc.barrier()
qc.cx(0,2); qc.cx(1,2)
qc.barrier()
qc.measure(2,0)
qc.draw('mpl')
job_sim = execute(qc, backend=simulator, shots=nshots)
counts_sim = job_sim.result().get_counts(qc)
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts_exp = job_exp.result().get_counts(qc)
counts_exp
plot_histogram([counts_sim, counts_exp], legend=['sim', 'exp'])
I = Matrix([[1,0],[0,1]]); X = Matrix([[0,1],[1,0]]);
Y = Matrix([[0,-1j],[1j,0]]); Z = Matrix([[1,0],[0,-1]])
I,X,Y,Z
XX = kronecker_product(X,X); XX.eigenvects()
YY = kronecker_product(Y,Y); YY.eigenvects()
ZZ = kronecker_product(Z,Z); ZZ.eigenvects()
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.barrier() # mede ZZ
qc.cx(0,2)
qc.cx(1,2)
qc.barrier() # mede XX
qc.h([0,1])
qc.cx(0,2)
qc.cx(1,2)
qc.barrier() # mede YY
qc.h([0,1])
qc.sdg([0,1])
qc.h([0,1])
qc.cx(0,2)
qc.cx(1,2)
qc.barrier()
qc.measure(2,0)
qc.draw('mpl')
job_sim = execute(qc, backend=simulator, shots=nshots)
counts_sim = job_sim.result().get_counts(qc)
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts_exp = job_exp.result().get_counts(qc)
counts_exp
plot_histogram([counts_sim, counts_exp], legend=['sim', 'exp'])
XY = kronecker_product(X,Y); XY.eigenvects()
YX = kronecker_product(Y,X); YX.eigenvects()
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.barrier() # mede ZZ
qc.cx(0,2)
qc.cx(1,2)
qc.barrier() # mede XX
qc.sdg(1)
qc.h([0,1])
qc.cx(0,2)
qc.cx(1,2)
qc.barrier() # mede YY
qc.h([0,1])
qc.sdg(0)
qc.s(1)
qc.h([0,1])
qc.cx(0,2)
qc.cx(1,2)
qc.barrier()
qc.measure(2,0)
qc.draw('mpl')
job_sim = execute(qc, backend=simulator, shots=nshots)
counts_sim = job_sim.result().get_counts(qc)
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts_exp = job_exp.result().get_counts(qc)
counts_exp
plot_histogram([counts_sim, counts_exp], legend=['sim', 'exp'])
cr1 = {'0': 7921, '1': 271}
cr2 = {'0': 7944, '1': 248}
cr3 = {'0': 7754, '1': 438}
cc1 = {'0': 7913, '1': 279}
cc2 = {'0': 7940, '1': 252}
cc3 = {'0': 610, '1': 7582}
r1a = (cr1['0']-cr1['1'])/(cr1['0']+cr1['1'])
r2a = (cr2['0']-cr2['1'])/(cr2['0']+cr2['1'])
r3a = (cr3['0']-cr3['1'])/(cr3['0']+cr3['1'])
c1a = (cc1['0']-cc1['1'])/(cc1['0']+cc1['1'])
c2a = (cc2['0']-cc2['1'])/(cc2['0']+cc2['1'])
c3a = (cc3['0']-cc3['1'])/(cc3['0']+cc3['1'])
print(r1a,r2a,r3a,c1a,c2a,c3a)
def objective(x):
mu_Q = np.array([0.93,0.94,0.89,0.93,0.94,-0.85])
vec = mu_Q - A_R@x
return np.linalg.norm(vec)
constraints = [{'type': 'eq', 'fun': lambda x: np.sum(x)-1},
{'type':'ineq', 'fun': lambda x: x},
{'type':'ineq', 'fun': lambda x: 1-x}]
np.random.seed(130000)
x0 = rpv_zhsl(16)
result = minimize(objective, x0, constraints=constraints, method='trust-constr')
print('melhor distribuicao de probabilidades', result.x)
print(objective(result.x))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from sympy import *
init_printing(use_unicode=True)
r1,r2,r3,s1,s2,s3 = symbols('r_1 r_2 r_3 s_1 s_2 s_3')
I = Matrix([[1,0],[0,1]]); X = Matrix([[0,1],[1,0]]); Y = Matrix([[0,-1j],[1j,0]]); Z = Matrix([[1,0],[0,-1]])
rho = (1/2)*(I+r1*X+r2*Y+r3*Z); sigma = (1/2)*(I+s1*X+s2*Y+s3*Z)
#rho, sigma
def frho(r1,r2,r3):
return (1/2)*(I+r1*X+r2*Y+r3*Z)
def fsigma(s1,s2,s3):
return (1/2)*(I+s1*X+s2*Y+s3*Z)
A = frho(r1,0,r2)*fsigma(0,s2,0)
simplify(A.eigenvals())
A = frho(0,0,r3); B = fsigma(s1,s2,0)
simplify(A*(B**2)*A - B*(A**2)*B)
M = A*B; simplify(M)
simplify(M.eigenvals()) # parecem ser positivos o que esta na raiz e o autovalores
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import *
import numpy as np
import math
import qiskit
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
dth = math.pi/10
th = np.arange(0,math.pi+dth,dth)
ph = 0; lb = 0
N = len(th)
F_the = np.zeros(N); F_sim = np.zeros(N); F_exp = np.zeros(N)
for j in range(0,N):
F_the[j] = math.cos(th[j]/2)**2
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.u(th[j],ph,lb,qr[2])
qc.h(qr[0])
qc.cswap(qr[0],qr[1],qr[2])
qc.h(qr[0])
qc.measure(qr[0],cr[0])
job_sim = execute(qc, backend=simulator, shots=nshots)
counts = job_sim.result().get_counts(qc)
if '0' in counts:
F_sim[j] = 2*counts['0']/nshots - 1
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts = job_exp.result().get_counts(qc)
if '0' in counts:
F_exp[j] = 2*counts['0']/nshots - 1
qc.draw('mpl')
qc.decompose().decompose().draw('mpl') # o circuito é "profundo" por causa da swap controlada
F_the, F_sim, F_exp
from matplotlib import pyplot as plt
plt.plot(th, F_the, label=r'$F_{the}$')
plt.plot(th, F_sim, '*', label=r'$F_{sim}$')
plt.plot(th, F_exp, 'o', label=r'$F_{exp}$')
plt.xlabel(r'$\theta$')
plt.legend()
plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import *
import numpy as np
import math
from matplotlib import pyplot as plt
import qiskit
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
#from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.visualization import plot_histogram
def qc_dqc1(ph):
qr = QuantumRegister(3)
qc = QuantumCircuit(qr, name='DQC1')
qc.h(0)
qc.h(1) # cria o estado de Bell dos qubits 1 e 2, que equivale ao estado de 1 sendo maximamente misto
qc.cx(1,2)
#qc.barrier()
qc.cp(ph, 0, 1)
return qc
ph = math.pi/2
qc_dqc1_ = qc_dqc1(ph)
qc_dqc1_.draw('mpl')
qc_dqc1_.decompose().draw('mpl')
def pTraceL_num(dl, dr, rhoLR): # Retorna traco parcial sobre L de rhoLR
rhoR = np.zeros((dr, dr), dtype=complex)
for j in range(0, dr):
for k in range(j, dr):
for l in range(0, dl):
rhoR[j,k] += rhoLR[l*dr+j,l*dr+k]
if j != k:
rhoR[k,j] = np.conj(rhoR[j,k])
return rhoR
def pTraceR_num(dl, dr, rhoLR): # Retorna traco parcial sobre R de rhoLR
rhoL = np.zeros((dl, dl), dtype=complex)
for j in range(0, dl):
for k in range(j, dl):
for l in range(0, dr):
rhoL[j,k] += rhoLR[j*dr+l,k*dr+l]
if j != k:
rhoL[k,j] = np.conj(rhoL[j,k])
return rhoL
# simulation
phmax = 2*math.pi
dph = phmax/20
ph = np.arange(0,phmax+dph,dph)
d = len(ph);
xm = np.zeros(d)
ym = np.zeros(d)
for j in range(0,d):
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
qc_dqc1_ = qc_dqc1(ph[j])
qc.append(qc_dqc1_, [0,1,2])
qstc = state_tomography_circuits(qc, [1,0])
job = execute(qstc, backend=simulator, shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho_01 = qstf.fit(method='lstsq')
rho_0 = pTraceR_num(2, 2, rho_01)
xm[j] = 2*rho_0[1,0].real
ym[j] = 2*rho_0[1,0].imag
qc.draw('mpl')
# experiment
phmax = 2*math.pi
dph = phmax/10
ph_exp = np.arange(0,phmax+dph,dph)
d = len(ph_exp);
xm_exp = np.zeros(d)
ym_exp = np.zeros(d)
for j in range(0,d):
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
qc_dqc1_ = qc_dqc1(ph_exp[j])
qc.append(qc_dqc1_, [0,1,2])
qstc = state_tomography_circuits(qc, [1,0])
job = execute(qstc, backend=device, shots=nshots)
print(job.job_id())
job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc)
rho_01 = qstf.fit(method='lstsq')
rho_0 = pTraceR_num(2, 2, rho_01)
xm_exp[j] = 2*rho_0[1,0].real
ym_exp[j] = 2*rho_0[1,0].imag
plt.plot(ph, xm, label = r'$\langle X\rangle_{sim}$')#, marker='*')
plt.plot(ph, ym, label = r'$\langle Y\rangle_{sim}$')#, marker='o')
plt.scatter(ph_exp, xm_exp, label = r'$\langle X\rangle_{exp}$', marker='*', color='r')
plt.scatter(ph_exp, ym_exp, label = r'$\langle Y\rangle_{exp}$', marker='o', color='g')
plt.legend(bbox_to_anchor=(1, 1))#,loc='center right')
#plt.xlim(0,2*math.pi)
#plt.ylim(-1,1)
plt.xlabel(r'$\phi$')
plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import *
import numpy as np
import math
from matplotlib import pyplot as plt
import qiskit
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
#from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.visualization import plot_histogram
qr = QuantumRegister(4)
cr = ClassicalRegister(3)
qc = QuantumCircuit(qr, cr)
qc.x(3)
qc.h([0,1,2])
qc.draw('mpl')
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-np.pi/2, np.pi/2, 1000) # generate 1000 evenly spaced points between -pi and pi
y_sin = np.abs(np.sin(x/2)) # compute sin(x) for each x
y_x = np.abs(x/2) # set y=x for each x
plt.plot(x, y_sin, label='sin(x)') # plot sin(x) as a blue line
plt.plot(x, y_x, label='x', color='orange') # plot x as an orange line
plt.legend() # display the legend
plt.show() # show the plot
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from sympy import *
init_printing(use_unicode=True)
%matplotlib inline
p00,p01,p10,p11 = symbols('p_{00} p_{01} p_{10} p_{11}')
th,ph = symbols('theta phi')
Psi00 = Matrix([[cos(th)],[0],[0],[sin(th)]])
Psi01 = Matrix([[0],[sin(ph)],[cos(ph)],[0]])
Psi11 = Matrix([[0],[cos(ph)],[-sin(ph)],[0]])
Psi10 = Matrix([[-sin(th)],[0],[0],[cos(th)]])
#Psi00, Psi00.T, Psi00*Psi00.T
rhoX = p00*Psi00*Psi00.T + p01*Psi01*Psi01.T + p10*Psi10*Psi10.T + p11*Psi11*Psi11.T
simplify(rhoX)
def kp(x,y):
return KroneckerProduct(x,y)
I = Matrix([[1,0],[0,1]])
Y = Matrix([[0,-1j],[1j,0]])
Y = Matrix([[0,1],[1,0]])
Z = Matrix([[1,0],[0,-1]])
cxx,cyy,czz,az,bz = symbols('c_{xx} c_{yy} c_{zz} a_{z} b_{z}')
rhoX = (1/4)*(kp(I,I) + cxx*kp(X,X) + cyy*kp(Y,Y) + czz*kp(Z,Z) + az*kp(Z,I) + bz*kp(I,Z))
simplify(rhoX)
th,be,ga = symbols('theta beta gamma')
c00 = cos(th/2)*cos(be/2)*cos(ga/2) + sin(th/2)*sin(be/2)*sin(ga/2)
c01 = cos(th/2)*cos(be/2)*sin(ga/2) - sin(th/2)*sin(be/2)*cos(ga/2)
c10 = cos(th/2)*sin(be/2)*cos(ga/2) - sin(th/2)*cos(be/2)*sin(ga/2)
c11 = cos(th/2)*sin(be/2)*sin(ga/2) + sin(th/2)*cos(be/2)*cos(ga/2)
simplify(c00**2 + c01**2 + c10**2 + c11**2) # ok!
P0 = Matrix([[1,0],[0,0]])
P1 = Matrix([[0,0],[0,1]])
def Ry(th):
return cos(th/2)*I - 1j*sin(th/2)*Y
def Cx_ab():
return KroneckerProduct(P0,I) + KroneckerProduct(P1,X)
def Cx_ba():
return KroneckerProduct(I,P0) + KroneckerProduct(X,P1)
MB = Cx_ab()*KroneckerProduct(Ry(th-ph),I)*Cx_ba()*KroneckerProduct(Ry(th+ph),I) # mudanca de base
simplify(MB)
from qiskit import *
import numpy as np
import math
import qiskit
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# retorna o circuito quantico que prepara um certo estado real de 1 qubit
# coef = array com os 2 coeficientes reais do estado na base computacional
def qc_psi_1qb_real(coef):
qr = QuantumRegister(1)
qc = QuantumCircuit(qr, name='psir_1qb')
th = 2*math.acos(np.abs(coef[0]))
qc.ry(th, qr[0])
return qc
eigvals = [0.1,0.9]
coef = np.sqrt(eigvals)
print(coef)
qc_psi_1qb_real_ = qc_psi_1qb_real(coef)
qc_psi_1qb_real_.draw('mpl')
from qiskit.quantum_info import Statevector
sv = Statevector.from_label('0')
sv
sv = sv.evolve(qc_psi_1qb_real_)
sv
# retorna o circuito quantico que prepara um certo estado real de 2 qubits
# coef = array com os 4 coeficientes reais do estado na base computacional
def qc_psi_2qb_real(coef):
qr = QuantumRegister(2)
qc = QuantumCircuit(qr, name = 'psir_2qb')
xi = 2*math.acos(math.sqrt(coef[0]**2+coef[1]**2))
coef1 = [math.sqrt(coef[0]**2+coef[1]**2),math.sqrt(1-coef[0]**2-coef[1]**2)]
c_psi_1qb_real_ = qc_psi_1qb_real(coef1)
qc.append(c_psi_1qb_real_, [qr[0]])
th0 = 2*math.atan(np.abs(coef[1])/np.abs(coef[0]))
th1 = 2*math.atan(np.abs(coef[3])/np.abs(coef[2]))
qc.x(0)
qc.cry(th0, 0, 1)
qc.x(0)
qc.cry(th1, 0, 1)
return qc
eigvals = [0.1, 0.2, 0.3, 0.4]
coef = np.sqrt(eigvals)
print(coef)
qc_psi_2qb_real_ = qc_psi_2qb_real(coef)
qc_psi_2qb_real_.draw('mpl')
sv = Statevector.from_label('00')
sv
sv = sv.evolve(qc_psi_2qb_real_)
sv # note o ordenamento, o 2º qb é o 1º e o 1º é o 2º (00,10,01,11)
def qc_ry(th):
qr = QuantumRegister(1)
qc = QuantumCircuit(qr, name = 'RY')
qc.ry(th, 0)
return qc
# retorna o circuito quantico que prepara um certo estado real de 3 qubits
# coef = array com os 8 coeficientes reais do estado na base computacional
def qc_psi_3qb_real(coef):
qr = QuantumRegister(3)
qc = QuantumCircuit(qr, name = 'psir_3qb')
d = len(coef)
coef2 = np.zeros(d//2)
th = np.zeros(d//2)
for j in range(0,2):
for k in range(0,2):
coef2[int(str(j)+str(k),2)] = math.sqrt(coef[int(str(j)+str(k)+str(0),2)]**2+coef[int(str(j)+str(k)+str(1),2)]**2)
c_psi_2qb_real_ = qc_psi_2qb_real(coef2)
qc.append(c_psi_2qb_real_, [qr[0],qr[1]])
for j in range(0,2):
for k in range(0,2):
th[int(str(j)+str(k),2)] = 2*math.atan(np.abs(coef[int(str(j)+str(k)+str(1),2)])/np.abs(coef[int(str(j)+str(k)+str(0),2)]))
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
qc_ry_ = qc_ry(th[int(str(j)+str(k),2)])
ccry = qc_ry_.to_gate().control(2)
qc.append(ccry, [0,1,2])
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
return qc
list_bin = []
for j in range(0,2**3):
b = "{:03b}".format(j)
list_bin.append(b)
print(list_bin)
eigvals = [0.01,0.1,0.04,0.2,0.05,0.3,0.18,0.12]
coef = np.sqrt(eigvals)
print(coef)
qc_psi_3qb_real_ = qc_psi_3qb_real(coef)
qc_psi_3qb_real_.draw('mpl') # odernamento: '000', '001', '010', '011', '100', '101', '110', '111'
sv = Statevector.from_label('000')
sv
sv = sv.evolve(qc_psi_3qb_real_)
sv # ordenamento aqui: 000 100 010 110 001 101 011 111
# retorna o circuito quantico que prepara um certo estado real de 4 qubits
# coef = array com os 16 coeficientes reais do estado na base computacional
def qc_psi_4qb_real(coef):
qr = QuantumRegister(4)
qc = QuantumCircuit(qr, name = 'psir_4qb')
d = len(coef)
coef3 = np.zeros(d//2)
th = np.zeros(d//2)
for j in range(0,2):
for k in range(0,2):
for l in range(0,2):
coef3[int(str(j)+str(k)+str(l),2)] = math.sqrt(coef[int(str(j)+str(k)+str(l)+str(0),2)]**2+coef[int(str(j)+str(k)+str(l)+str(1),2)]**2)
c_psi_3qb_real_ = qc_psi_3qb_real(coef3)
qc.append(c_psi_3qb_real_, [qr[0],qr[1],qr[2]])
for j in range(0,2):
for k in range(0,2):
for l in range(0,2):
th[int(str(j)+str(k)+str(l),2)] = 2*math.atan(np.abs(coef[int(str(j)+str(k)+str(l)+str(1),2)])/np.abs(coef[int(str(j)+str(k)+str(l)+str(0),2)]))
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
if l == 0:
qc.x(2)
qc_ry_ = qc_ry(th[int(str(j)+str(k)+str(l),2)])
ccry = qc_ry_.to_gate().control(3)
qc.append(ccry, [0,1,2,3])
if j == 0:
qc.x(0)
if k == 0:
qc.x(1)
if l == 0:
qc.x(2)
return qc
list_bin = []
for j in range(0,2**4):
b = "{:04b}".format(j)
list_bin.append(b)
print(list_bin)
eigvals = np.zeros(2**4)
eigvals[0] = 0.008
for j in range(1,len(eigvals)-1):
eigvals[j] = eigvals[j-1]+0.005
#print(np.sum(eigvals))
eigvals[j+1] = 1 - np.sum(eigvals)
#print(eigvals)
#print(np.sum(eigvals))
coef = np.sqrt(eigvals)
print(coef)
qc_psi_4qb_real_ = qc_psi_4qb_real(coef)
qc_psi_4qb_real_.draw('mpl')
# '0000', '0001', '0010', '0011', '0100', '0101', '0110', '0111', '1000', '1001', '1010', '1011', '1100', '1101', '1110', '1111'
sv = Statevector.from_label('0000')
sv
sv = sv.evolve(qc_psi_4qb_real_)
sv # ordenamento aqui: 0000 1000 0100 1100 0010 1010 0110 1110 0001 1001 0101 1101 0011 1011 0111 1111
sv[1]
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from sympy import *
init_printing(use_unicode=True)
r1,r2,r3,s1,s2,s3 = symbols('r_1 r_2 r_3 s_1 s_2 s_3')
I = Matrix([[1,0],[0,1]]); X = Matrix([[0,1],[1,0]]); Y = Matrix([[0,-1j],[1j,0]]); Z = Matrix([[1,0],[0,-1]])
rho = (1/2)*(I+r1*X+r2*Y+r3*Z); sigma = (1/2)*(I+s1*X+s2*Y+s3*Z)
#rho, sigma
def frho(r1,r2,r3):
return (1/2)*(I+r1*X+r2*Y+r3*Z)
def fsigma(s1,s2,s3):
return (1/2)*(I+s1*X+s2*Y+s3*Z)
A = frho(r1,0,r2)*fsigma(0,s2,0)
simplify(A.eigenvals())
A = frho(0,0,r3); B = fsigma(s1,s2,0)
simplify(A*(B**2)*A - B*(A**2)*B)
M = A*B; simplify(M)
simplify(M.eigenvals()) # parecem ser positivos o que esta na raiz e o autovalores
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import *
import numpy as np
import math
import qiskit
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
dth = math.pi/10
th = np.arange(0,math.pi+dth,dth)
ph = 0; lb = 0
N = len(th)
F_the = np.zeros(N); F_sim = np.zeros(N); F_exp = np.zeros(N)
for j in range(0,N):
F_the[j] = math.cos(th[j]/2)**2
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.u(th[j],ph,lb,qr[2])
qc.h(qr[0])
qc.cswap(qr[0],qr[1],qr[2])
qc.h(qr[0])
qc.measure(qr[0],cr[0])
job_sim = execute(qc, backend=simulator, shots=nshots)
counts = job_sim.result().get_counts(qc)
if '0' in counts:
F_sim[j] = 2*counts['0']/nshots - 1
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts = job_exp.result().get_counts(qc)
if '0' in counts:
F_exp[j] = 2*counts['0']/nshots - 1
qc.draw('mpl')
qc.decompose().decompose().draw('mpl') # o circuito é "profundo" por causa da swap controlada
F_the, F_sim, F_exp
from matplotlib import pyplot as plt
plt.plot(th, F_the, label=r'$F_{the}$')
plt.plot(th, F_sim, '*', label=r'$F_{sim}$')
plt.plot(th, F_exp, 'o', label=r'$F_{exp}$')
plt.xlabel(r'$\theta$')
plt.legend()
plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import *
import numpy as np
import math
from matplotlib import pyplot as plt
import qiskit
nshots = 8192
IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
#from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.visualization import plot_histogram
qr = QuantumRegister(4)
cr = ClassicalRegister(3)
qc = QuantumCircuit(qr, cr)
qc.x(3)
qc.h([0,1,2])
qc.draw('mpl')
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-np.pi/2, np.pi/2, 1000) # generate 1000 evenly spaced points between -pi and pi
y_sin = np.abs(np.sin(x/2)) # compute sin(x) for each x
y_x = np.abs(x/2) # set y=x for each x
plt.plot(x, y_sin, label='sin(x)') # plot sin(x) as a blue line
plt.plot(x, y_x, label='x', color='orange') # plot x as an orange line
plt.legend() # display the legend
plt.show() # show the plot
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
N = 10**7; d = np.arange(2,N+1,1); dl = np.zeros(len(d)); nv = np.zeros(len(d))
n = 1
for j in range(2,len(d)):
nv[j] = n
dl[j] = 2**n
if d[j] >= dl[j]:
n += 1
from matplotlib import pyplot as plt
plt.plot(d,d, label=r'$d$')
plt.plot(d,dl, label=r'$dl$')
plt.xlabel(r'$d$'); plt.ylabel(r'$dl$'); plt.show()
plt.plot(d,nv, label=r'$n$')
plt.xlabel(r'$d$'); plt.ylabel(r'$n$'); plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
pip install qiskit
import qiskit
qiskit.__qiskit_version__
pip install qiskit-ibm-runtime
from qiskit_ibm_runtime import QiskitRuntimeService
QiskitRuntimeService.save_account(channel="ibm_quantum", token="463bc61b55d82149a7ec719c9e89eeb8bc80a916eac5331f2d98fc35be2b4650af627d457593b0050910aa0bd4a0f1e3a8361ff25874d214f01640e55e571d27")
from qiskit.test.reference_circuits import ReferenceCircuits
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler
service = QiskitRuntimeService()
backend = service.backend("ibmq_qasm_simulator")
job = Sampler(backend).run(ReferenceCircuits.bell())
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
# General
import numpy as np
# Qiskit imports
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import SparsePauliOp
# Runtime imports
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, Session
# Plotting routines
import matplotlib.pyplot as plt
import matplotlib.ticker as tck
# Add your token below
service = QiskitRuntimeService(channel="ibm_quantum")
# Select the system with the fewest number of jobs in the queue
backend = service.least_busy(simulator=False, operational=True)
# Initialize your session
session = Session(backend=backend)
backend.name
theta = Parameter("$\\theta$")
chsh_circuit_no_meas = QuantumCircuit(2)
chsh_circuit_no_meas.h(0)
chsh_circuit_no_meas.cx(0, 1)
chsh_circuit_no_meas.ry(theta, 0)
chsh_circuit_no_meas.draw()
number_of_phases = 21
phases = np.linspace(0, 2 * np.pi, number_of_phases)
# Phases need to be expressed as list of lists in order to work
individual_phases = [[ph] for ph in phases]
ZZ = SparsePauliOp.from_list([("ZZ", 1)])
ZX = SparsePauliOp.from_list([("ZX", 1)])
XZ = SparsePauliOp.from_list([("XZ", 1)])
XX = SparsePauliOp.from_list([("XX", 1)])
ops = [ZZ, ZX, XZ, XX]
num_ops = len(ops)
batch_circuits = [chsh_circuit_no_meas] * number_of_phases * num_ops
batch_ops = [op for op in ops for _ in individual_phases]
estimator = Estimator(session=session)
batch_expvals = (
estimator.run(
batch_circuits, batch_ops, parameter_values=individual_phases * num_ops, shots=int(1e4)
)
.result()
.values
)
ZZ_expval, ZX_expval, XZ_expval, XX_expval = [
batch_expvals[kk * number_of_phases : (kk + 1) * number_of_phases] for kk in range(num_ops)
]
# <CHSH1> = <AB> - <Ab> + <aB> + <ab>
chsh1_est = ZZ_expval - ZX_expval + XZ_expval + XX_expval
# <CHSH2> = <AB> + <Ab> - <aB> + <ab>
chsh2_est = ZZ_expval + ZX_expval - XZ_expval + XX_expval
fig, ax = plt.subplots(figsize=(10, 6))
# results from hardware
ax.plot(phases / np.pi, chsh1_est, "o-", label="CHSH1", zorder=3)
ax.plot(phases / np.pi, chsh2_est, "o-", label="CHSH2", zorder=3)
# classical bound +-2
ax.axhline(y=2, color="0.9", linestyle="--")
ax.axhline(y=-2, color="0.9", linestyle="--")
# quantum bound, +-2√2
ax.axhline(y=np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.axhline(y=-np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.fill_between(phases / np.pi, 2, 2 * np.sqrt(2), color="0.6", alpha=0.7)
ax.fill_between(phases / np.pi, -2, -2 * np.sqrt(2), color="0.6", alpha=0.7)
# set x tick labels to the unit of pi
ax.xaxis.set_major_formatter(tck.FormatStrFormatter("%g $\pi$"))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))
# set title, labels, and legend
plt.title(f"Violation of CHSH Inequality")
plt.xlabel("Theta")
plt.ylabel("CHSH witness")
plt.legend()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
#!pip install pylatexenc # para desenhar os circuitos quânticos
from qiskit import QuantumCircuit
qc = QuantumCircuit(1,1)
qc.barrier()
qc.measure(0,0)
qc.draw('mpl') # Para medidas de Z
qc = QuantumCircuit(1,1)
qc.barrier()
qc.h(0)
qc.measure(0,0)
qc.draw('mpl') # Para medidas de X
qc = QuantumCircuit(1,1)
qc.barrier()
qc.sdg(0)
qc.h(0)
qc.measure(0,0)
qc.draw('mpl') # Para medidas de Y
# Calculo da inversa da matrix de Hadamard
from sympy import Matrix
H2 = Matrix([[1,1],[1,-1]]); H2
H2.inv()
def tomo_1qb(avgs):
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
return 0.5*(s0 + avgs[1]*s1 + avgs[2]*s2 + avgs[3]*s3)
import numpy as np
avgs = np.array([1,0.1,-0.2,0.5]); rho1qb = tomo_1qb(avgs); rho1qb
def qc_test_1qb():
from qiskit import QuantumCircuit
qc = QuantumCircuit(1, name='qc')
qc.h(0)
return qc
from qiskit import QuantumCircuit, execute
from qiskit import Aer
simulator = Aer.get_backend('qasm_simulator')
nshots = 2**13
qct = qc_test_1qb() # circuito quantico principal
# medida de X
qc = QuantumCircuit(1,1)
qc.append(qct,[0])
qc.h(0); qc.measure(0,0)
qcx = qc
job = execute(qc, backend = simulator, shots = nshots)
counts_x = job.result().get_counts()
print('counts_x=',counts_x)
if '0' in counts_x:
Xavg = counts_x['0']
if '1' in counts_x:
Xavg -= counts_x['1']
Xavg = Xavg/nshots
print(Xavg)
# medida de Y
qc = QuantumCircuit(1,1)
qc.append(qct,[0])
qc.sdg(0); qc.h(0); qc.measure(0,0)
qcy = qc
job = execute(qc, backend = simulator, shots = nshots)
counts_y = job.result().get_counts()
print('counts_y=',counts_y)
if '0' in counts_y:
Yavg = counts_y['0']
if '1' in counts_y:
Yavg -= counts_y['1']
Yavg = Yavg/nshots
print(Yavg)
# medida de Z
qc = QuantumCircuit(1,1)
qc.append(qct,[0])
qc.measure(0,0)
qcz = qc
job = execute(qc, backend = simulator, shots = nshots)
counts_z = job.result().get_counts()
print('counts_z=',counts_z)
if '0' in counts_z:
Zavg = counts_z['0']
if '1' in counts_y:
Zavg -= counts_z['1']
Zavg = Zavg/nshots
print(Zavg)
#qcx.draw('mpl') #ok
qcy.draw('mpl')
#qcz.draw('mpl')
avgs = [1, Xavg, Yavg, Zavg]
rho1qb = tomo_1qb(avgs)
rho1qb
from numpy import linalg as LA
evals, evecs = LA.eig(rho1qb)
evals
evecs
from sympy.physics.quantum import TensorProduct as tp
H4 = tp(H2,H2); H4
H4i = H4.inv(); H4i
def tomo_2qb(avgs):
# avgs e uma lista com 16 valores medios na seguinte ordem [II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
rho = np.zeros([4,4],dtype=complex)
l = 0
for j in range(0,3):
for k in range(0,3):
l += 1
rho += avgs[l]*tp(paulis[j],paulis[k])
return 0.25*rho
avgs = [1,0.1,0,0,0.1,0.3,0,0,0.3,0,0.2,0,0,0.1,0,0.5] #[II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
rho = tomo_2qb(avgs); rho
# Inversa da matriz de Hadamard 4x4 (sem o multiplo 1/4)
H4i = np.array([[1,1,1,1],[1,-1,1,-1],[1,1,-1,-1],[1,-1,-1,1]]); H4i
def qc_test_2qb():
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, name='qc2qb')
qc.h(0); qc.cx(0,1)
return qc
def tomo_2qb(avgs):
# avgs e uma lista com 64 valores medios na seguinte ordem [III,IIX,IIY,IIZ,IXI,IXX,IXY,IXZ,...]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3]
rho = np.zeros([4,4],dtype=complex)
m = 0
for j in range(0,4):
for k in range(0,4):
for l in range(0,4):
rho += avgs[m]*np.kron(np.kron(paulis[j],paulis[k]),paulis[l])
m += 1
return 0.25*rho
from qiskit import QuantumCircuit, execute
from qiskit import Aer
simulator = Aer.get_backend('qasm_simulator')
nshots = 2**13
qct = qc_test_2qb() # circuito quantico principal
# medida de XX
qc = QuantumCircuit(2,2); qc.append(qct,[0,1]); qc.h([0,1]); qc.measure([0,1],[0,1]); qcxx = qc
job = execute(qc, backend = simulator, shots = nshots); counts_xx = job.result().get_counts()
pr_xx = np.zeros(4); cb2_labels = ['00','10','01','11']
for j in range(0,4):
if cb2_labels[j] in counts_xx:
pr_xx[j] = counts_xx[cb2_labels[j]]/nshots
print('counts_xx=',counts_xx, pr_xx)
XX_vec = np.matmul(H4i,pr_xx); print('XX_vec=',XX_vec) # =[II,IX,XI,XX]
qcxx.draw('mpl')
ss_vecs = [] # list with the averages of the observables
obs = ['x','y','z']
for j in range(0,3):
lo = obs[j] # left observable
for k in range(0,3):
ro = obs[k] # right observable
qc = QuantumCircuit(2,2)
qc.append(qct,[0,1]) # the quantum circuit for preparing psi
if lo == 'x' and ro = 'x':
qc.h([0,1])
elif lo == 'x' and ro = 'y':
qc.sdg(1); qc.h([0,1])
elif lo == 'y' and ro = 'x':
qc.sdg(0); qc.h([0,1])
elif lo == 'y' and ro = 'y':
qc.sdg([0,1]); qc.h([0,1])
qc.measure([0,1],[0,1])
job = execute(qc, backend = simulator, shots = nshots)
counts = job.result().get_counts()
pr = np.zeros(4); cb2_labels = ['00','10','01','11']
for j in range(0,4):
if cb2_labels[j] in counts_xx:
pr_xx[j] = counts_xx[cb2_labels[j]]/nshots
ss_vec = np.matmul(H4i,pr)
ss_vecs.append(ss_vec)
# matriz de Hadamard
H8 = tp(H2,H4); H8
H8i = H8.inv(); H8i
from sympy import symbols
f000,f001,f010,f011,f100,f101,f110,f111 = symbols('f_{000},f_{001},f_{010},f_{011},f_{100},f_{101},f_{110},f_{111}')
f = Matrix([[f000],[f001],[f010],[f011],[f100],[f101],[f110],[f111]])
f.T
al = 8*H8i*f; al
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]]); s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
list_avgs = []
m = 0
for j in range(0,4):
for k in range(0,4):
for l in range(0,4):
list_avgs.append((j,k,l))
m += 1
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
#!pip install pylatexenc # para desenhar os circuitos quânticos
from qiskit import QuantumCircuit
qc = QuantumCircuit(1,1)
qc.barrier()
qc.measure(0,0)
qc.draw('mpl') # Para medidas de Z
# Para medidas de X
qc = QuantumCircuit(1,1)
qc.barrier()
qc.h(0)
qc.measure(0,0)
qc.draw('mpl')
# Para medidas de Y
qc = QuantumCircuit(1,1)
qc.barrier()
qc.sdg(0)
qc.h(0)
qc.measure(0,0)
qc.draw('mpl')
# Calculo da inversa da matrix de Hadamard
from sympy import Matrix
H2 = Matrix([[1,1],[1,-1]]); H2
H2.inv()
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import SamplerV2 as Sampler
import numpy as np
def tomo_rho_1qb_sim(nqb, qbt, qct, nshots, backend):
# qct = quantum circuit for tomography
# nqb = number of qubits
# qbt = qubit to be tomographed
sampler = Sampler(backend=backend)
avgs = []
for j in range(0,3):
qc_list = []
qc = QuantumCircuit(nqb,1)
qc.append(qct,list(range(nqb)))
if j == 0: # medida de X
qc.h(qbt)
elif j == 1: # medida de Y
qc.sdg(qbt)
qc.h(qbt)
qc.measure(qbt,0)
qc_list.append(qc.decompose())
job = sampler.run(qc_list, shots=nshots)
counts = job.result()[0].data.c.get_counts()
if '0' in counts:
avg = counts['0']
if '1' in counts:
avg -= counts['1']
avg = avg/nshots
avgs.append(avg)
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
rho_1qb = 0.5*(s0 + avgs[0]*s1 + avgs[1]*s2 + avgs[2]*s3)
return rho_1qb
nqb = 2; qbt = 0
qct = QuantumCircuit(nqb)
qct.h(0)
qct.cx(0,1)
nshots = 2**13
backend = AerSimulator()
rho = tomo_rho_1qb(nqb, qbt, qct, nshots, backend)
print(rho)
from sympy.physics.quantum import TensorProduct as tp
H4 = tp(H2,H2); H4
H4i = H4.inv(); H4i
def hadarmard_inv():
return (1/4)*np.array([[1,1,1,1],[1,-1,1,-1],[1,1,-1,-1],[1,-1,-1,1]])
#hadarmard_inv()
def tomo_rho_2qb(nqb, qbt, qct, nshots, backend):
# qct = quantum circuit for tomography
# nqb = number of qubits
# qbt = list with the 2 qubits to be tomographed
sampler = Sampler(backend=backend)
avgs = []
for j in range(1,4):
for k in range(1,4):
qc_list = []
qc = QuantumCircuit(nqb,2)
qc.append(qct,list(range(nqb)))
if j == 1: # medida de X_0
qc.h(qbt[0])
elif j == 2: # medida de Y_0
qc.sdg(qbt[0])
qc.h(qbt[0])
if k == 1: # medida de X_1
qc.h(qbt[1])
elif k == 2: # medida de Y_1
qc.sdg(qbt[1])
qc.h(qbt[1])
qc.measure(qbt,[0,1]) # medida de ZZ
qc_list.append(qc.decompose())
job = sampler.run(qc_list, shots=nshots)
counts = job.result()[0].data.c.get_counts()
labels = ['00','01','10','11']
probs = np.zeros(4)
for l in range(0,4):
if labels[l] in counts:
probs[l] = counts[labels[l]]/nshots
print(probs)
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
rho_2qb = 0.5*(s0 + avgs[0]*s1 + avgs[1]*s2 + avgs[2]*s3)
return rho_2qb
def tomo_2qb(avgs):
# avgs e uma lista com 16 valores medios na seguinte ordem [II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
rho = np.zeros([4,4],dtype=complex)
l = 0
for j in range(0,3):
for k in range(0,3):
l += 1
rho += avgs[l]*tp(paulis[j],paulis[k])
return 0.25*rho
nqb = 2; qbt = [0,1]
qct = QuantumCircuit(nqb)
qct.h(0)
qct.cx(0,1)
nshots = 2**13
backend = AerSimulator()
rho = tomo_rho_2qb(nqb, qbt, qct, nshots, backend)
print(rho)
print(np.zeros(4))
def tomo_2qb(avgs):
# avgs e uma lista com 16 valores medios na seguinte ordem [II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
rho = np.zeros([4,4],dtype=complex)
l = 0
for j in range(0,3):
for k in range(0,3):
l += 1
rho += avgs[l]*tp(paulis[j],paulis[k])
return 0.25*rho
avgs = [1,0.1,0,0,0.1,0.3,0,0,0.3,0,0.2,0,0,0.1,0,0.5] #[II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
rho = tomo_2qb(avgs); rho
# Inversa da matriz de Hadamard 4x4 (sem o multiplo 1/4)
H4i = np.array([[1,1,1,1],[1,-1,1,-1],[1,1,-1,-1],[1,-1,-1,1]]); H4i
def qc_test_2qb():
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, name='qc2qb')
qc.h(0); qc.cx(0,1)
return qc
def tomo_2qb(avgs):
# avgs e uma lista com 64 valores medios na seguinte ordem [III,IIX,IIY,IIZ,IXI,IXX,IXY,IXZ,...]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3]
rho = np.zeros([4,4],dtype=complex)
m = 0
for j in range(0,4):
for k in range(0,4):
for l in range(0,4):
rho += avgs[m]*np.kron(np.kron(paulis[j],paulis[k]),paulis[l])
m += 1
return 0.25*rho
from qiskit import QuantumCircuit, execute
from qiskit import Aer
simulator = Aer.get_backend('qasm_simulator')
nshots = 2**13
qct = qc_test_2qb() # circuito quantico principal
# medida de XX
qc = QuantumCircuit(2,2); qc.append(qct,[0,1]); qc.h([0,1]); qc.measure([0,1],[0,1]); qcxx = qc
job = execute(qc, backend = simulator, shots = nshots); counts_xx = job.result().get_counts()
pr_xx = np.zeros(4); cb2_labels = ['00','10','01','11']
for j in range(0,4):
if cb2_labels[j] in counts_xx:
pr_xx[j] = counts_xx[cb2_labels[j]]/nshots
print('counts_xx=',counts_xx, pr_xx)
XX_vec = np.matmul(H4i,pr_xx); print('XX_vec=',XX_vec) # =[II,IX,XI,XX]
qcxx.draw('mpl')
ss_vecs = [] # list with the averages of the observables
obs = ['x','y','z']
for j in range(0,3):
lo = obs[j] # left observable
for k in range(0,3):
ro = obs[k] # right observable
qc = QuantumCircuit(2,2)
qc.append(qct,[0,1]) # the quantum circuit for preparing psi
if lo == 'x' and ro = 'x':
qc.h([0,1])
elif lo == 'x' and ro = 'y':
qc.sdg(1); qc.h([0,1])
elif lo == 'y' and ro = 'x':
qc.sdg(0); qc.h([0,1])
elif lo == 'y' and ro = 'y':
qc.sdg([0,1]); qc.h([0,1])
qc.measure([0,1],[0,1])
job = execute(qc, backend = simulator, shots = nshots)
counts = job.result().get_counts()
pr = np.zeros(4); cb2_labels = ['00','10','01','11']
for j in range(0,4):
if cb2_labels[j] in counts_xx:
pr_xx[j] = counts_xx[cb2_labels[j]]/nshots
ss_vec = np.matmul(H4i,pr)
ss_vecs.append(ss_vec)
# matriz de Hadamard
H8 = tp(H2,H4); H8
H8i = H8.inv(); H8i
from sympy import symbols
f000,f001,f010,f011,f100,f101,f110,f111 = symbols('f_{000},f_{001},f_{010},f_{011},f_{100},f_{101},f_{110},f_{111}')
f = Matrix([[f000],[f001],[f010],[f011],[f100],[f101],[f110],[f111]])
f.T
al = 8*H8i*f; al
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]]); s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
list_avgs = []
m = 0
for j in range(0,4):
for k in range(0,4):
for l in range(0,4):
list_avgs.append((j,k,l))
m += 1
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit_ibm_runtime import QiskitRuntimeService
QiskitRuntimeService.save_account(channel='ibm_quantum',
token='83ab2a86232e48767228534cdae2cf55b8e8ea4e0eb1e57804268f40d7bee64692f719528e8871de617ffc35040d21bd389f4696313f46900c077c7f617a1512',
overwrite=True)
service = QiskitRuntimeService(instance='ibm-q/open/main')
print(service.backends())
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc.measure_all()
qc.draw()
from qiskit_ibm_runtime import Sampler, Options, Session
options = Options(optimization_level=1)
with Session(service=service, backend="ibmq_qasm_simulator") as session:
sampler = Sampler(session=session, options=options)
job = sampler.run(circuits=qc) # foi usado 18 s dos 10 min (por conjunto de 4000 prepara-evolui-mede experimentos)
job.result() # 'probabilidades' (eles chamam de quasiprobabilidades)
counts = job.result().quasi_dists[0].binary_probabilities()
counts
from qiskit.visualization import plot_histogram
plot_histogram(counts)
backend = service.get_backend("ibm_osaka")
with Session(service=service, backend=backend) as session:
sampler = Sampler(session=session, options=options)
job = sampler.run(circuits=qc)
print(job.job_id())
jobr = service.job('cnvn5zzvn4c0008a6df0')
jobr.result()
counts = jobr.result().quasi_dists[0].binary_probabilities()
counts # ?
plot_histogram(counts)
print(jobr.logs())
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator
service = QiskitRuntimeService(channel="ibm_cloud")
psi1 = RealAmplitudes(num_qubits=2, reps=2)
H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
H2 = SparsePauliOp.from_list([("IZ", 1)])
H3 = SparsePauliOp.from_list([("ZI", 1), ("ZZ", 1)])
with Session(service=service, backend="ibmq_qasm_simulator") as session:
estimator = Estimator(session=session)
theta1 = [0, 1, 1, 2, 3, 5]
# calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
psi1_H1 = estimator.run(circuits=[psi1], observables=[H1], parameter_values=[theta1])
print(psi1_H1.result())
# calculate [ <psi1(theta1)|H2|psi1(theta1)>, <psi1(theta1)|H3|psi1(theta1)> ]
psi1_H23 = estimator.run(
circuits=[psi1, psi1],
observables=[H2, H3],
parameter_values=[theta1]*2
)
print(psi1_H23.result())
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
!pip install --upgrade pyscf
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver(
atom="H 0 0 0; H 0 0 0.735",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
es_problem = driver.run()
#!pip install qiskit_algorithms
from qiskit_algorithms.optimizers import SPSA # simultaneous perturbation stochastic approximation
from qiskit.circuit.library import EfficientSU2 # ansatz para o circuito variacional
ansatz = EfficientSU2(2)
ansatz.decompose().draw('mpl')
from qiskit.primitives import Estimator
estimator = Estimator()
callback = lambda nfev, params, fval, step, acc: print(f'Evaluation {nfev}: {fval}')
optimizer = SPSA(callback=callback, maxiter=1000)
cost_func = lambda params: estimator.run(ansatz, H2_op, parameter_values=params).result().values[0]
result = optimizer.minimize(cost_func, x0=np.zeros(ansatz.num_parameters))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
def cnot_matrix_ab(d):
cn = np.zeros((d**2,d**2),dtype=int)
for p in range(0,d): # d^2 elementos não nulos
for q in range(0,d):
cn[p*d+(p+q)%d,p*d+q] = 1
return cn
d=2; cn = cnot_matrix_ab(d); print(cn)
d=3; cn = cnot_matrix_ab(d); print(cn)
d=4; cn = cnot_matrix_ab(d); print(cn)
import numpy as np
def cnot_matrix(d, ctr):
cn = np.zeros((d**2,d**2),dtype=int)
if ctr == 'a':
for p in range(0,d):
for q in range(0,d):
cn[p*d+(p+q)%d,p*d+q] = 1
elif ctr == 'b':
for p in range(0,d):
for q in range(0,d):
cn[((q+p)%d)*d+q,p*d+q] = 1
return cn
d=2; print(cnot_matrix(d, 'b')) # ok!
d=3; print(cnot_matrix(d, 'b'))
def den2dec(local,d):
# local = list with the local computational base state values
# d = individual qudit dimension
N = len(local)
j = 0
for k in range(0,N):
j += local[k]*d**(N-1-k)
return j # value of the global computational basis index
# example: 3 qutrits
d = 3; N = 3
local = [0,0,0]
for j0 in range(0,3):
for j1 in range(0,3):
for j2 in range(0,3):
local = [j0,j1,j2]
j = den2dec(local,d)
print('j0 j1 j2 =',j0,j1,j2,', j =',j)
def dec2den(j,N,d):
den = [0 for k in range(0,N)]
jv = j
for k in range(0,N):
if jv >= d**(N-1-k):
den[k] = jv//(d**(N-1-k))
jv = jv - den[k]*d**(N-1-k)
return den
N = 3; d = 3
for j in range(0,d**N):
print('j=',j,', den=', dec2den(j,N,d))
def dec2den_opt(j,N,d): # optmized version
den = [0 for k in range(0,N)]
if j < d:
den[N-1] = j; return den
rem = [] # list for the remainders
k = j
while k >= d:
rem.append(k%d)
k = k//d
rem.append(k%d)
for j in range(0,len(rem)):
den[N-1-j] = rem[j]
return den
N = 3; d = 3
for j in range(0,d**N):
print('j=',j,', den=', dec2den_opt(j,N,d))
def cnot_qudits(d,N,t,c):
# d = qudit dimension; N = No. of qudits; t = target qudit (0,...,N-1); c = control qudit (0,...,N-1)
D = d**N; cnot = np.zeros((D,D), dtype=int) # set all d^2N elements to 0
for k in range (0,d**N):
localr = dec2den_opt(k,N,d) # sequence os values for the local basis
locall = localr.copy() # copy the right list to the left list
locall[t] = (localr[t]+localr[c])%d
globall = den2dec(locall,d)
cnot[globall,k] = 1
return cnot
d=2; N=2; t=1; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok!
d=2; N=2; t=0; c=1; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok!
d=3; N=2; t=1; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok!
d=2; N=3; t=2; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok
from sympy import init_printing, Matrix
init_printing(use_unicode=True)
from sympy.physics.quantum import TensorProduct
def tp(x,y):
return TensorProduct(x,y)
s1 = Matrix([[0,1],[1,0]]); s0 = Matrix([[1,0],[0,1]]); P0 = Matrix([[1,0],[0,0]]); P1 = Matrix([[0,0],[0,1]])
cnot03 = tp(tp(P0,s0),s0) + tp(tp(P1,s0),s1); cnot03
d=3; N=3; t=1; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
def dec2den(j,N,d):
den = [0 for k in range(0,N)]
jv = j
for k in range(0,N):
if jv >= d**(N-1-k):
den[k] = jv//(d**(N-1-k))
jv = jv - den[k]*d**(N-1-k)
return den
def den2dec(local,d):
# local = list with the local computational base state values
# d = individual qudit dimension
N = len(local)
j = 0
for k in range(0,N):
j += local[k]*d**(N-1-k)
return j # value of the global computational basis index
def dec2den_opt(j,N,d): # optimized version
den = [0 for k in range(0,N)]
if j < d:
den[N-1] = j; return den
rem = [] # list for the remainder
k = j
while k >= d:
rem.append(k%d)
k = k//d
rem.append(k%d)
for j in range(0,len(rem)):
den[N-1-j] = rem[j]
return den
import numpy as np
def swap_qudits(d,N,t,c):
# d = qudit dimension; N = No. of qudits; t = target qudit (0,...,N-1); c = control qudit (0,...,N-1)
D = d**N; swap = np.zeros((D,D), dtype=int) # set all d^2N elements to 0
for k in range (0,d**N):
localr = dec2den_opt(k,N,d) # sequence of values for the local basis
#locall = [0 for k in range(0,N)]
#for s in range(0,N):
# locall[s] = localr[s]
locall = localr.copy()
#rt = localr[t];
locall[c] = localr[t]
#rc = localr[c];
locall[t] = localr[c]
globall = den2dec(locall,d)
swap[globall,k] = 1
return swap
d=2; N=2; t=0; c=1; print(swap_qudits(d,N,t,c)) # ok
d=3; N=2; t=0; c=1; print(swap_qudits(d,N,t,c)) # ok
d=2; N=3; t=0; c=2; print(swap_qudits(d,N,t,c)) # ok
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
10*15+13*125, 10*15-27*125
def euclides_gcd(a,b):
if b > a: # put in increasing order
t = a; a = b; b = t
if a == b or a%b == 0: # test equality or null remainder
return b
r = a%b
print('a =', a, ', b =', b, ', k =', a//b, ', r =', r)
while r != 0:
a = b; b = r
gcd = b
r = a%b
print('a =', a, ', b =', b, ', k =', a//b, ', r =', r)
return b
import math
a = 6825; b = 1430; egcd = euclides_gcd(a,b)
print('euclides_gcd('+str(a)+','+str(b)+')=',egcd, ', python_gcd = ', math.gcd(a,b))
-9*6825 + 43*1430 # ok!
a = 126; p = 23; a%p, (a**p)%p, (a**(p-1))%p
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
import math
def Sx(j,k,d):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
sx = np.zeros((d,d), dtype=complex)
sx[j,k] = 1
sx[k,j] = sx[j,k]
return sx
def Sy(j,k,d):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
sy = np.zeros((d,d), dtype=complex)
sy[j,k] = -1j
sy[k,j] = -sy[j,k]
return sy
def Sz(j,d):
# d = qudit dimension
# j = identification of the Gell-Mann matrix
# th = rotation angle
sz = np.zeros((d,d), dtype=complex)
for k in range(0,j+1):
sz[k,k] = math.sqrt(2/(j*(j+1)))
if k == j: # corrige para iniciar k em 0
sz[k,k] = sz[k,k]*(-j)
return sz
d = 2; j = 1; k = 2; Sx(j,k,d), Sy(j,k,d), Sz(j,d)
d = 3; Sx(1,2,d), Sx(1,3,d), Sx(2,3,d)
d = 3; Sy(1,2,d), Sy(1,3,d), Sy(2,3,d)
d = 3; Sz(1,d), Sz(2,d)
1/math.sqrt(3), -2/math.sqrt(3)
def Rx(j,k,d,th):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
rx = np.eye(d, dtype=complex)
rx[j,j] = math.cos(th/2)
rx[k,k] = rx[j,j]
rx[j,k] = -1j*math.sin(th/2)
rx[k,j] = rx[j,k]
return rx
def Ry(j,k,d,th):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
ry = np.eye(d, dtype=complex)
ry[j,j] = math.cos(th/2)
ry[k,k] = ry[j,j]
ry[j,k] = -math.sin(th/2)
ry[k,j] = -ry[j,k]
return ry
def Rz(j,d,th):
# d = qudit dimension
# j = identification of the Gell-Mann matrix
# th = rotation angle
rz = np.eye(d, dtype=complex)
for k in range(0,j+1):
angle = (th/2)*math.sqrt(2/(j*(j+1)))
if k == j: # corrige para iniciar k em 0
angle = angle*(-j)
rz[k,k] = math.cos(angle) - 1j*math.sin(angle)
return rz
d = 2; j = 1; k = 2; th = 0; Rx(j,k,d,th), Ry(j,k,d,th), Rz(j,d,th)
d = 3; j = 1; k = 2; th = 0; Rx(j,k,d,th), Ry(j,k,d,th), Rz(j,d,th)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
N = 10**7; d = np.arange(2,N+1,1); dl = np.zeros(len(d)); nv = np.zeros(len(d))
n = 1
for j in range(2,len(d)):
nv[j] = n
dl[j] = 2**n
if d[j] >= dl[j]:
n += 1
from matplotlib import pyplot as plt
plt.plot(d,d, label=r'$d$')
plt.plot(d,dl, label=r'$dl$')
plt.xlabel(r'$d$'); plt.ylabel(r'$dl$'); plt.show()
plt.plot(d,nv, label=r'$n$')
plt.xlabel(r'$d$'); plt.ylabel(r'$n$'); plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
pip install qiskit
import qiskit
qiskit.__qiskit_version__
pip install qiskit-ibm-runtime
from qiskit_ibm_runtime import QiskitRuntimeService
QiskitRuntimeService.save_account(channel="ibm_quantum", token="463bc61b55d82149a7ec719c9e89eeb8bc80a916eac5331f2d98fc35be2b4650af627d457593b0050910aa0bd4a0f1e3a8361ff25874d214f01640e55e571d27")
from qiskit.test.reference_circuits import ReferenceCircuits
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler
service = QiskitRuntimeService()
backend = service.backend("ibmq_qasm_simulator")
job = Sampler(backend).run(ReferenceCircuits.bell())
print(f"job id: {job.job_id()}")
result = job.result()
print(result)
# General
import numpy as np
# Qiskit imports
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import SparsePauliOp
# Runtime imports
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, Session
# Plotting routines
import matplotlib.pyplot as plt
import matplotlib.ticker as tck
# Add your token below
service = QiskitRuntimeService(channel="ibm_quantum")
# Select the system with the fewest number of jobs in the queue
backend = service.least_busy(simulator=False, operational=True)
# Initialize your session
session = Session(backend=backend)
backend.name
theta = Parameter("$\\theta$")
chsh_circuit_no_meas = QuantumCircuit(2)
chsh_circuit_no_meas.h(0)
chsh_circuit_no_meas.cx(0, 1)
chsh_circuit_no_meas.ry(theta, 0)
chsh_circuit_no_meas.draw()
number_of_phases = 21
phases = np.linspace(0, 2 * np.pi, number_of_phases)
# Phases need to be expressed as list of lists in order to work
individual_phases = [[ph] for ph in phases]
ZZ = SparsePauliOp.from_list([("ZZ", 1)])
ZX = SparsePauliOp.from_list([("ZX", 1)])
XZ = SparsePauliOp.from_list([("XZ", 1)])
XX = SparsePauliOp.from_list([("XX", 1)])
ops = [ZZ, ZX, XZ, XX]
num_ops = len(ops)
batch_circuits = [chsh_circuit_no_meas] * number_of_phases * num_ops
batch_ops = [op for op in ops for _ in individual_phases]
estimator = Estimator(session=session)
batch_expvals = (
estimator.run(
batch_circuits, batch_ops, parameter_values=individual_phases * num_ops, shots=int(1e4)
)
.result()
.values
)
ZZ_expval, ZX_expval, XZ_expval, XX_expval = [
batch_expvals[kk * number_of_phases : (kk + 1) * number_of_phases] for kk in range(num_ops)
]
# <CHSH1> = <AB> - <Ab> + <aB> + <ab>
chsh1_est = ZZ_expval - ZX_expval + XZ_expval + XX_expval
# <CHSH2> = <AB> + <Ab> - <aB> + <ab>
chsh2_est = ZZ_expval + ZX_expval - XZ_expval + XX_expval
fig, ax = plt.subplots(figsize=(10, 6))
# results from hardware
ax.plot(phases / np.pi, chsh1_est, "o-", label="CHSH1", zorder=3)
ax.plot(phases / np.pi, chsh2_est, "o-", label="CHSH2", zorder=3)
# classical bound +-2
ax.axhline(y=2, color="0.9", linestyle="--")
ax.axhline(y=-2, color="0.9", linestyle="--")
# quantum bound, +-2√2
ax.axhline(y=np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.axhline(y=-np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.fill_between(phases / np.pi, 2, 2 * np.sqrt(2), color="0.6", alpha=0.7)
ax.fill_between(phases / np.pi, -2, -2 * np.sqrt(2), color="0.6", alpha=0.7)
# set x tick labels to the unit of pi
ax.xaxis.set_major_formatter(tck.FormatStrFormatter("%g $\pi$"))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))
# set title, labels, and legend
plt.title(f"Violation of CHSH Inequality")
plt.xlabel("Theta")
plt.ylabel("CHSH witness")
plt.legend()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
#!pip install pylatexenc # para desenhar os circuitos quânticos
from qiskit import QuantumCircuit
qc = QuantumCircuit(1,1)
qc.barrier()
qc.measure(0,0)
qc.draw('mpl') # Para medidas de Z
# Para medidas de X
qc = QuantumCircuit(1,1)
qc.barrier()
qc.h(0)
qc.measure(0,0)
qc.draw('mpl')
# Para medidas de Y
qc = QuantumCircuit(1,1)
qc.barrier()
qc.sdg(0)
qc.h(0)
qc.measure(0,0)
qc.draw('mpl')
# Calculo da inversa da matrix de Hadamard
from sympy import Matrix
H2 = Matrix([[1,1],[1,-1]]); H2
H2.inv()
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import SamplerV2 as Sampler
import numpy as np
def tomo_rho_1qb_sim(nqb, qbt, qct, nshots, backend):
# qct = quantum circuit for tomography
# nqb = number of qubits
# qbt = qubit to be tomographed
sampler = Sampler(backend=backend)
avgs = []
for j in range(0,3):
qc_list = []
qc = QuantumCircuit(nqb,1)
qc.append(qct,list(range(nqb)))
if j == 0: # medida de X
qc.h(qbt)
elif j == 1: # medida de Y
qc.sdg(qbt)
qc.h(qbt)
qc.measure(qbt,0)
qc_list.append(qc.decompose())
job = sampler.run(qc_list, shots=nshots)
counts = job.result()[0].data.c.get_counts()
if '0' in counts:
avg = counts['0']
if '1' in counts:
avg -= counts['1']
avg = avg/nshots
avgs.append(avg)
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
rho_1qb = 0.5*(s0 + avgs[0]*s1 + avgs[1]*s2 + avgs[2]*s3)
return rho_1qb
nqb = 2; qbt = 0
qct = QuantumCircuit(nqb)
qct.h(0)
qct.cx(0,1)
nshots = 2**13
backend = AerSimulator()
rho = tomo_rho_1qb(nqb, qbt, qct, nshots, backend)
print(rho)
from sympy.physics.quantum import TensorProduct as tp
H4 = tp(H2,H2); H4
H4i = H4.inv(); H4i
def hadarmard_inv():
return (1/4)*np.array([[1,1,1,1],[1,-1,1,-1],[1,1,-1,-1],[1,-1,-1,1]])
#hadarmard_inv()
def tomo_rho_2qb(nqb, qbt, qct, nshots, backend):
# qct = quantum circuit for tomography
# nqb = number of qubits
# qbt = list with the 2 qubits to be tomographed
sampler = Sampler(backend=backend)
avgs = []
for j in range(1,4):
for k in range(1,4):
qc_list = []
qc = QuantumCircuit(nqb,2)
qc.append(qct,list(range(nqb)))
if j == 1: # medida de X_0
qc.h(qbt[0])
elif j == 2: # medida de Y_0
qc.sdg(qbt[0])
qc.h(qbt[0])
if k == 1: # medida de X_1
qc.h(qbt[1])
elif k == 2: # medida de Y_1
qc.sdg(qbt[1])
qc.h(qbt[1])
qc.measure(qbt,[0,1]) # medida de ZZ
qc_list.append(qc.decompose())
job = sampler.run(qc_list, shots=nshots)
counts = job.result()[0].data.c.get_counts()
labels = ['00','01','10','11']
probs = np.zeros(4)
for l in range(0,4):
if labels[l] in counts:
probs[l] = counts[labels[l]]/nshots
print(probs)
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
rho_2qb = 0.5*(s0 + avgs[0]*s1 + avgs[1]*s2 + avgs[2]*s3)
return rho_2qb
def tomo_2qb(avgs):
# avgs e uma lista com 16 valores medios na seguinte ordem [II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
rho = np.zeros([4,4],dtype=complex)
l = 0
for j in range(0,3):
for k in range(0,3):
l += 1
rho += avgs[l]*tp(paulis[j],paulis[k])
return 0.25*rho
nqb = 2; qbt = [0,1]
qct = QuantumCircuit(nqb)
qct.h(0)
qct.cx(0,1)
nshots = 2**13
backend = AerSimulator()
rho = tomo_rho_2qb(nqb, qbt, qct, nshots, backend)
print(rho)
print(np.zeros(4))
def tomo_2qb(avgs):
# avgs e uma lista com 16 valores medios na seguinte ordem [II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
rho = np.zeros([4,4],dtype=complex)
l = 0
for j in range(0,3):
for k in range(0,3):
l += 1
rho += avgs[l]*tp(paulis[j],paulis[k])
return 0.25*rho
avgs = [1,0.1,0,0,0.1,0.3,0,0,0.3,0,0.2,0,0,0.1,0,0.5] #[II,IX,IY,IZ,XI,XX,XY,XZ,YI,YX,YY,YZ,ZI,ZX,ZY,ZZ]
rho = tomo_2qb(avgs); rho
# Inversa da matriz de Hadamard 4x4 (sem o multiplo 1/4)
H4i = np.array([[1,1,1,1],[1,-1,1,-1],[1,1,-1,-1],[1,-1,-1,1]]); H4i
def qc_test_2qb():
from qiskit import QuantumCircuit
qc = QuantumCircuit(2, name='qc2qb')
qc.h(0); qc.cx(0,1)
return qc
def tomo_2qb(avgs):
# avgs e uma lista com 64 valores medios na seguinte ordem [III,IIX,IIY,IIZ,IXI,IXX,IXY,IXZ,...]
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]])
s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3]
rho = np.zeros([4,4],dtype=complex)
m = 0
for j in range(0,4):
for k in range(0,4):
for l in range(0,4):
rho += avgs[m]*np.kron(np.kron(paulis[j],paulis[k]),paulis[l])
m += 1
return 0.25*rho
from qiskit import QuantumCircuit, execute
from qiskit import Aer
simulator = Aer.get_backend('qasm_simulator')
nshots = 2**13
qct = qc_test_2qb() # circuito quantico principal
# medida de XX
qc = QuantumCircuit(2,2); qc.append(qct,[0,1]); qc.h([0,1]); qc.measure([0,1],[0,1]); qcxx = qc
job = execute(qc, backend = simulator, shots = nshots); counts_xx = job.result().get_counts()
pr_xx = np.zeros(4); cb2_labels = ['00','10','01','11']
for j in range(0,4):
if cb2_labels[j] in counts_xx:
pr_xx[j] = counts_xx[cb2_labels[j]]/nshots
print('counts_xx=',counts_xx, pr_xx)
XX_vec = np.matmul(H4i,pr_xx); print('XX_vec=',XX_vec) # =[II,IX,XI,XX]
qcxx.draw('mpl')
ss_vecs = [] # list with the averages of the observables
obs = ['x','y','z']
for j in range(0,3):
lo = obs[j] # left observable
for k in range(0,3):
ro = obs[k] # right observable
qc = QuantumCircuit(2,2)
qc.append(qct,[0,1]) # the quantum circuit for preparing psi
if lo == 'x' and ro = 'x':
qc.h([0,1])
elif lo == 'x' and ro = 'y':
qc.sdg(1); qc.h([0,1])
elif lo == 'y' and ro = 'x':
qc.sdg(0); qc.h([0,1])
elif lo == 'y' and ro = 'y':
qc.sdg([0,1]); qc.h([0,1])
qc.measure([0,1],[0,1])
job = execute(qc, backend = simulator, shots = nshots)
counts = job.result().get_counts()
pr = np.zeros(4); cb2_labels = ['00','10','01','11']
for j in range(0,4):
if cb2_labels[j] in counts_xx:
pr_xx[j] = counts_xx[cb2_labels[j]]/nshots
ss_vec = np.matmul(H4i,pr)
ss_vecs.append(ss_vec)
# matriz de Hadamard
H8 = tp(H2,H4); H8
H8i = H8.inv(); H8i
from sympy import symbols
f000,f001,f010,f011,f100,f101,f110,f111 = symbols('f_{000},f_{001},f_{010},f_{011},f_{100},f_{101},f_{110},f_{111}')
f = Matrix([[f000],[f001],[f010],[f011],[f100],[f101],[f110],[f111]])
f.T
al = 8*H8i*f; al
import numpy as np
s0 = np.array([[1,0],[0,1]]); s1 = np.array([[0,1],[1,0]]); s2 = np.array([[0,-1j],[1j,0]]); s3 = np.array([[1,0],[0,-1]])
paulis = [s0,s1,s2,s3] # lista com as matrizes de Pauli
list_avgs = []
m = 0
for j in range(0,4):
for k in range(0,4):
for l in range(0,4):
list_avgs.append((j,k,l))
m += 1
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit_ibm_runtime import QiskitRuntimeService
QiskitRuntimeService.save_account(channel='ibm_quantum',
token='83ab2a86232e48767228534cdae2cf55b8e8ea4e0eb1e57804268f40d7bee64692f719528e8871de617ffc35040d21bd389f4696313f46900c077c7f617a1512',
overwrite=True)
service = QiskitRuntimeService(instance='ibm-q/open/main')
print(service.backends())
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc.measure_all()
qc.draw()
from qiskit_ibm_runtime import Sampler, Options, Session
options = Options(optimization_level=1)
with Session(service=service, backend="ibmq_qasm_simulator") as session:
sampler = Sampler(session=session, options=options)
job = sampler.run(circuits=qc) # foi usado 18 s dos 10 min (por conjunto de 4000 prepara-evolui-mede experimentos)
job.result() # 'probabilidades' (eles chamam de quasiprobabilidades)
counts = job.result().quasi_dists[0].binary_probabilities()
counts
from qiskit.visualization import plot_histogram
plot_histogram(counts)
backend = service.get_backend("ibm_osaka")
with Session(service=service, backend=backend) as session:
sampler = Sampler(session=session, options=options)
job = sampler.run(circuits=qc)
print(job.job_id())
jobr = service.job('cnvn5zzvn4c0008a6df0')
jobr.result()
counts = jobr.result().quasi_dists[0].binary_probabilities()
counts # ?
plot_histogram(counts)
print(jobr.logs())
from qiskit.circuit.library import RealAmplitudes
from qiskit.quantum_info import SparsePauliOp
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator
service = QiskitRuntimeService(channel="ibm_cloud")
psi1 = RealAmplitudes(num_qubits=2, reps=2)
H1 = SparsePauliOp.from_list([("II", 1), ("IZ", 2), ("XI", 3)])
H2 = SparsePauliOp.from_list([("IZ", 1)])
H3 = SparsePauliOp.from_list([("ZI", 1), ("ZZ", 1)])
with Session(service=service, backend="ibmq_qasm_simulator") as session:
estimator = Estimator(session=session)
theta1 = [0, 1, 1, 2, 3, 5]
# calculate [ <psi1(theta1)|H1|psi1(theta1)> ]
psi1_H1 = estimator.run(circuits=[psi1], observables=[H1], parameter_values=[theta1])
print(psi1_H1.result())
# calculate [ <psi1(theta1)|H2|psi1(theta1)>, <psi1(theta1)|H3|psi1(theta1)> ]
psi1_H23 = estimator.run(
circuits=[psi1, psi1],
observables=[H2, H3],
parameter_values=[theta1]*2
)
print(psi1_H23.result())
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
!pip install --upgrade pyscf
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver(
atom="H 0 0 0; H 0 0 0.735",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
es_problem = driver.run()
#!pip install qiskit_algorithms
from qiskit_algorithms.optimizers import SPSA # simultaneous perturbation stochastic approximation
from qiskit.circuit.library import EfficientSU2 # ansatz para o circuito variacional
ansatz = EfficientSU2(2)
ansatz.decompose().draw('mpl')
from qiskit.primitives import Estimator
estimator = Estimator()
callback = lambda nfev, params, fval, step, acc: print(f'Evaluation {nfev}: {fval}')
optimizer = SPSA(callback=callback, maxiter=1000)
cost_func = lambda params: estimator.run(ansatz, H2_op, parameter_values=params).result().values[0]
result = optimizer.minimize(cost_func, x0=np.zeros(ansatz.num_parameters))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
def cnot_matrix_ab(d):
cn = np.zeros((d**2,d**2),dtype=int)
for p in range(0,d): # d^2 elementos não nulos
for q in range(0,d):
cn[p*d+(p+q)%d,p*d+q] = 1
return cn
d=2; cn = cnot_matrix_ab(d); print(cn)
d=3; cn = cnot_matrix_ab(d); print(cn)
d=4; cn = cnot_matrix_ab(d); print(cn)
import numpy as np
def cnot_matrix(d, ctr):
cn = np.zeros((d**2,d**2),dtype=int)
if ctr == 'a':
for p in range(0,d):
for q in range(0,d):
cn[p*d+(p+q)%d,p*d+q] = 1
elif ctr == 'b':
for p in range(0,d):
for q in range(0,d):
cn[((q+p)%d)*d+q,p*d+q] = 1
return cn
d=2; print(cnot_matrix(d, 'b')) # ok!
d=3; print(cnot_matrix(d, 'b'))
def den2dec(local,d):
# local = list with the local computational base state values
# d = individual qudit dimension
N = len(local)
j = 0
for k in range(0,N):
j += local[k]*d**(N-1-k)
return j # value of the global computational basis index
# example: 3 qutrits
d = 3; N = 3
local = [0,0,0]
for j0 in range(0,3):
for j1 in range(0,3):
for j2 in range(0,3):
local = [j0,j1,j2]
j = den2dec(local,d)
print('j0 j1 j2 =',j0,j1,j2,', j =',j)
def dec2den(j,N,d):
den = [0 for k in range(0,N)]
jv = j
for k in range(0,N):
if jv >= d**(N-1-k):
den[k] = jv//(d**(N-1-k))
jv = jv - den[k]*d**(N-1-k)
return den
N = 3; d = 3
for j in range(0,d**N):
print('j=',j,', den=', dec2den(j,N,d))
def dec2den_opt(j,N,d): # optmized version
den = [0 for k in range(0,N)]
if j < d:
den[N-1] = j; return den
rem = [] # list for the remainders
k = j
while k >= d:
rem.append(k%d)
k = k//d
rem.append(k%d)
for j in range(0,len(rem)):
den[N-1-j] = rem[j]
return den
N = 3; d = 3
for j in range(0,d**N):
print('j=',j,', den=', dec2den_opt(j,N,d))
def cnot_qudits(d,N,t,c):
# d = qudit dimension; N = No. of qudits; t = target qudit (0,...,N-1); c = control qudit (0,...,N-1)
D = d**N; cnot = np.zeros((D,D), dtype=int) # set all d^2N elements to 0
for k in range (0,d**N):
localr = dec2den_opt(k,N,d) # sequence os values for the local basis
locall = localr.copy() # copy the right list to the left list
locall[t] = (localr[t]+localr[c])%d
globall = den2dec(locall,d)
cnot[globall,k] = 1
return cnot
d=2; N=2; t=1; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok!
d=2; N=2; t=0; c=1; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok!
d=3; N=2; t=1; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok!
d=2; N=3; t=2; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok
from sympy import init_printing, Matrix
init_printing(use_unicode=True)
from sympy.physics.quantum import TensorProduct
def tp(x,y):
return TensorProduct(x,y)
s1 = Matrix([[0,1],[1,0]]); s0 = Matrix([[1,0],[0,1]]); P0 = Matrix([[1,0],[0,0]]); P1 = Matrix([[0,0],[0,1]])
cnot03 = tp(tp(P0,s0),s0) + tp(tp(P1,s0),s1); cnot03
d=3; N=3; t=1; c=0; cnot = cnot_qudits(d,N,t,c); print(cnot) # ok
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
def dec2den(j,N,d):
den = [0 for k in range(0,N)]
jv = j
for k in range(0,N):
if jv >= d**(N-1-k):
den[k] = jv//(d**(N-1-k))
jv = jv - den[k]*d**(N-1-k)
return den
def den2dec(local,d):
# local = list with the local computational base state values
# d = individual qudit dimension
N = len(local)
j = 0
for k in range(0,N):
j += local[k]*d**(N-1-k)
return j # value of the global computational basis index
def dec2den_opt(j,N,d): # optimized version
den = [0 for k in range(0,N)]
if j < d:
den[N-1] = j; return den
rem = [] # list for the remainder
k = j
while k >= d:
rem.append(k%d)
k = k//d
rem.append(k%d)
for j in range(0,len(rem)):
den[N-1-j] = rem[j]
return den
import numpy as np
def swap_qudits(d,N,t,c):
# d = qudit dimension; N = No. of qudits; t = target qudit (0,...,N-1); c = control qudit (0,...,N-1)
D = d**N; swap = np.zeros((D,D), dtype=int) # set all d^2N elements to 0
for k in range (0,d**N):
localr = dec2den_opt(k,N,d) # sequence of values for the local basis
#locall = [0 for k in range(0,N)]
#for s in range(0,N):
# locall[s] = localr[s]
locall = localr.copy()
#rt = localr[t];
locall[c] = localr[t]
#rc = localr[c];
locall[t] = localr[c]
globall = den2dec(locall,d)
swap[globall,k] = 1
return swap
d=2; N=2; t=0; c=1; print(swap_qudits(d,N,t,c)) # ok
d=3; N=2; t=0; c=1; print(swap_qudits(d,N,t,c)) # ok
d=2; N=3; t=0; c=2; print(swap_qudits(d,N,t,c)) # ok
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
10*15+13*125, 10*15-27*125
def euclides_gcd(a,b):
if b > a: # put in increasing order
t = a; a = b; b = t
if a == b or a%b == 0: # test equality or null remainder
return b
r = a%b
print('a =', a, ', b =', b, ', k =', a//b, ', r =', r)
while r != 0:
a = b; b = r
gcd = b
r = a%b
print('a =', a, ', b =', b, ', k =', a//b, ', r =', r)
return b
import math
a = 6825; b = 1430; egcd = euclides_gcd(a,b)
print('euclides_gcd('+str(a)+','+str(b)+')=',egcd, ', python_gcd = ', math.gcd(a,b))
-9*6825 + 43*1430 # ok!
a = 126; p = 23; a%p, (a**p)%p, (a**(p-1))%p
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
import math
def Sx(j,k,d):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
sx = np.zeros((d,d), dtype=complex)
sx[j,k] = 1
sx[k,j] = sx[j,k]
return sx
def Sy(j,k,d):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
sy = np.zeros((d,d), dtype=complex)
sy[j,k] = -1j
sy[k,j] = -sy[j,k]
return sy
def Sz(j,d):
# d = qudit dimension
# j = identification of the Gell-Mann matrix
# th = rotation angle
sz = np.zeros((d,d), dtype=complex)
for k in range(0,j+1):
sz[k,k] = math.sqrt(2/(j*(j+1)))
if k == j: # corrige para iniciar k em 0
sz[k,k] = sz[k,k]*(-j)
return sz
d = 2; j = 1; k = 2; Sx(j,k,d), Sy(j,k,d), Sz(j,d)
d = 3; Sx(1,2,d), Sx(1,3,d), Sx(2,3,d)
d = 3; Sy(1,2,d), Sy(1,3,d), Sy(2,3,d)
d = 3; Sz(1,d), Sz(2,d)
1/math.sqrt(3), -2/math.sqrt(3)
def Rx(j,k,d,th):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
rx = np.eye(d, dtype=complex)
rx[j,j] = math.cos(th/2)
rx[k,k] = rx[j,j]
rx[j,k] = -1j*math.sin(th/2)
rx[k,j] = rx[j,k]
return rx
def Ry(j,k,d,th):
# d = qudit dimension
# j,k = identification of the Gell-Mann matrix
# th = rotation angle
j = j-1; k = k-1
ry = np.eye(d, dtype=complex)
ry[j,j] = math.cos(th/2)
ry[k,k] = ry[j,j]
ry[j,k] = -math.sin(th/2)
ry[k,j] = -ry[j,k]
return ry
def Rz(j,d,th):
# d = qudit dimension
# j = identification of the Gell-Mann matrix
# th = rotation angle
rz = np.eye(d, dtype=complex)
for k in range(0,j+1):
angle = (th/2)*math.sqrt(2/(j*(j+1)))
if k == j: # corrige para iniciar k em 0
angle = angle*(-j)
rz[k,k] = math.cos(angle) - 1j*math.sin(angle)
return rz
d = 2; j = 1; k = 2; th = 0; Rx(j,k,d,th), Ry(j,k,d,th), Rz(j,d,th)
d = 3; j = 1; k = 2; th = 0; Rx(j,k,d,th), Ry(j,k,d,th), Rz(j,d,th)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram
import numpy as np
#prepares the initial quantum states for the BB84 protocol by generating a list of quantum states and their associated bases.
def prepare_bb84_states(num_qubits):
states = []
bases = []
for _ in range(num_qubits):
state, basis = generate_bb84_state()
states.append(state)
bases.append(basis)
return states, bases
#generates a single BB84 quantum state and its associated measurement basis.
def generate_bb84_state():
basis = np.random.randint(2) # 0 for rectilinear basis, 1 for diagonal basis
if np.random.rand() < 0.5:
state = QuantumCircuit(1, 1)
if basis == 0:
state.h(0)
else:
state.s(0)
state.h(0)
else:
state = QuantumCircuit(1, 1)
if basis == 0:
state.x(0)
state.h(0)
else:
state.x(0)
state.s(0)
state.h(0)
return state, basis
#measures the quantum states with the appropriate basis and returns the measurement results
def measure_bb84_states(states, bases):
measurements = []
for state, basis in zip(states, bases):
if basis == 0:
state.measure(0, 0)
else:
state.h(0)
state.measure(0, 0)
measurements.append(state)
return measurements
#sifts the keys by comparing Alice and Bob's measurement bases and bits. It checks if the measurement bases match (the same basis) and appends the corresponding bits to the sifted keys
def sift_keys(alice_bases, bob_bases, alice_bits, bob_bits):
sifted_alice_bits = []
sifted_bob_bits = []
for a_basis, b_basis, a_bit, b_bit in zip(alice_bases, bob_bases, alice_bits, bob_bits):
if a_basis == b_basis:
sifted_alice_bits.append(a_bit)
sifted_bob_bits.append(b_bit)
return sifted_alice_bits, sifted_bob_bits
#calculates the error rate between Alice's and Bob's sifted bits
def error_rate(alice_bits, bob_bits):
errors = sum([1 for a, b in zip(alice_bits, bob_bits) if a != b])
return errors / len(alice_bits)
# simulates the BB84 protocol
num_qubits = 100
num_qubits = 100
alice_states, alice_bases = prepare_bb84_states(num_qubits)
bob_bases = np.random.randint(2, size=num_qubits)
bob_measurements = measure_bb84_states(alice_states, bob_bases)
alice_bits = []
for state in alice_states:
result = execute(state, Aer.get_backend('qasm_simulator')).result()
counts = result.get_counts(state)
max_count = max(counts, key=counts.get)
alice_bits.append(int(max_count))
bob_bits = []
for state in bob_measurements:
result = execute(state, Aer.get_backend('qasm_simulator')).result()
counts = result.get_counts(state)
max_count = max(counts, key=counts.get)
bob_bits.append(int(max_count))
sifted_alice_bits, sifted_bob_bits = sift_keys(alice_bases, bob_bases, alice_bits, bob_bits)
error = error_rate(sifted_alice_bits, sifted_bob_bits)
final_key = privacy_amplification(sifted_alice_bits)
print("Sifted key length:", len(sifted_alice_bits))
print("Error rate:", error)
print("Final secret key:", final_key)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit.circuit import Parameter
from qiskit import QuantumCircuit
theta = Parameter('$\\theta$')
chsh_circuits_no_meas = QuantumCircuit(2)
chsh_circuits_no_meas.h(0)
chsh_circuits_no_meas.cx(0, 1)
chsh_circuits_no_meas.ry(theta, 0)
chsh_circuits_no_meas.draw('mpl')
import numpy as np
number_of_phases = 21
phases = np.linspace(0, 2*np.pi, number_of_phases)
# Phases need to be expressed as list of lists in order to work
individual_phases = [[ph] for ph in phases]
individual_phases
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = "ibmq_qasm_simulator"
from qiskit_ibm_runtime import Estimator, Session
from qiskit.quantum_info import SparsePauliOp
ZZ = SparsePauliOp.from_list([("ZZ", 1)])
ZX = SparsePauliOp.from_list([("ZX", 1)])
XZ = SparsePauliOp.from_list([("XZ", 1)])
XX = SparsePauliOp.from_list([("XX", 1)])
ops = [ZZ, ZX, XZ, XX]
chsh_est_sim = []
# Simulator
with Session(service=service, backend=backend):
estimator = Estimator()
for op in ops:
job = estimator.run(
circuits=[chsh_circuits_no_meas]*len(individual_phases),
observables=[op]*len(individual_phases),
parameter_values=individual_phases)
est_result = job.result()
chsh_est_sim.append(est_result)
# <CHSH1> = <AB> - <Ab> + <aB> + <ab>
chsh1_est_sim = chsh_est_sim[0].values - chsh_est_sim[1].values + chsh_est_sim[2].values + chsh_est_sim[3].values
# <CHSH2> = <AB> + <Ab> - <aB> + <ab>
chsh2_est_sim = chsh_est_sim[0].values + chsh_est_sim[1].values - chsh_est_sim[2].values + chsh_est_sim[3].values
import matplotlib.pyplot as plt
import matplotlib.ticker as tck
fig, ax = plt.subplots(figsize=(10, 6))
# results from a simulator
ax.plot(phases/np.pi, chsh1_est_sim, 'o-', label='CHSH1 Simulation')
ax.plot(phases/np.pi, chsh2_est_sim, 'o-', label='CHSH2 Simulation')
# classical bound +-2
ax.axhline(y=2, color='r', linestyle='--')
ax.axhline(y=-2, color='r', linestyle='--')
# quantum bound, +-2√2
ax.axhline(y=np.sqrt(2)*2, color='b', linestyle='-.')
ax.axhline(y=-np.sqrt(2)*2, color='b', linestyle='-.')
# set x tick labels to the unit of pi
ax.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))
# set title, labels, and legend
plt.title('Violation of CHSH Inequality')
plt.xlabel('Theta')
plt.ylabel('CHSH witness')
plt.legend()
from qiskit_ibm_runtime import Estimator, Session
from qiskit.quantum_info import SparsePauliOp
backend = service.get_backend("ibmq_belem")
ZZ = SparsePauliOp.from_list([("ZZ", 1)])
ZX = SparsePauliOp.from_list([("ZX", 1)])
XZ = SparsePauliOp.from_list([("XZ", 1)])
XX = SparsePauliOp.from_list([("XX", 1)])
ops = [ZZ, ZX, XZ, XX]
chsh_est_sim = []
with Session(service=service, backend=backend):
estimator = Estimator()
for op in ops:
job = estimator.run(
circuits=[chsh_circuits_no_meas]*len(individual_phases),
observables=[op]*len(individual_phases),
parameter_values=individual_phases)
print(job.job_id())
est_result = job.result()
chsh_est_sim.append(est_result)
# <CHSH1> = <AB> - <Ab> + <aB> + <ab>
chsh1_est_sim = chsh_est_sim[0].values - chsh_est_sim[1].values + chsh_est_sim[2].values + chsh_est_sim[3].values
# <CHSH2> = <AB> + <Ab> - <aB> + <ab>
chsh2_est_sim = chsh_est_sim[0].values + chsh_est_sim[1].values - chsh_est_sim[2].values + chsh_est_sim[3].values
import matplotlib.pyplot as plt
import matplotlib.ticker as tck
fig, ax = plt.subplots(figsize=(10, 6))
# results from a simulator
ax.plot(phases/np.pi, chsh1_est_sim, 'o-', label='CHSH1 Experiment')
ax.plot(phases/np.pi, chsh2_est_sim, 'o-', label='CHSH2 Experiment')
# classical bound +-2
ax.axhline(y=2, color='r', linestyle='--')
ax.axhline(y=-2, color='r', linestyle='--')
# quantum bound, +-2√2
ax.axhline(y=np.sqrt(2)*2, color='b', linestyle='-.')
ax.axhline(y=-np.sqrt(2)*2, color='b', linestyle='-.')
# set x tick labels to the unit of pi
ax.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))
# set title, labels, and legend
plt.title('Violation of CHSH Inequality')
plt.xlabel('Theta')
plt.ylabel('CHSH witness')
plt.legend()
(250/4)*3
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
def plot_Pr0(R1, R2):
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
ph_max = 2*math.pi; dph = ph_max/20; ph = np.arange(0, ph_max+dph, dph)
dimph = ph.shape[0]; P0 = np.zeros(dimph)
T1 = math.sqrt(1 - R1**2); T2 = math.sqrt(1 - R2**2)
P0 = T1**2*R2**2 + R1**2*T2**2 + 2*T1*R1*T2*R2*np.cos(ph)
plt.plot(ph, P0); plt.xlabel(r'$\phi$'); plt.ylabel(r'$Pr(0)$')
plt.xlim(0, 2*math.pi); plt.ylim(0, 1)
plt.annotate(r'$R_{1}=$'+str(R1), xy=(0.5,0.5), xytext=(0.5,0.5), fontsize=12)
plt.annotate(r'$R_{2}=$'+str(R1), xy=(0.5,0.4), xytext=(0.5,0.4), fontsize=12)
plt.show()
interactive(plot_Pr0, R1 = (0, 1, 0.05), R2 = (0, 1, 0.05))
def V1(T1, T2):
return (2*T1*T2*np.sqrt(1-T1**2)*np.sqrt(1-T2**2))/((T1**2)*(T2**2) + (1-T1**2)*(1-T2**2))
def V_3d(th, ph):
x = np.linspace(0.00001, 0.99999, 20); y = np.linspace(0.00001, 0.99999, 20); X, Y = np.meshgrid(x, y)
Z = V1(X, Y); fig = plt.figure();
ax = plt.axes(projection = "3d"); ax.plot_wireframe(X, Y, Z, color = 'blue')
ax.set_xlabel(r'$T_{1}$'); ax.set_ylabel(r'$T_{2}$'); ax.set_zlabel(r'$V_{0}$')
ax.view_init(th, ph); fig.tight_layout(); plt.show()
interactive(V_3d, th = (0,90,10), ph = (0,360,10))
from mpl_toolkits import mplot3d
def V0(T1, T2):
return (2*T1*T2*np.sqrt(1-T1**2)*np.sqrt(1-T2**2))/((T1**2)*(1-T2**2) + (1-T1**2)*T2**2)
def V_3d(th, ph):
x = np.linspace(0.00001, 0.99999, 20); y = np.linspace(0.00001, 0.99999, 20); X, Y = np.meshgrid(x, y)
Z = V0(X, Y); fig = plt.figure();
ax = plt.axes(projection = "3d"); ax.plot_wireframe(X, Y, Z, color = 'blue')
ax.set_xlabel(r'$T_{1}$'); ax.set_ylabel(r'$T_{2}$'); ax.set_zlabel(r'$V_{0}$')
ax.view_init(th, ph); fig.tight_layout(); plt.show()
interactive(V_3d, th = (0,90,10), ph = (0,360,10))
def V_3d(th, ph):
x = np.linspace(0.00001, 0.99999, 20); y = np.linspace(0.00001, 0.99999, 20); X, Y = np.meshgrid(x, y)
Z = V0(X, Y)-V1(X, Y); fig = plt.figure();
ax = plt.axes(projection = "3d"); ax.plot_wireframe(X, Y, Z, color = 'blue')
ax.set_xlabel(r'$T_{1}$'); ax.set_ylabel(r'$T_{2}$'); ax.set_zlabel(r'$V_{0}-V_{1}$')
ax.view_init(th, ph); fig.tight_layout(); plt.show()
interactive(V_3d, th = (0,90,10), ph = (0,360,10))
import math
import qiskit
def shannon_num(pv):
d = pv.shape[0]; SE = 0.0; j = -1
while (j < d-1):
j = j + 1
if pv[j] > 10**-15 and pv[j] < (1.0-10**-15):
SE -= pv[j]*math.log2(pv[j])
return SE
import scipy.linalg.lapack as lapak
def von_neumann_num(rho):
d = rho.shape[0]; b = lapak.zheevd(rho)
return shannon_num(b[0])
def coh_re_num(rho):
d = rho.shape[0]; pv = np.zeros(d)
for j in range(0,d):
pv[j] = rho[j,j].real
return shannon_num(pv) - von_neumann_num(rho)
def P_vn_num(rho):
d = rho.shape[0]; P = 0
for j in range(0, d):
if rho[j,j] > 10**-15 and rho[j,j] < (1.0-10**-15):
P += np.absolute(rho[j,j])*math.log2(np.absolute(rho[j,j]))
return math.log2(d) + P
def qc_gmzi(th, ph, ga):
qc = qiskit.QuantumCircuit(1)
qc.rx(-2*th, 0); qc.z(0); qc.y(0); qc.p(ph, 0); qc.rx(-2*ga, 0)
return qc
th, ph, ga = math.pi/3, math.pi/2, math.pi; qcgmzi = qc_gmzi(th, ph, ga); qcgmzi.draw(output = 'mpl')
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibmq_armonk')
simulator = qiskit.Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
# for error mitigation
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
qr = qiskit.QuantumRegister(1)
qubit_list = [0] # os qubits para os quais aplicaremos calibracao de medidas
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = qiskit.execute(meas_calibs, backend = device, shots = nshots); job_monitor(job)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
# for computing coherence and predictability
th_max = math.pi/2; dth = th_max/10; th = np.arange(0, th_max+dth, dth); dimth = th.shape[0]
Csim = np.zeros(dimth); Psim = np.zeros(dimth); Cexp = np.zeros(dimth); Pexp = np.zeros(dimth)
for j in range(0, dimth):
qr = qiskit.QuantumRegister(1); qc = qiskit.QuantumCircuit(qr); qc.rx(-2*th[j], qr[0])
qstc = state_tomography_circuits(qc, qr[0])
job = qiskit.execute(qstc, simulator, shots = nshots) # simulation
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method = 'lstsq')
Csim[j] = coh_re_num(rho); Psim[j] = P_vn_num(rho)
jobE = qiskit.execute(qstc, backend = device, shots = nshots); job_monitor(jobE)
mitigated_results = meas_fitter.filter.apply(jobE.result())
qstfE = StateTomographyFitter(mitigated_results, qstc)
#qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
Cexp[j] = coh_re_num(rhoE); Pexp[j] = P_vn_num(rhoE)
Cexp
Pexp
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(th, Csim, label = r'$C_{re}^{sim}$')
plt.plot(th, Psim, label = r'$P_{vn}^{sim}$')
plt.plot(th, Cexp, 'o', label = r'$C_{re}^{exp}$')
plt.plot(th, Pexp, '*', label = r'$P_{vn}^{exp}$')
plt.legend(); plt.xlabel(r'$\theta$')
plt.savefig('coh_vs_ivi_armonk_mit.pdf', format = 'pdf', dpi = 200)
plt.show()
# for computing the visibility
ph_max = 2*math.pi; dph = ph_max/10; ph = np.arange(0, ph_max+dph, dph); dimph = ph.shape[0]
P0sim = np.zeros(dimph); P0exp = np.zeros(dimph)
th[j] = math.pi/2
for k in range(0, dimph):
qr = qiskit.QuantumRegister(1); cr = qiskit.ClassicalRegister(1); qc = qiskit.QuantumCircuit(qr, cr)
qc.rx(-2*th[j], qr[0]); qc.z(qr[0]); qc.y(qr[0])
qc.p(ph[k], qr[0]); ga = th[j]; qc.rx(-2*ga, qr[0]); qc.measure(qr[0], cr[0])
job = qiskit.execute(qc, backend = simulator, shots = nshots) # simulation
counts = job.result().get_counts(qc)
if '0' in counts:
P0sim[k] = counts['0']
jobE = qiskit.execute(qc, backend = device, shots = nshots); job_monitor(jobE)
mitigated_results = meas_fitter.filter.apply(jobE.result())
countsE = mitigated_results.get_counts(qc)
#countsE = jobE.result().get_counts(qc)
if '0' in countsE:
P0exp[k] = countsE['0']
P0sim = P0sim/nshots; P0exp = P0exp/nshots
P0exp
P0sim
P0expthpi2 = np.array([0.0267666 , 0.02431936, 0.02646069, 0.03701438, 0.02340165,
0.02997859, 0.02095442, 0.02049556, 0.02156623, 0.01957785,
0.03242582])
P0simthpi2 = np.array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.])
P0expthpi4 = np.array([1. , 0.90838173, 0.66274091, 0.37488527, 0.11976134,
0.01881309, 0.12251453, 0.36310798, 0.65050474, 0.90455797,
1. ])
P0simthpi4 = np.array([1. , 0.90612793, 0.65258789, 0.34069824, 0.09924316,
0. , 0.09228516, 0.34741211, 0.64331055, 0.90209961,
1. ])
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, P0simthpi4, label = r'$P_{0}^{sim}(\theta=\pi/4)$')
plt.plot(ph, P0expthpi4, 'o', label = r'$P_{0}^{exp}(\theta=\pi/4)$')
plt.plot(ph, P0simthpi2, '.-', label = r'$P_{0}^{sim}(\theta=\pi/2)$')
plt.plot(ph, P0expthpi2, '*', label = r'$P_{0}^{exp}(\theta=\pi/2)$')
plt.ylim(0, 2*math.pi); plt.ylim(-0.01, 1.01)
plt.legend(); plt.xlabel(r'$\phi$')
plt.savefig('P0_thpi4_armonk_mit.pdf', format = 'pdf', dpi = 200)
plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
hub=qc-spring-22-2, group=group-5 and project=recPrYILNAOsYMWIV
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
((10+9.8+9.5)/3+10)/2
(9.77+10)/2
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
#In case you don't have qiskit, install it now
%pip install qiskit --quiet
#Installing/upgrading pylatexenc seems to have fixed my mpl issue
#If you try this and it doesn't work, try also restarting the runtime/kernel
%pip install pylatexenc --quiet
!pip install -Uqq ipdb
!pip install qiskit_optimization
import networkx as nx
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity
from qiskit.extensions.hamiltonian_gate import HamiltonianGate
from qiskit.extensions import RXGate, XGate, CXGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
import numpy as np
from qiskit.visualization import plot_histogram
import ipdb
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#quadratic optimization
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
%pdb on
# def ApplyCost(qc, gamma):
# Ix = np.array([[1,0],[0,1]])
# Zx= np.array([[1,0],[0,-1]])
# Xx = np.array([[0,1],[1,0]])
# Temp = (Ix-Zx)/2
# T = Operator(Temp)
# I = Operator(Ix)
# Z = Operator(Zx)
# X = Operator(Xx)
# FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
# ham = HamiltonianGate(FinalOp,gamma)
# qc.append(ham,[0,1,2])
task = QuadraticProgram(name = 'QUBO on QC')
task.binary_var(name = 'x')
task.binary_var(name = 'y')
task.binary_var(name = 'z')
task.minimize(linear = {"x":-1,"y":2,"z":-3}, quadratic = {("x", "z"): -2, ("y", "z"): -1})
qubo = QuadraticProgramToQubo().convert(task) #convert to QUBO
operator, offset = qubo.to_ising()
print(operator)
# ham = HamiltonianGate(operator,0)
# print(ham)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
ham = HamiltonianGate(FinalOp,0)
print(ham)
#define PYBIND11_DETAILED_ERROR_MESSAGES
def compute_expectation(counts):
"""
Computes expectation value based on measurement results
Args:
counts: dict
key as bitstring, val as count
G: networkx graph
Returns:
avg: float
expectation value
"""
avg = 0
sum_count = 0
for bitstring, count in counts.items():
x = int(bitstring[2])
y = int(bitstring[1])
z = int(bitstring[0])
obj = -2*x*z-y*z-x+2*y-3*z
avg += obj * count
sum_count += count
return avg/sum_count
# We will also bring the different circuit components that
# build the qaoa circuit under a single function
def create_qaoa_circ(theta):
"""
Creates a parametrized qaoa circuit
Args:
G: networkx graph
theta: list
unitary parameters
Returns:
qc: qiskit circuit
"""
nqubits = 3
n,m=3,3
p = len(theta)//2 # number of alternating unitaries
qc = QuantumCircuit(nqubits,nqubits)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(Z^I^Z)-(I^Z^Z)-(Z^I^I)+2*(I^Z^I)-3*(I^I^Z)
beta = theta[:p]
gamma = theta[p:]
# initial_state
for i in range(0, nqubits):
qc.h(i)
for irep in range(0, p):
#ipdb.set_trace(context=6)
# problem unitary
# for pair in list(G.edges()):
# qc.rzz(2 * gamma[irep], pair[0], pair[1])
#ApplyCost(qc,2*0)
ham = HamiltonianGate(operator,2 * gamma[irep])
qc.append(ham,[0,1,2])
# mixer unitary
for i in range(0, nqubits):
qc.rx(2 * beta[irep], i)
qc.measure(qc.qubits[:n],qc.clbits[:m])
return qc
# Finally we write a function that executes the circuit on the chosen backend
def get_expectation(shots=512):
"""
Runs parametrized circuit
Args:
G: networkx graph
p: int,
Number of repetitions of unitaries
"""
backend = Aer.get_backend('qasm_simulator')
backend.shots = shots
def execute_circ(theta):
qc = create_qaoa_circ(theta)
# ipdb.set_trace(context=6)
counts = {}
job = execute(qc, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc)
return compute_expectation(counts)
return execute_circ
from scipy.optimize import minimize
expectation = get_expectation()
res = minimize(expectation, [1, 1], method='COBYLA')
expectation = get_expectation()
res = minimize(expectation, res.x, method='COBYLA')
res
from qiskit.visualization import plot_histogram
backend = Aer.get_backend('aer_simulator')
backend.shots = 512
qc_res = create_qaoa_circ(res.x)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc_res, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc_res)
plot_histogram(counts)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
from sklearn.datasets.samples_generator import make_blobs
from qiskit.aqua.utils import split_dataset_to_data_and_labels
from sklearn import svm
from utility import breast_cancer_pca
from matplotlib import pyplot as plt
%matplotlib inline
%load_ext autoreload
%autoreload 2
n = 2 # number of principal components kept
training_dataset_size = 20
testing_dataset_size = 10
sample_Total, training_input, test_input, class_labels = breast_cancer_pca(training_dataset_size, testing_dataset_size, n)
data_train, _ = split_dataset_to_data_and_labels(training_input)
data_test, _ = split_dataset_to_data_and_labels(test_input)
print (f"data_train[0].shape: {data_train[0].shape}" )
print (f"data_train[1].shape: {data_train[1].shape}" )
# We use the function of scikit learn to generate linearly separable blobs
centers = [(2.5,0),(0,2.5)]
x, y = make_blobs(n_samples=100, centers=centers, n_features=2,random_state=0,cluster_std=0.5)
fig,ax=plt.subplots(1,2,figsize=(12,4))
ax[0].scatter(data_train[0][:,0],data_train[0][:,1],c=data_train[1])
ax[0].set_title('Breast Cancer dataset');
ax[1].scatter(x[:,0],x[:,1],c=y)
ax[1].set_title('Blobs linearly separable');
plt.scatter(data_train[0][:,0],data_train[0][:,1],c=data_train[1])
plt.title('Breast Cancer dataset');
model= svm.LinearSVC()
model.fit(data_train[0], data_train[1])
#small utility function
# some utility functions
def make_meshgrid(x, y, h=.02):
x_min, x_max = x.min() - 1, x.max() + 1
y_min, y_max = y.min() - 1, y.max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
np.arange(y_min, y_max, h))
return xx, yy
def plot_contours(ax, clf, xx, yy, **params):
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
out = ax.contourf(xx, yy, Z, **params)
return out
accuracy_train = model.score(data_train[0], data_train[1])
accuracy_test = model.score(data_test[0], data_test[1])
X0, X1 = data_train[0][:, 0], data_train[0][:, 1]
xx, yy = make_meshgrid(X0, X1)
Z = model.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
fig,ax=plt.subplots(1,2,figsize=(15,5))
ax[0].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[0].scatter(data_train[0][:,0], data_train[0][:,1], c=data_train[1])
ax[0].set_title('Accuracy on the training set: '+str(accuracy_train));
ax[1].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[1].scatter(data_test[0][:,0], data_test[0][:,1], c=data_test[1])
ax[1].set_title('Accuracy on the test set: '+str(accuracy_test));
clf = svm.SVC(gamma = 'scale')
clf.fit(data_train[0], data_train[1]);
accuracy_train = clf.score(data_train[0], data_train[1])
accuracy_test = clf.score(data_test[0], data_test[1])
X0, X1 = data_train[0][:, 0], data_train[0][:, 1]
xx, yy = make_meshgrid(X0, X1)
Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
fig,ax=plt.subplots(1,2,figsize=(15,5))
ax[0].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[0].scatter(data_train[0][:,0], data_train[0][:,1], c=data_train[1])
ax[0].set_title('Accuracy on the training set: '+str(accuracy_train));
ax[1].contourf(xx, yy, Z, cmap=plt.cm.coolwarm)
ax[1].scatter(data_test[0][:,0], data_test[0][:,1], c=data_test[1])
ax[1].set_title('Accuracy on the test set: '+str(accuracy_test));
import qiskit as qk
# Creating Qubits
q = qk.QuantumRegister(2)
# Creating Classical Bits
c = qk.ClassicalRegister(2)
circuit = qk.QuantumCircuit(q, c)
circuit.draw('mpl')
# Initialize empty circuit
circuit = qk.QuantumCircuit(q, c)
# Hadamard Gate on the first Qubit
circuit.h(q[0])
# CNOT Gate on the first and second Qubits
circuit.cx(q[0], q[1])
# Measuring the Qubits
circuit.measure(q, c)
circuit.draw('mpl')
# Using Qiskit Aer's Qasm Simulator: Define where do you want to run the simulation.
simulator = qk.BasicAer.get_backend('qasm_simulator')
# Simulating the circuit using the simulator to get the result
job = qk.execute(circuit, simulator, shots=100)
result = job.result()
# Getting the aggregated binary outcomes of the circuit.
counts = result.get_counts(circuit)
print (counts)
from qiskit.aqua.components.feature_maps import SecondOrderExpansion
feature_map = SecondOrderExpansion(feature_dimension=2, depth=1)
x = np.array([0.6, 0.3])
#feature_map.construct_circuit(x)
print(feature_map.construct_circuit(x))
from qiskit.aqua.algorithms import QSVM
qsvm = QSVM(feature_map, training_input, test_input)
#from qiskit.aqua import run_algorithm, QuantumInstance
from qiskit.aqua import algorithm, QuantumInstance
from qiskit import BasicAer
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=10598, seed_transpiler=10598)
result = qsvm.run(quantum_instance)
plt.scatter(training_input['Benign'][:,0], training_input['Benign'][:,1])
plt.scatter(training_input['Malignant'][:,0], training_input['Malignant'][:,1])
length_data = len(training_input['Benign']) + len(training_input['Malignant'])
print("size training set: {}".format(length_data))
#print("Matrix dimension: {}".format(result['kernel_matrix_training'].shape))
print("testing success ratio: ", result['testing_accuracy'])
test_set = np.concatenate((test_input['Benign'], test_input['Malignant']))
y_test = qsvm.predict(test_set, quantum_instance)
plt.scatter(test_set[:, 0], test_set[:,1], c=y_test)
plt.show()
plt.scatter(test_input['Benign'][:,0], test_input['Benign'][:,1])
plt.scatter(test_input['Malignant'][:,0], test_input['Malignant'][:,1])
plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit, Aer, execute, IBMQ
from qiskit.utils import QuantumInstance
import numpy as np
from qiskit.algorithms import Shor
IBMQ.enable_account('ENTER API TOKEN HERE') # Enter your API token here
provider = IBMQ.get_provider(hub='ibm-q')
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
my_shor = Shor(quantum_instance)
result_dict = my_shor.factor(15)
print(result_dict)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
device = provider.get_backend('ibmq_bogota')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from qiskit.quantum_info import state_fidelity
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
#Assign these values as per your requirements.
global min_qubits,max_qubits,skip_qubits,max_circuits,num_shots,Noise_Inclusion
min_qubits=4
max_qubits=15 #reference files are upto 12 Qubits only
skip_qubits=2
max_circuits=3
num_shots=4092
gate_counts_plots = True
Noise_Inclusion = False
saveplots = False
Memory_utilization_plot = True
Type_of_Simulator = "built_in" #Inputs are "built_in" or "FAKE" or "FAKEV2"
backend_name = "FakeGuadalupeV2" #Can refer to the README files for the available backends
#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
from qiskit.opflow import PauliTrotterEvolution, Suzuki
from qiskit.opflow.primitive_ops import PauliSumOp
import time,os,json
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
benchmark_name = "VQE Simulation"
# 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
Hf_ = None
CO_ = None
################### Circuit Definition #######################################
# Construct a Qiskit circuit for VQE Energy evaluation with UCCSD ansatz
# param: n_spin_orbs - The number of spin orbitals.
# return: return a Qiskit circuit for this VQE ansatz
def VQEEnergy(n_spin_orbs, na, nb, circuit_id=0, method=1):
# number of alpha spin orbitals
norb_a = int(n_spin_orbs / 2)
# construct the Hamiltonian
qubit_op = ReadHamiltonian(n_spin_orbs)
# allocate qubits
num_qubits = n_spin_orbs
qr = QuantumRegister(num_qubits)
qc = QuantumCircuit(qr, name=f"vqe-ansatz({method})-{num_qubits}-{circuit_id}")
# initialize the HF state
Hf = HartreeFock(num_qubits, na, nb)
qc.append(Hf, qr)
# form the list of single and double excitations
excitationList = []
for occ_a in range(na):
for vir_a in range(na, norb_a):
excitationList.append((occ_a, vir_a))
for occ_b in range(norb_a, norb_a+nb):
for vir_b in range(norb_a+nb, n_spin_orbs):
excitationList.append((occ_b, vir_b))
for occ_a in range(na):
for vir_a in range(na, norb_a):
for occ_b in range(norb_a, norb_a+nb):
for vir_b in range(norb_a+nb, n_spin_orbs):
excitationList.append((occ_a, vir_a, occ_b, vir_b))
# get cluster operators in Paulis
pauli_list = readPauliExcitation(n_spin_orbs, circuit_id)
# loop over the Pauli operators
for index, PauliOp in enumerate(pauli_list):
# get circuit for exp(-iP)
cluster_qc = ClusterOperatorCircuit(PauliOp, excitationList[index])
# add to ansatz
qc.append(cluster_qc, [i for i in range(cluster_qc.num_qubits)])
# method 1, only compute the last term in the Hamiltonian
if method == 1:
# last term in Hamiltonian
qc_with_mea, is_diag = ExpectationCircuit(qc, qubit_op[1], num_qubits)
# return the circuit
return qc_with_mea
# now we need to add the measurement parts to the circuit
# circuit list
qc_list = []
diag = []
off_diag = []
global normalization
normalization = 0.0
# add the first non-identity term
identity_qc = qc.copy()
identity_qc.measure_all()
qc_list.append(identity_qc) # add to circuit list
diag.append(qubit_op[1])
normalization += abs(qubit_op[1].coeffs[0]) # add to normalization factor
diag_coeff = abs(qubit_op[1].coeffs[0]) # add to coefficients of diagonal terms
# loop over rest of terms
for index, p in enumerate(qubit_op[2:]):
# get the circuit with expectation measurements
qc_with_mea, is_diag = ExpectationCircuit(qc, p, num_qubits)
# accumulate normalization
normalization += abs(p.coeffs[0])
# add to circuit list if non-diagonal
if not is_diag:
qc_list.append(qc_with_mea)
else:
diag_coeff += abs(p.coeffs[0])
# diagonal term
if is_diag:
diag.append(p)
# off-diagonal term
else:
off_diag.append(p)
# modify the name of diagonal circuit
qc_list[0].name = qubit_op[1].primitive.to_list()[0][0] + " " + str(np.real(diag_coeff))
normalization /= len(qc_list)
return qc_list
# Function that constructs the circuit for a given cluster operator
def ClusterOperatorCircuit(pauli_op, excitationIndex):
# compute exp(-iP)
exp_ip = pauli_op.exp_i()
# Trotter approximation
qc_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=1, reps=1)).convert(exp_ip)
# convert to circuit
qc = qc_op.to_circuit(); qc.name = f'Cluster Op {excitationIndex}'
global CO_
if CO_ == None or qc.num_qubits <= 4:
if qc.num_qubits < 7: CO_ = qc
# return this circuit
return qc
# Function that adds expectation measurements to the raw circuits
def ExpectationCircuit(qc, pauli, nqubit, method=2):
# copy the unrotated circuit
raw_qc = qc.copy()
# whether this term is diagonal
is_diag = True
# primitive Pauli string
PauliString = pauli.primitive.to_list()[0][0]
# coefficient
coeff = pauli.coeffs[0]
# basis rotation
for i, p in enumerate(PauliString):
target_qubit = nqubit - i - 1
if (p == "X"):
is_diag = False
raw_qc.h(target_qubit)
elif (p == "Y"):
raw_qc.sdg(target_qubit)
raw_qc.h(target_qubit)
is_diag = False
# perform measurements
raw_qc.measure_all()
# name of this circuit
raw_qc.name = PauliString + " " + str(np.real(coeff))
# save circuit
global QC_
if QC_ == None or nqubit <= 4:
if nqubit < 7: QC_ = raw_qc
return raw_qc, is_diag
# Function that implements the Hartree-Fock state
def HartreeFock(norb, na, nb):
# initialize the quantum circuit
qc = QuantumCircuit(norb, name="Hf")
# alpha electrons
for ia in range(na):
qc.x(ia)
# beta electrons
for ib in range(nb):
qc.x(ib+int(norb/2))
# Save smaller circuit
global Hf_
if Hf_ == None or norb <= 4:
if norb < 7: Hf_ = qc
# return the circuit
return qc
################ Helper Functions
# Function that converts a list of single and double excitation operators to Pauli operators
def readPauliExcitation(norb, circuit_id=0):
# load pre-computed data
filename = os.path.join(f'ansatzes/{norb}_qubit_{circuit_id}.txt')
with open(filename) as f:
data = f.read()
ansatz_dict = json.loads(data)
# initialize Pauli list
pauli_list = []
# current coefficients
cur_coeff = 1e5
# current Pauli list
cur_list = []
# loop over excitations
for ext in ansatz_dict:
if cur_coeff > 1e4:
cur_coeff = ansatz_dict[ext]
cur_list = [(ext, ansatz_dict[ext])]
elif abs(abs(ansatz_dict[ext]) - abs(cur_coeff)) > 1e-4:
pauli_list.append(PauliSumOp.from_list(cur_list))
cur_coeff = ansatz_dict[ext]
cur_list = [(ext, ansatz_dict[ext])]
else:
cur_list.append((ext, ansatz_dict[ext]))
# add the last term
pauli_list.append(PauliSumOp.from_list(cur_list))
# return Pauli list
return pauli_list
# Get the Hamiltonian by reading in pre-computed file
def ReadHamiltonian(nqubit):
# load pre-computed data
filename = os.path.join(f'Hamiltonians/{nqubit}_qubit.txt')
with open(filename) as f:
data = f.read()
ham_dict = json.loads(data)
# pauli list
pauli_list = []
for p in ham_dict:
pauli_list.append( (p, ham_dict[p]) )
# build Hamiltonian
ham = PauliSumOp.from_list(pauli_list)
# return Hamiltonian
return ham
# 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)
### 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 }
## 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
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):
dict_of_qc.clear()
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(qc,references,num_qubits):
# total circuit name (pauli string + coefficient)
total_name = qc.name
# pauli string
pauli_string = total_name.split()[0]
# get the correct measurement
if (len(total_name.split()) == 2):
correct_dist = references[pauli_string]
else:
circuit_id = int(total_name.split()[2])
correct_dist = references[f"Qubits - {num_qubits} - {circuit_id}"]
return correct_dist,total_name
# Max qubits must be 12 since the referenced files only go to 12 qubits
MAX_QUBITS = 12
method = 1
def run (min_qubits=min_qubits, max_qubits=max_qubits, skip_qubits=2,
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()
max_qubits = max(max_qubits, min_qubits) # max must be >= min
# validate parameters (smallest circuit is 4 qubits and largest is 10 qubits)
max_qubits = min(max_qubits, MAX_QUBITS)
min_qubits = min(max(4, min_qubits), max_qubits)
if min_qubits % 2 == 1: min_qubits += 1 # min_qubits must be even
skip_qubits = max(1, skip_qubits)
if method == 2: max_circuits = 1
if max_qubits < 4:
print(f"Max number of qubits {max_qubits} is too low to run method {method} of VQE algorithm")
return
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 input_size in range(min_qubits, max_qubits + 1, skip_qubits):
# reset random seed
np.random.seed(0)
# determine the number of circuits to execute for this group
num_circuits = min(3, max_circuits)
num_qubits = input_size
fidelity_data[num_qubits] = []
Hf_fidelity_data[num_qubits] = []
# decides number of electrons
na = int(num_qubits/4)
nb = int(num_qubits/4)
# random seed
np.random.seed(0)
numckts.append(num_circuits)
# create the circuit for given qubit size and simulation parameters, store time metric
ts = time.time()
# circuit list
qc_list = []
# Method 1 (default)
if method == 1:
# loop over circuits
for circuit_id in range(num_circuits):
# construct circuit
qc_single = VQEEnergy(num_qubits, na, nb, circuit_id, method)
qc_single.name = qc_single.name + " " + str(circuit_id)
# add to list
qc_list.append(qc_single)
# method 2
elif method == 2:
# construct all circuits
qc_list = VQEEnergy(num_qubits, na, nb, 0, method)
print(qc_list)
print(f"************\nExecuting [{len(qc_list)}] circuits with num_qubits = {num_qubits}")
for qc in qc_list:
print("*********************************************")
#print(f"qc of {qc} qubits for qc_list value: {qc_list}")
# get circuit id
if method == 1:
circuit_id = qc.name.split()[2]
else:
circuit_id = qc.name.split()[0]
#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
print("operations: ",operations)
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()
# load pre-computed data
if len(qc.name.split()) == 2:
filename = os.path.join(f'_common/precalculated_data_{num_qubits}_qubit.json')
with open(filename) as f:
references = json.load(f)
else:
filename = os.path.join(f'_common/precalculated_data_{num_qubits}_qubit_method2.json')
with open(filename) as f:
references = json.load(f)
#Correct distribution to compare with counts
correct_dist,total_name = analyzer(qc,references,num_qubits)
#fidelity calculation comparision of counts and correct_dist
fidelity_dict = polarization_fidelity(counts, correct_dist)
print(fidelity_dict)
# modify fidelity based on the coefficient
if (len(total_name.split()) == 2):
fidelity_dict *= ( abs(float(total_name.split()[1])) / normalization )
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!")
print("\nHartree Fock Generator 'Hf' ="); print(Hf_ if Hf_ != None else " ... too large!")
print("\nCluster Operator Example 'Cluster Op' ="); print(CO_ if CO_ != 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(int(np.mean(algorithmic_1Q_gate_counts[start:start+num])))
avg_2Q_algorithmic_gate_counts.append(int(np.mean(algorithmic_2Q_gate_counts[start:start+num])))
avg_1Q_Transpiled_gate_counts.append(int(np.mean(transpiled_1Q_gate_counts[start:start+num])))
avg_2Q_Transpiled_gate_counts.append(int(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/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
| |
https://github.com/h-rathee851/Pulse_application_qiskit
|
h-rathee851
|
"""
Object to calibrate pulse of backend and qubit of interest.
"""
# Importing required python packages
from warnings import warn
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
from scipy.signal import find_peaks
from sklearn.model_selection import train_test_split
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# Importing standard Qiskit libraries
from qiskit import IBMQ, execute, pulse
from qiskit.providers.ibmq import IBMQBackend
from qiskit.pulse import DriveChannel, Schedule, Play
from qiskit.pulse import library as pulse_lib
from qiskit.pulse.library import Waveform, Gaussian
from qiskit.tools.monitor import job_monitor
from qiskit.providers.exceptions import QiskitBackendNotFoundError, BackendConfigurationError
# Loading your IBM Q account(s)
#IBMQ.load_account()
#provider = IBMQ.get_provider()
class PulseCalibration():
"""Creates an object that is used for pulse calibration.
Args:
backend (IBMQBackend) : The IBMQBackend for which pulse calibration needs to be done.
qubit (int) : The qubit for which the pulse calibration is done.
qubit_freq_ground (float) : Custom frequency for 0->1 transition.
qubit_freq_excited (float) : Custom frequency for 1->2 transition.
pi_amp_ground (float) : Custom pi amplitude for 0->1 transition.
The value should be between 0 and 1.
pi_amp_excited (float) : Custom pi amplitude for 1->2 transition.
The value should be between 0 and 1.
pulse_dur (int) : The duration of the pi pulse to be used for calibration.
pulse_sigma (int) : The standard deviation of the pi pulse to be used for calibration.
"""
def __init__(self, backend, qubit, qubit_freq_ground=None, qubit_freq_excited=None,
pi_amp_ground=None, pi_amp_excited=None, pulse_dur=None, pulse_sigma=None):
# pylint: disable=too-many-locals
# pylint: disable=too-many-arguments
if not isinstance(backend, IBMQBackend):
raise QiskitBackendNotFoundError("Provided backend not available." +
"Please provide backend after obtaining from IBMQ.")
self._backend = backend
self._back_config = backend.configuration()
if qubit >= self._back_config.n_qubits:
raise BackendConfigurationError(f"Qubit {qubit} not present in the provided backend.")
self._qubit = qubit
self._back_defaults = backend.defaults()
self._dt = self._back_config.dt
self._qubit_freq = self._back_defaults.qubit_freq_est[self._qubit]
self._inst_sched_map = self._back_defaults.instruction_schedule_map
self._drive_chan = DriveChannel(qubit)
if pulse_sigma:
self._pulse_sigma = pulse_sigma
else:
self._pulse_sigma = 40
if pulse_dur:
self._pulse_duration = pulse_dur
else:
self._pulse_duration = (4*self._pulse_sigma)-((4*self._pulse_sigma) % 16)
self._qubit_freq_ground = qubit_freq_ground
self._qubit_freq_excited = qubit_freq_excited
self._pi_amp_ground = pi_amp_ground
self._pi_amp_excited = pi_amp_excited
self._state_discriminator_012 = None
# Find out which measurement map index is needed for this qubit
meas_map_idx = None
for i, measure_group in enumerate(self._back_config.meas_map):
if qubit in measure_group:
meas_map_idx = i
break
assert meas_map_idx is not None, f"Couldn't find qubit {qubit} in the meas_map!"
# The measurement pulse for measuring the qubit of interest.
self._measure = self._inst_sched_map.get('measure',
qubits=self._back_config.meas_map[meas_map_idx])
def create_cal_circuit(self, amp):
"""Constructs and returns a schedule containing Gaussian pulse with amplitude as 'amp',
sigma as 'pulse_sigma' and duration as 'pulse_duration'."""
sched = Schedule()
sched += Play(Gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=amp), self._drive_chan)
sched += self._measure << sched.duration
return sched
def create_cal_circuit_excited(self, base_pulse, freq):
""" Constructs and returns a schedule containing a pi pulse for 0->1 transition followed by
a sidebanded pulse which corresponds to applying 'base_pulse' at frequency 'freq'."""
sched = Schedule()
sched += Play(Gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=self._pi_amp_ground), self._drive_chan)
sched += Play(self.apply_sideband(base_pulse, freq), self._drive_chan)
sched += self._measure << sched.duration
return sched
@staticmethod
def _fit_function(x_values, y_values, function, init_params):
""" A function fitter. Returns the fit parameters of 'function'."""
fitparams, _ = curve_fit(function, x_values, y_values, init_params)
y_fit = function(x_values, *fitparams)
return fitparams, y_fit
@staticmethod
def _baseline_remove(values):
"""Centering data around zero."""
return np.array(values) - np.mean(values)
def apply_sideband(self, pulse, frequency):
"""Apply a sine sideband to 'pulse' at frequency 'freq'.
Args:
pulse (Waveform): The pulse to which sidebanding is to be applied.
frequency (float): LO frequency at which the pulse is to be applied.
Returns:
Waveform: The sidebanded pulse.
"""
t_samples = np.linspace(0, self._dt*self._pulse_duration, self._pulse_duration)
sine_pulse = np.sin(2*np.pi*(frequency-self._qubit_freq_ground)*t_samples)
sideband_pulse = Waveform(np.multiply(np.real(pulse.samples), sine_pulse),
name='sideband_pulse')
return sideband_pulse
def get_job_data(self, job, average):
"""Retrieve data from a job that has already run.
Args:
job (Job): The job whose data you want.
average (bool): If True, gets the data assuming data is an average.
If False, gets the data assuming it is for single shots.
Return:
list: List containing job result data.
"""
scale_factor = 1e-14
job_results = job.result(timeout=120) # timeout parameter set to 120 s
result_data = []
for i in range(len(job_results.results)):
if average: # get avg data
result_data.append(job_results.get_memory(i)[self._qubit]*scale_factor)
else: # get single data
result_data.append(job_results.get_memory(i)[:, self._qubit]*scale_factor)
return result_data
# Prints out relative maxima frequencies in output_data; height gives lower bound (abs val)
@staticmethod
def _rel_maxima(freqs, output_data, height, distance):
"""Prints out relative maxima frequencies in output_data (can see peaks);
height gives upper bound (abs val). Be sure to set the height properly or
the peak will be ignored!
Args:
freqs (list): frequency list
output_data (list): list of resulting signals
height (float): upper bound (abs val) on a peak
width (float):
Returns:
list: List containing relative maxima frequencies
"""
peaks, _ = find_peaks(x=output_data, height=height, distance=distance)
return freqs[peaks]
def find_freq_ground(self, verbose=False, visual=False):
"""Sets and returns the calibrated frequency corresponding to 0->1 transition."""
# pylint: disable=too-many-locals
sched_list = [self.create_cal_circuit(0.5)]*75
freq_list = np.linspace(self._qubit_freq-(40*1e+6), self._qubit_freq+(40*1e+6), 75)
sweep_job = execute(sched_list, backend=self._backend, meas_level=1, meas_return='avg',
shots=1024, schedule_los = [{self._drive_chan: freq} for freq in freq_list])
if verbose:
print("Executing the Frequency sweep job for 0->1 transition.")
job_monitor(sweep_job)
sweep_result = sweep_job.result()
sweep_values = []
for i in range(len(sweep_result.results)):
# Get the results from the ith experiment
res = sweep_result.get_memory(i)*1e-14
# Get the results for `qubit` from this experiment
sweep_values.append(res[self._qubit])
freq_list_GHz = freq_list/1e+9
if visual:
print("The frequency-signal plot for frequency sweep: ")
plt.scatter(freq_list_GHz, np.real(sweep_values), color='black')
plt.xlim([min(freq_list_GHz), max(freq_list_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured Signal [a.u.]")
plt.show()
def find_init_params(res_values):
est_baseline=np.mean(res_values)
est_slope=-5 if est_baseline-np.min(res_values)> 2 else 5
return [est_slope, self._qubit_freq/1e9, 1, est_baseline]
init_params = find_init_params(np.real(sweep_values))
# Obtain the optimal paramters that fit the result data.
def lorentzian(xval, scale, q_freq, hwhm, shift):
return (scale / np.pi) * (hwhm / ((xval - q_freq)**2 + hwhm**2)) + shift
fit_params, y_fit = self._fit_function(freq_list_GHz,
np.real(sweep_values),
lorentzian,
init_params # init parameters for curve_fit
)
if visual:
print("The frequency-signal plot for frequency sweep: ")
plt.scatter(freq_list_GHz, np.real(sweep_values), color='black')
plt.plot(freq_list_GHz, y_fit, color='red')
plt.xlim([min(freq_list_GHz), max(freq_list_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured Signal [a.u.]")
plt.show()
_, qubit_freq_new, _, _ = fit_params
self._qubit_freq_ground = qubit_freq_new*1e9
if verbose:
print(f"The calibrate frequency for the 0->1 transition is {self._qubit_freq_ground}")
return self._qubit_freq_ground
def find_pi_amp_ground(self, verbose=False, visual=False):
"""Sets and returns the amplitude of the pi pulse corresponding to 0->1 transition."""
# pylint: disable=too-many-locals
if not self._qubit_freq_ground:
warn("ground_qubit_freq not computed yet and custom qubit freq not provided." +
"Computing ground_qubit_freq now.")
self._qubit_freq_ground = self.find_freq_ground(verbose, visual)
amp_list = np.linspace(0, 0.74, 75)
rabi_sched_list = [self.create_cal_circuit(amp) for amp in amp_list]
rabi_list_len = len(rabi_sched_list)
rabi_job = execute(rabi_sched_list,backend=self._backend, meas_level=1, meas_return='avg',
shots=1024, schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*len(rabi_sched_list))
if verbose:
print("Executing the rabi oscillation job to get Pi pulse for 0->1 transition.")
job_monitor(rabi_job)
rabi_results = rabi_job.result()
scale_factor = 1e-14
rabi_values = []
for i in range(75):
# Get the results for `qubit` from the ith experiment
rabi_values.append(rabi_results.get_memory(i)[self._qubit]*scale_factor)
rabi_values = np.real(self._baseline_remove(rabi_values))
# Obtain the optimal paramters that fit the result data.
fit_params, y_fit = self._fit_function(amp_list,
rabi_values,
lambda x, A, B, drive_period, phi: (A*np.sin(2*np.pi*x/drive_period - phi) + B),
[3e-7, 0, 0.3, 0])
drive_period = fit_params[2]
self._pi_amp_ground = drive_period/2
if verbose:
print(f"The Pi amplitude of 0->1 transition is {self._pi_amp_ground}.")
if visual:
print("The amplitude-signal plot for rabi oscillation for 0->1 transition.")
plt.figure()
plt.scatter(amp_list, rabi_values, color='black')
plt.plot(amp_list, y_fit, color='red')
plt.axvline(drive_period/2, color='red', linestyle='--')
plt.axvline(drive_period, color='red', linestyle='--')
plt.annotate("", xy=(drive_period, 0), xytext=(drive_period/2, 0),
arrowprops=dict(arrowstyle="<->", color='red'))
#plt.annotate("$\pi$", xy=(drive_period/2-0.03, 0.1), color='red')
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.show()
return self._pi_amp_ground
def find_freq_excited(self, verbose=False, visual=False):
"""Sets and returns the frequency corresponding to 1->2 transition."""
# pylint: disable=too-many-locals
if not self._qubit_freq_ground:
raise ValueError("The qubit_freq_ground is not determined. Please determine" +
"qubit_freq_ground first.")
if not self._pi_amp_ground:
raise ValueError("The pi_amp_ground is not determined.\
Please determine pi_amp_ground first.")
base_pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=0.3)
sched_list = []
# Here we assume that the anharmocity is about 8% for all qubits.
excited_freq_list = self._qubit_freq_ground-0.33e9 + np.linspace(-100*1e+6, 100*1e+6, 75)
for freq in excited_freq_list:
sched_list.append(self.create_cal_circuit_excited(base_pulse, freq))
excited_sweep_job = execute(sched_list, backend=self._backend,
meas_level=1, meas_return='avg', shots=1024,
schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*len(excited_freq_list)
)
if verbose:
print("Executing the Frequency sweep job for 1->2 transition.")
job_monitor(excited_sweep_job)
excited_sweep_data = self.get_job_data(excited_sweep_job, average=True)
if visual:
print("The frequency-signal plot of frequency sweep for 1->2 transition.")
# Note: we are only plotting the real part of the signal
plt.scatter(excited_freq_list/1e+9, excited_sweep_data, color='black')
plt.xlim([min(excited_freq_list/1e+9), max(excited_freq_list/1e+9)])
plt.xlabel("Frequency [GHz]", fontsize=15)
plt.ylabel("Measured Signal [a.u.]", fontsize=15)
plt.title("1->2 Frequency Sweep", fontsize=15)
plt.show()
def lorentzian(xval, scale, q_freq, hwhm, shift):
return (scale / np.pi) * (hwhm / ((xval - q_freq)**2 + hwhm**2)) + shift
# do fit in Hz
excited_sweep_fit_params, excited_sweep_y_fit = self._fit_function(excited_freq_list,
excited_sweep_data,
lorentzian,
[12, self._qubit_freq_ground*0.92, 0.05*1e+9, 1e-7]
)
if visual:
print("The frequency-signal plot of frequency sweep for 1->2 transition.")
# Note: we are only plotting the real part of the signal
plt.scatter(excited_freq_list/1e+9, excited_sweep_data, color='black')
plt.plot(excited_freq_list/1e+9, excited_sweep_y_fit, color='red')
plt.xlim([min(excited_freq_list/1e+9), max(excited_freq_list/1e+9)])
plt.xlabel("Frequency [GHz]", fontsize=15)
plt.ylabel("Measured Signal [a.u.]", fontsize=15)
plt.title("1->2 Frequency Sweep", fontsize=15)
plt.show()
_, qubit_freq_12, _, _ = excited_sweep_fit_params
self._qubit_freq_excited = qubit_freq_12
if verbose:
print(f"The calibrated frequency for the 1->2 transition\
is {self._qubit_freq_excited}.")
return self._qubit_freq_excited
def find_pi_amp_excited(self, verbose=False, visual=False):
"""Sets and returns the amplitude of the pi pulse corresponding to 1->2 transition."""
if not self._qubit_freq_excited:
warn("ground_qubit_freq not computed yet and custom qubit freq not provided." +
"Computing ground_qubit_freq now.")
self._qubit_freq_ground = self.find_freq_excited(verbose, visual)
amp_list = np.linspace(0, 1.0, 75)
rabi_sched_list = []
for amp in amp_list:
base_pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=amp)
rabi_sched_list.append(self.create_cal_circuit_excited(base_pulse,
self._qubit_freq_excited))
rabi_job = execute(rabi_sched_list, backend=self._backend,
meas_level=1, meas_return='avg', shots=1024,
schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*75
)
if verbose:
print("Executing the rabi oscillation job for 1->2 transition.")
job_monitor(rabi_job)
rabi_data = self.get_job_data(rabi_job, average=True)
rabi_data = np.real(self._baseline_remove(rabi_data))
if visual:
print("The amplitude-signal plot of rabi oscillation for 1->2 transition.")
plt.figure()
plt.scatter(amp_list, rabi_data, color='black')
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.title('Rabi Experiment (1->2)', fontsize=20)
plt.show()
(rabi_fit_params,
rabi_y_fit) = self._fit_function(amp_list,
rabi_data,
lambda x, A, B, drive_period, phi: (A*np.cos(2*np.pi*x/drive_period - phi) + B),
[3e-8, 0, 0.4, np.pi/2])
drive_period_excited = rabi_fit_params[2]
pi_amp_excited = (drive_period_excited/2/np.pi) * (np.pi+rabi_fit_params[3])
self._pi_amp_excited = pi_amp_excited
if visual:
print("The amplitude-signal plot of rabi oscillation for 1->2 transition.")
plt.figure()
plt.scatter(amp_list, rabi_data, color='black')
plt.plot(amp_list, rabi_y_fit, color='red')
# account for phi in computing pi amp
plt.axvline(self._pi_amp_excited, color='red', linestyle='--')
plt.axvline(self._pi_amp_excited+drive_period_excited/2, color='red', linestyle='--')
plt.annotate("", xy=(self._pi_amp_excited+drive_period_excited/2, 0),
xytext=(self._pi_amp_excited, 0),
arrowprops=dict(arrowstyle="<->", color='red'))
#plt.annotate("$\\pi$", xy=(self._pi_amp_excited-0.03, 0.1), color='red')
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.title('Rabi Experiment (1->2)', fontsize=20)
plt.show()
return self._pi_amp_excited
def get_pi_pulse_ground(self):
"""Returns a pi pulse of the 0->1 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=self._pi_amp_ground)
return pulse
def get_pi_pulse_excited(self):
"""Returns a pi pulse of the 1->2 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=self._pi_amp_excited)
excited_pulse = self.apply_sideband(pulse, self._qubit_freq_excited)
return excited_pulse
def get_x90_pulse_ground(self):
"""Returns a pi/2 pulse of the 0->1 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=self._pi_amp_ground/2)
return pulse
def get_x90_pulse_excited(self):
"""Returns a pi/2 pulse of the 1->2 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=self._pi_amp_excited/2)
excited_pulse = self.apply_sideband(pulse, self._qubit_freq_excited)
return excited_pulse
def get_zero_sched(self):
"""Returns a schedule that performs only a measurement."""
zero_sched = Schedule()
zero_sched += self._measure
return zero_sched
def get_one_sched(self):
"""Returns a schedule that creates a |1> state from |0> by applying
a pi pulse of 0->1 transition and performs a measurement."""
one_sched = Schedule()
one_sched += Play(self.get_pi_pulse_ground(), self._drive_chan)
one_sched += self._measure << one_sched.duration
return one_sched
def get_two_sched(self):
"""Returns a schedule that creates a |2> state from |0> by applying
a pi pulse of 0->1 transition followed by applying a pi pulse
of 1->2 transition and performs a measurement."""
two_sched = Schedule()
two_sched += Play(self.get_pi_pulse_ground(), self._drive_chan)
two_sched += Play(self.get_pi_pulse_excited(), self._drive_chan)
two_sched += self._measure << two_sched.duration
return two_sched
@staticmethod
def _create_iq_plot(zero_data, one_data, two_data):
"""Helper function for plotting IQ plane for 0, 1, 2. Limits of plot given
as arguments."""
# zero data plotted in blue
plt.scatter(np.real(zero_data), np.imag(zero_data),
s=5, cmap='viridis', c='blue', alpha=0.5, label=r'$|0\rangle$')
# one data plotted in red
plt.scatter(np.real(one_data), np.imag(one_data),
s=5, cmap='viridis', c='red', alpha=0.5, label=r'$|1\rangle$')
# two data plotted in green
plt.scatter(np.real(two_data), np.imag(two_data),
s=5, cmap='viridis', c='green', alpha=0.5, label=r'$|2\rangle$')
x_min = np.min(np.append(np.real(zero_data), np.append(np.real(one_data),
np.real(two_data))))-5
x_max = np.max(np.append(np.real(zero_data), np.append(np.real(one_data),
np.real(two_data))))+5
y_min = np.min(np.append(np.imag(zero_data), np.append(np.imag(one_data),
np.imag(two_data))))-5
y_max = np.max(np.append(np.imag(zero_data), np.append(np.imag(one_data),
np.imag(two_data))))+5
# Plot a large dot for the average result of the 0, 1 and 2 states.
mean_zero = np.mean(zero_data) # takes mean of both real and imaginary parts
mean_one = np.mean(one_data)
mean_two = np.mean(two_data)
plt.scatter(np.real(mean_zero), np.imag(mean_zero),
s=200, cmap='viridis', c='black', alpha=1.0)
plt.scatter(np.real(mean_one), np.imag(mean_one),
s=200, cmap='viridis', c='black', alpha=1.0)
plt.scatter(np.real(mean_two), np.imag(mean_two),
s=200, cmap='viridis', c='black', alpha=1.0)
plt.xlim(x_min, x_max)
plt.ylim(y_min, y_max)
plt.legend()
plt.ylabel('I [a.u.]', fontsize=15)
plt.xlabel('Q [a.u.]', fontsize=15)
plt.title("0-1-2 discrimination", fontsize=15)
return x_min, x_max, y_min, y_max
@staticmethod
def reshape_complex_vec(vec):
"""Take in complex vector vec and return 2d array w/ real, imag entries.
This is needed for the learning.
Args:
vec (list): complex vector of data
Returns:
list: vector w/ entries given by (real(vec], imag(vec))
"""
length = len(vec)
vec_reshaped = np.zeros((length, 2))
for i, item in enumerate(vec):
vec_reshaped[i] = [np.real(item), np.imag(item)]
return vec_reshaped
def find_three_level_discriminator(self, verbose=False, visual=False):
"""Returns a discriminator for discriminating 0-1-2 states."""
# pylint: disable=too-many-locals
zero_sched = self.get_zero_sched()
one_sched = self.get_one_sched()
two_sched = self.get_two_sched()
iq_job = execute([zero_sched, one_sched, two_sched], backend=self._backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*3
)
if verbose:
job_monitor(iq_job)
iq_data = self.get_job_data(iq_job, average=False)
zero_data = iq_data[0]
one_data = iq_data[1]
two_data = iq_data[2]
if visual:
print("The discriminator plot for 0-1-2 discrimination.")
x_min, x_max, y_min, y_max = self._create_iq_plot(zero_data, one_data, two_data)
# Create IQ vector (split real, imag parts)
zero_data_reshaped = self.reshape_complex_vec(zero_data)
one_data_reshaped = self.reshape_complex_vec(one_data)
two_data_reshaped = self.reshape_complex_vec(two_data)
iq_data = np.concatenate((zero_data_reshaped, one_data_reshaped, two_data_reshaped))
# construct vector w/ 0's, 1's and 2's (for testing)
state_012 = np.zeros(1024) # shots gives number of experiments
state_012 = np.concatenate((state_012, np.ones(1024)))
state_012 = np.concatenate((state_012, 2*np.ones(1024)))
# Shuffle and split data into training and test sets
iq_012_train, iq_012_test, state_012_train, state_012_test = train_test_split(iq_data,
state_012,
test_size=0.5)
classifier_lda_012 = LinearDiscriminantAnalysis()
classifier_lda_012.fit(iq_012_train, state_012_train)
score_012 = classifier_lda_012.score(iq_012_test, state_012_test)
if verbose:
print('The accuracy score of the discriminator is: ', score_012)
self._state_discriminator_012 = classifier_lda_012
if visual:
self._separatrix_plot(classifier_lda_012, x_min, x_max, y_min, y_max, 1024)
return self._state_discriminator_012
@staticmethod
def _separatrix_plot(lda, x_min, x_max, y_min, y_max, shots):
"""Returns a sepratrix plot for the classifier."""
# pylint: disable=too-many-arguments
num_x, num_y = shots, shots
xvals, vals = np.meshgrid(np.linspace(x_min, x_max, num_x),
np.linspace(y_min, y_max, num_y))
predict_prob = lda.predict_proba(np.c_[xvals.ravel(), vals.ravel()])
predict_prob = predict_prob[:, 1].reshape(xvals.shape)
plt.contour(xvals, vals, predict_prob, [0.5], linewidths=2., colors='black')
def get_qubit_freq_ground(self):
"""Returns the set 0->1 transition frequency."""
return self._qubit_freq_ground
def get_qubit_freq_excited(self):
"""Returns the set 1->2 transition frequency."""
return self._qubit_freq_excited
def get_pi_amp_ground(self):
"""Returns the set 0->1 transition pi pulse amplitude."""
return self._pi_amp_ground
def get_pi_amp_excited(self):
"""Returns the set 1->2 transition pi pulse amplitude."""
return self._pi_amp_excited
def get_three_level_discriminator(self):
"""Returns the set 0-1-2 state discriminator."""
return self._state_discriminator_012
def calibrate_all(self, verbose=False, visual=False):
"""Calibrates and sets both the ground and excited transition frequencies and
corresponding pi pulse amplitudes. Also constructs a 0-1-2 state discriminator."""
ground_freq = self.find_freq_ground(verbose, visual)
ground_amp = self.find_pi_amp_ground(verbose, visual)
excited_freq = self.find_freq_excited(verbose, visual)
excited_amp = self.find_pi_amp_excited(verbose, visual)
state_discriminator = self.find_three_level_discriminator(verbose, visual)
return ground_freq, ground_amp, excited_freq, excited_amp, state_discriminator
def T1_ground(self, verbose=False, visual=False):
"""Returns the T1 of 1 state"""
time_max=600
time_step=8
times=np.arange(1,time_max,time_step)*1e-6
delay_times_dt=times/self._dt
t1_gnd_sched=[]
for delay in delay_times_dt:
this_sched= Schedule(name=f"T1 delay={delay*self._dt/1e-6} us")
this_sched+= Play(self.get_pi_pulse_ground(),self._drive_chan)
this_sched|=self._measure<<int(delay)
t1_gnd_sched.append(this_sched)
#sched_idx=0
#t1_gnd_sched[sched_idx]
# Execution settings
t1_gnd_job = execute(t1_gnd_sched, backend=self._backend, meas_level=1,
meas_return='avg', shots=256,
schedule_los=[{self._drive_chan: self.get_qubit_freq_ground()}]
* len(t1_gnd_sched))
if verbose:
job_monitor(t1_gnd_job)
t1_gnd_results =self.get_job_data(t1_gnd_job, average=True)
t1_gnd_results = np.real(t1_gnd_results)
# Fit the data
fit_params, y_fit = self._fit_function(times, t1_gnd_results,
lambda x, A, C, T1: (A * np.exp(-x / T1) + C),[-6, 8, 100*1e-6])
_, _, T1_gnd = fit_params
if visual:
plt.scatter(times*1e6, t1_gnd_results, color='black')
plt.plot(times*1e6, y_fit, color='red', label=f"T1 = {T1_gnd*1e6:.2f} us")
plt.xlim(0, np.max(times)*1e6)
plt.title("$T_1$ Experiment", fontsize=15)
plt.xlabel('Delay before measurement [$\mu$s]', fontsize=15)
plt.ylabel('Signal [a.u.]', fontsize=15)
plt.legend()
plt.show()
return T1_gnd
def T1_excited(self, verbose=False, visual=False):
"""Returns the T1 of 2 state"""
time_max=600
time_step=8
times=np.arange(1,time_max,time_step)*1e-6
delay_times_dt=times/self._dt
t1_exc_sched=[]
for delay in delay_times_dt:
this_sched= Schedule(name=f"T1 delay={delay*self._dt/1e-6} us")
this_sched+= Play(self.get_pi_pulse_ground(),self._drive_chan)
this_sched += Play(self.get_pi_pulse_excited(), self._drive_chan)
this_sched|=self._measure<<int(delay)
t1_exc_sched.append(this_sched)
#sched_idx=0
#t1_gnd_sched[sched_idx]
# Execution settings
t1_exc_job = execute(t1_exc_sched, backend=self._backend, meas_level=1,
meas_return='avg', shots=256,
schedule_los=[{self._drive_chan: self.get_qubit_freq_ground()}]
* len(t1_exc_sched))
if verbose:
job_monitor(t1_exc_job)
t1_exc_results =self.get_job_data(t1_exc_job, average=True)
t1_exc_results = np.real(t1_exc_results) # Reverse the sign to have a decay behavior.
# Fit the data
fit_params, y_fit = self._fit_function(times, t1_exc_results, lambda x, A, C, T1: (A * np.exp(-x / T1) + C),[-6, 8, 100*1e-6])
_, _, T1_exc = fit_params
if visual:
plt.scatter(times*1e6, t1_exc_results, color='black')
plt.plot(times*1e6, y_fit, color='red', label=f"T1 = {T1_exc*1e6:.2f} us")
plt.xlim(0, np.max(times)*1e6)
plt.title("$T_1$ Experiment", fontsize=15)
plt.xlabel('Delay before measurement [$\mu$s]', fontsize=15)
plt.ylabel('Signal [a.u.]', fontsize=15)
plt.legend()
plt.show()
return T1_exc
def T2_ground(self,verbose=False,visual=False):
"""Returns the T2 of 1 state"""
time_max=300
time_step=4
times=np.arange(2,time_max,time_step)*1e-6
delay_times_dt=times/self._dt
t2_gnd_sched=[]
for delay in delay_times_dt:
this_sched= Schedule(name=f"T2 delay={delay*self._dt/1e-6} us")
this_sched|= Play(self.get_x90_pulse_ground(),self._drive_chan)
this_sched|= Play(self.get_pi_pulse_ground(),self._drive_chan) << int(this_sched.duration+delay)
this_sched|= Play(self.get_x90_pulse_ground(),self._drive_chan)<< int(this_sched.duration+delay)
this_sched|=self._measure<<int(this_sched.duration)
t2_gnd_sched.append(this_sched)
#sched_idx=0
#t1_gnd_sched[sched_idx]
# Execution settings
t2_gnd_job = execute(t2_gnd_sched, backend=self._backend, meas_level=1,
meas_return='avg', shots=512,
schedule_los=[{self._drive_chan: self.get_qubit_freq_ground()}]
* len(t2_gnd_sched))
if verbose:
job_monitor(t2_gnd_job)
t2_gnd_results =self.get_job_data(t2_gnd_job, average=True)
t2_gnd_results = np.real(t2_gnd_results)
# Fit the data2
fit_params, y_fit = self._fit_function(2*times, t2_gnd_results, lambda x, A, C, T2: (A * np.exp(-x / T2) + C),[-3, 0, 100*1e-6])
_, _, T2_gnd = fit_params
if visual:
plt.scatter(2*times*1e6, t2_gnd_results, color='black')
plt.plot(2*times*1e6, y_fit, color='red', label=f"T2 = {T2_gnd*1e6:.2f} us")
plt.xlim(0, np.max(2*times)*1e6)
plt.title("$T_2$ Experiment with Hahn Echo", fontsize=15)
plt.xlabel('Delay before measurement [$\mu$s]', fontsize=15)
plt.ylabel('Signal [a.u.]', fontsize=15)
plt.legend()
plt.show()
return T2_gnd
|
https://github.com/h-rathee851/Pulse_application_qiskit
|
h-rathee851
|
from qiskit.tools.jupyter import *
from qiskit import IBMQ
IBMQ.load_account()
#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
provider=IBMQ.get_provider(hub='ibm-q-research', group='uni-maryland-1', project='main')
backend = provider.get_backend('ibmq_rome')
backend_config = backend.configuration()
backend_defaults = backend.defaults()
assert backend_config.open_pulse, "Backend doesn't support Pulse"
inst_sched_map=backend_defaults.instruction_schedule_map
print(inst_sched_map)
from qiskit.visualization.pulse_v2 import draw
from qiskit import execute
dt = backend_config.dt
print(f"Sampling time: {dt*1e9} ns") # The configuration returns dt in seconds, so multiply by
# 1e9 to get nanoseconds
import numpy as np
from qiskit import pulse # This is where we access all of our Pulse features!
from qiskit.pulse import Play
# This Pulse module helps us build sampled pulses for common pulse shapes
from qiskit.pulse import library as pulse_lib
from pulsecalibration import PulseCalibration as PulseCali
%load_ext autoreload
%autoreload
PC=PulseCali(backend=backend,qubit=0)
print(backend_defaults.qubit_freq_est)
f01=PC.find_freq_ground(verbose=True,visual=True)
f01_1=PC.get_qubit_freq_ground()
f01_1
PC=PulseCali(backend=backend,qubit=0,qubit_freq_ground=f01)
amp01=PC.find_pi_amp_ground(verbose=True,visual=True)
amp01_1=PC.get_pi_amp_ground()
amp01_1
PC=PulseCali(backend=backend,qubit=0,qubit_freq_ground=f01,pi_amp_ground=amp01)
f12=PC.find_freq_excited(verbose=True,visual=True)
PC=PulseCali(backend=backend,qubit=0,qubit_freq_ground=f01,pi_amp_ground=amp01,qubit_freq_excited=f12)
f12_1=PC.get_qubit_freq_excited()
f12_1
amp12=PC.find_pi_amp_excited(verbose=True,visual=True)
amp12_1=PC.get_pi_amp_excited()
amp12_1
PC=PulseCali(backend,0,qubit_freq_ground=f01,qubit_freq_excited=f12,
pi_amp_ground=amp01, pi_amp_excited=amp12)
PC.T1_ground(verbose=True,visual=True)
PC.T1_excited(verbose=True,visual=True)
PC.T2_ground(verbose=True,visual=True)
|
https://github.com/h-rathee851/Pulse_application_qiskit
|
h-rathee851
|
from calibration import *
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-research', group='iserc-1', project='main')
"""
Object to calibrate pulse of backend and qubit of interest.
"""
# Importing required python packages
from warnings import warn
import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import curve_fit
from scipy.signal import find_peaks
from sklearn.model_selection import train_test_split
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis
# Importing standard Qiskit libraries
from qiskit import IBMQ, execute, pulse
from qiskit.providers.ibmq import IBMQBackend
from qiskit.pulse import DriveChannel, Schedule, Play
from qiskit.pulse import library as pulse_lib
from qiskit.pulse.library import Waveform, Gaussian
from qiskit.tools.monitor import job_monitor
from qiskit.providers.exceptions import QiskitBackendNotFoundError, BackendConfigurationError
# Loading your IBM Q account(s)
#IBMQ.load_account()
#provider = IBMQ.get_provider()
class PulseCalibration():
"""Creates an object that is used for pulse calibration.
Args:
backend (IBMQBackend) : The IBMQBackend for which pulse calibration needs to be done.
qubit (int) : The qubit for which the pulse calibration is done.
qubit_freq_ground (float) : Custom frequency for 0->1 transition.
qubit_freq_excited (float) : Custom frequency for 1->2 transition.
pi_amp_ground (float) : Custom pi amplitude for 0->1 transition.
The value should be between 0 and 1.
pi_amp_excited (float) : Custom pi amplitude for 1->2 transition.
The value should be between 0 and 1.
pulse_dur (int) : The duration of the pi pulse to be used for calibration.
pulse_sigma (int) : The standard deviation of the pi pulse to be used for calibration.
"""
def __init__(self, backend, qubit, qubit_freq_ground=None, qubit_freq_excited=None,
pi_amp_ground=None, pi_amp_excited=None, pulse_dur=None, pulse_sigma=None):
# pylint: disable=too-many-locals
# pylint: disable=too-many-arguments
if not isinstance(backend, IBMQBackend):
raise QiskitBackendNotFoundError("Provided backend not available." +
"Please provide backend after obtaining from IBMQ.")
self._backend = backend
self._back_config = backend.configuration()
if qubit >= self._back_config.n_qubits:
raise BackendConfigurationError(f"Qubit {qubit} not present in the provided backend.")
self._qubit = qubit
self._back_defaults = backend.defaults()
self._qubit_anharmonicity = backend.properties().qubit_property(self._qubit)['anharmonicity'][0]
self._dt = self._back_config.dt
self._qubit_freq = self._back_defaults.qubit_freq_est[self._qubit]
self._inst_sched_map = self._back_defaults.instruction_schedule_map
self._drive_chan = DriveChannel(qubit)
if pulse_sigma:
self._pulse_sigma = pulse_sigma
else:
if self._backend.name() == 'ibmq_armonk':
self._pulse_sigma = 80
else:
self._pulse_sigma = 40
if pulse_dur:
self._pulse_duration = pulse_dur
else:
self._pulse_duration = (4*self._pulse_sigma)-((4*self._pulse_sigma) % 16)
self._qubit_freq_ground = qubit_freq_ground
self._qubit_freq_excited = qubit_freq_excited
self._pi_amp_ground = pi_amp_ground
self._pi_amp_excited = pi_amp_excited
self._state_discriminator_012 = None
# Find out which measurement map index is needed for this qubit
meas_map_idx = None
for i, measure_group in enumerate(self._back_config.meas_map):
if qubit in measure_group:
meas_map_idx = i
break
assert meas_map_idx is not None, f"Couldn't find qubit {qubit} in the meas_map!"
# The measurement pulse for measuring the qubit of interest.
self._measure = self._inst_sched_map.get('measure',
qubits=self._back_config.meas_map[meas_map_idx])
def create_cal_circuit(self, amp):
"""Constructs and returns a schedule containing Gaussian pulse with amplitude as 'amp',
sigma as 'pulse_sigma' and duration as 'pulse_duration'."""
sched = Schedule()
sched += Play(Gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=amp), self._drive_chan)
sched += self._measure << sched.duration
return sched
def create_cal_circuit_excited(self, base_pulse, freq):
""" Constructs and returns a schedule containing a pi pulse for 0->1 transition followed by
a sidebanded pulse which corresponds to applying 'base_pulse' at frequency 'freq'."""
sched = Schedule()
sched += Play(Gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=self._pi_amp_ground), self._drive_chan)
sched += Play(self.apply_sideband(base_pulse, freq), self._drive_chan)
sched += self._measure << sched.duration
return sched
@staticmethod
def _fit_function(x_values, y_values, function, init_params):
""" A function fitter. Returns the fit parameters of 'function'."""
fitparams, _ = curve_fit(function, x_values, y_values, init_params)
y_fit = function(x_values, *fitparams)
return fitparams, y_fit
@staticmethod
def _baseline_remove(values):
"""Centering data around zero."""
return np.array(values) - np.mean(values)
def apply_sideband(self, pulse, frequency):
"""Apply a sine sideband to 'pulse' at frequency 'freq'.
Args:
pulse (Waveform): The pulse to which sidebanding is to be applied.
frequency (float): LO frequency at which the pulse is to be applied.
Returns:
Waveform: The sidebanded pulse.
"""
t_samples = np.linspace(0, self._dt*self._pulse_duration, self._pulse_duration)
sine_pulse = np.sin(2*np.pi*(frequency-self._qubit_freq_ground)*t_samples)
sideband_pulse = Waveform(np.multiply(np.real(pulse.samples), sine_pulse),
name='sideband_pulse')
return sideband_pulse
def get_job_data(self, job, average):
"""Retrieve data from a job that has already run.
Args:
job (Job): The job whose data you want.
average (bool): If True, gets the data assuming data is an average.
If False, gets the data assuming it is for single shots.
Return:
list: List containing job result data.
"""
scale_factor = 1e-14
job_results = job.result(timeout=120) # timeout parameter set to 120 s
result_data = []
for i in range(len(job_results.results)):
if average: # get avg data
result_data.append(job_results.get_memory(i)[self._qubit]*scale_factor)
else: # get single data
result_data.append(job_results.get_memory(i)[:, self._qubit]*scale_factor)
return result_data
# Prints out relative maxima frequencies in output_data; height gives lower bound (abs val)
@staticmethod
def _rel_maxima(freqs, output_data, height, distance):
"""Prints out relative maxima frequencies in output_data (can see peaks);
height gives upper bound (abs val). Be sure to set the height properly or
the peak will be ignored!
Args:
freqs (list): frequency list
output_data (list): list of resulting signals
height (float): upper bound (abs val) on a peak
width (float):
Returns:
list: List containing relative maxima frequencies
"""
peaks, _ = find_peaks(x=output_data, height=height, distance=distance)
return freqs[peaks]
def find_freq_ground(self, verbose=False, visual=False):
"""Sets and returns the calibrated frequency corresponding to 0->1 transition."""
# pylint: disable=too-many-locals
sched_list = [self.create_cal_circuit(0.5)]*75
freq_list = np.linspace(self._qubit_freq-(45*1e+6), self._qubit_freq+(45*1e+6), 75)
sweep_job = execute(sched_list, backend=self._backend, meas_level=1, meas_return='avg',
shots=1024, schedule_los = [{self._drive_chan: freq} for freq in freq_list])
jid = sweep_job.job_id()
if verbose:
print("Executing the Frequency sweep job for 0->1 transition.")
print('Job Id : ', jid)
# job_monitor(sweep_job)
sweep_job = self._backend.retrieve_job(jid)
sweep_result = sweep_job.result()
sweep_values = []
for i in range(len(sweep_result.results)):
# Get the results from the ith experiment
res = sweep_result.get_memory(i)*1e-14
# Get the results for `qubit` from this experiment
sweep_values.append(res[self._qubit])
freq_list_GHz = freq_list/1e+9
if visual:
print("The frequency-signal plot for frequency sweep: ")
plt.scatter(freq_list_GHz, np.real(sweep_values), color='black')
plt.xlim([min(freq_list_GHz), max(freq_list_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured Signal [a.u.]")
plt.show()
# def find_init_params(freq_list, res_values):
# hmin_index = np.where(res_values==min(res_values[:len(freq_list)//2]))[0][0]
# hmax_index = np.where(res_values==max(res_values[:len(freq_list)//2]))[0][0]
# if hmin_index < hmax_index:
# est_baseline = min(res_values)
# est_slope = (res_values[hmax_index] - res_values[hmin_index])/(freq_list[hmax_index] - freq_list[hmin_index])
# else:
# est_baseline = max(res_values)
# est_slope = (res_values[hmin_index] - res_values[hmax_index])/(freq_list[hmin_index] - freq_list[hmax_index])
# return [est_slope, self._qubit_freq/1e9, 1, est_baseline]
def find_init_params_gauss(freq_list, res_values):
hmin_index = np.where(res_values==min(res_values[:len(freq_list)//2]))[0][0]
hmax_index = np.where(res_values==max(res_values[:len(freq_list)//2]))[0][0]
mean_est = freq_list[hmax_index]
var_est = np.abs(freq_list[hmax_index]-freq_list[hmin_index])/2
scale_est = max(res_values)-min(res_values)
shift_est = min(res_values)
return [mean_est, var_est, scale_est, shift_est]
def gauss(x, mean, var, scale, shift):
return (scale*(1/var*np.sqrt(2*np.pi))*np.exp(-(1/2)*(((x-mean)/var)**2)))+shift
def lorentzian(xval, scale, q_freq, hwhm, shift):
return (scale / np.pi) * (hwhm / ((xval - q_freq)**2 + hwhm**2)) + shift
# do fit in Hz
init_params = find_init_params_gauss(freq_list_GHz, np.real(sweep_values))
# init_params = find_init_params(freq_list_GHz, np.real(sweep_values))
print('ground freq init params : ', init_params)
# Obtain the optimal paramters that fit the result data.
# fit_params, y_fit = self._fit_function(freq_list_GHz,
# np.real(sweep_values),
# lorentzian,
# init_params # init parameters for curve_fit
# )
fit_params, y_fit = self._fit_function(freq_list_GHz,
np.real(sweep_values),
gauss,
init_params # init parameters for curve_fit
)
if visual:
print("The frequency-signal plot for frequency sweep: ")
plt.scatter(freq_list_GHz, np.real(sweep_values), color='black')
plt.plot(freq_list_GHz, y_fit, color='red')
plt.xlim([min(freq_list_GHz), max(freq_list_GHz)])
plt.xlabel("Frequency [GHz]")
plt.ylabel("Measured Signal [a.u.]")
plt.show()
qubit_freq_new, _, _, _ = fit_params
self._qubit_freq_ground = qubit_freq_new*1e9
if verbose:
print(f"The calibrate frequency for the 0->1 transition is {self._qubit_freq_ground}")
return [self._qubit_freq_ground, freq_list_GHz, sweep_values]
def find_pi_amp_ground(self, verbose=False, visual=False):
"""Sets and returns the amplitude of the pi pulse corresponding to 0->1 transition."""
# pylint: disable=too-many-locals
if not self._qubit_freq_ground:
warn("ground_qubit_freq not computed yet and custom qubit freq not provided." +
"Computing ground_qubit_freq now.")
self._qubit_freq_ground = self.find_freq_ground(verbose, visual)
amp_list = np.linspace(0, 1, 75)
rabi_sched_list = [self.create_cal_circuit(amp) for amp in amp_list]
rabi_list_len = len(rabi_sched_list)
rabi_job = execute(rabi_sched_list,backend=self._backend, meas_level=1, meas_return='avg',
shots=1024, schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*len(rabi_sched_list))
jid = rabi_job.job_id()
if verbose:
print("Executing the rabi oscillation job to get Pi pulse for 0->1 transition.")
print('Job Id : ', jid)
# job_monitor(rabi_job)
rabi_job = self._backend.retrieve_job(jid)
rabi_results = rabi_job.result()
scale_factor = 1e-14
rabi_values = []
for i in range(75):
# Get the results for `qubit` from the ith experiment
rabi_values.append(rabi_results.get_memory(i)[self._qubit]*scale_factor)
rabi_values = np.real(self._baseline_remove(rabi_values))
def find_init_params_amp(amp_list, rabi_values):
min_index = np.where(rabi_values==min(rabi_values))[0][0]
max_index = np.where(rabi_values==max(rabi_values))[0][0]
scale_est = (max(rabi_values) - min(rabi_values))/2
shift_est = (max(rabi_values) + min(rabi_values))/2
shift_est = np.mean(rabi_values)
period_est = 0.5
if ((max(rabi_values)-rabi_values[0])/(2*scale_est)) < 0.5:
phi_est = np.pi/2
else:
phi_est = -np.pi/2
return [scale_est, shift_est, period_est, phi_est]
# Obtain the optimal paramters that fit the result data.
init_params = find_init_params_amp(amp_list,rabi_values)
fit_params, y_fit = self._fit_function(amp_list,
rabi_values,
lambda x, A, B, drive_period, phi: (A*np.sin(2*np.pi*x/drive_period - phi) + B),
init_params)
drive_period = fit_params[2]
self._pi_amp_ground = drive_period/2
if verbose:
print(f"The Pi amplitude of 0->1 transition is {self._pi_amp_ground}.")
if visual:
print("The amplitude-signal plot for rabi oscillation for 0->1 transition.")
plt.figure()
plt.scatter(amp_list, rabi_values, color='black')
plt.plot(amp_list, y_fit, color='red')
plt.axvline(drive_period/2, color='red', linestyle='--')
plt.axvline(drive_period, color='red', linestyle='--')
plt.annotate("", xy=(drive_period, 0), xytext=(drive_period/2, 0),
arrowprops=dict(arrowstyle="<->", color='red'))
#plt.annotate("$\pi$", xy=(drive_period/2-0.03, 0.1), color='red')
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.show()
return [self._pi_amp_ground, amp_list, rabi_values]
def find_freq_excited(self, verbose=False, visual=False):
"""Sets and returns the frequency corresponding to 1->2 transition."""
# pylint: disable=too-many-locals
if not self._qubit_freq_ground:
raise ValueError("The qubit_freq_ground is not determined. Please determine" +
"qubit_freq_ground first.")
if not self._pi_amp_ground:
raise ValueError("The pi_amp_ground is not determined.\
Please determine pi_amp_ground first.")
base_pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=0.3)
sched_list = []
# Here we assume that the anharmocity is about 8% for all qubits.
excited_freq_list = self._qubit_freq_ground + self._qubit_anharmonicity + np.linspace(-30*1e+6, 30*1e+6, 75)
for freq in excited_freq_list:
sched_list.append(self.create_cal_circuit_excited(base_pulse, freq))
excited_sweep_job = execute(sched_list, backend=self._backend,
meas_level=1, meas_return='avg', shots=1024,
schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*len(excited_freq_list)
)
jid = excited_sweep_job.job_id()
excited_freq_list_GHz = excited_freq_list/1e+9
if verbose:
print("Executing the Frequency sweep job for 1->2 transition.")
print('Job Id : ', jid)
# job_monitor(excited_sweep_job)
excited_sweep_job = self._backend.retrieve_job(jid)
excited_sweep_data = self.get_job_data(excited_sweep_job, average=True)
if visual:
print("The frequency-signal plot of frequency sweep for 1->2 transition.")
# Note: we are only plotting the real part of the signal
plt.scatter(excited_freq_list_GHz, excited_sweep_data, color='black')
plt.xlim([min(excited_freq_list_GHz), max(excited_freq_list_GHz)])
plt.xlabel("Frequency [GHz]", fontsize=15)
plt.ylabel("Measured Signal [a.u.]", fontsize=15)
plt.title("1->2 Frequency Sweep", fontsize=15)
plt.show()
def find_init_params_gauss(freq_list, res_values):
hmin_index = np.where(res_values==min(res_values[:len(freq_list)//2]))[0][0]
hmax_index = np.where(res_values==max(res_values[:len(freq_list)//2]))[0][0]
mean_est = freq_list[hmax_index]
var_est = np.abs(freq_list[hmax_index]-freq_list[hmin_index])/2
scale_est = max(res_values)-min(res_values)
shift_est = min(res_values)
return [mean_est, var_est, scale_est, shift_est]
def gauss(x, mean, var, scale, shift):
return (scale*(1/var*np.sqrt(2*np.pi))*np.exp(-(1/2)*(((x-mean)/var)**2)))+shift
def lorentzian(xval, scale, q_freq, hwhm, shift):
return (scale / np.pi) * (hwhm / ((xval - q_freq)**2 + hwhm**2)) + shift
# do fit in Hz
# init_params = find_init_params(excited_freq_list_GHz, np.real(excited_sweep_data))
init_params = find_init_params_gauss(excited_freq_list_GHz, np.real(excited_sweep_data))
print("Init params : ", init_params)
excited_sweep_fit_params, excited_sweep_y_fit = self._fit_function(excited_freq_list_GHz,
excited_sweep_data,
gauss,
init_params
)
if visual:
print("The frequency-signal plot of frequency sweep for 1->2 transition.")
# Note: we are only plotting the real part of the signal
plt.scatter(excited_freq_list/1e+9, excited_sweep_data, color='black')
plt.plot(excited_freq_list/1e+9, excited_sweep_y_fit, color='red')
plt.xlim([min(excited_freq_list/1e+9), max(excited_freq_list/1e+9)])
plt.xlabel("Frequency [GHz]", fontsize=15)
plt.ylabel("Measured Signal [a.u.]", fontsize=15)
plt.title("1->2 Frequency Sweep", fontsize=15)
plt.show()
qubit_freq_12, _, _, _ = excited_sweep_fit_params
self._qubit_freq_excited = qubit_freq_12*1e+9
if verbose:
print(f"The calibrated frequency for the 1->2 transition\
is {self._qubit_freq_excited}.")
return [self._qubit_freq_excited, excited_freq_list, excited_sweep_data]
def find_pi_amp_excited(self, verbose=False, visual=False):
"""Sets and returns the amplitude of the pi pulse corresponding to 1->2 transition."""
if not self._qubit_freq_excited:
warn("ground_qubit_freq not computed yet and custom qubit freq not provided." +
"Computing ground_qubit_freq now.")
self._qubit_freq_ground = self.find_freq_excited(verbose, visual)
amp_list = np.linspace(0, 1.0, 75)
rabi_sched_list = []
for amp in amp_list:
base_pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=amp)
rabi_sched_list.append(self.create_cal_circuit_excited(base_pulse,
self._qubit_freq_excited))
rabi_job = execute(rabi_sched_list, backend=self._backend,
meas_level=1, meas_return='avg', shots=1024,
schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*75
)
jid = rabi_job.job_id()
if verbose:
print("Executing the rabi oscillation job for 1->2 transition.")
print('Job Id : ', jid)
# job_monitor(rabi_job)
rabi_job = self._backend.retrieve_job(jid)
rabi_data = self.get_job_data(rabi_job, average=True)
rabi_data = np.real(self._baseline_remove(rabi_data))
if visual:
print("The amplitude-signal plot of rabi oscillation for 1->2 transition.")
plt.figure()
plt.scatter(amp_list, rabi_data, color='black')
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.title('Rabi Experiment (1->2)', fontsize=20)
plt.show()
def find_init_params_amp(amp_list, rabi_values):
min_index = np.where(rabi_values==min(rabi_values))[0][0]
max_index = np.where(rabi_values==max(rabi_values))[0][0]
scale_est = (max(rabi_values) - min(rabi_values))/2
shift_est = (max(rabi_values) + min(rabi_values))/2
shift_est = np.mean(rabi_values)
period_est = 0.5
if ((max(rabi_values)-rabi_values[0])/(2*scale_est)) < 0.5:
phi_est = np.pi/2
else:
phi_est = -np.pi/2
return [scale_est, shift_est, period_est, phi_est]
init_params = find_init_params_amp(amp_list, rabi_data)
print('Init params for 01 amp : ', init_params)
(rabi_fit_params,
rabi_y_fit) = self._fit_function(amp_list,
rabi_data,
lambda x, A, B, drive_period, phi: (A*np.sin(2*np.pi*x/drive_period - phi) + B),
init_params)
drive_period_excited = rabi_fit_params[2]
pi_amp_excited = (drive_period_excited/2/np.pi) * (np.pi+rabi_fit_params[3])
self._pi_amp_excited = pi_amp_excited
if visual:
print("The amplitude-signal plot of rabi oscillation for 1->2 transition.")
plt.figure()
plt.scatter(amp_list, rabi_data, color='black')
plt.plot(amp_list, rabi_y_fit, color='red')
# account for phi in computing pi amp
plt.axvline(self._pi_amp_excited, color='red', linestyle='--')
plt.axvline(self._pi_amp_excited+drive_period_excited/2, color='red', linestyle='--')
plt.annotate("", xy=(self._pi_amp_excited+drive_period_excited/2, 0),
xytext=(self._pi_amp_excited, 0),
arrowprops=dict(arrowstyle="<->", color='red'))
#plt.annotate("$\\pi$", xy=(self._pi_amp_excited-0.03, 0.1), color='red')
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.title('Rabi Experiment (1->2)', fontsize=20)
plt.show()
return [self._pi_amp_excited, amp_list, rabi_data]
def get_pi_pulse_ground(self):
"""Returns a pi pulse of the 0->1 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=self._pi_amp_ground)
return pulse
def get_pi_pulse_excited(self):
"""Returns a pi pulse of the 1->2 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=self._pi_amp_excited)
excited_pulse = self.apply_sideband(pulse, self._qubit_freq_excited)
return excited_pulse
def get_x90_pulse_ground(self):
"""Returns a pi/2 pulse of the 0->1 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration,
sigma=self._pulse_sigma, amp=self._pi_amp_ground/2)
return pulse
def get_x90_pulse_excited(self):
"""Returns a pi/2 pulse of the 1->2 transition."""
pulse = pulse_lib.gaussian(duration=self._pulse_duration, sigma=self._pulse_sigma,
amp=self._pi_amp_excited/2)
excited_pulse = self.apply_sideband(pulse, self._qubit_freq_excited)
return excited_pulse
def get_zero_sched(self):
"""Returns a schedule that performs only a measurement."""
zero_sched = Schedule()
zero_sched += self._measure
return zero_sched
def get_one_sched(self):
"""Returns a schedule that creates a |1> state from |0> by applying
a pi pulse of 0->1 transition and performs a measurement."""
one_sched = Schedule()
one_sched += Play(self.get_pi_pulse_ground(), self._drive_chan)
one_sched += self._measure << one_sched.duration
return one_sched
def get_two_sched(self):
"""Returns a schedule that creates a |2> state from |0> by applying
a pi pulse of 0->1 transition followed by applying a pi pulse
of 1->2 transition and performs a measurement."""
two_sched = Schedule()
two_sched += Play(self.get_pi_pulse_ground(), self._drive_chan)
two_sched += Play(self.get_pi_pulse_excited(), self._drive_chan)
two_sched += self._measure << two_sched.duration
return two_sched
@staticmethod
def _create_iq_plot(zero_data, one_data, two_data):
"""Helper function for plotting IQ plane for 0, 1, 2. Limits of plot given
as arguments."""
# zero data plotted in blue
plt.scatter(np.real(zero_data), np.imag(zero_data),
s=5, cmap='viridis', c='blue', alpha=0.5, label=r'$|0\rangle$')
# one data plotted in red
plt.scatter(np.real(one_data), np.imag(one_data),
s=5, cmap='viridis', c='red', alpha=0.5, label=r'$|1\rangle$')
# two data plotted in green
plt.scatter(np.real(two_data), np.imag(two_data),
s=5, cmap='viridis', c='green', alpha=0.5, label=r'$|2\rangle$')
x_min = np.min(np.append(np.real(zero_data), np.append(np.real(one_data),
np.real(two_data))))-5
x_max = np.max(np.append(np.real(zero_data), np.append(np.real(one_data),
np.real(two_data))))+5
y_min = np.min(np.append(np.imag(zero_data), np.append(np.imag(one_data),
np.imag(two_data))))-5
y_max = np.max(np.append(np.imag(zero_data), np.append(np.imag(one_data),
np.imag(two_data))))+5
# Plot a large dot for the average result of the 0, 1 and 2 states.
mean_zero = np.mean(zero_data) # takes mean of both real and imaginary parts
mean_one = np.mean(one_data)
mean_two = np.mean(two_data)
plt.scatter(np.real(mean_zero), np.imag(mean_zero),
s=200, cmap='viridis', c='black', alpha=1.0)
plt.scatter(np.real(mean_one), np.imag(mean_one),
s=200, cmap='viridis', c='black', alpha=1.0)
plt.scatter(np.real(mean_two), np.imag(mean_two),
s=200, cmap='viridis', c='black', alpha=1.0)
# plt.xlim(x_min, x_max)
# plt.ylim(y_min, y_max)
plt.legend()
plt.ylabel('I [a.u.]', fontsize=15)
plt.xlabel('Q [a.u.]', fontsize=15)
plt.title("0-1-2 discrimination", fontsize=15)
return x_min, x_max, y_min, y_max
@staticmethod
def reshape_complex_vec(vec):
"""Take in complex vector vec and return 2d array w/ real, imag entries.
This is needed for the learning.
Args:
vec (list): complex vector of data
Returns:
list: vector w/ entries given by (real(vec], imag(vec))
"""
length = len(vec)
vec_reshaped = np.zeros((length, 2))
for i, item in enumerate(vec):
vec_reshaped[i] = [np.real(item), np.imag(item)]
return vec_reshaped
def find_three_level_discriminator(self, verbose=False, visual=False):
"""Returns a discriminator for discriminating 0-1-2 states."""
# pylint: disable=too-many-locals
zero_sched = self.get_zero_sched()
one_sched = self.get_one_sched()
two_sched = self.get_two_sched()
iq_job = execute([zero_sched, one_sched, two_sched], backend=self._backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{self._drive_chan: self._qubit_freq_ground}]*3
)
jid = iq_job.job_id()
if verbose:
print('Job Id : ', jid)
# job_monitor(iq_job)
iq_job = self._backend.retrieve_job(jid)
iq_data = self.get_job_data(iq_job, average=False)
zero_data = iq_data[0]
one_data = iq_data[1]
two_data = iq_data[2]
if visual:
print("The discriminator plot for 0-1-2 discrimination.")
x_min, x_max, y_min, y_max = self._create_iq_plot(zero_data, one_data, two_data)
# Create IQ vector (split real, imag parts)
zero_data_reshaped = self.reshape_complex_vec(zero_data)
one_data_reshaped = self.reshape_complex_vec(one_data)
two_data_reshaped = self.reshape_complex_vec(two_data)
iq_data = np.concatenate((zero_data_reshaped, one_data_reshaped, two_data_reshaped))
# construct vector w/ 0's, 1's and 2's (for testing)
state_012 = np.zeros(1024) # shots gives number of experiments
state_012 = np.concatenate((state_012, np.ones(1024)))
state_012 = np.concatenate((state_012, 2*np.ones(1024)))
# Shuffle and split data into training and test sets
iq_012_train, iq_012_test, state_012_train, state_012_test = train_test_split(iq_data,
state_012,
test_size=0.5)
classifier_lda_012 = LinearDiscriminantAnalysis()
classifier_lda_012.fit(iq_012_train, state_012_train)
score_012 = classifier_lda_012.score(iq_012_test, state_012_test)
if verbose:
print('The accuracy score of the discriminator is: ', score_012)
self._state_discriminator_012 = classifier_lda_012
if visual:
self._separatrix_plot(classifier_lda_012, x_min, x_max, y_min, y_max, 1024)
return self._state_discriminator_012
@staticmethod
def _separatrix_plot(lda, x_min, x_max, y_min, y_max, shots):
"""Returns a sepratrix plot for the classifier."""
# pylint: disable=too-many-arguments
num_x, num_y = shots, shots
xvals, vals = np.meshgrid(np.linspace(x_min, x_max, num_x),
np.linspace(y_min, y_max, num_y))
predict_prob = lda.predict_proba(np.c_[xvals.ravel(), vals.ravel()])
predict_prob = predict_prob[:, 1].reshape(xvals.shape)
plt.contour(xvals, vals, predict_prob, [0.5], linewidths=2., colors='black')
def get_qubit_freq_ground(self):
"""Returns the set 0->1 transition frequency."""
return self._qubit_freq_ground
def get_qubit_freq_excited(self):
"""Returns the set 1->2 transition frequency."""
return self._qubit_freq_excited
def get_pi_amp_ground(self):
"""Returns the set 0->1 transition pi pulse amplitude."""
return self._pi_amp_ground
def get_pi_amp_excited(self):
"""Returns the set 1->2 transition pi pulse amplitude."""
return self._pi_amp_excited
def get_three_level_discriminator(self):
"""Returns the set 0-1-2 state discriminator."""
return self._state_discriminator_012
def calibrate_all(self, verbose=False, visual=False):
"""Calibrates and sets both the ground and excited transition frequencies and
corresponding pi pulse amplitudes. Also constructs a 0-1-2 state discriminator."""
ground_freq = self.find_freq_ground(verbose, visual)
ground_amp = self.find_pi_amp_ground(verbose, visual)
excited_freq = self.find_freq_excited(verbose, visual)
excited_amp = self.find_pi_amp_excited(verbose, visual)
state_discriminator = self.find_three_level_discriminator(verbose, visual)
return ground_freq, ground_amp, excited_freq, excited_amp, state_discriminator
anharmon = backend.properties().qubit_property(qubit)['anharmonicity'][0]
qu_freq = backend.properties().qubit_property(qubit)['frequency'][0]
print(qu_freq)
print(anharmon)
print(qu_freq+anharmon)
# backend = provider.get_backend('ibmq_casablanca')
# backend = provider.get_backend('ibmq_jakarta')
backend = provider.get_backend('ibmq_bogota')
# backend = provider.get_backend('ibmq_rome')
qubit = 0
cal_object = PulseCalibration(backend, qubit)
visual = True
verbose = True
ground_freq_list = cal_object.find_freq_ground(verbose, visual)
[ground_freq, freq_list, sweep_vals] = ground_freq_list
print(ground_freq)
ground_amp_list = cal_object.find_pi_amp_ground(verbose, visual)
pi_amp_ground = ground_amp_list[0]
amp_list = ground_amp_list[1]
rabi_values = ground_amp_list[2]
print(ground_freq)
print(pi_amp_ground)
excited_list = cal_object.find_freq_excited(verbose, visual)
excited_freq = excited_list[0]
excited_freq_list = excited_list[1]
excited_sweep_data = excited_list[2]
excited_freq_list_GHz = excited_freq_list/1e+9
excited_freq
pi_amp_excited_list = cal_object.find_pi_amp_excited(verbose, visual)
[excited_amp, amp_list, rabi_data] = pi_amp_excited_list
pi_amp_excited = excited_amp
pi_amp_excited
print(ground_freq)
print(pi_amp_ground)
print(excited_freq)
print(pi_amp_excited)
discrim = cal_object.find_three_level_discriminator(verbose, visual)
def create_iq_plot(zero_data, one_data, two_data):
"""Helper function for plotting IQ plane for 0, 1, 2. Limits of plot given
as arguments."""
# zero data plotted in blue
plt.scatter(np.real(zero_data), np.imag(zero_data),
s=5, cmap='viridis', c='blue', alpha=0.5, label=r'$|0\rangle$')
# one data plotted in red
plt.scatter(np.real(one_data), np.imag(one_data),
s=5, cmap='viridis', c='red', alpha=0.5, label=r'$|1\rangle$')
# two data plotted in green
plt.scatter(np.real(two_data), np.imag(two_data),
s=5, cmap='viridis', c='green', alpha=0.5, label=r'$|2\rangle$')
x_min = np.min(np.append(np.real(zero_data), np.append(np.real(one_data),
np.real(two_data))))-5
x_max = np.max(np.append(np.real(zero_data), np.append(np.real(one_data),
np.real(two_data))))+5
y_min = np.min(np.append(np.imag(zero_data), np.append(np.imag(one_data),
np.imag(two_data))))-5
y_max = np.max(np.append(np.imag(zero_data), np.append(np.imag(one_data),
np.imag(two_data))))+5
# Plot a large dot for the average result of the 0, 1 and 2 states.
mean_zero = np.mean(zero_data) # takes mean of both real and imaginary parts
mean_one = np.mean(one_data)
mean_two = np.mean(two_data)
plt.scatter(np.real(mean_zero), np.imag(mean_zero),
s=200, cmap='viridis', c='black', alpha=1.0)
plt.scatter(np.real(mean_one), np.imag(mean_one),
s=200, cmap='viridis', c='black', alpha=1.0)
plt.scatter(np.real(mean_two), np.imag(mean_two),
s=200, cmap='viridis', c='black', alpha=1.0)
# plt.xlim(x_min, x_max)
# plt.ylim(y_min, y_max)
plt.legend()
plt.ylabel('I [a.u.]', fontsize=15)
plt.xlabel('Q [a.u.]', fontsize=15)
plt.title("0-1-2 discrimination", fontsize=15)
return x_min, x_max, y_min, y_max
def reshape_complex_vec(vec):
"""Take in complex vector vec and return 2d array w/ real, imag entries.
This is needed for the learning.
Args:
vec (list): complex vector of data
Returns:
list: vector w/ entries given by (real(vec], imag(vec))
"""
length = len(vec)
vec_reshaped = np.zeros((length, 2))
for i, item in enumerate(vec):
vec_reshaped[i] = [np.real(item), np.imag(item)]
return vec_reshaped
def separatrix_plot(lda, x_min, x_max, y_min, y_max, shots):
"""Returns a sepratrix plot for the classifier."""
# pylint: disable=too-many-arguments
num_x, num_y = shots, shots
xvals, vals = np.meshgrid(np.linspace(x_min-4, x_max+4, num_x),
np.linspace(y_min-4, y_max+4, num_y))
predict_prob = lda.predict_proba(np.c_[xvals.ravel(), vals.ravel()])
predict_prob = predict_prob[:, 1].reshape(xvals.shape)
plt.contour(xvals, vals, predict_prob, [0.5], linewidths=2., colors='black')
def get_job_data(job, average):
"""Retrieve data from a job that has already run.
Args:
job (Job): The job whose data you want.
average (bool): If True, gets the data assuming data is an average.
If False, gets the data assuming it is for single shots.
Return:
list: List containing job result data.
"""
scale_factor = 1e-14
job_results = job.result(timeout=120) # timeout parameter set to 120 s
result_data = []
for i in range(len(job_results.results)):
if average: # get avg data
result_data.append(job_results.get_memory(i)[qubit]*scale_factor)
else: # get single data
result_data.append(job_results.get_memory(i)[:, qubit]*scale_factor)
return result_data
iq_job = backend.retrieve_job('60b500cf5255f0280438b583')
iq_data = get_job_data(iq_job, average=False)
zero_data = iq_data[0]
one_data = iq_data[1]
two_data = iq_data[2]
if visual:
print("The discriminator plot for 0-1-2 discrimination.")
x_min, x_max, y_min, y_max = create_iq_plot(zero_data, one_data, two_data)
newcalobject = PulseCalibration(backend, qubit)
output_list = newcalobject.calibrate_all(verbose, visual)
[new_ground_freq, new_pi_amp_ground, new_excited_freq, new_pi_amp_excited, new_discrim] = output_list
print(new_ground_freq[0])
print(new_pi_amp_ground[0])
print(new_excited_freq[0])
print(new_pi_amp_excited[0])
back_config = backend.configuration()
back_defaults = backend.defaults()
inst_sched_map = back_defaults.instruction_schedule_map
meas_map_idx = None
for i, measure_group in enumerate(back_config.meas_map):
if qubit in measure_group:
meas_map_idx = i
break
assert meas_map_idx is not None, f"Couldn't find qubit {qubit} in the meas_map!"
# The measurement pulse for measuring the qubit of interest.
measure = inst_sched_map.get('measure', qubits=back_config.meas_map[meas_map_idx])
# Should be getting |2> ideally.
sigma = 40
duration = 4*40
chan = DriveChannel(0)
with pulse.build(backend) as test_0:
pulse.set_frequency(ground_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground), chan)
pulse.set_frequency(excited_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_excited), chan)
test_0 += measure << test_0.duration
test_0.draw()
test0_job = execute(test_0, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test0 = test0_job.job_id()
print(jid_test0)
test0_job = backend.retrieve_job(jid_test0)
res = get_job_data(test0_job, average=False)
res[0]
reshaped_res = reshape_complex_vec(res[0])
plt.scatter(np.real(res[0]), np.imag(res[0]))
plt.show()
output = discrim.predict(reshaped_res)
arr = [0,0,0]
for i in output:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a 0-1 pi pulse.
# Should be ideally getting |1>
with pulse.build(backend) as test_00:
pulse.set_frequency(ground_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground), chan)
test_00 += measure << test_00.duration
test_00.draw()
test00_job = execute(test_00, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test00 = test00_job.job_id()
print(jid_test00)
test00_job = backend.retrieve_job(jid_test00)
res00 = get_job_data(test00_job, average=False)
res00[0]
reshaped_res00 = reshape_complex_vec(res00[0])
plt.scatter(np.real(res00[0]), np.imag(res00[0]))
plt.show()
output00 = discrim.predict(reshaped_res00)
arr = [0,0,0]
for i in output00:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a H then Z then H gate on 0-1
# Should get |1> ideally.
chan = DriveChannel(0)
with pulse.build(backend) as test_pulse_1:
# Setting 0-1 frequency for channel and applying H gate
pulse.set_frequency(ground_freq, chan)
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
# Applying a Z pulse
pulse.shift_phase(np.pi, chan)
# Applying H gate on 0-1
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
test_pulse_1 += measure << test_pulse_1.duration
test_pulse_1.draw()
test1_job = execute(test_pulse_1, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test1 = test1_job.job_id()
print(jid_test1)
test1_job = backend.retrieve_job(jid_test1)
res1 = get_job_data(test1_job, average=False)
reshaped_res1 = reshape_complex_vec(res1[0])
plt.scatter(np.real(res1[0]), np.imag(res1[0]))
plt.show()
output1 = discrim.predict(reshaped_res1)
arr = [0,0,0]
for i in output1:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a H then Z then H gate on 1-2
# Should get |2> ideally.
chan = DriveChannel(0)
with pulse.build(backend) as test_pulse_2:
# Exciting the qubit to |1> state
pulse.set_frequency(ground_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground, name='X(pi)'), chan)
# Setting 1-2 frequency for channel and applying H gate
pulse.set_frequency(excited_freq, chan)
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_excited/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
# Applying a Z pulse
pulse.shift_phase(np.pi, chan)
# Applying H gate on 1-2
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_excited/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
test_pulse_2 += measure << test_pulse_2.duration
test_pulse_2.draw()
test2_job = execute(test_pulse_2, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test2 = test2_job.job_id()
print(jid_test2)
test2_job = backend.retrieve_job(jid_test2)
res2 = get_job_data(test2_job, average=False)
reshaped_res2 = reshape_complex_vec(res2[0])
plt.scatter(np.real(res2[0]), np.imag(res2[0]))
plt.show()
output2 = discrim.predict(reshaped_res2)
arr = [0,0,0]
for i in output2:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a H on 0-1, then H on 1-2
# then Z on 1-2 followed by H on 1-2
# Should get |0>/sqrt(2) + |2>/sqrt(2)
chan = DriveChannel(0)
with pulse.build(backend) as test_pulse_3:
# Setting 0-1 frequency for channel and applying H gate
pulse.set_frequency(ground_freq, chan)
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
# Undoing phase appied during 0-1 transitions
pulse.shift_phase(np.pi, chan)
# Setting 1-2 frequency for channel and applying H gate
pulse.set_frequency(excited_freq, chan)
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_excited/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
# Applying a Z pulse
pulse.shift_phase(np.pi, chan)
# Applying H gate on 1-2
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_excited/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
test_pulse_3 += measure << test_pulse_3.duration
test_pulse_3.draw()
test3_job = execute(test_pulse_3, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test3 = test3_job.job_id()
print(jid_test3)
test3_job = backend.retrieve_job(jid_test3)
res3 = get_job_data(test3_job, average=False)
reshaped_res3 = reshape_complex_vec(res3[0])
plt.scatter(np.real(res3[0]), np.imag(res3[0]))
plt.show()
output3 = discrim.predict(reshaped_res3)
arr = [0,0,0]
for i in output3:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a H on 1-2
# Should get |1>/sqrt(2) + |2>/sqrt(2) ideally.
chan = DriveChannel(0)
with pulse.build(backend) as test_pulse_4:
# Exciting the qubit to |1> state
pulse.set_frequency(ground_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground, name='X(pi)'), chan)
# Setting 1-2 frequency for channel and applying H gate
pulse.set_frequency(excited_freq, chan)
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_excited/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
test_pulse_4 += measure << test_pulse_4.duration
test_pulse_4.draw()
test4_job = execute(test_pulse_4, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test4 = test4_job.job_id()
print(jid_test4)
test4_job = backend.retrieve_job(jid_test4)
res4 = get_job_data(test4_job, average=False)
reshaped_res4 = reshape_complex_vec(res4[0])
plt.scatter(np.real(res4[0]), np.imag(res4[0]))
plt.show()
output4 = discrim.predict(reshaped_res4)
arr = [0,0,0]
for i in output4:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a H on 0-1
# Should get |0>/sqrt(2) + |1>/sqrt(2) ideally.
chan = DriveChannel(0)
with pulse.build(backend) as test_pulse_5:
# Setting 0-1 frequency for channel and applying H gate
pulse.set_frequency(ground_freq, chan)
pulse.shift_phase(-np.pi/2, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground/2, name='X(pi/2)'), chan)
pulse.shift_phase(-np.pi/2, chan)
test_pulse_5 += measure << test_pulse_5.duration
test_pulse_5.draw()
test5_job = execute(test_pulse_5, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test5 = test5_job.job_id()
print(jid_test5)
test5_job = backend.retrieve_job(jid_test5)
res5 = get_job_data(test5_job, average=False)
reshaped_res5 = reshape_complex_vec(res5[0])
plt.scatter(np.real(res5[0]), np.imag(res5[0]))
plt.show()
output5 = discrim.predict(reshaped_res5)
arr = [0,0,0]
for i in output5:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a X on 0-1
# Should get |1> ideally.
chan = DriveChannel(0)
with pulse.build(backend) as test_pulse_6:
# Setting 0-1 frequency for channel and applying X gate
pulse.set_frequency(ground_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground, name='X(pi)'), chan)
test_pulse_6 += measure << test_pulse_6.duration
test_pulse_6.draw()
test6_job = execute(test_pulse_6, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test6 = test6_job.job_id()
print(jid_test6)
test6_job = backend.retrieve_job(jid_test6)
res6 = get_job_data(test6_job, average=False)
reshaped_res6 = reshape_complex_vec(res6[0])
plt.scatter(np.real(res6[0]), np.imag(res6[0]))
plt.show()
output6 = discrim.predict(reshaped_res6)
arr = [0,0,0]
for i in output6:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
# Performing a X on 1-2
# Should get |2> ideally.
chan = DriveChannel(0)
with pulse.build(backend) as test_pulse_7:
# Setting 0-1 frequency for channel and applying 0-1 pi pulse
pulse.set_frequency(ground_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_ground, name='X(pi)'), chan)
# Setting 1-2 frequency for channel and applying 1-2 pi pulse
pulse.set_frequency(excited_freq, chan)
pulse.play(Gaussian(duration=duration, sigma=sigma, amp=pi_amp_excited, name='X(pi)'), chan)
test_pulse_7 += measure << test_pulse_7.duration
test_pulse_7.draw()
test7_job = execute(test_pulse_7, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_test7 = test7_job.job_id()
print(jid_test7)
test7_job = backend.retrieve_job(jid_test7)
res7 = get_job_data(test7_job, average=False)
reshaped_res7 = reshape_complex_vec(res7[0])
plt.scatter(np.real(res7[0]), np.imag(res7[0]))
plt.show()
output7 = discrim.predict(reshaped_res7)
arr = [0,0,0]
for i in output7:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
back_config = backend.configuration()
print("Supported kernels: ", back_config.meas_kernels)
print("Supported discriminators: ", back_config.discriminators)
qc = QuantumCircuit(2)
qc.cx(0,1)
with pulse.build(backend) as cnot_pulse:
pulse.call(qc)
cnot_pulse += measure << cnot_pulse.duration
cnot_pulse.draw()
cnot_job = execute(cnot_pulse, backend=backend,
meas_level=1, meas_return='single', shots=1024,
schedule_los=[{chan: ground_freq}]
)
jid_cnot = cnot_job.job_id()
print(jid_cnot)
cnot_job = backend.retrieve_job(jid_cnot)
cnot_job.result().to_dict()
cnot_res = get_job_data(cnot_job, average=False)
reshaped_cnot_res = reshape_complex_vec(cnot_res[0])
plt.scatter(np.real(cnot_res[0]), np.imag(cnot_res[0]))
plt.show()
cnot_output = discrim.predict(reshaped_cnot_res)
arr = [0,0,0]
for i in cnot_output:
if i==0:
arr[0]+=1
elif i==1:
arr[1]+=1
else:
arr[2]+=1
print(arr)
qc = QuantumCircuit(1)
qc.y(0)
with pulse.build(backend) as ypulse:
pulse.call(qc)
ypulse += measure << ypulse.duration
ypulse.draw()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.