repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/Simultonian/hamilutor-qiskit
|
Simultonian
|
from qiskit import QuantumCircuit
from ..utils import circuit_eq
from .simple import qdrift
from ..trotter.simple import trotter
import numpy as np
import pytest
hamiltonians = [
{"xx": 1.0, "iy": 1.0},
{"xi": 1.0},
]
order_list = [
["iy", "iy", "iy", "iy", "xx", "iy", "xx", "iy"],
["xi", "xi"],
]
@pytest.mark.parametrize("h,order", zip(hamiltonians, order_list))
def test_qdrift(h, order):
# Setting random seed for testing
np.random.seed(0)
result = qdrift(h, 1.0)
num_qubits = len(list(h.keys())[0])
lambd = sum(list(h.values()))
N = 2 * (lambd**2)
factor = lambd / N
# It is equivalent of constructing individual term exponentiated and then
# concatanating them.
expected = QuantumCircuit(num_qubits)
for term in order:
cur = trotter({term: factor / h[term]})
expected = expected.compose(cur)
assert circuit_eq(expected, result)
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.wrapper import available_backends, get_backend
from qiskit.wrapper import execute as q_execute
q = QuantumRegister(2, name='q')
c = ClassicalRegister(2, name='c')
qc = QuantumCircuit(q,c)
qc.h(q[0])
qc.h(q[1])
qc.cx(q[0], q[1])
qc.measure(q, c)
z = 0.995004165 + 1j * 0.099833417
z = z / abs(z)
u_error = np.array([[1, 0], [0, z]])
noise_params = {'U':
{'gate_time': 1,
'p_depol': 0.001,
'p_pauli': [0, 0, 0.01],
'U_error': u_error
}
}
config = {"noise_params": noise_params}
ret = q_execute(qc, 'local_qasm_simulator_cpp', shots=1024, config=config)
ret = ret.result()
print(ret.get_counts())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub="ibm-q", group="open", project="main")
program_id = "qaoa"
qaoa_program = provider.runtime.program(program_id)
print(f"Program name: {qaoa_program.name}, Program id: {qaoa_program.program_id}")
print(qaoa_program.parameters())
import numpy as np
from qiskit.tools import job_monitor
from qiskit.opflow import PauliSumOp, Z, I
from qiskit.algorithms.optimizers import SPSA
# Define the cost operator to run.
op = (
(Z ^ Z ^ I ^ I ^ I)
- (I ^ I ^ Z ^ Z ^ I)
+ (I ^ I ^ Z ^ I ^ Z)
- (Z ^ I ^ Z ^ I ^ I)
- (I ^ Z ^ Z ^ I ^ I)
+ (I ^ Z ^ I ^ Z ^ I)
+ (I ^ I ^ I ^ Z ^ Z)
)
# SPSA helps deal with noisy environments.
optimizer = SPSA(maxiter=100)
# We will run a depth two QAOA.
reps = 2
# The initial point for the optimization, chosen at random.
initial_point = np.random.random(2 * reps)
# The backend that will run the programm.
options = {"backend_name": "ibmq_qasm_simulator"}
# The inputs of the program as described above.
runtime_inputs = {
"operator": op,
"reps": reps,
"optimizer": optimizer,
"initial_point": initial_point,
"shots": 2**13,
# Set to True when running on real backends to reduce circuit
# depth by leveraging swap strategies. If False the
# given optimization_level (default is 1) will be used.
"use_swap_strategies": False,
# Set to True when optimizing sparse problems.
"use_initial_mapping": False,
# Set to true when using echoed-cross-resonance hardware.
"use_pulse_efficient": False,
}
job = provider.runtime.run(
program_id=program_id,
options=options,
inputs=runtime_inputs,
)
job_monitor(job)
print(f"Job id: {job.job_id()}")
print(f"Job status: {job.status()}")
result = job.result()
from collections import defaultdict
def op_adj_mat(op: PauliSumOp) -> np.array:
"""Extract the adjacency matrix from the op."""
adj_mat = np.zeros((op.num_qubits, op.num_qubits))
for pauli, coeff in op.primitive.to_list():
idx = tuple([i for i, c in enumerate(pauli[::-1]) if c == "Z"]) # index of Z
adj_mat[idx[0], idx[1]], adj_mat[idx[1], idx[0]] = np.real(coeff), np.real(coeff)
return adj_mat
def get_cost(bit_str: str, adj_mat: np.array) -> float:
"""Return the cut value of the bit string."""
n, x = len(bit_str), [int(bit) for bit in bit_str[::-1]]
cost = 0
for i in range(n):
for j in range(n):
cost += adj_mat[i, j] * x[i] * (1 - x[j])
return cost
def get_cut_distribution(result) -> dict:
"""Extract the cut distribution from the result.
Returns:
A dict of cut value: probability.
"""
adj_mat = op_adj_mat(PauliSumOp.from_list(result["inputs"]["operator"]))
state_results = []
for bit_str, amp in result["eigenstate"].items():
state_results.append((bit_str, get_cost(bit_str, adj_mat), amp**2 * 100))
vals = defaultdict(int)
for res in state_results:
vals[res[1]] += res[2]
return dict(vals)
import matplotlib.pyplot as plt
cut_vals = get_cut_distribution(result)
fig, axs = plt.subplots(1, 2, figsize=(14, 5))
axs[0].plot(result["optimizer_history"]["energy"])
axs[1].bar(list(cut_vals.keys()), list(cut_vals.values()))
axs[0].set_xlabel("Energy evaluation number")
axs[0].set_ylabel("Energy")
axs[1].set_xlabel("Cut value")
axs[1].set_ylabel("Probability")
from qiskit_optimization.runtime import QAOAClient
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization import QuadraticProgram
qubo = QuadraticProgram()
qubo.binary_var("x")
qubo.binary_var("y")
qubo.binary_var("z")
qubo.minimize(linear=[1, -2, 3], quadratic={("x", "y"): 1, ("x", "z"): -1, ("y", "z"): 2})
print(qubo.prettyprint())
qaoa_mes = QAOAClient(
provider=provider, backend=provider.get_backend("ibmq_qasm_simulator"), reps=2, alpha=0.75
)
qaoa = MinimumEigenOptimizer(qaoa_mes)
result = qaoa.solve(qubo)
print(result.prettyprint())
from qiskit.transpiler import PassManager
from qiskit.circuit.library.standard_gates.equivalence_library import (
StandardEquivalenceLibrary as std_eqlib,
)
from qiskit.transpiler.passes import (
Collect2qBlocks,
ConsolidateBlocks,
UnrollCustomDefinitions,
BasisTranslator,
Optimize1qGatesDecomposition,
)
from qiskit.transpiler.passes.calibration.builders import RZXCalibrationBuilderNoEcho
from qiskit.transpiler.passes.optimization.echo_rzx_weyl_decomposition import (
EchoRZXWeylDecomposition,
)
from qiskit.test.mock import FakeBelem
backend = FakeBelem()
inst_map = backend.defaults().instruction_schedule_map
channel_map = backend.configuration().qubit_channel_mapping
rzx_basis = ["rzx", "rz", "x", "sx"]
pulse_efficient = PassManager(
[
# Consolidate consecutive two-qubit operations.
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=["rz", "sx", "x", "rxx"]),
# Rewrite circuit in terms of Weyl-decomposed echoed RZX gates.
EchoRZXWeylDecomposition(backend.defaults().instruction_schedule_map),
# Attach scaled CR pulse schedules to the RZX gates.
RZXCalibrationBuilderNoEcho(
instruction_schedule_map=inst_map, qubit_channel_mapping=channel_map
),
# Simplify single-qubit gates.
UnrollCustomDefinitions(std_eqlib, rzx_basis),
BasisTranslator(std_eqlib, rzx_basis),
Optimize1qGatesDecomposition(rzx_basis),
]
)
from qiskit import QuantumCircuit
circ = QuantumCircuit(3)
circ.h([0, 1, 2])
circ.rzx(0.5, 0, 1)
circ.swap(0, 1)
circ.cx(2, 1)
circ.rz(0.4, 1)
circ.cx(2, 1)
circ.rx(1.23, 2)
circ.cx(2, 1)
circ.draw("mpl")
pulse_efficient.run(circ).draw("mpl", fold=False)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/abbarreto/qiskit4
|
abbarreto
|
from qiskit import *
import numpy as np
import math
import qiskit
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
dth = math.pi/10
th = np.arange(0,math.pi+dth,dth)
ph = 0; lb = 0
N = len(th)
F_the = np.zeros(N); F_sim = np.zeros(N); F_exp = np.zeros(N)
for j in range(0,N):
F_the[j] = math.cos(th[j]/2)**2
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.u(th[j],ph,lb,qr[2])
qc.h(qr[0])
qc.cswap(qr[0],qr[1],qr[2])
qc.h(qr[0])
qc.measure(qr[0],cr[0])
job_sim = execute(qc, backend=simulator, shots=nshots)
counts = job_sim.result().get_counts(qc)
if '0' in counts:
F_sim[j] = 2*counts['0']/nshots - 1
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts = job_exp.result().get_counts(qc)
if '0' in counts:
F_exp[j] = 2*counts['0']/nshots - 1
qc.draw('mpl')
qc.decompose().decompose().draw('mpl') # o circuito é "profundo" por causa da swap controlada
F_the, F_sim, F_exp
from matplotlib import pyplot as plt
plt.plot(th, F_the, label=r'$F_{the}$')
plt.plot(th, F_sim, '*', label=r'$F_{sim}$')
plt.plot(th, F_exp, 'o', label=r'$F_{exp}$')
plt.xlabel(r'$\theta$')
plt.legend()
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
#General imports
import numpy as np
#Operator Imports
from qiskit.opflow import Z, X, I, StateFn, CircuitStateFn, SummedOp
from qiskit.opflow.gradients import Gradient, NaturalGradient, QFI, Hessian
#Circuit imports
from qiskit.circuit import QuantumCircuit, QuantumRegister, Parameter, ParameterVector, ParameterExpression
from qiskit.circuit.library import EfficientSU2
# Instantiate the quantum state
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Instantiate the Hamiltonian observable
H = (2 * X) + Z
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# Print the operator corresponding to the expectation value
print(op)
params = [a, b]
# Define the values to be assigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi}
# Convert the operator and the gradient target params into the respective operator
grad = Gradient().convert(operator = op, params = params)
# Print the operator corresponding to the Gradient
print(grad)
# Assign the parameters and evaluate the gradient
grad_result = grad.assign_parameters(value_dict).eval()
print('Gradient', grad_result)
# Define the Hamiltonian with fixed coefficients
H = 0.5 * X - 1 * Z
# Define the parameters w.r.t. we want to compute the gradients
params = [a, b]
# Define the values to be assigned to the parameters
value_dict = { a: np.pi / 4, b: np.pi}
# Combine the Hamiltonian observable and the state into an expectation value operator
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
print(op)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameters using
# the parameter shift method.
state_grad = Gradient(grad_method='param_shift').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with parameter shift', state_grad_result)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the linear combination of unitaries method.
state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with the linear combination method', state_grad_result)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the finite difference method.
state_grad = Gradient(grad_method='fin_diff').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with finite difference', state_grad_result)
# Besides the method to compute the circuit gradients resp. QFI, a regularization method can be chosen:
# `ridge` or `lasso` with automatic parameter search or `perturb_diag_elements` or `perturb_diag`
# which perturb the diagonal elements of the QFI.
nat_grad = NaturalGradient(grad_method='lin_comb', qfi_method='lin_comb_full', regularization='ridge').convert(
operator=op, params=params)
# Assign the parameters and evaluate the gradient
nat_grad_result = nat_grad.assign_parameters(value_dict).eval()
print('Natural gradient computed with linear combination of unitaries', nat_grad_result)
# Instantiate the Hamiltonian observable
H = X
# Instantiate the quantum state with two parameters
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# Convert the operator and the hessian target coefficients into the respective operator
hessian = Hessian().convert(operator = op, params = [a, b])
# Define the values to be assigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi/4}
# Assign the parameters and evaluate the Hessian w.r.t. the Hamiltonian coefficients
hessian_result = hessian.assign_parameters(value_dict).eval()
print('Hessian \n', np.real(np.array(hessian_result)))
# Define parameters
params = [a, b]
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='param_shift').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the parameter shift method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='lin_comb').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the linear combination of unitaries method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian using finite difference
state_hess = Hessian(hess_method='fin_diff').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed with finite difference\n', (np.array(hessian_result)))
# Wrap the quantum circuit into a CircuitStateFn
state = CircuitStateFn(primitive=qc, coeff=1.)
# Convert the state and the parameters into the operator object that represents the QFI
qfi = QFI(qfi_method='lin_comb_full').convert(operator=state, params=params)
# Define the values for which the QFI is to be computed
values_dict = {a: np.pi / 4, b: 0.1}
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('full QFI \n', np.real(np.array(qfi_result)))
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'block_diagonal'
qfi = QFI('overlap_block_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Block-diagonal QFI \n', np.real(np.array(qfi_result)))
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'diagonal'
qfi = QFI('overlap_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Diagonal QFI \n', np.real(np.array(qfi_result)))
# Execution Imports
from qiskit import Aer
from qiskit.utils import QuantumInstance
# Algorithm Imports
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import CG
from qiskit.opflow import I, X, Z
from qiskit.circuit import QuantumCircuit, ParameterVector
from scipy.optimize import minimize
# Instantiate the system Hamiltonian
h2_hamiltonian = -1.05 * (I ^ I) + 0.39 * (I ^ Z) - 0.39 * (Z ^ I) - 0.01 * (Z ^ Z) + 0.18 * (X ^ X)
# This is the target energy
h2_energy = -1.85727503
# Define the Ansatz
wavefunction = QuantumCircuit(2)
params = ParameterVector('theta', length=8)
it = iter(params)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
wavefunction.cx(0, 1)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
# Define the expectation value corresponding to the energy
op = ~StateFn(h2_hamiltonian) @ StateFn(wavefunction)
grad = Gradient(grad_method='lin_comb')
qi_sv = QuantumInstance(Aer.get_backend('aer_simulator_statevector'),
shots=1,
seed_simulator=2,
seed_transpiler=2)
#Conjugate Gradient algorithm
optimizer = CG(maxiter=50)
# Gradient callable
vqe = VQE(wavefunction, optimizer=optimizer, gradient=grad, quantum_instance=qi_sv)
result = vqe.compute_minimum_eigenvalue(h2_hamiltonian)
print('Result:', result.optimal_value, 'Reference:', h2_energy)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/AbdulahAmer/Quantum-Phase-Estimation-with-Qiskit-
|
AbdulahAmer
|
'''
Quantum Phase Estimation
By Abdulah Amer
T gate leaves |0> state alone and adds a phase of e^pi/4 to
|1> state. Quantum Phase Estimation measures theta where
T|1> = e^2ipitheta|1>
First n-1 qubits are used for the protocol and get measured
the nth qubit is put into the eigenstate of the operator whose phase
we are measuring this is important
'''
from qiskit import *
import numpy as np
from math import *
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from fractions import Fraction
S_simulator=Aer.backends(name='statevector_simulator')[0]
M_simulator=Aer.backends(name='qasm_simulator')[0]
# # a circuit with 4 qubits and 3 classical bits
#
# n=4 #number of qubits
# m=3 #number of classical bits
#
# # a circuit with n qubits and m classical
# qc=QuantumCircuit(n,m)
#
# qc.x(3)
#
# for qubit in range(3):
# qc.h(qubit)
#
# #Now estimate phase for T gate with phase of pi/4
# # apply the T gate a bunch of times
#
# reps=1
# for counting_qubit in range(3):
# for i in range(reps):
# #applies T gate using the counting qubits as control
# #qubits and the last qubit as the target qubit.
# #
# qc.cu1(pi/4, counting_qubit, 3)
#
# reps *=2 #doubles the number of T gates to each adjacent qubit
#
#
# qc.draw(output='mpl')
#
#
# #Do the inverse qft to find the state
#
def qft_inverse(qc,n):
for qubit in range(n//2): #floor division for odd number of qubits
qc.swap(qubit, n-qubit-1)
#swaps the current qubit with n-qubit-1
for j in range(n):
for m in range(j):
qc.cu1(-pi/float(2**(j-m)),m,j)
qc.h(j)
#
#
# qc.barrier()
#
# qft_inverse(qc,3)
#
# qc.barrier()
#
# for n in range(3):
# qc.measure(n,n)
#
#
# #qc.draw(output='mpl')
#
#lol
#
#
# results=execute(qc,backend=M_simulator, shots=4096).result()
# histogram=results.get_counts()
#
# plot_histogram(histogram)
# After measurement we divide the decimal equivalent by 2^n
# 1/2^3 =1/8 , theta =1/8, therefore e^2ipitheta = e^ipi/4
#Which is the phase added by the T gate.
#This was a pretty trivial result since we perfectly get
#one highest probability
#make functions to generalize even better
# def prepQPE(qc, n,m): #prepares the circuit
# for qubit in range(m):
# qc.h(qubit)
#
# qc.x(m)
#
#
# def CU(theta, qc, n,m): #performs controlled unitary operations
#
# prepQPE(qc,n,m)
#
# angle=theta
# reps=1
# for counting_qubit in range(m):
# for i in range(reps):
# qc.cu1(angle, counting_qubit,5)
# reps*=2
#
#Let us also Automate more of the process so we can scale these things
#To learn even more from them
'''
Note we are making circuits to measure known thetas
But we will try to build up to design a circuit to do
Arbitrary Phase Estimation
'''
#Makes an isntance of a quantum circuit that runs the QPE protocol
def makeQPE(theta, n): #m=n-1
m=n-1
qc=QuantumCircuit(n,m)
#Prep
for qubit in range(m):
qc.h(qubit)
qc.x(m)
#CU1 gates
reps=1
for counting_qubit in range(m):
for i in range(reps):
qc.cu1(theta, counting_qubit, m)
reps*=2
qc.barrier()
qft_inverse(qc,m)
qc.barrier()
for n in range(m):
qc.measure(n,n)
return qc
#gets out results and aquires the one with the most hits
def get_results(q,n):
m=n-1
results=execute(q, backend=M_simulator).result()
histo=results.get_counts()
higher=0
hits=histo.values()
for i in hits:
if i>higher:
higher=i
newhisto=dict([(value,key) for key, value in histo.items()])
answer=int(newhisto[higher],2)
check=(answer/(2**m))
return check
#simple finding error function
def error(expected, actual):
expected_minus_actual=abs(expected-actual)
percent_error=expected_minus_actual/100
return percent_error
#tie it all together
def graph_qubits_error(piece_of_pi, qubits):
#set up
angle=pi*piece_of_pi
expected=(piece_of_pi/2)
qubits=[]
results=[]
errors=[]
n=2
while n<=qubits:
#make circuit and measure
q=makeQPE(angle,n)
actual=get_results(q,n)
#our error
err=error(expected, actual)
#Dont forget how to graph
qubits.append(n)
results.append(actual)
errors.append(err)
n+=1
#Plotting##########
# plt.figure(1)
# plt.title('Value vs qubits used')
# plt.plot(qubits,results, color='green', label='Experimental Result')
# plt.hlines(expected,2,16, color='blue', linestyles='dashed', label=' Expected Value')
# plt.xlabel('Number of Qubits')
# plt.ylabel('Result of Measurement')
#
#
# plt.figure(2)
# plt.title('Error vs qubits used')
# plt.plot(qubits, errors)
# plt.xlabel('Number of Qubits')
# plt.ylabel('Percent Error')
# plt.show()
piece_of_pi=1/2
qubits=8
#graph_qubits_error(piece_of_pi,qubits)
def error_per_slice(piece_of_pi, qubits):
angle=pi*piece_of_pi
expected=(piece_of_pi/2)
q=makeQPE(angle,qubits)
actual=get_results(q,qubits)
err=error(expected, actual)
return err
def yeet():
slices=[]
list_of_errors=[]
qubits=5
i=1
while i<=16:
piece_of_pi=1/i
slices.append(piece_of_pi)
list_of_errors.append(error_per_slice(piece_of_pi, qubits))
i+=1
title= ('Error for different slices of pi using '+ str(qubits)+ ' qubits')
plt.title(title)
plt.plot(slices,list_of_errors, color='green')
#plt.hlines(expected,2,16, color='blue', linestyles='dashed', label=' Expected Value')
plt.xlabel('Slices')
plt.ylabel('Error in measurement')
#plt.show()
return list_of_errors
def get_slices():
slices=[]
i=1
while i<=16:
piece_of_pi=1/i
slices.append(piece_of_pi)
i+=1
return slices
'''
some stuff to look at the fractions
'''
def frac_stuff(slices):
integers=[]
for i in range(len(slices)):
two_to_the_n=2**(qubits-1)
it_theta=slices[i]
integers.append(two_to_the_n*it_theta)
fracslices=[]
for i in range(len(slices)+1):
piece='1/' + str(i)
fracslices.append(piece)
#gets rid of the 1/0 at the front of the list
fracslices.pop(0)
#inserts a 1 instead of 1/1 in our list
fracslices.insert(0,1)
#gets ride of 1/1
fracslices.pop(1)
'''
Make a Table!
'''
Dabois=yeet()
header=['2^n*', 'Slice']
head1='2^n*'+ 'Theta'
head2='Slice'
head3='Error amounts'
col1=integers
col2=fracslices
col3=Dabois
from tabulate import tabulate
table=tabulate({head2: col2, head1: col1, head3:col3}, headers='keys', tablefmt='github')
for i in range(len(col1)):
print(col2[i], '&' , round(col1[i],5), '&', round(col3[i],5))
return table
#print(table)
from qiskit.visualization import plot_bloch_vector
'''
The following code is execute in Jupyter notebooks file called QPE final
It gives us images Rx and Ry respectively
#Rx
q=QuantumRegister(1, 'l')
blocher=QuantumCircuit(q)
blocher.ry(pi/2,0)
bloch_job=execute(blocher, S_simulator).result()
plot_bloch_multivector(bloch_job.get_statevector(blocher), title='initial')
#Ry
blocher=QuantumCircuit(q)
blocher.ry(pi/2,0)
blocher.u1(pi/2,0)
bloch_job=execute(blocher, S_simulator).result()
plot_bloch_multivector(bloch_job.get_statevector(blocher), title='final')
'''
piece_of_pi=1/4
qubits=3
q=makeQPE(piece_of_pi,qubits)
#q.draw(output='mpl').savefig('The Circuit is Here.png')
print(frac_stuff(get_slices()))
|
https://github.com/RachaelC358/Quantum-Daemonum
|
RachaelC358
|
# Rachael Carpenter
# 1/9/2022
#
# Quantum Daemonum
# A simple game where you play as as a wicked spirit in a battle with
# Van Helsing who happens to have a quantum computer. Van Helsing will
# attempt to guess your true name in an attempt to gain power over and
# and defeat you. You can attempt to thwart him with spiritual attacks.
#
import random
import qiskit
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit.providers.aer import QasmSimulator
import operator
import math
import numpy as np
# This function is called when its time to use the quantum simulator
def runGame(program):
shots = 100
# execute program on quantum simulator
job = qiskit.execute(program, qiskit.Aer.get_backend('qasm_simulator'), shots=shots)
result = job.result().get_counts()
return result
# utility function called by quantumGuess
def quantumProcessing(quessProcess, qreg, hiddenName):
# Convert hiddenName in binary from list to array
secretName = list(hiddenName)
# reverse order of bits
secretName.reverse()
indexList = []
# find indices of all zeroes
for i in range(len(secretName)):
if (secretName[i] == '0'):
indexList.append(i)
# Invert the 0s
for i in range(len(indexList)):
# find bits with a value of 0
anIndex = indexList[i]
# Invert qubit
quessProcess.x(qreg[anIndex])
# This function handles the quantum and classical registers and manipulates them
# to perform Grover's search algorithm.
def quantumGuess(hiddenName):
# 4-bit Grover's search to identify target index of 4 bits from list of all combinations of 4 bits
# create 2 qubits for input
qreg = QuantumRegister(4)
# these 2 registers take output
creg = ClassicalRegister(4)
guessProcess = QuantumCircuit(qreg, creg)
# place qubits into superposition, representing all possible outcomes(starting position)
guessProcess.h(qreg)
# Run quantumProcessing on key, inverting bits with value of zero
quantumProcessing(guessProcess, qreg, hiddenName)
#Grover's Algorithm
guessProcess.cp(np.pi / 4, qreg[0], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(-np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
#Reverse the earlier inversions by guessProcessing
quantumProcessing(guessProcess, qreg, hiddenName)
#Amplification
guessProcess.h(qreg)
guessProcess.x(qreg)
#apply grover's algorithm again for amplification
guessProcess.cp(np.pi / 4, qreg[0], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(-np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[0], qreg[1])
guessProcess.cp(np.pi / 4, qreg[1], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[1], qreg[2])
guessProcess.cp(-np.pi / 4, qreg[2], qreg[3])
guessProcess.cx(qreg[0], qreg[2])
guessProcess.cp(np.pi / 4, qreg[2], qreg[3])
# Reverse amplification
guessProcess.x(qreg)
guessProcess.h(qreg)
# Measure results
guessProcess.barrier(qreg)
guessProcess.measure(qreg, creg)
# 'results' can be printed to check for error
results = runGame(guessProcess)
foundName = max(results.items(), key=operator.itemgetter(1))[0]
# convert binary result to character array
resultArray = list(foundName)
# convert character array in integers
resultArrayInt = [int(i) for i in resultArray]
stringy = ''.join([str(item) for item in resultArrayInt])
#convert result to index in name array
myIndex = int(stringy, 2)
return myIndex
# list of names is accessed by index in list
def getDemonName(index):
demonNames = {
1:'Dusios',
2:'Belial',
3:'Belphegor',
4:'Andromalius',
5:'Astaroth',
6:'Beleth',
7:'Drekevac',
8:'Demiurge',
9:'Forneus',
10:'Gomory',
11:'Haures',
12:'Pithius',
13:'Mammon',
14:'Marchosias',
15:'Moloch',
16:'Naphula'
}
return demonNames.get(index)
# This function returns text based on game status variables.
def battleStatus(evil, good):
if good > 50 and good < 100 and evil <= 50:
return 'Dr. Van Helsing is fiddling will a strange quantum device. Your powers are weak.'
elif evil <= 50 and good == 100:
return 'A blast of light fills the cavern.'
elif good > 75:
return 'The quantum device is flickering with light and emits steam.'
elif evil <= 50 and good <= 50:
return 'Dr. Van Helsing is experiencing technical issues.'
elif evil == 100:
return 'Your are powers have returned.'
elif evil >= 50 and good >= 50:
return 'Your powers are growing stronger. The machine sparkling with electricity.'
# This function returns text that is printed describing effects after player input.
def statusChange(actionCode):
if actionCode == 5:
return ' '
elif actionCode == 4:
return 'The cavern glows with a red light.'
elif actionCode == 3:
return 'A thick fog fills the cavern.'
elif actionCode == 1:
return 'Nothing happens.'
# Processes main player input each turn.
def action(read):
read = str(read)
read = read.lower()
switcher = {
'p': 5, #possess, requires high evil
'd': 4, #duplici, increase evil,
'v': 3, #vaporum, decrease good, VH requires high good for quantum guess
#VH will increase good each turn until he can attack
'n': 1, #nothing
'q': 0 #quit
}
return switcher.get(read[0], -1)
# Processes player input at end of game.
def response(read):
read = str(read)
read = read.lower()
switcher = {
'y': 1,
'n': 0,
'q': 0
}
return switcher.get(read, -1)
# The main function; contains main game loop.
def main():
#print welcome message
print("")
print(" __ ___ __ ___ __")
print(" / \ | | /\ |\ | | | | |\/| | \ /\ |__ |\/| / \ |\ | | | |\/|")
print(" \__X \__/ /~~\ | \| | \__/ | | |__/ /~~\ |___ | | \__/ | \| \__/ | |")
print(" ~ A DARK GAME PLAYED AGAINST A SIMULATED QUANTUM COMPUTER ~\n\n")
print(" The year is 1887. You are a wicked spirit, evil personified, who is being hunted")
print(" by Van Helsing, the infamous slayer of unholy beasts. He will try to destroy you by")
print(" guessing your true name. You must stop him at any cost. A battle of magic and wits")
print(" begins! Van Helsing has you cornered in the caverns below Corvin Castle in Romania.")
print(" He performs the rites of excorcism while you have three spells.\n\n")
print(" Use keyboard commands to attempt to thwart Van Helsing, who makes guesses using")
print(" Grover's search algorithm, which runs on a quantum simulator.\n")
# controls main game loop which accomodates multiple interior loops for each round of play
quitGame = False
#Begin main loop of program
while not quitGame:
# pick the true name for this game from name array
playerName = random.randint(0, 15)
trueName = getDemonName(playerName + 1)
print(" Your true name is ... " + str(trueName) + "\n")
# convert player name index int to binary
secretBinary = format(playerName, "04b")
gameOver = False # controls whether main loop game runs
evil = 0 # evil level 100 allows posession to occur
good = 50 # good level 100 needed for quantum divination
loopControl = 1 # counts number of rounds of battle in each game
# controls for good and evil status/level changes
evilIncrease = -1
goodDecrease = -1
VHCasting = 5
# begin main loop for this round of play
while not gameOver and not quitGame:
# controls whether Van Helsing uses quantum guessing this round
VHActive = True
print(" +:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+\n")
# manage status changes for this turn
if VHCasting > 0:
good = good + random.randint(10,45)
if good > 100:
good = 100
if evilIncrease > -1:
evil = evil + random.randint(1,50)
evilIncrease = evilIncrease - 1
if evil > 100:
evil = 100
if goodDecrease > -1:
good = good - random.randint(1,40)
goodDecrease = goodDecrease - 1
if good < 0:
good = 0
# print stats for this round
roundStr = str(loopControl)
evilStr = str(evil)
print(" Round: ", roundStr.rjust(5))
print(" Evil : ", evilStr.rjust(5))
goodStr = str(good)
print(" Good : ", goodStr.rjust(5))
print("\n " + battleStatus(evil, good))
# this variable takes resulting index indicating the resulting name of quantum guess
VHResult = -1
#process on quantum simulator, VH will guess now
if VHActive and good == 100:
#let the computer guess
VHResult = quantumGuess(secretBinary)
#check player progress
if (VHResult != -1 and str(getDemonName(VHResult+1)) == str(trueName)):
gameOver = True
print(" The strange device spits out a slip of paper.")
print(" Van Helsing reads the paper aloud in a booming voice: \"" + getDemonName(VHResult+1) + "!\"")
print(" All your power is obliterated. GAME OVER.")
if VHResult != -1 and str(getDemonName(VHResult+1)) != str(trueName):
print(VHResult+1)
print(" The strange device spits out a slip of paper.")
print(" Van Helsing reads the paper aloud in a booming voice: \"" + getDemonName(VHResult+1) + "!\"")
print(" Quantum algorithms fail sometimes...")
# get player input for this turn
if gameOver == False:
read = '' # text of input will be stored here
while not read.lower() in ['p','d','v','f','n','q','possess','duplici','vaporum','nothing','quit']:
read = input("\n [Possess(p), Duplici(d), Vaporum(v), nothing(n), quit(q)]: ").lower()
#process input
actionCode = -1
actionCode = action(read)
if actionCode == 5: #possession
if evil == 100:
gameOver = True
print("\n Van Helsing's soul withers as you take over his physical form.")
print(" You destroy the machine and escape the cavern. THE END.")
else:
print("\n You are too weak to possess Van Helsing.")
elif actionCode == 4: # Duplici, evil increases for some random amount of turns
evilIncrease = random.randint(1, 5)
elif actionCode == 3: # Vaporum, good decreases for some random amount of turns
VHActive = False
goodDecrease = random.randint(1, 5)
elif actionCode == 0: # quit
quitGame = True
break
# report evil/good status changes from the last turn
print("\n " + statusChange(actionCode))
loopControl = loopControl + 1
# end game menu, take user input
if gameOver == True:
read = ''
while not read.lower() in ['y','n','q','yes','no','quit']:
#Read input from user
read = input("\n +:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+:+\n" +
" Do you want to play again?"+
"\n [yes(y), no(n), quit(q)]: ").lower()
#process input
actionCode = -1
actionCode = response(read)
if actionCode == 0:
quitGame = True
break
elif actionCode == 1:
loopControl = 1
gameOver == False
else:
print(" What?")
# run main function
if __name__ == "__main__":
main()
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from typing import Sequence
from qiskit import QuantumCircuit
from QiskitPBT.utils import HashableQuantumCircuit
class MeasurementConfiguration:
def __init__(self) -> None:
self._data: dict[HashableQuantumCircuit, list[tuple[str, dict[int, QuantumCircuit]]]] = {}
def add_measurement(self, measurement_id: str, circuit: QuantumCircuit, measurement_specification: dict[int, QuantumCircuit]) -> None:
if circuit in self._data:
self._data[circuit].append((measurement_id, measurement_specification))
else:
self._data[circuit] = [(measurement_id, measurement_specification)]
def get_measured_circuits(self) -> tuple[HashableQuantumCircuit]:
return tuple(self._data.keys())
def get_measurements_for_circuit(self, circuit: HashableQuantumCircuit) -> list[tuple[str, dict[int, QuantumCircuit]]]:
return self._data[circuit]
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
# Create a circuit with a register of three qubits
circ = QuantumCircuit(3)
# H gate on qubit 0, putting this qubit in a superposition of |0> + |1>.
circ.h(0)
# A CX (CNOT) gate on control qubit 0 and target qubit 1 generating a Bell state.
circ.cx(0, 1)
# CX (CNOT) gate on control qubit 0 and target qubit 2 resulting in a GHZ state.
circ.cx(0, 2)
# Draw the circuit
circ.draw('mpl')
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
import pickle
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.ignis.mitigation import expectation_value
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("./")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
scale_factors = [1.0, 2.0, 3.0]
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="lq")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder_init110(qc, targets=[0, 1, 2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = zne_wrapper(t3_st_qcs, scale_factors=scale_factors)
print("created zne_qcs (length:", len(zne_qcs), ")")
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
t3_zne_qcs[-3].draw("mpl")
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
# print("provider:", provider)
# backend = provider.get_backend("ibmq_jakarta")
shots = 1 << 13
reps = 1 # unused
# Number of trotter steps
print("trotter step: ", num_steps)
# execute: reps = 1
job = execute(t3_zne_qcs, backend, shots=shots) # 毎回チェック: ここちゃんと変えた？
print('Job ID', job.job_id())
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
mit_results = meas_fitter.filter.apply(job.result())
zne_expvals = zne_decoder(num_qubits, mit_results)
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
rho = expvals_to_valid_rho(num_qubits, zne_expvals)
fidelity = state_fidelity(rho, target_state)
print(fidelity)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
"""Define the Sycamore gate and its decompositions."""
from qiskit import QuantumCircuit
from qiskit.circuit.library import CZGate, iSwapGate
from qiskit.quantum_info import Operator
qc = QuantumCircuit(2)
qc.append(iSwapGate().power(-1), [0, 1])
qc.append(CZGate().power(1 / 6), [0, 1])
syc = Operator(qc)
syc.name = "syc"
syc.params = []
# # Get the directory of the current file
# current_directory = Path(__file__).parent
# # Compute the absolute paths to the .qasm files
# cx_decomp_path = current_directory / "../circuits/d02_syc_cnot.qasm"
# swap_decomp_path = current_directory / "../circuits/d02_syc_swap.qasm"
# cx_decomp = QuantumCircuit.from_qasm_file(cx_decomp_path)
# cx_decomp = cx_decomp.decompose()
# sel.add_equivalence(CXGate(), cx_decomp)
# swap_decomp = QuantumCircuit.from_qasm_file(swap_decomp_path)
# sel.add_equivalence(SwapGate(), swap_decomp)
|
https://github.com/TheGupta2012/QickStart-Challenges
|
TheGupta2012
|
## Enter Team ID
import os
os.environ["TEAMID"] = "Excalibur"
from qiskit import QuantumCircuit
from numpy import *
def qram_4q(m, array):
### your code here
size=int(floor(log2(m))+3)
n=size-2
qc=QuantumCircuit(size)
binary=[]
k=str(n)
for i in array:
binary.append(format(i, f'0{k}b'))
i=0
qc.h(0)
qc.h(1)
qc.x(0)
qc.x(1)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
i=i+1
qc.x(0)
qc.x(1)
qc.x(1)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
i=i+1
qc.x(1)
qc.x(0)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
i=i+1
qc.x(0)
for j in range(1,n+1):
if(binary[i][j-1]=='1'):
qc.ccx(0,1,size-j)
return qc
### your code here
def test_function_1():
m = 6
array = [3, 4, 5, 6]
qram = qram_4q(m, array)
return qram
test_function_1().draw('mpl')
from grader.graders.problem_5.grader import grader1
grader1.evaluate(qram_4q)
def qram_general(n, m, array):
### your code here
k=int(floor(log2(m))+1)
l=int(log2(n))
size=k+l
qc=QuantumCircuit(size)
index=list(range(l))
binary=[]
for i in array:
binary.append(format(i, f'0{k}b'))
qc.h(index)
for i in range(n):
b=format(i,f'0{l}b')
inverted=[]
for p in range(0,l):
if(b[p]=='0'):
qc.x(l-p-1)
inverted.append(l-p-1)
for j in range(1,k+1):
if(binary[i][j-1]=='1'):
qc.mct(index,size-j)
for q in inverted:
qc.x(q)
return qc
### your code here
def test_function_2():
n = 4
m = 4
array = [3,4,5,6]
qram = qram_general(n, m, array)
return qram
test_function_2().draw('mpl')
from grader.graders.problem_5.grader import grader2
grader2.evaluate(qram_general)
from qiskit.circuit.library import RYGate,RXGate,RZGate
def qram_rotations(n, rotations):
### your code here
l=int(log2(n))
size=l+1
qc=QuantumCircuit(size)
index=list(range(l))
full=list(range(size))
qc.h(index)
for i in range(n):
b=format(i,f'0{l}b')
inverted=[]
for p in range(0,l):
if(b[p]=='0'):
qc.x(l-p-1)
inverted.append(l-p-1)
qc.barrier()
if(rotations[i][0]=='x'):
multirx = RXGate(rotations[i][1]*2*pi).control(l,label=None)
qc.append(multirx,full)
elif(rotations[i][0]=='y'):
multiry = RYGate(rotations[i][1]*2*pi).control(l,label=None)
qc.append(multiry,full)
elif(rotations[i][0]=='z'):
multirz = RZGate(rotations[i][1]*2*pi).control(l,label=None)
qc.append(multirz,full)
qc.barrier()
for q in inverted:
qc.x(q)
qc.barrier()
return qc
### your code here
def test_function_3():
n = 8
rotations = [('x', 0.123), ('y', -0.912),('z',-0.12),('x', 0.5),('z',0.5),('y', -0.5),('z',0.5),('x', 0.5)]
qram = qram_rotations(n, rotations)
return qram
test_function_3().draw('mpl')
from grader.graders.problem_5.grader import grader3
grader3.evaluate(qram_rotations)
|
https://github.com/mspronesti/qlearnkit
|
mspronesti
|
from .encoding_map import EncodingMap
import numpy as np
from functools import reduce
from qiskit import QuantumCircuit
from qiskit.circuit.library.standard_gates import RXGate, RYGate, RZGate
"""Encoding classical data to quantum state via amplitude encoding."""
class AngleEncoding(EncodingMap):
"""
Angle Encoding algorithm. Assumes data is feature-normalized.
"""
def __init__(
self, n_features: int = 2, rotation: str = "Y", scaling: float = np.pi / 2
):
r"""
Args:
rotation: the direction
admitted values: X, Y, Z
scaling: scaling factor for normalized input data.
The default scaling :math:`\pi/2` does
not induce a relative phase difference.
"""
ROT = {"X": RXGate, "Y": RYGate, "Z": RZGate}
if rotation not in ROT:
raise ValueError("No such rotation direction {}".format(rotation))
super().__init__(n_features)
# angle encoding requires 1 qubit
# for each feature
self._num_qubits = n_features
self.gate = ROT[rotation]
self.scaling = scaling
def construct_circuit(self, x) -> QuantumCircuit:
"""
Args:
x (np.array): The input data to encode
Returns:
The circuit that encodes x.
Assumes data is feature-normalized.
Assumes every element in x is in [0, 1]
"""
self._check_feature_vector(x)
circuit = QuantumCircuit(self.num_qubits)
for i in range(self.num_qubits):
circuit.append(self.gate(2 * self.scaling * x[i]), [i])
return circuit
def state_vector(self, x):
"""
The encoding of a state via angle encoding, operating
a rotation around the ``rotation`` axis.
Args:
x (np.array): The input data to encode
Returns:
np.array: The state vector representation of x after angle encoding
"""
qubit_states = []
for x_i in x:
qubit_state = self.gate(2 * self.scaling * x_i).to_matrix()[:, 0]
qubit_states.append(qubit_state)
return reduce(lambda a, b: np.kron(a, b), qubit_states)
|
https://github.com/minminjao/qiskit1
|
minminjao
|
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()
circ=QuantumCircuit(5,5)
circ.h(0)
circ.cx(0,1)
circ.cx(1,2)
circ.cx(2,3)
circ.cx(3,4)
circ.barrier(range(5))
circ.measure(range(5),range(5))
circ.draw('mpl')
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
# the given matrix
M = [
[0.05, 0, 0.70, 0.60],
[0.45, 0.50, 0.20, 0.25],
[0.20, 0.35, 0.10, 0],
[0.30, 0.15, 0, 0.15]
]
#
# you may enumarate the columns and rows by the strings '00', '01', '10', and '11'
# int('011',2) returns the decimal value of the binary string '011'
#
#
# your solution is here
#
# the given matrix
M = [
[0.05, 0, 0.70, 0.60],
[0.45, 0.50, 0.20, 0.25],
[0.20, 0.35, 0.10, 0],
[0.30, 0.15, 0, 0.15]
]
print("Matrix M is")
for row in M:
print(row)
print()
# the target matrix is K
# we create it and filled with zeros
K = []
for i in range(8):
K.append([])
for j in range(8):
K[i].append(0)
# for each transition in M, we create four transitions in K, two of which are always zeros
for col in ['00','01','10','11']:
for row in ['00','01','10','11']:
prob = M[int(col,2)][int(row,2)]
# second bit is 0
newcol = col[0]+'0'+col[1]
newrow = row[0]+'0'+row[1]
K[int(newcol,2)][int(newrow,2)] = prob
# second bit is 1
newcol = col[0]+'1'+col[1]
newrow = row[0]+'1'+row[1]
K[int(newcol,2)][int(newrow,2)] = prob
print("Matrix K is")
for row in K:
print(row)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import execute, pulse
d0 = pulse.DriveChannel(0)
with pulse.build() as pulse_prog:
pulse.play(pulse.Constant(100, 1.0), d0)
pulse_prog.draw()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_circuit_layout
from qiskit.providers.fake_provider import FakeVigo
backend = FakeVigo()
ghz = QuantumCircuit(3, 3)
ghz.h(0)
ghz.cx(0,range(1,3))
ghz.barrier()
ghz.measure(range(3), range(3))
# Virtual -> physical
# 0 -> 3
# 1 -> 4
# 2 -> 2
my_ghz = transpile(ghz, backend, initial_layout=[3, 4, 2])
plot_circuit_layout(my_ghz, backend)
|
https://github.com/zhangx1923/QISKit_Deve_Challenge
|
zhangx1923
|
# -*- coding: utf-8 -*-
# Copyright 2017 IBM RESEARCH. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# =============================================================================
"""
---------------> do not modify this file for your submission <---------------
This file is not considered to be part of your submission.
It is only provided for you to benchmark your code.
The local_qasm_cpp_simulator that is used requires QISKit 0.43 or later.
"""
import numpy as np
import time
import copy
import qiskit
import sys, os, traceback
GLOBAL_TIMEOUT = 3600
ERROR_LIMIT = 1e-10
from qiskit import QuantumProgram
from qiskit.unroll import Unroller, DAGBackend
from qiskit._openquantumcompiler import dag2json
from multiprocessing import Pool
from qiskit.mapper._mappererror import MapperError
from qiskit.tools.qi.qi import state_fidelity
def score(depth,cmap,qnum,compiler_function=None,backend = 'local_qiskit_simulator'):
"""
Scores a compiler function based on a selected set of circuits and layouts
available in the two respective subfolders.
The final scoring will be done on a similar set of circuits and layouts.
Args:
compiler_function (function): reference to user compiler function
Returns:
float : score, speed
"""
# Load coupling maps
maps_q3 = ["circle_3","linear_3","neighbour_3","center_3"]
maps_q4 = ["circle_4","linear_4","neighbour_4","center_4"]
maps_q5 = ["circle_5","linear_5","neighbour_5","center_5"]
maps_q6 = ["circle_6","linear_6","neighbour_6","center_6"]
maps_q7 = ["circle_7","linear_7","neighbour_7","center_7"]
maps_q8 = ["circle_8","linear_8","neighbour_8","center_8"]
maps_q9 = ["circle_9","linear_9","neighbour_9","center_9"]
maps_q10 = ["circle_10","linear_10","neighbour_10","center_10"]
maps_q11 = ["circle_11","linear_11","neighbour_11","center_11"]
maps_q12 = ["circle_12","linear_12","neighbour_12","center_12"]
maps_q13 = ["circle_13","linear_13","neighbour_13","center_13"]
maps_q14 = ["circle_14","linear_14","neighbour_14","center_14"]
maps_q15 = ["circle_15","linear_15","neighbour_15","center_15"]
maps_q16 = ["circle_16","linear_16","neighbour_16","center_16"]
#maps_q5 = ["circle_rand_q5","ibmqx2_q5","linear_rand_q5","ibmqx4_q5","linear_reg_q5"]
#maps_q16 = ["ibmqx3_q16", "linear_rand_q16", "rect_rand_q16", "rect_def_q16", "ibmqx5_q16"]
#maps_q20 = ["circle_reg_q20", "linear_rand_q20", "rect_rand_q20", "rect_def_q20", "rect_reg_q20"]
# Load circuits files
ex_nr = 10 # examples to add per qubit number. maximum is 10
test_circuit_filenames = {}
mapss = []
if qnum == 10:
mapss = maps_q10
elif qnum ==11:
mapss = maps_q11
elif qnum == 12:
mapss = maps_q12
elif qnum == 13:
mapss = maps_q13
elif qnum == 14:
mapss = maps_q14
elif qnum == 15:
mapss = maps_q15
elif qnum == 9:
mapss = maps_q9
else:
pass
for ii in range(ex_nr):
#test_circuit_filenames['circuits/random%d_n15_d16.qasm' % ii] = load_coupling(maps_q15[1])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n8_d11.qasm' % ii] = load_coupling(maps_q8[3])["coupling_map"]
test_circuit_filenames['circuits/random%d_n%d_d%d.qasm' % (ii,qnum,depth)] = load_coupling(mapss[cmap])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n10_d1.qasm' % ii] = load_coupling(maps_q10[0])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n11_d1.qasm' % ii] = load_coupling(maps_q11[0])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n12_d1.qasm' % ii] = load_coupling(maps_q12[0])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n13_d1.qasm' % ii] = load_coupling(maps_q13[0])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n14_d1.qasm' % ii] = load_coupling(maps_q14[0])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n15_d1.qasm' % ii] = load_coupling(maps_q15[0])["coupling_map"]
# for jj in range(16):
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n16_d%d.qasm' % (ii,jj+1)] = load_coupling(maps_q16[0%len(maps_q16)])["coupling_map"]
# for jj in range(16):
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n16_d%d.qasm' % (ii,jj+1)] = load_coupling(maps_q16[1%len(maps_q16)])["coupling_map"]
# for jj in range(16):
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n16_d%d.qasm' % (ii,jj+1)] = load_coupling(maps_q16[2%len(maps_q16)])["coupling_map"]
# for jj in range(16):
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n16_d%d.qasm' % (ii,jj+1)] = load_coupling(maps_q16[3%len(maps_q16)])["coupling_map"]
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n16_d16.qasm' % ii] = load_coupling(maps_q16[ii%len(maps_q16)])["coupling_map"]
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n20_d20.qasm' % ii] = load_coupling(maps_q20[ii%len(maps_q20)])["coupling_map"]
#for ii in range(ex_nr):
#test_circuit_filenames['circuits/random%d_n5_d5.qasm' % ii] = load_coupling(maps_q5[ii%len(maps_q5)])["coupling_map"]
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n16_d16.qasm' % ii] = load_coupling(maps_q16[ii%len(maps_q16)])["coupling_map"]
# for ii in range(ex_nr):
# test_circuit_filenames['circuits/random%d_n20_d20.qasm' % ii] = load_coupling(maps_q20[ii%len(maps_q20)])["coupling_map"]
#for ii in range(ex_nr):
#test_circuit_filenames['circuits/random%d_n5_d5.qasm' % ii] = load_coupling(maps_q5[ii%len(maps_q5)])["coupling_map"]
#for ii in range(ex_nr):
#test_circuit_filenames['circuits/random%d_n16_d16.qasm' % ii] = load_coupling(maps_q16[ii%len(maps_q16)])["coupling_map"]
#for ii in range(ex_nr):
#test_circuit_filenames['circuits/random%d_n20_d20.qasm' % ii] = load_coupling(maps_q20[ii%len(maps_q20)])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n16_d16.qasm' % 0] = load_coupling(maps_q16[0])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n5_d5.qasm' % 5] = load_coupling(maps_q5[0])["coupling_map"]
#test_circuit_filenames['circuits/random%d_n20_d20.qasm' % 3] = load_coupling(maps_q20[3])["coupling_map"]
# Load example circuits and coupling maps
test_circuits = {}
for filename, cmap in test_circuit_filenames.items():
with open(filename, 'r') as infile:
qasm = infile.read()
test_circuits[filename] = {"qasm": qasm, "coupling_map": cmap}
#将verbose设置为False，则不会执行IBM的标准算法
res = evaluate(compiler_function, test_circuits, verbose=True, backend = backend)
res_scores=[]
for k in res.keys():
print(res[k])
for name in res:
if (res[name]["optimizer_time"] > 0) and res[name]["coupling_correct_optimized"]:
# only add the score if the QISKit reference compiler worked well
if (res[name]["reference_time"] > 0) and res[name]["coupling_correct_reference"]:
# both user and reference compiler gave the correct result without error
res_scores.append([res[name]["cost_optimized"]/res[name]["cost_reference"],res[name]["optimizer_time"]/res[name]["reference_time"]])
else:
# the user compiler had an error or did not produce the right quantum state
# this returns a value which is half as good as the reference
res_scores.append([2,2])
return [(1./np.mean([ii[0] for ii in res_scores]), 1./np.mean([ii[1] for ii in res_scores])),res]
def evaluate(compiler_function=None, test_circuits=None, verbose=False, backend = 'local_qiskit_simulator'):
"""
Evaluates the given complier_function with the circuits in test_circuits
and compares the output circuit and quantum state with the original and
a reference obtained with the qiskit compiler.
Args:
compiler_function (function): reference to user compiler function
test_circuits (dict): named dict of circuits for which the compiler performance is evaluated
test_circuits: {
"name": {
"qasm": 'qasm_str',
"coupling_map": 'target_coupling_map
}
}
verbose (bool): specifies if performance of basic QISKit unroler and mapper circuit is shown for each circuit
backend (string): backend to use. For Windows Systems you should specify 'local_qasm_simulator' until
'local_qiskit_simulator' is available.
Returns:
dict
{
"name": circuit name
{
"optimizer_time": time taken by user compiler,
"reference_time": reference time taken by qiskit circuit mapper/unroler (if verbose),
"cost_original": original circuit cost function value (if verbose),
"cost_reference": reference circuit cost function value (if verbose),
"cost_optimized": optimized circuit cost function value,
"coupling_correct_original": (bool) does original circuit
satisfy the coupling map (if verbose),
"coupling_correct_reference": (bool) does circuit produced
by the qiskit mapper/unroler
satisfy the coupling map (if verbose),
"coupling_correct_optimized": (bool) does optimized circuit
satisfy the coupling map,
"state_correct_optimized": (bool) does optimized circuit
return correct state
}
}
"""
# Initial Setup
basis_gates = 'u1,u2,u3,cx,id' # or use "U,CX?"
gate_costs = {'id': 0, 'u1': 0, 'measure': 0, 'reset': 0, 'barrier': 0,
'u2': 1, 'u3': 1, 'U': 1,
'cx': 10, 'CX': 10}
# Results data structure
results = {}
# Load QASM files and extract DAG circuits
for name, circuit in test_circuits.items():
qp = QuantumProgram()
qp.load_qasm_text(
circuit["qasm"], name, basis_gates=basis_gates)
circuit["dag_original"] = qasm_to_dag_circuit(circuit["qasm"], basis_gates=basis_gates)
test_circuits[name] = circuit
results[name] = {} # build empty result dict to be filled later
# Only return results if a valid compiler function is provided
if compiler_function is not None:
# step through all the test circuits using multiprocessing
compile_jobs = [[name,circuit,0,compiler_function,gate_costs] for name, circuit in test_circuits.items()]
with Pool(len(compile_jobs)) as job:
res_values_opt = job.map(_compile_circuits, compile_jobs)
# stash the results in the respective dicts
for job in range(len(compile_jobs)):
name = res_values_opt[job].pop("name")
test_circuits[name] = res_values_opt[job].pop("circuit") # remove the circuit from the results and store it
results[name] = res_values_opt[job]
# do the same for the reference compiler in qiskit if verbose == True
if verbose:
compile_jobs = [[name, circuit, 1, _qiskit_compiler, gate_costs] for name, circuit in
test_circuits.items()]
with Pool(len(compile_jobs)) as job:
res_values = job.map(_compile_circuits, compile_jobs)
# also stash this but use update so we don't overwrite anything
for job in range(len(compile_jobs)):
name = res_values[job].pop("name")
test_circuits[name].update(res_values[job].pop("circuit")) # remove the circuit from the results and store it
results[name].update(res_values[job])
# determine the final permutation of the qubits
# this is done by analyzing the measurements on the qubits
compile_jobs = [[name, circuit, verbose] for name, circuit in test_circuits.items()]
with Pool(len(compile_jobs)) as job:
res_values = job.map(_prep_sim, compile_jobs)
for job in range(len(compile_jobs)):
name = res_values[job].pop("name")
test_circuits[name].update(res_values[job].pop("circuit")) # remove the circuit from the results and store it
results[name].update(res_values[job])
# Compose qobj for simulation
config = {
'data': ['quantum_state'],
}
# generate qobj for original circuit
qobj_original = _compose_qobj("original", test_circuits,
backend=backend,
config=config,
basis_gates=basis_gates,
shots=1,
seed=None)
# Compute original cost and check original coupling map
for circuit in qobj_original["circuits"]:
name = circuit["name"]
coupling_map = test_circuits[name].get("coupling_map", None)
coupling_map_passes = True
cost = 0
for op in circuit["compiled_circuit"]["operations"]:
cost += gate_costs.get(op["name"]) # compute cost
if op["name"] in ["cx", "CX"] \
and coupling_map is not None: # check coupling map
coupling_map_passes &= (
op["qubits"][0] in coupling_map)
if op["qubits"][0] in coupling_map:
coupling_map_passes &= (
op["qubits"][1] in coupling_map[op["qubits"][0]]
)
if verbose:
results[name]["cost_original"] = cost
results[name]["coupling_correct_original"] = coupling_map_passes
# Run simulation
time_start = time.process_time()
#print(qobj_original['config'])
res_original = qp.run(qobj_original, timeout=GLOBAL_TIMEOUT)
results[name]["sim_time_orig"] = time.process_time() - time_start
# Generate qobj for optimized circuit
qobj_optimized = _compose_qobj("optimized", test_circuits,
backend=backend,
config=config,
basis_gates=basis_gates,
shots=1,
seed=None)
# Compute compiled circuit cost and check coupling map
for circuit in qobj_optimized["circuits"]:
name = circuit["name"]
coupling_map = test_circuits[name].get("coupling_map", None)
coupling_map_passes = True
cost = 0
for op in circuit["compiled_circuit"]["operations"]:
cost += gate_costs.get(op["name"]) # compute cost
if op["name"] in ["cx", "CX"] \
and coupling_map is not None: # check coupling map
coupling_map_passes &= (
op["qubits"][0] in coupling_map)
if op["qubits"][0] in coupling_map:
coupling_map_passes &= (
op["qubits"][1] in coupling_map[op["qubits"][0]]
)
results[name]["cost_optimized"] = cost
results[name]["coupling_correct_optimized"] = coupling_map_passes
# Run simulation
time_start = time.process_time()
res_optimized = qp.run(qobj_optimized, timeout=GLOBAL_TIMEOUT)
results[name]["sim_time_opti"] = time.process_time() - time_start
if verbose:
# Generate qobj for reference circuit optimized by qiskit compiler
qobj_reference = _compose_qobj("reference", test_circuits,
backend=backend,
config=config,
basis_gates=basis_gates,
shots=1,
seed=None)
# Compute reference cost and check reference coupling map
for circuit in qobj_reference["circuits"]:
name = circuit["name"]
coupling_map = test_circuits[name].get("coupling_map", None)
coupling_map_passes = True
cost = 0
for op in circuit["compiled_circuit"]["operations"]:
cost += gate_costs.get(op["name"]) # compute cost
if op["name"] in ["cx", "CX"] \
and coupling_map is not None: # check coupling map
coupling_map_passes &= (
op["qubits"][0] in coupling_map)
if op["qubits"][0] in coupling_map:
coupling_map_passes &= (
op["qubits"][1] in coupling_map[op["qubits"][0]]
)
results[name]["cost_reference"] = cost
results[name]["coupling_correct_reference"] = coupling_map_passes
# Skip simulation of reference State to speed things up!
# time_start = time.process_time()
# res_reference = qp.run(qobj_reference, timeout=GLOBAL_TIMEOUT)
# results[name]["sim_time_ref"] = time.process_time() - time_start
# Check output quantum state of optimized circuit is correct in comparison to original
for name in results.keys():
# handle errors here
data_original = res_original.get_data(name)
if test_circuits[name]["dag_optimized"]is not None:
data_optimized = res_optimized.get_data(name)
correct = _compare_outputs(data_original, data_optimized, test_circuits[name]["perm_optimized"])
results[name]["state_correct_optimized"] = correct
else:
results[name]["state_correct_optimized"] = False
# Skip verification of the reference State to speed things up!
# if verbose:
# if test_circuits[name]["dag_reference"] is not None:
# data_reference = res_reference.get_data(name)
# correct = _compare_outputs(data_original, data_reference, test_circuits[name]["perm_reference"])
# results[name]["state_correct_reference"] = correct
# else:
# results[name]["state_correct_reference"] = False
return results
def qasm_to_dag_circuit(qasm_string, basis_gates='u1,u2,u3,cx,id'):
"""
Convert an OPENQASM text string to a DAGCircuit.
Args:
qasm_string (str): OPENQASM2.0 circuit string.
basis_gates (str): QASM gates to unroll circuit to.
Returns:
A DAGCircuit object of the unrolled QASM circuit.
"""
program_node_circuit = qiskit.qasm.Qasm(data=qasm_string).parse()
dag_circuit = Unroller(program_node_circuit,
DAGBackend(basis_gates.split(","))).execute()
return dag_circuit
def get_layout(qubits = 5):
# load a random layout for a specifed number or qubits
# only layouts for 5, 16 and 20 qubits are stored
from os import path, getcwd
from glob import glob
from numpy.random import rand
filenames = glob(path.join(getcwd(), 'layouts', '*_q' + str(qubits) + '*'))
if len(filenames) > 0:
file = filenames[round(rand()*len(filenames)-0.5)]
return load_coupling(path.basename(file).split('.')[-2])["coupling_map"]
else:
return []
def load_coupling(name):
"""
Loads the coupling map that is given as a json file from a subfolder named layouts
Args:
name (string): name of the coupling map that was used when saving
(corresponds to the filename without the extension .json)
Returns:
dict
{
"qubits" : the number of qubits in the coupling map
"name": coupling map name
"coupling_map" : actual coupling map as used by QISKit
"position" : arrangement of the qubits in 2D if available
"description": additional information on the coupling map
}
"""
import json
with open("./layouts/"+name+".json", 'r') as infile:
temp = json.load(infile)
temp["coupling_map"] = {int(ii): kk for ii, kk in temp["coupling_map"].items()}
return temp
def _compile_circuits(compile_args):
name = compile_args[0]
circuit = compile_args[1]
comp_type = compile_args[2]
compiler_function = compile_args[3]
gate_costs = compile_args[4]
res_values = {}
res_values["name"] = name
# initialize error
circuit["error"] = {}
if comp_type == 0:
# Evaluate runtime of submitted compiler_function
try:
time_start = time.process_time()
circuit["dag_optimized"] = compiler_function(
circuit["dag_original"], coupling_map=circuit["coupling_map"],
gate_costs=gate_costs)
res_values["optimizer_time"] = time.process_time() - time_start
except:
circuit["dag_optimized"] = None
err = traceback.format_exc()
circuit["error"]["optimized"] = [err, name, circuit["coupling_map"]]
res_values["optimizer_time"] = -1
print(
"An error occurred in the user compiler while running " + name + " on " + str(
circuit["coupling_map"]) + '.')
pass
else:
# Evaluate runtime of qiskit compiler
try:
time_start = time.process_time()
circuit["dag_reference"] = _qiskit_compiler(
circuit["dag_original"], coupling_map=circuit["coupling_map"],
gate_costs=gate_costs)
res_values["reference_time"] = time.process_time() - time_start
except:
circuit["dag_reference"] = None
err = traceback.format_exc()
circuit["error"]["reference"] = [err, name, circuit["coupling_map"]]
res_values["reference_time"] = -1
print("An error occurred in the QISKit compiler while running " + name + " on " + str(
circuit["coupling_map"]) + '.')
pass
# Store the compiled circuits
res_values["circuit"] = circuit
return res_values
def _prep_sim(sim_args):
name = sim_args[0]
circuit = sim_args[1]
verbose = sim_args[2]
res_values = {}
res_values["name"] = name
# For simulation, delete all of the measurements
# original circuit
nlist = circuit["dag_original"].get_named_nodes("measure")
for n in nlist:
circuit["dag_original"]._remove_op_node(n)
# Skip verification of the reference State to speed things up!
# if verbose and circuit["dag_reference"] is not None:
# # reference circuit
# nlist = circuit["dag_reference"].get_named_nodes("measure")
# perm = {}
# for n in nlist:
# nd = circuit["dag_reference"].multi_graph.node[n]
# perm[nd["qargs"][0][1]] = nd["cargs"][0][1]
# circuit["dag_reference"]._remove_op_node(n)
# circuit["perm_reference"] = [perm[ii] for ii in range(len(perm))]
if circuit["dag_optimized"] is not None:
# optimized circuit
nlist = circuit["dag_optimized"].get_named_nodes("measure")
perm = {}
for n in nlist:
nd = circuit["dag_optimized"].multi_graph.node[n]
perm[nd["qargs"][0][1]] = nd["cargs"][0][1]
circuit["dag_optimized"]._remove_op_node(n)
circuit["perm_optimized"] = [perm[ii] for ii in range(len(perm))]
res_values["circuit"] = circuit
return res_values
def _qiskit_compiler(dag_circuit, coupling_map=None, gate_costs=None):
import copy
from qiskit.mapper import swap_mapper, direction_mapper, cx_cancellation, optimize_1q_gates, Coupling
from qiskit import qasm, unroll
initial_layout = None
coupling = Coupling(coupling_map)
compiled_dag, final_layout = swap_mapper(copy.deepcopy(dag_circuit), coupling, initial_layout, trials=40, seed=19)
# Expand swaps
basis_gates = "u1,u2,u3,cx,id" # QE target basis
program_node_circuit = qasm.Qasm(data=compiled_dag.qasm()).parse()
unroller_circuit = unroll.Unroller(program_node_circuit,
unroll.DAGBackend(
basis_gates.split(",")))
compiled_dag = unroller_circuit.execute()
# Change cx directions
compiled_dag = direction_mapper(compiled_dag, coupling)
# Simplify cx gates
cx_cancellation(compiled_dag)
# Simplify single qubit gates
compiled_dag = optimize_1q_gates(compiled_dag)
# Return the compiled dag circuit
return compiled_dag
def _get_perm(perm):
# get the permutation indices for the compiled quantum state given the permutation
n = len(perm)
res = np.arange(2**n)
for num_ind in range(2**n):
ss_orig = [digit for digit in bin(num_ind)[2:].zfill(n)]
ss_final = ss_orig.copy()
for ii in range(n):
ss_final[n-1-ii] = ss_orig[n-1-perm[ii]]
res[num_ind] = int(''.join(ss_final),2)
return list(res)
def _compare_outputs(data_original, data_compiled, permutation, threshold=ERROR_LIMIT):
# compare the output states of the original and the compiled circuit
# the bits of the compiled output state are permuted according to permutation before comparision
if 'quantum_state' in data_original \
and 'quantum_state' in data_compiled:
state = data_compiled.get('quantum_state')
target = data_original.get('quantum_state')
elif 'quantum_states' in data_original \
and 'quantum_states' in data_compiled:
state = data_compiled.get('quantum_states')[0]
target = data_original.get('quantum_states')[0]
else:
return False
state = state[_get_perm(permutation)]
fidelity = state_fidelity(target, state)
#print("fidelity = ", fidelity)
return abs(fidelity - 1.0) < threshold
def _compose_qobj(qobj_name, test_circuits,
backend="local_qasm_simulator",
config=None,
basis_gates='u1,u2,u3,id,cx',
shots=1,
max_credits=3,
seed=None):
qobj_out = {"id": qobj_name+"_test_circuits",
"config": config,
"circuits": []}
qobj_out["config"] = {"max_credits": max_credits,
"backend": backend,
"seed": seed,
"shots": shots}
for name, circuit in test_circuits.items():
# only add the job if there was no error in generating the circuit
if circuit["dag_"+qobj_name] is not None:
job = {}
job["name"] = name
# config parameters used by the runner
if config is None:
config = {} # default to empty config dict
job["config"] = copy.deepcopy(config)
job["config"]["basis_gates"] = basis_gates
job["config"]["seed"] = seed
# Add circuit
dag_circuit = copy.deepcopy(circuit["dag_"+qobj_name])
job["compiled_circuit"] = dag2json(dag_circuit,
basis_gates=basis_gates)
job["compiled_circuit_qasm"] = dag_circuit.qasm(qeflag=True)
qobj_out["circuits"].append(copy.deepcopy(job))
return qobj_out
|
https://github.com/MahmoodSpewAfsh/4-Qubit-Teleportation
|
MahmoodSpewAfsh
|
from qiskit import *
Q4Teleportation01 = QuantumCircuit(4, 4)
%matplotlib inline
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.x(0)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.h(1)
Q4Teleportation01.cnot(1, 2)
Q4Teleportation01.cnot(1, 3)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.cnot(1, 2)
Q4Teleportation01.cnot(0, 1)
Q4Teleportation01.h(0)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.measure([0, 1, 2], [0, 1 , 2])
Q4Teleportation01.draw(output='mpl')
Q4Teleportation01.cx(1, 3)
Q4Teleportation01.cz(0, 3)
Q4Teleportation01.barrier()
Q4Teleportation01.draw(output='mpl')
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""mpl circuit visualization style."""
import json
import os
from warnings import warn
from qiskit import user_config
class DefaultStyle:
"""Creates a Default Style dictionary
**Style Dict Details**
The style dict contains numerous options that define the style of the
output circuit visualization. The style dict is used by the `mpl` or
`latex` output. The options available in the style dict are defined below:
name (str): the name of the style. The name can be set to ``iqx``,
``iqx-dark``, ``textbook``, ``bw``, ``default``, or the name of a
user-created json file. This overrides the setting in the user config
file (usually ``~/.qiskit/settings.conf``).
textcolor (str): the color code to use for all text not inside a gate.
Defaults to ``#000000``
subtextcolor (str): the color code to use for subtext. Defaults to
``#000000``
linecolor (str): the color code to use for lines. Defaults to
``#000000``
creglinecolor (str): the color code to use for classical register
lines. Defaults to ``#778899``
gatetextcolor (str): the color code to use for gate text. Defaults to
``#000000``
gatefacecolor (str): the color code to use for a gate if no color
specified in the 'displaycolor' dict. Defaults to ``#BB8BFF``
barrierfacecolor (str): the color code to use for barriers. Defaults to
``#BDBDBD``
backgroundcolor (str): the color code to use for the background.
Defaults to ``#FFFFFF``
edgecolor (str): the color code to use for gate edges when using the
`bw` style. Defaults to ``#000000``.
fontsize (int): the font size to use for text. Defaults to 13.
subfontsize (int): the font size to use for subtext. Defaults to 8.
showindex (bool): if set to True, show the index numbers at the top.
Defaults to False.
figwidth (int): the maximum width (in inches) for the output figure.
If set to -1, the maximum displayable width will be used.
Defaults to -1.
dpi (int): the DPI to use for the output image. Defaults to 150.
margin (list): a list of margin values to adjust spacing around output
image. Takes a list of 4 ints: [x left, x right, y bottom, y top].
Defaults to [2.0, 0.1, 0.1, 0.3].
creglinestyle (str): The style of line to use for classical registers.
Choices are ``solid``, ``doublet``, or any valid matplotlib
`linestyle` kwarg value. Defaults to ``doublet``.
displaytext (dict): a dictionary of the text to use for certain element
types in the output visualization. These items allow the use of
LaTeX formatting for gate names. The 'displaytext' dict can contain
any number of elements. User created names and labels may be used as
keys, which allow these to have Latex formatting. The default
values are (`default.json`)::
{
'u1': 'U_1',
'u2': 'U_2',
'u3': 'U_3',
'sdg': 'S^\\dagger',
'sx': '\\sqrt{X}',
'sxdg': '\\sqrt{X}^\\dagger',
't': 'T',
'tdg': 'T^\\dagger',
'dcx': 'Dcx',
'iswap': 'Iswap',
'ms': 'MS',
'rx': 'R_X',
'ry': 'R_Y',
'rz': 'R_Z',
'rxx': 'R_{XX}',
'ryy': 'R_{YY}',
'rzx': 'R_{ZX}',
'rzz': 'ZZ',
'reset': '\\left|0\\right\\rangle',
'initialize': '|\\psi\\rangle'
}
displaycolor (dict): the color codes to use for each circuit element in
the form (gate_color, text_color). Colors can also be entered without
the text color, such as 'u1': '#FA74A6', in which case the text color
will always be `gatetextcolor`. The `displaycolor` dict can contain
any number of elements. User names and labels may be used as keys,
which allows for custom colors for user-created gates. The default
values are (`default.json`)::
{
'u1': ('#FA74A6', '#000000'),
'u2': ('#FA74A6', '#000000'),
'u3': ('#FA74A6', '#000000'),
'id': ('#05BAB6', '#000000'),
'u': ('#BB8BFF', '#000000'),
'p': ('#BB8BFF', '#000000'),
'x': ('#05BAB6', '#000000'),
'y': ('#05BAB6', '#000000'),
'z': ('#05BAB6', '#000000'),
'h': ('#6FA4FF', '#000000'),
'cx': ('#6FA4FF', '#000000'),
'ccx': ('#BB8BFF', '#000000'),
'mcx': ('#BB8BFF', '#000000'),
'mcx_gray': ('#BB8BFF', '#000000'),
'cy': ('#6FA4FF', '#000000'),
'cz': ('#6FA4FF', '#000000'),
'swap': ('#6FA4FF', '#000000'),
'cswap': ('#BB8BFF', '#000000'),
'ccswap': ('#BB8BFF', '#000000'),
'dcx': ('#6FA4FF', '#000000'),
'cdcx': ('#BB8BFF', '#000000'),
'ccdcx': ('#BB8BFF', '#000000'),
'iswap': ('#6FA4FF', '#000000'),
's': ('#6FA4FF', '#000000'),
'sdg': ('#6FA4FF', '#000000'),
't': ('#BB8BFF', '#000000'),
'tdg': ('#BB8BFF', '#000000'),
'sx': ('#6FA4FF', '#000000'),
'sxdg': ('#6FA4FF', '#000000')
'r': ('#BB8BFF', '#000000'),
'rx': ('#BB8BFF', '#000000'),
'ry': ('#BB8BFF', '#000000'),
'rz': ('#BB8BFF', '#000000'),
'rxx': ('#BB8BFF', '#000000'),
'ryy': ('#BB8BFF', '#000000'),
'rzx': ('#BB8BFF', '#000000'),
'reset': ('#000000', '#FFFFFF'),
'target': ('#FFFFFF', '#FFFFFF'),
'measure': ('#000000', '#FFFFFF'),
}
"""
def __init__(self):
colors = {
"### Default Colors": "Default Colors",
"basis": "#FA74A6", # Red
"clifford": "#6FA4FF", # Light Blue
"pauli": "#05BAB6", # Green
"def_other": "#BB8BFF", # Purple
"### IQX Colors": "IQX Colors",
"classical": "#002D9C", # Dark Blue
"phase": "#33B1FF", # Cyan
"hadamard": "#FA4D56", # Light Red
"non_unitary": "#A8A8A8", # Medium Gray
"iqx_other": "#9F1853", # Dark Red
"### B/W": "B/W",
"black": "#000000",
"white": "#FFFFFF",
"dark_gray": "#778899",
"light_gray": "#BDBDBD",
}
self.style = {
"name": "default",
"tc": colors["black"], # Non-gate Text Color
"gt": colors["black"], # Gate Text Color
"sc": colors["black"], # Gate Subtext Color
"lc": colors["black"], # Line Color
"cc": colors["dark_gray"], # creg Line Color
"gc": colors["def_other"], # Default Gate Color
"bc": colors["light_gray"], # Barrier Color
"bg": colors["white"], # Background Color
"ec": None, # Edge Color (B/W only)
"fs": 13, # Gate Font Size
"sfs": 8, # Subtext Font Size
"index": False,
"figwidth": -1,
"dpi": 150,
"margin": [2.0, 0.1, 0.1, 0.3],
"cline": "doublet",
"disptex": {
"u1": "U_1",
"u2": "U_2",
"u3": "U_3",
"id": "I",
"sdg": "S^\\dagger",
"sx": "\\sqrt{X}",
"sxdg": "\\sqrt{X}^\\dagger",
"tdg": "T^\\dagger",
"ms": "MS",
"rx": "R_X",
"ry": "R_Y",
"rz": "R_Z",
"rxx": "R_{XX}",
"ryy": "R_{YY}",
"rzx": "R_{ZX}",
"rzz": "ZZ",
"reset": "\\left|0\\right\\rangle",
"initialize": "$|\\psi\\rangle$",
},
"dispcol": {
"u1": (colors["basis"], colors["black"]),
"u2": (colors["basis"], colors["black"]),
"u3": (colors["basis"], colors["black"]),
"u": (colors["def_other"], colors["black"]),
"p": (colors["def_other"], colors["black"]),
"id": (colors["pauli"], colors["black"]),
"x": (colors["pauli"], colors["black"]),
"y": (colors["pauli"], colors["black"]),
"z": (colors["pauli"], colors["black"]),
"h": (colors["clifford"], colors["black"]),
"cx": (colors["clifford"], colors["black"]),
"ccx": (colors["def_other"], colors["black"]),
"mcx": (colors["def_other"], colors["black"]),
"mcx_gray": (colors["def_other"], colors["black"]),
"cy": (colors["clifford"], colors["black"]),
"cz": (colors["clifford"], colors["black"]),
"swap": (colors["clifford"], colors["black"]),
"cswap": (colors["def_other"], colors["black"]),
"ccswap": (colors["def_other"], colors["black"]),
"dcx": (colors["clifford"], colors["black"]),
"cdcx": (colors["def_other"], colors["black"]),
"ccdcx": (colors["def_other"], colors["black"]),
"iswap": (colors["clifford"], colors["black"]),
"s": (colors["clifford"], colors["black"]),
"sdg": (colors["clifford"], colors["black"]),
"t": (colors["def_other"], colors["black"]),
"tdg": (colors["def_other"], colors["black"]),
"sx": (colors["clifford"], colors["black"]),
"sxdg": (colors["clifford"], colors["black"]),
"r": (colors["def_other"], colors["black"]),
"rx": (colors["def_other"], colors["black"]),
"ry": (colors["def_other"], colors["black"]),
"rz": (colors["def_other"], colors["black"]),
"rxx": (colors["def_other"], colors["black"]),
"ryy": (colors["def_other"], colors["black"]),
"rzx": (colors["def_other"], colors["black"]),
"reset": (colors["black"], colors["white"]),
"target": (colors["white"], colors["white"]),
"measure": (colors["black"], colors["white"]),
},
}
def load_style(style):
"""Utility function to load style from json files and call set_style."""
current_style = DefaultStyle().style
style_name = "default"
def_font_ratio = current_style["fs"] / current_style["sfs"]
config = user_config.get_config()
if style is None:
if config:
style = config.get("circuit_mpl_style", "default")
else:
style = "default"
if style is False:
style_name = "bw"
elif isinstance(style, dict) and "name" in style:
style_name = style["name"]
elif isinstance(style, str):
style_name = style
elif not isinstance(style, (str, dict)):
warn(
f"style parameter '{style}' must be a str or a dictionary. Will use default style.",
UserWarning,
2,
)
if style_name.endswith(".json"):
style_name = style_name[:-5]
# Search for file in 'styles' dir, then config_path, and finally 'cwd'
style_path = []
if style_name != "default":
style_name = style_name + ".json"
spath = os.path.dirname(os.path.abspath(__file__))
style_path.append(os.path.join(spath, "styles", style_name))
if config:
config_path = config.get("circuit_mpl_style_path", "")
if config_path:
for path in config_path:
style_path.append(os.path.normpath(os.path.join(path, style_name)))
style_path.append(os.path.normpath(os.path.join("", style_name)))
for path in style_path:
exp_user = os.path.expanduser(path)
if os.path.isfile(exp_user):
try:
with open(exp_user) as infile:
json_style = json.load(infile)
set_style(current_style, json_style)
break
except json.JSONDecodeError as err:
warn(
f"Could not decode JSON in file '{path}': {str(err)}. "
"Will use default style.",
UserWarning,
2,
)
break
except (OSError, FileNotFoundError):
warn(
f"Error loading JSON file '{path}'. Will use default style.",
UserWarning,
2,
)
break
else:
warn(
f"Style JSON file '{style_name}' not found in any of these locations: "
f"{', '.join(style_path)}. "
"Will use default style.",
UserWarning,
2,
)
if isinstance(style, dict):
set_style(current_style, style)
return current_style, def_font_ratio
def set_style(current_style, new_style):
"""Utility function to take elements in new_style and
write them into current_style.
"""
valid_fields = {
"name",
"textcolor",
"gatetextcolor",
"subtextcolor",
"linecolor",
"creglinecolor",
"gatefacecolor",
"barrierfacecolor",
"backgroundcolor",
"edgecolor",
"fontsize",
"subfontsize",
"showindex",
"figwidth",
"dpi",
"margin",
"creglinestyle",
"displaytext",
"displaycolor",
}
current_style.update(new_style)
current_style["tc"] = current_style.get("textcolor", current_style["tc"])
current_style["gt"] = current_style.get("gatetextcolor", current_style["gt"])
current_style["sc"] = current_style.get("subtextcolor", current_style["sc"])
current_style["lc"] = current_style.get("linecolor", current_style["lc"])
current_style["cc"] = current_style.get("creglinecolor", current_style["cc"])
current_style["gc"] = current_style.get("gatefacecolor", current_style["gc"])
current_style["bc"] = current_style.get("barrierfacecolor", current_style["bc"])
current_style["bg"] = current_style.get("backgroundcolor", current_style["bg"])
current_style["ec"] = current_style.get("edgecolor", current_style["ec"])
current_style["fs"] = current_style.get("fontsize", current_style["fs"])
current_style["sfs"] = current_style.get("subfontsize", current_style["sfs"])
current_style["index"] = current_style.get("showindex", current_style["index"])
current_style["cline"] = current_style.get("creglinestyle", current_style["cline"])
current_style["disptex"] = {**current_style["disptex"], **new_style.get("displaytext", {})}
current_style["dispcol"] = {**current_style["dispcol"], **new_style.get("displaycolor", {})}
unsupported_keys = set(new_style) - valid_fields
if unsupported_keys:
warn(
f"style option/s ({', '.join(unsupported_keys)}) is/are not supported",
UserWarning,
2,
)
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeVigoV2
from qiskit.visualization import plot_circuit_layout
from qiskit.tools.monitor import job_monitor
from qiskit.providers.fake_provider import FakeVigoV2
import matplotlib.pyplot as plt
ghz = QuantumCircuit(3, 3)
ghz.h(0)
for idx in range(1,3):
ghz.cx(0,idx)
ghz.measure(range(3), range(3))
backend = FakeVigoV2()
new_circ_lv3 = transpile(ghz, backend=backend, optimization_level=3)
plot_circuit_layout(new_circ_lv3, backend)
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
from qiskit.transpiler.coupling import CouplingMap
def pretty_print(edge_list, simple=False):
if simple:
temp = list(edge_list)
temp2 = []
for i, j in temp:
if not (j, i) in temp2:
temp2.append((i, j))
edge_list = temp2
x = CouplingMap(edge_list)
# black magic errors when I modify the draw function directly in the CouplingMap file so Im just copying the code here to make it work
import pydot
from PIL import Image
import io
formatter2 = lambda _: dict(dir="none")
dot_str = x.graph.to_dot(edge_attr=formatter2, graph_attr={"size": "0"})
dot = pydot.graph_from_dot_data(dot_str)[0]
png = dot.create_png(prog="sfdp")
pdf = dot.create_pdf(prog="sfdp")
# png = dot.create_png(prog="neato")
return Image.open(io.BytesIO(png))
def snail_to_connectivity(snail_edge_list):
# Convert snail edge list where nodes are snails and edges are qubits
# To connectivity edge list where nodes are qubits and edges are coupling
edge_list = []
# qubits are coupled to a snail edge if they are both adjacent to a snail node
for qubit, snail_edge in enumerate(snail_edge_list):
for temp_qubit, temp_snail_edge in enumerate(snail_edge_list):
if qubit != temp_qubit and (
snail_edge[0] in temp_snail_edge or snail_edge[1] in temp_snail_edge
):
edge_list.append((qubit, temp_qubit))
return edge_list
snail_edge_list = [
(0, 1),
(0, 1),
(0, 2),
(0, 3),
(1, 2),
(1, 4),
(2, 3),
(2, 4),
(3, 4),
(3, 4),
]
pretty_print(snail_edge_list)
edge_list = snail_to_connectivity(snail_edge_list)
pretty_print(edge_list, simple=True)
# define corral
def corral(skip_pattern):
num_snails = 32
num_levels = 2
assert len(skip_pattern) == num_levels
snail_edge_list = []
for snail0, snail1 in zip(range(num_snails), range(1, num_snails + 1)):
for i in range(num_levels):
snail_edge_list.append((snail0, (skip_pattern[i] + snail1) % num_snails))
return snail_edge_list
snail_edge_list = corral((0, 0))
# some manual modifications for spanning across
snail_edge_list.remove((0, 1))
snail_edge_list.append((0, 16))
snail_edge_list.remove((16, 17))
snail_edge_list.append((0, 16))
pretty_print(snail_edge_list)
edge_list = snail_to_connectivity(snail_edge_list)
pretty_print(edge_list, simple=True)
snail_edge_list = corral((0, 0))
offset = 1 + max([el[1] for el in snail_edge_list])
snail_edge_list_2 = [(offset + el[0], offset + el[1]) for el in corral((0, 0))]
pretty_print(snail_edge_list_2)
# delete edges
snail_edge_list.remove((7, 0))
snail_edge_list.remove((0, 1))
snail_edge_list_2.remove((15, 8))
snail_edge_list_2.remove((8, 9))
# joining edges
snail_edge_list = snail_edge_list + snail_edge_list_2
snail_edge_list = [
(el[0], 0) if el[1] == 8 else (el[0], el[1]) for el in snail_edge_list
]
snail_edge_list = [
(0, el[1]) if el[0] == 8 else (el[0], el[1]) for el in snail_edge_list
]
pretty_print(snail_edge_list)
edge_list = snail_to_connectivity(snail_edge_list)
pretty_print(edge_list, simple=True)
|
https://github.com/PacktPublishing/Quantum-Computing-in-Practice-with-Qiskit-and-IBM-Quantum-Experience
|
PacktPublishing
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created Nov 2020
@author: hassi
"""
print('\nChapter 8: Shor Code')
print('---------------------')
from qiskit import QuantumCircuit, execute, Aer
from qiskit.visualization import plot_bloch_multivector, plot_state_qsphere
# Supporting methods
from math import pi
from random import random
from IPython.core.display import display
# Set the Aer simulator backend
backend = Aer.get_backend('qasm_simulator')
# Function that returns the state vector (Psi) for the qc
def get_psi(qc):
global psi
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result()
psi = result.get_statevector(qc)
return(psi)
# Function that adds an error to the first qubit
def add_error(error, circuit,ry_error, rz_error):
circuit.barrier([x for x in range(circuit.num_qubits)])
if error=="1": #Bit flip error
circuit.x(0)
elif error=="2": #Bit flip plus phase flip error
circuit.x(0)
circuit.z(0)
else: #Theta plus phi shift and Random
circuit.ry(ry_error,0)
circuit.rz(rz_error,0)
circuit.barrier([x for x in range(circuit.num_qubits)])
return(circuit)
def not_corrected(error, ry_error, rz_error):
# Non-corrected code
qco = QuantumCircuit(1,1)
print("\nOriginal qubit, in state |0>")
display(plot_bloch_multivector(get_psi(qco)))
display(plot_state_qsphere(get_psi(qco)))
# Add error
add_error(error,qco, ry_error, rz_error)
print("\nQubit with error...")
display(plot_bloch_multivector(get_psi(qco)))
display(plot_state_qsphere(get_psi(qco)))
qco.measure(0,0)
display(qco.draw('mpl'))
job = execute(qco, backend, shots=1000)
counts = job.result().get_counts()
print("\nResult of qubit error:")
print("-----------------------")
print(counts)
def shor_corrected(error, ry_error, rz_error):
# A combination of a three qubit phase flip code, and 3 bit flip codes
qc = QuantumCircuit(9,1)
print("\nOriginal LSB qubit, in state |...0>")
display(plot_state_qsphere(get_psi(qc)))
# Start of phase flip code
qc.cx(0,3)
qc.cx(0,6)
qc.h(0)
qc.h(3)
qc.h(6)
qc.barrier([x for x in range(qc.num_qubits)])
# Start of bit flip codes
qc.cx(0,1)
qc.cx(3,4)
qc.cx(6,7)
qc.cx(0,2)
qc.cx(3,5)
qc.cx(6,8)
# Error code
add_error(error,qc, ry_error, rz_error)
print("Qubit with error... LSB can be in |...0> and in |...1>, with various phase.")
display(plot_state_qsphere(get_psi(qc)))
display(qc.draw('mpl'))
# End of bit flip codes
qc.cx(0,1)
qc.cx(3,4)
qc.cx(6,7)
qc.cx(0,2)
qc.cx(3,5)
qc.cx(6,8)
qc.ccx(1,2,0)
qc.ccx(4,5,3)
qc.ccx(8,7,6)
# End of phase flip code
qc.h(0)
qc.h(3)
qc.h(6)
qc.cx(0,3)
qc.cx(0,6)
qc.ccx(6,3,0)
qc.barrier([x for x in range(qc.num_qubits)])
qc.measure(0,0)
print("Error corrected qubit... LSB in |...0> with phase 0.")
display(plot_state_qsphere(get_psi(qc)))
display(qc.draw('mpl'))
job = execute(qc, backend, shots=1000)
counts = job.result().get_counts()
print("\nResult of qubit error after Shor code correction:")
print("--------------------------------------------------")
print(counts)
def main():
error="1"
ry_error=0
rz_error=0
while error!="0":
error=input("Select an error:\n1. Bit flip\n2. Bit flip plus phase flip\n3. Theta plus phi shift\n4. Random\n")
if error=="3":
ry_error=float(input("Enter theta:\n"))
rz_error=float(input("Enter phi:\n"))
if error=="4":
ry_error=pi*random()
rz_error=2*pi*random()
not_corrected(error, ry_error, rz_error)
input("Press enter for error correction...")
shor_corrected(error, ry_error, rz_error)
if __name__ == '__main__':
main()
|
https://github.com/MonitSharma/Qiskit-Summer-School-and-Quantum-Challenges
|
MonitSharma
|
# -*- 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.
"""
The Variational Quantum Eigensolver algorithm.
See https://arxiv.org/abs/1304.3061
"""
import logging
import functools
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit
from qiskit.aqua.algorithms.adaptive.vq_algorithm import VQAlgorithm
from qiskit.aqua import AquaError, Pluggable, PluggableType, get_pluggable_class
from qiskit.aqua.utils.backend_utils import is_aer_statevector_backend
from qiskit.aqua.utils import find_regs_by_name
logger = logging.getLogger(__name__)
class VQE(VQAlgorithm):
"""
The Variational Quantum Eigensolver algorithm.
See https://arxiv.org/abs/1304.3061
"""
CONFIGURATION = {
'name': 'VQE',
'description': 'VQE Algorithm',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'vqe_schema',
'type': 'object',
'properties': {
'operator_mode': {
'type': 'string',
'default': 'matrix',
'oneOf': [
{'enum': ['matrix', 'paulis', 'grouped_paulis']}
]
},
'initial_point': {
'type': ['array', 'null'],
"items": {
"type": "number"
},
'default': None
},
'max_evals_grouped': {
'type': 'integer',
'default': 1
}
},
'additionalProperties': False
},
'problems': ['energy', 'ising'],
'depends': [
{'pluggable_type': 'optimizer',
'default': {
'name': 'L_BFGS_B'
}
},
{'pluggable_type': 'variational_form',
'default': {
'name': 'RYRZ'
}
},
],
}
def __init__(self, operator, var_form, optimizer, operator_mode='matrix',
initial_point=None, max_evals_grouped=1, aux_operators=None, callback=None):
"""Constructor.
Args:
operator (Operator): Qubit operator
operator_mode (str): operator mode, used for eval of operator
var_form (VariationalForm): parametrized variational form.
optimizer (Optimizer): the classical optimization algorithm.
initial_point (numpy.ndarray): optimizer initial point.
max_evals_grouped (int): max number of evaluations performed simultaneously
aux_operators (list of Operator): Auxiliary operators to be evaluated at each eigenvalue
callback (Callable): a callback that can access the intermediate data during the optimization.
Internally, four arguments are provided as follows
the index of evaluation, parameters of variational form,
evaluated mean, evaluated standard devation.
"""
self.validate(locals())
super().__init__(var_form=var_form,
optimizer=optimizer,
cost_fn=self._energy_evaluation,
initial_point=initial_point)
self._optimizer.set_max_evals_grouped(max_evals_grouped)
self._callback = callback
if initial_point is None:
self._initial_point = var_form.preferred_init_points
self._operator = operator
self._operator_mode = operator_mode
self._eval_count = 0
if aux_operators is None:
self._aux_operators = []
else:
self._aux_operators = [aux_operators] if not isinstance(aux_operators, list) else aux_operators
logger.info(self.print_settings())
@classmethod
def init_params(cls, params, algo_input):
"""
Initialize via parameters dictionary and algorithm input instance.
Args:
params (dict): parameters dictionary
algo_input (EnergyInput): EnergyInput instance
Returns:
VQE: vqe object
"""
if algo_input is None:
raise AquaError("EnergyInput instance is required.")
operator = algo_input.qubit_op
vqe_params = params.get(Pluggable.SECTION_KEY_ALGORITHM)
operator_mode = vqe_params.get('operator_mode')
initial_point = vqe_params.get('initial_point')
max_evals_grouped = vqe_params.get('max_evals_grouped')
# Set up variational form, we need to add computed num qubits
# Pass all parameters so that Variational Form can create its dependents
var_form_params = params.get(Pluggable.SECTION_KEY_VAR_FORM)
var_form_params['num_qubits'] = operator.num_qubits
var_form = get_pluggable_class(PluggableType.VARIATIONAL_FORM,
var_form_params['name']).init_params(params)
# Set up optimizer
opt_params = params.get(Pluggable.SECTION_KEY_OPTIMIZER)
optimizer = get_pluggable_class(PluggableType.OPTIMIZER,
opt_params['name']).init_params(params)
return cls(operator, var_form, optimizer, operator_mode=operator_mode,
initial_point=initial_point, max_evals_grouped=max_evals_grouped,
aux_operators=algo_input.aux_ops)
@property
def setting(self):
"""Prepare the setting of VQE as a string."""
ret = "Algorithm: {}\n".format(self._configuration['name'])
params = ""
for key, value in self.__dict__.items():
if key != "_configuration" and key[0] == "_":
if "initial_point" in key and value is None:
params += "-- {}: {}\n".format(key[1:], "Random seed")
else:
params += "-- {}: {}\n".format(key[1:], value)
ret += "{}".format(params)
return ret
def print_settings(self):
"""
Preparing the setting of VQE into a string.
Returns:
str: the formatted setting of VQE
"""
ret = "\n"
ret += "==================== Setting of {} ============================\n".format(self.configuration['name'])
ret += "{}".format(self.setting)
ret += "===============================================================\n"
ret += "{}".format(self._var_form.setting)
ret += "===============================================================\n"
ret += "{}".format(self._optimizer.setting)
ret += "===============================================================\n"
return ret
def construct_circuit(self, parameter, backend=None, use_simulator_operator_mode=False):
"""Generate the circuits.
Args:
parameters (numpy.ndarray): parameters for variational form.
backend (qiskit.BaseBackend): backend object.
use_simulator_operator_mode (bool): is backend from AerProvider, if True and mode is paulis,
single circuit is generated.
Returns:
[QuantumCircuit]: the generated circuits with Hamiltonian.
"""
input_circuit = self._var_form.construct_circuit(parameter)
if backend is None:
warning_msg = "Circuits used in VQE depends on the backend type, "
from qiskit import BasicAer
if self._operator_mode == 'matrix':
temp_backend_name = 'statevector_simulator'
else:
temp_backend_name = 'qasm_simulator'
backend = BasicAer.get_backend(temp_backend_name)
warning_msg += "since operator_mode is '{}', '{}' backend is used.".format(
self._operator_mode, temp_backend_name)
logger.warning(warning_msg)
circuit = self._operator.construct_evaluation_circuit(self._operator_mode,
input_circuit, backend, use_simulator_operator_mode)
return circuit
def _eval_aux_ops(self, threshold=1e-12, params=None):
if params is None:
params = self.optimal_params
wavefn_circuit = self._var_form.construct_circuit(params)
circuits = []
values = []
params = []
for operator in self._aux_operators:
if not operator.is_empty():
temp_circuit = QuantumCircuit() + wavefn_circuit
circuit = operator.construct_evaluation_circuit(self._operator_mode, temp_circuit,
self._quantum_instance.backend,
self._use_simulator_operator_mode)
params.append(operator.aer_paulis)
else:
circuit = None
circuits.append(circuit)
if len(circuits) > 0:
to_be_simulated_circuits = functools.reduce(lambda x, y: x + y, [c for c in circuits if c is not None])
if self._use_simulator_operator_mode:
extra_args = {'expectation': {
'params': params,
'num_qubits': self._operator.num_qubits}
}
else:
extra_args = {}
result = self._quantum_instance.execute(to_be_simulated_circuits, **extra_args)
for operator, circuit in zip(self._aux_operators, circuits):
if circuit is None:
mean, std = 0.0, 0.0
else:
mean, std = operator.evaluate_with_result(self._operator_mode,
circuit, self._quantum_instance.backend,
result, self._use_simulator_operator_mode)
mean = mean.real if abs(mean.real) > threshold else 0.0
std = std.real if abs(std.real) > threshold else 0.0
values.append((mean, std))
if len(values) > 0:
aux_op_vals = np.empty([1, len(self._aux_operators), 2])
aux_op_vals[0, :] = np.asarray(values)
self._ret['aux_ops'] = aux_op_vals
def _run(self):
"""
Run the algorithm to compute the minimum eigenvalue.
Returns:
Dictionary of results
"""
if not self._quantum_instance.is_statevector and self._operator_mode == 'matrix':
logger.warning('Qasm simulation does not work on {} mode, changing '
'the operator_mode to "paulis"'.format(self._operator_mode))
self._operator_mode = 'paulis'
self._use_simulator_operator_mode = \
is_aer_statevector_backend(self._quantum_instance.backend) \
and self._operator_mode != 'matrix'
self._quantum_instance.circuit_summary = True
self._eval_count = 0
self._ret = self.find_minimum(initial_point=self.initial_point,
var_form=self.var_form,
cost_fn=self._energy_evaluation,
optimizer=self.optimizer)
if self._ret['num_optimizer_evals'] is not None and self._eval_count >= self._ret['num_optimizer_evals']:
self._eval_count = self._ret['num_optimizer_evals']
self._eval_time = self._ret['eval_time']
logger.info('Optimization complete in {} seconds.\nFound opt_params {} in {} evals'.format(
self._eval_time, self._ret['opt_params'], self._eval_count))
self._ret['eval_count'] = self._eval_count
self._ret['energy'] = self.get_optimal_cost()
self._ret['eigvals'] = np.asarray([self.get_optimal_cost()])
self._ret['eigvecs'] = np.asarray([self.get_optimal_vector()])
self._eval_aux_ops()
return self._ret
# This is the objective function to be passed to the optimizer that is uses for evaluation
def _energy_evaluation(self, parameters):
"""
Evaluate energy at given parameters for the variational form.
Args:
parameters (numpy.ndarray): parameters for variational form.
Returns:
float or list of float: energy of the hamiltonian of each parameter.
"""
num_parameter_sets = len(parameters) // self._var_form.num_parameters
circuits = []
parameter_sets = np.split(parameters, num_parameter_sets)
mean_energy = []
std_energy = []
for idx in range(len(parameter_sets)):
parameter = parameter_sets[idx]
circuit = self.construct_circuit(parameter, self._quantum_instance.backend, self._use_simulator_operator_mode)
circuits.append(circuit)
to_be_simulated_circuits = functools.reduce(lambda x, y: x + y, circuits)
if self._use_simulator_operator_mode:
extra_args = {'expectation': {
'params': [self._operator.aer_paulis],
'num_qubits': self._operator.num_qubits}
}
else:
extra_args = {}
result = self._quantum_instance.execute(to_be_simulated_circuits, **extra_args)
for idx in range(len(parameter_sets)):
mean, std = self._operator.evaluate_with_result(
self._operator_mode, circuits[idx], self._quantum_instance.backend, result, self._use_simulator_operator_mode)
mean_energy.append(np.real(mean))
std_energy.append(np.real(std))
self._eval_count += 1
if self._callback is not None:
self._callback(self._eval_count, parameter_sets[idx], np.real(mean), np.real(std))
logger.info('Energy evaluation {} returned {}'.format(self._eval_count, np.real(mean)))
return mean_energy if len(mean_energy) > 1 else mean_energy[0]
def get_optimal_cost(self):
if 'opt_params' not in self._ret:
raise AquaError("Cannot return optimal cost before running the algorithm to find optimal params.")
return self._ret['min_val']
def get_optimal_circuit(self):
if 'opt_params' not in self._ret:
raise AquaError("Cannot find optimal circuit before running the algorithm to find optimal params.")
return self._var_form.construct_circuit(self._ret['opt_params'])
def get_optimal_vector(self):
if 'opt_params' not in self._ret:
raise AquaError("Cannot find optimal vector before running the algorithm to find optimal params.")
qc = self.get_optimal_circuit()
if self._quantum_instance.is_statevector:
ret = self._quantum_instance.execute(qc)
self._ret['min_vector'] = ret.get_statevector(qc, decimals=16)
else:
c = ClassicalRegister(qc.width(), name='c')
q = find_regs_by_name(qc, 'q')
qc.add_register(c)
qc.barrier(q)
qc.measure(q, c)
ret = self._quantum_instance.execute(qc)
self._ret['min_vector'] = ret.get_counts(qc)
return self._ret['min_vector']
@property
def optimal_params(self):
if 'opt_params' not in self._ret:
raise AquaError("Cannot find optimal params before running the algorithm.")
return self._ret['opt_params']
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.library import MCXGate
gate = MCXGate(4)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(5)
circuit.append(gate, [0, 1, 4, 2, 3])
circuit.draw('mpl')
|
https://github.com/hephaex/Quantum-Computing-Awesome-List
|
hephaex
|
pip install cirq
import cirq
circuit = cirq.Circuit()
(q0,q1) = cirq.LineQubit.range(2)
circuit.append([cirq.H(q0), cirq.CNOT(q0, q1)])
circuit.append([cirq.measure(q0), cirq.measure(q1)])
print(circuit)
sim = cirq.Simulator()
results = sim.run(circuit, repetitions=10)
print(results)
|
https://github.com/peiyong-addwater/Hackathon-QNLP
|
peiyong-addwater
|
import collections
import pickle
import warnings
warnings.filterwarnings("ignore")
import os
from random import shuffle
import re
import spacy
from discopy.tensor import Tensor
from discopy import Word
from discopy.rigid import Functor
import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
import numpy as np
from numpy import random, unique
from lambeq import AtomicType, IQPAnsatz, remove_cups, NumpyModel, spiders_reader
from lambeq import BobcatParser, TreeReader, cups_reader, DepCCGParser
from lambeq import Dataset
from lambeq import QuantumTrainer, SPSAOptimizer
from lambeq import TketModel
from lambeq import SpacyTokeniser
from pytket.extensions.qiskit import AerBackend
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem import WordNetLemmatizer, PorterStemmer
from nltk import pos_tag, ne_chunk
from nltk.chunk import tree2conlltags
import seaborn as sns
import matplotlib.pyplot as plt
from collections import Counter
import nltk
nltk.download('stopwords')
nltk.download('punkt')
nltk.download('wordnet')
nltk.download('averaged_perceptron_tagger')
nltk.download('maxent_ne_chunker')
nltk.download('words')
nltk.download('omw-1.4')
pd.set_option('display.width', 1000)
pd.options.display.max_colwidth=80
print(os.getcwd())
warnings.filterwarnings("ignore")
os.environ["TOKENIZERS_PARALLELISM"] = "false"
spacy.load('en_core_web_sm')
MAX_LENGTH = 5
BATCH_SIZE = 30
EPOCHS = 100
SEED = 0
random.seed(SEED)
def get_sent_length(sent):
if type(sent) is not str:
return 9999999
word_list = sent.split(" ")
return len(word_list)
columns = ["Id","Entity","Target","Text"]
data = pd.read_csv(os.path.join(os.getcwd(),"data/twitter_training.csv"), names=columns,header=None)
#data = data.sample(frac=1).reset_index(drop=True)
data_val = pd.read_csv(os.path.join(os.getcwd(), "data/twitter_validation.csv"), names=columns,header=None)
#data_val = data.sample(frac=1).reset_index(drop=True)
df_train = data[["Text","Target"]]
df_train = df_train.loc[(df_train["Target"]=='Positive') | (df_train["Target"]=='Negative') & (df_train["Text"]!=np.nan)&(df_train["Text"].map(get_sent_length)<=MAX_LENGTH)]
df_train= df_train.drop_duplicates()
df_val = data_val[['Text', 'Target']]
df_val = df_val.loc[(df_val['Target'] == 'Positive') | (df_val['Target'] == 'Negative') & (df_val["Text"]!=np.nan)&(df_val["Text"].map(get_sent_length)<=MAX_LENGTH)]
text_cleaning_re = "@\S+|https?:\S+|http?:\S|[^A-Za-z0-9]+"
emoji_pattern = re.compile("["
u"\U0001F600-\U0001F64F" # emoticons
u"\U0001F300-\U0001F5FF" # symbols & pictographs
u"\U0001F680-\U0001F6FF" # transport & map symbols
u"\U0001F1E0-\U0001F1FF" # flags (iOS)
"]+", flags=re.UNICODE)
def preprocess(text):
text = re.sub(text_cleaning_re, ' ', str(text).lower()).strip()
without_emoji = emoji_pattern.sub(r'', text)
tokens = word_tokenize(str(without_emoji).replace("'", "").lower())
# Remove Puncs
without_punc = [w for w in tokens if w.isalpha()]
# Lemmatize
text_len = [WordNetLemmatizer().lemmatize(t) for t in without_punc]
# Stem
text_cleaned = [PorterStemmer().stem(w) for w in text_len]
return " ".join(text_cleaned)
df_train["Text"]= df_train["Text"].str.replace("im","i am")
df_train["Text"]= df_train["Text"].str.replace("it's","it is")
df_train["Text"]= df_train["Text"].str.replace("you're","you are")
df_train["Text"]= df_train["Text"].str.replace("hasn't","has not")
df_train["Text"]= df_train["Text"].str.replace("haven't","have not")
df_train["Text"]= df_train["Text"].str.replace("don't","do not")
df_train["Text"]= df_train["Text"].str.replace("doesn't","does not")
df_train["Text"]= df_train["Text"].str.replace("won't","will not")
df_train["Text"]= df_train["Text"].str.replace("shouldn't","should not")
df_train["Text"]= df_train["Text"].str.replace("can't","can not")
df_train["Text"]= df_train["Text"].str.replace("couldn't","could not")
df_val["Text"] = df_val["Text"].str.replace("im","i am")
df_val["Text"]= df_val["Text"].str.replace("it's","it is")
df_val["Text"]= df_val["Text"].str.replace("you're","you are")
df_val["Text"]= df_val["Text"].str.replace("hasn't","has not")
df_val["Text"]= df_val["Text"].str.replace("haven't","have not")
df_val["Text"] = df_val["Text"].str.replace("don't","do not")
df_val["Text"] = df_val["Text"].str.replace("doesn't","does not")
df_val["Text"] = df_val["Text"].str.replace("won't","will not")
df_val["Text"] = df_val["Text"].str.replace("shouldn't","should not")
df_val["Text"] = df_val["Text"].str.replace("can't","can not")
df_val["Text"] = df_val["Text"].str.replace("couldn't","could not")
df_train["Text"] = df_train["Text"].apply(preprocess)
df_val["Text"] = df_val["Text"].apply(preprocess)
df_train = df_train.dropna()
df_val = df_val.dropna()
negative_train_df = df_train.loc[df_train["Target"]=="Negative"]
positive_train_df = df_train.loc[df_train["Target"]=='Positive']
if len(positive_train_df)>=len(negative_train_df):
positive_train_df = positive_train_df.head(len(negative_train_df))
else:
negative_train_df = negative_train_df.head(len(positive_train_df))
negative_val_df = df_val.loc[df_val['Target'] == 'Negative']
positive_val_df = df_val.loc[df_val['Target'] == 'Positive']
if len(positive_val_df)>=len(negative_val_df):
positive_val_df = positive_val_df.head(len(negative_val_df))
else:
negative_val_df = negative_val_df.head(len(positive_val_df))
df_train = pd.concat([positive_train_df, negative_train_df])
df_val = pd.concat([positive_val_df, negative_val_df])
# Positive sentiment to [0,1], negative sentiment to [1,0]
sentiment_train = []
sentiment_val = []
for i in df_train["Target"]:
if i == "Positive":
sentiment_train.append([0,1])
else:
sentiment_train.append([1,0])
df_train["Sentiment"] = sentiment_train
for i in df_val["Target"]:
if i == "Positive":
sentiment_val.append([0,1])
else:
sentiment_val.append([1,0])
df_val["Sentiment"] = sentiment_val
df_train.info()
df_val.info()
df_train.head()
df_val.head()
sns.countplot(x = "Target", data = df_train)
sns.countplot(x = "Target", data = df_val)
train_data_all, train_label_all = df_train["Text"].tolist(), df_train["Sentiment"].tolist()
dev_data, dev_labels = df_val["Text"].tolist(), df_val["Sentiment"].tolist()
data = train_data_all+dev_data
labels = train_label_all+dev_labels
pairs = []
for c in zip(labels, data):
if len(c[1]) != 0 and len(c[1].split(" "))<=5:
pairs.append(c)
random.seed(0)
random.shuffle(pairs)
N_EXAMPLES = len(pairs)
print("Total: {}".format(N_EXAMPLES))
TRAIN_RATIO_INDEX = 0.8
TEST_RATIO_INDEX = TRAIN_RATIO_INDEX + 0.1
DEV_RATIO_INDEX = TEST_RATIO_INDEX + 0.1
train_labels, train_data = zip(*pairs[:round(N_EXAMPLES * TRAIN_RATIO_INDEX)])
dev_labels, dev_data = zip(*pairs[round(N_EXAMPLES * TRAIN_RATIO_INDEX):round(N_EXAMPLES * TEST_RATIO_INDEX)])
test_labels, test_data = zip(*pairs[round(N_EXAMPLES * TEST_RATIO_INDEX):round(N_EXAMPLES * DEV_RATIO_INDEX)])
print("Data selected for train: {}\nData selected for test: {}\nData selected for dev: {}".format(len(train_data), len(test_data), len(dev_data)))
# Function for replacing low occuring word(s) with <unk> token
def replace(box):
if isinstance(box, Word) and dataset.count(box.name) < 1:
return Word('unk', box.cod, box.dom)
return box
tokeniser = SpacyTokeniser()
train_data = tokeniser.tokenise_sentences(train_data)
dev_data = tokeniser.tokenise_sentences(dev_data)
test_data = tokeniser.tokenise_sentences(test_data)
for i in range(len(train_data)):
train_data[i] = ' '.join(train_data[i])
for i in range(len(dev_data)):
dev_data[i] = ' '.join(dev_data[i])
for i in range(len(test_data)):
test_data[i] = ' '.join(test_data[i])
# training set words (with repetition)
train_data_string = ' '.join(train_data)
train_data_list = train_data_string.split(' ')
# validation set words (with repetition)
dev_data_string = ' '.join(dev_data)
dev_data_list = dev_data_string.split(' ')
# test set words (with repetition)
test_data_string = ' '.join(test_data)
test_data_list = test_data_string.split(' ')
# dataset words (with repetition)
dataset = train_data_list + dev_data_list + test_data_list
# list of all unique words in the dataset
unique_words = unique(dataset)
# frequency for each unique word
counter = collections.Counter(dataset)
#print(counter)
replace_functor = Functor(ob=lambda x: x, ar=replace)
# parser = BobcatParser(verbose='text')
print(BobcatParser.available_models())
parser = spiders_reader
#parser = DepCCGParser()
#parser = cups_reader
raw_train_diagrams = []
new_train_labels = []
raw_dev_diagrams = []
new_dev_labels = []
raw_test_diagrams = []
new_test_labels = []
for sent, label in zip(train_data, train_labels):
try:
diag = parser.sentence2diagram(sent)
raw_train_diagrams.append(diag)
new_train_labels.append(label)
except:
print("Cannot be parsed in train: {}".format(sent))
for sent, label in zip(dev_data, dev_labels):
try:
diag = parser.sentence2diagram(sent)
raw_dev_diagrams.append(diag)
new_dev_labels.append(label)
except:
print("Cannot be parsed in dev: {}".format(sent))
for sent, label in zip(test_data, test_labels):
try:
diag = parser.sentence2diagram(sent)
raw_test_diagrams.append(diag)
new_test_labels.append(label)
except:
print("Cannot be parsed in test: {}".format(sent))
train_labels = new_train_labels
dev_labels = new_dev_labels
test_labels = new_test_labels
# # Tokenizing low occuring words in each dataset
for i in range(len(raw_train_diagrams)):
raw_train_diagrams[i] = replace_functor(raw_train_diagrams[i])
for i in range(len(raw_dev_diagrams)):
raw_dev_diagrams[i] = replace_functor(raw_dev_diagrams[i])
for i in range(len(raw_test_diagrams)):
raw_test_diagrams[i] = replace_functor(raw_test_diagrams[i])
# sample sentence diagram (entry 1)
raw_train_diagrams[0].draw()
# merging all diagrams into one for checking the new words
raw_all_diagrams = raw_train_diagrams + raw_dev_diagrams + raw_test_diagrams
# removing cups (after performing top-to-bottom scan of the word diagrams)
train_diagrams = [remove_cups(diagram) for diagram in raw_train_diagrams]
dev_diagrams = [remove_cups(diagram) for diagram in raw_dev_diagrams]
test_diagrams = [remove_cups(diagram) for diagram in raw_test_diagrams]
# sample sentence diagram (entry 1)
train_diagrams[0].draw()
ansatz = IQPAnsatz({AtomicType.NOUN: 1, AtomicType.SENTENCE: 1, AtomicType.PREPOSITIONAL_PHRASE: 1, AtomicType.NOUN_PHRASE:1, AtomicType.CONJUNCTION:1}, n_layers=1, n_single_qubit_params=3)
# train/test circuits
train_circuits = [ansatz(diagram) for diagram in train_diagrams]
dev_circuits = [ansatz(diagram) for diagram in dev_diagrams]
test_circuits = [ansatz(diagram) for diagram in test_diagrams]
# sample circuit diagram
train_circuits[0].draw(figsize=(9, 12))
all_circuits = train_circuits + dev_circuits + test_circuits
model = NumpyModel.from_diagrams(all_circuits, use_jit=True)
loss = lambda y_hat, y: -np.sum(y * np.log(y_hat)) / len(y) # binary cross-entropy loss
acc = lambda y_hat, y: np.sum(np.round(y_hat) == y) / len(y) / 2 # half due to double-counting
trainer = QuantumTrainer(
model,
loss_function=loss,
epochs=EPOCHS,
optimizer=SPSAOptimizer,
optim_hyperparams={'a': 0.2, 'c': 0.06, 'A':0.01*EPOCHS},
evaluate_functions={'acc': acc},
evaluate_on_train=True,
verbose = 'text',
seed=0
)
train_dataset = Dataset(
train_circuits,
train_labels,
batch_size=BATCH_SIZE)
val_dataset = Dataset(dev_circuits, dev_labels, shuffle=False)
trainer.fit(train_dataset, val_dataset, logging_step=12)
fig, ((ax_tl, ax_tr), (ax_bl, ax_br)) = plt.subplots(2, 2, sharex=True, sharey='row', figsize=(10, 6))
ax_tl.set_title('Training set')
ax_tr.set_title('Development set')
ax_bl.set_xlabel('Iterations')
ax_br.set_xlabel('Iterations')
ax_bl.set_ylabel('Accuracy')
ax_tl.set_ylabel('Loss')
colours = iter(plt.rcParams['axes.prop_cycle'].by_key()['color'])
ax_tl.plot(trainer.train_epoch_costs, color=next(colours))
ax_bl.plot(trainer.train_results['acc'], color=next(colours))
ax_tr.plot(trainer.val_costs, color=next(colours))
ax_br.plot(trainer.val_results['acc'], color=next(colours))
test_acc = acc(model(test_circuits), test_labels)
print('Test accuracy:', test_acc)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import transpile
from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import FakeVigoV2
backend = FakeVigoV2()
qc = QuantumCircuit(2, 1)
qc.h(0)
qc.x(1)
qc.cp(np.pi/4, 0, 1)
qc.h(0)
qc.measure([0], [0])
qc_basis = transpile(qc, backend)
qc_basis.draw(output='mpl')
|
https://github.com/derwind/qiskit_applications
|
derwind
|
import numpy as np
from qiskit.visualization import plot_bloch_vector
%matplotlib inline
I = np.array([
[1., 0.],
[0., 1.]
])
X = np.array([
[0., 1.],
[1., 0.]
])
Y = np.array([
[0., -1.j],
[1.j, 0.]
])
Z = np.array([
[1., 0.],
[0., -1.]
])
def Rx(theta):
return np.cos(theta/2) * I - 1.j * np.sin(theta/2) * X
def Ry(theta):
return np.cos(theta/2) * I - 1.j * np.sin(theta/2) * Y
def Rz(theta):
return np.cos(theta/2) * I - 1.j * np.sin(theta/2) * Z
def density_matrix(state):
if len(state.shape) == 1:
state = state.reshape(-1, 1)
return state * np.conjugate(state.T)
def state2bloch(state):
rho = density_matrix(state)
x, y, z = np.trace(X @ rho), np.trace(Y @ rho), np.trace(Z @ rho)
return np.real(np.array([x, y, z]))
def bloch2state(vec, epsilon = 1e-10):
x, y, z = np.real(vec)
cos = np.sqrt((1 + z)/2)
if z > 1 - epsilon: # theta = 0
return np.array([1., 0.])
elif z < -1 + epsilon: # theta = pi
return np.array([0., 1.])
else:
sin = np.sqrt(x**2 + y**2) / (2*cos)
if x < 0:
sin = -sin
if abs(x) < epsilon: # phi = pi/2, 3pi/2
if y >= 0:
phi = np.pi/2
else:
phi = 3 * np.pi/2
else:
phi = np.arctan(y/x)
return np.array([cos, np.exp(1.j*phi)*sin])
#print(state2bloch(np.array([1., 0.])))
#print(bloch2state(np.array([0., 0., 1.])))
init_vec = np.array([0., 0., 1.])
print(init_vec)
display(plot_bloch_vector(init_vec))
final_vec = state2bloch(Rx(np.pi/4) @ bloch2state(init_vec))
print(final_vec)
display(plot_bloch_vector(final_vec))
init_state = np.array([1., 0.])
final_state = Rx(np.pi/4) @ Ry(np.pi/4) @ init_state
final_vec = state2bloch(final_state)
print(final_vec)
display(plot_bloch_vector(final_vec))
def rot(theta):
return np.array([
[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)],
])
init_vec = np.array([0., 0., 1.])
vec = init_vec[:]
vec[[2,0]] = rot(np.pi/4)@vec[[2,0]] # rotate only 2:z, 0:x around Y-axis
vec[[1,2]] = rot(np.pi/4)@vec[[1,2]] # rotate only 1:y, 2:z around X-axis
print(vec)
display(plot_bloch_vector(vec))
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qc = QuantumCircuit(1)
# First, rotate around Y-axis
qc.ry(np.pi/4, 0)
state = Statevector.from_instruction(qc)
print('First, rotate around Y-axis...')
display(plot_bloch_multivector(state))
# Then, rotate around X-axis
qc.rx(np.pi/4, 0)
print('Then, rotate around X-axis.')
state = Statevector.from_instruction(qc)
display(plot_bloch_multivector(state))
|
https://github.com/Spintronic6889/Introduction-of-Quantum-walk-its-application-on-search-and-decision-making
|
Spintronic6889
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer,assemble, transpile
from qiskit import BasicAer
from random import randrange
from qiskit.tools.visualization import plot_histogram, plot_state_city
import numpy as np
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import Operator, Statevector
q = QuantumRegister(6) # "Qubits q[0] and q[1] for coin 1 and 2", "q[2] and q[3] for player 1" and q[4] and q[5] for player 2"
c = ClassicalRegister(6)
Q = QuantumCircuit(q,c)
#Coin Operators
# Apply u gate as Hadamard gate to each coin
Q.u(np.pi/2,0,np.pi,q[0])
Q.u(np.pi/2,0,np.pi,q[1])
#S operator
Q.x(q[0])
Q.x(q[1])
Q.mct([q[0],q[1]],q[3])
Q.mct([q[0],q[1]],q[5])
Q.x(q[0])
Q.x(q[1])
Q.barrier()
Q.x(q[0])
Q.mct([q[0],q[1]],q[2])
Q.mct([q[0],q[1]],q[3])
Q.x(q[0])
Q.barrier()
Q.x(q[1])
Q.mct([q[0],q[1]],q[4])
Q.mct([q[0],q[1]],q[5])
Q.x(q[1])
Q.barrier()
Q.mct([q[0],q[1]],q[2])
Q.mct([q[0],q[1]],q[4])
Q.measure_all()
Q.draw(output='mpl')
# Execute the circuit on the qasm simulator
# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = execute(Q, backend_sim, shots=1000)
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(Q)
print(counts)
plot_histogram(counts, color='midnightblue', title="Decision Histogram")
q_o = QuantumRegister(6) # "Qubits q[0] and q[1] for coin 1 and 2", "q[2] and q[3] for player 1" and q[4] and q[5] for player 2"
c_o = ClassicalRegister(6)
Q_o = QuantumCircuit(q,c)
#Coin Operators
# Apply u gate as Hadamard gate to each coin
Q_o.u(2*np.pi/3,0,np.pi,q[0])
Q_o.u(np.pi/2,0,np.pi,q[1])
#S operator
Q_o.x(q[0])
Q_o.x(q[1])
Q_o.mct([q[0],q[1]],q[3])
Q_o.mct([q[0],q[1]],q[5])
Q_o.x(q[0])
Q_o.x(q[1])
Q_o.barrier()
Q_o.x(q[0])
Q_o.mct([q[0],q[1]],q[2])
Q_o.mct([q[0],q[1]],q[3])
Q_o.x(q[0])
Q_o.barrier()
Q_o.x(q[1])
Q_o.mct([q[0],q[1]],q[4])
Q_o.mct([q[0],q[1]],q[5])
Q_o.x(q[1])
Q_o.barrier()
Q_o.mct([q[0],q[1]],q[2])
Q_o.mct([q[0],q[1]],q[4])
Q_o.measure_all()
# Execute the circuit on the qasm simulator
# Use Aer's qasm_simulator
backend_sim_o = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim_o = execute(Q_o, backend_sim, shots=1000)
# Grab the results from the job.
result_sim_o = job_sim_o.result()
counts_o = result_sim_o.get_counts(Q_o)
print(counts_o)
plot_histogram(counts_o, color='midnightblue', title="Decision Histogram")
|
https://github.com/InvictusWingsSRL/QiskitTutorials
|
InvictusWingsSRL
|
#Libraries needed to implement and simulate quantum circuits
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, transpile, qasm2, qasm3
from qiskit_aer import Aer
from qiskit.primitives import BackendSampler
#Custem functions to simplify answers
import Our_Qiskit_Functions as oq #a part of the library presented in arXiv:1903.04359v1.
import numpy as np
import math as m
#Initialize backends simulators to visualize circuits
S_simulator = Aer.backends(name='statevector_simulator')[0]
Q_simulator = Aer.backends(name='qasm_simulator')[0]
q = QuantumRegister(1, name='q')
I_qc = QuantumCircuit(q, name = 'qc')
I_qc.id(q[0])
print('___________Initial____________')
oq.Wavefunction(I_qc)
I_qc.id(q[0])
print('___________Final____________')
oq.Wavefunction(I_qc)
I_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
H_qc = QuantumCircuit(q, name = 'qc')
H_qc.id(q[0])
print('___________Initial____________')
oq.Wavefunction(I_qc)
H_qc.h(q[0])
print('___________Final____________')
oq.Wavefunction(H_qc)
H_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
X_qc = QuantumCircuit(q, name = 'qc')
X_qc.id(q[0])
print('___________Initial____________')
oq.Wavefunction(X_qc)
X_qc.x(q[0])
print('___________Final____________')
oq.Wavefunction(X_qc)
X_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
Y_qc = QuantumCircuit(q, name = 'qc')
Y_qc.id(q[0])
print('___________Initial____________')
oq.Wavefunction(Y_qc)
Y_qc.y(q[0])
print('___________Final____________')
oq.Wavefunction(Y_qc)
Y_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
Z_qc = QuantumCircuit(q, name = 'qc')
Z_qc.h(q[0])
print('___________Initial____________')
oq.Wavefunction(Z_qc)
Z_qc.z(q[0])
print('___________Final____________')
oq.Wavefunction(Z_qc)
Z_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
u1_qc = QuantumCircuit(q, name = 'qc')
u1_qc.h(q[0])
print('___________Initial____________')
oq.Wavefunction(u1_qc)
u1_qc.p(m.pi/2,q[0])
print('___________Final____________')
oq.Wavefunction(u1_qc)
u1_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
S_qc = QuantumCircuit(q, name = 'qc')
S_qc.h(q[0])
print('___________Initial____________')
oq.Wavefunction(S_qc)
S_qc.s(q[0])
print('___________Final____________')
oq.Wavefunction(S_qc)
S_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
T_qc = QuantumCircuit(q, name = 'qc')
T_qc.h(q[0])
print('___________Initial____________')
oq.Wavefunction(T_qc)
T_qc.t(q[0])
#T_qc.t(q[0])
print('___________Final____________')
oq.Wavefunction(T_qc)
T_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
Rx_qc = QuantumCircuit(q, name = 'qc')
Rx_qc.id(q[0])
print('___________Initial____________')
oq.Wavefunction(Rx_qc)
Rx_qc.rx(m.pi/2,q[0])
print('___________Final____________')
oq.Wavefunction(Rx_qc)
Rx_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
Ry_qc = QuantumCircuit(q, name = 'qc')
Ry_qc.id(q[0])
print('___________Initial____________')
oq.Wavefunction(Ry_qc)
Ry_qc.ry(m.pi/2,q[0])
print('___________Final____________')
oq.Wavefunction(Ry_qc)
Ry_qc.draw(output='mpl')
q = QuantumRegister(1, name='q')
Rz_qc = QuantumCircuit(q, name = 'qc')
Rz_qc.h(q[0])
print('___________Initial____________')
oq.Wavefunction(Rz_qc)
Rz_qc.rz(m.pi/2,q[0])
#Rz_qc.t(q[0])
#Rz_qc.x(q[0])
#Rz_qc.t(q[0])
#Rz_qc.x(q[0])
print('___________Final____________')
oq.Wavefunction(Rz_qc)
Rz_qc.draw(output='mpl')
q = QuantumRegister(2, name='q')
Cx_qc = QuantumCircuit(q, name = 'qc')
Cx_qc.h(q[0])
Cx_qc.z(q[0])
Cx_qc.id(q[1])
print('___________Initial____________')
oq.Wavefunction(Cx_qc)
Cx_qc.cx(q[0],q[1])
print('___________Final____________')
oq.Wavefunction(Cx_qc)
Cx_qc.draw(output='mpl')
q = QuantumRegister(2, name='q')
Cz_qc = QuantumCircuit(q, name = 'qc')
Cz_qc.h(q[0])
Cz_qc.x(q[1])
print('___________Initial____________')
oq.Wavefunction(Cz_qc)
Cz_qc.cz(q[0],q[1])
print('___________Final____________')
oq.Wavefunction(Cz_qc)
Cz_qc.draw(output='mpl')
q = QuantumRegister(2, name='q')
cu1_qc = QuantumCircuit(q, name = 'qc')
cu1_qc.h(q[0])
cu1_qc.x(q[1])
print('___________Initial____________')
oq.Wavefunction(cu1_qc)
cu1_qc.cp(m.pi/2,q[0],q[1])
print('___________Final____________')
oq.Wavefunction(cu1_qc)
cu1_qc.draw(output='mpl')
q = QuantumRegister(2, name='q')
swap_qc = QuantumCircuit(q, name = 'qc')
swap_qc.x(q[0])
swap_qc.h(q[1])
print('___________Initial____________')
oq.Wavefunction(swap_qc)
swap_qc.swap(q[0],q[1])
print('___________Final____________')
oq.Wavefunction(swap_qc)
swap_qc.draw(output='mpl')
q = QuantumRegister(3, name='q')
cswap_qc = QuantumCircuit(q, name = 'qc')
cswap_qc.h(q[0])
cswap_qc.x(q[1])
cswap_qc.id(q[2])
print('___________Initial____________')
oq.Wavefunction(cswap_qc)
cswap_qc.cswap(q[0],q[1],q[2])
print('___________Final____________')
oq.Wavefunction(cswap_qc)
cswap_qc.draw(output='mpl')
q = QuantumRegister(3, name='q')
ccnot_qc = QuantumCircuit(q, name = 'qc')
ccnot_qc.x(q[0])
ccnot_qc.x(q[1])
ccnot_qc.h(q[2])
ccnot_qc.z(q[2])
print('___________Initial____________')
oq.Wavefunction(ccnot_qc)
ccnot_qc.ccx(q[0],q[1],q[2])
print('___________Final____________')
oq.Wavefunction(ccnot_qc)
ccnot_qc.draw(output='mpl')
|
https://github.com/TheGupta2012/QPE-Algorithms
|
TheGupta2012
|
from qiskit import QuantumCircuit, execute, transpile, Aer
from qiskit.extensions import UnitaryGate,Initialize
from qiskit.quantum_info import Statevector
from qiskit.tools.visualization import plot_bloch_vector
from qiskit.tools.visualization import plot_histogram,plot_bloch_multivector
import numpy as np
from time import sleep
import sys
sys.path.append("..")
from scipy.stats import unitary_group
import matplotlib.pyplot as plt
%matplotlib inline
from Modules.normal_SPEA import SPEA
from Modules.changed_SPEA import global_max_SPEA
def generate_random_estimation(unitaries,SPE_type,resolution = 40,save = True):
backend = Aer.get_backend('qasm_simulator')
best_costs, errors_in_phases = [] , []
for i,u_rand in enumerate(unitaries):
print("FOR UNITARY ",i+1)
# generate the phases and vectors
eigen_phases, eigen_vectors = np.linalg.eig(u_rand)
eigen_phases = np.angle(eigen_phases)
ep = []
# doing this as phase maybe be negative
for k in eigen_phases:
if k < 0:
ep.append((k + 2*np.pi)/(2*np.pi))
else:
ep.append(k/(2*np.pi))
eigen_phases = ep
ev1 , ev2 = eigen_vectors[0] , eigen_vectors[1]
ev1 = ev1 / np.linalg.norm(ev1)
ev2 = ev2 / np.linalg.norm(ev2)
# generate their corresponding init statevectors
sv1 = Initialize(ev1)
sv2 = Initialize(ev2)
print("Eigenvectors",ev1,ev2)
print("Eigenphases",eigen_phases)
# run the algorithm
if SPE_type == 'original':
spea = SPEA(resolution = resolution, max_iters = 10, unitary = u_rand,error = 4)
else:
spea = global_max_SPEA(resolution = resolution, max_iters = 10, unitary = u_rand,error = 4)
result = spea.get_eigen_pair(backend = backend, progress = False, randomize = True)
# get the results
res_state = result['state']
res_theta = result['theta']
sv_res = Initialize(res_state)
print("Result",result)
print("Phase returned :",res_theta)
# get the dot products
d1 = np.linalg.norm(np.dot(ev1, res_state.conjugate().T))**2
d2 = np.linalg.norm(np.dot(ev2, res_state.conjugate().T))**2
# make a bloch sphere
qc = QuantumCircuit(2)
qc = qc.compose(sv_res,qubits = [0])
if d1 > d2:
print("Best overlap :",d1)
# it is closer to the first
qc = qc.compose(sv1,qubits = [1])
best_costs.append(result['cost'])
errors_in_phases.append(abs(res_theta - eigen_phases[0]))
else:
# it is closer to the second
print("Best overlap :",d2)
qc = qc.compose(sv2,qubits = [1])
best_costs.append(result['cost'])
errors_in_phases.append(abs(res_theta - eigen_phases[1]))
print("Bloch Sphere for the states...")
s = Statevector.from_instruction(qc)
display(plot_bloch_multivector(s))
if SPE_type == 'original':
plt.title("Experiments over Random Matrices for original SPEA",fontsize= 16)
else:
plt.title("Experiments over Random Matrices for modified SPEA",fontsize= 16)
plt.xlabel("Experiment Number")
plt.ylabel("Metric value")
plt.plot([i for i in range(len(unitaries))], best_costs, label = 'Best Costs', alpha = 0.5, color = 'r',marker='o',linewidth = 2)
plt.plot([i for i in range(len(unitaries))], errors_in_phases, label = 'Corresponding Error in Phase',linewidth = 2, alpha = 0.5, color = 'b',marker='s')
plt.legend()
plt.grid()
if save:
if SPE_type == 'original':
plt.savefig("Random Estimation for Original SPE.jpg",dpi = 200)
else:
plt.savefig("Random Estimation for Modified SPE.jpg",dpi = 200)
unitaries = []
for i in range(6):
u = unitary_group.rvs(2)
unitaries.append(u)
print("Unitaries :",unitaries)
generate_random_estimation(unitaries,'original',resolution=15)
generate_random_estimation(unitaries,'modified',resolution=15)
|
https://github.com/Hayatto9217/QIskit12
|
Hayatto9217
|
#量子エラー研究.平均誤差率
from qiskit import IBMQ, transpile
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator
from qiskit.tools.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeVigo
device_backend =FakeVigo()
circ = QuantumCircuit(3, 3)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.measure([0,1,2],[0,1,2])
sim_ideal = AerSimulator()
result = sim_ideal.run(transpile(circ, sim_ideal)).result()
counts =result.get_counts(0)
plot_histogram(counts, title='Ideal counts for 3-qubit GHZ state')
#ibmq-vigo のsimulator
sim_vigo = AerSimulator.from_backend(device_backend)
tcirc = transpile(circ,sim_vigo)
result_noise =sim_vigo.run(tcirc).result()
counts_noise = result_noise.get_counts(0)
plot_histogram(counts_noise, title="Counts for 3-qubit GHZ device noise model")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/OldGinko/Qiskit-CKS-Algorithm
|
OldGinko
|
"""
Implementing the inversion of A with Hamiltonmian SImulation
(Fourier approach in CKS paper, see red box1 Page 5)
"""
from qiskit import *
import numpy as np
from qiskit.visualization import plot_histogram
import qiskit.tools.jupyter
import matplotlib.pyplot as plt
from qiskit.aqua.algorithms import IQPE
from scipy.linalg import expm, sinm, cosm #for the bridge Hamiltonian simulation
from qiskit.extensions import *
from qiskit.quantum_info.operators import Operator
A = np.array([[1/2+0.j,-1/3],[-1/3,1/2]])
# A =A/np.linalg.norm(A)
A_inv = qiskit.extensions.HamiltonianGate(A, 1)
A_inv1 = A_inv.to_matrix()
numpInv=np.linalg.inv(A)
print(np.dot(A,A_inv1))
|
https://github.com/qiskit-community/qiskit-cold-atom
|
qiskit-community
|
%load_ext autoreload
%autoreload 2
from qiskit_cold_atom.applications import FermiHubbard1D
# defining the system
system = FermiHubbard1D(
num_sites = 3, # number of lattice sites
particles_up = 1, # number of spin up particles
particles_down = 1, # number of spin down particles
hop_strength = 2., # parameter J tuning the hopping
int_strength = 1, # parameter U tuning the interaction
potential = [1, 0, -1] # parameters mu tuning the local potential
)
from qiskit_cold_atom.fermions.fermion_circuit_solver import FermionicState
# defining the initial state with one spin_up particle in the left site
# and one spin-down particle in the right site
initial_state = FermionicState([[1, 0, 0], [0, 0, 1]])
from qiskit_nature.second_q.operators import FermionicOp
# Observables: Spin-density and particle density at the first site
spin_density = FermionicOp({'+_0 -_0': 1, '+_3 -_3': -1}, num_spin_orbitals=6)
particle_density = FermionicOp({'+_0 -_0': 1, '+_3 -_3': 1}, num_spin_orbitals=6)
import numpy as np
evolution_times = np.linspace(0.1, 5, 40)
from qiskit_cold_atom.applications import FermionicEvolutionProblem
spin_problem = FermionicEvolutionProblem(system, initial_state, evolution_times, spin_density)
particle_problem = FermionicEvolutionProblem(system, initial_state, evolution_times, particle_density)
from qiskit_cold_atom.providers.fermionic_tweezer_backend import FermionicTweezerSimulator
from qiskit_cold_atom.applications import TimeEvolutionSolver
# initializing the fermionic solver
fermionic_backend = FermionicTweezerSimulator(n_tweezers=3)
fermionic_solver = TimeEvolutionSolver(backend = fermionic_backend)
from qiskit import Aer
# initializing the qubit solver with the qasm simulator backend
qubit_backend = Aer.get_backend('qasm_simulator')
mapping = 'bravyi_kitaev'
# mapping = 'jordan_wigner'
# mapping = 'parity'
shallow_qubit_solver = TimeEvolutionSolver(backend = qubit_backend, map_type = mapping, trotter_steps = 1)
deep_qubit_solver = TimeEvolutionSolver(backend = qubit_backend, map_type = mapping, trotter_steps = 6)
spin_vals_fermions = fermionic_solver.solve(spin_problem)
particle_vals_fermions = fermionic_solver.solve(particle_problem)
spin_vals_qubits_shallow = shallow_qubit_solver.solve(spin_problem)
particle_vals_qubits_shallow = shallow_qubit_solver.solve(particle_problem)
spin_vals_qubits_deep = deep_qubit_solver.solve(spin_problem)
particle_vals_qubits_deep = deep_qubit_solver.solve(particle_problem)
import matplotlib.pyplot as plt
plt.rcParams['figure.figsize'] = [9, 6]
plt.rcParams.update({'font.size': 14})
plt.xlabel('evolution time')
plt.ylabel('Spin at site 1')
plt.ylim(-1.1, 1.1)
plt.title('evolution of spin density')
plt.plot(evolution_times, np.real_if_close(spin_vals_qubits_shallow), '--o', color='#d02670', alpha=0.5, label='qubits, 1 trotter step')
plt.plot(evolution_times, np.real_if_close(spin_vals_qubits_deep), '-o', color='#08bdba', alpha=0.8, label='qubits, 6 trotter steps')
plt.plot(evolution_times, np.real_if_close(spin_vals_fermions), '-o', color='#0f62fe', alpha=0.8, label='fermionic backend')
plt.legend()
plt.show()
plt.xlabel('evolution time')
plt.ylabel('Particle number at site 1')
plt.title('evolution of particle density')
plt.plot(evolution_times, particle_vals_qubits_shallow, '--o', color='#d02670', alpha=0.5, label='qubits, 1 trotter step')
plt.plot(evolution_times, particle_vals_qubits_deep, '-o', color='#08bdba', alpha=0.8, label='qubits, 6 trotter steps')
plt.plot(evolution_times, particle_vals_fermions, '-o', color='#0f62fe', alpha=0.8, label='fermionic backend')
plt.legend()
plt.show()
fermion_circuit = spin_problem.circuits(fermionic_backend.initialize_circuit(initial_state.occupations))[-1]
fermion_circuit.measure_all()
qubit_circuit = deep_qubit_solver.construct_qubit_circuits(spin_problem)[-1]
qubit_circuit.measure_all()
fermion_circuit.draw(output='mpl', style="clifford")
from qiskit import transpile
from qiskit.providers.fake_provider import FakeGuadalupe
qubit_device = FakeGuadalupe()
transpiled_circ = transpile(qubit_circuit, qubit_device, optimization_level=3)
transpiled_circ.draw(output='mpl', idle_wires=False, style="clifford")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import FakeVigoV2
backend = FakeVigoV2()
qc = QuantumCircuit(2, 1)
qc.h(0)
qc.x(1)
qc.cp(np.pi/4, 0, 1)
qc.h(0)
qc.measure([0], [0])
qc.draw(output='mpl')
|
https://github.com/ElePT/qiskit-algorithms-test
|
ElePT
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022, 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 QAOA algorithm."""
import unittest
from functools import partial
from test.python.algorithms import QiskitAlgorithmsTestCase
import numpy as np
import rustworkx as rx
from ddt import ddt, idata, unpack
from scipy.optimize import minimize as scipy_minimize
from qiskit import QuantumCircuit
from qiskit_algorithms.minimum_eigensolvers import QAOA
from qiskit_algorithms.optimizers import COBYLA, NELDER_MEAD
from qiskit.circuit import Parameter
from qiskit.primitives import Sampler
from qiskit.quantum_info import Pauli, SparsePauliOp
from qiskit.result import QuasiDistribution
from qiskit.utils import algorithm_globals
W1 = np.array([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]])
P1 = 1
M1 = SparsePauliOp.from_list(
[
("IIIX", 1),
("IIXI", 1),
("IXII", 1),
("XIII", 1),
]
)
S1 = {"0101", "1010"}
W2 = np.array(
[
[0.0, 8.0, -9.0, 0.0],
[8.0, 0.0, 7.0, 9.0],
[-9.0, 7.0, 0.0, -8.0],
[0.0, 9.0, -8.0, 0.0],
]
)
P2 = 1
M2 = None
S2 = {"1011", "0100"}
CUSTOM_SUPERPOSITION = [1 / np.sqrt(15)] * 15 + [0]
@ddt
class TestQAOA(QiskitAlgorithmsTestCase):
"""Test QAOA with MaxCut."""
def setUp(self):
super().setUp()
self.seed = 10598
algorithm_globals.random_seed = self.seed
self.sampler = Sampler()
@idata(
[
[W1, P1, M1, S1],
[W2, P2, M2, S2],
]
)
@unpack
def test_qaoa(self, w, reps, mixer, solutions):
"""QAOA test"""
self.log.debug("Testing %s-step QAOA with MaxCut on graph\n%s", reps, w)
qubit_op, _ = self._get_operator(w)
qaoa = QAOA(self.sampler, COBYLA(), reps=reps, mixer=mixer)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
self.assertIn(graph_solution, solutions)
@idata(
[
[W1, P1, S1],
[W2, P2, S2],
]
)
@unpack
def test_qaoa_qc_mixer(self, w, prob, solutions):
"""QAOA test with a mixer as a parameterized circuit"""
self.log.debug(
"Testing %s-step QAOA with MaxCut on graph with a mixer as a parameterized circuit\n%s",
prob,
w,
)
optimizer = COBYLA()
qubit_op, _ = self._get_operator(w)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
theta = Parameter("θ")
mixer.rx(theta, range(num_qubits))
qaoa = QAOA(self.sampler, optimizer, reps=prob, mixer=mixer)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
self.assertIn(graph_solution, solutions)
def test_qaoa_qc_mixer_many_parameters(self):
"""QAOA test with a mixer as a parameterized circuit with the num of parameters > 1."""
optimizer = COBYLA()
qubit_op, _ = self._get_operator(W1)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
for i in range(num_qubits):
theta = Parameter("θ" + str(i))
mixer.rx(theta, range(num_qubits))
qaoa = QAOA(self.sampler, optimizer, reps=2, mixer=mixer)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
self.log.debug(x)
graph_solution = self._get_graph_solution(x)
self.assertIn(graph_solution, S1)
def test_qaoa_qc_mixer_no_parameters(self):
"""QAOA test with a mixer as a parameterized circuit with zero parameters."""
qubit_op, _ = self._get_operator(W1)
num_qubits = qubit_op.num_qubits
mixer = QuantumCircuit(num_qubits)
# just arbitrary circuit
mixer.rx(np.pi / 2, range(num_qubits))
qaoa = QAOA(self.sampler, COBYLA(), reps=1, mixer=mixer)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
# we just assert that we get a result, it is not meaningful.
self.assertIsNotNone(result.eigenstate)
def test_change_operator_size(self):
"""QAOA change operator size test"""
qubit_op, _ = self._get_operator(
np.array([[0, 1, 0, 1], [1, 0, 1, 0], [0, 1, 0, 1], [1, 0, 1, 0]])
)
qaoa = QAOA(self.sampler, COBYLA(), reps=1)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
with self.subTest(msg="QAOA 4x4"):
self.assertIn(graph_solution, {"0101", "1010"})
qubit_op, _ = self._get_operator(
np.array(
[
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
[0, 1, 0, 1, 0, 1],
[1, 0, 1, 0, 1, 0],
]
)
)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
with self.subTest(msg="QAOA 6x6"):
self.assertIn(graph_solution, {"010101", "101010"})
@idata([[W2, S2, None], [W2, S2, [0.0, 0.0]], [W2, S2, [1.0, 0.8]]])
@unpack
def test_qaoa_initial_point(self, w, solutions, init_pt):
"""Check first parameter value used is initial point as expected"""
qubit_op, _ = self._get_operator(w)
first_pt = []
def cb_callback(eval_count, parameters, mean, metadata):
nonlocal first_pt
if eval_count == 1:
first_pt = list(parameters)
qaoa = QAOA(
self.sampler,
COBYLA(),
initial_point=init_pt,
callback=cb_callback,
)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
x = self._sample_most_likely(result.eigenstate)
graph_solution = self._get_graph_solution(x)
with self.subTest("Initial Point"):
# If None the preferred random initial point of QAOA variational form
if init_pt is None:
self.assertLess(result.eigenvalue, -0.97)
else:
self.assertListEqual(init_pt, first_pt)
with self.subTest("Solution"):
self.assertIn(graph_solution, solutions)
def test_qaoa_random_initial_point(self):
"""QAOA random initial point"""
w = rx.adjacency_matrix(
rx.undirected_gnp_random_graph(5, 0.5, seed=algorithm_globals.random_seed)
)
qubit_op, _ = self._get_operator(w)
qaoa = QAOA(self.sampler, NELDER_MEAD(disp=True), reps=2)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
self.assertLess(result.eigenvalue, -0.97)
def test_optimizer_scipy_callable(self):
"""Test passing a SciPy optimizer directly as callable."""
w = rx.adjacency_matrix(
rx.undirected_gnp_random_graph(5, 0.5, seed=algorithm_globals.random_seed)
)
qubit_op, _ = self._get_operator(w)
qaoa = QAOA(
self.sampler,
partial(scipy_minimize, method="Nelder-Mead", options={"maxiter": 2}),
)
result = qaoa.compute_minimum_eigenvalue(qubit_op)
self.assertEqual(result.cost_function_evals, 5)
def _get_operator(self, weight_matrix):
"""Generate Hamiltonian for the max-cut problem of a graph.
Args:
weight_matrix (numpy.ndarray) : adjacency matrix.
Returns:
PauliSumOp: operator for the Hamiltonian
float: a constant shift for the obj function.
"""
num_nodes = weight_matrix.shape[0]
pauli_list = []
shift = 0
for i in range(num_nodes):
for j in range(i):
if weight_matrix[i, j] != 0:
x_p = np.zeros(num_nodes, dtype=bool)
z_p = np.zeros(num_nodes, dtype=bool)
z_p[i] = True
z_p[j] = True
pauli_list.append([0.5 * weight_matrix[i, j], Pauli((z_p, x_p))])
shift -= 0.5 * weight_matrix[i, j]
lst = [(pauli[1].to_label(), pauli[0]) for pauli in pauli_list]
return SparsePauliOp.from_list(lst), shift
def _get_graph_solution(self, x: np.ndarray) -> str:
"""Get graph solution from binary string.
Args:
x : binary string as numpy array.
Returns:
a graph solution as string.
"""
return "".join([str(int(i)) for i in 1 - x])
def _sample_most_likely(self, state_vector: QuasiDistribution) -> np.ndarray:
"""Compute the most likely binary string from state vector.
Args:
state_vector: Quasi-distribution.
Returns:
Binary string as numpy.ndarray of ints.
"""
values = list(state_vector.values())
n = int(np.log2(len(values)))
k = np.argmax(np.abs(values))
x = np.zeros(n)
for i in range(n):
x[i] = k % 2
k >>= 1
return x
if __name__ == "__main__":
unittest.main()
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
import qiskit
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.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from tsp_qaoa import marina_solution
G=nx.Graph()
i=1
G.add_node(i,pos=(i,i))
G.add_node(2,pos=(2,2))
G.add_node(3,pos=(1,0))
G.add_edge(1,2,weight=20.5)
G.add_edge(1,3,weight=9.8)
pos=nx.get_node_attributes(G,'pos')
nx.draw(G,pos)
labels = nx.get_edge_attributes(G,'weight')
nx.draw_networkx_edge_labels(G,pos,edge_labels=labels)
def append_zz_term(qc,q1,q2,gamma):
qc.cx(q1,q2)
qc.rz(2*gamma,q2)
qc.cx(q1,q2)
def get_cost_circuit(G,gamma):
N=G.number_of_nodes()
qc=QuantumCircuit(N,N)
for i,j in G.edges():
append_zz_term(qc,i,j,gamma)
return qc
#print(get_cost_circuit(G,0.5))
def append_x_term(qc,q1,beta):
qc.rx(2*beta,q1)
def get_mixer_operator(G,beta):
N=G.number_of_nodes()
qc=QuantumCircuit(N,N)
for n in G.nodes():
append_x_term(qc,n,beta)
return qc
#print(get_mixer_operator(G,0.5))
def get_QAOA_circuit(G,beta,gamma):
assert(len(beta)==len(gamma))
N=G.number_of_nodes()
qc=QuantumCircuit(N,N)
qc.h(range(N))
p=len(beta)
#aplicamos las p rotaciones
for i in range(p):
qc=qc.compose(get_cost_circuit(G,gamma[i]))
qc=qc.compose(get_mixer_operator(G,beta[i]))
qc.barrier(range(N))
qc.measure(range(N),range(N))
return qc
print(get_QAOA_circuit(G,[0.5,0,6],[0.5,0,6]))
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
qc=get_QAOA_circuit(G,[0.5,0,6],[0.5,0,6])
backend=Aer.get_backend('qasm_simulator')
job=execute(qc,backend)
result=job.result()
print(invert_counts(result.get_counts()))
def maxcut_obj(x,G):
cut=0
for i,j in G.edges():
if x[i]!=x[j]:
cut = cut-1
return cut
print(maxcut_obj("00011",G))
def compute_maxcut_energy(counts,G):
energy=0
get_counts=0
total_counts=0
for meas, meas_count in counts.items():
obj_for_meas=maxcut_obj(meas,G)
energy+=obj_for_meas*meas_count
total_counts+=meas_count
return energy/total_counts
def get_black_box_objective(G,p):
backend=Aer.get_backend('qasm_simulator')
def f(theta):
beta=theta[:p]
gamma=theta[p:]
qc=get_QAOA_circuit(G,beta,gamma)
counts=execute(qc,backend,seed_simulator=10).result().get_counts()
return compute_maxcut_energy(invert_counts(counts),G)
return f
p=5
obj=get_black_box_objective(G,p)
init_point=np.array([0.8,2.2,0.83,2.15,0.37,2.4,6.1,2.2,3.8,6.1])#([2,2,1,1,1,1,1,1,1,1])
res_sample=minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
res_sample
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
cantidad_ciudades = 4
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
pos=nx.spring_layout(G)
nx.draw(G,pos)
labels = nx.get_edge_attributes(G,'weight')
nx.draw_networkx_edge_labels(G,pos,edge_labels=labels)
G
pos=nx.get_node_attributes(G,'weight')
pos
labels = nx.get_edge_attributes(G,'weight')
labels
def funcion_costo(multiplicador_lagrange, cantidad_ciudades, pesos, conexiones ):
N = G.number_of_nodes()
N_square = N^2
# restriccion 1
for i in range(cantidad_ciudades):
cur = sI(N_square)
for j in range(num_cities):
cur -= D(i, j)
ret += cur**2
# retorna el indice de qubit por conversion al problema
def quibit_indice(i, l, N):
return i * N + l
from qiskit.quantum_info.operators import Operator, Pauli
# Create an operator
XX = Operator(Pauli(label='XX'))
# Add to a circuit
circ = QuantumCircuit(2, 2)
circ.append(XX, [0, 1])
circ.measure([0,1], [0,1])
circ.draw('mpl')
# Add to a circuit
circ = QuantumCircuit(2, 2)
circ.append(a, [0])
#circ.measure([0,1], [0,1])
circ.draw('mpl')
a = I - ( 0.5*(I+ Z))**2
a = Operator(a)
a.is_unitary()
print(I @ Z)
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
"""Performance Analysis of 5 Qubit Code under Depolarizing Error"""
import noise
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister
from qiskit import Aer, execute
from qiskit.visualization import plot_histogram, plot_bloch_vector
from five_qubit_code import FiveQubitCode
# Parameters
error_prob = 0.05
theta = np.pi / 3
phi = np.pi / 4
# Initialize error correcting circuit, backend and noise model
qasm = Aer.get_backend('qasm_simulator')
noise_depol = noise.depolarizing_noise(error_prob)
qecc = FiveQubitCode()
# Visualize parameters
print(noise_depol)
qecc.visualize()
# Define test circuit and input state
output = ClassicalRegister(5)
circ = QuantumCircuit(qecc.code, qecc.syndrm, output)
circ.ry(theta, qecc.code[4])
circ.rz(phi, qecc.code[4])
plot_bloch_vector([np.sin(theta) * np.cos(phi), np.sin(theta) * np.sin(phi), np.cos(theta)], title="Input State")
plt.show()
# Define final measurement circuit
meas = QuantumCircuit(qecc.code, qecc.syndrm, output)
meas.measure(qecc.code, output)
# QASM simulation w/o error correction
job = execute(circ + qecc.encoder_ckt + qecc.noise_ckt + qecc.decoder_ckt + meas,
backend=qasm, noise_model=noise_depol, basis_gates=noise_depol.basis_gates)
counts_noisy = job.result().get_counts()
# QASM simulation with error correction
job = execute(circ + qecc.circuit + meas, backend=qasm, noise_model=noise_depol,
basis_gates=noise_depol.basis_gates)
counts_corrected = job.result().get_counts()
# Plot QASM simulation data
plot_histogram([counts_noisy, counts_corrected],
title='5-Qubit Error Correction - Depolarizing Noise $(P_{error} = ' + str(error_prob) + ')$',
legend=['w/o code', 'with code'], figsize=(12, 9), bar_labels=False)
plt.subplots_adjust(left=0.15, right=0.72, top=0.9, bottom=0.20)
plt.show()
|
https://github.com/bayesian-randomized-benchmarking/qiskit-advocates-bayes-RB
|
bayesian-randomized-benchmarking
|
#Import general libraries (needed for functions)
import numpy as np
import matplotlib.pyplot as plt
#from IPython import display
#Import Qiskit classes
import qiskit
from qiskit.tools.monitor import job_monitor
from qiskit import Aer
from qiskit.providers.aer.noise import NoiseModel
from qiskit import QuantumRegister, QuantumCircuit
#Import the RB Functions
import qiskit.ignis.verification.randomized_benchmarking as rb
# import the bayesian packages
import pymc3 as pm
import arviz as az
from scipy.optimize import curve_fit
import bayesian_fitter as bf
# initialize the Bayesian extension
%config InlineBackend.figure_format = 'retina'
# Initialize random number generator
RANDOM_SEED = 8927
np.random.seed(RANDOM_SEED)
az.style.use("arviz-darkgrid")
RB_process = "1_Q RB"
if RB_process in ["3_Q RB","2-3_Q RB"] :
#Number of qubits
nQ = 3
#There are 3 qubits: Q0,Q1,Q2.
#2Q RB on Q0,Q2 and 1Q RB on Q1
rb_pattern = [[1,2],[3]] # because 3 qubits
#Do three times as many 1Q Cliffords
length_multiplier = [1,3]
#Interleaved Clifford gates (2-qubits and 1-qubit)
interleaved_gates = [['cx 0 1'],['x 2']]
elif RB_process == "2_Q RB":
#Number of qubits
nQ = 2
#There are 2 qubits: Q0,Q1.
#2Q RB Q0,Q1
rb_pattern = [[0,1]]
length_multiplier = 1
interleaved_gates = [['cx 0,1']]
elif RB_process == "1_Q RB":
#Number of qubits
nQ = 1
#There is 1 qubit: Q0
rb_pattern = [[0]]
length_multiplier = 1
interleaved_gates = [['sx 0']]
#Important parameters
#Number of Cliffords in the sequence (start, stop, steps)
nCliffs = [1, 50, 100, 200, 400, 600, 800, 1000, 1300, 1600]
#Number of seeds (random sequences)
nseeds=8
#Shots
shots = 2**9
scale = (2 ** len(rb_pattern[0]) - 1) / (2 ** len(rb_pattern[0]))
from qiskit import IBMQ
from qiskit import Aer
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
device = provider.get_backend('ibmq_athens') # type here hardware backend
properties = device.properties()
coupling_map = device.configuration().coupling_map
basis_gates = ['id', 'rz', 'sx', 'x', 'cx', 'reset']
hardware = device.name()
run_option = "real" # "simulation"
# choice of simulation or real device run
if run_option == "real":
backend = device
noise_model = None
elif run_option == "simulation":
backend = Aer.get_backend('qasm_simulator')
noise_model = NoiseModel.from_backend(properties)
qregs_02 = QuantumRegister(2)
circ_02 = QuantumCircuit(qregs_02, name='circ_02')
#circ_02.h(qregs_02[0]) # booptrap! WIP!
circ_02.cx(qregs_02[0], qregs_02[1])
circ_02.draw()
qregs_1 = QuantumRegister(1)
circ_1 = QuantumCircuit(qregs_1, name='circ_1')
circ_1.sx(qregs_1[0]) # booptrap! WIP!
circ_1.draw()
rb_opts = {}
rb_opts['rand_seed'] = 61946
rb_opts['length_vector'] = nCliffs
rb_opts['nseeds'] = nseeds
rb_opts['rb_pattern'] = rb_pattern
rb_opts['length_multiplier'] = length_multiplier
#rb_opts['align_cliffs'] = True
if RB_process in ["3_Q RB","2-3_Q RB"]:
rb_opts['interleaved_elem'] = [circ_02, circ_1]
elif RB_process == "2_Q RB":
rb_opts['interleaved_elem'] = [circ_02]
elif RB_process == "1_Q RB":
rb_opts['interleaved_elem'] = [circ_1]
rb_original_circs, xdata, rb_interleaved_circs = rb.randomized_benchmarking_seq(**rb_opts)
#Original RB circuits
print (rb_original_circs[0][0])
#Interleaved RB circuits
print (rb_interleaved_circs[0][0])
retrieve_list = []
original_result_list, original_transpile_list = bf.get_and_run_seeds(rb_circs=rb_original_circs,
shots=shots,
backend = backend,
coupling_map = coupling_map,
basis_gates = basis_gates,
noise_model = noise_model,
retrieve_list=retrieve_list)
retrieve_list = []
interleaved_result_list, interleaved_transpile_list = bf.get_and_run_seeds(rb_circs=rb_interleaved_circs,
shots=shots,
backend = backend,
coupling_map = coupling_map,
basis_gates = basis_gates,
noise_model = noise_model,
retrieve_list=retrieve_list)
epc_ref = 0.0003191
# skip if no model rerun
Y1 =np.array([[507, 503, 493, 478, 445, 423, 394, 390, 344, 310],
[506, 505, 497, 480, 447, 439, 415, 401, 383, 354],
[509, 501, 501, 487, 453, 443, 422, 414, 369, 352],
[511, 507, 497, 483, 450, 424, 397, 374, 332, 322],
[508, 505, 493, 482, 452, 452, 427, 408, 366, 339],
[511, 503, 490, 480, 456, 435, 418, 399, 369, 364],
[510, 499, 495, 484, 432, 409, 417, 374, 374, 350],
[508, 503, 487, 484, 470, 440, 416, 369, 363, 338]])
# skip if no model rerun
Y2 = np.array([[508, 494, 470, 462, 406, 376, 359, 360, 324, 334],
[509, 489, 477, 450, 421, 395, 356, 340, 316, 300],
[509, 494, 473, 455, 426, 397, 355, 327, 317, 320],
[510, 498, 475, 444, 406, 355, 326, 323, 278, 271],
[508, 492, 479, 455, 411, 389, 358, 335, 306, 307],
[509, 497, 487, 448, 412, 365, 351, 328, 304, 292],
[512, 499, 483, 455, 395, 390, 345, 331, 292, 306],
[509, 498, 475, 451, 408, 388, 366, 344, 316, 300]])
# function to optimize
def lsf(x, a, alpha, b):
return a * alpha ** x + b
# curve fit
popt_s,pcov_s = curve_fit(lsf, np.array(nseeds*list(nCliffs)),
np.ravel(Y1)/shots,
bounds = ([scale-0.15,.9,1-scale-.15],
[scale+0.15,1.0,1-scale+.15]))
perr_s= np.sqrt(np.diag(pcov_s))
# get EPC and EPC sigma for LSF accelerated
alpha_f = popt_s[1]
alpha_f_err = perr_s[1]
popt_s,perr_s
# curve fit
popt_i,pcov_i = curve_fit(lsf, np.array(nseeds*list(nCliffs)),
np.ravel(Y2)/shots,
bounds = ([scale-0.15,.9,1-scale-.15],
[scale+0.15,1.0,1-scale+.15]))
perr_i= np.sqrt(np.diag(pcov_i))
# get EPC and EPC sigma for LSF accelerated
alphC_f = popt_i[1]
alphC_f_err = perr_i[1]
popt_i,perr_i
epc_est_f = scale*(1 - alphC_f/alpha_f)
epc_est_f_err = scale*(alphC_f/alpha_f)*(np.sqrt(alpha_f_err**2 + alphC_f_err**2))
# function to optimize
def lsmf(x, a, alpha, p_tilde_m, b):
return x[1]*(a * alpha ** x[0] + b) + x[2]*(a * (alpha*p_tilde_m) ** x[0] + b)
# obtain the data
m_len = len(nCliffs)*nseeds
x0_lsmf = np.array(nseeds*2*list(nCliffs))
x1_lsmf = np.hstack((np.ones(m_len),np.zeros(m_len)))
x2_lsmf = np.hstack((np.zeros(m_len),np.ones(m_len)))
x_lsmf = np.vstack((x0_lsmf,x1_lsmf,x2_lsmf))
y_lsmf=np.hstack((np.ravel(Y1),np.ravel(Y2)))/shots
# curve fit
popt_m,pcov_m = curve_fit(lsmf, x_lsmf, y_lsmf,
bounds = ([scale-0.15,.9,.9,1-scale-.15],
[scale+0.15,1.0,1.0,1-scale+.15]))
perr_m = np.sqrt(np.diag(pcov_m))
# get EPC and EPC sigma for LSF accelerated
alpha_fm = popt_m[1]
p_tilde_m = popt_m[2]
alpha_fm_err = perr_m[1]
p_tilde_m_err = perr_m[2]
popt_m,perr_m
epc_est_fm = scale*(1 - p_tilde_m)
epc_est_fm_err = scale*p_tilde_m_err
# compare LSF and Reference
print("Model: Frequentist Reference")
print(" two-run accelerated")
print("EPC {0:.6f} {1:.6f} {2:.6f} "
.format(epc_est_f, epc_est_fm, epc_ref))
print("± sigma ± {0:.6f} ± {1:.6f} ------ "
.format(epc_est_f_err, epc_est_fm_err))
original_model = bf.get_bayesian_model(model_type="pooled",Y=Y1,shots=shots,m_gates=nCliffs,
mu_AB=[popt_s[0],popt_s[2]],cov_AB=[perr_s[0],perr_s[2]],
alpha_ref=alpha_f, alpha_upper=.999999, p_upper=.999999)
pm.model_to_graphviz(original_model)
trace_o = bf.get_trace(original_model, target_accept = .99)
azo_summary = bf.get_summary(original_model, trace_o)
azo_summary
alpha_original_p = azo_summary['mean']['alpha']
alpha_original_p_err = azo_summary['sd']['alpha']
interleaved_model = bf.get_bayesian_model(model_type="pooled",Y=Y2,shots=shots,m_gates=nCliffs,
mu_AB=[popt_i[0],popt_i[2]],cov_AB=[perr_i[0],perr_i[2]],
alpha_ref=alpha_f, alpha_upper=.999999, p_upper=.999999)
pm.model_to_graphviz(interleaved_model)
trace_i = bf.get_trace(interleaved_model, target_accept = .95)
azi_summary = bf.get_summary(interleaved_model, trace_i)
azi_summary
alpha_c_p = azi_summary['mean']['alpha']
alpha_c_p_err = azi_summary['sd']['alpha']
epc_est_p = scale*(1 - alpha_c_p/alpha_original_p)
epc_est_p_err = scale*(alpha_c_p/alpha_original_p)*(np.sqrt(alpha_original_p_err**2 + alpha_c_p_err**2))
Y = np.vstack((Y1,Y2))
RvsI = np.vstack((np.ones_like(Y1),np.zeros_like(Y2)))
IvsR = np.vstack((np.zeros_like(Y1),np.ones_like(Y2)))
tilde =bf.get_bayesian_model("tilde",Y=Y,shots=shots, m_gates=nCliffs,
alpha_ref=alpha_fm, p_testval= p_tilde_m,
mu_AB=[popt_m[0],popt_m[3]],cov_AB=[perr_m[0],perr_m[3]],
RvsI=RvsI,IvsR=IvsR, alpha_upper=.999999, p_upper=.999999)
pm.model_to_graphviz(tilde)
trace_t = bf.get_trace(tilde, target_accept = .95)
azt_summary = bf.get_summary(tilde, trace_t)
azt_summary
epc_est_a = scale*(1 - azt_summary['mean']['p_tilde'])
epc_est_a_err = scale* (azt_summary['sd']['p_tilde'])
# compare LSF and SMC
print("Model: Frequentist Bayesian Reference")
print(" two-run accelerated two-run accelerated ")
print("EPC {0:.6f} {1:.6f} {2:.6f} {3:.6f} {4:.6f} "
.format(epc_est_f ,epc_est_fm, epc_est_p, epc_est_a, epc_ref))
print("± sigma ± {0:.6f} ± {1:.6f} ± {2:.6f} ± {3:.6f} ------ "
.format(epc_est_f_err, epc_est_fm_err, epc_est_p_err, epc_est_a_err))
# obtain EPC from alpha (used by plot_posterior)
def alpha_to_EPC(alpha):
return scale*(1-alpha)
# for refering the interleaved gate in the title of the graphs
intl_g=str(interleaved_gates[0][0][0:2])+str(rb_pattern[0][0:2])
if RB_process in ["3_Q RB","2-3_Q RB"] :
intl_g=intl_g+"<"+str(interleaved_gates[1][0][0:1]+str(rb_pattern[1][0:2]))
import matplotlib.pyplot as plt # seems we need to reimport for replot WIP
with tilde:
ax = az.plot_posterior(trace_t, var_names=['p_tilde'], round_to=4, point_estimate=None,
transform = alpha_to_EPC)
ax.set_xlim(0.0, 0.0005)
plt.axvline(x=epc_est_fm,color='red',ls="-")
plt.axvline(x=epc_est_p,color='orange',ls="-")
plt.axvline(x=epc_est_f,color='cyan',ls="-")
if epc_ref > 0.0:
plt.axvline(x=epc_ref,color='green',ls=":")
plt.axvline(x=epc_est_a,color='blue',ls=":")
plt.title(RB_process +' $accelerated$, gate: ' + intl_g\
+", "+hardware+', backend: '+backend.name(),
fontsize=12)
Bayes_legend = "EPC Accelerated SMC: {0:1.3e} ({1:1.3e})".format(epc_est_a, epc_est_a_err)
Bayes2_legend = "EPC SMC 2-runs: {0:1.3e} ({1:1.3e})".format(epc_est_p, epc_est_p_err)
Fitter_legend = "EPC LSF 2-runs: {0:1.3e} ({1:1.3e})".format(epc_est_f, epc_est_f_err)
LSM_legend = "EPC Accelerated LSF: {0:1.3e} ({1:1.3e})".format(epc_est_fm, epc_est_fm_err)
Cal_legend = "EPC Reference: {0:1.3e}".format(epc_ref)
if epc_ref > 0.0:
plt.legend((Bayes_legend, "$Higher\; density\; interval$ HDI",
LSM_legend,Bayes2_legend,
Fitter_legend,Cal_legend), fontsize=10 )
else:
plt.legend((Bayes_legend, "$Higher\; density\; interval$ HDI",
LSM_legend, Bayes2_legend,
Fitter_legend), fontsize=10 )
import matplotlib.pyplot as plt # seems we need to reimport for replot WIP
fig, plt = plt.subplots(1, 1)
plt.set_ylabel("Ground State Population")
plt.set_xlabel("Number of Cliffords")
for i_seed in range(nseeds):
plt.scatter(nCliffs, Y1[i_seed,:]/shots, label = "data", marker="x",color="b")
plt.scatter(nCliffs, Y2[i_seed,:]/shots, label = "data", marker="+",color="r")
plt.plot(nCliffs,azt_summary['mean']['AB[0]']*azt_summary['mean']['alpha']**nCliffs+\
azt_summary['mean']['AB[1]'],'--',color="b")
plt.plot(nCliffs,azt_summary['mean']['AB[0]']*(azt_summary['mean']['alpha']*azt_summary['mean']['p_tilde'])**\
nCliffs+azt_summary['mean']['AB[1]'],'--',color="r")
plt.legend(("Standard",
"Interleaved"))
plt.set_title(RB_process +' SMC $accelerated$, gate: ' + intl_g\
+", "+hardware+', backend: '+backend.name(),
fontsize=14);
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/MonitSharma/Learn-Quantum-Computing-with-Qiskit
|
MonitSharma
|
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.tools.monitor import job_monitor
import matplotlib as mpl
# import basic plot tools
from qiskit.visualization import plot_histogram, plot_bloch_multivector
import numpy as np
from numpy import pi
qft_circuit = QuantumCircuit(3)
qft_circuit.clear()
#input state= 5
qft_circuit.x(0)
qft_circuit.x(2)
qft_circuit.h(0)
qft_circuit.cp(pi/2,0,1)
qft_circuit.cp(pi/4,0,2)
qft_circuit.h(1)
qft_circuit.cp(pi/2,1,2)
qft_circuit.h(2)
#qft_circuit.swap(0,2)
qft_circuit.draw('mpl')
#output is the bloch sphere representation in the fourier basis
sim = Aer.get_backend("aer_simulator")
qft_circuit_init = qft_circuit.copy()
qft_circuit_init.save_statevector()
statevector = sim.run(qft_circuit_init).result().get_statevector()
plot_bloch_multivector(statevector)
IBMQ.save_account('')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 2 and not b.configuration().simulator and b.status().operational==True))
print(backend)
t_qc = transpile(qft_circuit, backend, optimization_level=3)#transpile=assembling the circuit and everything
job = backend.run(t_qc)#backend means device
job_monitor(job)
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
# useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from collections import Counter #Use this to convert results from list to dict for histogram
# importing the QISKit
from qiskit import QuantumCircuit, QuantumProgram
import Qconfig
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
device = 'ibmqx2' # the device to run on
#device = 'local_qasm_simulator' # uncomment to run on the simulator
N = 50 # Number of bombs
steps = 20 # Number of steps for the algorithm, limited by maximum circuit depth
eps = np.pi / steps # Algorithm parameter, small
QPS_SPECS = {
"name": "IFM",
"circuits": [{
"name": "IFM_gen", # Prototype circuit for bomb generation
"quantum_registers": [{
"name":"q_gen",
"size":1
}],
"classical_registers": [{
"name":"c_gen",
"size":1
}]},
{"name": "IFM_meas", # Prototype circuit for bomb measurement
"quantum_registers": [{
"name":"q",
"size":2
}],
"classical_registers": [{
"name":"c",
"size":steps+1
}]}]
}
Q_program = QuantumProgram(specs=QPS_SPECS)
Q_program.set_api(Qconfig.APItoken, Qconfig.config["url"])
# Quantum circuits to generate bombs
circuits = ["IFM_gen"+str(i) for i in range(N)]
# NB: Can't have more than one measurement per circuit
for circuit in circuits:
q_gen = Q_program.get_quantum_register("q_gen")
c_gen = Q_program.get_classical_register('c_gen')
IFM = Q_program.create_circuit(circuit, [q_gen], [c_gen])
IFM.h(q_gen[0]) #Turn the qubit into |0> + |1>
IFM.measure(q_gen[0], c_gen[0])
_ = Q_program.get_qasms(circuits) # Suppress the output
result = Q_program.execute(circuits, device, shots=1, max_credits=5, wait=10, timeout=240) # Note that we only want one shot
bombs = []
for circuit in circuits:
for key in result.get_counts(circuit): # Hack, there should only be one key, since there was only one shot
bombs.append(int(key))
#print(', '.join(('Live' if bomb else 'Dud' for bomb in bombs))) # Uncomment to print out "truth" of bombs
plot_histogram(Counter(('Live' if bomb else 'Dud' for bomb in bombs))) #Plotting bomb generation results
device = 'local_qasm_simulator' #Running on the simulator
circuits = ["IFM_meas"+str(i) for i in range(N)]
#Creating one measurement circuit for each bomb
for i in range(N):
bomb = bombs[i]
q = Q_program.get_quantum_register("q")
c = Q_program.get_classical_register('c')
IFM = Q_program.create_circuit(circuits[i], [q], [c])
for step in range(steps):
IFM.ry(eps, q[0]) #First we rotate the control qubit by epsilon
if bomb: #If the bomb is live, the gate is a controlled X gate
IFM.cx(q[0],q[1])
#If the bomb is a dud, the gate is a controlled identity gate, which does nothing
IFM.measure(q[1], c[step]) #Now we measure to collapse the combined state
IFM.measure(q[0], c[steps])
Q_program.get_qasms(circuits)
result = Q_program.execute(circuits, device, shots=1, max_credits=5, wait=10, timeout=240)
def get_status(counts):
# Return whether a bomb was a dud, was live but detonated, or was live and undetonated
# Note that registers are returned in reversed order
for key in counts:
if '1' in key[1:]:
#If we ever measure a '1' from the measurement qubit (q1), the bomb was measured and will detonate
return '!!BOOM!!'
elif key[0] == '1':
#If the control qubit (q0) was rotated to '1', the state never entangled because the bomb was a dud
return 'Dud'
else:
#If we only measured '0' for both the control and measurement qubit, the bomb was live but never set off
return 'Live'
results = {'Live': 0, 'Dud': 0, "!!BOOM!!": 0}
for circuit in circuits:
status = get_status(result.get_counts(circuit))
results[status] += 1
plot_histogram(results)
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
excited = Statevector.from_int(1, 2)
plot_bloch_multivector(excited.data)
from qiskit.tools.jupyter import *
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend('ibmq_armonk')
backend_config = backend.configuration()
assert backend_config.open_pulse, "Backend doesn't support Pulse"
dt = backend_config.dt
print(f"Sampling time: {dt*1e9} ns")
backend_defaults = backend.defaults()
import numpy as np
# unit conversion factors -> all backend properties returned in SI (Hz, sec, etc)
GHz = 1.0e9 # Gigahertz
MHz = 1.0e6 # Megahertz
us = 1.0e-6 # Microseconds
ns = 1.0e-9 # Nanoseconds
# We will find the qubit frequency for the following qubit.
qubit = 0
# The Rabi sweep will be at the given qubit frequency.
center_frequency_Hz = backend_defaults.qubit_freq_est[qubit] # The default frequency is given in Hz
# warning: this will change in a future release
print(f"Qubit {qubit} has an estimated frequency of {center_frequency_Hz / GHz} GHz.")
from qiskit import pulse, assemble # This is where we access all of our Pulse features!
from qiskit.pulse import Play
from qiskit.pulse import pulse_lib # This Pulse module helps us build sampled pulses for common pulse shapes
### Collect the necessary channels
drive_chan = pulse.DriveChannel(qubit)
meas_chan = pulse.MeasureChannel(qubit)
acq_chan = pulse.AcquireChannel(qubit)
inst_sched_map = backend_defaults.instruction_schedule_map
measure = inst_sched_map.get('measure', qubits=[0])
# Rabi experiment parameters
# Drive amplitude values to iterate over: 50 amplitudes evenly spaced from 0 to 0.75
num_rabi_points = 50
drive_amp_min = 0
drive_amp_max = 0.75
drive_amps = np.linspace(drive_amp_min, drive_amp_max, num_rabi_points)
# drive waveforms mush be in units of 16
drive_sigma = 80 # in dt
drive_samples = 8*drive_sigma # in dt
# Build the Rabi experiments:
# A drive pulse at the qubit frequency, followed by a measurement,
# where we vary the drive amplitude each time.
rabi_schedules = []
for drive_amp in drive_amps:
rabi_pulse = pulse_lib.gaussian(duration=drive_samples, amp=drive_amp,
sigma=drive_sigma, name=f"Rabi drive amplitude = {drive_amp}")
this_schedule = pulse.Schedule(name=f"Rabi drive amplitude = {drive_amp}")
this_schedule += Play(rabi_pulse, drive_chan)
# The left shift `<<` is special syntax meaning to shift the start time of the schedule by some duration
this_schedule += measure << this_schedule.duration
rabi_schedules.append(this_schedule)
rabi_schedules[-1].draw(label=True, scaling=1.0)
# assemble the schedules into a Qobj
num_shots_per_point = 1024
rabi_experiment_program = assemble(rabi_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots_per_point,
schedule_los=[{drive_chan: center_frequency_Hz}]
* num_rabi_points)
# RUN the job on a real device
#job = backend.run(rabi_experiment_program)
#print(job.job_id())
#from qiskit.tools.monitor import job_monitor
#job_monitor(job)
# OR retreive result from previous run
job = backend.retrieve_job("5ef3bf17dc3044001186c011")
rabi_results = job.result()
import matplotlib.pyplot as plt
plt.style.use('dark_background')
scale_factor = 1e-14
# center data around 0
def baseline_remove(values):
return np.array(values) - np.mean(values)
rabi_values = []
for i in range(num_rabi_points):
# Get the results for `qubit` from the ith experiment
rabi_values.append(rabi_results.get_memory(i)[qubit]*scale_factor)
rabi_values = np.real(baseline_remove(rabi_values))
plt.xlabel("Drive amp [a.u.]")
plt.ylabel("Measured signal [a.u.]")
plt.scatter(drive_amps, rabi_values, color='white') # plot real part of Rabi values
plt.show()
from scipy.optimize import curve_fit
def fit_function(x_values, y_values, function, init_params):
fitparams, conv = curve_fit(function, x_values, y_values, init_params)
y_fit = function(x_values, *fitparams)
return fitparams, y_fit
fit_params, y_fit = fit_function(drive_amps,
rabi_values,
lambda x, A, B, drive_period, phi: (A*np.cos(2*np.pi*x/drive_period - phi) + B),
[10, 0.1, 0.6, 0])
plt.scatter(drive_amps, rabi_values, color='white')
plt.plot(drive_amps, y_fit, color='red')
drive_period = fit_params[2] # get period of rabi oscillation
plt.axvline(drive_period/2, color='red', linestyle='--')
plt.axvline(drive_period, color='red', linestyle='--')
plt.annotate("", xy=(drive_period, 0), xytext=(drive_period/2,0), arrowprops=dict(arrowstyle="<->", color='red'))
plt.xlabel("Drive amp [a.u.]", fontsize=15)
plt.ylabel("Measured signal [a.u.]", fontsize=15)
plt.show()
pi_amp = abs(drive_period / 2)
print(f"Pi Amplitude = {pi_amp}")
# Drive parameters
# The drive amplitude for pi/2 is simply half the amplitude of the pi pulse
drive_amp = pi_amp / 2
# x_90 is a concise way to say pi_over_2; i.e., an X rotation of 90 degrees
x90_pulse = pulse_lib.gaussian(duration=drive_samples,
amp=drive_amp,
sigma=drive_sigma,
name='x90_pulse')
# Ramsey experiment parameters
time_max_us = 1.8
time_step_us = 0.025
times_us = np.arange(0.1, time_max_us, time_step_us)
# Convert to units of dt
delay_times_dt = times_us * us / dt
# create schedules for Ramsey experiment
ramsey_schedules = []
for delay in delay_times_dt:
this_schedule = pulse.Schedule(name=f"Ramsey delay = {delay * dt / us} us")
this_schedule += Play(x90_pulse, drive_chan)
this_schedule += Play(x90_pulse, drive_chan) << this_schedule.duration + int(delay)
this_schedule += measure << this_schedule.duration
ramsey_schedules.append(this_schedule)
ramsey_schedules[-1].draw(label=True, scaling=1.0)
# Execution settings
num_shots = 256
detuning_MHz = 2
ramsey_frequency = round(center_frequency_Hz + detuning_MHz * MHz, 6) # need ramsey freq in Hz
ramsey_program = assemble(ramsey_schedules,
backend=backend,
meas_level=1,
meas_return='avg',
shots=num_shots,
schedule_los=[{drive_chan: ramsey_frequency}]*len(ramsey_schedules)
)
# RUN the job on a real device
#job = backend.run(ramsey_experiment_program)
#print(job.job_id())
#from qiskit.tools.monitor import job_monitor
#job_monitor(job)
# OR retreive job from previous run
job = backend.retrieve_job('5ef3ed3a84b1b70012374317')
ramsey_results = job.result()
ramsey_values = []
for i in range(len(times_us)):
ramsey_values.append(ramsey_results.get_memory(i)[qubit]*scale_factor)
fit_params, y_fit = fit_function(times_us, np.real(ramsey_values),
lambda x, A, del_f_MHz, C, B: (
A * np.cos(2*np.pi*del_f_MHz*x - C) + B
),
[5, 1./0.4, 0, 0.25]
)
# Off-resonance component
_, del_f_MHz, _, _, = fit_params # freq is MHz since times in us
plt.scatter(times_us, np.real(ramsey_values), color='white')
plt.plot(times_us, y_fit, color='red', label=f"df = {del_f_MHz:.2f} MHz")
plt.xlim(0, np.max(times_us))
plt.xlabel('Delay between X90 pulses [$\mu$s]', fontsize=15)
plt.ylabel('Measured Signal [a.u.]', fontsize=15)
plt.title('Ramsey Experiment', fontsize=15)
plt.legend()
plt.show()
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
filename = "job_ids_jakarta_100step_20220412_030333_.pkl"
import pickle
with open(filename, "rb") as f:
print(pickle.load(f))
filename = "job_ids_jakarta_100step_20220413_012425_.pkl"
with open(filename, "rb") as f:
print(pickle.load(f))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# If you introduce a list with less colors than bars, the color of the bars will
# alternate following the sequence from the list.
import numpy as np
from qiskit.quantum_info import DensityMatrix
from qiskit import QuantumCircuit
from qiskit.visualization import plot_state_paulivec
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0, 1)
qc.ry(np.pi/3, 0)
qc.rx(np.pi/5, 1)
matrix = DensityMatrix(qc)
plot_state_paulivec(matrix, color=['crimson', 'midnightblue', 'seagreen'])
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.circuit.library import QFT
from src.arithmetic.increment import control_increment, control_decrement
from src.util.util import run_qc
def count(circuit, count_register, control_register, amount=1, step=1, apply_QFT=True):
q_l = len(count_register)
a_l = len(control_register)
assert a_l % step == 0
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=False, insert_barriers=True, name='qft'), qubits=count_register)
# circuit.barrier()
for i in range(int(a_l / step)):
circuit = control_increment(circuit, count_register, control_register[i * step: (i + 1) * step],
amount, apply_QFT=False)
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='iqft'), qubits=count_register)
# circuit.barrier()
return circuit
def mincount(circuit, count_register, control_register, amount=1, step=1, apply_QFT=True):
q_l = len(count_register)
a_l = len(control_register)
assert a_l % step == 0
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=False, insert_barriers=True, name='qft'), qubits=count_register)
# circuit.barrier()
for i in range(int(a_l / step)):
circuit = control_decrement(circuit, count_register, control_register[i * step:(i + 1) * step], amount, apply_QFT=False)
if apply_QFT:
# circuit.barrier()
circuit = circuit.compose(QFT(num_qubits=q_l, approximation_degree=0, do_swaps=True,
inverse=True, insert_barriers=True, name='iqft'), qubits=count_register)
# circuit.barrier()
return circuit
def test():
q = QuantumRegister(3)
a = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, a, c)
qc.x(a[0])
qc.x(q[:])
qc = mincount(qc, q, a)
# Should equal 110
qc.measure(q[:], c[:])
run_qc(qc)
qc.draw(output="mpl")
if __name__ == "__main__":
test()
|
https://github.com/anpaschool/QC-School-Fall2020
|
anpaschool
|
from google.colab import drive
drive.mount('/content/drive')
!pip install pylatexenc
!pip install qiskit
# the output will be cleared after installation
from IPython.display import clear_output
clear_output()
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
plt.style.use('seaborn-notebook')
from scipy.fft import fft
def periodfind(x,I,N): # find period a of function f(x)=x^a mod N
arr=[]
for i in range(N):
f= (x**i)%(I)
arr.append(f)
return arr
N=16
I=15
a=11
y=np.array(periodfind(a,I,N))
x=np.arange(N)
print('f(x) = ',y) # Values of f(x)
# plotting
plt.style.use('seaborn-whitegrid')
def plot_fig(xvals,yvals,a,I): # to make the plot nice
yvals=list(yvals)
fig, ax = plt.subplots()
ax.plot(xvals, yvals, linewidth=1, linestyle='--', marker='o')
ax.set(xlabel='$x$', ylabel='f(x)=${a}^x$(mod {I})'.format(a=a,I=I),
title='Period of function f(x)=${a}^x$(mod {I})'.format(a=a,I=I))
try: # plot r on the graph
r = yvals[1:].index(1) +1
plt.annotate(s='', xy=(0,1), xytext=(r,1), arrowprops=dict(arrowstyle='<->'))
plt.annotate(s='$r=%i$' % r, xy=(r/3,1.5))
except:
print('Could not find period, check a < N and have no common factors.')
display(plt.show())
plot_fig(x,y,a,I)
z=fft(y) #Apply Fast fourier Transform
plt.style.use('seaborn-whitegrid')
plt.title('Fast Fourier transform of function f(x)=$3^x$(mod 16)')
plt.bar(x,np.abs(z),width=0.5)
display(plt.show())
print('Period is 1/(a/N) is ',2)
%matplotlib inline
import matplotlib.pyplot as plt
from qiskit import IBMQ
# Importing standard Qiskit libraries and configuring account
from qiskit.compiler import transpile, assemble
# Loading your IBM Q account(s)
# provider = IBMQ.load_account() # uncomment to run on quantum computerr
import numpy as np
import math
import qiskit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, execute
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram, plot_bloch_multivector, plot_state_hinton
from qiskit import Aer
def measure(circuit,n,c):
for i in range(n):
circuit.measure(i,i)
return circuit
pi = np.pi
qc_q = QuantumRegister(4, 'input') #Initialize the Working Register
qc_c = QuantumRegister(2, 'period') #Initialize the Control Register
c = ClassicalRegister(4) #Register which will eventually hold measurements
Shor = QuantumCircuit(qc_q, qc_c,c)
Shor.x(4) # It is common convention to add a not gate before Modular Exponentiation
Shor.h(qc_q[0:4]) #Initialize 4 Hadamard Gates to allow for all possibilities
Shor.barrier()
Shor.draw('mpl')
#This is a compiled version of modular exponentiation that will not generalize outside of fermat primes.
Shor.cx(qc_q[0],qc_c[0])
Shor.cx(qc_q[0],qc_c[1])
Shor.barrier()
Shor.draw(output='mpl')
#This can be ommited by classically swapping the order of measurments if noise is an issue.
Shor.swap(qc_q[0],qc_q[3])
Shor.swap(qc_q[1],qc_q[2])
#The Inverse Quantum Fourier Transform
Shor.h(0)
Shor.crz(-pi/2,qc_q[0],qc_q[1])
Shor.h(1)
Shor.crz(-pi/2,qc_q[1],qc_q[2])
Shor.crz(-pi/4,qc_q[0],qc_q[2])
Shor.h(2)
Shor.crz(-pi/2,qc_q[2],qc_q[3])
Shor.crz(-pi/4,qc_q[1],qc_q[3])
Shor.crz(-pi/8,qc_q[0],qc_q[3])
Shor.h(3)
Shor.barrier()
Shor.draw(output='mpl')
#Measure Working Register
Shor.measure(qc_q[3],3)
Shor.measure(qc_q[2],2)
Shor.measure(qc_q[1],1)
Shor.measure(qc_q[0],0)
Shor.draw(output='mpl')
import pandas as pd
df=pd.read_csv("/content/drive/My Drive/QC-project/SHor code/shor_format_15_11.csv")
print(df.head(16))
plt.plot(df["input_reg_value"],df["period_reg_value"])
plt.show()
# # Load our saved IBMQ accounts and get the least busy backend device with less than or equal to nqubits
# provider = IBMQ.get_provider(hub='ibm-q')
# from qiskit.providers.ibmq import least_busy
# backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= N
# and not x.configuration().simulator
# and x.status().operational==True))
# print("least busy backend: ", backend)
simulator = Aer.get_backend('qasm_simulator')
# backend = provider.get_backend("ibmq_16_melbourne") # to run in the actual quantum computer
# Replace simulator in execute function with 'backend' to run on a quantum computer
job = execute(Shor, simulator, shots=8192)
result = job.result()
counts = result.get_counts(Shor)
plot_histogram(counts)
output=[]
for keys in list(counts.keys()):
output.append(int(keys,2))
print('The values with maximum probabilities are: {}'.format(output))
# Classical analysis of result(classical)
print(output)
y_over_N=[out/N for out in output[1:] ]
print('y over N is',y_over_N)
def find_period(output):
y_over_N=[out/N for out in output[1:] ]
from fractions import Fraction
temp=[]
num=len(y_over_N)
for i in range(num):
temp.append(Fraction(y_over_N[i]).limit_denominator(N))
temp[i]=Fraction(temp[i].denominator,temp[i].numerator)
return temp[i].numerator
a= find_period(output)
print('The period of the function is ',a)
# find factors by taking GCD
from math import gcd
factors=[]
if (a/2)-(a//2)==0: # test if (a/2) is integer
p=int(a/2)
factors.append(gcd(11**p+1,15))
factors.append(gcd(11**p-1,15))
print(factors)
# General Implementation of Shor's Algorithm
# Using Qiskit library
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import Shor
n=63 # n is the number to be factored.
factors= Shor(n) # Shor() is a function in qiskit.aqua.algorithms that performs shor's algorithm
simulator = Aer.get_backend('qasm_simulator')
result_dict = factors.run(QuantumInstance(simulator))
result = result_dict['factors']
result
qc_shor=factors.construct_circuit()
qc_shor.draw('mpl')
import qiskit
qiskit.__qiskit_version__
|
https://github.com/martynscn/Masters-Thesis-on-Quantum-Cryptography
|
martynscn
|
# This code has been adapted and modified from IBM Qiskit 2021 and also from https://github.com/ttlion/ShorAlgQiskit.
# It uses the implementation as contained in the work of Stephane Beauregard (https://arxiv.org/abs/quant-ph/0205095)
# Many thanks to IBM Qiskit team, Tiago Miguel (ttlion), Qubit by Qubit, Peter Shor and Stephane Beauregard.
from typing import Optional, Union, Tuple, List
import math
import array
import fractions
import logging
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister, execute, IBMQ, transpile,BasicAer, Aer, assemble
from qiskit.circuit import Gate, Instruction, ParameterVector
from qiskit.circuit.library import QFT
from qiskit.providers import BaseBackend, Backend
from qiskit.quantum_info import partial_trace
from qiskit.utils import summarize_circuits
from qiskit.utils.arithmetic import is_power
from qiskit.utils.validation import validate_min
from qiskit.utils.quantum_instance import QuantumInstance
import qiskit.visualization
from qiskit.providers.aer import QasmSimulator
from datetime import datetime
import csv
# provider = IBMQ.enable_account("PUT TOKEN HERE")
backend = QasmSimulator()
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all" #"last_expr" or "all"
def get_angles(a: int, n) -> np.ndarray:
# """Calculates the array of angles to be used in the addition in Fourier Space."""
s = bin(int(a))[2:].zfill(n + 1)
angles = np.zeros([n + 1])
for i in range(0, n + 1):
for j in range(i, n + 1):
if s[j] == '1':
angles[n - i] += math.pow(2, -(j - i))
angles[n - i] *= np.pi
return angles[::-1]
# This returns the angles in the opposite order
def my_create_QFT(qft_num_qubits,approximation_degree: int = 0,do_swaps: bool = False,insert_barriers: bool = True, name: str = 'qft'):
# up_reg = QuantumRegister(size = qft_num_qubits, name="aux")
circuit_qft = QuantumCircuit(qft_num_qubits)
i=qft_num_qubits-1
while i>=0:
# circuit_qft.h(up_reg[i])
circuit_qft.h(i)
j=i-1
while j>=0:
if (np.pi)/(pow(2,(i-j))) > approximation_degree:
# circuit_qft.cu1( (np.pi)/(pow(2,(i-j))) , up_reg[i] , up_reg[j] )
circuit_qft.cu1( (np.pi)/(pow(2,(i-j))) , i , j )
j=j-1
if insert_barriers:
circuit_qft.barrier()
i=i-1
""" If specified, apply the Swaps at the end """
if do_swaps:
i=0
while i < ((qft_num_qubits-1)/2):
# circuit_qft.swap(up_reg[i], up_reg[qft_num_qubits-1-i])
circuit_qft.swap(i, qft_num_qubits-1-i)
i=i+1
circuit_qft.name = "QFT"
return circuit_qft
def my_create_inverse_QFT(qft_num_qubits,approximation_degree: int = 0,do_swaps: bool = False,insert_barriers: bool = True, name: str = 'iqft'):
my_create_QFT_circuit = my_create_QFT(qft_num_qubits,approximation_degree,do_swaps,insert_barriers, name)
my_create_inverse_QFT_circuit = my_create_QFT_circuit.inverse()
my_create_inverse_QFT_circuit.name = "QFT†"
return my_create_inverse_QFT_circuit
def phi_add_gate(size: int, angles: Union[np.ndarray, ParameterVector]) -> Gate:
# """Gate that performs addition by a in Fourier Space."""
circuit = QuantumCircuit(size, name="phi_add")
for i, angle in enumerate(angles):
circuit.p(angle, i)
return circuit.to_gate()
def double_controlled_phi_add_mod_N(num_qubits: int, angles: Union[np.ndarray, ParameterVector],reg_size, a, N, n) -> QuantumCircuit:
# """Creates a circuit which implements double-controlled modular addition by a."""
circuit = QuantumCircuit(num_qubits, name="ccphi_add_mod_N")
ctl_up = 0
ctl_down = 1
ctl_aux = 2
# get qubits from aux register, omitting the control qubit
qubits = range(3, num_qubits)
# store the gates representing addition/subtraction by a in Fourier Space
phi_add_a = phi_add_gate(len(qubits), angles)
iphi_add_a = phi_add_a.inverse()
phi_add_N = phi_add_gate(reg_size - 1, get_angles(N, n))
iphi_add_N = phi_add_N.inverse()
circuit.append(phi_add_a.control(2), [ctl_up, ctl_down, *qubits])
circuit.append(iphi_add_N, qubits)
qft = QFT(n + 1).to_instruction()
# qft = my_create_QFT(n + 1).to_instruction()
iqft = QFT(n + 1).inverse().to_instruction()
# iqft = my_create_inverse_QFT(n + 1).to_instruction()
circuit.append(iqft, qubits)
circuit.cx(qubits[0], ctl_aux)
circuit.append(qft, qubits)
circuit.append(phi_add_N, qubits)
circuit.append(iphi_add_a.control(2), [ctl_up, ctl_down, *qubits])
circuit.append(iqft, qubits)
circuit.x(qubits[0])
circuit.cx(qubits[0], ctl_aux)
circuit.x(qubits[0])
circuit.append(qft, qubits)
circuit.append(phi_add_a.control(2), [ctl_up, ctl_down, *qubits])
return circuit
# """Circuit that implements single controlled modular multiplication by a"""
def controlled_multiple_mod_N(num_qubits: int, N: int, a: int, n, aux_reg_size):
# """Implements modular multiplication by a as an instruction."""
circuit = QuantumCircuit(
num_qubits,
# name="multiply_by_{}_mod_{}".format(a % N, N),
name=r"${0}^{{{1}^{{{2}}}}} mod{3}$".format(2,2,int(math.log(math.log(a,2),2)), N)
)
# label = r"${0}^{{{1}^{{{2}}}}} mod{3}$".format("†","y")
down = circuit.qubits[1: n + 1]
aux = circuit.qubits[n + 1:]
qubits = [aux[i] for i in reversed(range(n + 1))]
ctl_up = 0
ctl_aux = aux[-1]
angle_params = ParameterVector("angles", length=len(aux) - 1)
double_controlled_phi_add = double_controlled_phi_add_mod_N(
len(aux) + 2, angle_params, aux_reg_size, a, N, n
)
idouble_controlled_phi_add = double_controlled_phi_add.inverse()
qft_circuit = QFT(n + 1).to_instruction()
# qft_circuit = my_create_QFT(n + 1).to_instruction()
iqft_circuit = QFT(n + 1).inverse().to_instruction()
# iqft_circuit = my_create_inverse_QFT(n + 1).to_instruction()
circuit.append(qft_circuit, qubits)
# perform controlled addition by a on the aux register in Fourier space
for i, ctl_down in enumerate(down):
a_exp = (2 ** i) * a % N
angles = get_angles(a_exp, n)
bound = double_controlled_phi_add.assign_parameters({angle_params: angles})
circuit.append(bound, [ctl_up, ctl_down, ctl_aux, *qubits])
circuit.append(iqft_circuit, qubits)
# perform controlled subtraction by a in Fourier space on both the aux and down register
for j in range(n):
circuit.cswap(ctl_up, down[j], aux[j])
circuit.append(qft_circuit, qubits)
a_inv = modinv(a, N)
for i in reversed(range(len(down))):
a_exp = (2 ** i) * a_inv % N
angles = get_angles(a_exp, n)
bound = idouble_controlled_phi_add.assign_parameters({angle_params: angles})
circuit.append(bound, [ctl_up, down[i], ctl_aux, *qubits])
circuit.append(iqft_circuit, qubits)
return circuit
def modinv(a: int, m: int) -> int:
# """Returns the modular multiplicative inverse of a with respect to the modulus m."""
def egcd(a: int, b: int) -> Tuple[int, int, int]:
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
g, x, _ = egcd(a, m)
if g != 1:
raise ValueError("The greatest common divisor of {} and {} is {}, so the "
"modular inverse does not exist.".format(a, m, g))
return x % m
def get_factors(N: int, a: int, measurement: str) -> Optional[List[int]]:
# """Apply the continued fractions to find r and the gcd to find the desired factors."""
x_final = int(measurement, 2)
#print('In decimal, x_final value for this result is: {}.'.format(x_final))
if x_final <= 0:
fail_reason = 'x_final value is <= 0, there are no continued fractions.'
else:
fail_reason = None
#print('Running continued fractions for this case.')
# Calculate T and x/T
T_upper = len(measurement)
T = pow(2, T_upper)
x_over_T = x_final / T ## this is our theta
# Cycle in which each iteration corresponds to putting one more term in the
# calculation of the Continued Fraction (CF) of x/T
# Initialize the first values according to CF rule
i = 0
b = array.array('i')
t = array.array('f')
b.append(math.floor(x_over_T))
t.append(x_over_T - b[i])
exponential = 0.0
while i < N and fail_reason is None:
# From the 2nd iteration onwards, calculate the new terms of the CF based on the previous terms as the rule suggests
if i > 0:
try:
b_temp = math.floor(1 / t[i - 1])
except ZeroDivisionError as err:
b_temp = 0
b.append(b_temp)
try:
t_temp = (1 / t[i - 1]) - b[i]
except ZeroDivisionError as err:
t_temp = 0
t.append(t_temp) # type: ignore
# Calculate the denominator of the CF using the known terms
denominator = calculate_continued_fraction(b)
# Increment i for next iteration
i += 1
if denominator % 2 == 1:
#print('Odd denominator, will try next iteration of continued fractions.')
continue
# Denominator is even, try to get factors of N. Get the exponential a^(r/2)
if denominator < 1000:
try:
exponential = pow(a, denominator / 2)
except OverflowError as err:
exponential = 999999999
# Check if the value is too big or not
if exponential > 1000000:
if exponential == 999999999:
fail_reason = 'OverflowError'
else:
fail_reason = 'denominator of continued fraction is too big (> 10^9).'
else:
# The value is not too big, get the right values and do the proper gcd()
putting_plus = int(exponential + 1)
putting_minus = int(exponential - 1)
one_factor = math.gcd(putting_plus, N)
other_factor = math.gcd(putting_minus, N)
# Check if the factors found are trivial factors or are the desired factors
if any(factor in {1, N} for factor in (one_factor, other_factor)):
#print('Found just trivial factors, not good enough.')
# Check if the number has already been found, (use i - 1 because i was already incremented)
if t[i - 1] == 0:
fail_reason = 'the continued fractions found exactly x_final/(2^(2n)).'
else:
return sorted((one_factor, other_factor))
# Search for factors failed, write the reason for failure to the debug logs
#print('Cannot find factors from measurement {0} because {1}'.format(measurement, fail_reason or 'it took too many attempts.'))
return None
def calculate_continued_fraction(b: array.array) -> int:
# """Calculate the continued fraction of x/T from the current terms of expansion b."""
x_over_T = 0
for i in reversed(range(len(b) - 1)):
x_over_T = 1 / (b[i + 1] + x_over_T)
x_over_T += b[0]
frac = fractions.Fraction(x_over_T).limit_denominator()
#print('Approximation number %s of continued fractions:'.format(len(b)))
#print("Numerator:{0} \t\t Denominator: {1}.".format(frac.numerator, frac.denominator))
return frac.denominator
def process_results(sim_result, circuit, shots, N, a, n):
counts_result = sim_result.get_counts(circuit)
total_counts = len(counts_result)
counts_result_sorted = sorted(counts_result.items(), key=lambda x: x[1], reverse=True)
# """ Print info to user from the simulation results """
# print('Printing the various results followed by how many times they happened (out of the {} cases):\n'.format(shots))
counts_result_keys = list(counts_result.keys())
counts_result_values = list(counts_result.values())
#i=0
#while i < len(counts_result):
#print('Result \"{0}\" happened {1} times out of {2}\n'.format(list(sim_result.get_counts().keys())[i],list(sim_result.get_counts().values())[i],shots))
#print('Result \"{0}\" happened {1} times out of {2}\n'.format(counts_result_keys[i],counts_result_values[i],shots))
#i=i+1
prob_success=0
prob_failure=0
result_successful_counts = 0
result_failure_counts = 0
# len(counts_result_sorted)
# For each simulation result, print proper info to user and try to calculate the factors of N
#for measurement in counts_result_keys:
for measurement, frequency in counts_result_sorted:
# Get the x_final value from the final state qubits
x_value = int(measurement, 2)
#prob_this_result = 100 * ( int(counts_result[measurement] ) ) / (shots)
prob_this_result = 100 * frequency/shots
# print("------> Analyzing result {0}. This result happened in {1:.4f} % of all cases\nIn decimal, x_final value for this result is: {2}".format(measurement,prob_this_result,x_value))
factors = get_factors(N, a, measurement)
if factors:
prob_success = prob_success + prob_this_result
# print('Found factors {0} from measurement {1} which is {2} in decimal.\n'.format(factors, measurement, x_value))
result_successful_counts = result_successful_counts + 1
if factors not in result_factors:
result_factors.append(factors)
elif not factors:
prob_failure = prob_failure + prob_this_result
result_failure_counts = result_failure_counts + 1
return [result_factors, prob_success, prob_failure, total_counts, result_successful_counts,result_failure_counts]
def my_shor(a,N,shots):
start_time_number = datetime.now()
start_time = start_time_number.strftime("%H:%M:%S")
summary_result = dict()
validate_min('N', N, 3)
validate_min('a', a, 2)
if N < 1 or N % 2 == 0:
raise ValueError('The input needs to be an odd integer greater than 1.')
if a >= N or math.gcd(a, N) != 1:
raise ValueError('The integer a needs to satisfy a < N and gcd(a, N) = 1.')
n = math.ceil(math.log(N,2))
global result_factors
result_factors = []
tf, b, p = is_power(N, return_decomposition=True)
if tf:
print('The input integer is a power: {0}={1}^{2}.'.format(N, b, p))
result_factors.append(b)
# """auxilliary quantum register used in addition and multiplication"""
aux_reg = QuantumRegister(size = n+2, name="aux_reg")
up_reg = QuantumRegister(2*n, name = "up_reg")
# """quantum register where the multiplications are made"""
down_reg = QuantumRegister(n, name = "down_reg")
# """classical register where the measured values of the QFT are stored"""
up_classic = ClassicalRegister(2*n, name="up_classic")
# """ Create Quantum Circuit """
circuit = QuantumCircuit(up_reg ,down_reg ,aux_reg, up_classic, name="Shor circuit(N={}, a={})".format(N, a))
# phi_add_N_gate = phiADD(circuit,q,a,N,inv)
phi_add_N_gate = phi_add_gate(aux_reg.size - 1, get_angles(N,n))
iphi_add_N_gate = phi_add_N_gate.inverse()
# """ Initialize down register to 1 and create maximal superposition in top register """
circuit.h(up_reg)
circuit.x(down_reg[0])
# circuit.draw(filename = "shor_standard_QFT")
# """ Apply the multiplication gates as showed in the report in order to create the exponentiation """
for i, ctl_up in enumerate(up_reg): # type: ignore
a_aux = int(pow(a, pow(2, i)))
controlled_multiple_mod_N_circuit = controlled_multiple_mod_N(
len(down_reg) + len(aux_reg) + 1, N, a_aux,n,aux_reg.size
)
controlled_multiple_mod_N_result = controlled_multiple_mod_N_circuit.to_instruction()
circuit.append(
controlled_multiple_mod_N_result, [ctl_up, *down_reg, *aux_reg]
)
# circuit.draw()
iqft = QFT(len(up_reg)).inverse().to_instruction()
# iqft = my_create_inverse_QFT(len(up_reg)).to_instruction()
# iqft = my_create_inverse_QFT(len(up_reg), insert_barriers = False).to_gate(label = r"$QFT^{{{0}}}$".format("†"))
circuit.append(iqft, up_reg)
circuit.measure(up_reg, up_classic)
# circuit.draw(filename = "shor_standard_QFT_final_circuit",fold = -1 )
# print(summarize_circuits(circuit))
# circuit.draw()
print('Running with N={0} and a={1} with number of qubits n={2}'.format(N, a, 4*n + 2))
qc_compiled = transpile(circuit, backend, optimization_level = 3)
job_sim_1 = backend.run(qc_compiled, shots=shots)
sim_result=job_sim_1.result()
# counts_result = sim_result.get_counts(circuit)
# len(counts_result)
# measurement_plot = qiskit.visualization.plot_histogram(counts_result,figsize=(20, 12) ,number_to_keep = 30,bar_labels=True, title = "Measurement results from shor_standard_QFT circuit variant" )
# measurement_plot.savefig("shor_standard_QFT_measurement")
# measurement_plot
processed_result = process_results(sim_result, circuit, shots, N, a, n)
end_time_number = datetime.now()
end_time = end_time_number.strftime("%H:%M:%S")
duration = end_time_number - start_time_number
print("Current Start Time =", start_time)
print(processed_result)
print("Current End Time =", end_time)
circuit_count_ops = circuit.count_ops()
circuit_decomposed = circuit.decompose()
circuit_decomposed_count_ops = circuit_decomposed.count_ops()
qc_compiled_count_ops = qc_compiled.count_ops()
summary_result["num_qubits"] = n
summary_result["Number(N)"] = N
summary_result["a"] = a
summary_result["start_time"] = start_time
summary_result["end_time"] = end_time
summary_result["duration"] = duration
summary_result["result_factors"] = processed_result[0]
summary_result["prob_success"] = processed_result[1]
summary_result["prob_failure"] = processed_result[2]
summary_result["total_counts"] = processed_result[3]
summary_result["result_successful_counts"] = processed_result[4]
summary_result["result_failure_counts"] = processed_result[5]
summary_result["circuit_width"] = circuit.width()
summary_result["circuit_depth"] = circuit.depth()
summary_result["circuit_size"] = circuit.size()
summary_result["circuit_num_nonlocal_gates"] = circuit.num_nonlocal_gates()
summary_result["circuit_num_ancillas"] = circuit.num_ancillas
summary_result["circuit_num_clbits"] = circuit.num_clbits
summary_result["circuit_num_qubits"] = circuit.num_qubits
summary_result["circuit_num_ancillas"] = circuit.num_ancillas
summary_result["circuit_num_of_count_ops"] = len(circuit_count_ops)
summary_result["circuit_num_of_x"] = circuit_count_ops.get('x')
summary_result["circuit_num_of_measure"] = circuit_count_ops.get('measure')
summary_result["circuit_num_of_h"] = circuit_count_ops.get('h')
summary_result["circuit_num_of_cswap"] = circuit_count_ops.get('cswap')
summary_result["circuit_num_of_swap"] = circuit_count_ops.get('swap')
summary_result["circuit_num_of_cx"] = circuit_count_ops.get('cx')
summary_result["circuit_num_of_toffoli"] = circuit_count_ops.get('toffoli')
summary_result["circuit_num_of_p"] = circuit_count_ops.get('p')
summary_result["circuit_num_of_t"] = circuit_count_ops.get('t')
summary_result["circuit_decomposed_width"] = circuit_decomposed.width()
summary_result["circuit_decomposed_depth"] = circuit_decomposed.depth()
summary_result["circuit_decomposed_size"] = circuit_decomposed.size()
summary_result["circuit_decomposed_num_nonlocal_gates"] = circuit_decomposed.num_nonlocal_gates()
summary_result["circuit_decomposed_num_ancillas"] = circuit_decomposed.num_ancillas
summary_result["circuit_decomposed_num_clbits"] = circuit_decomposed.num_clbits
summary_result["circuit_decomposed_num_qubits"] = circuit_decomposed.num_qubits
summary_result["circuit_decomposed_num_ancillas"] = circuit_decomposed.num_ancillas
summary_result["circuit_decomposed_num_of_count_ops"] = len(circuit_decomposed_count_ops)
summary_result["circuit_decomposed_num_of_x"] = circuit_decomposed_count_ops.get('x')
summary_result["circuit_decomposed_num_of_measure"] = circuit_decomposed_count_ops.get('measure')
summary_result["circuit_decomposed_num_of_h"] = circuit_decomposed_count_ops.get('h')
summary_result["circuit_decomposed_num_of_cswap"] = circuit_decomposed_count_ops.get('cswap')
summary_result["circuit_decomposed_num_of_swap"] = circuit_decomposed_count_ops.get('swap')
summary_result["circuit_decomposed_num_of_cx"] = circuit_decomposed_count_ops.get('cx')
summary_result["circuit_decomposed_num_of_toffoli"] = circuit_decomposed_count_ops.get('toffoli')
summary_result["circuit_decomposed_num_of_p"] = circuit_decomposed_count_ops.get('p')
summary_result["circuit_decomposed_num_of_t"] = circuit_decomposed_count_ops.get('t')
summary_result["qc_compiled_width"] = qc_compiled.width()
summary_result["qc_compiled_depth"] = qc_compiled.depth()
summary_result["qc_compiled_size"] = qc_compiled.size()
summary_result["qc_compiled_num_nonlocal_gates"] = qc_compiled.num_nonlocal_gates()
summary_result["qc_compiled_num_ancillas"] = qc_compiled.num_ancillas
summary_result["qc_compiled_num_clbits"] = qc_compiled.num_clbits
summary_result["qc_compiled_num_qubits"] = qc_compiled.num_qubits
summary_result["qc_compiled_num_ancillas"] = qc_compiled.num_ancillas
summary_result["qc_compiled_num_of_count_ops"] = len(qc_compiled_count_ops)
summary_result["qc_compiled_num_of_x"] = qc_compiled_count_ops.get('x')
summary_result["qc_compiled_num_of_measure"] = qc_compiled_count_ops.get('measure')
summary_result["qc_compiled_num_of_h"] = qc_compiled_count_ops.get('h')
summary_result["qc_compiled_num_of_cswap"] = qc_compiled_count_ops.get('cswap')
summary_result["qc_compiled_num_of_swap"] = qc_compiled_count_ops.get('swap')
summary_result["qc_compiled_num_of_cx"] = qc_compiled_count_ops.get('cx')
summary_result["qc_compiled_num_of_toffoli"] = qc_compiled_count_ops.get('toffoli')
summary_result["qc_compiled_num_of_p"] = qc_compiled_count_ops.get('p')
summary_result["qc_compiled_num_of_t"] = qc_compiled_count_ops.get('t')
return summary_result
# Run for just a single number N
%%time
N = 33
shots = 1024
global result_factors
all_summary_result_temp = []
for random_a in range(16, 17):
if math.gcd(random_a,N) > 1:
continue
a = random_a
summary_result = my_shor(a,N,shots)
print("Finished running for a = {} and N = {}\n".format(a, N))
all_summary_result_temp.append(summary_result)
summary_result_list = []
for key, value in summary_result.items():
summary_result_list.append([key,value])
summary_result_list
with open("a({0})_N({1})_standard.csv".format(a, N), 'a') as myfile:
write = csv.writer(myfile)
#write.writerow(fields)
write.writerows(summary_result_list)
all_summary_result_temp
# Run for many numbers N.
%%time
shots = 1024
global result_factors
all_summary_result = []
for N in [15, 21, 33, 35, 39, 51, 55, 57]:
for a in range(2, N):
if math.gcd(a,N) > 1:
continue
print("Beginning running for a = {} and N = {}".format(a, N))
summary_result = my_shor(a,N,shots)
print("Finished running for a = {} and N = {}\n\n".format(a, N))
all_summary_result.append(summary_result)
all_summary_result
%qiskit_copyright
|
https://github.com/josejad42/quantum_algorithms_and_protocols
|
josejad42
|
pip install qiskit
pip install qiskit_aer
from qiskit import QuantumCircuit
def deustch_func(value):
c = QuantumCircuit(2)
if value in [2,3]:
c.cx(0,1)
if value in [3,4]:
c.x(1)
return c
num = 2
deustch_func(num).draw()
def deustch_algorithm(func):
n = func.num_qubits - 1
qc = QuantumCircuit(n+1,n)
qc.x(n)
qc.h(range(n+1))
qc.barrier()
qc.compose(func, inplace=True)
qc.barrier()
qc.h(range(n))
qc.measure(range(n),range(n))
return qc
deustch_algorithm(deustch_func(2)).draw()
from qiskit_aer import AerSimulator
def execute_deutsch(function):
qc = deustch_algorithm(function)
result = AerSimulator().run(qc,shots=1,memory=True).result()
measurements = result.get_memory()
if measurements[0] == '0':
return "constant"
return "balanced"
f = deustch_func(2)
display(f.draw())
execute_deutsch(f)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.utils import algorithm_globals
algorithm_globals.random_seed = 123456
from sklearn.datasets import make_blobs
features, labels = make_blobs(
n_samples=20,
centers=2,
center_box=(-1, 1),
cluster_std=0.1,
random_state=algorithm_globals.random_seed,
)
from qiskit import BasicAer
from qiskit.utils import QuantumInstance
sv_qi = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
from qiskit.circuit.library import ZZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
feature_map = ZZFeatureMap(2)
previous_kernel = QuantumKernel(feature_map=feature_map, quantum_instance=sv_qi)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC(quantum_kernel=previous_kernel)
qsvc.fit(features, labels)
qsvc.score(features, labels)
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.primitives import Sampler
fidelity = ComputeUncompute(sampler=Sampler())
from qiskit_machine_learning.kernels import FidelityQuantumKernel
feature_map = ZZFeatureMap(2)
new_kernel = FidelityQuantumKernel(feature_map=feature_map, fidelity=fidelity)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC(quantum_kernel=new_kernel)
qsvc.fit(features, labels)
qsvc.score(features, labels)
from qiskit import QuantumCircuit
from qiskit.circuit.library import RealAmplitudes
num_inputs = 2
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
circuit = QuantumCircuit(num_inputs)
circuit.compose(feature_map, inplace=True)
circuit.compose(ansatz, inplace=True)
def parity(x):
return "{:b}".format(x).count("1") % 2
initial_point = algorithm_globals.random.random(ansatz.num_parameters)
from qiskit_machine_learning.neural_networks import CircuitQNN
circuit_qnn = CircuitQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=2,
quantum_instance=sv_qi,
)
from qiskit.algorithms.optimizers import COBYLA
from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
classifier = NeuralNetworkClassifier(
neural_network=circuit_qnn,
loss="cross_entropy",
one_hot=True,
optimizer=COBYLA(maxiter=40),
initial_point=initial_point,
)
classifier.fit(features, labels)
classifier.score(features, labels)
from qiskit.primitives import Sampler
sampler = Sampler()
from qiskit_machine_learning.neural_networks import SamplerQNN
sampler_qnn = SamplerQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=2,
sampler=sampler,
)
classifier = NeuralNetworkClassifier(
neural_network=sampler_qnn,
loss="cross_entropy",
one_hot=True,
optimizer=COBYLA(maxiter=40),
initial_point=initial_point,
)
classifier.fit(features, labels)
classifier.score(features, labels)
import numpy as np
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
features = (ub - lb) * np.random.rand(num_samples, 1) + lb
labels = np.sin(features[:, 0]) + eps * (2 * np.random.rand(num_samples) - 1)
from qiskit.circuit import Parameter
num_inputs = 1
feature_map = QuantumCircuit(1)
feature_map.ry(Parameter("input"), 0)
ansatz = QuantumCircuit(1)
ansatz.ry(Parameter("weight"), 0)
circuit = QuantumCircuit(num_inputs)
circuit.compose(feature_map, inplace=True)
circuit.compose(ansatz, inplace=True)
initial_point = algorithm_globals.random.random(ansatz.num_parameters)
from qiskit.opflow import PauliSumOp, StateFn
from qiskit_machine_learning.neural_networks import OpflowQNN
observable = PauliSumOp.from_list([("Z", 1)])
operator = StateFn(observable, is_measurement=True) @ StateFn(circuit)
opflow_qnn = OpflowQNN(
operator=operator,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
quantum_instance=sv_qi,
)
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit_machine_learning.algorithms import NeuralNetworkRegressor
regressor = NeuralNetworkRegressor(
neural_network=opflow_qnn,
optimizer=L_BFGS_B(maxiter=5),
initial_point=initial_point,
)
regressor.fit(features, labels)
regressor.score(features, labels)
from qiskit.primitives import Estimator
estimator = Estimator()
from qiskit_machine_learning.neural_networks import EstimatorQNN
estimator_qnn = EstimatorQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
estimator=estimator,
)
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit_machine_learning.algorithms import VQR
regressor = NeuralNetworkRegressor(
neural_network=estimator_qnn,
optimizer=L_BFGS_B(maxiter=5),
initial_point=initial_point,
)
regressor.fit(features, labels)
regressor.score(features, labels)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/vladciocoiu/shor-algorithm
|
vladciocoiu
|
from qiskit import QuantumCircuit, Aer, execute, IBMQ
from qiskit.utils import QuantumInstance
import numpy as np
from qiskit.algorithms import Shor
IBMQ.enable_account('ENTER API TOKEN HERE') # Enter your API token here
provider = IBMQ.get_provider(hub='ibm-q')
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
my_shor = Shor(quantum_instance)
result_dict = my_shor.factor(15)
print(result_dict)
|
https://github.com/quantum-tokyo/qiskit-handson
|
quantum-tokyo
|
# Qiskitライブラリーを導入
from qiskit import *
# 描画のためのライブラリーを導入
import matplotlib.pyplot as plt
%matplotlib inline
# 数値計算モジュールを導入
import numpy as np
# Qiskitバージョンの確認
qiskit.__qiskit_version__
# 3量子ビット回路を用意
qr = QuantumRegister(3)
a_0 = ClassicalRegister(1)
a_1 = ClassicalRegister(1)
b_0 = ClassicalRegister(1)
qc = QuantumCircuit(qr,a_0,a_1,b_0)
# 回路を描画
qc.draw(output="mpl")
# Aliceのもつ未知の量子状態ψを今回はRxで作ります
qc.rx(np.pi/3,0)
qc.barrier() #回路を見やすくするために入れます
# 回路を描画
qc.draw(output="mpl")
# EveがEPRペアを作ってq1をAliceにq2をBobに渡します
qc.h(1)
qc.cx(1, 2)
qc.barrier() #回路を見やすくするために入れます
# 回路を描画
qc.draw(output="mpl")
# AliceがCNOTとHでψと自分のEPRペアをエンタングルさせ測定します。
qc.cx(0, 1)
qc.h(0)
qc.barrier()
qc.measure(0, a_0)
qc.measure(1, a_1)
# 回路を描画
qc.draw(output="mpl")
#Aliceが測定結果をBobに送り、Bobが結果に合わせて操作します
qc.z(2).c_if(a_0, 1)
qc.x(2).c_if(a_1, 1)
qc.draw(output="mpl")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(
num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high)
)
# plot probability distribution
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel("Spot Price at Maturity $S_T$ (\$)", size=15)
plt.ylabel("Probability ($\%$)", size=15)
plt.show()
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 2.126
# set the approximation scaling for the payoff function
rescaling_factor = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [-1, 0]
offsets = [strike_price - low, 0]
f_min = 0
f_max = strike_price - low
european_put_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
rescaling_factor=rescaling_factor,
)
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
european_put = european_put_objective.compose(uncertainty_model, front=True)
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.maximum(0, strike_price - x)
plt.plot(x, y, "ro-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Spot Price", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value (normalized to the [0, 1] interval)
exact_value = np.dot(uncertainty_model.probabilities, y)
exact_delta = -sum(uncertainty_model.probabilities[x <= strike_price])
print("exact expected value:\t%.4f" % exact_value)
print("exact delta value: \t%.4f" % exact_delta)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put,
objective_qubits=[num_uncertainty_qubits],
post_processing=european_put_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (result.estimation_processed))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [0, 0]
offsets = [1, 0]
f_min = 0
f_max = 1
european_put_delta_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
)
# construct circuit for payoff function
european_put_delta = european_put_delta_objective.compose(uncertainty_model, front=True)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put_delta, objective_qubits=[num_uncertainty_qubits]
)
# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result_delta = ae_delta.estimate(problem)
conf_int = -np.array(result_delta.confidence_interval)[::-1]
print("Exact delta: \t%.4f" % exact_delta)
print("Esimated value: \t%.4f" % -result_delta.estimation)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/jwalaQ/my-qiskit-textbook-solutions
|
jwalaQ
|
from qiskit import *
from math import pi,sqrt
from qiskit.visualization import plot_bloch_multivector,plot_histogram
backend_s = Aer.get_backend('statevector_simulator')
backend_q = Aer.get_backend('qasm_simulator')
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.h(0)
qc.x(1)
display(qc.draw('mpl'))
# we use the statevector_simulator to obtain the statevector
job = execute(qc,backend_s)
job_result = job.result()
state_vec = job_result.get_statevector()
plot_bloch_multivector(state_vec)
qc = QuantumCircuit(2)
qc.x(0)
qc.z(0)
qc.y(1)
display(qc.draw('mpl'))
job = execute(qc,backend_s)
job_result = job.result()
state_vec = job_result.get_statevector()
plot_bloch_multivector(state_vec)
qc = QuantumCircuit(1,1)
# initialize qubit in state |+>
qc.initialize([1/sqrt(2),1/sqrt(2)],0)
qc.barrier()
qc.h(0)
qc.measure(0,0)
display(qc.draw('mpl'))
job = execute(qc, backend_q)
job_result = job.result()
res_counts = job_result.get_counts()
plot_histogram(res_counts)
# initialize in |+> state:
qc = QuantumCircuit(1,1)
qc.h(0)
qc.measure(0,0)
display(qc.draw('mpl'))
job = execute(qc, backend_q,shots=4000)
job_result = job.result()
res_counts = job_result.get_counts()
plot_histogram(res_counts)
qc = QuantumCircuit(1,1)
qc.x(0)
qc.h(0)
qc.measure(0,0)
display(qc.draw('mpl'))
job = execute(qc, backend_q,shots=4000)
job_result = job.result()
res_counts = job_result.get_counts()
plot_histogram(res_counts)
qc = QuantumCircuit(2)
qc.initialize([1/sqrt(2),1.j/sqrt(2)],0)
qc.initialize([1/sqrt(2),-1.j/sqrt(2)],1)
qc.sdg([0,1])
qc.h([0,1])
qc.measure_all()
qc.barrier()
qc.h([0,1])
qc.s([0,1])
qc.draw('mpl')
job = execute(qc,backend_q).result()
counts = job.get_counts()
plot_histogram(counts)
job = execute(qc,backend_s).result()
state_vec = job.get_statevector()
plot_bloch_multivector(state_vec)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
import qiskit
print(qiskit.__version__)
from qiskit_machine_learning.datasets import ad_hoc_data
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(training_size = 20, test_size = 5,
n = adhoc_dimension, gap=0.3,
plot_data =False, one_hot=False,
include_sample_total=True)
import numpy
print(numpy.array(adhoc_total).shape)
print("train data shape: ", train_features.shape,"\ttrain labels shape: ", train_labels.shape)
print("test data shape: ", test_features.shape,"\ttest labels shape: ", test_labels.shape)
print('train data:\n',train_features[:5])
print('\ntrain label:\n',train_labels[:5])
# plot_adhoc_dataset(train_features, train_labels, test_features, test_labels, adhoc_total)
from qiskit import Aer
from qiskit.utils import QuantumInstance
seed=20
quantum_instance = QuantumInstance(Aer.get_backend("qasm_simulator"), shots=1024,
seed_simulator=seed, seed_transpiler=seed)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=2)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
# z_feature_map.draw(output='mpl', scale=2)
z_feature_map.decompose().draw(output='mpl', scale=2)
from sklearn.svm import SVC
svc = SVC(kernel=z_kernel.evaluate)
svc.fit(train_features, train_labels)
score = svc.score(test_features, test_labels)
print('Callable kernel with ZFeatureMap classification test score: ', score)
prediction = svc.predict(test_features)
print(prediction)
from qiskit.circuit.library import ZZFeatureMap
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
from sklearn.svm import SVC
svc = SVC(kernel=zz_kernel.evaluate)
svc.fit(train_features, train_labels)
score = svc.score(test_features, test_labels)
print('Callable kernel with ZZFeatureMap classification test score: ', score)
prediction = svc.predict(test_features)
print(prediction)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC()
qsvc.quantum_kernel.quantum_instance = quantum_instance
qsvc.fit(train_features, train_labels)
score = qsvc.score(test_features, test_labels)
print('QSVC classification test score: ', score)
prediction = qsvc.predict(test_features)
print(prediction)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 2 and reps = 1
adhoc_dimension = 2
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=1)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 2 and reps = 2
adhoc_dimension = 2
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=2)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
from qiskit.circuit.library import ZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
# here feature_dimension = 3 and reps = 4
adhoc_dimension = 3
z_feature_map = ZFeatureMap(feature_dimension=adhoc_dimension, reps=4)
z_kernel = QuantumKernel(feature_map = z_feature_map, quantum_instance=quantum_instance)
z_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=2
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=1, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=2
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=3
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=1, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
# same happens for ZZFeatureMap
from qiskit.circuit.library import ZZFeatureMap
adhoc_dimension=3
zz_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement='linear')
zz_kernel = QuantumKernel(feature_map = zz_feature_map, quantum_instance=quantum_instance)
zz_feature_map.decompose().draw(output='mpl', scale=2)
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit import IBMQ
IBMQ.save_account(token='MY_API_TOKEN')
provider = IBMQ.load_account() # loads saved account from disk
from qiskit_ibm_provider import IBMProvider
IBMProvider.save_account(token='MY_API_TOKEN')
provider = IBMProvider() # loads default saved account from disk
IBMProvider.save_account(token='MY_API_TOKEN_2', name="personal")
provider = IBMProvider(name="personal") # loads saved account from disk named "personal"
from qiskit import IBMQ
IBMQ.stored_account() # get saved account from qiskitrc file
from qiskit_ibm_provider import IBMProvider
IBMProvider.saved_accounts() # get saved accounts from qiskit-ibm.json file
# export QE_TOKEN='MY_API_TOKEN' (bash command)
from qiskit import IBMQ
provider = IBMQ.load_account() # loads account from env variables
# export QISKIT_IBM_TOKEN='MY_API_TOKEN' (bash command)
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider() # loads account from env variables
from qiskit import IBMQ
provider = IBMQ.enable_account(token='MY_API_TOKEN') # enable account for current session
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider(token='MY_API_TOKEN') # enable account for current session
from qiskit import IBMQ
provider = IBMQ.load_account() # load saved account
IBMQ.active_account() # check active account
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider() # load saved account
provider.active_account() # check active account
from qiskit import IBMQ
IBMQ.delete_account() # delete saved account from qiskitrc file
from qiskit_ibm_provider import IBMProvider
IBMProvider.delete_account() # delete saved account from saved credentials
provider.backends()
backend = provider.get_backend("ibmq_manila")
print(backend)
from qiskit import QuantumCircuit
# Bell state circuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
qc.draw()
from qiskit import transpile
qc = transpile(qc, backend)
job = backend.run(circuits=qc, shots=1024)
result = job.result()
print(result)
from qiskit.visualization import plot_histogram
plot_histogram(result.get_counts())
from qiskit.providers.ibmq.managed import IBMQJobManager
job_manager = IBMQJobManager()
job_set = job_manager.run(long_list_of_circuits, backend=backend)
results = job_set.results()
job = backend.run(long_list_of_circuits) # returns IBMCompositeJob
result = job.result()
provider.jobs()
job = provider.job(job_id="627c7cb57c918115bb9a73fe")
print(job)
|
https://github.com/carstenblank/dc-qiskit-qml
|
carstenblank
|
# -*- coding: utf-8 -*-
# Copyright 2018 Carsten Blank
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
r"""
CCXToffoli
============
.. currentmodule:: dc_qiskit_qml.distance_based.hadamard.state.cnot._CCXToffoli
This module implements a :py:class:`CCXFactory` to create a multi-controlled X-gate (or NOT gate) to a circuit
using the Toffoli gate cascade on ancillary qubits described by Nielsen & Chuang (https://doi.org/10.1017/CBO9780511976667).
Its advantage is that it doesn't need expnential gates w.r.t. to the controlled qubit count, however, its downside is
that it needs auxiliary qubits. It depends strongly on the use case whether to use this or the algorithm by
Möttönen et al. as implemented by :py:class:`CCXMöttönen`.
.. autosummary::
:nosignatures:
CCXToffoli
CCXToffoli
#############
.. autoclass:: CCXToffoli
:members:
"""
import logging
from typing import List, Union, Tuple
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.register import Register
from . import CCXFactory
log = logging.getLogger(__name__)
class CCXToffoli(CCXFactory):
"""
cc-X gate implemented via the Toffoli cascade with auxiliary qubits.
"""
def ccx(self, qc, conditial_case, control_qubits, tgt):
# type:(CCXToffoli, QuantumCircuit, int, List[Tuple[Register, int]], Union[Tuple[Register, int], QuantumRegister]) -> QuantumCircuit
"""
Using the Toffoli gate cascade on auxiliary qubits, one can create multi-controlled NOT gate. The routine
needs to add an auxiliary register called ``
ccx_ancilla`` which also will be re-used if multiple calls
of this routine are done within the same circuit. As the cascade is always 'undone', the ancilla register
is left to the ground state.
:param qc: the circuit to apply this operation to
:param conditial_case: an integer whose binary representation signifies the branch to controll on
:param control_qubits: the qubits that hold the desired conditional case
:param tgt: the target to be applied the controlled X gate on
:return: the circuit after application of the gate
"""
# Prepare conditional case
bit_string = "{:b}".format(conditial_case).zfill(len(control_qubits))
for i, b in enumerate(reversed(bit_string)):
if b == '0':
qc.x(control_qubits[i])
qc.barrier()
if len(control_qubits) == 1: # This is just the normal CNOT
qc.cx(control_qubits[0], tgt)
elif len(control_qubits) == 2: # This is the simple Toffoli
qc.ccx(control_qubits[0], control_qubits[1], tgt)
else:
# Create ancilla qubit or take the one that is already there
if 'ccx_ancilla' not in [q.name for q in qc.qregs]:
ccx_ancilla = QuantumRegister(len(control_qubits) - 1, 'ccx_ancilla') # type: QuantumRegister
qc.add_register(ccx_ancilla)
else:
ccx_ancilla = [q for q in qc.qregs if q.name == 'ccx_ancilla'][0] # type: QuantumRegister
# Algorithm
qc.ccx(control_qubits[0], control_qubits[1], ccx_ancilla[0])
for i in range(1, ccx_ancilla.size):
qc.ccx(control_qubits[i], ccx_ancilla[i - 1], ccx_ancilla[i])
qc.ccx(control_qubits[-1], ccx_ancilla[ccx_ancilla.size - 1], tgt)
for i in reversed(range(1, ccx_ancilla.size)):
qc.ccx(control_qubits[i], ccx_ancilla[i - 1], ccx_ancilla[i])
qc.ccx(control_qubits[0], control_qubits[1], ccx_ancilla[0])
qc.barrier()
# Undo the conditional case
for i, b in enumerate(reversed(bit_string)):
if b == '0':
qc.x(control_qubits[i])
return qc
|
https://github.com/qiskit-community/qiskit-alt
|
qiskit-community
|
# Benchmark qiskit_alt creating a SparsePauliOp from a list of strings.
import sys
import qiskit_alt
qiskit_alt.project.ensure_init()
import random
from timeit import timeit
Main = qiskit_alt.project.julia.Main
QuantumOps = qiskit_alt.project.simple_import("QuantumOps")
from qiskit_alt.pauli_operators import PauliSum_to_SparsePauliOp
random.seed(123)
def rand_label(k, n):
return ["".join(random.choices("IXYZ", k=k)) for _ in range(n)]
def run_benchmarks():
qkalt_times = []
for k in (10, 100):
for n in (10, 100, 1000, 5000, 10_000, 100_000):
label = rand_label(k, n)
if qiskit_alt.project._calljulia_name == 'juliacall':
label = Main.pyconvert_list(Main.String, label)
PauliSum_to_SparsePauliOp(QuantumOps.PauliSum(label))
number = 20
t = timeit(lambda: PauliSum_to_SparsePauliOp(QuantumOps.PauliSum(label)), number=number)
t = t * 1000 / number
qkalt_times.append(t)
print(f'k={k}, n={n}, {t} ms')
return qkalt_times
if __name__ == '__main__':
qkalt_times = run_benchmarks()
|
https://github.com/vm6502q/qiskit-qrack-provider
|
vm6502q
|
# 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.
"""
QasmSimulator Integration Tests
"""
from test.terra.reference import ref_1q_clifford
from test.terra.reference import ref_2q_clifford
from qiskit import execute
from qiskit.providers.qrack import QasmSimulator
class QasmCliffordTests:
"""QasmSimulator Clifford gate tests in default basis."""
SIMULATOR = QasmSimulator()
BACKEND_OPTS = {}
# ---------------------------------------------------------------------
# Test h-gate
# ---------------------------------------------------------------------
def test_h_gate_deterministic_default_basis_gates(self):
"""Test h-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_1q_clifford.h_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.h_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_h_gate_nondeterministic_default_basis_gates(self):
"""Test h-gate circuits compiling to backend default basis_gates."""
shots = 4000
circuits = ref_1q_clifford.h_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.h_gate_counts_nondeterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test x-gate
# ---------------------------------------------------------------------
def test_x_gate_deterministic_default_basis_gates(self):
"""Test x-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_1q_clifford.x_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.x_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test z-gate
# ---------------------------------------------------------------------
def test_z_gate_deterministic_default_basis_gates(self):
"""Test z-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_1q_clifford.z_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.z_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test y-gate
# ---------------------------------------------------------------------
def test_y_gate_deterministic_default_basis_gates(self):
"""Test y-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_1q_clifford.y_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.y_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test s-gate
# ---------------------------------------------------------------------
def test_s_gate_deterministic_default_basis_gates(self):
"""Test s-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_1q_clifford.s_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.s_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_s_gate_nondeterministic_default_basis_gates(self):
"""Test s-gate circuits compiling to backend default basis_gates."""
shots = 4000
circuits = ref_1q_clifford.s_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.s_gate_counts_nondeterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test sdg-gate
# ---------------------------------------------------------------------
def test_sdg_gate_deterministic_default_basis_gates(self):
"""Test sdg-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_1q_clifford.sdg_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.sdg_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_sdg_gate_nondeterministic_default_basis_gates(self):
shots = 4000
"""Test sdg-gate circuits compiling to backend default basis_gates."""
circuits = ref_1q_clifford.sdg_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.sdg_gate_counts_nondeterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test cx-gate
# ---------------------------------------------------------------------
def test_cx_gate_deterministic_default_basis_gates(self):
"""Test cx-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_2q_clifford.cx_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_cx_gate_nondeterministic_default_basis_gates(self):
"""Test cx-gate circuits compiling to backend default basis_gates."""
shots = 4000
circuits = ref_2q_clifford.cx_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_nondeterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test cz-gate
# ---------------------------------------------------------------------
def test_cz_gate_deterministic_default_basis_gates(self):
"""Test cz-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_2q_clifford.cz_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.cz_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_cz_gate_nondeterministic_default_basis_gates(self):
"""Test cz-gate circuits compiling to backend default basis_gates."""
shots = 4000
circuits = ref_2q_clifford.cz_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.cz_gate_counts_nondeterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test swap-gate
# ---------------------------------------------------------------------
def test_swap_gate_deterministic_default_basis_gates(self):
"""Test swap-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_2q_clifford.swap_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.swap_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_swap_gate_nondeterministic_default_basis_gates(self):
"""Test swap-gate circuits compiling to backend default basis_gates."""
shots = 4000
circuits = ref_2q_clifford.swap_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.swap_gate_counts_nondeterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
class QasmCliffordTestsWaltzBasis:
"""QasmSimulator Clifford gate tests in Waltz u1,u2,u3,cx basis."""
SIMULATOR = QasmSimulator()
BACKEND_OPTS = {}
# ---------------------------------------------------------------------
# Test h-gate
# ---------------------------------------------------------------------
def test_h_gate_deterministic_waltz_basis_gates(self):
"""Test h-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 100
circuits = ref_1q_clifford.h_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.h_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_h_gate_nondeterministic_waltz_basis_gates(self):
"""Test h-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 4000
circuits = ref_1q_clifford.h_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.h_gate_counts_nondeterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test x-gate
# ---------------------------------------------------------------------
def test_x_gate_deterministic_waltz_basis_gates(self):
"""Test x-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 100
circuits = ref_1q_clifford.x_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.x_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test z-gate
# ---------------------------------------------------------------------
def test_z_gate_deterministic_waltz_basis_gates(self):
"""Test z-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 100
circuits = ref_1q_clifford.z_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.z_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_z_gate_deterministic_minimal_basis_gates(self):
"""Test z-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_1q_clifford.z_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.z_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test y-gate
# ---------------------------------------------------------------------
def test_y_gate_deterministic_default_basis_gates(self):
"""Test y-gate circuits compiling to backend default basis_gates."""
shots = 100
circuits = ref_1q_clifford.y_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.y_gate_counts_deterministic(shots)
job = execute(circuits, self.SIMULATOR, shots=shots,
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_y_gate_deterministic_waltz_basis_gates(self):
shots = 100
"""Test y-gate gate circuits compiling to u1,u2,u3,cx"""
circuits = ref_1q_clifford.y_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.y_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test s-gate
# ---------------------------------------------------------------------
def test_s_gate_deterministic_waltz_basis_gates(self):
"""Test s-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 100
circuits = ref_1q_clifford.s_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.s_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_s_gate_nondeterministic_waltz_basis_gates(self):
"""Test s-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 4000
circuits = ref_1q_clifford.s_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.s_gate_counts_nondeterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test sdg-gate
# ---------------------------------------------------------------------
def test_sdg_gate_deterministic_waltz_basis_gates(self):
"""Test sdg-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 100
circuits = ref_1q_clifford.sdg_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.sdg_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'])
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_sdg_gate_nondeterministic_waltz_basis_gates(self):
"""Test sdg-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 4000
circuits = ref_1q_clifford.sdg_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.sdg_gate_counts_nondeterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test cx-gate
# ---------------------------------------------------------------------
def test_cx_gate_deterministic_waltz_basis_gates(self):
shots = 100
"""Test cx-gate gate circuits compiling to u1,u2,u3,cx"""
circuits = ref_2q_clifford.cx_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_cx_gate_nondeterministic_waltz_basis_gates(self):
"""Test cx-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 4000
circuits = ref_2q_clifford.cx_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_nondeterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'])
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test cz-gate
# ---------------------------------------------------------------------
def test_cz_gate_deterministic_waltz_basis_gates(self):
"""Test cz-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 100
circuits = ref_2q_clifford.cz_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.cz_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'])
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_cz_gate_nondeterministic_waltz_basis_gates(self):
"""Test cz-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 4000
circuits = ref_2q_clifford.cz_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.cz_gate_counts_nondeterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test swap-gate
# ---------------------------------------------------------------------
def test_swap_gate_deterministic_waltz_basis_gates(self):
"""Test swap-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 100
circuits = ref_2q_clifford.swap_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.swap_gate_counts_deterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_swap_gate_nondeterministic_waltz_basis_gates(self):
"""Test swap-gate gate circuits compiling to u1,u2,u3,cx"""
shots = 4000
circuits = ref_2q_clifford.swap_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.swap_gate_counts_nondeterministic(shots)
job = execute(
circuits,
self.SIMULATOR,
shots=shots,
basis_gates=['u1', 'u2', 'u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
class QasmCliffordTestsMinimalBasis:
"""QasmSimulator Clifford gate tests in minimam U,CX basis."""
SIMULATOR = QasmSimulator()
BACKEND_OPTS = {}
# ---------------------------------------------------------------------
# Test h-gate
# ---------------------------------------------------------------------
def test_h_gate_deterministic_minimal_basis_gates(self):
"""Test h-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_1q_clifford.h_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.h_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
def test_h_gate_nondeterministic_minimal_basis_gates(self):
"""Test h-gate gate circuits compiling to u3,cx"""
shots = 4000
circuits = ref_1q_clifford.h_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.h_gate_counts_nondeterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test x-gate
# ---------------------------------------------------------------------
def test_x_gate_deterministic_minimal_basis_gates(self):
"""Test x-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_1q_clifford.x_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.x_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'])
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test z-gate
# ---------------------------------------------------------------------
def test_z_gate_deterministic_minimal_basis_gates(self):
"""Test z-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_1q_clifford.z_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.z_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test y-gate
# ---------------------------------------------------------------------
def test_y_gate_deterministic_minimal_basis_gates(self):
"""Test y-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_1q_clifford.y_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.y_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
# ---------------------------------------------------------------------
# Test s-gate
# ---------------------------------------------------------------------
def test_s_gate_deterministic_minimal_basis_gates(self):
"""Test s-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_1q_clifford.s_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.s_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_s_gate_nondeterministic_minimal_basis_gates(self):
"""Test s-gate gate circuits compiling to u3,cx"""
shots = 4000
circuits = ref_1q_clifford.s_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.s_gate_counts_nondeterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test sdg-gate
# ---------------------------------------------------------------------
def test_sdg_gate_deterministic_minimal_basis_gates(self):
"""Test sdg-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_1q_clifford.sdg_gate_circuits_deterministic(
final_measure=True)
targets = ref_1q_clifford.sdg_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_sdg_gate_nondeterministic_minimal_basis_gates(self):
"""Test sdg-gate gate circuits compiling to u3,cx"""
shots = 4000
circuits = ref_1q_clifford.sdg_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_1q_clifford.sdg_gate_counts_nondeterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test cx-gate
# ---------------------------------------------------------------------
def test_cx_gate_deterministic_minimal_basis_gates(self):
"""Test cx-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_2q_clifford.cx_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_cx_gate_nondeterministic_minimal_basis_gates(self):
"""Test cx-gate gate circuits compiling to u3,cx"""
shots = 4000
circuits = ref_2q_clifford.cx_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.cx_gate_counts_nondeterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test cz-gate
# ---------------------------------------------------------------------
def test_cz_gate_deterministic_minimal_basis_gates(self):
"""Test cz-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_2q_clifford.cz_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.cz_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_cz_gate_nondeterministic_minimal_basis_gates(self):
"""Test cz-gate gate circuits compiling to u3,cx"""
shots = 4000
circuits = ref_2q_clifford.cz_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.cz_gate_counts_nondeterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
# ---------------------------------------------------------------------
# Test swap-gate
# ---------------------------------------------------------------------
def test_swap_gate_deterministic_minimal_basis_gates(self):
"""Test swap-gate gate circuits compiling to u3,cx"""
shots = 100
circuits = ref_2q_clifford.swap_gate_circuits_deterministic(
final_measure=True)
targets = ref_2q_clifford.swap_gate_counts_deterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0)
def test_swap_gate_nondeterministic_minimal_basis_gates(self):
"""Test swap-gate gate circuits compiling to u3,cx"""
shots = 4000
circuits = ref_2q_clifford.swap_gate_circuits_nondeterministic(
final_measure=True)
targets = ref_2q_clifford.swap_gate_counts_nondeterministic(shots)
job = execute(
circuits, self.SIMULATOR, shots=shots, basis_gates=['u3', 'cx'],
**self.BACKEND_OPTS)
result = job.result()
self.assertSuccess(result)
self.compare_counts(result, circuits, targets, delta=0.05 * shots)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.h(1)
custom = qc1.to_gate().control(2)
qc2 = QuantumCircuit(4)
qc2.append(custom, [0, 3, 1, 2])
qc2.draw('mpl')
|
https://github.com/chaitanya-bhargava/QiskitSolutions
|
chaitanya-bhargava
|
## Enter Team ID
import os
os.environ["TEAMID"] = "Excalibur"
from qiskit import QuantumCircuit
def make_bell_state():
qc = QuantumCircuit(2)
### your code here
qc.x(0)
qc.h(0)
qc.cx(0,1)
### your code here
return qc
def test_function_1():
circuit = make_bell_state()
return circuit
test_function_1().draw()
from grader.graders.problem_1.grader import grader1
grader1.evaluate(make_bell_state)
def superposition_operation(n):
qc = QuantumCircuit(n)
### Your code here
for i in range(n):
qc.h(i)
### Your code here
return qc
def test_function_2():
n = 5
operation = superposition_operation(n)
return operation
test_function_2().draw()
from grader.graders.problem_1.grader import grader2
grader2.evaluate(superposition_operation)
def make_even_odd(n):
even = QuantumCircuit(n)
odd = QuantumCircuit(n)
### your code here
for i in range(1,n):
even.h(i)
odd.h(i)
odd.x(0)
### your code here
return (even, odd)
def test_function_3():
n = 3
even, odd = make_even_odd(n)
return even, odd
even, odd = test_function_3()
display(even.draw('mpl'))
odd.draw('mpl')
from grader.graders.problem_1.grader import grader3
grader3.evaluate(make_even_odd)
|
https://github.com/dimple12M/Qiskit-Certification-Guide
|
dimple12M
|
from qiskit import QuantumCircuit,Aer,transpile,execute
from qiskit.quantum_info import *
from qiskit.visualization import *
qc=QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.draw(output="mpl")
backend=Aer.get_backend('statevector_simulator')
job=execute(qc,backend)
result=job.result()
sv=result.get_statevector()
sv
sv.data
array_to_latex(sv.data)
sv.draw("latex")
sv.draw("qsphere")
qc_transpile=transpile(qc,backend)
job=backend.run(qc_transpile)
result=job.result()
sv=result.get_statevector()
sv
sv.data
array_to_latex(sv.data)
sv.draw("latex")
sv_label=Statevector.from_label('++')
sv_label.data
qc=QuantumCircuit(2)
sv=Statevector.from_label('++')
sv_evolve=sv.evolve(qc)
sv_evolve
sv_evolve.data
sv
sv_evolve.draw(output="latex")
qc.draw(output="mpl")
qc.initialize(sv_evolve)
qc.draw(output="mpl")
qc=QuantumCircuit(2)
qc.initialize([0.5,0.5,0.5,0.5],[0,1])
sv_evolve=sv.evolve(qc)
sv_evolve
sv_evolve.draw("latex")
array_to_latex(sv_evolve.data)
qc.draw(output="mpl")
from qiskit import BasicAer
qc=QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.draw(output="mpl")
backend=BasicAer.get_backend('statevector_simulator')
qc_transpile=transpile(qc,backend)
job=backend.run(qc_transpile)
result=job.result()
sv=result.get_statevector()
sv
array_to_latex(sv.data)
# basis |0> and dim= 2^1=2
sv_label_0=Statevector.from_int(0,2**1)
sv_label_0.data
sv_label_0.draw("latex")
# basis 1(|01>) and dim= 2^2=4
sv_label=Statevector.from_int(1,2**2)
sv_label.data
sv_label.draw("latex")
# basis |0> and dim= 2^2=4
sv_label=Statevector.from_int(0,2**2)
sv_label.data
sv_label.draw("latex")
qc=QuantumCircuit(2)
qc.h(0)
qc.h(1)
sv_evolve=sv_label.evolve(qc)
sv_evolve
sv_evolve.draw("latex")
array_to_latex(sv_evolve.data)
|
https://github.com/fedimser/quantum_decomp
|
fedimser
|
import unittest
import warnings
import numpy as np
from scipy.stats import unitary_group, ortho_group
import quantum_decomp as qd
from quantum_decomp.src.gate import gates_to_matrix
from quantum_decomp.src.test_utils import SWAP, check_decomp, QFT_2, CNOT, \
assert_all_close, random_orthogonal_matrix, random_unitary
from quantum_decomp.src.two_level_unitary import TwoLevelUnitary
from quantum_decomp.src.utils import is_power_of_two
def _check_correct_product(A, matrices):
n = A.shape[0]
B = np.eye(n)
for matrix in matrices:
assert matrix.matrix_size == n
B = matrix.get_full_matrix() @ B
assert np.allclose(A, B)
def _check_acting_on_same_bit(matrices):
for matrix in matrices:
assert is_power_of_two(matrix.index1 ^ matrix.index2)
def _check_two_level_decompose(matrix):
matrix = np.array(matrix)
_check_correct_product(matrix, qd.two_level_decompose(matrix))
def _check_decompose_gray(matrix):
matrix = np.array(matrix)
result = qd.two_level_decompose_gray(matrix)
_check_correct_product(matrix, result)
_check_acting_on_same_bit(result)
def _check_matrix_to_gates(mx):
check_decomp(mx, qd.matrix_to_gates(mx))
if mx.shape[0] == 4:
check_decomp(mx, qd.matrix_to_gates(mx, optimize=True))
def test_decompose_2x2():
_check_two_level_decompose([[1, 0], [0, 1]])
_check_two_level_decompose([[0, 1], [1, 0]])
_check_two_level_decompose([[0, 1j], [1j, 0]])
_check_two_level_decompose(np.array([[1, 1], [1, -1]]) / np.sqrt(2))
def test_decompose_3x3():
w = np.exp((2j / 3) * np.pi)
A = w * np.array([[1, 1, 1],
[1, w, w * w],
[1, w * w, w]]) / np.sqrt(3)
_check_two_level_decompose(A)
# This test checks that two-level decomposition algorithm ensures that
# diagonal element is equal to 1 after we are done with a row.
def test_diagonal_elements_handled_correctly():
_check_matrix_to_gates(np.array([
[1j, 0, 0, 0],
[0, -1j, 0, 0],
[0, 0, -1j, 0],
[0, 0, 0, 1j],
]))
_check_matrix_to_gates(np.array([
[1, 0, 0, 0],
[0, 0, 0, 1j],
[0, 0, 1, 0],
[0, 1j, 0, 0],
]))
_check_matrix_to_gates(np.array([
[0, 0, 1j, 0],
[0, 1j, 0, 0],
[1j, 0, 0, 0],
[0, 0, 0, 1],
]))
def test_decompose_random():
for matrix_size in range(2, 20):
for i in range(4):
A = np.array(unitary_group.rvs(matrix_size))
_check_correct_product(A, qd.two_level_decompose(A))
def test_decompose_gray_2x2():
_check_decompose_gray([[1, 0], [0, 1]])
_check_decompose_gray([[0, 1], [1, 0]])
_check_decompose_gray([[0, 1j], [1j, 0]])
_check_decompose_gray(np.array([[1, 1], [1, -1]] / np.sqrt(2)))
def test_decompose_gray_4x4():
_check_decompose_gray(np.eye(4).T)
w = np.exp((2j / 3) * np.pi)
A = w * np.array([[1, 1, 1, 0],
[1, w, w * w, 0],
[1, w * w, w, 0],
[0, 0, 0, np.sqrt(3)]]) / np.sqrt(3)
_check_decompose_gray(A)
def test_decompose_gray_random():
for matrix_size in [2, 4, 8, 16]:
for i in range(4):
A = np.array(unitary_group.rvs(matrix_size))
_check_correct_product(A, qd.two_level_decompose(A))
def test_TwoLevelUnitary_inv():
matrix1 = TwoLevelUnitary(unitary_group.rvs(2), 8, 1, 5)
matrix2 = matrix1.inv()
product = matrix1.get_full_matrix() @ matrix2.get_full_matrix()
assert np.allclose(product, np.eye(8))
def test_TwoLevelUnitary_multiply_right():
matrix_2x2 = TwoLevelUnitary(unitary_group.rvs(2), 8, 1, 5)
A1 = unitary_group.rvs(8)
A2 = np.array(A1)
matrix_2x2.multiply_right(A1)
assert np.allclose(A1, A2 @ matrix_2x2.get_full_matrix())
def test_matrix_to_gates_SWAP():
_check_matrix_to_gates(SWAP)
def test_matrix_to_gates_random_unitary():
np.random.seed(100)
for matrix_size in [2, 4, 8, 16]:
for _ in range(10):
_check_matrix_to_gates(unitary_group.rvs(matrix_size))
def test_matrix_to_gates_random_orthogonal():
np.random.seed(100)
for matrix_size in [2, 4, 8]:
for _ in range(10):
_check_matrix_to_gates((ortho_group.rvs(matrix_size)))
def test_matrix_to_gates_identity():
A = np.eye(16)
gates = qd.matrix_to_gates(A)
assert len(gates) == 0
def test_matrix_to_qsharp_SWAP():
qsharp_code = qd.matrix_to_qsharp(SWAP)
expected = "\n".join([
"operation ApplyUnitaryMatrix (qs : Qubit[]) : Unit {",
" CNOT(qs[1], qs[0]);",
" CNOT(qs[0], qs[1]);",
" CNOT(qs[1], qs[0]);",
"}", ""])
assert qsharp_code == expected
def test_matrix_to_cirq_circuit():
def _check(A):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
assert_all_close(A, qd.matrix_to_cirq_circuit(A).unitary())
_check(SWAP)
_check(CNOT)
_check(QFT_2)
np.random.seed(100)
for matrix_size in [2, 4, 8]:
_check(random_orthogonal_matrix(matrix_size))
_check(random_unitary(matrix_size))
def test_matrix_to_qiskit_circuit():
import qiskit.quantum_info as qi
def _check(matrix):
circuit = qd.matrix_to_qiskit_circuit(matrix)
op = qi.Operator(circuit)
assert np.allclose(op.data, matrix)
_check(SWAP)
_check(CNOT)
_check(QFT_2)
np.random.seed(100)
for matrix_size in [2, 4, 8]:
_check(random_orthogonal_matrix(matrix_size))
_check(random_unitary(matrix_size))
if __name__ == '__main__':
unittest.main()
|
https://github.com/AnikenC/JaxifiedQiskit
|
AnikenC
|
# All Imports
import numpy as np
import matplotlib.pyplot as plt
import sympy as sym
import qiskit
from qiskit import pulse
from qiskit_dynamics import Solver, DynamicsBackend
from qiskit_dynamics.pulse import InstructionToSignals
from qiskit_dynamics.array import Array
from qiskit.quantum_info import Statevector, DensityMatrix, Operator
from qiskit.circuit.parameter import Parameter
import jax
import jax.numpy as jnp
from jax import jit, vmap, block_until_ready, config
import chex
from typing import Optional, Union
Array.set_default_backend('jax')
config.update('jax_enable_x64', True)
config.update('jax_platform_name', 'cpu')
# Constructing a Two Qutrit Hamiltonian
dim = 3
v0 = 4.86e9
anharm0 = -0.32e9
r0 = 0.22e9
v1 = 4.97e9
anharm1 = -0.32e9
r1 = 0.26e9
J = 0.002e9
a = np.diag(np.sqrt(np.arange(1, dim)), 1)
adag = np.diag(np.sqrt(np.arange(1, dim)), -1)
N = np.diag(np.arange(dim))
ident = np.eye(dim, dtype=complex)
full_ident = np.eye(dim**2, dtype=complex)
N0 = np.kron(ident, N)
N1 = np.kron(N, ident)
a0 = np.kron(ident, a)
a1 = np.kron(a, ident)
a0dag = np.kron(ident, adag)
a1dag = np.kron(adag, ident)
static_ham0 = 2 * np.pi * v0 * N0 + np.pi * anharm0 * N0 * (N0 - full_ident)
static_ham1 = 2 * np.pi * v1 * N1 + np.pi * anharm1 * N1 * (N1 - full_ident)
static_ham_full = static_ham0 + static_ham1 + 2 * np.pi * J * ((a0 + a0dag) @ (a1 + a1dag))
drive_op0 = 2 * np.pi * r0 * (a0 + a0dag)
drive_op1 = 2 * np.pi * r1 * (a1 + a1dag)
batchsize = 400
amp_vals = jnp.linspace(0.5, 0.99, batchsize, dtype=jnp.float64).reshape(-1, 1)
sigma_vals = jnp.linspace(20, 80, batchsize, dtype=jnp.int8).reshape(-1, 1)
freq_vals = jnp.linspace(-0.5, 0.5, batchsize, dtype=jnp.float64).reshape(-1, 1) * 1e6
batch_params = jnp.concatenate((amp_vals, sigma_vals, freq_vals), axis=-1)
batch_y0 = jnp.tile(np.ones(9), (batchsize, 1))
batch_obs = jnp.tile(N0, (batchsize, 1, 1))
print(f"Batched Params Shape: {batch_params.shape}")
# Constructing a custom function that takes as input a parameter vector and returns the simulated state
def standard_func(params):
amp, sigma, freq = params
# Here we use a Drag Pulse as defined in qiskit pulse as its already a Scalable Symbolic Pulse
special_pulse = pulse.Drag(
duration=320,
amp=amp,
sigma=sigma,
beta=0.1,
angle=0.1,
limit_amplitude=False
)
with pulse.build(default_alignment='sequential') as sched:
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
u0 = pulse.ControlChannel(0)
u1 = pulse.ControlChannel(1)
pulse.shift_frequency(freq, d0)
pulse.play(special_pulse, d0)
pulse.shift_frequency(freq, d1)
pulse.play(special_pulse, d1)
pulse.shift_frequency(freq, u0)
pulse.play(special_pulse, u0)
pulse.shift_frequency(freq, u1)
pulse.play(special_pulse, u1)
return sched
# Constructing the new solver
dt = 1/4.5e9
atol = 1e-2
rtol = 1e-4
t_linspace = np.linspace(0.0, 400e-9, 11)
t_span = np.array([t_linspace[0], t_linspace[-1]])
ham_ops = [drive_op0, drive_op1, drive_op0, drive_op1]
ham_chans = ["d0", "d1", "u0", "u1"]
chan_freqs = {"d0": v0, "d1": v1, "u0": v1, "u1": v0}
solver = Solver(
static_hamiltonian=static_ham_full,
hamiltonian_operators=ham_ops,
rotating_frame=static_ham_full,
hamiltonian_channels=ham_chans,
channel_carrier_freqs=chan_freqs,
dt=dt,
)
class JaxifiedSolver:
def __init__(
self,
schedule_func,
dt,
carrier_freqs,
ham_chans,
t_span,
rtol,
atol
):
super().__init__()
self.schedule_func = schedule_func
self.dt = dt
self.carrier_freqs = carrier_freqs
self.ham_chans = ham_chans
self.t_span = t_span
self.rtol = rtol
self.atol = atol
self.fast_batched_sim = jit(vmap(self.run_sim))
def run_sim(self, y0, obs, params):
sched = self.schedule_func(params)
converter = InstructionToSignals(self.dt, carriers=self.carrier_freqs, channels=self.ham_chans)
signals = converter.get_signals(sched)
results = solver.solve(
t_span=self.t_span,
y0=y0 / jnp.linalg.norm(y0),
t_eval=self.t_span,
signals=signals,
rtol=self.rtol,
atol=self.atol,
convert_results=False,
method='jax_odeint'
)
state_vec = results.y.data[-1]
state_vec = state_vec / jnp.linalg.norm(state_vec)
two_vec = state_vec[:4]
evolved_vec = jnp.dot(obs, two_vec)
new_vec = jnp.concatenate((evolved_vec, state_vec[4:]))
probs_vec = jnp.abs(new_vec)**2
probs_vec = jnp.clip(probs_vec, a_min=0.0, a_max=1.0)
# Shots instead of probabilities
return probs_vec
def estimate(self, batch_y0, batch_obs, batch_params):
ops_mat = [b.to_matrix() for b in batch_obs]
ops_arr = jnp.array(ops_mat)
return self.fast_batched_sim(batch_y0, ops_arr, batch_params)
j_solver = JaxifiedSolver(
schedule_func=standard_func,
dt=dt,
carrier_freqs=chan_freqs,
ham_chans=ham_chans,
t_span=t_span,
rtol=rtol,
atol=atol
)
from qiskit.quantum_info import SparsePauliOp
ops_list = [SparsePauliOp(["IX"]), SparsePauliOp(["IY"]), SparsePauliOp(["YZ"]), SparsePauliOp(["ZX"])] * 100
batch_res = j_solver.estimate(
batch_y0,
ops_list,
batch_params
)
%timeit j_solver.estimate(batch_y0,ops_list,batch_params)
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(3)
ket = Statevector(qc)
qc.x(2)
ket2 = Statevector(qc)
qc.x(1)
ket3 = Statevector(qc)
ket.draw()
print(ket.data)
print(ket)
print(ket2)
print(ket3)
total_vec = np.ones(3 ** 2)
total_vec /= np.linalg.norm(total_vec)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeBoeblingen
backend = FakeBoeblingen()
ghz = QuantumCircuit(5)
ghz.h(0)
ghz.cx(0,range(1,5))
circ = transpile(ghz, backend, scheduling_method="asap")
circ.draw(output='mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver()
problem = driver.run()
fermionic_op = problem.hamiltonian.second_q_op()
from qiskit_nature.second_q.mappers import JordanWignerMapper
mapper = JordanWignerMapper()
qubit_jw_op = mapper.map(fermionic_op)
print(qubit_jw_op)
from qiskit_nature.second_q.mappers import ParityMapper
mapper = ParityMapper()
qubit_p_op = mapper.map(fermionic_op)
print(qubit_p_op)
mapper = ParityMapper(num_particles=problem.num_particles)
qubit_op = mapper.map(fermionic_op)
print(qubit_op)
tapered_mapper = problem.get_tapered_mapper(mapper)
print(type(tapered_mapper))
qubit_op = tapered_mapper.map(fermionic_op)
print(qubit_op)
from qiskit_nature.second_q.circuit.library import HartreeFock
hf_state = HartreeFock(2, (1, 1), JordanWignerMapper())
hf_state.draw()
from qiskit_nature.second_q.mappers import InterleavedQubitMapper
interleaved_mapper = InterleavedQubitMapper(JordanWignerMapper())
hf_state = HartreeFock(2, (1, 1), interleaved_mapper)
hf_state.draw()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Innanov/Qiskit-Global-Summer-School-2022
|
Innanov
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, assemble, Aer, IBMQ, execute
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram
from qiskit_textbook.problems import dj_problem_oracle
def lab1_ex1():
qc = QuantumCircuit(1)
#
#
# FILL YOUR CODE IN HERE
#
#
qc.x(0)
return qc
state = Statevector.from_instruction(lab1_ex1())
plot_bloch_multivector(state)
from qc_grader import grade_lab1_ex1
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex1(lab1_ex1())
def lab1_ex2():
qc = QuantumCircuit(1)
#
#
# FILL YOUR CODE IN HERE
#
#
qc.h(0)
return qc
state = Statevector.from_instruction(lab1_ex2())
plot_bloch_multivector(state)
from qc_grader import grade_lab1_ex2
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex2(lab1_ex2())
def lab1_ex3():
qc = QuantumCircuit(1)
#
#
# FILL YOUR CODE IN HERE
#
#
qc.x(0)
qc.h(0)
return qc
state = Statevector.from_instruction(lab1_ex3())
plot_bloch_multivector(state)
from qc_grader import grade_lab1_ex3
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex3(lab1_ex3())
def lab1_ex4():
qc = QuantumCircuit(1)
#
#
# FILL YOUR CODE IN HERE
#
#
qc.h(0)
qc.sdg(0)
return qc
state = Statevector.from_instruction(lab1_ex4())
plot_bloch_multivector(state)
from qc_grader import grade_lab1_ex4
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex4(lab1_ex4())
def lab1_ex5():
qc = QuantumCircuit(2,2) # this time, we not only want two qubits, but also two classical bits for the measurement
#
#
# FILL YOUR CODE IN HERE
#
#
qc.h(0)
qc.cx(0,1)
qc.x(0)
return qc
qc = lab1_ex5()
qc.draw() # we draw the circuit
from qc_grader import grade_lab1_ex5
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex5(lab1_ex5())
qc.measure(0, 0) # we perform a measurement on qubit q_0 and store the information on the classical bit c_0
qc.measure(1, 1) # we perform a measurement on qubit q_1 and store the information on the classical bit c_1
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1000).result().get_counts() # we run the simulation and get the counts
plot_histogram(counts) # let us plot a histogram to see the possible outcomes and corresponding probabilities
def lab1_ex6():
#
#
# FILL YOUR CODE IN HERE
#
#
qc = QuantumCircuit(3,3)
qc.h(0)
qc.cx(0,1)
qc.cx(1,2)
qc.y(1)
return qc
qc = lab1_ex6()
qc.draw() # we draw the circuit
from qc_grader import grade_lab1_ex6
# Note that the grading function is expecting a quantum circuit without measurements
grade_lab1_ex6(lab1_ex6())
oraclenr = 4 # determines the oracle (can range from 1 to 5)
oracle = dj_problem_oracle(oraclenr) # gives one out of 5 oracles
oracle.name = "DJ-Oracle"
def dj_classical(n, input_str):
# build a quantum circuit with n qubits and 1 classical readout bit
dj_circuit = QuantumCircuit(n+1,1)
# Prepare the initial state corresponding to your input bit string
for i in range(n):
if input_str[i] == '1':
dj_circuit.x(i)
# append oracle
dj_circuit.append(oracle, range(n+1))
# measure the fourth qubit
dj_circuit.measure(n,0)
return dj_circuit
n = 4 # number of qubits
input_str = '1111'
dj_circuit = dj_classical(n, input_str)
dj_circuit.draw() # draw the circuit
input_str = '1111'
dj_circuit = dj_classical(n, input_str)
qasm_sim = Aer.get_backend('qasm_simulator')
transpiled_dj_circuit = transpile(dj_circuit, qasm_sim)
qobj = assemble(transpiled_dj_circuit, qasm_sim)
results = qasm_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
def lab1_ex7():
min_nr_inputs = 2
max_nr_inputs = 9
return [min_nr_inputs, max_nr_inputs]
from qc_grader import grade_lab1_ex7
# Note that the grading function is expecting a list of two integers
grade_lab1_ex7(lab1_ex7())
n=4
def psi_0(n):
qc = QuantumCircuit(n+1,n)
# Build the state (|00000> - |10000>)/sqrt(2)
#
#
# FILL YOUR CODE IN HERE
#
#
qc.x(4)
qc.h(4)
return qc
dj_circuit = psi_0(n)
dj_circuit.draw()
def psi_1(n):
# obtain the |psi_0> = |00001> state
qc = psi_0(n)
# create the superposition state |psi_1>
#
#
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
#
#
qc.barrier()
return qc
dj_circuit = psi_1(n)
dj_circuit.draw()
def psi_2(oracle,n):
# circuit to obtain psi_1
qc = psi_1(n)
# append the oracle
qc.append(oracle, range(n+1))
return qc
dj_circuit = psi_2(oracle, n)
dj_circuit.draw()
def lab1_ex8(oracle, n): # note that this exercise also depends on the code in the functions psi_0 (In [24]) and psi_1 (In [25])
qc = psi_2(oracle, n)
# apply n-fold hadamard gate
#
#
# FILL YOUR CODE IN HERE
#
#
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
# add the measurement by connecting qubits to classical bits
#
#
qc.measure(0,0)
qc.measure(1,1)
qc.measure(2,2)
qc.measure(3,3)
#
#
return qc
dj_circuit = lab1_ex8(oracle, n)
dj_circuit.draw()
from qc_grader import grade_lab1_ex8
# Note that the grading function is expecting a quantum circuit with measurements
grade_lab1_ex8(lab1_ex8(dj_problem_oracle(4),n))
qasm_sim = Aer.get_backend('qasm_simulator')
transpiled_dj_circuit = transpile(dj_circuit, qasm_sim)
qobj = assemble(transpiled_dj_circuit)
results = qasm_sim.run(qobj).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
input_3sat_instance = '''
c example DIMACS-CNF 3-SAT
p cnf 3 5
-1 -2 -3 0
1 -2 3 0
1 2 -3 0
1 -2 -3 0
-1 2 3 0
'''
import os
import tempfile
from qiskit.exceptions import MissingOptionalLibraryError
from qiskit.circuit.library.phase_oracle import PhaseOracle
fp = tempfile.NamedTemporaryFile(mode='w+t', delete=False)
fp.write(input_3sat_instance)
file_name = fp.name
fp.close()
oracle = None
try:
oracle = PhaseOracle.from_dimacs_file(file_name)
except MissingOptionalLibraryError as ex:
print(ex)
finally:
os.remove(file_name)
from qiskit.algorithms import AmplificationProblem
problem = None
if oracle is not None:
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
from qiskit.algorithms import Grover
from qiskit.primitives import Sampler
grover = Grover(sampler=Sampler())
result = None
if problem is not None:
result = grover.amplify(problem)
print(result.assignment)
from qiskit.tools.visualization import plot_histogram
if result is not None:
display(plot_histogram(result.circuit_results[0]))
expression = '(w ^ x) & ~(y ^ z) & (x & y & z)'
try:
oracle = PhaseOracle(expression)
problem = AmplificationProblem(oracle, is_good_state=oracle.evaluate_bitstring)
grover = Grover(sampler=Sampler())
result = grover.amplify(problem)
display(plot_histogram(result.circuit_results[0]))
except MissingOptionalLibraryError as ex:
print(ex)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list(
[
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156),
]
)
print(f"Number of qubits: {H2_op.num_qubits}")
from qiskit.algorithms import NumPyMinimumEigensolver
from qiskit.opflow import PauliSumOp
numpy_solver = NumPyMinimumEigensolver()
result = numpy_solver.compute_minimum_eigenvalue(operator=PauliSumOp(H2_op))
ref_value = result.eigenvalue.real
print(f"Reference value: {ref_value:.5f}")
# define ansatz and optimizer
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import SPSA
iterations = 125
ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")
spsa = SPSA(maxiter=iterations)
# define callback
# note: Re-run this cell to restart lists before training
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
# define Aer Estimator for noiseless statevector simulation
from qiskit.utils import algorithm_globals
from qiskit_aer.primitives import Estimator as AerEstimator
seed = 170
algorithm_globals.random_seed = seed
noiseless_estimator = AerEstimator(
run_options={"seed": seed, "shots": 1024},
transpile_options={"seed_transpiler": seed},
)
# instantiate and run VQE
from qiskit.algorithms.minimum_eigensolvers import VQE
vqe = VQE(
noiseless_estimator, ansatz, optimizer=spsa, callback=store_intermediate_result
)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"VQE on Aer qasm simulator (no noise): {result.eigenvalue.real:.5f}")
print(
f"Delta from reference energy value is {(result.eigenvalue.real - ref_value):.5f}"
)
import pylab
pylab.rcParams["figure.figsize"] = (12, 4)
pylab.plot(counts, values)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Convergence with no noise")
from qiskit_aer.noise import NoiseModel
from qiskit.providers.fake_provider import FakeVigo
# fake providers contain data from real IBM Quantum devices stored in Qiskit Terra,
# and are useful for extracting realistic noise models.
device = FakeVigo()
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
print(noise_model)
noisy_estimator = AerEstimator(
backend_options={
"method": "density_matrix",
"coupling_map": coupling_map,
"noise_model": noise_model,
},
run_options={"seed": seed, "shots": 1024},
transpile_options={"seed_transpiler": seed},
)
# re-start callback variables
counts = []
values = []
vqe.estimator = noisy_estimator
result1 = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"VQE on Aer qasm simulator (with noise): {result1.eigenvalue.real:.5f}")
print(
f"Delta from reference energy value is {(result1.eigenvalue.real - ref_value):.5f}"
)
if counts or values:
pylab.rcParams["figure.figsize"] = (12, 4)
pylab.plot(counts, values)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Convergence with noise")
print(f"Reference value: {ref_value:.5f}")
print(f"VQE on Aer qasm simulator (no noise): {result.eigenvalue.real:.5f}")
print(f"VQE on Aer qasm simulator (with noise): {result1.eigenvalue.real:.5f}")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from qiskit.circuit import Gate
from qiskit.visualization import plot_bloch_multivector
from math import pi
q = QuantumRegister(3, name='q')
c = ClassicalRegister(2, name='c')
circ = QuantumCircuit(q, c)
circ.reset(q)
circ.u3(pi/2,pi/2,pi/2,q[2])
circ.h(q[1])
circ.cx(q[1],q[0])
circ.barrier()
circ.cx(q[2],q[1])
circ.h(q[2])
circ.barrier()
circ.measure([q[2],q[1]],[c[1],c[0]])
circ.barrier()
circ.x(0).c_if(c,1)
circ.z(0).c_if(c,2)
circ.x(0).c_if(c,3)
circ.z(0).c_if(c,3)
circ.draw('mpl', reverse_bits=True)
theta = pi/3
phi = pi/2
q = QuantumRegister(3, name='q')
c = ClassicalRegister(2, name='c')
circ = QuantumCircuit(q, c)
circ.reset(q)
circ.u3(theta,phi,pi,q[2])
circ.h(q[1])
circ.cx(q[1],q[0])
circ.barrier()
circ.draw('mpl', reverse_bits=True)
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
state = job.result().get_statevector(circ)
plot_bloch_multivector(state)
circ.cx(q[2],q[1])
circ.h(q[2])
circ.barrier()
circ.measure([q[2],q[1]],[c[1],c[0]])
circ.barrier()
circ.x(0).c_if(c,1)
circ.z(0).c_if(c,2)
circ.x(0).c_if(c,3)
circ.z(0).c_if(c,3)
circ.draw('mpl', reverse_bits=True)
backend = Aer.get_backend('statevector_simulator')
job = execute(circ, backend)
state = job.result().get_statevector(circ)
plot_bloch_multivector(state)
|
https://github.com/VedDharkar/IBM_QISKIT_EXAM_C1000-112
|
VedDharkar
|
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 import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_belem')
plot_gate_map(backend) #Tells us the way the qubits are arranged in a quantum system
plot_error_map(backend) #Also tell us the error rate of the qubits
#THERE ARE 2 WAYS TO SEE THE VERSION OF QISKIT:-
qiskit.__qiskit_version__ #TELLS US ABOUT THE VERSION OF QISKIT
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_backend_overview #TELLS US ABOUT THE HARDWARE PART OF EACH AVAILABLE QUANTUM SYSTEM.
#T1 = RELAXATION TIME | T2 = DECOHERNECE TIME | Avg. CX Err = Gate error rate | Avg. Meas.Er = Measurement error rate
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
from qiskit.providers.fake_provider import FakeArmonk
backend = FakeArmonk()
with pulse.build(backend) as drive_sched:
d0 = pulse.drive_channel(0)
a0 = pulse.acquire_channel(0)
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.delay(20, d0)
pulse.shift_phase(3.14/2, d0)
pulse.set_phase(3.14, d0)
pulse.shift_frequency(1e7, d0)
pulse.set_frequency(5e9, d0)
with pulse.build() as temp_sched:
pulse.play(pulse.library.Gaussian(20, 1.0, 3.0), d0)
pulse.play(pulse.library.Gaussian(20, -1.0, 3.0), d0)
pulse.call(temp_sched)
pulse.acquire(30, a0, pulse.MemorySlot(0))
drive_sched.draw()
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import *
qc = QuantumCircuit(2)
qc.h(i)
qc.crz (PI/4, 0, 1)
|
https://github.com/kerenavnery/qmail
|
kerenavnery
|
import Protocols
ALICE_ADDR = 'localhost'
OSCAR_ADDR = 'localhost'
ALICE_PORT = 5008
OSCAR_PORT = 5009
def main():
Protocols.oscar_sends('01', OSCAR_PORT, ALICE_PORT)
if __name__ == "__main__":
main()
|
https://github.com/JohnBurke4/qaoa_testing_framework
|
JohnBurke4
|
from qiskit import transpile
class CostFunction:
def __init__(self, problemType, problem):
self.problemType = problemType
self.problem = problem
def getCost(self, value):
if ('maxcut' in self.problemType):
return self.__getCostMaxcut(value)
elif ('3SAT' in self.problemType):
return self.__getCost3SAT(value)
return 0
def getExpectation(self, counts):
avg = 0
sum_count = 0
for bit_string, count in counts.items():
obj = self.getCost(bit_string)
avg += obj * count
sum_count += count
return avg/sum_count
def getBestExpectation(self, counts, goal, randomGuess, shots):
count = 0
minScore = self.getCost(min(counts.keys(), key=lambda x: self.getCost(x)))
for key, value in counts.items():
if (self.getCost(key) == minScore):
count += value
if (minScore != goal):
count = 0
return minScore, (count / (shots))
def getMostCommonExpectation(self, counts):
return self.getCost(max(counts, key=counts.get))
def getDesiredExpectation(self, counts, shots=1000):
minScore = self.getCost(min(counts.keys(), key=lambda x: self.getCost(x)))
score = minScore * shots
for key, value in counts.items():
if (self.getCost(key) == minScore):
score -= value
return score
def __getCostMaxcut(self, partition):
score = 0
part = partition[::-1]
for edge in self.problem.edges():
v1 = edge[0]
v2 = edge[1]
if part[v1] != part[v2]:
score-=1
return score
def __getCost3SAT(self, partition):
score = 0
if (partition == "0010" or partition == "0100"):
score -= 1
return score
|
https://github.com/minnukota381/Quantum-Computing-Qiskit
|
minnukota381
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector, visualize_transition, plot_histogram
qc = QuantumCircuit(3)
qc.x(0)
qc.x(1)
qc.cswap(0,1,2)
qc.draw('mpl')
backend = Aer.get_backend('unitary_simulator')
out = execute(qc,backend).result().get_unitary()
from qiskit_textbook.tools import array_to_latex
array_to_latex(out, pretext = "\\text{UnitaryMatrix} = ")
backend = Aer.get_backend('statevector_simulator')
out = execute(qc,backend).result().get_statevector()
array_to_latex(out, pretext = "\\text{Statevector} = ")
plot_bloch_multivector(out)
#execute the circuit and get the plain result
out = execute(qc,backend).result()
#getting the count of the result
counts = out.get_counts()
#plotting the histogram
plot_histogram(counts)
|
https://github.com/qiskit-community/qiskit-qcgpu-provider
|
qiskit-community
|
"""
Example used in the README. In this example a Bell state is made.
"""
# Import the Qiskit
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, QiskitError
from qiskit import execute
from qiskit_qcgpu_provider import QCGPUProvider
# Create a Quantum Register with 2 qubits.
q = QuantumRegister(2)
# Create a Classical Register with 2 bits.
c = ClassicalRegister(2)
# Create a Quantum Circuit
qc = QuantumCircuit(q, c)
# Add a H gate on qubit 0, putting this qubit in superposition.
qc.h(q[0])
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
qc.cx(q[0], q[1])
# Add a Measure gate to see the state.
qc.measure(q, c)
# Get the QCGPU Provider
Provider = QCGPUProvider()
# See a list of available local simulators
print("QCGPU backends: ", Provider.backends())
backend_sim = Provider.get_backend('qasm_simulator')
# Compile and run the Quantum circuit on a simulator backend
job_sim = execute(qc, backend_sim)
result_sim = job_sim.result()
# Show the results
print(result_sim.get_counts(qc))
|
https://github.com/Amey-2002/QAOA-Vehicle-Routing-Problem
|
Amey-2002
|
# importing required libraries
import numpy as np
import matplotlib.pyplot as plt
import sys
import operator
#importing qiskit packages
from qiskit import BasicAer
from qiskit.quantum_info import Pauli
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.algorithms import QAOA
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
#Setting values for given problem
n = 4# Total number of nodes(In the problem, (number of delivery centres + 1 depot))
veh = 2 # Total number of vehicles
# randomnly placing nodes and computing distances between nodes
np.random.seed(1543)
x = (np.random.rand(n)-0.5)*10
y = (np.random.rand(n)-0.5)*10
matrix = np.zeros([n,n])
# creating the distance matrix to indicate distances between individual nodes
for i in range(n):
for j in range(i+1,n):
matrix[i,j] = (x[i]-x[j])**2 + (y[i]-y[j])**2
matrix[j,i] = matrix[i,j]
# print(matrix)
# print(x,y)
# encoding the problem into a QuadraticProgram instance
def instance(n,veh,matrix,x_sol=0):
#parameter for cost function
A = np.max(matrix) * 100
#defining weights w
matrix_vec = matrix.reshape(n ** 2)
w_list = [matrix_vec[x] for x in range(n ** 2) if matrix_vec[x] > 0]
w = np.zeros(n * (n - 1))
for i in range(len(w_list)):
w[i] = w_list[i]
# print(matrix_vec)
# print(w)
#Finding the value of Q (Q defines the interactions between variables)
e1_id = np.eye(n)
e1_1 = np.ones([n-1,n-1])
e2 = np.ones(n)
e2_1 = np.ones(n-1)
e2[0]=0
neg_e2 = np.ones(n) - e2
v = np.zeros([n,n*(n-1)])
for i in range(n):
count = i - 1
for j in range(n * (n - 1)):
if j // (n - 1) == i:
count = i
if j // (n - 1) != i and j % (n - 1) == count:
v[i][j] = 1.0
# print(neg_e2)
#print(v)
v1 = np.sum(v[1:], axis=0)
#print(v1)
Q = A*(np.kron(e1_id,e1_1)) + np.dot(v.T,v)
#Finding the value of g
g = (w
- 2*A*(np.kron(e2,e2_1) + v1.T)
- 2*A*veh*(np.kron(neg_e2,e2_1) + v[0].T)
)
#Finding the value of c
c = 2 * A * (n-1) + 2 * A * (veh**2)
try:
#max(x_sol)
# Evaluates the cost distance from a binary representation of a path
fun = (
lambda x: np.dot(np.around(x), np.dot(Q, np.around(x)))
+ np.dot(g, np.around(x))
+ c
)
cost = fun(x_sol)
except:
cost = 0
return Q,g,c,cost
#creating the QuadraticProgram instance using the above calculated values
def q_program(n,veh,matrix,Q,g,c):
qp = QuadraticProgram()
for i in range(n*(n-1)):
qp.binary_var(str(i))
qp.objective.quadratic = Q
qp.objective.linear = g
qp.objective.constant = c
return qp
#solving the problem using qiskit optimization techniques
def solution(n,veh,matrix,qp):
algorithm_globals.random_seed = 10598
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend,
seed_simulator = algorithm_globals.random_seed,
seed_transpiler = algorithm_globals.random_seed
)
qaoa = QAOA(quantum_instance=quantum_instance)
optimizer = MinimumEigenOptimizer(min_eigen_solver=qaoa)
result = optimizer.solve(qp)
_,_,_,cost = instance(n,veh,matrix,x_sol=result.x)
print(result)
print(result.x)
return result.x, cost
Q,g,c,cost=instance(n,veh,matrix)
qp = q_program(n,veh,matrix,Q,g,c)
quantum_solution, quantum_cost = solution(n,veh,matrix,qp)
# print(qp)
# print(quantum_cost)
# print(cost)
print(quantum_solution, quantum_cost)
x_quantum = np.zeros(n**2)
k = 0
for i in range(n ** 2):
if i // n != i % n:
x_quantum[i] = quantum_solution[k]
k += 1
# Visualize the solution
def visualize_solution(x, y, x_q, C, n, K, title_str):
plt.figure()
plt.scatter(x, y, s=200)
for i in range(len(x)):
plt.annotate(i, (x[i] + 0.15, y[i]), size=16, color='r')
plt.plot(x[0], y[0], 'r*', ms=20)
plt.grid()
for ii in range(0, n ** 2):
if x_q[ii] > 0:
ix = ii // n
iy = ii % n
plt.arrow(x[ix], y[ix], x[iy] - x[ix], y[iy] - y[ix], length_includes_head=True, head_width=.25)
plt.title(title_str+' cost = ' + str(int(C * 100) / 100.))
plt.show()
visualize_solution(x, y, x_quantum, quantum_cost, n, veh, 'Quantum')
|
https://github.com/C2QA/bosonic-qiskit
|
C2QA
|
# To use the package locally, add the C2QA repository's root folder to the path prior to importing c2qa.
import os
import sys
module_path = os.path.abspath(os.path.join("../.."))
if module_path not in sys.path:
sys.path.append(module_path)
# Cheat to get MS Visual Studio Code Jupyter server to recognize Python venv
module_path = os.path.abspath(os.path.join("../../venv/Lib/site-packages"))
if module_path not in sys.path:
sys.path.append(module_path)
import c2qa
import numpy as np
import qiskit
import qiskit.visualization
import qiskit_aer
from matplotlib import pyplot as plt
from IPython.display import HTML
#setup registers
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode = 6)
qbr = qiskit.QuantumRegister(1)
cr = qiskit.ClassicalRegister(1)
#convenient labeling
qbit = qbr[0]
qumode = qmr[0]
#The circuit is initalized to |0>|0> by default
circuit = c2qa.CVCircuit(qmr, qbr, cr)
#put the qubit into a superposition and then execute a controlled displacement of the cavity
alpha = 2
circuit.h(qbr[0])
circuit.cv_c_d(alpha, qmr[0], qbr[0])
#apply a rotation around an angle pi/4
theta = np.pi/4
circuit.cv_r(theta, qmr[0])
#measure qubit in x basis to collapse into even or odd cat state
circuit.measure_x(qbr, cr)
#simulate and plot
state, _, _ = c2qa.util.simulate(circuit)
c2qa.wigner.plot_wigner(circuit, state)
#the resulting plot is a cat state that is rotated 45 degrees
circuit.clear() #reset
#Initialize Fock state and displace by alpha
alpha = 2
circuit.cv_initialize(3, qmr[0])
circuit.cv_d(alpha, qmr[0])
#Simulate and plot
state, _, _ = c2qa.util.simulate(circuit)
c2qa.wigner.plot_wigner(circuit, state)
#Resulting state is a displaced Fock state
circuit.clear()
s = 1
circuit.cv_initialize(0, qmr[0])
circuit.cv_sq(s, qmr[0])
state, _, _ = c2qa.util.simulate(circuit)
#the resulting plot is a coherent state which is squeezed in the position quadrature
c2qa.wigner.plot_wigner(circuit, state)
circuit.data.pop(1)
#plot a momentum-squeezed state for comparison
circuit.cv_sq(-s, qmr[0])
state, _, _ = c2qa.util.simulate(circuit)
c2qa.wigner.plot_wigner(circuit, state)
qmr = c2qa.QumodeRegister(2, num_qubits_per_qumode = 3)
qbr = qiskit.QuantumRegister(12)
circuit = c2qa.CVCircuit(qmr, qbr)
circuit.cv_sq2(1, qmr[0], qmr[1])
_, result, fock_counts = c2qa.util.simulate(circuit)
qiskit.visualization.plot_histogram(fock_counts)
#Notice the correlation between the state of the two qumodes! They always have the same photon number
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode=4)
circuit = c2qa.CVCircuit(qmr)
#Define the side lengths of the rectangle
a = 2
b = 1
animate_steps = 4
#Execute the sequence of displacements
circuit.cv_d(a, qmr[0])
circuit.cv_d(1j*b, qmr[0])
circuit.cv_d(-a, qmr[0])
circuit.cv_d(-1j*b, qmr[0])
#animate the result
anim = c2qa.animate.animate_wigner(circuit, animation_segments=10);
HTML(anim.to_html5_video())
qbr = qiskit.QuantumRegister(1)
creg = qiskit.ClassicalRegister(1)
def measure_phase(c): #choose a = b = sqrt(c) to get a square of area c
shots = 1024
circuit = c2qa.CVCircuit(qmr, qbr, creg, probe_measure=True)
circuit.h(qbr[0])
circuit.cv_c_d(np.sqrt(c)/2, qmr[0], qbr[0])
circuit.cv_d(1j*np.sqrt(c)/2, qmr[0])
circuit.cv_c_d(-np.sqrt(c)/2, qmr[0], qbr[0])
circuit.cv_d(-1j*np.sqrt(c)/2, qmr[0])
circuit.measure_x(qbr[0], creg[0])
state, result, fock_counts = c2qa.util.simulate(circuit)
counts = result.get_counts(circuit)
return (counts.get('0',0)-counts.get('1',0))/shots
measure_phase(0)
c_vals = np.linspace(0, 2*np.pi, 20)
results = []
for c in c_vals:
results.append(measure_phase(c))
plt.plot(c_vals, results, c = "b", linestyle = "None", marker = "o", label = "data")
plt.plot(c_vals, np.cos(c_vals), c = "k", linestyle = "--", label =r"$\cos(area)$")
plt.xlabel("area/4")
plt.ylabel(r"$\langle \sigma_x \rangle$")
plt.legend()
|
https://github.com/suvoooo/Qubits-Qiskit
|
suvoooo
|
# !pip3 install qiskit
import numpy as np
import qiskit as q
### build a circuit for 3 qubits
qr = q.QuantumRegister(3)
circ = q.QuantumCircuit(qr)
### add the first H gate (in qiskit east significant bit has the lowest index)
circ.h(qr[2])
### add the controlled phase gate
circ.cp(np.pi/2, qr[1], qr[2]) # based on qubit 1 apply 2pi/2**(k-1) rotation to qubit 2
### add the next cp gate
circ.cp(np.pi/4, qr[0], qr[2]) # based on qubit 0 apply 2pi/2**(k-1) rotation to qubit 2
### repeat the process for qubit 1
circ.h(qr[1])
circ.cp(np.pi/2, qr[0], qr[1])
### add the final h gate
circ.h(qr[0])
### finally swap the bits 0 th, and 2nd qubit
circ.swap(qr[0], qr[2])
circ.draw()
from google.colab import drive
drive.mount('/content/drive')
# !pip install pylatexenc
path='/content/drive/My Drive/Colab Notebooks/'
style = {'backgroundcolor': 'lavender', 'dpi':200, 'subfontsize':10}
circ.draw('mpl', scale=0.8, style=style, filename=path+'qfouriert_3bits.png')
qr = q.QuantumRegister(3)
circ1 = q.QuantumCircuit(qr)
### encode the state 110 at first
circ1.x(qr[2])
circ1.x(qr[1])
### repeat what's done before
### add the first H gate (in qiskit east significant bit has the lowest index)
circ1.h(qr[2])
### add the controlled phase gate
circ1.cp(np.pi/2, qr[1], qr[2]) # based on qubit 1 apply 2pi/2**(k-1) rotation to qubit 2
### add the next cp gate
circ1.cp(np.pi/4, qr[0], qr[2]) # based on qubit 0 apply 2pi/2**(k-1) rotation to qubit 2
### repeat the process for qubit 1
circ1.h(qr[1])
circ1.cp(np.pi/2, qr[0], qr[1])
### add the final h gate
circ1.h(qr[0])
### finally swap the bits 0 th, and 2nd qubit
circ1.swap(qr[0], qr[2])
circ1.draw()
circ1.save_statevector()
qasm_sim = q.Aer.get_backend('qasm_simulator')
statevector = qasm_sim.run(circ1).result().get_statevector()
q.visualization.plot_bloch_multivector(statevector)
qr = q.QuantumRegister(3)
circ2 = q.QuantumCircuit(qr)
### encode the state 101 at first
circ2.x(qr[2])
circ2.x(qr[0])
### repeat what's done before
### add the first H gate (in qiskit east significant bit has the lowest index)
circ2.h(qr[2])
### add the controlled phase gate
circ2.cp(np.pi/2, qr[1], qr[2]) # based on qubit 1 apply 2pi/2**(k-1) rotation to qubit 2
### add the next cp gate
circ2.cp(np.pi/4, qr[0], qr[2]) # based on qubit 0 apply 2pi/2**(k-1) rotation to qubit 2
### repeat the process for qubit 1
circ2.h(qr[1])
circ2.cp(np.pi/2, qr[0], qr[1])
### add the final h gate
circ2.h(qr[0])
### finally swap the bits 0 th, and 2nd qubit
circ2.swap(qr[0], qr[2])
circ2.draw()
circ2.save_statevector()
qasm_sim = q.Aer.get_backend('qasm_simulator')
statevector2 = qasm_sim.run(circ2).result().get_statevector()
q.visualization.plot_bloch_multivector(statevector2)
|
https://github.com/JohnBurke4/qaoa_testing_framework
|
JohnBurke4
|
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate
import networkx as nx
import random
import numpy as np
def getBestMaxcut(costFunction, v):
bestCut = 0
bestPartition = []
for i in range(0, 2**v):
partition = bin(i)
partition = partition[2:]
partition = "0" * (v - len(partition)) + partition
cut = costFunction.getCost(partition)
if (cut < bestCut):
bestPartition = [partition]
bestCut = cut
elif (cut == bestCut):
bestPartition.append(partition)
return bestCut, bestPartition
def groverDiffuser(n):
qc = QuantumCircuit(n)
# Apply transformation |s> -> |00..0> (H-gates)
qc.h(range(n))
# Apply transformation |00..0> -> |11..1> (X-gates)
qc.x(range(n))
# Do multi-controlled-Z gate
qc.h(n-1)
qc.mct(list(range(n-1)), n-1) # multi-controlled-toffoli
qc.h(n-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(n):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
qc.h(range(n))
# We will return the diffuser as a gate
gate = qc.to_gate()
gate.name = "diffuser"
return gate
def qaoaCompressor(graph):
nodes = list(graph.nodes)
edges = list(graph.edges)
# print(nodes)
# print(edges)
start = min(nodes, key=lambda node: sum(node in edge for edge in edges))
# print(start)
currentNodes = [start]
nodes.remove(start)
maxLen = 0
deadNodes = []
addedEdges = []
while (len(nodes) > 0):
current = min(currentNodes, key=lambda node: sum(node in edge for edge in edges))
connectingEdges = [edge for edge in edges if current in edge]
if (len(connectingEdges) == 0):
currentNodes.remove(current)
deadNodes.append(current)
else:
nextEdge = connectingEdges[0]
for ver in nextEdge:
if (ver != current):
nextNode = ver
currentNodes.append(nextNode)
nodes.remove(nextNode)
connectingEdges = [edge for edge in edges if nextNode in edge]
for edge in connectingEdges:
if ((edge[0] in currentNodes or edge[0] in deadNodes) and (edge[1] in currentNodes or edge[1] in deadNodes)):
edges.remove(edge)
addedEdges.append(edge)
if (len(currentNodes) > maxLen):
maxLen = len(currentNodes)
# print(currentNodes, current, nextNode)
# print(edges)
def custom_graphs():
graph = nx.Graph()
n = 3
graph.add_nodes_from(list(range(0, n)))
graph.add_edges_from([(0, 1), (1, 2)])
return graph
def ry_simulator(params, runs = 1000):
def sim_ry(param):
prob = random.random()
if (prob > np.cos(param/2)**2):
return "1"
return "0"
counts = {}
for i in range(0, runs):
string = ""
for param in params:
string += sim_ry(param)
if string in counts:
counts[string] += 1
else:
counts[string] = 1
# print("Epoch")
return counts
def greedyMaxcutSolver(graph, costFunction):
v = len(graph.nodes)
guess = ["0"] * v
bestCost = 0
indices = list(range(0, v))
while len(indices) > 0:
bestIndex = -1
for i in indices:
currentGuess = guess.copy()
currentGuess[i] = "1"
cost = costFunction.getCost("".join(currentGuess)[::-1])
# print("".join(currentGuess)[::-1])
# print(cost)
if (cost < bestCost):
bestCost = cost
bestIndex = i
print(cost)
if (bestIndex == -1):
break
guess[bestIndex] = "1"
indices.remove(bestIndex)
return (bestCost)
def customSATSolverCircuit(graph):
v = len(graph.nodes)
qc = QuantumCircuit(2*v, v)
qc.h(range(0, v))
for i in range(0, v):
qc.cx(i, v+i)
qc.barrier()
hGate = HGate().control(2)
for edge in graph.edges():
v1 = edge[0]
v2 = edge[1]
qc.append(hGate, ([v1, v2, v + v1]))
qc.append(hGate, ([v1, v2, v + v2]))
qc.barrier()
qc.x(v1)
qc.x(v2)
qc.append(hGate, ([v1, v2, v + v1]))
qc.append(hGate, ([v1, v2, v + v2]))
qc.x(v1)
qc.x(v2)
qc.barrier()
qc.measure(range(v, 2*v), range(0, v))
return qc
def customSATSolverCircuit(graph):
v = len(graph.nodes)
qc = QuantumCircuit(2*v, v)
qc.h(range(0, v))
for i in range(0, v):
qc.cx(i, v+i)
qc.barrier()
# hGate = HGate().control(2)
i = 0
order = [1, 0, 0, 0, 0, 0, 0, 0]
for edge in graph.edges():
v1 = edge[0]
v2 = edge[1]
o = order[i]
if (o):
vC = v2
else:
vC = v1
qc.toffoli(v1, v2, v + vC)
qc.barrier()
qc.x(v1)
qc.x(v2)
qc.toffoli(v1, v2, v + vC)
qc.x(v1)
qc.x(v2)
qc.barrier()
i+=1
qc.measure(range(v, 2*v), range(0, v))
return qc
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
#Imports
from itertools import product
import matplotlib.pyplot as plt
%matplotlib inline
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Result
from qiskit import available_backends, get_backend, execute, register, least_busy
from qiskit.tools.visualization import matplotlib_circuit_drawer, qx_color_scheme #require qiskit>0.5.5
%config InlineBackend.figure_format = 'svg'
style = qx_color_scheme()
style['compress'] = True
style['cregbundle'] = True
style['plotbarrier'] = True
circuit_drawer = lambda circuit: matplotlib_circuit_drawer(circuit, style=style)
# Creating registers
qa = QuantumRegister(1, 'alice')
qb = QuantumRegister(1, 'bob')
c = ClassicalRegister(2, 'c')
# Bell Measurement
bell_measurement = QuantumCircuit(qa, qb, c)
bell_measurement.cx(qa, qb)
bell_measurement.h(qa)
bell_measurement.measure(qa[0], c[0])
bell_measurement.measure(qb[0], c[1])
circuit_drawer(bell_measurement)
alice = {}
bob = {}
# eigenvalue
alice['+'] = QuantumCircuit(qa, qb, c) # do nothing
alice['-'] = QuantumCircuit(qa, qb, c)
alice['-'] .x(qa)
bob['+'] = QuantumCircuit(qa, qb, c) # do nothing
bob['-'] = QuantumCircuit(qa, qb, c)
bob['-'].x(qb)
# matrix
alice['Z'] = QuantumCircuit(qa, qb, c) # do nothing
alice['X'] = QuantumCircuit(qa, qb, c)
alice['X'].h(qa)
bob['W'] = QuantumCircuit(qa, qb, c)
bob['W'].h(qb)
bob['W'].t(qb)
bob['W'].h(qb)
bob['W'].s(qb)
bob['V'] = QuantumCircuit(qa, qb, c)
bob['V'].h(qb)
bob['V'].tdg(qb)
bob['V'].h(qb)
bob['V'].s(qb)
qc = alice['+'] + alice['Z'] + bob['+'] + bob['V']
circuit_drawer(qc)
qc = alice['-'] + alice['X'] + bob['+'] + bob['W']
circuit_drawer(qc)
backend = 'local_qasm_simulator'
shots = 1024
circuits = {}
for a_sign, a_basis, b_sign, b_basis in product(['+', '-'], ['Z', 'X'], ['+', '-'], ['V', 'W']):
name = a_sign + a_basis + b_sign + b_basis
circuits[name] = QuantumCircuit(qa, qb, c)
circuits[name] += alice[a_sign]
circuits[name] += alice[a_basis]
circuits[name] += bob[b_sign]
circuits[name] += bob[b_basis]
circuits[name].barrier(qa)
circuits[name].barrier(qb)
circuits[name] += bell_measurement
# Example
print('A quantum circuit of -X+V.')
circuit_drawer(circuits['-X+V'])
job = execute(circuits.values(), backend=backend, shots=shots)
result = job.result()
completely_mixed = {'00': 0, '01': 0, '10': 0, '11': 0}
for a_sign, a_basis, b_sign, b_basis in product(['+', '-'], ['Z', 'X'], ['+', '-'], ['V', 'W']):
name = a_sign + a_basis + b_sign + b_basis
completely_mixed['00'] += result.average_data(circuits[name], {'00': 1})/16
completely_mixed['01'] += result.average_data(circuits[name], {'01': 1})/16
completely_mixed['10'] += result.average_data(circuits[name], {'10': 1})/16
completely_mixed['11'] += result.average_data(circuits[name], {'11': 1})/16
plt.bar(completely_mixed.keys(), completely_mixed.values(), width=0.5)
plt.xlabel('Outcome', fontsize=15)
plt.ylabel('Probability for the completely mixed state', fontsize=10)
plt.axhline(y=0.25, color='red', linewidth=1)
def E(result: Result, observable: dict, a_basis: str, b_basis: str) -> float:
val = 0
str2int = lambda x: 1 if x == '+' else -1
for a_sign, b_sign in product(['+', '-'], ['+', '-']):
name = a_sign + a_basis + b_sign + b_basis
sign = str2int(a_sign) * str2int(b_sign)
val += sign * result.average_data(circuits[name], observable)
return val
def D(result: Result, outcome: str) -> float:
val = 0
for a_basis, b_basis in product(['Z', 'X'], ['V', 'W']):
if outcome[0] == outcome[1] and a_basis == 'X' and b_basis == 'V':
sign = -1
elif outcome[0] != outcome[1] and a_basis == 'X' and b_basis == 'W':
sign = -1
else:
sign = 1
val += sign * E(result, {outcome: 1}, a_basis=a_basis, b_basis=b_basis)
return val
for outcome in ['00', '01', '10', '11']:
if completely_mixed[outcome] <= 1/4: # check the condition
print('D is equal to {} for the outcome {}.'.format(D(result, outcome), outcome))
# Connecting to the IBM Quantum Experience
import sys, getpass
try:
sys.path.append("../../") # go to parent dir
import Qconfig
qx_config = {
"APItoken": Qconfig.APItoken,
"url": Qconfig.config['url']}
print('Qconfig loaded from %s.' % Qconfig.__file__)
except:
APItoken = getpass.getpass('Please input your token and hit enter: ')
qx_config = {
"APItoken": APItoken,
"url":"https://quantumexperience.ng.bluemix.net/api"}
print('Qconfig.py not found in qiskit-tutorial directory; Qconfig loaded using user input.')
register(qx_config['APItoken'], qx_config['url'])
device_shots = 1024
device_name = least_busy(available_backends({'simulator': False, 'local': False}))
device = get_backend(device_name)
device_coupling = device.configuration['coupling_map']
print("the best backend is " + device_name + " with coupling " + str(device_coupling))
job = execute(circuits.values(), backend=device_name, shots=device_shots)
result = job.result()
completely_mixed = {'00': 0, '01': 0, '10': 0, '11': 0}
for a_sign, a_basis, b_sign, b_basis in product(['+', '-'], ['Z', 'X'], ['+', '-'], ['V', 'W']):
name = a_sign + a_basis + b_sign + b_basis
completely_mixed['00'] += result.average_data(circuits[name], {'00': 1})/16
completely_mixed['01'] += result.average_data(circuits[name], {'01': 1})/16
completely_mixed['10'] += result.average_data(circuits[name], {'10': 1})/16
completely_mixed['11'] += result.average_data(circuits[name], {'11': 1})/16
plt.bar(completely_mixed.keys(), completely_mixed.values(), width=0.5)
plt.xlabel('Outcome', fontsize=15)
plt.ylabel('Probability for the completely mixed state', fontsize=10)
plt.axhline(y=0.25, color='red', linewidth=1)
for outcome in ['00', '01', '10', '11']:
if completely_mixed[outcome] <= 1/4: # check the condition
print('D is equal to {} for the outcome {}.'.format(D(result, outcome), outcome))
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import QuantumCircuit, Aer, execute, IBMQ
from qiskit.utils import QuantumInstance
import numpy as np
from qiskit.algorithms import Shor
IBMQ.enable_account('ENTER API TOKEN HERE') # Enter your API token here
provider = IBMQ.get_provider(hub='ibm-q')
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1000)
my_shor = Shor(quantum_instance)
result_dict = my_shor.factor(15)
print(result_dict)
|
https://github.com/QPower-Research/QPowerAlgo
|
QPower-Research
|
import numpy as np
from numpy import linalg as LA
from scipy.linalg import expm, sinm, cosm
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
import math
from scipy import stats
%matplotlib inline
from IPython.display import Image, display, Math, Latex
sns.set(color_codes=True)
#number of vertices
n = 4
#Define adjacency matrix A_Cn
A = np.zeros((n, n))
for i in range(n):
j1 = (i - 1)%n
j2 = (i + 1)%n
A[i][j1] = 1
A[i][j2] = 1
#Define our initial state Psi_a
psi_a = np.zeros(n)
psi_a[3] = 1
#Define the time t >= 0
t = math.pi/2
#Exponentiate or hamiltonian
U_t = expm(1j*t*A)
U_mt = expm(1j*(-t)*A)
#Compute Psi_t
psi_t = U_t @ psi_a
#Compute the probabilities
prob_t = abs(psi_t)**2
M_t = U_t*U_mt
M_t = np.around(M_t, decimals = 3)
M_t
x = M_t[:, 0].real
plt.bar(range(len(x)), x, tick_label=[0, 1, 2, 3])
plt.xlabel('Vertices')
plt.ylabel('Probability')
|
https://github.com/crabster/qiskit-learning
|
crabster
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 19 19:13:26 2023
@author: abdullahalshihry
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 18 19:15:12 2023
@author: abdullahalshihry
"""
import qiskit as qs
import qiskit.visualization as qv
import random
import qiskit.circuit as qf
def Deutsch_Jozsa(circuit):
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qc.x(qr[4])
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.h(qr[4])
qc.barrier(range(5))
qc = qc.compose(circuit)
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.barrier(range(5))
qc.measure(0,0)
qc.measure(1,1)
qc.measure(2,2)
qc.measure(3,3)
job1 = qs.execute(qc, qs.Aer.get_backend('aer_simulator'), shots = 1024)
output1 = job1.result().get_counts()
print(output1)
qc.draw('mpl')
def Oracle():
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qq = qs.QuantumCircuit(5,name='Uf')
v = random.randint(1, 2)
if v == 1:
qc.cx(0,4)
qc.cx(1,4)
qc.cx(2,4)
qc.cx(3,4)
print('Balanced (1)')
elif v == 2:
qq.i(qr[0])
qq.i(qr[1])
qq.i(qr[2])
qq.i(qr[3])
print('Constant (0)')
qq =qq.to_gate()
qc.append(qq,[0,1,2,3,4])
return qc
Deutsch_Jozsa(Oracle())
|
https://github.com/bagmk/qiskit-quantum-state-classifier
|
bagmk
|
import numpy as np
import json as json
from o_plot import opl # a small local package dedicated to this project
import sys
print(sys.executable)
# loading the data
file_name = 'TAL2_data_new.json'
f = open(file_name)
All_data = json.load(f)
# this for Jensen-Shannon metric
s_metric = 'jensenshannon'
sm = np.array([96])
SAD=0
# ! will be unselected by running the next cell
# main option for metric: squared euclidean distance
# skip this cell if you don't want this option
s_metric = 'sqeuclidean'
sm = np.array([97])
SAD=2
# this for no mitigation
mit = 'no'
MIT=-4
# ! will be unselected by running the next cell
# mainstream option: this for measurement mitigation
# skip this cell if you don't want this option
mit = 'yes'
MIT=0
ADD=-3
opl.plot_curves(All_data, ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared euclidean distance - $\epsilon=0.001$ - no delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=1
opl.plot_curves(All_data, ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared euclidean distance - $\epsilon=0.001$ - no delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=45
opl.plot_curves(All_data, ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared euclidean distance - $\epsilon=0.001$ - with delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=49
opl.plot_curves(All_data, ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared euclidean distance - $\epsilon=0.001$ - with delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=-4
opl.plot_curves(All_data, ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared euclidean distance - $\epsilon=0.001$ - no delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=0
opl.plot_curves(All_data, ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared euclidean distance - $\epsilon=0.001$ - no delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=44
opl.plot_curves(All_data, ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared euclidean distance - $\epsilon=0.001$ - with delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=48
opl.plot_curves(All_data,ADD+np.array([96-ADD,97-ADD,4,6,12,14,20,22,28,30,36,38,44,46]),
"Jensen-Shannon vs squared eucliden distance - $\epsilon=0.001$ - with delay",
["model","mitigation"], ["device","metric"], right_xlimit = 90)
ADD=1+SAD
opl.plot_curves(All_data, np.append(sm,ADD+np.array([0,4,8,12,16,20,24,28,32,36,40,44])),
"Effect of mitigation - $\epsilon=0.001$ - no delay",
["model","metric"], ["device","mitigation"], right_xlimit = 90)
ADD=49+SAD
opl.plot_curves(All_data, np.append(sm,ADD+np.array([0,4,8,12,16,20,24,28,32,36,40,44])),
"Effect of mitigation - $\epsilon=0.001$ - with delay",
["model","metric"], ["device","mitigation"], right_xlimit = 90)
ADD=0+SAD
opl.plot_curves(All_data,np.append(sm,ADD+np.array([0,4,8,12,16,20,24,28,32,36,40,44])),
"Effect of mitigation - $\epsilon=0.001$ - no delay",
["model","metric"], ["device","mitigation"], right_xlimit = 90)
ADD=48+SAD
opl.plot_curves(All_data,np.append(sm,ADD+np.array([0,4,8,12,16,20,24,28,32,36,40,44])),
"Effect of mitigation - $\epsilon=0.001$ - with delay",
["model","metric"], ["device","mitigation"], right_xlimit =90)
ADD=-3+SAD
opl.plot_curves(All_data,np.append(sm,ADD+np.array([4,52,12,60,20,68,28,76,36,84,44,92])),
"Effect of Delay - $\epsilon=0.001$",
["model","metric","mitigation"],
["device","model","id_gates"], right_xlimit = 90)
ADD=1+SAD
opl.plot_curves(All_data,np.append(sm,ADD+np.array([4,52,12,60,20,68,28,76,36,84,44,92])),
"Effect of Delay - $\epsilon=0.001$",
["model","metric","mitigation"],
["device","model","id_gates"], right_xlimit = 90)
ADD=-4+SAD
opl.plot_curves(All_data,np.append(sm,ADD+np.array([4,52,12,60,20,68,28,76,36,84,44,92])),
"Effect of Delay - $\epsilon=0.001$",
["model","metric","mitigation"],
["device","model","id_gates"], right_xlimit = 90)
ADD=0+SAD
opl.plot_curves(All_data,np.append(sm,ADD+np.array([4,52,12,60,20,68,28,76,36,84,44,92])),
"Effect of Delay - $\epsilon=0.001$",
["model","metric","mitigation"],
["device","model","id_gates"], right_xlimit = 90)
|
https://github.com/Pitt-JonesLab/mirror-gates
|
Pitt-JonesLab
|
from transpile_benchy.metrics.gate_counts import (
DepthMetric,
TotalMetric,
TotalSwaps,
)
from qiskit.circuit.library import iSwapGate
from qiskit.transpiler import CouplingMap
from mirror_gates.pass_managers import Mirage, QiskitLevel3
from mirror_gates.utilities import SubsMetric
from mirror_gates.logging import transpile_benchy_logger
# N = 4
# coupling_map = CouplingMap.from_line(N)
coupling_map = CouplingMap.from_grid(6, 6)
from transpile_benchy.library import CircuitLibrary
library = CircuitLibrary.from_txt("../../../circuits/medium_circuits.txt")
# library = CircuitLibrary.from_txt("../../circuits/debug.txt")
# XXX set consolidate to False
# this is allowed only because my pass manager will preserve consolidation
# see post_stage, I call fastconsolidate manually
# NOTE: use TotalSwaps to verify baselines have > 0 swaps
# otherwise, there is no room for improvement.
# we can include these if we want to show our methods will still work
# but somewhat trivial since we just append VF2Layout
metrics = [
DepthMetric(consolidate=False),
TotalMetric(consolidate=False),
TotalSwaps(consolidate=False),
SubsMetric(),
]
transpilers = [
QiskitLevel3(coupling_map, syc_basis=True),
Mirage(
coupling_map,
logger=transpile_benchy_logger,
syc_basis=True,
),
]
benchmark = Benchmark(
transpilers=transpilers,
circuit_library=library,
metrics=metrics,
logger=transpile_benchy_logger,
num_runs=5,
)
benchmark.run()
# print(benchmark)
print(benchmark)
benchmark.summary_statistics(transpilers[0], transpilers[1])
from transpile_benchy.render import plot_benchmark
plot_benchmark(
benchmark,
save=1,
legend_show=1,
filename="syc_sl",
color_override=[7, 8],
)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Size pass testing"""
import unittest
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.converters import circuit_to_dag
from qiskit.transpiler.passes import Size
from qiskit.test import QiskitTestCase
class TestSizePass(QiskitTestCase):
"""Tests for Depth analysis methods."""
def test_empty_dag(self):
"""Empty DAG has 0 size"""
circuit = QuantumCircuit()
dag = circuit_to_dag(circuit)
pass_ = Size()
_ = pass_.run(dag)
self.assertEqual(pass_.property_set["size"], 0)
def test_just_qubits(self):
"""A dag with 8 operations and no classic bits"""
qr = QuantumRegister(2)
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.h(qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[0], qr[1])
circuit.cx(qr[1], qr[0])
circuit.cx(qr[1], qr[0])
dag = circuit_to_dag(circuit)
pass_ = Size()
_ = pass_.run(dag)
self.assertEqual(pass_.property_set["size"], 8)
def test_depth_one(self):
"""A dag with operations in parallel and size 2"""
qr = QuantumRegister(2)
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.h(qr[1])
dag = circuit_to_dag(circuit)
pass_ = Size()
_ = pass_.run(dag)
self.assertEqual(pass_.property_set["size"], 2)
def test_size_control_flow(self):
"""A DAG with control flow still gives an estimate."""
qc = QuantumCircuit(5, 1)
qc.h(0)
qc.measure(0, 0)
with qc.if_test((qc.clbits[0], True)) as else_:
qc.x(1)
qc.cx(2, 3)
with else_:
qc.x(1)
with qc.for_loop(range(3)):
qc.z(2)
with qc.for_loop((4, 0, 1)):
qc.z(2)
with qc.while_loop((qc.clbits[0], True)):
qc.h(0)
qc.measure(0, 0)
pass_ = Size(recurse=True)
pass_(qc)
self.assertEqual(pass_.property_set["size"], 19)
if __name__ == "__main__":
unittest.main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.library import MCXGate
gate = MCXGate(4)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(5)
circuit.append(gate, [0, 1, 4, 2, 3])
circuit.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')
|
https://github.com/minminjao/qiskit1
|
minminjao
|
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()
circ=QuantumCircuit(2,2)
circ.h(0)
circ.cx(0,1)
circ.x(0)
circ.barrier(range(2))
circ.cx(0,1)
circ.h(0)
circ.measure(range(2),range(2))
circ.draw()
backend_sim=Aer.get_backend('qasm_simulator')
ch_sim=backend_sim.run(transpile(circ, backend_sim), shots=1024)
result_sim=ch_sim.result()
counts=result_sim.get_counts(circ)
print(counts)
|
https://github.com/GIRISHBELANI/QC_Benchmarks_using_dm-simulator
|
GIRISHBELANI
|
import matplotlib.pyplot as plt
import numpy as np
import copy
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, assemble
from collections.abc import Iterable
# Construct A operator that takes |0>_{n+1} to sqrt(1-a) |psi_0>|0> + sqrt(a) |psi_1>|1>
def A_gen(num_state_qubits, a, psi_zero=None, psi_one=None):
if psi_zero==None:
psi_zero = '0'*num_state_qubits
if psi_one==None:
psi_one = '1'*num_state_qubits
theta = 2 * np.arcsin(np.sqrt(a))
# Let the objective be qubit index n; state is on qubits 0 through n-1
qc_A = QuantumCircuit(num_state_qubits+1, name=f"A")
# qc_A.ry(theta, num_state_qubits) #ry is not present in the list of basis_gates (qiskit-aakash/qiskit/providers/basicaer/unitary_simulator.py)
qc_A.x(num_state_qubits)
for i in range(num_state_qubits):
if psi_zero[i]=='1':
qc_A.cnot(num_state_qubits,i)
qc_A.x(num_state_qubits)
for i in range(num_state_qubits):
if psi_one[i]=='1':
qc_A.cnot(num_state_qubits,i)
return qc_A
# Construct the grover-like operator and a controlled version of it
def Ctrl_Q(num_state_qubits, A_circ):
# index n is the objective qubit, and indexes 0 through n-1 are state qubits
qc = QuantumCircuit(num_state_qubits+1, name=f"Q")
temp_A = copy.copy(A_circ)
A_gate = temp_A.to_gate()
A_gate_inv = temp_A.inverse().to_gate()
### Each cycle in Q applies in order: S_chi, A_circ_inverse, S_0, A_circ
# S_chi
qc.z(num_state_qubits)
# A_circ_inverse
qc.append(A_gate_inv, [i for i in range(num_state_qubits+1)])
# S_0
for i in range(num_state_qubits+1):
qc.x(i)
qc.h(num_state_qubits)
qc.mcx([x for x in range(num_state_qubits)], num_state_qubits)
qc.h(num_state_qubits)
for i in range(num_state_qubits+1):
qc.x(i)
# A_circ
qc.append(A_gate, [i for i in range(num_state_qubits+1)])
# add "global" phase
qc.x(num_state_qubits)
qc.z(num_state_qubits)
qc.x(num_state_qubits)
qc.z(num_state_qubits)
# Create a gate out of the Q operator
qc.to_gate(label='Q')
# and also a controlled version of it
Ctrl_Q_ = qc.control(1)
# and return both
return Ctrl_Q_, qc
num_q = 3
qr_ = QuantumRegister(num_q+1)
cr_ = ClassicalRegister(num_q+1)
qc_ = QuantumCircuit(qr_, cr_)
a = 1/8
A = A_gen(num_q, a)
_, Q = Ctrl_Q(num_q, A)
qc_.append(A, qr_)
# qc_.append(Q, qr_)
qc_.measure(qr_, cr_)
from qiskit import execute, BasicAer
backend = BasicAer.get_backend("dm_simulator")
job = execute(qc_, backend, shots=1000)
result = job.result()
counts = result.get_counts()
print(counts)
num_q = 1
qr_ = QuantumRegister(num_q+1)
cr_ = ClassicalRegister(num_q+1)
qc_ = QuantumCircuit(qr_, cr_)
a = 1/5
A = A_gen(num_q, a)
_, Q = Ctrl_Q(num_q, A)
qc_.append(Q, qr_)
display(qc_.draw())
qc_ = qc_.decompose().decompose()
usim = BasicAer.get_backend('unitary_simulator')
qobj = assemble(qc_)
unitary = usim.run(qobj).result().get_unitary()
print(np.round(unitary, 6))
|
https://github.com/sebasmos/QuantumVE
|
sebasmos
|
import sys
sys.path.insert(0,'../')
# from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import random_split
from torch.utils.data import Subset, DataLoader, random_split
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR
import matplotlib.pyplot as plt
import numpy as np
from sklearn.metrics import confusion_matrix, classification_report
import pandas as pd
import argparse
import argparse
import datetime
import json
import numpy as np
import os
import time
from pathlib import Path
import torch
import torch.backends.cudnn as cudnn
from torch.utils.tensorboard import SummaryWriter
# import models_vit
import sys
import os
import torch
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
# import models_mae
import torch; print(f'numpy version: {np.__version__}\nCUDA version: {torch.version.cuda} - Torch versteion: {torch.__version__} - device count: {torch.cuda.device_count()}')
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns
from sklearn.preprocessing import LabelBinarizer
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
from itertools import cycle
import numpy as np
from sklearn.metrics import precision_score, recall_score, f1_score
import torch.optim as optim
import torch.nn as nn
import torch
import PIL
import pandas as pd
import torch
import numpy as np
import pandas as pd
from tqdm import tqdm
import os
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, fbeta_score
from sklearn.metrics import precision_score, recall_score, f1_score, fbeta_score
import numpy as np
from torchvision import datasets, transforms
from timm.data import create_transform
# from timm.data.constants import IMAGENET_DEFAULT_MEAN, IMAGENET_DEFAULT_STD
IMAGENET_DEFAULT_MEAN = np.array([0.485, 0.456, 0.406])
IMAGENET_DEFAULT_STD = np.array([0.229, 0.224, 0.225])
def show_image(image, title=''):
# image is [H, W, 3]
assert image.shape[2] == 3
plt.imshow(torch.clip((image * IMAGENET_DEFAULT_STD + IMAGENET_DEFAULT_MEAN) * 255, 0, 255).int())
plt.title(title, fontsize=16)
plt.axis('off')
return
def plot_multiclass_roc_curve(all_labels, all_predictions, EXPERIMENT_NAME="."):
# Step 1: Label Binarization
label_binarizer = LabelBinarizer()
y_onehot = label_binarizer.fit_transform(all_labels)
all_predictions_hot = label_binarizer.transform(all_predictions)
# Step 2: Calculate ROC curves
fpr = dict()
tpr = dict()
roc_auc = dict()
unique_classes = range(y_onehot.shape[1])
for i in unique_classes:
fpr[i], tpr[i], _ = roc_curve(y_onehot[:, i], all_predictions_hot[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
# Step 3: Plot ROC curves
fig, ax = plt.subplots(figsize=(8, 8))
# Micro-average ROC curve
fpr_micro, tpr_micro, _ = roc_curve(y_onehot.ravel(), all_predictions_hot.ravel())
roc_auc_micro = auc(fpr_micro, tpr_micro)
plt.plot(
fpr_micro,
tpr_micro,
label=f"micro-average ROC curve (AUC = {roc_auc_micro:.2f})",
color="deeppink",
linestyle=":",
linewidth=4,
)
# Macro-average ROC curve
all_fpr = np.unique(np.concatenate([fpr[i] for i in unique_classes]))
mean_tpr = np.zeros_like(all_fpr)
for i in unique_classes:
mean_tpr += np.interp(all_fpr, fpr[i], tpr[i])
mean_tpr /= len(unique_classes)
fpr_macro = all_fpr
tpr_macro = mean_tpr
roc_auc_macro = auc(fpr_macro, tpr_macro)
plt.plot(
fpr_macro,
tpr_macro,
label=f"macro-average ROC curve (AUC = {roc_auc_macro:.2f})",
color="navy",
linestyle=":",
linewidth=4,
)
# Individual class ROC curves with unique colors
colors = plt.cm.rainbow(np.linspace(0, 1, len(unique_classes)))
for class_id, color in zip(unique_classes, colors):
plt.plot(
fpr[class_id],
tpr[class_id],
color=color,
label=f"ROC curve for Class {class_id} (AUC = {roc_auc[class_id]:.2f})",
linewidth=2,
)
plt.plot([0, 1], [0, 1], color='gray', linestyle='--', linewidth=2) # Add diagonal line for reference
plt.axis("equal")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("Extension of Receiver Operating Characteristic\n to One-vs-Rest multiclass")
plt.legend()
plt.savefig(f'{EXPERIMENT_NAME}/roc_curve.png')
plt.show()
def build_dataset(is_train, args):
transform = build_transform(is_train, args)
root = os.path.join(args.data_path, 'train' if is_train else 'val')
dataset = datasets.ImageFolder(root, transform=transform)
print(dataset)
return dataset
def build_transform(is_train, args):
mean = IMAGENET_DEFAULT_MEAN
std = IMAGENET_DEFAULT_STD
# train transform
if is_train:
# this should always dispatch to transforms_imagenet_train
transform = create_transform(
input_size=args.input_size,
is_training=True,
color_jitter=args.color_jitter,
auto_augment=args.aa,
interpolation='bicubic',
re_prob=args.reprob,
re_mode=args.remode,
re_count=args.recount,
mean=mean,
std=std,
)
return transform
# eval transform
t = []
if args.input_size <= 224:
crop_pct = 224 / 256
else:
crop_pct = 1.0
size = int(args.input_size / crop_pct)
t.append(
transforms.Resize(size, interpolation=PIL.Image.BICUBIC), # to maintain same ratio w.r.t. 224 images
)
t.append(transforms.CenterCrop(args.input_size))
t.append(transforms.ToTensor())
t.append(transforms.Normalize(mean, std))
return transforms.Compose(t)
# Set the seed for PyTorch
torch.manual_seed(42)
# Read embeddings CSV files
train_embeddings = pd.read_csv(f'{train_path}/train_embeddings.csv')
val_embeddings = pd.read_csv(f'{val_path}/val_embeddings.csv')
# Split the data into training and validation sets (80/20 split)
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.15, random_state=42)
X_test = val_embeddings.iloc[:, :-1].values # Features
y_test = val_embeddings.iloc[:, -1].values # Labels
print(X_train.shape, y_train.shape)
print(X_val.shape, y_val.shape)
print(X_test.shape, y_test.shape)
print("GridSearch over a list of neighbors: {0}".format(l_k))
_ = knn_gscv.fit(x, y)
from sklearn.model_selection import StratifiedKFold
from sklearn.model_selection import GridSearchCV, cross_val_score, StratifiedKFold
# we use stratified folds
from sklearn.pipeline import Pipeline
n_folds = 10
skf = StratifiedKFold(n_folds, shuffle=True)
mlp_classifier = Pipeline(steps=[('std_sc', StandardScaler()),
('mlpc', MLPClassifier(solver='adam',
activation='relu',
tol=1.e-4,
max_iter=1000,
warm_start=False,
shuffle=True))])
l_hidden_layer_sizes = [(20,), (20, 20)]
l_alpha = [10.**k for k in range(-6, 4)]
param_grid = {'mlpc__alpha': l_alpha, 'mlpc__hidden_layer_sizes': l_hidden_layer_sizes}
mlpc_gscv = GridSearchCV(mlp_classifier,
param_grid=param_grid,
cv=skf,
scoring='accuracy',
return_train_score=True,
n_jobs=-1,
verbose=1)
t_0 = time.time()
_ = mlpc_gscv.fit(X_train, y_train)
t_1 = time.time()
print("\nmlp_grid_search_time: {0:.2}f".format((t_1 - t_0)/60.))
import joblib
# saving alpha_search in a pickle
joblib.dump(mlpc_gscv, 'mlp_classifier_gscv.joblib')
df_cv_estimator = pd.DataFrame.from_dict(mlpc_gscv.cv_results_)
display(df_cv_estimator[["param_mlpc__alpha", "param_mlpc__hidden_layer_sizes", "mean_test_score"]].sort_values(by="mean_test_score", ascending=False).head())
mlpc_gscv = joblib.load('mlp_classifier_gscv.joblib')
best_alpha = mlpc_gscv.best_params_['mlpc__alpha']
print("best alpha: %.6f\t" % best_alpha)
print("alpha_min: %f\talpha_max: %f" % (np.array(l_alpha).min(), np.array(l_alpha).max()))
best_hidden_layer_sizes = mlpc_gscv.best_params_['mlpc__hidden_layer_sizes']
print("best_hidden_layer_sizes", best_hidden_layer_sizes, "\nacc: %.3f" % mlpc_gscv.best_score_)
idx_best_hidden_layer_sizes = [tup == best_hidden_layer_sizes for tup in df_cv_estimator['param_mlpc__hidden_layer_sizes'].values]
idx_best_hidden_layer_sizes = np.array(idx_best_hidden_layer_sizes)
plt.title("CV alpha vs accuracy")
plt.xscale('log')
plt.xlabel("alpha")
plt.ylabel("cv_accuracy")
_ = plt.plot( df_cv_estimator[idx_best_hidden_layer_sizes]['param_mlpc__alpha'],
df_cv_estimator[idx_best_hidden_layer_sizes]['mean_test_score'])
from sklearn.model_selection import cross_val_score, cross_val_predict, KFold, GridSearchCV
### CV accuracy, recall and precision of best model
y_pred = cross_val_predict(mlpc_gscv.best_estimator_, X_train, y_train, cv=skf, n_jobs=2)
acc = accuracy_score(y, y_pred)
recall = recall_score(y, y_pred)
prec = precision_score(y, y_pred)
print("acc: %.3f\trecall: %.3f\tprecision: %.3f" % (acc, recall, prec))
print("\nconfusion matrix:\n", confusion_matrix(y, y_pred))
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neural_network import MLPClassifier
mlp_classifier = MLPClassifier(hidden_layer_sizes=(100,), activation='relu',
solver='adam', alpha=0.0001, batch_size='auto',
learning_rate='constant', learning_rate_init=0.001,
max_iter=200, shuffle=True, random_state=42,
verbose=True, early_stopping=True, validation_fraction=0.1,
n_iter_no_change=20) # Increased dropout rate
# mlp_classifier = MLPClassifier(random_state=1, max_iter=300)
# Train the classifier
mlp_classifier.fit(X_train, y_train)
# Evaluate the classifier
train_accuracy = accuracy_score(y_train, mlp_classifier.predict(X_train))
val_accuracy = accuracy_score(y_val, mlp_classifier.predict(X_val))
test_accuracy = accuracy_score(y_test, mlp_classifier.predict(X_test))
print(f"Training Accuracy: {train_accuracy}")
print(f"Validation Accuracy: {val_accuracy}")
print(f"Test Accuracy: {test_accuracy}")
# Full predictions on test data
y_pred = mlp_classifier.predict(X_test)
import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import accuracy_score
epochs=1000
# Convert data to PyTorch tensors
X_train_tensor = torch.tensor(X_train, dtype=torch.float32).cuda()
y_train_tensor = torch.tensor(y_train, dtype=torch.long).cuda()
X_val_tensor = torch.tensor(X_val, dtype=torch.float32).cuda()
y_val_tensor = torch.tensor(y_val, dtype=torch.long).cuda()
X_test_tensor = torch.tensor(X_test, dtype=torch.float32).cuda()
# Create DataLoader for training and validation data
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True)
val_dataset = TensorDataset(X_val_tensor, y_val_tensor)
val_loader = DataLoader(val_dataset, batch_size=64)
class MLP(nn.Module):
def __init__(self, dropout_rate=0.5):
super(MLP, self).__init__()
self.fc1 = nn.Linear(X_train.shape[1], 200)
self.fc2 = nn.Linear(200, 100)
self.fc3 = nn.Linear(100, len(np.unique(y_train)))
self.dropout = nn.Dropout(dropout_rate)
def forward(self, x):
x = F.relu(self.fc1(x))
x = self.dropout(x)
x = F.relu(self.fc2(x))
x = self.dropout(x)
x = self.fc3(x)
return x
# Initialize MLP model and move to CUDA
model = MLP(dropout_rate=0.5).cuda()
# Define loss function and optimizer
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=0.001) # Adding L2 regularization
# Training loop with early stopping
best_val_accuracy = 0.0
best_model_state_dict = None
patience = 10
for epoch in range(epochs):
model.train()
for inputs, labels in train_loader:
optimizer.zero_grad()
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()
# Evaluate on validation set
model.eval()
with torch.no_grad():
val_accuracy = 0.0
for inputs, labels in val_loader:
outputs = model(inputs)
val_accuracy += accuracy_score(labels.cpu(), torch.argmax(outputs, dim=1).cpu().numpy())
val_accuracy /= len(val_loader)
if val_accuracy > best_val_accuracy:
best_val_accuracy = val_accuracy
best_model_state_dict = model.state_dict()
patience = 10 # Reset patience if a new best validation accuracy is achieved
else:
patience -= 1
if patience == 0:
break
# Load the best model state dict
if best_model_state_dict is not None:
model.load_state_dict(best_model_state_dict)
# Evaluate the best model on test set
model.eval()
with torch.no_grad():
y_test_pred = torch.argmax(model(X_test_tensor), dim=1).cpu().numpy()
test_accuracy = accuracy_score(y_test, y_test_pred)
print(f"Test Accuracy: {test_accuracy}")
output_size = 5 # Example output size
hidden_images = [64] # Example hidden layer sizes
import torch
import torch.nn as nn
class SimpleClassifier(nn.Module):
def __init__(self, input_size, output_size, hidden_sizes=[64], dropout_prob=0.2):
super(SimpleClassifier, self).__init__()
self.fc_layers = self._create_fc_layers(input_size, hidden_sizes, dropout_prob)
self.output_layer = nn.Linear(hidden_sizes[-1], output_size)
def _create_fc_layers(self, input_size, hidden_sizes, dropout_prob):
layers = []
prev_size = input_size
for hidden_size in hidden_sizes:
layers.append(nn.Linear(prev_size, hidden_size))
layers.append(nn.ReLU())
layers.append(nn.Dropout(p=dropout_prob))
prev_size = hidden_size
return nn.Sequential(*layers)
def forward(self, x):
x = self.fc_layers(x)
x = self.output_layer(x)
return x
X_train_shape = X_train.shape
input_size = X_train_shape[1] # Input size based on the feature dimension
output_size = 5 # Example output size
hidden_sizes = [64] # Example hidden layer sizes
# Instantiate the model
classifier_model = SimpleClassifier(input_size, output_size, hidden_sizes)
# Forward pass
output = classifier_model(X_train_tensor)
print("Output shape:", output.shape) # Should be (7680, 5)
classifier_model
X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.long)
y_train_np = y_train.astype(int)
# Count occurrences of each class label
class_counts = np.bincount(y_train_np, minlength=5)
# Calculate class weights
total_samples = len(y_train_np)
num_classes = 5
class_weights = total_samples / (num_classes * class_counts)
class_weights = torch.tensor(class_weights, dtype=torch.float32)
class_weights
# Move data and model to CUDA if available
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
X_train_tensor = X_train_tensor.to(device)
y_train_tensor = y_train_tensor.to(device)
class_weights = class_weights.to(device)
classifier_model = SimpleClassifier(input_size, output_size, hidden_sizes)
classifier_model = classifier_model.to(device)
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader, TensorDataset
from sklearn.metrics import f1_score, precision_score, accuracy_score, recall_score, fbeta_score
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
# Define your SimpleClassifier class here (same as before)
# Assuming you have X_train and y_train as your training data
# Preprocess the data (scaling)
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_val_scaled = scaler.transform(X_val)
# Convert them to PyTorch tensors
X_train_tensor = torch.tensor(X_train_scaled, dtype=torch.float32)
y_train_tensor = torch.tensor(y_train, dtype=torch.long)
X_val_tensor = torch.tensor(X_val_scaled, dtype=torch.float32)
y_val_tensor = torch.tensor(y_val, dtype=torch.long)
# Define batch size and create DataLoader
batch_size = 64
train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
# Instantiate the model
classifier_model = SimpleClassifier(input_size=X_train.shape[1], output_size=output_size, hidden_sizes=hidden_sizes)
classifier_model = classifier_model.to(device)
# Define loss function
criterion = nn.CrossEntropyLoss()
# Define optimizer
optimizer = optim.Adam(classifier_model.parameters(), lr=0.001)
# Lists to store metrics for plotting
train_loss_history = []
val_loss_history = []
f1_score_history = []
precision_history = []
accuracy_history = []
# Initialize patience counter
patience = 50 # Adjust this value as needed
# Initialize variable to track epochs since last improvement
epochs_since_last_improvement = 0
# Training loop
num_epochs = 10
best_val_loss = float('inf')
for epoch in range(num_epochs):
classifier_model.train() # Set the model to training mode
total_train_loss = 0.0
for inputs, labels in train_loader:
inputs, labels = inputs.to(device), labels.to(device)
optimizer.zero_grad() # Zero the gradients
outputs = classifier_model(inputs) # Forward pass
loss = criterion(outputs, labels) # Calculate the loss
total_train_loss += loss.item() * inputs.size(0)
loss.backward() # Backward pass
optimizer.step() # Update weights
# Calculate average training loss for the epoch
average_train_loss = total_train_loss / len(train_loader.dataset)
train_loss_history.append(average_train_loss)
# Evaluate on validation set
classifier_model.eval() # Set the model to evaluation mode
with torch.no_grad():
val_outputs = classifier_model(X_val_tensor.to(device))
val_loss = criterion(val_outputs, y_val_tensor.to(device))
val_loss_history.append(val_loss.item())
# Get predictions for validation data
val_predictions = val_outputs.argmax(dim=1)
y_val_np = y_val_tensor.cpu().numpy()
val_predictions_np = val_predictions.cpu().numpy()
# Calculate evaluation metrics
f1 = f1_score(y_val_np, val_predictions_np, average='weighted')
precision = precision_score(y_val_np, val_predictions_np, average='weighted')
accuracy = accuracy_score(y_val_np, val_predictions_np)
f1_score_history.append(f1)
precision_history.append(precision)
accuracy_history.append(accuracy)
# Print average loss and evaluation metrics for the epoch
print(f"Epoch [{epoch+1}/{num_epochs}], Train Loss: {average_train_loss:.4f}, "
f"Val Loss: {val_loss.item():.4f}, F1 Score: {f1:.4f}, Precision: {precision:.4f}, "
f"Accuracy: {accuracy:.4f}")
# Check for early stopping
if val_loss.item() < best_val_loss:
best_val_loss = val_loss.item()
epochs_since_last_improvement = 0 # Reset counter
else:
epochs_since_last_improvement += 1
if epochs_since_last_improvement >= patience:
print("Early stopping at epoch:", epoch)
break
# Plot training and validation loss
plt.plot(train_loss_history, label='Training Loss')
plt.plot(val_loss_history, label='Validation Loss')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.title('Training and Validation Loss')
plt.legend()
plt.show()
# Plot evaluation metrics
plt.plot(f1_score_history, label='F1 Score')
plt.plot(precision_history, label='Precision')
plt.plot(accuracy_history, label='Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Score')
plt.title('Evaluation Metrics')
plt.legend()
plt.show()
|
https://github.com/JavaFXpert/think2020
|
JavaFXpert
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Create a quantum circuit containing three quantum bits, and three classical bits to hold measurement results.
# REPLACE THIS WITH CODE
# REPLACE THIS WITH CODE
def answer(result):
for key in result.keys():
state = key
print('The Quantum 8-ball says:')
if state == '000':
print('It is certain.')
elif state == '001':
print('Without a doubt.')
elif state == '010':
print('Yes - definitely.')
elif state == '011':
print('Most likely.')
elif state == '100':
print("Don't count on it.")
elif state == '101':
print('My reply is no.')
elif state == '110':
print('Very doubtful.')
else:
print('Concentrate and ask again.')
job = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots=1)
counts = job.result().get_counts(qc)
answer(counts)
from qiskit.quantum_info import Statevector
# REPLACE THIS WITH CODE THAT USES THE from_instruction()
# AND sample_counts() METHODS OF THE Statevector class
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests for the wrapper functionality."""
import os
import sys
import unittest
from qiskit.utils import optionals
from qiskit.test import Path, QiskitTestCase, slow_test
# Timeout (in seconds) for a single notebook.
TIMEOUT = 1000
# Jupyter kernel to execute the notebook in.
JUPYTER_KERNEL = "python3"
@unittest.skipUnless(optionals.HAS_IBMQ, "requires IBMQ provider")
@unittest.skipUnless(optionals.HAS_JUPYTER, "involves running Jupyter notebooks")
class TestJupyter(QiskitTestCase):
"""Notebooks test case."""
def setUp(self):
super().setUp()
self.execution_path = os.path.join(Path.SDK.value, "..")
self.notebook_dir = os.path.join(
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
"notebooks",
)
def _execute_notebook(self, filename):
import nbformat
from nbconvert.preprocessors import ExecutePreprocessor
# Create the preprocessor.
execute_preprocessor = ExecutePreprocessor(timeout=TIMEOUT, kernel_name=JUPYTER_KERNEL)
# Read the notebook.
with open(filename) as file_:
notebook = nbformat.read(file_, as_version=4)
top_str = """
import qiskit
import qiskit.providers.ibmq
import sys
from unittest.mock import create_autospec, MagicMock
from qiskit.providers.fake_provider import FakeProviderFactory
from qiskit.providers import basicaer
fake_prov = FakeProviderFactory()
qiskit.IBMQ = fake_prov
ibmq_mock = create_autospec(basicaer)
ibmq_mock.IBMQJobApiError = MagicMock()
sys.modules['qiskit.providers.ibmq'] = ibmq_mock
sys.modules['qiskit.providers.ibmq.job'] = ibmq_mock
sys.modules['qiskit.providers.ibmq.job.exceptions'] = ibmq_mock
"""
top = nbformat.notebooknode.NotebookNode(
{
"cell_type": "code",
"execution_count": 0,
"metadata": {},
"outputs": [],
"source": top_str,
}
)
notebook.cells = [top] + notebook.cells
# Run the notebook into the folder containing the `qiskit/` module.
execute_preprocessor.preprocess(notebook, {"metadata": {"path": self.execution_path}})
@unittest.skipIf(
sys.platform != "linux",
"Fails with Python >=3.8 on osx and windows",
)
def test_jupyter_jobs_pbars(self):
"""Test Jupyter progress bars and job status functionality"""
self._execute_notebook(os.path.join(self.notebook_dir, "test_pbar_status.ipynb"))
@unittest.skipIf(not optionals.HAS_MATPLOTLIB, "matplotlib not available.")
@slow_test
def test_backend_tools(self):
"""Test Jupyter backend tools."""
self._execute_notebook(os.path.join(self.notebook_dir, "test_backend_tools.ipynb"))
if __name__ == "__main__":
unittest.main(verbosity=2)
|
https://github.com/QPower-Research/QPowerAlgo
|
QPower-Research
|
my_list = [1, 3, 5, 2, 4, 9, 5, 8, 0, 7, 6]
def the_oracle(my_input):
winner = 7
return my_input == winner
for index, trial_number in enumerate(my_list):
if the_oracle(trial_number):
print(f"Found the winner at index {index}!")
print(f"{index+1} calls made")
break
from qiskit import *
from qiskit.visualization import plot_histogram, array_to_latex
from qiskit.providers.ibmq import least_busy
import matplotlib.pyplot as plt
import numpy as np
grover_circuit = QuantumCircuit(2)
def init_state(qc, qubits):
for q in qubits:
qc.h(q)
return qc
grover_circuit = init_state(grover_circuit, [0, 1])
grover_circuit.draw("mpl")
#define the oracle circuit
def oracle(qc, qubits):
qc.cz(qubits[0], qubits[1])
qc = QuantumCircuit(2)
oracle(qc, [0, 1])
qc.draw("mpl")
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
array_to_latex(unitary, prefix="\\text{One can see that only the state }\ket{11}\\text{ has been flipped: }\n")
def diffusion(qc, qubits):
qc.h([0, 1])
qc.z([0, 1])
qc.cz(0, 1)
qc.h([0, 1])
grover_circuit.barrier()
oracle(grover_circuit, [0, 1])
grover_circuit.barrier()
diffusion(grover_circuit, [0, 1])
grover_circuit.measure_all()
grover_circuit.draw("mpl")
# Let's see if the final statevector matches our expectations
sv_sim = Aer.get_backend('statevector_simulator')
result = sv_sim.run(grover_circuit).result()
statevec = result.get_statevector()
statevec
aer_sim = Aer.get_backend('aer_simulator')
result = execute(grover_circuit, aer_sim, shots=1024).result()
result.get_counts()
# Load IBM Q account and get the least busy backend device
# Run the following line with your API token to use IBM's own quantum computers
#IBMQ.save_account('')
provider = IBMQ.load_account()
provider = IBMQ.get_provider("ibm-q")
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 our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_grover_circuit = transpile(grover_circuit, device, optimization_level=3)
job = device.run(transpiled_grover_circuit)
job_monitor(job, interval=2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
grover_circuit = QuantumCircuit(3)
grover_circuit = init_state(grover_circuit, [0, 1, 2])
grover_circuit.draw("mpl")
oracle_qc = QuantumCircuit(3)
oracle_qc.cz(0, 1)
oracle_qc.cz(0, 2)
oracle_gate = oracle_qc.to_gate()
oracle_gate.name = "U$_\omega$"
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> -> |11..1>
for qubit in range(nqubits):
qc.h(qubit)
qc.x(qubit)
# When these are combined, they function as a multi-controlled Z gate
# A negative phase is added to |11..1> to flip the state
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0> -> |s>
for qubit in range(nqubits):
qc.x(qubit)
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
num_qubits = 3
grover_circuit = QuantumCircuit(num_qubits)
grover_circuit = init_state(grover_circuit, [0, 1, 2])
grover_circuit.barrier()
grover_circuit.append(oracle_gate, [0, 1, 2])
grover_circuit.barrier()
grover_circuit.append(diffuser(num_qubits), [0, 1, 2])
grover_circuit.measure_all()
grover_circuit.draw("mpl")
qasm_sim = Aer.get_backend('qasm_simulator')
transpiled_grover_circuit = transpile(grover_circuit, qasm_sim)
results = qasm_sim.run(transpiled_grover_circuit).result()
counts = results.get_counts()
plot_histogram(counts)
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
transpiled_grover_circuit = transpile(grover_circuit, device, optimization_level=3)
job = device.run(transpiled_grover_circuit)
job_monitor(job, interval=2)
# Get the results from the computation
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
|
https://github.com/mmetcalf14/Hamiltonian_Downfolding_IBM
|
mmetcalf14
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Controlled-Hadamard (ch) Gate.
"""
import logging
from math import pi
from qiskit import QuantumCircuit
from qiskit.aqua import AquaError
from qiskit.aqua.utils.circuit_utils import is_qubit
logger = logging.getLogger(__name__)
def ch(self, q_control, q_target):
"""
Apply Controlled-Hadamard (ch) Gate.
Note that this implementation of the ch uses a single cx gate,
which is more efficient than what's currently provided in Terra.
Args:
self (QuantumCircuit): The circuit to apply the ch gate on.
q_control ((QuantumRegister, int)): The control qubit.
q_target ((QuantumRegister, int)): The target qubit.
"""
if not is_qubit(q_control):
raise AquaError('A qubit is expected for the control.')
if not self.has_register(q_control[0]):
raise AquaError('The control qubit is expected to be part of the circuit.')
if not is_qubit(q_target):
raise AquaError('A qubit is expected for the target.')
if not self.has_register(q_target[0]):
raise AquaError('The target qubit is expected to be part of the circuit.')
if q_control == q_target:
raise AquaError('The control and target need to be different qubits.')
self.u3(-7 / 4 * pi, 0, 0, q_target)
self.cx(q_control, q_target)
self.u3(7 / 4 * pi, 0, 0, q_target)
return self
QuantumCircuit.ch = ch
|
https://github.com/DLR-RB/QUEASARS
|
DLR-RB
|
from pathlib import Path
import os
import sys
main_directory = Path(os.path.abspath("")).parent
sys.path.append(str(main_directory))
from queasars.job_shop_scheduling.problem_instances import Machine, Operation, Job, JobShopSchedulingProblemInstance
machines = (Machine(name="m0"), Machine(name="m1"), Machine("m2"))
j0op1 = Operation(name="j0op0", machine=machines[2], processing_duration=1, job_name="j0")
j0op2 = Operation(name="j0op1", machine=machines[0], processing_duration=1, job_name="j0")
j0op3 = Operation(name="j0op2", machine=machines[1], processing_duration=2, job_name="j0")
job0 = Job(name="j0", operations=(j0op1, j0op2, j0op3))
j1op1 = Operation(name="j1op1", machine=machines[2], processing_duration=2, job_name="j1")
j1op2 = Operation(name="j1op2", machine=machines[0], processing_duration=1, job_name="j1")
j1op3 = Operation(name="j1op3", machine=machines[1], processing_duration=1, job_name="j1")
job1 = Job(name="j1", operations=(j1op1, j1op2, j1op3))
jssp_instance = JobShopSchedulingProblemInstance(name="2_jobs_3_machines_seed_121", machines=machines, jobs=(job0, job1))
from queasars.job_shop_scheduling.visualization import plot_jssp_problem_instance_gantt
plot = plot_jssp_problem_instance_gantt(problem_instance=jssp_instance)
from queasars.job_shop_scheduling.domain_wall_hamiltonian_encoder import JSSPDomainWallHamiltonianEncoder
encoder = JSSPDomainWallHamiltonianEncoder(jssp_instance=jssp_instance, makespan_limit=6, max_opt_value=100, opt_all_operations_share=0.19, encoding_penalty=319, overlap_constraint_penalty=319, precedence_constraint_penalty=275)
print("needed qubits: ", encoder.n_qubits)
hamiltonian = encoder.get_problem_hamiltonian()
from qiskit_aer.primitives import Sampler
from qiskit_algorithms.optimizers import SPSA
from dask.distributed import LocalCluster
from queasars.minimum_eigensolvers.base.termination_criteria import BestIndividualRelativeChangeTolerance
from queasars.utility.spsa_termination import SPSATerminationChecker
from queasars.minimum_eigensolvers.evqe.evqe import EVQEMinimumEigensolverConfiguration
# The EVQEMinimumEigensolver needs at least a sampler and can also use an estimator.
# Here we only use a sampler, as the Critical Value at Risk objective value can
# can only be used when only using the sampler.
sampler_primitive = Sampler()
estimator_primitive = None
# If only a sampler is used, the expectation value with respect to the Hamiltonian
# is calculated using the measurement distribution provided by the sampler. This
# expectation value can also be calculated over only the lower tail of that distribution.
# In that case the objective score is also called the Critical Value at Risk.
distribution_alpha_tail = 0.5
# The EVQEMinimumEigensolver also needs a qiskit optimizer. It should be
# configured to terminate quickly, so that mutations are not overtly expensive.
# Here we use the SPSA optimizer with a very limited amount of iterations and a
# large step size.
termination_checker = SPSATerminationChecker(minimum_relative_change=0.01, allowed_consecutive_violations=2)
optimizer = SPSA(maxiter=33, perturbation=0.35, learning_rate=0.43, trust_region=True, last_avg=1, resamplings=1, termination_checker=termination_checker.termination_check)
# To help the EVQEMinimumEigensolver deal correctly with terminations based
# on the amount of circuit evaluations used, an estimate can be given for how
# many circuit evaluations the optimizer uses per optimization run.
# SPSA makes two measurements per gradient approximation, which means in total it will
# need 66 circuit evaluations for 33 iterations.
optimizer_n_circuit_evaluations = 66
# To specify when the EVQEMinimumEigensolver should terminate either max_generations,
# max_circuit_evaluations or a termination_criterion should be given.
max_generations = None
max_circuit_evaluations = None
termination_criterion = BestIndividualRelativeChangeTolerance(minimum_relative_change=0.01, allowed_consecutive_violations=1)
# A random seed can be provided to control the randomness of the evolutionary process.
random_seed = None
# The population size determines how many individuals are evaluated each generation.
# With a higher population size, fewer generations might be needed, but this also
# makes each generation more expensive to evaluate. A reasonable range might be
# 10 - 100 individuals per population.
population_size = 10
# The initial individuals in the starting population can be initialized with
# an arbitrary amount of layers and fully randomized parameter values. This
# can be particularly useful if the state |0 .. 0> is a local minima and
# the individuals should not start in that state
n_initial_layers = 2
randomize_initial_parameter_values = True
# Determines how many circuit layers apart two individuals need to be, to be considered to
# be of a different species. Reasonable values might be in the range 1 - 5.
speciation_genetic_distance_threshold = 1
# This implementation of EVQE offers both roulette wheel selection and tournament selection.
# Since tournament selection is more robust, we use it here.
use_tournament_selection = True
tournament_size = 2
# The alpha and beta penalties penalize quantum circuits of increasing depth (alpha) and
# increasing amount of controlled rotations (beta). increase them if the quantum circuits get to
# deep or complicated.
selection_alpha_penalty = 0.15
selection_beta_penalty = 0.02
# The parameter search probability determines how likely an individual is mutated by optimizing
# all it's parameter values. This should not be too large as this is costly.
parameter_search_probability = 0.39
# The topological search probability determines how likely a circuit layer is added to an individual
# as a mutation.
topological_search_probability = 0.79
# The layer removal probability determines how likely circuit layers are removed from an individual
# as a mutation. This is a very disruptive mutation and should only be used sparingly to counteract
# circuit growth.
layer_removal_probability = 0.02
# An executor for launching parallel computation can be specified.
# This can be a dask Client or a python ThreadPoolExecutor. If None is
# specified a ThreadPoolExecutor with population_size many threads will
# be used
parallel_executor = LocalCluster(n_workers=10, processes=True, threads_per_worker=1).get_client()
# Discerns whether to only allow mutually exclusive access to the Sampler and
# Estimator primitive respectively. This is needed if the Sampler or Estimator are not threadsafe and
# a ThreadPoolExecutor with more than one thread or a Dask Client with more than one thread per process is used.
# For safety reasons this is enabled by default. If the sampler and estimator are threadsafe disabling this
# option may lead to performance improvements
mutually_exclusive_primitives = False
configuration = EVQEMinimumEigensolverConfiguration(
sampler=sampler_primitive,
estimator=estimator_primitive,
distribution_alpha_tail=distribution_alpha_tail,
optimizer=optimizer,
optimizer_n_circuit_evaluations=optimizer_n_circuit_evaluations,
max_generations=max_generations,
max_circuit_evaluations=max_circuit_evaluations,
termination_criterion=termination_criterion,
random_seed=random_seed,
population_size=population_size,
n_initial_layers=n_initial_layers,
randomize_initial_population_parameters=randomize_initial_parameter_values,
speciation_genetic_distance_threshold=speciation_genetic_distance_threshold,
use_tournament_selection=use_tournament_selection,
tournament_size=tournament_size,
selection_alpha_penalty=selection_alpha_penalty,
selection_beta_penalty=selection_beta_penalty,
parameter_search_probability=parameter_search_probability,
topological_search_probability=topological_search_probability,
layer_removal_probability=layer_removal_probability,
parallel_executor=parallel_executor,
mutually_exclusive_primitives=mutually_exclusive_primitives,
)
from queasars.minimum_eigensolvers.evqe.evqe import EVQEMinimumEigensolver
eigensolver = EVQEMinimumEigensolver(configuration=configuration)
import logging
logger = logging.getLogger("queasars.minimum_eigensolvers.base.evolving_ansatz_minimum_eigensolver")
handler = logging.StreamHandler()
logger.setLevel(logging.INFO)
logger.addHandler(handler)
result = eigensolver.compute_minimum_eigenvalue(operator=hamiltonian)
quasi_distribution = result.eigenstate.binary_probabilities()
from qiskit.visualization import plot_distribution
plot_distribution(quasi_distribution, number_to_keep=10)
solutions = []
for bitstring, probability in quasi_distribution.items():
if probability < 0.05:
continue
solution = encoder.translate_result_bitstring(bitstring=bitstring)
print("probability: ", probability, "is valid: ", solution.is_valid)
print(solution)
if solution.is_valid:
solutions.append(solution)
from queasars.job_shop_scheduling.visualization import plot_jssp_problem_solution_gantt
for solution in solutions:
plot = plot_jssp_problem_solution_gantt(result=solution)
|
https://github.com/Praween-em/QiskitBasics
|
Praween-em
|
from qiskit import Aer, QuantumCircuit, transpile, assemble, execute
from math import gcd
from numpy.random import randint
def a_mod_N(a, power, N, quantum_reg):
# Function to perform modular exponentiation using quantum gates
circuit = QuantumCircuit(quantum_reg, 1)
circuit.x(quantum_reg[0]) # Set the last qubit to |1>
circuit.h(quantum_reg[1]).c_if(quantum_reg[1], 1) # Conditional H gate
circuit.h(quantum_reg[0]).c_if(quantum_reg[0], 1) # Conditional H gate
circuit.x(quantum_reg[0]).c_if(quantum_reg[0], 1) # Conditional X gate
circuit.cx(quantum_reg[0], quantum_reg[1]) # Conditional CX gate
circuit.x(quantum_reg[0]).c_if(quantum_reg[0], 1) # Conditional X gate
circuit.x(quantum_reg[1]).c_if(quantum_reg[1], 1) # Conditional X gate
circuit.measure(quantum_reg[1], 0) # Measure the result
# Execute the quantum circuit on the simulator
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots=1).result()
outcome = int(result.get_counts().popitem()[0])
return outcome
def shors_algorithm_quantum(N):
a = randint(2, N) # Choose a random integer a between 2 and N-1
# Check if the chosen 'a' shares a non-trivial factor with N
if gcd(a, N) > 1:
return gcd(a, N)
r = 2 # Initialize a guess for the period
quantum_reg = QuantumCircuit(4, 2) # Quantum register with 4 qubits
# Modify the a_mod_N function to use the quantum version
while True:
outcome = a_mod_N(a, r, N, quantum_reg)
if outcome == 1:
break
r += 1
# ... (continue with the rest of the code)
# Test Shor's algorithm with a sample number N
N = 21
result = shors_algorithm_quantum(N)
print(f"Non-trivial factor of {N}: {result}")
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.