repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/ashishpatel26/IBM-Quantum-Challenge-Africa-2021
|
ashishpatel26
|
from qiskit import *
import numpy as np
from numpy import linalg as la
from qiskit.tools.monitor import job_monitor
import qiskit.tools.jupyter
qc = QuantumCircuit(1)
#### your code goes here
# z measurement of qubit 0
measure_z = QuantumCircuit(1,1)
measure_z.measure(0,0)
# x measurement of qubit 0
measure_x = QuantumCircuit(1,1)
# your code goes here
# y measurement of qubit 0
measure_y = QuantumCircuit(1,1)
# your code goes here
shots = 2**14 # number of samples used for statistics
sim = Aer.get_backend('qasm_simulator')
bloch_vector_measure = []
for measure_circuit in [measure_x, measure_y, measure_z]:
# run the circuit with a the selected measurement and get the number of samples that output each bit value
counts = execute(qc+measure_circuit, sim, shots=shots).result().get_counts()
# calculate the probabilities for each bit value
probs = {}
for output in ['0','1']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
bloch_vector_measure.append( probs['0'] - probs['1'] )
# normalizing the bloch sphere vector
bloch_vector = bloch_vector_measure/la.norm(bloch_vector_measure)
print('The bloch sphere coordinates are [{0:4.3f}, {1:4.3f}, {2:4.3f}]'
.format(*bloch_vector))
from kaleidoscope.interactive import bloch_sphere
bloch_sphere(bloch_vector, vectors_annotation=True)
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector( bloch_vector )
# circuit for the state Tri1
Tri1 = QuantumCircuit(2)
# your code goes here
# circuit for the state Tri2
Tri2 = QuantumCircuit(2)
# your code goes here
# circuit for the state Tri3
Tri3 = QuantumCircuit(2)
# your code goes here
# circuit for the state Sing
Sing = QuantumCircuit(2)
# your code goes here
# <ZZ>
measure_ZZ = QuantumCircuit(2)
measure_ZZ.measure_all()
# <XX>
measure_XX = QuantumCircuit(2)
# your code goes here
# <YY>
measure_YY = QuantumCircuit(2)
# your code goes here
shots = 2**14 # number of samples used for statistics
A = 1.47e-6 #unit of A is eV
E_sim = []
for state_init in [Tri1,Tri2,Tri3,Sing]:
Energy_meas = []
for measure_circuit in [measure_XX, measure_YY, measure_ZZ]:
# run the circuit with a the selected measurement and get the number of samples that output each bit value
qc = state_init+measure_circuit
counts = execute(qc, sim, shots=shots).result().get_counts()
# calculate the probabilities for each computational basis
probs = {}
for output in ['00','01', '10', '11']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
Energy_meas.append( probs['00'] - probs['01'] - probs['10'] + probs['11'] )
E_sim.append(A * np.sum(np.array(Energy_meas)))
# Run this cell to print out your results
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E_sim[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E_sim[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E_sim[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E_sim[3]))
# reduced plank constant in (eV) and the speed of light(cgs units)
hbar, c = 4.1357e-15, 3e10
# energy difference between the triplets and singlet
E_del = abs(E_sim[0] - E_sim[3])
# frequency associated with the energy difference
f = E_del/hbar
# convert frequency to wavelength in (cm)
wavelength = c/f
print('The wavelength of the radiation from the transition\
in the hyperfine structure is : {:.1f} cm'.format(wavelength))
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_athens')
# run this cell to get the backend information through the widget
backend
# assign your choice for the initial layout to the list variable `initial_layout`.
initial_layout =
qc_all = [state_init+measure_circuit for state_init in [Tri1,Tri2,Tri3,Sing]
for measure_circuit in [measure_XX, measure_YY, measure_ZZ] ]
shots = 8192
job = execute(qc_all, backend, initial_layout=initial_layout, optimization_level=3, shots=shots)
print(job.job_id())
job_monitor(job)
# getting the results of your job
results = job.result()
## To access the results of the completed job
#results = backend.retrieve_job('job_id').result()
def Energy(results, shots):
"""Compute the energy levels of the hydrogen ground state.
Parameters:
results (obj): results, results from executing the circuits for measuring a hamiltonian.
shots (int): shots, number of shots used for the circuit execution.
Returns:
Energy (list): energy values of the four different hydrogen ground states
"""
E = []
A = 1.47e-6
for ind_state in range(4):
Energy_meas = []
for ind_comp in range(3):
counts = results.get_counts(ind_state*3+ind_comp)
# calculate the probabilities for each computational basis
probs = {}
for output in ['00','01', '10', '11']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
Energy_meas.append( probs['00'] - probs['01'] - probs['10'] + probs['11'] )
E.append(A * np.sum(np.array(Energy_meas)))
return E
E = Energy(results, shots)
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E[3]))
from qiskit.ignis.mitigation.measurement import *
# your code to create the circuits, meas_calibs, goes here
meas_calibs, state_labels =
# execute meas_calibs on your choice of the backend
job = execute(meas_calibs, backend, shots = shots)
print(job.job_id())
job_monitor(job)
cal_results = job.result()
## To access the results of the completed job
#cal_results = backend.retrieve_job('job_id').result()
# your code to obtain the measurement filter object, 'meas_filter', goes here
results_new = meas_filter.apply(results)
E_new = Energy(results_new, shots)
print('Energy expection value of the state Tri1 : {:.3e} eV'.format(E_new[0]))
print('Energy expection value of the state Tri2 : {:.3e} eV'.format(E_new[1]))
print('Energy expection value of the state Tri3 : {:.3e} eV'.format(E_new[2]))
print('Energy expection value of the state Sing : {:.3e} eV'.format(E_new[3]))
# results for the energy estimation from the simulation,
# execution on a quantum system without error mitigation and
# with error mitigation in numpy array format
Energy_exact, Energy_exp_orig, Energy_exp_new = np.array(E_sim), np.array(E), np.array(E_new)
# Calculate the relative errors of the energy values without error mitigation
# and assign to the numpy array variable `Err_rel_orig` of size 4
Err_rel_orig =
# Calculate the relative errors of the energy values with error mitigation
# and assign to the numpy array variable `Err_rel_new` of size 4
Err_rel_new =
np.set_printoptions(precision=3)
print('The relative errors of the energy values for four bell basis\
without measurement error mitigation : {}'.format(Err_rel_orig))
np.set_printoptions(precision=3)
print('The relative errors of the energy values for four bell basis\
with measurement error mitigation : {}'.format(Err_rel_new))
|
https://github.com/lockwo/Paper-Review
|
lockwo
|
from qiskit.providers.ibmq.runtime import UserMessenger
from qiskit import Aer, IBMQ
import numpy as np
from runtime_test import main
import matplotlib.pyplot as plt
provider = IBMQ.load_account()
provider = IBMQ.get_provider(group='deployed')
def interim_result_callback(job_id, interim_result):
print(interim_result)
import uuid
meta = {
"name": #"grad_paper-{}".format(uuid.uuid4()),
"grad_paper-lima",
"description": "A sample gradient program.",
"max_execution_time": 10000,
}
meta["parameters"] = [
{"name": "shots", "description": "Number of shots", "type": "int", "required": True},
{"name": "init_point", "description": "Initial parameters", "type": "ndarray", "required": True},
]
meta['return_values'] = [
{"name": "result", "description": "Final result in list.", "type": "list"}
]
meta["interim_results"] = [
{"name": "vals", "description": "Iteration, value at current optimization step", "type": "list"},
]
#backend = provider.backend.ibmq_qasm_simulator
backend = provider.backend.ibmq_lima
#backend = provider.backend.ibmq_manila
options = {'backend_name': backend.name()}
program_id = provider.runtime.upload_program(data='runtime_test.py', metadata=meta)
initial_point = np.random.uniform(0, 2 * np.pi, 5)
inputs = {}
inputs['init_point'] = initial_point
shots = [10, 100, 1000]
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.tight_layout()
for s in shots:
print(s)
inputs['shots'] = s
job = provider.runtime.run(program_id, options=options, inputs=inputs, callback=interim_result_callback)
gd_loss, x_values = job.result()
cir_evals = np.array([i for i in range(len(gd_loss))])
cir_evals *= (2 * len(initial_point) * s)
ax1.plot(cir_evals, gd_loss, label='Shots %d'%s)
ax2.plot(x_values[:,0], x_values[:,1], label='Shots %d'%s)
# Make the graph look nice
#ax1.axhline(-1, ls='--', c='tab:red', label='Target')
ax1.set_ylabel('Cost')
ax1.set_xlabel('Circuit Evaluations')
ax1.set_xscale('log')
ax1.legend()
ax2.set_ylim(0, np.pi)
ax2.set_xlim(-np.pi/2, np.pi/2)
ax2.set_ylabel('Theta 2')
ax2.set_xlabel('Theta 1')
#ax2.legend()
plt.show()
|
https://github.com/lockwo/Paper-Review
|
lockwo
|
import numpy as np
from qiskit import Aer, IBMQ
from qiskit.utils import QuantumInstance
from qiskit.circuit import QuantumCircuit, ParameterVector
from qiskit.opflow import StateFn, Z, I, CircuitSampler, Gradient, Hessian
from qiskit.algorithms.optimizers import GradientDescent
import matplotlib.pyplot as plt
# Code to generate a circuit as present in the paper
def paper_circuit():
circuit = QuantumCircuit(5)
params = ParameterVector("theta", length=5)
for i in range(5):
circuit.rx(params[i], i)
circuit.cx(0, 1)
circuit.cx(2, 1)
circuit.cx(3, 1)
circuit.cx(4, 3)
hamiltonian = I
for i in range(1, 5):
if i == 3:
hamiltonian = hamiltonian ^ Z
else:
hamiltonian = hamiltonian ^ I
readout_operator = StateFn(hamiltonian, is_measurement=True) @ StateFn(circuit)
return circuit, readout_operator
print(paper_circuit()[0])
def evaluate_expectation(x):
value_dict = dict(zip(circuit.parameters, x))
result = sampler.convert(op, params=value_dict).eval()
return np.real(result)
def evaluate_gradient(x):
value_dict = dict(zip(circuit.parameters, x))
result = sampler.convert(gradient, params=value_dict).eval()
return np.real(result)
def gd_callback(nfevs, x, fx, stepsize):
#if nfevs % 10 == 0:
# print(nfevs, fx)
#print(nfevs, fx)
gd_loss.append(fx)
x_values.append([x[0], x[1]])
simulate = True
provider = IBMQ.load_account()
if simulate:
backend = Aer.get_backend('aer_simulator')
else:
backend = provider.backends(name='ibmq_belem')[0]
initial_point = np.random.uniform(0, 2 * np.pi, 5)
shots = [10, 100, 1000]
fig, (ax1, ax2) = plt.subplots(1, 2)
fig.tight_layout()
for s in shots:
# Create circuit
circuit, op = paper_circuit()
# Specify backend information
q_instance = QuantumInstance(backend, shots=s)
sampler = CircuitSampler(q_instance)
gradient = Gradient(grad_method='param_shift').convert(op)
gd_loss, x_values = [], []
# Create optimizer
gd = GradientDescent(maxiter=100, learning_rate=0.1, tol=1e-4, callback=gd_callback)
# Minimize function
gd.optimize(initial_point.size, evaluate_expectation, gradient_function=evaluate_gradient, initial_point=initial_point)
# Plotting information
cir_evals = np.array([i for i in range(len(gd_loss))])
cir_evals *= (2 * circuit.num_parameters * s)
ax1.plot(cir_evals, gd_loss, label='Shots %d'%s)
x_values.clear()
# Keeping track of just theta_0 and theta_1
gd.optimize(initial_point.size, evaluate_expectation, gradient_function=evaluate_gradient, \
initial_point=[0.1, 0.15, 0, 0, 0])
x_values = np.array(x_values)
ax2.plot(x_values[:,0], x_values[:,1], label='Shots %d'%s)
# Make the graph look nice
ax1.axhline(-1, ls='--', c='tab:red', label='Target')
ax1.set_ylabel('Cost')
ax1.set_xlabel('Circuit Evaluations')
ax1.set_xscale('log')
ax1.legend()
ax2.set_ylim(0, np.pi + 0.2)
ax2.set_xlim(-np.pi/2, np.pi/2)
ax2.set_ylabel('Theta 2')
ax2.set_xlabel('Theta 1')
#ax2.legend()
plt.show()
class NewtonOpt(object):
def __init__(self, hess, grad, num_param, circuit, sampler, op, init, lr=0.1, s=1000, maxiter=100):
self.lr = lr
self.shots = s
self.hess = hess
self.grad = grad
self.max_iter = maxiter
self.num_params = num_param
self.circuit = circuit
self.sampler = sampler
self.op = op
self.values = []
self.circuit_evals = []
self.init = init
def optimize(self):
x = self.init
for i in range(self.max_iter):
value_dict = dict(zip(self.circuit.parameters, x))
result = np.real(self.sampler.convert(self.op, params=value_dict).eval())
self.values.append(result)
value_dict = dict(zip(self.circuit.parameters, x))
hessian = np.real(self.sampler.convert(self.hess, params=value_dict).eval())
gradient = np.real(self.sampler.convert(self.grad, params=value_dict).eval())
x = x - self.lr * np.linalg.inv(hessian + np.eye(self.num_params)) @ gradient
#if i % 10 == 0:
# print(i, result)
return self.values, np.array([i for i in range(len(self.values))]) * \
((4 * self.num_params**2 - 3 * self.num_params) * self.shots)
# Generate circuit with only two parameters
def paper_circuit_two_param():
circuit = QuantumCircuit(5) # 5 qubit circuit
params = ParameterVector("theta", length=2)
for i in range(2):
circuit.rx(params[i], i)
circuit.cx(0, 1)
circuit.cx(2, 1)
circuit.cx(3, 1)
circuit.cx(4, 3)
hamiltonian = I
for i in range(1, 5):
if i == 3:
hamiltonian = hamiltonian ^ Z
else:
hamiltonian = hamiltonian ^ I
readout_operator = StateFn(hamiltonian, is_measurement=True) @ StateFn(circuit)
return circuit, readout_operator
initial_point = np.array([0.1, 0.15])
s = 1000
circuit, op = paper_circuit_two_param()
q_instance = QuantumInstance(backend, shots=s)
sampler = CircuitSampler(q_instance)
gradient = Gradient(grad_method='param_shift').convert(op)
hessian = Hessian(hess_method='param_shift').convert(op)
gd_loss = []
x_values = []
# GD minimization
gd = GradientDescent(maxiter=80, learning_rate=0.1, tol=1e-4, callback=gd_callback)
x_opt, fx_opt, nfevs = gd.optimize(initial_point.size, evaluate_expectation, gradient_function=evaluate_gradient, \
initial_point=initial_point)
cir_evals = np.array([i for i in range(len(gd_loss))])
cir_evals *= (2 * circuit.num_parameters * s)
# 2nd order mimization
newton = NewtonOpt(hessian, gradient, circuit.num_parameters, circuit, sampler, op, initial_point, maxiter=80)
loss, evals = newton.optimize()
plt.plot(evals, loss, label='Newton')
plt.plot(cir_evals, gd_loss, label='GD')
plt.axhline(-1, ls='--', c='tab:red', label='Target')
plt.ylabel('Cost')
plt.xlabel('Circuit Evaluations')
plt.legend()
plt.show()
#initial_point = np.random.uniform(0, 2 * np.pi, 5)
initial_point = np.array([0.1, 0.15, 0, 0, 0])
s = 1000
circuit, op = paper_circuit()
q_instance = QuantumInstance(backend, shots=s)
sampler = CircuitSampler(q_instance)
gradient = Gradient().convert(op)
hessian = Hessian(hess_method='param_shift').convert(op)
gd_loss = []
x_values = []
# GD minimization
gd = GradientDescent(maxiter=100, learning_rate=0.1, tol=1e-4, callback=gd_callback)
x_opt, fx_opt, nfevs = gd.optimize(initial_point.size, evaluate_expectation, gradient_function=evaluate_gradient, \
initial_point=initial_point)
cir_evals = np.array([i for i in range(len(gd_loss))])
cir_evals *= (2 * circuit.num_parameters * s)
# 2nd order mimization
newton = NewtonOpt(hessian, gradient, circuit.num_parameters, circuit, sampler, op, initial_point)
loss, evals = newton.optimize()
plt.plot(evals, loss, label='Newton')
plt.plot(cir_evals, gd_loss, label='GD')
plt.axhline(-1, ls='--', c='tab:red', label='Target')
plt.ylabel('Cost')
plt.xlabel('Circuit Evaluations')
plt.xscale('log')
plt.legend()
plt.show()
|
https://github.com/lockwo/Paper-Review
|
lockwo
|
import numpy as np
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.circuit import QuantumCircuit, ParameterVector
from qiskit.opflow import StateFn, Z, I, CircuitSampler, Gradient
from qiskit.algorithms.optimizers import GradientDescent
from qiskit.providers.aer import QasmSimulator
from qiskit.test.mock import FakeBogota
from qiskit.providers.aer.noise import NoiseModel
def main(backend, user_message, shots, init_point):
def paper_circuit():
circuit = QuantumCircuit(5)
params = ParameterVector("theta", length=5)
for i in range(5):
circuit.rx(params[i], i)
circuit.cx(0, 1)
circuit.cx(2, 1)
circuit.cx(3, 1)
circuit.cx(4, 3)
hamiltonian = I
for i in range(1, 5):
if i == 3:
hamiltonian = hamiltonian ^ Z
else:
hamiltonian = hamiltonian ^ I
readout_operator = StateFn(hamiltonian, is_measurement=True) @ StateFn(circuit)
return circuit, readout_operator
def evaluate_expectation(x):
value_dict = dict(zip(circuit.parameters, x))
result = sampler.convert(op, params=value_dict).eval()
return np.real(result)
def evaluate_gradient(x):
value_dict = dict(zip(circuit.parameters, x))
result = sampler.convert(gradient, params=value_dict).eval()
return np.real(result)
def gd_callback(nfevs, x, fx, stepsize):
if nfevs % 10 == 0:
user_message.publish([nfevs, fx])
gd_loss.append(fx)
x_values.append([x[0], x[1]])
circuit, op = paper_circuit()
device_backend = FakeBogota()
backend = Aer.get_backend('aer_simulator')
device = QasmSimulator.from_backend(device_backend)
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
q_instance = QuantumInstance(backend=backend, coupling_map=coupling_map, noise_model=noise_model, shots=shots)
#q_instance = QuantumInstance(backend, shots=shots)
sampler = CircuitSampler(q_instance)
gradient = Gradient(grad_method='param_shift').convert(op)
gd_loss, x_values = [], []
gd = GradientDescent(maxiter=100, learning_rate=0.1, tol=1e-4, callback=gd_callback)
gd.optimize(init_point.size, evaluate_expectation, gradient_function=evaluate_gradient, \
initial_point=init_point)
x_values.clear()
gd_values = gd_loss.copy()
gd.optimize(init_point.size, evaluate_expectation, gradient_function=evaluate_gradient, \
initial_point=[0.1, 0.15, 0, 0, 0])
x_values = np.array(x_values)
return gd_values, x_values
|
https://github.com/lockwo/Paper-Review
|
lockwo
|
import numpy as np
from scipy.linalg import sqrtm
from qiskit import Aer
from qiskit.utils import QuantumInstance
from qiskit.quantum_info import state_fidelity, DensityMatrix
from qiskit.circuit import QuantumCircuit, ParameterVector
from qiskit.opflow import StateFn, I, X, Y, Z, CircuitSampler, Gradient, PauliExpectation
from qiskit.algorithms.optimizers import GradientDescent, ADAM, L_BFGS_B
from qiskit.providers.aer import AerSimulator, extensions, QasmSimulator
from qiskit.providers.aer.noise import depolarizing_error, amplitude_damping_error, phase_damping_error, NoiseModel
import matplotlib.pyplot as plt
def get_fidelity(s1, s2):
return state_fidelity(s1, s2)
pauli_y = np.array([[0, -1j], [1j, 0]])
krons = np.kron(pauli_y, pauli_y)
def get_concurrance(p):
p = np.array(p)
p_hat = np.matmul(np.matmul(krons, p.conj().T), krons)
try:
mat = sqrtm(np.matmul(np.matmul(sqrtm(p), p_hat), sqrtm(p)))
except:
return 0
eigs = np.linalg.eigvals(mat)
sorted_eigs = sorted(eigs, reverse=True)
return max(0, sorted_eigs[0] - sorted_eigs[1] - sorted_eigs[2] - sorted_eigs[3])
def get_density_matrix(circuit, params, noise_model=NoiseModel()):
c = circuit.bind_parameters(params)
c.save_density_matrix()
sim_noise = AerSimulator(noise_model=noise_model)
result = sim_noise.run(c).result()
density_matrix = result.data()['density_matrix']
return density_matrix
def make_circuit(version):
circuit = QuantumCircuit(2)
params = ParameterVector("theta", length=4 if version == 2 else 3)
circuit.ry(params[0], 0)
circuit.ry(params[1], 1)
circuit.cx(0, 1)
if version == 0:
circuit.ry(params[2], 0)
elif version == 1:
circuit.ry(params[2], 1)
elif version == 2:
circuit.ry(params[2], 0)
circuit.ry(params[3], 1)
return circuit
hamiltonian = (Z ^ Z) + (X ^ I) + (I ^ X)
print(hamiltonian)
noises = [phase_damping_error, amplitude_damping_error, depolarizing_error]
gammas = np.linspace(0, 1, 100)
backend = Aer.get_backend('qasm_simulator')
fig, axs = plt.subplots(3, 3, figsize=(16, 10))
for count, noise_type in enumerate(noises):
for ver in range(3):
print(count, ver)
energies = []
fidelities = []
concurrances = []
noiseless_solution = None
for g in gammas:
initial_point = np.random.uniform(0, 2 * np.pi, 4)
def evaluate_expectation(x):
value_dict = dict(zip(cir.parameters, x))
result = sampler.convert(op, params=value_dict).eval()
return np.real(result)
def evaluate_gradient(x):
value_dict = dict(zip(cir.parameters, x))
result = sampler.convert(gradient, params=value_dict).eval()
return np.real(result)
#print(noise_type, ver, g)
params = 4 if ver == 2 else 3
cir = make_circuit(ver)
noise_model = NoiseModel()
if g != 0:
if count == 2:
noise = noise_type(g, 2)
else:
noise = noise_type(g)
noise = noise.tensor(noise)
noise_model.add_all_qubit_quantum_error(noise, ['cx'])
q_instance = QuantumInstance(backend, noise_model=noise_model)
sampler = CircuitSampler(q_instance)
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(cir)
op = PauliExpectation().convert(expectation)
gradient = Gradient(grad_method='param_shift').convert(op)
#gd = GradientDescent(maxiter=100, learning_rate=0.05, tol=1e-4)
#gd = ADAM(maxiter=80, lr=0.05)
gd = L_BFGS_B()
point, value, nfev = gd.optimize(params, evaluate_expectation, gradient_function=evaluate_gradient, initial_point=initial_point[:params])
energies.append(value)
if g == 0 and noiseless_solution is None:
noiseless_solution = get_density_matrix(cir, point)
current_density_matrix = get_density_matrix(cir, point, noise_model)
fidelity = get_fidelity(noiseless_solution, current_density_matrix)
fidelities.append(fidelity)
concurrance = get_concurrance(current_density_matrix)
concurrances.append(concurrance)
axs[0, count].scatter(gammas, energies, label=str(ver))
axs[1, count].scatter(gammas, fidelities)
axs[2, count].scatter(gammas, concurrances)
axs[2, 0].set_xlabel("$\gamma$")
axs[2, 1].set_xlabel("$\gamma$")
axs[2, 2].set_xlabel("$\gamma$")
axs[0, 0].set_title('Phase damping')
axs[0, 1].set_title('Amplitude damping')
axs[0, 2].set_title('Depolarizing')
axs[0, 0].set_ylim(-2.3, -1.5)
axs[0, 1].set_ylim(-2.3, -1.5)
axs[0, 2].set_ylim(-2.2, 0)
axs[1, 0].set_ylim(0.5, 1)
axs[1, 1].set_ylim(0.5, 1)
axs[1, 2].set_ylim(0.2, 1)
axs[2, 0].set_ylim(0, 0.5)
axs[2, 1].set_ylim(0, 0.5)
axs[2, 2].set_ylim(0, 0.5)
axs[0, 0].legend()
axs[0, 0].set_ylabel("Energy")
axs[1, 0].set_ylabel("Fidelity")
axs[2, 0].set_ylabel("Concurrance")
plt.show()
def make_circuit_four():
circuit = QuantumCircuit(4)
params = ParameterVector("theta", length=8)
for i in range(4):
circuit.ry(params[i], i)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.cx(2, 3)
for i in range(4):
circuit.ry(params[i + 4], i)
return circuit
hamiltonian = (I ^ Z ^ I ^ Z) + 1/2 * ((I ^ I ^ X ^ X) + (I ^ I ^ Y ^ Y) + (X ^ X ^ I ^ I) + (Y ^ Y ^ I ^ I))
print(hamiltonian)
noises = [phase_damping_error, amplitude_damping_error, depolarizing_error]
noise_names = ["Phase Damping", "Amplitude Damping", "Depolarizing"]
gammas = np.linspace(0, 1, 50)
backend = Aer.get_backend('qasm_simulator')
fig, axs = plt.subplots(2, 1, figsize=(10, 10))
for count, noise_type in enumerate(noises):
energies = []
fidelities = []
noiseless_solution = None
for g in gammas:
initial_point = np.random.uniform(0, 2 * np.pi, 8)
def evaluate_expectation(x):
value_dict = dict(zip(cir.parameters, x))
result = sampler.convert(op, params=value_dict).eval()
return np.real(result)
def evaluate_gradient(x):
value_dict = dict(zip(cir.parameters, x))
result = sampler.convert(gradient, params=value_dict).eval()
return np.real(result)
#print(noise_type, g)
cir = make_circuit_four()
noise_model = NoiseModel()
if g != 0:
if count == 2:
noise = noise_type(g, 2)
else:
noise = noise_type(g)
noise = noise.tensor(noise)
noise_model.add_all_qubit_quantum_error(noise, ['cx'])
q_instance = QuantumInstance(backend, noise_model=noise_model)
sampler = CircuitSampler(q_instance)
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(cir)
op = PauliExpectation().convert(expectation)
gradient = Gradient(grad_method='param_shift').convert(op)
#gd = GradientDescent(maxiter=100, learning_rate=0.05, tol=1e-4)
#gd = ADAM(maxiter=80, lr=0.05)
gd = L_BFGS_B()
point, value, nfev = gd.optimize(8, evaluate_expectation, gradient_function=evaluate_gradient, initial_point=initial_point)
energies.append(value)
if g == 0 and noiseless_solution is None:
noiseless_solution = get_density_matrix(cir, point)
current_density_matrix = get_density_matrix(cir, point, noise_model)
fidelity = get_fidelity(noiseless_solution, current_density_matrix)
fidelities.append(fidelity)
axs[0].scatter(gammas, energies, label=noise_names[count])
axs[1].scatter(gammas, fidelities)
axs[1].set_xlabel("$\gamma$")
axs[0].set_ylim(-2.5, 0)
axs[1].set_ylim(0, 1)
axs[0].legend()
axs[0].set_ylabel("Energy")
axs[1].set_ylabel("Fidelity")
plt.show()
def make_circuit_one():
circuit = QuantumCircuit(1)
params = ParameterVector("theta", length=2)
circuit.ry(params[0], 0, label='first')
circuit.ry(params[1], 0)
return circuit
hamiltonian = Z
gamma = 0.4
backend = Aer.get_backend('qasm_simulator')
def evaluate_expectation(x):
value_dict = dict(zip(cir.parameters, x))
result = sampler.convert(op, params=value_dict).eval()
return np.real(result)
cir = make_circuit_one()
noise_model = NoiseModel()
#noise = depolarizing_error(gamma, 1)
noise = phase_damping_error(gamma)
noise_model.add_all_qubit_quantum_error(noise, ['first'])
q_instance = QuantumInstance(backend, noise_model=noise_model)
sampler = CircuitSampler(q_instance)
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(cir)
op = PauliExpectation().convert(expectation)
N = 30
xs = np.linspace(-np.pi, np.pi, N)
ys = np.linspace(-np.pi, np.pi, N)
zs = np.zeros(shape=(N, N))
for i in range(len(xs)):
#print(i)
for j in range(len(ys)):
zs[i][j] = evaluate_expectation([xs[i], ys[j]])
cir = make_circuit_one()
q_instance = QuantumInstance(backend)
sampler = CircuitSampler(q_instance)
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(cir)
op = PauliExpectation().convert(expectation)
xs = np.linspace(-np.pi, np.pi, N)
ys = np.linspace(-np.pi, np.pi, N)
zs1 = np.zeros(shape=(N, N))
for i in range(len(xs)):
#print(i)
for j in range(len(ys)):
zs1[i][j] = evaluate_expectation([xs[i], ys[j]])
# Label axes
fig, axs = plt.subplots(1, 2, figsize=(20, 10))
axs[1].contourf(xs, ys, zs, 10, cmap='YlGnBu')
#axs[1].contour(xs, ys, zs, 30, cmap='cool')
axs[1].set_title("Noisy")
axs[0].contourf(xs, ys, zs1, 10, cmap='YlGnBu')
#axs[0].contour(xs, ys, zs1, 30, cmap='cool')
axs[0].set_title("Noiseless")
plt.show()
def make_circuit_layers(l):
circuit = QuantumCircuit(4)
params = ParameterVector("theta", length=4 * l)
counter = 0
for i in range(l):
for j in range(4):
circuit.ry(params[counter], j)
counter += 1
circuit.cx(0, 1, label='first')
circuit.cx(2, 3)
circuit.cx(1, 2, label='second')
return circuit
noises = [phase_damping_error, amplitude_damping_error, depolarizing_error]
gammas = [0, 1e-3, 1e-2, 5 * 1e-2, 1e-1]
layers = [i for i in range(1, 7)]
backend = Aer.get_backend('qasm_simulator')
fig, axs = plt.subplots(2, 3, figsize=(10, 10))
target_state = np.random.uniform(0, 1, (1, 2**4)) + np.random.uniform(0, 1, (1, 2**4)) * 1j
target_state = target_state / np.linalg.norm(target_state)
target_dm = np.matmul(target_state.conj().T, target_state)
for count, noise_type in enumerate(noises):
for g in gammas:
reopts = []
non_reopts = []
for lay in layers:
initial_point = np.random.uniform(0, 2 * np.pi, lay * 4)
def evaluate_expectation_noiseless(x):
fid = get_fidelity(target_dm, get_density_matrix(cir, x))
return 1 - fid
def evaluate_expectation_noisy(x):
fid = get_fidelity(target_dm, get_density_matrix(cir, x, noise_model))
return 1 - fid
cir = make_circuit_layers(lay)
noise_model = NoiseModel()
no_noise = NoiseModel()
if g != 0:
if count == 2:
noise = noise_type(g, 2)
else:
noise = noise_type(g)
noise = noise.tensor(noise)
noise_model.add_all_qubit_quantum_error(noise, ['first', 'second'])
gd = L_BFGS_B()
point, value, nfev = gd.optimize(initial_point.size, evaluate_expectation_noiseless, initial_point=initial_point)
current_density_matrix = get_density_matrix(cir, point, noise_model)
fidelity = get_fidelity(target_dm, current_density_matrix)
non_reopts.append(fidelity)
gd = L_BFGS_B()
point, value, nfev = gd.optimize(initial_point.size, evaluate_expectation_noisy, initial_point=point)
current_density_matrix = get_density_matrix(cir, point, noise_model)
fidelity = get_fidelity(target_dm, current_density_matrix)
reopts.append(fidelity)
axs[0, count].plot(layers, reopts, label=str(g))
axs[0, count].scatter(layers, reopts)
axs[1, count].plot(layers, non_reopts)
axs[1, count].scatter(layers, non_reopts)
axs[1, 0].set_xlabel("Layers")
axs[1, 1].set_xlabel("Layers")
axs[1, 2].set_xlabel("Layers")
axs[0, 0].set_title('Phase damping')
axs[0, 1].set_title('Amplitude damping')
axs[0, 2].set_title('Depolarizing')
axs[0, 0].set_ylim(0.3, 1)
axs[0, 1].set_ylim(0.3, 1)
axs[0, 2].set_ylim(0.2, 1)
axs[1, 0].set_ylim(0.3, 1)
axs[1, 1].set_ylim(0.3, 1)
axs[1, 2].set_ylim(0.2, 1)
axs[0, 0].legend()
axs[0, 0].set_ylabel("Reoptimized Fidelity")
axs[1, 0].set_ylabel("Non-Reoptimized Fidelity")
plt.show()
from qiskit.tools.jupyter import *
%qiskit_version_table
|
https://github.com/lockwo/Paper-Review
|
lockwo
|
from qiskit import IBMQ, Aer, transpile, schedule as build_schedule
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes.calibration import RZXCalibrationBuilderNoEcho
from qiskit_nature.drivers import Molecule
from qiskit_nature.drivers.second_quantization import ElectronicStructureDriverType, ElectronicStructureMoleculeDriver
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
from qiskit_nature.operators.second_quantization import FermionicOp
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit_nature.algorithms import GroundStateEigensolver
from qiskit.algorithms import NumPyMinimumEigensolver, VQE
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit import QuantumCircuit, ParameterVector
from qiskit.utils import QuantumInstance
import matplotlib.pyplot as plt
import numpy as np
IBMQ.load_account()
provider = IBMQ.get_provider()
lagos = provider.get_backend('ibm_lagos')
def HEA_naive(num_q, depth):
circuit = QuantumCircuit(num_q)
params = ParameterVector("theta", length=num_q * (3 * depth + 2))
counter = 0
for q in range(num_q):
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
for d in range(depth):
for q in range(num_q - 1):
circuit.cx(q, q + 1)
for q in range(num_q):
circuit.rz(params[counter], q)
counter += 1
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
return circuit, params
def HEA_aware(num_q, depth, hardware):
circuit = QuantumCircuit(num_q)
params = ParameterVector("theta", length=num_q * (3 * depth + 2))
counter = 0
for q in range(num_q):
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
for d in range(depth):
for q in range(num_q - 1):
gate = QuantumCircuit(num_q)
gate.rzx(np.pi/2, q, q + 1)
pass_ = RZXCalibrationBuilderNoEcho(hardware)
qc_cr = PassManager(pass_).run(gate)
circuit.compose(qc_cr, inplace=True)
for q in range(num_q):
circuit.rz(params[counter], q)
counter += 1
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
return circuit, params
depth = 1
qubits = 2
back = lagos
circuit, _ = HEA_naive(qubits, depth)
t = transpile(circuit, back)
schedule = build_schedule(t, back)
schedule.draw()
circuit, _ = HEA_aware(qubits, depth, back)
t = transpile(circuit, back)
schedule = build_schedule(t, back)
schedule.draw()
qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
numpy_solver = NumPyMinimumEigensolver()
spsa = SPSA(100)
qi = QuantumInstance(Aer.get_backend('aer_simulator'))
vqe_circuit = VQE(ansatz=circuit, quantum_instance=qi, optimizer=spsa)
# H2 simulation
total_dist = 4
dist = 0.1
incr_early = 0.1
incr_late = 0.3
real_energies = []
vqe_energies = []
dists = []
while dist < total_dist:
print(dist, total_dist)
molecule = Molecule(geometry=[['H', [0., 0., 0.]], ['H', [0., 0., dist]]])
driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \
driver_type=ElectronicStructureDriverType.PYSCF)
es_problem = ElectronicStructureProblem(driver)
second_q_ops = es_problem.second_q_ops()
if dist == 0.1:
FermionicOp.set_truncation(0)
print(second_q_ops[0])
FermionicOp.set_truncation(1)
print(qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles))
print(es_problem.grouped_property)
calc = GroundStateEigensolver(qubit_converter, numpy_solver)
res = calc.solve(es_problem)
real_energies.append(np.real(res.total_energies[0]))
calc = GroundStateEigensolver(qubit_converter, vqe_circuit)
res = calc.solve(es_problem)
vqe_energies.append(np.real(res.total_energies[0]))
dists.append(dist)
if dist > total_dist / 2:
dist += incr_late
else:
dist += incr_early
plt.plot(dists, real_energies, label='Real', color='red')
plt.scatter(dists, vqe_energies, label='VQE', color='black')
plt.title("H2")
plt.ylim(-1.2, 0.4)
plt.xlim(0, 4)
plt.xlabel('Angstroms')
plt.ylabel('Hartree')
plt.legend()
plt.show()
depth = 2
qubits = 4
circuit, _ = HEA_naive(qubits, depth)
spsa = SPSA(100)
qi = QuantumInstance(Aer.get_backend('aer_simulator'))
vqe_circuit = VQE(ansatz=circuit, quantum_instance=qi, optimizer=spsa)
#print(circuit)
total_dist = 5
dist = 0.3
incr_early = 0.1
incr_late = 0.3
real_energies = []
vqe_energies = []
dists = []
while dist < total_dist:
print(dist, total_dist)
molecule = Molecule(geometry=[['Li', [0., 0., 0.]], ['H', [0., 0., dist]]])
driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \
driver_type=ElectronicStructureDriverType.PYSCF)
transformer = FreezeCoreTransformer(freeze_core=True, remove_orbitals=[3, 4])
es_problem = ElectronicStructureProblem(driver, transformers=[transformer])
second_q_ops = es_problem.second_q_ops()
if dist == 0.3:
print(second_q_ops[0])
print(qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles))
print(es_problem.grouped_property)
print(es_problem.grouped_property_transformed)
calc = GroundStateEigensolver(qubit_converter, numpy_solver)
res = calc.solve(es_problem)
real_energies.append(np.real(res.total_energies[0]))
calc = GroundStateEigensolver(qubit_converter, vqe_circuit) #VQEClient()
res = calc.solve(es_problem)
vqe_energies.append(np.real(res.total_energies[0]))
dists.append(dist)
if dist > total_dist / 2:
dist += incr_late
else:
dist += incr_early
plt.plot(dists, real_energies, label='Real', color='green')
plt.scatter(dists, vqe_energies, label='VQE', color='black')
plt.title("LiH")
plt.ylim(-8, -6.6)
plt.xlim(0.3, 5)
plt.xlabel('Angstroms')
plt.ylabel('Hartree')
plt.legend()
plt.show()
depth = 2
qubits = 6
circuit, _ = HEA_naive(qubits, depth)
spsa = SPSA(100)
qi = QuantumInstance(Aer.get_backend('aer_simulator'))
vqe_circuit = VQE(ansatz=circuit, quantum_instance=qi, optimizer=spsa)
#print(circuit)
total_dist = 5
dist = 0.4
incr_early = 0.2
incr_late = 0.4
real_energies = []
vqe_energies = []
dists = []
while dist < total_dist:
print(dist, total_dist)
molecule = Molecule(geometry=[['H', [0., 0., -dist]], ['Be', [0., 0., 0.]], ['H', [0., 0., dist]]])
driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \
driver_type=ElectronicStructureDriverType.PYSCF)
transformer = FreezeCoreTransformer(freeze_core=True, remove_orbitals=[4, 5])
es_problem = ElectronicStructureProblem(driver, transformers=[transformer])
second_q_ops = es_problem.second_q_ops()
if dist == 0.4:
print(second_q_ops[0])
print(qubit_converter.convert(second_q_ops[0], num_particles=es_problem.num_particles))
print(es_problem.grouped_property)
print(es_problem.grouped_property_transformed)
calc = GroundStateEigensolver(qubit_converter, numpy_solver)
res = calc.solve(es_problem)
real_energies.append(np.real(res.total_energies[0]))
calc = GroundStateEigensolver(qubit_converter, vqe_circuit)
res = calc.solve(es_problem)
vqe_energies.append(np.real(res.total_energies[0]))
dists.append(dist)
if dist > total_dist / 2:
dist += incr_late
else:
dist += incr_early
plt.plot(dists, real_energies, label='Real', color='blue')
plt.scatter(dists, vqe_energies, label='VQE', color='black')
plt.title("BeH2")
plt.ylim(-15.7, -12.0)
plt.xlim(0.48, 5)
plt.xlabel('Angstroms')
plt.ylabel('Hartree')
plt.legend()
plt.show()
from qiskit.tools.jupyter import *
%qiskit_version_table
|
https://github.com/lockwo/Paper-Review
|
lockwo
|
from qiskit import Aer, IBMQ
from qiskit.utils import QuantumInstance
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes.calibration import RZXCalibrationBuilderNoEcho
from qiskit_nature.drivers import UnitsType, Molecule
from qiskit_nature.drivers.second_quantization import ElectronicStructureDriverType, ElectronicStructureMoleculeDriver
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
from qiskit_nature.mappers.second_quantization import ParityMapper
from qiskit_nature.algorithms import GroundStateEigensolver
from qiskit_nature.runtime import VQEClient
from qiskit.algorithms import NumPyMinimumEigensolver, VQE
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit import QuantumCircuit, ParameterVector
from qiskit.utils import QuantumInstance
from qiskit.providers.aer import AerSimulator
import matplotlib.pyplot as plt
import numpy as np
IBMQ.load_account()
provider = IBMQ.get_provider()
hardware_backend = provider.get_backend('ibmq_quito')
def HEA_aware(num_q, depth):
circuit = QuantumCircuit(num_q)
params = ParameterVector("theta", length=num_q * (3 * depth + 2))
counter = 0
for q in range(num_q):
circuit.rx(params[counter], q)
counter += 1
circuit.rz(params[counter], q)
counter += 1
for d in range(depth):
for q in range(num_q - 1):
gate = QuantumCircuit(num_q)
gate.rzx(np.pi/2, q, q + 1)
pass_ = RZXCalibrationBuilderNoEcho(hardware_backend)
qc_cr = PassManager(pass_).run(gate)
circuit.compose(qc_cr, inplace=True)
for q in range(num_q):
circuit.rz(params[counter], q)
counter += 1
circuit.rx(params[counter], q)
counter += 1
circuit.rx(params[counter], q, label="last" if q == num_q - 1 else 'rz')
counter += 1
return circuit, params
dist = 0.82
qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
numpy_solver = NumPyMinimumEigensolver()
molecule = Molecule(geometry=[['H', [0., 0., 0.]], ['H', [0., 0., dist]]])
driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \
driver_type=ElectronicStructureDriverType.PYSCF)
es_problem = ElectronicStructureProblem(driver)
calc = GroundStateEigensolver(qubit_converter, numpy_solver)
res = calc.solve(es_problem)
ret_1 = np.real(res.total_energies[0])
target_energy = ret_1
shots = 1024
backend = provider.get_backend('ibmq_qasm_simulator')
qubits = 2
depth = 1
circuit, _ = HEA_aware(qubits, depth)
spsa = SPSA(200)
qubit_converter = QubitConverter(ParityMapper(), two_qubit_reduction=True)
numpy_solver = NumPyMinimumEigensolver()
molecule = Molecule(geometry=[['H', [0., 0., 0.]], ['H', [0., 0., dist]]])
driver = ElectronicStructureMoleculeDriver(molecule, basis='sto3g', \
driver_type=ElectronicStructureDriverType.PYSCF)
es_problem = ElectronicStructureProblem(driver)
runtime_vqe = VQEClient(
ansatz=circuit,
optimizer=spsa,
provider=provider,
backend=backend,
shots=shots
)
runtime_vqe_groundstate_solver = GroundStateEigensolver(qubit_converter, runtime_vqe)
runtime_vqe_result_soft = runtime_vqe_groundstate_solver.solve(es_problem)
runtime_result_soft = runtime_vqe_result_soft.raw_result
history_soft = runtime_result_soft.optimizer_history
loss_soft = history_soft["loss"]
target_energy = ret_1
plt.figure(figsize=(14, 8))
plt.plot(loss_soft + runtime_vqe_result_soft.nuclear_repulsion_energy, label="Noiseless Sim")
plt.axhline(y=target_energy, color="tab:red", ls="--", label="Target")
plt.legend()
plt.xlabel("Iteration")
plt.ylabel("Energy [H]")
plt.title("VQE energy")
plt.show()
from qiskit.tools.jupyter import *
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
from qiskit import QuantumCircuit, execute, Aer
from qiskit.opflow import One, Zero, Plus, Minus
from qiskit.opflow import I, X, Y, Z, S, H
from qiskit.visualization import plot_bloch_multivector, plot_bloch_vector, plot_histogram
from math import pi, sqrt, acos, asin, e, log, sin, cos
from numpy import angle
Zero
One
Plus
Minus
1.5 * Zero
-3 * Plus
Zero^Zero^One
Plus^Minus^Zero^Zero
Zero + One
Plus + Minus
(Zero^Zero^One) + (Zero^One^Zero) + (One^Zero^Zero)
(Zero^Zero^One) - 1.5*(Zero^One^Zero) + 3*(One^Zero^Zero)
def arbitrary_state(beta):
##### ==================================
# Write your solution in here.
##### ==================================
Zero.eval('0')
Zero.eval('1')
Minus.eval('0')
Minus.eval('1')
~Zero
~One
~Plus
print("< 0 | 0 > =",(~Zero @ Zero).eval())
print("< 1 | 0 > =",(~One @ Zero).eval())
beta = 0.232 + 0.341j
arbitrary_state(beta)
beta = 0.232 + 0.341j
print("< 1 | Ψ > =",(~One @ arbitrary_state(beta)).eval())
print("< 0 | Ψ > =",(~Zero @ arbitrary_state(beta)).eval())
print("< Ψ | Ψ > =", (~arbitrary_state(beta) @ arbitrary_state(beta)).eval())
def normality_check(beta):
##### ==================================
# Write your solution in here.
##### ==================================
# Play with your beta parameter to see if this value changes.
beta = 0.232 + 0.341j
print("|< 1 | Ψ >|^2 + |< 0 | Ψ >|^2 =", normality_check(beta))
def convert_braket_to_Bloch(beta):
if beta == 0: # special case
return [1.0, 0, 0]
##### ==================================
# Write your solution in here.
##### ==================================
return [1.0, theta, phi]
# Check
beta = -1/sqrt(2)*1j
plot_bloch_vector(convert_braket_to_Bloch(beta), coord_type='spherical',
title=r"$|\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle-\frac{1}{\sqrt{2}}i|0\rangle$")
# Play with more values of beta to see if it matches with your expectation
beta = -1/sqrt(10)*1j
plot_bloch_vector(convert_braket_to_Bloch(beta), coord_type='spherical',
title=r"$|\psi\rangle = \sqrt{1-|\beta|^2}|0\rangle+\beta|0\rangle$ in Spherical")
X
Y
Z
def expectation_Z(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
##### ==================================
print("<Z> =", expectation_Z(beta))
def expectation_X(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
##### ==================================
def expectation_Y(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
##### ==================================
def get_cartesian_coordinate(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
##### ==================================
return [x, y, z]
# Play with more values of beta to see if it matches with your previous Bloch sphere
beta = -1/sqrt(10)*1j
plot_bloch_vector(get_cartesian_coordinate(beta), coord_type='cartesian',
title=r"$|\psi\rangle = \sqrt{1-|\beta|^2}|0\rangle+\beta|0\rangle$ in Cartesian")
# Let's define the quantum simulator
sv_simulator = Aer.get_backend("statevector_simulator")
qasm_simulator = Aer.get_backend("qasm_simulator")
this_circ = QuantumCircuit(1)
this_circ.initialize([1/sqrt(2), -1/sqrt(2)])
this_circ.measure_all()
this_circ.draw('mpl')
shots = 1024
counts = execute(this_circ, backend=qasm_simulator, shots=shots).result().get_counts()
print(counts)
plot_histogram(counts, title=r"Measuring the $|+\rangle$ state")
def contruct_arbitrary_state_on_circuit(beta):
##### ==================================
# Write your solution in here. Here you do not need to append the measurement part in this function
##### ==================================
return circuit
shots = 81920
beta = 0.213
this_circuit = contruct_arbitrary_state_on_circuit(beta)
this_circuit.measure_all()
counts = execute(this_circuit, backend=qasm_simulator, shots=shots).result().get_counts()
print("Probability in |1> basis =", beta**2)
plot_histogram(counts, title=r"Measuring the arbitrary $|\psi(\beta)\rangle$ state")
def expectation_Z_with_QASM(beta, shots):
##### ==================================
# Write your solution in here. Here
##### ==================================
return expectation
beta = -1/sqrt(2)*1j
shots = 81920
print("Expectation <Z> with QASM =", expectation_Z_with_QASM(beta, shots=shots))
print("Expectation <Z> with opflow =", expectation_Z(beta))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, array_to_latex
from grader import *
language(False)
phi_plus = QuantumCircuit(2)
phi_plus.h(0)
phi_plus.cnot(0, 1)
phi_plus.draw('mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(phi_plus, backend).result().get_statevector()
array_to_latex(result)
phi_minus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
##### ==================================
phi_minus.draw('mpl')
# This cell will tell you if what you did gives the correct result.
# Just take it as an indication, the tests do not take into consideration every possible option
# If you think that your answer is (in)correct and the grader says different, just ask me please
# Don't try to tamper with the code, please :)
ex1_grader(phi_minus)
psi_plus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
##### ==================================
psi_plus.draw('mpl')
ex2_grader(psi_plus)
psi_minus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
##### ==================================
psi_minus.draw('mpl')
ex3_grader(psi_minus)
GHZ = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
##### ==================================
GHZ.draw('mpl')
ex4_grader(GHZ)
Even = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
##### ==================================
Even.draw('mpl')
ex5_grader(Even)
Odd = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
##### ==================================
Odd.draw('mpl')
ex6_grader(Odd)
def measure_z_axis(qc, qubit, cbit): #Measurements have to be saved in classical bits
qc.measure(qubit, cbit)
def measure_x_axis(qc, qubit, cbit):
##### ==================================
# Write your solution in here.
##### ==================================
ex7_grader(measure_x_axis)
def expectation_value_single_qubit(qc, nshots=8092):
# Run the given circuit that is already measuring the selected basis
backend_shots = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend_shots, shots=nshots).result().get_counts() #Counts is a dictionary that contains the number of zeros and the number of ones measured
# This is just to make things easier in your solution
if '1' not in counts.keys():
counts['1'] = 0
if '0' not in counts.keys():
counts['0'] = 0
# Get the number of times that 0 and 1 were measured
n_zeros = counts['0']
n_ones = counts['1']
# Compute the probabilities
p_0 = n_zeros/nshots
p_1 = n_ones/nshots #OR 1-p_0
expectation_value = 1*p_0+(-1)*p_1
return expectation_value
# Measure <Z> over a state that you like
qc_z = QuantumCircuit(1,1)
measure_z_axis(qc_z, 0, 0)
print('<Z>=', expectation_value_single_qubit(qc_z))
qc_z.draw('mpl')
# Measure <X> over a state that you like
qc_x = QuantumCircuit(1,1)
measure_x_axis(qc_x, 0, 0)
print('<X>=', expectation_value_single_qubit(qc_x))
qc_x.draw('mpl')
##### ==================================
# Write your solution in here.
# Create bell state circuit
# For each of the operators that we want to measure (ZZ, ZX, XZ and XX) create a new circuit (maybe using qc.copy())
# that measures along that axis.
chsh_circuits = []
##### ==================================
chsh_circuits[0].draw('mpl')
chsh_circuits[1].draw('mpl')
chsh_circuits[2].draw('mpl')
chsh_circuits[3].draw('mpl')
# I couldn't come up with tests that would not give the answer away if you looked at the code so you are on your own here!
# We can run all the circuits at the same time and then post process the data
nshots = 8092 # The more shots, the less error
backend_shots = Aer.get_backend('qasm_simulator')
counts_list = execute(chsh_circuits, backend_shots, shots=nshots).result().get_counts()
counts_list
##### ==================================
# Write your solution in here.
# For each of the circuits, take the counts that you got from that circuit, compute the probability
# of each state and combine them together being very careful of which sign goes with which term
# You might want to take some inspiration from the function expectation_value_single_qubit
# If you are completely lost and don't know how to solve this, just ask
##### ==================================
# If you don't know if your answer is correct you can compute the results by hand
# (it's probably easier than doing this) and check if everything is working
##### ==================================
# Write your solution in here.
exp_AB =
exp_Ab =
exp_aB =
exp_ab =
CHSH =
##### ==================================
print('Your result is <CHSH>=', CHSH)
print('The correct result is <CHSH>=', 2*np.sqrt(2))
##### ==================================
# Write your solution in here.
Can_entanglement_be_teleported = #Write True or False :D
##### ==================================
# There is no grader for this question hehe
##### ==================================
# Write your solution in here.
Where_did_the_bell_pair_go = 'Write where you think they went'
##### ==================================
# There is no grader for this question hehe
##### ==================================
# Write your solution in here.
##### ==================================
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, array_to_latex
from grader import *
language(True)
phi_plus = QuantumCircuit(2)
phi_plus.h(0)
phi_plus.cnot(0, 1)
phi_plus.draw('mpl')
# Simulamos para ver su resultado
backend = Aer.get_backend('statevector_simulator')
result = execute(phi_plus, backend).result().get_statevector()
array_to_latex(result)
phi_minus = QuantumCircuit(2)
##### ==================================
# Escribe tu solución aquí.
##### ==================================
phi_minus.draw('mpl')
# Esta celda te dirá si lo que has hecho da el resultado correcto.
# Tómalo como un indicador, los tests que hace no consideran todas las opciones posibles.
# Si crees que tu respuesta es (in)correcta y el grader dice algo diferente, simplemente pregúntame.
# No intentes hacer trampas modificando el código del corrector :)
ex1_grader(phi_minus)
psi_plus = QuantumCircuit(2)
##### ==================================
# Escribe tu solución aquí.
##### ==================================
psi_plus.draw('mpl')
ex2_grader(psi_plus)
psi_minus = QuantumCircuit(2)
##### ==================================
# Escribe tu solución aquí.
##### ==================================
psi_minus.draw('mpl')
ex3_grader(psi_minus)
GHZ = QuantumCircuit(3)
##### ==================================
# Escribe tu solución aquí.
##### ==================================
GHZ.draw('mpl')
ex4_grader(GHZ)
Even = QuantumCircuit(3)
##### ==================================
# Escribe tu solución aquí.
##### ==================================
Even.draw('mpl')
ex5_grader(Even)
Odd = QuantumCircuit(3)
##### ==================================
# Escribe tu solución aquí.
##### ==================================
Odd.draw('mpl')
ex6_grader(Odd)
def measure_z_axis(qc, qubit, cbit): #Las medidas deben guardarse en bits clásicos.
qc.measure(qubit, cbit)
def measure_x_axis(qc, qubit, cbit):
##### ==================================
# Escribe tu solución aquí.
##### ==================================
ex7_grader(measure_x_axis)
def expectation_value_single_qubit(qc, nshots=8092):
# Ejecuta el circuito que ya está rotado a la base correspondiente
backend_shots = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend_shots, shots=nshots).result().get_counts() #Counts is a dictionary that contains the number of zeros and the number of ones measured
# Esto es simplemente para evitar problemas. En caso de que falte una key en el diccionario la añade
if '1' not in counts.keys():
counts['1'] = 0
if '0' not in counts.keys():
counts['0'] = 0
# Obten el numero de veces que se ha medido 0 y 1
n_zeros = counts['0']
n_ones = counts['1']
# Calcula las probabilidades
p_0 = n_zeros/nshots
p_1 = n_ones/nshots # O 1-p_0
expectation_value = 1*p_0+(-1)*p_1
return expectation_value
# Mide <Z> sobre un estado que te guste
qc_z = QuantumCircuit(1,1)
measure_z_axis(qc_z, 0, 0)
print('<Z>=', expectation_value_single_qubit(qc_z))
qc_z.draw('mpl')
# Mide <X> sobre un estado que te guste
qc_x = QuantumCircuit(1,1)
measure_x_axis(qc_x, 0, 0)
print('<X>=', expectation_value_single_qubit(qc_x))
qc_x.draw('mpl')
##### ==================================
# Escribe tu solución aquí.
# Primero crea un estado de Bell
# Para cada uno de los operadores que queremos medir, (ZZ, ZX, XZ and XX) crea un nuevo circuito (quizás usando qc.copy())
# que mida en ese eje.
chsh_circuits = []
##### ==================================
chsh_circuits[0].draw('mpl')
chsh_circuits[1].draw('mpl')
chsh_circuits[2].draw('mpl')
chsh_circuits[3].draw('mpl')
# Hacer tests aquí que no revelasen la respuesta era complicado, así que no hay ayuda :(
# Podemos correr todos los circuitos a la vez y luego postprocesar los datos
nshots = 8092 # Cuantos más shots, menos error
backend_shots = Aer.get_backend('qasm_simulator')
counts_list = execute(chsh_circuits, backend_shots, shots=nshots).result().get_counts()
counts_list
##### ==================================
# Escribe tu solución aquí.
# Para cada uno de los circuitos, coge las counts que tengas para ese circuito, calcula la probabilidad
#de cada estado y combinalas teniendo mucho cuidado con qué signo lleva cada término
# Puede que quieras inspirarte en la función expectation_value_single_qubit
# Si estás muy perdido y no sabes cómo resolver esto, puedes preguntar.
##### ==================================
# Si no sabes si tu respuesta es correcta, puedes calcular los resultados a mano
# (de hecho seguramente sea más fácil que calcularlo así) y comprobar si tu código está funcionando
##### ==================================
# Escribe tu solución aquí.
exp_AB =
exp_Ab =
exp_aB =
exp_ab =
CHSH =
##### ==================================
print('Tu resultado es <CHSH>=', CHSH)
print('El resultado correcto es <CHSH>=', 2*np.sqrt(2))
##### ==================================
# Escribe tu solución aquí.
Can_entanglement_be_teleported = #Escribe True or False :D
##### ==================================
##### ==================================
# Escribe tu solución aquí.
Where_did_the_bell_pair_go = 'Escribe aquí'
##### ==================================
##### ==================================
# Escribe tu solución aquí.
##### ==================================
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, array_to_latex
##### DO NOT CHANGE THIS CODE #######
# This is used to help you check if your exercises are correct and allow you to keep track
# of your progress. Modifying this can make the system fail.
ex_correct_dict = {'ex1': False, 'ex2': False, 'ex3': False, 'ex4': False, 'ex5': False,
'ex6': False, 'ex7': False}
def language(x):
global ESP
ESP = x
def correction_announcer(x):
if ESP:
if x:
print('¡La respuesta es correcta! :) \n¡Te llevas un MAPI!')
else:
print('La respuesta es incorrecta :(')
else:
if x:
print('Your answer is correct! :)')
else:
print('Your answer is incorrect :(')
def ex1_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([1., 0., 0., -1.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex1'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex2_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([0., 1., 1., 0.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex2'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex3_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([0., 1., -1., 0.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex3'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex4_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./np.sqrt(2))*np.array([1., 0., 0., 0., 0., 0., 0., 1.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex4'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex5_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./2.)*np.array([1., 0., 0., 1., 0., 1., 1., 0.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex5'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex6_grader(qc):
from qiskit.quantum_info import Statevector
state_vector_solution = Statevector(qc)
state_vector_real = Statevector((1./2.)*np.array([0., 1., 1., 0., 1., 0., 0., 1.]))
if state_vector_solution==state_vector_real or state_vector_solution==-state_vector_real:
ex_correct_dict['ex6'] = True
correction_announcer(True)
else:
correction_announcer(False)
def ex7_grader(fun):
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(1, 1)
qc.h(0)
fun(qc, 0, 0)
backend_shots = Aer.get_backend('qasm_simulator', shots = 1024)
result = execute(qc, backend_shots).result().get_counts()
if result['0'] == 1024:
qc = QuantumCircuit(1, 1)
qc.x(0)
qc.h(0)
fun(qc, 0, 0)
result = execute(qc, backend_shots).result().get_counts()
if result['1'] == 1024:
ex_correct_dict['ex7'] = True
correction_announcer(True)
else:
correction_announcer(False)
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_bloch_multivector, array_to_latex
from math import pi
x_gate = QuantumCircuit(1) # Create a quantum circuit with 1 qubit
x_gate.x(0)
x_gate.draw(output='mpl')
backend = Aer.get_backend('statevector_simulator')
result = execute(x_gate, backend).result().get_statevector()
plot_bloch_multivector(result)
# Let's do an H-gate on a |0> qubit
h_gate = QuantumCircuit(1)
h_gate.h(0)
h_gate.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(h_gate, backend).result().get_statevector()
plot_bloch_multivector(result)
# To make the problem more interesting, let's do an P-gate on a |+> state
p_gate = QuantumCircuit(1)
p_gate.h(0)
p_gate.p(pi/2, 0)
p_gate.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(p_gate, backend).result().get_statevector()
plot_bloch_multivector(result)
array_to_latex(result)
cx_gate = QuantumCircuit(2)
cx_gate.cx(0,1)
cx_gate.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(cx_gate, backend).result().get_statevector()
plot_bloch_multivector(result)
circuit = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
circuit.x(1)
circuit.cx(0, 1)
##### ==================================
backend = Aer.get_backend('statevector_simulator')
result = execute(circuit, backend).result().get_statevector()
plot_bloch_multivector(result)
circuit = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
circuit.x(0)
circuit.x(1)
circuit.cx(0, 1)
##### ==================================
backend = Aer.get_backend('statevector_simulator')
result = execute(circuit, backend).result().get_statevector()
plot_bloch_multivector(result)
ccx_gate = QuantumCircuit(3)
ccx_gate.ccx(0,1,2)
ccx_gate.draw(output='mpl')
def encode_integer(circuit, qubit, integer):
##### ==================================
# Write your solution in here.
if integer == 1:
circuit.x(qubit)
##### ==================================
return circuit
def classical_add(a, b):
assert a in [0, 1]
assert b in [0, 1]
circuit = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
encode_integer(circuit, 0, a)
encode_integer(circuit, 1, b)
circuit.cx(0, 1)
##### ==================================
return circuit
# You may want to the following code to test your results
this_circ = classical_add(a=0, b=1)
backend = Aer.get_backend('statevector_simulator')
result = execute(this_circ, backend).result().get_statevector()
plot_bloch_multivector(result)
def classical_add_with_carry(a, b, carry):
assert a in [0, 1]
assert b in [0, 1]
assert carry in [0, 1]
circuit = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
encode_integer(circuit, 0, carry)
encode_integer(circuit, 1, a)
encode_integer(circuit, 2, b)
circuit.cx(0, 2)
circuit.cx(1, 2)
##### ==================================
return circuit
# You may want to the following code to test your results
this_circ = classical_add_with_carry(a=1, b=0, carry=1)
backend = Aer.get_backend('statevector_simulator')
result = execute(this_circ, backend).result().get_statevector()
plot_bloch_multivector(result)
def encode_integer_to_phase(circuit, qubit):
##### ==================================
# Write your solution in here. Remember, before encoding to phases,
# your integers are already encoded as quantum state |0> and |1>
circuit.h(qubit)
##### ==================================
return circuit
def phase_addition(circuit, incoming_qubit, recipient_qubit):
##### ==================================
# Write your solution in here.
circuit.cp(pi, incoming_qubit, recipient_qubit)
##### ==================================
return circuit
# You may want to the following code to test your results
a = 0; b = 1;
this_circ = QuantumCircuit(2)
this_circ = encode_integer(this_circ, 0, a)
this_circ = encode_integer(this_circ, 1, b)
this_circ = encode_integer_to_phase(this_circ, 1)
this_circ = phase_addition(this_circ, 0, 1)
backend = Aer.get_backend('statevector_simulator')
result = execute(this_circ, backend).result().get_statevector()
plot_bloch_multivector(result)
def decode_phase_to_integer(circuit, qubit):
##### ==================================
# Write your solution in here.
circuit.h(qubit)
##### ==================================
return circuit
def quantum_add(a, b):
assert a in [0, 1]
assert b in [0, 1]
circuit = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
circuit = QuantumCircuit(2)
circuit = encode_integer(circuit, 0, a)
circuit = encode_integer(circuit, 1, b)
circuit = encode_integer_to_phase(circuit, 1)
circuit = phase_addition(circuit, 0, 1)
circuit = decode_phase_to_integer(circuit, 1)
##### ==================================
return circuit
# You may want to the following code to test your results
this_circ = quantum_add(a=1, b=0)
backend = Aer.get_backend('statevector_simulator')
result = execute(this_circ, backend).result().get_statevector()
plot_bloch_multivector(result)
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
from qiskit import QuantumCircuit, execute, Aer
from qiskit.opflow import One, Zero, Plus, Minus
from qiskit.opflow import I, X, Y, Z, S, H
from qiskit.visualization import plot_bloch_multivector, plot_bloch_vector, plot_histogram
from math import pi, sqrt, acos, asin, e, log, sin, cos
from numpy import angle
Zero
One
Plus
Minus
1.5 * Zero
-3 * Plus
Zero^Zero^One
Plus^Minus^Zero^Zero
Zero + One
Plus + Minus
(Zero^Zero^One) + (Zero^One^Zero) + (One^Zero^Zero)
(Zero^Zero^One) - 1.5*(Zero^One^Zero) + 3*(One^Zero^Zero)
def arbitrary_state(beta):
##### ==================================
# Write your solution in here.
alpha = sqrt(1 - abs(beta)**2)
return alpha*Zero + beta*One
##### ==================================
Zero.eval('0')
Zero.eval('1')
Minus.eval('0')
Minus.eval('1')
~Zero
~One
~Plus
print("< 0 | 0 > =",(~Zero @ Zero).eval())
print("< 1 | 0 > =",(~One @ Zero).eval())
beta = 0.232 + 0.341j
arbitrary_state(beta)
beta = 0.232 + 0.341j
print("< 1 | Ψ > =",(~One @ arbitrary_state(beta)).eval())
print("< 0 | Ψ > =",(~Zero @ arbitrary_state(beta)).eval())
print("< Ψ | Ψ > =", (~arbitrary_state(beta) @ arbitrary_state(beta)).eval())
def normality_check(beta):
##### ==================================
# Write your solution in here.
return abs((~One @ arbitrary_state(beta)).eval())**2 + abs((~Zero @ arbitrary_state(beta)).eval())**2
##### ==================================
# Play with your beta parameter to see if this value changes.
beta = 0.232 + 0.341j
print("|< 1 | Ψ >|^2 + |< 0 | Ψ >|^2 =", normality_check(beta))
def convert_braket_to_Bloch(beta):
if beta == 0: # special case
return [1.0, 0, 0]
##### ==================================
# Write your solution in here.
alpha = sqrt(1 - abs(beta)**2)
theta = acos(alpha)*2
beta = beta / sin(theta/2)
phi = angle(beta)
##### ==================================
return [1.0, theta, phi]
# Check
beta = -1/sqrt(2)*1j
plot_bloch_vector(convert_braket_to_Bloch(beta), coord_type='spherical',
title=r"$|\psi\rangle = \frac{1}{\sqrt{2}}|0\rangle-\frac{1}{\sqrt{2}}i|0\rangle$")
# Play with more values of beta to see if it matches with your expectation
beta = -1/sqrt(10)*1j
plot_bloch_vector(convert_braket_to_Bloch(beta), coord_type='spherical',
title=r"$|\psi\rangle = \sqrt{1-|\beta|^2}|0\rangle+\beta|0\rangle$ in Spherical")
X
Y
Z
def expectation_Z(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
return (~arbitrary_state(beta) @ Z @ arbitrary_state(beta)).eval()
##### ==================================
print("<Z> =", expectation_Z(beta))
def expectation_X(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
return (~arbitrary_state(beta) @ ~H @ Z @ H @ arbitrary_state(beta)).eval()
##### ==================================
def expectation_Y(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
return (~arbitrary_state(beta) @ ~(H @ ~S) @ Z @ (H @ ~S) @ arbitrary_state(beta)).eval()
##### ==================================
def get_cartesian_coordinate(beta):
##### ==================================
# Write your solution in here. There are more than one solution here...
x = expectation_X(beta).real
y = expectation_Y(beta).real
z = expectation_Z(beta).real
##### ==================================
return [x, y, z]
# Play with more values of beta to see if it matches with your previous Bloch sphere
beta = -1/sqrt(10)*1j
plot_bloch_vector(get_cartesian_coordinate(beta), coord_type='cartesian',
title=r"$|\psi\rangle = \sqrt{1-|\beta|^2}|0\rangle+\beta|0\rangle$ in Cartesian")
# Let's define the quantum simulator
sv_simulator = Aer.get_backend("statevector_simulator")
qasm_simulator = Aer.get_backend("qasm_simulator")
this_circ = QuantumCircuit(1)
this_circ.initialize([1/sqrt(2), -1/sqrt(2)])
this_circ.measure_all()
this_circ.draw('mpl')
shots = 1024
counts = execute(this_circ, backend=qasm_simulator, shots=shots).result().get_counts()
print(counts)
plot_histogram(counts, title=r"Measuring the $|+\rangle$ state")
def contruct_arbitrary_state_on_circuit(beta):
##### ==================================
# Write your solution in here. Here you do not need to append the measurement part in this function
circuit = QuantumCircuit(1)
circuit.initialize([sqrt(1-abs(beta)**2), beta])
##### ==================================
return circuit
shots = 81920
beta = 0.213
this_circuit = contruct_arbitrary_state_on_circuit(beta)
this_circuit.measure_all()
counts = execute(this_circuit, backend=qasm_simulator, shots=shots).result().get_counts()
print("Probability in |1> basis =", beta**2)
plot_histogram(counts, title=r"Measuring the arbitrary $|\psi(\beta)\rangle$ state")
def expectation_Z_with_QASM(beta, shots):
##### ==================================
# Write your solution in here. Here
circuit = contruct_arbitrary_state_on_circuit(beta)
circuit.measure_all()
counts = execute(circuit, backend=qasm_simulator, shots=shots).result().get_counts()
expectation = (counts["0"] - counts["1"])/(counts["0"] + counts["1"])
##### ==================================
return expectation
beta = -1/sqrt(2)*1j
shots = 81920
print("Expectation <Z> with QASM =", expectation_Z_with_QASM(beta, shots=shots))
print("Expectation <Z> with opflow =", expectation_Z(beta))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, array_to_latex
from grader import *
language(True)
phi_plus = QuantumCircuit(2)
phi_plus.h(0)
phi_plus.cnot(0, 1)
phi_plus.draw('mpl')
# Simulamos para ver su resultado
backend = Aer.get_backend('statevector_simulator')
result = execute(phi_plus, backend).result().get_statevector()
array_to_latex(result)
phi_minus = QuantumCircuit(2)
##### ==================================
# Escribe tu solución aquí.
phi_minus.h(0)
phi_minus.z(0)
phi_minus.cnot(0, 1)
##### ==================================
phi_minus.draw('mpl')
# Esta celda te dirá si lo que has hecho da el resultado correcto.
# Tómalo como un indicador, los tests que hace no consideran todas las opciones posibles.
# Si crees que tu respuesta es (in)correcta y el grader dice algo diferente, simplemente pregúntame.
# No intentes hacer trampas modificando el código del corrector :)
ex1_grader(phi_minus)
psi_plus = QuantumCircuit(2)
##### ==================================
# Escribe tu solución aquí.
psi_plus.h(0)
psi_plus.x(1)
psi_plus.cnot(0, 1)
##### ==================================
psi_plus.draw('mpl')
ex2_grader(psi_plus)
psi_minus = QuantumCircuit(2)
##### ==================================
# Escribe tu solución aquí.
psi_minus.h(0)
psi_minus.x(1)
psi_minus.z(0)
psi_minus.cnot(0, 1)
##### ==================================
psi_minus.draw('mpl')
ex3_grader(psi_minus)
GHZ = QuantumCircuit(3)
##### ==================================
# Escribe tu solución aquí.
GHZ.h(0)
GHZ.cnot(0, 1)
GHZ.cnot(0, 2)
##### ==================================
GHZ.draw('mpl')
ex4_grader(GHZ)
Even = QuantumCircuit(3)
##### ==================================
# Escribe tu solución aquí.
Even.h(0)
Even.h(1)
Even.cnot(0, 2)
Even.cnot(1, 2)
##### ==================================
Even.draw('mpl')
ex5_grader(Even)
Odd = QuantumCircuit(3)
##### ==================================
# Escribe tu solución aquí.
Odd.h(0)
Odd.h(1)
Odd.x(2)
Odd.cnot(0, 2)
Odd.cnot(1, 2)
##### ==================================
Odd.draw('mpl')
ex6_grader(Odd)
def measure_z_axis(qc, qubit, cbit): #Las medidas deben guardarse en bits clásicos.
qc.measure(qubit, cbit)
def measure_x_axis(qc, qubit, cbit):
##### ==================================
# Escribe tu solución aquí.
qc.h(qubit)
qc.measure(qubit, cbit)
##### ==================================
ex7_grader(measure_x_axis)
def expectation_value_single_qubit(qc, nshots=8092):
# Ejecuta el circuito que ya está rotado a la base correspondiente
backend_shots = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend_shots, shots=nshots).result().get_counts() #Counts is a dictionary that contains the number of zeros and the number of ones measured
# Esto es simplemente para evitar problemas. En caso de que falte una key en el diccionario la añade
if '1' not in counts.keys():
counts['1'] = 0
if '0' not in counts.keys():
counts['0'] = 0
# Obten el numero de veces que se ha medido 0 y 1
n_zeros = counts['0']
n_ones = counts['1']
# Calcula las probabilidades
p_0 = n_zeros/nshots
p_1 = n_ones/nshots # O 1-p_0
expectation_value = 1*p_0+(-1)*p_1
return expectation_value
# Mide <Z> sobre un estado que te guste
qc_z = QuantumCircuit(1,1)
measure_z_axis(qc_z, 0, 0)
print('<Z>=', expectation_value_single_qubit(qc_z))
qc_z.draw('mpl')
# Mide <X> sobre un estado que te guste
qc_x = QuantumCircuit(1,1)
measure_x_axis(qc_x, 0, 0)
print('<X>=', expectation_value_single_qubit(qc_x))
qc_x.draw('mpl')
##### ==================================
# Escribe tu solución aquí.
measure_strings = ['ZZ', 'ZX', 'XZ', 'XX']
# Primero crea un estado de Bell
qc = QuantumCircuit(2,2)
qc.h(0)
qc.cnot(0, 1)
# Para cada uno de los operadores que queremos medir, (ZZ, ZX, XZ and XX) crea un nuevo circuito (quizás usando qc.copy())
# que mida en ese eje.
chsh_circuits = []
for string in measure_strings:
qc1 = qc.copy()
if string[0] == 'Z':
measure_z_axis(qc1, 0, 0)
if string[0] == 'X':
measure_x_axis(qc1, 0, 0)
if string[1] == 'Z':
measure_z_axis(qc1, 1, 1)
if string[1] == 'X':
measure_x_axis(qc1, 1, 1)
chsh_circuits.append(qc1)
##### ==================================
chsh_circuits[0].draw('mpl')
chsh_circuits[1].draw('mpl')
chsh_circuits[2].draw('mpl')
chsh_circuits[3].draw('mpl')
# Hacer tests aquí que no revelasen la respuesta era complicado, así que no hay ayuda :(
# Podemos correr todos los circuitos a la vez y luego postprocesar los datos
nshots = 8092 # Cuantos más shots, menos error
backend_shots = Aer.get_backend('qasm_simulator')
counts_list = execute(chsh_circuits, backend_shots, shots=nshots).result().get_counts()
counts_list
##### ==================================
# Escribe tu solución aquí.
exp_dict = {}
# Para cada uno de los circuitos, coge las counts que tengas para ese circuito, calcula la probabilidad
#de cada estado y combinalas teniendo mucho cuidado con qué signo lleva cada término
for i in range(len(chsh_circuits)):
string = measure_strings[i] #ZZ, ZX, XZ and XX
counts = counts_list[i]
exp = 0.
for element in counts:
parity = (-1)**(int(element[0])+int(element[1]))
#print(element, parity)
exp += counts[element]*parity
exp_dict[string] = exp/nshots
# Puede que quieras inspirarte en la función expectation_value_single_qubit
# Si estás muy perdido y no sabes cómo resolver esto, puedes preguntar.
##### ==================================
# Si no sabes si tu respuesta es correcta, puedes calcular los resultados a mano
# (de hecho seguramente sea más fácil que calcularlo así) y comprobar si tu código está funcionando
##### ==================================
# Escribe tu solución aquí.
exp_AB = np.sqrt(1/2)*(exp_dict['ZZ']-exp_dict['XZ'])
exp_Ab = np.sqrt(1/2)*(exp_dict['ZX']-exp_dict['XX'])
exp_aB = np.sqrt(1/2)*(exp_dict['ZZ']+exp_dict['XZ'])
exp_ab = np.sqrt(1/2)*(exp_dict['ZX']+exp_dict['XX'])
CHSH = exp_AB - exp_Ab + exp_aB + exp_ab
##### ==================================
print('Tu resultado es <CHSH>=', CHSH)
print('El resultado correcto es <CHSH>=', 2*np.sqrt(2))
##### ==================================
# Escribe tu solución aquí.
Can_entanglement_be_teleported = True#Escribe True or False :D
##### ==================================
##### ==================================
# Escribe tu solución aquí.
Where_did_the_bell_pair_go = 'En los dos últimos cúbits'
##### ==================================
##### ==================================
# Escribe tu solución aquí.
##### ==================================
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
import numpy as np
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_bloch_multivector, array_to_latex
from grader import *
language(False)
phi_plus = QuantumCircuit(2)
phi_plus.h(0)
phi_plus.cnot(0, 1)
phi_plus.draw('mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(phi_plus, backend).result().get_statevector()
array_to_latex(result)
phi_minus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
phi_minus.h(0)
phi_minus.z(0)
phi_minus.cnot(0, 1)
##### ==================================
phi_minus.draw('mpl')
# This cell will tell you if what you did gives the correct result.
# Just take it as an indication, the tests do not take into consideration every possible option
# If you think that your answer is (in)correct and the grader says different, just ask me please
# Don't try to tamper with the code, please :)
ex1_grader(phi_minus)
psi_plus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
psi_plus.h(0)
psi_plus.x(1)
psi_plus.cnot(0, 1)
##### ==================================
psi_plus.draw('mpl')
ex2_grader(psi_plus)
psi_minus = QuantumCircuit(2)
##### ==================================
# Write your solution in here.
psi_minus.h(0)
psi_minus.x(1)
psi_minus.z(0)
psi_minus.cnot(0, 1)
##### ==================================
psi_minus.draw('mpl')
ex3_grader(psi_minus)
GHZ = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
GHZ.h(0)
GHZ.cnot(0, 1)
GHZ.cnot(0, 2)
##### ==================================
GHZ.draw('mpl')
ex4_grader(GHZ)
Even = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
Even.h(0)
Even.h(1)
Even.cnot(0, 2)
Even.cnot(1, 2)
##### ==================================
Even.draw('mpl')
ex5_grader(Even)
Odd = QuantumCircuit(3)
##### ==================================
# Write your solution in here.
Odd.h(0)
Odd.h(1)
Odd.x(2)
Odd.cnot(0, 2)
Odd.cnot(1, 2)
##### ==================================
Odd.draw('mpl')
ex6_grader(Odd)
def measure_z_axis(qc, qubit, cbit): #Measurements have to be saved in classical bits
qc.measure(qubit, cbit)
def measure_x_axis(qc, qubit, cbit):
##### ==================================
# Write your solution in here.
qc.h(qubit)
qc.measure(qubit, cbit)
##### ==================================
ex7_grader(measure_x_axis)
def expectation_value_single_qubit(qc, nshots=8092):
# Run the given circuit that is already measuring the selected basis
backend_shots = Aer.get_backend('qasm_simulator')
counts = execute(qc, backend_shots, shots=nshots).result().get_counts() #Counts is a dictionary that contains the number of zeros and the number of ones measured
# This is just to make things easier in your solution
if '1' not in counts.keys():
counts['1'] = 0
if '0' not in counts.keys():
counts['0'] = 0
# Get the number of times that 0 and 1 were measured
n_zeros = counts['0']
n_ones = counts['1']
# Compute the probabilities
p_0 = n_zeros/nshots
p_1 = n_ones/nshots #OR 1-p_0
expectation_value = 1*p_0+(-1)*p_1
return expectation_value
# Measure <Z> over a state that you like
qc_z = QuantumCircuit(1,1)
measure_z_axis(qc_z, 0, 0)
print('<Z>=', expectation_value_single_qubit(qc_z))
qc_z.draw('mpl')
# Measure <X> over a state that you like
qc_x = QuantumCircuit(1,1)
measure_x_axis(qc_x, 0, 0)
print('<X>=', expectation_value_single_qubit(qc_x))
qc_x.draw('mpl')
##### ==================================
# Write your solution in here.
measure_strings = ['ZZ', 'ZX', 'XZ', 'XX']
# Create bell state circuit
qc = QuantumCircuit(2,2)
qc.h(0)
qc.cnot(0, 1)
# For each of the operators that we want to measure (ZZ, ZX, XZ and XX) create a new circuit (maybe using qc.copy())
# that measures along that axis.
chsh_circuits = []
for string in measure_strings:
qc1 = qc.copy()
if string[0] == 'Z':
measure_z_axis(qc1, 0, 0)
if string[0] == 'X':
measure_x_axis(qc1, 0, 0)
if string[1] == 'Z':
measure_z_axis(qc1, 1, 1)
if string[1] == 'X':
measure_x_axis(qc1, 1, 1)
chsh_circuits.append(qc1)
##### ==================================
chsh_circuits[0].draw('mpl')
chsh_circuits[1].draw('mpl')
chsh_circuits[2].draw('mpl')
chsh_circuits[3].draw('mpl')
# I couldn't come up with tests that would not give the answer away if you looked at the code so you are on your own here!
# We can run all the circuits at the same time and then post process the data
nshots = 8092 # The more shots, the less error
backend_shots = Aer.get_backend('qasm_simulator')
counts_list = execute(chsh_circuits, backend_shots, shots=nshots).result().get_counts()
counts_list
##### ==================================
# Write your solution in here.
exp_dict = {}
# For each of the circuits, take the counts that you got from that circuit, compute the probability
# of each state and combine them together being very careful of which sign goes with which term
for i in range(len(chsh_circuits)):
string = measure_strings[i] #ZZ, ZX, XZ and XX
counts = counts_list[i]
exp = 0.
for element in counts:
parity = (-1)**(int(element[0])+int(element[1]))
#print(element, parity)
exp += counts[element]*parity
exp_dict[string] = exp/nshots
# You might want to take some inspiration from the function expectation_value_single_qubit
# If you are completely lost and don't know how to solve this, just ask
##### ==================================
# If you don't know if your answer is correct you can compute the results by hand
# (it's probably easier than doing this) and check if everything is working
##### ==================================
# Write your solution in here.
exp_AB = np.sqrt(1/2)*(exp_dict['ZZ']-exp_dict['XZ'])
exp_Ab = np.sqrt(1/2)*(exp_dict['ZX']-exp_dict['XX'])
exp_aB = np.sqrt(1/2)*(exp_dict['ZZ']+exp_dict['XZ'])
exp_ab = np.sqrt(1/2)*(exp_dict['ZX']+exp_dict['XX'])
CHSH = exp_AB - exp_Ab + exp_aB + exp_ab
##### ==================================
print('Your result is <CHSH>=', CHSH)
print('The correct result is <CHSH>=', 2*np.sqrt(2))
##### ==================================
# Write your solution in here.
Can_entanglement_be_teleported = True #Write True or False :D
##### ==================================
# There is no grader for this question hehe
##### ==================================
# Write your solution in here.
Where_did_the_bell_pair_go = 'To the last two qubits'
##### ==================================
# There is no grader for this question hehe
##### ==================================
# Write your solution in here.
##### ==================================
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/wyqian1027/Qiskit-Fall-Fest-USC-2022
|
wyqian1027
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex
from qiskit.extensions import Initialize
from qiskit.quantum_info import random_statevector
from qiskit.quantum_info import Statevector
# Creamos 3 registros cuánticos
qr = QuantumRegister(3, name="q")
# Creamos dos registros clásicos con nombres diferentes
crz = ClassicalRegister(1, name="crz")
crx = ClassicalRegister(1, name="crx")
# Creamos el circuito
qc = QuantumCircuit(qr, crz, crx) # O QuantumCircuit(3, 2)
qc.draw('mpl')
# Creamos un circuito cuántico de dos cúbits
phi_plus = QuantumCircuit(2)
# Aplicamos la puerta H
phi_plus.h(0)
# Aplicamos la CNOT
phi_plus.cnot(0, 1)
phi_plus.draw('mpl')
Statevector(phi_plus).draw('latex')
# Primero fabricamos un estado aleatorio
psi = random_statevector(2)
#Esta función nos permite meter el estado en q_{0}
init_gate = Initialize(psi)
init_gate.label = "psi"
# Lo representamos en la esfera de Bloch
plot_bloch_multivector(psi)
# Lo aplicamos qc
qc.append(init_gate, [0])
# Y creamos el estado de bell en los dos últimos cúbits
qc.h(1)
qc.cnot(1, 2)
# Representamos
qc.draw('mpl')
# Implementamos la acción de alice
qc.barrier()
qc.cnot(0, 1)
qc.h(0)
qc.draw('mpl')
# Medimos los cúbits de Alice
qc.barrier()
qc.measure(1,crx)
qc.measure(0,crz)
qc.draw('mpl')
# Aplicamos estas operaciones controladas por los bits clásicos
#c_if controla las puertas con un bit clásico en vez de con un cubit
qc.x(2).c_if(crx, 1) # Estas dos líneas verifican
qc.z(2).c_if(crz, 1) # las acciones vistas arriba.
qc.draw('mpl')
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(out_vector)
|
https://github.com/RigiResearch/qiskit-fall-fest-22-public
|
RigiResearch
|
# Imports from Qiskit Terra
from qiskit.circuit import QuantumCircuit
from qiskit.visualization import plot_bloch_vector, plot_bloch_multivector, plot_state_qsphere, plot_histogram, visualize_transition
from qiskit.quantum_info import Pauli, PauliList, Statevector
# Imports from Qiskit Aer
from qiskit import Aer, execute
# Creation of multi-qubit circuit
q_multi = QuantumCircuit() # Mention multi-quantum and classical bits in args
# Display circuit
q_multi.draw()
cx_circ = QuantumCircuit() # Mention number of quantum and classical bits in args
# Apply CX gate to the qubits [0 - Control qubit; 1 - Target qubit]
# Draw the circuit
cx_circ.draw()
# Bloch Sphere visualization
state = Statevector(cx_circ) # Statevector of the circuit
plot_bloch_multivector(state)
# Let's measaure the multi-qubit circuit
cx_circ.measure() # Add measurement gate with appropriate args
# Draw the circuit
cx_circ.draw()
# Import the backend
backend = Aer.get_backend('qasm_simulator')
# Creating a job and extracting results
job = execute(cx_circ, backend = backend, shots = 1024)
result = job.result()
counts = result.get_counts()
# Plotting the counts
plot_histogram(counts)
# Do you know some of the quantum gates are reversible?
# Can you verify what happens when you apply these gates twice?
reverse_gate_circ = QuantumCircuit(2, 2)
# Apply 2 CX gates on the same qubits
## APPLY GATE 1 HERE ##
## APPLY GATE 2 HERE ##
# Draw circuit
reverse_gate_circ.draw()
# Send the circuit to a simulator to check the results!
# Your blank canvas to apply the Toffoli gate!
# Let us contruct the circuit for the first Bell state |phi+>
entangled_circ = QuantumCircuit(2, 2)
# Apply H gate follwoed by a CX gate on the qubits [0 - Control qubit; 1 - Target qubit]
# Draw the circuit
entangled_circ.draw()
# Let's measaure the multi-qubit circuit
entangled_circ.measure([0, 1], [0, 1]) # Add measurement gate with appropriate args
# Draw the circuit
entangled_circ.draw()
# Import the backend
backend = Aer.get_backend('qasm_simulator')
# Creating a job and extracting results
job = execute(entangled_circ, backend = backend, shots = 1024)
result = job.result()
counts = result.get_counts()
# Plotting the counts
plot_histogram(counts) # Don't forget Qiskit uses a little-endian notation !
# Do you know there are 4 different Bell States? Can you build a circuit for the rest 3 Bell States?
|
https://github.com/RigiResearch/qiskit-fall-fest-22-public
|
RigiResearch
|
# Imports
import numpy as np
# Imports from Qiskit Terra
from qiskit.circuit import QuantumCircuit
from qiskit.visualization import plot_bloch_vector, plot_bloch_multivector, plot_state_qsphere, plot_histogram, visualize_transition
from qiskit.quantum_info import Pauli, PauliList, Statevector
# Imports from Qiskit Aer
from qiskit import Aer, execute
# Creation of a single qubit circuit
q_circ = QuantumCircuit() # Mention number of quantum and classical bits in args
# Display circuit
q_circ.draw()
# Plot a Bloch sphere for state |0>
plot_bloch_vector([0, 0, 1])
# Creation of multi-qubit circuit
q_multi = QuantumCircuit() # Mention multi-quantum and classical bits in args
# Display circuit
q_multi.draw()
# Pauli-X representation as a matrix
Pauli('X').to_matrix(sparse = False)
x_circ = QuantumCircuit(1, 1)
# Apply X gate to the qubit
# Draw the circuit
x_circ.draw()
# Bloch Sphere visualization
state = Statevector(x_circ) # Statevector of the circuit
plot_bloch_multivector(state)
# Visualize the effect of X gate
visualize_transition(x_circ, trace = True, fpg = 15)
# Your blank canvas!
# Your blank canvas!
rx_circ = QuantumCircuit(1, 1)
# Apply Rx gate to the qubit
rx_circ.rx(np.pi/2, 0)
# Draw the circuit
rx_circ.draw()
# Bloch Sphere visualization
state = Statevector(rx_circ) # Statevector of the circuit
plot_bloch_multivector(state)
# Visualize the effect of Rx gate
visualize_transition(rx_circ, trace = True, fpg = 15)
# Try experimenting with Ry and Rz gates!
h_circ = QuantumCircuit(1, 1)
# Apply H gate to the qubit
h_circ.h(0)
# Draw the circuit
h_circ.draw()
# Bloch Sphere visualization
state = Statevector(h_circ) # Statevector of the circuit
plot_bloch_multivector(state)
# Visualize the effect of H gate
visualize_transition(h_circ, trace = True, fpg = 15)
uneq_superpos = QuantumCircuit(1, 1)
# Apply series of single-qubit gates to create unequal superposition
## APPLY GATE(S) HERE ##
# Draw the circuit
uneq_superpos.draw()
# Visualize the transition
# Grab the circuits (every circuit made till now has a different name)
# Let's measure the x_circ
# Add measurement gate
# Draw circuit
x_circ.draw()
# Measure the h_circ (superposition)
# Add measurement gate
# Draw circuit
h_circ.draw()
# What happens when you measure the unequal superposition circuit (uneq_superpos)?
# Add measurement gate
# Draw_circuit
|
https://github.com/RigiResearch/qiskit-fall-fest-22-public
|
RigiResearch
|
from qiskit import QuantumCircuit
from qiskit import Aer, transpile
from qiskit.tools.visualization import plot_histogram
Aer.backends()
simulator = Aer.get_backend('statevector_simulator')
# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)
# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)
circ.draw('mpl')
# Create a Quantum Program for execution
result = simulator.run(circ).result()
counts = result.get_counts(circ)
print(counts)
plot_histogram(counts)
simulator = Aer.get_backend('aer_simulator')
# Create a Quantum Circuit acting on a quantum register of three qubits
circ = QuantumCircuit(3)
# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1
circ.cx(0, 1)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 2, putting
# the qubits in a GHZ state.
circ.cx(0, 2)
circ.measure_all()
circ = transpile(circ, simulator)
# Run and get counts
result = simulator.run(circ).result()
counts = result.get_counts(circ)
plot_histogram(counts, title='GHZ State counts')
result = simulator.run(circ, shots=10, memory=True).result()
memory = result.get_memory(circ)
print(memory)
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub = 'ibm-q')
# device = provider.get_backend('ibmq_16_melbourne')
# job = execute(circuit,backend = device,shots = 1024)
# print(job.job_id())
# device_result = job.result()
# plot_histogram(device_result.get_counts(circuit))
|
https://github.com/amitcrypto/ARIA-Blocks-Qiskit
|
amitcrypto
|
# Copyright (c) Amit Kumar Chauhan, IIT Ropar, India.
# Licensed under the GNU General Public License.
# Importing standard Qiskit libraries and configuring account
import qiskit
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Creating qubits
q = qiskit.QuantumRegister(128)
circuit = qiskit.QuantumCircuit(q)
# Applying CNOT gates on the register of qubits
circuit.cx(q[40], q[0])
circuit.cx(q[56], q[0])
circuit.cx(q[80], q[0])
circuit.cx(q[88], q[0])
circuit.cx(q[104], q[0])
circuit.cx(q[112], q[0])
circuit.cx(q[41], q[1])
circuit.cx(q[57], q[1])
circuit.cx(q[81], q[1])
circuit.cx(q[89], q[1])
circuit.cx(q[105], q[1])
circuit.cx(q[113], q[1])
circuit.cx(q[42], q[2])
circuit.cx(q[58], q[2])
circuit.cx(q[82], q[2])
circuit.cx(q[90], q[2])
circuit.cx(q[106], q[2])
circuit.cx(q[114], q[2])
circuit.cx(q[43], q[3])
circuit.cx(q[59], q[3])
circuit.cx(q[83], q[3])
circuit.cx(q[91], q[3])
circuit.cx(q[107], q[3])
circuit.cx(q[115], q[3])
circuit.cx(q[44], q[4])
circuit.cx(q[60], q[4])
circuit.cx(q[84], q[4])
circuit.cx(q[92], q[4])
circuit.cx(q[108], q[4])
circuit.cx(q[116], q[4])
circuit.cx(q[45], q[5])
circuit.cx(q[61], q[5])
circuit.cx(q[85], q[5])
circuit.cx(q[93], q[5])
circuit.cx(q[109], q[5])
circuit.cx(q[117], q[5])
circuit.cx(q[46], q[6])
circuit.cx(q[62], q[6])
circuit.cx(q[86], q[6])
circuit.cx(q[94], q[6])
circuit.cx(q[110], q[6])
circuit.cx(q[118], q[6])
circuit.cx(q[47], q[7])
circuit.cx(q[63], q[7])
circuit.cx(q[87], q[7])
circuit.cx(q[95], q[7])
circuit.cx(q[111], q[7])
circuit.cx(q[119], q[7])
circuit.cx(q[32], q[8])
circuit.cx(q[48], q[8])
circuit.cx(q[80], q[8])
circuit.cx(q[88], q[8])
circuit.cx(q[96], q[8])
circuit.cx(q[120], q[8])
circuit.cx(q[33], q[9])
circuit.cx(q[49], q[9])
circuit.cx(q[81], q[9])
circuit.cx(q[89], q[9])
circuit.cx(q[97], q[9])
circuit.cx(q[121], q[9])
circuit.cx(q[34], q[10])
circuit.cx(q[50], q[10])
circuit.cx(q[82], q[10])
circuit.cx(q[90], q[10])
circuit.cx(q[98], q[10])
circuit.cx(q[122], q[10])
circuit.cx(q[35], q[11])
circuit.cx(q[51], q[11])
circuit.cx(q[83], q[11])
circuit.cx(q[91], q[11])
circuit.cx(q[99], q[11])
circuit.cx(q[123], q[11])
circuit.cx(q[36], q[12])
circuit.cx(q[52], q[12])
circuit.cx(q[84], q[12])
circuit.cx(q[92], q[12])
circuit.cx(q[100], q[12])
circuit.cx(q[124], q[12])
circuit.cx(q[37], q[13])
circuit.cx(q[53], q[13])
circuit.cx(q[85], q[13])
circuit.cx(q[93], q[13])
circuit.cx(q[101], q[13])
circuit.cx(q[125], q[13])
circuit.cx(q[38], q[14])
circuit.cx(q[54], q[14])
circuit.cx(q[86], q[14])
circuit.cx(q[94], q[14])
circuit.cx(q[102], q[14])
circuit.cx(q[126], q[14])
circuit.cx(q[39], q[15])
circuit.cx(q[55], q[15])
circuit.cx(q[87], q[15])
circuit.cx(q[95], q[15])
circuit.cx(q[103], q[15])
circuit.cx(q[127], q[15])
circuit.cx(q[40], q[16])
circuit.cx(q[56], q[16])
circuit.cx(q[64], q[16])
circuit.cx(q[72], q[16])
circuit.cx(q[96], q[16])
circuit.cx(q[120], q[16])
circuit.cx(q[41], q[17])
circuit.cx(q[57], q[17])
circuit.cx(q[65], q[17])
circuit.cx(q[73], q[17])
circuit.cx(q[97], q[17])
circuit.cx(q[121], q[17])
circuit.cx(q[42], q[18])
circuit.cx(q[58], q[18])
circuit.cx(q[66], q[18])
circuit.cx(q[74], q[18])
circuit.cx(q[98], q[18])
circuit.cx(q[122], q[18])
circuit.cx(q[43], q[19])
circuit.cx(q[59], q[19])
circuit.cx(q[67], q[19])
circuit.cx(q[75], q[19])
circuit.cx(q[99], q[19])
circuit.cx(q[123], q[19])
circuit.cx(q[44], q[20])
circuit.cx(q[60], q[20])
circuit.cx(q[68], q[20])
circuit.cx(q[76], q[20])
circuit.cx(q[100], q[20])
circuit.cx(q[124], q[20])
circuit.cx(q[45], q[21])
circuit.cx(q[61], q[21])
circuit.cx(q[69], q[21])
circuit.cx(q[77], q[21])
circuit.cx(q[101], q[21])
circuit.cx(q[125], q[21])
circuit.cx(q[46], q[22])
circuit.cx(q[62], q[22])
circuit.cx(q[70], q[22])
circuit.cx(q[78], q[22])
circuit.cx(q[102], q[22])
circuit.cx(q[126], q[22])
circuit.cx(q[47], q[23])
circuit.cx(q[63], q[23])
circuit.cx(q[71], q[23])
circuit.cx(q[79], q[23])
circuit.cx(q[103], q[23])
circuit.cx(q[127], q[23])
circuit.cx(q[32], q[24])
circuit.cx(q[48], q[24])
circuit.cx(q[64], q[24])
circuit.cx(q[72], q[24])
circuit.cx(q[104], q[24])
circuit.cx(q[112], q[24])
circuit.cx(q[33], q[25])
circuit.cx(q[49], q[25])
circuit.cx(q[65], q[25])
circuit.cx(q[73], q[25])
circuit.cx(q[105], q[25])
circuit.cx(q[113], q[25])
circuit.cx(q[34], q[26])
circuit.cx(q[50], q[26])
circuit.cx(q[66], q[26])
circuit.cx(q[74], q[26])
circuit.cx(q[106], q[26])
circuit.cx(q[114], q[26])
circuit.cx(q[35], q[27])
circuit.cx(q[51], q[27])
circuit.cx(q[67], q[27])
circuit.cx(q[75], q[27])
circuit.cx(q[107], q[27])
circuit.cx(q[115], q[27])
circuit.cx(q[36], q[28])
circuit.cx(q[52], q[28])
circuit.cx(q[68], q[28])
circuit.cx(q[76], q[28])
circuit.cx(q[108], q[28])
circuit.cx(q[116], q[28])
circuit.cx(q[37], q[29])
circuit.cx(q[53], q[29])
circuit.cx(q[69], q[29])
circuit.cx(q[77], q[29])
circuit.cx(q[109], q[29])
circuit.cx(q[117], q[29])
circuit.cx(q[38], q[30])
circuit.cx(q[54], q[30])
circuit.cx(q[70], q[30])
circuit.cx(q[78], q[30])
circuit.cx(q[110], q[30])
circuit.cx(q[118], q[30])
circuit.cx(q[39], q[31])
circuit.cx(q[55], q[31])
circuit.cx(q[71], q[31])
circuit.cx(q[79], q[31])
circuit.cx(q[111], q[31])
circuit.cx(q[119], q[31])
circuit.cx(q[32], q[8])
circuit.cx(q[32], q[24])
circuit.cx(q[64], q[32])
circuit.cx(q[88], q[32])
circuit.cx(q[96], q[32])
circuit.cx(q[104], q[32])
circuit.cx(q[33], q[9])
circuit.cx(q[33], q[25])
circuit.cx(q[65], q[33])
circuit.cx(q[89], q[33])
circuit.cx(q[97], q[33])
circuit.cx(q[105], q[33])
circuit.cx(q[34], q[10])
circuit.cx(q[34], q[26])
circuit.cx(q[66], q[34])
circuit.cx(q[90], q[34])
circuit.cx(q[98], q[34])
circuit.cx(q[106], q[34])
circuit.cx(q[35], q[11])
circuit.cx(q[35], q[27])
circuit.cx(q[67], q[35])
circuit.cx(q[91], q[35])
circuit.cx(q[99], q[35])
circuit.cx(q[107], q[35])
circuit.cx(q[36], q[12])
circuit.cx(q[36], q[28])
circuit.cx(q[68], q[36])
circuit.cx(q[92], q[36])
circuit.cx(q[100], q[36])
circuit.cx(q[108], q[36])
circuit.cx(q[37], q[13])
circuit.cx(q[37], q[29])
circuit.cx(q[69], q[37])
circuit.cx(q[93], q[37])
circuit.cx(q[101], q[37])
circuit.cx(q[109], q[37])
circuit.cx(q[38], q[14])
circuit.cx(q[38], q[30])
circuit.cx(q[70], q[38])
circuit.cx(q[94], q[38])
circuit.cx(q[102], q[38])
circuit.cx(q[110], q[38])
circuit.cx(q[39], q[15])
circuit.cx(q[39], q[31])
circuit.cx(q[71], q[39])
circuit.cx(q[95], q[39])
circuit.cx(q[103], q[39])
circuit.cx(q[111], q[39])
circuit.cx(q[40], q[0])
circuit.cx(q[40], q[16])
circuit.cx(q[72], q[40])
circuit.cx(q[80], q[40])
circuit.cx(q[96], q[40])
circuit.cx(q[104], q[40])
circuit.cx(q[41], q[1])
circuit.cx(q[41], q[17])
circuit.cx(q[73], q[41])
circuit.cx(q[81], q[41])
circuit.cx(q[97], q[41])
circuit.cx(q[105], q[41])
circuit.cx(q[42], q[2])
circuit.cx(q[42], q[18])
circuit.cx(q[74], q[42])
circuit.cx(q[82], q[42])
circuit.cx(q[98], q[42])
circuit.cx(q[106], q[42])
circuit.cx(q[43], q[3])
circuit.cx(q[43], q[19])
circuit.cx(q[75], q[43])
circuit.cx(q[83], q[43])
circuit.cx(q[99], q[43])
circuit.cx(q[107], q[43])
circuit.cx(q[44], q[4])
circuit.cx(q[44], q[20])
circuit.cx(q[76], q[44])
circuit.cx(q[84], q[44])
circuit.cx(q[100], q[44])
circuit.cx(q[108], q[44])
circuit.cx(q[45], q[5])
circuit.cx(q[45], q[21])
circuit.cx(q[77], q[45])
circuit.cx(q[85], q[45])
circuit.cx(q[101], q[45])
circuit.cx(q[109], q[45])
circuit.cx(q[46], q[6])
circuit.cx(q[46], q[22])
circuit.cx(q[78], q[46])
circuit.cx(q[86], q[46])
circuit.cx(q[102], q[46])
circuit.cx(q[110], q[46])
circuit.cx(q[47], q[7])
circuit.cx(q[47], q[23])
circuit.cx(q[79], q[47])
circuit.cx(q[87], q[47])
circuit.cx(q[103], q[47])
circuit.cx(q[111], q[47])
circuit.cx(q[48], q[8])
circuit.cx(q[48], q[24])
circuit.cx(q[72], q[48])
circuit.cx(q[80], q[48])
circuit.cx(q[112], q[48])
circuit.cx(q[120], q[48])
circuit.cx(q[49], q[9])
circuit.cx(q[49], q[25])
circuit.cx(q[73], q[49])
circuit.cx(q[81], q[49])
circuit.cx(q[113], q[49])
circuit.cx(q[121], q[49])
circuit.cx(q[50], q[10])
circuit.cx(q[50], q[26])
circuit.cx(q[74], q[50])
circuit.cx(q[82], q[50])
circuit.cx(q[114], q[50])
circuit.cx(q[122], q[50])
circuit.cx(q[51], q[11])
circuit.cx(q[51], q[27])
circuit.cx(q[75], q[51])
circuit.cx(q[83], q[51])
circuit.cx(q[115], q[51])
circuit.cx(q[123], q[51])
circuit.cx(q[52], q[12])
circuit.cx(q[52], q[28])
circuit.cx(q[76], q[52])
circuit.cx(q[84], q[52])
circuit.cx(q[116], q[52])
circuit.cx(q[124], q[52])
circuit.cx(q[53], q[13])
circuit.cx(q[53], q[29])
circuit.cx(q[77], q[53])
circuit.cx(q[85], q[53])
circuit.cx(q[117], q[53])
circuit.cx(q[125], q[53])
circuit.cx(q[54], q[14])
circuit.cx(q[54], q[30])
circuit.cx(q[78], q[54])
circuit.cx(q[86], q[54])
circuit.cx(q[118], q[54])
circuit.cx(q[126], q[54])
circuit.cx(q[55], q[15])
circuit.cx(q[55], q[31])
circuit.cx(q[79], q[55])
circuit.cx(q[87], q[55])
circuit.cx(q[119], q[55])
circuit.cx(q[127], q[55])
circuit.cx(q[56], q[0])
circuit.cx(q[56], q[16])
circuit.cx(q[64], q[56])
circuit.cx(q[88], q[56])
circuit.cx(q[112], q[56])
circuit.cx(q[120], q[56])
circuit.cx(q[57], q[1])
circuit.cx(q[57], q[17])
circuit.cx(q[65], q[57])
circuit.cx(q[89], q[57])
circuit.cx(q[113], q[57])
circuit.cx(q[121], q[57])
circuit.cx(q[58], q[2])
circuit.cx(q[58], q[18])
circuit.cx(q[66], q[58])
circuit.cx(q[90], q[58])
circuit.cx(q[114], q[58])
circuit.cx(q[122], q[58])
circuit.cx(q[59], q[3])
circuit.cx(q[59], q[19])
circuit.cx(q[67], q[59])
circuit.cx(q[91], q[59])
circuit.cx(q[115], q[59])
circuit.cx(q[123], q[59])
circuit.cx(q[60], q[4])
circuit.cx(q[60], q[20])
circuit.cx(q[68], q[60])
circuit.cx(q[92], q[60])
circuit.cx(q[116], q[60])
circuit.cx(q[124], q[60])
circuit.cx(q[61], q[5])
circuit.cx(q[61], q[21])
circuit.cx(q[69], q[61])
circuit.cx(q[93], q[61])
circuit.cx(q[117], q[61])
circuit.cx(q[125], q[61])
circuit.cx(q[62], q[6])
circuit.cx(q[62], q[22])
circuit.cx(q[70], q[62])
circuit.cx(q[94], q[62])
circuit.cx(q[118], q[62])
circuit.cx(q[126], q[62])
circuit.cx(q[63], q[7])
circuit.cx(q[63], q[23])
circuit.cx(q[71], q[63])
circuit.cx(q[95], q[63])
circuit.cx(q[119], q[63])
circuit.cx(q[127], q[63])
circuit.cx(q[64], q[16])
circuit.cx(q[64], q[24])
circuit.cx(q[64], q[32])
circuit.cx(q[64], q[56])
circuit.cx(q[104], q[64])
circuit.cx(q[120], q[64])
circuit.cx(q[65], q[17])
circuit.cx(q[65], q[25])
circuit.cx(q[65], q[33])
circuit.cx(q[65], q[57])
circuit.cx(q[105], q[65])
circuit.cx(q[121], q[65])
circuit.cx(q[66], q[18])
circuit.cx(q[66], q[26])
circuit.cx(q[66], q[34])
circuit.cx(q[66], q[58])
circuit.cx(q[106], q[66])
circuit.cx(q[122], q[66])
circuit.cx(q[67], q[19])
circuit.cx(q[67], q[27])
circuit.cx(q[67], q[35])
circuit.cx(q[67], q[59])
circuit.cx(q[107], q[67])
circuit.cx(q[123], q[67])
circuit.cx(q[68], q[20])
circuit.cx(q[68], q[28])
circuit.cx(q[68], q[36])
circuit.cx(q[68], q[60])
circuit.cx(q[108], q[68])
circuit.cx(q[124], q[68])
circuit.cx(q[69], q[21])
circuit.cx(q[69], q[29])
circuit.cx(q[69], q[37])
circuit.cx(q[69], q[61])
circuit.cx(q[109], q[69])
circuit.cx(q[125], q[69])
circuit.cx(q[70], q[22])
circuit.cx(q[70], q[30])
circuit.cx(q[70], q[38])
circuit.cx(q[70], q[62])
circuit.cx(q[110], q[70])
circuit.cx(q[126], q[70])
circuit.cx(q[71], q[23])
circuit.cx(q[71], q[31])
circuit.cx(q[71], q[39])
circuit.cx(q[71], q[63])
circuit.cx(q[111], q[71])
circuit.cx(q[127], q[71])
circuit.cx(q[72], q[16])
circuit.cx(q[72], q[24])
circuit.cx(q[72], q[40])
circuit.cx(q[72], q[48])
circuit.cx(q[96], q[72])
circuit.cx(q[112], q[72])
circuit.cx(q[73], q[17])
circuit.cx(q[73], q[25])
circuit.cx(q[73], q[41])
circuit.cx(q[73], q[49])
circuit.cx(q[97], q[73])
circuit.cx(q[113], q[73])
circuit.cx(q[74], q[18])
circuit.cx(q[74], q[26])
circuit.cx(q[74], q[42])
circuit.cx(q[74], q[50])
circuit.cx(q[98], q[74])
circuit.cx(q[114], q[74])
circuit.cx(q[75], q[19])
circuit.cx(q[75], q[27])
circuit.cx(q[75], q[43])
circuit.cx(q[75], q[51])
circuit.cx(q[99], q[75])
circuit.cx(q[115], q[75])
circuit.cx(q[76], q[20])
circuit.cx(q[76], q[28])
circuit.cx(q[76], q[44])
circuit.cx(q[76], q[52])
circuit.cx(q[100], q[76])
circuit.cx(q[116], q[76])
circuit.cx(q[77], q[21])
circuit.cx(q[77], q[29])
circuit.cx(q[77], q[45])
circuit.cx(q[77], q[53])
circuit.cx(q[101], q[77])
circuit.cx(q[117], q[77])
circuit.cx(q[78], q[22])
circuit.cx(q[78], q[30])
circuit.cx(q[78], q[46])
circuit.cx(q[78], q[54])
circuit.cx(q[102], q[78])
circuit.cx(q[118], q[78])
circuit.cx(q[79], q[23])
circuit.cx(q[79], q[31])
circuit.cx(q[79], q[47])
circuit.cx(q[79], q[55])
circuit.cx(q[103], q[79])
circuit.cx(q[119], q[79])
circuit.cx(q[80], q[0])
circuit.cx(q[80], q[8])
circuit.cx(q[80], q[40])
circuit.cx(q[80], q[48])
circuit.cx(q[104], q[80])
circuit.cx(q[120], q[80])
circuit.cx(q[81], q[1])
circuit.cx(q[81], q[9])
circuit.cx(q[81], q[41])
circuit.cx(q[81], q[49])
circuit.cx(q[105], q[81])
circuit.cx(q[121], q[81])
circuit.cx(q[82], q[2])
circuit.cx(q[82], q[10])
circuit.cx(q[82], q[42])
circuit.cx(q[82], q[50])
circuit.cx(q[106], q[82])
circuit.cx(q[122], q[82])
circuit.cx(q[83], q[3])
circuit.cx(q[83], q[11])
circuit.cx(q[83], q[43])
circuit.cx(q[83], q[51])
circuit.cx(q[107], q[83])
circuit.cx(q[123], q[83])
circuit.cx(q[84], q[4])
circuit.cx(q[84], q[12])
circuit.cx(q[84], q[44])
circuit.cx(q[84], q[52])
circuit.cx(q[108], q[84])
circuit.cx(q[124], q[84])
circuit.cx(q[85], q[5])
circuit.cx(q[85], q[13])
circuit.cx(q[85], q[45])
circuit.cx(q[85], q[53])
circuit.cx(q[109], q[85])
circuit.cx(q[125], q[85])
circuit.cx(q[86], q[6])
circuit.cx(q[86], q[14])
circuit.cx(q[86], q[46])
circuit.cx(q[86], q[54])
circuit.cx(q[110], q[86])
circuit.cx(q[126], q[86])
circuit.cx(q[87], q[7])
circuit.cx(q[87], q[15])
circuit.cx(q[87], q[47])
circuit.cx(q[87], q[55])
circuit.cx(q[111], q[87])
circuit.cx(q[127], q[87])
circuit.cx(q[88], q[0])
circuit.cx(q[88], q[8])
circuit.cx(q[88], q[32])
circuit.cx(q[88], q[56])
circuit.cx(q[96], q[88])
circuit.cx(q[112], q[88])
circuit.cx(q[89], q[1])
circuit.cx(q[89], q[9])
circuit.cx(q[89], q[33])
circuit.cx(q[89], q[57])
circuit.cx(q[97], q[89])
circuit.cx(q[113], q[89])
circuit.cx(q[90], q[2])
circuit.cx(q[90], q[10])
circuit.cx(q[90], q[34])
circuit.cx(q[90], q[58])
circuit.cx(q[98], q[90])
circuit.cx(q[114], q[90])
circuit.cx(q[91], q[3])
circuit.cx(q[91], q[11])
circuit.cx(q[91], q[35])
circuit.cx(q[91], q[59])
circuit.cx(q[99], q[91])
circuit.cx(q[115], q[91])
circuit.cx(q[92], q[4])
circuit.cx(q[92], q[12])
circuit.cx(q[92], q[36])
circuit.cx(q[92], q[60])
circuit.cx(q[100], q[92])
circuit.cx(q[116], q[92])
circuit.cx(q[93], q[5])
circuit.cx(q[93], q[13])
circuit.cx(q[93], q[37])
circuit.cx(q[93], q[61])
circuit.cx(q[101], q[93])
circuit.cx(q[117], q[93])
circuit.cx(q[94], q[6])
circuit.cx(q[94], q[14])
circuit.cx(q[94], q[38])
circuit.cx(q[94], q[62])
circuit.cx(q[102], q[94])
circuit.cx(q[118], q[94])
circuit.cx(q[95], q[7])
circuit.cx(q[95], q[15])
circuit.cx(q[95], q[39])
circuit.cx(q[95], q[63])
circuit.cx(q[103], q[95])
circuit.cx(q[119], q[95])
circuit.cx(q[96], q[8])
circuit.cx(q[96], q[16])
circuit.cx(q[96], q[32])
circuit.cx(q[96], q[40])
circuit.cx(q[96], q[72])
circuit.cx(q[96], q[88])
circuit.cx(q[97], q[9])
circuit.cx(q[97], q[17])
circuit.cx(q[97], q[33])
circuit.cx(q[97], q[41])
circuit.cx(q[97], q[73])
circuit.cx(q[97], q[89])
circuit.cx(q[98], q[10])
circuit.cx(q[98], q[18])
circuit.cx(q[98], q[34])
circuit.cx(q[98], q[42])
circuit.cx(q[98], q[74])
circuit.cx(q[98], q[90])
circuit.cx(q[99], q[11])
circuit.cx(q[99], q[19])
circuit.cx(q[99], q[35])
circuit.cx(q[99], q[43])
circuit.cx(q[99], q[75])
circuit.cx(q[99], q[91])
circuit.cx(q[100], q[12])
circuit.cx(q[100], q[20])
circuit.cx(q[100], q[36])
circuit.cx(q[100], q[44])
circuit.cx(q[100], q[76])
circuit.cx(q[100], q[92])
circuit.cx(q[101], q[13])
circuit.cx(q[101], q[21])
circuit.cx(q[101], q[37])
circuit.cx(q[101], q[45])
circuit.cx(q[101], q[77])
circuit.cx(q[101], q[93])
circuit.cx(q[102], q[14])
circuit.cx(q[102], q[22])
circuit.cx(q[102], q[38])
circuit.cx(q[102], q[46])
circuit.cx(q[102], q[78])
circuit.cx(q[102], q[94])
circuit.cx(q[103], q[15])
circuit.cx(q[103], q[23])
circuit.cx(q[103], q[39])
circuit.cx(q[103], q[47])
circuit.cx(q[103], q[79])
circuit.cx(q[103], q[95])
circuit.cx(q[104], q[0])
circuit.cx(q[104], q[24])
circuit.cx(q[104], q[32])
circuit.cx(q[104], q[40])
circuit.cx(q[104], q[64])
circuit.cx(q[104], q[80])
circuit.cx(q[105], q[1])
circuit.cx(q[105], q[25])
circuit.cx(q[105], q[33])
circuit.cx(q[105], q[41])
circuit.cx(q[105], q[65])
circuit.cx(q[105], q[81])
circuit.cx(q[106], q[2])
circuit.cx(q[106], q[26])
circuit.cx(q[106], q[34])
circuit.cx(q[106], q[42])
circuit.cx(q[106], q[66])
circuit.cx(q[106], q[82])
circuit.cx(q[107], q[3])
circuit.cx(q[107], q[27])
circuit.cx(q[107], q[35])
circuit.cx(q[107], q[43])
circuit.cx(q[107], q[67])
circuit.cx(q[107], q[83])
circuit.cx(q[108], q[4])
circuit.cx(q[108], q[28])
circuit.cx(q[108], q[36])
circuit.cx(q[108], q[44])
circuit.cx(q[108], q[68])
circuit.cx(q[108], q[84])
circuit.cx(q[109], q[5])
circuit.cx(q[109], q[29])
circuit.cx(q[109], q[37])
circuit.cx(q[109], q[45])
circuit.cx(q[109], q[69])
circuit.cx(q[109], q[85])
circuit.cx(q[110], q[6])
circuit.cx(q[110], q[30])
circuit.cx(q[110], q[38])
circuit.cx(q[110], q[46])
circuit.cx(q[110], q[70])
circuit.cx(q[110], q[86])
circuit.cx(q[111], q[7])
circuit.cx(q[111], q[31])
circuit.cx(q[111], q[39])
circuit.cx(q[111], q[47])
circuit.cx(q[111], q[71])
circuit.cx(q[111], q[87])
circuit.cx(q[112], q[0])
circuit.cx(q[112], q[24])
circuit.cx(q[112], q[48])
circuit.cx(q[112], q[56])
circuit.cx(q[112], q[72])
circuit.cx(q[112], q[88])
circuit.cx(q[113], q[1])
circuit.cx(q[113], q[25])
circuit.cx(q[113], q[49])
circuit.cx(q[113], q[57])
circuit.cx(q[113], q[73])
circuit.cx(q[113], q[89])
circuit.cx(q[114], q[2])
circuit.cx(q[114], q[26])
circuit.cx(q[114], q[50])
circuit.cx(q[114], q[58])
circuit.cx(q[114], q[74])
circuit.cx(q[114], q[90])
circuit.cx(q[115], q[3])
circuit.cx(q[115], q[27])
circuit.cx(q[115], q[51])
circuit.cx(q[115], q[59])
circuit.cx(q[115], q[75])
circuit.cx(q[115], q[91])
circuit.cx(q[116], q[4])
circuit.cx(q[116], q[28])
circuit.cx(q[116], q[52])
circuit.cx(q[116], q[60])
circuit.cx(q[116], q[76])
circuit.cx(q[116], q[92])
circuit.cx(q[117], q[5])
circuit.cx(q[117], q[29])
circuit.cx(q[117], q[53])
circuit.cx(q[117], q[61])
circuit.cx(q[117], q[77])
circuit.cx(q[117], q[93])
circuit.cx(q[118], q[6])
circuit.cx(q[118], q[30])
circuit.cx(q[118], q[54])
circuit.cx(q[118], q[62])
circuit.cx(q[118], q[78])
circuit.cx(q[118], q[94])
circuit.cx(q[119], q[7])
circuit.cx(q[119], q[31])
circuit.cx(q[119], q[55])
circuit.cx(q[119], q[63])
circuit.cx(q[119], q[79])
circuit.cx(q[119], q[95])
circuit.cx(q[120], q[8])
circuit.cx(q[120], q[16])
circuit.cx(q[120], q[48])
circuit.cx(q[120], q[56])
circuit.cx(q[120], q[64])
circuit.cx(q[120], q[80])
circuit.cx(q[121], q[9])
circuit.cx(q[121], q[17])
circuit.cx(q[121], q[49])
circuit.cx(q[121], q[57])
circuit.cx(q[121], q[65])
circuit.cx(q[121], q[81])
circuit.cx(q[122], q[10])
circuit.cx(q[122], q[18])
circuit.cx(q[122], q[50])
circuit.cx(q[122], q[58])
circuit.cx(q[122], q[66])
circuit.cx(q[122], q[82])
circuit.cx(q[123], q[11])
circuit.cx(q[123], q[19])
circuit.cx(q[123], q[51])
circuit.cx(q[123], q[59])
circuit.cx(q[123], q[67])
circuit.cx(q[123], q[83])
circuit.cx(q[124], q[12])
circuit.cx(q[124], q[20])
circuit.cx(q[124], q[52])
circuit.cx(q[124], q[60])
circuit.cx(q[124], q[68])
circuit.cx(q[124], q[84])
circuit.cx(q[125], q[13])
circuit.cx(q[125], q[21])
circuit.cx(q[125], q[53])
circuit.cx(q[125], q[61])
circuit.cx(q[125], q[69])
circuit.cx(q[125], q[85])
circuit.cx(q[126], q[14])
circuit.cx(q[126], q[22])
circuit.cx(q[126], q[54])
circuit.cx(q[126], q[62])
circuit.cx(q[126], q[70])
circuit.cx(q[126], q[86])
circuit.cx(q[127], q[15])
circuit.cx(q[127], q[23])
circuit.cx(q[127], q[55])
circuit.cx(q[127], q[63])
circuit.cx(q[127], q[71])
circuit.cx(q[127], q[87])
# Printing the circuit
qc = circuit.draw()
print(qc)
# Estimating the circuit depth
d = QuantumCircuit.depth(circuit)
print('The Circuit Depth :=', d)
|
https://github.com/amitcrypto/ARIA-Blocks-Qiskit
|
amitcrypto
|
# Copyright (c) Amit Kumar Chauhan, IIT Ropar, India.
# Licensed under the GNU General Public License.
# Importing standard Qiskit libraries and configuring account
import qiskit
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Creating qubits
q = qiskit.QuantumRegister(128)
circuit = qiskit.QuantumCircuit(q)
# Applying Toffoli gate on the register of qubits
circuit.ccx(q[7], q[9], q[16])
circuit.ccx(q[6], q[10], q[16])
circuit.ccx(q[5], q[11], q[16])
circuit.ccx(q[4], q[12], q[16])
circuit.ccx(q[3], q[13], q[16])
circuit.ccx(q[2], q[14], q[16])
circuit.ccx(q[1], q[15], q[16])
circuit.ccx(q[7], q[10], q[17])
circuit.ccx(q[6], q[11], q[17])
circuit.ccx(q[5], q[12], q[17])
circuit.ccx(q[4], q[13], q[17])
circuit.ccx(q[3], q[14], q[17])
circuit.ccx(q[2], q[15], q[17])
circuit.ccx(q[7], q[11], q[18])
circuit.ccx(q[6], q[12], q[18])
circuit.ccx(q[5], q[13], q[18])
circuit.ccx(q[4], q[14], q[18])
circuit.ccx(q[3], q[15], q[18])
circuit.ccx(q[7], q[12], q[19])
circuit.ccx(q[6], q[13], q[19])
circuit.ccx(q[5], q[14], q[19])
circuit.ccx(q[4], q[15], q[19])
circuit.ccx(q[7], q[13], q[20])
circuit.ccx(q[6], q[14], q[20])
circuit.ccx(q[5], q[15], q[20])
circuit.ccx(q[7], q[14], q[21])
circuit.ccx(q[6], q[15], q[21])
circuit.ccx(q[7], q[15], q[22])
# Applying CNOT gate on the register of qubits
circuit.cx(q[22], q[23])
circuit.cx(q[20], q[23])
circuit.cx(q[19], q[23])
circuit.cx(q[21], q[22])
circuit.cx(q[19], q[22])
circuit.cx(q[18], q[22])
circuit.cx(q[20], q[21])
circuit.cx(q[18], q[21])
circuit.cx(q[17], q[21])
circuit.cx(q[19], q[20])
circuit.cx(q[17], q[20])
circuit.cx(q[16], q[20])
circuit.cx(q[18], q[19])
circuit.cx(q[16], q[19])
circuit.cx(q[18], q[22])
circuit.cx(q[17], q[18])
circuit.cx(q[17], q[22])
circuit.cx(q[17], q[21])
circuit.cx(q[16], q[17])
circuit.cx(q[16], q[21])
circuit.cx(q[16], q[20])
# Applying Toffoli gate on the register of qubits
circuit.ccx(q[7], q[8], q[23])
circuit.ccx(q[6], q[9], q[23])
circuit.ccx(q[5], q[10], q[23])
circuit.ccx(q[4], q[11], q[23])
circuit.ccx(q[3], q[12], q[23])
circuit.ccx(q[2], q[13], q[23])
circuit.ccx(q[1], q[14], q[23])
circuit.ccx(q[0], q[15], q[23])
circuit.ccx(q[6], q[8], q[22])
circuit.ccx(q[5], q[9], q[22])
circuit.ccx(q[4], q[10], q[22])
circuit.ccx(q[3], q[11], q[22])
circuit.ccx(q[2], q[12], q[22])
circuit.ccx(q[1], q[13], q[22])
circuit.ccx(q[0], q[14], q[22])
circuit.ccx(q[5], q[8], q[21])
circuit.ccx(q[4], q[9], q[21])
circuit.ccx(q[3], q[10], q[21])
circuit.ccx(q[2], q[11], q[21])
circuit.ccx(q[1], q[12], q[21])
circuit.ccx(q[0], q[13], q[21])
circuit.ccx(q[4], q[8], q[20])
circuit.ccx(q[3], q[9], q[20])
circuit.ccx(q[2], q[10], q[20])
circuit.ccx(q[1], q[11], q[20])
circuit.ccx(q[0], q[12], q[20])
circuit.ccx(q[3], q[8], q[19])
circuit.ccx(q[2], q[9], q[19])
circuit.ccx(q[1], q[10], q[19])
circuit.ccx(q[0], q[11], q[19])
circuit.ccx(q[2], q[8], q[18])
circuit.ccx(q[1], q[9], q[18])
circuit.ccx(q[0], q[10], q[18])
circuit.ccx(q[1], q[8], q[17])
circuit.ccx(q[0], q[9], q[17])
circuit.ccx(q[0], q[8], q[16])
# Printing the circuit
qc = circuit.draw()
print(qc)
# Estimating the circuit depth
d = QuantumCircuit.depth(circuit)
print('The Circuit Depth :=', d)
|
https://github.com/amitcrypto/ARIA-Blocks-Qiskit
|
amitcrypto
|
# Copyright (c) Amit Kumar Chauhan, IIT Ropar, India.
# Licensed under the GNU General Public License.
# Importing standard Qiskit libraries and configuring account
import qiskit
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Creating qubits
q = qiskit.QuantumRegister(128)
circuit = qiskit.QuantumCircuit(q)
# Applying CNOT gates on the register of qubits
circuit.cx(q[4], q[0])
circuit.cx(q[6], q[0])
circuit.cx(q[5], q[1])
circuit.cx(q[4], q[2])
circuit.cx(q[7], q[2])
circuit.cx(q[5], q[3])
circuit.cx(q[6], q[4])
circuit.cx(q[7], q[4])
circuit.cx(q[6], q[5])
circuit.cx(q[6], q[7])
circuit.cx(q[5], q[6])
circuit.cx(q[4], q[6])
# Printing the circuit
qc = circuit.draw()
print(qc)
# Estimating the circuit depth
d = QuantumCircuit.depth(circuit)
print('The Circuit Depth :=', d)
|
https://github.com/MonitSharma/Qiskit-Hindi-Tutorials
|
MonitSharma
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
!pip install qutip -q
!pip install qiskit -q
!pip install qiskit[visualization] -q
!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src -q
import numpy as np
np.set_printoptions(precision=3, suppress=True)
import qutip as qt
from matplotlib import pyplot as plt
%matplotlib inline
import pandas as pd
import sklearn as sk
import qiskit as qk
# Remember that qiskit has to be already installed in the Python environment.
# Otherwise the import command will fail
import qiskit as qk
# A circuit composed of just one qubit
qc = qk.QuantumCircuit(1)
qc.draw('mpl')
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl')
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl')
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl')
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
# Let's choose the statevector simulator from the Aer backend
backend = qk.Aer.get_backend('statevector_simulator')
# And execute the circuit qc in the simulator backend
# getting as final result the counts from 1.000 measures
# of the qubit state
result = qk.execute(qc, backend, shots=1000).result().get_counts()
result
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_histogram(result)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.measure(0,0)
qc.draw('mpl')
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_histogram(result)
import numpy as np
v0 = np.array([[1],[0]]);v0
v1 = np.array([[0],[1]]); v1
X = np.array([[0,1],[1,0]]); X
X.dot(v0)
X.dot(v1)
import qiskit as qk
qr = qk.QuantumRegister(1,"q0")
cr = qk.ClassicalRegister(1,"c0")
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.measure(qr[0], cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=1000).result().get_counts()
results
qk.visualization.plot_histogram(results)
import numpy as np
# Notice that we are creating the v0 matrix using the transpose operation
v0 = np.array([[1,0]]).T; v0
# Here it is created again de X matrix
X = np.array([[0,1],[1,0]]); X
# Multiplying v0 by the X matrix twice you get again v0
X.dot(X).dot(v0)
# Multiplying the X matrix by itself you get the Identity matrix
X.dot(X)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.x(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
# The result of 1000 measures of the qubit above gives the |0> state as result
# in all measures
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
results
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,2**-0.5],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
v0 = np.array([[1,0]]).T; v0
H = np.array([[1,1],[1,-1]])/np.sqrt(2); H
H.dot(v0)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.h(qr[0])
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.h(0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
# First let's start with the qubit in the state |psi> = (|0> - |1>)/sqrt(2)
psi = np.array([[1,-1]]).T/(2**0.5); psi
H = np.array([[1,1],[1,-1]])/2**0.5; H
# Now let's pass the qubit Psi through an Hadamard gate.
# The result is a qubit in the state |1>
H.dot(psi)
# Let's start with a qubit in the state |1>, pass it through a
# a hadamard gate twice and check the result
v0 = np.array([[0,1]]).T; v0
H.dot(H).dot(v0)
# This means that if we multiply the H gate by itself the result
# will be an Identity matrix. Let's check it.
H.dot(H)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[1,0]]).T; psi1
psi2 = np.array([[1,0]]).T; psi2
# In numpy the tensor product is calculated with the function kron
np.kron(psi1,psi2)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.h(1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[1,0]]).T;psi1
psi2 = np.array([[1,0]]).T;psi2
H = np.array([[1,1],[1,-1]])/2**0.5;H
# When we want to combine two vector states or gate matrices we tensor product them.
psi3 = np.kron(psi1,psi2);psi3
H2 = np.kron(H,H);H2
# When we want to pass a vetor through a gate we calculate the dot product
# of the total gate matrix with the total vector.
# As we have predicted, the resulting vector state has a=b=c=d=1/2
psi4 = H2.dot(psi3); psi4
|
https://github.com/MonitSharma/Qiskit-Hindi-Tutorials
|
MonitSharma
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit.providers.aer import QasmSimulator
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
!pip install qutip -q
!pip install qiskit -q
!pip install qiskit[visualization] -q
!pip install git+https://github.com/qiskit-community/qiskit-textbook.git#subdirectory=qiskit-textbook-src -q
import numpy as np
np.set_printoptions(precision=3, suppress=True)
import qutip as qt
from matplotlib import pyplot as plt
%matplotlib inline
import pandas as pd
import sklearn as sk
import qiskit as qk
# Remember that qiskit has to be already installed in the Python environment.
# Otherwise the import command will fail
import qiskit as qk
# A circuit composed of just one qubit
qc = qk.QuantumCircuit(1)
qc.draw('mpl')
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl')
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl')
import qiskit as qiskit
# A qubit initialized in the state |0>
qc = qk.QuantumCircuit(1)
qc.initialize([1,0])
qc.draw('mpl')
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
# Let's choose the statevector simulator from the Aer backend
backend = qk.Aer.get_backend('statevector_simulator')
# And execute the circuit qc in the simulator backend
# getting as final result the counts from 1.000 measures
# of the qubit state
result = qk.execute(qc, backend, shots=1000).result().get_counts()
result
import qiskit as qk
qc = qk.QuantumCircuit(1)
qc.initialize([1,0],0)
qc.measure_all()
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_histogram(result)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.measure(0,0)
qc.draw('mpl')
backend = qk.Aer.get_backend('statevector_simulator')
result = qk.execute(qc, backend, shots=1000).result().get_counts()
qk.visualization.plot_histogram(result)
import numpy as np
v0 = np.array([[1],[0]]);v0
v1 = np.array([[0],[1]]); v1
X = np.array([[0,1],[1,0]]); X
X.dot(v0)
X.dot(v1)
import qiskit as qk
qr = qk.QuantumRegister(1,"q0")
cr = qk.ClassicalRegister(1,"c0")
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.measure(qr[0], cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=1000).result().get_counts()
results
qk.visualization.plot_histogram(results)
import numpy as np
# Notice that we are creating the v0 matrix using the transpose operation
v0 = np.array([[1,0]]).T; v0
# Here it is created again de X matrix
X = np.array([[0,1],[1,0]]); X
# Multiplying v0 by the X matrix twice you get again v0
X.dot(X).dot(v0)
# Multiplying the X matrix by itself you get the Identity matrix
X.dot(X)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.x(0)
qc.x(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
# The result of 1000 measures of the qubit above gives the |0> state as result
# in all measures
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=1000).result().get_counts()
results
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,2**-0.5],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
v0 = np.array([[1,0]]).T; v0
H = np.array([[1,1],[1,-1]])/np.sqrt(2); H
H.dot(v0)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.h(qr[0])
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([2**-0.5,-(2**-0.5)],0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(1,'q0')
cr = qk.ClassicalRegister(1,'c0')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.h(0)
qc.h(0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
# First let's start with the qubit in the state |psi> = (|0> - |1>)/sqrt(2)
psi = np.array([[1,-1]]).T/(2**0.5); psi
H = np.array([[1,1],[1,-1]])/2**0.5; H
# Now let's pass the qubit Psi through an Hadamard gate.
# The result is a qubit in the state |1>
H.dot(psi)
# Let's start with a qubit in the state |1>, pass it through a
# a hadamard gate twice and check the result
v0 = np.array([[0,1]]).T; v0
H.dot(H).dot(v0)
# This means that if we multiply the H gate by itself the result
# will be an Identity matrix. Let's check it.
H.dot(H)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[1,0]]).T; psi1
psi2 = np.array([[1,0]]).T; psi2
# In numpy the tensor product is calculated with the function kron
np.kron(psi1,psi2)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.h(1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[1,0]]).T;psi1
psi2 = np.array([[1,0]]).T;psi2
H = np.array([[1,1],[1,-1]])/2**0.5;H
# When we want to combine two vector states or gate matrices we tensor product them.
psi3 = np.kron(psi1,psi2);psi3
H2 = np.kron(H,H);H2
# When we want to pass a vetor through a gate we calculate the dot product
# of the total gate matrix with the total vector.
# As we have predicted, the resulting vector state has a=b=c=d=1/2
psi4 = H2.dot(psi3); psi4
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([0,1],1)
qc.h(0)
qc.h(1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
psi1 = np.array([[0,1]]).T;psi1
psi2 = np.array([[0,1]]).T;psi2
H = np.array([[1,1],[1,-1]])/2**0.5;H
# When we want to combine two vector states or gate matrices we tensor product them.
psi3 = np.kron(psi1,psi2);psi3
H2 = np.kron(H,H);H2
# When we want to pass a vetor through a gate we calculate the dot product
# of the total gate matrix with the total vector.
# As we have predicted, the resulting vector state has a=b=c=d=1/2
psi4 = H2.dot(psi3); psi4
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v00 = np.array([[1,0,0,0]]).T;v00
# C.v00 = v00
C.dot(v00)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([0,1],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
# Please notice that Qiskit's qubits presentation order is reversed.
# Therefore 10 in the histogram's x axis should be read as 01 (from
# inside out or right to left).
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v01 = np.array([[0,1,0,0]]).T;v01
C.dot(v01)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([1,0],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v10 = np.array([[0,0,1,0]]).T; v10
C.dot(v10)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([0,1],0)
qc.initialize([0,1],1)
qc.cnot(0,1)
qc.measure(qr,cr)
qc.draw('mpl')
# Again remember to read qiskit qubits state presentation order
# from right to left. Therefore 01 in the x axis is in fact 10
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc, simulator, shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
v11 = np.array([[0,0,0,1]]).T; v11
# C.v11 = v10
C.dot(v11)
import qiskit as qk
qr = qk.QuantumRegister(2, 'q')
cr = qk.ClassicalRegister(2, 'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.measure(qr, cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
va = np.array([[1,0]]).T; va
vb = np.array([[1,0]]).T; vb
H = np.array([[1,1],[1,-1]])/2**0.5;H
vaH = H.dot(va); vaH
vaHvb = np.kron(vaH,vb); vaHvb
C = np.array([[1,0,0,0],[0,1,0,0],[0,0,0,1],[0,0,1,0]]); C
vout = C.dot(vaHvb); vout
import qiskit as qk
qr = qk.QuantumRegister(2, 'q')
cr = qk.ClassicalRegister(2, 'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([0,1],0)
qc.initialize([1,0],1)
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.measure(qr, cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
va = np.array([[0,1]]).T; va
vb = np.array([[1,0]]).T; vb
H = np.array([[1,1],[1,-1]])/2**0.5;H
vaH = H.dot(va); vaH
vaHvb = np.kron(vaH,vb); vaHvb
vout = C.dot(vaHvb); vout
vout = C.dot(vaHvb); vout
# Get the IBM API key in: https://quantum-computing.ibm.com
# chave = 'My key is already saved in this environment'
# qk.IBMQ.save_account(chave)
# Load the account in the active session
qk.IBMQ.load_account()
# The default provider is é hub='ibm-q', group='open, project='main'
# The code below is executed as an example
provider_1 = qk.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
# In the public provider we will use a cloud simulator.
backend_1 = provider_1.get_backend('ibmq_qasm_simulator')
# The provider listed below has unlimited jobs
provider_2 = qk.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
# For this provider we will use the ibmq_jakarta machine
backend_2 = provider_2.get_backend('ibmq_manila')
# With n Qubits we can generate a random number from 0 to 2^n - 1
n = 3
qr = qk.QuantumRegister(n,'q')
cr = qk.ClassicalRegister(n,'c')
qc = qk.QuantumCircuit(qr, cr)
# Applying a Hadamard to each of the three qubits
for i in range(n):
qc.h(i)
# Measuring the three qubits
qc.measure(qr,cr)
# Visualizing the circuit
qc.draw('mpl')
new_job = qk.execute(qc, backend_2, shots=1)
# this result is stored on the local machine. However, it will only be available
# after the job has been executed. It returns a python dictionary.
new_job.result().get_counts()
int(list(new_job.result().get_counts().keys())[0],2)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(2, 2)
circuit.h(0)
circuit.cx(0,1)
circuit.measure([0,1], [0,1])
display(circuit.draw('mpl'))
from qiskit.providers.aer import AerSimulator
print(AerSimulator().run(circuit, shots=1000).result().get_counts())
print(AerSimulator().run(circuit, shots=1000).result().get_counts())
from qiskit import QuantumCircuit
circuito = QuantumCircuit(3,3)
for i in range(3):
circuito.h(i)
circuito.measure(i,i)
display(circuito.draw('mpl'))
from qiskit.providers.aer import AerSimulator
AerSimulator().run(circuito, shots = 1000).result().get_counts()
from qiskit import QuantumCircuit
qc = QuantumCircuit(4,4)
qc.x([0,1])
qc.cx([0,1],[2,2])
qc.ccx(0,1,3)
qc.measure([0,1,2,3],[0,1,2,3])
display(qc.draw(output='mpl'))
from qiskit.providers.aer import AerSimulator
AerSimulator().run(qc, shots = 10000).result().get_counts()
import qiskit as qk
qr = qk.QuantumRegister(1,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr, cr)
qc.initialize([1,0],0)
print("Circuit 1 - Registers Only")
display(qc.draw('mpl'))
qc.x(qr)
print("Circuit 1 - Quantum Register with a Gate X ")
display(qc.draw('mpl'))
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('statevector_simulator'))
result1 = job.result().get_statevector()
print("Quantum Register Vector State")
from qiskit.tools.visualization import plot_bloch_multivector
display(plot_bloch_multivector(result1))
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('unitary_simulator'))
print("Transformation Matrix (up to this stage)")
print(job.result().get_unitary())
qc.measure(qr, cr)
print()
print("Circuit 1 - Registers, Gate X and Quantum Register Measure")
display(qc.draw('mpl'))
print("Quantum Register Thousand Measures")
job = qk.execute(experiments = qc,
backend = qk.Aer.get_backend('statevector_simulator'),
shots = 1000)
print(job.result().get_counts())
print()
print("Result's Histogram")
from qiskit.tools.visualization import plot_histogram
plot_histogram(data = job.result().get_counts(), figsize=(4,3))
import qiskit as qk
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qr = qk.QuantumRegister(3,'q')
cr = qk.ClassicalRegister(3,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.initialize([1,0],2)
display(qc.draw('mpl'))
sv = Statevector.from_label('000')
state_data = lambda qc,sv: np.round(np.asarray(sv.evolve(qc).data),4)
state_bloch = lambda qc,sv: plot_bloch_multivector(sv.evolve(qc).data, reverse_bits=True)
print(state_data(qc,sv))
state_bloch(qc,sv)
qc.x(0)
qc.barrier()
display(qc.draw('mpl'))
print(state_data(qc,sv))
display(state_bloch(qc,sv))
qc.h(1)
display(qc.draw('mpl'))
print(state_data(qc,sv))
state_bloch(qc,sv)
qc.cnot(1,2)
display(qc.draw("mpl"))
state_data(qc,sv)
state_bloch(qc,sv)
qc.cnot(0,1)
display(qc.draw('mpl'))
state_data(qc,sv)
qc.h(0)
qc.barrier()
display(qc.draw('mpl'))
state_data(qc,sv)
qc.measure(0,0)
qc.measure(1,1)
qc.barrier()
qc.cnot(1,2)
qc.cz(0,2)
qc.measure(2,2)
display(qc.draw('mpl'))
simulador = qk.Aer.get_backend('statevector_simulator')
resultado = qk.execute(qc, simulador, shots=10000).result()
qk.visualization.plot_histogram(resultado.get_counts())
import numpy as np
V = np.array([[3+2j],[4-2j]])
modV = np.real(V.T.conjugate().dot(V)[0,0])**0.5
Vn = V/modV; Vn
v0 = np.array([[1,0]]).T
v1 = np.array([[0,1]]).T
Vn[0,0]*v0 + Vn[1,0]*v1
import qiskit as qk
qr = qk.QuantumRegister(1,'q')
cr = qk.ClassicalRegister(1,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([Vn[0,0],Vn[1,0]],0)
qc.measure(qr[0],cr[0])
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
Vn[0,0].conjugate()*Vn[0,0]
Vn[1,0].conjugate()*Vn[1,0]
import numpy as np
CNOT = np.array([[1,0,0,0],
[0,1,0,0],
[0,0,0,1],
[0,0,1,0]])
CNOT.dot(CNOT)
import numpy as np
H = np.array([[1,1],[1,-1]])/2**0.5
H.dot(H)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import qiskit as qk
qr = qk.QuantumRegister(2,'q')
cr = qk.ClassicalRegister(2,'c')
qc = qk.QuantumCircuit(qr,cr)
qc.initialize([1,0],0)
qc.initialize([1,0],1)
qc.h(0)
qc.cnot(qr[0],qr[1])
qc.cnot(qr[0],qr[1])
qc.measure(qr,cr)
qc.draw('mpl')
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
simulator = qk.Aer.get_backend('statevector_simulator')
results = qk.execute(qc,simulator,shots=10000).result().get_counts()
qk.visualization.plot_histogram(results)
import numpy as np
X = np.array([[0,1],
[1,0]])
X
X.conj().T.dot(X)
Y = np.array([[0,-1j],
[1j,0]])
Y
Y.conj().T.dot(Y)
Z = np.array([[1,0],
[0,-1]])
Z
Z.conj().T.dot(Z)
H = (X+Z)/np.sqrt(2); H
H.dot(Z).dot(H)
H.dot(X).dot(H)
-H.dot(Y).dot(H)
import numpy as np
S = np.array([[1,0],
[0,1j]])
S
S.conj().T.dot(S)
T = np.array([[1,0],
[0,np.exp(1j*np.pi/4)]])
T
T.conj().T.dot(T)
S = np.array([[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]]); S
S.dot(v00)
S.dot(v01)
S.dot(v10)
S.dot(v11)
C_ = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]]);C_
C_ = np.array([[1,0,0,0],
[0,0,0,1],
[0,0,1,0],
[0,1,0,0]]);C_
C.dot(C_).dot(C)
v = v0 + v1; v
n = np.array([[0,0],[0,1]]); n
n.dot(v)
n_ = np.array([[1,0],[0,0]]);n_
I2 = np.identity(2); I2
I2 - n
n_.dot(v)
n.dot(n)
n_.dot(n_)
n.dot(n_)
n_.dot(n)
n.dot(X)
n+n_
X.dot(n_)
import numpy as np
n = np.array([[0,0],[0,1]]); n
n_ = np.array([[1,0],[0,0]]);n_
np.kron(n,n)
np.kron(n_,n_)
np.kron(n,n_)
np.kron(n_,n)
np.kron(X,X)
np.kron(X,X).dot(np.kron(n,n_)+np.kron(n_,n))
np.kron(n,n) + np.kron(n_,n_) + np.kron(X,X).dot(np.kron(n,n_)+np.kron(n_,n))
np.kron(n,n)
np.kron(n_,n_)
np.kron(n_,n)
np.kron(n,n_)
nn = np.kron(n,n)
nn_ = np.kron(n,n_)
n_n = np.kron(n_,n)
n_n_ = np.kron(n_,n_)
nn + nn_ + n_n + n_n_
import numpy as np
n = np.array([[0,0],[0,1]]); n
n_ = np.array([[1,0],[0,0]]);n_
#(n x n).(n_ x n_)
np.kron(n,n).dot(np.kron(n_,n_))
np.kron(n,n).dot(np.kron(n_,n_))
np.kron(n.dot(n_),n.dot(n_))
nn.dot(n_n_)
# (n_ x n).(n x n_)
np.kron(n_,n).dot(np.kron(n,n_))
n_n.dot(nn_)
# (n x n_).(n_ x n)
np.kron(n, n_).dot(np.kron(n_,n))
n_n_.dot(nn)
NOT = np.array([[0,1],[1,0]]); NOT
D0 = np.array([[1],[0]])
D1 = np.array([[0],[1]])
NOT.dot(D0)
NOT.dot(D1)
AND = np.array([[1,1,1,0],[0,0,0,1]]); AND
AND.dot(np.kron(D0,D0))
AND.dot(np.kron(D0,D1))
AND.dot(np.kron(D1,D0))
AND.dot(np.kron(D1,D1))
OR = np.array([[1,0,0,0],[0,1,1,1]]); OR
OR.dot(np.kron(D0,D0))
OR.dot(np.kron(D0,D1))
OR.dot(np.kron(D1,D0))
OR.dot(np.kron(D1,D1))
NAND = np.array([[0,0,0,1],[1,1,1,0]]); NAND
NOT.dot(AND)
NOR = np.array([[0,1,1,1],[1,0,0,0]]);NOR
NOT.dot(OR)
np.kron(NOT,AND)
OR.dot(np.kron(NOT,AND))
NOT.dot(AND).dot(np.kron(NOT,NOT))
OR
NOT.dot(OR).dot(np.kron(NOT,NOT))
AND
import numpy as np
k = np.kron
XOR = np.array([[1,0,0,1],
[0,1,1,0]])
AND = np.array(([1,1,1,0],
[0,0,0,1]))
k(XOR,AND)
def criaCompat(nbits,nvezes):
nlins = 2**(nbits*nvezes)
ncols = 2**nbits
compat = np.zeros(nlins*ncols).reshape(nlins,ncols)
for i in range(ncols):
formato = "0" + str(nbits) + "b"
binario = format(i,formato)*nvezes
decimal = int(binario,2)
compat[decimal,i] = 1
return(compat)
criaCompat(2,2)
k(XOR,AND).dot(criaCompat(2,2))
import numpy as np
k = np.kron
def criaCompat(nbits,nvezes):
nlins = 2**(nbits*nvezes)
ncols = 2**nbits
compat = np.zeros(nlins*ncols).reshape(nlins,ncols)
for i in range(ncols):
formato = "0" + str(nbits) + "b"
binario = format(i,formato)*nvezes
decimal = int(binario,2)
compat[decimal,i] = 1
return(compat)
criaCompat(2,2)
NOT = np.array([[0,1],
[1,0]])
AND3 = np.array([[1,1,1,1,1,1,1,0],
[0,0,0,0,0,0,0,1]])
OR4 = np.array([[1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],
[0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]])
I2 = np.array([[1,0],
[0,1]])
t1z = k(NOT,k(NOT,I2))
t2z = k(NOT,k(I2,NOT))
t3z = k(I2,k(NOT,NOT))
t4z = k(I2,k(I2,I2))
ORz = k(AND3,k(AND3,k(AND3,AND3)))
ORz = OR4.dot(ORz).dot(k(t1z,k(t2z,k(t3z,t4z))))
t1c = k(NOT,k(I2,I2))
t2c = k(I2,k(NOT,I2))
t3c = k(I2,k(I2,NOT))
t4c = k(I2,k(I2,I2))
ORc = k(AND3,k(AND3,k(AND3,AND3)))
ORc = OR4.dot(ORc).dot(k(t1c,k(t2c,k(t3c,t4c))))
compat = criaCompat(3,8)
k(ORz,ORc).dot(compat)
import numpy as np
TOFFOLI = np.array([[1,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,1,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,1,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,1],
[0,0,0,0,0,0,1,0]])
TOFFOLI.dot(TOFFOLI)
Z1 = np.array([[0,0,0,0,0,0,0,0],
[0,1,0,0,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,1,0,0,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,1,0,0],
[0,0,0,0,0,0,0,0],
[0,0,0,0,0,0,0,1]])
Z1
ZpY = np.zeros([8,8])
ZpY[0,0] = 1; ZpY[1,2] = 1; ZpY[2,1] = 1; ZpY[3,3] = 1
ZpY[4,4] = 1; ZpY[5,6] = 1; ZpY[6,5] = 1; ZpY[7,7] = 1
ZpY
Z1I4 = np.array([[0,0,0,0],
[1,0,0,0],
[0,0,0,0],
[0,1,0,0],
[0,0,0,0],
[0,0,1,0],
[0,0,0,0],
[0,0,0,1]])
TOFFOLI.dot(ZpY).dot(TOFFOLI).dot(Z1I4)
Zfim = np.array([[1,0,1,0,1,0,1,0],
[0,1,0,1,0,1,0,1]])
Zfim = np.array([[1,0,1,0,1,0,1,0],
[0,1,0,1,0,1,0,1]])
Zfim.dot(TOFFOLI).dot(ZpY).dot(TOFFOLI).dot(Z1I4)
import numpy as np
fred = np.identity(8)
fred[5,5] = 0; fred[5,6] = 1
fred[6,5] = 1; fred[6,6] = 0
fred
fred.dot(fred)
import numpy as np
Fy0 = np.zeros([8,4])
Fy0[0,0] = 1; Fy0[1,1] = 1; Fy0[4,2] = 1; Fy0[5,3] = 1
Fy0
xYz = np.array([[1,1,0,0,1,1,0,0],
[0,0,1,1,0,0,1,1]])
xYz.dot(fred).dot(Fy0)
|
https://github.com/TRSasasusu/qiskit-quantum-zoo
|
TRSasasusu
|
from typing import Optional
import math
import numpy as np
import matplotlib.pyplot as plt
from sympy import gcdex
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
from sympy import Rational, gcdex
from sympy.ntheory.continued_fraction import continued_fraction, continued_fraction_convergents
from qft import qft
from elementary import ax_modM
from order_finding import order_finding
from classical_utils import decode_bin
def discrete_log(a: int, b: int, p: int, show_hist: Optional[bool] = False, coef_t: Optional[int] = 1) -> int:
"""Shor's discrete log algorithm: given $a,b,p\in\mathbb{Z}$, it finds $s$ such that $a^s\equiv b\pmod p$.
Args:
a (int): $a$
b (int): $b$
p (int): $p$
"""
r = order_finding(x=a, N=p, show_hist=False)
t = coef_t * int(np.ceil(np.log2(p)))
first_register = QuantumRegister(t)
second_register = QuantumRegister(t)
third_register = QuantumRegister(2 * t)
auxiliary_register_mid = QuantumRegister(t)
auxiliary_register_end = QuantumRegister(6 * t - 2)
classical_register = ClassicalRegister(2 * t)
qc = QuantumCircuit(
first_register,
second_register,
third_register,
auxiliary_register_mid,
auxiliary_register_end,
classical_register,
)
qc.h(first_register)
qc.h(second_register)
qc.append(ax_modM(a=b, M=p, N_len=t), list(first_register) + list(auxiliary_register_mid) + list(third_register) + list(auxiliary_register_end))
qc.append(ax_modM(a=a, M=p, N_len=t, x_0_at_first=False), list(second_register) + list(auxiliary_register_mid) + list(third_register) + list(auxiliary_register_end))
qc.append(qft(n=t).inverse(), first_register)
qc.append(qft(n=t).inverse(), second_register)
qc.measure(list(first_register) + list(second_register), classical_register)
#qc.measure(third_register, classical_register)
backend = Aer.get_backend('aer_simulator_matrix_product_state')#('aer_simulator')
qc = transpile(qc, backend)
job = backend.run(qc, shots=10000)
hist = job.result().get_counts()
if show_hist:
figsize_x = max(7 * (len(hist) // 8), 7)
plot_histogram(hist, figsize=(figsize_x, 5))
plt.savefig(f'img/discrete_log_a{a}_b{b}_p{p}_r{r}_t{t}.png', bbox_inches='tight')
for measured_key, _ in sorted(hist.items(), key=lambda x: x[1], reverse=True):
tilde_l_per_r = Rational(decode_bin(measured_key[:t]), 2 ** t) # decoded from second register: $\widetilde{l/r}$
if tilde_l_per_r == 0:
continue
l = None
for fraction in continued_fraction_convergents(continued_fraction(tilde_l_per_r)):
if fraction.denominator == r:
l = fraction.numerator # get correct $l$
break
if l is None:
continue
tilde_beta_per_r = Rational(decode_bin(measured_key[-t:]), 2 ** t) # decoded from first register: $\widetilde{\beta/r}$
if tilde_beta_per_r == 0:
if pow(a, 0, p) == b: # the case where b == 1
return r # returning 0 is also ok
continue
beta = None
for fraction in continued_fraction_convergents(continued_fraction(tilde_beta_per_r)):
if fraction.denominator == r:
beta = fraction.numerator # get correct $\beta$
break
if beta is None:
continue
s, alpha, _ = gcdex(l, -r)
s = int(s * beta)
if pow(a, s, p) == b:
return s
raise Exception('s is NOT found!')
if __name__ == '__main__':
#print(discrete_log(a=2, b=4, p=7, show_hist=True))
#print(discrete_log(a=3, b=5, p=11, show_hist=True, coef_t=2))
print(discrete_log(a=2, b=1, p=3, show_hist=True, coef_t=1))
|
https://github.com/TRSasasusu/qiskit-quantum-zoo
|
TRSasasusu
|
"""
Implementing [arXiv:quant-ph/9511018](https://arxiv.org/abs/quant-ph/9511018)
"""
from typing import Optional
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit import Gate
def carry() -> Gate:
"""CARRY. It requires 4 qubits.
Returns:
its gate
"""
qc = QuantumCircuit(4)
qc.ccx(1, 2, 3)
qc.cx(1, 2)
qc.ccx(0, 2, 3)
return qc.to_gate()
def qsum() -> Gate:
"""SUM. It requires 3 qubits.
Returns:
its gate
"""
qc = QuantumCircuit(3)
qc.cx(1, 2)
qc.cx(0, 2)
return qc.to_gate()
def adder(n: int) -> Gate:
r"""ADDER: $a,b\to a,a+b$. It requires $3n+1$ qubits: $a$ uses $n$ qubits, $b$ uses $n+1$ qubits, and $c$ uses $n$ qubits.
Args:
n (int): $n$ bits for representing $a$.
Returns:
its gate
"""
qubits = QuantumRegister(n + (n + 1) + n)
a = qubits[:n]
b = qubits[n:n + (n + 1)]
c = qubits[n + (n + 1):]
qc = QuantumCircuit(qubits)
carry_gate = carry()
carry_gate_dag = carry_gate.inverse()
sum_gate = qsum()
for i in range(n - 1):
qc.append(carry_gate, [c[i]] + [a[i]] + [b[i]] + [c[i + 1]])
qc.append(carry_gate, [c[n - 1]] + [a[-1]] + [b[n - 1]] + [b[n]])
qc.cx(a[-1], b[n - 1])
qc.append(sum_gate, [c[n - 1]] + [a[-1]] + [b[n - 1]])
for i in reversed(range(n - 1)):
qc.append(carry_gate_dag, [c[i]] + [a[i]] + [b[i]] + [c[i + 1]])
qc.append(sum_gate, [c[i]] + [a[i]] + [b[i]])
return qc.to_gate()
def adder_modM(M: int, N_len: int) -> Gate:
r"""ADDER MOD: $a,b\to a,a+b\mod M$. It requires $4N_\mathit{len}+2$ qubits: $a$ uses $N_\mathit{len}$ qubits, $b$ uses $N_\mathit{len}+1$ qubits, $c$ uses $N_\mathit{len}$ qubits, $M$ uses $N_\mathit{len}$ qubits, and $t$ uses 1 qubit.
Args:
M (int): $N$ in the paper, but we uses $M$ instead.
N_len (int): a number of bits for representing $a$.
Returns:
its gate
"""
M_val = M
qubits = QuantumRegister(N_len + (N_len + 1) + N_len + N_len + 1)
a, left_qubits = qubits[:N_len], qubits[N_len:]
b, left_qubits = left_qubits[:N_len + 1], left_qubits[N_len + 1:]
c, left_qubits = left_qubits[:N_len], left_qubits[N_len:]
M, left_qubits = left_qubits[:N_len], left_qubits[N_len:]
t = left_qubits[:1]
qc = QuantumCircuit(qubits)
adder_gate = adder(N_len)
adder_gate_dag = adder_gate.inverse()
for i, char in enumerate(bin(M_val)[2:][::-1]):
if char == '1':
qc.x(M[i])
qc.append(adder_gate, a + b + c)
qc.append(adder_gate_dag, M + b + c)
qc.x(b[-1])
qc.cx(b[-1], t[0])
qc.x(b[-1])
for i, char in enumerate(bin(M_val)[2:][::-1]):
if char == '1':
qc.cx(t[0], M[i])
qc.append(adder_gate, M + b + c)
for i, char in enumerate(bin(M_val)[2:][::-1]):
if char == '1':
qc.cx(t[0], M[i])
qc.append(adder_gate_dag, a + b + c)
qc.cx(b[-1], t[0])
qc.append(adder_gate, a + b + c)
for i, char in enumerate(bin(M_val)[2:][::-1]):
if char == '1':
qc.x(M[i])
return qc.to_gate()
def ctrl_multi_modM(a: int, M: int, N_len: int) -> Gate:
r"""Ctrl MULT MOD: $x,0\to x,ax\mod M$ if $c=1$, otherwise $x,0\to x,x$. It requires $9N_\mathit{len}-1$ qubits: $\mathit{ctrl}$ uses 1 qubit, $x$ uses $N_\mathit{len}$ qubits, $y$ uses $2N_\mathit{len}$ qubits, $\mathit{xx}$ (which is a register in the middle of Fig. 5 in the paper) uses $2N_\mathit{len}-1$ qubits, $c$ (which is $c$ for ADDER MOD) uses $2N_\mathit{len}-1$ qubits, $M$ (which is $M$ for ADDER MOD) uses $2N_\mathit{len}-1$ qubits, and $t$ (which is $t$ for ADDER MOD) uses 1 qubit.
Args:
a (int): $a$
M (int): $M$ (see `adder_modM`)
N_len (int): a number of bits for representing $x$
Returns:
its gate
"""
M_val = M
N_len = N_len
qubits = QuantumRegister(9 * N_len - 1)
ctrl, left_qubits = qubits[:1], qubits[1:]
x, left_qubits = left_qubits[:N_len], left_qubits[N_len:]
y, left_qubits = left_qubits[:2 * N_len], left_qubits[2 * N_len:]
xx, left_qubits = left_qubits[:2 * N_len - 1], left_qubits[2 * N_len - 1:]
c, left_qubits = left_qubits[:2 * N_len - 1], left_qubits[2 * N_len - 1:]
M, left_qubits = left_qubits[:2 * N_len - 1], left_qubits[2 * N_len - 1:]
t, left_qubits = left_qubits[:1], qubits[1:]
qc = QuantumCircuit(qubits)
adder_modM_gate = adder_modM(M=M_val, N_len=2 * N_len - 1)
for i in range(N_len):
for j, char in enumerate(bin(2 ** i * a % M_val)[2:][::-1]):
if char == '1':
qc.ccx(ctrl[0], x[i], xx[j])
qc.append(adder_modM_gate, xx + y + c + M + t)
for j, char in enumerate(bin(2 ** i * a % M_val)[2:][::-1]):
if char == '1':
qc.ccx(ctrl[0], x[i], xx[j])
qc.x(ctrl[0])
for x_bit, y_bit in zip(x, y):
qc.ccx(ctrl[0], x_bit, y_bit)
qc.x(ctrl[0])
return qc.to_gate()
def ax_modM(a: int, M: int, N_len: Optional[int] = None, x_0_at_first: bool = True) -> Gate:
r"""Modular exponentiation, $a^x\mod M$. It requires $10N_\mathit{len}-2$ qubits: $x$ uses $N_\mathit{len}$ qubits, $\mathit{x\ for\ Ctrl\ MULT\ MOD}$ uses $N_\mathit{len}$ qubits, $y$ uses $2N_\mathit{len}$ qubits, $\mathit{xx}$ uses $2N_\mathit{len}-1$ qubits, $c$ (which is $c$ for ADDER MOD) uses $2N_\mathit{len}-1$ qubits, $M$ (which is $M$ for ADDER MOD) uses $2N_\mathit{len}-1$ qubits, and $t$ (which is $t$ for ADDER MOD) uses 1 qubit.
Args:
a (int): $a$
M (int): $M$ (see `adder_modM`)
N_len (int): a number of bits for representing $x$
x_0_at_first (bool): if True, it adds 1 into the target register before calculating modular exponentiation
Returns:
its gate
"""
M_val = M
if N_len is None:
N_len = int(np.ceil(np.log2(M)))
qubits = QuantumRegister(10 * N_len - 2)
x, left_qubits = qubits[:N_len], qubits[N_len:]
x_for_ctrl_multi_modM_gate, left_qubits = left_qubits[:N_len], left_qubits[N_len:]
y, left_qubits = left_qubits[:2 * N_len], left_qubits[2 * N_len:]
xx, left_qubits = left_qubits[:2 * N_len - 1], left_qubits[2 * N_len - 1:]
c, left_qubits = left_qubits[:2 * N_len - 1], left_qubits[2 * N_len - 1:]
M, left_qubits = left_qubits[:2 * N_len - 1], left_qubits[2 * N_len - 1:]
t, left_qubits = left_qubits[:1], qubits[1:]
qc = QuantumCircuit(qubits)
if x_0_at_first:
qc.x(x_for_ctrl_multi_modM_gate[0])
for i in range(N_len):
ctrl_multi_modM_gate = ctrl_multi_modM(pow(a, 2 ** i, M_val), M_val, N_len)
ctrl_multi_modM_gate_dag = ctrl_multi_modM(pow(a, -2 ** i, M_val), M_val, N_len).inverse()
qc.append(ctrl_multi_modM_gate, [x[i]] + x_for_ctrl_multi_modM_gate + y + xx + c + M + t)
for j in range(N_len):
qc.cswap(x[i], x_for_ctrl_multi_modM_gate[j], y[j])
qc.append(ctrl_multi_modM_gate_dag, [x[i]] + x_for_ctrl_multi_modM_gate + y + xx + c + M + t)
return qc.to_gate()
|
https://github.com/TRSasasusu/qiskit-quantum-zoo
|
TRSasasusu
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/TRSasasusu/qiskit-quantum-zoo
|
TRSasasusu
|
from typing import Optional
from math import gcd
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
from sympy import Rational
from sympy.ntheory.continued_fraction import continued_fraction, continued_fraction_convergents
from qft import qft
from elementary import ax_modM
from classical_utils import lcm
def order_finding(x: int, N: int, show_hist: Optional[bool] = False) -> int:
#def order_finding(x: int, N: int, epsilon: Optional[float] = 0.2, show_hist: Optional[bool] = False) -> int:
r"""Order-finding algorithm: it finds $r$ of $x^r\equiv 1\pmod N$. It requires
Args:
x (int): $x$
N (int): $N$
Returns:
order $r$
Examples:
```
>>> order_finding(x=3, N=5, show_hist=True)
4
```
and get below image in `img` directory:
It represents $0/2^6=0$, $2^4/2^6=1/4$, $2^5/2^6=1/2$, and $(2^4+2^5)/2^6=3/4$ from the left.
This answer is $r=4$, so $1/2$ looks wrong.
However, $\tilde{r}=2$ is a factor of $r$, so we can get correct $r$ by lcm with another $\tilde{r}$.
"""
L = int(np.ceil(np.log2(N)))
t = 2 * L# + 1 + int(np.ceil(np.log2(3 + 1 / (2 * epsilon)))) # epsilon requires too many qubits to run this program...
first_register = QuantumRegister(t)
second_register = QuantumRegister(2 * t)
auxiliary_register_mid = QuantumRegister(t)
auxiliary_register_end = QuantumRegister(6 * t - 2)
classical_register = ClassicalRegister(len(first_register))
qc = QuantumCircuit(first_register, auxiliary_register_mid, second_register, auxiliary_register_end, classical_register)
# qc.add_register(first_register)
# qc.add_register(second_register)
# qc.add_register(classical_register)
qc.h(first_register)
#import pdb; pdb.set_trace()
#qc.append(ax_modM(a=x, M=N, N_len=len(first_register)), [first_register, auxiliary_register_mid, second_register, auxiliary_register_end])
qc.append(ax_modM(a=x, M=N, N_len=len(first_register)), qc.qubits[:10 * t - 2])
qc.append(qft(n=len(first_register)).inverse(), first_register)
qc.measure(first_register, classical_register)
backend = Aer.get_backend('aer_simulator_matrix_product_state')#('aer_simulator')
qc = transpile(qc, backend)
job = backend.run(qc, shots=10000)
hist = job.result().get_counts()
if show_hist:
plot_histogram(hist)
plt.savefig(f'img/order_finding_x{x}_N{N}.png', bbox_inches='tight')
#plt.savefig(f'img/order_finding_x{x}_N{N}_eps{epsilon}.png', bbox_inches='tight')
all_fractions = []
for measured_key, _ in sorted(hist.items(), key=lambda x: x[1], reverse=True):
tilde_s_per_r = Rational(int(measured_key[-t:], 2), 2 ** t)
if tilde_s_per_r == 0:
continue
fractions = []
for fraction in continued_fraction_convergents(continued_fraction(tilde_s_per_r)):
if pow(x, fraction.denominator, N) == 1:
return fraction.denominator
fractions.append(fraction)
for other_fraction in all_fractions:
if math.gcd(fraction.numerator, other_fraction.numerator) == 1:
r_candidate = lcm(fraction.denominator, other_fraction.denominator)
if pow(x, r_candidate, N) == 1:
return r_candidate
raise Exception('r is NOT found!')
if __name__ == '__main__':
#print(order_finding(x=5, N=21, show_hist=True))
print(order_finding(x=3, N=5, show_hist=True))
|
https://github.com/TRSasasusu/qiskit-quantum-zoo
|
TRSasasusu
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
This module contains the definition of a base class for quantum fourier transforms.
"""
from abc import abstractmethod
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.aqua import Pluggable, AquaError
class QFT(Pluggable):
"""Base class for QFT.
This method should initialize the module and its configuration, and
use an exception if a component of the module is
available.
Args:
configuration (dict): configuration dictionary
"""
@abstractmethod
def __init__(self, *args, **kwargs):
super().__init__()
@classmethod
def init_params(cls, params):
qft_params = params.get(Pluggable.SECTION_KEY_QFT)
kwargs = {k: v for k, v in qft_params.items() if k != 'name'}
return cls(**kwargs)
@abstractmethod
def _build_matrix(self):
raise NotImplementedError
@abstractmethod
def _build_circuit(self, qubits=None, circuit=None, do_swaps=True):
raise NotImplementedError
def construct_circuit(self, mode='circuit', qubits=None, circuit=None, do_swaps=True):
"""Construct the circuit.
Args:
mode (str): 'matrix' or 'circuit'
qubits (QuantumRegister or qubits): register or qubits to build the circuit on.
circuit (QuantumCircuit): circuit for construction.
do_swaps (bool): include the swaps.
Returns:
The matrix or circuit depending on the specified mode.
"""
if mode == 'circuit':
return self._build_circuit(qubits=qubits, circuit=circuit, do_swaps=do_swaps)
elif mode == 'matrix':
return self._build_matrix()
else:
raise AquaError('Unrecognized mode: {}.'.format(mode))
|
https://github.com/TRSasasusu/qiskit-quantum-zoo
|
TRSasasusu
|
"""The following is python code utilizing the qiskit library that can be run on extant quantum
hardware using 5 qubits for factoring the integer 15 into 3 and 5. Using period finding,
for a^r mod N = 1, where a = 11 and N = 15 (the integer to be factored) the problem is to find
r values for this identity such that one can find the prime factors of N. For 11^r mod(15) =1,
results (as shown in fig 1.) correspond with period r = 4 (|00100>) and r = 0 (|00000>).
To find the factor, use the equivalence a^r mod 15. From this:
(a^r -1) mod 15 = (a^(r/2) + 1)(a^(r/2) - 1) mod 15.In this case, a = 11. Plugging in the two r
values for this a value yields (11^(0/2) +1)(11^(4/2) - 1) mod 15 = 2*(11 +1)(11-1) mod 15
Thus, we find (24)(20) mod 15. By finding the greatest common factor between the two coefficients,
gcd(24,15) and gcd(20,15), yields 3 and 5 respectively. These are the prime factors of 15,
so the result of running shors algorithm to find the prime factors of an integer using quantum
hardware are demonstrated. Note, this is not the same as the technical implementation of shor's
algorithm described in this section for breaking the discrete log hardness assumption,
though the proof of concept remains."""
# Import libraries
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from numpy import pi
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.visualization import plot_histogram
# Initialize qubit registers
qreg_q = QuantumRegister(5, 'q')
creg_c = ClassicalRegister(5, 'c')
circuit = QuantumCircuit(qreg_q, creg_c)
circuit.reset(qreg_q[0])
circuit.reset(qreg_q[1])
circuit.reset(qreg_q[2])
circuit.reset(qreg_q[3])
circuit.reset(qreg_q[4])
# Apply Hadamard transformations to qubit registers
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.h(qreg_q[2])
# Apply first QFT, modular exponentiation, and another QFT
circuit.h(qreg_q[1])
circuit.cx(qreg_q[2], qreg_q[3])
circuit.crx(pi/2, qreg_q[0], qreg_q[1])
circuit.ccx(qreg_q[2], qreg_q[3], qreg_q[4])
circuit.h(qreg_q[0])
circuit.rx(pi/2, qreg_q[2])
circuit.crx(pi/2, qreg_q[1], qreg_q[2])
circuit.crx(pi/2, qreg_q[1], qreg_q[2])
circuit.cx(qreg_q[0], qreg_q[1])
# Measure the qubit registers 0-2
circuit.measure(qreg_q[2], creg_c[2])
circuit.measure(qreg_q[1], creg_c[1])
circuit.measure(qreg_q[0], creg_c[0])
# Get least busy quantum hardware backend to run on
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
# Run the circuit on available quantum hardware and plot histogram
from qiskit.tools.monitor import job_monitor
job = execute(circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(circuit)
plot_histogram(answer)
#largest amplitude results correspond with r values used to find the prime factor of N.
|
https://github.com/TRSasasusu/qiskit-quantum-zoo
|
TRSasasusu
|
import unittest
import numpy as np
from sympy.physics.quantum.qubit import matrix_to_qubit
from qiskit import QuantumCircuit, Aer, transpile
from qqz.elementary import (
adder,
adder_modN,
ctrl_multi_modN,
ax_modN,
)
def run_qc_and_get_ket_vector(qc):
backend = Aer.get_backend('aer_simulator_statevector')
qc = transpile(qc, backend)
qc.save_statevector()
job = backend.run(qc)
statevector = job.result().get_statevector(qc)
return matrix_to_qubit(np.array(statevector)[:, np.newaxis])
class TestElementary(unittest.TestCase):
def test_adder(self):
qc = QuantumCircuit(2 + (2 + 1) + 2)
qc.x([0, 1])
qc.x(2)
qc.append(adder(2), range(2 + (2 + 1) + 2))
ket_vector = run_qc_and_get_ket_vector(qc)
self.assertEqual(str(ket_vector), '1.0*|0010011>')
def test_adder_modN(self):
qc = QuantumCircuit(2 + (2 + 1) + 2 + 2 + 1)
qc.x([0, 1])
qc.x(2)
qc.append(adder_modN(3), range(2 + (2 + 1) + 2 + 2 + 1))
ket_vector = run_qc_and_get_ket_vector(qc)
self.assertEqual(str(ket_vector), '1.0*|0000000111>')
def test_ctrl_multi_modN(self):
qc = QuantumCircuit(9 * 2 - 1)
qc.h(0)
qc.x(2)
qc.append(ctrl_multi_modN(a=2, N=3), range(9 * 2 - 1))
ket_vector = run_qc_and_get_ket_vector(qc)
self.assertEqual(str(ket_vector), '0.707106781186547*|00000000000001101> + 0.707106781186548*|00000000000010100>')
def test_ax_modN(self):
qc = QuantumCircuit(10 * 2 - 2)
qc.h([0, 1])
qc.append(ax_modN(a=2, N=3), range(10 * 2 - 2))
ket_vector = run_qc_and_get_ket_vector(qc)
self.assertEqual(str(ket_vector), '0.5*|000000000000000100> + 0.5*|000000000000000110> + 0.5*|000000000000001001> + 0.5*|000000000000001011>')
if __name__ == '__main__':
unittest.main()
|
https://github.com/animeshnanda1/my_QAOA_qiskit
|
animeshnanda1
|
import qiskit
qiskit.__qiskit_version__
# import warnings; warnings.filterwarnings("ignore")
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer
from qiskit.visualization import plot_histogram
G = nx.Graph()
Lx=6
G.add_nodes_from([i for i in range(Lx)])
G.add_edges_from([[i,i+1] for i in range(Lx-1)])
G.add_edges_from([[Lx-1,0]])
options = {
'node_color': 'y',
'node_size': 1000,
'width': 3,
}
nx.draw(G, with_labels=True,pos=nx.circular_layout(G),**options)
print(list(G.edges()))
print(G.number_of_nodes())
def ham_rot(G,gamma):
L=G.number_of_nodes()
qc=QuantumCircuit(L,L)
for i,j in list(G.edges()):
qc.cx(i,j)
qc.rz(2*gamma,j)
qc.cx(i,j)
return qc
qc = ham_rot(G, np.pi/3)
print(G.edges())
qc.draw()
def x_field_rot(G, beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N,N)
for n in G.nodes():
qc.rx(2*beta, n)
return qc
qc = x_field_rot(G, np.pi/3)
qc.draw()
def qaoa_circuit(G,beta,gamma):
assert(len(beta)==len(gamma))
layer=len(beta)
L=G.number_of_nodes()
qc=QuantumCircuit(L,L)
qc.h(range(L))
for k in range(layer):
qc=qc+ham_rot(G,gamma[k])
qc=qc+x_field_rot(G,beta[k])
qc.measure(range(L), range(L))
return qc
qc = qaoa_circuit(G,[np.pi/3], [np.pi/2])
qc.draw()
def invert_counts(counts):
return {k[::-1]:v for k, v in counts.items()}
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend,shots=2048) # this is just a test run for the above circuit
result = job.result()
print(result.get_counts())
def ising_energy(x,G):
ener = 0
for i, j in G.edges():
if x[i] != x[j]:
# the edge is cut
ener -= 1
elif x[i] == x[j]:
# the edge is cut
ener += 1
return ener
ising_energy('010101', G),ising_energy('111110', G)
def compute_ising_energy(counts, G):
energy = 0
total_counts = 0
for meas, meas_count in counts.items(): # meas and meas_count are the state and freq
# print(type(meas),meas_count)
obj_for_meas = ising_energy(meas, G) # calling the state to compute the energy
energy += obj_for_meas * meas_count
total_counts += meas_count # energy is total energy of all the states
return energy / total_counts # total_counts is total number of sampling
compute_ising_energy(invert_counts(result.get_counts()), G)
invert_counts(result.get_counts());
# here p is the number of layer used for the optimize
def get_black_box_objective(G,p,list1):
backend = Aer.get_backend('qasm_simulator')
def f(theta):
# let's assume first half is betas, second half is gammas
# theta is a 2*p length array, first 'p' entries are gamma and rest are beta
beta = theta[:p]
gamma = theta[p:]
qc = qaoa_circuit(G,beta, gamma)
counts = execute(qc, backend,shots=1024, seed_simulator=100).result().get_counts()
# return the energy
ener=compute_ising_energy(invert_counts(counts), G)
list1.append(ener)
return ener, list1
return f
# p is the number of QAOA alternating operators
p = 5
energy_qasm=[]
obj = get_black_box_objective(G, p, energy_qasm)
init_point = np.array([0.81069872, 2.2067517 , 1.83830696, 2.15579759, 0.37060699,
2.42068091, 6.1575306 , 2.2453419 , 0.85060091, 3.137845 ])
# We are going to limit the number of iterations to 2500
res_sample = minimize(obj, init_point, method='COBYLA', options={'maxiter':2500, 'disp': True})
res_sample
# Once we have gotten the optimum beta and gamma we run the circuit again with the
optimal_theta = res_sample['x']
qc = qaoa_circuit(G, optimal_theta[:p], optimal_theta[p:])
counts = invert_counts(execute(qc, backend,shots=2048).result().get_counts())
counts
plot_histogram(counts,figsize=(12,4))
# get the best solution:
best_cut, best_solution = min([(ising_energy(x,G),x) for x in counts.keys()], key=itemgetter(0))
print(f"Best string: {best_solution} with cut: {-best_cut}")
# color the graph nodes by part
colors = ['c' if best_solution[node] == '0' else 'y' for node in G]
options = {
'node_size': 1000,
'width': 3,
}
nx.draw(G, with_labels=True,node_color = colors,pos=nx.circular_layout(G),**options)
len(energy_qasm);
def state_to_ampl_counts(vec, eps=1e-15):
"""Converts a statevector to a dictionary
of bitstrings and corresponding amplitudes
"""
qubit_dims = np.log2(vec.shape[0])
if qubit_dims % 1:
raise ValueError("Input vector is not a valid statevector for qubits.")
qubit_dims = int(qubit_dims)
counts = {}
str_format = '0{}b'.format(qubit_dims)
for kk in range(vec.shape[0]):
val = vec[kk]
if val.real**2+val.imag**2 > eps:
counts[format(kk, str_format)] = val
return counts
def compute_ising_energy_sv(sv, G):
"""Compute objective from statevector
For large number of qubits, this is slow.
"""
counts = state_to_ampl_counts(sv)
return sum(ising_energy(np.array([int(x) for x in k]), G) * (np.abs(v)**2) for k, v in counts.items())
def get_qaoa_circuit_sv(G, beta, gamma):
assert(len(beta) == len(gamma))
p = len(beta) # infering number of QAOA steps from the parameters passed
N = G.number_of_nodes()
qc = QuantumCircuit(N,N)
# first, apply a layer of Hadamards
qc.h(range(N))
# second, apply p alternating operators
for k in range(p):
qc=qc+ham_rot(G,gamma[k])
qc=qc+x_field_rot(G,beta[k])
# no measurement in the end!
return qc
def get_black_box_objective_sv(G,p,list1):
backend = Aer.get_backend('statevector_simulator')
def f(theta):
# let's assume first half is betas, second half is gammas
beta = theta[:p]
gamma = theta[p:]
qc = get_qaoa_circuit_sv(G,beta, gamma)
sv = execute(qc, backend).result().get_statevector() # the sv is np.array with complex entries
# return the energy
ener=compute_ising_energy_sv(sv, G)
list1.append(ener)
return ener, list1
return f
# p is the number of QAOA alternating operators
energy_sv=[]
obj = get_black_box_objective_sv(G, p, energy_sv)
init_point = np.array([0.81069872, 2.2067517 , 0.83830696, 2.15579759, 0.37060699,
2.42068091, 6.1575306 , 2.2453419 , 3.85060091, 6.137845 ])
p = len(init_point)//2
# We are going to limit the number of iterations to 2500
res_sv = minimize(obj, init_point, method='COBYLA', options={'maxiter':2500, 'disp': True})
res_sv
# Once we have gotten the optimum beta and gamma we run the circuit again with the
backend = Aer.get_backend('qasm_simulator')
optimal_theta = res_sv['x']
qc = qaoa_circuit(G, optimal_theta[:p], optimal_theta[p:])
counts = invert_counts(execute(qc, backend,shots=2048).result().get_counts())
counts
plot_histogram(counts,figsize=(8,4))
len(energy_sv);
ms=6
x_sv=np.arange(1,len(energy_sv)+1)
x_qasm=np.arange(1,len(energy_qasm)+1)
plt.figure(figsize=(7,6))
plt.plot(x_sv,energy_sv,'b-',markersize=ms,label='Statevector')
plt.plot(x_qasm,energy_qasm,'r--',markersize=ms,label='QASM')
plt.xlabel('Iterations',fontsize=16)
plt.ylabel('Energy',fontsize=16)
plt.xticks(fontsize=16)
plt.yticks(fontsize=16)
plt.legend(fontsize=16)
# plt.title('Plot of gap for different $t_2$, at $t_1=0$ ')
plt.grid()
plt.tight_layout()
# plt.yscale('log')
# plt.legend(loc='upper right',fontsize=16)
# plt.savefig('%s/gap_t2.pdf'%(loc), bbox_inches='tight')
plt.show()
print(f"Angles found with samples: beta={res_sample['x'][:p]}, gamma={res_sample['x'][p:]}")
print(f"Angles found with full state: beta={res_sv['x'][:p]}, gamma={res_sv['x'][p:]}")
|
https://github.com/animeshnanda1/my_QAOA_qiskit
|
animeshnanda1
|
import qiskit
qiskit.__qiskit_version__
# import warnings; warnings.filterwarnings("ignore")
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer
from qiskit.visualization import plot_histogram
G = nx.Graph()
Lx=6
G.add_nodes_from([i for i in range(Lx)])
G.add_edges_from([[i,i+1] for i in range(Lx-1)])
G.add_edges_from([[Lx-1,0]])
options = {
'node_color': 'y',
'node_size': 1000,
'width': 3,
}
nx.draw(G, with_labels=True,pos=nx.circular_layout(G),**options)
print(list(G.edges()))
print(G.number_of_nodes())
def ham_rot(G,gamma):
L=G.number_of_nodes()
qc=QuantumCircuit(L,L)
for i,j in list(G.edges()):
qc.cx(i,j)
qc.rz(2*gamma,j)
qc.cx(i,j)
return qc
qc = ham_rot(G, np.pi/3)
print(G.edges())
qc.draw()
def x_field_rot(G, beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N,N)
for n in G.nodes():
qc.rx(2*beta, n)
return qc
qc = x_field_rot(G, np.pi/3)
qc.draw()
def qaoa_circuit(G,beta,gamma):
assert(len(beta)==len(gamma))
layer=len(beta)
L=G.number_of_nodes()
qc=QuantumCircuit(L,L)
qc.h(range(L))
for k in range(layer):
qc=qc+ham_rot(G,gamma[k])
qc=qc+x_field_rot(G,beta[k])
qc.measure(range(L), range(L))
return qc
qc = qaoa_circuit(G,[np.pi/3], [np.pi/2])
qc.draw()
def invert_counts(counts):
return {k[::-1]:v for k, v in counts.items()}
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend,shots=2048) # this is just a test run for the above circuit
result = job.result()
print(result.get_counts())
def ising_energy(x,G):
ener = 0
for i, j in G.edges():
if x[i] != x[j]:
# the edge is cut
ener += 1
elif x[i] == x[j]:
# the edge is cut
ener -= 1
return ener
ising_energy('010101', G),ising_energy('111110', G)
def compute_ising_energy(counts, G):
energy = 0
total_counts = 0
for meas, meas_count in counts.items(): # meas and meas_count are the state and freq
# print(type(meas),meas_count)
obj_for_meas = ising_energy(meas, G) # calling the state to compute the energy
energy += obj_for_meas * meas_count
total_counts += meas_count # energy is total energy of all the states
return energy / total_counts # total_counts is total number of sampling
compute_ising_energy(invert_counts(result.get_counts()), G)
invert_counts(result.get_counts());
# here p is the number of layer used for the optimize
def get_black_box_objective(G,p,list1):
backend = Aer.get_backend('qasm_simulator')
def f(theta):
# let's assume first half is betas, second half is gammas
# theta is a 2*p length array, first 'p' entries are gamma and rest are beta
beta = theta[:p]
gamma = theta[p:]
qc = qaoa_circuit(G,beta, gamma)
counts = execute(qc, backend,shots=1024, seed_simulator=100).result().get_counts()
# return the energy
ener=compute_ising_energy(invert_counts(counts), G)
list1.append(ener)
return ener, list1
return f
# p is the number of QAOA alternating operators
p = 5
energy_qasm=[]
obj = get_black_box_objective(G, p, energy_qasm)
init_point = np.array([0.81069872, 2.2067517 , 1.83830696, 2.15579759, 0.37060699,
2.42068091, 6.1575306 , 2.2453419 , 0.85060091, 3.137845 ])
# We are going to limit the number of iterations to 2500
res_sample = minimize(obj, init_point, method='COBYLA', options={'maxiter':2500, 'disp': True})
res_sample
# Once we have gotten the optimum beta and gamma we run the circuit again with the
optimal_theta = res_sample['x']
qc = qaoa_circuit(G, optimal_theta[:p], optimal_theta[p:])
counts = invert_counts(execute(qc, backend,shots=2048).result().get_counts())
counts
plot_histogram(counts,figsize=(12,4))
# get the best solution:
best_cut, best_solution = min([(ising_energy(x,G),x) for x in counts.keys()], key=itemgetter(0))
print(f"Best string: {best_solution} with cut: {-best_cut}")
# color the graph nodes by part
colors = ['c' if best_solution[node] == '0' else 'y' for node in G]
options = {
'node_size': 1000,
'width': 3,
}
nx.draw(G, with_labels=True,node_color = colors,pos=nx.circular_layout(G),**options)
len(energy_qasm);
def state_to_ampl_counts(vec, eps=1e-15):
"""Converts a statevector to a dictionary
of bitstrings and corresponding amplitudes
"""
qubit_dims = np.log2(vec.shape[0])
if qubit_dims % 1:
raise ValueError("Input vector is not a valid statevector for qubits.")
qubit_dims = int(qubit_dims)
counts = {}
str_format = '0{}b'.format(qubit_dims)
for kk in range(vec.shape[0]):
val = vec[kk]
if val.real**2+val.imag**2 > eps:
counts[format(kk, str_format)] = val
return counts
def compute_ising_energy_sv(sv, G):
"""Compute objective from statevector
For large number of qubits, this is slow.
"""
counts = state_to_ampl_counts(sv)
return sum(ising_energy(np.array([int(x) for x in k]), G) * (np.abs(v)**2) for k, v in counts.items())
def get_qaoa_circuit_sv(G, beta, gamma):
assert(len(beta) == len(gamma))
p = len(beta) # infering number of QAOA steps from the parameters passed
N = G.number_of_nodes()
qc = QuantumCircuit(N,N)
# first, apply a layer of Hadamards
qc.h(range(N))
# second, apply p alternating operators
for k in range(p):
qc=qc+ham_rot(G,gamma[k])
qc=qc+x_field_rot(G,beta[k])
# no measurement in the end!
return qc
def get_black_box_objective_sv(G,p,list1):
backend = Aer.get_backend('statevector_simulator')
def f(theta):
# let's assume first half is betas, second half is gammas
beta = theta[:p]
gamma = theta[p:]
qc = get_qaoa_circuit_sv(G,beta, gamma)
sv = execute(qc, backend).result().get_statevector() # the sv is np.array with complex entries
# return the energy
ener=compute_ising_energy_sv(sv, G)
list1.append(ener)
return ener, list1
return f
# p is the number of QAOA alternating operators
energy_sv=[]
obj = get_black_box_objective_sv(G, p, energy_sv)
init_point = np.array([0.81069872, 2.2067517 , 0.83830696, 2.15579759, 0.37060699,
2.42068091, 6.1575306 , 2.2453419 , 3.85060091, 6.137845 ])
p = len(init_point)//2
# We are going to limit the number of iterations to 2500
res_sv = minimize(obj, init_point, method='COBYLA', options={'maxiter':2500, 'disp': True})
res_sv
# Once we have gotten the optimum beta and gamma we run the circuit again with the
backend = Aer.get_backend('qasm_simulator')
optimal_theta = res_sv['x']
qc = qaoa_circuit(G, optimal_theta[:p], optimal_theta[p:])
counts = invert_counts(execute(qc, backend,shots=2048).result().get_counts())
counts
plot_histogram(counts,figsize=(8,4))
len(energy_sv);
ms=6
x_sv=np.arange(1,len(energy_sv)+1)
x_qasm=np.arange(1,len(energy_qasm)+1)
plt.figure(figsize=(7,6))
plt.plot(x_sv,energy_sv,'b-',markersize=ms,label='Statevector')
plt.plot(x_qasm,energy_qasm,'r--',markersize=ms,label='QASM')
plt.xlabel('Iterations',fontsize=16)
plt.ylabel('Energy',fontsize=16)
plt.xticks(fontsize=16)
plt.yticks(fontsize=16)
plt.legend(fontsize=16)
# plt.title('Plot of gap for different $t_2$, at $t_1=0$ ')
plt.grid()
plt.tight_layout()
# plt.yscale('log')
# plt.legend(loc='upper right',fontsize=16)
# plt.savefig('%s/gap_t2.pdf'%(loc), bbox_inches='tight')
plt.show()
print(f"Angles found with samples: beta={res_sample['x'][:p]}, gamma={res_sample['x'][p:]}")
print(f"Angles found with full state: beta={res_sv['x'][:p]}, gamma={res_sv['x'][p:]}")
|
https://github.com/ayushidubal/qram
|
ayushidubal
|
%matplotlib inline
from qiskit import QuantumCircuit, QuantumRegister, transpile, ClassicalRegister
from qiskit.quantum_info import Statevector
from qiskit.visualization import array_to_latex, plot_histogram, plot_bloch_multivector
from qiskit.circuit.library import CHGate
from qiskit_aer import AerSimulator
from functools import partial
import numpy as np
from utils import get_image_path
show_unitary = partial(array_to_latex, max_size=100000)
show_state = lambda qc: Statevector(qc).draw('latex')
def get_unitary(qc, sim=AerSimulator()):
qc_copy = qc.copy()
qc_copy.save_unitary()
unitary = sim.run(transpile(qc_copy, sim), shots=1000).result().get_unitary()
return unitary
def measure(qc, sim=AerSimulator(), qubits=None):
qc_copy = qc.copy()
if(not qubits):
qc_copy.measure_all()
else:
qc_copy.measure(qubits, list(range(len(qubits))))
result = sim.run(transpile(qc_copy, sim), shots=1000).result().get_counts()
return result
mem = QuantumCircuit(2, name="QROM")
mem.cz(0,1)
display(mem.draw('mpl'))
show_unitary(get_unitary(mem))
qc = QuantumCircuit(2)
qc.x(range(2))
qc.append(mem, [0,1])
qc.x(range(2))
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
show_state(qc)
mem = QuantumCircuit(2, name="QROM")
mem.cp(np.pi/3,0,1)
display(mem.draw('mpl'))
show_unitary(get_unitary(mem))
qc = QuantumCircuit(2)
qc.x(range(2))
qc.append(mem, [0,1])
qc.x(range(2))
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
show_state(qc)
plot_bloch_multivector(qc)
qc = QuantumCircuit(3)
qc.x(range(2))
qc.h(2)
qc.barrier()
qc.append(mem, [0,1])
qc.barrier()
qc.cx(2,1)
qc.x(range(2))
qc.h(2)
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc)))
qc = QuantumCircuit(1)
#qc.h(0)
qc.p(np.pi/2, 0)
#qc.barrier()
#qc.cx(1,0)
qc.h(0)
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc)))
mem = QuantumCircuit(2, name="QROM")
mem.cp(np.pi/3,0,1)
mem.x(range(2))
mem.cp(np.pi/7,0,1)
mem.x(range(2))
display(mem.draw('mpl'))
show_unitary(get_unitary(mem))
qc = QuantumCircuit(2)
#qc.x(range(2))
qc.append(mem, [0,1])
#qc.x(range(2))
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
show_state(qc)
mem = QuantumCircuit(2, name="qrom")
mem.ch(0,1)
mem.x(0)
mem.cry(np.pi/3, 0, 1)
mem.x(0)
display(mem.draw('mpl', filename=get_image_path("qrom_1.png")))
display(show_unitary(get_unitary(mem)))
show_state(mem)
addr = QuantumRegister(1, name="addr")
out = QuantumRegister(1, name="out")
q = QuantumRegister(1,name="q")
result = ClassicalRegister(1, "m")
qc = QuantumCircuit(addr, out, q, result)
qc.x(addr)
qc.barrier(addr)
qc.append(mem, [addr, out])
qc.cx(out, q)
display(qc.draw('mpl'))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[2])))
addr = QuantumRegister(1, name="addr")
out = QuantumRegister(1, name="out")
q = QuantumRegister(1,name="q")
result = ClassicalRegister(1, "m")
qc = QuantumCircuit(addr, out, q)
qc.h(addr)
qc.barrier(addr)
qc.append(mem, [addr, out])
qc.cx(out, q)
display(qc.draw('mpl', filename=get_image_path("qrom_1_usage.png")))
display(show_unitary(get_unitary(qc)))
display(show_state(qc))
#display(plot_histogram(measure(qc, qubits=[2])))
CCH = CHGate().control(1)
addr = QuantumRegister(2, name="addr")
data = QuantumRegister(2, name="data")
mem = QuantumCircuit(addr, data, name="qrom")
mem.x(addr[0])
mem.ccx(addr[0], addr[1], data[0])
mem.x(addr[0])
mem.barrier()
mem.append(CCH, [addr[0], addr[1], data[0]])
mem.ccx(addr[0], addr[1], data[1])
display(mem.draw('mpl'))
display(show_unitary(get_unitary(mem)))
show_state(mem)
addr = QuantumRegister(2, name="addr")
data = QuantumRegister(2, name="data")
q = QuantumRegister(1, name="q")
out = ClassicalRegister(1, name="c")
qc = QuantumCircuit(addr, data, q, out)
qc.x(range(2))
qc.barrier(addr)
qc.append(mem, [*addr, *data])
qc.cx(data[1], q[0])
qc.cx(data[0], q[0])
qc.append(mem, [*addr, *data])
qc.barrier(addr)
qc.x(range(2))
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[4])))
#memory with teleportation
addr = QuantumRegister(1, name="addr")
data = QuantumRegister(1, name="data")
mem = QuantumCircuit(addr, data, name="qrom")
mem.cry(np.pi/5, 0, 1)
display(mem.draw('mpl'))
display(show_unitary(get_unitary(mem)))
show_state(mem)
addr = QuantumRegister(1, name="addr")
data = QuantumRegister(2, name="data")
q = QuantumRegister(1, name="q")
out = ClassicalRegister(1, name="c")
qc = QuantumCircuit(addr, data, q, out)
qc.x(addr)
qc.barrier(addr)
qc.append(mem, [addr, data[0]])
qc.cx(data[0], q)
qc.barrier(addr)
qc.append(mem, [addr, data[0]])
qc.x(addr)
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[3])))
addr = QuantumRegister(1, name="addr")
data = QuantumRegister(2, name="data")
q = QuantumRegister(1, name="q")
out = ClassicalRegister(1, name="c")
qc = QuantumCircuit(addr, data, q, out)
qc.x(addr)
qc.barrier(addr)
qc.append(mem, [addr, data[0]])
qc.h(data[1])
qc.cx(data[1], q)
qc.cx(data[0], data[1])
qc.h(data[0])
qc.cx(data[1], q)
qc.cz(data[0], q)
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[3])))
display(plot_histogram(measure(qc, qubits=[1])))
(np.cos(np.pi/5/2))**2, (np.sin(np.pi/5/2))**2
qc = QuantumCircuit(3,3)
qc.ry(np.pi/5, 0)
qc.barrier()
qc.h(1)
qc.cx(1,2)
qc.barrier()
qc.cx(0,1)
qc.h(0)
qc.cx(1,2)
qc.cz(0,2)
qc.draw('mpl')
display(qc.draw('mpl'))
#display(show_unitary(get_unitary(qc)))
display(show_state(qc))
display(plot_histogram(measure(qc, qubits=[2])))
data = QuantumRegister(1, name="data")
teleportation_provider = QuantumRegister(1, name="t")
q = QuantumRegister(1, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.ry(np.pi/7, q)
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl'))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[2])))
np.cos(np.pi/7/2)**2, np.sin(np.pi/7/2)**2
data = QuantumRegister(2, name="data")
teleportation_provider = QuantumRegister(2, name="t")
q = QuantumRegister(2, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.ry(np.pi/3, q[0])
qram.ry(np.pi/7, q[1])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl', filename=get_image_path('qram.png')))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[4])))
display(plot_histogram(measure(qram, qubits=[1])))
display(plot_histogram(measure(qram, qubits=[5])))
np.cos(np.pi/3/2)**2, np.sin(np.pi/3/2)**2
data = QuantumRegister(2, name="data")
teleportation_provider = QuantumRegister(2, name="t")
q = QuantumRegister(2, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.h(q[0])
qram.h(q[1])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
qram.barrier(label='second')
qram.cz(q, data)
qram.cx(teleportation_provider, data)
qram.h(q)
qram.cx(q, teleportation_provider)
qram.barrier()
qram.h(q[0])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl'))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[4])))
display(plot_histogram(measure(qram, qubits=[1])))
display(plot_histogram(measure(qram, qubits=[5])))
data = QuantumRegister(2, name="data")
teleportation_provider = QuantumRegister(1, name="t")
q = QuantumRegister(2, name="q")
meas = ClassicalRegister(1, name="out")
qram = QuantumCircuit(data, teleportation_provider, q,meas)
qram.h(teleportation_provider)
qram.cx(teleportation_provider, data)
qram.barrier()
qram.ry(np.pi/3, q[0])
qram.ry(np.pi/7, q[1])
qram.barrier()
qram.cx(q, teleportation_provider)
qram.h(q)
qram.cx(teleportation_provider, data)
qram.cz(q, data)
display(qram.draw('mpl', filename=get_image_path('qram.png')))
#display(show_unitary(get_unitary(qram)))
display(show_state(qram))
display(plot_histogram(measure(qram, qubits=[0])))
display(plot_histogram(measure(qram, qubits=[4])))
display(plot_histogram(measure(qram, qubits=[1])))
display(plot_histogram(measure(qram, qubits=[5])))
|
https://github.com/ayushidubal/qram
|
ayushidubal
|
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.library import ZGate
from qiskit.quantum_info import Operator, Statevector
from qiskit.extensions import Initialize
from qiskit.providers.aer import AerSimulator
from qiskit.providers.aer.backends import statevector_simulator, qasm_simulator
from qiskit.visualization import plot_histogram, plot_state_city
from qiskit import Aer, execute, transpile
import numpy as np
def targets(n):
state1 = ""
state2 = ""
bits = ["0", "1"]
for i in range(n):
state1 += bits[i%2]
state2 += bits[1-(i%2)]
return state1, state2
def getData(input_array, mem_bits):
state = ""
for i in input_array:
state += bin(i)[2:].rjust(mem_bits, '0')
return state[::-1]
def decoder(addr_bits, aux_bits, n):
addr = QuantumRegister(addr_bits)
tau = QuantumRegister(aux_bits)
decoder = QuantumCircuit(addr, tau)
decoder.x(tau[0])
decoder.cx(addr[addr_bits-1], tau[1])
decoder.cx(tau[1], tau[0])
c = 1
for i in range(1, addr_bits-1):
p = 2**i
for j in range(p):
decoder.ccx(addr[addr_bits-i-1], tau[j], tau[p+j])
c += 1
for j in range(p):
decoder.cx(tau[p+j], tau[j])
p = aux_bits - 1 - c
for j in range(p):
decoder.ccx(addr[0], tau[j], tau[p+j])
c += 1
for j in range(p):
decoder.cx(tau[p+j], tau[j])
return decoder.to_gate(label = "Decoder")
def groverOracle(aux_bits, mem_bits, n):
winners = targets(mem_bits)
tau = QuantumRegister(aux_bits)
mem = QuantumRegister(mem_bits*n)
oracle = QuantumCircuit(tau, mem)
gate1 = ZGate().control(num_ctrl_qubits=mem_bits, ctrl_state=winners[0])
gate2 = ZGate().control(num_ctrl_qubits=mem_bits, ctrl_state=winners[1])
for i in range(aux_bits):
qubits = [mem[mem_bits*i + j] for j in range(mem_bits)]
oracle.append(gate1, qubits + [tau[i]])
oracle.append(gate2, qubits + [tau[i]])
return oracle.to_gate(label="Oracle")
def groverDiffuser(addr_bits):
d = 2**addr_bits
s = np.array([[1.0/np.sqrt(d)] for i in range(d)])
op = np.matmul(s, s.T)
U_S = Operator((2*op)-np.identity(d))
return U_S
def qram(input_array):
n = len(input_array)
if n < 8:
input_array += [0 for i in range(8-n)]
n = len(input_array)
addr_bits = len(bin(n-1)) - 2 # number of address bits
aux_bits = n # number of memory locations
mem_bits = len(bin(max(input_array))) - 2 # size of one memory location
addr = QuantumRegister(addr_bits, name="a") # address register
tau = QuantumRegister(aux_bits, name="tau") # auxillary register to store selected address
mem = QuantumRegister(mem_bits*n, name="m") # memory register
cr = ClassicalRegister(addr_bits) # to store final output
qram_circ = QuantumCircuit(addr, tau, mem, cr)
for i in range(addr_bits):
qram_circ.h(addr[i])
# Load data into qRAM
data = getData(input_array[::-1], mem_bits)
for i in range(len(data)):
if data[i] == "1":
qram_circ.x(mem[i])
# End of loading
# Entangle tau with addr
decode = decoder(addr_bits, aux_bits, n)
qram_circ.append(decode, addr[:] + tau[:])
# Grover oracle
oracle = groverOracle(aux_bits, mem_bits, n)
qram_circ.append(oracle, tau[:] + mem[:])
# End of grover oracle
# Detangle tau from addr
encode = decode.inverse()
encode.label = "Encoder"
qram_circ.append(encode, addr[:] + tau[:])
# Diffuser
U_S = groverDiffuser(addr_bits)
qram_circ.append(U_S, [addr[i] for i in range(addr_bits)])
# Measure
qram_circ.measure([addr[i] for i in range(addr_bits)], [cr[i] for i in range(addr_bits)])
return qram_circ
circ = qram([3, 2, 0, 1])
circ.draw('mpl')
backend = Aer.get_backend("qasm_simulator")
job = execute(circ, backend)
res = job.result()
counts = res.get_counts()
print(counts)
plot_histogram(counts)
circ = qram([1, 0, 3, 2, 3])
circ.draw('mpl')
backend = Aer.get_backend("qasm_simulator")
job = execute(circ, backend)
res = job.result()
counts = res.get_counts()
print(counts)
plot_histogram(counts)
circ = qram([0, 1, 3, 2, 2])
circ.draw('mpl')
backend = Aer.get_backend("qasm_simulator")
job = execute(circ, backend)
res = job.result()
counts = res.get_counts()
print(counts)
plot_histogram(counts)
|
https://github.com/mickahell/qiskit-ecosystem_template
|
mickahell
|
"""Docstring."""
from qiskit import QuantumCircuit, execute, QuantumRegister, ClassicalRegister
from qiskit_aer import Aer
class Random:
"""Demo random."""
def __init__(self):
"""Demo random."""
self.pow = 2
self.qasm = Aer.get_backend("aer_simulator")
def run(self, number: int) -> int:
"""Run method."""
nb_qubits = number
print("Generate random number")
circ = QuantumRegister(nb_qubits, "the number")
meas = ClassicalRegister(nb_qubits, "measurement")
quant_circ = QuantumCircuit(circ, meas)
for i in range(0, nb_qubits):
quant_circ.x(i)
quant_circ.measure(circ, meas)
job = execute(quant_circ, self.qasm, shots=1, memory=True)
result_sim = job.result()
memory = result_sim.get_memory()
result = int(memory[0], 2) + 1
return result
def __repr__(self):
return f"Random(circuit of: {self.pow})"
|
https://github.com/qiskit-community/qiskit-tket-passes
|
qiskit-community
|
from qiskit_tket_passes import ToQiskitPass
import pytket.passes as tkps
_pass1 = ToQiskitPass(tkps.SynthesiseTket)
# If TKET pass' constructor expects some arguments, pass them after the class name
_pass2 = ToQiskitPass(tkps.FullPeepholeOptimise, allow_swaps=True, target_2qb_gate='cx')
from pytket.architecture import Architecture
arc = Architecture([(0, 1), (1, 0), (1, 2), (1, 3), (2, 1), (3, 1), (3, 4), (4, 3)])
_pass = ToQiskitPass(tkps.AASRouting, arc=arc)
_pass = ToQiskitPass(tkps.AASRouting, arc=[[0, 1], [1, 0], [1, 2], [1, 3], [2, 1], [3, 1], [3, 4], [4, 3]])
from qiskit.providers.fake_provider import FakeQuitoV2
backend = FakeQuitoV2()
_pass = ToQiskitPass(tkps.AASRouting, target=backend.target)
print(_pass.tket_argument('arc').to_dict())
from qiskit.circuit.random import random_circuit
from pytket.extensions.qiskit import AerBackend
from qiskit_tket_passes import TketPassManager
qc = random_circuit(3, 10, seed=1)
pm = TketPassManager(AerBackend(), optimization_level=2)
transpiled_qc = pm.run(qc)
from qiskit.circuit.random import random_circuit
circ = random_circuit(7, 30, seed=1)
circ.draw('mpl', fold=-1)
from qiskit.transpiler.passes import (
UnitarySynthesis,
Collect2qBlocks,
ConsolidateBlocks,
Unroll3qOrMore,
)
from qiskit.transpiler import PassManager, StagedPassManager
basis_gates = ["rx", "ry", "rxx"]
init = PassManager([UnitarySynthesis(basis_gates, min_qubits=3), Unroll3qOrMore()])
translate = PassManager(
[
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=basis_gates),
UnitarySynthesis(basis_gates),
]
)
staged_pm = StagedPassManager(
stages=["init", "translation"], init=init, translation=translate
)
tr_circ = staged_pm.run(circ)
print('Depth:', tr_circ.depth())
optimize = PassManager(
[
ToQiskitPass(tkps.RemoveRedundancies)
]
)
staged_pm = StagedPassManager(
stages=["init", "translation", "optimization"], init=init, translation=translate, optimization=optimize
)
tr_circ = staged_pm.run(circ)
print('Depth:', tr_circ.depth())
from pytket.extensions.qiskit import IBMQBackend
from qiskit_tket_passes import TketPassManager
qbackend = IBMQBackend('ibmq_jakarta')
pm = TketPassManager(qbackend, optimization_level=2)
#pm.draw()
tr_circ = pm.run(circ)
print('CNOTs:', tr_circ.count_ops()['cx'])
print('Depth:', tr_circ.depth())
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
backend = provider.get_backend('ibmq_jakarta')
from qiskit import transpile
tr_circ = transpile(circ, backend=backend, optimization_level=3)
print('CNOTs:', tr_circ.count_ops()['cx'])
print('Depth:', tr_circ.depth())
print('init:')
circ_init = transpile(circ, backend=backend, optimization_level=3, init_method='tket')
print('CNOTs:', circ_init.count_ops()['cx'])
print('Depth:', circ_init.depth())
print('\ntranslation:')
circ_trans = transpile(circ, backend=backend, optimization_level=3, translation_method='tket')
print('CNOTs:', circ_trans.count_ops()['cx'])
print('Depth:', circ_trans.depth())
print('\noptimization:')
circ_opt = transpile(circ, backend=backend, optimization_level=3, optimization_method='tket')
print('CNOTs:', circ_opt.count_ops()['cx'])
print('Depth:', circ_opt.depth())
from colorama import Fore, Style
def _callback(pass_, dag, time, property_set, count):
is_tket_pass = pass_.name().startswith('TketPass_')
print(Fore.GREEN if is_tket_pass else Fore.WHITE, pass_.name())
Style.RESET_ALL
circ_layout = transpile(circ, backend=backend, optimization_level=3,
init_method='tket',
translation_method='tket',
optimization_method='tket',
callback=_callback)
|
https://github.com/qiskit-community/qiskit-tket-passes
|
qiskit-community
|
import re
from collections import OrderedDict
from qiskit import QuantumCircuit
from qiskit.transpiler import TransformationPass
from qiskit.transpiler.target import Target, target_to_backend_properties
from pytket.architecture import Architecture
from pytket.circuit import OpType
from pytket.passes import BasePass
from pytket.passes._decompositions import _TK1_to_X_SX_Rz, _TK1_to_U
from pytket.transform import CXConfigType, PauliSynthStrat
from pytket.extensions.qiskit import qiskit_to_tk
from pytket.placement import GraphPlacement, LinePlacement, NoiseAwarePlacement
from .utils import get_arguments_from_doc, qiskit_dag_to_tk, tk_to_qiskit_dag
def ToQiskitPass(tket_pass, target: Target = None, **kwargs):
class TketPassClass(TransformationPass):
def __init__(self, target: Target = None, **kwargs):
if isinstance(tket_pass, BasePass):
self._pass = tket_pass
_dict = tket_pass.to_dict()
class_name = _dict[_dict['pass_class']]['name']
self.requires = []
self.preserves = []
else:
self.target = target
super().__init__()
class_name = tket_pass.__name__
self._args_dict = OrderedDict()
parsed_args = get_arguments_from_doc(tket_pass)
for parsed_arg in parsed_args:
arg_name = parsed_arg[0]
arg_type = parsed_arg[1]
if arg_type.endswith('architecture.Architecture'):
if arg_name in kwargs:
arc = kwargs.pop(arg_name)
if type(arc) == list:
connections = []
for edge in arc:
connections.append(tuple(edge))
arc = Architecture(connections)
self._args_dict[arg_name] = arc
elif self.target:
arc = self._arch_from_target()
self._args_dict[arg_name] = arc
elif arg_type.endswith('placement.Placement'):
if arg_name in kwargs:
placer_str = kwargs.pop(arg_name)
else:
placer_str = 'NoiseAware'
if placer_str == 'Graph':
placer = GraphPlacement(self._arch_from_target())
self._args_dict[arg_name] = placer
elif placer_str == 'Line':
placer = LinePlacement(self._arch_from_target())
self._args_dict[arg_name] = placer
elif placer_str == 'NoiseAware':
if self.target:
placer = self._noise_aware_placer_from_target()
self._args_dict[arg_name] = placer
else:
raise ValueError('Unsupported placer type:', placer_str)
elif arg_type.endswith('circuit.Circuit'):
if arg_name in kwargs:
circ = kwargs.pop(arg_name)
tkcirc = qiskit_to_tk(circ)
self._args_dict[arg_name] = tkcirc
elif self.target:
if class_name == 'DecomposeSwapsToCircuit' and arg_name == 'replacement_circuit':
# Construct SWAP replacement circuit based on target's gate set.
circ = self._swap_decomposition_from_target()
tkcirc = qiskit_to_tk(circ)
self._args_dict[arg_name] = tkcirc
elif class_name == 'RebaseCustom' and arg_name == 'cx_replacement':
# Construct CNOT replacement circuit based on target's gate set.
circ = self._cnot_decomposition_from_target()
tkcirc = qiskit_to_tk(circ)
self._args_dict[arg_name] = tkcirc
elif arg_type.endswith('circuit.OpType'):
if arg_name in kwargs:
op_str = kwargs.pop(arg_name)
op_type = self._optype_from_str(op_str)
self._args_dict[arg_name] = op_type
elif re.match("Set\[.+\.circuit\.OpType\]", arg_type) is not None:
if arg_name in kwargs:
_value = kwargs.pop(arg_name)
if all(isinstance(elem, str) for elem in _value):
op_types = set()
for op_str in _value:
op_types.add(self._optype_from_str(op_str))
self._args_dict[arg_name] = op_types
elif isinstance(_value, set) and all(isinstance(elem, OpType) for elem in _value):
self._args_dict[arg_name] = _value
elif self.target and class_name == 'RebaseCustom' and arg_name == 'gateset':
# Get the target's gate set.
self._args_dict[arg_name] = self._gateset_from_target()
elif arg_type.endswith('transform.PauliSynthStrat'):
if arg_name in kwargs:
strategy = kwargs.pop(arg_name)
strategies_map = {
'Individual': PauliSynthStrat.Individual,
'Pairwise': PauliSynthStrat.Pairwise,
'Sets': PauliSynthStrat.Sets,
}
value = strategies_map[strategy]
self._args_dict[arg_name] = value
elif arg_type.endswith('transform.CXConfigType'):
if arg_name in kwargs:
cx_config = kwargs.pop(arg_name)
cx_config_map = {
'Snake': CXConfigType.Snake,
'Star': CXConfigType.Star,
'Tree': CXConfigType.Tree,
'MultiQGate': CXConfigType.MultiQGate
}
value = cx_config_map[cx_config]
self._args_dict[arg_name] = value
elif arg_name == 'tk1_replacement':
if self.target:
self._args_dict[arg_name] = self._tk1_replacement_from_target()
else:
self._args_dict[arg_name] = _TK1_to_U
else:
if arg_name in kwargs:
value = kwargs.pop(arg_name)
self._args_dict[arg_name] = value
args = self._args_dict.values()
self._pass = tket_pass(*args, **kwargs)
__class__.__name__ = 'TketPass_' + class_name
def run(self, dag):
tkcirc = qiskit_dag_to_tk(dag)
self._pass.apply(tkcirc)
return tk_to_qiskit_dag(tkcirc)
def tket_argument(self, arg_name):
if arg_name in self._args_dict:
return self._args_dict[arg_name]
else:
raise ValueError(f"{__class__.__name__} has no argument with the name {arg_name}.")
#TODO: May be we should move the following methods to utils file instead of having them as class methods
def _optype_from_str(self, op_str):
for op_type in dir(OpType):
if op_str.upper() == op_type.upper():
return OpType.from_name(op_type)
ops_map = {
'id': 'noop',
'u': 'U3',
'cu': 'CU3',
'iswap': 'ISWAPMax',
'rxx': 'XXPhase',
'ryy': 'YYPhase',
'rzz': 'ZZPhase',
'p': 'U1',
'cp': 'CU1',
'r': 'PhasedX',
}
return OpType.from_name(ops_map[op_str])
def _gateset_from_target(self):
operation_names = list(self.target.operation_names)
for op in ['delay', 'if_else', 'rzx']:
if op in operation_names:
operation_names.remove(op)
return { self._optype_from_str(op_str) for op_str in operation_names }
def _arch_from_target(self):
_coupling_map = self.target.build_coupling_map()
if _coupling_map is None:
return Architecture([])
else:
return Architecture(_coupling_map.get_edges())
def _cnot_decomposition_from_target(self):
circ = QuantumCircuit(2)
circ.cx(0, 1)
if 'cx' not in self.target.operation_names:
from qiskit import transpile
circ = transpile(circ, basis_gates=list(self.target.operation_names))
return circ
def _swap_decomposition_from_target(self):
from qiskit import transpile
circ = QuantumCircuit(2)
circ.swap(0, 1)
return transpile(circ, basis_gates=list(self.target.operation_names))
def _tk1_replacement_from_target(self):
if {'x', 'sx', 'rz'}.issubset(self.target.operation_names):
return _TK1_to_X_SX_Rz
else:
return _TK1_to_U
def _noise_aware_placer_from_target(self):
"""
Get noise data from target.
This code is a modified copy from `process_characterisation` & `get_avg_characterisation` functions in pytket-qiskit module.
"""
from collections import defaultdict
from pytket.circuit import Node
node_errors = defaultdict(dict)
edge_errors = defaultdict(dict)
readout_errors = {}
coupling_map = target.build_coupling_map()
arc = self._arch_from_target()
properties = target_to_backend_properties(target)
if properties is None:
return None
else:
for gate in properties.gates:
for param in gate.parameters:
if param.name == 'gate_error':
optype = self._optype_from_str(gate.gate)
gate_error = param.value
if len(gate.qubits) == 1:
node_errors[Node(gate.qubits[0])].update({optype: gate_error})
else:
edge_errors[(Node(gate.qubits[0]), Node(gate.qubits[1]))].update({optype: gate_error})
if gate.qubits[::-1] not in coupling_map:
edge_errors[(Node(gate.qubits[1]), Node(gate.qubits[0]))].update({optype: 2 * gate_error})
props_dict = properties.to_dict()
for n in range(target.num_qubits):
if len(props_dict['qubits']) > n:
readout_error = properties.readout_error(n)
else:
readout_error = 0
readout_errors[Node(n)] = [
[1.0 - readout_error, readout_error],
[readout_error, 1.0 - readout_error],
]
avg = lambda xs: sum(xs.values()) / len(xs)
avg_mat = (lambda xs: (xs[0][1] + xs[1][0]) / 2.0)
map_values = lambda f, d: { k: f(v) for k, v in d.items() }
avg_node_errors = map_values(avg, node_errors)
avg_edge_errors = map_values(avg, edge_errors)
avg_readout_errors = map_values(avg_mat, readout_errors)
return NoiseAwarePlacement(
arc,
avg_node_errors,
avg_edge_errors,
avg_readout_errors
)
return TketPassClass(target, **kwargs)
|
https://github.com/qiskit-community/qiskit-tket-passes
|
qiskit-community
|
import pydoc
import re
import pytket.passes as tkps
def get_arguments_from_doc(tket_pass):
arguments = []
_doc = pydoc.getdoc(tket_pass)
if 'Overloaded function.' in _doc:
#Return the first signature
#TODO: We should return all possible signatures. This would requires changes in ToQiskitPass also.
matches = re.findall("[1-9]\. (" + tket_pass.__name__ + '[^\n]+)', _doc)
synopsis_line = matches[0]
else:
synopsis_line = pydoc.splitdoc(_doc)[0]
# To avoid issue caused by callable parentheses:
synopsis_line = re.sub('Callable\[\[[^\[]+\][^\[]+\]', 'Callable', synopsis_line)
match = re.search("\(([^(]+)\)", synopsis_line)
if match is not None:
splitted_args = match.group(1).split(', ')
for arg_str in splitted_args:
if arg_str == '**kwargs':
continue
else:
argument = arg_str.split(': ')
eq_index = argument[1].find('=')
if eq_index > 0:
(_type, _default) = argument[1].split(' = ')
arguments.append((argument[0], _type, _default))
else:
arguments.append(tuple(argument))
return arguments
# This is **temp**. Conversion should be done in a better way
# https://github.com/CQCL/pytket-qiskit/blob/develop/pytket/extensions/qiskit/qiskit_convert.py
from pytket.extensions.qiskit import qiskit_to_tk, tk_to_qiskit
from qiskit.converters import dag_to_circuit, circuit_to_dag
from pytket.circuit import Circuit
from qiskit.dagcircuit import DAGCircuit
def qiskit_dag_to_tk(dag: DAGCircuit):
# Replace any gate that is not known to pyket by its definition
from pytket.extensions.qiskit.qiskit_convert import _known_qiskit_gate
for node in dag.op_nodes():
if not type(node.op) in _known_qiskit_gate:
dag.substitute_node_with_dag(node, circuit_to_dag(node.op.definition))
return qiskit_to_tk(dag_to_circuit(dag))
def tk_to_qiskit_dag(tkcirc: Circuit):
return circuit_to_dag(tk_to_qiskit(tkcirc))
|
https://github.com/qiskit-community/qiskit-tket-passes
|
qiskit-community
|
import unittest
from qiskit.transpiler.preset_passmanagers.plugin import (
list_stage_plugins,
passmanager_stage_plugins,
)
import qiskit_tket_passes.plugins as plgn
class TestPassManagerStagePlugins(unittest.TestCase):
def test_plugins_are_installed(self):
for stage_name in ['init', 'layout', 'routing', 'translation', 'optimization']:
installed_plugins = list_stage_plugins(stage_name)
self.assertIn('tket', installed_plugins)
def test_plugins_are_used(self):
plugins = passmanager_stage_plugins('init')
self.assertIsInstance(isinstance(plugins['tket'], plgn.TketInitPassManager))
plugins = passmanager_stage_plugins('layout')
self.assertIsInstance(plugins['tket'], plgn.TketLayoutPassManager)
plugins = passmanager_stage_plugins('routing')
self.assertIsInstance(plugins['tket'], plgn.TketRoutingPassManager)
plugins = passmanager_stage_plugins('translation')
self.assertIsInstance(plugins['tket'], plgn.TketTranslationPassManager)
plugins = passmanager_stage_plugins('optimization')
self.assertIsInstance(plugins['tket'], plgn.TketOptimizationPassManager)
if __name__ == '__main__':
unittest.main()
|
https://github.com/ArunSehrawat/Quantum_Machine_Learning_use_cases_with_Qiskit
|
ArunSehrawat
|
import numpy as np
import matplotlib.pyplot as plt
import time, copy, warnings
from sklearn import linear_model, svm
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.neural_network import MLPClassifier
'''datasets:'''
from sklearn.datasets import (load_iris, load_wine, load_breast_cancer)
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
dataset = load_wine() # choose one of the above datasets
X, y = dataset.data, dataset.target
X = MinMaxScaler().fit_transform(X) # this will put all the feature (X) values in the interval [0,1]
num_examples, num_features = X.shape
print("number of examples = ", num_examples)
print("number of features = ", num_features)
X[:3,:], y[:3] # first 3 examples
X_train_, X_test_, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
print(X_train_.shape, X_test_.shape)
feature_names = dataset.feature_names
print(f'feature_names = {feature_names} \n')
k = 4
print(f'number of features to be selected = {k}\n')
# Pearson correlation coefficient between features x_i and x_j
xx_pcc = np.corrcoef(X_train_.T)
xx_pcc = np.abs(np.triu(xx_pcc, 1))
plt.matshow(xx_pcc, cmap='Reds')
plt.xticks(np.arange(num_features))
plt.yticks(np.arange(num_features))
cb = plt.colorbar(shrink=0.7)
plt.title('abs corr upp-tri matrix')
plt.show()
# Pearson correlation coefficient between feature x_i and target y
xy_pcc = [np.abs(np.corrcoef(X_train_[:,l], y_train)[0,1]) for l in range(num_features)]
# alpha is the weight attached to the off-diagonal terms, 0 <= alpha <=1
# 1- alpha is the weight attached to the diagonal terms of Q
alpha = 0.5
Q = alpha*xx_pcc - (1-alpha)*np.diag(xy_pcc)
def plot_Q_matrix():
plt.matshow(Q, cmap='bwr')
plt.xticks(np.arange(num_features))
plt.yticks(np.arange(num_features))
cb = plt.colorbar(shrink=0.7)
plt.title(f'Q matrix (alpha = {alpha})')
plt.show()
plot_Q_matrix()
from qiskit_optimization import QuadraticProgram #!pip install qiskit[optimization]
from qiskit.algorithms.minimum_eigensolvers import SamplingVQE, NumPyMinimumEigensolver, QAOA
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.converters import QuadraticProgramToQubo
from qiskit.primitives import Sampler
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import SPSA, COBYLA
qp = QuadraticProgram()
for i in range(num_features):
qp.binary_var(f'v{i}')
linear = [Q[i,i] for i in range(num_features)]
quadratic = {}
for i in range(num_features):
for j in range(i+1, num_features):
quadratic[(f'v{i}', f'v{j}')] = Q[i,j]
qp.minimize(linear=linear, quadratic=quadratic)
linear_const = {f'v{i}':1 for i in range(num_features)} # the constraint to select k number of features
qp.linear_constraint(linear=linear_const, sense="==", rhs=k, name="lin_const")
qp
%%time
exact = MinimumEigenOptimizer(min_eigen_solver=NumPyMinimumEigensolver())
result = exact.solve(qp)
print(result.prettyprint())
print()
%%time
ansatz = TwoLocal(num_features, "ry", "cz", reps=3, entanglement="linear") # construct ansatz for VQE
vqe = SamplingVQE(sampler=Sampler(), ansatz=ansatz, optimizer=COBYLA(maxiter=10)) # construct VQE
meo_vqe = MinimumEigenOptimizer(min_eigen_solver=vqe) # run VQE
result_vqe = meo_vqe.solve(qp)
print(result_vqe.prettyprint())
print()
%%time
qaoa = QAOA(sampler=Sampler(), optimizer=COBYLA(maxiter=10), reps=3) # construct QAOA
meo_qaoa = MinimumEigenOptimizer(min_eigen_solver=qaoa) # run QAOA
result_qaoa = meo_qaoa.solve(qp)
print(result_qaoa.prettyprint())
print()
sol = np.append(np.ones(k, dtype=int), np.zeros(num_features-k, dtype=int))
Emin = np.linalg.multi_dot([sol, Q , sol])
print(f'inital sol = {sol}')
print(f'initial Emin = {round(Emin,3)}\n')
for l in range(10000):
s = np.random.permutation(sol)
E = np.linalg.multi_dot([s, Q , s])
if E < Emin:
sol, Emin = s, E
print(f'l = {l:5d} Emin = {round(Emin,3)} sol = {sol}')
pos = np.where(sol==1)[0]
print()
print(f'selected_feature_positions = {pos}\n')
plot_Q_matrix()
from sklearn.feature_selection import SelectKBest, mutual_info_classif
f = SelectKBest(mutual_info_classif, k=4).fit(X_train_, y_train)
selected_features = f.get_feature_names_out(feature_names)
selected_features_pos = [np.where(np.array(feature_names) == sf)[0][0] for sf in selected_features]
print(f'selected_features = {selected_features}\n')
print(f'selected_feature_positions = {selected_features_pos}\n')
print(f'selected_feature_positions = {pos}\n')
print(f'selected_features = {np.array(feature_names)[pos]}\n')
X_train, X_test = X_train_[:,pos], X_test_[:,pos]
print(f"number selected of features = k = {k}:", k==X_train.shape[1])
from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap
fm = ZZFeatureMap(feature_dimension=k, reps=1)
fm.decompose().draw()
from qiskit.circuit.library import RealAmplitudes
pqc = RealAmplitudes(num_qubits=k, reps=3)
pqc.decompose().draw()
from qiskit.algorithms.optimizers import COBYLA
# This defines where to train our classifier: on a simulator or a real quantum computer
from qiskit.primitives import Sampler # here we have chosen a simulator
from qiskit_machine_learning.algorithms.classifiers import VQC # !pip install qiskit[machine-learning]
#------------------------------------------------------------------------------------------------
optimizer = COBYLA(maxiter=250) # maxiter = Maximum number of iterations (function evaluations)
sampler = Sampler()
#------------------------------------------------------------------------------------------------
from IPython.display import clear_output
objective_func_vals = []
# a callback that can access the intermediate data during the optimization
def callback(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
#------------------------------------------------------------------------------------------------
vqc = VQC(
sampler=sampler,
feature_map=fm,
ansatz=pqc,
optimizer=optimizer,
callback=callback,
)
%%time
'''Training time increases with the number of features'''
vqc.fit(X_train, y_train)
train_score = vqc.score(X_train, y_train)
test_score = vqc.score(X_test, y_test)
print(f"VQC train score: {train_score:.2f}")
print(f"VQC test score: {test_score:.2f}")
%%time
warnings.filterwarnings('ignore')
def train_test(ML_model):
print(15*'-', ML_model, 15*'-','\n')
ML_model.fit(X_train, y_train) # fit model
train_score_ML = ML_model.score(X_train, y_train) # evaluate model
test_score_ML = ML_model.score(X_test, y_test)
print(f"ML train score: {train_score_ML:.2f}")
print(f"ML test score: {test_score_ML:.2f}")
print()
#----------------------------------------------------------------------------------
ML_model = linear_model.LogisticRegression() # create model instance
train_test(ML_model)
ML_model = MLPClassifier()
train_test(ML_model)
ML_model = svm.SVC()
train_test(ML_model)
ML_model = RandomForestClassifier()
train_test(ML_model)
|
https://github.com/ArunSehrawat/Quantum_Machine_Learning_use_cases_with_Qiskit
|
ArunSehrawat
|
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import time, copy, warnings
from sklearn import linear_model, svm
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.preprocessing import MinMaxScaler
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score, roc_auc_score
data = pd.read_csv("creditcard.csv")
histogram = data.hist(bins=20)
data
# See: 'Time' and 'Amount' are bigger than other features V1, ..., V28 values
data.plot.box()
# See: features V1, ..., V28 are not correlated as they are the principal components obtained with PCA
plt.matshow(data.corr(), cmap='bwr')
cb = plt.colorbar(shrink=0.7)
plt.title('Correlation Matrix', fontsize=16)
plt.show()
normal = data[data.Class==0] # Set of all normal (y = 0) cases
fraud = data[data.Class==1] # Set of all fraud (y = 1) cases
num_normal = normal.shape[0]
num_fraud = fraud.shape[0]
print(f"Number of normal examples = {num_normal}")
print(f"Number of fraud examples = {num_fraud}\n")
ratio = num_normal/num_fraud
print(f'normal to fraud ratio in the whole data = {round(ratio,2)}')
'A choice of normal_fraud_ratio has effects on precision and recall given below.'
normal_fraud_ratio = 1 # normal_fraud_ratio = 1 means balance sample
normal_sample = normal.sample(normal_fraud_ratio*num_fraud)
# joining row-wise (axis=0) normal and fraud cases to get a sample
sample = pd.concat([fraud, normal_sample], axis=0)
for i in range(100):
sample = np.random.permutation(sample) # random shuffling of sample examples 100 times
#==============================================================================
X, y = sample[:, :-1], sample[:, -1]
X = MinMaxScaler().fit_transform(X) # this will put all the feature (X) values in the interval [0,1]
num_examples, num_features = X.shape
print("number of examples = ", num_examples)
print("number of features = ", num_features)
X[:3,:], y[:3] # see first 3 examples
'''
Zero padding is to make the number of features equal to a power of 2.
it is required for 'amplitude encoding' given below.
'''
n = int(np.ceil(np.log2(num_features)))
dim = 2**n
print(f'(number of qubits, dimension of the Hilbert space) = {(n, dim)}')
zeros = np.zeros((num_examples, dim-num_features))
X = np.append(X, zeros, axis=1)
num_examples, num_features = X.shape
num_examples, num_features = X.shape
print("number of examples = ", num_examples)
print("number of features = ", num_features)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=0)
print(X_train.shape, X_test.shape)
from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap
fm = ZZFeatureMap(feature_dimension=num_features, reps=1) # ZZFeatureMap seems better
fm.decompose().draw()
from qiskit_machine_learning.circuit.library import RawFeatureVector
fm = RawFeatureVector(feature_dimension=num_features)
fm.draw()
from qiskit.circuit.library import RealAmplitudes
'''
For angle encoding, num_qubits = num_features
For amplitude encoding, num_qubits = n = np.log2(num_features)
'''
pqc = RealAmplitudes(num_qubits=n, reps=3)
pqc.decompose().draw()
from qiskit.algorithms.optimizers import COBYLA
# This defines where to train our classifier: on a simulator or a real quantum computer
from qiskit.primitives import Sampler # here we have chosen a simulator
from qiskit_machine_learning.algorithms.classifiers import VQC # !pip install qiskit[machine-learning]
#------------------------------------------------------------------------------------------------
optimizer = COBYLA(maxiter=150) # maxiter = Maximum number of iterations (function evaluations)
sampler = Sampler()
#------------------------------------------------------------------------------------------------
from IPython.display import clear_output
objective_func_vals = []
# a callback that can access the intermediate data during the optimization
def callback(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
#------------------------------------------------------------------------------------------------
vqc = VQC(
sampler=sampler,
feature_map=fm,
ansatz=pqc,
optimizer=optimizer,
callback=callback,
)
%%time
'''Training time seems to increase with the number of features'''
vqc.fit(X_train, y_train)
y_train_pred = vqc.predict(X_train)
y_test_pred = vqc.predict(X_test)
print(classification_report(y_train, y_train_pred))
print(confusion_matrix(y_train, y_train_pred), "= confusion matrix for train set \n")
print(classification_report(y_test, y_test_pred))
print(confusion_matrix(y_test, y_test_pred), "= confusion matrix for test set \n ")
print(round(roc_auc_score(y_test, y_test_pred),2), "= roc_auc_score for test set \n")
%%time
warnings.filterwarnings('ignore')
def train_test(ML_model):
print(20*' ', ML_model,'\n')
ML_model.fit(X_train, y_train) # fit model
y_train_pred = ML_model.predict(X_train) # predict with the trained model
y_test_pred = ML_model.predict(X_test)
print(classification_report(y_train, y_train_pred)) # evaluate model performance
print(confusion_matrix(y_train, y_train_pred), "= confusion matrix for train set \n")
print(classification_report(y_test, y_test_pred))
print(confusion_matrix(y_test, y_test_pred), "= confusion matrix for test set \n")
print(round(roc_auc_score(y_test, y_test_pred),2), "= roc_auc_score for test set \n")
print(70*'=')
#----------------------------------------------------------------------------------
print(70*'=')
ML_model = linear_model.LogisticRegression() # create model instance
train_test(ML_model)
ML_model = MLPClassifier()
train_test(ML_model)
ML_model = svm.SVC()
train_test(ML_model)
ML_model = RandomForestClassifier()
train_test(ML_model)
|
https://github.com/ArunSehrawat/Quantum_Machine_Learning_use_cases_with_Qiskit
|
ArunSehrawat
|
import numpy as np
import matplotlib.pyplot as plt
import time, copy, warnings
from sklearn import linear_model, svm
from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
from sklearn.neural_network import MLPClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, accuracy_score
size = 4 # size of image
binaries = np.array([[int(i) for i in np.binary_repr(a, size)] for a in range(1, 2**size - 1)])
#--------------------------------------------------------------------------------------------------
ones = np.ones((size, size))
X = [] # X collects (size x size) feature matrices
y = [] # y collects class labels 1 or 0
for b in binaries:
x = b*ones
X.append(x.flatten()) # image with vertical strips, class 1
y.append(1)
X.append((x.T).flatten()) # image with horizontal strips, class 0
y.append(0)
X, y = np.array(X), np.array(y)
#--------------------------------------------------------------------------------------------------
num_examples, num_features = X.shape
print(f'number of examples = {num_examples}')
print(f'number of features = {num_features}')
num_features == size*size
idx = np.random.choice(num_examples)
x = X[idx].reshape(size,size)
print(f'x_{idx} of size {x.shape} :')
plt.imshow(x, cmap='gray', vmin=0, vmax=1)
plt.show()
if y[idx]==1:
class_ = 'vertical'
elif y[idx]==0:
class_ = 'horizontal'
print(f'true label = y = {y[idx]} = image of {class_} strips \n')
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.4, random_state=0)
num_train_examples, num_test_examples = X_train.shape[0], X_test.shape[0]
print(f'number of train examples = {num_train_examples}')
print(f'number of test examples = {num_test_examples}\n')
print(f'number of features = {num_features}')
num_train_examples + num_test_examples == num_examples
from qiskit.circuit.library import PauliFeatureMap, ZFeatureMap, ZZFeatureMap
'For angle encoding, num_qubits = num_features'
#fm = PauliFeatureMap(feature_dimension=num_features, reps=1, paulis=['Z'])
fm = ZZFeatureMap(feature_dimension=num_features, reps=1)
fm.decompose().draw()
from qiskit_machine_learning.circuit.library import RawFeatureVector
'For amplitude encoding, num_qubits = n = np.log2(num_features)''
fm = RawFeatureVector(feature_dimension=n)
fm.draw()
from qiskit.circuit.library import RealAmplitudes
'''
For angle encoding, num_qubits = num_features
For amplitude encoding, num_qubits = n = np.log2(num_features)
'''
pqc = RealAmplitudes(num_qubits=num_features, reps=3)
pqc.decompose().draw()
from qiskit.algorithms.optimizers import COBYLA
# This defines where to train our classifier: on a simulator or a real quantum computer
from qiskit.primitives import Sampler # here we have chosen a simulator
from qiskit_machine_learning.algorithms.classifiers import VQC # !pip install qiskit[machine-learning]
#------------------------------------------------------------------------------------------------
optimizer = COBYLA(maxiter=60) # maxiter = Maximum number of iterations (function evaluations)
sampler = Sampler()
#------------------------------------------------------------------------------------------------
from IPython.display import clear_output
objective_func_vals = []
# a callback that can access the intermediate data during the optimization
def callback(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
#------------------------------------------------------------------------------------------------
vqc = VQC(
sampler=sampler,
feature_map=fm,
ansatz=pqc,
optimizer=optimizer,
callback=callback,
)
%%time
'''Training time seems to increase with the number of features, examples, and learnable-parameters'''
vqc.fit(X_train, y_train)
%%time
def performance_VQC(X, y, name):
y_pred = vqc.predict(X)
print(classification_report(y, y_pred))
print(f'{confusion_matrix(y, y_pred)} = confusion matrix for {name} set \n')
return y_pred
y_pred_train = performance_VQC(X_train, y_train, 'train')
y_pred_test = performance_VQC(X_test, y_test, 'test')
idx = np.random.choice(len(X_test))
x = X_test[idx]
print(f'x of size {(size,size)} :')
plt.imshow(x.reshape(size,size), cmap='gray')
plt.show()
if y[idx]==1:
class_ = 'vertical'
elif y[idx]==0:
class_ = 'horizontal'
print(f'true label = y = {y[idx]} = image with {class_} strips \n')
y_pred_ = vqc.predict(x)
print(f'predicted label = {y_pred_}\n')
%%time
warnings.filterwarnings('ignore')
def train_test(ML_model):
print(20*' ', ML_model,'\n')
ML_model.fit(X_train, y_train) # fit model on train set
y_train_pred = ML_model.predict(X_train) # predict with the trained model
y_test_pred = ML_model.predict(X_test)
print(classification_report(y_train, y_train)) # evaluate model performance
print(confusion_matrix(y_train, y_train_pred), "= confusion matrix for train set \n")
print(classification_report(y_test, y_test_pred))
print(confusion_matrix(y_test, y_test_pred), "= confusion matrix for test set \n")
print(70*'=')
#----------------------------------------------------------------------------------
print(70*'=')
ML_model = linear_model.LogisticRegression() # create model instance
train_test(ML_model)
ML_model = MLPClassifier()
train_test(ML_model)
ML_model = svm.SVC()
train_test(ML_model)
ML_model = RandomForestClassifier()
train_test(ML_model)
|
https://github.com/ArunSehrawat/Quantum_Machine_Learning_use_cases_with_Qiskit
|
ArunSehrawat
|
import numpy as np
import matplotlib.pyplot as plt
import time, copy, warnings
import networkx as nx
n = 17 # = number of qubits
dim = 2**n # = dimension of the n-qubit Hilbert space
Q = np.random.randint(-10, 10, (n, n))
Q = np.triu(Q)
print(f'{Q} = Q matrix')
def plot_Q_matrix():
plt.matshow(Q, cmap='bwr')
plt.xticks(np.arange(n))
plt.yticks(np.arange(n))
cb = plt.colorbar(shrink=0.7)
plt.title(f'Q matrix')
plt.show()
plot_Q_matrix()
#----------------------------------------------------------------------------
'In the graph, a node represents a qubit (binary variables), width of the edge (i,j) is proportional to Q_ij'
plt.subplots(figsize=(10,8))
g = nx.Graph()
edges = []
for i in range(n):
for j in range(i, n):
if Q[i,j]!=0:
edges.append((i, j, Q[i,j]))
g.add_weighted_edges_from(edges)
pos = nx.spring_layout(g, seed=0)
nx.draw_networkx(g, pos, node_size= 700, node_color='magenta',
width=list(nx.get_edge_attributes(g, "weight").values()))
%%time
def energy(x, Q): # x in an integer, one-to-one correspondence: x <--> x_bin
x_bin = np.array([int(i) for i in np.binary_repr(x, n)]) # x_bin has n components, each one is either 0 (spin-up) or 1(spin-down)
E = np.linalg.multi_dot([x_bin, Q, x_bin]) # E_x = energy for a given x
return E
def energies(Q):
n = Q.shape[0] # number of qubits
dim = 2**n # dimension of the n-qubit Hilbert space
xE = []
for x in range(dim):
E = energy(x, Q)
xE.append([x, E])
return np.array(xE) # collection of all possible 2**n energies for different x
#----------------------------------------------------------------------------
xE = energies(Q=Q)
engs = xE[:,1]
print(f'energies for different x = [...E_x...] = {engs}')
#==============================================================================
min_eng = np.min(engs)
max_eng = np.max(engs)
plt.rcParams["figure.figsize"] = (12,10)
plt.scatter(np.arange(dim), engs, s=1, c='blue')
plt.axhline(y = 0, color = 'black', linestyle = '-')
plt.axhline(y = min_eng, color = 'red', linestyle = '-')
plt.ylabel(r'energy = $E_x = \langle x|H|x\rangle$', fontsize=20)
plt.xlabel('x', fontsize=20)
plt.show()
xmins = np.where(engs==min_eng)[0]
xmins_bin = [[int(i) for i in np.binary_repr(xmin, n)] for xmin in xmins]
print(f'global min_energy = {min_eng}')
print(f'global min_energy eigenstates = {xmins} = {xmins_bin}\n')
print(f'global max_energy = {max_eng}')
from qiskit_optimization import QuadraticProgram #!pip install qiskit[optimization]
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver, SamplingVQE, QAOA
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit.primitives import Sampler
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import SPSA, COBYLA
qp = QuadraticProgram()
for i in range(n):
qp.binary_var(f'x{i}')
linear = [Q[i,i] for i in range(n)]
quadratic = {}
for i in range(n):
for j in range(i+1, n):
quadratic[(f'x{i}', f'x{j}')] = Q[i,j]
qp.minimize(linear=linear, quadratic=quadratic)
qp
%%time
exact = MinimumEigenOptimizer(min_eigen_solver=NumPyMinimumEigensolver())
result = exact.solve(qp)
print(result.prettyprint())
print()
%%time
ansatz = TwoLocal(n, "ry", "cx", reps=3, entanglement="linear") # construct ansatz for VQE
vqe = SamplingVQE(sampler=Sampler(), ansatz=ansatz, optimizer=COBYLA(maxiter=10)) # construct VQE
meo_vqe = MinimumEigenOptimizer(min_eigen_solver=vqe) # run VQE
result_vqe = meo_vqe.solve(qp)
print(result_vqe.prettyprint())
print()
%%time
qaoa = QAOA(sampler=Sampler(), optimizer=COBYLA(maxiter=10), reps=3) # construct QAOA
meo_qaoa = MinimumEigenOptimizer(min_eigen_solver=qaoa) # run QAOA
result_qaoa = meo_qaoa.solve(qp)
print(result_qaoa.prettyprint())
print()
|
https://github.com/Subhamdg/QAOA_qiskit_MAXCUT
|
Subhamdg
|
%%capture
!pip install qiskit
from qiskit import *
import numpy as nm
import math
import matplotlib.pyplot as plt
import networkx as nx
v=nm.arange(0,8,1)
e=[(0,1,1),(1,3,4),(1,3,1),(0,5,2),(2,4,7),(3,4,6),(4,5,3),(4,6,4),(2,6,3),(3,6,1),(4,7,5),(6,7,1),(1,7,2)]
g=nx.Graph()
g.add_nodes_from(v)
g.add_weighted_edges_from(e)
nx.draw_networkx(g)
step=0.05
g=b=nm.arange(0,math.pi,step)
g,b=nm.meshgrid(g,b)
k=3-((nm.sin(2*b)**2)*(nm.sin(2*g)**2)-(0.5*nm.sin(4*b))*(nm.sin(4*g)))*(1+nm.cos(4*g)**2)
res=nm.where(k==nm.amax(k))
a=list(zip(res[0],res[1]))[0]
gam=a[0]*step;
bet=a[1]*step;
from matplotlib import cm
fig = plt.figure()
ax = fig.gca(projection='3d')
surf = ax.plot_surface(g,b,k,cmap=cm.coolwarm,linewidth=0,antialiased=True)
plt.show()
pi=math.pi
q=QuantumRegister(len(v))
c=ClassicalRegister(len(v))
qc=QuantumCircuit(q,c)
for i in range(len(v)):
qc.u3(pi/2,0,pi,q[i])
qc.barrier()
for i in e:
k = i[0]
l = i[1]
qc.u3(0,0,-gam,q[l])
qc.cx(q[l],q[k])
qc.u3(0,0,gam,q[k])
qc.cx(q[l],q[k])
qc.u3(0,0,-gam,q[k])
qc.u3(0,0,gam, k)
qc.u3(0,0,gam, l)
qc.barrier()
for i in range(len(v)):
qc.u3(2*bet,3*pi/2,pi/2,q[i])
qc.barrier()
for i in range(len(v)):
qc.measure(q[i],c[i])
qc.draw(output="mpl")
sim = Aer.get_backend('qasm_simulator')
res=execute(qc, backend=sim).result()
from qiskit.visualization import plot_histogram as ph
ph(res.get_counts(qc),figsize=(150,50))
|
https://github.com/harshdeeps036/QiskitFallFest21-AU
|
harshdeeps036
|
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumRegister, ClassicalRegister, execute
from qiskit import QuantumCircuit, execute, Aer
from qiskit.tools.jupyter import *
import matplotlib.pyplot as plt
import numpy as np
from math import pi
%matplotlib inline
def real_map(value, leftMin, leftMax, rightMin, rightMax):
# Maps one range to another
# Figure out how 'wide' each range is
leftSpan = leftMax - leftMin
rightSpan = rightMax - rightMin
# Convert the left range into a 0-1 range (float)
valueScaled = float(value - leftMin) / float(leftSpan)
# Convert the 0-1 range into a value in the right range.
return rightMin + (valueScaled * rightSpan)
# Quantum Random Number generator
def QRandom(a, b, qubits):
q = QuantumRegister(qubits, 'q')
circ = QuantumCircuit(q)
c0 = ClassicalRegister(1, 'c0')
circ.add_register(c0)
for i in range(qubits):
circ.h(q[i])
for i in range(qubits):
circ.measure(q[i], c0)
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
output = result.get_statevector(circ, decimals=5)
n1 = 0
n2 = 0
n3 = 0
for i in range( output.size ):
if abs(output[i]) != 0:
n1 = i
n2 = np.real(output[i])
n3 = np.imag(output[i])
y = real_map(n1+n2+n3, -qubits, len(output)-1+qubits, a, b)
return y
y = []
for i in range(20):
y.append(QRandom(0,100,3))
plt.plot(y)
# Example of number of unique random numbers:
# Generating 40 random numbers with our QRNG
y = []
for i in range(40):
y.append(QRandom(0,100,3))
count = 0
z=[]
#Counting the number of unique elements
for num in y:
if num not in z:
count = count+1
z.append(num)
print('The number of unique elements in provided random distribution is:')
print(count)
# Variational Quantum Random Number generator
def VarQRandom(a, b, theta, depth, qubits):
q = QuantumRegister(qubits, 'q')
circ = QuantumCircuit(q)
c0 = ClassicalRegister(2, 'c0')
circ.add_register(c0)
for j in range(depth):
for i in range(qubits):
circ.h(q[i])
#rotating the axis by an angle theta along y-axis
circ.ry(theta, q[i])
#rotating the axis by an angle theta along x-axis
circ.rx(theta, q[i])
for i in range(qubits):
circ.measure(q[i], c0)
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
result = job.result()
output = result.get_statevector(circ, decimals=5)
n1 = 0
n2 = 0
n3 = 0
for i in range( output.size ):
if abs(output[i]) != 0:
n1 = i
n2 = np.real(output[i])
n3 = np.imag(output[i])
y = real_map(n1+n2+n3, -qubits, len(output)-1+qubits, a, b)
return y
#initialization
m=0
length = 0
theta = 0
#taking input from the user
number = int(input('Enter the number of random numbers required'))
low = int(input('Enter lower limit'))
high = int(input('Enter higher limit'))
depth=1
x=[]
n=1
while length!=number:
y = VarQRandom(low,high,theta,depth,3)
while (y in x):
i=i+1
theta = theta + pi/16
y= VarQRandom(low,high,theta,depth,3)
if(i==(16*n)):
depth = depth+1
n=n+1
x.append(y)
length=len(x)
plt.plot(x)
count = 0
z=[]
#Counting the number of unique elements
for num in x:
if num not in z:
count = count+1
z.append(num)
print('The number of unique elements in provided random distribution is:')
print(count)
y2 = []
for i in range(20):
y2.append(QRandom(0,100,2))
plt.plot(y2)
z2=[]
count = 0
#Counting the number of unique elements
for num in y2:
if num not in z2:
count = count+1
z2.append(num)
print('The number of unique elements in provided random distribution is:')
print(count)
#initialization
m=0
length = 0
theta = 0
#taking input from the user
number = int(input('Enter the number of random numbers required'))
low = int(input('Enter lower limit'))
high = int(input('Enter higher limit'))
depth=1
x2=[]
n=1
while length!=number:
y = VarQRandom(low,high,theta,depth,2)
while (y in x2):
i=i+1
theta = theta + pi/16
y= VarQRandom(low,high,theta,depth,2)
if(i==(16*n)):
depth = depth+1
n=n+1
x2.append(y)
length=len(x2)
plt.plot(x2)
z2=[]
count = 0
#Counting the number of unique elements
for num in x2:
if num not in z2:
count = count+1
z2.append(num)
print('The number of unique elements in provided random distribution is:')
print(count)
from datetime import datetime
start_time = datetime.now()
y3 = []
for i in range(100):
y3.append(QRandom(0,100,2))
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
#initialization
m=0
length = 0
theta = 0
#taking input from the user
number = int(input('Enter the number of random numbers required'))
low = int(input('Enter lower limit'))
high = int(input('Enter higher limit'))
depth=1
x2=[]
n=1
start_time = datetime.now()
while length!=number:
y = VarQRandom(low,high,theta,depth,3)
while (y in x2):
i=i+1
theta = theta + pi/16
y= VarQRandom(low,high,theta,depth,3)
if(i==(16*n)):
depth = depth+1
n=n+1
x2.append(y)
length=len(x2)
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
#initialization
m=0
length = 0
theta = 0
#taking input from the user
number = int(input('Enter the number of random numbers required'))
low = int(input('Enter lower limit'))
high = int(input('Enter higher limit'))
depth=1
x4=[]
n=1
start_time = datetime.now()
while length!=number:
y = VarQRandom(low,high,theta,depth,2)
while (y in x2):
i=i+1
theta = theta + pi/16
y= VarQRandom(low,high,theta,depth,2)
if(i==(16*n)):
depth = depth+1
n=n+1
x4.append(y)
length=len(x4)
end_time = datetime.now()
print('Duration: {}'.format(end_time - start_time))
import random
testpy=[]
for i in range(20):
y=random.randint(1,100)
if y not in testpy:
testpy.append(y)
plt.plot(testpy)
#initialization
m=0
length = 0
theta = 0
#taking input from the user
number = int(input('Enter the number of random numbers required'))
low = int(input('Enter lower limit'))
high = int(input('Enter higher limit'))
depth=1
testvc=[]
n=1
while length!=number:
y = VarQRandom(low,high,theta,depth,2)
while (y in testvc):
i=i+1
theta = theta + pi/16
y= VarQRandom(low,high,theta,depth,2)
if(i==(16*n)):
depth = depth+1
n=n+1
testvc.append(y)
length=len(testvc)
plt.plot(testvc)
|
https://github.com/1ucian0/qiskit-openqasm2
|
1ucian0
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Created on Wed Mar 11 18:03:12 2020
Functional interface to Qasm2 source loading and exporting
Supersede QuantumCircuit member functions
Provide for pluggable qasm translator
Based on conversation with Dr. Luciano Bello
@author: jax
"""
from importlib import import_module
from os import linesep
from typing import List, BinaryIO, TextIO
from qiskit import QuantumCircuit, QiskitError
from qiskit_openqasm2 import Qasm
from .funhelp import qasm_load, qasm_export
def _load_from_string(qasm_src: str or List[str],
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
qasm_src : str or List[str]
Qasm program source as string or list of string.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Raises
------
QiskitError
If unknown loader.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
if isinstance(qasm_src, list):
qasm_src = ''.join(s + linesep for s in qasm_src)
qasm = Qasm(data=qasm_src)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(data=qasm_src,
include_path=include_path)
return circ
def _load_from_file(filename: str,
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
filename : str
Filepath to qasm program source.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
qasm = Qasm(filename=filename)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(filename=filename,
include_path=include_path)
return circ
def load(data: str or List[str] = None,
filename: str = None,
loader: str = None,
include_path: str = None) -> QuantumCircuit:
"""
Parameters
----------
data : str or List[str], optional
Qasm program source as string or list of string. The default is None.
filename : str, optional
Filepath to qasm program source. The default is None.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is None.
Raises
------
QiskitError
If both filename and data or neither filename nor data.
Returns
-------
QuantumCircuit
The factoried circuit.
"""
if (not data and not filename) or (data and filename):
raise QiskitError("To load, either filename or data (and not both) must be provided.")
circ = None
if data:
circ = _load_from_string(data, loader=loader, include_path=include_path)
elif filename:
circ = _load_from_file(filename, loader=loader, include_path=include_path)
return circ
def export(qc: QuantumCircuit,
exporter: str = None,
file: BinaryIO or TextIO = None,
filename: str = None,
include_path: str = None,) -> str:
"""
Decompile a QuantumCircuit into Return OpenQASM string
Parameters
----------
qc : QuantumCircuit
Circuit to decompile ("export")
exporter : str, optional
Name of module with functional attribute
export(qc: QuantumCircuit,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
file : BinaryIO or TextIO, optional
File object to write to as well as return str
Written in UTF-8
Caller must close file.
Mutually exclusive with filename=
The default is None.
filename : str, optional
Name of file to write export to as well as return str
Mutually exclusive with file=
The default is None.
include_path: str, optional
Unloader-specific include path for qasm include directives
Raises
------
QiskitError
If both filename and file
Returns
-------
str
OpenQASM source for circuit.
"""
if filename and file:
raise QiskitError("export: file= and filename= are mutually exclusive")
qasm_src = None
if not exporter:
qasm_src = qasm_export(qc)
else:
m_m = import_module(exporter)
qasm_src = getattr(m_m, 'export')(qc, include_path=include_path)
if filename:
f_f = open(filename, 'w')
f_f.write(qasm_src)
f_f.close()
elif file:
if 'b' in file.mode:
file.write(bytes(qasm_src, 'utf-8'))
else:
file.write(qasm_src)
return qasm_src
|
https://github.com/1ucian0/qiskit-openqasm2
|
1ucian0
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Created on Wed Mar 11 18:03:12 2020
Support via qiskit.qasm for functional interface
to Qasm2 source loading and exporting in functions.py
@author: jax
"""
# from importlib import import_module
# from os import linesep
# from typing import List
from qiskit import QuantumCircuit # , QiskitError
from qiskit.converters import ast_to_dag
from qiskit.converters import dag_to_circuit
from qiskit_openqasm2 import Qasm
def qasm_load(qasm: Qasm) -> QuantumCircuit:
"""
Factory OpenQASM src into QuantumCircuit
using qiskit.qasm code.
Parameters
----------
qasm : Qasm
The Qasm object of source to load.
Returns
-------
QuantumCircuit
The resulting QuantumCircuit.
"""
ast = qasm.parse()
dag = ast_to_dag(ast)
return dag_to_circuit(dag)
def qasm_export(qc: QuantumCircuit) -> str:
"""
Return OpenQASM string using qiskit.qasm code.
Parameters
----------
qc : QuantumCircuit
The circuit to be disassembled into OpenQASM source
Returns
-------
str
OpenQASM source for the circuit.
"""
string_temp = qc.header + "\n"
string_temp += qc.extension_lib + "\n"
for register in qc.qregs:
string_temp += register.qasm() + "\n"
for register in qc.cregs:
string_temp += register.qasm() + "\n"
unitary_gates = []
for instruction, qargs, cargs in qc._data:
if instruction.name == 'measure':
qubit = qargs[0]
clbit = cargs[0]
string_temp += "%s %s[%d] -> %s[%d];\n" % (instruction.qasm(),
qubit.register.name, qubit.index,
clbit.register.name, clbit.index)
else:
string_temp += "%s %s;\n" % (instruction.qasm(),
",".join(["%s[%d]" % (j.register.name, j.index)
for j in qargs + cargs]))
if instruction.name == 'unitary':
unitary_gates.append(instruction)
# this resets them, so if another call to qasm() is made the gate def is added again
for gate in unitary_gates:
gate._qasm_def_written = False
return string_temp
|
https://github.com/kaelynj/Qiskit-IsingModel
|
kaelynj
|
%reset -f
#%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister
from qiskit.providers.aer import QasmSimulator, StatevectorSimulator, UnitarySimulator
from qiskit.compiler import transpile, assemble
from qiskit.tools.monitor import job_monitor
import matplotlib.pyplot as plt
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.quantum_info import *
import numpy as np
provider = IBMQ.load_account()
# Loading your IBM Q account(s)
#provider = IBMQ.load_account()
#constants
n = 4
lambd = 1.2
def thetak(k,lamb):
num = lamb - np.cos(2*np.pi*k/n)
denom = np.sqrt( (lamb-np.cos(2*np.pi*k/n))**2 + np.sin(2*np.pi*k/n)**2)
theta = np.arccos(num/denom)
return theta
#Create functions based on the decomposition included in appendix of Ising paper
def bog(qcirc, q1, q2, theta):
qcirc.x(q2)
qcirc.cx(q2, q1)
#Controlled RX gate
qcirc.rz(np.pi/2, q2)
qcirc.ry(theta/2, q2)
qcirc.cx(q1, q2)
qcirc.ry(-theta/2, q2)
qcirc.cx(q1, q2) #changed from qc to qcirc here - Bruna
qcirc.rz(-np.pi/2, q2)
#####################
qcirc.cx(q2, q1)
qcirc.x(q2)
qcirc.barrier()
return qcirc
def fourier(qcirc, q1, q2, phase):
qcirc.rz(phase, q1)
qcirc.cx(q1, q2)
#Controlled Hadamard
qcirc.sdg(q1)
qcirc.h(q1)
qcirc.tdg(q1)
qcirc.cx(q2, q1)
qcirc.t(q1)
qcirc.h(q1)
qcirc.s(q1)
####################
qcirc.cx(q1, q2)
qcirc.cz(q1, q2)
qcirc.barrier()
return qcirc
def digit_sum(n):
num_str = str(n)
sum = 0
for i in range(0, len(num_str)):
sum += int(num_str[i])
return sum
def ground_state(lamb, backend_name): # backend is now an imput, so we can plot
# different ones easily - Bruna
qc = QuantumCircuit(4, 4)
#Set correct ground state if lambda < 1
if lamb < 1:
qc.x(3)
qc.barrier()
#magnetization
mag = []
#Apply disentangling gates
qc = bog(qc, 0, 1, thetak(1.,lamb))
qc = fourier(qc, 0, 1, 2*np.pi/n)
qc = fourier(qc, 2, 3, 0.)
qc = fourier(qc, 0, 1, 0.)
qc = fourier(qc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
qc.measure(i,i)
backend = Aer.get_backend(backend_name)
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
##while not '0000' in counts:
# job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
# job_monitor(job)
# result = job.result()
# counts = result.get_counts(qc)
#Check what ground state is based on lambda
r1=list(counts.keys())
r2=list(counts.values())
M=0
for j in range(0,len(r1)):
M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots
#print("$\lambda$: ",lam,", $<\sigma_{z}>$: ",M/4)
mag.append(M/4)
return mag
# if lamb < 1:
# return counts['0001']
# return counts['0000']/shots # it does not always works, sometimes it returns keyword error
# maybe we can add another else for the possibility of other states, but
# do not use it for plotting - Bruna
print(ground_state(lambd, 'qasm_simulator'))
#print(ground_state(.8,'statevector_simulator'))
lmbd = np.arange(.2, 1.75, 0.1)
sigmaz = []
for l in lmbd:
sigmaz.append(ground_state(l, 'qasm_simulator'))
print(sigmaz)
plt.plot(lmbd, sigmaz,'bo')
plt.ylabel("$\sigma_z$")
plt.xlabel("$\lambda$")
plt.ylim(0., 1.1)
plt.xlim(0., 1.8)
#Start up and initialize circuit
#Measurement
qc = QuantumCircuit(4, 4)
#Set correct ground state if lambda < 1
if lambd < 1:
qc.x(3)
qc.barrier()
#Apply disentangling gates
qc = bog(qc, 0, 1, thetak(1.,1.2))
qc = fourier(qc, 0, 1, 2*np.pi/n)
qc = fourier(qc, 2, 3, 0.)
qc = fourier(qc, 0, 1, 0.)
qc = fourier(qc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
qc.measure(i,i)
#Choose provider and backend
#provider = IBMQ.get_provider()
#provider = AerProvider()
#backend = Aer.get_backend('statevector_simulator')
backend = Aer.get_backend('qasm_simulator')
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = provider.get_backend('ibmqx4')
#backend = provider.get_backend('ibmqx2')
#backend = provider.get_backend('ibmq_16_melbourne')
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
#print(counts['0000'])
plot_histogram(counts)
# had to comment this part because qc is a local variable in groundstate function now - Bruna
phi = np.arccos(lambd/np.sqrt(1+lambd**2))/2
#print(result.get_statevector(qc))
print("|0000> probability should be: ",np.cos(phi)**2)
print("|0011> probability should be: ",np.sin(phi)**2 )
#print(counts['0000'])
def Time_Evo(t, lamb, backend_name):
quc = QuantumCircuit(4, 4)
#step 1. we are already in the |111> state
# time evolution of computational basis, step 2
quc.u3(np.arccos(lamb/np.sqrt(1+lamb**2)), np.pi/2 + 4*t*np.sqrt(1+lamb**2),0,0)
quc.cx(0,1)
#magnetization
mag = []
#step 3
#Apply disentangling gates
quc = bog(quc, 0, 1, thetak(1.,lamb))
quc = fourier(quc, 0, 1, 2*np.pi/n)
quc = fourier(quc, 2, 3, 0.)
quc = fourier(quc, 0, 1, 0.)
quc = fourier(quc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
quc.measure(i,i)
#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend(backend_name)
#backend = Aer.get_backend('statevector_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = provider.get_backend('ibmqx4')
#backend = provider.get_backend('ibmqx2')
#backend = provider.get_backend('ibmq_16_melbourne')
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(quc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(quc)
##while not '0000' in counts:
# job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
# job_monitor(job)
# result = job.result()
# counts = result.get_counts(qc)
#Check what ground state is based on lambda
r1=list(counts.keys())
r2=list(counts.values())
M=0
for j in range(0,len(r1)):
M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots
#print("$\lambda$: ",lam,", $<\sigma_{z}>$: ",M/4)
mag.append(M/4)
return mag
#f = Time_Evo(qc,1,lambd,'qasm_simulator')
#print(f)
#
ti = 0
tf = 2
time = np.arange(ti,tf,(tf-ti)/10)
f = []
for t in time:
f.append(Time_Evo(t,0.5,'ibmq_athens'))
#step 4
plt.plot(time, f)
plt.ylim(0., 1)
plt.xlim(0., 1.8)
plt.ylabel("Magnetization")
plt.xlabel("t")
plt.show()
|
https://github.com/kaelynj/Qiskit-IsingModel
|
kaelynj
|
%reset -f
#%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister
from qiskit.providers.aer import QasmSimulator, StatevectorSimulator, UnitarySimulator
from qiskit.compiler import transpile, assemble
from qiskit.tools.monitor import job_monitor
import matplotlib.pyplot as plt
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.quantum_info import *
import numpy as np
provider = IBMQ.load_account()
# Loading your IBM Q account(s)
#provider = IBMQ.load_account()
#constants
n = 4
lambd = 1.2
def thetak(k,lamb):
num = lamb - np.cos(2*np.pi*k/n)
denom = np.sqrt( (lamb-np.cos(2*np.pi*k/n))**2 + np.sin(2*np.pi*k/n)**2)
theta = np.arccos(num/denom)
return theta
#Create functions based on the decomposition included in appendix of Ising paper
def bog(qcirc, q1, q2, theta):
qcirc.x(q2)
qcirc.cx(q2, q1)
#Controlled RX gate
qcirc.rz(np.pi/2, q2)
qcirc.ry(theta/2, q2)
qcirc.cx(q1, q2)
qcirc.ry(-theta/2, q2)
qcirc.cx(q1, q2) #changed from qc to qcirc here - Bruna
qcirc.rz(-np.pi/2, q2)
#####################
qcirc.cx(q2, q1)
qcirc.x(q2)
qcirc.barrier()
return qcirc
def fourier(qcirc, q1, q2, phase):
qcirc.rz(phase, q1)
qcirc.cx(q1, q2)
#Controlled Hadamard
qcirc.sdg(q1)
qcirc.h(q1)
qcirc.tdg(q1)
qcirc.cx(q2, q1)
qcirc.t(q1)
qcirc.h(q1)
qcirc.s(q1)
####################
qcirc.cx(q1, q2)
qcirc.cz(q1, q2)
qcirc.barrier()
return qcirc
def digit_sum(n):
num_str = str(n)
sum = 0
for i in range(0, len(num_str)):
sum += int(num_str[i])
return sum
def ground_state(lamb, backend_name): # backend is now an imput, so we can plot
# different ones easily - Bruna
qc = QuantumCircuit(4, 4)
#Set correct ground state if lambda < 1
if lamb < 1:
qc.x(3)
qc.barrier()
#magnetization
mag = []
#Apply disentangling gates
qc = bog(qc, 0, 1, thetak(1.,lamb))
qc = fourier(qc, 0, 1, 2*np.pi/n)
qc = fourier(qc, 2, 3, 0.)
qc = fourier(qc, 0, 1, 0.)
qc = fourier(qc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
qc.measure(i,i)
backend = Aer.get_backend(backend_name)
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
##while not '0000' in counts:
# job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
# job_monitor(job)
# result = job.result()
# counts = result.get_counts(qc)
#Check what ground state is based on lambda
r1=list(counts.keys())
r2=list(counts.values())
M=0
for j in range(0,len(r1)):
M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots
#print("$\lambda$: ",lam,", $<\sigma_{z}>$: ",M/4)
mag.append(M/4)
return mag
# if lamb < 1:
# return counts['0001']
# return counts['0000']/shots # it does not always works, sometimes it returns keyword error
# maybe we can add another else for the possibility of other states, but
# do not use it for plotting - Bruna
print(ground_state(lambd, 'qasm_simulator'))
#print(ground_state(.8,'statevector_simulator'))
lmbd = np.arange(.2, 1.75, 0.1)
sigmaz = []
for l in lmbd:
sigmaz.append(ground_state(l, 'qasm_simulator'))
print(sigmaz)
plt.plot(lmbd, sigmaz,'bo')
plt.ylabel("$\sigma_z$")
plt.xlabel("$\lambda$")
plt.ylim(0., 1.1)
plt.xlim(0., 1.8)
#Start up and initialize circuit
#Measurement
qc = QuantumCircuit(4, 4)
#Set correct ground state if lambda < 1
if lambd < 1:
qc.x(3)
qc.barrier()
#Apply disentangling gates
qc = bog(qc, 0, 1, thetak(1.,1.2))
qc = fourier(qc, 0, 1, 2*np.pi/n)
qc = fourier(qc, 2, 3, 0.)
qc = fourier(qc, 0, 1, 0.)
qc = fourier(qc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
qc.measure(i,i)
#Choose provider and backend
#provider = IBMQ.get_provider()
#provider = AerProvider()
#backend = Aer.get_backend('statevector_simulator')
backend = Aer.get_backend('qasm_simulator')
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = provider.get_backend('ibmqx4')
#backend = provider.get_backend('ibmqx2')
#backend = provider.get_backend('ibmq_16_melbourne')
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
#print(counts['0000'])
plot_histogram(counts)
# had to comment this part because qc is a local variable in groundstate function now - Bruna
phi = np.arccos(lambd/np.sqrt(1+lambd**2))/2
#print(result.get_statevector(qc))
print("|0000> probability should be: ",np.cos(phi)**2)
print("|0011> probability should be: ",np.sin(phi)**2 )
#print(counts['0000'])
def Time_Evo(t, lamb, backend_name):
quc = QuantumCircuit(4, 4)
#step 1. we are already in the |111> state
# time evolution of computational basis, step 2
quc.u3(np.arccos(lamb/np.sqrt(1+lamb**2)), np.pi/2 + 4*t*np.sqrt(1+lamb**2),0,0)
quc.cx(0,1)
#magnetization
mag = []
#step 3
#Apply disentangling gates
quc = bog(quc, 0, 1, thetak(1.,lamb))
quc = fourier(quc, 0, 1, 2*np.pi/n)
quc = fourier(quc, 2, 3, 0.)
quc = fourier(quc, 0, 1, 0.)
quc = fourier(quc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
quc.measure(i,i)
#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend(backend_name)
#backend = Aer.get_backend('statevector_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = provider.get_backend('ibmqx4')
#backend = provider.get_backend('ibmqx2')
#backend = provider.get_backend('ibmq_16_melbourne')
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(quc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(quc)
##while not '0000' in counts:
# job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
# job_monitor(job)
# result = job.result()
# counts = result.get_counts(qc)
#Check what ground state is based on lambda
r1=list(counts.keys())
r2=list(counts.values())
M=0
for j in range(0,len(r1)):
M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots
#print("$\lambda$: ",lam,", $<\sigma_{z}>$: ",M/4)
mag.append(M/4)
return mag
#f = Time_Evo(qc,1,lambd,'qasm_simulator')
#print(f)
#
ti = 0
tf = 2
time = np.arange(ti,tf,(tf-ti)/10)
f = []
for t in time:
f.append(Time_Evo(t,0.5,'ibmq_athens'))
#step 4
plt.plot(time, f)
plt.ylim(0., 1)
plt.xlim(0., 1.8)
plt.ylabel("Magnetization")
plt.xlabel("t")
plt.show()
|
https://github.com/qiskit-community/qiskit-scheduling-extension
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test the CompactScheduling pass"""
from qiskit import QuantumCircuit
from qiskit.test import QiskitTestCase
from qiskit.transpiler.instruction_durations import InstructionDurations
from qiskit.transpiler.passes import PadDelay
from qiskit.transpiler.passmanager import PassManager
from qiskit_scheduling_extension.compact import CompactScheduleAnalysis
class TestCompactScheduling(QiskitTestCase):
"""Tests the CompactScheduling pass"""
def test_compact(self):
"""Test if Compact scheduling yields expected schedule.
(input)
┌───┐ ┌───┐ ░ ┌─┐
q_0: ┤ H ├──■─────────■──┤ H ├─░─┤M├──────
└───┘┌─┴─┐ ┌─┴─┐└───┘ ░ └╥┘┌─┐
q_1: ─────┤ X ├──■──┤ X ├──────░──╫─┤M├───
┌───┐└───┘┌─┴─┐├───┤ ░ ║ └╥┘┌─┐
q_2: ┤ H ├─────┤ X ├┤ H ├──────░──╫──╫─┤M├
└───┘ └───┘└───┘ ░ ║ ║ └╥┘
meas: 3/═════════════════════════════╩══╩══╩═
0 1 2
(Compact scheduled)
┌───┐ ┌────────────────┐ ┌───┐ ░ ┌─┐
q_0: ──────┤ H ├─────────■──┤ Delay(900[dt]) ├──■────────┤ H ├────────░─┤M├──────
┌─────┴───┴──────┐┌─┴─┐└────────────────┘┌─┴─┐┌─────┴───┴──────┐ ░ └╥┘┌─┐
q_1: ┤ Delay(200[dt]) ├┤ X ├────────■─────────┤ X ├┤ Delay(200[dt]) ├─░──╫─┤M├───
├────────────────┤├───┤ ┌─┴─┐ ├───┤├────────────────┤ ░ ║ └╥┘┌─┐
q_2: ┤ Delay(700[dt]) ├┤ H ├──────┤ X ├───────┤ H ├┤ Delay(700[dt]) ├─░──╫──╫─┤M├
└────────────────┘└───┘ └───┘ └───┘└────────────────┘ ░ ║ ║ └╥┘
meas: 3/════════════════════════════════════════════════════════════════════╩══╩══╩═
0 1 2
"""
qc = QuantumCircuit(3)
qc.h([0, 2])
qc.cx(0, 1)
qc.cx(1, 2)
qc.cx(0, 1)
qc.h([0, 2])
qc.measure_all()
durations = InstructionDurations(
[("h", None, 200), ("cx", [0, 1], 700), ("cx", [1, 2], 900), ("measure", None, 1000)]
)
pm = PassManager([CompactScheduleAnalysis(durations), PadDelay()])
compact_qc = pm.run(qc)
expected = QuantumCircuit(3)
expected.delay(200, 1)
expected.delay(700, 2)
expected.h([0, 2])
expected.cx(0, 1)
expected.cx(1, 2)
expected.delay(900, 0)
expected.cx(0, 1)
expected.h([0, 2])
expected.delay(200, 1)
expected.delay(700, 2)
expected.measure_all()
self.assertEqual(expected, compact_qc)
def test_compact_can_shift_block(self):
"""Test if Compact scheduling can shift front blocks towards the back and
back blocks towards the front.
(input)
░ ┌─┐
q_0: ──■─────────────────────────────■─────────────░─┤M├─────────
┌─┴─┐ ┌─┴─┐ ░ └╥┘┌─┐
q_1: ┤ X ├────────────■─────────■──┤ X ├───────────░──╫─┤M├──────
└───┘ ┌───┐┌─┴─┐ ┌─┴─┐├───┤ ░ ║ └╥┘┌─┐
q_2: ───────■──┤ H ├┤ X ├──■──┤ X ├┤ H ├──■────────░──╫──╫─┤M├───
┌───┐┌─┴─┐├───┤└───┘┌─┴─┐├───┤└───┘┌─┴─┐┌───┐ ░ ║ ║ └╥┘┌─┐
q_3: ┤ H ├┤ X ├┤ H ├─────┤ X ├┤ H ├─────┤ X ├┤ H ├─░──╫──╫──╫─┤M├
└───┘└───┘└───┘ └───┘└───┘ └───┘└───┘ ░ ║ ║ ║ └╥┘
meas: 4/═════════════════════════════════════════════════╩══╩══╩══╩═
0 1 2 3
(Compact scheduled)
┌─────────────────┐ »
q_0: ────────■─────────┤ Delay(1000[dt]) ├────────────────────────────»
┌─┴─┐ └─────────────────┘ »
q_1: ──────┤ X ├────────────────────────────────────────────■─────────»
┌─────┴───┴──────┐ ┌───┐ ┌─┴─┐ »
q_2: ┤ Delay(750[dt]) ├─────────────────────■──┤ H ├──────┤ X ├───────»
├────────────────┤ ┌───┐ ┌─┴─┐├───┤┌─────┴───┴──────┐»
q_3: ┤ Delay(700[dt]) ├───────┤ H ├───────┤ X ├┤ H ├┤ Delay(400[dt]) ├»
└────────────────┘ └───┘ └───┘└───┘└────────────────┘»
meas: 4/═════════════════════════════════════════════════════════════════»
»
« »
« q_0: ───────────────────────────────■────────────────────────────────»
« ┌────────────────┐ ┌─┴─┐ »
« q_1: ┤ Delay(200[dt]) ├──■────────┤ X ├──────────────────────────────»
« └────────────────┘┌─┴─┐ ├───┤ ┌────────────────┐»
« q_2: ────────■─────────┤ X ├──────┤ H ├─────────■──┤ Delay(750[dt]) ├»
« ┌─┴─┐ ├───┤┌─────┴───┴──────┐┌─┴─┐└─────┬───┬──────┘»
« q_3: ──────┤ X ├───────┤ H ├┤ Delay(400[dt]) ├┤ X ├──────┤ H ├───────»
« └───┘ └───┘└────────────────┘└───┘ └───┘ »
«meas: 4/════════════════════════════════════════════════════════════════»
« »
« ░ ┌─┐
« q_0: ───────────────────░─┤M├─────────
« ░ └╥┘┌─┐
« q_1: ───────────────────░──╫─┤M├──────
« ░ ║ └╥┘┌─┐
« q_2: ───────────────────░──╫──╫─┤M├───
« ┌────────────────┐ ░ ║ ║ └╥┘┌─┐
« q_3: ┤ Delay(700[dt]) ├─░──╫──╫──╫─┤M├
« └────────────────┘ ░ ║ ║ ║ └╥┘
«meas: 4/══════════════════════╩══╩══╩══╩═
« 0 1 2 3
"""
qc = QuantumCircuit(4)
qc.cx(0, 1)
qc.h(3)
qc.cx(2, 3)
qc.h([2, 3])
qc.cx(1, 2)
qc.cx(2, 3)
qc.cx(1, 2)
qc.h([2, 3])
qc.cx(2, 3)
qc.h(3)
qc.cx(0, 1)
qc.measure_all()
durations = InstructionDurations(
[
("h", None, 50),
("cx", [0, 1], 1000),
("cx", [1, 2], 400),
("cx", [2, 3], 200),
("measure", None, 1000),
]
)
pm = PassManager([CompactScheduleAnalysis(durations), PadDelay()])
compact_qc = pm.run(qc)
expected = QuantumCircuit(4)
expected.delay(750, 2)
expected.delay(700, 3)
expected.cx(0, 1)
expected.h(3)
expected.cx(2, 3)
expected.h([2, 3])
expected.delay(400, 3)
expected.cx(1, 2)
expected.delay(1000, 0)
expected.delay(200, 1)
expected.cx(2, 3)
expected.cx(1, 2)
expected.h([2, 3])
expected.delay(400, 3)
expected.cx(2, 3)
expected.h(3)
expected.cx(0, 1)
expected.delay(750, 2)
expected.delay(700, 3)
expected.measure_all()
self.assertEqual(expected, compact_qc)
|
https://github.com/qiskit-community/qiskit-scheduling-extension
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test the CompactScheduling pass"""
from qiskit import QuantumCircuit, transpile
from qiskit.test import QiskitTestCase
from qiskit.transpiler.preset_passmanagers.plugin import list_stage_plugins
class TestCompactScheduling(QiskitTestCase):
"""Tests the CompactScheduling plugin"""
def test_plugin_in_list(self):
"""Test compact scheduling plugin is installed."""
self.assertIn("compact", list_stage_plugins("scheduling"))
def test_compact(self):
"""Test if Compact scheduling yields expected schedule.
(input)
┌───┐ ┌───┐ ░ ┌─┐
q_0: ┤ H ├──■─────────■──┤ H ├─░─┤M├──────
└───┘┌─┴─┐ ┌─┴─┐└───┘ ░ └╥┘┌─┐
q_1: ─────┤ X ├──■──┤ X ├──────░──╫─┤M├───
┌───┐└───┘┌─┴─┐├───┤ ░ ║ └╥┘┌─┐
q_2: ┤ H ├─────┤ X ├┤ H ├──────░──╫──╫─┤M├
└───┘ └───┘└───┘ ░ ║ ║ └╥┘
meas: 3/═════════════════════════════╩══╩══╩═
0 1 2
(Compact scheduled)
┌───┐ ┌────────────────┐ ┌───┐ ░ ┌─┐
q_0: ──────┤ H ├─────────■──┤ Delay(900[dt]) ├──■────────┤ H ├────────░─┤M├──────
┌─────┴───┴──────┐┌─┴─┐└────────────────┘┌─┴─┐┌─────┴───┴──────┐ ░ └╥┘┌─┐
q_1: ┤ Delay(200[dt]) ├┤ X ├────────■─────────┤ X ├┤ Delay(200[dt]) ├─░──╫─┤M├───
├────────────────┤├───┤ ┌─┴─┐ ├───┤├────────────────┤ ░ ║ └╥┘┌─┐
q_2: ┤ Delay(700[dt]) ├┤ H ├──────┤ X ├───────┤ H ├┤ Delay(700[dt]) ├─░──╫──╫─┤M├
└────────────────┘└───┘ └───┘ └───┘└────────────────┘ ░ ║ ║ └╥┘
meas: 3/════════════════════════════════════════════════════════════════════╩══╩══╩═
0 1 2
"""
qc = QuantumCircuit(3)
qc.h([0, 2])
qc.cx(0, 1)
qc.cx(1, 2)
qc.cx(0, 1)
qc.h([0, 2])
qc.measure_all()
durations = [
("h", None, 200),
("cx", [0, 1], 700),
("cx", [1, 2], 900),
("measure", None, 1000)
]
actual = transpile(
qc, instruction_durations=durations, scheduling_method="compact", optimization_level=0
)
expected = QuantumCircuit(3)
expected.delay(200, 1)
expected.delay(700, 2)
expected.h([0, 2])
expected.cx(0, 1)
expected.cx(1, 2)
expected.delay(900, 0)
expected.cx(0, 1)
expected.h([0, 2])
expected.delay(200, 1)
expected.delay(700, 2)
expected.measure_all()
self.assertEqual(expected, actual)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
CX_12 = tp(proj(cb(2,0)),id(2)) + tp(proj(cb(2,1)),pauli(1)); CX_12
CX_21 = tp(id(2),proj(cb(2,0))) + tp(pauli(1),proj(cb(2,1))); CX_21
SWAP = CX_12*CX_21*CX_12; SWAP
Cz = tp(proj(cb(2,0)), id(2)) + tp(proj(cb(2,1)), pauli(3)); Cz_12 = Cz
Cz_21 = tp(id(2),proj(cb(2,0))) + tp(pauli(3),proj(cb(2,1)))
Cz_12, Cz_21
H = (1/sqrt(2))*Matrix([[1,1],[1,-1]]); H
Cx12 = tp(id(2),H)*Cz*tp(id(2),H); Cx12
Cx21 = tp(H,id(2))*Cz*tp(H,id(2)); Cx21
CX_21 = tp(id(2),proj(cb(2,0))) + tp(pauli(1),proj(cb(2,1))); CX_21
Cz12 = tp(id(2),H)*Cx12*tp(id(2),H); Cz12
Cz21 = tp(id(2),H)*Cx21*tp(id(2),H); Cz12
CCX = tp(proj(cb(2,0)),id(4)) + tp(proj(cb(2,1)),Cx12); CCX
def qc_ry(th):
qr = QuantumRegister(1)
qc = QuantumCircuit(qr, name = 'RY')
qc.ry(th, 0)
return qc
from qiskit import *
qr = QuantumRegister(3)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
qc_ry_ = qc_ry(math.pi)
ccry = qc_ry_.to_gate().control(2)
qc.append(ccry, [2, 0, 1])
qc.draw(output = 'mpl')
from qiskit import *
qc = QuantumCircuit(1, 1); qc.h([0]); qc.h([0]); qc.measure([0], [0]); qc.draw(output = 'mpl')
qc = QuantumCircuit(1, 1); qc.barrier(); qc.h([0]); qc.barrier(); qc.h([0]); qc.barrier(); qc.measure([0], [0])
qc.draw(output = 'mpl')
qc.decompose().draw(output = 'mpl')
qc = QuantumCircuit(1, 1)
N = 5
for j in range(0, N):
qc.id([0])
qc.measure([0], [0])
qc.draw(output = 'mpl')
nshots = 8192
qiskit.IBMQ.load_account()
#provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
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.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import backend_overview, backend_monitor
from qiskit.tools.visualization import plot_histogram
qc = QuantumCircuit(1, 1)
N = 0
for j in range(0, N):
qc.barrier(); qc.id([0])
qc.barrier(); qc.measure([0], [0])
qc.draw(output = 'mpl')
job_exp = execute(qc, backend = device, shots = nshots)
print(job_exp.job_id()); job_monitor(job_exp)
plot_histogram(job_exp.result().get_counts(qc))
qc = QuantumCircuit(1, 1)
N = 10000
for j in range(0, N):
qc.barrier(); qc.id([0])
qc.barrier(); qc.measure([0], [0]);
#qc.draw(output = 'mpl')
job_exp = execute(qc, backend = device, shots = nshots)
print(job_exp.job_id()); job_monitor(job_exp)
plot_histogram(job_exp.result().get_counts(qc))
qc = QuantumCircuit(4); qc.h([0]); qc.cx([0], [2]); qc.h([1]); qc.cx([1], [3]); qc.draw(output = 'mpl')
qc = QuantumCircuit(3); qc.h([0]); qc.cx([0], [1]); qc.reset([0]); qc.h([0]); qc.cx([0], [2])
qc.draw(output = 'mpl')
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
4312/8192, 8155/8192
a,b,c,d = symbols('a b c d')
a, b, c, d
X = Matrix([[0,1],[1,0]]); Y = Matrix([[0,-1j],[1j,0]]); Z = Matrix([[1,0],[0,-1]]); I = Matrix([[1,0],[0,1]])
X, Y, Z, I
rho = a*X+b*Y+c*Z+d*I; rho
tr(X*rho), simplify(tr(Y*rho)), tr(Z*rho), tr(I*rho),
pp=4260/8192; pop=4470/8192; p0=8158/8192; pp, pop, p0
Xav = 2*pp-1; Yav = 2*pop-1; Zav = 2*p0-1; Xav, Yav, Zav
def rho_1qb_tomo(Xav,Yav,Zav):
return (1/2)*(Xav*X+Yav*Y+Zav*Z+I)
rho = rho_1qb_tomo(Xav,Yav,Zav); rho, rho.eigenvects()
c00, a1, a2, a3, b1, b2, b3 = symbols('c_{00} a_1 a_2 a_3 b_1 b_2 b_3')
c11, c12, c13, c21,c22,c23,c31,c32,c33 = symbols('c_{11} c_{12} c_{13} c_{21} c_{22} c_{23} c_{31} c_{32} c_{33}')
c00, a1, a2, a3, b1, b2, b3, c11, c12, c13, c21,c22,c23,c31,c32,c33
rho = c00*tp(I,I) + a1*tp(X,I) + a2*tp(Y,I) + a3*tp(Z,I) + b1*tp(I,X) + b2*tp(I,Y) + b3*tp(I,Z)
rho += c11*tp(X,X) + c12*tp(X,Y) + c13*tp(X,Z) + c21*tp(Y,X) + c22*tp(Y,Y) + c23*tp(Y,Z)
rho += c31*tp(Z,X) + c32*tp(Z,Y) + c33*tp(Z,Z)
rho
tr(rho), tr(rho*tp(X,I)), simplify(tr(rho*tp(Y,I))), simplify(tr(rho*tp(Z,I))), \
simplify(tr(rho*tp(I,X))), simplify(tr(rho*tp(I,Y))), simplify(tr(rho*tp(I,Z))), \
tr(rho*tp(X,X)), simplify(tr(rho*tp(X,Y))), simplify(tr(rho*tp(X,Z))), \
simplify(tr(rho*tp(Y,X))), simplify(tr(rho*tp(Y,Y))), simplify(tr(rho*tp(Y,Z))), \
tr(rho*tp(Z,X)), simplify(tr(rho*tp(Z,Y))), simplify(tr(rho*tp(Z,Z)))
n = 137; N = 4**n-1; N-10**82
p00 = 3906/8192; p01 = 257/8192; p10 = 253/8192; p11 = 3776/8192; p00,p01,p10,p11
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
# importa o qiskit, cujas funcoes podemos entao usar
import qiskit
# para ver que versoes das ferramentas do qiskit temos instaladas
qiskit.__qiskit_version__
# determina o API token a ser usado
qiskit.IBMQ.save_account('76cefda2ab77d95541b7cf7a52dc060ae5552c2c67297b954cb056ea1dbf4cc2de3428fc8156cfa85ce0816608b323bf8b9134d8567bcebd3d84d2c4d9473bb9',
overwrite = True)
# conecta meu computador com minha conta IBMQ na nuvem
qiskit.IBMQ.load_account()
# determina qual das minhas "contas" vou usar.
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
# mostra quais beckends posso utilizar
provider.backends()
provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
# para ter um panorama do tipo e status dos backends disponiveis
#from qiskit.tools.monitor import backend_overview, backend_monitor
#backend_overview()
# utilizado para obter informacoes sobre um determinado backend
#simulator = provider.get_backend('ibmq_qasm_simulator')
#device = provider.get_backend('ibmq_oslo')
# informacao detalhada sobre um determinado backend
#chip_info = backend_monitor(device); print(chip_info)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
X = Matrix([[0,1],[1,0]]); Y = Matrix([[0,-1j],[1j,0]]); Z = Matrix([[1,0],[0,-1]]); I = Matrix([[1,0],[0,1]])
x,y,z=symbols('x y z'); rho = (1/2)*(x*X+y*Y+z*Z+I); rho
rho.eigenvals()
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector([[0.5,0.5,0.3]])
# Exemplo de representacao de vários estados na esfera de Bloch
points = []
r = 0.1; M = 3; dr = 1/M
for k in range(0, M):
r += dr
th = math.pi/2; ph = 0+k*0.01; N = 10; dph = 2*math.pi/N
for j in range(0, N):
ph += dph
x = r*math.sin(th)*math.cos(ph); y = r*math.sin(th)*math.sin(ph); z = r*math.cos(th)
points.append([x,y,z])
plot_bloch_vector(points)
#bb.savefig('blochb.pdf', format = 'png', dpi = 100)
trace(rho**2)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import * # import tudo do qiskit
# Determina o número de qubits e de cbits a serem utilizados
qr = QuantumRegister(2) # determina quantos qubits serão usados
cr = ClassicalRegister(2) # determina quantos cbits serão usados
# Constrói o circuito quântico
qc = QuantumCircuit(qr, cr)
# para o circuitos quânticos ficarem mais apresentáveis
%matplotlib inline
qc.draw(output='mpl') # mostra o circuito
# adiciona a porta lógica de Hadamard ao circuito, aplicada no qubit (registro quântico) 0
qc.h(qr[0]); # tem que usar ; pra não dar aviso
qc.draw(output = 'mpl') # o output = 'mpl' é para a figura ficar mais apresentável
# adiciona uma controll-not ao circuito, com o controle sendo qr[0] e o target sendo qr[1]
qc.cx(qr[0],qr[1]);
# é importante sempre mandar mostrar o circuito, pra ter certeza que é realmente o que queremos construir
qc.draw(output = 'mpl')
# adiciona medidas em todos os qubits (a ser usada quando queremos acessar a distribuições de probabilidades)
qc.measure(qr,cr);
qc.draw(output = 'mpl')
# Determina o backend a ser usado, que poder ser um simulador ou um chip real
# Neste caso escolhemos o simulador qasm_simulator
simulator = Aer.get_backend('qasm_simulator')
# número de medidas para estimativa de uma distribuição de probabilidades
nshots = 8192
# executa o circuito qc no backend escolhido
result = execute(qc, backend = simulator, shots = nshots).result()
# para visualizar o histograma da distribuicao de probabilidades
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(qc))
counts = result.get_counts(qc); counts, counts['00']
# carrega minha conta no IBMQ (o ID foi incluido no outro arquivo, nao precisa incluir aqui)
qiskit.IBMQ.load_account();
#provider = IBMQ.get_provider('ibm-q')
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
# determina em qual backend vamos executar o circuito
device = provider.get_backend('ibmq_casablanca')
# se certifica que o backend esta certo
device.name()
# executa o circuito quantico qc no CQ escolhido
job = execute(qc, backend = device, shots = nshots)
from qiskit.tools.monitor import job_monitor
# para monitorar a execucao do circuito
job_monitor(job)
result = job.result()
plot_histogram(result.get_counts(qc))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
!pip install -U qiskit==0.39.4
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
qr = QuantumRegister(1)
qc = QuantumCircuit(qr)
qc.h(qr[0])
qc.draw()
from qiskit_experiments.library import StateTomography # essa é com o novo qiskit 039
qcst = StateTomography(qc, measurement_qubits = [0])
data = qcst.run(simulator)
rho = data.block_for_results().analysis_results(0).value
from qiskit.visualization import array_to_latex
array_to_latex(rho)
d = rho.dims()[0]; print(rho.dims(), d)
rhoM = rho.to_operator().data; print(rhoM)
rhoM[0,0], abs(rhoM[0,0])
job_exp = qcst.run(device, shots=nshots)#.block_for_results()
print(job_exp.experiment_id)
job_exp.job_status()
sudo apt install jupyter-core
rho = job_exp.block_for_results().analysis_results(0).value
rhoM = rho.to_operator().data; print(rhoM)
for j in range(0,10):
print("\r %d"%j,end=" ")
data = device.retrieve_job('03834ee2-0c74-45ff-b744-2cfa3d74f860')
rho = data.block_for_results().analysis_results(0).value
rhoM = rho.to_operator().data; print(rhoM)
!pip install -U qiskit==0.36.2
# como sempre, importa tudo do qiskit
from qiskit import *
import qiskit
qiskit.__qiskit_version__
# importa também funcoes para determinar os circuitos a serem tomografados e pra ajustar os dados
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
# cria os circuitos, sem medidas
qr = QuantumRegister(1); qc = qiskit.QuantumCircuit(qr);
# cria o circuito
qc.h(qr[0]);
# visualiza o circuito
qc.draw(output='mpl')
# Determina de qual circuito e de qual qubit fazer TEQ
qstc = state_tomography_circuits(qc, qr[0])
# No. de medidas pra estimar cada dist. de probabilidade
nshots = 8192
# testa/executa no simulador
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
# 'ajusta' os resultados conforme o esperado do circuit qst
qstf = StateTomographyFitter(job.result(), qstc)
# extrai o operador densidade tomografado
rho = qstf.fit(method='lstsq')
# note que o que retorna é um array do numpy
rho # funcionou mudando a versao do qiskit com o novo ambiente conda
import numpy as np
from matplotlib import pyplot as plt
# grafica a parte real de um estado de um qubit
def plot_rho1qb(rho):
from mpl_toolkits.mplot3d import Axes3D
from matplotlib import cm
result = [rho[0,0], rho[0,1], rho[1,0], rho[1,1]]
result = np.array(result, dtype=float)
fig = plt.figure(figsize=(4, 4), dpi=100)
ax1 = fig.add_subplot(111, projection='3d')
xlabels = np.array([r'$|0\rangle$', r'$|1\rangle$']); xpos = np.arange(xlabels.shape[0])
ylabels = np.array([r'$|1\rangle$', r'$|0\rangle$']); ypos = np.arange(ylabels.shape[0])
xposM, yposM = np.meshgrid(xpos, ypos, copy=False); zpos = result
dx = 0.5; dy = 0.5; dz = zpos
ax1.set_xlim(0, 1.5); ax1.set_ylim(0, 1.5); ax1.set_zlim(-1, 1)
ax1.w_xaxis.set_ticks(xpos + dx/2.0); ax1.w_xaxis.set_ticklabels(xlabels)
ax1.w_yaxis.set_ticks(ypos + dy/2.0); ax1.w_yaxis.set_ticklabels(ylabels)
values = np.linspace(0.2, 1.0, xposM.ravel().shape[0]); colors = cm.rainbow(values)
ax1.bar3d(xposM.ravel(), yposM.ravel(), dz*0, dx, dy, dz, color=colors)
plt.show()
plot_rho1qb(rho.real), plot_rho1qb(rho.imag)
# carrega minha conta no IBMQ (o ID foi incluido no outro arquivo, nao precisa incluir aqui)
qiskit.IBMQ.load_account();
#provider = IBMQ.get_provider('ibm-q')
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
# determina em qual backend vamos executar o circuito
device = provider.get_backend('ibmq_quito')
# para monitorar a execucao
from qiskit.tools.monitor import job_monitor
# executa os circuitos para TEQ no chip
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
# 'ajusta' os resultados conforme o esperado do circuit qst
qstf = StateTomographyFitter(job.result(), qstc)
# extrai o operador densidade tomografado
rho = qstf.fit(method='lstsq'); rho
plot_rho1qb(rho.real), plot_rho1qb(rho.imag)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
X = Matrix([[0,1],[1,0]]); Y = Matrix([[0,-1j],[1j,0]]); Z = Matrix([[1,0],[0,-1]]); I = Matrix([[1,0],[0,1]])
xa,ya,za,xb,yb,zb = symbols('x_a y_a z_a x_b y_b z_b')
xx,xy,xz,yx,yy,yz,zx,zy,zz = symbols('xx xy xz yx yy yz zx zy zz')
rho_ab = (1/4)*(tp(I,I) + xa*tp(X,I) + ya*tp(Y,I) + za*tp(Z,I) + xb*tp(I,X) + yb*tp(I,Y) + zb*tp(I,Z))
rho_ab += (1/4)*(xx*tp(X,X) + xy*tp(X,Y) + xz*tp(X,Z) + yx*tp(Y,X) + yy*tp(Y,Y) + yz*tp(Y,Z))
rho_ab += (1/4)*(zx*tp(Z,X) + xy*tp(Z,Y) + zz*tp(Z,Z))
rho_ab
trace(rho_ab)
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_a = ptraceB(2, 2, rho_ab); rho_a
rho_b = ptraceA(2, 2, rho_ab); rho_b
# alguns resultados prontos que usare de init.ipynb
cb(2,0), cb(2,1), id(2), pauli(1), proj(cb(2,0)), tp(cb(2,0),cb(2,0))
CX_ab = tp(proj(cb(2,0)),id(2)) + tp(proj(cb(2,1)),pauli(1)); CX_ab
CX_ba = tp(id(2),proj(cb(2,0))) + tp(pauli(1),proj(cb(2,1))); CX_ba
SWAP = CX_ab*CX_ba*CX_ab; SWAP
SWAP = CX_ba*CX_ab*CX_ba; SWAP
# aplica a troca ao estado de 2 qubits
rho_ab_swap = SWAP*rho_ab*SWAP # pois a SWAP é hermitiana
# verificação que a troca ocorreu
rho_a_swap = ptraceB(2, 2, rho_ab_swap); rho_a_swap
rho_b_swap = ptraceA(2, 2, rho_ab_swap); rho_b_swap
def pTraceL_num(dl, dr, rhoLR):
# Returns the left partial trace over the 'left' subsystem of 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):
# Returns the right partial trace over the 'right' subsystem of 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
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
qc.h(qr[1]); qc.s(qr[1]); qc.draw()
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
nshots = 8192
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots) # executa no simulador
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); rhoBA # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
qc.cx(qr[0],qr[1]); qc.cx(qr[0],qr[1]); qc.draw()
# data contém todas as portas lógicas do cicuito quântico em uma lista (ou dicionário)
data = qc.data; data
# imprime uma componente de qc.data
print( data[3] )
# deleta uma componente de data
data.pop(3)
data.pop(4)
data.pop(3)
# agora o circuit está como queremos
qc.draw()
qc.cx(qr[1],qr[0]); qc.draw()
data = qc.data; data.pop(3)
qc.cx(qr[0],qr[1]); qc.draw()
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots) # executa no simulador
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
qc.h(qr[1]); qc.s(qr[1]); qc.barrier(); qc.draw()
qiskit.IBMQ.load_account();
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
qc.cx(qr[0],qr[1]); qc.cx(qr[1],qr[0]); qc.cx(qr[0],qr[1]);
data = qc.data; data.pop(5)
qc.draw()
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
def psi(th):
return cos(th/2)*cb(2,0) + sin(th/2)*cb(2,1)
th, ph = symbols('theta phi'); psi(th)
def Psi(th,ph):
return CX_ab*tp(psi(th),psi(ph))
th, ph = symbols('theta phi'); Psi(th,ph)
th, ph = math.pi/3, math.pi/4; Psi(th,ph)
def rhoA(th,ph):
return ptraceB(2, 2, proj(Psi(th,ph)))
th, ph = symbols('theta phi'); simplify(rhoA(th,ph))
th, ph = math.pi/3, math.pi/4; simplify(rhoA(th,ph))
rhoa = rhoA(th,ph); rhoa.eigenvals()
def rhoB(th,ph):
return ptraceA(2, 2, proj(Psi(th,ph)))
th, ph = symbols('theta phi'); simplify(rhoB(th,ph))
th, ph = math.pi/3, math.pi/4; simplify(rhoB(th,ph))
rhob = rhoB(th,ph); rhob.eigenvals()
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
th = math.pi/3; ph = math.pi/4
qc.u(th,0,0,qr[0]); qc.u(ph,0,0,qr[1]); qc.cx(qr[0],qr[1]); qc.barrier();
qc.draw()
data = qc.data; data.pop(1);
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots) # executa no simulador
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
qc.cx(qr[1],qr[0]); qc.cx(qr[0],qr[1]); qc.cx(qr[1],qr[0])
qc.draw()
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots) # executa no simulador
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
rhoB = pTraceR_num(2, 2, rhoBA); rhoB
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
rp = np.arange(0,1.1,0.1); vth = 2*np.arccos(np.sqrt(rp)); rp, vth
def ket_rp(th,phi):
return Matrix([[cos(th/2)],[(cos(ph)+1j*sin(ph))*sin(th/2)]])
def ket_rm(th,phi):
return Matrix([[sin(th/2)],[-(cos(ph)+1j*sin(ph))*cos(th/2)]])
rp,th,ph = symbols('r_{+} theta phi', Real=True); ket_rp(th,ph), ket_rm(th,ph)
def rho(rp,rm,th,ph):
return rp*proj(ket_rp(th,ph)) + rm*proj(ket_rm(th,ph))
rp,rm,th,ph = symbols('r_{+} r_{-} theta phi', Real=True); simplify(rho(rp,rm,th,ph))
rp = 1/2; vth = 2*math.acos(sqrt(rp)); th = 0*math.pi/4; ph = 0*math.pi/3
simplify(rho(rp,1-rp,th,ph))
print(rp, vth, th, ph)
import qiskit
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
simulator = provider.get_backend('ibmq_qasm_simulator')
device = provider.get_backend('ibmq_belem')
nshots = 8192
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import job_monitor
def pTraceL_num(dl, dr, rhoLR):
# Returns the left partial trace over the 'left' subsystem of 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
qr = qiskit.QuantumRegister(2); qc = qiskit.QuantumCircuit(qr)
qc.u(vth,0,0,qr[0]); qc.cx(qr[0],qr[1]); qc.u(th,ph,math.pi,qr[0]);
qc.draw()
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, backend = simulator, shots = nshots) # executa no simulador
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); rhoA = pTraceL_num(2, 2, rhoBA); rhoA
qc.draw()
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
a,b,c,d = symbols('a,b,c,d', Real=True, Positive=True);
z,w = symbols('z,w', Real=True)
rhoX = Matrix([[a,0,0,w],[0,b,z,0],[0,z,c,0],[w,0,0,d]]); rhoX
rhoX.eigenvals()
rhoX.eigenvects()
a,b,g = symbols('alpha beta gamma', Real = True, Positive = True)
p00 = (cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2
p01 = (cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2
p10 = (cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2
p11 = (cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2
p00,p01,p10,p11
simplify(p00+p01+p10+p11) # ok
th,ph = symbols('theta phi', Real = True, Positive = True)
psi00 = cos(th)*tp(cb(2,0),cb(2,0)) + sin(th)*tp(cb(2,1),cb(2,1))
psi10 = -sin(th)*tp(cb(2,0),cb(2,0)) + cos(th)*tp(cb(2,1),cb(2,1))
psi01 = sin(ph)*tp(cb(2,0),cb(2,1)) + cos(ph)*tp(cb(2,1),cb(2,0))
psi11 = cos(ph)*tp(cb(2,0),cb(2,1)) - sin(ph)*tp(cb(2,1),cb(2,0))
psi00, psi10, psi01, psi11
rho23 = p00*proj(psi00) + p01*proj(psi01) + p10*proj(psi10) + p11*proj(psi11);
simplify(rho23)
p00,p01,p10,p11 = symbols('p_{00},p_{01},p_{10},p_{11}')
rho23 = p00*proj(psi00) + p01*proj(psi01) + p10*proj(psi10) + p11*proj(psi11);
rho23
nonlinsolve([((cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2)*cos(th)**2 + (cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2*sin(th)**2 - a,
((cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2)*sin(ph)**2 + ((cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2)*cos(ph)**2 - b,
((cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2)*cos(ph)**2 + ((cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2)*sin(ph)**2 - c,
((cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2)*sin(ph)**2 + (cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2*cos(th)**2 - d,
((cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2-(cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2)*sin(ph)*cos(ph) - z,
((cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2-(cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2)*sin(th)*cos(th) - w],
[th,ph,a,b,g])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
def gell_mann(d, g, j, k):
gm = np.zeros((d,d), dtype= complex)
if g == 'i': # identity
for j in range(0,d):
gm[j,j] = 1
elif g == 'd': # diagonal
nt = math.sqrt(2/(j*(j+1)))
for m in range(0,j):
gm[m,m] = nt
gm[j,j] = -j*nt
elif g == 's': # symmetric
gm[j-1,k-1] = 1; gm[k-1,j-1] = 1
elif g == 'a': # anti-symmetric
gm[j-1,k-1] = -1j; gm[k-1,j-1] = 1j
return gm
gell_mann(2, 'i', 0, 0), gell_mann(2, 'd', 1, 1), gell_mann(2, 's', 1, 2), gell_mann(2, 'a', 1, 2)
def bloch_vector(A):
d = A.shape[0]; bv = np.zeros((d**2-1), dtype = complex)
#bv[0] = trace(d,A)
for j in range(1,d): # diagonal
bv[j-1] = 0
for k in range(1,j+1):
bv[j-1] += A[k-1,k-1]
bv[j-1] -= j*A[j,j]
bv[j-1] *= math.sqrt(2/(j*(j+1)))
for k in range(1,d): # symmetric
for l in range(k+1,d+1):
j += 1
bv[j-1] = A[l-1,k-1] + A[k-1,l-1]
for k in range(1,d): # anti-symmetric
for l in range(k+1,d+1):
j += 1
bv[j-1] = -1j*(A[l-1,k-1] - A[k-1,l-1])
return bv.real
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]])
A = 0.5*(s0 + 0.1*s1 + 0.2*s2 + 0.3*s3); bloch_vector(A)
def corr_mat_dd(da, db, M):
cmdd = np.zeros((da-1,db-1), dtype = complex)
for j in range(1,da):
for k in range(1,db):
for m in range(1,j+1):
for n in range(1,k+1):
cmdd[j-1,k-1] += M[(m-1)*db+(n-1),(m-1)*db+(n-1)]
m = j+1
for n in range(1,k+1):
cmdd[j-1,k-1] -= j*M[(m-1)*db+(n-1),(m-1)*db+(n-1)]
n = k+1
for m in range(1,j+1):
cmdd[j-1,k-1] -= k*M[(m-1)*db+(n-1),(m-1)*db+(n-1)]
m = j+1
n = k+1
cmdd[j-1,k-1] += j*k*M[(m-1)*db+(n-1),(m-1)*db+(n-1)]
cmdd[j-1,k-1] *= 2/sqrt(j*(j+1)*k*(k+1))
return cmdd.real
def Pauli(j):
if j == 0:
return np.array([[1,0],[0,1]])
elif j == 1:
return np.array([[0,1],[1,0]])
elif j == 2:
return np.array([[0,-1j],[1j,0]])
elif j == 3:
return np.array([[1,0],[0,-1]])
def rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33):
return (1/4)*(tp(Pauli(0),Pauli(0)) + b1*tp(Pauli(0),Pauli(1)) + b2*tp(Pauli(0),Pauli(2)) + b3*tp(Pauli(0),Pauli(3))
+ a1*tp(Pauli(1),Pauli(0)) + c11*tp(Pauli(1),Pauli(1)) + c12*tp(Pauli(1),Pauli(2)) + c13*tp(Pauli(1),Pauli(3))
+ a2*tp(Pauli(2),Pauli(0)) + c21*tp(Pauli(2),Pauli(1)) + c22*tp(Pauli(2),Pauli(2)) + c23*tp(Pauli(2),Pauli(3))
+ a3*tp(Pauli(3),Pauli(0)) + c31*tp(Pauli(3),Pauli(1)) + c32*tp(Pauli(3),Pauli(2)) + c33*tp(Pauli(3),Pauli(3)))
a1, a2, a3, b1, b2, b3 = 0.11, 0.12, 0.13, 0.25, 0.26, 0.27
c11, c12, c13, c21, c22, c23, c31, c32, c33 = 0.11, 0.12, 0.13, 0.21, 0.22, 0.23, 0.31, 0.32, 0.33
corr_mat_dd(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33))
def corr_mat_ds(da, db, M):
cmds = np.zeros((da-1,db*(db-1)//2), dtype = complex)
for j in range(1,da):
n = 0
for k in range(1,db):
for l in range(k+1,db+1):
n += 1
for m in range(1,j+1):
cmds[j-1,n-1] += (M[(m-1)*db+(l-1),(m-1)*db+(k-1)] + M[(m-1)*db+(k-1),(m-1)*db+(l-1)])
m = j+1
cmds[j-1,n-1] -= j*(M[(m-1)*db+(l-1),(m-1)*db+(k-1)] + M[(m-1)*db+(k-1),(m-1)*db+(l-1)])
cmds[j-1,n-1] *= sqrt(2/(j*(j+1)))
return cmds.real
corr_mat_ds(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33))
def corr_mat_da(da, db, M):
cmda = np.zeros((da-1,db*(db-1)//2), dtype = complex)
for j in range(1,da):
n = 0
for k in range(1,db):
for l in range(k+1,db+1):
n += 1
for m in range(1,j+1):
cmda[j-1,n-1] += (M[(m-1)*db+(l-1),(m-1)*db+(k-1)] - M[(m-1)*db+(k-1),(m-1)*db+(l-1)])
m = j+1
cmda[j-1,n-1] -= j*(M[(m-1)*db+(l-1),(m-1)*db+(k-1)] - M[(m-1)*db+(k-1),(m-1)*db+(l-1)])
cmda[j-1,n-1] *= -1j*sqrt(2/(j*(j+1)))
return cmda.real
corr_mat_da(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33))
def corr_mat_sd(da, db, M):
cmsd = np.zeros((da*(da-1)//2,db-1), dtype = complex)
n = 0
for k in range(1,da):
for l in range(k+1,da+1):
n += 1
for j in range(1,db):
for m in range(1,j+1):
cmsd[n-1,j-1] += (M[(l-1)*db+(m-1),(k-1)*db+(m-1)] + M[(k-1)*db+(m-1),(l-1)*db+(m-1)])
m = j+1
cmsd[n-1,j-1] -= j*(M[(l-1)*db+(m-1),(k-1)*db+(m-1)] + M[(k-1)*db+(m-1),(l-1)*db+(m-1)])
cmsd[n-1,j-1] *= sqrt(2/(j*(j+1)))
return cmsd.real
corr_mat_sd(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33))
def corr_mat_ad(da, db, M):
cmad = np.zeros((da*(da-1)//2,db-1), dtype = complex)
n = 0
for k in range(1,da):
for l in range(k+1,da+1):
n += 1
for j in range(1,db):
for m in range(1,j+1):
cmad[n-1,j-1] += (M[(l-1)*db+m-1,(k-1)*db+m-1] - M[(k-1)*db+m-1,(l-1)*db+m-1])
m = j+1
cmad[n-1,j-1] -= j*(M[(l-1)*db+m-1,(k-1)*db+m-1] - M[(k-1)*db+m-1,(l-1)*db+m-1])
cmad[n-1,j-1] *= -1j*sqrt(2/(j*(j+1)))
return cmad.real
corr_mat_ad(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33))
def corr_mat_ss(da, db, M):
cmss = np.zeros((da*(da-1)//2,db*(db-1)//2), dtype = complex)
p = 0
for k in range(1,da):
for l in range(k+1,da+1):
p += 1
q = 0
for m in range(1,db):
for n in range(m+1,db+1):
q += 1
cmss[p-1,q-1] += (M[(l-1)*db+n-1,(k-1)*db+m-1] + M[(k-1)*db+m-1,(l-1)*db+n-1])
cmss[p-1,q-1] += (M[(l-1)*db+m-1,(k-1)*db+n-1] + M[(k-1)*db+n-1,(l-1)*db+m-1])
return cmss.real
corr_mat_ss(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33))
def corr_mat_sa(da, db, M):
cmsa = np.zeros((da*(da-1)//2,db*(db-1)//2), dtype = complex)
p = 0
for k in range(1,da):
for l in range(k+1,da+1):
p += 1
q = 0
for m in range(1,db):
for n in range(m+1,db+1):
q += 1
cmsa[p-1,q-1] -= 1j*(M[(l-1)*db+n-1,(k-1)*db+m-1] - M[(k-1)*db+m-1,(l-1)*db+n-1])
cmsa[p-1,q-1] -= 1j*(M[(k-1)*db+n-1,(l-1)*db+m-1] - M[(l-1)*db+m-1,(k-1)*db+n-1])
return cmsa.real
simplify(corr_mat_sa(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33)))
def corr_mat_as(da, db, M):
cmas = np.zeros((da*(da-1)//2,db*(db-1)//2), dtype = complex)
p = 0
for k in range(1,da):
for l in range(k+1,da+1):
p += 1
q = 0
for m in range(1,db):
for n in range(m+1,db+1):
q += 1
cmas[p-1,q-1] -= 1j*(M[(l-1)*db+n-1,(k-1)*db+m-1] - M[(k-1)*db+m-1,(l-1)*db+n-1])
cmas[p-1,q-1] -= 1j*(M[(l-1)*db+m-1,(k-1)*db+n-1] - M[(k-1)*db+n-1,(l-1)*db+m-1])
return cmas.real
simplify(corr_mat_as(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33)))
def corr_mat_aa(da, db, M):
cmaa = np.zeros((da*(da-1)//2,db*(db-1)//2), dtype = complex)
p = 0
for k in range(1,da):
for l in range(k+1,da+1):
p += 1
q = 0
for m in range(1,db):
for n in range(m+1,db+1):
q += 1
cmaa[p-1,q-1] += (M[(l-1)*db+m-1,(k-1)*db+n-1] + M[(k-1)*db+n-1,(l-1)*db+m-1])
cmaa[p-1,q-1] -= (M[(l-1)*db+n-1,(k-1)*db+m-1] + M[(k-1)*db+m-1,(l-1)*db+n-1])
return cmaa.real
corr_mat_aa(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33))
def corr_mat(da, db, M):
dda = int((da*(da-1))/2); ddb = int((db*(db-1))/2); cm = np.zeros((da**2-1,db**2-1))
k = -1; l = -1
cmdd = corr_mat_dd(da, db, M); cmds = corr_mat_ds(da, db, M); cmda = corr_mat_da(da, db, M)
for m in range(0,da-1):
k += 1
for n in range(0,db-1): # diagonal-diagonal
l += 1; cm[k,l] = cmdd[m,n]
for n in range(0,ddb): # diagonal-symmetric
l += 1; cm[k,l] = cmds[m,n]
for n in range(0,ddb): # diagonal-antisymmetric
l += 1; cm[k,l] = cmda[m,n]
cmsd = corr_mat_sd(da, db, M); cmss = corr_mat_ss(da, db, M); cmsa = corr_mat_sa(da, db, M)
l = -1
for m in range(0,dda):
k += 1
for n in range(0,db-1): # symmetric-diagonal
l += 1; cm[k,l] = cmsd[m,n]
for n in range(0,ddb): # symmetric-symmetric
l += 1; cm[k,l] = cmss[m,n]
for n in range(0,ddb): # symmetric-antisymmetric
l += 1; cm[k,l] = cmsa[m,n]
cmad = corr_mat_ad(da, db, M); cmas = corr_mat_as(da, db, M); cmaa = corr_mat_aa(da, db, M)
l = -1
for m in range(0,dda):
k += 1
for n in range(0,db-1): # antisymmetric-diagonal
l += 1; cm[k,l] = cmad[m,n]
for n in range(0,ddb): # antisymmetric-symmetric
l += 1; cm[k,l] = cmas[m,n]
for n in range(0,ddb): # antisymmetric-antisymmetric
l += 1; cm[k,l] = cmaa[m,n]
return cm.real
simplify(corr_mat(2,2,rho2qb(a1, a2, a3, b1, b2, b3, c11, c12, c13, c21, c22, c23, c31, c32, c33)))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
%run 08_gellmann.ipynb
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
rho = np.array([[1,0],[0,0]]); rho, coh_l1(rho)
rho = np.array([[1,1],[1,1]])/2; rho, coh_l1(rho)
def mutual_info(da, db, rhoAB):
rhoA = pTraceR_num(da, db, rhoAB); Sa = von_neumann_num(rhoA)
rhoB = pTraceL_num(da, db, rhoAB); Sb = von_neumann_num(rhoB)
Sab = von_neumann_num(rhoAB)
return Sa + Sb - Sab
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.log(pv[j], 2)
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 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
rho = proj(tp(cb(2,0),cb(2,0))); rho, mutual_info(2, 2, rho)
rho = 0.5*proj(tp(cb(2,0),cb(2,0))) + 0.5*proj(tp(cb(2,1),cb(2,1))); rho, mutual_info(2, 2, rho)
psi = (1/math.sqrt(2))*(tp(cb(2,0),cb(2,0))+tp(cb(2,1),cb(2,1)))
rho = proj(psi); rho, mutual_info(2, 2, rho)
import scipy
def Dhellinger(da, db, rhoAB):
M = scipy.linalg.sqrtm(rhoAB)
A = pTraceR_num(da, db, M); bva = bloch_vector(A)/math.sqrt(2*db)
B = pTraceL_num(da, db, M); bvb = bloch_vector(B)/2
cm = corr_mat(da, db, M)/2; ev = lapak.zheevd(bva*bva.T + cm*cm.T)
D_he = 2 - 2*math.sqrt((np.trace(A)/math.sqrt(2*db))**2 + (scipy.linalg.norm(bvb))**2 + max(ev[0].real))
D_he = D_he/(2 - 2/math.sqrt(da))
return D_he
da = 2; db = 2
M = scipy.linalg.sqrtm(np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,1]])/4)
A = pTraceR_num(2, 2, M); bva = bloch_vector(A)/math.sqrt(2*2); bva
B = pTraceL_num(da, db, M); bvb = bloch_vector(B)/2; bvb
cm = corr_mat(da, db, M)/2; ev = lapak.zheevd(bva*bva.T + cm*cm.T); cm
D_he = 2 - 2*math.sqrt((np.trace(A)/math.sqrt(2*db))**2 + (scipy.linalg.norm(bvb))**2 + max(ev[0].real))
D_he = D_he/(2 - 2/math.sqrt(da)); D_he
# teste para a raiz quadrada de matriz calculada usando scipy
A = np.array([[1,0],[0,-1]]); Asr = scipy.linalg.sqrtm(A); Asr # raiz quadrada (testes)
#Asr*Asr
def Pauli(j):
if j == 0:
return np.array([[1,0],[0,1]])
elif j == 1:
return np.array([[0,1],[1,0]])
elif j == 2:
return np.array([[0,-1j],[1j,0]])
elif j == 3:
return np.array([[1,0],[0,-1]])
ev = lapak.zheevd(Pauli(1)); ev, ev[0], ev[0][0], ev[1][0], ev[1][0][0]
def Econcurrence(rho):
R = rho@tp(Pauli(2),Pauli(2))@np.matrix.conjugate(rho)@tp(Pauli(2),Pauli(2))
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
# Emaranhamento de formação
def Eof(rho):
Ec = Econcurrence(rho)
pv = np.zeros(2); pv[0] = (1+math.sqrt(1-Ec**2))/2; pv[1] = 1 - pv[0]
return shannon_num(pv)
pv=np.array([1,2]); pv.shape
x = np.arange(10**-3,1,0.01); p0 = (1 + np.sqrt(1-x**2))/2; p1 = 1 - p0
ef = np.zeros(x.shape[0]); ef = -p0*np.log2(p0) - p1*np.log2(p1)
plt.plot(x , ef); plt.xlabel(r'$E_{c}$'); plt.ylabel(r'$E_{f}$'); plt.show()
def rho_werner(w):
rho = np.zeros((4,4), dtype = complex)
rho =+ ((1-w)/4)*np.identity(4) + (w/2)*np.array([[1,0,0,1],[0,0,0,0],[0,0,0,0],[1,0,0,1]])
return rho
rho_werner(0)
w = np.arange(0, 1.05, 0.05); C = np.zeros(w.shape[0]); MI = np.zeros(w.shape[0]); D_he = np.zeros(w.shape[0])
Ec = np.zeros(w.shape[0]); Ef = np.zeros(w.shape[0])
for j in range(0, w.shape[0]):
rho = rho_werner(w[j]); C[j] = coh_l1(rho); MI[j] = mutual_info(2, 2, rho)/2
D_he[j] = Dhellinger(2, 2, rho); Ec[j] = Econcurrence(rho); Ef[j] = Eof(rho)
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(w, C, label = r'$C$'); plt.plot(w, MI, label = r'$I/2$');
plt.plot(w, D_he, label = r'$D_{A}^{he}$')
plt.plot(w, Ec, '*', label = r'$E_{c}$'); plt.plot(w, Ef, '-.', label = r'$E_{f}$')
plt.xlabel(r'$w$'); plt.legend(); plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
def Uf_c(n):
qr = QuantumRegister(n+1); qc = QuantumCircuit(qr, name = 'Uf_c')
qc.x(qr[n])
return qc
qc = Uf_c(3); qc.draw()
def Uf_b(n):
qr = QuantumRegister(n+1); qc = QuantumCircuit(qr, name = 'Uf_b')
qc.cx(qr[n-1],qr[n])
return qc
qc = Uf_b(3); qc.draw()
def deutsch_jozsa(n, typ):
qr = QuantumRegister(n+1); cr = ClassicalRegister(n); qc = QuantumCircuit(qr,cr)
qc.x(qr[n])
for j in range(0,n+1):
qc.h(qr[j])
qc.barrier()
qrs = []
for j in range(0,n+1):
qrs.append(qr[j])
if typ == 'c':
qc_uf = Uf_c(n); qc.append(qc_uf, qrs)
elif typ == 'b':
qc_uf = Uf_b(n); qc.append(qc_uf, qrs)
qc.barrier()
for j in range(0,n):
qc.h(qr[j])
for j in range(0,n):
qc.measure(qr[j], cr[j])
return qc
qc = deutsch_jozsa(3, 'c'); qc.draw() # exemplo pra funcao constante
simulator = Aer.get_backend('qasm_simulator')
nshots = 8192
result = execute(qc, backend = simulator, shots = nshots).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(qc))
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import backend_overview, backend_monitor
job = execute(qc, backend = device, shots = nshots)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result = job.result(); plot_histogram(result.get_counts(qc))
qc = deutsch_jozsa(3, 'b'); qc.draw() # exemplo de funcao balanceada
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
result = job.result(); plot_histogram(result.get_counts(qc))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
lbda = symbols('lambda', real=True); E0 = Matrix([[1,0],[0,sqrt(1-lbda)]]); E0
# coefficients of the expansion of E0 in the Pauli basis
c0 = trace((id(2)/sqrt(2))*E0); c1 = trace((pauli(1)/sqrt(2))*E0)
c2 = trace((pauli(2)/sqrt(2))*E0); c3 = trace((pauli(3)/sqrt(2))*E0)
simplify(c0), simplify(c1), simplify(c2), simplify(c3)
E1 = Matrix([[0,0],[0,sqrt(lbda)]]); E1
# coefficients for the expansion of E1 in the Pauli basis
c0 = trace((id(2)/sqrt(2))*E1); c1 = trace((pauli(1)/sqrt(2))*E1)
c2 = trace((pauli(2)/sqrt(2))*E1); c3 = trace((pauli(3)/sqrt(2))*E1)
simplify(c0), simplify(c1), simplify(c2), simplify(c3)
V00,V10,V20,V30,W00,W01,W02,W03,W10,W11,W12,W13=symbols('V00 V10 V20 V30 W00 W01 W02 W03 W10 W11 W12 W13',real=True)
#nonlinsolve([V00**2+V10**2+V20**2+V30**2-1, W00**2+W01**2+W02**2+W03**2-1,
# W10**2+W11**2+W12**2+W13**2-1,W10*W00+W11*W01+W12*W02+W13*W03,
# W00*V00-(1+sqrt(1-lbda))/2, W01*V10, W02*V20, W03*V30-(1-sqrt(1-lbda))/2,
# W10*V00-sqrt(lbda)/2, W11*V10, W12*V20, W13*V30+sqrt(lbda)/2],
# [V00,V10,V20,V30,W00,W01,W02,W03,W10,W11,W12,W13])
# took too long for solving (did not return any result)
V = Matrix([[sqrt((1+sqrt(1-lbda))/2),0,0,sqrt((1-sqrt(1-lbda))/2)],[0,1,0,0],[0,0,1,0],
[sqrt((1-sqrt(1-lbda))/2),0,0,-sqrt((1+sqrt(1-lbda))/2)]])
V
V*V.T, V.T*V # verification of unitarity
W = Matrix([[0,1,0,0],[sqrt((1-sqrt(1-lbda))/2),0,0,sqrt((1+sqrt(1-lbda))/2)],[0,0,1,0],
[sqrt((1+sqrt(1-lbda))/2),0,0,-sqrt((1-sqrt(1-lbda))/2)]])
W
W*W.T, W.T*W # verification of unitarity
r00,r01,r10,r11 = symbols('r00,r01,r10,r11',real=True)
rhoS0 = Matrix([[r00,r01],[r10,r11]])
rhoS0 # initial state
rhoS = E0*rhoS0*E0 + E1*rhoS0*E1; simplify(rhoS) # evolved state using the Kraus' operators
# Outside these functions, initialize: rhos = zeros(ds,ds), s=A,B
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
# tests the circuit for the PDC
rhoSA0 = tp(rhoS0,proj(cb(4,0)))#; rhoSA0
rhoSA1 = tp(id(2),V)*rhoSA0*tp(id(2),V.T)#; rhoSA1
Uc = tp(id(2),proj(cb(4,0))) + tp(id(2),proj(cb(4,1))) + tp(id(2),proj(cb(4,2))) + tp(pauli(3),proj(cb(4,3)))
#Uc*Uc.T, Uc.T*Uc
rhoSA2 = Uc*rhoSA1*Uc.T; #rhoSA2
rhoSA3 = tp(id(2),W)*rhoSA2*tp(id(2),W.T) # Não precisava pois só mudará a base de A
rhoS = ptraceB(2, 4, rhoSA3); simplify(rhoS) # ok!
V = Matrix([[sqrt((1+sqrt(1-lbda))/2),sqrt((1-sqrt(1-lbda))/2)],
[sqrt((1-sqrt(1-lbda))/2),-sqrt((1+sqrt(1-lbda))/2)]])
W = V; V
# tests the (http://arxiv.org/abs/1704.05593) circuit
rhoSA0 = tp(rhoS0,proj(cb(2,0))); rhoSA0
rhoSA1 = tp(id(2),V)*rhoSA0*tp(id(2),V.T); rhoSA1
Uc = tp(id(2),proj(cb(2,0))) + tp(pauli(3),proj(cb(2,1))); Uc, Uc*Uc.T, Uc.T*Uc
rhoSA2 = Uc*rhoSA1*Uc.T; rhoSA2
rhoSA3 = tp(id(2),W)*rhoSA2*tp(id(2),W.T)
rhoS = ptraceB(2, 2, rhoSA3); simplify(rhoS) # also works!
lb = np.arange(0,1.05,0.05); th = 2*np.arccos(np.sqrt((1+np.sqrt(1-lb))/2))
th_ = 2*np.arcsin(np.sqrt((1-np.sqrt(1-lb))/2))
plt.plot(lb,th); plt.plot(lb, th_, '*')
plt.xlabel(r'$\lambda$'); plt.ylabel(r'$\theta$'); plt.show()
# phase damping channel, exact
def phase_damping(rho, lb):
E0 = Matrix([[1,0],[0,sqrt(1-lb)]]); E1 = Matrix([[0,0],[0,sqrt(lb)]])
return E0*rho*E0 + E1*rho*E1
lb = symbols('lambda')
psi = (cb(2,0)+cb(2,1))/sqrt(2); rho = proj(psi); rhopd = phase_damping(rho, lb)
rho, rhopd
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 += abs(rho[j,k])
return 2*C
coh = coh_l1(rhopd); coh
# simulation
from qiskit import *
def state_prep():
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name = 'state_prep')
qc.h(qr[0])
return qc
qc_sp = state_prep(); qc_sp.draw()
def qc_sim_pd(lb):
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name = 'pd_sim')
th = 2*math.acos(math.sqrt((1+math.sqrt(1-lb))/2))
qc.u(th, 0, math.pi, qr[1]); qc.cz(qr[1],qr[0]); qc.u(th, 0, math.pi, qr[1])
return qc
lb = 0.5; qc_pd = qc_sim_pd(lb); qc_pd.draw()
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
qc_sp = state_prep(); qc.append(qc_sp, [qr[0]]); qc.barrier()
lb = 0; qc_pd = qc_sim_pd(lb); qc.append(qc_pd, [qr[0],qr[1]]); qc.barrier()
qc.draw()
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
lb = np.arange(0,1.05,0.05); d = lb.shape[0]; Cteo = np.zeros(d); Csim = np.zeros(d); Cexp = np.zeros(d)
for j in range(0, d):
Cteo[j] = np.abs(math.sqrt(1-lb[j])) # theoretical
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
qc_sp = state_prep(); qc.append(qc_sp, [qr[0]]) # state preparation
qc_pd = qc_sim_pd(lb[j]); qc.append(qc_pd, [qr[0],qr[1]]) # apply sim phase damping
qstc = state_tomography_circuits(qc, qr[0]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
Csim[j] = coh_l1(rho)
# 1st I did the simulation, only afterwards I added the code for the experiments
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
Cexp[j] = coh_l1(rho)
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(lb, Cteo, label = r'$C_{teo}$'); plt.plot(lb, Csim, 'o', label = r'$C_{sim}$')
plt.plot(lb, Cexp, '*', label = r'$C_{exp}$')
plt.legend(); plt.xlabel(r'$\lambda$'); plt.show()
2960/8
750/15
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
S = Matrix([[1,0],[0,1j]]); Sd = Matrix([[1,0],[0,-1j]]); H = (1/sqrt(2))*Matrix([[1,1],[1,-1]])#; S, H
S*H*S
from qiskit import *
def qc_mzi_sim(ph): # quantum circuit for the Mach-Zehnder interferometer
qr = QuantumRegister(1); qc = QuantumCircuit(qr)
qc.u(math.pi/2, math.pi/2, -math.pi/2, qr[0]); # DF
#qc.s(qr[0]); qc.h(qr[0]); qc.s(qr[0]) # DF
qc.z(qr[0]); qc.y(qr[0]) # espelho
qc.p(ph, qr[0]); # fase
qc.u(math.pi/2, math.pi/2, -math.pi/2, qr[0]) # DF
#qc.s(qr[0]); qc.h(qr[0]); qc.s(qr[0]) # DF
return qc
qcmzi = qc_mzi_sim(math.pi/8); qcmzi.draw()
def state_prep(th, ph):
qr = QuantumRegister(1); qc = QuantumCircuit(qr)
qc.u(th, ph, 0, qr[0])
return qc
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
# 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 = execute(meas_calibs, backend = device, shots = nshots); job_monitor(job)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph)#; ph
d = ph.shape[0]; PD0teo = np.zeros(d); PD0sim = np.zeros(d); PD0exp = np.zeros(d)
for j in range(0, d):
PD0teo[j] = (1+math.cos(ph[j]))/2 # theoretical
qr = QuantumRegister(1); qc = QuantumCircuit(qr)
qc_sp = state_prep(0, 0); qc.append(qc_sp, [qr[0]]) # state preparation (estado |0>)
qc_mzi = qc_mzi_sim(ph[j]); qc.append(qc_mzi, [qr[0]]) # apply sim mzi
qstc = state_tomography_circuits(qc, qr[0]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0sim[j] = rho[0,0].real
# 1º fiz as simulações, só depois adicionei o código para os experimentos
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0exp[j] = rho[0,0].real
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, PD0teo, label = r'$P_{teo}(D_{0})$')
plt.plot(ph, PD0sim, 'o', label = r'$P_{sim}(D_{0})$')
plt.plot(ph, PD0exp, '*', label = r'$P_{exp}(D_{0})$')
plt.legend(); plt.xlabel(r'$\phi$'); plt.show()
# gráfico para estado inicial |+>
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph)#; ph
d = ph.shape[0]; PD0teo = np.zeros(d); PD0sim = np.zeros(d); PD0exp = np.zeros(d)
for j in range(0, d):
c0 = 1/math.sqrt(2); c1 = c0;
PD0teo[j] = (abs(c0)**2*(1+math.cos(ph[j])) + abs(c1)**2*(1-math.cos(ph[j]))\
- 2*((c0*np.conjugate(c1)).real)*math.sin(ph[j]))/2
qr = QuantumRegister(1); qc = QuantumCircuit(qr)
qc_sp = state_prep(math.pi/2, 0); qc.append(qc_sp, [qr[0]]) # state preparation (estado |+>)
qc_mzi = qc_mzi_sim(ph[j]); qc.append(qc_mzi, [qr[0]]) # apply sim phase damping
qstc = state_tomography_circuits(qc, qr[0]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0sim[j] = rho[0,0].real
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, PD0teo, label = r'$P_{teo}(D_{0})$')
plt.plot(ph, PD0sim, 'o', label = r'$P_{sim}(D_{0})$')
plt.legend(); plt.xlabel(r'$\phi$'); plt.show()
phmax = 4*math.pi; dph = phmax/50; ph = np.arange(0, phmax+dph, dph); d = ph.shape[0]
w = 1; pw1 = (1+(2*w-1)*np.cos(ph))/2; w = 0.25; pw025 = (1+(2*w-1)*np.cos(ph))/2
w = 0.5; pw05 = (1+(2*w-1)*np.cos(ph))/2; w = 0.75; pw075 = (1+(2*w-1)*np.cos(ph))/2
w = 0; pw0 = (1+(2*w-1)*np.cos(ph))/2
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, pw1, label = r'$w=1$'); plt.plot(ph, pw075, label = r'$w=0.75$')
plt.plot(ph, pw05, label = r'$w=0.5$'); plt.plot(ph, pw025, label = r'$w=0.25$')
plt.plot(ph, pw0, label = r'$w=0$')
plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left'); plt.xlabel(r'$\phi$'); plt.show()
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.log(pv[j], 2)
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 V(pd):
return (np.max(pd)-np.min(pd))/(np.max(pd)+np.min(pd))
def pd_ph(w):
phmax = 4*math.pi; dph = phmax/100; ph = np.arange(0, phmax+dph, dph)
return (1+(2*w-1)*np.cos(ph))/2
def rhow(w):
return np.array([[w,0],[0,1-w]])
w = np.arange(0, 1.05, 0.05); d = w.shape[0]; Vis = np.zeros(d); Svn = np.zeros(d)
for j in range(0, d):
pd = pd_ph(w[j]); Vis[j] = V(pd); rho = rhow(w[j]); Svn[j] = von_neumann_num(rho)
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(w, Vis, label = 'V'); plt.plot(w, Svn, label = r'$S_{vn}$')
plt.xlabel(r'$w$'); plt.legend(); plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
Udfp = (1/sqrt(2))*Matrix([[1,1j,0,0],[1j,1,0,0],[0,0,1,1j],[0,0,1j,1]]); Udfp
Udfp*conjugate(Udfp), conjugate(Udfp)*Udfp # ok!
Udf = (1/sqrt(2))*Matrix([[1,1j],[1j,1]]); Udf
X = Matrix([[0,1],[1,0]]); C_Udf = tp(proj(cb(2,0)),id(2)) + tp(proj(cb(2,1)),Udf)
C_Udf, tp(X,id(2))*C_Udf*tp(X,id(2)), tp(X,id(2))*C_Udf*tp(X,id(2))*C_Udf, C_Udf*tp(X,id(2))*C_Udf*tp(X,id(2))
C_Udf*tp(X,id(2))*C_Udf*tp(X,id(2))
def P(al):
return Matrix([[1,0],[0,cos(al)+1j*sin(al)]])
S = Matrix([[1,0],[0,1j]]); Sd = Matrix([[1,0],[0,-1j]]); H = (1/sqrt(2))*Matrix([[1,1],[1,-1]])
X = Matrix([[0,1],[1,0]]); Y = Matrix([[0,-1j],[1j,0]]); Z = Matrix([[1,0],[0,-1]])
def U(th,ph,lb):
return Matrix([[cos(th/2),-(cos(lb)+1j*sin(lb))*sin(th/2)],[(cos(ph)+1j*sin(ph))*sin(th/2),cos(th/2)]])
th, ph, lb = symbols('theta phi lambda'); U(pi,-pi/2,pi/2)*S*X*H*X*S
A = U(pi,-pi/2,pi/2)*S; B = H; C = S; A*B*C # = Udf^dagger != I
a,b,c,d, x, y, z, w = symbols('a,b,c,d, x, y, z, w')
A = Matrix([[a,b],[c,d]]); B = Matrix([[x,y],[z,w]]); A, B, A*B
a = -1/sqrt(2); b = 1j/sqrt(2); c = b; d = a # para trocar o sinal dos elementos da diagonal principal
solve([a*x+b*z+a, a*y+b*w-b, c*x+d*z-c, c*y+d*w+d], [x,y,z,w])
from qiskit import *
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
def state_prep(th, ph):
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name = 'prep')
qc.u(th, ph, 0, qr[0])
qc.u(th, ph, 0, qr[1])
return qc
def qc_dfp():
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='DFP')
'''qc.x(qr[1])
qc.cu(math.pi/2, math.pi/2, -math.pi/2, 0.0, qr[1], qr[0]) # Udf controlada
qc.x(qr[1])
qc.cu(math.pi/2, math.pi/2, -math.pi/2, 0.0, qr[1], qr[0])'''
qc.cu(math.pi, math.pi/2, -math.pi/2, 0.0, qr[0], qr[1])
return qc
qc_dfp_ = qc_dfp(); qc_dfp_.draw()
###### Para ver a matriz unitário implementada por um certo circuito quântico ##########
backend = Aer.get_backend('unitary_simulator'); qc_dfp_ = qc_dfp(); job = execute(qc_dfp_, backend)
result = job.result(); print(result.get_unitary(qc_dfp_, decimals=3))
# agora tá certo, mas ao contrário em relação aos qubits...
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='DFP')
#qc.cx(qr[0],qr[1]) # Sai a matrix para C21
qc.cx(qr[1],qr[0]) # Sai a matrix para C12
job = execute(qc, backend); result = job.result(); print(result.get_unitary(qc, decimals=3))
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='DFP')
qc.h(qr[0])
#qc.cx(qr[0], qr[1]) # sai o estado certo, |00>+|11>
qc.cx(qr[1], qr[0]) # sai |+0>
qstc = state_tomography_circuits(qc, [qr[0],qr[1]])
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
rho
# Verificação da Udf controlada
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='DFP')
qc.x(qr[1])
qc.cu(math.pi/2, math.pi/2, -math.pi/2, 0.0, qr[1], qr[0]) # a sequência é target depois control
qc.x(qr[1])
job = execute(qc, backend); result = job.result(); print(result.get_unitary(qc, decimals=3))
qc.draw()
# Verificação da Udf controlada
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='DFP')
qc.cx(qr[1], qr[0]) # a sequência é target depois control
job = execute(qc, backend); result = job.result(); print(result.get_unitary(qc, decimals=3))
def qc_mzi_dfp(ph): # quantum circuit for the Mach-Zehnder interferometer com DFP
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
state_prep_ = state_prep(0, 0); qc.append(state_prep_, [qr[0],qr[1]]) # estado prep
qc_dfp_ = qc_dfp(); qc.append(qc_dfp_, [qr[0],qr[1]]) # DFP
qc.z(qr[1]); qc.y(qr[1]) # espelho
qc.p(ph, qr[1]); # fase
qc.s(qr[1]); qc.h(qr[1]); qc.s(qr[1]) # DF
return qc
qcmzi = qc_mzi_dfp(math.pi/8); qcmzi.draw()
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph)#; ph
d = ph.shape[0]; PD0teo = np.zeros(d); PD0sim = np.zeros(d); PD0exp = np.zeros(d)
for j in range(0, d):
PD0teo[j] = 1/2 # theoretical
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
state_prep_ = state_prep(0, 0); qc.append(state_prep_, [qr[0],qr[1]]) # state preparation (estado |00>)
qc_mzi_dfp_ = qc_mzi_dfp(ph[j]); qc.append(qc_mzi_dfp_, [qr[0],qr[1]]) # apply sim mzip
qstc = state_tomography_circuits(qc, qr[1]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0sim[j] = rho[0,0].real
#print(rho[0,0].real)
# 1º fiz as simulações, só depois adicionei o código para os experimentos
'''job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0exp[j] = rho[0,0].real'''
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, PD0teo, label = r'$P_{teo}(D_{0})$')
plt.plot(ph, PD0sim, 'o', label = r'$P_{sim}(D_{0})$')
#plt.plot(ph, PD0exp, '*', label = r'$P_{exp}(D_{0})$')
plt.legend(); plt.xlabel(r'$\phi$'); plt.ylim(-0.02,1.02); plt.show()
def state_prep_psip():
qr = QuantumRegister(3); qc = QuantumCircuit(qr, name = 'prep')
qc.h(qr[0]); qc.cx(qr[0],qr[1]); qc.x(qr[1]) # prepara psi+_01
return qc
state_prep_psip_ = state_prep_psip(); state_prep_psip_.draw()
def qc_dfp():
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='DFP')
qc.cu(math.pi, math.pi/2, -math.pi/2, 0.0, qr[0], qr[1])
return qc
qc_dfp_ = qc_dfp(); qc_dfp_.draw()
def qc_df():
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name='DF')
qc.s(qr[0]); qc.h(qr[0]); qc.s(qr[0])
return qc
qc_df_ = qc_df(); qc_df_.draw()
def qc_pmo():
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='PMO')
qc.cx(qr[1],qr[0])
return qc
qc_pmo_ = qc_pmo(); qc_pmo_.draw()
def qc_pqo():
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name='PQO')
qc.h(qr[0]); qc.s(qr[0])
return qc
qc_pqo_ = qc_pqo(); qc_pqo_.draw()
def qc_apagador(ph):
qr = QuantumRegister(3); qc = QuantumCircuit(qr)
state_prep_psip_ = state_prep_psip(); qc.append(state_prep_psip_, [qr[0],qr[1],qr[2]])
qc_dfp_ = qc_dfp(); qc.append(qc_dfp_, [qr[1],qr[2]]) # DFP
qc_pmo_ = qc_pmo(); qc.append(qc_pmo_, [qr[1],qr[2]]) # PMO
qc_pqo_ = qc_pqo(); qc.append(qc_pqo_, [qr[0]])
qc.z(qr[2]); qc.y(qr[2]) # espelho
qc.p(ph, qr[2]); # fase
qc_df_ = qc_df(); qc.append(qc_df_, [qr[2]]) # DF
return qc
qc_apagador_ = qc_apagador(math.pi/3); qc_apagador_.draw()
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph)#; ph
d = ph.shape[0]; PD0teo = np.zeros(d); PD0sim = np.zeros(d); PD0exp = np.zeros(d)
for j in range(0, d):
PD0teo[j] = (2+math.cos(ph[j])+math.sin(ph[j]))/4 # theoretical
qr = QuantumRegister(3); qc = QuantumCircuit(qr)
qc_apagador_ = qc_apagador(ph[j]); qc.append(qc_apagador_, [qr[0],qr[1],qr[2]]) # apagador q
qstc = state_tomography_circuits(qc, qr[2]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0sim[j] = rho[0,0].real
#print(rho[0,0].real)
# 1º fiz as simulações, só depois adicionei o código para os experimentos
'''job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0exp[j] = rho[0,0].real'''
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, PD0teo, label = r'$P_{teo}(D_{0})$')
plt.plot(ph, PD0sim, 'o', label = r'$P_{sim}(D_{0})$')
#plt.plot(ph, PD0exp, '*', label = r'$P_{exp}(D_{0})$')
plt.legend(); plt.xlabel(r'$\phi$'); plt.ylim(-0.02,1.02); plt.show()
H = (1/sqrt(2))*Matrix([[1,1],[1,-1]]); S = Matrix([[1,0],[0,1j]]); X = Matrix([[0,1],[1,0]])
def U(th, ph, lb):
return Matrix([[cos(th/2),-(cos(lb)+1j*sin(lb))*sin(th/2)],
[(cos(ph)+1j*sin(ph))*sin(th/2),(cos(ph+lb)+1j*sin(ph+lb))*cos(th/2)]])
def dfp():
return tp(proj(cb(2,0)), id(2)) + tp(proj(cb(2,1)), U(math.pi, math.pi/2, -math.pi/2))
def pmo():
return tp(id(2), proj(cb(2,0))) + tp(X, proj(cb(2,1)))
th, ph, lb = symbols('theta phi lambda');# U(th, ph, lb)
psi0 = tp(tp(cb(2,0),cb(2,0)),cb(2,0))#; psi0
dfp_ = dfp(); psi1 = tp(id(2), dfp_)*psi0; psi1
pmo_ = pmo(); psi2 = tp(id(2), pmo_)*psi1; psi2
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
import qiskit
from qiskit import *
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
def state_prep_psip():
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name = 'sprep')
qc.h(qr[0]); qc.cx(qr[0],qr[1]); qc.x(qr[1]) # prepara psi+_01
return qc
state_prep_psip_ = state_prep_psip(); state_prep_psip_.draw(output = 'mpl')
def qc_dfp():
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='DFP')
qc.cz(qr[0],qr[1]); qc.cy(qr[0], qr[1])
return qc
qc_dfp_ = qc_dfp(); qc_dfp_.draw(output = 'mpl')
def qc_df():
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name='DF')
qc.s(qr[0]); qc.h(qr[0]); qc.s(qr[0])
return qc
qc_df_ = qc_df(); qc_df_.draw(output = 'mpl')
def qc_pmo():
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name='PMO')
qc.cx(qr[1],qr[0])
return qc
qc_pmo_ = qc_pmo(); qc_pmo_.draw(output = 'mpl')
def qc_pqo():
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name='PQO')
qc.h(qr[0]); qc.s(qr[0])
return qc
qc_pqo_ = qc_pqo(); qc_pqo_.draw(output = 'mpl')
def qc_espelho():
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name='espelho')
qc.z(qr[0]); qc.y(qr[0])
return qc
qc_espelho_ = qc_espelho(); qc_espelho_.draw(output = 'mpl')
import math
def qc_fase(ph):
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name='fase')
qc.p(ph, qr[0])
return qc
qc_fase_ = qc_fase(math.pi); qc_fase_.draw(output = 'mpl')
def qc_apagador(ph):
qr = QuantumRegister(3); qc = QuantumCircuit(qr, name = 'apagador')
state_prep_psip_ = state_prep_psip(); qc.append(state_prep_psip_, [qr[0],qr[1]]) # sprep
qc.barrier()
qc_dfp_ = qc_dfp(); qc.append(qc_dfp_, [qr[1],qr[2]]) # DFP
qc_pmo_ = qc_pmo(); qc.append(qc_pmo_, [qr[1],qr[2]]) # PMO
qc_pqo_ = qc_pqo(); qc.append(qc_pqo_, [qr[0]]) # PQO
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [qr[2]]) # espelho
qc_fase_ = qc_fase(ph); qc.append(qc_fase_, [qr[2]]) # fase
qc_df_ = qc_df(); qc.append(qc_df_, [qr[2]]) # DF
return qc
qc_apagador_ = qc_apagador(math.pi/3)
qc_apagador_.draw(output = 'mpl')
qc_apagador_.decompose().draw(output = 'mpl')
import numpy as np
from numpy import random
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph)#; ph
d = ph.shape[0]; PD0teo = np.zeros(d); PD0sim = np.zeros(d); PD0exp = np.zeros(d)
ri = random.randint(0,d)
for j in range(0, d):
PD0teo[j] = 1/2 # theoretical
qr = QuantumRegister(3); qc = QuantumCircuit(qr)
qc_apagador_ = qc_apagador(ph[j]); qc.append(qc_apagador_, [qr[0],qr[1],qr[2]]) # apagador q
qstc = state_tomography_circuits(qc, qr[2]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0sim[j] = rho[0,0].real
#if j == ri:
# print(rho)
# 1º fiz as simulações, só depois adicionei o código para os experimentos
'''job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0exp[j] = rho[0,0].real'''
import matplotlib
from matplotlib import pyplot as plt
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, PD0teo, label = r'$P_{teo}(D_{0})$')
plt.plot(ph, PD0sim, 'o', label = r'$P_{sim}(D_{0})$')
#plt.plot(ph, PD0exp, '*', label = r'$P_{exp}(D_{0})$')
plt.legend(); plt.xlabel(r'$\phi$'); plt.ylim(-0.02,1.02);
plt.title('IMZ com info de caminho'); plt.show()
# Nesse caso, não foram feitas medidas projetivas para obtenção de informação de caminho
qr = QuantumRegister(1); cr = ClassicalRegister(1); qc = QuantumCircuit(qr,cr)
qc.h(qr[0]); qc.measure(qr[0],cr[0])
job = qiskit.execute(qc, Aer.get_backend('qasm_simulator'), shots=10)
res = job.result().get_counts()
if '0' in res:
print('z = 0, ', res, ', ', res['0'])
elif '1' in res:
print('z = 1, ', res, ', ', res['1'])
qc.draw(output = 'mpl')
for j in range(0,1):
qr = QuantumRegister(2); cr = ClassicalRegister(2); qc = QuantumCircuit(qr,cr)
qc.h(qr[0]);
qc.measure(qr[0],cr[0])
qc.h(qr[1]); qc.measure(qr[1],cr[1])
job = qiskit.execute(qc, Aer.get_backend('qasm_simulator'), shots=10)
res = job.result().get_counts()
print(res)
if '00' in res:
P00 = 1; print('P00',P00)
elif '01' in res:
P01 = 1; print('P01',P01)
qc.draw(output = 'mpl')
# O apagador quântico mesmo, com as medidas
def apagadorM(ph):
qr = QuantumRegister(3); cr = ClassicalRegister(2); qc = QuantumCircuit(qr, cr)
qc_apagador_ = qc_apagador(ph); qc.append(qc_apagador_, [qr[0],qr[1],qr[2]])
qc.measure(qr[0],cr[0]) # medida da polarização de A
qc.measure(qr[2],cr[1]) # medida do caminho de B
return qc
apagadorM_ = apagadorM(math.pi/8); apagadorM_.draw(output = 'mpl')
qc = apagadorM(math.pi/8)
job = qiskit.execute(qc, Aer.get_backend('qasm_simulator'), shots=1)
res = job.result().get_counts(); print(res)
nshots = 1000
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph); d = ph.shape[0]
PD0teo0 = np.zeros(d); PD0sim0 = np.zeros(d); PD0exp0 = np.zeros(d)
PD0teo1 = np.zeros(d); PD0sim1 = np.zeros(d); PD0exp1 = np.zeros(d)
for j in range(0, d):
PD0teo0[j] = (1 + math.cos(ph[j]))/2; PD0teo1[j] = (1 - math.cos(ph[j]))/2
qc = apagadorM(ph[j])
N0 = 0; N1 = 0; N0e = 0; N1e = 0
for k in range(0, nshots): # não usar esse loop
job = qiskit.execute(qc, Aer.get_backend('qasm_simulator'), shots=1)
res = job.result().get_counts()#; print(res)
if '00' in res or '10' in res:
N0 += 1
elif '01' in res or '11' in res:
N1 += 1
if '00' in res:
PD0sim0[j] += 1
elif '01' in res:
PD0sim1[j] += 1
'''job = qiskit.execute(qc, Aer.get_backend(device), shots=1)
res = job.result().get_counts()
if '00' in res or '10' in res:
N0e += 1
elif '01' in res or '11' in res:
N1e += 1
if '00' in res:
PD0exp0[j] += 1
elif '01' in res:
PD0exp1[j] += 1'''
PD0sim0 = PD0sim0/N0; PD0sim1 = PD0sim1/N1
#PD0exp0 = PD0exp0/N0e; PD0exp1 = PD0exp1/N1e
# sem o loop em k
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (5,3.3), dpi = 100)
plt.plot(ph, PD0teo0, '-', label = r'$P_{teo}(0,0)$')
plt.plot(ph, PD0teo1, '-.', label = r'$P_{teo}(1,0)$')
plt.plot(ph, PD0sim0, 'o', label = r'$2P_{sim}(0,0)$')
plt.plot(ph, PD0sim1, '*', label = r'$2P_{sim}(1,0)$')
#plt.plot(ph, PD0exp0, '+', label = r'$2P_{exp}(0,0)$')
#plt.plot(ph, PD0exp1, 'd', label = r'$2P_{exp}(1,0)$')
plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.xlabel(r'$\phi$'); plt.ylim(-0.05,1.05);
plt.title('IMZ com apagador de info de caminho'); plt.show()
def qc_MBB():
qr = QuantumRegister(2); qc = QuantumCircuit(qr)
qc.h(qr[0]); qc.cx(qr[0],qr[1])
return qc
qc_MBB_ = qc_MBB(); qc_MBB_.draw(output = 'mpl')
def qc_apagadorE(ph):
qr = QuantumRegister(3); qc = QuantumCircuit(qr, name = 'apagador')
state_prep_psip_ = state_prep_psip(); qc.append(state_prep_psip_, [qr[0],qr[1]]) # sprep
qc_dfp_ = qc_dfp(); qc.append(qc_dfp_, [qr[1],qr[2]]) # DFP
qc_pmo_ = qc_pmo(); qc.append(qc_pmo_, [qr[1],qr[2]]) # PMO
qc_pqo_ = qc_pqo(); qc.append(qc_pqo_, [qr[0]]) # PQO
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [qr[2]]) # espelho
qc_fase_ = qc_fase(ph); qc.append(qc_fase_, [qr[2]]) # fase
qc_df_ = qc_df(); qc.append(qc_df_, [qr[2]]) # DF
return qc
qc_apagador_ = qc_apagador(math.pi/3); qc_apagador_.draw(output = 'mpl')
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
N = 2**10; th = asin(1/sqrt(N)); N, float(th), float(sin(th)), float(th*180/pi), sqrt(N)
my_list = [1,3,5,2,4,9,5,8,0,7,6]
def my_oracle(my_input):
solution = 2
if my_input == solution:
response = True
else:
response = False
return response
my_input = 7; res = my_oracle(my_input); print(res)
for j in range(0,len(my_list)):
if my_oracle(my_list[j]) == True:
print('Solução encontrada no índice',j, ', após ', j+1, ' consultas ao oráculo.')
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
def qc_Uz(n): # 2|0><0| - I
qc = QuantumCircuit(n, name = 'Uz')
qrl = []
for j in range(0, n):
qrl.append(j)
qc.z(0); qc.x(0); qc.z(0); qc.x(0)
qc.x(qrl) # 00...0 -> 11...1
qc.h(n-1); qc.mcx(qrl[0:n-1],n-1); qc.h(n-1) # Cz multicontrolada. Multiplica 11...1 por -1
qc.x(qrl); # 11...1 -> 00...0
return qc
qc_Uz_ = qc_Uz(3); qc_Uz_.draw()
def qc_Uh(n): # 2|h><h| - I
qc = QuantumCircuit(n, name = 'Uh')
qrl = []
for j in range(0, n):
qrl.append(j)
qc.h(qrl) # transforma Uz em Uh
qc_Uz_ = qc_Uz(n); qc.append(qc_Uz_, qrl)
qc.h(qrl)
return qc
qc_Uh_ = qc_Uh(3); qc_Uh_.draw()
def qc_oracle(n):
# Nielsen & Chuang, Box 6.1 (N=4)
qc = QuantumCircuit(n+1, name = 'Oracle')
qc.ccx(0,1,2) # para a solução sendo o estado |11>
return qc
qc_oracle_ = qc_oracle(2)
qc_oracle_.draw('mpl')
def qc_grover_iteration(n):
qc = QuantumCircuit(n+1, name = 'G')
qrl = []
for j in range(0, n+1):
qrl.append(j)
qc_oracle_ = qc_oracle(n)
qc.append(qc_oracle_, qrl)
qc_Uh_ = qc_Uh(n); qc.append(qc_Uh_, qrl[0:n])
return qc
qc_grover_iteration_ = qc_grover_iteration(2)
qc_grover_iteration_.draw('mpl')
def qc_hadamard_state(n): # aplica a Hadamard em n qubits
qc = QuantumCircuit(n, name = 'H state') # começarei a não usar mais os qr[j]
qrl = [] # lista de registros quânticos
for j in range(0, n):
qrl.append(j)
qc.h(qrl) # aplica a hadamard em toda a lista de registros quânticos
return qc
qc_hadamard_state_ = qc_hadamard_state(3); qc_hadamard_state_.draw()
def qc_grover_search(n):
qc = QuantumCircuit(n+1, n)
qc.x(n)
qrl = [] # lista de registros quânticos
for j in range(0, n+1):
qrl.append(j)
qc_hadamard_state_ = qc_hadamard_state(n+1); qc.append(qc_hadamard_state_, qrl)
for j in range(0, int((math.pi*math.sqrt(2**n))/4 - 1/2)):
qc_grover_iteration_ = qc_grover_iteration(n); qc.append(qc_grover_iteration_, qrl)
qc.measure(qrl[0:n], qrl[0:n])
return qc
qc_grover_search_ = qc_grover_search(2); qc_grover_search_.draw()
qc_grover_search_ = qc_grover_search(2)
result = execute(qc_grover_search_, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc_grover_search_))
job = execute(qc_grover_search_, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc_grover_search_))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (5,3), dpi = 100)
p = np.arange(0,1.01,0.01)
plt.plot(p, p, label = r'$p$'); plt.plot(p, 3*p**2-2*p**3, label = r'$p_{e}$')
plt.xlim(0,1); plt.ylim(-0.01,1.01); plt.legend(); plt.xlabel('p'); plt.show()
from qiskit import *
def qc_coding_bf(th, ph):
qc = QuantumCircuit(3, name = 'Coding BF')
qc.u(th, ph, 0, 0)
qc.barrier()
qc.cx(0,1); qc.cx(1,2)
return qc
qc_coding_bf_ = qc_coding_bf(math.pi, math.pi/4); qc_coding_bf_.draw(output = 'mpl')
qc = QuantumCircuit(3, 1); qc.cx([0], [2]); qc.cx([1], [2]); qc.measure([2], 0); qc.draw(output = 'mpl')
qc = QuantumCircuit(5, 2); qc.u(0.1, 0.2, 0.2, [0]); qc.cx([0], [1]); qc.cx([1], [2]); qc.barrier()
qc.cx([0], [3]); qc.cx([1], [3]); qc.cx([1], [4]); qc.cx([2], [4]); qc.barrier(); qc.measure([3, 4], [0, 1])
qc.draw(output = 'mpl')
def qc_ec_bf(th, ph, lb, j):
qc = QuantumCircuit(5, name = 'EC_BF')
qc.u(th, ph, lb, [0]) # qubit state preparation
qc.barrier()
qc.cx([0], [1]); qc.cx([1], [2]) # encoding
qc.barrier()
if j == 0 or j == 1 or j == 2: # error
qc.x([j])
qc.barrier()
qc.cx([0], [3]); qc.cx([1], [3]); qc.cx([1], [4]); qc.cx([2], [4]) # syndrome detection
qc.barrier()
qc.x([3]); qc.ccx([4], [3], [2]); qc.x([3]); qc.ccx([4], [3], [1]) # correction
qc.x([4]); qc.ccx([4], [3], [0]); qc.x([4]) # correction
qc.barrier()
return qc
th, ph, lb = math.pi, 0.0, 0.0; j = 2; qc_ec_bf_ = qc_ec_bf(th, ph, lb, j)
qc_ec_bf_.draw(output = 'mpl')
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
#provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
#device = provider.get_backend('ibmq_jakarta')
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.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import backend_overview, backend_monitor
from qiskit.tools.visualization import plot_histogram
qc = QuantumCircuit(5, 3);
j = 0 # sets the error
qc_ec_bf_ = qc_ec_bf(math.pi/2, 0.0, 0.0, j); qc.append(qc_ec_bf_, [0, 1, 2, 3, 4])
qc.measure([0, 1, 2], [0, 1, 2])
qc.decompose().draw(output = 'mpl')
job_sim = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(job_sim.get_counts(qc))
job_exp = execute(qc, backend = device, shots = nshots)
print(job_exp.job_id()); job_monitor(job_exp)
plot_histogram(job_exp.result().get_counts(qc))
qc = QuantumCircuit(2, 1)
qc.u(1,2,3, [1])
qc.barrier()
qc.h([0]); qc.cz(0, 1); qc.h([0]);
qc.measure(0,0); qc.draw(output = 'mpl')
qc = QuantumCircuit(2, 1);
qc.u(1,2,3, 1);
qc.barrier()
qc.cx(1,0); qc.measure(0,0); qc.draw(output = 'mpl')
qc = QuantumCircuit(2, 1);
qc.u(1,2,3, 1)
qc.barrier()
qc.h(0); qc.cx(0,1); qc.h(0); qc.measure(0,0);
qc.draw(output = 'mpl')
qc = QuantumCircuit(2, 1);
qc.u(1,2,3, [1]);
qc.barrier()
qc.h(1); qc.cx(1,0); qc.h(1); qc.measure(0,0);
qc.draw(output = 'mpl')
qc = QuantumCircuit(2, 1);
qc.u(0.1, 0.2, 0.3, [1])
qc.barrier()
qc.h(0); qc.cu(0.4, 0.5, 0.6, 0.0, [0], [1]); qc.h([0]); qc.measure([0], [0])
qc.draw(output = 'mpl')
qc = QuantumCircuit(2, 1)
th, ph, lb = math.pi, 0.0, 0.0; qc.u(th, ph, lb, [0]) # state preparation
qc.barrier(); qc.cx([0], [1]); qc.barrier()
qc.x([0]); qc.barrier()
qc.cx([0], [1]); qc.cx([1], [0])
qc.measure([0], [0])
qc.draw(output = 'mpl')
job = execute(qc, backend = simulator, shots = nshots)
plot_histogram(job.result().get_counts(qc))
job = execute(qc, backend = device, shots = nshots); job_monitor(job)
plot_histogram(job.result().get_counts(qc))
# quantum circuit for bit flip error mitigation
def qc_em_bf():
qc = QuantumCircuit(2, name = 'EM_BF')
qc.cx([0], [1]); qc.cx([0], [1]); qc.cx([1], [0]); qc.reset([1])
return qc
qc_em_bf_ = qc_em_bf(); qc_em_bf_.draw(output = 'mpl')
N = 5; qc = QuantumCircuit(1, N); qc.x([0]);
for j in range(0, N):
qc.id([0]); qc.measure([0],[j])
job = execute(qc, backend = simulator, shots = nshots)
qc.draw(output = 'mpl')
plot_histogram(job.result().get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
N = 5; qc = QuantumCircuit(2, N); qc.x([0]);
for j in range(0, N):
qc_em_bf_ = qc_em_bf(); qc.append(qc_em_bf_, [0, 1]); qc.measure([0],[j])
job = execute(qc, backend = simulator, shots = nshots)
qc.decompose().draw(output = 'mpl')
plot_histogram(job.result().get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
import math
qc = QuantumCircuit(2, 1)
th, ph, lb = math.pi, 0.0, 0.0; qc.u(th, ph, lb, [0]) # state preparation
qc.barrier(); qc.cx([0], [1]); qc.barrier()
qc.z([0]); qc.x([0]); qc.h([0]); qc.barrier()
qc.cx([0], [1]); qc.cx([1], [0]); qc.measure([0], [0])
qc.draw(output = 'mpl')
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
thc, phc, lbc = math.pi/2, 0, 0; tha, pha, lba = math.pi/2, math.pi/4, math.pi/8
qc = QuantumCircuit(2, 1); qc.u(thc, phc, lbc, 0); qc.u(tha, pha, lba, 1)
qc.cx(0, 1); qc.measure(0, 0); qc.draw()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
simplify(cos(pi/8)), simplify(sin(pi/8))
from qiskit.visualization import plot_bloch_vector
th, ph = pi/4, 0
#plot_bloch_vector([[math.sin(th)*math.cos(ph), math.sin(th)*math.sin(ph), math.cos(th)]])
float(1+1/sqrt(2))/2
X = Matrix([[0,1],[1,0]]); Z = Matrix([[1,0],[0,-1]]); O = (X+Z)/sqrt(2); O.eigenvects()
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
qc = QuantumCircuit(1, 1)
qc.h(0) # preparação do estado
qc.barrier()
# medida de O=H
th = math.pi/4; ph = 0; lb = math.pi - ph; qc.u(th, ph, lb, 0)
qc.measure(0, 0)
qc.draw()
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
def qc_bb_cb():
qc = QuantumCircuit(2, name = 'BB->CB')
qc.cx(0,1); qc.h(0)#; qc.measure([0,1],[0,1])
return qc
qc_bb_cb_ = qc_bb_cb(); qc_bb_cb_.draw()
qc = QuantumCircuit(2, 2)
qc.x(1); qc.h([0,1]) # preparação do estado |+->
qc.barrier()
qc_bb_cb_ = qc_bb_cb(); qc.append(qc_bb_cb_, [0,1]); qc.measure([0,1],[0,1])
qc.draw()
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
from qiskit import *
def Hxxx():
H = tp(tp(pauli(1),pauli(1)),id(2)) + tp(id(2),tp(pauli(1),pauli(1)))\
+ tp(tp(pauli(2),pauli(2)),id(2)) + tp(id(2),tp(pauli(2),pauli(2)))\
+ tp(tp(pauli(3),pauli(3)),id(2)) + tp(id(2),tp(pauli(3),pauli(3)))
return H
H = Hxxx(); H
#eig
#eig = H.eigenvects(); eig[0], eig[0][0], eig[0][2][0]
def mat_exp(A):
d = A.shape[0]; eig = A.eigenvects(); Aexp = zeros(d,d); ne = 0; j = 0; lk = 0
while ne < d:
mult = eig[j][1]; ne += mult
for k in range(0,mult):
Proj = proj(eig[j][2][k]); Aexp += exp(eig[j][0])*(Proj/trace(Proj))
j += 1
return Aexp
simplify(mat_exp(pauli(1)))
def UHxxx(t):
H = Hxxx()
return mat_exp(-1j*t*H)
U = UHxxx(0); U
psi0 = tp(tp(cb(2,1),cb(2,1)),cb(2,0)); #psi0
dt = 0.05; t = np.arange(0, 2*pi+dt, dt); d = len(t); F = np.zeros(d); psit = psi0
for j in range(0, d):
U = UHxxx(t[j]); psit = U*psi0
ip = inner_product(psi0, psit); F[j] = ip*conjugate(ip)
#print(t[j], F[j])
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(t, F); plt.xlabel(r'$t$'); plt.ylabel(r'$F$'); plt.grid(); plt.show()
t = symbols('t'); U = UHxxx(t); psit = U*psi0; simplify(psit)
tp(tp(cb(2,0),cb(2,0)), cb(2,0)).T, tp(tp(cb(2,0),cb(2,0)), cb(2,1)).T, tp(tp(cb(2,0),cb(2,1)), cb(2,0)).T,\
tp(tp(cb(2,1),cb(2,0)), cb(2,0)).T, tp(tp(cb(2,0),cb(2,1)), cb(2,1)).T, tp(tp(cb(2,1),cb(2,0)), cb(2,1)).T,\
tp(tp(cb(2,1),cb(2,1)), cb(2,0)).T, tp(tp(cb(2,1),cb(2,1)), cb(2,1)).T
1/3, 1/6
H12 = tp(tp(pauli(1),pauli(1)),id(2)) + tp(tp(pauli(2),pauli(2)),id(2)) + tp(tp(pauli(3),pauli(3)),id(2))
H23 = tp(id(2),tp(pauli(1),pauli(1))) + tp(id(2),tp(pauli(2),pauli(2))) + tp(id(2),tp(pauli(3),pauli(3)))
dH = comm(H12,H23); dH, dH.norm()
H1 = tp(tp(pauli(1),pauli(1)),id(2)) + tp(id(2),tp(pauli(1),pauli(1))) + tp(id(2),tp(pauli(3),pauli(3)))
H2 = tp(tp(pauli(2),pauli(2)),id(2)) + tp(id(2),tp(pauli(2),pauli(2))) + tp(tp(pauli(3),pauli(3)),id(2))
dH = comm(H1,H2); dH, dH.norm()
comm(tp(pauli(1),pauli(1)),tp(pauli(2),pauli(2)))
XX = tp(pauli(1), pauli(1)); YY = tp(pauli(2), pauli(2)); ZZ = tp(pauli(3), pauli(3)); XX, YY, ZZ
XX.eigenvects(), YY.eigenvects()#, ZZ.eigenvects()
def Hxxx12():
H = tp(pauli(1),pauli(1)) + tp(pauli(2),pauli(2)) + tp(pauli(3),pauli(3))
return tp(H,id(2))
def Hxxx23():
H = tp(pauli(1),pauli(1)) + tp(pauli(2),pauli(2)) + tp(pauli(3),pauli(3))
return tp(id(2),H)
def UHxxx12(t):
H = Hxxx12()
return mat_exp(-1j*t*H)
def UHxxx23(t):
H = Hxxx23()
return mat_exp(-1j*t*H)
dt = 0.05; t = np.arange(0, 2*pi+dt, dt); d = len(t)
F1 = np.zeros(d); F2 = np.zeros(d); F3 = np.zeros(d); F4 = np.zeros(d); F5 = np.zeros(d)
psit1 = psi0; psit2 = psi0; psit3 = psi0; psit4 = psi0; psit5 = psi0
for j in range(0, d):
U12 = UHxxx12(t[j]); U23 = UHxxx23(t[j]); U1 = U12*U23; psit1 = U1*psi0
ip = inner_product(psi0,psit1); F1[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/2); U23 = UHxxx23(t[j]/2); U2 = U12*U23*U12*U23; psit2 = U2*psi0
#ip = inner_product(psi0,psit2); F2[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/3); U23 = UHxxx23(t[j]/3); U3 = U12*U23*U12*U23*U12*U23; psit3 = U3*psi0
#ip = inner_product(psi0,psit3); F3[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/4); U23 = UHxxx23(t[j]/4); U4 = U12*U23*U12*U23*U12*U23*U12*U23; psit4 = U4*psi0
#ip = inner_product(psi0,psit4); F4[j] = ip*conjugate(ip)
#U12 = UHxxx12(t[j]/5); U23 = UHxxx23(t[j]/5); U5 = U12*U23*U12*U23*U12*U23*U12*U23*U12*U23; psit5 = U5*psi0
#ip = inner_product(psi0,psit5); F5[j] = ip*conjugate(ip)
plt.figure(figsize = (6,3), dpi = 100)
plt.plot(t, F, '^', label = r'$F$'); plt.plot(t, F1, '--', label = r'$F_{1}$')
#plt.plot(t, F2, '-.', label = r'$F_{2}$'); plt.plot(t, F3, ':', label = r'$F_{3}$')
#plt.plot(t, F4, '.', label = r'$F_{4}$'); plt.plot(t, F5, '*', label = r'$F_{5}$')
plt.xlabel(r'$t$'); plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.grid(); plt.show()
# esse cálculo "simbólico" demora muito. Melhor usar o numpy!
# matrizes de Pauli
I = np.array([[1,0],[0,1]]); #print(I)
X = np.array([[0,1],[1,0]]); #print(X)
Y = np.array([[0,-1j],[1j,0]]);# print(Y)
Z = np.array([[1,0],[0,-1]]); #print(Z)
def Hxxx_num():
H = np.kron(np.kron(X,X),I) + np.kron(I,np.kron(X,X))\
+ np.kron(np.kron(Y,Y),I) + np.kron(I,np.kron(Y,Y))\
+ np.kron(np.kron(Z,Z),I) + np.kron(I,np.kron(Z,Z))
return H
H = Hxxx_num(); print(H.real)
# para calcular a função de matriz (teve problemas de pequenas oscilações)
def proj_num(psi):
#return np.outer(psi, np.ndarray.conjugate(psi))
d = len(psi); proj = np.zeros((d, d), dtype = complex)
for j in range(0, d):
for k in range(0, d):
proj[j,k] = psi[j]*np.conj(psi[k])
return proj
proj_num(np.array([[1],[1j]]))
import cmath
#from math import e
# para calcular a função de matriz (teve problemas de pequenas oscilações)
def mat_exp_num(A):
d = A.shape[0]; Aexp = np.zeros((d,d), dtype = complex);
eva, eve = np.linalg.eig(A);
# eva, eve = scipy.linalg.eig(A)
for j in range(0, d):
Aexp += cmath.exp(eva[j])*proj_num(eve[:,j])
#Aexp += e**(eva[j])*proj_num(eve[:,j])
return Aexp
mat_exp_num(Y)
def UHxxx_num(t):
H = Hxxx_num()
#return mat_exp_num(-1j*t*H)
return scipy.linalg.expm(-1j*t*H) # resolveu o problema das pequenas flutuações
U = UHxxx_num(0*math.pi); U.real
def ip_num(a, b):
d = len(a); ip = 0
for j in range(0, d):
ip += np.conj(a[j])*b[j]
return ip
a = np.array([[1],[1j]]); b = np.array([[1],[1j]]); ip_num(a, b)
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
dt = 0.05; t = np.arange(0, math.pi+dt, dt); d = len(t); F = np.zeros(d); psit = np.zeros(d, dtype = complex)
psi0_ = np.zeros(d, dtype = complex); psi0_ = np.kron(ket1, np.kron(ket1, ket0)); #psi0
for j in range(0, d):
U = UHxxx_num(t[j]); psit = np.dot(U, psi0_)
#ip = ip_num(psi0_, psit); F[j] = np.abs(ip)**2
F[j] = qiskit.quantum_info.state_fidelity(psi0_, psit)
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(t, F); plt.xlabel(r'$t$'); plt.ylabel(r'$F$'); plt.grid(); plt.show()
H2 = np.kron(X, X) + np.kron(Y, Y) + np.kron(Z, Z)
def UHxxx12_num(t):
H = np.kron(H2, I)
return scipy.linalg.expm(-1j*t*H)
def UHxxx23_num(t):
H = np.kron(I, H2)
return scipy.linalg.expm(-1j*t*H)
dt = 0.05; t = np.arange(0, math.pi+dt, dt); d = len(t)
#F = np.zeros(d);
F1 = np.zeros(d); F2 = np.zeros(d); F3 = np.zeros(d); F4 = np.zeros(d); F5 = np.zeros(d)
F6 = np.zeros(d); F7 = np.zeros(d); F8 = np.zeros(d); F9 = np.zeros(d); F10 = np.zeros(d); F11 = np.zeros(d)
#psi0_ = np.zeros(d, dtype = complex);
psi0_ = np.kron(ket1, np.kron(ket1, ket0))
for j in range(0, d):
U12 = UHxxx12_num(t[j]); U23 = UHxxx23_num(t[j])
B = np.dot(U12, U23); U1 = np.linalg.matrix_power(B, 1); psit1 = np.dot(U1, psi0_)
#ip = ip_num(psi0_, psit1); F1[j] = np.abs(ip)**2
F1[j] = qiskit.quantum_info.state_fidelity(psi0_, psit1)
U12 = UHxxx12_num(t[j]/2); U23 = UHxxx23_num(t[j]/2)
B = np.dot(U12, U23); U2 = np.linalg.matrix_power(B, 2); psit2 = np.dot(U2, psi0_)
#ip = ip_num(psi0_, psit2); F2[j] = np.abs(ip)**2
F2[j] = qiskit.quantum_info.state_fidelity(psi0_, psit2)
U12 = UHxxx12_num(t[j]/3); U23 = UHxxx23_num(t[j]/3)
B = np.dot(U12, U23); U3 = np.linalg.matrix_power(B, 3); psit3 = np.dot(U3, psi0_)
#ip = ip_num(psi0_, psit3); F3[j] = np.abs(ip)**2
F3[j] = qiskit.quantum_info.state_fidelity(psi0_, psit3)
U12 = UHxxx12_num(t[j]/4); U23 = UHxxx23_num(t[j]/4)
B = np.dot(U12, U23); U4 = np.linalg.matrix_power(B, 4); psit4 = np.dot(U4, psi0_)
#ip = ip_num(psi0_, psit4); F4[j] = np.abs(ip)**2
F4[j] = qiskit.quantum_info.state_fidelity(psi0_, psit4)
U12 = UHxxx12_num(t[j]/5); U23 = UHxxx23_num(t[j]/5)
B = np.dot(U12, U23); U5 = np.linalg.matrix_power(B, 5); psit5 = np.dot(U5, psi0_)
#ip = ip_num(psi0_, psit5); F5[j] = np.abs(ip)**2
F5[j] = qiskit.quantum_info.state_fidelity(psi0_, psit5)
U12 = UHxxx12_num(t[j]/6); U23 = UHxxx23_num(t[j]/6)
B = np.dot(U12, U23); U6 = np.linalg.matrix_power(B, 6); psit6 = np.dot(U6, psi0_)
#ip = ip_num(psi0_, psit6); F6[j] = np.abs(ip)**2
F6[j] = qiskit.quantum_info.state_fidelity(psi0_, psit6)
U12 = UHxxx12_num(t[j]/7); U23 = UHxxx23_num(t[j]/7)
B = np.dot(U12, U23); U7 = np.linalg.matrix_power(B, 7); psit7 = np.dot(U7, psi0_)
#ip = ip_num(psi0_, psit7); F7[j] = np.abs(ip)**2
F7[j] = qiskit.quantum_info.state_fidelity(psi0_, psit7)
U12 = UHxxx12_num(t[j]/8); U23 = UHxxx23_num(t[j]/8)
B = np.dot(U12, U23); U8 = np.linalg.matrix_power(B, 8); psit8 = np.dot(U8, psi0_)
#ip = ip_num(psi0_, psit8); F8[j] = np.abs(ip)**2
F8[j] = qiskit.quantum_info.state_fidelity(psi0_, psit8)
U12 = UHxxx12_num(t[j]/9); U23 = UHxxx23_num(t[j]/9)
B = np.dot(U12, U23); U9 = np.linalg.matrix_power(B, 9); psit9 = np.dot(U9, psi0_)
#ip = ip_num(psi0_, psit9); F9[j] = np.abs(ip)**2
F9[j] = qiskit.quantum_info.state_fidelity(psi0_, psit9)
U12 = UHxxx12_num(t[j]/10); U23 = UHxxx23_num(t[j]/10)
B = np.dot(U12, U23); U10 = np.linalg.matrix_power(B, 10); psit10 = np.dot(U10, psi0_)
#ip = ip_num(psi0_, psit10); F10[j] = np.abs(ip)**2
F10[j] = qiskit.quantum_info.state_fidelity(psi0_, psit10)
U12 = UHxxx12_num(t[j]/11); U23 = UHxxx23_num(t[j]/11)
B = np.dot(U12, U23); U11 = np.linalg.matrix_power(B, 11); psit11 = np.dot(U11, psi0_)
#ip = ip_num(psi0_, psit11); F11[j] = np.abs(ip)**2
F11[j] = qiskit.quantum_info.state_fidelity(psi0_, psit11)
if j == d-1:
print('F5 = ', F5[j], ', F6 = ', F6[j])
plt.figure(figsize = (8,5), dpi = 100)
plt.plot(t, F, '^', label = r'$F$');
plt.plot(t, F1, '-.', label = r'$F_{1}$')
plt.plot(t, F2, '', label = r'$F_{2}$'); plt.plot(t, F3, '-.', label = r'$F_{3}$')
plt.plot(t, F4, '', label = r'$F_{4}$'); plt.plot(t, F5, '-.', label = r'$F_{5}$')
plt.plot(t, F6, '', label = r'$F_{6}$'); plt.plot(t, F7, '-.', label = r'$F_{7}$')
plt.plot(t, F8, '', label = r'$F_{8}$'); plt.plot(t, F9, '-.', label = r'$F_{9}$')
plt.plot(t, F10, '*', label = r'$F_{10}$'); plt.plot(t, F11, 'o', label = r'$F_{11}$')
plt.xlabel(r'$t$'); plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.grid(); plt.show()
def qc_ezz(t):
qc = QuantumCircuit(2, name = 'e^(-itZZ)')
qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1)
return qc
qc_ezz_ = qc_ezz(math.pi); qc_ezz_.draw(output='mpl')
def qc_exx(t):
qc = QuantumCircuit(2, name = 'e^(-itXX)')
qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1])
#qc.h([0,1]); qc_ezz_ = qc_ezz(t); qc.append(qc_ezz_, [0, 1]); qc.h([0,1])
return qc
qc_exx_ = qc_exx(math.pi); qc_exx_.draw(output='mpl')
#qc_exx_.decompose().draw(output='mpl')
def qc_eyy(t):
qc = QuantumCircuit(2, name = 'e^(-itYY)')
qc.sdg([0,1]); qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1]); qc.s([0,1])
#qc.sdg([0,1]); qc_exx_ = qc_exx(t); qc.append(qc_exx_, [0, 1]); qc.s([0,1])
return qc
qc_eyy_ = qc_eyy(math.pi); qc_eyy_.draw(output='mpl')
#qc_eyy_.decompose().draw(output='mpl')
def qc_Bj(t):
qc = QuantumCircuit(3, name = 'B_j')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
return qc
qc_Bj_ = qc_Bj(math.pi/2); qc_Bj_.draw(output='mpl')
qc_Bj_.decompose().draw(output='mpl')
def F_psi_rho_num(psi, rho):
d = rho.shape[0]; F = 0
for j in range(0, d):
for k in range(0, d):
F += np.conj(psi[j])*rho[j,k]*psi[k]
return F.real
psi = [1/math.sqrt(2),1j/math.sqrt(2)]; rho = 0.5*np.array([[1,-1j],[1j,1]])
F = F_psi_rho_num(psi, rho); print(F) # ok!
nshots = 8192
qiskit.IBMQ.load_account()
#provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
#device = provider.get_backend('ibmq_jakarta')
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.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import backend_overview, backend_monitor
backend_overview()
def qc_psi0():
qc = QuantumCircuit(3, name = 'psi0')
qc.x([0,1])
return qc
qc_psi0_ = qc_psi0(); qc_psi0_.draw(output = 'mpl')
psi0_ = np.kron(ket1, np.kron(ket1, ket0));
psi0__ = np.kron(ket0, np.kron(ket1, ket1)) # para calcular a fidelidade com o estado da tomografia
psi0_.T, psi0__.T
nshots = 500
dt = 0.2; t = np.arange(0, math.pi+dt, dt); d = len(t)
F_teo = np.zeros(d); F_sim = np.zeros(d); F_exp = np.zeros(d)
for j in range(0, d):fidelity
# teórico
U12 = UHxxx12_num(t[j]/2); U23 = UHxxx23_num(t[j]/2)
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, 2); psit = np.dot(U, psi0_)
F_teo[j] = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuito quântico
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2])
qc_Bj_ = qc_Bj(t[j]/2); qc.append(qc_Bj_, [0, 1, 2]); qc.append(qc_Bj_, [0, 1, 2]) # 2 passos de Trotter
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim[j] = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp[j] = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
qc.draw(output = 'mpl')
plt.figure(figsize = (8,5), dpi = 100)
plt.plot(t, F_teo, '-.', label = r'$F_{teo}$'); plt.plot(t, F_sim, '-.', label = r'$F_{sim}$')
plt.plot(t, F_exp, '-.', label = r'$F_{exp}$')
plt.xlabel(r'$t$'); plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.grid(); plt.show()
device = provider.get_backend('ibmq_jakarta')
jakarta_info = backend_monitor(device); print(jakarta_info)
nshots = 500
t = math.pi
for j in range(0, 7): # muda o No. de passos de Trotter
# teórico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2])
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.append(qc_Bj_, [0, 1, 2])
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
nshots = 500;
Npt = 7 # Número de passos de Trotter
ph = 2*math.pi # ângulo para a transformação de simetria
t = math.pi
for j in range(0, Npt): # muda o No. de passos de Trotter
# teórico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2]) # estado inicial
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.rz(ph/(j+1), [0, 1, 2]) # transformação de simetria
qc.append(qc_Bj_, [0, 1, 2])
qc.rz(-ph, [0, 1, 2]) # revertendo a transformação de simetria
if j == 1:
qc.draw(output = 'mpl')
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
nshots = 1000;
Npt = 7 # Número de passos de Trotter
ph = 2*math.pi # ângulo para a transformação de simetria RZ
th = math.pi # ângulo para a transformação de simetria RX
t = math.pi
for j in range(0, Npt): # muda o No. de passos de Trotter
# teórico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2]) # estado inicial
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.rx(th/(j+1), [0, 1, 2]) # transformação de simetria RX
qc.rz(ph/(j+1), [0, 1, 2]) # transformação de simetria RZ
qc.append(qc_Bj_, [0, 1, 2])
qc.rz(-ph, [0, 1, 2]) # revertendo a transformação de simetria RZ
qc.rx(-th, [0, 1, 2]) # revertendo a transformação de simetria RX
if j == 1:
qc.draw(output = 'mpl')
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
|
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_bogota')
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_df():
qc = QuantumCircuit(1, name = 'DF')
qc.s(0); qc.h(0); qc.s(0)
return qc
qc_df_ = qc_df(); qc_df_.draw(output = 'mpl')
def qc_bomb():
qc = QuantumCircuit(2, name = 'bomba')
qc.cx(0,1)
return qc
qc_bomb_ = qc_bomb(); qc_bomb_.draw(output = 'mpl')
def qc_espelho():
qc = QuantumCircuit(1, name = 'espelho')
qc.z(0); qc.y(0)
return qc
qc_espelho_ = qc_espelho(); qc_espelho_.draw(output = 'mpl')
qc = QuantumCircuit(2, 2)
qc_df_ = qc_df(); qc.append(qc_df_, [0])
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [0])
qc_bomb_ = qc_bomb(); qc.append(qc_bomb_, [0,1])
qc.append(qc_df_, [0]); qc.barrier()
qc.measure([0,1],[0,1])
qc.draw(output = 'mpl')
job = qiskit.execute(qc, backend = simulator, shots = nshots)
plot_histogram(job.result().get_counts(qc))
job = qiskit.execute(qc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
plot_histogram(job.result().get_counts(qc))
T, R = symbols('T R'); Udfg = Matrix([[T,1j*R],[1j*R,T]]); Udfgd = Matrix([[T,-1j*R],[-1j*R,T]])
Udfg*Udfgd, Udfgd*Udfg # ok, é unitária
def qc_dfg(th):
qc = QuantumCircuit(1, name = 'DFG')
qc.rx(-2*th, 0)
return qc
qc_dfg_ = qc_dfg(math.pi); qc_dfg_.draw(output = 'mpl')
def qc_imzg(th, ph):
qc = QuantumCircuit(1, name = 'IMZG')
qc_dfg_ = qc_dfg(th); qc.append(qc_dfg_, [0])
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [0])
qc.p(ph, 0)
qc_dfg_ = qc_dfg(th); qc.append(qc_dfg_, [0])
return qc
qc_imzg_ = qc_imzg(math.pi, math.pi/2); qc_imzg_.draw(output = 'mpl')
phmax = 2*math.pi; dph = phmax/20; ph = np.arange(0, phmax+dph, dph)#; ph
th = math.pi/8
print('T = ', math.cos(th), ', R = ', math.sin(th))
d = ph.shape[0]; PD0teo = np.zeros(d); PD0sim = np.zeros(d);
for j in range(0, d):
PD0teo[j] = 2*math.sin(th)**2*math.cos(th)**2*(1+math.cos(ph[j])) # theoretical
qc = QuantumCircuit(1)
qc_imzg_ = qc_imzg(th, ph[j]); qc.append(qc_imzg_, [0])
qstc = state_tomography_circuits(qc, [0]) # circuit for state tomography
job = qiskit.execute(qstc, Aer.get_backend('qasm_simulator'), shots=nshots)
qstf = StateTomographyFitter(job.result(), qstc); rho = qstf.fit(method='lstsq')
PD0sim[j] = rho[0,0].real
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(ph, PD0teo, label = r'$P_{teo}(D_{0})$')
plt.plot(ph, PD0sim, 'o', label = r'$P_{sim}(D_{0})$')
#plt.plot(ph, PD0exp, '*', label = r'$P_{exp}(D_{0})$')
plt.legend(); plt.xlabel(r'$\phi$'); plt.show()
def V(pd):
return (np.max(pd)-np.min(pd))/(np.max(pd)+np.min(pd))
def Vt(pd):
return np.max(pd)*(np.max(pd)-np.min(pd))/(np.max(pd)+np.min(pd))
def pd_ph(th):
phmax = 2*math.pi; dph = phmax/100; ph = np.arange(0, phmax+dph, dph)
return 2*math.sin(th)**2*math.cos(th)**2*(1+np.cos(ph))
dth = 0.05; th = np.arange(dth, math.pi/2, dth); d = th.shape[0]
Vis = np.zeros(d); VisT= np.zeros(d); Vteo = np.zeros(d)
for j in range(0, d):
Vteo[j] = 4*math.cos(th[j])**2*math.sin(th[j])**2
pd = pd_ph(th[j]); Vis[j] = V(pd); VisT[j] = Vt(pd)
matplotlib.rcParams.update({'font.size':12}); plt.figure(figsize = (6,4), dpi = 100)
plt.plot(th, Vis, label = r'$V$'); plt.plot(th, VisT, label = r'$\tilde{V}$')
plt.plot(th, Vteo, '*', label = r'$V_{teo}$')
plt.xlabel(r'$\theta$'); plt.legend(); plt.show()
float(cos(pi/12)**2)
float((cos(pi/12)**2)**6), float((cos(pi/24)**2)**12), float((cos(pi/48)**2)**24), float((cos(pi/96)**2)**48)
Udf = (1/sqrt(2))*Matrix([[1,1j],[1j,1]]); Ue = Matrix([[0,1j],[1j,0]]); Udf*Ue*Udf
T = cos(math.pi/12); T
th = +pi-pi/6; float((sin(th/2)**2)**6)
T = cos(th); R = sin(th); print('T = ', float(T), ', R = ', float(R)) # ??????????????
N = 6; th = math.pi-math.pi/N; qc = QuantumCircuit(2, N)
for j in range(0, N-1):
qc.rx(th, 0)
qc_espelho_ = qc_espelho(); qc.append(qc_espelho_, [0])
qc.cx(0, 1); qc.measure(1, j); qc.reset(1)
qc.barrier()
qc.rx(th, 0) # o último DFG é colocado só na última volta
qc.measure(0, N-1)
#qc.draw(output = 'mpl')
qc.decompose().draw(output = 'mpl')
matplotlib.rcParams.update({'font.size':12})
#plt.figure(figsize = (6,4), dpi = 100)
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
import numpy as np
for j in range(0,20):
print(np.random.randint(11))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import math
import numpy as np
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
#provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
#device = provider.get_backend('ibmq_jakarta')
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.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import backend_overview, backend_monitor
from qiskit.tools.visualization import plot_histogram
qc = QuantumCircuit(5)
th, ph, lb = 0.1, 0.2, 0.3; qc.u(th, ph, lb, [0]); qc.barrier() # qubit estate preparation
qc.cx([0],[1]); qc.cx([1], [2]); qc.h([0, 1, 2]); qc.barrier() # encoding
qc.z([0]); qc.barrier() # phase flip error
qc.draw(output = 'mpl')
qc.h([0, 1, 2]); qc.cx([0], [3]); qc.cx([1], [3]); qc.cx([1], [4]); qc.cx([2], [4])
qc.draw(output = 'mpl')
def qc_ec_pf(th, ph, lb, j):
qc = QuantumCircuit(5, name = 'EC_PF')
qc.u(th, ph, lb, [0]) # qubit state preparation
qc.barrier()
qc.cx([0], [1]); qc.cx([1], [2]); qc.h([0, 1, 2]) # encoding
qc.barrier()
if j == 0 or j == 1 or j == 2: # error
qc.z([j])
qc.barrier()
qc.h([0, 1, 2]); qc.cx([0], [3]); qc.cx([1], [3]); qc.cx([1], [4]); qc.cx([2], [4]) # syndrome detection
qc.barrier()
qc.x([3]); qc.ccx([4], [3], [2]); qc.x([3]); qc.ccx([4], [3], [1]) # correction
qc.x([4]); qc.ccx([4], [3], [0]); qc.x([4]) # correction
qc.barrier()
return qc
th, ph, lb = math.pi, 0.0, 0.0; j = 2; qc_ec_pf_ = qc_ec_pf(th, ph, lb, j)
qc_ec_pf_.draw(output = 'mpl')
# Teste da funcionalidade do circuito para correção do phase flip
qc = QuantumCircuit(5, 3);
j = 2 # sets the error
qc_ec_pf_ = qc_ec_pf(math.pi/2, 0.0, 0.0, j); qc.append(qc_ec_pf_, [0, 1, 2, 3, 4])
qc.measure([0, 1, 2], [0, 1, 2]);
#qc.decompose().draw(output = 'mpl')
job_sim = execute(qc, backend = simulator, shots = nshots)
plot_histogram(job_sim.result().get_counts(qc))
job_exp = execute(qc, backend = device, shots = nshots)
print(job_exp.job_id()); job_monitor(job_exp)
plot_histogram(job_exp.result().get_counts(qc))
qc = QuantumCircuit(2, 1)
th, ph, lb = math.pi, 0.0, 0.0; qc.u(th, ph, lb, [0]) # state preparation
qc.barrier(); qc.cx([0], [1]); qc.h([0]); qc.barrier()
qc.z([0]); qc.barrier()
qc.h([0]); qc.cx([0], [1]); qc.cx([1], [0])
qc.measure([0], [0])
qc.draw(output = 'mpl')
job = execute(qc, backend = simulator, shots = nshots)
plot_histogram(job.result().get_counts(qc))
job = execute(qc, backend = device, shots = nshots); job_monitor(job)
plot_histogram(job.result().get_counts(qc))
def qc_encoding_shor():
qc = QuantumCircuit(9, name = 'encoding')
qc.cx([0], [3]); qc.cx([0], [6])
qc.h([0, 3, 6])
qc.cx([0], [1]); qc.cx([0], [2]); qc.cx([3], [4])
qc.cx([3], [5]); qc.cx([6], [7]); qc.cx([6], [8])
return qc
qc_encoding_shor_ = qc_encoding_shor(); qc_encoding_shor_.draw(output = 'mpl')
def qc_gen_bf():
qc = QuantumCircuit(9+6, name = 'BF')
qc.decompose().draw(output = 'mpl')
qc.cx([0], [9]); qc.cx([1], [9]); qc.cx([1], [10]); qc.cx([2], [10])
qc.barrier()
qc.x([9]); qc.ccx([10], [9], [2]); qc.x([9]); qc.ccx([10], [9], [1]); qc.x([10]); qc.ccx([10], [9], [0]); qc.x([10])
qc.barrier()
qc.cx([3], [11]); qc.cx([4], [11]); qc.cx([4], [12]); qc.cx([5], [12])
qc.barrier()
qc.x([11]); qc.ccx([12], [11], [5]); qc.x([11]); qc.ccx([12], [11], [4]); qc.x([12]); qc.ccx([12], [11], [3]); qc.x([12])
qc.barrier()
qc.cx([6], [13]); qc.cx([7], [13]); qc.cx([7], [14]); qc.cx([8], [14])
qc.barrier()
qc.x([13]); qc.ccx([14], [13], [8]); qc.x([13]); qc.ccx([14], [13], [7]); qc.x([14]); qc.ccx([14], [13], [6]); qc.x([14])
return qc
qc_gen_bf_ = qc_gen_bf(); qc_gen_bf_.draw(output = 'mpl')
#qc.decompose().draw(output = 'mpl')
def qc_gen_pf():
qc = QuantumCircuit(9+2, name = 'PF')
qc.cx([0], [1]); qc.cx([0], [2]); qc.cx([3], [4]); qc.cx([3], [5]); qc.cx([6], [7]); qc.cx([6], [8]) # destrói o emaranhamento
qc.h([0, 3, 6]) # destrói a coerência
qc.cx([0], [9]); qc.cx([3], [9]); qc.cx([3], [10]); qc.cx([6], [10]) # medida de síndrome
qc.barrier()
qc.x([9]); qc.ccx([10], [9], [6]); qc.x([9]); qc.ccx([10], [9], [3]); qc.x([10]); qc.ccx([10], [9], [0]); qc.x([10]) # reversão do erro
qc.barrier()
qc.h([0, 3, 6]) # passa esses qubits para a base |+>,|->
qc.cx([0], [1]); qc.cx([0], [2]); qc.cx([3], [4]); qc.cx([3], [5]); qc.cx([6], [7]); qc.cx([6], [8]) # recria o emaranhamento
return qc
qc_gen_pf_ = qc_gen_pf(); qc_gen_pf_.draw(output = 'mpl')
def qc_decoding_shor():
qc = QuantumCircuit(9, name = 'decoding')
qc.cx([0], [2]); qc.cx([3], [5]); qc.cx([6], [8])
qc.cx([0], [1]); qc.cx([3], [4]); qc.cx([6], [7])
qc.h([0, 3, 6])
qc.cx([0], [3]); qc.cx([0], [6])
return qc
qc_decoding_shor_ = qc_decoding_shor(); qc_decoding_shor_.draw(output = 'mpl')
def qc_error():
qc = QuantumCircuit(9, name = 'error')
qc.x([0]); qc.z([0])
#qc.z(4); qc.x([5])
qc.x([8])
return qc
qc_error_ = qc_error(); qc_error_.draw(output = 'mpl')
qc = QuantumCircuit(9+6+2, 1)
qc.h([0]) # prepara o estado |1>
qc.barrier()
qc_encoding_shor_ = qc_encoding_shor(); qc.append(qc_encoding_shor_, [0,1,2,3,4,5,6,7,8])
qc.barrier()
qc_error_ = qc_error(); qc.append(qc_error_, [0,1,2,3,4,5,6,7,8])
qc.barrier()
qc_gen_bf_ = qc_gen_bf(); qc.append(qc_gen_bf_, [0,1,2,3,4,5,6,7,8,9,10,11,12,13,14])
qc.barrier()
qc_gen_pf_ = qc_gen_pf(); qc.append(qc_gen_pf_, [0,1,2,3,4,5,6,7,8,15,16])
qc.barrier()
qc_decoding_shor_ = qc_decoding_shor(); qc.append(qc_decoding_shor_, [0,1,2,3,4,5,6,7,8])
qc.barrier()
qc.measure([0], 0)
qc.draw(output = 'mpl')
job = execute(qc, backend = simulator, shots = nshots)
plot_histogram(job.result().get_counts(qc))
qc = QuantumCircuit(9)
th, ph, lb = math.pi/2, 0.0, 0.0; qc.u(th, ph, lb, [0])
qc.barrier(); qc.x([0]); qc.z([0]); qc.barrier() # o erro
qc.cx([0], [1]); qc.cx([0], [2]); qc.cx([3], [4]); qc.cx([3], [5]); qc.cx([6], [7]); qc.cx([6], [8])
qc.ccx([2], [1], [0]); qc.ccx([5], [4], [3]); qc.ccx([8], [7], [6])
qc.h([0, 3, 6])
qc.cx([0], [3]); qc.cx([0], [6])
qc.ccx([6], [3], [0])
qc.draw(output = 'mpl')
qc = QuantumCircuit(3, 1)
th, ph, lb = math.pi, 0.0, 0.0; qc.u(th, ph, lb, [1]) # state preparation
qc.barrier(); qc.cx([1], [2]); qc.barrier()
qc.x([1]); qc.z([1]); qc.barrier()
qc.cx([1], [2]); qc.cx([2], [1])
qc.measure([1], [0])
qc.draw(output = 'mpl')
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit, IBMQ, Aer
def qc_ezz(t):
qc = QuantumCircuit(2, name = 'e^(-itZZ)')
qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1)
return qc
def qc_exx(t):
qc = QuantumCircuit(2, name = 'e^(-itXX)')
qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1])
return qc
def qc_eyy(t):
qc = QuantumCircuit(2, name = 'e^(-itYY)')
qc.sdg([0,1]); qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1]); qc.s([0,1])
return qc
def qc_Bj(t):
qc = QuantumCircuit(3, name = 'B_j')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
return qc
import math
qc_Bj_ = qc_Bj(math.pi)
qc_Bj_.draw(output = 'mpl')
qc_Bj_.decompose().draw(output = 'mpl')
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
#provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibmq_jakarta')
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.tools.monitor import backend_overview, backend_monitor
def qc_psi0():
qc = QuantumCircuit(3, name = 'psi0')
qc.x([0,1])
return qc
import numpy as np
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
psi0_ = np.kron(ket1, np.kron(ket1, ket0));
psi0__ = np.kron(ket0, np.kron(ket1, ket1)) # para calcular a fidelidade com o estado da tomografia
psi0_.T, psi0__.T
import scipy
I = np.array([[1,0],[0,1]]); X = np.array([[0,1],[1,0]]); Y = np.array([[0,-1j],[1j,0]]); Z = np.array([[1,0],[0,-1]])
H2 = np.kron(X, X) + np.kron(Y, Y) + np.kron(Z, Z)
def UHxxx12_num(t):
H = np.kron(H2, I)
return scipy.linalg.expm(-1j*t*H)
def UHxxx23_num(t):
H = np.kron(I, H2)
return scipy.linalg.expm(-1j*t*H)
#U = UHxxx23_num(math.pi); print(U.shape[0])
from qiskit import quantum_info, execute
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
t = math.pi
for j in range(0, 8): # muda o No. de passos de Trotter
# teórico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(7)
qc.x([5, 3]) # initial state
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.append(qc_Bj_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulação
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim = quantum_info.state_fidelity(psi0__, rho_sim)
# experimento
job_exp = execute(qstc, backend = device, shots = nshots)
job_monitor(job_exp)
qstf_exp = StateTomographyFitter(job_exp.result(), qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp = quantum_info.state_fidelity(psi0__, rho_exp)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
npt = 7
dt = math.pi/16; t = np.arange(0, math.pi+dt, dt); d = len(t)
F_teo = np.zeros(d); F_sim = np.zeros(d); F_exp = np.zeros(d)
for j in range(0, d):
# teórico
U12 = UHxxx12_num(t[j]/npt); U23 = UHxxx23_num(t[j]/npt)
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, npt); psit = np.dot(U, psi0_)
F_teo[j] = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuito quântico
qc = QuantumCircuit(7); qc.x([5, 3]) # initial state
qc_Bj_ = qc_Bj(t[j]/npt)
for k in range(0, npt):
qc.append(qc_Bj_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulação
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim[j] = quantum_info.state_fidelity(psi0__, rho_sim)
# experimento
job_exp = execute(qstc, backend = device, shots = nshots)
job_monitor(job_exp)
qstf_exp = StateTomographyFitter(job_exp.result(), qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp[j] = quantum_info.state_fidelity(psi0__, rho_exp)
qc.draw(output = 'mpl')
print('t = ', t[j], 'F_exp = ', F_exp[j])
%run init.ipynb
plt.figure(figsize = (8,5), dpi = 100)
plt.plot(t, F_teo, '-.', label = r'$F_{teo}$'); plt.plot(t, F_sim, '-.', label = r'$F_{sim}$')
plt.plot(t, F_exp, '-.', label = r'$F_{exp}$')
plt.xlabel(r'$t$'); plt.legend(bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.grid(); plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import qiskit
qc = qiskit.QuantumCircuit(4, 2)
qc.h([0, 2]); qc.cx([0], [1]); qc.cx([2], [3]) # preparacao e distribuicao de emaranhamento
qc.barrier() # base de Bell -> base computacional
qc.cx([1], [2]); qc.h([1])
qc.barrier() # feedback baseado na info classica
qc.x([1, 2]); qc.cx([2], [3]); qc.cz([1], [3]); qc.x([1, 2])
qc.barrier() # para verificacao da funcionalidade do cq (tem que sair Psi-=11)
qc.cx([0], [3]); qc.h([0]); qc.measure([0, 3], [0, 1])
qc.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')
simulator = qiskit.Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_bogota')
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
job = qiskit.execute(qc, backend = simulator, shots = nshots)
plot_histogram(job.result().get_counts(qc))
job = qiskit.execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
#from qiskit.circuit.Instruction import c_if
from qiskit import *
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 = qiskit.QuantumCircuit(q0, q1, q2, q3, c0, c1, c2, c3)
qc.h(q0); qc.h(q2); qc.cx(q0, q1); qc.cx(q2, q3) # preparacao e distribuicao de emaranhamento
qc.barrier() # base de Bell -> base computacional
qc.cx(q1, q2); qc.h(q1); qc.measure(q1, c0); qc.measure(q2, c1)
qc.barrier() # feedback baseado na info classica
qc.x(q3).c_if(c1, 0); qc.z(q3).c_if(c0, 0)
qc.barrier() # para verificacao da funcionalidade do cq
qc.measure(q0, c2); qc.measure(q3, c3)
qc.draw(output = 'mpl')
job = qiskit.execute(qc, backend = simulator, shots = nshots)
plot_histogram(job.result().get_counts(qc))
# parece que não podemos executar no chip real a c_if
job = qiskit.execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
import math
def E_Phi(p, q):
return 2*math.sqrt(p*(1-p)*q*(1-q))/(p*q+(1-p)*(1-q))
def E_Psi(p, q):
return 2*math.sqrt(p*(1-p)*q*(1-q))/(p*(1-q)+(1-p)*q)
import numpy as np
from matplotlib import pyplot as plt
import matplotlib
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
p = np.zeros(101)
Eq0 = np.zeros(101); Eq001 = np.zeros(101); Eq005 = np.zeros(101); Eq025 = np.zeros(101); Eq05 = np.zeros(101)
Eq0 = np.zeros(101); Eq099 = np.zeros(101); Eq095 = np.zeros(101); Eq075 = np.zeros(101)
for j in range(0, 101):
p[j] = j*0.01
if p[j] != 0 and p[j] != 1:
q = 0.0; Eq0[j] = E_Phi(p[j], q); q = 0.01; Eq001[j] = E_Phi(p[j], q)
q = 0.05; Eq005[j] = E_Phi(p[j], q); q = 0.25; Eq025[j] = E_Phi(p[j],q)
q = 0.5; Eq05[j] = E_Phi(p[j],q); q = 0.75; Eq075[j] = E_Phi(p[j],q)
q = 0.95; Eq095[j] = E_Phi(p[j],q); q = 0.99; Eq099[j] = E_Phi(p[j],q)
plt.plot(p, Eq0); plt.plot(p, Eq001); plt.plot(p, Eq005); plt.plot(p, Eq025); plt.plot(p, Eq05)
plt.plot(p, Eq075); plt.plot(p, Eq095); plt.plot(p, Eq099)
plt.xlabel('p'); plt.ylabel(r'$E(\rho_{AD})$')
plt.legend(('q=0','q=0.01','q=0.05','q=0.25','q=0.5','q=0.75','q=0.95','q=0.99'),
bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.title(r'$|\Phi_{\pm}\rangle$')
plt.show()
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
p = np.zeros(101)
Eq0 = np.zeros(101); Eq001 = np.zeros(101); Eq005 = np.zeros(101); Eq025 = np.zeros(101); Eq05 = np.zeros(101)
Eq0 = np.zeros(101); Eq099 = np.zeros(101); Eq095 = np.zeros(101); Eq075 = np.zeros(101)
for j in range(0, 101):
p[j] = j*0.01
if p[j] != 0 and p[j] != 1:
q = 0.0; Eq0[j] = E_Psi(p[j], q); q = 0.01; Eq001[j] = E_Psi(p[j], q)
q = 0.05; Eq005[j] = E_Psi(p[j], q); q = 0.25; Eq025[j] = E_Psi(p[j],q)
q = 0.5; Eq05[j] = E_Psi(p[j],q); q = 0.75; Eq075[j] = E_Psi(p[j],q)
q = 0.95; Eq095[j] = E_Psi(p[j],q); q = 0.99; Eq099[j] = E_Psi(p[j],q)
plt.plot(p, Eq0); plt.plot(p, Eq001); plt.plot(p, Eq005); plt.plot(p, Eq025); plt.plot(p, Eq05)
plt.plot(p, Eq075); plt.plot(p, Eq095); plt.plot(p, Eq099)
plt.xlabel('p'); plt.ylabel(r'$E(\rho_{AD})$')
plt.legend(('q=0','q=0.01','q=0.05','q=0.25','q=0.5','q=0.75','q=0.95','q=0.99'),
bbox_to_anchor=(1.05, 1.0), loc='upper left')
plt.title(r'$|\Psi_{\pm}\rangle$')
plt.show()
E_Phi(p,q), E_Psi(p,q)
p,q = symbols('p q'); factor(diff(E_Phi(p,q),p)), factor(diff(E_Psi(p,q),p))
E_Phi(1-q,q), E_Psi(q,q) # nos 2 casos, E=1
import numpy as np
from matplotlib import pyplot as plt
q = np.arange(0.001, 1.0, 0.001); PmaxE = 2*(1-q)*q; plt.plot(q, 1-PmaxE, label = r'$1-Pr(\max E)$');
pred = 1 + q*np.log2(q) + (1-q)*np.log2(1-q); plt.plot(q, pred, label = r'$P_{vn}(\rho_{A})$')
plt.legend(); plt.xlabel(r'$q$'); plt.show()
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute, IBMQ
from qiskit.providers.aer import noise
from qiskit.providers.aer.noise import NoiseModel
from qiskit.visualization import plot_histogram
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
qr = QuantumRegister(5)
qubit_list = [2, 3, 4] # os qubits para os quais aplicaremos calibracao de medidas
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
print(state_labels)
meas_calibs # circuitos que serao executados para obter dados para calibracao (uma para cada state_labels)
nshots = 8192
simulator = Aer.get_backend('qasm_simulator')
job = execute(meas_calibs, backend = simulator, shots = nshots) # executa a calibracao
cal_results = job.result()
# a matriz de calibracao sem ruido e a identidade
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
print(meas_fitter.cal_matrix)
meas_fitter.plot_calibration()
provider = IBMQ.load_account()
device = provider.get_backend('ibmq_bogota')
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
coupling_map = device.configuration().coupling_map
job = execute(meas_calibs, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
print(meas_fitter.cal_matrix)
# visualizacao grafica da matriz de calibracao
meas_fitter.plot_calibration()
qr = QuantumRegister(5); cr = ClassicalRegister(3); qc_ghz = QuantumCircuit(qr, cr)
qc_ghz.h(qr[2]); qc_ghz.cx(qr[2], qr[3]); qc_ghz.cx(qr[3], qr[4])
qc_ghz.measure(qr[2], cr[0]); qc_ghz.measure(qr[3], cr[1]); qc_ghz.measure(qr[4], cr[2]);
qc_ghz.draw(output = 'mpl')
qubit_list = [2, 3, 4] # os qubits para os quais aplicaremos calibracao de medidas
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = execute(meas_calibs, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
job = execute(qc_ghz, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
unmitigated_counts = job.result().get_counts() # resultados sem mitigacao de erros
# Resultados com mitigacao de erros
mitigated_results = meas_fitter.filter.apply(job.result())
mitigated_counts = mitigated_results.get_counts()
plot_histogram([unmitigated_counts, mitigated_counts], legend=['sem mit', 'com mit'])
qr = QuantumRegister(3); qc = QuantumCircuit(qr); qc.h([0]); qc.cx([0], [1])
qc.draw(output = 'mpl')
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
qstc = state_tomography_circuits(qc, [qr[0], qr[1]])
job = execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
print(rho.real)
from qiskit.visualization import plot_state_city
plot_state_city(rho, title=r'$|\Phi_{+}^{sim}\rangle$')
device = provider.get_backend('ibmq_bogota')
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
coupling_map = device.configuration().coupling_map
job = execute(qstc, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method='lstsq')
print(rho.real)
plot_state_city(rho, title=r'$|\Phi_{+}^{simN}\rangle$')
qubit_list = [0, 1]
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = execute(meas_calibs, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
qstc = state_tomography_circuits(qc, [qr[0], qr[1]])
job = execute(qstc, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
mitigated_results = meas_fitter.filter.apply(job.result())
qstf = StateTomographyFitter(mitigated_results, qstc)
rho = qstf.fit(method = 'lstsq')
print(rho.real)
plot_state_city(rho, title=r'$|\Phi_{+}^{simNcal}\rangle$')
qr = QuantumRegister(3); qc = QuantumCircuit(qr); qc.h([0]); qc.cx([0], [1])
qc.draw(output = 'mpl')
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibmq_bogota')
from qiskit.tools.monitor import job_monitor
qstc = state_tomography_circuits(qc, [qr[0], qr[1]])
job_exp = execute(qstc, backend = device, shots = nshots); job_monitor(job_exp)
qstf = StateTomographyFitter(job_exp.result(), qstc)
rho = qstf.fit(method = 'lstsq'); print(rho.real)
plot_state_city(rho, title=r'$|\Phi_{+}^{exp}\rangle$')
qubit_list = [0, 1] # os qubits para os quais aplicaremos calibracao de medidas
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = execute(meas_calibs, backend = device, shots = nshots)
job_monitor(job)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
mitigated_results = meas_fitter.filter.apply(job_exp.result())
qstf = StateTomographyFitter(mitigated_results, qstc)
rho = qstf.fit(method = 'lstsq'); print(rho.real)
plot_state_city(rho, title=r'$|\Phi_{+}^{ExpCal}\rangle$')
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit, execute, IBMQ, Aer
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.noise import NoiseModel
# contruir modelo de ruido a partir das propriedades do chip
nshots = 8192
provider = IBMQ.load_account()
device = provider.get_backend('ibmq_bogota')
simulator = Aer.get_backend('qasm_simulator')
noise_model = NoiseModel.from_backend(device) # essa funcao constroi o modelo de ruido
print(noise_model)
# obter mapa de acoplamento do chip
coupling_map = device.configuration().coupling_map
print(coupling_map)
# obter base de portas logicas a partir do modelo de ruido
basis_gates = noise_model.basis_gates
print(basis_gates)
# construir o circuit
qc = QuantumCircuit(3, 3)
qc.h(0); qc.cx(0, 1); qc.cx(0, 2); qc.measure([0, 1, 2], [0, 1, 2])
qc.draw(output = 'mpl')
jobS = execute(qc, backend = simulator, shots = nshots)
plot_histogram(jobS.result().get_counts())
# faz a simulacao com o ruido ja incluido
jobNS = execute(qc, backend = simulator, coupling_map = coupling_map, basis_gates = basis_gates,
noise_model = noise_model, shots = nshots)
plot_histogram(jobNS.result().get_counts())
from qiskit.tools.monitor import job_monitor
jobE = execute(qc, backend = device, shots = nshots)
job_monitor(jobE)
plot_histogram(jobE.result().get_counts())
plot_histogram([jobS.result().get_counts(0), jobNS.result().get_counts(0), jobE.result().get_counts(0)],
bar_labels = False, legend = ['sim', 'noise_sim', 'exp'])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit
def qc_state_prep():
qc = QuantumCircuit(2, name = 'state_prep');
qc.h(0)
qc.cx(0, 1)
qc.z(0)
qc.x(1)
return qc
qc_state_prep_ = qc_state_prep(); qc_state_prep_.draw(output = 'mpl')
from qiskit import IBMQ, Aer, execute
nshots = 8192
provider = IBMQ.load_account()
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.visualization import plot_state_city
qstc = state_tomography_circuits(qc_state_prep_, [0, 1])
job = execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
plot_state_city(rho, title = r'$|\Psi_{-}^{sim}\rangle$')
import math
def qc_A1B1():
qc = QuantumCircuit(2, name = 'A1B1'); qc.z(0); qc.u(math.pi/4, 0, math.pi, [1])
return qc
qc_A1B1_ = qc_A1B1(); qc_A1B1_.draw(output = 'mpl')
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc.barrier()
qc_A1B1_ = qc_A1B1(); qc.append(qc_A1B1_, [0, 1]); qc.measure([0, 1], [0, 1])
qc.draw(output = 'mpl')
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); print(resultS , ',', resultS['11'])
def AB_avg(result, nshots):
avg = 0
if '00' in result:
avg += result['00']
if '01' in result:
avg -= result['01']
if '10' in result:
avg -= result['10']
if '11' in result:
avg += result['11']
return avg/nshots
A1B1_avg = AB_avg(resultS, nshots); print(A1B1_avg)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A1B1_avgE = AB_avg(jobE.result().get_counts(), nshots)
print('<A1B1>_teo = ', -1/math.sqrt(2), ', <A1B1>_sim = ', A1B1_avg, ', <A1B1>_exp = ', A1B1_avgE)
def qc_A1B2():
qc = QuantumCircuit(2, name = 'A1B2'); qc.z(0); qc.u(-math.pi/4, 0, math.pi, [1])
return qc
qc_A1B2_ = qc_A1B2(); qc_A1B2_.draw(output = 'mpl')
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc_A1B2_ = qc_A1B2(); qc.append(qc_A1B2_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts()
A1B2_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A1B2_avgE = AB_avg(jobE.result().get_counts(), nshots)
print('<A1B2>_teo = ', -1/math.sqrt(2), ', <A1B2>_sim = ', A1B2_avg, ', <A1B2>_exp = ', A1B2_avgE)
def qc_A2B1():
qc = QuantumCircuit(2, name = 'A2B1'); qc.h(0); qc.u(math.pi/4, 0, math.pi, [1])
return qc
qc_A2B1_ = qc_A2B1(); qc_A2B1_.draw(output = 'mpl')
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc_A2B1_ = qc_A2B1(); qc.append(qc_A2B1_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts()
A2B1_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A2B1_avgE = AB_avg(jobE.result().get_counts(), nshots)
print('<A2B1>_teo = ', -1/math.sqrt(2), ', <A2B1>_sim = ', A2B1_avg, ', <A2B1>_exp = ', A2B1_avgE)
def qc_A2B2():
qc = QuantumCircuit(2, name = 'A2B2'); qc.h(0); qc.u(-math.pi/4, 0, math.pi, [1])
return qc
qc_A2B2_ = qc_A2B2(); qc_A2B2_.draw(output = 'mpl')
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc_A2B2_ = qc_A2B2(); qc.append(qc_A2B2_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts()
A2B2_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A2B2_avgE = AB_avg(jobE.result().get_counts(), nshots)
print('<A2B2>_teo = ', 1/math.sqrt(2), ', <A2B2>_sim = ', A2B2_avg, ', <A2B2>_exp = ', A2B2_avgE)
O_avg = A1B1_avg + A1B2_avg + A2B1_avg - A2B2_avg
O_avgE = A1B1_avgE + A1B2_avgE + A2B1_avgE - A2B2_avgE
print('<O>_teo = ', -2*math.sqrt(2), ', <O>_sim = ', O_avg, ', <O>_exp = ', O_avgE)
import numpy as np
from matplotlib import pyplot as plt
import matplotlib
def qc_state_prep(th):
qc = QuantumCircuit(2, name = 'Psi')
qc.u(th, 0, 0, [0]); qc.cx([0], [1]); qc.z([0]); qc.x([1])
return qc
qc_state_prep_ = qc_state_prep(math.pi); qc_state_prep_.draw(output = 'mpl')
p = np.arange(0, math.pi/2+0.1, 0.1); Oavg = -math.sqrt(2)*(1+np.sin(p))
d = p.shape[0]; y = -2*np.ones(d); Oavg_sim = np.zeros(d); Oavg_exp = np.zeros(d)
for j in range(0, d):
# A1B1
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(p[j]); qc.append(qc_state_prep_, [0, 1])
qc_A1B1_ = qc_A1B1(); qc.append(qc_A1B1_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A1B1_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A1B1_avgE = AB_avg(jobE.result().get_counts(), nshots)
# A1B2
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(p[j]); qc.append(qc_state_prep_, [0, 1])
qc_A1B2_ = qc_A1B2(); qc.append(qc_A1B2_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A1B2_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A1B2_avgE = AB_avg(jobE.result().get_counts(), nshots)
# A2B1
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(p[j]); qc.append(qc_state_prep_, [0, 1])
qc_A2B1_ = qc_A2B1(); qc.append(qc_A2B1_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A2B1_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A2B1_avgE = AB_avg(jobE.result().get_counts(), nshots)
# A2B2
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(p[j]); qc.append(qc_state_prep_, [0, 1])
qc_A2B2_ = qc_A2B2(); qc.append(qc_A2B2_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A2B2_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A2B2_avgE = AB_avg(jobE.result().get_counts(), nshots)
# O
Oavg_sim[j] = A1B1_avg + A1B2_avg + A2B1_avg - A2B2_avg
Oavg_exp[j] = A1B1_avgE + A1B2_avgE + A2B1_avgE - A2B2_avgE
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(p, y, label = 'LHV limit')
plt.plot(p, Oavg, label = r'$\langle O\rangle_{\Psi}^{teo}$')
plt.plot(p, Oavg_sim, '*', label = r'$\langle O\rangle_{\Psi}^{sim}$')
plt.plot(p, Oavg_exp, 'o', label = r'$\langle O\rangle_{\Psi}^{exp}$')
plt.xlabel(r'$\theta$'); plt.legend(); plt.show()
def qc_A1B1(th):
qc = QuantumCircuit(2, name = 'A1B1'); qc.z(0); qc.u(th, 0, math.pi, [1])
return qc
def qc_A1B2():
qc = QuantumCircuit(2, name = 'A1B2'); qc.z(0); qc.u(-math.pi/4, 0, math.pi, [1])
return qc
def qc_A2B1(th):
qc = QuantumCircuit(2, name = 'A2B1'); qc.h(0); qc.u(th, 0, math.pi, [1])
return qc
def qc_A2B2():
qc = QuantumCircuit(2, name = 'A2B2'); qc.h(0); qc.u(-math.pi/4, 0, math.pi, [1])
return qc
def qc_state_prep():
qc = QuantumCircuit(2, name = 'state_prep'); qc.h(0); qc.cx(0, 1); qc.z(0); qc.x(1)
return qc
th = np.arange(-math.pi/4, math.pi/4+0.1, 0.1); Oavg = -(math.sqrt(2)+np.cos(th)+np.sin(th))
d = p.shape[0]; y = -2*np.ones(d); Oavg_sim = np.zeros(d); Oavg_exp = np.zeros(d)
for j in range(0, d):
# A1B1
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc_A1B1_ = qc_A1B1(th[j]); qc.append(qc_A1B1_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A1B1_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A1B1_avgE = AB_avg(jobE.result().get_counts(), nshots)
# A1B2
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc_A1B2_ = qc_A1B2(); qc.append(qc_A1B2_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A1B2_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A1B2_avgE = AB_avg(jobE.result().get_counts(), nshots)
# A2B1
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc_A2B1_ = qc_A2B1(th[j]); qc.append(qc_A2B1_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A2B1_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A2B1_avgE = AB_avg(jobE.result().get_counts(), nshots)
# A2B2
qc = QuantumCircuit(2, 2)
qc_state_prep_ = qc_state_prep(); qc.append(qc_state_prep_, [0, 1])
qc_A2B2_ = qc_A2B2(); qc.append(qc_A2B2_, [0, 1]); qc.measure([0, 1], [0, 1])
jobS = execute(qc, backend = simulator, shots = nshots)
resultS = jobS.result().get_counts(); A2B2_avg = AB_avg(resultS, nshots)
jobE = execute(qc, backend = device, shots = nshots); job_monitor(jobE)
A2B2_avgE = AB_avg(jobE.result().get_counts(), nshots)
# O
Oavg_sim[j] = A1B1_avg + A1B2_avg + A2B1_avg - A2B2_avg
Oavg_exp[j] = A1B1_avgE + A1B2_avgE + A2B1_avgE - A2B2_avgE
matplotlib.rcParams.update({'font.size':12})
plt.figure(figsize = (6,4), dpi = 100)
plt.plot(th, y, label = 'LHV limit')
plt.plot(th, Oavg, label = r'$\langle O\rangle_{\Psi}^{teo}$')
plt.plot(th, Oavg_sim, '*', label = r'$\langle O\rangle_{\Psi}^{sim}$')
plt.plot(th, Oavg_exp, 'o', label = r'$\langle O\rangle_{\Psi}^{exp}$')
plt.xlabel(r'$\theta$'); plt.legend(); plt.show()
def chsh(rho):
cm = zeros(3,3); cm = corr_mat(2, 2, rho)
evals = zeros(3,1); W = zeros(3,1); W = eVals(3, cm)
return max(0,(sqrt(W[0]**2+W[1]**2+W[2]**2-min(W[0],W[1],W[2])**2)-1)/(sqrt(2)-1))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit, IBMQ, Aer
def qc_ezz(t):
qc = QuantumCircuit(2, name = 'e^(-itZZ)')
qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1)
return qc
def qc_exx(t):
qc = QuantumCircuit(2, name = 'e^(-itXX)')
qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1])
return qc
def qc_eyy(t):
qc = QuantumCircuit(2, name = 'e^(-itYY)')
qc.sdg([0,1]); qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1]); qc.s([0,1])
return qc
def qc_Bj(t):
qc = QuantumCircuit(3, name = 'B_j')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
return qc
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
#provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibmq_jakarta')
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.tools.monitor import backend_overview, backend_monitor
def qc_psi0():
qc = QuantumCircuit(3, name = 'psi0')
qc.x([0,1])
return qc
import numpy as np
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
psi0_ = np.kron(ket1, np.kron(ket1, ket0));
psi0__ = np.kron(ket0, np.kron(ket1, ket1)) # para calcular a fidelidade com o estado da tomografia
psi0_.T, psi0__.T
import scipy
I = np.array([[1,0],[0,1]]); X = np.array([[0,1],[1,0]]);
Y = np.array([[0,-1j],[1j,0]]); Z = np.array([[1,0],[0,-1]])
H2 = np.kron(X, X) + np.kron(Y, Y) + np.kron(Z, Z)
def UHxxx12_num(t):
H = np.kron(H2, I)
return scipy.linalg.expm(-1j*t*H)
def UHxxx23_num(t):
H = np.kron(I, H2)
return scipy.linalg.expm(-1j*t*H)
#U = UHxxx23_num(math.pi); print(U.shape[0])
from qiskit import quantum_info, execute
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 import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute, IBMQ
qr = QuantumRegister(7)
qubit_list = [5, 3, 1] # os qubits para os quais aplicaremos calibracao de medidas
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job = execute(meas_calibs, backend = device, shots = nshots)
job_monitor(job)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
t = math.pi
for j in range(0, 8): # muda o No. de passos de Trotter
# teórico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(7)
qc.x([5, 3]) # initial state
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.append(qc_Bj_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulação
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim = quantum_info.state_fidelity(psi0__, rho_sim)
# experimento
job_exp = execute(qstc, backend = device, shots = nshots)
job_monitor(job_exp)
mitigated_results = meas_fitter.filter.apply(job_exp.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp = quantum_info.state_fidelity(psi0__, rho_exp)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
nshots = 500;
Npt = 7 # Número de passos de Trotter
ph = 2*math.pi # ângulo para a transformação de simetria
t = math.pi
for j in range(0, Npt): # muda o No. de passos de Trotter
# teórico
U12 = UHxxx12_num(t/(j+1)); U23 = UHxxx23_num(t/(j+1))
B = np.dot(U12, U23); U = np.linalg.matrix_power(B, j+1); psit = np.dot(U, psi0_)
F_teo = qiskit.quantum_info.state_fidelity(psi0_, psit)
# circuit q
qc = QuantumCircuit(3)
qc_psi0_ = qc_psi0(); qc.append(qc_psi0_, [0, 1, 2]) # estado inicial
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.rz(ph/(j+1), [0, 1, 2]) # transformação de simetria
qc.append(qc_Bj_, [0, 1, 2])
qc.rz(-ph, [0, 1, 2]) # revertendo a transformação de simetria
if j == 1:
qc.draw(output = 'mpl')
qstc = state_tomography_circuits(qc, [0, 1, 2])
# simulação
job = qiskit.execute(qstc, backend = simulator, shots = nshots)
qstf = StateTomographyFitter(job.result(), qstc)
rho = qstf.fit(method = 'lstsq')
F_sim = qiskit.quantum_info.state_fidelity(psi0__, rho)
# experimento
jobE = qiskit.execute(qstc, backend = device, shots = nshots)
print(jobE.job_id()); job_monitor(jobE)
qstfE = StateTomographyFitter(jobE.result(), qstc)
rhoE = qstfE.fit(method = 'lstsq')
F_exp = qiskit.quantum_info.state_fidelity(psi0__, rhoE)
print('No. passos=', j+1, ',F_teo=', F_teo, ',F_sim=', F_sim, ',F_exp=', F_exp)
qc.draw(output = 'mpl')
|
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
N = 2**10; th = asin(1/sqrt(N)); N, float(th), float(sin(th)), float(th*180/pi), sqrt(N)
my_list = [1,3,5,2,4,9,5,8,0,7,6]
def my_oracle(my_input):
solution = 2
if my_input == solution:
response = True
else:
response = False
return response
my_input = 7; res = my_oracle(my_input); print(res)
for j in range(0,len(my_list)):
if my_oracle(my_list[j]) == True:
print('Solução encontrada no índice',j, ', após ', j+1, ' consultas ao oráculo.')
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
def qc_Uz(n): # 2|0><0| - I
qc = QuantumCircuit(n, name = 'Uz')
qrl = []
for j in range(0, n):
qrl.append(j)
qc.z(0); qc.x(0); qc.z(0); qc.x(0)
qc.x(qrl) # 00...0 -> 11...1
qc.h(n-1); qc.mcx(qrl[0:n-1],n-1); qc.h(n-1) # Cz multicontrolada. Multiplica 11...1 por -1
qc.x(qrl); # 11...1 -> 00...0
return qc
qc_Uz_ = qc_Uz(3); qc_Uz_.draw()
def qc_Uh(n): # 2|h><h| - I
qc = QuantumCircuit(n, name = 'Uh')
qrl = []
for j in range(0, n):
qrl.append(j)
qc.h(qrl) # transforma Uz em Uh
qc_Uz_ = qc_Uz(n); qc.append(qc_Uz_, qrl)
qc.h(qrl)
return qc
qc_Uh_ = qc_Uh(3); qc_Uh_.draw()
def qc_oracle(n):
# Nielsen & Chuang, Box 6.1 (N=4)
qc = QuantumCircuit(n+1, name = 'Oracle')
qc.ccx(0,1,2) # para a solução sendo o estado |11>
return qc
qc_oracle_ = qc_oracle(2)
qc_oracle_.draw('mpl')
def qc_grover_iteration(n):
qc = QuantumCircuit(n+1, name = 'G')
qrl = []
for j in range(0, n+1):
qrl.append(j)
qc_oracle_ = qc_oracle(n)
qc.append(qc_oracle_, qrl)
qc_Uh_ = qc_Uh(n); qc.append(qc_Uh_, qrl[0:n])
return qc
qc_grover_iteration_ = qc_grover_iteration(2)
qc_grover_iteration_.draw('mpl')
def qc_hadamard_state(n): # aplica a Hadamard em n qubits
qc = QuantumCircuit(n, name = 'H state') # começarei a não usar mais os qr[j]
qrl = [] # lista de registros quânticos
for j in range(0, n):
qrl.append(j)
qc.h(qrl) # aplica a hadamard em toda a lista de registros quânticos
return qc
qc_hadamard_state_ = qc_hadamard_state(3); qc_hadamard_state_.draw()
def qc_grover_search(n):
qc = QuantumCircuit(n+1, n)
qc.x(n)
qrl = [] # lista de registros quânticos
for j in range(0, n+1):
qrl.append(j)
qc_hadamard_state_ = qc_hadamard_state(n+1); qc.append(qc_hadamard_state_, qrl)
for j in range(0, int((math.pi*math.sqrt(2**n))/4 - 1/2)):
qc_grover_iteration_ = qc_grover_iteration(n); qc.append(qc_grover_iteration_, qrl)
qc.measure(qrl[0:n], qrl[0:n])
return qc
qc_grover_search_ = qc_grover_search(2); qc_grover_search_.draw()
qc_grover_search_ = qc_grover_search(2)
result = execute(qc_grover_search_, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc_grover_search_))
job = execute(qc_grover_search_, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc_grover_search_))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
simplify(cos(pi/8)), simplify(sin(pi/8))
from qiskit.visualization import plot_bloch_vector
th, ph = pi/4, 0
#plot_bloch_vector([[math.sin(th)*math.cos(ph), math.sin(th)*math.sin(ph), math.cos(th)]])
float(1+1/sqrt(2))/2
X = Matrix([[0,1],[1,0]]); Z = Matrix([[1,0],[0,-1]]); O = (X+Z)/sqrt(2); O.eigenvects()
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_belem')
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
qc = QuantumCircuit(1, 1)
qc.h(0) # preparação do estado
qc.barrier()
# medida de O=H
th = math.pi/4; ph = 0; lb = math.pi - ph; qc.u(th, ph, lb, 0)
qc.measure(0, 0)
qc.draw()
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
def qc_bb_cb():
qc = QuantumCircuit(2, name = 'BB->CB')
qc.cx(0,1); qc.h(0)#; qc.measure([0,1],[0,1])
return qc
qc_bb_cb_ = qc_bb_cb(); qc_bb_cb_.draw()
qc = QuantumCircuit(2, 2)
qc.x(1); qc.h([0,1]) # preparação do estado |+->
qc.barrier()
qc_bb_cb_ = qc_bb_cb(); qc.append(qc_bb_cb_, [0,1]); qc.measure([0,1],[0,1])
qc.draw()
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import qiskit
from qiskit import *
import math
import numpy as np
def qc_ezz(t):
qc = QuantumCircuit(2, name = 'e^(-itZZ)')
qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1)
return qc
def qc_exx(t):
qc = QuantumCircuit(2, name = 'e^(-itXX)')
qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1])
return qc
def qc_eyy(t):
qc = QuantumCircuit(2, name = 'e^(-itYY)')
qc.sdg([0,1]); qc.h([0,1]); qc.cx(0, 1); qc.rz(2*t, 1); qc.cx(0, 1); qc.h([0,1]); qc.s([0,1])
return qc
def qc_Bj(t):
qc = QuantumCircuit(3, name = 'B_j')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
return qc
qc_Bj_ = qc_Bj(math.pi/2); qc_Bj_.draw(output='mpl')
qc_Bj_.decompose().draw(output='mpl')
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
#provider = qiskit.IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibmq_jakarta')
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.tools.monitor import backend_overview, backend_monitor
from qiskit.providers.aer import noise
from qiskit.providers.aer.noise import NoiseModel
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
coupling_map = device.configuration().coupling_map
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]);
psi0 = np.kron(ket0, np.kron(ket1, ket1)) # initial state to be used for computing the fidelity
t = math.pi
for j in range(0, 10): # Trotter stepsm_info.
# quantum circuit
qc = QuantumCircuit(7)
qc.x([5, 3]) # prepares the initial state
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.append(qc_Bj_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulation
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim = quantum_info.state_fidelity(psi0, rho_sim)
# simulation with simulated noise
job_exp = execute(qstc, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
qstf_exp = StateTomographyFitter(job_exp.result(), qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp = quantum_info.state_fidelity(psi0, rho_exp)
print('No. passos=', j+1, ',F_sim=', F_sim, ',F_exp=', F_exp)
inha visto essa reprovação mas não me dei por conta que n# for error mitigation
qr = QuantumRegister(7)
qubit_list = [5,3,1] # the qubits on which we shall apply error mitigation
meas_calibs, state_labels = complete_meas_cal(qubit_list = qubit_list, qr = qr)
job_cal = execute(meas_calibs, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
meas_fitter = CompleteMeasFitter(job_cal.result(), state_labels)
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
psi0 = np.kron(ket0, np.kron(ket1, ket1)) # initial state to be used for computing the fidelity
t = math.pi
for j in range(0, 10): # Trotter steps
# quantum circuit
qc = QuantumCircuit(7)
qc.x([5, 3]) # prepares the initial state
qc_Bj_ = qc_Bj(t/(j+1))
for k in range(0, j+1):
qc.append(qc_Bj_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulation
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim = quantum_info.state_fidelity(psi0, rho_sim)
# simulation with simulated noise and error mitigation
job_exp = execute(qstc, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
mitigated_results = meas_fitter.filter.apply(job_exp.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp = quantum_info.state_fidelity(psi0, rho_exp)
print('No. passos=', j+1, ',F_sim=', F_sim, ',F_exp=', F_exp)
def qc_Bj_zz(t, th, ph):
qc = QuantumCircuit(3, name = 'B_j_zz')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.rz(2*th, [1,2])
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.rz(-2*th, [1,2])
qc.rz(2*ph, [0,1])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
qc.rz(-2*ph, [0,1])
return qc
qc_Bj_zz_ = qc_Bj_zz(math.pi, math.pi/3, math.pi/4); qc_Bj_zz_.draw(output='mpl')
ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
psi0 = np.kron(ket0, np.kron(ket1, ket1)) # initial state to be used for computing the fidelity
t = math.pi
j = 6; print('N. of Trotter steps = ', j+1)
th_max = 2*math.pi; dth = th_max/16; th = np.arange(0, th_max+dth, dth); dim_th = th.shape[0]
ph_max = 2*math.pi; dph = ph_max/16; ph = np.arange(0, ph_max+dph, dph); dim_ph = ph.shape[0]
for m in range(0, dim_th):
for n in range(0, dim_ph):
# quantum circuit
qc = QuantumCircuit(7)
qc.x([5, 3]) # prepares the initial state
qc_Bj_zz_ = qc_Bj_zz(t/(j+1), th[m], ph[n])
for k in range(0, j+1):
qc.append(qc_Bj_zz_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulation
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim = quantum_info.state_fidelity(psi0, rho_sim)
# simulation with simulated noise and error mitigation
job_exp = execute(qstc, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
mitigated_results = meas_fitter.filter.apply(job_exp.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp = quantum_info.state_fidelity(psi0, rho_exp)
print('th=', th[m], ', ph=', ph[n], ', F_sim=', F_sim, ', F_exp=', F_exp)
def qc_Bj_zx(t, th, ph):
qc = QuantumCircuit(3, name = 'B_j_zz')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.rx(2*th, [1,2])
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.rx(-2*th, [1,2])
qc.rz(2*ph, [0,1])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
qc.rz(-2*ph, [0,1])
return qc
qc_Bj_zx_ = qc_Bj_zx(math.pi, math.pi/3, math.pi/4); qc_Bj_zx_.draw(output='mpl')
inha visto essa reprovação mas não me dei por conta que nket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
psi0 = np.kron(ket0, np.kron(ket1, ket1)) # initial state to be used for computing the fidelity
t = math.pi
j = 6; print('N. of Trotter steps = ', j+1)
th_max = 2*math.pi; dth = th_max/16; th = np.arange(0, th_max+dth, dth); dim_th = th.shape[0]
ph_max = 2*math.pi; dph = ph_max/16; ph = np.arange(0, ph_max+dph, dph); dim_ph = ph.shape[0]
for m in range(0, dim_th):
for n in range(0, dim_ph):
# quantum circuit
qc = QuantumCircuit(7)
qc.x([5, 3]) # prepares the initial state
qc_Bj_zx_ = qc_Bj_zx(t/(j+1), th[m], ph[n])
for k in range(0, j+1):
qc.append(qc_Bj_zx_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulation
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim = quantum_info.state_fidelity(psi0, rho_sim)
# simulation with simulated noise and error mitigation
job_exp = execute(qstc, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
mitigated_results = meas_fitter.filter.apply(job_exp.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp = quantum_info.state_fidelity(psi0, rho_exp)
print('th=', th[m], ', ph=', ph[n], ', F_sim=', F_sim, ', F_exp=', F_exp)
def qc_Bj_yx(t, th, ph):
qc = QuantumCircuit(3, name = 'B_j_zz')
qc_ezz_ = qc_ezz(t); qc_eyy_ = qc_eyy(t); qc_exx_ = qc_exx(t)
qc.rx(2*th, [1,2])
qc.append(qc_ezz_, [1, 2]); qc.append(qc_eyy_, [1, 2]); qc.append(qc_exx_, [1, 2])
qc.rx(-2*th, [1,2])
qc.barrier()
qc.ry(2*ph, [0,1])
qc.append(qc_ezz_, [0, 1]); qc.append(qc_eyy_, [0, 1]); qc.append(qc_exx_, [0, 1])
qc.ry(-2*ph, [0,1])
return qc
qc_Bj_yx_ = qc_Bj_yx(math.pi, math.pi/3, math.pi/4); qc_Bj_yx_.draw(output='mpl')
https://arxiv.org/abs/2204.07816ket0 = np.array([[1],[0]]); ket1 = np.array([[0],[1]]); #ket0, ket1
psi0 = np.kron(ket0, np.kron(ket1, ket1)) # initial state to be used for computing the fidelity
t = math.pi
j = 6; print('N. of Trotter steps = ', j+1)
th_max = 2*math.pi; dth = th_max/16; th = np.arange(0, th_max+dth, dth); dim_th = th.shape[0]
ph_max = 2*math.pi; dph = ph_max/16; ph = np.arange(0, ph_max+dph, dph); dim_ph = ph.shape[0]
for m in range(0, dim_th):
for n in range(0, dim_ph):
# quantum circuit
qc = QuantumCircuit(7)
qc.x([5, 3]) # prepares the initial state
qc_Bj_yx_ = qc_Bj_yx(t/(j+1), th[m], ph[n])
for k in range(0, j+1):
qc.append(qc_Bj_yx_, [5, 3, 1])
qstc = state_tomography_circuits(qc, [5, 3, 1])
# simulation
job_sim = execute(qstc, backend = simulator, shots = nshots)
qstf_sim = StateTomographyFitter(job_sim.result(), qstc)
rho_sim = qstf_sim.fit(method = 'lstsq')
F_sim = quantum_info.state_fidelity(psi0, rho_sim)
# simulation with simulated noise and error mitigation0.34
job_exp = execute(qstc, backend = simulator, shots = nshots, noise_model = noise_model,
basis_gates = basis_gates, coupling_map = coupling_map)
mitigated_results = meas_fitter.filter.apply(job_exp.result())
qstf_exp = StateTomographyFitter(mitigated_results, qstc)
rho_exp = qstf_exp.fit(method = 'lstsq')
F_exp = quantum_info.state_fidelity(psi0, rho_exp)
print('th=', th[m], ', ph=', ph[n], ', F_sim=', F_sim, ', F_exp=', F_exp)
noise_model = NoiseModel.from_backend(device)
basis_gates = noise_model.basis_gates
coupling_map = device.configuration().coupling_map
basis_gates
print(coupling_map)
553/3
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
import numpy as np
import matplotlib
from matplotlib import pyplot as plt
import math
th = np.arange(0, 2*math.pi, 0.1)
prE3 = 2*(1-(math.sqrt(2)*(np.sin(th/2)**2))/(1+math.sqrt(2)))
matplotlib.rcParams.update({'font.size':10})
plt.figure(figsize = (5,3), dpi = 100)
plt.plot(th, prE3)
plt.xlabel(r'$\theta$')
plt.ylabel(r'$Pr(E_{3})$')
plt.show()
|
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
cos(pi/8), sin(pi/8)
U = (1/sqrt(2))*Matrix([[1,1],[1,-1]]); V1 = Matrix([[1,0],[0,1]]); V2 = V1
D1 = Matrix([[cos(pi/8),0],[0,cos(pi/8)]]); D2 = Matrix([[sin(pi/8),0],[0,sin(pi/8)]])
U, U*U.T, D1, D2
M1 = V1*D1*U; M2 = V2*D2*U; M1, M2
M1*M1, M2*M2, M1*M1 + M2*M2 # não são projetores, mas são operadores de medida
2*float((1/4)*(1+1/sqrt(2))), 2*float((1/4)*(1-1/sqrt(2)))
qr = QuantumRegister(2); cr = ClassicalRegister(1); qc = QuantumCircuit(qr, cr)
qc.h(qr[0]); qc.x(qr[0]); qc.cry(math.pi/4, 0, 1); qc.x(qr[0]); qc.cry(math.pi/4, 0, 1)
# V1=V2=I
qc.measure(1,0)
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'])
def U(xi, et, ga):
return Matrix([[(cos(xi)+1j*sin(xi))*cos(ga), (cos(et)+1j*sin(et))*sin(ga)],
[-(cos(et)-1j*sin(et))*sin(ga), (cos(xi)-1j*sin(xi))*cos(ga)]])
xi, et, ga = symbols('xi eta gamma'); U(xi, et, ga)
def D1(th, ph):
return Matrix([[cos(th/2),0],[0,cos(ph/2)]])
def D2(th, ph):
return Matrix([[sin(th/2),0],[0,sin(ph/2)]])
th,ph = symbols('theta phi'); D1(th, ph), D2(th, ph)
xi1,et1,ga1,xi2,et2,ga2,xi3,et3,ga3 = symbols('xi_1 eta_1 gamma_1 xi_2 eta_2 gamma_2 xi_3 eta_3 gamma_3')
simplify(U(xi1,et1,ga1)*D1(th,ph)*U(xi2,et2,ga2) - (1/2)*sqrt(1+1/sqrt(2))*Matrix([[1,1],[1,-1]]))
simplify(U(xi3,et3,ga3)*D2(th,ph)*U(xi2,et2,ga2) - (1/2)*sqrt(1+1/sqrt(2))*Matrix([[1,1],[1,-1]]))
cos(pi/3), sin(pi/3), cos(2*pi/3), sin(2*pi/3)
M1 = sqrt(2/3)*Matrix([[1,0],[0,0]])
M2 = (1/(4*sqrt(6)))*Matrix([[1,sqrt(3)],[sqrt(3),3]])
M3 = (1/(4*sqrt(6)))*Matrix([[1,-sqrt(3)],[-sqrt(3),3]])
M1,M2,M3
M1.T*M1 + M2.T*M2 + M3.T*M3
M1 = sqrt(2/3.)*Matrix([[1,0],[0,0]]); M2 = sqrt(2/3.)*(1/4)*Matrix([[1,sqrt(3.)],[sqrt(3.),3]])
M3 = sqrt(2/3.)*(1/4)*Matrix([[1,-sqrt(3.)],[-sqrt(3.),3]])
M1, M2, M3
M1.T*M1 + M2.T*M2 + M3.T*M3
2/3, 1/6, 2/3+2*(1/6)
#th1 = acos(sqrt(2/3)); ph1 = pi; th2 = pi/2; ph2 = pi/2
D11 = Matrix([[sqrt(2/3),0],[0,0]])
D21 = Matrix([[sqrt(1/3),0],[0,1]])
D12 = Matrix([[1/sqrt(2),0],[0,1/sqrt(2)]])
D22 = Matrix([[1/sqrt(2),0],[0,1/sqrt(2)]])
U = Matrix([[1,0],[0,1]])
V11 = Matrix([[1,0],[0,1]])
V21 = (1/sqrt(2))*Matrix([[1,1],[-1,1]])
V12 = (1/2)*Matrix([[1,-sqrt(3)],[sqrt(3),1]])
V22 = -(1/2)*Matrix([[sqrt(3),-1],[1,sqrt(3)]])
M1 = V11*D11*U
np.array(M1).astype(np.float64), np.array(Matrix([[sqrt(2/3),0],[0,0]])).astype(np.float64)
M2 = V12*D12*V21*D21*U
np.array(M2).astype(np.float64), np.array((1/4)*sqrt(2/3)*Matrix([[1,sqrt(3)],[sqrt(3),3]])).astype(np.float64)
# não é o resultado que precisamos
M3 = V22*D22*V21*D21*U
np.array(M3).astype(np.float64), np.array((1/4)*sqrt(2/3)*Matrix([[1,-sqrt(3)],[-sqrt(3),3]])).astype(np.float64)
# não é o resultado que precisamos
np.array(M1.T*M1 + M2.T*M2 + M3.T*M3).astype(np.float64) # esta ok a relacao de completeza
cos(pi/3), sin(pi/3), cos(pi/6)
def qc_ry(th):
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name = 'RY')
qc.ry(th, 0)
return qc
def qc_u(th,ph,lb):
qr = QuantumRegister(1); qc = QuantumCircuit(qr, name = 'U')
qc.u(th,ph,lb, 0)
return qc
qr = QuantumRegister(3); cr = ClassicalRegister(2); qc = QuantumCircuit(qr, cr)
# U = I
qc.x(qr[0]); qc.cry(math.acos(math.sqrt(2/3)), 0, 1); qc.x(qr[0]); qc.cry(math.pi/2, 0, 1)
# V11 = I
qc.cu(math.pi/2,math.pi,math.pi,0, 1,0)
qc.barrier()
qc_ry_ = qc_ry(0); ccry = qc_ry_.to_gate().control(2) # cria a ctrl-ctrl-RY
qc.x(0); qc.append(ccry, [0,1,2]); qc.x(0)
qc_ry_ = qc_ry(math.pi/2); ccry = qc_ry_.to_gate().control(2)
qc.append(ccry, [0,1,2]) # os primeiros sao o controle, os ultimos sao o target
qc.x(2)
qc_u_ = qc_u(2*math.pi/3,0,0); ccu = qc_u_.to_gate().control(2)
qc.append(ccu, [1,2,0])
qc.x(2)
qc_u_ = qc_u(4*math.pi/3,0,0); ccu = qc_u_.to_gate().control(2)
qc.append(ccu, [1,2,0])
qc.barrier()
qc.measure(1,0); qc.measure(2,1)
qc.draw(output = 'mpl')
qc.decompose().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'])
# sequencia: 000 001 010 011 100 101 110 111 = 0 1 2 3 4 5 6 7
Phi_ACD = [math.sqrt(2/3), (1/4)*math.sqrt(2/3), (1/4)*math.sqrt(2/3), 0,
0, (1/4)*math.sqrt(2), -(1/4)*math.sqrt(2), 0]
qr = QuantumRegister(3); cr = ClassicalRegister(2); qc = QuantumCircuit(qr,cr)
qc.initialize(Phi_ACD, [qr[2],qr[1],qr[0]])
qc.draw(output='mpl')
backend = BasicAer.get_backend('statevector_simulator')
job = backend.run(transpile(qc, backend))
qc_state = job.result().get_statevector(qc)
qc_state
sqrt(2/3), 0.25*sqrt(2/3), 0.25*sqrt(2.)
state_fidelity(Phi_ACD,qc_state)
qc.measure([1,2],[0,1])
qc.draw(output='mpl')
job_sim = execute(qc, backend = simulator, shots = nshots)
job_exp = execute(qc, backend = device, shots = nshots)
job_monitor(job_exp)
# tava dando errado o resultado. Me parece que na inicializacao a ordem dos qubits foi trocada
plot_histogram([job_sim.result().get_counts(), job_exp.result().get_counts()],
legend = ['sim', 'exp'])
# sequencia: 000 001 010 011 100 101 110 111 = 0 1 2 3 4 5 6 7
Phi_ACD = [1/math.sqrt(2), 1/(2*math.sqrt(2)), 0, 1/(2*math.sqrt(2)),
0, 1/(2*math.sqrt(2)), 0, -1/(2*math.sqrt(2))]
qr = QuantumRegister(3); cr = ClassicalRegister(2); qc = QuantumCircuit(qr,cr)
qc.initialize(Phi_ACD, [qr[2],qr[1],qr[0]])
qc.measure([1,2],[0,1])
qc.draw(output='mpl')
qc.decompose().decompose().decompose().decompose().decompose().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'])
qr = QuantumRegister(4); cr = ClassicalRegister(3); qc = QuantumCircuit(qr, cr)
# U = I
qc.x(qr[0]); qc.cry(math.acos(math.sqrt(2/3)), 0, 1); qc.x(qr[0]); qc.cry(math.pi/2, 0, 1)
# V11 = I
qc.cu(math.pi/2,math.pi,math.pi,0, 1,0)
qc.barrier()
qc_ry_ = qc_ry(0); ccry = qc_ry_.to_gate().control(2) # cria a ctrl-ctrl-RY
qc.x(0); qc.append(ccry, [0,1,2]); qc.x(0)
qc_ry_ = qc_ry(math.pi/2); ccry = qc_ry_.to_gate().control(2)
qc.append(ccry, [0,1,2]) # os primeiros sao o controle, os ultimos sao o target
qc.x(2)
qc_u_ = qc_u(2*math.pi/3,0,0); ccu = qc_u_.to_gate().control(2)
qc.append(ccu, [1,2,0])
qc.x(2)
qc_u_ = qc_u(4*math.pi/3,0,0); ccu = qc_u_.to_gate().control(2)
qc.append(ccu, [1,2,0])
qc.barrier()
qc_ry_ = qc_ry(math.pi); cccry = qc_ry_.to_gate().control(3) # cria a ctrl-ctrl-ctrl-RY
qc.x(0); qc.append(cccry, [0,1,2,3]); qc.x(0)
qc_ry_ = qc_ry(math.pi/2); cccry = qc_ry_.to_gate().control(3)
qc.append(cccry, [0,1,2,3])
qc_u_ = qc_u(math.pi,0,0); cccu = qc_u_.to_gate().control(3)
qc.x(3); qc.append(cccu, [3,2,1,0]); qc.x(3)
qc.append(cccu, [3,2,1,0])
qc_u_ = qc_u(math.pi/3,0,0); cccu = qc_u_.to_gate().control(3)
qc.barrier()
qc.measure(1,0); qc.measure(2,1); qc.measure(3,2)
qc.draw(output = 'mpl')
qc.decompose().draw(output = 'mpl')
%run init.ipynb
# 2 element 1-qubit povm (Yordanov)
M1 = (1/2)*Matrix([[1,0],[0,sqrt(3)]]); M2 = M1
M1, M2
M1.T*M1 + M2.T*M2
# 3 element 1-qubit povm (Yordanov)
M1 = sqrt(2/3)*Matrix([[1,0],[0,0]])
M2 = (1/(4*sqrt(6)))*Matrix([[1,sqrt(3)],[sqrt(3),1]])
M3 = (1/(4*sqrt(6)))*Matrix([[1,-sqrt(3)],[-sqrt(3),1]])
M1,M2,M3
M1.T*M1 + M2.T*M2 + M3.T*M3
# 2-element 1-qubit POVM (Douglas)
M1 = (1/(2*sqrt(2)))*Matrix([[1,0],[sqrt(3),2]])
M2 = (1/(2*sqrt(2)))*Matrix([[1,0],[-sqrt(3),2]])
M1,M2
M1.T*M1 + M2.T*M2
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
%run init.ipynb
p = symbols('p')
Ubf = Matrix([[sqrt(1-p),-sqrt(p),0,0],[0,0,sqrt(p),sqrt(1-p)],[0,0,sqrt(1-p),-sqrt(p)],[sqrt(p),sqrt(1-p),0,0]])
Ubf
Ubf*Ubf.T, Ubf.T*Ubf
g = symbols('gamma')
Uad = Matrix([[sqrt(1-g),0,0,sqrt(g)],[0,1,0,0],[0,0,1,0],[-sqrt(g),0,0,sqrt(1-g)]])
Uad, Uad*Uad.T, Uad.T*Uad
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import *
nshots = 8192
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
simulator = Aer.get_backend('qasm_simulator')
device = provider.get_backend('ibmq_bogota')
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
def qc_ent_dist():
qc = QuantumCircuit(2, name = 'E dist')
qc.h([1]); qc.cx(1, 0)
return qc
qc_ent_dist_ = qc_ent_dist()
qc_ent_dist_.draw(output = 'mpl')
def qc_encoding(cbits):
qc = QuantumCircuit(1, name = 'codificação')
if cbits == '00':
qc.id([0])
elif cbits == '01':
qc.z([0])
elif cbits == '10':
qc.x([0])
elif cbits == '11':
qc.x([0]); qc.z([0])
return qc
qc_encoding_ = qc_encoding('11')
qc_encoding_.draw(output = 'mpl')
def qc_decoding():
qc = QuantumCircuit(2, name = 'decodificação')
qc.cx(1, 0); qc.h([1])
return qc
qc_decoding_ = qc_decoding(); qc_decoding_.draw(output = 'mpl')
cbits = '00'
qc = QuantumCircuit(2, 2)
qc_ent_dist_ = qc_ent_dist(); qc.append(qc_ent_dist_, [0,1])
qc.barrier()
qc_encoding_ = qc_encoding(cbits); qc.append(qc_encoding_, [0])
qc.barrier()
qc_decoding_ = qc_decoding(); qc.append(qc_decoding_, [0,1])
qc.measure([0,1],[0,1])
#qc.draw(output = 'mpl')
qc.decompose().draw(output = 'mpl')
result = execute(qc, backend = simulator, shots = nshots).result()
plot_histogram(result.get_counts(qc))
job = execute(qc, backend = device, shots = nshots)
job_monitor(job)
plot_histogram(job.result().get_counts(qc))
|
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_bogota')
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)
c0 = ClassicalRegister(1); c1 = ClassicalRegister(1)
qc = QuantumCircuit(q0,q1,c0,c1)
qc.h(q0); qc.cx(q0,q1) # emaranhamento compartilhado entre Alice e Bob
qc.barrier()
qc.x(q0); qc.sdg(q0); qc.h(q0); qc.measure(q0,c0) # Medida de Alice
qc.barrier()
qc.z(q1).c_if(c0, 1) # acao de Bob condicionada no cbit enviado por Alice
qc.barrier()
qc.sdg(q1); qc.h(q1); qc.measure(q1,c1) # passa da base circular pra computacional
qc.draw(output='mpl')
jobS = execute(qc, backend = simulator, shots = nshots)
plot_histogram(jobS.result().get_counts(qc))
|
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'])
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.