repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.timeline import draw
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc = transpile(qc, FakeBoeblingen(), scheduling_method='alap', layout_method='trivial')
draw(qc)
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
|
https://github.com/purvi1508/Quantum_Computing_Fundamentals
|
purvi1508
|
!pip install qiskit
!pip install pylatexenc
import qiskit
import pylatexenc
from qiskit import *
from pylatexenc import *
# Create a quantum circuit with three qubits
qc = QuantumCircuit(3, 3)
%matplotlib inline
qc.draw(initial_state = True)
# Create a Bell pair between qubits 1 and 2
qc.h(1)
qc.cx(1, 2)
# The Hadamard gate qc.h(1) is applied to qubit 1 to create a superposition, and the CNOT gate qc.cx(1, 2) is applied between qubits 1 and 2 to entangle them and create a Bell pair
qc.draw(initial_state = True)
# Entangle qubit 0 with qubit 1
qc.cx(0, 1)
qc.h(0)
qc.draw(initial_state = True)
# Apply a measurement to qubits 0 and 1
qc.barrier()
qc.measure([0,1], [0,1])
qc.draw(initial_state = True)
# Apply a controlled-X gate to qubits 1 and 2
qc.cx(1, 2)
qc.draw(initial_state = True)
# Apply a controlled-Z gate to qubits 0 and 2
qc.cz(0, 2)
qc.draw(initial_state = True)
# Apply a measurement to qubit 2
qc.measure(2, 2)
qc.draw(initial_state = True)
# Run the circuit on a simulator
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend).result()
# Print the result
print(result.get_counts(qc))
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=invalid-name
import itertools
import json
import numpy as np
from numpy.random import RandomState
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.compiler import transpile
from cvxopt import matrix, solvers # pylint: disable=import-error
from qtils.featuremap import FeatureMap
from qtils.qka import QKA
import os
import pandas as pd
def main(backend, user_messenger, **kwargs):
df = pd.read_csv(os.path.dirname(os.path.abspath(__file__)) + '/aux_file/dataset_graph7.csv',sep=',', header=None) # alterative problem: dataset_graph10.csv
data = df.values
# choose number of training and test samples per class:
num_train = 10
num_test = 10
# extract training and test sets and sort them by class label
train = data[:2*num_train, :]
test = data[2*num_train:2*(num_train+num_test), :]
ind=np.argsort(train[:,-1])
x_train = train[ind][:,:-1]
y_train = train[ind][:,-1]
ind=np.argsort(test[:,-1])
x_test = test[ind][:,:-1]
y_test = test[ind][:,-1]
C = 1
maxiters = 1
initial_point = [0.1]
initial_layout = [10, 11, 12, 13, 14, 15, 16] # see figure above for the 7-qubit graph
# initial_layout = [9, 8, 11, 14, 16, 19, 22, 25, 24, 23] # see figure above for the 10-qubit graph
d = np.shape(data)[1]-1 # feature dimension is twice the qubit number
em = [[0,2],[3,4],[2,5],[1,4],[2,3],[4,6]]
fm = FeatureMap(feature_dimension=d, entangler_map=em)
qka = QKA(
feature_map=fm,
backend=backend,
initial_layout=initial_layout,
user_messenger=user_messenger,
)
qka_results = qka.align_kernel(
data=x_train,
labels=y_train,
initial_kernel_parameters=initial_point,
maxiters=maxiters,
C=C,
)
user_messenger.publish(qka_results, final=True)
|
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/anpaschool/quantum-computing
|
anpaschool
|
from qiskit import *
from math import pi
import numpy as np
from qiskit.visualization import *
import matplotlib.pyplot as plt
from qutip import *
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[0])
qc.draw(output='mpl')
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
result = job.result()
print(result.get_unitary(qc, decimals=3))
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[1])
qc.draw(output='mpl')
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
result = job.result()
print(result.get_unitary(qc, decimals=3))
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[2])
qc.draw(output='mpl')
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
result = job.result()
print(result.get_unitary(qc, decimals=3))
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[0])
qc.u3(pi/2,pi/2,pi/2,q[1])
qc.draw(output='mpl')
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
result = job.result()
print(result.get_unitary(qc, decimals=3))
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[0])
qc.u3(pi/2,pi/2,pi/2,q[1])
qc.u3(pi/2,pi/2,pi/2,q[2])
qc.draw(output='mpl')
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
result = job.result()
print(result.get_unitary(qc, decimals=3))
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[0])
qc.u3(pi/2,pi/2,pi/2,q[0])
qc.u3(pi/4,pi/4,pi/4,q[1])
qc.u3(3*pi/4,3*pi/4,3*pi/4,q[1])
qc.u3(pi/6,pi/6,pi/6,q[2])
qc.u3(5*pi/6,5*pi/6,5*pi/6,q[2])
qc.draw(output='mpl')
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
result = job.result()
print(result.get_unitary(qc, decimals=3))
|
https://github.com/yaelbh/qiskit-sympy-provider
|
yaelbh
|
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
# pylint: disable=invalid-name,missing-docstring
from test.common import QiskitSympyTestCase
import unittest
from sympy import sqrt
from qiskit import (load_qasm_file, execute, QuantumRegister,
ClassicalRegister, QuantumCircuit, wrapper)
from qiskit_addon_sympy import SympyProvider
class SympyUnitarySimulatorTest(QiskitSympyTestCase):
"""Test local unitary simulator sympy."""
def setUp(self):
self.qasm_filename = self._get_resource_path('simple.qasm')
self.q_circuit = load_qasm_file(self.qasm_filename)
def test_unitary_simulator(self):
"""test generation of circuit unitary"""
SyQ = SympyProvider()
backend = SyQ.get_backend('unitary_simulator')
result = execute(self.q_circuit, backend).result()
actual = result.get_unitary(self.q_circuit)
self.assertEqual(actual[0][0], sqrt(2)/2)
self.assertEqual(actual[0][1], sqrt(2)/2)
self.assertEqual(actual[0][2], 0)
self.assertEqual(actual[0][3], 0)
self.assertEqual(actual[1][0], 0)
self.assertEqual(actual[1][1], 0)
self.assertEqual(actual[1][2], sqrt(2)/2)
self.assertEqual(actual[1][3], -sqrt(2)/2)
self.assertEqual(actual[2][0], 0)
self.assertEqual(actual[2][1], 0)
self.assertEqual(actual[2][2], sqrt(2)/2)
self.assertEqual(actual[2][3], sqrt(2)/2)
self.assertEqual(actual[3][0], sqrt(2)/2)
self.assertEqual(actual[3][1], -sqrt(2)/2)
self.assertEqual(actual[3][2], 0)
self.assertEqual(actual[3][3], 0)
class TestQobj(QiskitSympyTestCase):
"""Check the objects compiled for this backend create names properly"""
def setUp(self):
qr = QuantumRegister(2, name="qr2")
cr = ClassicalRegister(2, name=None)
qc = QuantumCircuit(qr, cr, name="qc10")
qc.h(qr[0])
qc.measure(qr[0], cr[0])
self.qr_name = qr.name
self.cr_name = cr.name
self.circuits = [qc]
def test_qobj_sympy_unitary_simulator(self):
SyQ = SympyProvider()
backend = SyQ.get_backend('unitary_simulator')
qobj = wrapper.compile(self.circuits, backend)
cc = qobj.experiments[0].as_dict()
ccq = qobj.experiments[0].header.compiled_circuit_qasm
self.assertIn(self.qr_name, map(lambda x: x[0], cc['header']['qubit_labels']))
self.assertIn(self.qr_name, ccq)
self.assertIn(self.cr_name, map(lambda x: x[0], cc['header']['clbit_labels']))
self.assertIn(self.cr_name, ccq)
if __name__ == '__main__':
unittest.main()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/hephaex/Quantum-Computing-Awesome-List
|
hephaex
|
from qiskit import QuantumCircuit
from qiskit.circuit import Gate
from math import pi
qc = QuantumCircuit(2)
c = 0
t = 1
qc = QuantumCircuit(2)
# a controlled-Y
qc.sdg(t)
qc.cx(c,t)
qc.s(t)
qc.draw()
qc = QuantumCircuit(2)
# also a controlled-Z
qc.h(t)
qc.cx(c,t)
qc.h(t)
qc.draw()
qc = QuantumCircuit(2)
# a controlled-H
qc.ry(pi/4,t)
qc.cx(c,t)
qc.ry(-pi/4,t)
qc.draw()
#Controlled Rotations
qc = QuantumCircuit(2)
theta = pi # theta can be anything (pi chosen arbitrarily)
qc.ry(theta/2,t)
qc.cx(c,t)
qc.ry(-theta/2,t)
qc.cx(c,t)
qc.draw()
|
https://github.com/ggridin/QiskitTests
|
ggridin
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer
from qiskit.extensions import Initialize
from qiskit.quantum_info import random_statevector, Statevector,partial_trace
def trace01(out_vector):
return Statevector([sum([out_vector[i] for i in range(0,4)]), sum([out_vector[i] for i in range(4,8)])])
def teleportation():
# Create random 1-qubit state
psi = random_statevector(2)
print(psi)
init_gate = Initialize(psi)
init_gate.label = "init"
## SETUP
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical registers
crx = ClassicalRegister(1, name="crx")
qc = QuantumCircuit(qr, crz, crx)
# Don't modify the code above
## Put your code below
# ----------------------------
qc.initialize(psi, qr[0])
qc.h(qr[1])
qc.cx(qr[1],qr[2])
qc.cx(qr[0],qr[1])
qc.h(qr[0])
qc.measure(qr[0],crz[0])
qc.measure(qr[1],crx[0])
qc.x(qr[2]).c_if(crx[0], 1)
qc.z(qr[2]).c_if(crz[0], 1)
# ----------------------------
# Don't modify the code below
sim = Aer.get_backend('aer_simulator')
qc.save_statevector()
out_vector = sim.run(qc).result().get_statevector()
result = trace01(out_vector)
return psi, result
# (psi,res) = teleportation()
# print(psi)
# print(res)
# if psi == res:
# print('1')
# else:
# print('0')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
import matplotlib.pyplot as plt
try:
import cplex
from cplex.exceptions import CplexError
except:
print("Warning: Cplex not found.")
import math
from qiskit.utils import algorithm_globals
from qiskit.algorithms.minimum_eigensolvers import SamplingVQE
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import Sampler
# Initialize the problem by defining the parameters
n = 3 # number of nodes + depot (n+1)
K = 2 # number of vehicles
# Get the data
class Initializer:
def __init__(self, n):
self.n = n
def generate_instance(self):
n = self.n
# np.random.seed(33)
np.random.seed(1543)
xc = (np.random.rand(n) - 0.5) * 10
yc = (np.random.rand(n) - 0.5) * 10
instance = np.zeros([n, n])
for ii in range(0, n):
for jj in range(ii + 1, n):
instance[ii, jj] = (xc[ii] - xc[jj]) ** 2 + (yc[ii] - yc[jj]) ** 2
instance[jj, ii] = instance[ii, jj]
return xc, yc, instance
# Initialize the problem by randomly generating the instance
initializer = Initializer(n)
xc, yc, instance = initializer.generate_instance()
class ClassicalOptimizer:
def __init__(self, instance, n, K):
self.instance = instance
self.n = n # number of nodes
self.K = K # number of vehicles
def compute_allowed_combinations(self):
f = math.factorial
return f(self.n) / f(self.K) / f(self.n - self.K)
def cplex_solution(self):
# refactoring
instance = self.instance
n = self.n
K = self.K
my_obj = list(instance.reshape(1, n**2)[0]) + [0.0 for x in range(0, n - 1)]
my_ub = [1 for x in range(0, n**2 + n - 1)]
my_lb = [0 for x in range(0, n**2)] + [0.1 for x in range(0, n - 1)]
my_ctype = "".join(["I" for x in range(0, n**2)]) + "".join(
["C" for x in range(0, n - 1)]
)
my_rhs = (
2 * ([K] + [1 for x in range(0, n - 1)])
+ [1 - 0.1 for x in range(0, (n - 1) ** 2 - (n - 1))]
+ [0 for x in range(0, n)]
)
my_sense = (
"".join(["E" for x in range(0, 2 * n)])
+ "".join(["L" for x in range(0, (n - 1) ** 2 - (n - 1))])
+ "".join(["E" for x in range(0, n)])
)
try:
my_prob = cplex.Cplex()
self.populatebyrow(my_prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs)
my_prob.solve()
except CplexError as exc:
print(exc)
return
x = my_prob.solution.get_values()
x = np.array(x)
cost = my_prob.solution.get_objective_value()
return x, cost
def populatebyrow(self, prob, my_obj, my_ub, my_lb, my_ctype, my_sense, my_rhs):
n = self.n
prob.objective.set_sense(prob.objective.sense.minimize)
prob.variables.add(obj=my_obj, lb=my_lb, ub=my_ub, types=my_ctype)
prob.set_log_stream(None)
prob.set_error_stream(None)
prob.set_warning_stream(None)
prob.set_results_stream(None)
rows = []
for ii in range(0, n):
col = [x for x in range(0 + n * ii, n + n * ii)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
for ii in range(0, n):
col = [x for x in range(0 + ii, n**2, n)]
coef = [1 for x in range(0, n)]
rows.append([col, coef])
# Sub-tour elimination constraints:
for ii in range(0, n):
for jj in range(0, n):
if (ii != jj) and (ii * jj > 0):
col = [ii + (jj * n), n**2 + ii - 1, n**2 + jj - 1]
coef = [1, 1, -1]
rows.append([col, coef])
for ii in range(0, n):
col = [(ii) * (n + 1)]
coef = [1]
rows.append([col, coef])
prob.linear_constraints.add(lin_expr=rows, senses=my_sense, rhs=my_rhs)
# Instantiate the classical optimizer class
classical_optimizer = ClassicalOptimizer(instance, n, K)
# Print number of feasible solutions
print("Number of feasible solutions = " + str(classical_optimizer.compute_allowed_combinations()))
# Solve the problem in a classical fashion via CPLEX
x = None
z = None
try:
x, classical_cost = classical_optimizer.cplex_solution()
# Put the solution in the z variable
z = [x[ii] for ii in range(n**2) if ii // n != ii % n]
# Print the solution
print(z)
except:
print("CPLEX may be missing.")
# Visualize the solution
def visualize_solution(xc, yc, x, C, n, K, title_str):
plt.figure()
plt.scatter(xc, yc, s=200)
for i in range(len(xc)):
plt.annotate(i, (xc[i] + 0.15, yc[i]), size=16, color="r")
plt.plot(xc[0], yc[0], "r*", ms=20)
plt.grid()
for ii in range(0, n**2):
if x[ii] > 0:
ix = ii // n
iy = ii % n
plt.arrow(
xc[ix],
yc[ix],
xc[iy] - xc[ix],
yc[iy] - yc[ix],
length_includes_head=True,
head_width=0.25,
)
plt.title(title_str + " cost = " + str(int(C * 100) / 100.0))
plt.show()
if x is not None:
visualize_solution(xc, yc, x, classical_cost, n, K, "Classical")
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
class QuantumOptimizer:
def __init__(self, instance, n, K):
self.instance = instance
self.n = n
self.K = K
def binary_representation(self, x_sol=0):
instance = self.instance
n = self.n
K = self.K
A = np.max(instance) * 100 # A parameter of cost function
# Determine the weights w
instance_vec = instance.reshape(n**2)
w_list = [instance_vec[x] for x in range(n**2) if instance_vec[x] > 0]
w = np.zeros(n * (n - 1))
for ii in range(len(w_list)):
w[ii] = w_list[ii]
# Some variables I will use
Id_n = np.eye(n)
Im_n_1 = np.ones([n - 1, n - 1])
Iv_n_1 = np.ones(n)
Iv_n_1[0] = 0
Iv_n = np.ones(n - 1)
neg_Iv_n_1 = np.ones(n) - Iv_n_1
v = np.zeros([n, n * (n - 1)])
for ii in range(n):
count = ii - 1
for jj in range(n * (n - 1)):
if jj // (n - 1) == ii:
count = ii
if jj // (n - 1) != ii and jj % (n - 1) == count:
v[ii][jj] = 1.0
vn = np.sum(v[1:], axis=0)
# Q defines the interactions between variables
Q = A * (np.kron(Id_n, Im_n_1) + np.dot(v.T, v))
# g defines the contribution from the individual variables
g = (
w
- 2 * A * (np.kron(Iv_n_1, Iv_n) + vn.T)
- 2 * A * K * (np.kron(neg_Iv_n_1, Iv_n) + v[0].T)
)
# c is the constant offset
c = 2 * A * (n - 1) + 2 * A * (K**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
def construct_problem(self, Q, g, c) -> QuadraticProgram:
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
def solve_problem(self, qp):
algorithm_globals.random_seed = 10598
vqe = SamplingVQE(sampler=Sampler(), optimizer=SPSA(), ansatz=RealAmplitudes())
optimizer = MinimumEigenOptimizer(min_eigen_solver=vqe)
result = optimizer.solve(qp)
# compute cost of the obtained result
_, _, _, level = self.binary_representation(x_sol=result.x)
return result.x, level
# Instantiate the quantum optimizer class with parameters:
quantum_optimizer = QuantumOptimizer(instance, n, K)
# Check if the binary representation is correct
try:
if z is not None:
Q, g, c, binary_cost = quantum_optimizer.binary_representation(x_sol=z)
print("Binary cost:", binary_cost, "classical cost:", classical_cost)
if np.abs(binary_cost - classical_cost) < 0.01:
print("Binary formulation is correct")
else:
print("Error in the binary formulation")
else:
print("Could not verify the correctness, due to CPLEX solution being unavailable.")
Q, g, c, binary_cost = quantum_optimizer.binary_representation()
print("Binary cost:", binary_cost)
except NameError as e:
print("Warning: Please run the cells above first.")
print(e)
qp = quantum_optimizer.construct_problem(Q, g, c)
quantum_solution, quantum_cost = quantum_optimizer.solve_problem(qp)
print(quantum_solution, quantum_cost)
# Put the solution in a way that is compatible with the classical variables
x_quantum = np.zeros(n**2)
kk = 0
for ii in range(n**2):
if ii // n != ii % n:
x_quantum[ii] = quantum_solution[kk]
kk += 1
# visualize the solution
visualize_solution(xc, yc, x_quantum, quantum_cost, n, K, "Quantum")
# and visualize the classical for comparison
if x is not None:
visualize_solution(xc, yc, x, classical_cost, n, K, "Classical")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/vm6502q/qiskit-qrack-provider
|
vm6502q
|
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
"""
QasmSimulator Integration Tests
"""
import json
from qiskit import execute, QuantumRegister, ClassicalRegister, QuantumCircuit, Aer
from qiskit.providers.qrack import QasmSimulator
from qiskit.providers.aer import noise
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors import ReadoutError, depolarizing_error
from qiskit.providers.models import BackendProperties
class QasmQubitsTruncateTests:
"""QasmSimulator Qubits Truncate tests."""
SIMULATOR = QasmSimulator()
def create_circuit_for_truncate(self):
qr = QuantumRegister(4)
cr = ClassicalRegister(4)
circuit = QuantumCircuit(qr, cr)
circuit.u3(0.1,0.1,0.1,qr[1])
circuit.barrier(qr)
circuit.x(qr[2])
circuit.barrier(qr)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.x(qr[3])
circuit.barrier(qr)
circuit.u3(0.1,0.1,0.1,qr[0])
circuit.barrier(qr)
circuit.measure(qr[0], cr[0])
circuit.measure(qr[1], cr[1])
return circuit
def device_properties(self):
properties = {"general": [],
"last_update_date": "2019-04-22T03:26:08+00:00",
"gates": [
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [0]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [0]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [0]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [1]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [1]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [1]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [2]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [2]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [2]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [3]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [3]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [3]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [4]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [4]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [4]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [5]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [5]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [5]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [6]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [6]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [6]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [7]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [7]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [7]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [8]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [8]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [8]},
{"gate": "u1", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [9]},
{"gate": "u2", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [9]},
{"gate": "u3", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-23T01:45:04+00:00", "unit": ""}], "qubits": [9]},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:26:00+00:00", "unit": ""}], "qubits": [0, 1], "name": "CX0_1"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:29:15+00:00", "unit": ""}], "qubits": [1, 2], "name": "CX1_2"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:32:48+00:00", "unit": ""}], "qubits": [2, 3], "name": "CX2_3"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:26:00+00:00", "unit": ""}], "qubits": [3, 4], "name": "CX3_4"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:29:15+00:00", "unit": ""}], "qubits": [4, 5], "name": "CX4_5"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:32:48+00:00", "unit": ""}], "qubits": [5, 6], "name": "CX5_6"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:26:00+00:00", "unit": ""}], "qubits": [6, 7], "name": "CX6_7"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:29:15+00:00", "unit": ""}], "qubits": [7, 8], "name": "CX7_8"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:32:48+00:00", "unit": ""}], "qubits": [8, 9], "name": "CX8_9"},
{"gate": "cx", "parameters": [{"name": "gate_error", "value": 0.001, "date": "2019-04-22T02:26:00+00:00", "unit": ""}], "qubits": [9, 0], "name": "CX9_0"}],
"qubits": [
[
{"name": "T1", "value": 23.809868955712616, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 43.41142418044261, "date": "2019-04-22T01:33:33+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 5.032871440179164, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.03489999999999993, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
[
{"name": "T1", "value": 68.14048367144501, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 56.95903203933663, "date": "2019-04-22T01:34:36+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 4.896209948700639, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.19589999999999996, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
[
{"name": "T1", "value": 83.26776276928099, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 23.49615795695734, "date": "2019-04-22T01:31:32+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 5.100093544085939, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.09050000000000002, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
[
{"name": "T1", "value": 57.397746445609975, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 98.47976889309517, "date": "2019-04-22T01:32:32+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 5.238526396839902, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.24350000000000005, "date": "2019-04-20T15:31:39+00:00", "unit": ""}],
[
{"name": "T1", "value": 23.809868955712616, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 43.41142418044261, "date": "2019-04-22T01:33:33+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 5.032871440179164, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.03489999999999993, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
[
{"name": "T1", "value": 68.14048367144501, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 56.95903203933663, "date": "2019-04-22T01:34:36+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 4.896209948700639, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.19589999999999996, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
[
{"name": "T1", "value": 83.26776276928099, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 23.49615795695734, "date": "2019-04-22T01:31:32+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 5.100093544085939, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.09050000000000002, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
[
{"name": "T1", "value": 57.397746445609975, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 98.47976889309517, "date": "2019-04-22T01:32:32+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 5.238526396839902, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.24350000000000005, "date": "2019-04-20T15:31:39+00:00", "unit": ""}],
[
{"name": "T1", "value": 23.809868955712616, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 43.41142418044261, "date": "2019-04-22T01:33:33+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 5.032871440179164, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.03489999999999993, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
[
{"name": "T1", "value": 68.14048367144501, "date": "2019-04-22T01:30:15+00:00", "unit": "\u00b5s"},
{"name": "T2", "value": 56.95903203933663, "date": "2019-04-22T01:34:36+00:00", "unit": "\u00b5s"},
{"name": "frequency", "value": 4.896209948700639, "date": "2019-04-22T03:26:08+00:00", "unit": "GHz"},
{"name": "readout_error", "value": 0.19589999999999996, "date": "2019-04-22T01:29:47+00:00", "unit": ""}],
],
"backend_name": "mock_4q",
"backend_version": "1.0.0"}
return BackendProperties.from_dict(properties)
def test_truncate_ideal_sparse_circuit(self):
"""Test qubit truncation for large circuit with unused qubits."""
# Circuit that uses just 2-qubits
circuit = QuantumCircuit(50, 2)
circuit.x(10)
circuit.x(20)
circuit.measure(10, 0)
circuit.measure(20, 1)
qasm_sim = Aer.get_backend('qasm_simulator')
backend_options = self.BACKEND_OPTS.copy()
backend_options["truncate_verbose"] = True
backend_options['optimize_ideal_threshold'] = 1
backend_options['optimize_noise_threshold'] = 1
result = execute(circuit,
qasm_sim,
shots=100,
**backend_options).result()
metadata = result.results[0].metadata
self.assertTrue('truncate_qubits' in metadata, msg="truncate_qubits must work.")
active_qubits = sorted(metadata['truncate_qubits'].get('active_qubits', []))
mapping = sorted(metadata['truncate_qubits'].get('mapping', []))
self.assertEqual(active_qubits, [10, 20])
self.assertIn(mapping, [[[10, 0], [20, 1]], [[10, 1], [20, 0]]])
def test_truncate_nonlocal_noise(self):
"""Test qubit truncation with non-local noise."""
# Circuit that uses just 2-qubits
circuit = QuantumCircuit(10, 1)
circuit.x(5)
circuit.measure(5, 0)
# Add non-local 2-qubit depolarizing error
# that acts on qubits [4, 6] when X applied to qubit 5
noise_model = NoiseModel()
error = depolarizing_error(0.1, 2)
noise_model.add_nonlocal_quantum_error(error, ['x'], [5], [4, 6])
qasm_sim = Aer.get_backend('qasm_simulator')
backend_options = self.BACKEND_OPTS.copy()
backend_options["truncate_verbose"] = True
backend_options['optimize_ideal_threshold'] = 1
backend_options['optimize_noise_threshold'] = 1
result = execute(circuit,
qasm_sim,
shots=100,
noise_model=noise_model,
**backend_options).result()
metadata = result.results[0].metadata
self.assertTrue('truncate_qubits' in metadata, msg="truncate_qubits must work.")
active_qubits = sorted(metadata['truncate_qubits'].get('active_qubits', []))
mapping = metadata['truncate_qubits'].get('mapping', [])
active_remapped = sorted([i[1] for i in mapping if i[0] in active_qubits])
self.assertEqual(active_qubits, [4, 5, 6])
self.assertEqual(active_remapped, [0, 1, 2])
def test_truncate(self):
"""Test truncation with noise model option"""
circuit = self.create_circuit_for_truncate()
qasm_sim = Aer.get_backend('qasm_simulator')
backend_options = self.BACKEND_OPTS.copy()
backend_options["truncate_verbose"] = True
backend_options['optimize_ideal_threshold'] = 1
backend_options['optimize_noise_threshold'] = 1
result = execute(circuit,
qasm_sim,
noise_model=NoiseModel.from_backend(self.device_properties()),
shots=100,
coupling_map=[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 0]], # 10-qubit device
**backend_options).result()
self.assertTrue('truncate_qubits' in result.to_dict()['results'][0]['metadata'], msg="truncate_qubits must work.")
def test_no_truncate(self):
"""Test truncation with noise model option"""
circuit = self.create_circuit_for_truncate()
qasm_sim = Aer.get_backend('qasm_simulator')
backend_options = self.BACKEND_OPTS.copy()
backend_options["truncate_verbose"] = True
backend_options['optimize_ideal_threshold'] = 1
backend_options['optimize_noise_threshold'] = 1
result = execute(circuit,
qasm_sim,
noise_model=NoiseModel.from_backend(self.device_properties()),
shots=100,
coupling_map=[[1, 0], [1, 2], [1, 3], [2, 0], [2, 1], [2, 3], [3, 0], [3, 1], [3, 2]], # 4-qubit device
**backend_options).result()
self.assertFalse('truncate_qubits' in result.to_dict()['results'][0]['metadata'], msg="truncate_qubits must work.")
def test_truncate_disable(self):
"""Test explicitly disabling truncation with noise model option"""
circuit = self.create_circuit_for_truncate()
qasm_sim = Aer.get_backend('qasm_simulator')
backend_options = self.BACKEND_OPTS.copy()
backend_options["truncate_verbose"] = True
backend_options["truncate_enable"] = False
backend_options['optimize_ideal_threshold'] = 1
backend_options['optimize_noise_threshold'] = 1
result = execute(circuit,
qasm_sim,
noise_model=NoiseModel.from_backend(self.device_properties()),
shots=100,
coupling_map=[[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6], [6, 7], [7, 8], [8, 9], [9, 0]], # 10-qubit device
**backend_options).result()
self.assertFalse('truncate_qubits' in result.to_dict()['results'][0]['metadata'], msg="truncate_qubits must not work.")
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
# 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.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2*dt,0)
qc.rz(2*dt,1)
qc.h(1)
qc.cx(1,0)
qc.rz(-2*dt, 0)
qc.rx(-2*dt, 1)
qc.rz(2*dt, 1)
qc.cx(1,0)
qc.h(1)
qc.rz(2*dt, 0)
return qc.to_instruction() if to_instruction else qc
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
# 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)
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# backend = provider.get_backend("ibmq_jakarta")
jobs = []
st_qcs_list = []
shots = 1 << 13
# Number of trotter steps
trotter_steps = 8 ### CAN BE >= 4
for num_steps in range(1, trotter_steps + 1, 1):
print("trotter step: ", num_steps)
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(7)
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>)
qc.x([5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(num_steps):
qc.append(Trot_gate, [qr[3], qr[5]])
qc.cx(qr[3], qr[1])
qc.cx(qr[5], qr[3])
# 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})
t3_qc = transpile(qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(t3_qc, [qr[1], qr[3], qr[5]])
st_qcs_list.append(st_qcs)
# execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
print()
# 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=[5,3,1])
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
results = []
for job in jobs:
results.append( job.result() )
mit_results = []
for job in jobs:
mit_results.append( meas_fitter.filter.apply(job.result()) )
len(results), len(mit_results)
# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits
def state_tomo(result, st_qcs):
# The expected final state; necessary to determine state tomography fidelity
target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Fit state tomography results
tomo_fitter = StateTomographyFitter(result, st_qcs)
rho_fit = tomo_fitter.fit(method='lstsq')
# Compute fidelity
fid = state_fidelity(rho_fit, target_state)
return fid
# Compute tomography fidelities for each repetition
raw_fids = []
for result in results:
fid = state_tomo(result, st_qcs)
raw_fids.append(fid)
# print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
# Compute tomography fidelities for each repetition
fids = []
for result in mit_results:
fid = state_tomo(result, st_qcs)
fids.append(fid)
# print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
plt.clf()
plt.title("fidelity with QREM")
plt.plot(range(1, trotter_steps + 1, 1), raw_fids)
plt.plot(range(1, trotter_steps + 1, 1), fids)
plt.xlabel("number of trotter steps")
plt.ylabel("fidelity")
for i, fid in enumerate(raw_fids):
print(i+1, fid)
for i, fid in enumerate(fids):
print(i+1, fid)
st_qcs_list[-1][-1].draw("mpl")
st_qcs_list[-2][-1].draw("mpl")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
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
|
import matplotlib.pyplot as plt
from scipy.interpolate import griddata
%matplotlib inline
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, AncillaRegister, transpile
from qiskit.circuit.library import IntegerComparator, WeightedAdder, LinearAmplitudeFunction
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits per dimension to represent the uncertainty
num_uncertainty_qubits = 2
# 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
# map to higher dimensional distribution
# for simplicity assuming dimensions are independent and identically distributed)
dimension = 2
num_qubits = [num_uncertainty_qubits] * dimension
low = low * np.ones(dimension)
high = high * np.ones(dimension)
mu = mu * np.ones(dimension)
cov = sigma**2 * np.eye(dimension)
# construct circuit
u = LogNormalDistribution(num_qubits=num_qubits, mu=mu, sigma=cov, bounds=(list(zip(low, high))))
# plot PDF of uncertainty model
x = [v[0] for v in u.values]
y = [v[1] for v in u.values]
z = u.probabilities
# z = map(float, z)
# z = list(map(float, z))
resolution = np.array([2**n for n in num_qubits]) * 1j
grid_x, grid_y = np.mgrid[min(x) : max(x) : resolution[0], min(y) : max(y) : resolution[1]]
grid_z = griddata((x, y), z, (grid_x, grid_y))
plt.figure(figsize=(10, 8))
ax = plt.axes(projection="3d")
ax.plot_surface(grid_x, grid_y, grid_z, cmap=plt.cm.Spectral)
ax.set_xlabel("Spot Price $S_1$ (\$)", size=15)
ax.set_ylabel("Spot Price $S_2$ (\$)", size=15)
ax.set_zlabel("Probability (\%)", size=15)
plt.show()
# determine number of qubits required to represent total loss
weights = []
for n in num_qubits:
for i in range(n):
weights += [2**i]
# create aggregation circuit
agg = WeightedAdder(sum(num_qubits), weights)
n_s = agg.num_sum_qubits
n_aux = agg.num_qubits - n_s - agg.num_state_qubits # number of additional qubits
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price_1 = 3
strike_price_2 = 4
# set the barrier threshold
barrier = 2.5
# map strike prices and barrier threshold from [low, high] to {0, ..., 2^n-1}
max_value = 2**n_s - 1
low_ = low[0]
high_ = high[0]
mapped_strike_price_1 = (
(strike_price_1 - dimension * low_) / (high_ - low_) * (2**num_uncertainty_qubits - 1)
)
mapped_strike_price_2 = (
(strike_price_2 - dimension * low_) / (high_ - low_) * (2**num_uncertainty_qubits - 1)
)
mapped_barrier = (barrier - low) / (high - low) * (2**num_uncertainty_qubits - 1)
# condition and condition result
conditions = []
barrier_thresholds = [2] * dimension
n_aux_conditions = 0
for i in range(dimension):
# target dimension of random distribution and corresponding condition (which is required to be True)
comparator = IntegerComparator(num_qubits[i], mapped_barrier[i] + 1, geq=False)
n_aux_conditions = max(n_aux_conditions, comparator.num_ancillas)
conditions += [comparator]
# set the approximation scaling for the payoff function
c_approx = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [0, mapped_strike_price_1, mapped_strike_price_2]
slopes = [0, 1, 0]
offsets = [0, 0, mapped_strike_price_2 - mapped_strike_price_1]
f_min = 0
f_max = mapped_strike_price_2 - mapped_strike_price_1
objective = LinearAmplitudeFunction(
n_s,
slopes,
offsets,
domain=(0, max_value),
image=(f_min, f_max),
rescaling_factor=c_approx,
breakpoints=breakpoints,
)
# define overall multivariate problem
qr_state = QuantumRegister(u.num_qubits, "state") # to load the probability distribution
qr_obj = QuantumRegister(1, "obj") # to encode the function values
ar_sum = AncillaRegister(n_s, "sum") # number of qubits used to encode the sum
ar_cond = AncillaRegister(len(conditions) + 1, "conditions")
ar = AncillaRegister(
max(n_aux, n_aux_conditions, objective.num_ancillas), "work"
) # additional qubits
objective_index = u.num_qubits
# define the circuit
asian_barrier_spread = QuantumCircuit(qr_state, qr_obj, ar_cond, ar_sum, ar)
# load the probability distribution
asian_barrier_spread.append(u, qr_state)
# apply the conditions
for i, cond in enumerate(conditions):
state_qubits = qr_state[(num_uncertainty_qubits * i) : (num_uncertainty_qubits * (i + 1))]
asian_barrier_spread.append(cond, state_qubits + [ar_cond[i]] + ar[: cond.num_ancillas])
# aggregate the conditions on a single qubit
asian_barrier_spread.mcx(ar_cond[:-1], ar_cond[-1])
# apply the aggregation function controlled on the condition
asian_barrier_spread.append(agg.control(), [ar_cond[-1]] + qr_state[:] + ar_sum[:] + ar[:n_aux])
# apply the payoff function
asian_barrier_spread.append(objective, ar_sum[:] + qr_obj[:] + ar[: objective.num_ancillas])
# uncompute the aggregation
asian_barrier_spread.append(
agg.inverse().control(), [ar_cond[-1]] + qr_state[:] + ar_sum[:] + ar[:n_aux]
)
# uncompute the conditions
asian_barrier_spread.mcx(ar_cond[:-1], ar_cond[-1])
for j, cond in enumerate(reversed(conditions)):
i = len(conditions) - j - 1
state_qubits = qr_state[(num_uncertainty_qubits * i) : (num_uncertainty_qubits * (i + 1))]
asian_barrier_spread.append(
cond.inverse(), state_qubits + [ar_cond[i]] + ar[: cond.num_ancillas]
)
print(asian_barrier_spread.draw())
print("objective qubit index", objective_index)
# plot exact payoff function
plt.figure(figsize=(7, 5))
x = np.linspace(sum(low), sum(high))
y = (x <= 5) * np.minimum(np.maximum(0, x - strike_price_1), strike_price_2 - strike_price_1)
plt.plot(x, y, "r-")
plt.grid()
plt.title("Payoff Function (for $S_1 = S_2$)", size=15)
plt.xlabel("Sum of Spot Prices ($S_1 + S_2)$", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# plot contour of payoff function with respect to both time steps, including barrier
plt.figure(figsize=(7, 5))
z = np.zeros((17, 17))
x = np.linspace(low[0], high[0], 17)
y = np.linspace(low[1], high[1], 17)
for i, x_ in enumerate(x):
for j, y_ in enumerate(y):
z[i, j] = np.minimum(
np.maximum(0, x_ + y_ - strike_price_1), strike_price_2 - strike_price_1
)
if x_ > barrier or y_ > barrier:
z[i, j] = 0
plt.title("Payoff Function", size=15)
plt.contourf(x, y, z)
plt.colorbar()
plt.xlabel("Spot Price $S_1$", size=15)
plt.ylabel("Spot Price $S_2$", size=15)
plt.xticks(size=15)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value
sum_values = np.sum(u.values, axis=1)
payoff = np.minimum(np.maximum(sum_values - strike_price_1, 0), strike_price_2 - strike_price_1)
leq_barrier = [np.max(v) <= barrier for v in u.values]
exact_value = np.dot(u.probabilities[leq_barrier], payoff[leq_barrier])
print("exact expected value:\t%.4f" % exact_value)
num_state_qubits = asian_barrier_spread.num_qubits - asian_barrier_spread.num_ancillas
print("state qubits: ", num_state_qubits)
transpiled = transpile(asian_barrier_spread, basis_gates=["u", "cx"])
print("circuit width:", transpiled.width())
print("circuit depth:", transpiled.depth())
asian_barrier_spread_measure = asian_barrier_spread.measure_all(inplace=False)
sampler = Sampler()
job = sampler.run(asian_barrier_spread_measure)
# evaluate the result
value = 0
probabilities = job.result().quasi_dists[0].binary_probabilities()
for i, prob in probabilities.items():
if prob > 1e-4 and i[-num_state_qubits:][0] == "1":
value += prob
# map value to original range
mapped_value = objective.post_processing(value) / (2**num_uncertainty_qubits - 1) * (high_ - low_)
print("Exact Operator Value: %.4f" % value)
print("Mapped Operator value: %.4f" % mapped_value)
print("Exact Expected Payoff: %.4f" % exact_value)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=asian_barrier_spread,
objective_qubits=[objective_index],
post_processing=objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100}))
result = ae.estimate(problem)
conf_int = (
np.array(result.confidence_interval_processed)
/ (2**num_uncertainty_qubits - 1)
* (high_ - low_)
)
print("Exact value: \t%.4f" % exact_value)
print(
"Estimated value:\t%.4f"
% (result.estimation_processed / (2**num_uncertainty_qubits - 1) * (high_ - low_))
)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/hidemita/QiskitExamples
|
hidemita
|
# Useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import math
import random
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
from qiskit import BasicAer
qc = QuantumCircuit(9,4)
# Z-type Stabilizers
qc.h(5)
qc.cz(5, 0)
qc.cz(5, 1)
qc.cz(5, 2)
qc.h(5)
qc.h(8)
qc.cz(8, 2)
qc.cz(8, 3)
qc.cz(8, 4)
qc.h(8)
# X-type Stabilizers
qc.h(6)
qc.cx(6, 0)
qc.cx(6, 2)
qc.cx(6, 3)
qc.h(6)
qc.h(7)
qc.cx(7, 1)
qc.cx(7, 2)
qc.cx(7, 4)
qc.h(7)
# Measurement
qc.measure(5, 0)
qc.measure(6, 1)
qc.measure(7, 2)
qc.measure(8, 3)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
job.result().get_counts(qc)
qc = QuantumCircuit(9,4)
# Make stabilizer state
qc.h(0)
qc.cx(0, 2)
qc.cx(0, 3)
qc.h(1)
qc.cx(1, 2)
qc.cx(1, 4)
# Z-type Stabilizers
qc.h(5)
qc.cz(5, 0)
qc.cz(5, 1)
qc.cz(5, 2)
qc.h(5)
qc.h(8)
qc.cz(8, 2)
qc.cz(8, 3)
qc.cz(8, 4)
qc.h(8)
# X-type Stabilizers
qc.h(6)
qc.cx(6, 0)
qc.cx(6, 2)
qc.cx(6, 3)
qc.h(6)
qc.h(7)
qc.cx(7, 1)
qc.cx(7, 2)
qc.cx(7, 4)
qc.h(7)
# Measurement
qc.measure(5, 0)
qc.measure(6, 1)
qc.measure(7, 2)
qc.measure(8, 3)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
job.result().get_counts(qc)
qc = QuantumCircuit(9,4)
# Make stabilizer state
qc.h(0)
qc.cx(0, 2)
qc.cx(0, 3)
qc.h(1)
qc.cx(1, 2)
qc.cx(1, 4)
# Simulate Z error
qc.z(2)
# Z-type Stabilizers
qc.h(5)
qc.cz(5, 0)
qc.cz(5, 1)
qc.cz(5, 2)
qc.h(5)
qc.h(8)
qc.cz(8, 2)
qc.cz(8, 3)
qc.cz(8, 4)
qc.h(8)
# X-type Stabilizers
qc.h(6)
qc.cx(6, 0)
qc.cx(6, 2)
qc.cx(6, 3)
qc.h(6)
qc.h(7)
qc.cx(7, 1)
qc.cx(7, 2)
qc.cx(7, 4)
qc.h(7)
# Measurement
qc.measure(5, 0)
qc.measure(6, 1)
qc.measure(7, 2)
qc.measure(8, 3)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
job.result().get_counts(qc)
qc = QuantumCircuit(10,5) # q_9 and c_5 bits for logical bit measurement
# Make Stabilizer State
qc.h(0)
qc.cx(0, 2)
qc.cx(0, 3)
qc.h(1)
qc.cx(1, 2)
qc.cx(1, 4)
# Z-type Stabilizers
qc.h(5)
qc.cz(5, 0)
qc.cz(5, 1)
qc.cz(5, 2)
qc.h(5)
qc.h(8)
qc.cz(8, 2)
qc.cz(8, 3)
qc.cz(8, 4)
qc.h(8)
# X-type Stabilizers
qc.h(6)
qc.cx(6, 0)
qc.cx(6, 2)
qc.cx(6, 3)
qc.h(6)
qc.h(7)
qc.cx(7, 1)
qc.cx(7, 2)
qc.cx(7, 4)
qc.h(7)
# logical pauli-X operator
qc.x(0)
qc.x(1)
# logical Z-basis hadamard test for the logical bit
qc.h(9)
qc.cz(9,1)
qc.cz(9,4)
qc.h(9)
# Measurement
qc.measure(5, 0)
qc.measure(6, 1)
qc.measure(7, 2)
qc.measure(8, 3)
qc.measure(9, 4)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
job.result().get_counts(qc)
qc = QuantumCircuit(16,8)
# Z-type stabilizers
qc.h(12)
qc.cz(12, 0)
qc.cz(12, 2)
qc.cz(12, 3)
qc.cz(12, 4)
qc.h(12)
qc.h(13)
qc.cz(13, 0)
qc.cz(13, 2)
qc.cz(13, 3)
qc.cz(13, 4)
qc.h(13)
qc.h(14)
qc.cz(14, 0)
qc.cz(14, 2)
qc.cz(14, 3)
qc.cz(14, 4)
qc.h(14)
qc.h(15)
qc.cz(15, 0)
qc.cz(15, 2)
qc.cz(15, 3)
qc.cz(15, 4)
qc.h(15)
# X-type stabilizers
qc.h(8)
qc.cx(8, 0)
qc.cx(8, 1)
qc.cx(8, 2)
qc.cx(8, 6)
qc.h(8)
qc.h(9)
qc.cx(9, 0)
qc.cx(9, 1)
qc.cx(9, 3)
qc.cx(9, 7)
qc.h(9)
qc.h(10)
qc.cx(10, 2)
qc.cx(10, 4)
qc.cx(10, 5)
qc.cx(10, 6)
qc.h(10)
qc.h(11)
qc.cx(11, 3)
qc.cx(11, 4)
qc.cx(11, 5)
qc.cx(11, 7)
qc.h(11)
qc.measure(8, 0)
qc.measure(9, 1)
qc.measure(10, 2)
qc.measure(11, 3)
qc.measure(12, 4)
qc.measure(13, 5)
qc.measure(14, 6)
qc.measure(15, 7)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
job.result().get_counts(qc)
qc = QuantumCircuit(16,8)
# Initialize to a stabilizers state
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
qc.cx(0, 6)
qc.h(3)
qc.cx(3, 0)
qc.cx(3, 1)
qc.cx(3, 7)
qc.h(4)
qc.cx(4, 2)
qc.cx(4, 5)
qc.cx(4, 6)
# Z-type stabilizers
qc.h(12)
qc.cz(12, 0)
qc.cz(12, 2)
qc.cz(12, 3)
qc.cz(12, 4)
qc.h(12)
qc.h(13)
qc.cz(13, 0)
qc.cz(13, 2)
qc.cz(13, 3)
qc.cz(13, 4)
qc.h(13)
qc.h(14)
qc.cz(14, 0)
qc.cz(14, 2)
qc.cz(14, 3)
qc.cz(14, 4)
qc.h(14)
qc.h(15)
qc.cz(15, 0)
qc.cz(15, 2)
qc.cz(15, 3)
qc.cz(15, 4)
qc.h(15)
# X-type stabilizers
qc.h(8)
qc.cx(8, 0)
qc.cx(8, 1)
qc.cx(8, 2)
qc.cx(8, 6)
qc.h(8)
qc.h(9)
qc.cx(9, 0)
qc.cx(9, 1)
qc.cx(9, 3)
qc.cx(9, 7)
qc.h(9)
qc.h(10)
qc.cx(10, 2)
qc.cx(10, 4)
qc.cx(10, 5)
qc.cx(10, 6)
qc.h(10)
qc.h(11)
qc.cx(11, 3)
qc.cx(11, 4)
qc.cx(11, 5)
qc.cx(11, 7)
qc.h(11)
qc.measure(8, 0)
qc.measure(9, 1)
qc.measure(10, 2)
qc.measure(11, 3)
qc.measure(12, 4)
qc.measure(13, 5)
qc.measure(14, 6)
qc.measure(15, 7)
#qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
job.result().get_counts(qc)
qc = QuantumCircuit(16,8)
# Initialize to a stabilizers state
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
qc.cx(0, 6)
qc.h(3)
qc.cx(3, 0)
qc.cx(3, 1)
qc.cx(3, 7)
qc.h(4)
qc.cx(4, 2)
qc.cx(4, 5)
qc.cx(4, 6)
# A simulated error
qc.z(0)
# Z-type stabilizers
qc.h(12)
qc.cz(12, 0)
qc.cz(12, 2)
qc.cz(12, 3)
qc.cz(12, 4)
qc.h(12)
qc.h(13)
qc.cz(13, 0)
qc.cz(13, 2)
qc.cz(13, 3)
qc.cz(13, 4)
qc.h(13)
qc.h(14)
qc.cz(14, 0)
qc.cz(14, 2)
qc.cz(14, 3)
qc.cz(14, 4)
qc.h(14)
qc.h(15)
qc.cz(15, 0)
qc.cz(15, 2)
qc.cz(15, 3)
qc.cz(15, 4)
qc.h(15)
# X-type stabilizers
qc.h(8)
qc.cx(8, 0)
qc.cx(8, 1)
qc.cx(8, 2)
qc.cx(8, 6)
qc.h(8)
qc.h(9)
qc.cx(9, 0)
qc.cx(9, 1)
qc.cx(9, 3)
qc.cx(9, 7)
qc.h(9)
qc.h(10)
qc.cx(10, 2)
qc.cx(10, 4)
qc.cx(10, 5)
qc.cx(10, 6)
qc.h(10)
qc.h(11)
qc.cx(11, 3)
qc.cx(11, 4)
qc.cx(11, 5)
qc.cx(11, 7)
qc.h(11)
qc.measure(8, 0)
qc.measure(9, 1)
qc.measure(10, 2)
qc.measure(11, 3)
qc.measure(12, 4)
qc.measure(13, 5)
qc.measure(14, 6)
qc.measure(15, 7)
#qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
job.result().get_counts(qc)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
import numpy as np
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import TwoLocal
from qiskit.quantum_info import Statevector
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit_aer.primitives import Sampler
from qiskit_finance.applications.estimation import EuropeanCallPricing
from qiskit_finance.circuit.library import NormalDistribution
# Set upper and lower data values
bounds = np.array([0.0, 7.0])
# Set number of qubits used in the uncertainty model
num_qubits = 3
# Load the trained circuit parameters
g_params = [0.29399714, 0.38853322, 0.9557694, 0.07245791, 6.02626428, 0.13537225]
# Set an initial state for the generator circuit
init_dist = NormalDistribution(num_qubits, mu=1.0, sigma=1.0, bounds=bounds)
# construct the variational form
var_form = TwoLocal(num_qubits, "ry", "cz", entanglement="circular", reps=1)
# keep a list of the parameters so we can associate them to the list of numerical values
# (otherwise we need a dictionary)
theta = var_form.ordered_parameters
# compose the generator circuit, this is the circuit loading the uncertainty model
g_circuit = init_dist.compose(var_form)
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 2
# set the approximation scaling for the payoff function
c_approx = 0.25
# Evaluate trained probability distribution
values = [
bounds[0] + (bounds[1] - bounds[0]) * x / (2**num_qubits - 1) for x in range(2**num_qubits)
]
uncertainty_model = g_circuit.assign_parameters(dict(zip(theta, g_params)))
amplitudes = Statevector.from_instruction(uncertainty_model).data
x = np.array(values)
y = np.abs(amplitudes) ** 2
# Sample from target probability distribution
N = 100000
log_normal = np.random.lognormal(mean=1, sigma=1, size=N)
log_normal = np.round(log_normal)
log_normal = log_normal[log_normal <= 7]
log_normal_samples = []
for i in range(8):
log_normal_samples += [np.sum(log_normal == i)]
log_normal_samples = np.array(log_normal_samples / sum(log_normal_samples))
# Plot distributions
plt.bar(x, y, width=0.2, label="trained distribution", color="royalblue")
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.plot(
log_normal_samples,
"-o",
color="deepskyblue",
label="target distribution",
linewidth=4,
markersize=12,
)
plt.legend(loc="best")
plt.show()
# Evaluate payoff for different distributions
payoff = np.array([0, 0, 0, 1, 2, 3, 4, 5])
ep = np.dot(log_normal_samples, payoff)
print("Analytically calculated expected payoff w.r.t. the target distribution: %.4f" % ep)
ep_trained = np.dot(y, payoff)
print("Analytically calculated expected payoff w.r.t. the trained distribution: %.4f" % ep_trained)
# Plot exact payoff function (evaluated on the grid of the trained uncertainty model)
x = np.array(values)
y_strike = np.maximum(0, x - strike_price)
plt.plot(x, y_strike, "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()
# construct circuit for payoff function
european_call_pricing = EuropeanCallPricing(
num_qubits,
strike_price=strike_price,
rescaling_factor=c_approx,
bounds=bounds,
uncertainty_model=uncertainty_model,
)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = european_call_pricing.to_estimation_problem()
# 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" % ep_trained)
print("Estimated value: \t%.4f" % (result.estimation_processed))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/ericardomuten/qiskit-advocate-mentorship
|
ericardomuten
|
!pip install qiskit
!pip install pylatexenc--upgrade
!pip install retworkx
#!pip install numpy --upgrade
from IPython.display import clear_output
clear_output()
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, transpile
from qiskit.circuit.library import ZGate, XGate
from qiskit.extensions import UnitaryGate
from qiskit.aqua.algorithms import VQE, NumPyEigensolver
from qiskit.aqua.operators import WeightedPauliOperator, MatrixOperator, op_converter
from qiskit.aqua.components.optimizers import COBYLA, SPSA, SLSQP
#from qiskit.quantum_info.operators import Operator
import numpy as np
import scipy
import networkx as nx
from matplotlib import pyplot as plt
import copy
# Define the number of qubits
num_qubit = 4
qubits = range(num_qubit)
# Generating the graph
ising_graph = nx.star_graph(num_qubit-1)
print("Edges:", ising_graph.edges)
nx.draw(ising_graph)
# Set the random seed
rng = np.random.default_rng(seed=2021)
# Initialize the true weights and bias
true_weights = rng.random(size=len(ising_graph.edges)) - 0.5
true_bias = rng.random(size=num_qubit) - 0.5
print("True Weights:", true_weights)
print("True Bias", true_bias)
def create_hamiltonian_matrix(n_qubits, graph, weights, bias):
full_matrix = np.zeros((2 ** n_qubits, 2 ** n_qubits))
# Creates the interaction component of the Hamiltonian
for i, edge in enumerate(graph.edges):
interaction_term = 1
for qubit in range(0, n_qubits):
if qubit in edge:
interaction_term = np.kron(interaction_term, np.array(ZGate().to_matrix(), dtype=float))
else:
interaction_term = np.kron(interaction_term, np.identity(2))
full_matrix += weights[i] * interaction_term
# Creates the bias components of the matrix
for i in range(0, n_qubits):
z_term = x_term = 1
for j in range(0, n_qubits):
if j == i:
z_term = np.kron(z_term, np.array(ZGate().to_matrix(), dtype=float))
x_term = np.kron(x_term, np.array(XGate().to_matrix(), dtype=float))
else:
z_term = np.kron(z_term, np.identity(2))
x_term = np.kron(x_term, np.identity(2))
full_matrix += bias[i] * z_term + x_term
return full_matrix
# Prints a visual representation of the Hamiltonian matrix
H_matrix = create_hamiltonian_matrix(num_qubit, ising_graph, true_weights, true_bias)
print("Hamiltonian Matrix Visualization")
plt.matshow(H_matrix, cmap="cool")
plt.colorbar()
plt.show()
ground_state_energy = np.real_if_close(min(np.linalg.eig(H_matrix)[0]))
print("Ground State Energy:", ground_state_energy)
H_operator = op_converter.to_weighted_pauli_operator(MatrixOperator(H_matrix))
eig_vals = NumPyEigensolver(H_operator).run()
print("Minimum Eigenvalue:", np.real_if_close(min(eig_vals['eigenvalues'])))
opt = SLSQP(maxiter=5)
backend = Aer.get_backend("statevector_simulator")
vqe=VQE(operator=H_operator, optimizer=opt)
vqe_result=vqe.run(backend)
print("VQE Eigenvalue:", np.real_if_close(vqe_result['eigenvalue']))
#vqe.get_optimal_circuit().draw()
low_energy_state = vqe.get_optimal_vector()
print("Low Energy State:", low_energy_state)
# Sanity check, will be deleted in the final notebook
print(np.real_if_close(np.conj(vqe.get_optimal_vector())@H_matrix@vqe.get_optimal_vector()))
print(np.conj(vqe.get_optimal_vector())@vqe.get_optimal_vector())
import math
math.isclose(np.sum(np.absolute(np.kron(low_energy_state,low_energy_state)) ** 2), 1.0,
abs_tol=1e-11)
def state_evolve(circuit, hamiltonian, qubits, time):
U = scipy.linalg.expm(-1j * hamiltonian * time)
U_gate = UnitaryGate(U, label='evolved_unitary_'+str(time))
circuit.unitary(U_gate, qubits)
return circuit
def qgrnn_layer(circuit, weights, bias, qubits, graph, trotter_step):
# Applies a layer of RZZ gates (based on a graph)
for i, edge in enumerate(graph.edges):
circuit.rzz(2 * weights[i] * trotter_step, edge[0], edge[1])
# Applies a layer of RZ gates
for i, qubit in enumerate(qubits):
circuit.rz(2 * bias[i] * trotter_step, qubit)
# Applies a layer of RX gates
for qubit in qubits:
circuit.rx(2 * trotter_step, qubit)
return circuit
def swap_test(circuit, control, register1, register2):
circuit.h(control)
for reg1_qubit, reg2_qubit in zip(register1, register2):
circuit.cswap(control, reg1_qubit, reg2_qubit)
circuit.h(control)
return circuit
# Defines some fixed values
reg_data = tuple(range(num_qubit)) # First qubit register for quantum data
reg_qgrnn = tuple(range(num_qubit, 2 * num_qubit)) # Second qubit register for QGRNN
control = 2 * num_qubit # Index of control qubit
trotter_step = 0.01 # Trotter step size
# Defines the initial interaction graph
initial_ising_graph = nx.complete_graph(reg_qgrnn)
print("Edges:", initial_ising_graph.edges)
nx.draw(initial_ising_graph)
# Initialize random weights and bias
weights = rng.random(size=len(initial_ising_graph.edges)) - 0.5
bias = rng.random(size=num_qubit) - 0.5
trainable_params = np.concatenate((weights, bias))
initial_weights = copy.copy(weights)
initial_bias = copy.copy(bias)
print(trainable_params)
def qgrnn(param_weights, param_bias, time=None):
circuit = QuantumCircuit(2*num_qubit+1, 1)
# Prepares the low energy state in the two registers
circuit.initialize(np.kron(low_energy_state, low_energy_state), reg_data + reg_qgrnn)
# Evolves the first qubit register with the time-evolution circuit to
# prepare a piece of quantum data
circuit = state_evolve(circuit, H_matrix, reg_data, time)
# Applies the QGRNN layers to the second qubit register
depth = time / trotter_step # P = t/Delta
for _ in range(0, int(depth)):
circuit = qgrnn_layer(circuit, param_weights, param_bias, reg_qgrnn, initial_ising_graph, trotter_step)
# Applies the SWAP test between the registers
circuit = swap_test(circuit, control, reg_data, reg_qgrnn)
# Measure the circuit
circuit.measure([control], [0])
return circuit
qgrnn(initial_weights, initial_bias, time=0.02).draw()
def z_exp(circuit, shots=10000):
backend = Aer.get_backend('aer_simulator_statevector')
job = backend.run(circuit, shots=shots)
result = job.result()
counts = result.get_counts(0)
try:
exp_0 = counts['0']/shots
except:
exp_0 = 0
try:
exp_1 = counts['1']/shots
except:
exp_1 = 0
exp = exp_0 - exp_1
return exp
N = 15 # The number of pieces of quantum data that are used for each step
max_time = 0.1 # The maximum value of time that can be used for quantum data
def cost_function(params):
# Randomly samples times at which the QGRNN runs
times_sampled = rng.random(size=N) * max_time
# Cycles through each of the sampled times and calculates the cost
total_cost = 0
for dt in times_sampled:
result = z_exp(qgrnn(params[:len(initial_ising_graph.edges)], params[len(initial_ising_graph.edges):], time=dt))
total_cost += -1 * result
return total_cost / N
# Sanity check, will be deleted in the final notebook
backend = Aer.get_backend('aer_simulator_statevector')
job = backend.run(qgrnn(trainable_params[:len(initial_ising_graph.edges)], trainable_params[len(initial_ising_graph.edges):], time=0.09716818), shots=10000)
result = job.result()
counts = result.get_counts(0)
counts
# Sanity check
cost_function(trainable_params)
opt_params = scipy.optimize.minimize(fun=cost_function, x0=trainable_params, tol=1e-12,
method='L-BFGS-B',
#args=(),
options={'maxiter':5000, 'ftol':1e-12})
print(opt_params)
trained_weights = opt_params['x'][:len(initial_ising_graph.edges)]
trained_bias = opt_params['x'][len(initial_ising_graph.edges):]
weights.shape, bias.shape
H_matrix_trained = create_hamiltonian_matrix(
num_qubit, nx.complete_graph(num_qubit), trained_weights, trained_bias
)
H_matrix_initial = create_hamiltonian_matrix(
num_qubit, nx.complete_graph(num_qubit), initial_weights, initial_bias
)
fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(6, 6))
axes[0].matshow(H_matrix, vmin=-7, vmax=7, cmap="cool")
axes[0].set_title("Target", y=1.13)
axes[1].matshow(H_matrix_initial, vmin=-7, vmax=7, cmap="cool")
axes[1].set_title("Initial", y=1.13)
axes[2].matshow(H_matrix_trained, vmin=-7, vmax=7, cmap="cool")
axes[2].set_title("Learned", y=1.13)
plt.subplots_adjust(wspace=0.3, hspace=0.3)
plt.show()
|
https://github.com/AislingHeanue/Quantum-Computing-Circuits
|
AislingHeanue
|
from scipy.fft import fft
import matplotlib.pyplot as plt
import numpy as np
from tqdm import tqdm
from fractions import Fraction
from numpy.random import choice
import warnings
warnings.filterwarnings("ignore", category=RuntimeWarning)
#some Runtime Warnings occur when graph is set to true
delta = lambda x,y: int(x==y)
shorbox = lambda a,x,nbits,N: (abs(fft([delta(x, a**k % N) for k in range(2**nbits)]))/(2**nbits))**2
# Chooses smallest nbits > log2(N) so code is fast as possible
# Picks some a coprime with N
# Takes the Fourier transform of the periodic equation a^k mod N = x with respect to k, and sums all these for every a.
# Measures the location of one of the spikes of the probability graph about 1000 times
# And uses fractions.Fraction to guess r
# If r is odd the code is thrown out and we start again for a new a.
# If we have the correct r, p1 = gcd(a^(r/2) - 1,N), p2 = gcd(a^(r/2) + 1,N)
def Factorise(N,tests = 8000,a = 2,nbits = 0,loop = True,graph = False,timer = False): #loop = False if we know it only works for a certain seed
loop2 = True
if nbits == 0:
nbits = max(7,int(1+np.log2(N+4)))
while a < N and loop2 == True:
loop2 = loop
while np.gcd(a,N) != 1:
a += 1
if timer:
probabilities = [0]*2**nbits
for i in tqdm(range(2**nbits)):
probabilities += shorbox(a,i,nbits,N)#
else: #the following line does the same as above but is less likely to give divide by zero errors
probabilities = sum([shorbox(a,x,nbits,N) for x in range(2**nbits)]) #probabilites is a list length 2**nbits
if graph:
plt.bar(range(len(probabilities)),probabilities,width=.6,color=(0.4,0.6,1))
checkedlist = []
for i in range(tests):
phase = choice(range(2**nbits),p=probabilities)/2**nbits
r = Fraction(phase).limit_denominator(int(N/2)).denominator
if r not in checkedlist:
checkedlist.append(r)
#print(r)
if r > 1 and r % 2 == 0:
if int(a**(r/2)) <= 2**62: #gcd requires numbers below 2^64
p1 = np.gcd(int(a**(r/2)-1),N)
p2 = np.gcd(int(a**(r/2)+1),N)
plist = [p1,p2] if p1 <= p2 else [p2,p1]
if p1 * p2 == N and p1 != 1 and p2 != 1:
return f"{plist[0]:<2d}* {plist[1]:<3d} = {N:<3d}, r = {r:<3d}, a = {a:<3d}, nbits = {nbits:<2d}"
a += 1
return "I can't do "+str(N)
print(Factorise(15,nbits=4,a=2,graph=True,loop=False,timer = True))
def primes(N):
primel = [2]
endindex = 0
for i in range(3,N+1,2):
for j in primel[endindex:-1]:
if j > np.sqrt(i):
endindex = primel.index(j)
break
prime = True
for k in primel[0:endindex]:
if i%k == 0:
prime = False
break
if prime:
primel.append(i)
return primel
def Semiprimes(N):
semiprimel = []
primelist = primes(N//2)[1:] #2 does not behave well with Shor's algorithm
for i in enumerate(primelist):
for j in primelist[i[0]:]:
if j > i[1]: #square numbers also dont work since the algorithm finds 2 different factors
if i[1]*j <= N:
semiprimel.append(i[1]*j)
semiprimel.sort()
return semiprimel
for N in Semiprimes(292):
print(Factorise(N,100))
|
https://github.com/Chibikuri/qwopt
|
Chibikuri
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/microsoft/qiskit-qir
|
microsoft
|
##
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
##
from typing import List
import pytest
from qiskit_qir.elements import QiskitModule
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit_qir.capability import (
Capability,
ConditionalBranchingOnResultError,
QubitUseAfterMeasurementError,
)
from qiskit_qir.visitor import BasicQisVisitor
# test circuits
def teleport() -> QuantumCircuit:
qq = QuantumRegister(3, name="qq")
cr = ClassicalRegister(2, name="cr")
circuit = QuantumCircuit(qq, cr, name="Teleport")
circuit.h(1)
circuit.cx(1, 2)
circuit.cx(0, 1)
circuit.h(0)
circuit.measure(0, 0)
circuit.measure(1, 1)
circuit.x(2).c_if(cr, int("10", 2))
circuit.z(2).c_if(cr, int("01", 2))
return circuit
def use_after_measure():
qq = QuantumRegister(2, name="qq")
cr = ClassicalRegister(2, name="cr")
circuit = QuantumCircuit(qq, cr)
circuit.h(1)
circuit.measure(1, 1)
circuit.h(1)
return circuit
def use_another_after_measure():
circuit = QuantumCircuit(3, 2)
circuit.h(0)
circuit.measure(0, 0)
circuit.h(1)
circuit.cx(1, 2)
circuit.measure(1, 1)
return circuit
def use_another_after_measure_and_condition():
qq = QuantumRegister(3, name="qq")
cr = ClassicalRegister(2, name="cr")
circuit = QuantumCircuit(qq, cr)
circuit.h(0)
circuit.measure(0, 0)
circuit.h(1)
circuit.cx(1, 2)
circuit.measure(1, 1)
circuit.x(2).c_if(cr, int("10", 2))
return circuit
def use_conditional_branch_on_single_register_true_value():
circuit = QuantumCircuit(name="Conditional")
qr = QuantumRegister(2, "qreg")
cr = ClassicalRegister(3, "creg")
circuit.add_register(qr)
circuit.add_register(cr)
circuit.x(0)
circuit.measure(0, 0)
circuit.x(1).c_if(cr[2], 1)
circuit.measure(0, 1)
return circuit
def use_conditional_branch_on_single_register_false_value():
circuit = QuantumCircuit(name="Conditional")
qr = QuantumRegister(2, "qreg")
cr = ClassicalRegister(3, "creg")
circuit.add_register(qr)
circuit.add_register(cr)
circuit.x(0)
circuit.measure(0, 0)
circuit.x(1).c_if(cr[2], 0)
circuit.measure(0, 1)
return circuit
def conditional_branch_on_bit():
qr = QuantumRegister(2, "qreg")
cr = ClassicalRegister(2, "creg")
circuit = QuantumCircuit(qr, cr, name="conditional_branch_on_bit")
circuit.x(0)
circuit.measure(0, 0)
circuit.x(1).c_if(cr[0], 1)
circuit.measure(1, 1)
return circuit
# Utility using new visitor
def circuit_to_qir(circuit, profile: str = "AdaptiveExecution"):
module = QiskitModule.from_quantum_circuit(circuit=circuit)
visitor = BasicQisVisitor(profile)
module.accept(visitor)
return visitor.ir()
def test_branching_on_measurement_fails_without_required_capability():
circuit = teleport()
with pytest.raises(ConditionalBranchingOnResultError) as exc_info:
_ = circuit_to_qir(circuit, "BasicExecution")
exception_raised = exc_info.value
assert (
str(exception_raised.instruction)
== "Instruction(name='x', num_qubits=1, num_clbits=0, params=[])"
)
assert (
str(exception_raised.instruction.condition) == "(ClassicalRegister(2, 'cr'), 2)"
)
assert str(exception_raised.qargs) == "[Qubit(QuantumRegister(3, 'qq'), 2)]"
assert str(exception_raised.cargs) == "[]"
assert str(exception_raised.profile) == "BasicExecution"
assert exception_raised.instruction_string == "if(cr == 2) x qq[2]"
def test_branching_on_measurement_fails_without_required_capability():
circuit = use_conditional_branch_on_single_register_true_value()
with pytest.raises(ConditionalBranchingOnResultError) as exc_info:
_ = circuit_to_qir(circuit, "BasicExecution")
exception_raised = exc_info.value
assert (
str(exception_raised.instruction)
== "Instruction(name='x', num_qubits=1, num_clbits=0, params=[])"
)
assert (
str(exception_raised.instruction.condition)
== "(Clbit(ClassicalRegister(3, 'creg'), 2), True)"
)
assert str(exception_raised.qargs) == "[Qubit(QuantumRegister(2, 'qreg'), 1)]"
assert str(exception_raised.cargs) == "[]"
assert str(exception_raised.profile) == "BasicExecution"
assert exception_raised.instruction_string == "if(creg[2] == True) x qreg[1]"
def test_branching_on_measurement_fails_without_required_capability():
circuit = use_conditional_branch_on_single_register_false_value()
with pytest.raises(ConditionalBranchingOnResultError) as exc_info:
_ = circuit_to_qir(circuit, "BasicExecution")
exception_raised = exc_info.value
assert (
str(exception_raised.instruction)
== "Instruction(name='x', num_qubits=1, num_clbits=0, params=[])"
)
assert (
str(exception_raised.instruction.condition)
== "(Clbit(ClassicalRegister(3, 'creg'), 2), False)"
)
assert str(exception_raised.qargs) == "[Qubit(QuantumRegister(2, 'qreg'), 1)]"
assert str(exception_raised.cargs) == "[]"
assert str(exception_raised.profile) == "BasicExecution"
assert exception_raised.instruction_string == "if(creg[2] == False) x qreg[1]"
def test_branching_on_measurement_register_passses_with_required_capability():
circuit = teleport()
_ = circuit_to_qir(circuit)
def test_branching_on_measurement_bit_passses_with_required_capability():
circuit = conditional_branch_on_bit()
_ = circuit_to_qir(circuit)
def test_reuse_after_measurement_fails_without_required_capability():
circuit = use_after_measure()
with pytest.raises(QubitUseAfterMeasurementError) as exc_info:
_ = circuit_to_qir(circuit, "BasicExecution")
exception_raised = exc_info.value
assert (
str(exception_raised.instruction)
== "Instruction(name='h', num_qubits=1, num_clbits=0, params=[])"
)
assert exception_raised.instruction.condition is None
assert str(exception_raised.qargs) == "[Qubit(QuantumRegister(2, 'qq'), 1)]"
assert str(exception_raised.cargs) == "[]"
assert str(exception_raised.profile) == "BasicExecution"
assert exception_raised.instruction_string == "h qq[1]"
def test_reuse_after_measurement_passes_with_required_capability():
circuit = use_after_measure()
_ = circuit_to_qir(circuit)
def test_using_an_unread_qubit_after_measuring_passes_without_required_capability():
circuit = use_another_after_measure()
_ = circuit_to_qir(circuit, "BasicExecution")
def test_use_another_after_measure_and_condition_passes_with_required_capability():
circuit = use_another_after_measure_and_condition()
_ = circuit_to_qir(circuit)
|
https://github.com/LarianeMohceneMouad/Variation-Circuit-Based-Hybrid-Quantum-Classical-Binary-Algorithm
|
LarianeMohceneMouad
|
!pip install qiskit
!pip install pylatexenc
from sklearn import model_selection, datasets, svm
from qiskit import QuantumCircuit, Aer, IBMQ, QuantumRegister, ClassicalRegister
import numpy as np
import qiskit
import copy
import matplotlib.pyplot as plt
np.random.seed(42)
iris = datasets.load_iris()
X = iris.data[0:100]
Y = iris.target[0:100]
X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size=0.33, random_state=42)
N = 4
def feature_map(X, encoding_type):
q = QuantumRegister(N)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
if encoding_type == 'rx':
for i, x in enumerate(X):
qc.rx(x, i)
elif encoding_type == 'ry':
for i, x in enumerate(X):
qc.ry(x, i)
elif encoding_type == 'rz':
for i, x in enumerate(X):
qc.rz(x, i)
return qc, c
# feature map test
qc,c = feature_map(X[0], 'rx')
qc.draw('mpl')
def variational_circuit(qc, theta, rotation_type):
for i in range(N-1):
qc.cnot(i, i+1)
qc.cnot(N-1, 0)
if rotation_type == 'rx':
for i in range(N):
qc.rx(theta[i], i)
elif rotation_type == 'ry':
for i in range(N):
qc.ry(theta[i], i)
elif rotation_type == 'rz':
for i in range(N):
qc.rz(theta[i], i)
return qc
qc = variational_circuit(qc, np.ones(4), 'ry')
qc.draw('mpl')
def quantum_nn(X, theta, shots, encoding_type, rotation_type, simulator=True):
qc, c = feature_map(X, encoding_type)
qc = variational_circuit(qc, theta, rotation_type)
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
if simulator == False:
provider = IBMQ.load_account()
backend = provider.get_backend('ibm_oslo')
job = qiskit.execute(qc, backend, shots=shots)
result = job.result()
counts = result.get_counts(qc)
return counts['1']/shots
qc, c = feature_map(X[0], 'rz')
qc = variational_circuit(qc, np.ones(4), 'rz')
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
job = qiskit.execute(qc, backend, shots=5000)
result = job.result()
counts = result.get_counts(qc)
print(counts)
# quantum_nn test
quantum_nn(X[0], np.ones(4), 5000, 'rx', 'ry')
def loss(prediction, target):
return(prediction-target)**2
# loss test
loss(quantum_nn(X[0], [0.9, 0.9, 0.9, 0.9], 5000, 'rx', 'ry'), Y[0])
def gradient(X, Y, theta, delta, shots, encoding_type, rotation_type):
grad = []
for i in range(len(theta)):
dtheta = copy.copy(theta)
dtheta[i] += delta
prediction_1 = quantum_nn(X, dtheta, shots, encoding_type, rotation_type)
prediction_2 = quantum_nn(X, theta, shots, encoding_type, rotation_type)
grad.append((loss(prediction_1, Y) - loss(prediction_2, Y)) / delta)
return np.array(grad)
gradient(X[0], Y[0], np.ones(4), 0.01, 5000, 'rx', 'ry')
def accuracy(X, Y, theta, shots, encoding_type, rotation_type):
counter = 0
for X_i, Y_i, in zip(X, Y):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
if prediction < 0.5 and Y_i == 0:
counter += 1
elif prediction >= 0.5 and Y_i == 1:
counter += 1
return counter/len(Y)
# Accuracy test
accuracy(X_test, Y_test, [-1.5, 1.2, 0.6, -0.2], 1000, 'rx', 'ry')
def get_best_weight(accuracies, weights):
return(weights[accuracies.index(max(accuracies))])
N = 4
def model(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
if optimizing_weights==True:
acc = accuracy(x_test, y_test, get_best_weight(acc_list, weights_list), shots, encoding_type=encoding_gate, rotation_type=rotation_gate)
return acc, get_best_weight(acc_list, weights_list), theta, loss_list, acc_list, weights_list
else:
acc = accuracy(x_test, y_test, theta, shots, encoding_type=encoding_gate, rotation_type=rotation_gate)
return acc, theta, loss_list, acc_list, weights_list
gates = ['rx', 'ry', 'rz']
results = {}
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
print(f'Circuit type : {circuit_type} -> encoding : {encoding_gate} rotation : {rotation_gate}')
acc, theta, loss_list, acc_list, weights_history = model(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=10, theta=np.ones(N), shots=5000, encoding_type=encoding_gate, rotation_type=rotation_gate, delta=0.01)
results.update({circuit_type: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" {circuit_type} accuracy : {results.get(circuit_type).get('accuracy')}")
gates = ['rx', 'ry', 'rz']
labels = []
accuracies = []
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
labels.append(circuit_type)
accuracies.append(results.get(circuit_type).get('accuracy'))
plt.bar(labels, accuracies)
plt.show()
gates = ['rx', 'ry', 'rz']
labels = []
accuracies = []
for encoding_gate in gates:
for rotation_gate in gates:
circuit_type = encoding_gate + '-' + rotation_gate
if circuit_type != 'rz-rz':
plt.plot([x for x in range(1, 11)], results.get(circuit_type).get('acc_list'), label=circuit_type)
plt.xticks([x for x in range(1, 11)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.title('Circuit Type accuracy effect')
plt.legend()
plt.show()
N = 4
def model_1(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
loss_val = 1
i = 0
print('Epoch \t Loss \t Training Accuracy \t theta')
while loss_val > 0.17:
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_val = np.mean(loss_tmp)
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
i = i + 1
return theta, loss_list, acc_list, weights_list
theta_b, loss_list_b, acc_list_b, weights_history_b = model_1(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=20, theta=np.ones(N), shots=5000, encoding_type='ry', rotation_type='ry', delta=0.01)
N = 4
def model_2(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, encoding_type, rotation_type, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots, encoding_type, rotation_type)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots, encoding_type, rotation_type)
if loss(quantum_nn(X_i, new_theta, shots, encoding_type, rotation_type), Y_i) < loss(quantum_nn(X_i, theta, shots, encoding_type, rotation_type), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots, encoding_type, rotation_type))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
return theta, loss_list, acc_list, weights_list
for learning_rate in [0.001, 0.01, 0.05, 0.1]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=learning_rate, epochs=20, theta=np.ones(N), shots=5000, encoding_type='ry', rotation_type='ry', delta=0.01)
acc = accuracy(X_test, Y_test, theta, 5000, encoding_type='ry', rotation_type='ry')
results.update({learning_rate: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Learning rate : {learning_rate} accuracy : {results.get(learning_rate).get('accuracy')}")
for learning_rate in [0.001, 0.01, 0.05, 0.1]:
plt.plot([x for x in range(1, 21)], results.get(learning_rate).get('acc_list'), label=learning_rate)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('learning rates - accuracy effect')
plt.legend()
plt.show()
n_shots_results = {}
for n_shots in [1000, 5000, 10000, 50000]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=0.05, epochs=20, theta=np.ones(N), shots=n_shots, encoding_type='ry', rotation_type='ry', delta=0.01)
acc = accuracy(X_test, Y_test, theta, n_shots, encoding_type='ry', rotation_type='ry')
n_shots_results.update({n_shots: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Number of Shots : {n_shots} accuracy : {n_shots_results.get(n_shots).get('accuracy')}")
shots_list = [1000, 5000, 10000, 50000]
for n_shots in shots_list:
plt.plot([x for x in range(1, 21)], n_shots_results.get(n_shots).get('acc_list'), label=n_shots)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('n_shots')
plt.ylabel('Accuracy')
plt.title('number of shots - accuracy effecta')
plt.legend()
plt.show()
delta_results = {}
for delta in [0.01, 0.05, 0.1, 1]:
theta, loss_list, acc_list, weights_history = model_2(X_train, Y_train, X_test, Y_test, learning_rate=0.1, epochs=20, theta=np.ones(N), shots=1000, encoding_type='ry', rotation_type='ry', delta=delta)
acc = accuracy(X_test, Y_test, theta, 1000, encoding_type='ry', rotation_type='ry')
delta_results.update({delta: {'accuracy': acc, 'theta': theta, 'loss_list':loss_list, 'acc_list':acc_list, 'weights_history_list':weights_history}})
print(f" Delta : {delta} accuracy : {delta_results.get(delta).get('accuracy')}")
for delta in [0.01, 0.05, 0.1, 1]:
plt.plot([x for x in range(1, 21)], delta_results.get(delta).get('acc_list'), label=delta)
plt.xticks([x for x in range(1, 21)])
plt.yticks(np.arange (0, 1.1, 0.1))
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('Delta - accuracy effect')
plt.legend()
plt.show()
def feature_map_2(X, theta):
n = 4
qr = QuantumRegister(4)
c = ClassicalRegister(1)
qc = QuantumCircuit(qr,c )
for i, x in enumerate(X):
qc.ry(x, i)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
for i in range(4):
qc.rz(theta[i], i)
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
return qc, c
qc, c = feature_map_2(X[0], np.ones(4))
qc.draw('mpl')
def quantum_nn(X, theta, shots, encoding_type=None, rotation_type=None, simulator=True):
qc, c = feature_map_2(X, theta)
qc.measure(0, c)
backend = Aer.get_backend('qasm_simulator')
if simulator == False:
provider = IBMQ.load_account()
backend = provider.get_backend('ibm_oslo')
job = qiskit.execute(qc, backend, shots=shots)
result = job.result()
counts = result.get_counts(qc)
return counts['1']/shots
def accuracy(X, Y, theta, shots):
counter = 0
for X_i, Y_i, in zip(X, Y):
prediction = quantum_nn(X_i, theta, shots)
if prediction < 0.5 and Y_i == 0:
counter += 1
elif prediction >= 0.5 and Y_i == 1:
counter += 1
return counter/len(Y)
def gradient(X, Y, theta, delta, shots):
grad = []
for i in range(len(theta)):
dtheta = copy.copy(theta)
dtheta[i] += delta
prediction_1 = quantum_nn(X, dtheta, shots)
prediction_2 = quantum_nn(X, theta, shots)
grad.append((loss(prediction_1, Y) - loss(prediction_2, Y)) / delta)
return np.array(grad)
N = 4
def model_5(x_train, y_train, x_test, y_test, learning_rate, epochs, theta, shots, delta, optimizing_weights=False):
loss_list = []
acc_list = []
weights_list = []
print('Epoch \t Loss \t Training Accuracy \t theta')
for i in range(epochs):
loss_tmp = []
for X_i, Y_i in zip(x_train, y_train):
prediction = quantum_nn(X_i, theta, shots)
loss_tmp.append(loss(prediction, Y_i))
# update theta
new_theta = theta - learning_rate * gradient(X_i, Y_i, theta, delta, shots)
if loss(quantum_nn(X_i, new_theta, shots), Y_i) < loss(quantum_nn(X_i, theta, shots), Y_i):
theta = new_theta
loss_list.append(np.mean(loss_tmp))
acc_list.append(accuracy(X_train, Y_train, theta, shots))
weights_list.append(theta)
print(f'{i} \t {round(loss_list[-1], 3)} \t {round(acc_list[-1], 3)} \t {theta} \t {len(weights_list)}')
return theta, loss_list, acc_list, weights_list
theta, loss_list, acc_list, weights_list = model_5(X_train, Y_train, X_test, Y_test, 0.01, 100, [1, 1, 1, 1], 5000, 0.01)
accuracy(X_test, Y_test, theta, 5000)
plt.figure(figsize=(25, 8))
plt.plot([x for x in range(0, 100)], acc_list)
plt.xticks([x for x in range(0, 101, 10)])
plt.ylim([0.6, 1])
plt.xlabel('eposhs')
plt.ylabel('Accuracy')
plt.title('Accuracy')
plt.show()
from qiskit.circuit.library import ZZFeatureMap
num_features = X_train.shape[1]
feature_map = ZZFeatureMap(feature_dimension=num_features, reps=1)
feature_map.decompose().draw(output="mpl", fold=20)
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=num_features, reps=3)
ansatz.decompose().draw(output="mpl", fold=20)
from qiskit.algorithms.optimizers import COBYLA
optimizer = COBYLA(maxiter=100)
from qiskit.primitives import Sampler
sampler = Sampler()
from matplotlib import pyplot as plt
from IPython.display import clear_output
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
!pip install qiskit[machine-learning]
import time
from qiskit_machine_learning.algorithms.classifiers import VQC
vqc = VQC(
sampler=sampler,
feature_map=feature_map,
ansatz=ansatz,
optimizer=optimizer,
callback=callback_graph,
)
# clear objective value history
objective_func_vals = []
start = time.time()
vqc.fit(X_train, Y_train)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
train_score_q4 = vqc.score(X_train, Y_train)
test_score_q4 = vqc.score(X_test, Y_test)
print(f"Quantum QNN on the training dataset: {accuracy(X_train, Y_train, theta, 5000):.2f}")
print(f"Quantum QNN on the test dataset: {accuracy(X_test, Y_test, theta, 5000):.2f}")
print(f"Quantum VQC on the training dataset: {train_score_q4:.2f}")
print(f"Quantum VQC on the test dataset: {test_score_q4:.2f}")
train_acc_results_1 = []
test_acc_results_1 = []
train_acc_results_2 = []
test_acc_results_2 = []
start = time.time()
for _ in range(10):
print(_)
X_train, X_test, Y_train, Y_test = model_selection.train_test_split(X, Y, test_size=0.33, random_state=42)
theta, loss_list, acc_list, weights_list = model_5(X_train, Y_train, X_test, Y_test, 0.01, 100, [1, 1, 1, 1], 5000, 0.01)
train_acc_results_1.append(accuracy(X_train, Y_train, theta, 5000))
test_acc_results_1.append(accuracy(X_test, Y_test, theta, 5000))
objective_func_vals = []
vqc.fit(X_train, Y_train)
train_acc_results_2.append(vqc.score(X_train, Y_train))
test_acc_results_2.append(vqc.score(X_test, Y_test))
print(_)
elapsed = time.time() - start
print(f"Training time: {round(elapsed)} seconds")
from numpy.lib.function_base import average
average(train_acc_results_1), average(test_acc_results_1), average(train_acc_results_2), average(test_acc_results_2)
|
https://github.com/drobiu/quantum-project
|
drobiu
|
from qiskit import ClassicalRegister
from qiskit.circuit.quantumcircuit import QuantumCircuit
from qiskit.circuit.quantumregister import QuantumRegister
import numpy as np
from src.logic.oracles import oracle_a
from src.logic.query import query_cd
from src.util.util import run_qc
from src.arithmetic.add import add
from src.arithmetic.counter import count, mincount
from src.arithmetic.increment import decrement, increment
def FCPA(circuit, y_register, qy_register, s_register, memory, k, secret_string, c):
# k is number of available colours
# init
# q1 = QuantumRegister(num_position, "q1")
# q2 = QuantumRegister(num_bits_color * num_position)
# out = QuantumRegister(num_bits_color + 1, "o")
c = 3 - c
# step 1: apply H gate
circuit.h(y_register[:])
circuit.barrier()
# step 2: section that repeat k times
for d in range(k):
# Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# Apply oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string)
circuit.barrier()
# add in memory qubits
circuit = add(circuit, s_register, memory)
circuit.barrier()
# Apply inverse Oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string, do_inverse=True)
circuit.barrier()
# Apply inverse Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# step 3: count
circuit = count(circuit, memory, y_register)
circuit.barrier()
# step 4:ignore
# First logk lsb memory registers must be ignored.
# For visualizing Idendity gate will be applied
# Defining logk
logk = int(np.ceil(np.log2(k)))
for i in range(logk):
circuit.i(memory[i])
circuit.barrier()
# step 5: decrement
# Decrement
circuit = decrement(circuit, memory[logk::])
circuit.barrier()
# step 6: z gate to the now remaining LSB memory
circuit.z(memory[logk])
circuit.barrier()
# step 7: undo step 2:5
# undo decrement
circuit = increment(circuit, memory[logk::])
circuit.barrier()
# undo count
circuit = mincount(circuit, memory, y_register)
circuit.barrier()
# undo the loop
for d in range(k):
# cases:
# d not in s: position c +1
# d = c: position c+0
# d in s != c: position c+1, position d+1
# all mod 2
# position c +5 == 1
# position d +1 == 1
print(d)
# Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# Oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string)
circuit.barrier()
# Substractor
circuit = add(circuit, s_register, memory, amount=-1)
circuit.barrier()
# Apply inverse Oracle A
circuit = oracle_a(circuit, qy_register, s_register, secret_string, do_inverse=True)
circuit.barrier()
# Apply inverse Query
circuit = circuit.compose(query_cd(c, d), [*y_register, *qy_register])
circuit.barrier()
# step 8: Hadamard
circuit.h(y_register[:])
circuit.barrier()
return circuit
# Test
if __name__ == "__main__":
qy = QuantumRegister(8, name='qy')
y = QuantumRegister(4, name='y')
s = QuantumRegister(3)
c2 = ClassicalRegister(4)
memory = QuantumRegister(5)
qc = QuantumCircuit(y, qy, s, memory, c2)
# k is number of available colours
k = 4
# qc.x(qy[0])
qc = FCPA(qc, y, qy, s, memory, k, [3, 2, 1, 0], 3)
qc.barrier()
qc.measure(y[:], c2[::-1])
run_qc(qc, with_QI=False)
# print(qc.draw(output="text"))
|
https://github.com/Harcipan/QAI_GroverSim
|
Harcipan
|
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/qiskit-community/qiskit-alt
|
qiskit-community
|
import qiskit_alt
def do_jw_problem():
# qiskit_alt.Main.eval('include("examples/jw_example.jl")')
qiskit_alt.Main.eval('include("jw_example.jl")')
pauli_op = qiskit_alt.Main.eval("pauli_op")
spop_jl = qiskit_alt.QiskitQuantumInfo.SparsePauliOp(pauli_op)
spop = qiskit_alt.jlSparsePauliOp(spop_jl)
return spop
|
https://github.com/abbarreto/qiskit2
|
abbarreto
|
%run init.ipynb
1 + cos(2*pi/3) + 1j*sin(2*pi/3) + cos(4*pi/3) + 1j*sin(4*pi/3)
1 + cos(4*pi/3) + 1j*sin(4*pi/3) + cos(8*pi/3) + 1j*sin(8*pi/3)
cos(2*pi/3), cos(4*pi/3)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from scipy.interpolate import griddata
%matplotlib inline
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, AncillaRegister, transpile
from qiskit.circuit.library import IntegerComparator, WeightedAdder, LinearAmplitudeFunction
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits per dimension to represent the uncertainty
num_uncertainty_qubits = 2
# 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
# map to higher dimensional distribution
# for simplicity assuming dimensions are independent and identically distributed)
dimension = 2
num_qubits = [num_uncertainty_qubits] * dimension
low = low * np.ones(dimension)
high = high * np.ones(dimension)
mu = mu * np.ones(dimension)
cov = sigma**2 * np.eye(dimension)
# construct circuit
u = LogNormalDistribution(num_qubits=num_qubits, mu=mu, sigma=cov, bounds=(list(zip(low, high))))
# plot PDF of uncertainty model
x = [v[0] for v in u.values]
y = [v[1] for v in u.values]
z = u.probabilities
# z = map(float, z)
# z = list(map(float, z))
resolution = np.array([2**n for n in num_qubits]) * 1j
grid_x, grid_y = np.mgrid[min(x) : max(x) : resolution[0], min(y) : max(y) : resolution[1]]
grid_z = griddata((x, y), z, (grid_x, grid_y))
plt.figure(figsize=(10, 8))
ax = plt.axes(projection="3d")
ax.plot_surface(grid_x, grid_y, grid_z, cmap=plt.cm.Spectral)
ax.set_xlabel("Spot Price $S_1$ (\$)", size=15)
ax.set_ylabel("Spot Price $S_2$ (\$)", size=15)
ax.set_zlabel("Probability (\%)", size=15)
plt.show()
# determine number of qubits required to represent total loss
weights = []
for n in num_qubits:
for i in range(n):
weights += [2**i]
# create aggregation circuit
agg = WeightedAdder(sum(num_qubits), weights)
n_s = agg.num_sum_qubits
n_aux = agg.num_qubits - n_s - agg.num_state_qubits # number of additional qubits
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price_1 = 3
strike_price_2 = 4
# set the barrier threshold
barrier = 2.5
# map strike prices and barrier threshold from [low, high] to {0, ..., 2^n-1}
max_value = 2**n_s - 1
low_ = low[0]
high_ = high[0]
mapped_strike_price_1 = (
(strike_price_1 - dimension * low_) / (high_ - low_) * (2**num_uncertainty_qubits - 1)
)
mapped_strike_price_2 = (
(strike_price_2 - dimension * low_) / (high_ - low_) * (2**num_uncertainty_qubits - 1)
)
mapped_barrier = (barrier - low) / (high - low) * (2**num_uncertainty_qubits - 1)
# condition and condition result
conditions = []
barrier_thresholds = [2] * dimension
n_aux_conditions = 0
for i in range(dimension):
# target dimension of random distribution and corresponding condition (which is required to be True)
comparator = IntegerComparator(num_qubits[i], mapped_barrier[i] + 1, geq=False)
n_aux_conditions = max(n_aux_conditions, comparator.num_ancillas)
conditions += [comparator]
# set the approximation scaling for the payoff function
c_approx = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [0, mapped_strike_price_1, mapped_strike_price_2]
slopes = [0, 1, 0]
offsets = [0, 0, mapped_strike_price_2 - mapped_strike_price_1]
f_min = 0
f_max = mapped_strike_price_2 - mapped_strike_price_1
objective = LinearAmplitudeFunction(
n_s,
slopes,
offsets,
domain=(0, max_value),
image=(f_min, f_max),
rescaling_factor=c_approx,
breakpoints=breakpoints,
)
# define overall multivariate problem
qr_state = QuantumRegister(u.num_qubits, "state") # to load the probability distribution
qr_obj = QuantumRegister(1, "obj") # to encode the function values
ar_sum = AncillaRegister(n_s, "sum") # number of qubits used to encode the sum
ar_cond = AncillaRegister(len(conditions) + 1, "conditions")
ar = AncillaRegister(
max(n_aux, n_aux_conditions, objective.num_ancillas), "work"
) # additional qubits
objective_index = u.num_qubits
# define the circuit
asian_barrier_spread = QuantumCircuit(qr_state, qr_obj, ar_cond, ar_sum, ar)
# load the probability distribution
asian_barrier_spread.append(u, qr_state)
# apply the conditions
for i, cond in enumerate(conditions):
state_qubits = qr_state[(num_uncertainty_qubits * i) : (num_uncertainty_qubits * (i + 1))]
asian_barrier_spread.append(cond, state_qubits + [ar_cond[i]] + ar[: cond.num_ancillas])
# aggregate the conditions on a single qubit
asian_barrier_spread.mcx(ar_cond[:-1], ar_cond[-1])
# apply the aggregation function controlled on the condition
asian_barrier_spread.append(agg.control(), [ar_cond[-1]] + qr_state[:] + ar_sum[:] + ar[:n_aux])
# apply the payoff function
asian_barrier_spread.append(objective, ar_sum[:] + qr_obj[:] + ar[: objective.num_ancillas])
# uncompute the aggregation
asian_barrier_spread.append(
agg.inverse().control(), [ar_cond[-1]] + qr_state[:] + ar_sum[:] + ar[:n_aux]
)
# uncompute the conditions
asian_barrier_spread.mcx(ar_cond[:-1], ar_cond[-1])
for j, cond in enumerate(reversed(conditions)):
i = len(conditions) - j - 1
state_qubits = qr_state[(num_uncertainty_qubits * i) : (num_uncertainty_qubits * (i + 1))]
asian_barrier_spread.append(
cond.inverse(), state_qubits + [ar_cond[i]] + ar[: cond.num_ancillas]
)
print(asian_barrier_spread.draw())
print("objective qubit index", objective_index)
# plot exact payoff function
plt.figure(figsize=(7, 5))
x = np.linspace(sum(low), sum(high))
y = (x <= 5) * np.minimum(np.maximum(0, x - strike_price_1), strike_price_2 - strike_price_1)
plt.plot(x, y, "r-")
plt.grid()
plt.title("Payoff Function (for $S_1 = S_2$)", size=15)
plt.xlabel("Sum of Spot Prices ($S_1 + S_2)$", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# plot contour of payoff function with respect to both time steps, including barrier
plt.figure(figsize=(7, 5))
z = np.zeros((17, 17))
x = np.linspace(low[0], high[0], 17)
y = np.linspace(low[1], high[1], 17)
for i, x_ in enumerate(x):
for j, y_ in enumerate(y):
z[i, j] = np.minimum(
np.maximum(0, x_ + y_ - strike_price_1), strike_price_2 - strike_price_1
)
if x_ > barrier or y_ > barrier:
z[i, j] = 0
plt.title("Payoff Function", size=15)
plt.contourf(x, y, z)
plt.colorbar()
plt.xlabel("Spot Price $S_1$", size=15)
plt.ylabel("Spot Price $S_2$", size=15)
plt.xticks(size=15)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value
sum_values = np.sum(u.values, axis=1)
payoff = np.minimum(np.maximum(sum_values - strike_price_1, 0), strike_price_2 - strike_price_1)
leq_barrier = [np.max(v) <= barrier for v in u.values]
exact_value = np.dot(u.probabilities[leq_barrier], payoff[leq_barrier])
print("exact expected value:\t%.4f" % exact_value)
num_state_qubits = asian_barrier_spread.num_qubits - asian_barrier_spread.num_ancillas
print("state qubits: ", num_state_qubits)
transpiled = transpile(asian_barrier_spread, basis_gates=["u", "cx"])
print("circuit width:", transpiled.width())
print("circuit depth:", transpiled.depth())
asian_barrier_spread_measure = asian_barrier_spread.measure_all(inplace=False)
sampler = Sampler()
job = sampler.run(asian_barrier_spread_measure)
# evaluate the result
value = 0
probabilities = job.result().quasi_dists[0].binary_probabilities()
for i, prob in probabilities.items():
if prob > 1e-4 and i[-num_state_qubits:][0] == "1":
value += prob
# map value to original range
mapped_value = objective.post_processing(value) / (2**num_uncertainty_qubits - 1) * (high_ - low_)
print("Exact Operator Value: %.4f" % value)
print("Mapped Operator value: %.4f" % mapped_value)
print("Exact Expected Payoff: %.4f" % exact_value)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=asian_barrier_spread,
objective_qubits=[objective_index],
post_processing=objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100}))
result = ae.estimate(problem)
conf_int = (
np.array(result.confidence_interval_processed)
/ (2**num_uncertainty_qubits - 1)
* (high_ - low_)
)
print("Exact value: \t%.4f" % exact_value)
print(
"Estimated value:\t%.4f"
% (result.estimation_processed / (2**num_uncertainty_qubits - 1) * (high_ - low_))
)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/a24l/IBM_Qiskit_QGSS
|
a24l
|
import numpy as np
from qiskit.opflow import I, X, Y, Z, MatrixEvolution, PauliTrotterEvolution
from qiskit.circuit import Parameter
from qiskit import QuantumCircuit
from qiskit import Aer
from qiskit.compiler import transpile
import qc_grader
# Define which will contain the Paulis
pauli_list = [X,Y,Z,I]
# Define Paulis and add them to the list
###INSERT CODE BELOW THIS LINE
###DO NOT EDIT BELOW THIS LINE
for pauli in pauli_list:
print(pauli, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex1
grade_lab2_ex1(pauli_list)
# Define list of ladder operators
s_plus, s_minus = (X+(1j*Y))/2, (X-(1j*Y))/2
ladder_operator_list = [s_plus, s_minus]
# Define ladder operators and add the to the list
###INSERT CODE BELOW THIS LINE
###DO NOT EDIT BELOW THIS LINE
for ladder_operator in ladder_operator_list:
print(ladder_operator, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex2
grade_lab2_ex2(ladder_operator_list)
# Define list which will contain the matrices representing the Pauli operators
matrix_sigma_list = []
# Add matrix representation of Paulis to the list
###INSERT CODE BELOW THIS LINE
for op in pauli_list:
matrix_sigma_list.append(op.to_matrix())
###DO NOT EDIT BELOW THIS LINE
for matrix_sigma in matrix_sigma_list:
print(matrix_sigma, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex3
grade_lab2_ex3(matrix_sigma_list)
# Define a list which will contain the circuit representation of the Paulis
circuit_sigma_list = []
# Add circuits to list
###INSERT CODE BELOW THIS LINE
for gate in pauli_list:
circuit_sigma_list.append(gate.to_circuit())
###DO NOT EDIT BELOW THIS LINE
for circuit in circuit_sigma_list:
print(circuit, '\n')
from qc_grader.challenges.qgss_2022 import grade_lab2_ex4
grade_lab2_ex4(circuit_sigma_list)
# Define a variable theta to be a parameter with name 'theta'
theta = Parameter('theta')
# Set number of qubits to 1
qubits_count = 1
# Initialize a quantum circuit with one qubit
quantum_circuit = QuantumCircuit(qubits_count)
# Add a parametrized RX rotation on the qubit
###INSERT CODE BELOW THIS LINE
quantum_circuit.rx(theta,0)
###DO NOT EDIT BELOW THIS LINE
print(quantum_circuit)
quantum_circuit.draw()
from qc_grader.challenges.qgss_2022 import grade_lab2_ex5
grade_lab2_ex5(quantum_circuit)
# Set the value of the parameter
theta_value = np.pi
# Bind the value to the parametrized circuit
###INSERT CODE BELOW THIS LINE
quantum_circuit = quantum_circuit.bind_parameters({theta: theta_value})
###DO NOT EDIT BELOW THIS LINE
print(quantum_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex6
grade_lab2_ex6(quantum_circuit)
print(I.to_matrix())
# Use the formula above to define the Hamiltonian operator
###INSERT CODE BELOW THIS LINE
###DO NOT EDIT BELOW THIS LINE
H = 1/2*((I^I)+(X^X)+(Y^Y)+(Z^Z))
# Get its matrix representation
H_matrix = H.to_matrix()
print(H_matrix)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex7
grade_lab2_ex7(H_matrix)
# Define a parameter t for the time in the time evolution operator
t = Parameter('t')
# Follow the instructions above to define a time-evolution operator
###INSERT CODE BELOW THIS LINE
time_evolution_operator=(H*t).exp_i()
###DO NOT EDIT BELOW THIS LINE
print(time_evolution_operator)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex8
grade_lab2_ex8(time_evolution_operator)
# Set a total time for the time evolution
evolution_time = 0.5
# Instantiate a MatrixEvolution() object to convert the time evolution operator
qc = MatrixEvolution().convert(time_evolution_operator)
# and bind the value for the time parameter
bound_matrix_exponentiation_circuit = qc.bind_parameters({t: evolution_time})
###INSERT CODE BELOW THIS LINE
###DO NOT EDIT BELOW THIS LINE
print(bound_matrix_exponentiation_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex9
grade_lab2_ex9(bound_matrix_exponentiation_circuit)
# Define a value for the duration of the time-step
time_step_value = 0.1
# Instantiate a PauliTrotterEvolution() object and convert the time-evolution operator
# to then bind the value of the time step
###INSERT CODE BELOW THIS LINE
trotter_circuit=PauliTrotterEvolution().convert(time_evolution_operator)
bound_trotter_exponentiation_circuit = trotter_circuit.bind_parameters({t: time_step_value})
###DO NOT EDIT BELOW THIS LINE
print(bound_trotter_exponentiation_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex10
grade_lab2_ex10(bound_trotter_exponentiation_circuit)
# Define the number of steps needed to reach the previously set total time-evolution
steps = int(evolution_time/time_step_value)
# Compose the operator for a Trotter step several times to generate the
# operator for the full time-evolution
###INSERT CODE BELOW THIS LINE
trot = bound_trotter_exponentiation_circuit
U = trot
for i in range(steps-1):
trot@=U
total_time_evolution_circuit = trot
###DO NOT EDIT BELOW THIS LINE
print(total_time_evolution_circuit)
from qc_grader.challenges.qgss_2022 import grade_lab2_ex11
grade_lab2_ex11(total_time_evolution_circuit)
# Set number of qubits
num_qubits = 3
# Define time parameter
t = Parameter('t')
# Set total evolution time
evolution_time_t = 2
# Set size of time-step for Trotter evolution
time_step_value_t = 0.1
# Define the number of steps
steps_t = int(evolution_time_t/time_step_value_t)
# Create circuit
tight_binding_circuit = QuantumCircuit(num_qubits)
# Add initial state preparation
tight_binding_circuit.x(0)
# Define the Hamiltonian, the time-evolution operator, the Trotter step and the total evolution
###INSERT CODE BELOW THIS LINE
XXs = (I^X^X) + (X^X^I) #make the sigmax first term
YYs = (I^Y^Y) + (Y^Y^I) #make the sigmay second term
H = (XXs + YYs) # prepare the Hamiltonian
time_evolution_operator = (t * H).exp_i() # make the time evolution
trotter_circuit=PauliTrotterEvolution().convert(time_evolution_operator) #trotterize it.
bound = trotter_circuit.bind_parameters({t: time_step_value_t}) #bind it
#tight_binding_circuit.append(bound,[[0],[1],[2]])
for _ in range(steps_t):
tight_binding_circuit.append(bound, [[0], [1], [2]])
full_time_evolution_circuit=tight_binding_circuit
###DO NOT EDIT BELOW THIS LINE
print(full_time_evolution_circuit)
full_time_evolution_circuit.decompose().decompose().decompose().draw() # create a trotterized decomposition
from qc_grader.challenges.qgss_2022 import grade_lab2_ex12
grade_lab2_ex12(full_time_evolution_circuit)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
ghz = QuantumCircuit(5)
ghz.h(0)
ghz.cx(0,range(1,5))
ghz.draw(output='mpl')
|
https://github.com/JavaFXpert/qiskit4devs-workshop-notebooks
|
JavaFXpert
|
#!pip install qiskit
# Include the necessary imports for this program
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
# Create a Quantum Register with 3 qubits
qr = QuantumRegister(3)
# Create a Quantum Circuit from the quantum register. Because we're going to use
# the statevector_simulator, we won't measure the circuit or need classical registers.
circ = QuantumCircuit(qr)
# Place an X gate on the 2nd and 3rd wires. The topmost wire is index 0.
circ.x(qr[1])
circ.x(qr[2])
# Draw the circuit
circ.draw(output='mpl')
# Use the BasicAer statevector_simulator backend
from qiskit import BasicAer
backend_sv_sim = BasicAer.get_backend('statevector_simulator')
# Execute the circuit on the state vector simulator
job_sim = execute(circ, backend_sv_sim)
# Grab the results from the job.
result_sim = job_sim.result()
# Obtain the state vector for the quantum circuit
quantum_state = result_sim.get_statevector(circ, decimals=3)
# Output the quantum state vector in a manner that contains a comma-delimited string.
quantum_state
# Plot the state vector on a Q-sphere
from qiskit.tools.visualization import plot_state_qsphere
plot_state_qsphere(quantum_state)
# Create a Classical Register with 3 bits
cr = ClassicalRegister(3)
# Create the measurement portion of a quantum circuit
meas_circ = QuantumCircuit(qr, cr)
# Create a barrier that separates the gates from the measurements
meas_circ.barrier(qr)
# Measure the qubits into the classical registers
meas_circ.measure(qr, cr)
# Add the measument circuit to the original circuit
complete_circuit = circ + meas_circ
# Draw the new circuit
complete_circuit.draw(output='mpl')
# Use the BasicAer qasm_simulator backend
from qiskit import BasicAer
backend_sim = BasicAer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator, running it 1000 times.
job_sim = execute(complete_circuit, backend_sim, shots=1000)
# Grab the results from the job.
result_sim = job_sim.result()
# Print the counts, which are contained in a Python dictionary
counts = result_sim.get_counts(complete_circuit)
print(counts)
# Plot the results on a histogram
from qiskit.tools.visualization import plot_histogram
plot_histogram(counts)
# Include the necessary imports for this program
# Create a Quantum Register with 3 qubits
# Create a Quantum Circuit from the quantum register. Because we're going to use
# the statevector_simulator, we won't measure the circuit or need classical registers.
# Place Hadamard gate on each of the wires.
# Draw the circuit
# Use the BasicAer statevector_simulator backend
# Execute the circuit on the state vector simulator
# Grab the results from the job.
# Obtain the state vector for the quantum circuit
# Output the quantum state vector in a manner that contains a comma-delimited string.
# Plot the state vector on a Q-sphere
# Create a Classical Register with 3 bits
# Create the measurement portion of a quantum circuit
# Create a barrier that separates the gates from the measurements
# Measure the qubits into the classical registers
# Add the measument circuit to the original circuit
# Draw the new circuit
# Use the BasicAer qasm_simulator backend
# Execute the circuit on the qasm simulator, running it 1000 times.
# Grab the results from the job.
# Print the counts, which are contained in a Python dictionary
# Plot the results on a histogram
|
https://github.com/anpaschool/QC-School-Fall2020
|
anpaschool
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute, Aer
from qiskit.tools.visualization import plot_histogram, plot_bloch_multivector
#import numpy as np
q = QuantumRegister(2)
c = ClassicalRegister(2)
# Define Quantum circuit with 2 quantum register and 2 classical register
bell = QuantumCircuit(q,c)
# Create a Bell state
bell.x(q[0])
bell.x(q[1])
bell.h(q[0])
bell.cx(q[0], q[1])
# Draw circuit
bell.draw(output = 'mpl')
backend_statevector = Aer.get_backend('statevector_simulator')
job = execute(bell, backend_statevector)
result = job.result()
outputstate = result.get_statevector(bell, decimals = 3)
print(outputstate)
#plot_bloch_multivector(job.result().get_statevector(bell))
bell.measure(q, c)
bell.draw('mpl')
backend = Aer.get_backend('qasm_simulator')
job = execute(bell, backend)
result = job.result()
result.get_counts(bell)
plot_histogram(job.result().get_counts(bell))
import numpy as np
zero_ket = np.array([[1], [0]])
one_ket = np.array([[0], [1]])
ψ = (zero_ket + one_ket)/np.sqrt(2)
print("Density matrix of the equal superposition")
print(ψ @ ψ.T.conj())
print("Density matrix of the equally mixed state of |0><0| and |1><1|")
print((zero_ket @ zero_ket.T.conj()+one_ket @ one_ket.T.conj())/2)
def mixed_state(pure_state, visibility):
#density_matrix = pure_state @ pure_state.T.conj()
density_matrix = np.dot( pure_state, np.matrix.getH(pure_state) )
maximally_mixed_state = np.eye(4)/2**2
return visibility*density_matrix + (1-visibility)*maximally_mixed_state
ϕ = np.array([[1],[0],[0],[1]])/np.sqrt(2)
#print (array_to_latex(ϕ, pretext="$\phi$ = "))
print(f"Maximum visibility is a pure state: \n{mixed_state(ϕ, 1.0)}\n")
print(f"The state is still entangled with visibility 0.8:\n {mixed_state(ϕ, 0.8)}\n")
print(f"Entanglement is lost by 0.6:\n{mixed_state(ϕ, 0.6)}\n")
print(f"Barely any coherence remains by 0.2:\n{mixed_state(ϕ, 0.2)}\n")
import matplotlib.pyplot as plt
temperatures = [.5, 5, 2000]
energies = np.linspace(0, 20, 100)
fig, ax = plt.subplots()
for i, T in enumerate(temperatures):
probabilities = np.exp(-energies/T)
Z = probabilities.sum()
probabilities /= Z
ax.plot(energies, probabilities, linewidth=3, label = "$T_" + str(i+1)+"$="+str(T))
ax.set_xlim(0, 20)
ax.set_ylim(0, 1.2*probabilities.max())
ax.set_xticks([])
ax.set_yticks([])
ax.set_xlabel('Energy')
ax.set_ylabel('Probability')
ax.legend()
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer
cq = QuantumRegister(2,'code\_qubit\_')
lq = QuantumRegister(1,'ancilla\_qubit\_')
sb = ClassicalRegister(1,'syndrome\_bit')
qc = QuantumCircuit(cq,lq,sb)
qc.cx(cq[0],lq[0])
qc.cx(cq[1],lq[0])
qc.measure(lq,sb)
qc.draw('mpl')
qc_init = QuantumCircuit(cq)
(qc_init+qc).draw('mpl')
counts = execute( qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()
print('Results:',counts)
qc_init = QuantumCircuit(cq)
qc_init.x(cq)
(qc_init+qc).draw('mpl')
counts = execute(qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()
print('Results:',counts)
qc_init = QuantumCircuit(cq)
qc_init.h(cq[0])
qc_init.cx(cq[0],cq[1])
(qc_init+qc).draw('mpl')
counts = execute(qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()
print('Results:',counts)
qc_init = QuantumCircuit(cq)
qc_init.h(cq[0])
qc_init.cx(cq[0],cq[1])
qc_init.x(cq[0])
(qc_init+qc).draw('mpl')
counts = execute(qc_init+qc, Aer.get_backend('qasm_simulator')).result().get_counts()
print('Results:',counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import *
from qiskit.circuit import Gate
my_gate = Gate(name='my_gate', num_qubits=2, params=[])
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.append(my_gate, [qr[0], qr[1]])
circ.append(my_gate, [qr[1], qr[2]])
circ.draw()
# Build a sub-circuit
sub_q = QuantumRegister(2)
sub_circ = QuantumCircuit(sub_q, name='sub_circ')
sub_circ.h(sub_q[0])
sub_circ.crz(1, sub_q[0], sub_q[1])
sub_circ.barrier()
sub_circ.id(sub_q[1])
sub_circ.u(1, 2, -2, sub_q[0])
# Convert to a gate and stick it into an arbitrary place in the bigger circuit
sub_inst = sub_circ.to_instruction()
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.cx(qr[1], qr[2])
circ.append(sub_inst, [qr[1], qr[2]])
circ.draw()
decomposed_circ = circ.decompose() # Does not modify original circuit
decomposed_circ.draw()
from qiskit.circuit import Parameter
theta = Parameter('θ')
n = 5
qc = QuantumCircuit(5, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(5))
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
print(qc.parameters)
import numpy as np
theta_range = np.linspace(0, 2 * np.pi, 128)
circuits = [qc.bind_parameters({theta: theta_val})
for theta_val in theta_range]
circuits[-1].draw()
backend = BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(circuits, backend))
counts = job.result().get_counts()
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111)
ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')
ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'], fontsize=14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
import time
from itertools import combinations
from qiskit.compiler import assemble
from qiskit.test.mock import FakeVigo
start = time.time()
qcs = []
theta_range = np.linspace(0, 2*np.pi, 32)
for n in theta_range:
qc = QuantumCircuit(5)
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(n, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qcs.append(qc)
compiled_circuits = transpile(qcs, backend=FakeVigo())
qobj = assemble(compiled_circuits, backend=FakeVigo())
end = time.time()
print('Time compiling over set of bound circuits: ', end-start)
start = time.time()
qc = QuantumCircuit(5)
theta = Parameter('theta')
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(theta, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
transpiled_qc = transpile(qc, backend=FakeVigo())
qobj = assemble([transpiled_qc.bind_parameters({theta: n})
for n in theta_range], backend=FakeVigo())
end = time.time()
print('Time compiling over parameterized circuit, then binding: ', end-start)
phi = Parameter('phi')
sub_circ1 = QuantumCircuit(2, name='sc_1')
sub_circ1.rz(phi, 0)
sub_circ1.rx(phi, 1)
sub_circ2 = QuantumCircuit(2, name='sc_2')
sub_circ2.rx(phi, 0)
sub_circ2.rz(phi, 1)
qc = QuantumCircuit(4)
qr = qc.qregs[0]
qc.append(sub_circ1.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[2], qr[3]])
print(qc.draw())
# The following raises an error: "QiskitError: 'Name conflict on adding parameter: phi'"
# phi2 = Parameter('phi')
# qc.u3(0.1, phi2, 0.3, 0)
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0, 1)
qc.rz(p, 1)
qc.cx(1, 2)
qc.rz(p, 2)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())
print(larger_qc.decompose().draw())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
#Import general libraries (needed for functions)
import numpy as np
import matplotlib.pyplot as plt
from IPython import display
#Import the RB Functions
import qiskit.ignis.verification.randomized_benchmarking as rb
#Import Qiskit classes
import qiskit
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error
#Generate RB circuits (2Q RB)
#number of qubits
nQ=2
rb_opts = {}
#Number of Cliffords in the sequence
rb_opts['length_vector'] = [1, 10, 20, 50, 75, 100, 125, 150, 175, 200]
#Number of seeds (random sequences)
rb_opts['nseeds'] = 5
#Default pattern
rb_opts['rb_pattern'] = [[0,1]]
rb_circs, xdata = rb.randomized_benchmarking_seq(**rb_opts)
print(rb_circs[0][0])
# Create a new circuit without the measurement
qregs = rb_circs[0][-1].qregs
cregs = rb_circs[0][-1].cregs
qc = qiskit.QuantumCircuit(*qregs, *cregs)
for i in rb_circs[0][-1][0:-nQ]:
qc.data.append(i)
# The Unitary is an identity (with a global phase)
backend = qiskit.Aer.get_backend('unitary_simulator')
basis_gates = ['u1','u2','u3','cx'] # use U,CX for now
job = qiskit.execute(qc, backend=backend, basis_gates=basis_gates)
print(np.around(job.result().get_unitary(),3))
# Run on a noisy simulator
noise_model = NoiseModel()
# Depolarizing_error
dp = 0.005
noise_model.add_all_qubit_quantum_error(depolarizing_error(dp, 1), ['u1', 'u2', 'u3'])
noise_model.add_all_qubit_quantum_error(depolarizing_error(2*dp, 2), 'cx')
backend = qiskit.Aer.get_backend('qasm_simulator')
# Create the RB fitter
backend = qiskit.Aer.get_backend('qasm_simulator')
basis_gates = ['u1','u2','u3','cx']
shots = 200
qobj_list = []
rb_fit = rb.RBFitter(None, xdata, rb_opts['rb_pattern'])
for rb_seed,rb_circ_seed in enumerate(rb_circs):
print('Compiling seed %d'%rb_seed)
new_rb_circ_seed = qiskit.compiler.transpile(rb_circ_seed, basis_gates=basis_gates)
qobj = qiskit.compiler.assemble(new_rb_circ_seed, shots=shots)
print('Simulating seed %d'%rb_seed)
job = backend.run(qobj, noise_model=noise_model, backend_options={'max_parallel_experiments': 0})
qobj_list.append(qobj)
# Add data to the fitter
rb_fit.add_data(job.result())
print('After seed %d, alpha: %f, EPC: %f'%(rb_seed,rb_fit.fit[0]['params'][1], rb_fit.fit[0]['epc']))
plt.figure(figsize=(8, 6))
ax = plt.subplot(1, 1, 1)
# Plot the essence by calling plot_rb_data
rb_fit.plot_rb_data(0, ax=ax, add_label=True, show_plt=False)
# Add title and label
ax.set_title('%d Qubit RB'%(nQ), fontsize=18)
plt.show()
#Count the number of single and 2Q gates in the 2Q Cliffords
gates_per_cliff = rb.rb_utils.gates_per_clifford(qobj_list, xdata[0],basis_gates, rb_opts['rb_pattern'][0])
for i in range(len(basis_gates)):
print("Number of %s gates per Clifford: %f"%(basis_gates[i],
np.mean([gates_per_cliff[0][i],gates_per_cliff[1][i]])))
# Prepare lists of the number of qubits and the errors
ngates = np.zeros(7)
ngates[0:3] = gates_per_cliff[0][0:3]
ngates[3:6] = gates_per_cliff[1][0:3]
ngates[6] = gates_per_cliff[0][3]
gate_qubits = np.array([0, 0, 0, 1, 1, 1, -1], dtype=int)
gate_errs = np.zeros(len(gate_qubits))
gate_errs[[1, 4]] = dp/2 #convert from depolarizing error to epg (1Q)
gate_errs[[2, 5]] = 2*dp/2 #convert from depolarizing error to epg (1Q)
gate_errs[6] = dp*3/4 #convert from depolarizing error to epg (2Q)
#Calculate the predicted epc
pred_epc = rb.rb_utils.twoQ_clifford_error(ngates,gate_qubits,gate_errs)
print("Predicted 2Q Error per Clifford: %e"%pred_epc)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import qiskit.qasm3
program = """
OPENQASM 3.0;
include "stdgates.inc";
input float[64] a;
qubit[3] q;
bit[2] mid;
bit[3] out;
let aliased = q[0:1];
gate my_gate(a) c, t {
gphase(a / 2);
ry(a) c;
cx c, t;
}
gate my_phase(a) c {
ctrl @ inv @ gphase(a) c;
}
my_gate(a * 2) aliased[0], q[{1, 2}][0];
measure q[0] -> mid[0];
measure q[1] -> mid[1];
while (mid == "00") {
reset q[0];
reset q[1];
my_gate(a) q[0], q[1];
my_phase(a - pi/2) q[1];
mid[0] = measure q[0];
mid[1] = measure q[1];
}
if (mid[0]) {
let inner_alias = q[{0, 1}];
reset inner_alias;
}
out = measure q;
"""
circuit = qiskit.qasm3.loads(program)
circuit.draw("mpl")
|
https://github.com/minnukota381/Quantum-Computing-Qiskit
|
minnukota381
|
from qiskit import *
from qiskit.visualization import plot_bloch_multivector, visualize_transition, plot_histogram
# Create a quantum circuit with 2 qubits
# The default initial state of qubits will be |0> or [1,0]
qc = QuantumCircuit(2)
# Apply h gate to the control and target qubits
qc.h(0)
qc.h(1)
#Applying the CNOT gate
qc.cx(0,1)
# Once again apply h gate to the control and target qubits
qc.h(0)
qc.h(1)
#Draw the circuit
# qc.draw()
qc.draw('mpl')
#Get the backend for the circuit to display unitary matrix
backend = Aer.get_backend('unitary_simulator')
#execute the circuit using the backend
out = execute(qc,backend).result().get_unitary()
#import qiskit_textbook and display the combined unitary matrix
from qiskit_textbook.tools import array_to_latex
array_to_latex(out, pretext = "\\text{UnitaryMatrix} = ")
#Get the backend for the circuit (simulator or realtime system)
backend = Aer.get_backend('statevector_simulator')
#execute the circuit using the backend
out = execute(qc,backend).result().get_statevector()
#import qiskit_textbook and display the statevector
#from qiskit_textbook.tools import array_to_latex
array_to_latex(out, pretext = "\\text{Statevector} = ")
#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-translations-staging
|
qiskit-community
|
# You can choose different colors for the real and imaginary parts of the density matrix.
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_city
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
state = DensityMatrix(qc)
plot_state_city(state, color=['midnightblue', 'crimson'], title="New State City")
|
https://github.com/weiT1993/qiskit_helper_functions
|
weiT1993
|
"""
Teague Tomesh - 2/10/2020
Implementation of an n-bit ripple-carry adder.
Based on the specification given in Cuccaro, Draper, Kutin, Moulton.
(https://arxiv.org/abs/quant-ph/0410184v1)
"""
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
class RCAdder:
"""
An n-bit ripple-carry adder can be generated using an instance of the
RCAdder class by calling the gen_circuit() method.
This adder circuit uses 1 ancilla qubit to add together two values
a = a_(n-1)...a_0 and b = b_(n-1)...a_0
and store their sum
s = s_n...s_0
in the registers which initially held the b value.
The adder circuit uses 2 + binary_len(a) + binary_len(b) qubits.
The initial carry value is stored in the qubit at index = 0.
The binary value of a_i is stored in the qubit at index = 2*i + 2
The binary value of b_i is stored in the qubit at index = 2*i + 1
The high bit, s_n, is stored in the last qubit at index = num_qubits - 1
Attributes
----------
nbits : int
size, in bits, of the numbers the adder can handle
nq : int
number of qubits needed to construct the adder circuit
a, b : int
optional parameters to specify the numbers the adder should add.
Will throw an exception if the length of the bitstring representations
of a or b are greater than nbits.
use_toffoli : bool
Should the toffoli gate be used in the generated circuit or should it
first be decomposed
barriers : bool
should barriers be included in the generated circuit
regname : str
optional string to name the quantum and classical registers. This
allows for the easy concatenation of multiple QuantumCircuits.
qr : QuantumRegister
Qiskit QuantumRegister holding all of the quantum bits
circ : QuantumCircuit
Qiskit QuantumCircuit that represents the uccsd circuit
"""
def __init__(
self,
nbits=None,
a=0,
b=0,
use_toffoli=False,
barriers=False,
measure=False,
regname=None,
):
# number of bits the adder can handle
if nbits is None:
raise Exception("Number of bits must be specified")
else:
self.nbits = nbits
# given nbits, compute the number of qubits the adder will need
# number of qubits = 1 ancilla for the initial carry value
# + 2*nbits to hold both a and b
# + 1 more qubit to hold the high bit, s_n
self.nq = 1 + 2 * nbits + 1
# set flags for circuit generation
if len("{0:b}".format(a)) > nbits or len("{0:b}".format(b)) > nbits:
raise Exception(
"Binary representations of a and b must be less than or equal to nbits"
)
self.a = a
self.b = b
self.use_toffoli = use_toffoli
self.barriers = barriers
self.measure = measure
# create a QuantumCircuit object
if regname is None:
self.qr = QuantumRegister(self.nq)
else:
self.qr = QuantumRegister(self.nq, name=regname)
self.circ = QuantumCircuit(self.qr)
# add ClassicalRegister if measure is True
if self.measure:
self.cr = ClassicalRegister(self.nq)
self.circ.add_register(self.cr)
def _initialize_value(self, indices, value):
"""
Initialize the qubits at indices to the given value
Parameters
----------
indices : List[int]
List of qubit indices
value : int
The desired initial value
"""
binstr = "{0:b}".format(value)
for index, val in enumerate(reversed(binstr)):
if val == "1":
self.circ.x(indices[index])
def _toffoli(self, x, y, z):
"""
Implement the toffoli gate using 1 and 2 qubit gates
"""
self.circ.h(z)
self.circ.cx(y, z)
self.circ.tdg(z)
self.circ.cx(x, z)
self.circ.t(z)
self.circ.cx(y, z)
self.circ.t(y)
self.circ.tdg(z)
self.circ.cx(x, z)
self.circ.cx(x, y)
self.circ.t(z)
self.circ.h(z)
self.circ.t(x)
self.circ.tdg(y)
self.circ.cx(x, y)
def _MAJ(self, x, y, z):
"""
Implement the MAJ (Majority) gate described in Cuccaro, Draper, Kutin,
Moulton.
"""
self.circ.cx(z, y)
self.circ.cx(z, x)
if self.use_toffoli:
self.circ.ccx(x, y, z)
else:
# use a decomposed version of toffoli
self._toffoli(x, y, z)
def _UMA(self, x, y, z):
"""
Implement the UMA (UnMajority and Add) gate described in Cuccaro,
Draper, Kutin, Moulton.
"""
self.circ.x(y)
self.circ.cx(x, y)
if self.use_toffoli:
self.circ.ccx(x, y, z)
else:
# use a decomposed version of toffoli
self._toffoli(x, y, z)
self.circ.x(y)
self.circ.cx(z, x)
self.circ.cx(z, y)
def gen_circuit(self):
"""
Create a circuit implementing the ripple-carry adder
Returns
-------
QuantumCircuit
QuantumCircuit object of size self.nq
"""
high_bit_index = self.nq - 1
# initialize the a and b registers
a_indices = [2 * i + 2 for i in range(self.nbits)]
b_indices = [2 * i + 1 for i in range(self.nbits)]
for index_list, value in zip([a_indices, b_indices], [self.a, self.b]):
self._initialize_value(index_list, value)
# compute the carry bits, c_i, in order using the MAJ ladder
for a_i in a_indices:
self._MAJ(a_i - 2, a_i - 1, a_i)
# write the final carry bit value to the high bit register
self.circ.cx(a_indices[-1], high_bit_index)
# erase the carry bits in reverse order using the UMA ladder
for a_i in reversed(a_indices):
self._UMA(a_i - 2, a_i - 1, a_i)
if self.measure:
# measure the circuit
self.circ.measure_all()
return self.circ
if __name__ == "__main__":
adder = RCAdder(nbits=6, a=0, b=0, use_toffoli=True, measure=True)
circ = adder.gen_circuit()
print(circ)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import datetime
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
plt.rcParams.update({"text.usetex": True})
plt.rcParams["figure.figsize"] = (6,4)
mpl.rcParams["figure.dpi"] = 200
from qiskit_ibm_runtime import Estimator, Session, QiskitRuntimeService, Options
from qiskit.quantum_info import SparsePauliOp
from qiskit import QuantumCircuit
service = QiskitRuntimeService()
backend_simulator = "backend_simulator"
backend = "ibmq_montreal"
qubits = 4
trotter_layer = QuantumCircuit(qubits)
trotter_layer.rx(0.1, range(qubits))
trotter_layer.cx(0, 1)
trotter_layer.cx(2, 3)
trotter_layer.rz(-0.2, [1, 3])
trotter_layer.cx(0, 1)
trotter_layer.cx(2, 3)
trotter_layer.cx(1, 2)
trotter_layer.rz(-0.2, 2)
trotter_layer.cx(1, 2)
num_steps = 6
trotter_circuit_list = []
for i in range(1, num_steps):
trotter_circuit = QuantumCircuit(qubits)
for _ in range(i):
trotter_circuit = trotter_circuit.compose(trotter_layer)
trotter_circuit_list.append(trotter_circuit)
print(f'Trotter circuit with {i} Trotter steps`)
display(trotter_circuit.draw(fold=-1))
obs = SparsePauliOp("Z"*qubits)
obs_list = [obs]*len(trotter_circuit_list)
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # No optimization
options.resilience_level = 0 # No mitigation
with Session(service=service, backend=backend_simulator) as session:
estimator_sim = Estimator(session=session, options=options)
job_sim = estimator_sim.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_sim.job_id)
print(job_sim.result())
expvals_ideal = job_sim.result().values
expvals_ideal_variance = [metadata['variance']/metadata['shots'] for metadata in job_sim.result().metadata]
std_error_ideal = np.sqrt(expvals_ideal_variance)
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # No optimization
options.resilience_level = 0 # No error mitigation
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job.job_id)
print(job.result())
expvals_unmit = job.result().values
expvals_unmit_variance = [metadata['variance']/metadata['shots'] for metadata in job.result().metadata]
std_error_unmit = np.sqrt(expvals_unmit_variance)
options = Options()
options.execution.shots = 1000
options.optimization_level = 3 # Dynamical decoupling
options.resilience_level = 0 # No error mitigation
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job_dd = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_dd.job_id)
print(job_dd.result())
expvals_unmit_dd = job_dd.result().values
expvals_unmit_dd_variance = [metadata['variance']/metadata['shots'] for metadata in job_dd.result().metadata]
std_error_dd = np.sqrt(expvals_unmit_dd_variance)
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_dd, std_error_dd, fmt = 'o', linestyle = '-', capsize=4, c='blue', label='Dynamical decoupling')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
options = Options()
options.resilience_level = 1 # T-REx
options.optimization_level = 0 # No optimization
options.execution.shots = 1000
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job_trex = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_trex.job_id)
print(job_trex.result())
expvals_unmit_trex = job_trex.result().values
expvals_unmit_trex_variance = [metadata['variance']/metadata['shots'] for metadata in job_trex.result().metadata]
std_error_trex = np.sqrt(expvals_unmit_trex_variance)
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_trex, std_error_trex, fmt = 'o', linestyle = '-', capsize=4, c='violet', label='T-REx')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # No optimization
options.resilience_level = 2 # ZNE
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job_zne = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_zne.job_id)
print(job_zne.result())
expvals_unmit_zne = job_zne.result().values
# Standard error: coming soon!
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_zne, [0]*(num_steps-1), fmt = 'o', linestyle = '-', capsize=4, c='cyan', label='ZNE')
plt.xlabel('No. Trotter Steps')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
def interim_results_callback(job_id, result):
now = datetime.datetime.now()
print(now, "*** Callback ***", result, "\n")
options = Options()
options.optimization_level = 0 # No optimization
options.execution.shots = 100
options.resilience_level = 3 # PEC
options.environment.callback = interim_results_callback
with Session(service=service, backend=backend) as session:
estimator_pec = Estimator(session=session, options=options)
job_pec = estimator_pec.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_pec.job_id)
expvals_pec = job_pec.result().values
std_error_pec = [metadata['standard_error'] for metadata in job_pec.result().metadata]
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_pec, std_error_pec, fmt = 'd', linestyle = '-', capsize=4, c='orange', label='PEC')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
print(job_pec.result())
pec_metadata = job_pec.result().metadata
fig, ax = plt.subplots()
fig.subplots_adjust(right=0.75)
twin1 = ax.twinx()
twin2 = ax.twinx()
twin3 = ax.twinx()
twin2.spines.right.set_position(("axes", 1.2))
twin3.spines.right.set_position(("axes", 1.4))
p1, = ax.plot(range(1, num_steps), [m["total_mitigated_layers"] for m in pec_metadata] , "b-", label="Total mitigated layers")
p2, = twin1.plot(range(1, num_steps), [m["sampling_overhead"] for m in pec_metadata], "r-", label="Sampling overhead")
p3, = twin2.plot(range(1, num_steps), [m["samples"] for m in pec_metadata], "g-", label="Samples")
p4, = twin3.plot(range(1, num_steps), [m["shots"] for m in pec_metadata], "c-", label="Shots")
ax.set_ylim(0, 20)
twin1.set_ylim(0, 2.8)
twin2.set_ylim(0, 300)
twin3.set_ylim(0, 35000)
ax.set_xlabel("No. Trotter Steps")
ax.set_ylabel("Total mitigated layers")
twin1.set_ylabel("Sampling overhead")
twin2.set_ylabel("Samples")
twin3.set_ylabel("Shots")
ax.yaxis.label.set_color(p1.get_color())
twin1.yaxis.label.set_color(p2.get_color())
twin2.yaxis.label.set_color(p3.get_color())
twin3.yaxis.label.set_color(p4.get_color())
tkw = dict(size=4, width=1.5)
ax.tick_params(axis='y', colors=p1.get_color(), **tkw)
twin1.tick_params(axis='y', colors=p2.get_color(), **tkw)
twin2.tick_params(axis='y', colors=p3.get_color(), **tkw)
twin3.tick_params(axis='y', colors=p4.get_color(), **tkw)
plt.xticks([1, 2, 3, 4, 5])
ax.legend(handles=[p1, p2, p3, p4])
plt.title('PEC metadata')
plt.show()
from matplotlib.pyplot import figure
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_trex, std_error_trex, fmt = 'o', linestyle = '-', capsize=4, c='violet', label='T-REx')
plt.errorbar(range(1, num_steps), expvals_unmit_zne, [0]*(num_steps-1), fmt = 'o', linestyle = '-', capsize=4, c='cyan', label='ZNE')
plt.errorbar(range(1, num_steps), expvals_pec, std_error_pec, fmt = 'd', linestyle = '-', capsize=4, c='orange', label='PEC')
plt.title('Trotter circuits expectation value')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # no optimization
options.resilience_level = 2 # ZNE
options.resilience.noise_factors = [1, 2, 3, 4]
options.resilience.noise_amplifier = "LocalFoldingAmplifier"
options.resilience.extrapolator = "QuadraticExtrapolator"
with Session(service=service, backend='ibmq_montreal') as session:
estimator = Estimator(session=session, options=options)
job_zne_options = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_zne_options.job_id)
print(job_zne_options.result())
from qiskit.tools import jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/suvoooo/Qubits-Qiskit
|
suvoooo
|
path_to_file = '/content/drive/My Drive/Colab Notebooks/Quantum_Compute/'
from google.colab import drive
drive.mount('/content/drive/')
###### can we visualize the period
import math
import matplotlib.pyplot as plt
N = 21 #15
a_1 = 5 #13 # starting co-prime
a_2 = 11
x = list(range(N))
K_1 = [a_1**r % N for r in x]
K_2 = [a_2**r % N for r in x]
# K_3 = [a_3**r % N for r in x]
period = x[K_2[1:].index(1) + 1]
print ('period of the function: ', x[K_1[1:].index(1) + 1]) # (index of the 1 after the first 1) + 1
print ('period of the function: ', x[K_2[1:].index(1) + 1])
fig=plt.figure(figsize=(15, 5))
fig.add_subplot(121)
plt.plot(x, K_1, label='a = %d'%(a_1))
plt.xlabel('x', fontsize=14)
plt.ylabel(r'$a^x\, (\mathrm{mod}\, N)$', fontsize=14)
plt.legend(fontsize=12)
fig.add_subplot(122)
plt.plot(x, K_2, linestyle='--', color='purple', alpha=0.6, label='a = %d'%(a_2))
plt.axvline(x=period, lw=0.8, ls='--', color='magenta', alpha=0.6, label='Period=%d'%(period))
plt.axvline(x=2*period, lw=0.8, ls='--', color='magenta', alpha=0.6)
plt.xlabel('x', fontsize=14)
# plt.legend(fontsize=12)
# fig.add_subplot(133)
# plt.plot(x, K_3, linestyle=':', color='lime', alpha=0.6, label='a = 8')
# plt.xlabel('x', fontsize=12)
plt.legend(fontsize=12)
plt.savefig(path_to_file +'/Period_Mod_N.png', dpi=250)
plt.show()
# print ('period of the function: ', x[K_3[1:].index(1) + 1])
import numpy as np
for y in range(15):
exp = np.exp(-1j*2*np.pi*(3*y/16)) + np.exp(-1j*2*np.pi*(7*y/16)) + np.exp(-1j*2*np.pi*(11*y/16)) + np.exp(-1j*2*np.pi*(15*y/16))
if abs(exp) < 1e-10:
exp = 0
print(exp, y, abs(exp))
# !pip install qiskit
import qiskit as q
import numpy as np
import matplotlib.pyplot as plt
def c_amod15(a, power):
"""Controlled multiplication by a mod 15"""
if a not in [2,4,7,8,11,13]:
raise ValueError("'a' must be 2,4,7,8,11 or 13")
U = q.QuantumCircuit(4)
for iteration in range(power):
if a in [2,13]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
if a in [7,8]:
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
if a in [4, 11]:
U.swap(1,3)
U.swap(0,2)
if a in [7,11,13]:
for i in range(4):
U.x(i)
U = U.to_gate()
U.name = "%i^%i mod 15" % (a, power)
c_U = U.control()
return c_U
def qft_dagger(n):
"""n-qubit QFTdagger the first n qubits in circ"""
qc = q.QuantumCircuit(n)
# Don't forget the Swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
qc.name = "QFT†"
return qc
n_count = 8
a = 7
# Create QuantumCircuit with n_count counting qubits
# plus 4 qubits for U to act on
qc = q.QuantumCircuit(n_count + 4, n_count)
# # Initialize counting qubits
# # in state |+>
for i in range(n_count):
qc.h(i)
# # And auxiliary register in state |1>
qc.x(3+n_count)
# # Do controlled-U operations
for k in range(n_count):
qc.append(c_amod15(a, 2**k),
[k] + [i+n_count for i in range(4)])
# # Do inverse-QFT
qc.append(qft_dagger(n_count), range(n_count))
# # Measure circuit
qc.measure(range(n_count), range(n_count))
qc.draw() # -1 means 'do not fold'
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from collections import Counter
import matplotlib.pyplot as plt
import networkx as nx
import dwave_networkx as dnx
from dwave.embedding import pegasus
import dwave.system
pegasus_2 = dnx.pegasus_graph(2) # complete P_2
unit_cell_nodes = [8, 9, 10, 11, 36, 37, 38, 39]
odd_edges = [(node, node+1) for node in pegasus_2 if not node%2] # odd couplers
pegasus_k44 = dnx.pegasus_graph(2, node_list=unit_cell_nodes)
pegasus_k44_odd = dnx.pegasus_graph(2,node_list=unit_cell_nodes, edge_list=odd_edges)
pegasus_connections = dnx.pegasus_graph(2, edge_list=pegasus_2.edges(unit_cell_nodes))
pegasus_connections_odd = dnx.pegasus_graph(2, edge_list=odd_edges)
fig, ax = plt.subplots(1, 2, figsize=(16,8))
dnx.draw_pegasus(pegasus_k44, ax=ax[0], node_size=500, node_color='g', crosses=True)
dnx.draw_pegasus(pegasus_k44_odd, ax=ax[0], node_size=500, node_color='g', edge_color='r', width=3, crosses=True)
ax[0].set_title('Unit Cell', fontsize=18)
dnx.draw_pegasus(pegasus_2, ax=ax[1], node_size=150, node_color='b', crosses=True)
dnx.draw_pegasus(pegasus_connections_odd, ax=ax[1], node_size=150, node_color='b', edge_color='r', width=5, crosses=True)
dnx.draw_pegasus(pegasus_connections, ax=ax[1], node_size=100, node_color='cyan', edge_color='g',crosses=True)
dnx.draw_pegasus(pegasus_k44, ax=ax[1], node_size=150, node_color='g', crosses=True)
ax[1].set_title('Pegasus P2', fontsize=18)
plt.show()
# Define target Pegasus Graph
M = 16 # Defines number of qubits in Pegasus graph : 24M(M-1)
P_M = dnx.pegasus_graph(M, data = True) # allow the use of pegasus indizes
print(f"P 16: Nodes {P_M.number_of_nodes()} Connections {P_M.number_of_edges()}")
degree_ct = Counter()
for node, degree in dict(P_M.degree()).items():
degree_ct[degree] += 1
print("Degree to number of nodes: ", degree_ct)
# Embedding K_a into P_M
# Define source complete graph
a = 12*(M-1) # See section 3.1 in Next Generation Topologies White Paper
K_a = nx.complete_graph(a)
chain_ct = Counter()
print(f"complete graph of size {a=}")
embedding = pegasus.find_clique_embedding(K_a, target_graph=P_M) # heuristic search
if embedding:
print("Found Embedding")
for node, chainlist in embedding.items():
chain_ct[len(chainlist)] += 1
print(f"The embedding has {len(embedding.keys())} nodes")
print("Length of chains to number of logical qubits: ", chain_ct)
sampler = dwave.system.DWaveSampler()
print(f"Sampler with {sampler.properties['topology']['type']} topology and processor {sampler.properties['chip_id']}.")
print(f"Has default annealing time {sampler.properties['default_annealing_time']} "
+ f"and range {sampler.properties['annealing_time_range']} in microseconds")
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-function-docstring
"""Tests basic functionality of the sequence function"""
import unittest
from qiskit import QuantumCircuit, pulse
from qiskit.compiler import sequence, transpile, schedule
from qiskit.pulse.transforms import pad
from qiskit.providers.fake_provider import FakeParis
from qiskit.test import QiskitTestCase
class TestSequence(QiskitTestCase):
"""Test sequence function."""
def setUp(self):
super().setUp()
self.backend = FakeParis()
def test_sequence_empty(self):
self.assertEqual(sequence([], self.backend), [])
def test_transpile_and_sequence_agree_with_schedule(self):
qc = QuantumCircuit(2, name="bell")
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
sc = transpile(qc, self.backend, scheduling_method="alap")
actual = sequence(sc, self.backend)
expected = schedule(transpile(qc, self.backend), self.backend)
self.assertEqual(actual, pad(expected))
def test_transpile_and_sequence_agree_with_schedule_for_circuit_with_delay(self):
qc = QuantumCircuit(1, 1, name="t2")
qc.h(0)
qc.delay(500, 0, unit="ns")
qc.h(0)
qc.measure(0, 0)
sc = transpile(qc, self.backend, scheduling_method="alap")
actual = sequence(sc, self.backend)
expected = schedule(transpile(qc, self.backend), self.backend)
self.assertEqual(
actual.exclude(instruction_types=[pulse.Delay]),
expected.exclude(instruction_types=[pulse.Delay]),
)
@unittest.skip("not yet determined if delays on ancilla should be removed or not")
def test_transpile_and_sequence_agree_with_schedule_for_circuits_without_measures(self):
qc = QuantumCircuit(2, name="bell_without_measurement")
qc.h(0)
qc.cx(0, 1)
sc = transpile(qc, self.backend, scheduling_method="alap")
actual = sequence(sc, self.backend)
expected = schedule(transpile(qc, self.backend), self.backend)
self.assertEqual(actual, pad(expected))
|
https://github.com/InvictusWingsSRL/QiskitTutorials
|
InvictusWingsSRL
|
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit, transpile, qasm2, qasm3
from qiskit_aer import Aer
from qiskit.primitives import BackendSampler
from qiskit.providers.basic_provider import BasicProvider # instead of BasicAer
import Our_Qiskit_Functions as oq
import numpy as np
import math as m
import scipy as sci
import random
import matplotlib
import matplotlib.pyplot as plt
from itertools import permutations
S_simulator = Aer.backends(name='statevector_simulator')[0]
def Happiness( A ):
happiness = 0
for i in np.arange(len(A)):
if( A[i] == 1):
Mi = int(i)
if( A[i] == 2):
Be = int(i)
if( A[i] == 3):
Ma = int(i)
if( A[i] == 4):
Cu = int(i)
if( A[i] == 5):
Na = int(i)
if( A[i] == 6):
Cl = int(i)
if( A[i] == 7):
Wi = int(i)
if( (abs(Mi - Be)<=3) and (abs(Mi - Ma)<=3) ): # Michelle
happiness += 1
if( (abs(Be - Mi)<=3) and (abs(Be - Ma)<=3) ): # Betty
happiness += 1
if( (abs(Ma - Mi)<=3) and (abs(Ma - Be)<=3) ): # Margaret
happiness += 1
if( abs(Cu - Na)>=3 ): # Cullen
happiness += 1
if( (abs(Na - Cu)>=3) and (abs(Na - Be)==1) ): # Nate
happiness += 1
if( (abs(Cl - Cu)>1) and (abs(Cl - Wi)>1) ): # Clint
happiness += 1
happiness += 1 # Will
return happiness
#==================================================================================
perm = permutations([1, 2, 3, 4, 5, 6, 7])
All_Happy = []
all_perm = 0
for i in list(perm):
all_perm = all_perm + 1
if( Happiness(list(i)) == 7 ):
All_Happy.append( list(i) )
print('Total Combinations Where Everyone Is Happy: ',len(All_Happy))
q = QuantumRegister(2, name = 'q')
a = QuantumRegister(1, name = 'a')
qc= QuantumCircuit(q,a, name = 'qc')
#===================================
qc.h( q[0] )
qc.h( q[1] )
qc.barrier()
print('__ Initial State __')
oq.Wavefunction(qc, systems=[2,1])
#----------------------------------- Uc Operator
qc.x( q[0] )
qc.ccx( q[0], q[1], a[0] )
qc.cp( -m.pi/2, a[0], q[0] )
qc.ccx( q[0], q[1], a[0] )
qc.x( q[0] )
#-----------------------------------
print('\n__ After Applying The |01> Phase Term __')
oq.Wavefunction(qc, systems=[2,1], show_systems=[True,False])
print('\n__ Circuit Diagram __\n')
print(qc)
q = QuantumRegister(2, name = 'q')
a = QuantumRegister(1, name = 'a')
Uc_qc= QuantumCircuit(q,a, name = 'qc')
Uc_qc.h( q[0] )
Uc_qc.h( q[1] )
print('__ Initial State __')
oq.Wavefunction(Uc_qc, systems=[2,1])
#-------------------------------------- # |00> state
Uc_qc.x( q[0] )
Uc_qc.x( q[1] )
Uc_qc.ccx( q[0], q[1], a[0] )
Uc_qc.cp( m.pi/4, a[0], q[0] )
Uc_qc.ccx( q[0], q[1], a[0] )
Uc_qc.x( q[1] )
Uc_qc.x( q[0] )
#-------------------------------------- # |01> state
Uc_qc.x( q[0] )
Uc_qc.ccx( q[0], q[1], a[0] )
Uc_qc.cp( -m.pi/2, a[0], q[0] )
Uc_qc.ccx( q[0], q[1], a[0] )
Uc_qc.x( q[0] )
#-------------------------------------- # |10> state
Uc_qc.x( q[1] )
Uc_qc.ccx( q[0], q[1], a[0] )
Uc_qc.cp( -m.pi/4, a[0], q[0] )
Uc_qc.ccx( q[0], q[1], a[0] )
Uc_qc.x( q[1] )
#-------------------------------------- # |11> state
Uc_qc.ccx( q[0], q[1], a[0] )
Uc_qc.cp( m.pi/2, a[0], q[0] )
Uc_qc.ccx( q[0], q[1], a[0] )
print('\n__ After Applying U(C,gamma) __')
oq.Wavefunction(Uc_qc, systems=[2,1]);
q = QuantumRegister(3,name='q')
c = ClassicalRegister(3,name='c')
qc = QuantumCircuit(q,c,name='qc')
#=================================
qc.h( q[0] )
qc.h( q[1] )
qc.h( q[2] )
qc.p( m.pi/10, q[0] )
qc.p( m.pi/15, q[1] )
qc.p( m.pi/20, q[2] )
qc.rx( m.pi/5, q[0] )
qc.ry( m.pi/6, q[1])
qc.rz( m.pi/7, q[2])
#----------------------
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
qc.measure(q,c)
M = oq.Measurement( qc, shots=10000, return_M=True, print_M=False)
#-----------------------------------------------------------------
Energies = [ ['000',2],['100',-4],['010',-2],['110',4],['001',4],['101',-2],['011',-4],['111',2]]
EV1 = 0
EV2 = 0
for i in range( len(Energies) ):
EV1 = EV1 + M[ Energies[i][0] ] * Energies[i][1]/10000
EV2 = EV2 + np.real(SV[i]*np.conj(SV[i])) * Energies[i][1]
print('Energy Expectation Value From Measurements: ',round(EV1,4))
print('\nEnergy Expectation Value From Wavefunction: ',round(EV2,4))
q = QuantumRegister(2,name='q')
qc = QuantumCircuit(q,name='qc')
#===============================
qc.h( q[0] )
qc.h( q[1] )
qc.barrier()
print('___ Initial State ___')
oq.Wavefunction( qc )
#-------------------------------
qc.cx( q[0], q[1] )
qc.p( -m.pi/2, q[1] )
qc.cx( q[0], q[1] )
#-------------------------------
print('\n___ After e^{ZZ} ___')
oq.Wavefunction( qc )
print( qc )
gamma = 0.8
beta = 1.6
B = [-2.5,3.25,2.25]
#====================================
q = QuantumRegister(3,name='q')
c = ClassicalRegister(3,name='c')
qc = QuantumCircuit(q,c,name='qc')
#------------------------------------
for i in np.arange(3):
qc.h( q[int(i)] )
#---------------------- # Z1Z2
qc.cx( q[0], q[1] )
qc.p( 2*gamma, q[1] )
qc.cx( q[0], q[1] )
#---------------------- # Z1Z3
qc.cx( q[0], q[2] )
qc.p( 2*gamma, q[2] )
qc.cx( q[0], q[2] )
#---------------------- # Z2Z3
qc.cx( q[1], q[2] )
qc.p( 2*gamma, q[2] )
qc.cx( q[1], q[2] )
#---------------------- # Z_gamma gates
for j in np.arange(3):
qc.p( gamma*B[j], q )
#---------------------- # X_beta gates
for k in np.arange(3):
qc.rx( beta, q )
#------------------------------------
qc.measure( q,c )
oq.Measurement( qc, shots = 1 )
trials = 10000
M = oq.Measurement(qc, shots = trials, return_M=True)
K = list(M.keys())
Cz = { '000':-5.0, '001':1.5, '010':5.5, '011':8.0, '100':-6.0, '101':-3.5, '110':0.5, '111':-1.0 }
#----------------------------
F = 0
for k in np.arange( len(K) ):
F = F + (M[K[k]]*Cz[K[k]])/trials
print('\u03B3 = ',gamma,' \u03B2 = ',beta,' Expectation Value: ',round(F,3))
size = 100
Vert = [ [0,-2.5] , [1,3.25] , [2,1.25] ]
Edge = [ [0,1],[0,2],[1,2] ]
#-------------------------------------------------------
Energies,States = oq.Ising_Energy( Vert,Edge )
EV_grid = np.zeros(shape=(size,size))
EV_min = 10000
#========================================================
for b in np.arange(size):
beta = round(2*m.pi*(b/size),4)
for g in np.arange(size):
gamma = round(2*m.pi*(g/size),4)
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma )
EV = oq.E_Expectation_Value( qc, Energies )
EV_grid[b,g] = EV
if( EV < EV_min ):
Params = [beta,gamma]
EV_min = EV
print('Optimal Energy Expectation Value: ',EV_min,' \u03B3 = ',Params[1],' \u03B2 = ',Params[0],'\n')
#========================================================
fig, ax = plt.subplots()
show_text = False
show_ticks = False
oq.Heatmap(EV_grid, show_text, show_ticks, ax, "plasma", "Energy Expectation Value")
fig.tight_layout()
plt.show()
beta = Params[0] # Params is required from the previous cell of code
gamma = Params[1]
Vert = [ [0,-2.5] , [1,3.25] , [2,1.25] ]
Edge = [ [0,1],[0,2],[1,2] ]
Energies,States = oq.Ising_Energy( Vert,Edge )
#=======================================================
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma )
#========================================================
print('Optimal Energy Expectation Value: ',EV_min,' \u03B3 = ',Params[1],' \u03B2 = ',Params[0],'\n')
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
oq.Top_States(States,Energies,SV,8)
T = 8
Z = [m.sqrt(0.5),0,0,m.sqrt(0.5)]
Closest_IP = 0
#====================================
for i1 in np.arange(T+1):
t1 = i1*m.pi/T
for i2 in np.arange(T+1):
t2 = i2*m.pi/T
for i3 in np.arange(T+1):
t3 = i3*m.pi/T
for i4 in np.arange(T+1):
t4 = i4*m.pi/T
#---------------------
q = QuantumRegister(2)
qc= QuantumCircuit(q)
qc.rx( t1, q[0] )
qc.rx( t2, q[1] )
qc.ry( t3, q[0] )
qc.ry( t4, q[1] )
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
IP = (SV[0]*Z[0]) + (SV[1]*Z[1]) + (SV[2]*Z[2]) + (SV[3]*Z[3])
if( IP > Closest_IP ):
Closest_IP = IP
print( 'Largest Inner Product Overlap with the |00> + |11> state: ',round(np.real(Closest_IP),4 ))
T = 8
Z = [m.sqrt(0.5),0,0,m.sqrt(0.5)]
Closest_IP = 0
#====================================
for i1 in np.arange(T+1):
t1 = i1*m.pi/T
for i2 in np.arange(T+1):
t2 = i2*m.pi/T
for i3 in np.arange(T+1):
t3 = i3*m.pi/T
for i4 in np.arange(T+1):
t4 = i4*m.pi/T
#---------------------
q = QuantumRegister(2)
qc= QuantumCircuit(q)
qc.rx( t1, q[0] )
qc.rx( t2, q[1] )
qc.ry( t3, q[0] )
qc.ry( t4, q[1] )
qc.cx( q[0], q[1] )
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
IP = (SV[0]*Z[0]) + (SV[1]*Z[1]) + (SV[2]*Z[2]) + (SV[3]*Z[3])
if( IP > Closest_IP ):
Closest_IP = IP
print( 'Largest Inner Product Overlap with |\u03A8>: ',round(np.real(Closest_IP),4 ))
size = 100
Vert = [ [0,-2.5] , [1,3.25] , [2,1.25] ]
Edge = [ [0,1],[0,2],[1,2] ]
#-------------------------------------------------------
Energies,States = oq.Ising_Energy( Vert,Edge )
EV_grid = np.zeros(shape=(size,size))
EV_min = 10000
#========================================================
for b in np.arange(size):
beta = round(2*m.pi*(b/size),4)
for g in np.arange(size):
gamma = round(2*m.pi*(g/size),4)
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma, Mixing=2, p = 2)
EV = oq.E_Expectation_Value( qc, Energies )
EV_grid[b,g] = EV
if( EV < EV_min ):
Params = [beta,gamma]
EV_min = EV
print('Optimal Energy Expectation Value: ',EV_min,' \u03B3 = ',Params[1],' \u03B2 = ',Params[0],'\n')
#========================================================
fig, ax = plt.subplots()
show_text = False
show_ticks = False
oq.Heatmap(EV_grid, show_text, show_ticks, ax, "plasma", "Energy Expectation Value")
fig.tight_layout()
plt.show()
#========================================================
beta = Params[0]
gamma = Params[1]
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma, Mixing=2,p=2 )
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
oq.Top_States(States,Energies,SV,8)
size = 100
#-------------------------------------------------------
Vert = [ [0,-2.5] , [1,3.25] , [2,1.25] ]
Edge = [ [0,1,2],[1,2,1.5],[2,0,-3] ]
#-------------------------------------------------------
Energies,States = oq.Ising_Energy( Vert,Edge,Transverse=True )
EV_grid = np.zeros(shape=(size,size))
EV_min = 10000
#========================================================
for b in np.arange(size):
beta = round(2*m.pi*(b/size),4)
for g in np.arange(size):
gamma = round(2*m.pi*(g/size),4)
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma , Transverse=True, Mixing=2, p = 2 )
EV = oq.E_Expectation_Value( qc, Energies )
EV_grid[b,g] = EV
if( EV < EV_min ):
Params = [beta,gamma]
EV_min = EV
print('Optimal Energy Expectation Value: ',EV_min,' \u03B3 = ',Params[1],' \u03B2 = ',Params[0],'\n')
#========================================================
fig, ax = plt.subplots()
show_text = False
show_ticks = False
oq.Heatmap(EV_grid, show_text, show_ticks, ax, "plasma", "Energy Expectation Value")
fig.tight_layout()
plt.show()
#========================================================
beta = Params[0]
gamma = Params[1]
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma, Transverse=True, Mixing=2,p=2 )
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
oq.Top_States(States,Energies,SV,8)
def Ising_Gradient_Descent(qc, q, Circ, V, E, beta, gamma, epsilon, En, step, **kwargs):
'''
Input: qc (QuantumCircuit) q (QuantumRegister) Circ (Ising_Circuit function) V (array) E
beta (float) gamma (float) epsilon (float) En (array) step (float)
Keyword Arguments: Transverse (Bool) - Changes to the Transve
Mixing (integer) - Denotes which mixing circuit to use for U(B,beta)
Calculates and returns the next values for beta and gamma using gradient descent
'''
Trans = False
if 'Transverse' in kwargs:
if( kwargs['Transverse'] == True ):
Trans = True
Mixer = 1
if 'Mixing' in kwargs:
Mixer = int(kwargs['Mixing'])
params = [ [beta+epsilon,gamma],[beta-epsilon,gamma],[beta,gamma+epsilon],[beta,gamma-epsilon] ]
ev = []
for i in np.arange( 4 ):
q = QuantumRegister(len(V))
qc= QuantumCircuit(q)
for hh in np.arange(len(V)):
qc.h( q[int(hh)] )
Circ( qc, q, V, E, params[i][0], params[i][1], Transverse=Trans, Mixing=Mixer )
ev.append( E_Expectation_Value( qc, En ) )
beta_next = beta - ( ev[0] - ev[1] )/( 2.0*epsilon ) * step
gamma_next = gamma - ( ev[2] - ev[3] )/( 2.0*epsilon ) * step
return beta_next, gamma_next
epsilon = 0.001
step_size = 0.001
delta = 0.0001
#-------------------------------------------------------
Vert = [ [0,-2.5] , [1,3.25] , [2,1.25] ]
Edge = [ [0,1,2],[1,2,1.5],[2,0,-3] ]
#-------------------------------------------------------
Energies,States = oq.Ising_Energy( Vert,Edge, Transverse=True )
EV = 100
EV_old = 1000
EV_min = 1000
#========================================================
beta = 0.5
gamma = 4.5
s = 0
while( (abs( EV - EV_old ) > delta)):
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
if( s != 0 ):
beta,gamma = oq.Ising_Gradient_Descent(qc,q,oq.Ising_Circuit,Vert,Edge,beta,gamma,epsilon,Energies,step_size,Transverse=True,Mixing=1)
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma, Transverse=True, Mixing=2 )
EV_old = EV
EV = oq.E_Expectation_Value( qc, Energies )
if( EV < EV_min ):
Params = [beta,gamma]
EV_min = EV
s = int(s+1)
if (s % 10 == 0):
print('F(\u03B3,\u03B2): ',EV,' \u03B3 = ',round(gamma,6),' \u03B2 = ',round(beta,6),)
Energies
States
epsilon = 0.0001
step_size = 0.001
delta = 0.0001
#-------------------------------------------------------
Vert = [ [0,-2.5] , [1,3.25] , [2,1.25] ]
Edge = [ [0,1,2],[1,2,1.5],[2,0,-3] ]
#-------------------------------------------------------
Energies,States = oq.Ising_Energy( Vert,Edge, Transverse=True )
EV = 100
EV_old = 1000
EV_min = 1000
#========================================================
mixing = 2
pp = 1
beta = 2*m.pi*random.random()
gamma = 2*m.pi*random.random()
s = 0
while( (abs( EV - EV_old ) > delta) and ( EV < EV_old ) ):
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
if( s != 0 ):
beta,gamma = oq.Ising_Gradient_Descent(qc,q,oq.Ising_Circuit,Vert,Edge,beta,gamma,epsilon,Energies,step_size,Transverse=True,Mixing=mixing,p=pp)
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma, Transverse=True, Mixing=2 )
EV_old = EV
EV = oq.E_Expectation_Value( qc, Energies )
if( EV < EV_min ):
Params = [beta,gamma]
EV_min = EV
s = int(s+1)
print('F(\u03B3,\u03B2): ',EV,' \u03B3 = ',round(gamma,6),' \u03B2 = ',round(beta,6),)
#========================================================
print('\n-----------------------------------------------------------\n')
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.Ising_Circuit( qc, q, Vert, Edge, beta, gamma, Transverse=True, Mixing=mixing,p=pp)
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
oq.Top_States(States,Energies,SV,8)
p = 2
epsilon = 0.001
step_size = 0.01
delta = 0.001
#-------------------------------------------------------
Vert = [ 0,1,2,3,4,5 ]
Edge = [ [0,1],[0,2],[0,5],[1,2],[1,3],[2,3],[2,4],[3,5] ]
#-------------------------------------------------------
Energies,States = oq.MaxCut_Energy( Vert,Edge )
EV = -100
EV_old = -1000
EV_max = -1
#========================================================
beta = []
gamma = []
for pp in np.arange(p):
beta.append(2*m.pi*random.random())
gamma.append(2*m.pi*random.random())
s = 0
while( abs( EV - EV_old ) > delta ):
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
if( s != 0 ):
beta,gamma = oq.p_Gradient_Ascent(qc,q,oq.MaxCut_Circuit,Vert,Edge,p,beta,gamma,epsilon,Energies,step_size)
for i in np.arange(p):
oq.MaxCut_Circuit( qc, q, Vert, Edge, beta[i], gamma[i] )
#-------------------------------
EV_old = EV
EV = oq.E_Expectation_Value( qc, Energies )
if( EV_old > EV ):
EV_old = EV
if( EV > EV_max ):
Params = [beta,gamma]
EV_max = EV
s = int(s+1)
#-------------------------------
if( (m.floor( s/10 ) == s/10) or (s == 1) ):
params_string = ''
for ps in np.arange(p):
params_string = params_string + ' \u03B3'+str(int(ps+1))+' = '+str(round(gamma[ps],6))+' \u03B2'+str(int(ps+1))+' = '+str(round(beta[ps],6)) + ' '
params_string = params_string+' steps: '+str(s)
print('F(\u03B3,\u03B2): ',EV,' |',params_string)
print('\n _____ Terminated Gradient Ascent _____ \n')
params_string = ''
for ps in np.arange(p):
params_string = params_string + ' \u03B3'+str(int(ps+1))+' = '+str(round(gamma[ps],6))+' \u03B2'+str(int(ps+1))+' = '+str(round(beta[ps],6)) + ' '
params_string = params_string+' steps: '+str(s)
print('F(\u03B3,\u03B2): ',EV,' |',params_string,'\n')
#=========================================================
beta = Params[0]
gamma = Params[1]
p = len( Params[0] )
#------------------------------
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
for i in np.arange(p):
oq.MaxCut_Circuit( qc, q, Vert, Edge, beta[i], gamma[i] )
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
oq.Top_States(States,Energies,SV,12)
size = 100
#-------------------------------------------------------
Vert = [ 0,1,2,3,4,5 ]
Edge = [ [0,1],[0,2],[0,5],[1,2],[1,3],[2,3],[2,4],[3,5] ]
#-------------------------------------------------------
Energies,States = oq.MaxCut_Energy( Vert,Edge )
EV_grid = np.zeros(shape=(size,size))
EV_max = -1
#========================================================
for b in np.arange(size):
beta = round(2*m.pi*(b/size),4)
for g in np.arange(size):
gamma = round(2*m.pi*(g/size),4)
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.MaxCut_Circuit( qc, q, Vert, Edge, beta, gamma )
EV = oq.E_Expectation_Value( qc, Energies )
EV_grid[b,g] = EV
if( EV > EV_max ):
Params = [beta,gamma]
EV_max = EV
print('Energy Expectation Value: ',EV_max,' \u03B3 = ',Params[1],' \u03B2 = ',Params[0],'\n')
#--------------------------------------
fig, ax = plt.subplots()
show_text = False
show_ticks = False
oq.Heatmap(EV_grid, show_text, show_ticks, ax, "plasma", "Energy Expectation Value")
fig.tight_layout()
plt.show()
#======================================
beta = Params[0]
gamma = Params[1]
#--------------------------------------
q = QuantumRegister(len(Vert))
qc= QuantumCircuit(q)
for hh in np.arange(len(Vert)):
qc.h( q[int(hh)] )
oq.MaxCut_Circuit( qc, q, Vert, Edge, beta, gamma )
SV = oq.execute( qc, S_simulator, shots=1 ).result().get_statevector()
oq.Top_States(States,Energies,SV,12)
|
https://github.com/qiskit-community/qiskit-alt
|
qiskit-community
|
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow import X, Y, Z, I, PauliSumOp
from qiskit.circuit.library import TwoLocal
from qiskit import Aer
import numpy as np
import qiskit_alt, qiskit_alt.electronic_structure
from qiskit_alt.pauli_operators import PauliSum_to_SparsePauliOp
from qiskit.opflow import PauliSumOp
# Describe the Hydrogen molecule by fixing the location of each nucleus
geometry = [['H', [0., 0., 0.]], ['H', [0., 0., 0.739]]]
basis = 'sto3g'
# Compute the Fermionic operator of the molecule
fermi_op = qiskit_alt.electronic_structure.fermionic_hamiltonian(geometry, basis)
# Convert the Fermionic operator to a Pauli operator using the Jordan-Wigner transform
pauli_op = qiskit_alt.electronic_structure.jordan_wigner(fermi_op);
# Convert the Pauli operator into a sum of Pauli operators
# input to the VQE algorithm to compute the minimum eigenvalue
pauli_sum_op = PauliSumOp(pauli_op)
print(pauli_sum_op)
# Set up the ansatz of type TwoLOcal
ansatz = TwoLocal(num_qubits=4,
rotation_blocks=['ry'],
entanglement_blocks='cx',
reps=1,
entanglement='linear',
skip_final_rotation_layer= False)
# Initialize the COBYLA optimizer
optimizer = COBYLA(maxiter=500)
# Select the backend for the quantum_instance
backend = Aer.get_backend('aer_simulator_statevector')
# Run VQE algorithm
vqe = VQE(ansatz = ansatz,
optimizer = optimizer,
quantum_instance = backend)
# Compute the ground-state energy of the molecule
result = vqe.compute_minimum_eigenvalue(operator=pauli_sum_op)
print("The ground-state energy of the Hydrogen molecule is {} Hatree".format(round(result.eigenvalue.real,3)))
|
https://github.com/PavanCyborg/Quantum-Algorithms-Benchmarking
|
PavanCyborg
|
import sys
sys.path[1:1] = ["_common", "_common/qiskit"]
sys.path[1:1] = ["../../_common", "../../_common/qiskit"]
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import time
import math
import os
import numpy as np
np.random.seed(0)
import execute as ex
import metrics as metrics
from collections import defaultdict
from qiskit_nature.drivers import PySCFDriver, UnitsType, Molecule
from qiskit_nature.circuit.library import HartreeFock as HF
from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.transformers import ActiveSpaceTransformer
from qiskit_nature.operators.second_quantization import FermionicOp
from qiskit.opflow import PauliTrotterEvolution, CircuitStateFn, Suzuki
from qiskit.opflow.primitive_ops import PauliSumOp
# Function that converts a list of single and double excitation operators to Pauli operators
def readPauliExcitation(norb, circuit_id=0):
# load pre-computed data
filename = os.path.join(os.getcwd(), f'../qiskit/ansatzes/{norb}_qubit_{circuit_id}.txt')
with open(filename) as f:
data = f.read()
ansatz_dict = json.loads(data)
# initialize Pauli list
pauli_list = []
# current coefficients
cur_coeff = 1e5
# current Pauli list
cur_list = []
# loop over excitations
for ext in ansatz_dict:
if cur_coeff > 1e4:
cur_coeff = ansatz_dict[ext]
cur_list = [(ext, ansatz_dict[ext])]
elif abs(abs(ansatz_dict[ext]) - abs(cur_coeff)) > 1e-4:
pauli_list.append(PauliSumOp.from_list(cur_list))
cur_coeff = ansatz_dict[ext]
cur_list = [(ext, ansatz_dict[ext])]
else:
cur_list.append((ext, ansatz_dict[ext]))
# add the last term
pauli_list.append(PauliSumOp.from_list(cur_list))
# return Pauli list
return pauli_list
# Get the Hamiltonian by reading in pre-computed file
def ReadHamiltonian(nqubit):
# load pre-computed data
filename = os.path.join(os.getcwd(), f'../qiskit/Hamiltonians/{nqubit}_qubit.txt')
with open(filename) as f:
data = f.read()
ham_dict = json.loads(data)
# pauli list
pauli_list = []
for p in ham_dict:
pauli_list.append( (p, ham_dict[p]) )
# build Hamiltonian
ham = PauliSumOp.from_list(pauli_list)
# return Hamiltonian
return ham
def VQEEnergy(n_spin_orbs, na, nb, circuit_id=0, method=1):
'''
Construct a Qiskit circuit for VQE Energy evaluation with UCCSD ansatz
:param n_spin_orbs:The number of spin orbitals
:return: return a Qiskit circuit for this VQE ansatz
'''
# allocate qubits
num_qubits = n_spin_orbs
qr = QuantumRegister(num_qubits); cr = ClassicalRegister(num_qubits); qc = QuantumCircuit(qr, cr, name="main")
# number of alpha spin orbitals
norb_a = int(n_spin_orbs / 2)
# number of beta spin orbitals
norb_b = norb_a
# construct the Hamiltonian
qubit_op = ReadHamiltonian(n_spin_orbs)
# initialize the HF state
qc = HartreeFock(n_spin_orbs, na, nb)
# form the list of single and double excitations
singles = []
doubles = []
for occ_a in range(na):
for vir_a in range(na, norb_a):
singles.append((occ_a, vir_a))
for occ_b in range(norb_a, norb_a+nb):
for vir_b in range(norb_a+nb, n_spin_orbs):
singles.append((occ_b, vir_b))
for occ_a in range(na):
for vir_a in range(na, norb_a):
for occ_b in range(norb_a, norb_a+nb):
for vir_b in range(norb_a+nb, n_spin_orbs):
doubles.append((occ_a, vir_a, occ_b, vir_b))
# get cluster operators in Paulis
pauli_list = readPauliExcitation(n_spin_orbs, circuit_id)
# loop over the Pauli operators
for index, PauliOp in enumerate(pauli_list):
# get circuit for exp(-iP)
cluster_qc = ClusterOperatorCircuit(PauliOp)
# add to ansatz
qc.compose(cluster_qc, inplace=True)
# method 2, only compute the last term in the Hamiltonian
if method == 2:
# last term in Hamiltonian
qc_with_mea, is_diag = ExpectationCircuit(qc, qubit_op[1], num_qubits)
# return the circuit
return qc_with_mea
# now we need to add the measurement parts to the circuit
# circuit list
qc_list = []
diag = []
off_diag = []
for p in qubit_op:
# get the circuit with expectation measurements
qc_with_mea, is_diag = ExpectationCircuit(qc, p, num_qubits)
# add to circuit list
qc_list.append(qc_with_mea)
# diagonal term
if is_diag:
diag.append(p)
# off-diagonal term
else:
off_diag.append(p)
return qc_list
def ClusterOperatorCircuit(pauli_op):
# compute exp(-iP)
exp_ip = pauli_op.exp_i()
# Trotter approximation
qc_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=1, reps=1)).convert(exp_ip)
# convert to circuit
qc = qc_op.to_circuit()
# return this circuit
return qc
# Function that adds expectation measurements to the raw circuits
def ExpectationCircuit(qc, pauli, nqubit, method=1):
# a flag that tells whether we need to perform rotation
need_rotate = False
# copy the unrotated circuit
raw_qc = qc.copy()
# whether this term is diagonal
is_diag = True
# primitive Pauli string
PauliString = pauli.primitive.to_list()[0][0]
# coefficient
coeff = pauli.coeffs[0]
# basis rotation
for i, p in enumerate(PauliString):
target_qubit = nqubit - i - 1
if (p == "X"):
need_rotate = True
is_diag = False
raw_qc.h(target_qubit)
elif (p == "Y"):
raw_qc.sdg(target_qubit)
raw_qc.h(target_qubit)
need_rotate = True
is_diag = False
# perform measurements
raw_qc.measure_all()
# name of this circuit
raw_qc.name = PauliString + " " + str(np.real(coeff))
return raw_qc, is_diag
# Function that implements the Hartree-Fock state
def HartreeFock(norb, na, nb):
# initialize the quantum circuit
qc = QuantumCircuit(norb)
# alpha electrons
for ia in range(na):
qc.x(ia)
# beta electrons
for ib in range(nb):
qc.x(ib+int(norb/2))
# return the circuit
return qc
import json
from qiskit import execute, Aer
backend = Aer.get_backend("qasm_simulator")
precalculated_data = {}
def run(min_qubits=4, max_qubits=4, max_circuits=3, num_shots=4092 * 2**8, method=2):
print(f"... using circuit method {method}")
# validate parameters (smallest circuit is 4 qubits)
max_qubits = max(4, max_qubits)
min_qubits = min(max(4, min_qubits), max_qubits)
if min_qubits % 2 == 1: min_qubits += 1 # min_qubits must be even
if method == 1: max_circuits = 1
# Execute Benchmark Program N times for multiple circuit sizes
# Accumulate metrics asynchronously as circuits complete
for input_size in range(min_qubits, max_qubits + 1, 2):
# determine the number of circuits to execute fo this group
num_circuits = max_circuits
num_qubits = input_size
# decides number of electrons
na = int(num_qubits/4)
nb = int(num_qubits/4)
# decides number of unoccupied orbitals
nvira = int(num_qubits/2) - na
nvirb = int(num_qubits/2) - nb
# determine the size of t1 and t2 amplitudes
t1_size = na * nvira + nb * nvirb
t2_size = na * nb * nvira * nvirb
# random seed
np.random.seed(0)
# create the circuit for given qubit size and simulation parameters, store time metric
ts = time.time()
# circuit list
qc_list = []
# method 1 (default)
if method == 1:
# sample t1 and t2 amplitude
t1 = np.random.normal(size=t1_size)
t2 = np.random.normal(size=t2_size)
# construct all circuits
qc_list = VQEEnergy(num_qubits, na, nb, 0, method)
else:
# loop over circuits
for circuit_id in range(num_circuits):
# sample t1 and t2 amplitude
t1 = np.random.normal(size=t1_size)
t2 = np.random.normal(size=t2_size)
# construct circuit
qc_single = VQEEnergy(num_qubits, na, nb, circuit_id, method)
qc_single.name = qc_single.name + " " + str(circuit_id)
# add to list
qc_list.append(qc_single)
print(f"************\nExecuting VQE with num_qubits {num_qubits}")
for qc in qc_list:
# get circuit id
if method == 1:
circuit_id = qc.name.split()[0]
else:
circuit_id = qc.name.split()[2]
# collapse the sub-circuits used in this benchmark (for qiskit)
qc2 = qc.decompose()
# submit circuit for execution on target (simulator, cloud simulator, or hardware)
job = execute(qc, backend, shots=num_shots)
# executation result
result = job.result()
# get measurement counts
counts = result.get_counts(qc)
# initialize empty dictionary
dist = {}
for key in counts.keys():
prob = counts[key] / num_shots
dist[key] = prob
# add dist values to precalculated data for use in fidelity calculation
precalculated_data[f"{circuit_id}"] = dist
with open(f'precalculated_data_qubit_{num_qubits}_method1.json', 'w') as f:
f.write(json.dumps(
precalculated_data,
sort_keys=True,
indent=4,
separators=(',', ': ')
))
run()
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver()
problem = driver.run()
hamiltonian = problem.hamiltonian.second_q_op()
print(hamiltonian)
from qiskit_nature.second_q.mappers import JordanWignerMapper
mapper = JordanWignerMapper()
print(mapper.map(hamiltonian))
from qiskit_nature.second_q.mappers import QubitConverter
converter = QubitConverter(mapper)
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
algo = GroundStateEigensolver(converter, NumPyMinimumEigensolver())
print(algo.solve(problem))
algo = GroundStateEigensolver(mapper, NumPyMinimumEigensolver())
print(algo.solve(problem))
from qiskit_nature.second_q.mappers import ParityMapper
mapper = ParityMapper(num_particles=(1, 1))
print(mapper.map(hamiltonian))
tapered_mapper = problem.get_tapered_mapper(mapper)
print(type(tapered_mapper))
print(tapered_mapper.map(hamiltonian))
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()
print(type(mapper.map(hamiltonian)))
from qiskit_nature import settings
settings.use_pauli_sum_op = False
print(type(mapper.map(hamiltonian)))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import re
import numpy as np
import matplotlib.pyplot as plt
import itertools
import random
import pickle
plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
# 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.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2*dt,0)
qc.rz(2*dt,1)
qc.h(1)
qc.cx(1,0)
qc.rz(-2*dt, 0)
qc.rx(-2*dt, 1)
qc.rz(2*dt, 1)
qc.cx(1,0)
qc.h(1)
qc.rz(2*dt, 0)
return qc.to_instruction() if to_instruction else qc
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
# 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)
# Number of trotter steps
trotter_steps = 100 ### CAN BE >= 4
# Initialize quantum circuit for 3 qubits
# qr = QuantumRegister(7)
qc = QuantumCircuit(3)
# 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>)
qc.x([1,0]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
qc.x([1]) # encoding
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(trotter_steps):
qc.append(Trot_gate, [1, 0])
qc.cx(1, 2)
qc.cx(0, 1)
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time/trotter_steps})
# circuit optimization
t3_qc = transpile(qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_qc = transpile(t3_qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(t3_qc, [2, 1, 0])
# Display circuit for confirmation
# st_qcs[-1].decompose().draw() # view decomposition of trotter gates
st_qcs[-1].draw("mpl") # only view trotter gates
def zne_wrapper(qcs, scale_factors = [1.0, 2.0, 3.0]):
"""
"""
folded_qcs = [] #! ZNE用の回路
for qc in qcs:
folded_qcs.append([mitiq.zne.scaling.fold_gates_at_random(qc, scale) for scale in scale_factors]) #! ここでmitiqを使用
folded_qcs = list(itertools.chain(*folded_qcs)) #! folded_qcsを平坦化
return folded_qcs
zne_qcs = zne_wrapper(st_qcs)
print("number of circuits: ", len(zne_qcs))
zne_qcs[-3].draw("mpl")
zne_qcs_jakarta = transpile(zne_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"], initial_layout=[5,3,1])
zne_qcs_jakarta = transpile(zne_qcs_jakarta, optimization_level=3, basis_gates=["sx", "cx", "rz"])
zne_qcs_jakarta[-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 = 8192
reps = 8
jobs = []
for _ in range(reps):
# execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
# 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)
print('Job ID', cal_job.job_id())
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
mit_results = []
for job in jobs:
mit_results.append( meas_fitter.filter.apply(job.result()) )
# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits
def state_tomo(result, st_qcs):
# The expected final state; necessary to determine state tomography fidelity
target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Fit state tomography results
tomo_fitter = StateTomographyFitter(result, st_qcs)
rho_fit = tomo_fitter.fit(method='lstsq')
# Compute fidelity
fid = state_fidelity(rho_fit, target_state)
return fid
# Compute tomography fidelities for each repetition
fids = []
for result in mit_results:
fid = state_tomo(result, st_qcs)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
|
https://github.com/RishwiBT/Open-Quantum-Systems-Algorithms
|
RishwiBT
|
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import *
from ibm_quantum_widgets import *
# qiskit-ibmq-provider has been deprecated.
# Please see the Migration Guides in https://ibm.biz/provider_migration_guide for more detail.
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Estimator, Session, Options
# Loading your IBM Quantum account(s)
service = QiskitRuntimeService(channel="ibm_quantum")
# Invoke a primitive. For more details see https://docs.quantum.ibm.com/run/primitives
# result = Sampler().run(circuits).result()
from qiskit import quantum_info as qi
import numpy as np
# Define the probability for the bit-flip error
p = 0.5
# Define the Kraus operators for the bit-flip channel
I = np.eye(2) # Identity matrix
X = np.array([[0, 1], [1, 0]]) # Pauli-X matrix
E0 = np.sqrt(1-p) * I
E1 = np.sqrt(p) * X
# Create the bit-flip channel using Kraus operators
bit_flip_channel = qi.Kraus([E0, E1])
# Get the Choi matrix of the channel
choi_matrix = qi.Choi(bit_flip_channel)
# Alternatively, create the channel as a SuperOp and get the process matrix
process_matrix = qi.SuperOp(bit_flip_channel)
# Alternatively, create the channel as a SuperOp and get the process matrix
chi_matrix = qi.Chi(bit_flip_channel)
print("Choi matrix:")
print(choi_matrix.data)
print("\n(SuperOp representation):")
print(process_matrix.data)
print("\nProcess matrix ")
print(chi_matrix.data)
from qiskit import QuantumCircuit
from qiskit.quantum_info import Choi, Operator
# Create the entanglement circuit
qc = QuantumCircuit(2)
qc.h(0) # Apply Hadamard gate to the first qubit
qc.cx(0, 1) # Apply CNOT gate controlled by the first qubit targeting the second qubit
# Convert the circuit into an operator
operator = Operator(qc)
# Get the Choi matrix of the operator
choi_matrix = Choi(operator)
# Print the Choi matrix
print(choi_matrix)
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
# Create the entanglement circuit
qc = QuantumCircuit(2)
qc.h(0) # Apply Hadamard gate to the first qubit
qc.cx(0, 1) # Apply CNOT gate controlled by the first qubit targeting the second qubit
# Convert the circuit to a unitary operator
unitary = Operator(qc)
# The Kraus operator for this unitary process is the unitary itself
kraus_op = [unitary.data]
# Print out the Kraus operator
for i, k in enumerate(kraus_op):
print(f"Kraus operator K{i+1}:\n{k}\n")
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
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.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2*dt,0)
qc.rz(2*dt,1)
qc.h(1)
qc.cx(1,0)
qc.rz(-2*dt, 0)
qc.rx(-2*dt, 1)
qc.rz(2*dt, 1)
qc.cx(1,0)
qc.h(1)
qc.rz(2*dt, 0)
return qc.to_instruction() if to_instruction else qc
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
# 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)
# Number of trotter steps
trotter_steps = 15 ### CAN BE >= 4
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(7)
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>)
qc.x([5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(trotter_steps):
qc.append(Trot_gate, [qr[3], qr[5]])
qc.cx(qr[3], qr[1])
qc.cx(qr[5], qr[3])
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time/trotter_steps})
t3_qc = transpile(qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_qc = transpile(t3_qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(t3_qc, [qr[1], qr[3], qr[5]])
# Display circuit for confirmation
# st_qcs[-1].decompose().draw() # view decomposition of trotter gates
st_qcs[-1].draw("mpl") # only view trotter gates
# from qiskit.test.mock import FakeJakarta
# backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
print("provider:", provider)
backend = provider.get_backend("ibmq_jakarta")
shots = 8192
reps = 8
jobs = []
for _ in range(reps):
# execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
# 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=[5,3,1])
print('Job ID', cal_job.job_id())
dt_now = datetime.datetime.now()
print(dt_now)
with open("jobs_jakarta_15step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"jobs": jobs, "cal_job": cal_job}, f)
with open("job_ids_jakarta_15step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"job_ids": [job.job_id() for job in jobs], "cal_job_id": cal_job.job_id()}, f)
with open("properties_jakarta" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump(backend.properties(), f)
filename = "job_ids_jakarta_15step_20220412_031437_.pkl" # change here
with open(filename, "rb") as f:
job_ids_dict = pickle.load(f)
job_ids = job_ids_dict["job_ids"]
cal_job_id = job_ids_dict["cal_job_id"]
retrieved_jobs = []
for job_id in job_ids:
retrieved_jobs.append(backend.retrieve_job(job_id))
retrieved_cal_job = backend.retrieve_job(cal_job_id)
cal_results = retrieved_cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
# set the target state
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
fids = []
for job in retrieved_jobs:
mit_results = meas_fitter.filter.apply(job.result()) # apply QREM
rho = StateTomographyFitter(mit_results, st_qcs).fit(method='lstsq')
fid = state_fidelity(rho, target_state)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# -*- coding: utf-8 -*-
# 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.
"""Utils for reading a user preference config files."""
import configparser
import os
from qiskit import exceptions
DEFAULT_FILENAME = os.path.join(os.path.expanduser("~"),
'.qiskit', 'settings.conf')
class UserConfig:
"""Class representing a user config file
The config file format should look like:
[default]
circuit_drawer = mpl
"""
def __init__(self, filename=None):
"""Create a UserConfig
Args:
filename (str): The path to the user config file. If one isn't
specified ~/.qiskit/settings.conf is used.
"""
if filename is None:
self.filename = DEFAULT_FILENAME
else:
self.filename = filename
self.settings = {}
self.config_parser = configparser.ConfigParser()
def read_config_file(self):
"""Read config file and parse the contents into the settings attr."""
if not os.path.isfile(self.filename):
return
self.config_parser.read(self.filename)
if 'default' in self.config_parser.sections():
circuit_drawer = self.config_parser.get('default',
'circuit_drawer')
if circuit_drawer:
if circuit_drawer not in ['text', 'mpl', 'latex',
'latex_source']:
raise exceptions.QiskitUserConfigError(
"%s is not a valid circuit drawer backend. Must be "
"either 'text', 'mpl', 'latex', or 'latex_source'"
% circuit_drawer)
self.settings['circuit_drawer'] = circuit_drawer
def get_config():
"""Read the config file from the default location or env var
It will read a config file at either the default location
~/.qiskit/settings.conf or if set the value of the QISKIT_SETTINGS env var.
It will return the parsed settings dict from the parsed config file.
Returns:
dict: The settings dict from the parsed config file.
"""
filename = os.getenv('QISKIT_SETTINGS', DEFAULT_FILENAME)
if not os.path.isfile(filename):
return {}
user_config = UserConfig(filename)
user_config.read_config_file()
return user_config.settings
|
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.
"""
Test circuits and reference outputs for multiplexer gates.
"""
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from test.terra.utils.multiplexer import multiplexer_multi_controlled_x
from test.terra.reference.ref_2q_clifford import (cx_gate_counts_nondeterministic,
cx_gate_counts_deterministic)
from test.terra.reference.ref_non_clifford import (ccx_gate_counts_nondeterministic,
ccx_gate_counts_deterministic)
def multiplexer_cx_gate_circuits_deterministic(final_measure=True):
"""multiplexer-gate simulating cx gate, test circuits with deterministic counts."""
circuits = []
qr = QuantumRegister(2)
if final_measure:
cr = ClassicalRegister(2)
regs = (qr, cr)
else:
regs = (qr, )
num_control_qubits = 1
# CX01, |00> state
circuit = QuantumCircuit(*regs)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[0], qr[1]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10, |00> state
circuit = QuantumCircuit(*regs)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[1], qr[0]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX01.(X^I), |10> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[0], qr[1]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10.(I^X), |01> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[0])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[1], qr[0]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX01.(I^X), |11> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[0])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[0], qr[1]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10.(X^I), |11> state
circuit = QuantumCircuit(*regs)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[1], qr[0]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX01.(X^X), |01> state
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[0], qr[1]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10.(X^X), |10> state
circuit = QuantumCircuit(*regs)
circuit.x(qr)
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[1], qr[0]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
return circuits
def multiplexer_cx_gate_circuits_nondeterministic(final_measure=True):
"""Multiplexer CX-like gate test circuits with non-deterministic counts."""
circuits = []
qr = QuantumRegister(2)
if final_measure:
cr = ClassicalRegister(2)
regs = (qr, cr)
else:
regs = (qr, )
# cx gate only has one control qubit
num_control_qubits = 1
# CX01.(I^H), Bell state
circuit = QuantumCircuit(*regs)
circuit.h(qr[0])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[0], qr[1]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CX10.(H^I), Bell state
circuit = QuantumCircuit(*regs)
circuit.h(qr[1])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits), [qr[1], qr[0]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
return circuits
def multiplexer_cx_gate_counts_deterministic(shots, hex_counts=True):
""" The counts are exactly the same as the cx gate """
return cx_gate_counts_deterministic(shots, hex_counts)
def multiplexer_cx_gate_counts_nondeterministic(shots, hex_counts=True):
""" The counts are exactly the same as the cx gate """
return cx_gate_counts_nondeterministic(shots, hex_counts)
# ==========================================================================
# Multiplexer-gate (CCX-like)
# ==========================================================================
def multiplexer_ccx_gate_circuits_deterministic(final_measure=True):
"""multiplexer-gate simulating ccx gate, test circuits with deterministic counts."""
circuits = []
qr = QuantumRegister(3)
if final_measure:
cr = ClassicalRegister(3)
regs = (qr, cr)
else:
regs = (qr, )
# because ccx has two control qubits and one target
num_control_qubits = 2
# CCX(0,1,2)
circuit = QuantumCircuit(*regs)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits),
[qr[0], qr[1], qr[2]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# (I^X^X).CCX(0,1,2).(I^X^X) -> |100>
circuit = QuantumCircuit(*regs)
circuit.x(qr[0])
circuit.barrier(qr)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits),
[qr[0], qr[1], qr[2]])
circuit.barrier(qr)
circuit.x(qr[0])
circuit.barrier(qr)
circuit.x(qr[1])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# CCX(2,1,0)
circuit = QuantumCircuit(*regs)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits),
[qr[2], qr[1], qr[0]])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# (X^X^I).CCX(2,1,0).(X^X^I) -> |001>
circuit = QuantumCircuit(*regs)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.x(qr[2])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits),
[qr[2], qr[1], qr[0]])
circuit.barrier(qr)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.x(qr[2])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
return circuits
def multiplexer_ccx_gate_circuits_nondeterministic(final_measure=True):
"""mukltiplexer CCX-like gate test circuits with non-deterministic counts."""
circuits = []
qr = QuantumRegister(3)
if final_measure:
cr = ClassicalRegister(3)
regs = (qr, cr)
else:
regs = (qr, )
# because ccx has two control qubits and one target
num_control_qubits = 2
# (I^X^I).CCX(0,1,2).(I^X^H) -> |000> + |101>
circuit = QuantumCircuit(*regs)
circuit.h(qr[0])
circuit.barrier(qr)
circuit.x(qr[1])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits),
[qr[0], qr[1], qr[2]])
circuit.barrier(qr)
circuit.x(qr[1])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
# (X^I^I).CCX(2,1,0).(X^H^I) -> |000> + |011>
circuit = QuantumCircuit(*regs)
circuit.h(qr[1])
circuit.barrier(qr)
circuit.x(qr[2])
circuit.barrier(qr)
circuit.append(multiplexer_multi_controlled_x(num_control_qubits),
[qr[2], qr[1], qr[0]])
circuit.barrier(qr)
circuit.x(qr[2])
if final_measure:
circuit.barrier(qr)
circuit.measure(qr, cr)
circuits.append(circuit)
return circuits
def multiplexer_ccx_gate_counts_deterministic(shots, hex_counts=True):
""" The counts are exactly the same as the ccx gate """
return ccx_gate_counts_deterministic(shots, hex_counts)
def multiplexer_ccx_gate_counts_nondeterministic(shots, hex_counts=True):
""" The counts are exactly the same as the ccx gate """
return ccx_gate_counts_nondeterministic(shots, hex_counts)
|
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import json
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import ZFeatureMap
from qiskit.quantum_info import SparsePauliOp
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
from qiskit_machine_learning.neural_networks import EstimatorQNN
from sklearn.model_selection import train_test_split
algorithm_globals.random_seed = 12345
# We now define a two qubit unitary as defined in [3]
def conv_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
target.cx(1, 0)
target.rz(np.pi / 2, 0)
return target
# Let's draw this circuit and see what it looks like
params = ParameterVector("θ", length=3)
circuit = conv_circuit(params)
circuit.draw("mpl")
def conv_layer(num_qubits, param_prefix):
qc = QuantumCircuit(num_qubits, name="Convolutional Layer")
qubits = list(range(num_qubits))
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits * 3)
for q1, q2 in zip(qubits[0::2], qubits[1::2]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
for q1, q2 in zip(qubits[1::2], qubits[2::2] + [0]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, qubits)
return qc
circuit = conv_layer(4, "θ")
circuit.decompose().draw("mpl")
def pool_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
return target
params = ParameterVector("θ", length=3)
circuit = pool_circuit(params)
circuit.draw("mpl")
def pool_layer(sources, sinks, param_prefix):
num_qubits = len(sources) + len(sinks)
qc = QuantumCircuit(num_qubits, name="Pooling Layer")
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits // 2 * 3)
for source, sink in zip(sources, sinks):
qc = qc.compose(pool_circuit(params[param_index : (param_index + 3)]), [source, sink])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, range(num_qubits))
return qc
sources = [0, 1]
sinks = [2, 3]
circuit = pool_layer(sources, sinks, "θ")
circuit.decompose().draw("mpl")
def generate_dataset(num_images):
images = []
labels = []
hor_array = np.zeros((6, 8))
ver_array = np.zeros((4, 8))
j = 0
for i in range(0, 7):
if i != 3:
hor_array[j][i] = np.pi / 2
hor_array[j][i + 1] = np.pi / 2
j += 1
j = 0
for i in range(0, 4):
ver_array[j][i] = np.pi / 2
ver_array[j][i + 4] = np.pi / 2
j += 1
for n in range(num_images):
rng = algorithm_globals.random.integers(0, 2)
if rng == 0:
labels.append(-1)
random_image = algorithm_globals.random.integers(0, 6)
images.append(np.array(hor_array[random_image]))
elif rng == 1:
labels.append(1)
random_image = algorithm_globals.random.integers(0, 4)
images.append(np.array(ver_array[random_image]))
# Create noise
for i in range(8):
if images[-1][i] == 0:
images[-1][i] = algorithm_globals.random.uniform(0, np.pi / 4)
return images, labels
images, labels = generate_dataset(50)
train_images, test_images, train_labels, test_labels = train_test_split(
images, labels, test_size=0.3
)
fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={"xticks": [], "yticks": []})
for i in range(4):
ax[i // 2, i % 2].imshow(
train_images[i].reshape(2, 4), # Change back to 2 by 4
aspect="equal",
)
plt.subplots_adjust(wspace=0.1, hspace=0.025)
feature_map = ZFeatureMap(8)
feature_map.decompose().draw("mpl")
feature_map = ZFeatureMap(8)
ansatz = QuantumCircuit(8, name="Ansatz")
# First Convolutional Layer
ansatz.compose(conv_layer(8, "с1"), list(range(8)), inplace=True)
# First Pooling Layer
ansatz.compose(pool_layer([0, 1, 2, 3], [4, 5, 6, 7], "p1"), list(range(8)), inplace=True)
# Second Convolutional Layer
ansatz.compose(conv_layer(4, "c2"), list(range(4, 8)), inplace=True)
# Second Pooling Layer
ansatz.compose(pool_layer([0, 1], [2, 3], "p2"), list(range(4, 8)), inplace=True)
# Third Convolutional Layer
ansatz.compose(conv_layer(2, "c3"), list(range(6, 8)), inplace=True)
# Third Pooling Layer
ansatz.compose(pool_layer([0], [1], "p3"), list(range(6, 8)), inplace=True)
# Combining the feature map and ansatz
circuit = QuantumCircuit(8)
circuit.compose(feature_map, range(8), inplace=True)
circuit.compose(ansatz, range(8), inplace=True)
observable = SparsePauliOp.from_list([("Z" + "I" * 7, 1)])
# we decompose the circuit for the QNN to avoid additional data copying
qnn = EstimatorQNN(
circuit=circuit.decompose(),
observables=observable,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
)
circuit.draw("mpl")
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
with open("11_qcnn_initial_point.json", "r") as f:
initial_point = json.load(f)
classifier = NeuralNetworkClassifier(
qnn,
optimizer=COBYLA(maxiter=200), # Set max iterations here
callback=callback_graph,
initial_point=initial_point,
)
x = np.asarray(train_images)
y = np.asarray(train_labels)
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
classifier.fit(x, y)
# score classifier
print(f"Accuracy from the train data : {np.round(100 * classifier.score(x, y), 2)}%")
y_predict = classifier.predict(test_images)
x = np.asarray(test_images)
y = np.asarray(test_labels)
print(f"Accuracy from the test data : {np.round(100 * classifier.score(x, y), 2)}%")
# Let's see some examples in our dataset
fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={"xticks": [], "yticks": []})
for i in range(0, 4):
ax[i // 2, i % 2].imshow(test_images[i].reshape(2, 4), aspect="equal")
if y_predict[i] == -1:
ax[i // 2, i % 2].set_title("The QCNN predicts this is a Horizontal Line")
if y_predict[i] == +1:
ax[i // 2, i % 2].set_title("The QCNN predicts this is a Vertical Line")
plt.subplots_adjust(wspace=0.1, hspace=0.5)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qgss-2023
|
qiskit-community
|
from qiskit import QuantumCircuit, Aer, execute
import numpy as np
from qiskit.visualization import plot_histogram
import matplotlib.pyplot as plt
from math import gcd
#QFT Circuit
def qft(n):
"""Creates an n-qubit QFT circuit"""
circuit = QuantumCircuit(n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(np.pi/2**(n-qubit), qubit, n)
qft_rotations(circuit, n)
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
#Inverse Quantum Fourier Transform
def qft_dagger(qc, n):
"""n-qubit QFTdagger the first n qubits in circ"""
# Don't forget the Swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
return qc
phase_register_size = 4
qpe4 = QuantumCircuit(phase_register_size+1, phase_register_size)
### Insert your code here
## Run this cell to simulate 'qpe4' and to plot the histogram of the result
sim = Aer.get_backend('aer_simulator')
shots = 2000
count_qpe4 = execute(qpe4, sim, shots=shots).result().get_counts()
plot_histogram(count_qpe4, figsize=(9,5))
from qc_grader.challenges.qgss_2023 import grade_lab3_ex1
grade_lab3_ex1(count_qpe4)
#Grab the highest probability measurement
max_binary_counts = 0
max_binary_val = ''
for key, item in count_qpe4.items():
if item > max_binary_counts:
max_binary_counts = item
max_binary_val = key
## Your function to convert a binary string to decimal goes here
estimated_phase = # calculate the estimated phase
phase_accuracy_window = # highest power of 2 (i.e. smallest decimal) this circuit can estimate
from qc_grader.challenges.qgss_2023 import grade_lab3_ex2
grade_lab3_ex2([estimated_phase, phase_accuracy_window])
from qiskit_ibm_provider import IBMProvider
from qiskit.compiler import transpile
provider = IBMProvider()
hub = "YOUR_HUB"
group = "YOUR_GROUP"
project = "YOUR_PROJECT"
backend_name = "YOUR_BACKEND"
backend = provider.get_backend(backend_name, instance=f"{hub}/{group}/{project}")
# your code goes here
from qc_grader.challenges.qgss_2023 import grade_lab3_ex3
grade_lab3_ex3([max_depth_qpe, min_depth_qpe])
shots = 2000
#OPTIONAL: Run the minimum depth qpe circuit
job_min_qpe4 = backend.run(min_depth_qpe, sim, shots=shots)
print(job_min_qpe4.job_id())
#Gather the count data
count_min_qpe4 = job_min_qpe4.result().get_counts()
plot_histogram(count_min_qpe4, figsize=(9,5))
#OPTIONAL: Run the maximum depth qpe circuit
job_max_qpe4 = backend.run(max_depth_qpe, sim, shots=shots)
print(job_max_qpe4.job_id())
#Gather the count data
count_max_qpe4 = job_max_qpe4.result().get_counts()
plot_histogram(count_max_qpe4, figsize=(9,5))
def qpe_circuit(register_size):
# Your code goes here
return qpe
## Run this cell to simulate 'qpe4' and to plot the histogram of the result
reg_size = # Vary the register sizes
qpe_check = qpe_circuit(reg_size)
sim = Aer.get_backend('aer_simulator')
shots = 10000
count_qpe4 = execute(qpe_check, sim, shots=shots).result().get_counts()
plot_histogram(count_qpe4, figsize=(9,5))
# Process the count data to determine accuracy of the estimated phase
required_register_size = #your answer here
from qc_grader.challenges.qgss_2023 import grade_lab3_ex4
grade_lab3_ex4(required_register_size)
## Create 7mod15 gate
N = 15
m = int(np.ceil(np.log2(N)))
U_qc = QuantumCircuit(m)
U_qc.x(range(m))
U_qc.swap(1, 2)
U_qc.swap(2, 3)
U_qc.swap(0, 3)
U = U_qc.to_gate()
U.name ='{}Mod{}'.format(7, N)
### your code goes here
qcirc = QuantumCircuit(m)
## Run this cell to simulate 'qpe4' and to plot the histogram of the result
sim = Aer.get_backend('aer_simulator')
shots = 20000
input_1 = execute(qcirc, sim, shots=shots).result().get_counts() # save the count data for input 1
input_2 = # save the count data for input 2
input_5 = # save the count data for input 5
from qc_grader.challenges.qgss_2023 import grade_lab3_ex5
grade_lab3_ex5([input_1, input_2, input_5])
unitary_circ = QuantumCircuit(m)
# Your code goes here
sim = Aer.get_backend('unitary_simulator')
unitary = execute(unitary_circ, sim).result().get_unitary()
from qc_grader.challenges.qgss_2023 import grade_lab3_ex6
grade_lab3_ex6(unitary, unitary_circ)
#This function will return a ControlledGate object which repeats the action
# of U, 2^k times
def cU_multi(k):
sys_register_size = 4
circ = QuantumCircuit(sys_register_size)
for _ in range(2**k):
circ.append(U, range(sys_register_size))
U_multi = circ.to_gate()
U_multi.name = '7Mod15_[2^{}]'.format(k)
cU_multi = U_multi.control()
return cU_multi
# your code goes here
shor_qpe = #Create the QuantumCircuit needed to run with 8 phase register qubits
## Run this cell to simulate 'shor_qpe' and to plot the histogram of the results
sim = Aer.get_backend('aer_simulator')
shots = 20000
shor_qpe_counts = execute(shor_qpe, sim, shots=shots).result().get_counts()
plot_histogram(shor_qpe_counts, figsize=(9,5))
from qc_grader.challenges.qgss_2023 import grade_lab3_ex7
grade_lab3_ex7(shor_qpe_counts)
from fractions import Fraction
print(Fraction(0.666), '\n')
print(Fraction(0.666).limit_denominator(15))
shor_qpe_fractions = # create a list of Fraction objects for each measurement outcome
from qc_grader.challenges.qgss_2023 import grade_lab3_ex8
grade_lab3_ex8(shor_qpe_fractions)
def shor_qpe(k):
a = 7
#Step 1. Begin a while loop until a nontrivial guess is found
### Your code goes here ###
#Step 2a. Construct a QPE circuit with m phase count qubits
# to guess the phase phi = s/r using the function cU_multi()
### Your code goes here ###
#Step 2b. Run the QPE circuit with a single shot, record the results
# and convert the estimated phase bitstring to decimal
### Your code goes here ###
#Step 3. Use the Fraction object to find the guess for r
### Your code goes here ###
#Step 4. Now that r has been found, use the builtin greatest common deonominator
# function to determine the guesses for a factor of N
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
#Step 5. For each guess in guesses, check if at least one is a non-trivial factor
# i.e. (guess != 1 or N) and (N % guess == 0)
### Your code goes here ###
#Step 6. If a nontrivial factor is found return the list 'guesses', otherwise
# continue the while loop
### Your code goes here ###
return guesses
from qc_grader.challenges.qgss_2023 import grade_lab3_ex9
grade_lab3_ex9(shor_qpe)
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""The FeatureMap class."""
import json
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
class FeatureMap:
"""Mapping data with the feature map."""
def __init__(self, feature_dimension, entangler_map=None):
"""
Args:
feature_dimension (int): number of features (twice the number of qubits for this
encoding)
entangler_map (list[list]): connectivity of qubits with a list of [source, target],
or None for full entanglement. Note that the order in the list is the order of
applying the two-qubit gate.
Raises:
ValueError: If the value of ``feature_dimension`` is odd.
"""
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j] for i in range(self._num_qubits) for j in range(i + 1, self._num_qubits)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
"""Construct the feature map circuit.
Args:
x (numpy.ndarray): data vector of size feature_dimension
parameters (numpy.ndarray): optional parameters in feature map
q (QauntumRegister): the QuantumRegister object for the circuit
inverse (bool): whether or not to invert the circuit
name (str): The name to use for the constructed ``QuantumCircuit`` object
Returns:
QuantumCircuit: a quantum circuit transforming data x
Raises:
ValueError: If the input parameters or vector are invalid
"""
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
"""Return JSON representation of this object.
Returns:
str: JSON string representing this object.
"""
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
"""Return an instance of this class from the JSON representation.
Args:
data (str): JSON string representing an object.
Returns:
FeatureMap: An instance of this class.
"""
return cls(**json.loads(data))
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests preset pass managers with 1Q backend"""
from test import combine
from ddt import ddt
from qiskit import QuantumCircuit
from qiskit.compiler import transpile
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import Fake1Q
from qiskit.transpiler import TranspilerError
def emptycircuit():
"""Empty circuit"""
return QuantumCircuit()
def circuit_3516():
"""Circuit from https://github.com/Qiskit/qiskit-terra/issues/3516 should fail"""
circuit = QuantumCircuit(2, 1)
circuit.h(0)
circuit.ry(0.11, 1)
circuit.measure([0], [0])
return circuit
@ddt
class Test1QFailing(QiskitTestCase):
"""1Q tests that should fail."""
@combine(
circuit=[circuit_3516],
level=[0, 1, 2, 3],
dsc="Transpiling {circuit.__name__} at level {level} should fail",
name="{circuit.__name__}_level{level}_fail",
)
def test(self, circuit, level):
"""All the levels with all the 1Q backend"""
with self.assertRaises(TranspilerError):
transpile(circuit(), backend=Fake1Q(), optimization_level=level, seed_transpiler=42)
@ddt
class Test1QWorking(QiskitTestCase):
"""1Q tests that should work."""
@combine(
circuit=[emptycircuit],
level=[0, 1, 2, 3],
dsc="Transpiling {circuit.__name__} at level {level} should work",
name="{circuit.__name__}_level{level}_valid",
)
def test_device(self, circuit, level):
"""All the levels with all the 1Q backend"""
result = transpile(
circuit(), backend=Fake1Q(), optimization_level=level, seed_transpiler=42
)
self.assertIsInstance(result, QuantumCircuit)
@combine(
circuit=[circuit_3516],
level=[0, 1, 2, 3],
dsc="Transpiling {circuit.__name__} at level {level} should work for simulator",
name="{circuit.__name__}_level{level}_valid",
)
def test_simulator(self, circuit, level):
"""All the levels with all the 1Q simulator backend"""
# Set fake backend config to simulator
backend = Fake1Q()
backend._configuration.simulator = True
result = transpile(circuit(), backend=backend, optimization_level=level, seed_transpiler=42)
self.assertIsInstance(result, QuantumCircuit)
|
https://github.com/carstenblank/dc-qiskit-stochastics
|
carstenblank
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/Qubico-Hack/tutorials
|
Qubico-Hack
|
from sklearn.datasets import make_blobs
# example dataset
features, labels = make_blobs(n_samples=20, n_features=2, centers=2, random_state=3, shuffle=True)
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler
features = MinMaxScaler(feature_range=(0, np.pi)).fit_transform(features)
train_features, test_features, train_labels, test_labels = train_test_split(
features, labels, train_size=15, shuffle=False
)
# number of qubits is equal to the number of features
num_qubits = 2
# number of steps performed during the training procedure
tau = 100
# regularization parameter
C = 1000
!pip install qiskit
!pip install qiskit_algorithms
!pip install qiskit_machine_learning
from qiskit import BasicAer
from qiskit.circuit.library import ZFeatureMap
from qiskit_algorithms.utils import algorithm_globals
from qiskit_machine_learning.kernels import FidelityQuantumKernel
algorithm_globals.random_seed = 12345
feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
qkernel = FidelityQuantumKernel(feature_map=feature_map)
from qiskit_machine_learning.algorithms import PegasosQSVC
pegasos_qsvc = PegasosQSVC(quantum_kernel=qkernel, C=C, num_steps=tau)
# training
pegasos_qsvc.fit(train_features, train_labels)
# testing
pegasos_score = pegasos_qsvc.score(test_features, test_labels)
print(f"PegasosQSVC classification test score: {pegasos_score}")
grid_step = 0.2
margin = 0.2
grid_x, grid_y = np.meshgrid(
np.arange(-margin, np.pi + margin, grid_step), np.arange(-margin, np.pi + margin, grid_step)
)
meshgrid_features = np.column_stack((grid_x.ravel(), grid_y.ravel()))
meshgrid_colors = pegasos_qsvc.predict(meshgrid_features)
import matplotlib.pyplot as plt
plt.figure(figsize=(5, 5))
meshgrid_colors = meshgrid_colors.reshape(grid_x.shape)
plt.pcolormesh(grid_x, grid_y, meshgrid_colors, cmap="RdBu", shading="auto")
plt.scatter(
train_features[:, 0][train_labels == 0],
train_features[:, 1][train_labels == 0],
marker="s",
facecolors="w",
edgecolors="r",
label="A train",
)
plt.scatter(
train_features[:, 0][train_labels == 1],
train_features[:, 1][train_labels == 1],
marker="o",
facecolors="w",
edgecolors="b",
label="B train",
)
plt.scatter(
test_features[:, 0][test_labels == 0],
test_features[:, 1][test_labels == 0],
marker="s",
facecolors="r",
edgecolors="r",
label="A test",
)
plt.scatter(
test_features[:, 0][test_labels == 1],
test_features[:, 1][test_labels == 1],
marker="o",
facecolors="b",
edgecolors="b",
label="B test",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Pegasos Classification")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import Aer, QuantumCircuit, transpile
from qiskit.circuit.library import PhaseEstimation
qc= QuantumCircuit(3,3)
# dummy unitary circuit
unitary_circuit = QuantumCircuit(1)
unitary_circuit.h(0)
# QPE
qc.append(PhaseEstimation(2, unitary_circuit), list(range(3)))
qc.measure(list(range(3)), list(range(3)))
backend = Aer.get_backend('qasm_simulator')
qc_transpiled = transpile(qc, backend)
result = backend.run(qc, shots = 8192).result()
|
https://github.com/sebasmos/QuantumVE
|
sebasmos
|
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()}')
# define the utils
imagenet_mean = np.array([0.485, 0.456, 0.406])
imagenet_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_std + imagenet_mean) * 255, 0, 255).int())
plt.title(title, fontsize=16)
plt.axis('off')
return
def prepare_model(chkpt_dir, arch='mae_vit_large_patch16'):
# build model
model = getattr(models_mae, arch)()
# load model
checkpoint = torch.load(chkpt_dir, map_location='cpu')
msg = model.load_state_dict(checkpoint['model'], strict=False)
print(msg)
return model
def run_one_image(img, model):
x = torch.tensor(img)
# make it a batch-like
x = x.unsqueeze(dim=0)
x = torch.einsum('nhwc->nchw', x)
# run MAE
loss, y, mask = model(x.float(), mask_ratio=0.75)
y = model.unpatchify(y)
y = torch.einsum('nchw->nhwc', y).detach().cpu()
# visualize the mask
mask = mask.detach()
mask = mask.unsqueeze(-1).repeat(1, 1, model.patch_embed.patch_size[0]**2 *3) # (N, H*W, p*p*3)
mask = model.unpatchify(mask) # 1 is removing, 0 is keeping
mask = torch.einsum('nchw->nhwc', mask).detach().cpu()
x = torch.einsum('nchw->nhwc', x)
# masked image
im_masked = x * (1 - mask)
# MAE reconstruction pasted with visible patches
im_paste = x * (1 - mask) + y * mask
# make the plt figure larger
plt.rcParams['figure.figsize'] = [24, 24]
plt.subplot(1, 4, 1)
show_image(x[0], "original")
plt.subplot(1, 4, 2)
show_image(im_masked[0], "masked")
plt.subplot(1, 4, 3)
show_image(y[0], "reconstruction")
plt.subplot(1, 4, 4)
show_image(im_paste[0], "reconstruction + visible")
plt.show()
# load an image
# img_url = 'https://user-images.githubusercontent.com/11435359/147738734-196fd92f-9260-48d5-ba7e-bf103d29364d.jpg' # fox, from ILSVRC2012_val_00046145
# img_url = 'https://user-images.githubusercontent.com/11435359/147743081-0428eecf-89e5-4e07-8da5-a30fd73cc0ba.jpg' # cucumber, from ILSVRC2012_val_00047851
img_path = "/media/enc/vera1/sebastian/data/Data-set-Urban_Esc/test/BI/4-172143-A-13.png"
# img = Image.open(requests.get(img_url, stream=True).raw)
img = Image.open(img_path)
print(img.mode)
# If the image has an alpha channel, you can convert it to RGB
if img.mode == 'RGBA':
# Convert the image to RGB mode (remove alpha channel)
img = img.convert('RGB')
img = img.resize((224, 224))
img = np.array(img) / 255.
assert img.shape == (224, 224, 3)
# normalize by ImageNet mean and std
img = img - imagenet_mean
img = img / imagenet_std
plt.rcParams['figure.figsize'] = [5, 5]
show_image(torch.tensor(img))
# This is an MAE model trained with pixels as targets for visualization (ViT-Large, training mask ratio=0.75)
# download checkpoint if not exist
#!wget -nc https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_large.pth
# !pip install numpy --upgrade
chkpt_dir = 'mae_visualize_vit_large.pth'
model_mae = prepare_model(chkpt_dir, 'mae_vit_large_patch16')
print('Model loaded.')
# make random mask reproducible (comment out to make it change)
torch.manual_seed(2)
print('MAE with pixel reconstruction:')
run_one_image(img, model_mae)
# This is an MAE model trained with an extra GAN loss for more realistic generation (ViT-Large, training mask ratio=0.75)
# download checkpoint if not exist
!wget -nc https://dl.fbaipublicfiles.com/mae/visualize/mae_visualize_vit_large_ganloss.pth
chkpt_dir = 'mae_visualize_vit_large_ganloss.pth'
model_mae_gan = prepare_model('mae_visualize_vit_large_ganloss.pth', 'mae_vit_large_patch16')
print('Model loaded.')
# make random mask reproducible (comment out to make it change)
torch.manual_seed(2)
print('MAE with extra GAN loss:')
run_one_image(img, model_mae_gan)
chkpt_dir = './EXP_mae_vit_base_patch16/checkpoint-99.pth'
model_mae_gan = prepare_model(chkpt_dir, 'mae_vit_base_patch16')
print('Model loaded.')
# make random mask reproducible (comment out to make it change)
torch.manual_seed(2)
print('MAE with extra GAN loss:')
run_one_image(img, model_mae_gan)
# mae_base = models_mae.mae_vit_base_patch16()
mae_base = prepare_model(chkpt_dir, 'mae_vit_base_patch16')
print('MAE with extra GAN loss:')
run_one_image(img, model_mae_gan)
# t = np.transpose(img, (2,1,0)).astype(np.uint8)
t.shape, t.dtype
img_with_extra_dim = np.expand_dims(img, axis=0)
img_with_extra_dim.shape
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
# importing the QISKit
from qiskit import QuantumCircuit, QuantumProgram
import Qconfig
# import tomography library
import qiskit.tools.qcvv.tomography as tomo
#visualization packages
from qiskit.tools.visualization import plot_wigner_function, plot_wigner_data
density_matrix = np.matrix([[0.5, 0, 0, 0.5],[0, 0, 0, 0],[0, 0, 0, 0],[0.5, 0, 0, 0.5]])
print(density_matrix)
plot_wigner_function(density_matrix, res=200)
import sympy as sym
from sympy.physics.quantum import TensorProduct
num = int(np.log2(len(density_matrix)))
harr = sym.sqrt(3)
Delta_su2 = sym.zeros(2)
Delta = sym.ones(1)
for qubit in range(num):
phi = sym.Indexed('phi', qubit)
theta = sym.Indexed('theta', qubit)
costheta = harr*sym.cos(2*theta)
sintheta = harr*sym.sin(2*theta)
Delta_su2[0,0] = (1+costheta)/2
Delta_su2[0,1] = -(sym.exp(2j*phi)*sintheta)/2
Delta_su2[1,0] = -(sym.exp(-2j*phi)*sintheta)/2
Delta_su2[1,1] = (1-costheta)/2
Delta = TensorProduct(Delta,Delta_su2)
W = sym.trace(density_matrix*Delta)
print(sym.latex(W))
Q_program = QuantumProgram()
number_of_qubits = 2
backend = 'local_qasm_simulator'
shots = 1024
bell_qubits = [0, 1]
qr = Q_program.create_quantum_register('qr',2)
cr = Q_program.create_classical_register('cr',2)
bell = Q_program.create_circuit('bell', [qr], [cr])
bell.h(qr[0])
bell.cx(qr[0],qr[1])
bell_tomo_set = tomo.state_tomography_set([0, 1])
bell_tomo_circuits = tomo.create_tomography_circuits(Q_program, 'bell', qr, cr, bell_tomo_set)
bell_tomo_result = Q_program.execute(bell_tomo_circuits, backend=backend, shots=shots)
bell_tomo_data = tomo.tomography_data(bell_tomo_result, 'bell', bell_tomo_set)
rho_fit_sim = tomo.fit_tomography_data(bell_tomo_data)
plot_wigner_function(np.matrix(rho_fit_sim),res=200)
Delta_su2 = sym.zeros(2)
Delta = sym.ones(1)
for qubit in range(num):
phi = sym.Indexed('phi', qubit)
theta = sym.Indexed('theta', qubit)
costheta = harr*sym.cos(2*theta)
sintheta = harr*sym.sin(2*theta)
Delta_su2[0,0] = (1+costheta)/2
Delta_su2[0,1] = -(sym.exp(2j*phi)*sintheta)/2
Delta_su2[1,0] = -(sym.exp(-2j*phi)*sintheta)/2
Delta_su2[1,1] = (1-costheta)/2
Delta = TensorProduct(Delta,Delta_su2)
W = sym.trace(np.matrix(rho_fit_sim)*Delta)
print(sym.latex(W))
Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
backend = 'ibmqx2'
max_credits = 8
shots = 1024
bell_qubits = [0, 1]
bell_tomo_set = tomo.state_tomography_set(bell_qubits)
bell_tomo_circuits = tomo.create_tomography_circuits(Q_program, 'bell', qr, cr, bell_tomo_set)
bell_tomo_result = Q_program.execute(bell_tomo_circuits, backend=backend, shots=shots,
max_credits=max_credits, timeout=300)
bell_tomo_data = tomo.tomography_data(bell_tomo_result, 'bell', bell_tomo_set)
rho_fit_ibmqx = tomo.fit_tomography_data(bell_tomo_data)
plot_wigner_function(np.matrix(rho_fit_ibmqx), res=100)
print(rho_fit_ibmqx)
Delta_su2 = sym.zeros(2)
Delta = sym.ones(1)
for qubit in range(num):
phi = sym.Indexed('phi', qubit)
theta = sym.Indexed('theta', qubit)
costheta = harr*sym.cos(2*theta)
sintheta = harr*sym.sin(2*theta)
Delta_su2[0,0] = (1+costheta)/2
Delta_su2[0,1] = -(sym.exp(2j*phi)*sintheta)/2
Delta_su2[1,0] = -(sym.exp(-2j*phi)*sintheta)/2
Delta_su2[1,1] = (1-costheta)/2
Delta = TensorProduct(Delta,Delta_su2)
W = sym.trace(np.matrix(rho_fit_ibmqx)*Delta)
print(sym.latex(W))
theta1_points = 8
theta2_points = 8
number_of_points = theta1_points*theta2_points
the1 = [0]*number_of_points
the2 = [0]*number_of_points #initialize theta values
phis = [[0]*number_of_points]*number_of_qubits #set phi values to 0
point = 0
for i in range(theta1_points):
for k in range(theta2_points):
the1[point] = 2*i*np.pi/theta1_points
the2[point] = 2*k*np.pi/theta2_points #create the values of theta for all points on plot
point += 1
thetas = np.vstack((the1,the2))
bell_circuits = tomo.build_wigner_circuits(Q_program, 'bell', phis, thetas,
bell_qubits, qr, cr)
backend = 'local_qasm_simulator'
shots = 1024
bell_result = Q_program.execute(bell_circuits, backend=backend, shots=shots)
print(bell_result)
wdata = tomo.wigner_data(bell_result, bell_qubits,
bell_circuits, shots=shots)
wdata = np.matrix(wdata)
wdata = wdata.reshape(theta1_points,theta2_points)
plot_wigner_data(wdata, method='plaquette')
equator_points = 64
theta = [np.pi/2]*equator_points
phi = [0]*equator_points
point = 0
for i in range(equator_points):
phi[i] = 2*i*np.pi/equator_points
thetas = np.vstack((theta,theta))
phis = np.vstack((phi,phi))
bell_eq_circuits = tomo.build_wigner_circuits(Q_program, 'bell', phis, thetas,
bell_qubits, qr, cr)
bell_eq_result = Q_program.execute(bell_eq_circuits, backend=backend, shots=shots)
wdata_eq = tomo.wigner_data(bell_eq_result, bell_qubits,
bell_eq_circuits, shots=shots)
plot_wigner_data(wdata_eq, method='curve')
Q_program = QuantumProgram()
number_of_qubits = 5
backend = 'local_qasm_simulator'
shots = 1024
ghz_qubits = [0, 1, 2, 3, 4]
qr = Q_program.create_quantum_register('qr',5)
cr = Q_program.create_classical_register('cr',5)
ghz = Q_program.create_circuit('ghz', [qr], [cr])
ghz.h(qr[0])
ghz.h(qr[1])
ghz.x(qr[2])
ghz.h(qr[3])
ghz.h(qr[4])
ghz.cx(qr[0],qr[2])
ghz.cx(qr[1],qr[2])
ghz.cx(qr[3],qr[2])
ghz.cx(qr[4],qr[2])
ghz.h(qr[0])
ghz.h(qr[1])
ghz.h(qr[2])
ghz.h(qr[3])
ghz.h(qr[4])
equator_points = 64
thetas = [[np.pi/2]*equator_points]*number_of_qubits
phi = [0]*equator_points
point = 0
for i in range(equator_points):
phi[i] = 2*i*np.pi/equator_points
phis = np.vstack((phi,phi,phi,phi,phi))
ghz_eq_circuits = tomo.build_wigner_circuits(Q_program, 'ghz', phis, thetas,
ghz_qubits, qr, cr)
ghz_eq_result = Q_program.execute(ghz_eq_circuits, backend=backend, shots=shots, timeout = 300)
wghzdata_eq = tomo.wigner_data(ghz_eq_result, ghz_qubits,
ghz_eq_circuits, shots=shots)
plot_wigner_data(wghzdata_eq, method='curve')
import matplotlib.pyplot as plt
plt.plot(phi, wghzdata_eq, 'o')
plt.axis([0, 2*np.pi, -0.6, 0.6])
plt.show()
density_matrix = np.zeros((32,32))
density_matrix[0][0] = 0.5
density_matrix[0][31] = -0.5
density_matrix[31][0] = -0.5
density_matrix[31][31] = 0.5
plot_wigner_function(density_matrix, res=200)
|
https://github.com/jcylim/QiskitProject
|
jcylim
|
# Imports
import matplotlib.pyplot as plt
#%matplotlib inline
import numpy as np
from qiskit import QuantumProgram, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import available_backends, get_backend, execute, register, least_busy
from qiskit.tools.visualization import plot_histogram, circuit_drawer
# Connecting to the IBM Quantum Experience
qx_config = {
"APItoken": 'dcdb2d9414a625c1f57373c544add3711c78c3d7faf39397fe2c41887110e8b59caf81bcb2bc32714d936da41a261fea510f96df379afcbdfa9df6cc6bfe3829',
"url": 'https://quantumexperience.ng.bluemix.net/api'
}
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))
# Creating registers
q = QuantumRegister(2)
c = ClassicalRegister(2)
# quantum circuit to make an entangled bell state
bell = QuantumCircuit(q, c)
bell.h(q[0])
bell.cx(q[0], q[1])
# quantum circuit to measure q in the standard basis
measureZZ = QuantumCircuit(q, c)
measureZZ.measure(q[0], c[0])
measureZZ.measure(q[1], c[1])
bellZZ = bell+measureZZ
# quantum circuit to measure q in the superposition basis
measureXX = QuantumCircuit(q, c)
measureXX.h(q[0])
measureXX.h(q[1])
measureXX.measure(q[0], c[0])
measureXX.measure(q[1], c[1])
bellXX = bell+measureXX
# quantum circuit to measure ZX
measureZX = QuantumCircuit(q, c)
measureZX.h(q[0])
measureZX.measure(q[0], c[0])
measureZX.measure(q[1], c[1])
bellZX = bell+measureZX
# quantum circuit to measure XZ
measureXZ = QuantumCircuit(q, c)
measureXZ.h(q[1])
measureXZ.measure(q[0], c[0])
measureXZ.measure(q[1], c[1])
bellXZ = bell+measureXZ
circuits = [bellZZ,bellXX,bellZX,bellXZ]
job = execute(circuits, backend=device_name, coupling_map=device_coupling, shots=device_shots)
result = job.result()
observable_first ={'00': 1, '01': -1, '10': 1, '11': -1}
observable_second ={'00': 1, '01': 1, '10': -1, '11': -1}
observable_correlated ={'00': 1, '01': -1, '10': -1, '11': 1}
print('IZ = ' + str(result.average_data(bellZZ,observable_first)))
print('ZI = ' + str(result.average_data(bellZZ,observable_second)))
print('ZZ = ' + str(result.average_data(bellZZ,observable_correlated)))
print('IX = ' + str(result.average_data(bellXX,observable_first)))
print('XI = ' + str(result.average_data(bellXX,observable_second)))
print('XX = ' + str(result.average_data(bellXX,observable_correlated)))
print('ZX = ' + str(result.average_data(bellZX,observable_correlated)))
print('XZ = ' + str(result.average_data(bellXZ,observable_correlated)))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import pulse
d0 = pulse.DriveChannel(0)
x90 = pulse.Gaussian(10, 0.1, 3)
x180 = pulse.Gaussian(10, 0.2, 3)
def udd10_pos(j):
return np.sin(np.pi*j/(2*10 + 2))**2
with pulse.build() as udd_sched:
pulse.play(x90, d0)
with pulse.align_func(duration=300, func=udd10_pos):
for _ in range(10):
pulse.play(x180, d0)
pulse.play(x90, d0)
udd_sched.draw()
|
https://github.com/OJB-Quantum/Qiskit-Metal-to-Litho
|
OJB-Quantum
|
import matplotlib.pyplot as plt
import numpy as np
# Calculate a 100 keV electron-beam path in an egg white resist based on the paper found at https://onlinelibrary.wiley.com/doi/epdf/10.1002/admi.201601223
# Full-access paper title: 'Water-Based Photo- and Electron-Beam Lithography Using Egg White as a Resist'
# Monte Carlo simulation
# Constants
energy_keV = 100 # Beam energy in keV
dose_uC_cm2 = 3000 # Beam dose in microcoulombs per cm^2 for positive pattern
thickness_nm = 100 # Resist thickness in nm
electron_charge = 1.602e-19 # Charge of an electron in Coulombs
area_cm2 = 1e-14 # Area in cm^2 for single electron simulation (arbitrarily small for simulation purposes)
# Calculations for the number of electrons per area
dose_C_cm2 = dose_uC_cm2 * 1e-6 # Convert microcoulombs to coulombs
num_electrons = dose_C_cm2 / electron_charge # Calculate the number of electrons per cm^2
# Monte Carlo simulation parameters
num_electrons_simulated = int(num_electrons * area_cm2) # Scale number of electrons to the simulation area
penetration_depths = [] # To store penetration depths
# Define penetration depth function for the egg white resist
# Assumption: Using a simple model where each interaction with the resist material reduces energy by a fixed amount
# until energy falls below a threshold value, simulating the electron stopping in the resist.
def simulate_electron_paths(num_electrons, energy_keV, thickness_nm):
# Assuming simplistic linear penetration with energy reduction at each step
# and a random scattering angle introducing some deviation in the path.
paths = []
for _ in range(num_electrons):
energy_remaining = energy_keV
depth = 0
path = {'x': [0], 'z': [0]} # Start at origin
while energy_remaining > 0 and depth < thickness_nm:
# Simulate a step
scattering_angle = np.random.uniform(-np.pi/4, np.pi/4) # Random angle within -45 to 45 degrees
step_length = np.random.uniform(1, 5) # Random step length between 1 nm and 5 nm
depth += step_length * np.cos(scattering_angle) # Increment depth based on step length and angle
lateral_displacement = step_length * np.sin(scattering_angle) # Calculate lateral displacement
# Update path
path['x'].append(path['x'][-1] + lateral_displacement)
path['z'].append(depth)
# Reduce energy
energy_remaining -= step_length * 0.1 # Arbitrary energy reduction per nm
paths.append(path)
return paths
# Run the simulation
electron_paths = simulate_electron_paths(num_electrons_simulated, energy_keV, thickness_nm)
# Plot the results
fig, ax = plt.subplots()
plt.figure(figsize=(8,5), dpi=300)
for path in electron_paths:
ax.plot(path['x'], path['z'])
ax.set_xlabel('Lateral Displacement (nm)', fontdict={'fontsize':14})
ax.set_ylabel('Penetration Depth (nm)', fontdict={'fontsize':14})
ax.set_title('Simulated Electron Paths in Egg White Resist', fontdict={'fontsize':20})
plt.show()
# Adjusting plot parameters including title font size, axis font size, figure size, and dpi
fig, ax = plt.subplots(figsize=(8, 5), dpi=300)
for path in electron_paths:
ax.plot(path['x'], -np.array(path['z'])) # Multiply the z values by -1 to flip the plot
ax.set_xlabel('Lateral Displacement (nm)', fontsize=14)
ax.set_ylabel('Penetration Depth (nm)', fontsize=14)
ax.set_title('Simulated Electron Paths in Egg White Resist', fontsize=20)
plt.show()
# Try with 250 nm resist thickness
# Constants
energy_keV = 100 # Beam energy in keV
dose_uC_cm2 = 3000 # Beam dose in microcoulombs per cm^2 for positive pattern
thickness_nm = 250 # Resist thickness in nm
electron_charge = 1.602e-19 # Charge of an electron in Coulombs
area_cm2 = 1e-14 # Area in cm^2 for single electron simulation (arbitrarily small for simulation purposes)
# Calculations for the number of electrons per area
dose_C_cm2 = dose_uC_cm2 * 1e-6 # Convert microcoulombs to coulombs
num_electrons = dose_C_cm2 / electron_charge # Calculate the number of electrons per cm^2
# Monte Carlo simulation parameters
num_electrons_simulated = int(num_electrons * area_cm2) # Scale number of electrons to the simulation area
penetration_depths = [] # To store penetration depths
# Define penetration depth function for the egg white resist
# Assumption: Using a simple model where each interaction with the resist material reduces energy by a fixed amount
# until energy falls below a threshold value, simulating the electron stopping in the resist.
def simulate_electron_paths(num_electrons, energy_keV, thickness_nm):
# Assuming simplistic linear penetration with energy reduction at each step
# and a random scattering angle introducing some deviation in the path.
paths = []
for _ in range(num_electrons):
energy_remaining = energy_keV
depth = 0
path = {'x': [0], 'z': [0]} # Start at origin
while energy_remaining > 0 and depth < thickness_nm:
# Simulate a step
scattering_angle = np.random.uniform(-np.pi/4, np.pi/4) # Random angle within -45 to 45 degrees
step_length = np.random.uniform(1, 5) # Random step length between 1 nm and 5 nm
depth += step_length * np.cos(scattering_angle) # Increment depth based on step length and angle
lateral_displacement = step_length * np.sin(scattering_angle) # Calculate lateral displacement
# Update path
path['x'].append(path['x'][-1] + lateral_displacement)
path['z'].append(depth)
# Reduce energy
energy_remaining -= step_length * 0.1 # Arbitrary energy reduction per nm
paths.append(path)
return paths
# Run the simulation
electron_paths = simulate_electron_paths(num_electrons_simulated, energy_keV, thickness_nm)
# Plot results
fig, ax = plt.subplots(figsize=(8, 5), dpi=300)
for path in electron_paths:
ax.plot(path['x'], -np.array(path['z'])) # Multiply the z values by -1 to flip the plot
ax.set_xlabel('Lateral Displacement (nm)', fontsize=14)
ax.set_ylabel('Penetration Depth (nm)', fontsize=14)
ax.set_title('Simulated Electron Paths in Egg White Resist', fontsize=20)
plt.show()
# Try with 250 nm resist thickness
# Constants
energy_keV = 100 # Beam energy in keV
dose_uC_cm2 = 3000 # Beam dose in microcoulombs per cm^2 for positive pattern
thickness_nm = 250 # Resist thickness in nm
electron_charge = 1.602e-19 # Charge of an electron in Coulombs
area_cm2 = 1e-14 # Area in cm^2 for single electron simulation (arbitrarily small for simulation purposes)
# Calculations for the number of electrons per area
dose_C_cm2 = dose_uC_cm2 * 1e-6 # Convert microcoulombs to coulombs
num_electrons = dose_C_cm2 / electron_charge # Calculate the number of electrons per cm^2
# Monte Carlo simulation parameters
num_electrons_simulated = int(num_electrons * area_cm2) # Scale number of electrons to the simulation area
penetration_depths = [] # To store penetration depths
x_range_nm = (-150, 150) # X-axis range for plotting
# Define penetration depth function for the egg white resist
# Assumption: Using a simple model where each interaction with the resist material reduces energy by a fixed amount
# until energy falls below a threshold value, simulating the electron stopping in the resist.
def simulate_electron_paths(num_electrons, energy_keV, thickness_nm):
# Assuming simplistic linear penetration with energy reduction at each step
# and a random scattering angle introducing some deviation in the path.
paths = []
for _ in range(num_electrons):
energy_remaining = energy_keV
depth = 0
path = {'x': [0], 'z': [0]} # Start at origin
while energy_remaining > 0 and depth < thickness_nm:
# Simulate a step
scattering_angle = np.random.uniform(-np.pi/4, np.pi/4) # Random angle within -45 to 45 degrees
step_length = np.random.uniform(1, 5) # Random step length between 1 nm and 5 nm
depth += step_length * np.cos(scattering_angle) # Increment depth based on step length and angle
lateral_displacement = step_length * np.sin(scattering_angle) # Calculate lateral displacement
# Update path
path['x'].append(path['x'][-1] + lateral_displacement)
path['z'].append(depth)
# Reduce energy
energy_remaining -= step_length * 0.1 # Arbitrary energy reduction per nm
paths.append(path)
return paths
# Run the simulation
electron_paths = simulate_electron_paths(num_electrons_simulated, energy_keV, thickness_nm)
# Plot results
fig, ax = plt.subplots(figsize=(8, 5), dpi=300)
for path in electron_paths:
ax.plot(path['x'], -np.array(path['z'])) # Multiply the z values by -1 to flip the plot
plt.xlim(x_range_nm)
ax.set_xlabel('Lateral Displacement (nm)', fontsize=14)
ax.set_ylabel('Penetration Depth (nm)', fontsize=14)
ax.set_title('Simulated Electron Paths in Egg White Resist', fontsize=20)
plt.show()
# Try with a beam spot size of 2 nm, x-axis range of -150 nm to 150 nm, and 250 nm resist thickness
# Constants for simulation
electron_energy_keV = 100 # Electron energy in keV
beam_dose_uSv_per_cm2 = 3000 # Beam dose in micro Sieverts per square centimeter
beam_spot_size_nm = 2 # Beam spot size in nm
resist_thickness_nm = 250 # Resist thickness in nm
# Conversion factors and constants
keV_to_Joule = 1.60218e-16 # Conversion from keV to Joules (1eV = 1.60218e-19 J)
uSv_to_Joule_per_kg = 1e-6 # Conversion from micro Sieverts to Joules per kg (1 Sv = 1 J/kg)
density_g_cm3 = 1.35 # Assumed density for egg white in g/cm^3 (value assumed for organic materials)
density_kg_m3 = density_g_cm3 * 1e3 # Convert density to kg/m^3
# Assuming a spherical beam spot for volume calculation, which is an approximation for the Monte Carlo point source
beam_radius_m = beam_spot_size_nm * 1e-9 / 2 # Convert nm to m and calculate radius
beam_area_m2 = np.pi * (beam_radius_m ** 2) # Area of the beam spot in square meters
# Calculate total energy deposited per beam spot
total_energy_J = (beam_dose_uSv_per_cm2 * uSv_to_Joule_per_kg * density_kg_m3 * beam_area_m2)
energy_per_electron_J = electron_energy_keV * keV_to_Joule
number_of_electrons = total_energy_J / energy_per_electron_J # Calculate the number of electrons
# Monte Carlo simulation parameters
number_of_simulated_electrons = 1000 # Number of electrons to simulate for plotting
max_depth_nm = resist_thickness_nm # Maximum penetration depth in nm
x_range_nm = (-150, 150) # X-axis range for plotting
# Generate random electron paths
paths = []
for _ in range(number_of_simulated_electrons):
# For simplicity, assume each electron travels straight down with some lateral dispersion
depth = np.random.uniform(0, max_depth_nm)
x_dispersion = np.random.normal(0, beam_spot_size_nm / 2) # Assume Gaussian spread around the beam spot size
paths.append((x_dispersion, depth))
# Plotting the electron paths
plt.figure(figsize=(6, 6), dpi=300)
for path in paths:
plt.plot([path[0], path[0]], [0, -path[1]], 'b') # Plot each path as a blue line
# Set the plot limits and labels
plt.xlim(x_range_nm)
plt.ylim(-resist_thickness_nm, 0)
plt.xlabel('Lateral Position (nm)', fontsize=14)
plt.ylabel('Depth (nm)', fontsize=14)
plt.title('Simulated Electron Beam Penetration in Egg White Resist', fontsize=20)
plt.gca().set_aspect('equal', adjustable='box')
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import GaussianForcesDriver
# if you ran Gaussian elsewhere and already have the output file
driver = GaussianForcesDriver(logfile="aux_files/CO2_freq_B3LYP_631g.log")
# if you want to run the Gaussian job from Qiskit
# driver = GaussianForcesDriver(
# ['#p B3LYP/6-31g Freq=(Anharm) Int=Ultrafine SCF=VeryTight',
# '',
# 'CO2 geometry optimization B3LYP/6-31g',
# '',
# '0 1',
# 'C -0.848629 2.067624 0.160992',
# 'O 0.098816 2.655801 -0.159738',
# 'O -1.796073 1.479446 0.481721',
# '',
# ''
from qiskit_nature.second_q.problems import HarmonicBasis
basis = HarmonicBasis([2, 2, 2, 2])
from qiskit_nature.second_q.problems import VibrationalStructureProblem
from qiskit_nature.second_q.mappers import DirectMapper
vibrational_problem = driver.run(basis=basis)
vibrational_problem.hamiltonian.truncation_order = 2
main_op, aux_ops = vibrational_problem.second_q_ops()
print(main_op)
qubit_mapper = DirectMapper()
qubit_op = qubit_mapper.map(main_op)
print(qubit_op)
basis = HarmonicBasis([3, 3, 3, 3])
vibrational_problem = driver.run(basis=basis)
vibrational_problem.hamiltonian.truncation_order = 2
main_op, aux_ops = vibrational_problem.second_q_ops()
qubit_mapper = DirectMapper()
qubit_op = qubit_mapper.map(main_op)
print(qubit_op)
# for simplicity, we will use the smaller basis again
vibrational_problem = driver.run(basis=HarmonicBasis([2, 2, 2, 2]))
vibrational_problem.hamiltonian.truncation_order = 2
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
solver = GroundStateEigensolver(
qubit_mapper,
NumPyMinimumEigensolver(filter_criterion=vibrational_problem.get_default_filter_criterion()),
)
result = solver.solve(vibrational_problem)
print(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/QuantumBarcelona/Qiskit-Hackathon-BCN
|
QuantumBarcelona
|
from typing import List, Optional
from qiskit import transpile, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.result import marginal_counts
import warnings
warnings.filterwarnings("ignore")
import math
pi=math.pi
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
hub = "ibm-q-community"
group = "digiq-icfo-hack"
project = "main"
backend_name = "ibmq_jakarta" # 7 qubits
#backend_name = "ibmq_guadalupe " # 16 qubits
backend = provider.get_backend(backend_name, instance=f"{hub}/{group}/{project}")
shots: int = 1024 # Number of shots to run each circuit for
print(len(backend.properties().qubits))
from qiskit import transpile
initial_layout=[0,1,2,3,4] # optional
qc_transpiled = transpile(your_circuit, backend, initial_layout=initial_layout)
job = backend.run(qc_transpiled, shots=1024, job_tags=["team_name", "bcn_hackathon"])
counts = job.result().get_counts()
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019, 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# =============================================================================
"""Test Estimator Gradients"""
import unittest
import numpy as np
from ddt import ddt, data, unpack
from qiskit import QuantumCircuit
from qiskit_algorithms.gradients import (
FiniteDiffEstimatorGradient,
LinCombEstimatorGradient,
ParamShiftEstimatorGradient,
SPSAEstimatorGradient,
ReverseEstimatorGradient,
DerivativeType,
)
from qiskit.circuit import Parameter
from qiskit.circuit.library import EfficientSU2, RealAmplitudes
from qiskit.circuit.library.standard_gates import RXXGate, RYYGate, RZXGate, RZZGate
from qiskit.primitives import Estimator
from qiskit.quantum_info import Operator, SparsePauliOp, Pauli
from qiskit.quantum_info.random import random_pauli_list
from qiskit.test import QiskitTestCase
from .logging_primitives import LoggingEstimator
gradient_factories = [
lambda estimator: FiniteDiffEstimatorGradient(estimator, epsilon=1e-6, method="central"),
lambda estimator: FiniteDiffEstimatorGradient(estimator, epsilon=1e-6, method="forward"),
lambda estimator: FiniteDiffEstimatorGradient(estimator, epsilon=1e-6, method="backward"),
ParamShiftEstimatorGradient,
LinCombEstimatorGradient,
lambda estimator: ReverseEstimatorGradient(), # does not take an estimator!
]
@ddt
class TestEstimatorGradient(QiskitTestCase):
"""Test Estimator Gradient"""
@data(*gradient_factories)
def test_gradient_operators(self, grad):
"""Test the estimator gradient for different operators"""
estimator = Estimator()
a = Parameter("a")
qc = QuantumCircuit(1)
qc.h(0)
qc.p(a, 0)
qc.h(0)
gradient = grad(estimator)
op = SparsePauliOp.from_list([("Z", 1)])
correct_result = -1 / np.sqrt(2)
param = [np.pi / 4]
value = gradient.run([qc], [op], [param]).result().gradients[0]
self.assertAlmostEqual(value[0], correct_result, 3)
op = SparsePauliOp.from_list([("Z", 1)])
value = gradient.run([qc], [op], [param]).result().gradients[0]
self.assertAlmostEqual(value[0], correct_result, 3)
op = Operator.from_label("Z")
value = gradient.run([qc], [op], [param]).result().gradients[0]
self.assertAlmostEqual(value[0], correct_result, 3)
@data(*gradient_factories)
def test_single_circuit_observable(self, grad):
"""Test the estimator gradient for a single circuit and observable"""
estimator = Estimator()
a = Parameter("a")
qc = QuantumCircuit(1)
qc.h(0)
qc.p(a, 0)
qc.h(0)
gradient = grad(estimator)
op = SparsePauliOp.from_list([("Z", 1)])
correct_result = -1 / np.sqrt(2)
param = [np.pi / 4]
value = gradient.run(qc, op, [param]).result().gradients[0]
self.assertAlmostEqual(value[0], correct_result, 3)
@data(*gradient_factories)
def test_gradient_p(self, grad):
"""Test the estimator gradient for p"""
estimator = Estimator()
a = Parameter("a")
qc = QuantumCircuit(1)
qc.h(0)
qc.p(a, 0)
qc.h(0)
gradient = grad(estimator)
op = SparsePauliOp.from_list([("Z", 1)])
param_list = [[np.pi / 4], [0], [np.pi / 2]]
correct_results = [[-1 / np.sqrt(2)], [0], [-1]]
for i, param in enumerate(param_list):
gradients = gradient.run([qc], [op], [param]).result().gradients[0]
for j, value in enumerate(gradients):
self.assertAlmostEqual(value, correct_results[i][j], 3)
@data(*gradient_factories)
def test_gradient_u(self, grad):
"""Test the estimator gradient for u"""
estimator = Estimator()
a = Parameter("a")
b = Parameter("b")
c = Parameter("c")
qc = QuantumCircuit(1)
qc.h(0)
qc.u(a, b, c, 0)
qc.h(0)
gradient = grad(estimator)
op = SparsePauliOp.from_list([("Z", 1)])
param_list = [[np.pi / 4, 0, 0], [np.pi / 4, np.pi / 4, np.pi / 4]]
correct_results = [[-0.70710678, 0.0, 0.0], [-0.35355339, -0.85355339, -0.85355339]]
for i, param in enumerate(param_list):
gradients = gradient.run([qc], [op], [param]).result().gradients[0]
for j, value in enumerate(gradients):
self.assertAlmostEqual(value, correct_results[i][j], 3)
@data(*gradient_factories)
def test_gradient_efficient_su2(self, grad):
"""Test the estimator gradient for EfficientSU2"""
estimator = Estimator()
qc = EfficientSU2(2, reps=1)
op = SparsePauliOp.from_list([("ZI", 1)])
gradient = grad(estimator)
param_list = [
[np.pi / 4 for param in qc.parameters],
[np.pi / 2 for param in qc.parameters],
]
correct_results = [
[
-0.35355339,
-0.70710678,
0,
0.35355339,
0,
-0.70710678,
0,
0,
],
[0, 0, 0, 1, 0, 0, 0, 0],
]
for i, param in enumerate(param_list):
gradients = gradient.run([qc], [op], [param]).result().gradients[0]
np.testing.assert_allclose(gradients, correct_results[i], atol=1e-3)
@data(*gradient_factories)
def test_gradient_2qubit_gate(self, grad):
"""Test the estimator gradient for 2 qubit gates"""
estimator = Estimator()
for gate in [RXXGate, RYYGate, RZZGate, RZXGate]:
param_list = [[np.pi / 4], [np.pi / 2]]
correct_results = [
[-0.70710678],
[-1],
]
op = SparsePauliOp.from_list([("ZI", 1)])
for i, param in enumerate(param_list):
a = Parameter("a")
qc = QuantumCircuit(2)
gradient = grad(estimator)
if gate is RZZGate:
qc.h([0, 1])
qc.append(gate(a), [qc.qubits[0], qc.qubits[1]], [])
qc.h([0, 1])
else:
qc.append(gate(a), [qc.qubits[0], qc.qubits[1]], [])
gradients = gradient.run([qc], [op], [param]).result().gradients[0]
np.testing.assert_allclose(gradients, correct_results[i], atol=1e-3)
@data(*gradient_factories)
def test_gradient_parameter_coefficient(self, grad):
"""Test the estimator gradient for parameter variables with coefficients"""
estimator = Estimator()
qc = RealAmplitudes(num_qubits=2, reps=1)
qc.rz(qc.parameters[0].exp() + 2 * qc.parameters[1], 0)
qc.rx(3.0 * qc.parameters[0] + qc.parameters[1].sin(), 1)
qc.u(qc.parameters[0], qc.parameters[1], qc.parameters[3], 1)
qc.p(2 * qc.parameters[0] + 1, 0)
qc.rxx(qc.parameters[0] + 2, 0, 1)
gradient = grad(estimator)
param_list = [[np.pi / 4 for _ in qc.parameters], [np.pi / 2 for _ in qc.parameters]]
correct_results = [
[-0.7266653, -0.4905135, -0.0068606, -0.9228880],
[-3.5972095, 0.10237173, -0.3117748, 0],
]
op = SparsePauliOp.from_list([("ZI", 1)])
for i, param in enumerate(param_list):
gradients = gradient.run([qc], [op], [param]).result().gradients[0]
np.testing.assert_allclose(gradients, correct_results[i], atol=1e-3)
@data(*gradient_factories)
def test_gradient_parameters(self, grad):
"""Test the estimator gradient for parameters"""
estimator = Estimator()
a = Parameter("a")
b = Parameter("b")
qc = QuantumCircuit(1)
qc.rx(a, 0)
qc.rx(b, 0)
gradient = grad(estimator)
param_list = [[np.pi / 4, np.pi / 2]]
correct_results = [
[-0.70710678],
]
op = SparsePauliOp.from_list([("Z", 1)])
for i, param in enumerate(param_list):
gradients = gradient.run([qc], [op], [param], parameters=[[a]]).result().gradients[0]
np.testing.assert_allclose(gradients, correct_results[i], atol=1e-3)
# parameter order
with self.subTest(msg="The order of gradients"):
c = Parameter("c")
qc = QuantumCircuit(1)
qc.rx(a, 0)
qc.rz(b, 0)
qc.rx(c, 0)
param_list = [[np.pi / 4, np.pi / 2, np.pi / 3]]
correct_results = [
[-0.35355339, 0.61237244, -0.61237244],
[-0.61237244, 0.61237244, -0.35355339],
[-0.35355339, -0.61237244],
[-0.61237244, -0.35355339],
]
param = [[a, b, c], [c, b, a], [a, c], [c, a]]
op = SparsePauliOp.from_list([("Z", 1)])
for i, p in enumerate(param):
gradient = grad(estimator)
gradients = (
gradient.run([qc], [op], param_list, parameters=[p]).result().gradients[0]
)
np.testing.assert_allclose(gradients, correct_results[i], atol=1e-3)
@data(*gradient_factories)
def test_gradient_multi_arguments(self, grad):
"""Test the estimator gradient for multiple arguments"""
estimator = Estimator()
a = Parameter("a")
b = Parameter("b")
qc = QuantumCircuit(1)
qc.rx(a, 0)
qc2 = QuantumCircuit(1)
qc2.rx(b, 0)
gradient = grad(estimator)
param_list = [[np.pi / 4], [np.pi / 2]]
correct_results = [
[-0.70710678],
[-1],
]
op = SparsePauliOp.from_list([("Z", 1)])
gradients = gradient.run([qc, qc2], [op] * 2, param_list).result().gradients
np.testing.assert_allclose(gradients, correct_results, atol=1e-3)
c = Parameter("c")
qc3 = QuantumCircuit(1)
qc3.rx(c, 0)
qc3.ry(a, 0)
param_list2 = [[np.pi / 4], [np.pi / 4, np.pi / 4], [np.pi / 4, np.pi / 4]]
correct_results2 = [
[-0.70710678],
[-0.5],
[-0.5, -0.5],
]
gradients2 = (
gradient.run([qc, qc3, qc3], [op] * 3, param_list2, parameters=[[a], [c], None])
.result()
.gradients
)
np.testing.assert_allclose(gradients2[0], correct_results2[0], atol=1e-3)
np.testing.assert_allclose(gradients2[1], correct_results2[1], atol=1e-3)
np.testing.assert_allclose(gradients2[2], correct_results2[2], atol=1e-3)
@data(*gradient_factories)
def test_gradient_validation(self, grad):
"""Test estimator gradient's validation"""
estimator = Estimator()
a = Parameter("a")
qc = QuantumCircuit(1)
qc.rx(a, 0)
gradient = grad(estimator)
param_list = [[np.pi / 4], [np.pi / 2]]
op = SparsePauliOp.from_list([("Z", 1)])
with self.assertRaises(ValueError):
gradient.run([qc], [op], param_list)
with self.assertRaises(ValueError):
gradient.run([qc, qc], [op, op], param_list, parameters=[[a]])
with self.assertRaises(ValueError):
gradient.run([qc, qc], [op], param_list, parameters=[[a]])
with self.assertRaises(ValueError):
gradient.run([qc], [op], [[np.pi / 4, np.pi / 4]])
def test_spsa_gradient(self):
"""Test the SPSA estimator gradient"""
estimator = Estimator()
with self.assertRaises(ValueError):
_ = SPSAEstimatorGradient(estimator, epsilon=-0.1)
a = Parameter("a")
b = Parameter("b")
qc = QuantumCircuit(2)
qc.rx(b, 0)
qc.rx(a, 1)
param_list = [[1, 1]]
correct_results = [[-0.84147098, 0.84147098]]
op = SparsePauliOp.from_list([("ZI", 1)])
gradient = SPSAEstimatorGradient(estimator, epsilon=1e-6, seed=123)
gradients = gradient.run([qc], [op], param_list).result().gradients
np.testing.assert_allclose(gradients, correct_results, atol=1e-3)
# multi parameters
with self.subTest(msg="Multiple parameters"):
gradient = SPSAEstimatorGradient(estimator, epsilon=1e-6, seed=123)
param_list2 = [[1, 1], [1, 1], [3, 3]]
gradients2 = (
gradient.run([qc] * 3, [op] * 3, param_list2, parameters=[None, [b], None])
.result()
.gradients
)
correct_results2 = [[-0.84147098, 0.84147098], [0.84147098], [-0.14112001, 0.14112001]]
for grad, correct in zip(gradients2, correct_results2):
np.testing.assert_allclose(grad, correct, atol=1e-3)
# batch size
with self.subTest(msg="Batch size"):
correct_results = [[-0.84147098, 0.1682942]]
gradient = SPSAEstimatorGradient(estimator, epsilon=1e-6, batch_size=5, seed=123)
gradients = gradient.run([qc], [op], param_list).result().gradients
np.testing.assert_allclose(gradients, correct_results, atol=1e-3)
# parameter order
with self.subTest(msg="The order of gradients"):
gradient = SPSAEstimatorGradient(estimator, epsilon=1e-6, seed=123)
c = Parameter("c")
qc = QuantumCircuit(1)
qc.rx(a, 0)
qc.rz(b, 0)
qc.rx(c, 0)
op = SparsePauliOp.from_list([("Z", 1)])
param_list3 = [[np.pi / 4, np.pi / 2, np.pi / 3]]
param = [[a, b, c], [c, b, a], [a, c], [c, a]]
expected = [
[-0.3535525, 0.3535525, 0.3535525],
[0.3535525, 0.3535525, -0.3535525],
[-0.3535525, 0.3535525],
[0.3535525, -0.3535525],
]
for i, p in enumerate(param):
gradient = SPSAEstimatorGradient(estimator, epsilon=1e-6, seed=123)
gradients = (
gradient.run([qc], [op], param_list3, parameters=[p]).result().gradients[0]
)
np.testing.assert_allclose(gradients, expected[i], atol=1e-3)
@data(ParamShiftEstimatorGradient, LinCombEstimatorGradient)
def test_gradient_random_parameters(self, grad):
"""Test param shift and lin comb w/ random parameters"""
rng = np.random.default_rng(123)
qc = RealAmplitudes(num_qubits=3, reps=1)
params = qc.parameters
qc.rx(3.0 * params[0] + params[1].sin(), 0)
qc.ry(params[0].exp() + 2 * params[1], 1)
qc.rz(params[0] * params[1] - params[2], 2)
qc.p(2 * params[0] + 1, 0)
qc.u(params[0].sin(), params[1] - 2, params[2] * params[3], 1)
qc.sx(2)
qc.rxx(params[0].sin(), 1, 2)
qc.ryy(params[1].cos(), 2, 0)
qc.rzz(params[2] * 2, 0, 1)
qc.crx(params[0].exp(), 1, 2)
qc.cry(params[1].arctan(), 2, 0)
qc.crz(params[2] * -2, 0, 1)
qc.dcx(0, 1)
qc.csdg(0, 1)
qc.toffoli(0, 1, 2)
qc.iswap(0, 2)
qc.swap(1, 2)
qc.global_phase = params[0] * params[1] + params[2].cos().exp()
size = 10
op = SparsePauliOp(random_pauli_list(num_qubits=qc.num_qubits, size=size, seed=rng))
op.coeffs = rng.normal(0, 10, size)
estimator = Estimator()
findiff = FiniteDiffEstimatorGradient(estimator, 1e-6)
gradient = grad(estimator)
num_tries = 10
param_values = rng.normal(0, 2, (num_tries, qc.num_parameters)).tolist()
np.testing.assert_allclose(
findiff.run([qc] * num_tries, [op] * num_tries, param_values).result().gradients,
gradient.run([qc] * num_tries, [op] * num_tries, param_values).result().gradients,
rtol=1e-4,
)
@data((DerivativeType.IMAG, -1.0), (DerivativeType.COMPLEX, -1.0j))
@unpack
def test_complex_gradient(self, derivative_type, expected_gradient_value):
"""Tests if the ``LinCombEstimatorGradient`` has the correct value."""
estimator = Estimator()
lcu = LinCombEstimatorGradient(estimator, derivative_type=derivative_type)
reverse = ReverseEstimatorGradient(derivative_type=derivative_type)
for gradient in [lcu, reverse]:
with self.subTest(gradient=gradient):
c = QuantumCircuit(1)
c.rz(Parameter("p"), 0)
result = gradient.run([c], [Pauli("I")], [[0.0]]).result()
self.assertAlmostEqual(result.gradients[0][0], expected_gradient_value)
@data(
FiniteDiffEstimatorGradient,
ParamShiftEstimatorGradient,
LinCombEstimatorGradient,
SPSAEstimatorGradient,
)
def test_options(self, grad):
"""Test estimator gradient's run options"""
a = Parameter("a")
qc = QuantumCircuit(1)
qc.rx(a, 0)
op = SparsePauliOp.from_list([("Z", 1)])
estimator = Estimator(options={"shots": 100})
with self.subTest("estimator"):
if grad is FiniteDiffEstimatorGradient or grad is SPSAEstimatorGradient:
gradient = grad(estimator, epsilon=1e-6)
else:
gradient = grad(estimator)
options = gradient.options
result = gradient.run([qc], [op], [[1]]).result()
self.assertEqual(result.options.get("shots"), 100)
self.assertEqual(options.get("shots"), 100)
with self.subTest("gradient init"):
if grad is FiniteDiffEstimatorGradient or grad is SPSAEstimatorGradient:
gradient = grad(estimator, epsilon=1e-6, options={"shots": 200})
else:
gradient = grad(estimator, options={"shots": 200})
options = gradient.options
result = gradient.run([qc], [op], [[1]]).result()
self.assertEqual(result.options.get("shots"), 200)
self.assertEqual(options.get("shots"), 200)
with self.subTest("gradient update"):
if grad is FiniteDiffEstimatorGradient or grad is SPSAEstimatorGradient:
gradient = grad(estimator, epsilon=1e-6, options={"shots": 200})
else:
gradient = grad(estimator, options={"shots": 200})
gradient.update_default_options(shots=100)
options = gradient.options
result = gradient.run([qc], [op], [[1]]).result()
self.assertEqual(result.options.get("shots"), 100)
self.assertEqual(options.get("shots"), 100)
with self.subTest("gradient run"):
if grad is FiniteDiffEstimatorGradient or grad is SPSAEstimatorGradient:
gradient = grad(estimator, epsilon=1e-6, options={"shots": 200})
else:
gradient = grad(estimator, options={"shots": 200})
options = gradient.options
result = gradient.run([qc], [op], [[1]], shots=300).result()
self.assertEqual(result.options.get("shots"), 300)
# Only default + estimator options. Not run.
self.assertEqual(options.get("shots"), 200)
@data(
FiniteDiffEstimatorGradient,
ParamShiftEstimatorGradient,
LinCombEstimatorGradient,
SPSAEstimatorGradient,
)
def test_operations_preserved(self, gradient_cls):
"""Test non-parameterized instructions are preserved and not unrolled."""
x = Parameter("x")
circuit = QuantumCircuit(2)
circuit.initialize([0.5, 0.5, 0.5, 0.5]) # this should remain as initialize
circuit.crx(x, 0, 1) # this should get unrolled
values = [np.pi / 2]
expect = -1 / (2 * np.sqrt(2))
observable = SparsePauliOp(["XX"])
ops = []
def operations_callback(op):
ops.append(op)
estimator = LoggingEstimator(operations_callback=operations_callback)
if gradient_cls in [SPSAEstimatorGradient, FiniteDiffEstimatorGradient]:
gradient = gradient_cls(estimator, epsilon=0.01)
else:
gradient = gradient_cls(estimator)
job = gradient.run([circuit], [observable], [values])
result = job.result()
with self.subTest(msg="assert initialize is preserved"):
self.assertTrue(all("initialize" in ops_i[0].keys() for ops_i in ops))
with self.subTest(msg="assert result is correct"):
self.assertAlmostEqual(result.gradients[0].item(), expect, places=5)
if __name__ == "__main__":
unittest.main()
|
https://github.com/anirban-m/qiskit-superstaq
|
anirban-m
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import os
from typing import List, Union
import qiskit
import requests
import qiskit_superstaq as qss
class SuperstaQProvider(qiskit.providers.ProviderV1):
"""Provider for SuperstaQ backend.
Typical usage is:
.. code-block:: python
import qiskit_superstaq as qss
ss_provider = qss.superstaq_provider.SuperstaQProvider('MY_TOKEN')
backend = ss_provider.get_backend('my_backend')
where `'MY_TOKEN'` is the access token provided by SuperstaQ,
and 'my_backend' is the name of the desired backend.
Attributes:
access_token (str): The access token.
name (str): Name of the provider instance.
url (str): The url that the API is hosted on.
"""
def __init__(
self,
access_token: str,
url: str = os.getenv("SUPERSTAQ_REMOTE_HOST") or qss.API_URL,
) -> None:
self.access_token = access_token
self._name = "superstaq_provider"
self.url = url
def __str__(self) -> str:
return f"<SuperstaQProvider(name={self._name})>"
def __repr__(self) -> str:
repr1 = f"<SuperstaQProvider(name={self._name}, "
return repr1 + f"access_token={self.access_token})>"
def get_backend(self, backend: str) -> "qss.superstaq_backend.SuperstaQBackend":
return qss.superstaq_backend.SuperstaQBackend(provider=self, url=self.url, backend=backend)
def get_access_token(self) -> str:
return self.access_token
def backends(self) -> List[qss.superstaq_backend.SuperstaQBackend]:
# needs to be fixed (#469)
backend_names = [
"aqt_device",
"ionq_device",
"rigetti_device",
"ibmq_botoga",
"ibmq_casablanca",
"ibmq_jakarta",
"ibmq_qasm_simulator",
]
backends = []
for name in backend_names:
backends.append(
qss.superstaq_backend.SuperstaQBackend(provider=self, url=self.url, backend=name)
)
return backends
def aqt_compile(
self, circuits: Union[qiskit.QuantumCircuit, List[qiskit.QuantumCircuit]]
) -> "qss.aqt.AQTCompilerOutput":
"""Compiles the given circuit(s) to AQT device, optimized to its native gate set.
Args:
circuits: qiskit QuantumCircuit(s)
Returns:
object whose .circuit(s) attribute is an optimized qiskit QuantumCircuit(s)
If qtrl is installed, the object's .seq attribute is a qtrl Sequence object of the
pulse sequence corresponding to the optimized qiskit.QuantumCircuit(s) and the
.pulse_list(s) attribute is the list(s) of cycles.
"""
if isinstance(circuits, qiskit.QuantumCircuit):
json_dict = {"qasm_strs": [circuits.qasm()]}
circuits_list = False
else:
json_dict = {"qasm_strs": [c.qasm() for c in circuits]}
circuits_list = True
headers = {
"Authorization": self.get_access_token(),
"Content-Type": "application/json",
}
res = requests.post(
self.url + "/" + qss.API_VERSION + "/aqt_compile",
json=json_dict,
headers=headers,
verify=(self.url == qss.API_URL),
)
res.raise_for_status()
json_dict = res.json()
from qiskit_superstaq import aqt
return aqt.read_json(json_dict, circuits_list)
|
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/chaurasiyag/minor-project-quantum-computing
|
chaurasiyag
|
from qiskit import *
qr=QuantumRegister(1)
qc=ClassicalRegister(1)
cir=QuantumCircuit(qr,qc)
cir.draw()
cir.x(qr[0])
cir.draw()
cir.measure(qr,qc)
cir.draw()
simulator=BasicAer.get_backend("qasm_simulator")
res=execute(cir,backend=simulator).result()
print(res)
from qiskit.tools.visualization import plot_histogram
plot_histogram(res.get_counts(cir))
IBMQ.save_account('7cd5664973bf6ce405272fc6fa2bd7684625b387b768de3dd459fa38dd3cdc417387fa4c306562485e0bb6ddb46fd20fcd24da495248304d90d155b52011fd6f')
IBMQ.load_account()
provider=IBMQ.get_provider('ibm-q')
qcomp=provider.get_backend('ibmq_quito')
job=execute(cir,backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
res=job.result()
plot_histogram(res.get_counts(cir))
from qiskit import *
from math import pi
qr=QuantumRegister(1)
cr=ClassicalRegister(1)
qc=QuantumCircuit(qr,cr)
qc.draw()
qc.u3(pi,0,0,qr[0])
qc.measure(qr,cr)
qc.draw()
simulator=BasicAer.get_backend("qasm_simulator")
job=execute(qc,backend=simulator)
from qiskit.tools.visualization import plot_histogram
plot_histogram(job.result().get_counts())
plot_histogram(job.result().get_counts(qc))
qrr=QuantumRegister(1)
crr=ClassicalRegister(1)
qcc=QuantumCircuit(qrr,crr)
qcc.x(qrr[0])
qcc.z(qrr[0])
qcc.draw()
qcc.measure(qrr,crr)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qcc,backend=simu).result()
plot_histogram(result.get_counts(qcc))
qr2=QuantumRegister(2)
cr2=ClassicalRegister(2)
qc=QuantumCircuit(qr2,cr2)
qc.h(qr2[0])
qc.cx(qr2[0],qr2[1])
qc.draw()
qc.measure(qr2,cr2)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qc,backend=simu).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(qc))
IBMQ.save_account('7cd5664973bf6ce405272fc6fa2bd7684625b387b768de3dd459fa38dd3cdc417387fa4c306562485e0bb6ddb46fd20fcd24da495248304d90d155b52011fd6f',overwrite=True)
IBMQ.load_account()
pr=IBMQ.get_provider('ibm-q')
qcomp=pr.get_backend("ibmq_quito")
job=execute(qc,backend=qcomp)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
res=job.result()
plot_histogram(res.get_counts(qc))
qiskit.tools
from qiskit import *
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
qr=QuantumRegister(2)
cr=ClassicalRegister(2)
qc=QuantumCircuit(qr,cr)
qc.x(qr[0])
qc.draw()
qc.h(qr[0])
qc.cx(qr[0],qr[1])
qc.draw()
qc.measure(qr,cr)
simu=BasicAer.get_backend("qasm_simulator")
result=execute(qc,backend=simu).result()
plot_histogram(result.get_counts(qc))
IBMQ.save_account('c10fa12997ad898683c72c5496c720b9657d7b96ce93b3f443366854e87973466f32f0bd9d807b4c147a63ac230eb03987972bdf400193154e11bdd834503a58',overwrite=True)
IBMQ.load_account()
pr=IBMQ.get_provider("ibm-q")
qcomp=pr.get_backend("ibmq_manila")
job=execute(qc,backend=qcomp)
job_monitor(job)
result=job.result()
plot_histogram(result.get_counts(qc))
qr1=QuantumRegister(2)
cr1=ClassicalRegister(2)
qc1=QuantumCircuit(qr1,cr1)
qc1.h(qr1[0])
qc1.x(qr1[1])
qc1.cx(qr1[0],qr1[1])
qc1.measure(qr1,cr1)
simu=BasicAer.get_backend("qasm_simulator")
job=execute(qc1,backend=simu).result()
print(job.get_counts())
plot_histogram(job.get_counts(qc1))
qcomp1=pr.get_backend("ibmq_manila")
job1=execute(qc1,backend=qcomp1)
job_monitor(job1)
plot_histogram(job1.result().get_counts(q))
print(job1.result().get_counts())
from qiskit import *
from qiskit.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
qr2=QuantumRegister(2)
cr2=ClassicalRegister(2)
qc2=QuantumCircuit(qr2,cr2)
qc2.x(qr2[0])
qc2.x(qr2[1])
qc2.h(qr2[0])
qc2.cx(qr2[0],qr2[1])
qc2.draw()
simu=BasicAer.get_backend("qasm_simulator")
qc2.measure(qr2,cr2)
job3=execute(qc2,backend=simu)
print(job3.result().get_counts())
plot_histogram(job3.result().get_counts())
IBMQ.load_account()
pr=IBMQ.get_provider("ibm-q")
qcomp2=pr.get_backend("ibmq_manila")
job4=execute(qc2,backend=qcomp2)
job_monitor(job4)
print(job4.result().get_counts())
plot_histogram(job4.result().get_counts())
from qiskit import *
bell=QuantumCircuit(2,2)
bell.h(0)
bell.cx(0,1)
meas=QuantumCircuit(2,2)
meas.measure([0,1],[0,1])
backend=BasicAer.get_backend('qasm_simulator')
circ=bell.compose(meas)
result=backend.run(transpile(circ,backend)).result()
count=result.get_counts(circ)
print(count)
from qiskit.visualization import plot_bloch_multivector,plot_state_qsphere,plot_histogram,plot_bloch_vector
# bell=QuantumCircuit(1,1)
bell.h(0)
bell.y(0)
backend=BasicAer.get_backend('statevector_simulator')
result=backend.run(transpile(bell,backend)).result()
ps1=result.get_statevector(bell)
plot_bloch_multivector(ps1)
!pip install seaborn
# plot_state_qsphere(ps1)
# plot_bloch_vector(['00','11'])
q=QuantumCircuit(1,1)
q.y(0)
plot_bloch_multivector(q)
from qiskit_textbook.widgets import bloch_calc
!pip install qiskit_textbook
from qiskit_textbook.widgets import binary_widget
binary_widget(nbits=5)
print("Just adding for update automatically on github repo using shell script cronjob")
print("Added Second Line to Check Automatic Update")
print("third")
print($$$)
print(000)
print("Last")
print("Automatic Updates Successfully")
from qiskit import *
import numpy as np
pi=np.pi
def qft(no_of_qbit):
qc=QuantumCircuit(no_of_qbit)
for qbit in range(no_of_qbit):
qc.h(qbit)
for other_qbit in range(qbit+1,no_of_qbit):
qc.cu1(pi/(2**(other_qbit-qbit)),other_qbit,qbit)
return qc
display(qft(5).draw())
display(qft(4).draw())
display(qft(3).draw())
print(90)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.pulse_v2 import draw, IQXDebugging
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
qc = transpile(qc, FakeBoeblingen(), layout_method='trivial')
sched = schedule(qc, FakeBoeblingen())
draw(sched, style=IQXDebugging(), backend=FakeBoeblingen())
|
https://github.com/jvscursulim/qamp_fall22_project
|
jvscursulim
|
import numpy as np
import matplotlib.pyplot as plt
from frqi import FRQI
from qiskit import execute, transpile
from qiskit.circuit import ClassicalRegister, QuantumCircuit, QuantumRegister, Parameter
from qiskit.circuit.library.standard_gates import RYGate
from qiskit.providers.aer.backends import AerSimulator
from qiskit.quantum_info import DensityMatrix, state_fidelity, partial_trace
from qiskit.visualization import plot_histogram
from skimage import data
from skimage.color import rgb2gray
from skimage.transform import resize
SHOTS = 8192
BACKEND = AerSimulator()
image_frqi = FRQI()
mcry = RYGate(theta=2*Parameter(r"$\theta$")).control(num_ctrl_qubits=2)
ry_qc = QuantumCircuit(1)
ry_qc.ry(theta=2*Parameter(r"$\theta$"), qubit=0)
mcry_alt = ry_qc.to_gate(label="mcry").control(num_ctrl_qubits=2)
test = QuantumCircuit(3)
test.append(mcry, [0,1,2])
test.draw(output="mpl")
qubits = QuantumRegister(size=2, name="pixels")
color_qubit = QuantumRegister(size=1, name="color")
bits = ClassicalRegister(size=2, name="bits_pixels")
color_bit = ClassicalRegister(size=1)
qc = QuantumCircuit(qubits, color_qubit, bits, color_bit)
qc.h(qubit=qubits)
qc.barrier()
qc.draw(output="mpl")
theta = np.pi/4
for i in range(4):
if i == 0:
qc.x(qubit=qubits)
elif i == 1:
qc.x(qubit=qubits[1])
elif i == 2:
qc.x(qubit=qubits[0])
qc.cry(theta=theta, control_qubit=qubits[0], target_qubit=color_qubit)
qc.cx(control_qubit=qubits[0], target_qubit=qubits[1])
qc.cry(theta=-theta, control_qubit=qubits[1], target_qubit=color_qubit)
qc.cx(control_qubit=qubits[0], target_qubit=qubits[1])
qc.cry(theta=theta, control_qubit=qubits[1], target_qubit=color_qubit)
if i == 0:
qc.x(qubit=qubits)
elif i == 1:
qc.x(qubit=qubits[1])
elif i == 2:
qc.x(qubit=qubits[0])
qc.barrier()
qc.measure(qubit=qubits, cbit=bits)
qc.measure(qubit=color_qubit, cbit=color_bit)
qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qc.depth()}")
print(f"Circuit size: {qc.size()}")
print(f"Circuit operations: {qc.count_ops()}")
transpiled_qc = transpile(circuits=qc, basis_gates=["id", "x", "sx", "cx", "rz"], optimization_level=0)
transpiled_qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {transpiled_qc.depth()}")
print(f"Circuit size: {transpiled_qc.size()}")
print(f"Circuit operations: {transpiled_qc.count_ops()}")
transpiled_qc = transpile(circuits=qc, basis_gates=["id", "x", "sx", "cx", "rz"], optimization_level=1)
transpiled_qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {transpiled_qc.depth()}")
print(f"Circuit size: {transpiled_qc.size()}")
print(f"Circuit operations: {transpiled_qc.count_ops()}")
transpiled_qc = transpile(circuits=qc, basis_gates=["id", "x", "sx", "cx", "rz"], optimization_level=2)
transpiled_qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {transpiled_qc.depth()}")
print(f"Circuit size: {transpiled_qc.size()}")
print(f"Circuit operations: {transpiled_qc.count_ops()}")
transpiled_qc = transpile(circuits=qc, basis_gates=["id", "x", "sx", "cx", "rz"], optimization_level=3)
transpiled_qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {transpiled_qc.depth()}")
print(f"Circuit size: {transpiled_qc.size()}")
print(f"Circuit operations: {transpiled_qc.count_ops()}")
counts = execute(experiments=qc, backend=BACKEND, shots=SHOTS).result().get_counts()
plot_histogram(counts)
qubits = QuantumRegister(size=2, name="pixels")
color_qubit = QuantumRegister(size=1, name="color")
bits = ClassicalRegister(size=2, name="bits_pixels")
color_bit = ClassicalRegister(size=1)
qc = QuantumCircuit(qubits, color_qubit, bits, color_bit)
qc.h(qubit=qubits)
qc.barrier()
theta = np.pi/4
for i in range(4):
if i == 0:
qc.x(qubit=qubits)
elif i == 1:
qc.x(qubit=qubits[1])
elif i == 2:
qc.x(qubit=qubits[0])
mcry = RYGate(theta=2*theta).control(num_ctrl_qubits=2)
qc.append(mcry, qargs=[qubits[0], qubits[1], color_qubit])
if i == 0:
qc.x(qubit=qubits)
elif i == 1:
qc.x(qubit=qubits[1])
elif i == 2:
qc.x(qubit=qubits[0])
qc.barrier()
qc.measure(qubit=qubits, cbit=bits)
qc.measure(qubit=color_qubit, cbit=color_bit)
qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {qc.depth()}")
print(f"Circuit size: {qc.size()}")
print(f"Circuit operations: {qc.count_ops()}")
transpiled_qc = transpile(circuits=qc, basis_gates=["id", "x", "sx", "cx", "rz"], optimization_level=3)
transpiled_qc.draw(output="mpl")
print("Circuit dimensions")
print(f"Circuit depth: {transpiled_qc.depth()}")
print(f"Circuit size: {transpiled_qc.size()}")
print(f"Circuit operations: {transpiled_qc.count_ops()}")
counts = execute(experiments=qc, backend=BACKEND, shots=SHOTS).result().get_counts()
plot_histogram(counts)
from fractions import Fraction
a = Fraction(2*255,90)
print(a)
(((127*3)/17))/90
astronaut_gray = rgb2gray(data.astronaut())
plt.imshow(astronaut_gray, cmap="gray")
resized_astronaut_gray = resize(astronaut_gray, (2,2))
resized_astronaut_gray
pixels_intensity_list = list(resized_astronaut_gray[0]) + list(resized_astronaut_gray[1])
qubits = QuantumRegister(size=2, name="pixels")
color_qubit = QuantumRegister(size=1, name="color")
bits = ClassicalRegister(size=2, name="bits_pixels")
color_bit = ClassicalRegister(size=1)
qc = QuantumCircuit(qubits, color_qubit, bits, color_bit)
qc.h(qubit=qubits)
qc.barrier()
for i, pixel in enumerate(pixels_intensity_list):
theta = ((pixel*255*12)/17)/180
if i == 0:
qc.x(qubit=qubits)
elif i == 1:
qc.x(qubit=qubits[1])
elif i == 2:
qc.x(qubit=qubits[0])
qc.cry(theta=theta, control_qubit=qubits[0], target_qubit=color_qubit)
qc.cx(control_qubit=qubits[0], target_qubit=qubits[1])
qc.cry(theta=-theta, control_qubit=qubits[1], target_qubit=color_qubit)
qc.cx(control_qubit=qubits[0], target_qubit=qubits[1])
qc.cry(theta=theta, control_qubit=qubits[1], target_qubit=color_qubit)
if i == 0:
qc.x(qubit=qubits)
elif i == 1:
qc.x(qubit=qubits[1])
elif i == 2:
qc.x(qubit=qubits[0])
qc.barrier()
qc.measure(qubit=qubits, cbit=bits)
qc.measure(qubit=color_qubit, cbit=color_bit)
qc.draw(output="mpl")
counts = execute(experiments=qc, backend=BACKEND, shots=SHOTS).result().get_counts()
plot_histogram(counts)
image = np.array([[0.5,0.5],[0.5,0.5]])
qc = image_frqi.image_quantum_circuit(image=image, measurements=True)
qc.draw(output="mpl")
counts = execute(experiments=qc, backend=BACKEND, shots=SHOTS).result().get_counts()
plot_histogram(counts)
image = np.ones((4,4))
qc = image_frqi.image_quantum_circuit(image=image, measurements=True)
qc.draw(output="mpl")
counts = execute(experiments=qc, backend=BACKEND, shots=SHOTS).result().get_counts()
counts
qc = image_frqi.image_quantum_circuit(image=resized_astronaut_gray, measurements=True)
qc.draw(output="mpl")
counts = execute(experiments=qc, backend=BACKEND, shots=SHOTS).result().get_counts()
plot_histogram(counts)
astronaut = data.astronaut()
plt.imshow(astronaut)
resized_astronaut = resize(astronaut, (2,2))
plt.imshow(resized_astronaut)
qc = image_frqi.image_quantum_circuit(image=resized_astronaut, measurements=True)
qc.draw(output="mpl")
counts = execute(experiments=qc, backend=BACKEND, shots=SHOTS).result().get_counts()
plot_histogram(counts)
print("Circuit dimensions")
print(f"Circuit depth: {qc.depth()}")
print(f"Circuit size: {qc.size()}")
print(f"Circuit operations: {qc.count_ops()}")
image = np.ones((4,4,4))
qc = image_frqi.image_quantum_circuit(image=image, measurements=True)
qc.draw(output="mpl")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
import copy
# Problem modelling imports
from docplex.mp.model import Model
# Qiskit imports
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit.utils.algorithm_globals import algorithm_globals
from qiskit_optimization.algorithms import MinimumEigenOptimizer, CplexOptimizer
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.problems.variable import VarType
from qiskit_optimization.converters.quadratic_program_to_qubo import QuadraticProgramToQubo
from qiskit_optimization.translators import from_docplex_mp
def create_problem(mu: np.array, sigma: np.array, total: int = 3) -> QuadraticProgram:
"""Solve the quadratic program using docplex."""
mdl = Model()
x = [mdl.binary_var("x%s" % i) for i in range(len(sigma))]
objective = mdl.sum([mu[i] * x[i] for i in range(len(mu))])
objective -= 2 * mdl.sum(
[sigma[i, j] * x[i] * x[j] for i in range(len(mu)) for j in range(len(mu))]
)
mdl.maximize(objective)
cost = mdl.sum(x)
mdl.add_constraint(cost == total)
qp = from_docplex_mp(mdl)
return qp
def relax_problem(problem) -> QuadraticProgram:
"""Change all variables to continuous."""
relaxed_problem = copy.deepcopy(problem)
for variable in relaxed_problem.variables:
variable.vartype = VarType.CONTINUOUS
return relaxed_problem
mu = np.array([3.418, 2.0913, 6.2415, 4.4436, 10.892, 3.4051])
sigma = np.array(
[
[1.07978412, 0.00768914, 0.11227606, -0.06842969, -0.01016793, -0.00839765],
[0.00768914, 0.10922887, -0.03043424, -0.0020045, 0.00670929, 0.0147937],
[0.11227606, -0.03043424, 0.985353, 0.02307313, -0.05249785, 0.00904119],
[-0.06842969, -0.0020045, 0.02307313, 0.6043817, 0.03740115, -0.00945322],
[-0.01016793, 0.00670929, -0.05249785, 0.03740115, 0.79839634, 0.07616951],
[-0.00839765, 0.0147937, 0.00904119, -0.00945322, 0.07616951, 1.08464544],
]
)
qubo = create_problem(mu, sigma)
print(qubo.prettyprint())
result = CplexOptimizer().solve(qubo)
print(result.prettyprint())
qp = relax_problem(QuadraticProgramToQubo().convert(qubo))
print(qp.prettyprint())
sol = CplexOptimizer().solve(qp)
print(sol.prettyprint())
c_stars = sol.samples[0].x
print(c_stars)
algorithm_globals.random_seed = 12345
qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 1.0])
exact_mes = NumPyMinimumEigensolver()
qaoa = MinimumEigenOptimizer(qaoa_mes)
qaoa_result = qaoa.solve(qubo)
print(qaoa_result.prettyprint())
from qiskit import QuantumCircuit
thetas = [2 * np.arcsin(np.sqrt(c_star)) for c_star in c_stars]
init_qc = QuantumCircuit(len(sigma))
for idx, theta in enumerate(thetas):
init_qc.ry(theta, idx)
init_qc.draw(output="mpl")
from qiskit.circuit import Parameter
beta = Parameter("β")
ws_mixer = QuantumCircuit(len(sigma))
for idx, theta in enumerate(thetas):
ws_mixer.ry(-theta, idx)
ws_mixer.rz(-2 * beta, idx)
ws_mixer.ry(theta, idx)
ws_mixer.draw(output="mpl")
ws_qaoa_mes = QAOA(
sampler=Sampler(),
optimizer=COBYLA(),
initial_state=init_qc,
mixer=ws_mixer,
initial_point=[0.0, 1.0],
)
ws_qaoa = MinimumEigenOptimizer(ws_qaoa_mes)
ws_qaoa_result = ws_qaoa.solve(qubo)
print(ws_qaoa_result.prettyprint())
def format_qaoa_samples(samples, max_len: int = 10):
qaoa_res = []
for s in samples:
if sum(s.x) == 3:
qaoa_res.append(("".join([str(int(_)) for _ in s.x]), s.fval, s.probability))
res = sorted(qaoa_res, key=lambda x: -x[1])[0:max_len]
return [(_[0] + f": value: {_[1]:.3f}, probability: {1e2*_[2]:.1f}%") for _ in res]
format_qaoa_samples(qaoa_result.samples)
format_qaoa_samples(ws_qaoa_result.samples)
from qiskit_optimization.algorithms import WarmStartQAOAOptimizer
qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 1.0])
ws_qaoa = WarmStartQAOAOptimizer(
pre_solver=CplexOptimizer(), relax_for_pre_solver=True, qaoa=qaoa_mes, epsilon=0.0
)
ws_result = ws_qaoa.solve(qubo)
print(ws_result.prettyprint())
format_qaoa_samples(ws_result.samples)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
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/xtophe388/QISKIT
|
xtophe388
|
# Checking the version of PYTHON; we only support 3 at the moment
import sys
if sys.version_info < (3,0):
raise Exception('Please use Python version 3 or greater.')
# useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
import time
from pprint import pprint
# importing the QISKit
from qiskit import QuantumCircuit, QuantumProgram
#import Qconfig
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
QPS_SPECS = {
'circuits': [{
'name': 'W_states',
'quantum_registers': [{
'name':'q',
'size':5
}],
'classical_registers': [{
'name':'c',
'size':5
}]}],
}
Q_program = QuantumProgram(specs=QPS_SPECS)
#Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
"Choice of the backend"
# The flag_qx2 must be "True" for using the ibmqx2.
# "True" is also better when using the simulator (shorter circuit)
#backend = 'ibmqx2'
#backend = 'ibmqx4'
backend = 'local_qasm_simulator'
#backend = 'ibmqx_hpc_qasm_simulator'
flag_qx2 = True
if backend == 'ibmqx4':
flag_qx2 = False
print("Your choice for the backend is: ", backend, "flag_qx2 is: ", flag_qx2)
# Here, two useful routine
# Define a F_gate
def F_gate(circ,q,i,j,n,k) :
theta = np.arccos(np.sqrt(1/(n-k+1)))
circ.ry(-theta,q[j])
circ.cz(q[i],q[j])
circ.ry(theta,q[j])
circ.barrier(q[i])
# Define the cxrv gate which uses reverse CNOT instead of CNOT
def cxrv(circ,q,i,j) :
circ.h(q[i])
circ.h(q[j])
circ.cx(q[j],q[i])
circ.h(q[i])
circ.h(q[j])
circ.barrier(q[i],q[j])
# 3-qubit W state Step 1
Q_program = QuantumProgram(specs=QPS_SPECS)
#Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
W_states = Q_program.get_circuit('W_states')
q = Q_program.get_quantum_register('q')
c = Q_program.get_classical_register('c')
W_states.x(q[2]) #start is |100>
F_gate(W_states,q,2,1,3,1) # Applying F12
for i in range(3) :
W_states.measure(q[i] , c[i])
circuits = ['W_states']
shots = 1024
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('start W state 3-qubit (step 1) on', backend, "N=", shots,time_exp)
result = Q_program.execute(circuits, backend=backend, shots=shots, max_credits=5, wait=5, timeout=600)
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('end W state 3-qubit (step 1) on', backend, "N=", shots,time_exp)
plot_histogram(result.get_counts('W_states'))
# 3-qubit W state, first and second steps
Q_program = QuantumProgram(specs=QPS_SPECS)
#Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
W_states = Q_program.get_circuit('W_states')
q = Q_program.get_quantum_register('q')
c = Q_program.get_classical_register('c')
W_states.x(q[2]) #start is |100>
F_gate(W_states,q,2,1,3,1) # Applying F12
F_gate(W_states,q,1,0,3,2) # Applying F23
for i in range(3) :
W_states.measure(q[i] , c[i])
circuits = ['W_states']
shots = 1024
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('start W state 3-qubit (steps 1 + 2) on', backend, "N=", shots,time_exp)
result = Q_program.execute(circuits, backend=backend, shots=shots, max_credits=5, wait=5, timeout=600)
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('end W state 3-qubit (steps 1 + 2) on', backend, "N=", shots,time_exp)
plot_histogram(result.get_counts('W_states'))
# 3-qubit W state
Q_program = QuantumProgram(specs=QPS_SPECS)
#Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
W_states = Q_program.get_circuit('W_states')
q = Q_program.get_quantum_register('q')
c = Q_program.get_classical_register('c')
W_states.x(q[2]) #start is |100>
F_gate(W_states,q,2,1,3,1) # Applying F12
F_gate(W_states,q,1,0,3,2) # Applying F23
if flag_qx2 : # option ibmqx2
W_states.cx(q[1],q[2]) # cNOT 21
W_states.cx(q[0],q[1]) # cNOT 32
else : # option ibmqx4
cxrv(W_states,q,1,2)
cxrv(W_states,q,0,1)
for i in range(3) :
W_states.measure(q[i] , c[i])
circuits = ['W_states']
shots = 1024
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('start W state 3-qubit on', backend, "N=", shots,time_exp)
result = Q_program.execute(circuits, backend=backend, shots=shots, max_credits=5, wait=5, timeout=600)
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('end W state 3-qubit on', backend, "N=", shots,time_exp)
plot_histogram(result.get_counts('W_states'))
# 4-qubit W state
Q_program = QuantumProgram(specs=QPS_SPECS)
# Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
W_states = Q_program.get_circuit('W_states')
q = Q_program.get_quantum_register('q')
c = Q_program.get_classical_register('c')
W_states.x(q[3]) #start is |1000>
F_gate(W_states,q,3,2,4,1) # Applying F12
F_gate(W_states,q,2,1,4,2) # Applying F23
F_gate(W_states,q,1,0,4,3) # Applying F34
cxrv(W_states,q,2,3) # cNOT 21
if flag_qx2 : # option ibmqx2
W_states.cx(q[1],q[2]) # cNOT 32
W_states.cx(q[0],q[1]) # cNOT 43
else : # option ibmqx4
cxrv(W_states,q,1,2)
cxrv(W_states,q,0,1)
for i in range(4) :
W_states.measure(q[i] , c[i])
circuits = ['W_states']
shots = 1024
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('start W state 4-qubit ', backend, "N=", shots,time_exp)
result = Q_program.execute(circuits, backend=backend, shots=shots, max_credits=5, wait=5, timeout=600)
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('end W state 4-qubit on', backend, "N=", shots,time_exp)
plot_histogram(result.get_counts('W_states'))
# 5-qubit W state
Q_program = QuantumProgram(specs=QPS_SPECS)
#Q_program.set_api(Qconfig.APItoken, Qconfig.config['url'])
W_states = Q_program.get_circuit('W_states')
q = Q_program.get_quantum_register('q')
c = Q_program.get_classical_register('c')
W_states.x(q[4]) #start is |10000>
F_gate(W_states,q,4,3,5,1) # Applying F12
F_gate(W_states,q,3,2,5,2) # Applying F23
F_gate(W_states,q,2,1,5,3) # Applying F34
F_gate(W_states,q,1,0,5,4) # Applying F45
W_states.cx(q[3],q[4]) # cNOT 21
cxrv(W_states,q,2,3) # cNOT 32
if flag_qx2 : # option ibmqx2
W_states.cx(q[1],q[2]) # cNOT 43
W_states.cx(q[0],q[1]) # cNOT 54
else : # option ibmqx4
cxrv(W_states,q,1,2)
cxrv(W_states,q,0,1)
for i in range(5) :
W_states.measure(q[i] , c[i])
circuits = ['W_states']
shots = 1024
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('start W state 5-qubit on', backend, "N=", shots,time_exp)
result = Q_program.execute(circuits, backend=backend, shots=shots, max_credits=5, wait=5, timeout=1200)
time_exp = time.strftime('%d/%m/%Y %H:%M:%S')
print('end W state 5-qubit on', backend, "N=", shots,time_exp)
plot_histogram(result.get_counts('W_states'))
|
https://github.com/peiyong-addwater/Hackathon-QNLP
|
peiyong-addwater
|
import tarfile
from urllib.request import urlretrieve
from depccg.instance_models import MODEL_DIRECTORY
URL = 'https://qnlp.cambridgequantum.com/models/tri_headfirst.tar.gz'
print('Please consider using Bobcat, the parser included with lambeq,\n'
'instead of depccg.')
def print_progress(chunk: int, chunk_size: int, size: int) -> None:
percentage = chunk * chunk_size / size
mb_size = size / 10**6
print(f'\rDownloading model... {percentage:.1%} of {mb_size:.1f} MB',
end='')
print(MODEL_DIRECTORY)
print('Downloading model...', end='')
download, _ = urlretrieve(URL, reporthook=print_progress)
print('\nExtracting model...')
tarfile.open(download).extractall(MODEL_DIRECTORY)
print('Download successful')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, execute
from qiskit.providers.fake_provider import FakeVigoV2
from qiskit.visualization import plot_gate_map
backend = FakeVigoV2()
plot_gate_map(backend)
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
global c
c = QuantumCircuit(2,2)
def ua(bit_0 , bit_1):
global c
if(bit_0 == 1):
if(bit_1 == 0):
c.x(0)
else:
c.h(0)
ua(0,0)
c.draw()
c.reset(0)
c.reset(1)
c.draw()
def ub(numeo_bob):
2 -> comp
3 -> diag
0 == 0
0 == 1
qc = QuantumCircuit(2,2)
qc.y(1)
qc.measure(1,1)
qc.draw()
backend = Aer.get_backend('qasm_simulator')
result = execute(qc, backend, shots = 1).result()
count = result.get_counts()
count
int(count.popitem()[0][0])
import random
def index(abc):
index = random.randint(0, abc)
i = index(len(lista_bases))
[c,d,c,d,c]
[c,c,c,d,c]
|
https://github.com/zeynepCankara/Introduction-Quantum-Programming
|
zeynepCankara
|
from random import randrange
A = []
B = []
for i in range(3):
A.append([])
B.append([])
for j in range(4):
A[i].append(randrange(-5,6))
B[i].append(randrange(-5,6))
print("A is",A)
print("B is",B)
C = []
for i in range(3):
C.append([])
for j in range(4):
C[i].append( 3*A[i][j]-2*B[i][j])
print("C is 3A - 2B")
print("C is",C)
M = [
[-2,3,0,4],
[-1,1,5,9]
]
N =[
[1,2,3],
[4,5,6],
[7,8,9]
]
# create the transpose of M as a zero matrix
# its dimension is (4x2)
MT = []
for i in range(4):
MT.append([])
for j in range(2):
MT[i].append(0)
# create the transpose of N as a zero matrix
# its dimension is (3x3)
NT = []
for i in range(3):
NT.append([])
for j in range(3):
NT[i].append(0)
# calculate the MT
for i in range(2):
for j in range(4):
MT[j][i]=M[i][j] # check the indices
print("M is")
for i in range(len(M)):
print(M[i])
print()
print("Transpose of M is")
for i in range(len(MT)):
print(MT[i])
print()
# calculate the NT
for i in range(3):
for j in range(3):
NT[j][i]=N[i][j] # check the indices
print("N is")
for i in range(len(N)):
print(N[i])
print()
print("Transpose of N is")
for i in range(len(NT)):
print(NT[i])
N = [
[-1,1,2],
[0,-2,-3],
[3,2,5],
[0,2,-2]
]
u = [2,-1,3]
uprime =[]
print("N is")
for i in range(len(N)):
print(N[i])
print()
print("u is",u)
for i in range(len(N)): # the number of rows of N
S = 0 # summation of pairwise multiplications
for j in range(len(u)): # the dimension of u
S = S + N[i][j] * u[j]
uprime.append(S)
print()
print("u' is",uprime)
# matrix M
M = [
[-1,0,1],
[-2,-1,2],
[1,2,-2]
]
# matrix N
N = [
[0,2,1],
[3,-1,-2],
[-1,1,0]
]
# matrix K
K = []
for i in range(3):
K.append([])
for j in range(3):
# here we calculate K[i][j]
# inner product of i-th row of M with j-th row of N
S = 0
for k in range(3):
S = S + M[i][k] * N[k][j]
K[i].append(S)
print("M is")
for i in range(len(M)):
print(M[i])
print()
print("N is")
for i in range(len(N)):
print(N[i])
print()
print("K is")
for i in range(len(K)):
print(K[i])
from random import randrange
A = []
B = []
AB = []
BA = []
DIFF = []
# create A, B, AB, BA, DIFF together
for i in range(2):
A.append([])
B.append([])
AB.append([])
BA.append([])
DIFF.append([])
for j in range(2):
A[i].append(randrange(-10,10)) # the elements of A are random
B[i].append(randrange(-10,10)) # the elements of B are random
AB[i].append(0) # the elements of AB are initially set to zeros
BA[i].append(0) # the elements of BA are initially set to zeros
DIFF[i].append(0) # the elements of DIFF are initially set to zeros
print("A =",A)
print("B =",B)
print() # print a line
print("AB, BA, and DIFF are initially zero matrices")
print("AB =",AB)
print("BA =",BA)
print("DIFF =",BA)
# let's find AB
for i in range(2):
for j in range(2):
# remark that AB[i][j] is already 0, and so we can directly add all pairwise multiplications
for k in range(2):
AB[i][j] = AB[i][j] + A[i][k] * B[k][j] # each multiplication is added
print() # print a line
print("AB =",AB)
# let's find BA
for i in range(2):
for j in range(2):
# remark that BA[i][j] is already 0, and so we can directly add all pairwise multiplications
for k in range(2):
BA[i][j] = BA[i][j] + B[i][k] * A[k][j] # each multiplication is added
print("BA =",BA)
# let's calculate DIFF = AB- BA
for i in range(2):
for j in range(2):
DIFF[i][j] = AB[i][j] - BA[i][j]
print() # print a line
print("DIFF = AB - BA =",DIFF)
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
secret_unitary = 'hz'
# make the imports that are necessary for our work
import qiskit as qk
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
from qiskit import execute, Aer
from qiskit import IBMQ
from qiskit.tools.visualization import plot_histogram
# simple function that applies a series of unitary gates from a given string
def apply_secret_unitary(secret_unitary, qubit, quantum_circuit, dagger):
functionmap = {
'x':quantum_circuit.x,
'y':quantum_circuit.y,
'z':quantum_circuit.z,
'h':quantum_circuit.h,
't':quantum_circuit.t,
}
if dagger: functionmap['t'] = quantum_circuit.tdg
if dagger:
[functionmap[unitary](qubit) for unitary in secret_unitary]
else:
[functionmap[unitary](qubit) for unitary in secret_unitary[::-1]]
# Create the quantum circuit
q = QuantumRegister(3)
c = ClassicalRegister(3)
qc = QuantumCircuit(q, c)
''' Qubit ordering as follows (classical registers will just contain measured values of the corresponding qubits):
q[0]: qubit to be teleported (Alice's first qubit. It was given to her after the application of a secret unitary
which she doesn't know)
q[1]: Alice's second qubit
q[2]: Bob's qubit, which will be the destination for the teleportation
'''
# Apply the secret unitary that we are using to generate the state to teleport. You can change it to any unitary
apply_secret_unitary(secret_unitary, q[0], qc, dagger = 0)
qc.barrier()
# Next, generate the entangled pair between Alice and Bob (Remember: Hadamard followed by CX generates a Bell pair)
qc.h(q[1])
qc.cx(q[1], q[2])
qc.barrier()
# Next, apply the teleportation protocol.
qc.cx(q[0], q[1])
qc.h(q[0])
qc.measure(q[0], c[0])
qc.measure(q[1], c[1])
qc.cx(q[1], q[2])
qc.cz(q[0], q[2])
qc.barrier()
'''
In principle, if the teleportation protocol worked, we have q[2] = secret_unitary|0>
As a result, we should be able to recover q[2] = |0> by applying the reverse of secret_unitary
since for a unitary u, u^dagger u = I.
'''
apply_secret_unitary(secret_unitary, q[2], qc, dagger=1)
qc.measure(q[2], c[2])
qc.draw(output='mpl')
backend = Aer.get_backend('qasm_simulator')
job_sim = execute(qc, backend, shots=1024)
sim_result = job_sim.result()
measurement_result = sim_result.get_counts(qc)
print(measurement_result)
plot_histogram(measurement_result)
# First, see what devices we are allowed to use by loading our saved accounts
IBMQ.load_account()
IBMQ.get_provider(hub='ibm-q')
provider.backends()
# get the least-busy backend at IBM and run the quantum circuit there
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(simulator=False))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/qiskit-community/qgss-2023
|
qiskit-community
|
# required imports:
from qiskit.visualization import array_to_latex
from qiskit.quantum_info import Statevector, random_statevector
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit import QuantumCircuit
from qiskit.circuit.library import HGate, CXGate
import numpy as np
ket0 = [[1],[0]]
array_to_latex(ket0)
bra0 = [1,0]
array_to_latex(bra0)
ket1 = # put your answer answer here for |1⟩
bra1 = # put answer here for ⟨1|
from qc_grader.challenges.qgss_2023 import grade_lab1_ex1
grade_lab1_ex1([ket1, bra1])
sv_bra0 = Statevector(bra0)
sv_bra0
sv_bra0.draw('latex')
sv_eq = Statevector([1/2, 3/4, 4/5, 6/8])
sv_eq.draw('latex')
sv_eq.is_valid()
sv_valid = # create your statevector here
from qc_grader.challenges.qgss_2023 import grade_lab1_ex2
grade_lab1_ex2(sv_valid)
op_bra0 = Operator(bra0)
op_bra0
op_ket0 = Operator(ket0)
op_bra0.tensor(op_ket0)
braket = np.dot(op_bra0,op_ket0)
array_to_latex(braket)
ketbra = np.outer(ket0,bra0)
array_to_latex(ketbra)
braket = np.dot(op_bra0,op_ket0)
array_to_latex(braket)
bra1ket0 = # put your answer for ⟨1|0⟩ here
bra0ket1 = # put your answer for ⟨0|1⟩ here
bra1ket1 = # put your answer for ⟨1|1⟩ here
ket1bra0 = # put your answer for |1⟩⟨0| here
ket0bra1 = # put your answer for |0⟩⟨1| here
ket1bra1 = # put your answer for |1⟩⟨1| here
from qc_grader.challenges.qgss_2023 import grade_lab1_ex3
grade_lab1_ex3([bra1ket0, bra0ket1, bra1ket1, ket1bra0, ket0bra1, ket1bra1])
# add or remove your answer from this list
answer = ['a', 'b', 'c']
from qc_grader.challenges.qgss_2023 import grade_lab1_ex4
grade_lab1_ex4(answer)
m1 = Operator([[1,1],[0,0]])
array_to_latex(m1)
m3 = Operator([[0,1],[1,0]])
array_to_latex(m3)
array_to_latex(m1@ket0)
m2 = # create an operator for m2 here
m4 = # create and operator for m4 here
from qc_grader.challenges.qgss_2023 import grade_lab1_ex5
grade_lab1_ex5([m2, m4])
cnot = CXGate()
array_to_latex(cnot)
m3.is_unitary()
random = Operator(np.array([[ 0.50778085-0.44607116j, -0.1523741 +0.14128434j, 0.44607116+0.50778085j,
-0.14128434-0.1523741j ],
[ 0.16855994+0.12151822j, 0.55868196+0.38038841j, -0.12151822+0.16855994j,
-0.38038841+0.55868196j],
[ 0.50778085-0.44607116j, -0.1523741 +0.14128434j, -0.44607116-0.50778085j,
0.14128434+0.1523741j ],
[ 0.16855994+0.12151822j, 0.55868196+0.38038841j, 0.12151822-0.16855994j,
0.38038841-0.55868196j]]))
random.is_unitary()
non_unitary_op = # create your operator here
from qc_grader.challenges.qgss_2023 import grade_lab1_ex6
grade_lab1_ex6(non_unitary_op)
pauli_x = Pauli('X')
array_to_latex(pauli_x)
pauli_y = Pauli('Y')
array_to_latex(pauli_y)
pauli_z = Pauli('Z')
array_to_latex(pauli_z)
op_x = Operator(pauli_x)
op_x
op_new = np.dot(op_x,ket0)
array_to_latex(op_new)
result = # do your operations here
from qc_grader.challenges.qgss_2023 import grade_lab1_ex7
grade_lab1_ex7(result)
hadamard = HGate()
array_to_latex(hadamard)
hop = Operator(hadamard)
hop.is_unitary()
bell = QuantumCircuit(2)
bell.h(0) # apply an H gate to the circuit
bell.cx(0,1) # apply a CNOT gate to the circuit
bell.draw(output="mpl")
bell_op = Operator(bell)
array_to_latex(bell_op)
ghz = QuantumCircuit(3)
##############################
# add gates to your circuit here
##############################
ghz.draw(output='mpl')
from qc_grader.challenges.qgss_2023 import grade_lab1_ex8
grade_lab1_ex8(ghz)
plus_state = Statevector.from_label("+")
plus_state.draw('latex')
plus_state
plus_state.probabilities_dict()
# run this cell multiple times to show collapsing into one state or the other
res = plus_state.measure()
res
qc = QuantumCircuit(1,1)
qc.h(0)
qc.measure(0, 0)
qc.draw(output="mpl")
sv_bell = Statevector([np.sqrt(1/2), 0, 0, np.sqrt(1/2)])
sv_bell.draw('latex')
sv_bell.probabilities_dict()
sv_psi_plus = # create a statevector for |𝜓+⟩ here
prob_psi_plus = # find the measurement probabilities for |𝜓+⟩ here
sv_psi_minus = # create a statevector for |𝜓−⟩ here
prob_psi_minus = # find the measurement probabilities for |𝜓−⟩ here
sv_phi_minus = # create a statevector for |𝜙−⟩ here
prob_phi_minus = # find the measurement probabilities for |𝜙−⟩ here
from qc_grader.challenges.qgss_2023 import grade_lab1_ex9
grade_lab1_ex9([prob_psi_plus, prob_psi_minus, prob_phi_minus])
qft = QuantumCircuit(2)
##############################
# add gates to your circuit here
##############################
qft.draw(output='mpl')
from qc_grader.challenges.qgss_2023 import grade_lab1_ex10
grade_lab1_ex10(qft)
U = Operator(qft)
array_to_latex(U)
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import qiskit
from qiskit import IBMQ # requires qiskit version >= 0.6
IBMQ.save_account("MY_TOKEN")
IBMQ.load_accounts()
for backend in IBMQ.backends():
print(backend)
backend_0 = IBMQ.backends()[0] # retrieve the Backend at index 0
print(backend_0.configuration())
print("Go check its specification at %s" % backend_0.configuration()["url"])
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test CZ circuits synthesis functions."""
import unittest
from test import combine
import numpy as np
from ddt import ddt
from qiskit import QuantumCircuit
from qiskit.circuit.library import Permutation
from qiskit.synthesis.linear_phase import synth_cz_depth_line_mr
from qiskit.synthesis.linear.linear_circuits_utils import check_lnn_connectivity
from qiskit.quantum_info import Clifford
from qiskit.test import QiskitTestCase
@ddt
class TestCZSynth(QiskitTestCase):
"""Test the linear reversible circuit synthesis functions."""
@combine(num_qubits=[3, 4, 5, 6, 7])
def test_cz_synth_lnn(self, num_qubits):
"""Test the CZ synthesis code for linear nearest neighbour connectivity."""
seed = 1234
rng = np.random.default_rng(seed)
num_gates = 10
num_trials = 5
for _ in range(num_trials):
mat = np.zeros((num_qubits, num_qubits))
qctest = QuantumCircuit(num_qubits)
# Generate a random CZ circuit
for _ in range(num_gates):
i = rng.integers(num_qubits)
j = rng.integers(num_qubits)
if i != j:
qctest.cz(i, j)
if j > i:
mat[i][j] = (mat[i][j] + 1) % 2
else:
mat[j][i] = (mat[j][i] + 1) % 2
qc = synth_cz_depth_line_mr(mat)
# Check that the output circuit 2-qubit depth equals to 2*n+2
depth2q = qc.depth(filter_function=lambda x: x.operation.num_qubits == 2)
self.assertTrue(depth2q == 2 * num_qubits + 2)
# Check that the output circuit has LNN connectivity
self.assertTrue(check_lnn_connectivity(qc))
# Assert that we get the same element, up to reverse order of qubits
perm = Permutation(num_qubits=num_qubits, pattern=range(num_qubits)[::-1])
qctest = qctest.compose(perm)
self.assertEqual(Clifford(qc), Clifford(qctest))
if __name__ == "__main__":
unittest.main()
|
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.
"""Randomized tests of quantum synthesis."""
import unittest
from test.python.quantum_info.test_synthesis import CheckDecompositions
from hypothesis import given, strategies, settings
import numpy as np
from qiskit import execute
from qiskit.circuit import QuantumCircuit, QuantumRegister
from qiskit.extensions import UnitaryGate
from qiskit.providers.basicaer import UnitarySimulatorPy
from qiskit.quantum_info.random import random_unitary
from qiskit.quantum_info.synthesis.two_qubit_decompose import (
two_qubit_cnot_decompose,
TwoQubitBasisDecomposer,
Ud,
)
class TestSynthesis(CheckDecompositions):
"""Test synthesis"""
seed = strategies.integers(min_value=0, max_value=2**32 - 1)
rotation = strategies.floats(min_value=-np.pi * 10, max_value=np.pi * 10)
@given(seed)
def test_1q_random(self, seed):
"""Checks one qubit decompositions"""
unitary = random_unitary(2, seed=seed)
self.check_one_qubit_euler_angles(unitary)
self.check_one_qubit_euler_angles(unitary, "U3")
self.check_one_qubit_euler_angles(unitary, "U1X")
self.check_one_qubit_euler_angles(unitary, "PSX")
self.check_one_qubit_euler_angles(unitary, "ZSX")
self.check_one_qubit_euler_angles(unitary, "ZYZ")
self.check_one_qubit_euler_angles(unitary, "ZXZ")
self.check_one_qubit_euler_angles(unitary, "XYX")
self.check_one_qubit_euler_angles(unitary, "RR")
@settings(deadline=None)
@given(seed)
def test_2q_random(self, seed):
"""Checks two qubit decompositions"""
unitary = random_unitary(4, seed=seed)
self.check_exact_decomposition(unitary.data, two_qubit_cnot_decompose)
@given(strategies.tuples(*[seed] * 5))
def test_exact_supercontrolled_decompose_random(self, seeds):
"""Exact decomposition for random supercontrolled basis and random target"""
k1 = np.kron(random_unitary(2, seed=seeds[0]).data, random_unitary(2, seed=seeds[1]).data)
k2 = np.kron(random_unitary(2, seed=seeds[2]).data, random_unitary(2, seed=seeds[3]).data)
basis_unitary = k1 @ Ud(np.pi / 4, 0, 0) @ k2
decomposer = TwoQubitBasisDecomposer(UnitaryGate(basis_unitary))
self.check_exact_decomposition(random_unitary(4, seed=seeds[4]).data, decomposer)
@given(strategies.tuples(*[rotation] * 6), seed)
def test_cx_equivalence_0cx_random(self, rnd, seed):
"""Check random circuits with 0 cx gates locally equivalent to identity."""
qr = QuantumRegister(2, name="q")
qc = QuantumCircuit(qr)
qc.u(rnd[0], rnd[1], rnd[2], qr[0])
qc.u(rnd[3], rnd[4], rnd[5], qr[1])
sim = UnitarySimulatorPy()
unitary = execute(qc, sim, seed_simulator=seed).result().get_unitary()
self.assertEqual(two_qubit_cnot_decompose.num_basis_gates(unitary), 0)
@given(strategies.tuples(*[rotation] * 12), seed)
def test_cx_equivalence_1cx_random(self, rnd, seed):
"""Check random circuits with 1 cx gates locally equivalent to a cx."""
qr = QuantumRegister(2, name="q")
qc = QuantumCircuit(qr)
qc.u(rnd[0], rnd[1], rnd[2], qr[0])
qc.u(rnd[3], rnd[4], rnd[5], qr[1])
qc.cx(qr[1], qr[0])
qc.u(rnd[6], rnd[7], rnd[8], qr[0])
qc.u(rnd[9], rnd[10], rnd[11], qr[1])
sim = UnitarySimulatorPy()
unitary = execute(qc, sim, seed_simulator=seed).result().get_unitary()
self.assertEqual(two_qubit_cnot_decompose.num_basis_gates(unitary), 1)
@given(strategies.tuples(*[rotation] * 18), seed)
def test_cx_equivalence_2cx_random(self, rnd, seed):
"""Check random circuits with 2 cx gates locally equivalent to some circuit with 2 cx."""
qr = QuantumRegister(2, name="q")
qc = QuantumCircuit(qr)
qc.u(rnd[0], rnd[1], rnd[2], qr[0])
qc.u(rnd[3], rnd[4], rnd[5], qr[1])
qc.cx(qr[1], qr[0])
qc.u(rnd[6], rnd[7], rnd[8], qr[0])
qc.u(rnd[9], rnd[10], rnd[11], qr[1])
qc.cx(qr[0], qr[1])
qc.u(rnd[12], rnd[13], rnd[14], qr[0])
qc.u(rnd[15], rnd[16], rnd[17], qr[1])
sim = UnitarySimulatorPy()
unitary = execute(qc, sim, seed_simulator=seed).result().get_unitary()
self.assertEqual(two_qubit_cnot_decompose.num_basis_gates(unitary), 2)
@given(strategies.tuples(*[rotation] * 24), seed)
def test_cx_equivalence_3cx_random(self, rnd, seed):
"""Check random circuits with 3 cx gates are outside the 0, 1, and 2 qubit regions."""
qr = QuantumRegister(2, name="q")
qc = QuantumCircuit(qr)
qc.u(rnd[0], rnd[1], rnd[2], qr[0])
qc.u(rnd[3], rnd[4], rnd[5], qr[1])
qc.cx(qr[1], qr[0])
qc.u(rnd[6], rnd[7], rnd[8], qr[0])
qc.u(rnd[9], rnd[10], rnd[11], qr[1])
qc.cx(qr[0], qr[1])
qc.u(rnd[12], rnd[13], rnd[14], qr[0])
qc.u(rnd[15], rnd[16], rnd[17], qr[1])
qc.cx(qr[1], qr[0])
qc.u(rnd[18], rnd[19], rnd[20], qr[0])
qc.u(rnd[21], rnd[22], rnd[23], qr[1])
sim = UnitarySimulatorPy()
unitary = execute(qc, sim, seed_simulator=seed).result().get_unitary()
self.assertEqual(two_qubit_cnot_decompose.num_basis_gates(unitary), 3)
if __name__ == "__main__":
unittest.main()
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""User-space constructor functions for the expression tree, which do some of the inference and
lifting boilerplate work."""
# pylint: disable=redefined-builtin,redefined-outer-name
from __future__ import annotations
__all__ = [
"lift",
"bit_not",
"logic_not",
"bit_and",
"bit_or",
"bit_xor",
"logic_and",
"logic_or",
"equal",
"not_equal",
"less",
"less_equal",
"greater",
"greater_equal",
"lift_legacy_condition",
]
import enum
import typing
from .expr import Expr, Var, Value, Unary, Binary, Cast
from .. import types
if typing.TYPE_CHECKING:
import qiskit
class _CastKind(enum.Enum):
EQUAL = enum.auto()
"""The two types are equal; no cast node is required at all."""
IMPLICIT = enum.auto()
"""The 'from' type can be cast to the 'to' type implicitly. A ``Cast(implicit=True)`` node is
the minimum required to specify this."""
LOSSLESS = enum.auto()
"""The 'from' type can be cast to the 'to' type explicitly, and the cast will be lossless. This
requires a ``Cast(implicit=False)`` node, but there's no danger from inserting one."""
DANGEROUS = enum.auto()
"""The 'from' type has a defined cast to the 'to' type, but depending on the value, it may lose
data. A user would need to manually specify casts."""
NONE = enum.auto()
"""There is no casting permitted from the 'from' type to the 'to' type."""
def _uint_cast(from_: types.Uint, to_: types.Uint, /) -> _CastKind:
if from_.width == to_.width:
return _CastKind.EQUAL
if from_.width < to_.width:
return _CastKind.LOSSLESS
return _CastKind.DANGEROUS
_ALLOWED_CASTS = {
(types.Bool, types.Bool): lambda _a, _b, /: _CastKind.EQUAL,
(types.Bool, types.Uint): lambda _a, _b, /: _CastKind.LOSSLESS,
(types.Uint, types.Bool): lambda _a, _b, /: _CastKind.IMPLICIT,
(types.Uint, types.Uint): _uint_cast,
}
def _cast_kind(from_: types.Type, to_: types.Type, /) -> _CastKind:
if (coercer := _ALLOWED_CASTS.get((from_.kind, to_.kind))) is None:
return _CastKind.NONE
return coercer(from_, to_)
def _coerce_lossless(expr: Expr, type: types.Type) -> Expr:
"""Coerce ``expr`` to ``type`` by inserting a suitable :class:`Cast` node, if the cast is
lossless. Otherwise, raise a ``TypeError``."""
kind = _cast_kind(expr.type, type)
if kind is _CastKind.EQUAL:
return expr
if kind is _CastKind.IMPLICIT:
return Cast(expr, type, implicit=True)
if kind is _CastKind.LOSSLESS:
return Cast(expr, type, implicit=False)
if kind is _CastKind.DANGEROUS:
raise TypeError(f"cannot cast '{expr}' to '{type}' without loss of precision")
raise TypeError(f"no cast is defined to take '{expr}' to '{type}'")
def lift_legacy_condition(
condition: tuple[qiskit.circuit.Clbit | qiskit.circuit.ClassicalRegister, int], /
) -> Expr:
"""Lift a legacy two-tuple equality condition into a new-style :class:`Expr`.
Examples:
Taking an old-style conditional instruction and getting an :class:`Expr` from its
condition::
from qiskit.circuit import ClassicalRegister
from qiskit.circuit.library import HGate
from qiskit.circuit.classical import expr
cr = ClassicalRegister(2)
instr = HGate().c_if(cr, 3)
lifted = expr.lift_legacy_condition(instr.condition)
"""
from qiskit.circuit import Clbit # pylint: disable=cyclic-import
target, value = condition
if isinstance(target, Clbit):
bool_ = types.Bool()
return Var(target, bool_) if value else Unary(Unary.Op.LOGIC_NOT, Var(target, bool_), bool_)
left = Var(target, types.Uint(width=target.size))
if value.bit_length() > target.size:
left = Cast(left, types.Uint(width=value.bit_length()), implicit=True)
right = Value(value, left.type)
return Binary(Binary.Op.EQUAL, left, right, types.Bool())
def lift(value: typing.Any, /, type: types.Type | None = None) -> Expr:
"""Lift the given Python ``value`` to a :class:`~.expr.Value` or :class:`~.expr.Var`.
If an explicit ``type`` is given, the typing in the output will reflect that.
Examples:
Lifting simple circuit objects to be :class:`~.expr.Var` instances::
>>> from qiskit.circuit import Clbit, ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.lift(Clbit())
Var(<clbit>, Bool())
>>> expr.lift(ClassicalRegister(3, "c"))
Var(ClassicalRegister(3, "c"), Uint(3))
The type of the return value can be influenced, if the given value could be interpreted
losslessly as the given type (use :func:`cast` to perform a full set of casting
operations, include lossy ones)::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr, types
>>> expr.lift(ClassicalRegister(3, "c"), types.Uint(5))
Var(ClassicalRegister(3, "c"), Uint(5))
>>> expr.lift(5, types.Uint(4))
Value(5, Uint(4))
"""
if isinstance(value, Expr):
if type is not None:
raise ValueError("use 'cast' to cast existing expressions, not 'lift'")
return value
from qiskit.circuit import Clbit, ClassicalRegister # pylint: disable=cyclic-import
inferred: types.Type
if value is True or value is False or isinstance(value, Clbit):
inferred = types.Bool()
constructor = Value if value is True or value is False else Var
elif isinstance(value, ClassicalRegister):
inferred = types.Uint(width=value.size)
constructor = Var
elif isinstance(value, int):
if value < 0:
raise ValueError("cannot represent a negative value")
inferred = types.Uint(width=value.bit_length() or 1)
constructor = Value
else:
raise TypeError(f"failed to infer a type for '{value}'")
if type is None:
type = inferred
if types.is_supertype(type, inferred):
return constructor(value, type)
raise TypeError(
f"the explicit type '{type}' is not suitable for representing '{value}';"
f" it must be non-strict supertype of '{inferred}'"
)
def cast(operand: typing.Any, type: types.Type, /) -> Expr:
"""Create an explicit cast from the given value to the given type.
Examples:
Add an explicit cast node that explicitly casts a higher precision type to a lower precision
one::
>>> from qiskit.circuit.classical import expr, types
>>> value = expr.value(5, types.Uint(32))
>>> expr.cast(value, types.Uint(8))
Cast(Value(5, types.Uint(32)), types.Uint(8), implicit=False)
"""
operand = lift(operand)
if _cast_kind(operand.type, type) is _CastKind.NONE:
raise TypeError(f"cannot cast '{operand}' to '{type}'")
return Cast(operand, type)
def bit_not(operand: typing.Any, /) -> Expr:
"""Create a bitwise 'not' expression node from the given value, resolving any implicit casts and
lifting the value into a :class:`Value` node if required.
Examples:
Bitwise negation of a :class:`.ClassicalRegister`::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_not(ClassicalRegister(3, "c"))
Unary(Unary.Op.BIT_NOT, Var(ClassicalRegister(3, 'c'), Uint(3)), Uint(3))
"""
operand = lift(operand)
if operand.type.kind not in (types.Bool, types.Uint):
raise TypeError(f"cannot apply '{Unary.Op.BIT_NOT}' to type '{operand.type}'")
return Unary(Unary.Op.BIT_NOT, operand, operand.type)
def logic_not(operand: typing.Any, /) -> Expr:
"""Create a logical 'not' expression node from the given value, resolving any implicit casts and
lifting the value into a :class:`Value` node if required.
Examples:
Logical negation of a :class:`.ClassicalRegister`::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.logic_not(ClassicalRegister(3, "c"))
Unary(\
Unary.Op.LOGIC_NOT, \
Cast(Var(ClassicalRegister(3, 'c'), Uint(3)), Bool(), implicit=True), \
Bool())
"""
operand = _coerce_lossless(lift(operand), types.Bool())
return Unary(Unary.Op.LOGIC_NOT, operand, operand.type)
def _lift_binary_operands(left: typing.Any, right: typing.Any) -> tuple[Expr, Expr]:
"""Lift two binary operands simultaneously, inferring the widths of integer literals in either
position to match the other operand."""
left_int = isinstance(left, int) and not isinstance(left, bool)
right_int = isinstance(right, int) and not isinstance(right, bool)
if not (left_int or right_int):
left = lift(left)
right = lift(right)
elif not right_int:
right = lift(right)
if right.type.kind is types.Uint:
if left.bit_length() > right.type.width:
raise TypeError(
f"integer literal '{left}' is wider than the other operand '{right}'"
)
left = Value(left, right.type)
else:
left = lift(left)
elif not left_int:
left = lift(left)
if left.type.kind is types.Uint:
if right.bit_length() > left.type.width:
raise TypeError(
f"integer literal '{right}' is wider than the other operand '{left}'"
)
right = Value(right, left.type)
else:
right = lift(right)
else:
# Both are `int`, so we take our best case to make things work.
uint = types.Uint(max(left.bit_length(), right.bit_length(), 1))
left = Value(left, uint)
right = Value(right, uint)
return left, right
def _binary_bitwise(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
left, right = _lift_binary_operands(left, right)
type: types.Type
if left.type.kind is right.type.kind is types.Bool:
type = types.Bool()
elif left.type.kind is types.Uint and right.type.kind is types.Uint:
if left.type != right.type:
raise TypeError(
"binary bitwise operations are defined between unsigned integers of the same width,"
f" but got {left.type.width} and {right.type.width}."
)
type = left.type
else:
raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
return Binary(op, left, right, type)
def bit_and(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a bitwise 'and' expression node from the given value, resolving any implicit casts and
lifting the values into :class:`Value` nodes if required.
Examples:
Bitwise 'and' of a classical register and an integer literal::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_and(ClassicalRegister(3, "c"), 0b111)
Binary(\
Binary.Op.BIT_AND, \
Var(ClassicalRegister(3, 'c'), Uint(3)), \
Value(7, Uint(3)), \
Uint(3))
"""
return _binary_bitwise(Binary.Op.BIT_AND, left, right)
def bit_or(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a bitwise 'or' expression node from the given value, resolving any implicit casts and
lifting the values into :class:`Value` nodes if required.
Examples:
Bitwise 'or' of a classical register and an integer literal::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_or(ClassicalRegister(3, "c"), 0b101)
Binary(\
Binary.Op.BIT_OR, \
Var(ClassicalRegister(3, 'c'), Uint(3)), \
Value(5, Uint(3)), \
Uint(3))
"""
return _binary_bitwise(Binary.Op.BIT_OR, left, right)
def bit_xor(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a bitwise 'exclusive or' expression node from the given value, resolving any implicit
casts and lifting the values into :class:`Value` nodes if required.
Examples:
Bitwise 'exclusive or' of a classical register and an integer literal::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.bit_xor(ClassicalRegister(3, "c"), 0b101)
Binary(\
Binary.Op.BIT_XOR, \
Var(ClassicalRegister(3, 'c'), Uint(3)), \
Value(5, Uint(3)), \
Uint(3))
"""
return _binary_bitwise(Binary.Op.BIT_XOR, left, right)
def _binary_logical(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
bool_ = types.Bool()
left = _coerce_lossless(lift(left), bool_)
right = _coerce_lossless(lift(right), bool_)
return Binary(op, left, right, bool_)
def logic_and(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a logical 'and' expression node from the given value, resolving any implicit casts and
lifting the values into :class:`Value` nodes if required.
Examples:
Logical 'and' of two classical bits::
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> expr.logical_and(Clbit(), Clbit())
Binary(Binary.Op.LOGIC_AND, Var(<clbit 0>, Bool()), Var(<clbit 1>, Bool()), Bool())
"""
return _binary_logical(Binary.Op.LOGIC_AND, left, right)
def logic_or(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a logical 'or' expression node from the given value, resolving any implicit casts and
lifting the values into :class:`Value` nodes if required.
Examples:
Logical 'or' of two classical bits
>>> from qiskit.circuit import Clbit
>>> from qiskit.circuit.classical import expr
>>> expr.logical_and(Clbit(), Clbit())
Binary(Binary.Op.LOGIC_OR, Var(<clbit 0>, Bool()), Var(<clbit 1>, Bool()), Bool())
"""
return _binary_logical(Binary.Op.LOGIC_OR, left, right)
def _equal_like(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
left, right = _lift_binary_operands(left, right)
if left.type.kind is not right.type.kind:
raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
type = types.greater(left.type, right.type)
return Binary(op, _coerce_lossless(left, type), _coerce_lossless(right, type), types.Bool())
def equal(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create an 'equal' expression node from the given value, resolving any implicit casts and
lifting the values into :class:`Value` nodes if required.
Examples:
Equality between a classical register and an integer::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.equal(ClassicalRegister(3, "c"), 7)
Binary(Binary.Op.EQUAL, \
Var(ClassicalRegister(3, "c"), Uint(3)), \
Value(7, Uint(3)), \
Uint(3))
"""
return _equal_like(Binary.Op.EQUAL, left, right)
def not_equal(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a 'not equal' expression node from the given value, resolving any implicit casts and
lifting the values into :class:`Value` nodes if required.
Examples:
Inequality between a classical register and an integer::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.not_equal(ClassicalRegister(3, "c"), 7)
Binary(Binary.Op.NOT_EQUAL, \
Var(ClassicalRegister(3, "c"), Uint(3)), \
Value(7, Uint(3)), \
Uint(3))
"""
return _equal_like(Binary.Op.NOT_EQUAL, left, right)
def _binary_relation(op: Binary.Op, left: typing.Any, right: typing.Any) -> Expr:
left, right = _lift_binary_operands(left, right)
if left.type.kind is not right.type.kind or left.type.kind is types.Bool:
raise TypeError(f"invalid types for '{op}': '{left.type}' and '{right.type}'")
type = types.greater(left.type, right.type)
return Binary(op, _coerce_lossless(left, type), _coerce_lossless(right, type), types.Bool())
def less(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a 'less than' expression node from the given value, resolving any implicit casts and
lifting the values into :class:`Value` nodes if required.
Examples:
Query if a classical register is less than an integer::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less(ClassicalRegister(3, "c"), 5)
Binary(Binary.Op.LESS, \
Var(ClassicalRegister(3, "c"), Uint(3)), \
Value(5, Uint(3)), \
Uint(3))
"""
return _binary_relation(Binary.Op.LESS, left, right)
def less_equal(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a 'less than or equal to' expression node from the given value, resolving any implicit
casts and lifting the values into :class:`Value` nodes if required.
Examples:
Query if a classical register is less than or equal to another::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less(ClassicalRegister(3, "a"), ClassicalRegister(3, "b"))
Binary(Binary.Op.LESS_EQUAL, \
Var(ClassicalRegister(3, "a"), Uint(3)), \
Var(ClassicalRegister(3, "b"), Uint(3)), \
Uint(3))
"""
return _binary_relation(Binary.Op.LESS_EQUAL, left, right)
def greater(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a 'greater than' expression node from the given value, resolving any implicit casts
and lifting the values into :class:`Value` nodes if required.
Examples:
Query if a classical register is greater than an integer::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less(ClassicalRegister(3, "c"), 5)
Binary(Binary.Op.GREATER, \
Var(ClassicalRegister(3, "c"), Uint(3)), \
Value(5, Uint(3)), \
Uint(3))
"""
return _binary_relation(Binary.Op.GREATER, left, right)
def greater_equal(left: typing.Any, right: typing.Any, /) -> Expr:
"""Create a 'greater than or equal to' expression node from the given value, resolving any
implicit casts and lifting the values into :class:`Value` nodes if required.
Examples:
Query if a classical register is greater than or equal to another::
>>> from qiskit.circuit import ClassicalRegister
>>> from qiskit.circuit.classical import expr
>>> expr.less(ClassicalRegister(3, "a"), ClassicalRegister(3, "b"))
Binary(Binary.Op.GREATER_EQUAL, \
Var(ClassicalRegister(3, "a"), Uint(3)), \
Var(ClassicalRegister(3, "b"), Uint(3)), \
Uint(3))
"""
return _binary_relation(Binary.Op.GREATER_EQUAL, left, right)
|
https://github.com/MiChaelinzo/Quantum-time-travel
|
MiChaelinzo
|
# Quantum Time Travel Algorithm (Hypothetical)
import qiskit
def quantum_time_travel(qubit, target_time):
"""
A fictional function to simulate sending a qubit to a target time using Qiskit.
Note: This is a simplified representation and does not reflect actual time travel capabilities.
"""
# Initialize the quantum circuit
qc = qiskit.QuantumCircuit(1, 1)
# Apply quantum gates to simulate 'time travel'
qc.h(0) # Put the qubit in a superposition state
qc.s(0) # Apply a phase gate
# Theoretical loop to the past (Closed Timelike Curve)
for _ in range(target_time):
qc.unitary(time_loop_operator(), [0], label='Time Loop')
# Measurement to collapse the qubit's state
qc.measure(0, 0)
# Execute the quantum circuit
result = qiskit.execute(qc, qiskit.Aer.get_backend('qasm_simulator')).result()
return result.get_counts(qc)
def time_loop_operator():
"""
A hypothetical unitary operator representing the time loop.
In reality, the specifics of such an operator are unknown.
"""
# Placeholder for the time loop operator
return qiskit.quantum_info.random_unitary(2)
# Example usage:
# Send a qubit 'back in time' by 5 units (hypothetical)
quantum_time_travel_result = quantum_time_travel(qubit=1, target_time=5)
print(quantum_time_travel_result)
|
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/Alice-Bob-SW/qiskit-alice-bob-provider
|
Alice-Bob-SW
|
##############################################################################
# Copyright 2023 Alice & Bob
#
# 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.
##############################################################################
# pylint: disable=unused-argument
from pathlib import Path
from textwrap import dedent
import pytest
from qiskit import QiskitError, QuantumCircuit, execute, transpile
from qiskit.providers import Options
from qiskit.pulse.schedule import Schedule
from qiskit.result import Result
from qiskit.transpiler.exceptions import TranspilerError
from requests_mock.mocker import Mocker
from qiskit_alice_bob_provider.remote.api.client import AliceBobApiException
from qiskit_alice_bob_provider.remote.backend import (
AliceBobRemoteBackend,
_ab_input_params_from_options,
_qiskit_to_qir,
)
from qiskit_alice_bob_provider.remote.provider import AliceBobRemoteProvider
def test_get_backend(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
assert isinstance(backend, AliceBobRemoteBackend)
assert backend.options['average_nb_photons'] == 4.0 # Default value.
def test_get_backend_with_options(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend(
'EMU:1Q:LESCANNE_2020', average_nb_photons=6.0
)
assert isinstance(backend, AliceBobRemoteBackend)
assert backend.options['average_nb_photons'] == 6.0
def test_get_backend_options_validation(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', average_nb_photons=40)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', average_nb_photons=-1)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', shots=0)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', shots=1e10)
with pytest.raises(ValueError):
provider.get_backend('EMU:1Q:LESCANNE_2020', bad_option=1)
def test_execute_options_validation(mocked_targets) -> None:
# We are permissive in our options sytem, allowing the user to both
# define options when creating the backend and executing.
# We therefore need to test both behaviors.
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(ValueError):
execute(c, backend, average_nb_photons=40)
with pytest.raises(ValueError):
execute(c, backend, average_nb_photons=-1)
with pytest.raises(ValueError):
execute(c, backend, bad_option=1)
with pytest.raises(ValueError):
execute(c, backend, shots=0)
with pytest.raises(ValueError):
execute(c, backend, shots=1e10)
def test_too_many_qubits_clients_side(mocked_targets) -> None:
c = QuantumCircuit(3, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(TranspilerError):
execute(c, backend)
def test_input_not_quantum_circuit(mocked_targets) -> None:
c1 = QuantumCircuit(1, 1)
c2 = QuantumCircuit(1, 1)
s1 = Schedule()
s2 = Schedule()
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(NotImplementedError):
execute([c1, c2], backend)
with pytest.raises(NotImplementedError):
execute(s1, backend)
with pytest.raises(NotImplementedError):
execute([s1, s2], backend)
def test_counts_ordering(successful_job: Mocker) -> None:
c = QuantumCircuit(1, 2)
c.initialize('+', 0)
c.measure_x(0, 0)
c.measure(0, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
counts = job.result(wait=0).get_counts()
expected = {'11': 12, '10': 474, '01': 6, '00': 508}
assert counts == expected
counts = job.result(wait=0).get_counts() # testing memoization
assert counts == expected
def test_failed_transpilation(failed_transpilation_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is None
res = job.result(wait=0) # testing memoization
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is None
with pytest.raises(QiskitError):
res.get_counts()
def test_failed_execution(failed_execution_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is not None
with pytest.raises(QiskitError):
res.get_counts()
def test_cancel_job(cancellable_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
job = execute(c, backend)
job.cancel()
res: Result = job.result(wait=0)
assert res.results[0].data.input_qir is not None
assert res.results[0].data.transpiled_qir is not None
with pytest.raises(QiskitError):
res.get_counts()
def test_failed_server_side_validation(failed_validation_job: Mocker) -> None:
c = QuantumCircuit(1, 1)
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('EMU:1Q:LESCANNE_2020')
with pytest.raises(AliceBobApiException):
execute(c, backend)
def test_delay_instruction_recognized() -> None:
c = QuantumCircuit(1, 2)
c.initialize('+', 0)
c.measure_x(0, 0)
c.delay(3000, 0, unit='ns')
c.measure(0, 1)
qir = _qiskit_to_qir(c)
delay_call = (
'call void @__quantum__qis__delay__body'
'(double 3.000000e+00, %Qubit* null)'
)
assert delay_call in qir
def test_ab_input_params_from_options() -> None:
options = Options(shots=43, average_nb_photons=3.2, foo_hey='bar')
params = _ab_input_params_from_options(options)
assert params == {'nbShots': 43, 'averageNbPhotons': 3.2, 'fooHey': 'bar'}
def test_translation_plugin_and_qir(mocked_targets) -> None:
provider = AliceBobRemoteProvider(api_key='foo')
backend = provider.get_backend('ALL_INSTRUCTIONS')
c = QuantumCircuit(4, 4)
c.initialize('-01+')
c.measure([0, 1], [2, 3])
c.x(2).c_if(2, 1)
c.measure_x(2, 0)
c.measure_x(3, 1)
transpiled = transpile(c, backend)
qir = _qiskit_to_qir(transpiled)
assert (
dedent(
Path(
'tests/resources/test_translation_plugin_and_qir.ll'
).read_text(encoding='utf-8')
)
in qir
)
def test_determine_translation_plugin(mocked_targets) -> None:
p = AliceBobRemoteProvider(api_key='foo')
# Rotations available
assert (
p.get_backend('ALL_INSTRUCTIONS').get_translation_stage_plugin()
== 'state_preparation'
)
# H and T missing
assert (
p.get_backend('EMU:1Q:LESCANNE_2020').get_translation_stage_plugin()
== 'state_preparation'
)
# T missing
assert (
p.get_backend('H').get_translation_stage_plugin()
== 'state_preparation'
)
# ok
assert (
p.get_backend('H_T').get_translation_stage_plugin() == 'sk_synthesis'
)
|
https://github.com/ichen17/Learning-Qiskit
|
ichen17
|
from qiskit import *
import numpy as np
from qiskit.visualization import plot_histogram
qb_Alice = QuantumRegister(1, name='qr') # Alice's qubit
qb_Bob = QuantumRegister(1, name='qr1') # Bob's qubit
Superdense_Code = QuantumCircuit(qb_Alice, qb_Bob)
def buid_Bell_pair(qc,q1,q2): #To build up the a bell pair state
qc.h(q1) #Applying the Hadamard gate on qubit for alice
qc.cx(q1,q2) #Applying the Cnot gate with the control qubit Alice's and target qubit bob's
def operation_from_Alice(qc,q1,classical_info):
if classical_info =='00': #The classical information Alice want to send
return
elif classical_info =='01':#The classical information Alice want to send
qc.z(q1)
elif classical_info =='10':#The classical information Alice want to send
qc.x(q1)
else: #'11': #The classical information Alice want to send
qc.x(q1)
qc.z(q1)
def Bell_decoding(qc,q1,q2): # In this step, Bob get the qubit operated by Alice and another qubit of Bell pair state.
qc.cx(q1,q2) # Bob applies the CNOT gate with the control qubit Alice's and target qubit bob's
qc.h(q1) # Applying the Hadamard gate on qubit for Alice's qubit
classical_info='01' # The classical information Alice wants to send
buid_Bell_pair(Superdense_Code, 0, 1)
Superdense_Code.barrier()
operation_from_Alice(Superdense_Code,0,classical_info)
Superdense_Code.barrier()
Bell_decoding(Superdense_Code,0,1)
Superdense_Code.measure_all() #measure all of qubits
Superdense_Code.draw(output = "mpl")
backend = Aer.get_backend('qasm_simulator')
job_sim = execute(Superdense_Code, backend, shots=10)
sim_result = job_sim.result()
measurement_result = sim_result.get_counts(Superdense_Code)
print(measurement_result)
plot_histogram(measurement_result)
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# 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.
"""
Ripple adder example based on Cuccaro et al., quant-ph/0410184.
"""
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import BasicAer
from qiskit import execute
###############################################################
# Set the backend name and coupling map.
###############################################################
backend = BasicAer.get_backend("qasm_simulator")
coupling_map = [
[0, 1],
[0, 8],
[1, 2],
[1, 9],
[2, 3],
[2, 10],
[3, 4],
[3, 11],
[4, 5],
[4, 12],
[5, 6],
[5, 13],
[6, 7],
[6, 14],
[7, 15],
[8, 9],
[9, 10],
[10, 11],
[11, 12],
[12, 13],
[13, 14],
[14, 15],
]
###############################################################
# Make a quantum program for the n-bit ripple adder.
###############################################################
n = 2
a = QuantumRegister(n, "a")
b = QuantumRegister(n, "b")
cin = QuantumRegister(1, "cin")
cout = QuantumRegister(1, "cout")
ans = ClassicalRegister(n + 1, "ans")
qc = QuantumCircuit(a, b, cin, cout, ans, name="rippleadd")
def majority(p, a, b, c):
"""Majority gate."""
p.cx(c, b)
p.cx(c, a)
p.ccx(a, b, c)
def unmajority(p, a, b, c):
"""Unmajority gate."""
p.ccx(a, b, c)
p.cx(c, a)
p.cx(a, b)
# Build a temporary subcircuit that adds a to b,
# storing the result in b
adder_subcircuit = QuantumCircuit(cin, a, b, cout)
majority(adder_subcircuit, cin[0], b[0], a[0])
for j in range(n - 1):
majority(adder_subcircuit, a[j], b[j + 1], a[j + 1])
adder_subcircuit.cx(a[n - 1], cout[0])
for j in reversed(range(n - 1)):
unmajority(adder_subcircuit, a[j], b[j + 1], a[j + 1])
unmajority(adder_subcircuit, cin[0], b[0], a[0])
# Set the inputs to the adder
qc.x(a[0]) # Set input a = 0...0001
qc.x(b) # Set input b = 1...1111
# Apply the adder
qc &= adder_subcircuit
# Measure the output register in the computational basis
for j in range(n):
qc.measure(b[j], ans[j])
qc.measure(cout[0], ans[n])
###############################################################
# execute the program.
###############################################################
# First version: not mapped
job = execute(qc, backend=backend, coupling_map=None, shots=1024)
result = job.result()
print(result.get_counts(qc))
# Second version: mapped to 2x8 array coupling graph
job = execute(qc, backend=backend, coupling_map=coupling_map, shots=1024)
result = job.result()
print(result.get_counts(qc))
# Both versions should give the same distribution
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations 🎉! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops 😕! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess 🎉! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops 😕! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/Qottmann/Quantum-anomaly-detection
|
Qottmann
|
from qiskit import IBMQ
# token is obtained from IBMQ expierence website, just set up an account at https://quantum-computing.ibm.com/ and once run
# IBMQ.enable_account(token)
# IBMQ.save_account(token)
IBMQ.load_account() # this then automatically loads your saved account
IBMQ.providers() # list of providers, in our case just the standard open one since we dont have any special access (yet!)
provider = IBMQ.get_provider(hub='ibm-q-research')
provider.backends(simulator=False, operational=True)
provider.backends(filters=lambda x: x.configuration().n_qubits >= 10
and not x.configuration().simulator
and x.status().operational==True)
from qiskit.providers.ibmq import least_busy
small_devices = provider.backends(filters=lambda x: x.configuration().n_qubits == 5
and not x.configuration().simulator)
least_busy(small_devices)
backend = least_busy(small_devices)
#backend = provider.backends(simulator=False, operational=True)[7]
backend
status = backend.status()
print("pending jobs: ", status.pending_jobs)
print("maximum jobs to submit: ", backend.job_limit().maximum_jobs)
print("operational: ", status.operational)
ran_job = None
for ran_job in backend.jobs(limit=5):
print(str(ran_job.job_id()) + " " + str(ran_job.status()))
import qiskit
qr = qiskit.QuantumRegister(3)
cr = qiskit.ClassicalRegister(3)
circuit = qiskit.QuantumCircuit(qr, cr)
circuit.x(qr[0])
circuit.x(qr[1])
circuit.ccx(qr[0], qr[1], qr[2])
circuit.cx(qr[0], qr[1])
circuit.measure(qr, cr)
mapped_circuit = qiskit.compiler.transpile(circuit, backend=backend)
#qobj = qiskit.compiler.assemble(mapped_circuit, backend=backend, shots=1024) # apparently deprecated and or unnecessary
job = backend.run(mapped_circuit)
print(status.pending_jobs)
job.status()
job.job_id()
retrieved_job = backend.retrieve_job(job.job_id())
# once job is done this should yield result
#result = retrieved_job.result()
#counts = result.get_counts()
#print(counts)
from qiskit.providers.ibmq.managed import IBMQJobManager
sim_backend = provider.get_backend('ibmq_qasm_simulator')
circs = qiskit.compiler.transpile([circuit]*20, backend=sim_backend)
# Submit them all to the backend
job_manager = IBMQJobManager()
job_set = job_manager.run(circs, backend=sim_backend, name='foo')
print(job_set.report())
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
import os
import sys
cwd = os.getcwd()
qiskit_dir = os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(cwd))))
sys.path.append(qiskit_dir)
from qiskit import BasicAer, execute
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.compiler import transpile
from qiskit.tools.parallel import parallel_map
from qiskit.tools.monitor import job_monitor
from qiskit.tools.events import TextProgressBar
from qiskit.tools.jupyter import *
sim_backend = BasicAer.get_backend("qasm_simulator")
import time
def func(_):
time.sleep(0.1)
return 0
HTMLProgressBar()
parallel_map(func, list(range(10)));
%qiskit_progress_bar
parallel_map(func, list(range(10)));
TextProgressBar()
parallel_map(func, list(range(10)));
%qiskit_progress_bar -t text
parallel_map(func, list(range(10)));
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)
qc.h(q[0])
qc.cx(q[0], q[1])
qc.measure(q, c)
HTMLProgressBar()
qobj = transpile([qc] * 20, backend=sim_backend)
job_sim2 = execute([qc] * 10, backend=sim_backend)
job_monitor(job_sim2)
|
https://github.com/avkhadiev/schwinger-vqe
|
avkhadiev
|
from qiskit import *
import qiskit.tools.jupyter
import numpy as np
IBMQ.load_account()
optimizer = qiskit.aqua.components.optimizers.SPSA()
print(optimizer.setting)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
d0 = pulse.DriveChannel(0)
x90 = pulse.Gaussian(10, 0.1, 3)
x180 = pulse.Gaussian(10, 0.2, 3)
with pulse.build() as hahn_echo:
with pulse.align_equispaced(duration=100):
pulse.play(x90, d0)
pulse.play(x180, d0)
pulse.play(x90, d0)
hahn_echo.draw()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.visualization.timeline import draw as timeline_draw
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")
timeline_draw(circ)
|
https://github.com/ctuning/ck-qiskit
|
ctuning
|
#!/usr/bin/env python3
"""
This script runs Variational-Quantum-Eigensolver using Qiskit library
Example running it partially using CK infrastructure:
ck virtual env --tag_groups='compiler,python qiskit,lib vqe,utils vqe,hamiltonian deployed,ansatz deployed,optimizer' \
--shell_cmd="$HOME/CK/ck-qiskit/program/qiskit-vqe/qiskit_vqe_common.py --start_param_value=0.5"
"""
import os
import json
import time
import inspect
import numpy as np
from scipy import linalg as la
from qiskit import QuantumProgram, register, QISKitError
from qiskit.tools.apps.optimization import make_Hamiltonian, group_paulis
from qiskit.tools.qi.pauli import Pauli, label_to_pauli
from eval_hamiltonian import eval_hamiltonian
from vqe_utils import cmdline_parse_and_report, get_first_callable, NumpyEncoder
from vqe_hamiltonian import label_to_hamiltonian_coeff # the file contents will be different depending on the plugin choice
import custom_ansatz # the file contents will be different depending on the plugin choice
fun_evaluation_counter = 0 # global
def vqe_for_qiskit(sample_number, pauli_list, timeout_seconds, json_stream_file):
def expectation_estimation(current_params, report):
timestamp_before_ee = time.time()
timestamp_before_q_run = timestamp_before_ee # no point in taking consecutive timestamps
ansatz_circuit = ansatz_function(current_params)
global fun_evaluation_counter
# Trying to recover from a timed-out run assuming it to be a temporary glitch:
#
for attempt in range(1,8):
try:
complex_energy, q_run_seconds = eval_hamiltonian(Q_program, pauli_list_grouped, ansatz_circuit, sample_number, q_device_name, timeout=timeout_seconds)
energy = complex_energy.real
break
except QISKitError as e:
print("{}, trying again -- attempt number {}, timeout: {} seconds".format(e, attempt, timeout_seconds))
if len(q_run_seconds)>0: # got the real measured q time
total_q_run_seconds = sum( q_run_seconds )
else: # have to assume
total_q_run_seconds = time.time() - timestamp_before_q_run
q_run_seconds = [ total_q_run_seconds ]
q_runs = len(q_run_seconds)
total_q_run_shots = sample_number * q_runs
q_run_shots = [sample_number] * q_runs
report_this_iteration = {
'total_q_seconds_per_c_iteration' : total_q_run_seconds,
'seconds_per_individual_q_run' : q_run_seconds,
'total_q_shots_per_c_iteration' : total_q_run_shots,
'shots_per_individual_q_run' : q_run_shots,
'energy' : energy,
}
if report != 'TestMode':
report['iterations'].append( report_this_iteration )
report['total_q_seconds'] += report_this_iteration['total_q_seconds_per_c_iteration'] # total_q_time += total
report['total_q_shots'] += report_this_iteration['total_q_shots_per_c_iteration']
fun_evaluation_counter += 1
report_this_iteration['total_seconds_per_c_iteration'] = time.time() - timestamp_before_ee
print(report_this_iteration, "\n")
json_stream_file.write( json.dumps(report_this_iteration, cls=NumpyEncoder)+"\n" )
json_stream_file.flush()
return energy
# Initialise quantum program
Q_program = QuantumProgram()
# Groups a list of (coeff,Pauli) tuples into tensor product basis (tpb) sets
pauli_list_grouped = group_paulis(pauli_list)
report = { 'total_q_seconds': 0, 'total_q_shots':0, 'iterations' : [] }
# Initial objective function value
fun_initial = expectation_estimation(start_params, 'TestMode')
print('Initial guess at start_params is: {:.4f}'.format(fun_initial))
timestamp_before_optimizer = time.time()
optimizer_output = minimizer_function(expectation_estimation, start_params, my_args=(report), my_options = minimizer_options)
report['total_seconds'] = time.time() - timestamp_before_optimizer
# Also generate and provide a validated function value at the optimal point
fun_validated = expectation_estimation(optimizer_output['x'], 'TestMode')
print('Validated value at solution is: {:.4f}'.format(fun_validated))
# Exact (noiseless) calculation of the energy at the given point:
complex_energy, _ = eval_hamiltonian(Q_program, pauli_list, ansatz_function(optimizer_output['x']), 1, 'local_statevector_simulator')
optimizer_output['fun_exact'] = complex_energy.real
optimizer_output['fun_validated'] = fun_validated
print('Total Q seconds = %f' % report['total_q_seconds'])
print('Total Q shots = %d' % report['total_q_shots'])
print('Total seconds = %f' % report['total_seconds'])
return (optimizer_output, report)
if __name__ == '__main__':
start_params, sample_number, q_device_name, minimizer_method, minimizer_options, minimizer_function = cmdline_parse_and_report(
num_params = custom_ansatz.num_params,
q_device_name_default = 'local_qasm_simulator',
q_device_name_help = "Real devices: 'ibmqx4' or 'ibmqx5'. Use 'ibmq_qasm_simulator' for remote simulator or 'local_qasm_simulator' for local",
minimizer_options_default = '{"maxfev":200, "xatol": 0.001, "fatol": 0.001}',
start_param_value_default = 0.0
)
# q_device_name = os.environ.get('VQE_QUANTUM_BACKEND', 'local_qasm_simulator') # try 'local_qasm_simulator', 'ibmq_qasm_simulator', 'ibmqx4', 'ibmqx5'
try:
import Qconfig
register(Qconfig.APItoken, Qconfig.config["url"], verify=False,
hub=Qconfig.config["hub"],
group=Qconfig.config["group"],
project=Qconfig.config["project"])
except:
print("""
WARNING: There's no connection with IBMQuantumExperience servers.
cannot test I/O intesive tasks, will only test CPU intensive tasks
running the jobs in the local simulator
""")
# Ignore warnings due to chopping of small imaginary part of the energy
#import warnings
#warnings.filterwarnings('ignore')
# Load the Hamiltonian into Qiskit-friendly format:
pauli_list = [ [label_to_hamiltonian_coeff[label], label_to_pauli(label)] for label in label_to_hamiltonian_coeff ]
# Calculate Exact Energy classically, to compare with quantum solution:
#
H = make_Hamiltonian(pauli_list)
classical_energy = np.amin(la.eigh(H)[0])
print('The exact ground state energy (the smallest eigenvalue of the Hamiltonian) is: {:.4f}'.format(classical_energy))
# Load the ansatz function from the plug-in
ansatz_method = get_first_callable( custom_ansatz )
ansatz_function = getattr(custom_ansatz, ansatz_method) # ansatz_method is a string/name, ansatz_function is an imported callable
timeout_seconds = int( os.environ.get('VQE_QUANTUM_TIMEOUT', '120') )
json_stream_file = open('vqe_stream.json', 'a')
# ---------------------------------------- run VQE: --------------------------------------------------
(vqe_output, report) = vqe_for_qiskit(sample_number, pauli_list, timeout_seconds, json_stream_file)
# ---------------------------------------- store the results: ----------------------------------------
json_stream_file.write( '# Experiment finished\n' )
json_stream_file.close()
minimizer_src = inspect.getsource( minimizer_function )
ansatz_src = inspect.getsource( ansatz_function )
vqe_input = {
"q_device_name" : q_device_name,
"minimizer_method" : minimizer_method,
"minimizer_src" : minimizer_src,
"minimizer_options" : minimizer_options,
"ansatz_method" : ansatz_method,
"ansatz_src" : ansatz_src,
"sample_number" : sample_number,
"classical_energy" : classical_energy
}
output_dict = { "vqe_input" : vqe_input, "vqe_output" : vqe_output, "report" : report }
formatted_json = json.dumps(output_dict, cls=NumpyEncoder, sort_keys = True, indent = 4)
# print(formatted_json)
with open('ibm_vqe_report.json', 'w') as json_file:
json_file.write( formatted_json )
|
https://github.com/zhangx1923/QISKit_Deve_Challenge
|
zhangx1923
|
from qiskit import QuantumCircuit
from TestProperty import TestProperty
import cmath
import numpy as np
from math import cos, sin, radians, degrees
import random
class Generator:
"""
This method generates one concrete test case and provides the exact parameters
used to initialise the qubits
Inputs: a TestProperty
Output: a tuple containing the initialised test (a QantumCircuit),
and two dictionaries, that store the theta (first one) and phi (second one)
of each qubit in degrees
"""
def generateTest(self, testProperties: TestProperty):
preConditions = testProperties.preConditions
phiVal = {}
thetaVal = {}
#Adds 2 classical bits to read the results of any assertion
#Those bits will not interfere with the normal functioning of the program
if testProperties.minQubits == testProperties.maxQubits:
noOfQubits = testProperties.minQubits
else:
noOfQubits = np.random.randint(testProperties.minQubits, testProperties.maxQubits)
qc = QuantumCircuit(noOfQubits, testProperties.noOfClassicalBits + 2)
for key, value in preConditions.items():
#ignores the keys that are outside of the range
if key >= noOfQubits:
continue
#converts from degrees to radian
randPhi = random.randint(value.minPhi, value.maxPhi)
randTheta = random.randint(value.minTheta, value.maxTheta)
#stores the random values generated
phiVal[key] = randPhi
thetaVal[key] = randTheta
randPhiRad = radians(randPhi)
randThetaRad = radians(randTheta)
"""WHY THIS HAPPEN"""
value0 = cos(randThetaRad/2)
value1 = cmath.exp(randPhiRad * 1j) * sin(randThetaRad / 2)
qc.initialize([value0, value1], key)
return (qc, thetaVal, phiVal)
"""
This method runs self.generateTest to generate the specified amount of tests in
the TestProperty
Inputs: a TestProperty
Outputs: a list of what self.generateTests returns (a tuple containing a QuantumCircuit,
a dictionary for the thetas used and a dictionary for the phi used in degrees)
"""
def generateTests(self, testProperties: TestProperty):
return [self.generateTest(testProperties) for _ in range(testProperties.noOfTests)]
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_circuit_layout
from qiskit.providers.fake_provider import FakeVigo
backend = FakeVigo()
ghz = QuantumCircuit(3, 3)
ghz.h(0)
ghz.cx(0,range(1,3))
ghz.barrier()
ghz.measure(range(3), range(3))
new_circ_lv3 = transpile(ghz, backend=backend, optimization_level=3)
plot_circuit_layout(new_circ_lv3, backend)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.