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, IQXDebugging
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc = transpile(qc, FakeBoeblingen(), scheduling_method='alap', layout_method='trivial')
draw(qc, style=IQXDebugging())
|
https://github.com/quantumgenetics/quantumgenetics
|
quantumgenetics
|
from multiprocessing import Pool
from qiskit import Aer
import numpy as np
from collections import deque
from copy import deepcopy
import math
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
import random
from functools import reduce
class Genetic_Executor:
'''
It is just a class to keep things together.
'''
def __init__(\
self,
number_of_processors,
population_initializer,
population_size,
parallel_population_initialization_flag=True):
'''
number_of_processors -> positive integer
the number of processes that will be spawned
population_initializer -> function
a function that returns an iterable representing the population
'''
self.processs_pool = Pool(number_of_processors)
self.population = population_initializer(population_size, self.processs_pool)
self.population_size = population_size
def apply_operation(self, operation_on_population):
'''
operation_on_population -> function
It receives the process pool and the population. It is called here
'''
return operation_on_population(self.processs_pool, self.population)
def get_number_gate_seq_relation(depth, available_gates):
'''
Based on how many gates can there be, after a qubit,
all the possible combinations of the gates are generated in a list and
returned.
'''
av_gates_tuple = tuple()
for key in available_gates.keys():
av_gates_tuple += available_gates[key]
av_gates_tuple += ('i',)
mapping_list = []
current_seq_gates_list = []
dq = deque([(gate,0) for gate in av_gates_tuple])
while dq:
gate, d = dq.pop()
current_seq_gates_list = current_seq_gates_list[:d]
current_seq_gates_list.append(gate)
if d == depth - 1:
mapping_list.append(deepcopy(current_seq_gates_list))
elif d < depth - 1:
for g in av_gates_tuple:
dq.append((g,d+1,))
return mapping_list
def get_binary(decimal):
'''
Gets a decimal as input. Outputs a list of the decimals binary representation.
e.g. If the nuber of binaries in the list is 3 and decimal is 3, then the
function outputs [0,1,1].
'''
key = [0 for _ in range(number_of_qubits_in_possible_circuit)]
s_i = format(decimal, "b")
k = number_of_qubits_in_possible_circuit - 1
j = len(s_i)-1
while j >= 0:
if s_i[j] == '1': key[k] = 1
k-=1
j-=1
return key
def get_binary_from_str(s):
key = []
for ch in s:
if ch == '0':
key.append(0)
else:
key.append(1)
return key
def get_decimal(binary):
'''
Gets a binary list and returns the decimal representaion.
'''
i = len(binary)-1
a = 0
for b in binary:
a += b**i
i -= 1
return a
def get_random_goal_function(number_of_qubits_in_possible_circuit):
'''
Generates a random binary function of "number_of_qubits_in_possible_circuit"
bits.
'''
goal_function_dict = dict()
for i in range(2**number_of_qubits_in_possible_circuit):
goal_function_dict[tuple(get_binary(i))] = np.random.choice(2,
number_of_qubits_in_possible_circuit)
return goal_function_dict
def chromosome_initialzer(a):
'''
Randomly initializez and returns a chromosome (a tuple of 3 elements:
theta, and amplitudes based on theta). Argument "a" is not used anywhere.
'''
theta_arr = 2 * math.pi * np.random.random(number_of_qubits_in_individual)
return (theta_arr,\
np.cos(theta_arr),\
np.sin(theta_arr))
def initializer1(pop_size, p_pool):
return p_pool.map(chromosome_initialzer, [None for _ in range(pop_size)])
def get_pop_fitness(p_pool, population_iterable):
'''
Collapses the individuals and then evalueates the circuit.
'''
fitness_list = []
for theta_arr, _, _ in population_iterable:
qr = QuantumRegister(number_of_qubits_in_individual)
cr = ClassicalRegister(number_of_qubits_in_individual)
qc = QuantumCircuit(qr, cr,)
for i in range(number_of_qubits_in_individual):
qc.u3(theta_arr[i], 0, 0, qr[i])
qc.measure(qr,cr)
job = execute(qc, backend=backend, shots=1,)
results = job.result()
answer = results.get_counts()
binary_list = get_binary_from_str(tuple(answer.keys())[0])
if binary_mutation_flag:
for i in range(len(binary_list)):
if random.random() < binary_mutation_prob:
if binary_list[i] == 0:
binary_list[i] = 1
else:
binary_list[i] = 0
binary_bu_list = deepcopy(binary_list)
qubits_per_line = len(binary_list)//number_of_qubits_in_possible_circuit
v = 0
for key in goal_function.keys():
qr = QuantumRegister(number_of_qubits_in_possible_circuit)
cr = ClassicalRegister(number_of_qubits_in_possible_circuit)
qc = QuantumCircuit(qr, cr,)
for i in range(number_of_qubits_in_possible_circuit):
if key[i] == 1: qc.x(qr[i])
a = 0
for i in range(number_of_qubits_in_possible_circuit):
config = config_list[get_decimal(binary_bu_list[a:a+qubits_per_line])]
for gate in config:
if gate == 'i':
qc.iden(qr[i])
elif gate == 's':
qc.u3(0,0,math.pi/4,qr[i])
elif gate == 'h':
qc.h(qr[i])
else:
qc.cx(qr[i],qr[(i+1)%number_of_qubits_in_possible_circuit])
a += qubits_per_line
qc.measure(qr,cr)
job = execute(qc, backend=backend, shots=global_shots,\
backend_options={\
"max_parallel_threads":0,
'max_parallel_shots':0})
results = job.result()
answer = results.get_counts()
goal_value = reduce(
lambda acc, x: acc + str(x),
goal_function[key],
''
)
if goal_value not in answer:
v += global_shots
else:
v += global_shots - answer[goal_value]
fitness_list.append((v,binary_bu_list))
return fitness_list
def main0():
global number_of_qubits_in_individual,backend,number_of_qubits_in_possible_circuit,config_list
number_of_qubits_in_individual = 18
number_of_qubits_in_possible_circuit = 3
available_gates = {
1 : ('s', 'h'),
2 : ('cnot',),
}
kill_percentage = 0.5
population_size = 15
depth = 3
global binary_mutation_flag, binary_mutation_prob
binary_mutation_flag = True
binary_mutation_prob = 0.1
surviving_population_size = int(population_size * (1 - kill_percentage))
killed_population_size = population_size - surviving_population_size
global global_shots,goal_function
global_shots = 2048
backend = Aer.get_backend('qasm_simulator',)
config_list = get_number_gate_seq_relation(depth, available_gates)
goal_function = get_random_goal_function(number_of_qubits_in_possible_circuit)
ge = Genetic_Executor(7, initializer1, population_size,)
for it_no in range(10):
fitness_values = list( enumerate( map( lambda e: e[0], ge.apply_operation(get_pop_fitness) ) ) )
fitness_values.sort(key=lambda p: p[1])
print(f'{it_no}: {fitness_values[0][1]}')
new_pop = []
for i in range(surviving_population_size):
new_pop.append(ge.population[fitness_values[i][0]])
ge.population = new_pop
for _ in range(killed_population_size):
theta_arr = np.empty(number_of_qubits_in_individual)
alpha_arr = np.empty(number_of_qubits_in_individual)
beta_arr = np.empty(number_of_qubits_in_individual)
first_index = random.choice(range(surviving_population_size))
second_index = random.choice(tuple(filter(lambda e: e!=first_index, range(surviving_population_size))))
for i in range(number_of_qubits_in_individual):
if random.choice((True,False,)):
theta_arr[i] = ge.population[first_index][0][i]
alpha_arr[i] = ge.population[first_index][1][i]
beta_arr[i] = ge.population[first_index][2][i]
else:
theta_arr[i] = ge.population[second_index][0][i]
alpha_arr[i] = ge.population[second_index][1][i]
beta_arr[i] = ge.population[second_index][2][i]
ge.population.append((theta_arr,alpha_arr,beta_arr))
if __name__ == '__main__':
main0()
|
https://github.com/QuCO-CSAM/Solving-Combinatorial-Optimisation-Problems-Using-Quantum-Algorithms
|
QuCO-CSAM
|
#In case you don't have qiskit, install it now
%pip install qiskit --quiet
#Installing/upgrading pylatexenc seems to have fixed my mpl issue
#If you try this and it doesn't work, try also restarting the runtime/kernel
%pip install pylatexenc --quiet
!pip install -Uqq ipdb
!pip install qiskit_optimization
import networkx as nx
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity
from qiskit.extensions.hamiltonian_gate import HamiltonianGate
from qiskit.extensions import RXGate, XGate, CXGate
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
import numpy as np
from qiskit.visualization import plot_histogram
import ipdb
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#quadratic optimization
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
%pdb on
# def ApplyCost(qc, gamma):
# Ix = np.array([[1,0],[0,1]])
# Zx= np.array([[1,0],[0,-1]])
# Xx = np.array([[0,1],[1,0]])
# Temp = (Ix-Zx)/2
# T = Operator(Temp)
# I = Operator(Ix)
# Z = Operator(Zx)
# X = Operator(Xx)
# FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
# ham = HamiltonianGate(FinalOp,gamma)
# qc.append(ham,[0,1,2])
task = QuadraticProgram(name = 'QUBO on QC')
task.binary_var(name = 'x')
task.binary_var(name = 'y')
task.binary_var(name = 'z')
task.minimize(linear = {"x":-1,"y":2,"z":-3}, quadratic = {("x", "z"): -2, ("y", "z"): -1})
qubo = QuadraticProgramToQubo().convert(task) #convert to QUBO
operator, offset = qubo.to_ising()
print(operator)
# ham = HamiltonianGate(operator,0)
# print(ham)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(T^I^T)-(I^T^T)-(T^I^I)+2*(I^T^I)-3*(I^I^T)
ham = HamiltonianGate(FinalOp,0)
print(ham)
#define PYBIND11_DETAILED_ERROR_MESSAGES
def compute_expectation(counts):
"""
Computes expectation value based on measurement results
Args:
counts: dict
key as bitstring, val as count
G: networkx graph
Returns:
avg: float
expectation value
"""
avg = 0
sum_count = 0
for bitstring, count in counts.items():
x = int(bitstring[2])
y = int(bitstring[1])
z = int(bitstring[0])
obj = -2*x*z-y*z-x+2*y-3*z
avg += obj * count
sum_count += count
return avg/sum_count
# We will also bring the different circuit components that
# build the qaoa circuit under a single function
def create_qaoa_circ(theta):
"""
Creates a parametrized qaoa circuit
Args:
G: networkx graph
theta: list
unitary parameters
Returns:
qc: qiskit circuit
"""
nqubits = 3
n,m=3,3
p = len(theta)//2 # number of alternating unitaries
qc = QuantumCircuit(nqubits,nqubits)
Ix = np.array([[1,0],[0,1]])
Zx= np.array([[1,0],[0,-1]])
Xx = np.array([[0,1],[1,0]])
Temp = (Ix-Zx)/2
T = Operator(Temp)
I = Operator(Ix)
Z = Operator(Zx)
X = Operator(Xx)
FinalOp=-2*(Z^I^Z)-(I^Z^Z)-(Z^I^I)+2*(I^Z^I)-3*(I^I^Z)
beta = theta[:p]
gamma = theta[p:]
# initial_state
for i in range(0, nqubits):
qc.h(i)
for irep in range(0, p):
#ipdb.set_trace(context=6)
# problem unitary
# for pair in list(G.edges()):
# qc.rzz(2 * gamma[irep], pair[0], pair[1])
#ApplyCost(qc,2*0)
ham = HamiltonianGate(operator,2 * gamma[irep])
qc.append(ham,[0,1,2])
# mixer unitary
for i in range(0, nqubits):
qc.rx(2 * beta[irep], i)
qc.measure(qc.qubits[:n],qc.clbits[:m])
return qc
# Finally we write a function that executes the circuit on the chosen backend
def get_expectation(shots=512):
"""
Runs parametrized circuit
Args:
G: networkx graph
p: int,
Number of repetitions of unitaries
"""
backend = Aer.get_backend('qasm_simulator')
backend.shots = shots
def execute_circ(theta):
qc = create_qaoa_circ(theta)
# ipdb.set_trace(context=6)
counts = {}
job = execute(qc, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc)
return compute_expectation(counts)
return execute_circ
from scipy.optimize import minimize
expectation = get_expectation()
res = minimize(expectation, [1, 1], method='COBYLA')
expectation = get_expectation()
res = minimize(expectation, res.x, method='COBYLA')
res
from qiskit.visualization import plot_histogram
backend = Aer.get_backend('aer_simulator')
backend.shots = 512
qc_res = create_qaoa_circ(res.x)
backend = Aer.get_backend('qasm_simulator')
job = execute(qc_res, backend, shots=1024)
result = job.result()
counts=result.get_counts(qc_res)
plot_histogram(counts)
|
https://github.com/weiT1993/qiskit_helper_functions
|
weiT1993
|
import sys
import math
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
class QFT:
"""
Class which generates the circuit to perform the Quantum Fourier
Transform (or its inverse) as described in Mike & Ike Chapter 5.
(Michael A Nielsen and Isaac L Chuang. Quantum computation and quantum
information (10th anniv. version), 2010.)
For another example see Figure 1 of Daniel E Browne 2007 New J. Phys. 9 146
A QFT or iQFT circuit can be generated with a given instance of the
QFT class by calling the gen_circuit() method.
Attributes
----------
width : int
number of qubits
inverse : bool
Set to true to generate the inverse quantum fourier transform
kvals : bool
optional parameter that will change the angle of the controlled
rotations so that when the circuit is printed it will display
the same k values that are shown in Mike & Ike Chpt 5, Fig 5.1
(NOTE: the generated circuit will no longer be valid! This is
for visualization purposes only.)
barriers : bool
should barriers be included in the generated circuit
measure : bool
should a classical register & measurement be added to the 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
cr : ClassicalRegister
Qiskit ClassicalRegister holding all of the classical bits
circ : QuantumCircuit
Qiskit QuantumCircuit that represents the uccsd circuit
"""
def __init__(
self,
width,
approximation_degree,
inverse=False,
kvals=False,
barriers=True,
measure=False,
regname=None,
):
# number of qubits
self.nq = width
self.approximation_degree = approximation_degree
# set flags for circuit generation
self.inverse = inverse
self.kvals = kvals
self.barriers = barriers
self.measure = measure
# create a QuantumCircuit object
if regname is None:
self.qr = QuantumRegister(self.nq)
self.cr = ClassicalRegister(self.nq)
else:
self.qr = QuantumRegister(self.nq, name=regname)
self.cr = ClassicalRegister(self.nq, name="c" + regname)
# Have the option to include measurement if desired
if self.measure:
self.circ = QuantumCircuit(self.qr, self.cr)
else:
self.circ = QuantumCircuit(self.qr)
def inv_qft(self):
"""
Implement the inverse QFT on self.circ
j ranges from nq-1 -> 0
k ranges from nq-1 -> j+1
For each j qubit, a controlled cu1 gate is applied with target=j,
control=k (for each k).
cu1 = 1 0
0 e^(-2pi*i / 2^(k-j+1))
"""
for j in range(self.nq - 1, -1, -1):
for k in range(self.nq - 1, j, -1):
if self.kvals:
self.circ.cu1(-1 * (k - j + 1), self.qr[k], self.qr[j])
else:
self.circ.cu1(
-1 * (2 * np.pi) / (2 ** (k - j + 1)), self.qr[k], self.qr[j]
)
self.circ.h(self.qr[j])
if self.barriers:
self.circ.barrier()
def reg_qft(self):
"""
Implement the QFT on self.circ
j ranges from 0 -> nq-1
k ranges from j+1 -> nq-1
For each j qubit, a controlled cu1 gate is applied with target=j,
control=k (for each k).
cu1 = 1 0
0 e^(2pi*i / 2^(k-j+1))
"""
for j in range(self.nq):
self.circ.h(self.qr[j])
for k in range(j + 1, self.nq):
if self.kvals:
self.circ.cu1(k - j + 1, self.qr[k], self.qr[j])
else:
if k - j + 1 <= self.approximation_degree:
self.circ.cu1(
(2 * np.pi) / (2 ** (k - j + 1)), self.qr[k], self.qr[j]
)
if self.barriers:
self.circ.barrier()
def gen_circuit(self):
"""
Create a circuit implementing the UCCSD ansatz
Given the number of qubits and parameters, construct the
ansatz as given in Whitfield et al.
Returns
-------
QuantumCircuit
QuantumCircuit object of size nq with no ClassicalRegister and
no measurements
"""
if self.inverse:
self.inv_qft()
else:
self.reg_qft()
if self.measure:
self.circ.barrier()
self.circ.measure(self.qr, self.cr)
return self.circ
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
import numpy as np
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import Sampler
from qiskit.utils import algorithm_globals
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import OneHotEncoder, MinMaxScaler
from qiskit_machine_learning.algorithms.classifiers import VQC
from IPython.display import clear_output
algorithm_globals.random_seed = 42
sampler1 = Sampler()
sampler2 = Sampler()
num_samples = 40
num_features = 2
features = 2 * algorithm_globals.random.random([num_samples, num_features]) - 1
labels = 1 * (np.sum(features, axis=1) >= 0) # in { 0, 1}
features = MinMaxScaler().fit_transform(features)
features.shape
features[0:5, :]
labels = OneHotEncoder(sparse=False).fit_transform(labels.reshape(-1, 1))
labels.shape
labels[0:5, :]
train_features, test_features, train_labels, test_labels = train_test_split(
features, labels, train_size=30, random_state=algorithm_globals.random_seed
)
train_features.shape
def plot_dataset():
plt.scatter(
train_features[np.where(train_labels[:, 0] == 0), 0],
train_features[np.where(train_labels[:, 0] == 0), 1],
marker="o",
color="b",
label="Label 0 train",
)
plt.scatter(
train_features[np.where(train_labels[:, 0] == 1), 0],
train_features[np.where(train_labels[:, 0] == 1), 1],
marker="o",
color="g",
label="Label 1 train",
)
plt.scatter(
test_features[np.where(test_labels[:, 0] == 0), 0],
test_features[np.where(test_labels[:, 0] == 0), 1],
marker="o",
facecolors="w",
edgecolors="b",
label="Label 0 test",
)
plt.scatter(
test_features[np.where(test_labels[:, 0] == 1), 0],
test_features[np.where(test_labels[:, 0] == 1), 1],
marker="o",
facecolors="w",
edgecolors="g",
label="Label 1 test",
)
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.plot([1, 0], [0, 1], "--", color="black")
plot_dataset()
plt.show()
maxiter = 20
objective_values = []
# callback function that draws a live plot when the .fit() method is called
def callback_graph(_, objective_value):
clear_output(wait=True)
objective_values.append(objective_value)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
stage1_len = np.min((len(objective_values), maxiter))
stage1_x = np.linspace(1, stage1_len, stage1_len)
stage1_y = objective_values[:stage1_len]
stage2_len = np.max((0, len(objective_values) - maxiter))
stage2_x = np.linspace(maxiter, maxiter + stage2_len - 1, stage2_len)
stage2_y = objective_values[maxiter : maxiter + stage2_len]
plt.plot(stage1_x, stage1_y, color="orange")
plt.plot(stage2_x, stage2_y, color="purple")
plt.show()
plt.rcParams["figure.figsize"] = (12, 6)
original_optimizer = COBYLA(maxiter=maxiter)
ansatz = RealAmplitudes(num_features)
initial_point = np.asarray([0.5] * ansatz.num_parameters)
original_classifier = VQC(
ansatz=ansatz, optimizer=original_optimizer, callback=callback_graph, sampler=sampler1
)
original_classifier.fit(train_features, train_labels)
print("Train score", original_classifier.score(train_features, train_labels))
print("Test score ", original_classifier.score(test_features, test_labels))
original_classifier.save("vqc_classifier.model")
loaded_classifier = VQC.load("vqc_classifier.model")
loaded_classifier.warm_start = True
loaded_classifier.neural_network.sampler = sampler2
loaded_classifier.optimizer = COBYLA(maxiter=80)
loaded_classifier.fit(train_features, train_labels)
print("Train score", loaded_classifier.score(train_features, train_labels))
print("Test score", loaded_classifier.score(test_features, test_labels))
train_predicts = loaded_classifier.predict(train_features)
test_predicts = loaded_classifier.predict(test_features)
# return plot to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
plot_dataset()
# plot misclassified data points
plt.scatter(
train_features[np.all(train_labels != train_predicts, axis=1), 0],
train_features[np.all(train_labels != train_predicts, axis=1), 1],
s=200,
facecolors="none",
edgecolors="r",
linewidths=2,
)
plt.scatter(
test_features[np.all(test_labels != test_predicts, axis=1), 0],
test_features[np.all(test_labels != test_predicts, axis=1), 1],
s=200,
facecolors="none",
edgecolors="r",
linewidths=2,
)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/vindem/quantumMD
|
vindem
|
import timeit
from qiskit.circuit.library import EfficientSU2
from qiskit import IBMQ
from qiskit.algorithms.optimizers import GradientDescent, COBYLA
import numpy as np
from qiskit.opflow import MatrixOp
from qiskit.algorithms import VQE
from qiskit.providers.aer import QasmSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit.test.mock import FakeJakarta, FakeManila, FakeLagos, FakeSantiago
from qiskit import Aer
from qiskit.utils import QuantumInstance
from matplotlib import pyplot as plt
import scipy.linalg as lin_alg
from qiskit.utils.mitigation import CompleteMeasFitter
import csv
from sklearn.metrics import mean_squared_error, mean_absolute_error
import math
from main import generate_random_matrices, generate_ansaetze
IBMQ.load_account()
provider = IBMQ.get_provider('ibm-q-research-2', 'vienna-uni-tech-1', 'main')
exponents = range(0,5)
reps = range(1,6)
#target_backend = [FakeJakarta(), FakeManila(), FakeSantiago(), FakeLagos()]
target_backend = [FakeJakarta()]
backend_sim = Aer.get_backend('aer_simulator')
for num_reps in reps:
for e in exponents:
num_qubits = e + 1
matrices = generate_random_matrices(2 ** e, 2 ** e, 0, 10)
ansaetze = generate_ansaetze(num_qubits, num_reps, 'circular')
row = []
for a in ansaetze:
row.append(a.__class__.__name__ + '-RT')
row.append(a.__class__.__name__ + '-EIG')
row.append("Classic-EIG")
for backend in target_backend:
print(backend.name())
vqe_times = []
vqe_res = []
classic_result = []
summary_fname = "VQE_" + backend.name() + '_' + str(num_qubits) + '_' + str(num_reps) + '_rt-nrmse.csv'
rawdata_fname = "VQE_" + backend.name() + '_' + str(num_qubits) + '_' + str(num_reps) + '_raw-data.csv'
summary = open(summary_fname, 'w')
rawdata = open(rawdata_fname, 'w')
summary_writer = csv.writer(summary)
rawdata_writer = csv.writer(rawdata)
results = {}
results = dict.fromkeys(row)
for r in row:
results[r] = []
summary_writer.writerow(["PQC","AVG-RUNTIME", "MAE", "MSE", "RMSE", "NRMSE"])
rawdata_writer.writerow(row)
noise_model = NoiseModel.from_backend(QasmSimulator.from_backend(backend))
quantum_instance = QuantumInstance(backend=backend_sim, noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter)
optimizer = COBYLA(maxiter=100)
for matrix in matrices:
# matrix_op = pauli_representation(matrix)
operator = MatrixOp(matrix)
results["Classic-EIG"].append(lin_alg.eigvalsh(matrix)[0])
for ansatz in ansaetze:
initial_point = np.random.random(ansatz.num_parameters)
local_vqe = VQE(ansatz=ansatz,
optimizer=optimizer,
initial_point=initial_point,
quantum_instance=quantum_instance)
key_rt = ansatz.__class__.__name__ + "-RT"
key_eig = ansatz.__class__.__name__ + "-EIG"
start = timeit.timeit()
mde_eig_result = local_vqe.compute_minimum_eigenvalue(operator)
end = timeit.timeit()
eig = np.real(mde_eig_result.eigenvalue)
rt = end - start
results[key_eig].append(eig)
results[key_rt].append(rt)
row_results = []
for r in row:
row_results.append(str(results[r][-1]))
rawdata_writer.writerow(row_results)
print(backend.name())
print("PQC \t RUNTIME \t MAE \t MSE \t RMSE \t NRMSE")
for a in ansaetze:
rt = a.__class__.__name__ + '-RT'
avg_time = sum(results[rt]) / len(results[rt])
eig = a.__class__.__name__ + '-EIG'
eig_mae = mean_absolute_error(results["Classic-EIG"], results[eig])
eig_mse = mean_squared_error(results["Classic-EIG"], results[eig])
eig_rmse = math.sqrt(mean_squared_error(results["Classic-EIG"], results[eig]))
eig_nrmse = eig_rmse / (max(results["Classic-EIG"]) - min(results["Classic-EIG"]))
print(a.__class__.__name__ + " \t" + str(avg_time) + "\t" +
str(eig_mae) + "\t" + str(eig_mse) + "\t" + str(eig_rmse) + "\t" + str(eig_nrmse))
summary_writer.writerow(
[a.__class__.__name__, str(avg_time), str(eig_mae), str(eig_mse), str(eig_rmse), str(eig_nrmse)])
summary.close()
rawdata.close()
|
https://github.com/alejomonbar/Quantum-Supply-Chain-Manager
|
alejomonbar
|
%load_ext autoreload
%autoreload 2
# to use dataframe and load csv file
import pandas as pd
# to use for mathematical operations
import numpy as np
# split the set in 2 set, common train and test
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
# plot different designs
import matplotlib.pyplot as plt
%matplotlib inline
np.random.seed(123)
data = pd.read_csv("dataset/BackOrders.csv",header=0)
data.shape
data.head()
for col in ['potential_issue',
'deck_risk',
'oe_constraint',
'ppap_risk',
'stop_auto_buy',
'rev_stop',
'went_on_backorder']:
data[col]=pd.factorize(data[col])[0]
data.describe(include='all')
data['perf_6_month_avg']=data['perf_6_month_avg'].replace(-99, np.NaN)
data['perf_12_month_avg']=data['perf_12_month_avg'].replace(-99, np.NaN)
varnames=list(data)[1:]
correlations = data[varnames].corr()
fig = plt.figure()
ax = fig.add_subplot(111)
cax = ax.matshow(correlations, vmin=-1, vmax=1)
fig.colorbar(cax)
ticks = np.arange(0,22,1)
ax.set_xticks(ticks)
ax.set_yticks(ticks)
ax.set_xticklabels(varnames,rotation=90)
ax.set_yticklabels(varnames)
plt.show()
data.drop('rev_stop', axis=1, inplace=True)
data.drop('oe_constraint', axis=1, inplace=True)
data.drop('potential_issue', axis=1, inplace=True)
data.drop('stop_auto_buy', axis=1, inplace=True)
data.drop('deck_risk', axis=1, inplace=True)
def check_missing(data):
tot = data.isnull().sum().sort_values(ascending=False)
perc = ( round(100*data.isnull().sum()/data.isnull().count(),1) ).sort_values(ascending=False)
missing_data = pd.concat([tot, perc], axis=1, keys=['Missing', 'Percent'])
return missing_data[:3]
check_missing(data)
data.fillna(data.median(), inplace=True)
data
check_missing(data)
data.drop('sku', axis=1, inplace=True)
data
X, y = data.loc[:,data.columns!='went_on_backorder'].values, data.loc[:,'went_on_backorder'].values
X,y
X_train_1, X_test, y_train_1, y_test = train_test_split(X, y, test_size=0.1, random_state=123, stratify = data['went_on_backorder'])
print(X_train_1.shape)
print(X_test.shape)
print(pd.value_counts(y_train)/y_train.size * 100)
print(pd.value_counts(y_test)/y_test.size * 100)
def balance_split(X_train_1,y_train_1,flag=""):
X_train0 = []
X_train1 = []
y_train0 = []
y_train1 = []
for i in range(len(y_train_1)):
if y_train_1[i] == 0:
X_train0.append(X_train_1[i])
y_train0.append(y_train_1[i])
else:
X_train1.append(X_train_1[i])
y_train1.append(y_train_1[i])
X_train =[]
y_train = []
if flag == "fair":
X_train = X_train0[:1000] + X_train1[:1000]
y_train = y_train0[:1000] + y_train1[:1000]
else:
X_train = X_train0[:10000] + X_train1
y_train = y_train0[:10000] + y_train1
return np.asarray(X_train),np.asarray(y_train)
def save_data(X_train_1,y_train_1,flag="",name=""):
if flag == "fair":
X_train,y_train = balance_split(X_train_1,y_train_1,flag)
df_train = pd.concat([pd.DataFrame(X_train), pd.DataFrame(y_train)], axis=1)
df_train.to_csv("dataset/fair_"+name+".csv", index=False)
else:
X_train,y_train = balance_split(X_train_1,y_train_1)
df_train = pd.concat([pd.DataFrame(X_train), pd.DataFrame(y_train)], axis=1)
df_train.to_csv("dataset/classic_"+name+".csv", index=False)
#classic data
save_data(X_train_1,y_train_1,flag="classic",name="train")
#fair data
save_data(X_train_1,y_train_1,flag="fair",name="train")
#classic data
save_data(X_test,y_test,flag="classic",name="test")
data = pd.read_csv("dataset/classic_train.csv")
X,y = data[data.columns[:16]].values, data[data.columns[16]].values
X.shape, y.shape
data = pd.read_csv("dataset/fair_train.csv")
X,y = data[data.columns[:16]].values, data[data.columns[16]].values
X.shape, y.shape
data = pd.read_csv("dataset/classic_test.csv")
X,y = data[data.columns[:16]].values, data[data.columns[16]].values
X.shape, y.shape
|
https://github.com/MetalKyubit/Quantum-Algorithms-in-Qiskit
|
MetalKyubit
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import *
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
from qiskit.providers.fake_provider import FakeJakarta
from qiskit.providers.fake_provider import FakeNairobi
#defining a function to create the Simon's Algorithm circuit. Function takes in the oracle and number of qubits
# and ouputs the quantum circuit
def Simons_algo(oracle,n):
# n input qubits and n helper qubit
qc = QuantumCircuit(2*n,n)
# creating superposition of all the inputs
for i in range(n):
qc.h(i)
qc.barrier()
# applying the oracle that has the funciton and the secret string encoded in it to the circuit
qc.append(oracle, range(2*n))
qc.barrier()
#applying the hadamard gates again to collapse the superposition to one state that has the final result
#encoded in it.
for i in range(n):
qc.h(i)
# measuring the input qubits to find the final result.
qc.measure(range(n),range(n))
return (qc)
a = '10'
n = len(a)
ora = simon_oracle(a)
ora.draw('mpl')
q1 = Simons_algo(ora, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend, shots=1024)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
a = '101'
n = len(a)
ora = simon_oracle(a)
ora.draw('mpl')
q1 = Simons_algo(ora, n)
q1.draw('mpl')
# Running on non-noisy simulator
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend, shots=1024)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
|
https://github.com/JouziP/MQITE
|
JouziP
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Created on Wed Mar 11 18:03:12 2020
Functional interface to Qasm2 source loading and exporting
Supersede QuantumCircuit member functions
Provide for pluggable qasm translator
Based on conversation with Dr. Luciano Bello
@author: jax
"""
from importlib import import_module
from os import linesep
from typing import List, BinaryIO, TextIO
from qiskit import QuantumCircuit, QiskitError
from qiskit_openqasm2 import Qasm
from .funhelp import qasm_load, qasm_export
def _load_from_string(qasm_src: str or List[str],
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
qasm_src : str or List[str]
Qasm program source as string or list of string.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Raises
------
QiskitError
If unknown loader.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
if isinstance(qasm_src, list):
qasm_src = ''.join(s + linesep for s in qasm_src)
qasm = Qasm(data=qasm_src)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(data=qasm_src,
include_path=include_path)
return circ
def _load_from_file(filename: str,
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
filename : str
Filepath to qasm program source.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
qasm = Qasm(filename=filename)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(filename=filename,
include_path=include_path)
return circ
def load(data: str or List[str] = None,
filename: str = None,
loader: str = None,
include_path: str = None) -> QuantumCircuit:
"""
Parameters
----------
data : str or List[str], optional
Qasm program source as string or list of string. The default is None.
filename : str, optional
Filepath to qasm program source. The default is None.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is None.
Raises
------
QiskitError
If both filename and data or neither filename nor data.
Returns
-------
QuantumCircuit
The factoried circuit.
"""
if (not data and not filename) or (data and filename):
raise QiskitError("To load, either filename or data (and not both) must be provided.")
circ = None
if data:
circ = _load_from_string(data, loader=loader, include_path=include_path)
elif filename:
circ = _load_from_file(filename, loader=loader, include_path=include_path)
return circ
def export(qc: QuantumCircuit,
exporter: str = None,
file: BinaryIO or TextIO = None,
filename: str = None,
include_path: str = None,) -> str:
"""
Decompile a QuantumCircuit into Return OpenQASM string
Parameters
----------
qc : QuantumCircuit
Circuit to decompile ("export")
exporter : str, optional
Name of module with functional attribute
export(qc: QuantumCircuit,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
file : BinaryIO or TextIO, optional
File object to write to as well as return str
Written in UTF-8
Caller must close file.
Mutually exclusive with filename=
The default is None.
filename : str, optional
Name of file to write export to as well as return str
Mutually exclusive with file=
The default is None.
include_path: str, optional
Unloader-specific include path for qasm include directives
Raises
------
QiskitError
If both filename and file
Returns
-------
str
OpenQASM source for circuit.
"""
if filename and file:
raise QiskitError("export: file= and filename= are mutually exclusive")
qasm_src = None
if not exporter:
qasm_src = qasm_export(qc)
else:
m_m = import_module(exporter)
qasm_src = getattr(m_m, 'export')(qc, include_path=include_path)
if filename:
f_f = open(filename, 'w')
f_f.write(qasm_src)
f_f.close()
elif file:
if 'b' in file.mode:
file.write(bytes(qasm_src, 'utf-8'))
else:
file.write(qasm_src)
return qasm_src
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import ClassicalRegister, QuantumRegister, QuantumCircuit
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
qc.h(range(2))
qc.measure(range(2), range(2))
# apply x gate if the classical register has the value 2 (10 in binary)
qc.x(0).c_if(cr, 2)
# apply y gate if bit 0 is set to 1
qc.y(1).c_if(0, 1)
qc.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# useful additional packages
import matplotlib.pyplot as plt
import numpy as np
import networkx as nx
from qiskit_aer import Aer
from qiskit.tools.visualization import plot_histogram
from qiskit.circuit.library import TwoLocal
from qiskit_optimization.applications import Maxcut, Tsp
from qiskit.algorithms.minimum_eigensolvers import SamplingVQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import SPSA
from qiskit.utils import algorithm_globals
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import MinimumEigenOptimizer
# Generating a graph of 4 nodes
n = 4 # Number of nodes in graph
G = nx.Graph()
G.add_nodes_from(np.arange(0, n, 1))
elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]
# tuple is (i,j,weight) where (i,j) is the edge
G.add_weighted_edges_from(elist)
colors = ["r" for node in G.nodes()]
pos = nx.spring_layout(G)
def draw_graph(G, colors, pos):
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=0.8, ax=default_axes, pos=pos)
edge_labels = nx.get_edge_attributes(G, "weight")
nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=edge_labels)
draw_graph(G, colors, pos)
# Computing the weight matrix from the random graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp["weight"]
print(w)
best_cost_brute = 0
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]
cost = 0
for i in range(n):
for j in range(n):
cost = cost + w[i, j] * x[i] * (1 - x[j])
if best_cost_brute < cost:
best_cost_brute = cost
xbest_brute = x
print("case = " + str(x) + " cost = " + str(cost))
colors = ["r" if xbest_brute[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
print("\nBest solution = " + str(xbest_brute) + " cost = " + str(best_cost_brute))
max_cut = Maxcut(w)
qp = max_cut.to_quadratic_program()
print(qp.prettyprint())
qubitOp, offset = qp.to_ising()
print("Offset:", offset)
print("Ising Hamiltonian:")
print(str(qubitOp))
# solving Quadratic Program using exact classical eigensolver
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())
result = exact.solve(qp)
print(result.prettyprint())
# Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = NumPyMinimumEigensolver()
result = ee.compute_minimum_eigenvalue(qubitOp)
x = max_cut.sample_most_likely(result.eigenstate)
print("energy:", result.eigenvalue.real)
print("max-cut objective:", result.eigenvalue.real + offset)
print("solution:", x)
print("solution objective:", qp.objective.evaluate(x))
colors = ["r" if x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
algorithm_globals.random_seed = 123
seed = 10598
# construct SamplingVQE
optimizer = SPSA(maxiter=300)
ry = TwoLocal(qubitOp.num_qubits, "ry", "cz", reps=5, entanglement="linear")
vqe = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=optimizer)
# run SamplingVQE
result = vqe.compute_minimum_eigenvalue(qubitOp)
# print results
x = max_cut.sample_most_likely(result.eigenstate)
print("energy:", result.eigenvalue.real)
print("time:", result.optimizer_time)
print("max-cut objective:", result.eigenvalue.real + offset)
print("solution:", x)
print("solution objective:", qp.objective.evaluate(x))
# plot results
colors = ["r" if x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
# create minimum eigen optimizer based on SamplingVQE
vqe_optimizer = MinimumEigenOptimizer(vqe)
# solve quadratic program
result = vqe_optimizer.solve(qp)
print(result.prettyprint())
colors = ["r" if result.x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
# Generating a graph of 3 nodes
n = 3
num_qubits = n**2
tsp = Tsp.create_random_instance(n, seed=123)
adj_matrix = nx.to_numpy_array(tsp.graph)
print("distance\n", adj_matrix)
colors = ["r" for node in tsp.graph.nodes]
pos = [tsp.graph.nodes[node]["pos"] for node in tsp.graph.nodes]
draw_graph(tsp.graph, colors, pos)
from itertools import permutations
def brute_force_tsp(w, N):
a = list(permutations(range(1, N)))
last_best_distance = 1e10
for i in a:
distance = 0
pre_j = 0
for j in i:
distance = distance + w[j, pre_j]
pre_j = j
distance = distance + w[pre_j, 0]
order = (0,) + i
if distance < last_best_distance:
best_order = order
last_best_distance = distance
print("order = " + str(order) + " Distance = " + str(distance))
return last_best_distance, best_order
best_distance, best_order = brute_force_tsp(adj_matrix, n)
print(
"Best order from brute force = "
+ str(best_order)
+ " with total distance = "
+ str(best_distance)
)
def draw_tsp_solution(G, order, colors, pos):
G2 = nx.DiGraph()
G2.add_nodes_from(G)
n = len(order)
for i in range(n):
j = (i + 1) % n
G2.add_edge(order[i], order[j], weight=G[order[i]][order[j]]["weight"])
default_axes = plt.axes(frameon=True)
nx.draw_networkx(
G2, node_color=colors, edge_color="b", node_size=600, alpha=0.8, ax=default_axes, pos=pos
)
edge_labels = nx.get_edge_attributes(G2, "weight")
nx.draw_networkx_edge_labels(G2, pos, font_color="b", edge_labels=edge_labels)
draw_tsp_solution(tsp.graph, best_order, colors, pos)
qp = tsp.to_quadratic_program()
print(qp.prettyprint())
from qiskit_optimization.converters import QuadraticProgramToQubo
qp2qubo = QuadraticProgramToQubo()
qubo = qp2qubo.convert(qp)
qubitOp, offset = qubo.to_ising()
print("Offset:", offset)
print("Ising Hamiltonian:")
print(str(qubitOp))
result = exact.solve(qubo)
print(result.prettyprint())
# Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = NumPyMinimumEigensolver()
result = ee.compute_minimum_eigenvalue(qubitOp)
print("energy:", result.eigenvalue.real)
print("tsp objective:", result.eigenvalue.real + offset)
x = tsp.sample_most_likely(result.eigenstate)
print("feasible:", qubo.is_feasible(x))
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
algorithm_globals.random_seed = 123
seed = 10598
optimizer = SPSA(maxiter=300)
ry = TwoLocal(qubitOp.num_qubits, "ry", "cz", reps=5, entanglement="linear")
vqe = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=optimizer)
result = vqe.compute_minimum_eigenvalue(qubitOp)
print("energy:", result.eigenvalue.real)
print("time:", result.optimizer_time)
x = tsp.sample_most_likely(result.eigenstate)
print("feasible:", qubo.is_feasible(x))
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
algorithm_globals.random_seed = 123
seed = 10598
# create minimum eigen optimizer based on SamplingVQE
vqe_optimizer = MinimumEigenOptimizer(vqe)
# solve quadratic program
result = vqe_optimizer.solve(qp)
print(result.prettyprint())
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/luis6156/Shor-s-Quantum-Algorithm
|
luis6156
|
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/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/swe-bench/Qiskit__qiskit
|
swe-bench
|
# 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.
"""A container class for counts from a circuit execution."""
import re
from qiskit.result import postprocess
from qiskit import exceptions
# NOTE: A dict subclass should not overload any dunder methods like __getitem__
# this can cause unexpected behavior and issues as the cPython dict
# implementation has many standard methods in C for performance and the dunder
# methods are not always used as expected. For example, update() doesn't call
# __setitem__ so overloading __setitem__ would not always provide the expected
# result
class Counts(dict):
"""A class to store a counts result from a circuit execution."""
bitstring_regex = re.compile(r"^[01\s]+$")
def __init__(self, data, time_taken=None, creg_sizes=None, memory_slots=None):
"""Build a counts object
Args:
data (dict): The dictionary input for the counts. Where the keys
represent a measured classical value and the value is an
integer the number of shots with that result.
The keys can be one of several formats:
* A hexadecimal string of the form ``'0x4a'``
* A bit string prefixed with ``0b`` for example ``'0b1011'``
* A bit string formatted across register and memory slots.
For example, ``'00 10'``.
* A dit string, for example ``'02'``. Note for objects created
with dit strings the ``creg_sizes`` and ``memory_slots``
kwargs don't work and :meth:`hex_outcomes` and
:meth:`int_outcomes` also do not work.
time_taken (float): The duration of the experiment that generated
the counts in seconds.
creg_sizes (list): a nested list where the inner element is a list
of tuples containing both the classical register name and
classical register size. For example,
``[('c_reg', 2), ('my_creg', 4)]``.
memory_slots (int): The number of total ``memory_slots`` in the
experiment.
Raises:
TypeError: If the input key type is not an ``int`` or ``str``.
QiskitError: If a dit string key is input with ``creg_sizes`` and/or
``memory_slots``.
"""
bin_data = None
data = dict(data)
if not data:
self.int_raw = {}
self.hex_raw = {}
bin_data = {}
else:
first_key = next(iter(data.keys()))
if isinstance(first_key, int):
self.int_raw = data
self.hex_raw = {hex(key): value for key, value in self.int_raw.items()}
elif isinstance(first_key, str):
if first_key.startswith("0x"):
self.hex_raw = data
self.int_raw = {int(key, 0): value for key, value in self.hex_raw.items()}
elif first_key.startswith("0b"):
self.int_raw = {int(key, 0): value for key, value in data.items()}
self.hex_raw = {hex(key): value for key, value in self.int_raw.items()}
else:
if not creg_sizes and not memory_slots:
self.hex_raw = None
self.int_raw = None
bin_data = data
else:
hex_dict = {}
int_dict = {}
for bitstring, value in data.items():
if not self.bitstring_regex.search(bitstring):
raise exceptions.QiskitError(
"Counts objects with dit strings do not "
"currently support dit string formatting parameters "
"creg_sizes or memory_slots"
)
int_key = self._remove_space_underscore(bitstring)
int_dict[int_key] = value
hex_dict[hex(int_key)] = value
self.hex_raw = hex_dict
self.int_raw = int_dict
else:
raise TypeError(
"Invalid input key type %s, must be either an int "
"key or string key with hexademical value or bit string"
)
header = {}
self.creg_sizes = creg_sizes
if self.creg_sizes:
header["creg_sizes"] = self.creg_sizes
self.memory_slots = memory_slots
if self.memory_slots:
header["memory_slots"] = self.memory_slots
if not bin_data:
bin_data = postprocess.format_counts(self.hex_raw, header=header)
super().__init__(bin_data)
self.time_taken = time_taken
def most_frequent(self):
"""Return the most frequent count
Returns:
str: The bit string for the most frequent result
Raises:
QiskitError: when there is >1 count with the same max counts, or
an empty object.
"""
if not self:
raise exceptions.QiskitError("Can not return a most frequent count on an empty object")
max_value = max(self.values())
max_values_counts = [x[0] for x in self.items() if x[1] == max_value]
if len(max_values_counts) != 1:
raise exceptions.QiskitError(
"Multiple values have the same maximum counts: %s" % ",".join(max_values_counts)
)
return max_values_counts[0]
def hex_outcomes(self):
"""Return a counts dictionary with hexadecimal string keys
Returns:
dict: A dictionary with the keys as hexadecimal strings instead of
bitstrings
Raises:
QiskitError: If the Counts object contains counts for dit strings
"""
if self.hex_raw:
return {key.lower(): value for key, value in self.hex_raw.items()}
else:
out_dict = {}
for bitstring, value in self.items():
if not self.bitstring_regex.search(bitstring):
raise exceptions.QiskitError(
"Counts objects with dit strings do not "
"currently support conversion to hexadecimal"
)
int_key = self._remove_space_underscore(bitstring)
out_dict[hex(int_key)] = value
return out_dict
def int_outcomes(self):
"""Build a counts dictionary with integer keys instead of count strings
Returns:
dict: A dictionary with the keys as integers instead of bitstrings
Raises:
QiskitError: If the Counts object contains counts for dit strings
"""
if self.int_raw:
return self.int_raw
else:
out_dict = {}
for bitstring, value in self.items():
if not self.bitstring_regex.search(bitstring):
raise exceptions.QiskitError(
"Counts objects with dit strings do not "
"currently support conversion to integer"
)
int_key = self._remove_space_underscore(bitstring)
out_dict[int_key] = value
return out_dict
@staticmethod
def _remove_space_underscore(bitstring):
"""Removes all spaces and underscores from bitstring"""
return int(bitstring.replace(" ", "").replace("_", ""), 2)
def shots(self):
"""Return the number of shots"""
return sum(self.values())
|
https://github.com/quantumyatra/quantum_computing
|
quantumyatra
|
import numpy as np
np.random.seed(999999)
target_distr = np.random.rand(2)
# We now convert the random vector into a valid probability vector
target_distr /= sum(target_distr)
print (target_distr)
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
def get_var_form(params):
qr = QuantumRegister(1, name="q")
cr = ClassicalRegister(1, name='c')
qc = QuantumCircuit(qr, cr)
qc.u3(params[0], params[1], params[2], qr[0])
qc.measure(qr, cr[0])
return qc
params = [0.1, 0, 0]
qcc = get_var_form(params)
qcc.draw('mpl')
from qiskit import Aer, execute
backend = Aer.get_backend("qasm_simulator")
num_shots = 10000
def get_probability_distribution(counts):
output_distr = [v / num_shots for v in counts.values()]
if len(output_distr) == 1:
output_distr.append(0)
return output_distr
def objective_function(params):
# Obtain a quantum circuit instance from the paramters
qc = get_var_form(params)
# Execute the quantum circuit to obtain the probability distribution associated with the current parameters
result = execute(qc, backend, shots=num_shots).result()
# Obtain the counts for each measured state, and convert those counts into a probability vector
output_distr = get_probability_distribution(result.get_counts(qc))
# Calculate the cost as the distance between the output distribution and the target distribution
cost = sum([np.abs(output_distr[i] - target_distr[i]) for i in range(2)])
return cost
from qiskit.aqua.components.optimizers import COBYLA
# Initialize the COBYLA optimizer
optimizer = COBYLA(maxiter=50, tol=0.0001)
# Create the initial parameters (noting that our single qubit variational form has 3 parameters)
params = np.random.rand(3)
ret = optimizer.optimize(num_vars=3, objective_function=objective_function, initial_point=params)
# Obtain the output distribution using the final parameters
qc = get_var_form(ret[0])
counts = execute(qc, backend, shots=num_shots).result().get_counts(qc)
output_distr = get_probability_distribution(counts)
print("Target Distribution:", target_distr)
print("Obtained Distribution:", output_distr)
print("Output Error (Manhattan Distance):", ret[1])
print("Parameters Found:", ret[0])
from qiskit.circuit.library import EfficientSU2
entanglements = ["linear", "full"]
for entanglement in entanglements:
form = EfficientSU2(num_qubits=4, entanglement=entanglement)
if entanglement == "linear":
print("=============Linear Entanglement:=============")
else:
print("=============Full Entanglement:=============")
# We initialize all parameters to 0 for this demonstration
display(form.draw("mpl", fold=100))
print()
from qiskit.aqua.algorithms import VQE, NumPyEigensolver
import matplotlib.pyplot as plt
import numpy as np
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.circuit.library import EfficientSU2
from qiskit.aqua.components.optimizers import COBYLA, SPSA, SLSQP
from qiskit.aqua.operators import Z2Symmetries
from qiskit import IBMQ, BasicAer, Aer
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.chemistry import FermionicOperator
from qiskit import IBMQ
from qiskit.aqua import QuantumInstance
from qiskit.ignis.mitigation.measurement import CompleteMeasFitter
from qiskit.providers.aer.noise import NoiseModel
def get_qubit_op(dist):
driver = PySCFDriver(atom="Li .0 .0 .0; H .0 .0 " + str(dist), unit=UnitsType.ANGSTROM,
charge=0, spin=0, basis='sto3g')
molecule = driver.run()
freeze_list = [0]
remove_list = [-3, -2]
repulsion_energy = molecule.nuclear_repulsion_energy
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
remove_list = [x % molecule.num_orbitals for x in remove_list]
freeze_list = [x % molecule.num_orbitals for x in freeze_list]
remove_list = [x - len(freeze_list) for x in remove_list]
remove_list += [x + molecule.num_orbitals - len(freeze_list) for x in remove_list]
freeze_list += [x + molecule.num_orbitals for x in freeze_list]
ferOp = FermionicOperator(h1=molecule.one_body_integrals, h2=molecule.two_body_integrals)
ferOp, energy_shift = ferOp.fermion_mode_freezing(freeze_list)
num_spin_orbitals -= len(freeze_list)
num_particles -= len(freeze_list)
ferOp = ferOp.fermion_mode_elimination(remove_list)
num_spin_orbitals -= len(remove_list)
qubitOp = ferOp.mapping(map_type='parity', threshold=0.00000001)
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles)
shift = energy_shift + repulsion_energy
return qubitOp, num_particles, num_spin_orbitals, shift
dist = 1.
qubitOp, num_particles, num_spin_orbitals, shift = get_qubit_op(dist)
print ( qubitOp, num_particles, num_spin_orbitals, shift )
backend = BasicAer.get_backend("statevector_simulator")
distances = np.arange(0.5, 4.0, 0.1)
exact_energies = []
vqe_energies = []
optimizer = SLSQP(maxiter=5)
for dist in distances:
qubitOp, num_particles, num_spin_orbitals, shift = get_qubit_op(dist)
result = NumPyEigensolver(qubitOp).run()
exact_energies.append(np.real(result.eigenvalues) + shift)
initial_state = HartreeFock(
num_spin_orbitals,
num_particles,
qubit_mapping='parity'
)
var_form = UCCSD(
num_orbitals=num_spin_orbitals,
num_particles=num_particles,
initial_state=initial_state,
qubit_mapping='parity'
)
vqe = VQE(qubitOp, var_form, optimizer)
vqe_result = np.real(vqe.run(backend)['eigenvalue'] + shift)
vqe_energies.append(vqe_result)
print("Interatomic Distance:", np.round(dist, 2), "VQE Result:", vqe_result, "Exact Energy:", exact_energies[-1])
print("All energies have been calculated")
plt.plot(distances, exact_energies, label="Exact Energy")
plt.plot(distances, vqe_energies, label="VQE Energy")
plt.xlabel('Atomic distance (Angstrom)')
plt.ylabel('Energy')
plt.legend()
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.library import RealAmplitudes
from qiskit.algorithms.optimizers import COBYLA
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver, SamplingVQE
from qiskit.primitives import Sampler
from qiskit_optimization.converters import LinearEqualityToPenalty
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.translators import from_docplex_mp
from qiskit.utils import algorithm_globals
import numpy as np
import matplotlib.pyplot as plt
from docplex.mp.model import Model
algorithm_globals.random_seed = 123456
# prepare problem instance
n = 6 # number of assets
q = 0.5 # risk factor
budget = n // 2 # budget
penalty = 2 * n # scaling of penalty term
# instance from [1]
mu = np.array([0.7313, 0.9893, 0.2725, 0.8750, 0.7667, 0.3622])
sigma = np.array(
[
[0.7312, -0.6233, 0.4689, -0.5452, -0.0082, -0.3809],
[-0.6233, 2.4732, -0.7538, 2.4659, -0.0733, 0.8945],
[0.4689, -0.7538, 1.1543, -1.4095, 0.0007, -0.4301],
[-0.5452, 2.4659, -1.4095, 3.5067, 0.2012, 1.0922],
[-0.0082, -0.0733, 0.0007, 0.2012, 0.6231, 0.1509],
[-0.3809, 0.8945, -0.4301, 1.0922, 0.1509, 0.8992],
]
)
# or create random instance
# mu, sigma = portfolio.random_model(n, seed=123) # expected returns and covariance matrix
# create docplex model
mdl = Model("portfolio_optimization")
x = mdl.binary_var_list(range(n), name="x")
objective = mdl.sum([mu[i] * x[i] for i in range(n)])
objective -= q * mdl.sum([sigma[i, j] * x[i] * x[j] for i in range(n) for j in range(n)])
mdl.maximize(objective)
mdl.add_constraint(mdl.sum(x[i] for i in range(n)) == budget)
# case to
qp = from_docplex_mp(mdl)
# solve classically as reference
opt_result = MinimumEigenOptimizer(NumPyMinimumEigensolver()).solve(qp)
print(opt_result.prettyprint())
# we convert the problem to an unconstrained problem for further analysis,
# otherwise this would not be necessary as the MinimumEigenSolver would do this
# translation automatically
linear2penalty = LinearEqualityToPenalty(penalty=penalty)
qp = linear2penalty.convert(qp)
_, offset = qp.to_ising()
# set classical optimizer
maxiter = 100
optimizer = COBYLA(maxiter=maxiter)
# set variational ansatz
ansatz = RealAmplitudes(n, reps=1)
m = ansatz.num_parameters
# set sampler
sampler = Sampler()
# run variational optimization for different values of alpha
alphas = [1.0, 0.50, 0.25] # confidence levels to be evaluated
# dictionaries to store optimization progress and results
objectives = {alpha: [] for alpha in alphas} # set of tested objective functions w.r.t. alpha
results = {} # results of minimum eigensolver w.r.t alpha
# callback to store intermediate results
def callback(i, params, obj, stddev, alpha):
# we translate the objective from the internal Ising representation
# to the original optimization problem
objectives[alpha].append(np.real_if_close(-(obj + offset)))
# loop over all given alpha values
for alpha in alphas:
# initialize SamplingVQE using CVaR
vqe = SamplingVQE(
sampler=sampler,
ansatz=ansatz,
optimizer=optimizer,
aggregation=alpha,
callback=lambda i, params, obj, stddev: callback(i, params, obj, stddev, alpha),
)
# initialize optimization algorithm based on CVaR-SamplingVQE
opt_alg = MinimumEigenOptimizer(vqe)
# solve problem
results[alpha] = opt_alg.solve(qp)
# print results
print("alpha = {}:".format(alpha))
print(results[alpha].prettyprint())
print()
# plot resulting history of objective values
plt.figure(figsize=(10, 5))
plt.plot([0, maxiter], [opt_result.fval, opt_result.fval], "r--", linewidth=2, label="optimum")
for alpha in alphas:
plt.plot(objectives[alpha], label="alpha = %.2f" % alpha, linewidth=2)
plt.legend(loc="lower right", fontsize=14)
plt.xlim(0, maxiter)
plt.xticks(fontsize=14)
plt.xlabel("iterations", fontsize=14)
plt.yticks(fontsize=14)
plt.ylabel("objective value", fontsize=14)
plt.show()
# evaluate and sort all objective values
objective_values = np.zeros(2**n)
for i in range(2**n):
x_bin = ("{0:0%sb}" % n).format(i)
x = [0 if x_ == "0" else 1 for x_ in reversed(x_bin)]
objective_values[i] = qp.objective.evaluate(x)
ind = np.argsort(objective_values)
# evaluate final optimal probability for each alpha
for alpha in alphas:
probabilities = np.fromiter(
results[alpha].min_eigen_solver_result.eigenstate.binary_probabilities().values(),
dtype=float,
)
print("optimal probability (alpha = %.2f): %.4f" % (alpha, probabilities[ind][-1:]))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
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.
# pylint: disable=invalid-name
"""Single-qubit unitary tests."""
import unittest
from test import combine
import numpy as np
from ddt import ddt
from qiskit.quantum_info.random import random_unitary
from qiskit import BasicAer
from qiskit import QuantumCircuit
from qiskit import QuantumRegister
from qiskit import execute
from qiskit.test import QiskitTestCase
from qiskit.extensions.quantum_initializer.squ import SingleQubitUnitary
from qiskit.compiler import transpile
from qiskit.quantum_info.operators.predicates import matrix_equal
squs = [
np.eye(2, 2),
np.array([[0.0, 1.0], [1.0, 0.0]]),
1 / np.sqrt(2) * np.array([[1.0, 1.0], [-1.0, 1.0]]),
np.array([[np.exp(1j * 5.0 / 2), 0], [0, np.exp(-1j * 5.0 / 2)]]),
random_unitary(2, seed=42).data,
]
up_to_diagonal_list = [True, False]
@ddt
class TestSingleQubitUnitary(QiskitTestCase):
"""Qiskit ZYZ-decomposition tests."""
@combine(u=squs, up_to_diagonal=up_to_diagonal_list)
def test_squ(self, u, up_to_diagonal):
"""Tests for single-qubit unitary decomposition."""
qr = QuantumRegister(1, "qr")
qc = QuantumCircuit(qr)
qc.squ(u, qr[0], up_to_diagonal=up_to_diagonal)
# Decompose the gate
qc = transpile(qc, basis_gates=["u1", "u3", "u2", "cx", "id"])
# Simulate the decomposed gate
simulator = BasicAer.get_backend("unitary_simulator")
result = execute(qc, simulator).result()
unitary = result.get_unitary(qc)
if up_to_diagonal:
squ = SingleQubitUnitary(u, up_to_diagonal=up_to_diagonal)
unitary = np.dot(np.diagflat(squ.diag), unitary)
unitary_desired = u
self.assertTrue(matrix_equal(unitary_desired, unitary, ignore_phase=True))
if __name__ == "__main__":
unittest.main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Operator
from qiskit.transpiler.passes import UnitarySynthesis
circuit = QuantumCircuit(1)
circuit.rx(0.8, 0)
unitary = Operator(circuit).data
unitary_circ = QuantumCircuit(1)
unitary_circ.unitary(unitary, [0])
synth = UnitarySynthesis(basis_gates=["h", "s"], method="sk")
out = synth(unitary_circ)
out.draw('mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.drivers import Molecule
from qiskit_nature.drivers.second_quantization import (
ElectronicStructureDriverType,
ElectronicStructureMoleculeDriver,
PySCFDriver,
)
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
from qiskit_nature.settings import settings
settings.dict_aux_operators = True
molecule = Molecule(
geometry=[["H", [0.0, 0.0, 0.0]], ["H", [0.0, 0.0, 0.735]]], charge=0, multiplicity=1
)
driver = ElectronicStructureMoleculeDriver(
molecule, basis="sto3g", driver_type=ElectronicStructureDriverType.PYSCF
)
# or equivalently:
driver = PySCFDriver.from_molecule(molecule, basis="sto3g")
transformer = FreezeCoreTransformer()
problem = ElectronicStructureProblem(driver, transformers=[transformer])
# Note: at this point, `driver.run()` has NOT been called yet. We can trigger this indirectly like so:
second_q_ops = problem.second_q_ops()
hamiltonian = second_q_ops["ElectronicEnergy"]
print(hamiltonian)
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.formats.molecule_info import MoleculeInfo
from qiskit_nature.second_q.transformers import FreezeCoreTransformer
molecule = MoleculeInfo(["H", "H"], [(0.0, 0.0, 0.0), (0.0, 0.0, 0.735)], charge=0, multiplicity=1)
driver = PySCFDriver.from_molecule(molecule, basis="sto3g")
# this is now done explicitly
problem = driver.run()
transformer = FreezeCoreTransformer()
# and you also apply transformers explicitly
problem = transformer.transform(problem)
hamiltonian = problem.hamiltonian.second_q_op()
print("\n".join(str(hamiltonian).splitlines()[:10] + ["..."]))
from qiskit_nature.drivers import Molecule
from qiskit_nature.drivers.second_quantization import PySCFDriver
molecule = Molecule(
geometry=[["H", [0.0, 0.0, 0.0]], ["H", [0.0, 0.0, 0.735]]], charge=0, multiplicity=1
)
driver = PySCFDriver.from_molecule(molecule)
result = driver.run()
print(type(result))
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.formats.molecule_info import MoleculeInfo
molecule = MoleculeInfo(["H", "H"], [(0.0, 0.0, 0.0), (0.0, 0.0, 0.735)], charge=0, multiplicity=1)
driver = PySCFDriver.from_molecule(molecule, basis="sto3g")
result = driver.run()
print(type(result))
from qiskit_nature.drivers.second_quantization import FCIDumpDriver
path_to_fcidump = "aux_files/h2.fcidump"
driver = FCIDumpDriver(path_to_fcidump)
result = driver.run()
print(type(result))
from qiskit_nature.second_q.formats.fcidump import FCIDump
path_to_fcidump = "aux_files/h2.fcidump"
fcidump = FCIDump.from_file(path_to_fcidump)
print(type(fcidump))
from qiskit_nature.second_q.formats.fcidump_translator import fcidump_to_problem
problem = fcidump_to_problem(fcidump)
print(type(problem))
from qiskit_nature.drivers.second_quantization import PySCFDriver
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
transformer = FreezeCoreTransformer()
driver = PySCFDriver()
transformed_result = transformer.transform(driver.run())
print(type(transformed_result))
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.transformers import FreezeCoreTransformer
transformer = FreezeCoreTransformer()
driver = PySCFDriver()
transformed_result = transformer.transform(driver.run())
print(type(transformed_result))
from qiskit_nature.drivers.second_quantization import PySCFDriver
from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
driver = PySCFDriver()
transformer = FreezeCoreTransformer()
problem = ElectronicStructureProblem(driver, transformers=[transformer])
# we trigger driver.run() implicitly like so:
second_q_ops = problem.second_q_ops()
hamiltonian_op = second_q_ops.pop("ElectronicEnergy")
aux_ops = second_q_ops
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.transformers import FreezeCoreTransformer
driver = PySCFDriver()
problem = driver.run()
transformer = FreezeCoreTransformer()
problem = transformer.transform(problem)
hamiltonian_op, aux_ops = problem.second_q_ops()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/AmirhoseynpowAsghari/Qiskit-Tutorials
|
AmirhoseynpowAsghari
|
#DOI : https://doi.org/10.1143/JPSJ.12.570
import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import expm
# Define Pauli matrices
sigma_x = np.array([[0, 1], [1, 0]])
sigma_y = np.array([[0, -1j], [1j, 0]])
sigma_z = np.array([[1, 0], [0, -1]])
# System parameters
omega_0 = 1.0 # Transition frequency
Omega = 0.1 # Driving strength
omega = 1.0 # Driving frequency
hbar = 1.0
# Time array
t = np.linspace(0, 50, 10000)
dt = t[1] - t[0]
# Initial density matrix (ground state)
rho = np.array([[1, 0], [0, 0]], dtype=complex)
# Hamiltonian matrices
H0 = (hbar * omega_0 / 2) * sigma_z
H_prime = lambda t: hbar * Omega * np.cos(omega * t) * sigma_x
# Time evolution
rho_t = np.zeros((len(t), 2, 2), dtype=complex)
rho_t[0] = rho
for i in range(1, len(t)):
H = H0 + H_prime(t[i-1])
U = expm(-1j * H * dt / hbar)
rho = U @ rho @ U.conj().T
rho_t[i] = rho
# Calculate expectation values of Pauli z-matrix
expectation_z = [np.trace(rho @ sigma_z).real for rho in rho_t]
# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(t, expectation_z, label=r'$\langle \sigma_z \rangle$')
plt.xlabel('Time $t$')
plt.ylabel(r'$\langle \sigma_z \rangle$')
plt.title('Response of a Two-Level System to a Sinusoidal Driving Field')
plt.legend()
plt.grid()
plt.show()
import numpy as np
import matplotlib.pyplot as plt
from scipy.linalg import expm
# Define Pauli matrices
sigma_x = np.array([[0, 1], [1, 0]])
sigma_y = np.array([[0, -1j], [1j, 0]])
sigma_z = np.array([[1, 0], [0, -1]])
# System parameters
omega_0 = 1.0 # Transition frequency
Omega = 0.1 # Driving strength
hbar = 1.0
# Time array
t = np.linspace(0, 50, 10000)
dt = t[1] - t[0]
# Initial density matrix (ground state)
rho = np.array([[1, 0], [0, 0]], dtype=complex)
# Hamiltonian matrices
H0 = (hbar * omega_0 / 2) * sigma_z
H_prime = lambda t: hbar * Omega * (t >= 0) * sigma_x # Step function perturbation
# Time evolution
rho_t = np.zeros((len(t), 2, 2), dtype=complex)
rho_t[0] = rho
for i in range(1, len(t)):
H = H0 + H_prime(t[i-1])
U = expm(-1j * H * dt / hbar)
rho = U @ rho @ U.conj().T
rho_t[i] = rho
# Calculate expectation values of Pauli z-matrix
expectation_z = [np.trace(rho @ sigma_z).real for rho in rho_t]
# Plot the results
plt.figure(figsize=(10, 6))
plt.plot(t, expectation_z, label=r'$\langle \sigma_z \rangle$')
plt.xlabel('Time $t$')
plt.ylabel(r'$\langle \sigma_z \rangle$')
plt.title('Response of a Two-Level System to a Step Function Driving Field')
plt.legend()
plt.grid()
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.translators import from_docplex_mp
# Make a Docplex model
from docplex.mp.model import Model
mdl = Model("docplex model")
x = mdl.binary_var("x")
y = mdl.integer_var(lb=-1, ub=5, name="y")
mdl.minimize(x + 2 * y)
mdl.add_constraint(x - y == 3)
mdl.add_constraint((x + y) * (x - y) <= 1)
print(mdl.export_as_lp_string())
# load from a Docplex model
mod = from_docplex_mp(mdl)
print(type(mod))
print()
print(mod.prettyprint())
# make an empty problem
mod = QuadraticProgram("my problem")
print(mod.prettyprint())
# Add variables
mod.binary_var(name="x")
mod.integer_var(name="y", lowerbound=-1, upperbound=5)
mod.continuous_var(name="z", lowerbound=-1, upperbound=5)
print(mod.prettyprint())
# Add objective function using dictionaries
mod.minimize(constant=3, linear={"x": 1}, quadratic={("x", "y"): 2, ("z", "z"): -1})
print(mod.prettyprint())
# Add objective function using lists/arrays
mod.minimize(constant=3, linear=[1, 0, 0], quadratic=[[0, 1, 0], [1, 0, 0], [0, 0, -1]])
print(mod.prettyprint())
print("constant:\t\t\t", mod.objective.constant)
print("linear dict:\t\t\t", mod.objective.linear.to_dict())
print("linear array:\t\t\t", mod.objective.linear.to_array())
print("linear array as sparse matrix:\n", mod.objective.linear.coefficients, "\n")
print("quadratic dict w/ index:\t", mod.objective.quadratic.to_dict())
print("quadratic dict w/ name:\t\t", mod.objective.quadratic.to_dict(use_name=True))
print(
"symmetric quadratic dict w/ name:\t",
mod.objective.quadratic.to_dict(use_name=True, symmetric=True),
)
print("quadratic matrix:\n", mod.objective.quadratic.to_array(), "\n")
print("symmetric quadratic matrix:\n", mod.objective.quadratic.to_array(symmetric=True), "\n")
print("quadratic matrix as sparse matrix:\n", mod.objective.quadratic.coefficients)
# Add linear constraints
mod.linear_constraint(linear={"x": 1, "y": 2}, sense="==", rhs=3, name="lin_eq")
mod.linear_constraint(linear={"x": 1, "y": 2}, sense="<=", rhs=3, name="lin_leq")
mod.linear_constraint(linear={"x": 1, "y": 2}, sense=">=", rhs=3, name="lin_geq")
print(mod.prettyprint())
# Add quadratic constraints
mod.quadratic_constraint(
linear={"x": 1, "y": 1},
quadratic={("x", "x"): 1, ("y", "z"): -1},
sense="==",
rhs=1,
name="quad_eq",
)
mod.quadratic_constraint(
linear={"x": 1, "y": 1},
quadratic={("x", "x"): 1, ("y", "z"): -1},
sense="<=",
rhs=1,
name="quad_leq",
)
mod.quadratic_constraint(
linear={"x": 1, "y": 1},
quadratic={("x", "x"): 1, ("y", "z"): -1},
sense=">=",
rhs=1,
name="quad_geq",
)
print(mod.prettyprint())
lin_geq = mod.get_linear_constraint("lin_geq")
print("lin_geq:", lin_geq.linear.to_dict(use_name=True), lin_geq.sense, lin_geq.rhs)
quad_geq = mod.get_quadratic_constraint("quad_geq")
print(
"quad_geq:",
quad_geq.linear.to_dict(use_name=True),
quad_geq.quadratic.to_dict(use_name=True),
quad_geq.sense,
lin_geq.rhs,
)
# Remove constraints
mod.remove_linear_constraint("lin_eq")
mod.remove_quadratic_constraint("quad_leq")
print(mod.prettyprint())
sub = mod.substitute_variables(constants={"x": 0}, variables={"y": ("z", -1)})
print(sub.prettyprint())
sub = mod.substitute_variables(constants={"x": -1})
print(sub.status)
from qiskit_optimization import QiskitOptimizationError
try:
sub = mod.substitute_variables(constants={"x": -1}, variables={"y": ("x", 1)})
except QiskitOptimizationError as e:
print("Error: {}".format(e))
mod = QuadraticProgram()
mod.binary_var(name="e")
mod.binary_var(name="f")
mod.continuous_var(name="g")
mod.minimize(linear=[1, 2, 3])
print(mod.export_as_lp_string())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=invalid-name,no-name-in-module,ungrouped-imports
"""A circuit library widget module"""
import ipywidgets as wid
from IPython.display import display
from qiskit import QuantumCircuit
from qiskit.utils import optionals as _optionals
from qiskit.utils.deprecation import deprecate_func
@_optionals.HAS_MATPLOTLIB.require_in_call
def _generate_circuit_library_visualization(circuit: QuantumCircuit):
import matplotlib.pyplot as plt
circuit = circuit.decompose()
ops = circuit.count_ops()
num_nl = circuit.num_nonlocal_gates()
_fig, (ax0, ax1) = plt.subplots(2, 1)
circuit.draw("mpl", ax=ax0)
ax1.axis("off")
ax1.grid(visible=None)
ax1.table(
[[circuit.name], [circuit.width()], [circuit.depth()], [sum(ops.values())], [num_nl]],
rowLabels=["Circuit Name", "Width", "Depth", "Total Gates", "Non-local Gates"],
)
plt.tight_layout()
plt.show()
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def circuit_data_table(circuit: QuantumCircuit) -> wid.HTML:
"""Create a HTML table widget for a given quantum circuit.
Args:
circuit: Input quantum circuit.
Returns:
Output widget.
"""
circuit = circuit.decompose()
ops = circuit.count_ops()
num_nl = circuit.num_nonlocal_gates()
html = "<table>"
html += """<style>
table {
font-family: "IBM Plex Sans", Arial, Helvetica, sans-serif;
border-collapse: collapse;
width: 100%;
border-left: 2px solid #212121;
}
th {
text-align: left;
padding: 5px 5px 5px 5px;
width: 100%;
background-color: #988AFC;
color: #fff;
font-size: 14px;
border-left: 2px solid #988AFC;
}
td {
text-align: left;
padding: 5px 5px 5px 5px;
width: 100%;
font-size: 12px;
font-weight: medium;
}
tr:nth-child(even) {background-color: #f6f6f6;}
</style>"""
html += f"<tr><th>{circuit.name}</th><th></tr>"
html += f"<tr><td>Width</td><td>{circuit.width()}</td></tr>"
html += f"<tr><td>Depth</td><td>{circuit.depth()}</td></tr>"
html += f"<tr><td>Total Gates</td><td>{sum(ops.values())}</td></tr>"
html += f"<tr><td>Non-local Gates</td><td>{num_nl}</td></tr>"
html += "</table>"
out_wid = wid.HTML(html)
return out_wid
head_style = (
"font-family: IBM Plex Sans, Arial, Helvetica, sans-serif;"
" font-size: 20px; font-weight: medium;"
)
property_label = wid.HTML(
f"<p style='{head_style}'>Circuit Properties</p>",
layout=wid.Layout(margin="0px 0px 10px 0px"),
)
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def properties_widget(circuit: QuantumCircuit) -> wid.VBox:
"""Create a HTML table widget with header for a given quantum circuit.
Args:
circuit: Input quantum circuit.
Returns:
Output widget.
"""
properties = wid.VBox(
children=[property_label, circuit_data_table(circuit)],
layout=wid.Layout(width="40%", height="auto"),
)
return properties
@_optionals.HAS_PYGMENTS.require_in_call
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def qasm_widget(circuit: QuantumCircuit) -> wid.VBox:
"""Generate a QASM widget with header for a quantum circuit.
Args:
circuit: Input quantum circuit.
Returns:
Output widget.
"""
import pygments
from pygments.formatters import HtmlFormatter
from qiskit.qasm.pygments import QasmHTMLStyle, OpenQASMLexer
qasm_code = circuit.qasm()
code = pygments.highlight(qasm_code, OpenQASMLexer(), HtmlFormatter())
html_style = HtmlFormatter(style=QasmHTMLStyle).get_style_defs(".highlight")
code_style = (
"""
<style>
.highlight
{
font-family: monospace;
font-size: 14px;
line-height: 1.7em;
}
.highlight .err { color: #000000; background-color: #FFFFFF }
%s
</style>
"""
% html_style
)
out = wid.HTML(
code_style + code,
layout=wid.Layout(max_height="500px", height="auto", overflow="scroll scroll"),
)
out_label = wid.HTML(
f"<p style='{head_style}'>OpenQASM</p>",
layout=wid.Layout(margin="0px 0px 10px 0px"),
)
qasm = wid.VBox(
children=[out_label, out],
layout=wid.Layout(
height="auto", max_height="500px", width="60%", margin="0px 0px 0px 20px"
),
)
qasm._code_length = len(qasm_code.split("\n"))
return qasm
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def circuit_diagram_widget() -> wid.Box:
"""Create a circuit diagram widget.
Returns:
Output widget.
"""
# The max circuit height corresponds to a 20Q circuit with flat
# classical register.
top_out = wid.Output(
layout=wid.Layout(
width="100%",
height="auto",
max_height="1000px",
overflow="hidden scroll",
)
)
top = wid.Box(children=[top_out], layout=wid.Layout(width="100%", height="auto"))
return top
@deprecate_func(
since="0.25.0",
additional_msg="This is unused by Qiskit, and no replacement will be publicly provided.",
)
def circuit_library_widget(circuit: QuantumCircuit) -> None:
"""Create a circuit library widget.
Args:
circuit: Input quantum circuit.
"""
qasm_wid = qasm_widget(circuit)
sep_length = str(min(20 * qasm_wid._code_length, 495))
# The separator widget
sep = wid.HTML(
f"<div style='border-left: 3px solid #212121;height: {sep_length}px;'></div>",
layout=wid.Layout(height="auto", max_height="495px", margin="40px 0px 0px 20px"),
)
bottom = wid.HBox(
children=[properties_widget(circuit), sep, qasm_widget(circuit)],
layout=wid.Layout(max_height="550px", height="auto"),
)
top = circuit_diagram_widget()
with top.children[0]:
display(circuit.decompose().draw(output="mpl"))
display(wid.VBox(children=[top, bottom], layout=wid.Layout(width="100%", height="auto")))
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.problems import BaseProblem
dummy_hamiltonian = None
base_problem = BaseProblem(dummy_hamiltonian)
print(base_problem.properties)
from qiskit_nature.second_q.properties import AngularMomentum
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Adding AngularMomentum to problem.properties...")
base_problem.properties.add(AngularMomentum(2))
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
print("Discarding AngularMomentum from problem.properties...")
base_problem.properties.discard(AngularMomentum)
print("AngularMomentum is in problem.properties:", AngularMomentum in base_problem.properties)
from qiskit_nature.second_q.drivers import PySCFDriver
es_problem = PySCFDriver().run()
print(es_problem.properties.particle_number)
print(es_problem.properties.angular_momentum)
print(es_problem.properties.magnetization)
print(es_problem.properties.electronic_dipole_moment)
print(es_problem.properties.electronic_density)
from qiskit_nature.second_q.properties import ElectronicDensity
density = ElectronicDensity.from_orbital_occupation(
es_problem.orbital_occupations,
es_problem.orbital_occupations_b,
)
es_problem.properties.electronic_density = density
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 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.
"""Example of using the StochasticSwap pass."""
from qiskit.transpiler.passes import StochasticSwap
from qiskit.transpiler import CouplingMap
from qiskit.converters import circuit_to_dag
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
coupling = CouplingMap([[0, 1], [1, 2], [1, 3]])
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(4, "c")
circ = QuantumCircuit(qr, cr)
circ.cx(qr[1], qr[2])
circ.cx(qr[0], qr[3])
circ.measure(qr[0], cr[0])
circ.h(qr)
circ.cx(qr[0], qr[1])
circ.cx(qr[2], qr[3])
circ.measure(qr[0], cr[0])
circ.measure(qr[1], cr[1])
circ.measure(qr[2], cr[2])
circ.measure(qr[3], cr[3])
dag = circuit_to_dag(circ)
# ┌─┐┌───┐ ┌─┐
# q_0: |0>─────────────────■──────────────────┤M├┤ H ├──■─────┤M├
# ┌───┐ │ └╥┘└───┘┌─┴─┐┌─┐└╥┘
# q_1: |0>──■───────┤ H ├──┼───────────────────╫──────┤ X ├┤M├─╫─
# ┌─┴─┐┌───┐└───┘ │ ┌─┐ ║ └───┘└╥┘ ║
# q_2: |0>┤ X ├┤ H ├───────┼─────────■─────┤M├─╫────────────╫──╫─
# └───┘└───┘ ┌─┴─┐┌───┐┌─┴─┐┌─┐└╥┘ ║ ║ ║
# q_3: |0>───────────────┤ X ├┤ H ├┤ X ├┤M├─╫──╫────────────╫──╫─
# └───┘└───┘└───┘└╥┘ ║ ║ ║ ║
# c_0: 0 ═══════════════════════════════╬══╬══╩════════════╬══╩═
# ║ ║ ║
# c_1: 0 ═══════════════════════════════╬══╬═══════════════╩════
# ║ ║
# c_2: 0 ═══════════════════════════════╬══╩════════════════════
# ║
# c_3: 0 ═══════════════════════════════╩═══════════════════════
#
# ┌─┐┌───┐ ┌─┐
# q_0: |0>────────────────────■──┤M├┤ H ├──────────────────■──┤M├──────
# ┌─┴─┐└╥┘└───┘┌───┐┌───┐ ┌─┴─┐└╥┘┌─┐
# q_1: |0>──■───X───────────┤ X ├─╫──────┤ H ├┤ X ├─X────┤ X ├─╫─┤M├───
# ┌─┴─┐ │ ┌───┐└───┘ ║ └───┘└─┬─┘ │ └───┘ ║ └╥┘┌─┐
# q_2: |0>┤ X ├─┼──────┤ H ├──────╫─────────────■───┼──────────╫──╫─┤M├
# └───┘ │ ┌───┐└───┘ ║ │ ┌─┐ ║ ║ └╥┘
# q_3: |0>──────X─┤ H ├───────────╫─────────────────X─┤M├──────╫──╫──╫─
# └───┘ ║ └╥┘ ║ ║ ║
# c_0: 0 ════════════════════════╩════════════════════╬═══════╩══╬══╬═
# ║ ║ ║
# c_1: 0 ═════════════════════════════════════════════╬══════════╩══╬═
# ║ ║
# c_2: 0 ═════════════════════════════════════════════╬═════════════╩═
# ║
# c_3: 0 ═════════════════════════════════════════════╩═══════════════
#
#
# 2
# |
# 0 - 1 - 3
# Build the expected output to verify the pass worked
expected = QuantumCircuit(qr, cr)
expected.cx(qr[1], qr[2])
expected.h(qr[2])
expected.swap(qr[0], qr[1])
expected.h(qr[0])
expected.cx(qr[1], qr[3])
expected.h(qr[3])
expected.measure(qr[1], cr[0])
expected.swap(qr[1], qr[3])
expected.cx(qr[2], qr[1])
expected.h(qr[3])
expected.swap(qr[0], qr[1])
expected.measure(qr[2], cr[2])
expected.cx(qr[3], qr[1])
expected.measure(qr[0], cr[3])
expected.measure(qr[3], cr[0])
expected.measure(qr[1], cr[1])
expected_dag = circuit_to_dag(expected)
# Run the pass on the dag from the input circuit
pass_ = StochasticSwap(coupling, 20, 999)
after = pass_.run(dag)
# Verify the output of the pass matches our expectation
assert expected_dag == after
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import QuantumCircuit
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import NormalDistribution
# can be used in case a principal component analysis has been done to derive the uncertainty model, ignored in this example.
A = np.eye(2)
b = np.zeros(2)
# specify the number of qubits that are used to represent the different dimenions of the uncertainty model
num_qubits = [2, 2]
# specify the lower and upper bounds for the different dimension
low = [0, 0]
high = [0.12, 0.24]
mu = [0.12, 0.24]
sigma = 0.01 * np.eye(2)
# construct corresponding distribution
bounds = list(zip(low, high))
u = NormalDistribution(num_qubits, mu, sigma, bounds)
# plot contour of probability density function
x = np.linspace(low[0], high[0], 2 ** num_qubits[0])
y = np.linspace(low[1], high[1], 2 ** num_qubits[1])
z = u.probabilities.reshape(2 ** num_qubits[0], 2 ** num_qubits[1])
plt.contourf(x, y, z)
plt.xticks(x, size=15)
plt.yticks(y, size=15)
plt.grid()
plt.xlabel("$r_1$ (%)", size=15)
plt.ylabel("$r_2$ (%)", size=15)
plt.colorbar()
plt.show()
# specify cash flow
cf = [1.0, 2.0]
periods = range(1, len(cf) + 1)
# plot cash flow
plt.bar(periods, cf)
plt.xticks(periods, size=15)
plt.yticks(size=15)
plt.grid()
plt.xlabel("periods", size=15)
plt.ylabel("cashflow ($)", size=15)
plt.show()
# estimate real value
cnt = 0
exact_value = 0.0
for x1 in np.linspace(low[0], high[0], pow(2, num_qubits[0])):
for x2 in np.linspace(low[1], high[1], pow(2, num_qubits[1])):
prob = u.probabilities[cnt]
for t in range(len(cf)):
# evaluate linear approximation of real value w.r.t. interest rates
exact_value += prob * (
cf[t] / pow(1 + b[t], t + 1)
- (t + 1) * cf[t] * np.dot(A[:, t], np.asarray([x1, x2])) / pow(1 + b[t], t + 2)
)
cnt += 1
print("Exact value: \t%.4f" % exact_value)
# specify approximation factor
c_approx = 0.125
# create fixed income pricing application
from qiskit_finance.applications.estimation import FixedIncomePricing
fixed_income = FixedIncomePricing(
num_qubits=num_qubits,
pca_matrix=A,
initial_interests=b,
cash_flow=cf,
rescaling_factor=c_approx,
bounds=bounds,
uncertainty_model=u,
)
fixed_income._objective.draw()
fixed_income_circ = QuantumCircuit(fixed_income._objective.num_qubits)
# load probability distribution
fixed_income_circ.append(u, range(u.num_qubits))
# apply function
fixed_income_circ.append(fixed_income._objective, range(fixed_income._objective.num_qubits))
fixed_income_circ.draw()
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
# construct amplitude estimation
problem = fixed_income.to_estimation_problem()
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (fixed_income.interpret(result)))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/brunorijsman/qiskit-cheat-sheet
|
brunorijsman
|
from qiskit import *
from qiskit.visualization import *
from math import *
# A simple example Quantum Circuit that is used in many code snippets below
example_qc = QuantumCircuit(2, 1)
example_qc.h(0)
example_qc.cx(0, 1)
example_qc.measure(1, 0)
None
# Specify number of qubits and classical bits
qc = QuantumCircuit(2, 1) # Quantum circuit with 2 qubits and 1 classical bit
# In any of these examples add qc.draw() at the end to see better what is happening:
# qc.draw()
# Specify only number of qubits
# Number of classical bits is zero by default
qc = QuantumCircuit(2) # Quantum circuit with 2 qubits, and 0 classical bits
# Quantum circuit with two quantum registers (a and b) and one classical register (c)
a = QuantumRegister(2, "a") # 2 qubits in register, name is "a"
b = QuantumRegister(3, "b") # 3 qubits in register, name is "b"
c = ClassicalRegister(1, "c") # 1 classical bit in register, name is "c"
qc = QuantumCircuit(a, b, c) # Quantum circuit with register a, b, and c
# Give a name to the quantum circuit (not shown in draw or print)
qc = QuantumCircuit(2, 2, name="my-quantum-circuit")
# Apply a global phase to the quantum circuit
# This is reported in draw() and print() and this is relevant when composing circuits
qc = QuantumCircuit(2, 2, global_phase=pi/4)
# Initialize to state provided as explicit vector
qc = QuantumCircuit(2)
qc.initialize([1, 0], 0) # Initialize qubit number 0 to [1, 0] = |0>
qc.initialize([0, 1], 1) # Initialize qubit number 1 to [0, 1] = |1>
# Many example end with "None" to avoid printing the return value of the last statement
# In this case, qc.intialize() returns an InstructionSet object
None
# Reset qubit
qc = QuantumCircuit(1)
qc.reset(0)
None
# Initalize to string label
# TODO: This is supposed to work, but it throws an exception
# qc = QuantumCircuit(2)
# qc.initialize('01', qc.qubits) # Initialize qubit 0 to |1> and qubit 1 to |0>
# qc.initialize('+-', qc.qubits) # Initialize qubit 0 to |+> and qubit 1 to |->
# qc.initialize('rl', qc.qubits) # Initialize qubit 0 to |r> = |i> and qubit 1 to |l> = |-i>
None
# Apply a gate to a single qubit
qc = QuantumCircuit(1)
qc.x(0) # Apply X = NOT gate to qubit number 0
None # qc.x function returns an InstructionSet which I don't want to be printed
# Apply a gate to two qubits
qc = QuantumCircuit(2)
qc.cx(0, 1) # Apply CX = controlled X = controlled NOT gate, qubit 0 is control, qubit 1 is target
None
# Apply a gate to three qubits
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2) # Apply CCX = controlled controlled X = Toffoli gate, qubits 0 and 1 are control, qubit 2 is target
None
# Single qubit gates
qc = QuantumCircuit(1)
qc.x(0) # X gate = NOT gate = 180 degree rotation around X-axis
qc.y(0) # Y gate = 180 degree rotation around Y-axis
qc.z(0) # Z gate = 180 degree rotation around Z-axis
qc.s(0) # S gate = 90 degree positive rotation around Z-axis
qc.sdg(0) # S-dagger gate = 90 degree negative rotation around Z-axis
qc.t(0) # T gate = 45 degree positive rotation around Z-axis
qc.tdg(0) # T-dagger gate = 45 degree negative rotation around Z-axis
qc.h(0) # H gate = Hadamard gate
qc.i(0) # I gate = Identity gate (does nothing)
qc.id(0) # Identity gate (synonym for I gate)
# Parameterized gates
qc.p(pi/4, 0) # P gate = Phase gate: first argument is phase
qc.rx(pi/4, 0) # Rotate around X-axis by some angle
qc.ry(pi/4, 0) # Rotate around Y-axis by some angle
qc.rz(pi/4, 0) # Rotate around Z-axis by some angle
None
# Two qubit gates
qc = QuantumCircuit(2)
# "True" two qubit gates
qc.swap(0, 1) # Swap gate
qc.iswap(0, 1) # Iswap gate
# Controlled single qubit gates
# First argument is control qubit second argument is target qubit
qc.cx(0, 1) # Controlled-X = Controlled-NOT
qc.cnot(0, 1) # Controller-NOT = Controlled-X (synonym for cx)
qc.cy(0, 1) # Controlled-Y
qc.cz(0, 1) # Controlled-Z (Note control and target are symmetric due to phase kick-back)
qc.ch(0, 1) # Controlled-H = Controlled-Hadamard
# Controlled rotations around various axes / controlled phase
# First arg is phase, second is control qubit, third is target qubit
qc.crx(pi/8, 0, 1) # Controlled rotation around x-axis
qc.cry(pi/8, 0, 1) # Controlled rotation around y-axis
qc.crz(pi/8, 0, 1) # Controlled rotation around z-axis
qc.cp(pi/8, 0, 1) # Controlled-Phase
qc.csx(0, 1) # Controlled-SX gate = Controlled square-root-of-X gate
None
# Three qubit gates
# Double controlled single qubit gates
# First and second argument are control qubits, third argument is target qubit
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2) # Controlled-controlled-X = controlled-controlled-NOT = Tofolli gate
# Controlled two qubit gates
# First argument is control qubit, second and third argument are target qubits
qc.cswap(0, 1, 2) # Controlled-swap
qc.fredkin(0, 1, 2) # Fredkin gate = synonym for controlled-swap
None
# TODO: more gates
# cu gate
# cu1 gate
# cu3 gate
# dcx gate
# ecr gate
# mcp gate
# mcrx gate
# mcry gate
# mcrz gate
# mct gate
# mcu1 gate
# mcx gate
# ms gate
# pauli gate
# r gate
# rccx gate
# rcccx gate
# rv gate
# rxx gate
# ryy gate
# rzz gate
# rzx gate
# sx gate
# sxdg gate
# u gate
# u1 gate
# u2 gate
# uc gate
# ucrx gate
# ucry gate
# ucrz gate
# Measure one qubit in existing classical bit
# Measure qubit number 0 into classical bit number 0
qc = QuantumCircuit(1, 1)
qc.measure(0, 0)
None
# Measure multiple qubits into multiple existing classical bits
# Measure qubit number 0 into classical bit number 0, and qubit number 1 into classical bit number 1
qc = QuantumCircuit(2, 2)
qc.measure([0, 1], [0, 1])
None
# Measure quantum register into existing classical register
quantum_register = QuantumRegister(2)
classical_register = ClassicalRegister(2)
qc = QuantumCircuit(quantum_register, classical_register)
qc.measure(quantum_register, classical_register)
None
# Create barrier and measure all qubits into newly created classical bits "meas"
qc = QuantumCircuit(2)
qc.measure_all()
None
# Create barrier and measure all qubits that have at least one gate into newly created classical bits "meas"
qc = QuantumCircuit(2)
qc.x(0)
qc.measure_active()
None
# Use Python control logic to procedurally generate a circuit
nr_qubits = 6
qc = QuantumCircuit(nr_qubits)
for i in range(nr_qubits-1):
qc.h(i)
qc.cx(i, nr_qubits-1)
# Draw a quantum circuit
example_qc.draw()
# Draw multiple quantum circuits
# Without the display calls, only the last draw is shown
display(example_qc.draw())
display(example_qc.draw())
# Draw a scaled quantum circuit
example_qc.draw(scale=0.5)
# Draw a quantum circuit as text
example_qc.draw(output="text")
# Print a quantum circuit (same as draw as text)
print(example_qc)
# Execute by invoking execute method, passing in quantum circuit and backend
backend = Aer.get_backend("qasm_simulator")
job = execute(example_qc, backend)
result = job.result()
# Execute by compiling to object code and then invoking backend run method, passing in object code
backend = Aer.get_backend("qasm_simulator")
qobj = assemble(example_qc)
job = backend.run(qobj)
result = job.result()
# Features of qasm_simulator backend:
# - Simulates a real (noisy) hardware device
# - No access to state vector, only to measurement results
# - TODO: more
backend = Aer.get_backend("qasm_simulator") # Note: synonymous with "aer_simulator" TODO: is that so?
result = execute(example_qc, backend).result()
# Features of statevector_simulator backend:
# - TODO
backend = Aer.get_backend("statevector_simulator") # Note: synonymous with "aer_simulator_statevector"
result = execute(example_qc, backend).result()
# Features of unitary_simulator backend:
# - TODO
backend = Aer.get_backend("unitary_simulator") # Note: synonymous with "aer_simulator_unitary"
result = execute(example_qc, backend).result()
# Plot histogram of measurement results
# Available with all backends
backend = Aer.get_backend("qasm_simulator")
job = execute(example_qc, backend)
result = job.result()
counts = result.get_counts()
plot_histogram(counts)
# Plot Bloch multivector for a quantum state
# Only available on backends where the internal statevector is available
backend = Aer.get_backend("statevector_simulator")
job = execute(example_qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_bloch_multivector(statevector)
# Plot a state city for a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_city(statevector)
# Plot a hinton diagram for the density matrix of a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_hinton(statevector)
# Plot the paulivec representation of a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_paulivec(statevector)
# Plot the qsphere representation of a quantum state
# Only available on backends where the internal statevector is available
qc = QuantumCircuit(2)
qc.h(0)
qc.z(0)
qc.cx(0, 1)
backend = Aer.get_backend("statevector_simulator")
job = execute(qc, backend)
result = job.result()
statevector = result.get_statevector()
plot_state_qsphere(statevector)
# TODO: Schedule a jon on real hardware
# TODO: Monitor progress of a job
# TODO: Gate class, circuit to gate, ...
# TODO: classes Parameter, ParameterVector, ParameterExpression,
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
from dwave.system import DWaveSampler, EmbeddingComposite
import dimod
import dwave.inspector
# select quadratic program to solve
qp = QuadraticProgram()
qp.read_from_lp_file("example.lp")
qubo = QuadraticProgramToQubo().convert(qp)
bqm_binary = dimod.as_bqm(qubo.objective.linear.to_array(), qubo.objective.quadratic.to_array(), dimod.BINARY)
print(qp)
print(bqm_binary)
bqm_ising = bqm_binary.to_ising()
print("Ising Model form coefficients:")
print(bqm_ising)
sampler = EmbeddingComposite(DWaveSampler())
res = sampler.sample(bqm_binary, label="example_qubo_3_1024", num_reads=1024)
res.to_pandas_dataframe()
dwave.inspector.show(res) # this is a good looking one
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import QuantumCircuit
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(
num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high)
)
# plot probability distribution
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel("Spot Price at Maturity $S_T$ (\$)", size=15)
plt.ylabel("Probability ($\%$)", size=15)
plt.show()
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 1.896
# set the approximation scaling for the payoff function
c_approx = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [0, 1]
offsets = [0, 0]
f_min = 0
f_max = high - strike_price
european_call_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
rescaling_factor=c_approx,
)
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
num_qubits = european_call_objective.num_qubits
european_call = QuantumCircuit(num_qubits)
european_call.append(uncertainty_model, range(num_uncertainty_qubits))
european_call.append(european_call_objective, range(num_qubits))
# draw the circuit
european_call.draw()
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.maximum(0, x - strike_price)
plt.plot(x, y, "ro-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Spot Price", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value (normalized to the [0, 1] interval)
exact_value = np.dot(uncertainty_model.probabilities, y)
exact_delta = sum(uncertainty_model.probabilities[x >= strike_price])
print("exact expected value:\t%.4f" % exact_value)
print("exact delta value: \t%.4f" % exact_delta)
european_call.draw()
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_call,
objective_qubits=[3],
post_processing=european_call_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (result.estimation_processed))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
from qiskit_finance.applications.estimation import EuropeanCallPricing
european_call_pricing = EuropeanCallPricing(
num_state_qubits=num_uncertainty_qubits,
strike_price=strike_price,
rescaling_factor=c_approx,
bounds=(low, high),
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" % exact_value)
print("Estimated value: \t%.4f" % (european_call_pricing.interpret(result)))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
from qiskit_finance.applications.estimation import EuropeanCallDelta
european_call_delta = EuropeanCallDelta(
num_state_qubits=num_uncertainty_qubits,
strike_price=strike_price,
bounds=(low, high),
uncertainty_model=uncertainty_model,
)
european_call_delta._objective.decompose().draw()
european_call_delta_circ = QuantumCircuit(european_call_delta._objective.num_qubits)
european_call_delta_circ.append(uncertainty_model, range(num_uncertainty_qubits))
european_call_delta_circ.append(
european_call_delta._objective, range(european_call_delta._objective.num_qubits)
)
european_call_delta_circ.draw()
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = european_call_delta.to_estimation_problem()
# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result_delta = ae_delta.estimate(problem)
conf_int = np.array(result_delta.confidence_interval_processed)
print("Exact delta: \t%.4f" % exact_delta)
print("Esimated value: \t%.4f" % european_call_delta.interpret(result_delta))
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/mathelatics/QGSS-2023-From-Theory-to-Implementations
|
mathelatics
|
import numpy as np
from qiskit import BasicAer
from qiskit.transpiler import PassManager
from qiskit.aqua import QuantumInstance
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver, IQPE
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.circuit.library import TwoLocal
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua.components.initial_states.var_form_based import VarFormBased
pauli_dict = {
'paulis': [{"coeff": {"imag": 0.0, "real": -1.052373245772859}, "label": "II"},
{"coeff": {"imag": 0.0, "real": 0.39793742484318045}, "label": "IZ"},
{"coeff": {"imag": 0.0, "real": -0.39793742484318045}, "label": "ZI"},
{"coeff": {"imag": 0.0, "real": -0.01128010425623538}, "label": "ZZ"},
{"coeff": {"imag": 0.0, "real": 0.18093119978423156}, "label": "XX"}
]
}
qubit_op = WeightedPauliOperator.from_dict(pauli_dict)
result_reference = NumPyMinimumEigensolver(qubit_op).run()
print('The reference ground energy level is {}.'.format(result_reference.eigenvalue.real))
random_seed = 0
np.random.seed(random_seed)
backend = BasicAer.get_backend('qasm_simulator')
var_form_depth = 3
var_form = TwoLocal(qubit_op.num_qubits, ['ry', 'rz'], 'cz', reps=var_form_depth)
spsa_max_trials=10
optimizer = SPSA(max_trials=spsa_max_trials)
vqe = VQE(qubit_op, var_form, optimizer)
quantum_instance = QuantumInstance(backend)
result_vqe = vqe.run(quantum_instance)
print('VQE estimated the ground energy to be {}.'.format(result_vqe.eigenvalue.real))
state_in = VarFormBased(var_form, result_vqe.optimal_point)
num_time_slices = 1
num_iterations = 6
iqpe = IQPE(qubit_op, state_in, num_time_slices, num_iterations,
expansion_mode='suzuki', expansion_order=2,
shallow_circuit_concat=True)
quantum_instance = QuantumInstance(backend, shots=100, seed_simulator=random_seed, seed_transpiler=random_seed)
result_iqpe = iqpe.run(quantum_instance)
print("Continuing with VQE's result, IQPE estimated the ground energy to be {}.".format(
result_iqpe.eigenvalue.real))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_hinton
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0,1)
qc.ry(np.pi/3 , 0)
qc.rx(np.pi/5, 1)
state = DensityMatrix(qc)
plot_state_hinton(state, title="New Hinton Plot")
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
10*15+13*125, 10*15-27*125
def euclides_gcd(a,b):
if b > a: # put in increasing order
t = a; a = b; b = t
if a == b or a%b == 0: # test equality or null remainder
return b
r = a%b
print('a =', a, ', b =', b, ', k =', a//b, ', r =', r)
while r != 0:
a = b; b = r
gcd = b
r = a%b
print('a =', a, ', b =', b, ', k =', a//b, ', r =', r)
return b
import math
a = 6825; b = 1430; egcd = euclides_gcd(a,b)
print('euclides_gcd('+str(a)+','+str(b)+')=',egcd, ', python_gcd = ', math.gcd(a,b))
-9*6825 + 43*1430 # ok!
a = 126; p = 23; a%p, (a**p)%p, (a**(p-1))%p
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# 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.
"""Assembler Test."""
import unittest
import numpy as np
from numpy.testing import assert_allclose
from qiskit import pulse
from qiskit.compiler.assembler import assemble
from qiskit.assembler.disassemble import disassemble
from qiskit.assembler.run_config import RunConfig
from qiskit.circuit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.circuit import Gate, Instruction, Parameter
from qiskit.circuit.library import RXGate
from qiskit.pulse.transforms import target_qobj_transform
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import FakeOpenPulse2Q
import qiskit.quantum_info as qi
def _parametric_to_waveforms(schedule):
instructions = list(schedule.instructions)
for i, time_instruction_tuple in enumerate(schedule.instructions):
time, instruction = time_instruction_tuple
if not isinstance(instruction.pulse, pulse.library.Waveform):
new_inst = pulse.Play(instruction.pulse.get_waveform(), instruction.channel)
instructions[i] = (time, new_inst)
return tuple(instructions)
class TestQuantumCircuitDisassembler(QiskitTestCase):
"""Tests for disassembling circuits to qobj."""
def test_disassemble_single_circuit(self):
"""Test disassembling a single circuit."""
qr = QuantumRegister(2, name="q")
cr = ClassicalRegister(2, name="c")
circ = QuantumCircuit(qr, cr, name="circ")
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.measure(qr, cr)
qubit_lo_freq = [5e9, 5e9]
meas_lo_freq = [6.7e9, 6.7e9]
qobj = assemble(
circ,
shots=2000,
memory=True,
qubit_lo_freq=qubit_lo_freq,
meas_lo_freq=meas_lo_freq,
)
circuits, run_config_out, headers = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(run_config_out.shots, 2000)
self.assertEqual(run_config_out.memory, True)
self.assertEqual(run_config_out.qubit_lo_freq, qubit_lo_freq)
self.assertEqual(run_config_out.meas_lo_freq, meas_lo_freq)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], circ)
self.assertEqual({}, headers)
def test_disassemble_multiple_circuits(self):
"""Test disassembling multiple circuits, all should have the same config."""
qr0 = QuantumRegister(2, name="q0")
qc0 = ClassicalRegister(2, name="c0")
circ0 = QuantumCircuit(qr0, qc0, name="circ0")
circ0.h(qr0[0])
circ0.cx(qr0[0], qr0[1])
circ0.measure(qr0, qc0)
qr1 = QuantumRegister(3, name="q1")
qc1 = ClassicalRegister(3, name="c1")
circ1 = QuantumCircuit(qr1, qc1, name="circ0")
circ1.h(qr1[0])
circ1.cx(qr1[0], qr1[1])
circ1.cx(qr1[0], qr1[2])
circ1.measure(qr1, qc1)
qobj = assemble([circ0, circ1], shots=100, memory=False, seed=6)
circuits, run_config_out, headers = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 3)
self.assertEqual(run_config_out.memory_slots, 3)
self.assertEqual(run_config_out.shots, 100)
self.assertEqual(run_config_out.memory, False)
self.assertEqual(run_config_out.seed, 6)
self.assertEqual(len(circuits), 2)
for circuit in circuits:
self.assertIn(circuit, [circ0, circ1])
self.assertEqual({}, headers)
def test_disassemble_no_run_config(self):
"""Test disassembling with no run_config, relying on default."""
qr = QuantumRegister(2, name="q")
qc = ClassicalRegister(2, name="c")
circ = QuantumCircuit(qr, qc, name="circ")
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.measure(qr, qc)
qobj = assemble(circ)
circuits, run_config_out, headers = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], circ)
self.assertEqual({}, headers)
def test_disassemble_initialize(self):
"""Test disassembling a circuit with an initialize."""
q = QuantumRegister(2, name="q")
circ = QuantumCircuit(q, name="circ")
circ.initialize([1 / np.sqrt(2), 0, 0, 1 / np.sqrt(2)], q[:])
qobj = assemble(circ)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 0)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], circ)
self.assertEqual({}, header)
def test_disassemble_isometry(self):
"""Test disassembling a circuit with an isometry."""
q = QuantumRegister(2, name="q")
circ = QuantumCircuit(q, name="circ")
circ.iso(qi.random_unitary(4).data, circ.qubits, [])
qobj = assemble(circ)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 0)
self.assertEqual(len(circuits), 1)
# params array
assert_allclose(circuits[0]._data[0].operation.params[0], circ._data[0].operation.params[0])
# all other data
self.assertEqual(
circuits[0]._data[0].operation.params[1:], circ._data[0].operation.params[1:]
)
self.assertEqual(circuits[0]._data[0].qubits, circ._data[0].qubits)
self.assertEqual(circuits[0]._data[0].clbits, circ._data[0].clbits)
self.assertEqual(circuits[0]._data[1:], circ._data[1:])
self.assertEqual({}, header)
def test_opaque_instruction(self):
"""Test the disassembler handles opaque instructions correctly."""
opaque_inst = Instruction(name="my_inst", num_qubits=4, num_clbits=2, params=[0.5, 0.4])
q = QuantumRegister(6, name="q")
c = ClassicalRegister(4, name="c")
circ = QuantumCircuit(q, c, name="circ")
circ.append(opaque_inst, [q[0], q[2], q[5], q[3]], [c[3], c[0]])
qobj = assemble(circ)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 6)
self.assertEqual(run_config_out.memory_slots, 4)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], circ)
self.assertEqual({}, header)
def test_circuit_with_conditionals(self):
"""Verify disassemble sets conditionals correctly."""
qr = QuantumRegister(2)
cr1 = ClassicalRegister(1)
cr2 = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr1, cr2)
qc.measure(qr[0], cr1) # Measure not required for a later conditional
qc.measure(qr[1], cr2[1]) # Measure required for a later conditional
qc.h(qr[1]).c_if(cr2, 3)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 3)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def test_circuit_with_simple_conditional(self):
"""Verify disassemble handles a simple conditional on the only bits."""
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0]).c_if(cr, 1)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 1)
self.assertEqual(run_config_out.memory_slots, 1)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def test_circuit_with_single_bit_conditions(self):
"""Verify disassemble handles a simple conditional on a single bit of a register."""
# This circuit would fail to perfectly round-trip if 'cr' below had only one bit in it.
# This is because the format of QasmQobj is insufficient to disambiguate single-bit
# conditions from conditions on registers with only one bit. Since single-bit conditions are
# mostly a hack for the QasmQobj format at all, `disassemble` always prefers to return the
# register if it can. It would also fail if registers overlap.
qr = QuantumRegister(1)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0]).c_if(cr[0], 1)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, len(qr))
self.assertEqual(run_config_out.memory_slots, len(cr))
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def test_circuit_with_mcx(self):
"""Verify disassemble handles mcx gate - #6271."""
qr = QuantumRegister(5)
cr = ClassicalRegister(5)
qc = QuantumCircuit(qr, cr)
qc.mcx([0, 1, 2], 4)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 5)
self.assertEqual(run_config_out.memory_slots, 5)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def test_multiple_conditionals_multiple_registers(self):
"""Verify disassemble handles multiple conditionals and registers."""
qr = QuantumRegister(3)
cr1 = ClassicalRegister(3)
cr2 = ClassicalRegister(5)
cr3 = ClassicalRegister(6)
cr4 = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr1, cr2, cr3, cr4)
qc.x(qr[1])
qc.h(qr)
qc.cx(qr[1], qr[0]).c_if(cr3, 14)
qc.ccx(qr[0], qr[2], qr[1]).c_if(cr4, 1)
qc.h(qr).c_if(cr1, 3)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 3)
self.assertEqual(run_config_out.memory_slots, 15)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def test_circuit_with_bit_conditional_1(self):
"""Verify disassemble handles conditional on a single bit."""
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
qc.h(qr[0]).c_if(cr[1], True)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def test_circuit_with_bit_conditional_2(self):
"""Verify disassemble handles multiple single bit conditionals."""
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
cr1 = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr, cr1)
qc.h(qr[0]).c_if(cr1[1], False)
qc.h(qr[1]).c_if(cr[0], True)
qc.cx(qr[0], qr[1]).c_if(cr1[0], False)
qobj = assemble(qc)
circuits, run_config_out, header = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.n_qubits, 2)
self.assertEqual(run_config_out.memory_slots, 4)
self.assertEqual(len(circuits), 1)
self.assertEqual(circuits[0], qc)
self.assertEqual({}, header)
def assertCircuitCalibrationsEqual(self, in_circuits, out_circuits):
"""Verify circuit calibrations are equivalent pre-assembly and post-disassembly"""
self.assertEqual(len(in_circuits), len(out_circuits))
for in_qc, out_qc in zip(in_circuits, out_circuits):
in_cals = in_qc.calibrations
out_cals = out_qc.calibrations
self.assertEqual(in_cals.keys(), out_cals.keys())
for gate_name in in_cals:
self.assertEqual(in_cals[gate_name].keys(), out_cals[gate_name].keys())
for gate_params, in_sched in in_cals[gate_name].items():
out_sched = out_cals[gate_name][gate_params]
self.assertEqual(*map(_parametric_to_waveforms, (in_sched, out_sched)))
def test_single_circuit_calibrations(self):
"""Test that disassembler parses single circuit QOBJ calibrations (from QOBJ-level)."""
theta = Parameter("theta")
qc = QuantumCircuit(2)
qc.h(0)
qc.rx(np.pi, 0)
qc.rx(theta, 1)
qc = qc.assign_parameters({theta: np.pi})
with pulse.build() as h_sched:
pulse.play(pulse.library.Drag(1, 0.15, 4, 2), pulse.DriveChannel(0))
with pulse.build() as x180:
pulse.play(pulse.library.Gaussian(1, 0.2, 5), pulse.DriveChannel(0))
qc.add_calibration("h", [0], h_sched)
qc.add_calibration(RXGate(np.pi), [0], x180)
qobj = assemble(qc, FakeOpenPulse2Q())
output_circuits, _, _ = disassemble(qobj)
self.assertCircuitCalibrationsEqual([qc], output_circuits)
def test_parametric_pulse_circuit_calibrations(self):
"""Test that disassembler parses parametric pulses back to pulse gates."""
with pulse.build() as h_sched:
pulse.play(pulse.library.Drag(50, 0.15, 4, 2), pulse.DriveChannel(0))
qc = QuantumCircuit(2)
qc.h(0)
qc.add_calibration("h", [0], h_sched)
backend = FakeOpenPulse2Q()
backend.configuration().parametric_pulses = ["drag"]
qobj = assemble(qc, backend)
output_circuits, _, _ = disassemble(qobj)
out_qc = output_circuits[0]
self.assertCircuitCalibrationsEqual([qc], output_circuits)
self.assertTrue(
all(
qc_sched.instructions == out_qc_sched.instructions
for (_, qc_gate), (_, out_qc_gate) in zip(
qc.calibrations.items(), out_qc.calibrations.items()
)
for qc_sched, out_qc_sched in zip(qc_gate.values(), out_qc_gate.values())
),
)
def test_multi_circuit_uncommon_calibrations(self):
"""Test that disassembler parses uncommon calibrations (stored at QOBJ experiment-level)."""
with pulse.build() as sched:
pulse.play(pulse.library.Drag(50, 0.15, 4, 2), pulse.DriveChannel(0))
qc_0 = QuantumCircuit(2)
qc_0.h(0)
qc_0.append(RXGate(np.pi), [1])
qc_0.add_calibration("h", [0], sched)
qc_0.add_calibration(RXGate(np.pi), [1], sched)
qc_1 = QuantumCircuit(2)
qc_1.h(0)
circuits = [qc_0, qc_1]
qobj = assemble(circuits, FakeOpenPulse2Q())
output_circuits, _, _ = disassemble(qobj)
self.assertCircuitCalibrationsEqual(circuits, output_circuits)
def test_multi_circuit_common_calibrations(self):
"""Test that disassembler parses common calibrations (stored at QOBJ-level)."""
with pulse.build() as sched:
pulse.play(pulse.library.Drag(1, 0.15, 4, 2), pulse.DriveChannel(0))
qc_0 = QuantumCircuit(2)
qc_0.h(0)
qc_0.append(RXGate(np.pi), [1])
qc_0.add_calibration("h", [0], sched)
qc_0.add_calibration(RXGate(np.pi), [1], sched)
qc_1 = QuantumCircuit(2)
qc_1.h(0)
qc_1.add_calibration(RXGate(np.pi), [1], sched)
circuits = [qc_0, qc_1]
qobj = assemble(circuits, FakeOpenPulse2Q())
output_circuits, _, _ = disassemble(qobj)
self.assertCircuitCalibrationsEqual(circuits, output_circuits)
def test_single_circuit_delay_calibrations(self):
"""Test that disassembler parses delay instruction back to delay gate."""
qc = QuantumCircuit(2)
qc.append(Gate("test", 1, []), [0])
test_sched = pulse.Delay(64, pulse.DriveChannel(0)) + pulse.Delay(
160, pulse.DriveChannel(0)
)
qc.add_calibration("test", [0], test_sched)
qobj = assemble(qc, FakeOpenPulse2Q())
output_circuits, _, _ = disassemble(qobj)
self.assertEqual(len(qc.calibrations), len(output_circuits[0].calibrations))
self.assertEqual(qc.calibrations.keys(), output_circuits[0].calibrations.keys())
self.assertTrue(
all(
qc_cal.keys() == out_qc_cal.keys()
for qc_cal, out_qc_cal in zip(
qc.calibrations.values(), output_circuits[0].calibrations.values()
)
)
)
self.assertEqual(
qc.calibrations["test"][((0,), ())], output_circuits[0].calibrations["test"][((0,), ())]
)
class TestPulseScheduleDisassembler(QiskitTestCase):
"""Tests for disassembling pulse schedules to qobj."""
def setUp(self):
super().setUp()
self.backend = FakeOpenPulse2Q()
self.backend_config = self.backend.configuration()
self.backend_config.parametric_pulses = ["constant", "gaussian", "gaussian_square", "drag"]
def test_disassemble_single_schedule(self):
"""Test disassembling a single schedule."""
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build(self.backend) as sched:
with pulse.align_right():
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.set_phase(1.0, d0)
pulse.shift_phase(3.11, d0)
pulse.set_frequency(1e9, d0)
pulse.shift_frequency(1e7, d0)
pulse.delay(20, d0)
pulse.delay(10, d1)
pulse.play(pulse.library.Constant(8, 0.1), d1)
pulse.measure_all()
qobj = assemble(sched, backend=self.backend, shots=2000)
scheds, run_config_out, _ = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(run_config_out.shots, 2000)
self.assertEqual(run_config_out.memory, False)
self.assertEqual(run_config_out.meas_level, 2)
self.assertEqual(run_config_out.meas_lo_freq, self.backend.defaults().meas_freq_est)
self.assertEqual(run_config_out.qubit_lo_freq, self.backend.defaults().qubit_freq_est)
self.assertEqual(run_config_out.rep_time, 99)
self.assertEqual(len(scheds), 1)
self.assertEqual(scheds[0], target_qobj_transform(sched))
def test_disassemble_multiple_schedules(self):
"""Test disassembling multiple schedules, all should have the same config."""
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build(self.backend) as sched0:
with pulse.align_right():
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.set_phase(1.0, d0)
pulse.shift_phase(3.11, d0)
pulse.set_frequency(1e9, d0)
pulse.shift_frequency(1e7, d0)
pulse.delay(20, d0)
pulse.delay(10, d1)
pulse.play(pulse.library.Constant(8, 0.1), d1)
pulse.measure_all()
with pulse.build(self.backend) as sched1:
with pulse.align_right():
pulse.play(pulse.library.Constant(8, 0.1), d0)
pulse.play(pulse.library.Waveform([0.0, 1.0]), d1)
pulse.set_phase(1.1, d0)
pulse.shift_phase(3.5, d0)
pulse.set_frequency(2e9, d0)
pulse.shift_frequency(3e7, d1)
pulse.delay(20, d1)
pulse.delay(10, d0)
pulse.play(pulse.library.Constant(8, 0.4), d1)
pulse.measure_all()
qobj = assemble([sched0, sched1], backend=self.backend, shots=2000)
scheds, run_config_out, _ = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.memory_slots, 2)
self.assertEqual(run_config_out.shots, 2000)
self.assertEqual(run_config_out.memory, False)
self.assertEqual(len(scheds), 2)
self.assertEqual(scheds[0], target_qobj_transform(sched0))
self.assertEqual(scheds[1], target_qobj_transform(sched1))
def test_disassemble_parametric_pulses(self):
"""Test disassembling multiple schedules all should have the same config."""
d0 = pulse.DriveChannel(0)
with pulse.build(self.backend) as sched:
with pulse.align_right():
pulse.play(pulse.library.Constant(10, 1.0), d0)
pulse.play(pulse.library.Gaussian(10, 1.0, 2.0), d0)
pulse.play(pulse.library.GaussianSquare(10, 1.0, 2.0, 3), d0)
pulse.play(pulse.library.Drag(10, 1.0, 2.0, 0.1), d0)
qobj = assemble(sched, backend=self.backend, shots=2000)
scheds, _, _ = disassemble(qobj)
self.assertEqual(scheds[0], target_qobj_transform(sched))
def test_disassemble_schedule_los(self):
"""Test disassembling schedule los."""
d0 = pulse.DriveChannel(0)
m0 = pulse.MeasureChannel(0)
d1 = pulse.DriveChannel(1)
m1 = pulse.MeasureChannel(1)
sched0 = pulse.Schedule()
sched1 = pulse.Schedule()
schedule_los = [
{d0: 4.5e9, d1: 5e9, m0: 6e9, m1: 7e9},
{d0: 5e9, d1: 4.5e9, m0: 7e9, m1: 6e9},
]
qobj = assemble([sched0, sched1], backend=self.backend, schedule_los=schedule_los)
_, run_config_out, _ = disassemble(qobj)
run_config_out = RunConfig(**run_config_out)
self.assertEqual(run_config_out.schedule_los, schedule_los)
if __name__ == "__main__":
unittest.main(verbosity=2)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
import numpy as np
from qiskit.circuit.library import UnitaryGate
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomEigenvectorUnitaryPair, RandomUnitary, Integer
from QiskitPBT.case_studies.quantum_phase_estimation.quantum_phase_estimation import qpe_general
class LowerRegisterUnchangedByEigenvector(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
eigenvector_unitary_pair = RandomEigenvectorUnitaryPair(RandomUnitary(1, 2), 1)
estimation_qubits = Integer(1, 3)
return [eigenvector_unitary_pair, estimation_qubits]
# specify the preconditions for the test
def preconditions(self, eigenvector_unitary_pair, estimation_qubits):
return True
# specify the operations to be performed on the input
def operations(self, eigenvector_unitary_pair, estimation_qubits):
eigenvectors, unitary = eigenvector_unitary_pair
n = unitary.num_qubits
# perform qpe on with an eigenvector in lower register
qpe = qpe_general(estimation_qubits, UnitaryGate(unitary), eigenvectors[0][0])
# state should be the unchanged eigenvector
qpe2 = QuantumCircuit(n, n)
qpe2.initialize(eigenvectors[0][0], list(range(n)))
self.statistical_analysis.assert_equal(self, list(range(estimation_qubits, estimation_qubits+unitary.num_qubits)), qpe, list(range(n)), qpe2)
|
https://github.com/qiskit-community/qgss-2023
|
qiskit-community
|
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def step_1_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
qc = QuantumCircuit(qr, cr)
####### your code goes here #######
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = step_1_circuit(qr, cr)
qc.draw("mpl")
# Submit your circuit
from qc_grader.challenges.qgss_2023 import grade_lab4_ex1
grade_lab4_ex1(qc)
def step_2_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
# begin with the circuit from Step 1
qc = step_1_circuit(qr, cr)
####### your code goes here #######
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = step_2_circuit(qr, cr)
qc.draw("mpl")
# Submit your circuit
from qc_grader.challenges.qgss_2023 import grade_lab4_ex2
grade_lab4_ex2(qc)
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
counts
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def t_gate_ipe_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 3 bits
qc = QuantumCircuit(qr, cr)
####### your code goes here #######
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(3, "c")
qc = QuantumCircuit(qr, cr)
qc = t_gate_ipe_circuit(qr, cr)
qc.draw("mpl")
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
counts
# Submit your circuit
from qc_grader.challenges.qgss_2023 import grade_lab4_ex3
grade_lab4_ex3(qc)
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
qc = QuantumCircuit(qr, cr)
# Initialization
q0, q1 = qr
qc.h(q0)
qc.x(q1)
# Apply control-U operator as many times as needed to get the least significant phase bit
u_angle = 2 * np.pi / 3
k = 1
cphase_angle = u_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the first classical bit
qc.h(q0)
c0, c1 = cr
qc.measure(q0, c0)
# Reset and re-initialize the auxiliary qubit
qc.reset(q0)
qc.h(q0)
# Apply phase correction conditioned on the first classical bit
with qc.if_test((c0, 1)):
qc.p(-np.pi / 2, q0)
# Apply control-U operator as many times as needed to get the next phase bit
k = 0
cphase_angle = u_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis into the second classical bit
qc.h(q0)
qc.measure(q0, c1)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = u_circuit(qr, cr)
qc.draw("mpl")
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
print(counts)
success_probability = counts["01"] / counts.shots()
print(f"Success probability: {success_probability}")
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 1 bits
qc = QuantumCircuit(qr, cr)
# Initialization
q0, q1 = qr
qc.h(q0)
qc.x(q1)
# Apply control-U operator as many times as needed to get the least significant phase bit
u_angle = 2 * np.pi / 3
k = 1
cphase_angle = u_angle * 2**k
qc.cp(cphase_angle, q0, q1)
# Measure the auxiliary qubit in x-basis
qc.h(q0)
(c0,) = cr
qc.measure(q0, c0)
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(1, "c")
qc = QuantumCircuit(qr, cr)
qc = u_circuit(qr, cr)
qc.draw("mpl")
job = sim.run(qc, shots=15)
result = job.result()
counts = result.get_counts()
print(counts)
step1_bit: int
####### your code goes here #######
# Submit your result
from qc_grader.challenges.qgss_2023 import grade_lab4_ex4
grade_lab4_ex4(step1_bit)
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
import numpy as np
def u_circuit(qr: QuantumRegister, cr: ClassicalRegister) -> QuantumCircuit:
# qr is a quantum register with 2 qubits
# cr is a classical register with 2 bits
qc = QuantumCircuit(qr, cr)
####### your code goes here #######
return qc
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = u_circuit(qr, cr)
qc.draw("mpl")
# Submit your result
from qc_grader.challenges.qgss_2023 import grade_lab4_ex5
grade_lab4_ex5(qc)
from qiskit_aer import AerSimulator
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
print(counts)
success_probability = counts["01"] / counts.shots()
print(f"Success probability: {success_probability}")
from qiskit.circuit import Gate
def iterative_phase_estimation(
qr: QuantumRegister,
cr: ClassicalRegister,
controlled_unitaries: list[Gate],
state_prep: Gate,
) -> QuantumCircuit:
qc = QuantumCircuit(qr, cr)
####### your code goes here #######
return qc
from qiskit.circuit.library import CPhaseGate, XGate
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
s_angle = np.pi / 2
controlled_unitaries = [CPhaseGate(s_angle * 2**k) for k in range(2)]
qc = iterative_phase_estimation(qr, cr, controlled_unitaries, XGate())
sim = AerSimulator()
job = sim.run(qc, shots=1000)
result = job.result()
counts = result.get_counts()
counts
from qiskit_ibm_provider import IBMProvider
provider = IBMProvider()
hub = "YOUR_HUB"
group = "YOUR_GROUP"
project = "YOUR_PROJECT"
backend_name = "ibmq_manila"
backend = provider.get_backend(backend_name, instance=f"{hub}/{group}/{project}")
from qiskit import transpile
qr = QuantumRegister(2, "q")
cr = ClassicalRegister(2, "c")
qc = QuantumCircuit(qr, cr)
qc = step_2_circuit(qr, cr)
qc_transpiled = transpile(qc, backend)
job = backend.run(qc_transpiled, shots=1000, dynamic=True)
job_id = job.job_id()
print(job_id)
retrieve_job = provider.retrieve_job(job_id)
retrieve_job.status()
from qiskit.tools.visualization import plot_histogram
counts = retrieve_job.result().get_counts()
plot_histogram(counts)
|
https://github.com/GIRISHBELANI/QC_Benchmarks_using_dm-simulator
|
GIRISHBELANI
|
"""
HHL Benchmark Program - Qiskit (KM initial version 220402)
TODO:
- switch from total variation distance to Hellinger fidelity
"""
import sys
import time
import numpy as np
pi = np.pi
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
import sparse_Ham_sim as shs
import uniform_controlled_rotation as ucr
# include QFT in this list, so we can refer to the QFT sub-circuit definition
#sys.path[1:1] = ["_common", "_common/qiskit", "quantum-fourier-transform/qiskit"]
#sys.path[1:1] = ["../../_common", "../../_common/qiskit", "../../quantum-fourier-transform/qiskit"]
# cannot use the QFT common yet, as HHL seems to use reverse bit order
sys.path[1:1] = ["_common", "_common/qiskit", "quantum-fourier-transform/qiskit"]
sys.path[1:1] = ["../../_common", "../../_common/qiskit", "../../quantum-fourier-transform/qiskit"]
#from qft_benchmark import qft_gate, inv_qft_gate
import execute as ex
import metrics as metrics
np.random.seed(0)
verbose = False
# Variable for number of resets to perform after mid circuit measurements
num_resets = 1
# saved circuits for display
QC_ = None
U_ = None
UI_ = None
QFT_ = None
QFTI_ = None
############### Circuit Definitions
''' replaced with code below ...
def qft_dagger(qc, clock, n):
qc.h(clock[1]);
for j in reversed(range(n)):
for k in reversed(range(j+1,n)):
qc.cu1(-np.pi/float(2**(k-j)), clock[k], clock[j]);
qc.h(clock[0]);
def qft(qc, clock, n):
qc.h(clock[0]);
for j in reversed(range(n)):
for k in reversed(range(j+1,n)):
qc.cu1(np.pi/float(2**(k-j)), clock[k], clock[j]);
qc.h(clock[1]);
'''
'''
DEVNOTE: the QFT and IQFT are defined here as they are in the QFT benchmark - almost;
Here, the sign of the angles is reversed and the QFT is actually used as the inverse QFT.
This is an inconsistency that needs to be resolved later.
The QPE part of the algorithm should be using the inverse QFT, but the qubit order is not correct.
The QFT as defined in the QFT benchmark operates on qubits in the opposite order from the HHL pattern.
'''
def initialize_state(qc, qreg, b):
""" b (int): initial basis state |b> """
n = qreg.size
b_bin = np.binary_repr(b, width=n)
for q in range(n):
if b_bin[n-1-q] == '1':
qc.x(qreg[q])
return qc
def IQFT(qc, qreg):
""" inverse QFT
qc : QuantumCircuit
qreg : QuantumRegister belonging to qc
does not include SWAP at end of the circuit
"""
n = int(qreg.size)
for i in reversed(range(n)):
for j in range(i+1,n):
phase = -pi/2**(j-i)
qc.cp(phase, qreg[i], qreg[j])
qc.h(qreg[i])
return qc
def QFT(qc, qreg):
""" QFT
qc : QuantumCircuit
qreg : QuantumRegister belonging to qc
does not include SWAP at end of circuit
"""
n = int(qreg.size)
for i in range(n):
qc.h(qreg[i])
for j in reversed(range(i+1,n)):
phase = pi/2**(j-i)
qc.cp(phase, qreg[i], qreg[j])
return qc
def inv_qft_gate(input_size, method=1):
#def qft_gate(input_size):
#global QFT_
qr = QuantumRegister(input_size);
#qc = QuantumCircuit(qr, name="qft")
qc = QuantumCircuit(qr, name="QFT†")
if method == 1:
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in range(0, input_size):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in range(0, num_crzs):
divisor = 2 ** (num_crzs - j)
#qc.crz( math.pi / divisor , qr[hidx], qr[input_size - j - 1])
##qc.crz( -np.pi / divisor , qr[hidx], qr[input_size - j - 1])
qc.cu1(-np.pi / divisor, qr[hidx], qr[input_size - j - 1]);
# followed by an H gate (applied to all qubits)
qc.h(qr[hidx])
elif method == 2:
# apply IQFT to register
for i in range(input_size)[::-1]:
for j in range(i+1,input_size):
phase = -np.pi/2**(j-i)
qc.cp(phase, qr[i], qr[j])
qc.h(qr[i])
qc.barrier()
return qc
############### Inverse QFT Circuit
def qft_gate(input_size, method=1):
#def inv_qft_gate(input_size):
#global QFTI_
qr = QuantumRegister(input_size);
#qc = QuantumCircuit(qr, name="inv_qft")
qc = QuantumCircuit(qr, name="QFT")
if method == 1:
# Generate multiple groups of diminishing angle CRZs and H gate
for i_qubit in reversed(range(0, input_size)):
# start laying out gates from highest order qubit (the hidx)
hidx = input_size - i_qubit - 1
# precede with an H gate (applied to all qubits)
qc.h(qr[hidx])
# if not the highest order qubit, add multiple controlled RZs of decreasing angle
if hidx < input_size - 1:
num_crzs = i_qubit
for j in reversed(range(0, num_crzs)):
divisor = 2 ** (num_crzs - j)
#qc.crz( -math.pi / divisor , qr[hidx], qr[input_size - j - 1])
##qc.crz( np.pi / divisor , qr[hidx], qr[input_size - j - 1])
qc.cu1( np.pi / divisor , qr[hidx], qr[input_size - j - 1])
elif method == 2:
# apply QFT to register
for i in range(input_size):
qc.h(qr[i])
for j in range(i+1, input_size):
phase = np.pi/2**(j-i)
qc.cp(phase, qr[i], qr[j])
qc.barrier()
return qc
############# Controlled U Gate
#Construct the U gates for A
def ctrl_u(exponent):
qc = QuantumCircuit(1, name=f"U^{exponent}")
for i in range(exponent):
#qc.u(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, target);
#qc.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, control, target);
qc.u(np.pi/2, -np.pi/2, np.pi/2, 0);
cu_gate = qc.to_gate().control(1)
return cu_gate, qc
#Construct the U^-1 gates for reversing A
def ctrl_ui(exponent):
qc = QuantumCircuit(1, name=f"U^-{exponent}")
for i in range(exponent):
#qc.u(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, target);
#qc.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, control, target);
qc.u(np.pi/2, np.pi/2, -np.pi/2, 0);
cu_gate = qc.to_gate().control(1)
return cu_gate, qc
############# Quantum Phase Estimation
# DEVNOTE: The QPE and IQPE methods below mirror the mechanism in Hector_Wong
# Need to investigate whether the clock qubits are in the correct, as this implementation
# seems to require the QFT be implemented in reverse also. TODO
# Append a series of Quantum Phase Estimation gates to the circuit
def qpe(qc, clock, target, extra_qubits=None, ancilla=None, A=None, method=1):
qc.barrier()
''' original code from Hector_Wong
# e^{i*A*t}
#qc.cu(np.pi/2, -np.pi/2, np.pi/2, 3*np.pi/4, clock[0], target, label='U');
# The CU gate is equivalent to a CU1 on the control bit followed by a CU3
qc.u1(3*np.pi/4, clock[0]);
qc.cu3(np.pi/2, -np.pi/2, np.pi/2, clock[0], target);
# e^{i*A*t*2}
#qc.cu(np.pi, np.pi, 0, 0, clock[1], target, label='U2');
qc.cu3(np.pi, np.pi, 0, clock[1], target);
qc.barrier();
'''
# apply series of controlled U operations to the state |1>
# does nothing to state |0>
# DEVNOTE: have not found a way to create a controlled operation that contains a U gate
# with the global phase; instead do it piecemeal for now
if method == 1:
repeat = 1
#for j in reversed(range(len(clock))):
for j in (range(len(clock))):
# create U with exponent of 1, but in a loop repeating N times
for k in range(repeat):
# this global phase is applied to clock qubit
qc.u1(3*np.pi/4, clock[j]);
# apply the rest of U controlled by clock qubit
#cp, _ = ctrl_u(repeat)
cp, _ = ctrl_u(1)
qc.append(cp, [clock[j], target])
repeat *= 2
qc.barrier();
#Define global U operator as the phase operator (for printing later)
_, U_ = ctrl_u(1)
if method == 2:
for j in range(len(clock)):
control = clock[j]
phase = -(2*np.pi)*2**j
con_H_sim = shs.control_Ham_sim(A, phase)
qubits = [control] + [q for q in target] + [q for q in extra_qubits] + [ancilla[0]]
qc.append(con_H_sim, qubits)
# Perform an inverse QFT on the register holding the eigenvalues
qc.append(inv_qft_gate(len(clock), method), clock)
# Append a series of Inverse Quantum Phase Estimation gates to the circuit
def inv_qpe(qc, clock, target, extra_qubits=None, ancilla=None, A=None, method=1):
# Perform a QFT on the register holding the eigenvalues
qc.append(qft_gate(len(clock), method), clock)
qc.barrier()
if method == 1:
''' original code from Hector_Wong
# e^{i*A*t*2}
#qc.cu(np.pi, np.pi, 0, 0, clock[1], target, label='U2');
qc.cu3(np.pi, np.pi, 0, clock[1], target);
# e^{i*A*t}
#qc.cu(np.pi/2, np.pi/2, -np.pi/2, -3*np.pi/4, clock[0], target, label='U');
# The CU gate is equivalent to a CU1 on the control bit followed by a CU3
qc.u1(-3*np.pi/4, clock[0]);
qc.cu3(np.pi/2, np.pi/2, -np.pi/2, clock[0], target);
qc.barrier()
'''
# apply inverse series of controlled U operations to the state |1>
# does nothing to state |0>
# DEVNOTE: have not found a way to create a controlled operation that contains a U gate
# with the global phase; instead do it piecemeal for now
repeat = 2 ** (len(clock) - 1)
for j in reversed(range(len(clock))):
#for j in (range(len(clock))):
# create U with exponent of 1, but in a loop repeating N times
for k in range(repeat):
# this global phase is applied to clock qubit
qc.u1(-3*np.pi/4, clock[j]);
# apply the rest of U controlled by clock qubit
#cp, _ = ctrl_u(repeat)
cp, _ = ctrl_ui(1)
qc.append(cp, [clock[j], target])
repeat = int(repeat / 2)
qc.barrier();
#Define global U operator as the phase operator (for printing later)
_, UI_ = ctrl_ui(1)
if method == 2:
for j in reversed(range(len(clock))):
control = clock[j]
phase = (2*np.pi)*2**j
con_H_sim = shs.control_Ham_sim(A, phase)
qubits = [control] + [q for q in target] + [q for q in extra_qubits] + [ancilla[0]]
qc.append(con_H_sim, qubits)
def hhl_routine(qc, ancilla, clock, input_qubits, measurement, extra_qubits=None, A=None, method=1):
qpe(qc, clock, input_qubits, extra_qubits, ancilla, A, method)
qc.reset(ancilla)
qc.barrier()
if method == 1:
# This section is to test and implement C = 1
# since we are not swapping after the QFT, reverse order of qubits from what is in papers
qc.cry(np.pi, clock[1], ancilla)
qc.cry(np.pi/3, clock[0], ancilla)
# uniformly-controlled rotation
elif method == 2:
n_clock = clock.size
C = 1/2**n_clock # constant in rotation (lower bound on eigenvalues A)
# compute angles for inversion rotations
alpha = [2*np.arcsin(C)]
for x in range(1,2**n_clock):
x_bin_rev = np.binary_repr(x, width=n_clock)[::-1]
lam = int(x_bin_rev,2)/(2**n_clock)
alpha.append(2*np.arcsin(C/lam))
theta = ucr.alpha2theta(alpha)
# do inversion step
qc = ucr.uniformly_controlled_rot(qc, clock, ancilla, theta)
qc.barrier()
qc.measure(ancilla, measurement[0])
qc.reset(ancilla)
qc.barrier()
inv_qpe(qc, clock, input_qubits, extra_qubits, ancilla, A, method)
def HHL(num_qubits, num_input_qubits, num_clock_qubits, beta, A=None, method=1):
if method == 1:
# Create the various registers needed
clock = QuantumRegister(num_clock_qubits, name='clock')
input_qubits = QuantumRegister(num_input_qubits, name='b')
ancilla = QuantumRegister(1, name='ancilla')
measurement = ClassicalRegister(2, name='c')
# Create an empty circuit with the specified registers
qc = QuantumCircuit(ancilla, clock, input_qubits, measurement)
# State preparation. (various initial values, done with initialize method)
# intial_state = [0,1]
# intial_state = [1,0]
# intial_state = [1/np.sqrt(2),1/np.sqrt(2)]
# intial_state = [np.sqrt(0.9),np.sqrt(0.1)]
##intial_state = [np.sqrt(1 - beta), np.sqrt(beta)]
##qc.initialize(intial_state, 3)
# use an RY rotation to initialize the input state between 0 and 1
qc.ry(2 * np.arcsin(beta), input_qubits)
# Put clock qubits into uniform superposition
qc.h(clock)
# Perform the HHL routine
hhl_routine(qc, ancilla, clock, input_qubits, measurement)
# Perform a Hadamard Transform on the clock qubits
qc.h(clock)
qc.barrier()
# measure the input, which now contains the answer
qc.measure(input_qubits, measurement[1])
# return a handle on the circuit
return qc
# Make the HHL circuit (this is the one aactually used right now)
def make_circuit(A, b, num_clock_qubits):
""" circuit for HHL algo A|x>=|b>
A : sparse Hermitian matrix
b (int): between 0,...,2^n-1. Initial basis state |b>
"""
# read in number of qubits
N = len(A)
n = int(np.log2(N))
n_t = num_clock_qubits # number of qubits in clock register
# lower bound on eigenvalues of A. Fixed for now
C = 1/4
# create quantum registers
qr = QuantumRegister(n)
qr_b = QuantumRegister(n) # ancillas for Hamiltonian simulation
cr = ClassicalRegister(n)
qr_t = QuantumRegister(n_t) # for phase estimation
qr_a = QuantumRegister(1) # ancilla qubit
cr_a = ClassicalRegister(1)
qc = QuantumCircuit(qr, qr_b, qr_t, qr_a, cr, cr_a)
# initialize the |b> state
qc = initialize_state(qc, qr, b)
# Hadamard phase estimation register
for q in range(n_t):
qc.h(qr_t[q])
# perform controlled e^(i*A*t)
for q in range(n_t):
control = qr_t[q]
phase = -(2*pi)*2**q
qc = shs.control_Ham_sim(qc, A, phase, control, qr, qr_b, qr_a[0])
# inverse QFT
qc = IQFT(qc, qr_t)
# reset ancilla
qc.reset(qr_a[0])
# compute angles for inversion rotations
alpha = [2*np.arcsin(C)]
for x in range(1,2**n_t):
x_bin_rev = np.binary_repr(x, width=n_t)[::-1]
lam = int(x_bin_rev,2)/(2**n_t)
if lam < C:
alpha.append(0)
elif lam >= C:
alpha.append(2*np.arcsin(C/lam))
theta = ucr.alpha2theta(alpha)
# do inversion step and measure ancilla
qc = ucr.uniformly_controlled_rot(qc, qr_t, qr_a, theta)
qc.measure(qr_a[0], cr_a[0])
qc.reset(qr_a[0])
# QFT
qc = QFT(qc, qr_t)
# uncompute phase estimation
# perform controlled e^(-i*A*t)
for q in reversed(range(n_t)):
control = qr_t[q]
phase = (2*pi)*2**q
qc = shs.control_Ham_sim(qc, A, phase, control, qr, qr_b, qr_a[0])
# Hadamard phase estimation register
for q in range(n_t):
qc.h(qr_t[q])
# measure ancilla and main register
qc.barrier()
qc.measure(qr[0:], cr[0:])
return qc
def sim_circuit(qc, shots):
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator, shots=shots).result()
outcomes = result.get_counts(qc)
return outcomes
def postselect(outcomes, return_probs=True):
mar_out = {}
for b_str in outcomes:
if b_str[0] == '1':
counts = outcomes[b_str]
mar_out[b_str[2:]] = counts
# compute postselection rate
ps_shots = sum(mar_out.values())
shots = sum(outcomes.values())
rate = ps_shots/shots
# convert to probability distribution
if return_probs == True:
mar_out = {b_str:round(mar_out[b_str]/ps_shots, 4) for b_str in mar_out}
return mar_out, rate
############### Result Data Analysis
saved_result = None
def true_distr(A, b=0):
N = len(A)
n = int(np.log2(N))
b_vec = np.zeros(N); b_vec[b] = 1.0
#b = np.array([1,1])/np.sqrt(2)
x = np.linalg.inv(A) @ b_vec
# normalize x
x_n = x/np.linalg.norm(x)
probs = np.array([np.abs(xj)**2 for xj in x_n])
distr = {}
for j, prob in enumerate(probs):
if prob > 1e-8:
j_bin = np.binary_repr(j, width=n)
distr[j_bin] = prob
distr = {out:distr[out]/sum(distr.values()) for out in distr}
return distr
def TVD(distr1, distr2):
""" compute total variation distance between distr1 and distr2
which are represented as dictionaries of bitstrings and probabilities
"""
tvd = 0.0
for out1 in distr1:
if out1 in distr2:
p1, p2 = distr1[out1], distr2[out1]
tvd += np.abs(p1-p2)/2
else:
p1 = distr1[out1]
tvd += p1/2
for out2 in distr2:
if out2 not in distr1:
p2 = distr2[out2]
tvd += p2/2
return tvd
def analyze_and_print_result (qc, result, num_qubits, s_int, num_shots):
global saved_result
saved_result = result
# obtain counts from the result object
counts = result.get_counts(qc)
# post-select counts where ancilla was measured as |1>
post_counts, rate = postselect(counts)
num_input_qubits = len(list(post_counts.keys())[0])
if verbose:
print(f'Ratio of counts with ancilla measured |1> : {round(rate, 4)}')
# compute true distribution from secret int
off_diag_index = 0
b = 0
s_int_o = int(s_int)
s_int_b = int(s_int)
while (s_int_o % 2) == 0:
s_int_o = int(s_int_o/2)
off_diag_index += 1
while (s_int_b % 3) == 0:
s_int_b = int(s_int_b/3)
b += 1
# temporarily fix diag and off-diag matrix elements
diag_el = 0.5
off_diag_el = -0.25
A = shs.generate_sparse_H(num_input_qubits, off_diag_index,
diag_el=diag_el, off_diag_el=off_diag_el)
ideal_distr = true_distr(A, b)
# compute total variation distance
tvd = TVD(ideal_distr, post_counts)
# use TVD as infidelity
fidelity = 1 - tvd
return post_counts, fidelity
################ Benchmark Loop
# Execute program with default parameters
def run (min_input_qubits=1, max_input_qubits=3, min_clock_qubits=2,
max_clock_qubits=3, max_circuits=3, num_shots=100,
backend_id='qasm_simulator', provider_backend=None,
hub="ibm-q", group="open", project="main", exec_options=None):
print("HHL Benchmark Program - Qiskit")
# Initialize metrics module
metrics.init_metrics()
# Define custom result handler
def execution_handler(qc, result, num_qubits, s_int, num_shots):
# determine fidelity of result set
num_qubits = int(num_qubits)
#counts, fidelity = analyze_and_print_result(qc, result, num_qubits, ideal_distr)
counts, fidelity = analyze_and_print_result(qc, result, num_qubits, int(s_int), num_shots)
metrics.store_metric(num_qubits, s_int, 'fidelity', fidelity)
# Variable for new qubit group ordering if using mid_circuit measurements
mid_circuit_qubit_group = []
# If using mid_circuit measurements, set transform qubit group to true
transform_qubit_group = False
# Initialize execution module using the execution result handler above and specified backend_id
ex.init_execution(execution_handler)
ex.set_execution_target(backend_id, provider_backend=provider_backend,
hub=hub, group=group, project=project, exec_options=exec_options)
# for noiseless simulation, set noise model to be None
#ex.set_noise_model(None)
# temporarily fix diag and off-diag matrix elements
diag_el = 0.5
off_diag_el = -0.25
# Execute Benchmark Program N times for multiple circuit sizes
# Accumulate metrics asynchronously as circuits complete
#for num_input_qubits in range(min_input_qubits, max_input_qubits+1):
for num_input_qubits in range(min_input_qubits, max_input_qubits+1):
N = 2**num_input_qubits # matrix size
for num_clock_qubits in range(min_clock_qubits, max_clock_qubits+1):
num_qubits = 2*num_input_qubits + num_clock_qubits + 1
# determine number of circuits to execute for this group
num_circuits = max_circuits
print(f"************\nExecuting {num_circuits} circuits with {num_input_qubits} input qubits and {num_clock_qubits} clock qubits")
# loop over randomly generated problem instances
for i in range(num_circuits):
b = np.random.choice(range(N))
off_diag_index = np.random.choice(range(1,N))
A = shs.generate_sparse_H(num_input_qubits, off_diag_index,
diag_el=diag_el, off_diag_el=off_diag_el)
# define secret_int
s_int = (2**off_diag_index)*(3**b)
# create the circuit for given qubit size and secret string, store time metric
ts = time.time()
qc = make_circuit(A, b, num_clock_qubits)
metrics.store_metric(num_qubits, s_int, 'create_time', time.time()-ts)
# submit circuit for execution on target (simulator, cloud simulator, or hardware)
ex.submit_circuit(qc, num_qubits, s_int, shots=num_shots)
# Wait for some active circuits to complete; report metrics when groups complete
ex.throttle_execution(metrics.finalize_group)
# Wait for all active circuits to complete; report metrics when groups complete
ex.finalize_execution(metrics.finalize_group)
# print a sample circuit
#print("Sample Circuit:"); print(QC_ if QC_ != None else " ... too large!")
#if method == 1: print("\nQuantum Oracle 'Uf' ="); print(Uf_ if Uf_ != None else " ... too large!")
#print("\nU Circuit ="); print(U_ if U_ != None else " ... too large!")
#print("\nU^-1 Circuit ="); print(UI_ if UI_ != None else " ... too large!")
#print("\nQFT Circuit ="); print(QFT_ if QFT_ != None else " ... too large!")
#print("\nInverse QFT Circuit ="); print(QFTI_ if QFTI_ != None else " ... too large!")
# Plot metrics for all circuit sizes
metrics.plot_metrics("Benchmark Results - HHL - Qiskit",
transform_qubit_group = transform_qubit_group, new_qubit_group = mid_circuit_qubit_group)
# if main, execute method
if __name__ == '__main__': run()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
#General imports
import numpy as np
#Operator Imports
from qiskit.opflow import Z, X, I, StateFn, CircuitStateFn, SummedOp
from qiskit.opflow.gradients import Gradient, NaturalGradient, QFI, Hessian
#Circuit imports
from qiskit.circuit import QuantumCircuit, QuantumRegister, Parameter, ParameterVector, ParameterExpression
from qiskit.circuit.library import EfficientSU2
# Instantiate the quantum state
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Instantiate the Hamiltonian observable
H = (2 * X) + Z
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# Print the operator corresponding to the expectation value
print(op)
params = [a, b]
# Define the values to be assigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi}
# Convert the operator and the gradient target params into the respective operator
grad = Gradient().convert(operator = op, params = params)
# Print the operator corresponding to the Gradient
print(grad)
# Assign the parameters and evaluate the gradient
grad_result = grad.assign_parameters(value_dict).eval()
print('Gradient', grad_result)
# Define the Hamiltonian with fixed coefficients
H = 0.5 * X - 1 * Z
# Define the parameters w.r.t. we want to compute the gradients
params = [a, b]
# Define the values to be assigned to the parameters
value_dict = { a: np.pi / 4, b: np.pi}
# Combine the Hamiltonian observable and the state into an expectation value operator
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
print(op)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameters using
# the parameter shift method.
state_grad = Gradient(grad_method='param_shift').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with parameter shift', state_grad_result)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the linear combination of unitaries method.
state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with the linear combination method', state_grad_result)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the finite difference method.
state_grad = Gradient(grad_method='fin_diff').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with finite difference', state_grad_result)
# Besides the method to compute the circuit gradients resp. QFI, a regularization method can be chosen:
# `ridge` or `lasso` with automatic parameter search or `perturb_diag_elements` or `perturb_diag`
# which perturb the diagonal elements of the QFI.
nat_grad = NaturalGradient(grad_method='lin_comb', qfi_method='lin_comb_full', regularization='ridge').convert(
operator=op, params=params)
# Assign the parameters and evaluate the gradient
nat_grad_result = nat_grad.assign_parameters(value_dict).eval()
print('Natural gradient computed with linear combination of unitaries', nat_grad_result)
# Instantiate the Hamiltonian observable
H = X
# Instantiate the quantum state with two parameters
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# Convert the operator and the hessian target coefficients into the respective operator
hessian = Hessian().convert(operator = op, params = [a, b])
# Define the values to be assigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi/4}
# Assign the parameters and evaluate the Hessian w.r.t. the Hamiltonian coefficients
hessian_result = hessian.assign_parameters(value_dict).eval()
print('Hessian \n', np.real(np.array(hessian_result)))
# Define parameters
params = [a, b]
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='param_shift').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the parameter shift method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='lin_comb').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the linear combination of unitaries method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian using finite difference
state_hess = Hessian(hess_method='fin_diff').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed with finite difference\n', (np.array(hessian_result)))
# Wrap the quantum circuit into a CircuitStateFn
state = CircuitStateFn(primitive=qc, coeff=1.)
# Convert the state and the parameters into the operator object that represents the QFI
qfi = QFI(qfi_method='lin_comb_full').convert(operator=state, params=params)
# Define the values for which the QFI is to be computed
values_dict = {a: np.pi / 4, b: 0.1}
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('full QFI \n', np.real(np.array(qfi_result)))
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'block_diagonal'
qfi = QFI('overlap_block_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Block-diagonal QFI \n', np.real(np.array(qfi_result)))
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'diagonal'
qfi = QFI('overlap_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Diagonal QFI \n', np.real(np.array(qfi_result)))
# Execution Imports
from qiskit import Aer
from qiskit.utils import QuantumInstance
# Algorithm Imports
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import CG
from qiskit.opflow import I, X, Z
from qiskit.circuit import QuantumCircuit, ParameterVector
from scipy.optimize import minimize
# Instantiate the system Hamiltonian
h2_hamiltonian = -1.05 * (I ^ I) + 0.39 * (I ^ Z) - 0.39 * (Z ^ I) - 0.01 * (Z ^ Z) + 0.18 * (X ^ X)
# This is the target energy
h2_energy = -1.85727503
# Define the Ansatz
wavefunction = QuantumCircuit(2)
params = ParameterVector('theta', length=8)
it = iter(params)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
wavefunction.cx(0, 1)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
# Define the expectation value corresponding to the energy
op = ~StateFn(h2_hamiltonian) @ StateFn(wavefunction)
grad = Gradient(grad_method='lin_comb')
qi_sv = QuantumInstance(Aer.get_backend('aer_simulator_statevector'),
shots=1,
seed_simulator=2,
seed_transpiler=2)
#Conjugate Gradient algorithm
optimizer = CG(maxiter=50)
# Gradient callable
vqe = VQE(wavefunction, optimizer=optimizer, gradient=grad, quantum_instance=qi_sv)
result = vqe.compute_minimum_eigenvalue(h2_hamiltonian)
print('Result:', result.optimal_value, 'Reference:', h2_energy)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/hugoecarl/TSP-Problem-Study
|
hugoecarl
|
import math
import matplotlib.pyplot as plt
%matplotlib inline
class TSP:
def __init__(self):
self.flat_mat = flat_mat
self.n = 0
self.melhor_dist = 1e11
self.pontos = []
self.melhores_pontos = []
def busca_exaustiva(self, flat_mat, n, ite):
if ite == n:
dist = 0
for j in range(1, n):
dist += flat_mat[self.pontos[j-1] * n + self.pontos[j]]
dist += flat_mat[self.pontos[n-1] * n + self.pontos[0]]
if dist < self.melhor_dist:
self.melhor_dist = dist
self.melhores_pontos = self.pontos[:]
return
for i in range(n):
if self.pontos[i] == -1:
self.pontos[i] = ite
self.busca_exaustiva(flat_mat, n, ite + 1)
self.pontos[i] = -1
def dist_mat(self):
x = []
y = []
flat_mat = [] #matriz 1 dimensao contendo todas as distancias possiveis entre os pontos para facilitar cálculo.
while True:
try:
temp = input("Digite a coordenada x y: ").split()
x.append(float(temp[0]))
y.append(float(temp[1]))
except:
break
for i in range(len(x)):
for j in range(len(y)):
flat_mat.append(math.sqrt((x[i] - x[j])**2 + (y[i] - y[j])**2))
return flat_mat, x, y
def get_results(self):
self.flat_mat, x, _ = self.dist_mat()
self.n = len(x)
self.pontos = [-1]*self.n
self.pontos[0] = 0
self.busca_exaustiva(self.flat_mat, self.n, 1)
return self.melhor_dist, self.melhores_pontos
Tsp = TSP()
distancia, pontos = Tsp.get_results()
print("Melhor distancia encontrada: ", distancia)
print("Melhor caminho encontrado: ", pontos)
#plota gráfico
def connectpoints(x,y,p1,p2):
x1, x2 = x[p1], x[p2]
y1, y2 = y[p1], y[p2]
plt.plot([x1,x2],[y1,y2],'ro-')
for i in range(1, len(pontos)):
connectpoints(x,y,pontos[i-1],pontos[i])
connectpoints(x,y,pontos[len(x)-1],pontos[0])
plt.title("Percurso")
plt.show()
%%time
%%cmd
python TSP.py < in-1.txt
type out-1.txt
python TSP.py < in-2.txt
type out-2.txt
python TSP.py < in-3.txt
type out-3.txt
python TSP.py < in-4.txt
type out-4.txt
from qiskit import IBMQ
import numpy as np
#IBMQ.save_account('seu-tokenIBMQ-para-rodar-localmente')
IBMQ.load_account()
from qiskit import Aer
from qiskit.tools.visualization import plot_histogram
from qiskit.circuit.library import TwoLocal
from qiskit.optimization.applications.ising import max_cut, tsp
from qiskit.aqua.algorithms import VQE, NumPyMinimumEigensolver
from qiskit.aqua.components.optimizers import SPSA
from qiskit.aqua import aqua_globals
from qiskit.aqua import QuantumInstance
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.optimization.algorithms import MinimumEigenOptimizer
from qiskit.optimization.problems import QuadraticProgram
import logging
from qiskit.aqua import set_qiskit_aqua_logging
#Preparando os dados segundo os imputs do usuario para serem resolvidos pelo qiskit max 4 pontos por limitação de qubits
coord = []
flat_mat, x, y = TSP().dist_mat()
dist_mat = np.array(flat_mat).reshape(len(x),len(x))
for i, j in zip(x, y):
coord.append([i,j])
ins = tsp.TspData('TSP_Q', dim=len(x), coord=np.array(coord), w=dist_mat)
qubitOp, offset = tsp.get_operator(ins)
print('Offset:', offset)
print('Ising Hamiltonian:')
print(qubitOp.print_details())
#Usando o numpyMinimumEigensolver como o solver do problema para resolver de forma quantica
ee = NumPyMinimumEigensolver(qubitOp)
result = ee.run()
print('energy:', result.eigenvalue.real)
print('tsp objective:', result.eigenvalue.real + offset)
x_Q = sample_most_likely(result.eigenstate)
print('feasible:', tsp.tsp_feasible(x_Q))
z = tsp.get_tsp_solution(x_Q)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
for i in range(1, len(z)):
connectpoints(x,y,z[i-1],z[i])
connectpoints(x,y,z[len(x)-1],z[0])
plt.title("Percurso")
plt.show()
#instanciando o simulador ou o computador real importante lembrar que nao ira funcionar para mais de 4 pontos pelo numero de qubits disponibilizados pela IBM que sao apenas 16 para o simulador qasm e 15 para a maquina quantica
provider = IBMQ.get_provider(hub = 'ibm-q')
device = provider.get_backend('ibmq_16_melbourne')
aqua_globals.random_seed = np.random.default_rng(123)
seed = 10598
backend = Aer.get_backend('qasm_simulator')
#descomentar essa linha caso queira rodar na maquina real
#backend = device
quantum_instance = QuantumInstance(backend, seed_simulator=seed, seed_transpiler=seed)
#rodando no simulador quantico
spsa = SPSA(maxiter=10)
ry = TwoLocal(qubitOp.num_qubits, 'ry', 'cz', reps=5, entanglement='linear')
vqe = VQE(qubitOp, ry, spsa, quantum_instance=quantum_instance)
result = vqe.run(quantum_instance)
print('energy:', result.eigenvalue.real)
print('time:', result.optimizer_time)
x = sample_most_likely(result.eigenstate)
print('feasible:', tsp.tsp_feasible(x_Q))
z = tsp.get_tsp_solution(x_Q)
print('solution:', z)
print('solution objective:', tsp.tsp_value(z, ins.w))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.visualization import dag_drawer
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
dag = circuit_to_dag(circ)
dag_drawer(dag)
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
plt.style.use("ggplot")
from pprint import pprint
import pickle
import time
import datetime
%matplotlib inline
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, X, Y, Z, I
from qiskit.opflow.state_fns.dict_state_fn import DictStateFn
from qiskit.quantum_info import DensityMatrix
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, 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
# unused for this file
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("../../solutions/utils/")
import circuit_utils, zne_utils, tomography_utils
importlib.reload(circuit_utils)
importlib.reload(zne_utils) # unused for this file
importlib.reload(tomography_utils) # unused for this file
from circuit_utils import *
from zne_utils import zne_wrapper, zne_decoder
from tomography_utils import expvals_to_valid_rho
from qiskit.test.mock import FakeJakarta
# backend = FakeJakarta()
backend = Aer.get_backend("qasm_simulator")
# Returns the matrix representation of the XXX Heisenberg model for 3 spin-1/2 particles in a line
def H_heis3():
# Interactions (I is the identity matrix; X, Y, and Z are Pauli matricies; ^ is a tensor product)
XXs = (I^X^X) + (X^X^I)
YYs = (I^Y^Y) + (Y^Y^I)
ZZs = (I^Z^Z) + (Z^Z^I)
# Sum interactions
H = XXs + YYs + ZZs
# Return Hamiltonian
return H
# Returns the matrix representation of U_heis3(t) for a given time t assuming an XXX Heisenberg Hamiltonian for 3 spins-1/2 particles in a line
def U_heis3(t):
# Compute XXX Hamiltonian for 3 spins in a line
H = H_heis3()
# Return the exponential of -i multipled by time t multipled by the 3 spin XXX Heisenberg Hamilonian
return (t * H).exp_i()
# Define array of time points
ts = np.linspace(0, np.pi, 100)
target_state = DictStateFn({"000": 0,
"001": 0,
"010": 1,
"011": 0,
"100": 0,
"101": 0,
"110": 1,
"111": 0}, 1 / np.sqrt(2))
print(DensityMatrix(target_state.to_density_matrix()).is_valid())
# Compute probability of remaining in |110> state over the array of time points
# ~target_state gives the bra of the initial state (<110|)
# @ is short hand for matrix multiplication
# U_heis3(t) is the unitary time evolution at time t
# t needs to be wrapped with float(t) to avoid a bug
# (...).eval() returns the inner product <110|U_heis3(t)|110>
# np.abs(...)**2 is the modulus squared of the innner product which is the expectation value, or probability, of remaining in |110>
probs_010_110 = [np.abs((~target_state @ U_heis3(float(t)) @ target_state).eval())**2 for t in ts]
# Plot evolution of |110>
plt.figure(dpi=200)
plt.plot(ts, probs_010_110)
plt.xlabel('time')
plt.ylabel(r'probability of state $|010\rangle + |110\rangle$')
plt.title(r'Evolution of state $|010\rangle + |110\rangle$ under $H_{Heis3}$')
# plt.grid()
plt.show()
num_qubits = 3
# The final time of the state evolution
target_times = [i * np.pi / 20 for i in range(0, 20 + 1)]
pprint(target_times)
# 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] # unused for this file
shots = 1 << 13
reps = 8 # unused
target_state = np.zeros((1 << num_qubits, 1 << num_qubits))
target_state[2, 2] = target_state[6, 6] = target_state[2, 6] = target_state[6, 2] = 0.5
target_state = DensityMatrix(target_state)
target_state.draw("latex")
prob_list = []
for target_time in target_times:
print("target_time: ", target_time)
t1 = time.perf_counter()
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="q")
cr = ClassicalRegister(num_qubits, name="c")
qc = QuantumCircuit(qr, cr)
# 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.h(0)
qc.x(1)
general_subspace_encoder(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
general_subspace_decoder(qc, targets=[0, 1, 2]) # decode
qc.x(1)
qc.h(0)
qc.measure(qr, cr[::-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 / num_steps})
print("created qc")
# optimize circuit
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"])
print("created t3_qc (depth:", t3_qc.depth(), ")")
t3_qc = transpile(t3_qc, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_qc (depth:", t3_qc.depth(), ")")
job = execute(t3_qc, backend, shots=shots, optimization_level=0)
print('Job ID', job.job_id())
prob = job.result().get_counts().get("0" * num_qubits, 0) / shots
prob_list.append(prob)
t2 = time.perf_counter()
print(r'probability of state |010> + |110> = {:.4f}'.format(prob))
print("time:", t2 - t1)
print()
plt.figure(dpi=200)
plt.plot(ts, probs_010_110, label="theoretical prediction")
plt.scatter(target_times, prob_list, c="green", zorder=4)
plt.legend(("theoretical prediction", "proposed method"))
plt.xlabel('time')
plt.ylabel(r'probability of state $|010\rangle + |110\rangle$')
plt.title(r'Evolution of state $|010\rangle + |110\rangle$ under $H_{Heis3}$')
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
fid_list = []
for target_time in target_times:
print("target_time: ", target_time)
t1 = time.perf_counter()
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="q")
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.h(0)
qc.x(1)
general_subspace_encoder(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
general_subspace_decoder(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"])
t3_st_qcs = transpile(t3_st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = t3_st_qcs
# zne_qcs = zne_wrapper(t3_st_qcs, scale_factors = scale_factors, pt = False)
# print("created zne_qcs (length:", len(zne_qcs), ")")
# optimization_level must be 0
# feed initial_layout here to see the picture of the circuits before casting the job
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), ")")
job = execute(t3_zne_qcs, backend, shots=shots, optimization_level=0)
print('Job ID', job.job_id())
rho = StateTomographyFitter(job.result(), t3_zne_qcs).fit(method='lstsq')
fid = state_fidelity(rho, target_state)
fid_list.append(fid)
t2 = time.perf_counter()
print('state tomography fidelity = {:.4f}'.format(fid))
print("time:", t2 - t1)
print()
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
import numpy as np
# Import Qiskit
from qiskit import QuantumCircuit
from qiskit import Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_state_city
from qiskit import *
from qiskit.tools.monitor import job_monitor
import qiskit.quantum_info as qi
Aer.backends()
simulator = Aer.get_backend('aer_simulator')
# Set initial state to generated statevector
circ = QuantumCircuit(7, 6)
circ.x(6)
circ.barrier()
circ.h(0)
circ.h(1)
circ.h(2)
circ.h(3)
circ.h(4)
circ.h(5)
circ.h(6)
circ.barrier()
circ.x(0)
circ.x(2)
circ.x(3)
circ.barrier()
circ.h(0)
circ.h(1)
circ.h(2)
circ.h(3)
circ.h(4)
circ.h(5)
circ.h(6)
circ.barrier()
circ.measure(range(6), range(6))
circ.draw()
# execute the quantum circuit
backend = BasicAer.get_backend('qasm_simulator') # the device to run on
result = backend.run(transpile(circ, backend), shots=1000).result()
counts = result.get_counts(circ)
print(counts)
plot_histogram(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
d0 = pulse.DriveChannel(0)
d1 = pulse.DriveChannel(1)
with pulse.build() as pulse_prog:
with pulse.align_right():
# this pulse will start at t=0
pulse.play(pulse.Constant(100, 1.0), d0)
# this pulse will start at t=80
pulse.play(pulse.Constant(20, 1.0), d1)
pulse_prog.draw()
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=invalid-name,missing-docstring
"""Quick program to test the quantum information states modules."""
import unittest
import numpy as np
from qiskit import execute, QuantumRegister, QuantumCircuit, BasicAer
from qiskit.quantum_info import basis_state, random_state
from qiskit.quantum_info import state_fidelity
from qiskit.quantum_info import projector
from qiskit.quantum_info import purity
from qiskit.test import QiskitTestCase
class TestStates(QiskitTestCase):
"""Tests for qi.py"""
def test_state_fidelity(self):
psi1 = [0.70710678118654746, 0, 0, 0.70710678118654746]
psi2 = [0., 0.70710678118654746, 0.70710678118654746, 0.]
rho1 = [[0.5, 0, 0, 0.5], [0, 0, 0, 0], [0, 0, 0, 0], [0.5, 0, 0, 0.5]]
mix = [[0.25, 0, 0, 0], [0, 0.25, 0, 0],
[0, 0, 0.25, 0], [0, 0, 0, 0.25]]
self.assertAlmostEqual(state_fidelity(psi1, psi1), 1.0, places=7,
msg='vector-vector input')
self.assertAlmostEqual(state_fidelity(psi1, psi2), 0.0, places=7,
msg='vector-vector input')
self.assertAlmostEqual(state_fidelity(psi1, rho1), 1.0, places=7,
msg='vector-matrix input')
self.assertAlmostEqual(state_fidelity(psi1, mix), 0.25, places=7,
msg='vector-matrix input')
self.assertAlmostEqual(state_fidelity(psi2, rho1), 0.0, places=7,
msg='vector-matrix input')
self.assertAlmostEqual(state_fidelity(psi2, mix), 0.25, places=7,
msg='vector-matrix input')
self.assertAlmostEqual(state_fidelity(rho1, psi1), 1.0, places=7,
msg='matrix-vector input')
self.assertAlmostEqual(state_fidelity(rho1, rho1), 1.0, places=7,
msg='matrix-matrix input')
self.assertAlmostEqual(state_fidelity(mix, mix), 1.0, places=7,
msg='matrix-matrix input')
def test_state_fidelity_qubit(self):
state0 = np.array([1.+0.j, 0.+0.j])
state1 = np.array([0.+0.j, 1.+0.j])
self.assertEqual(state_fidelity(state0, state0), 1.0)
self.assertEqual(state_fidelity(state1, state1), 1.0)
self.assertEqual(state_fidelity(state0, state1), 0.0)
def test_projector(self):
state0 = np.array([1.+0.j, 0.+0.j])
state1 = projector(np.array([0.+0.j, 1.+0.j]))
self.assertEqual(state_fidelity(state0, state0), 1.0)
self.assertEqual(state_fidelity(state1, state1), 1.0)
self.assertEqual(state_fidelity(state0, state1), 0.0)
def test_basis(self):
# reference
state = basis_state('010', 3)
state_ideal = np.array([0.+0.j, 0.+0.j, 1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j])
state_fidelity(state, state_ideal)
self.assertEqual(state_fidelity(state, state_ideal), 1.0)
def test_basis_state_circuit(self):
state = state = (basis_state('001', 3)+basis_state('111', 3))/np.sqrt(2)
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.initialize(state, [q[0], q[1], q[2]])
backend = BasicAer.get_backend('statevector_simulator')
qc_state = execute(qc, backend).result().get_statevector(qc)
self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
def test_random_state(self):
# this test that a random state converges to 1/d
number = 100000
E_P0_last = 0
for ii in range(number):
state = basis_state(bin(3)[2:].zfill(3), 3)
E_P0 = (E_P0_last*ii)/(ii+1)+state_fidelity(state, random_state(2**3, seed=ii))/(ii+1)
E_P0_last = E_P0
self.assertAlmostEqual(E_P0, 1/8, places=2)
def test_random_state_circuit(self):
state = random_state(2**3, seed=40)
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.initialize(state, [q[0], q[1], q[2]])
backend = BasicAer.get_backend('statevector_simulator')
qc_state = execute(qc, backend).result().get_statevector(qc)
self.assertAlmostEqual(state_fidelity(qc_state, state), 1.0, places=7)
def test_purity_list_input(self):
rho1 = [[1, 0], [0, 0]]
rho2 = [[0.5, 0], [0, 0.5]]
rho3 = 0.7 * np.array(rho1) + 0.3 * np.array(rho2)
test_pass = (purity(rho1) == 1.0 and
purity(rho2) == 0.5 and
round(purity(rho3), 10) == 0.745)
self.assertTrue(test_pass)
def test_purity_1d_list_input(self):
input_state = [1, 0]
res = purity(input_state)
self.assertEqual(1, res)
def test_purity_basis_state_input(self):
state_1 = basis_state('0', 1)
state_2 = basis_state('11', 2)
state_3 = basis_state('010', 3)
self.assertEqual(purity(state_1), 1.0)
self.assertEqual(purity(state_2), 1.0)
self.assertEqual(purity(state_3), 1.0)
def test_purity_pure_state(self):
state_1 = (1/np.sqrt(2))*(basis_state('0', 1) + basis_state('1', 1))
state_2 = (1/np.sqrt(3))*(basis_state('00', 2)
+ basis_state('01', 2) + basis_state('11', 2))
state_3 = 0.5*(basis_state('000', 3) + basis_state('001', 3)
+ basis_state('010', 3) + basis_state('100', 3))
self.assertEqual(purity(state_1), 1.0)
self.assertEqual(purity(state_2), 1.0)
self.assertEqual(purity(state_3), 1.0)
def test_purity_pure_matrix_state(self):
state_1 = (1/np.sqrt(2))*(basis_state('0', 1) + basis_state('1', 1))
state_1 = projector(state_1)
state_2 = (1/np.sqrt(3))*(basis_state('00', 2)
+ basis_state('01', 2) + basis_state('11', 2))
state_2 = projector(state_2)
state_3 = 0.5*(basis_state('000', 3) + basis_state('001', 3)
+ basis_state('010', 3) + basis_state('100', 3))
state_3 = projector(state_3)
self.assertAlmostEqual(purity(state_1), 1.0, places=10)
self.assertAlmostEqual(purity(state_2), 1.0, places=10)
self.assertEqual(purity(state_3), 1.0)
def test_purity_mixed_state(self):
state_1 = 0.5*(projector(basis_state('0', 1))
+ projector(basis_state('1', 1)))
state_2 = (1/3.0)*(projector(basis_state('00', 2))
+ projector(basis_state('01', 2))
+ projector(basis_state('10', 2)))
self.assertEqual(purity(state_1), 0.5)
self.assertEqual(purity(state_2), 1.0/3)
if __name__ == '__main__':
unittest.main()
|
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.
"""
A collection of functions that decide the layout of an output image.
See :py:mod:`~qiskit.visualization.timeline.types` for more info on the required data.
There are 2 types of layout functions in this module.
1. layout.bit_arrange
In this stylesheet entry the input data is a list of `types.Bits` and returns a
sorted list of `types.Bits`.
The function signature of the layout is restricted to:
```python
def my_layout(bits: List[types.Bits]) -> List[types.Bits]:
# your code here: sort input bits and return list of bits
```
2. layout.time_axis_map
In this stylesheet entry the input data is `Tuple[int, int]` that represents horizontal
axis limit of the output image. The layout function returns `types.HorizontalAxis` data
which is consumed by the plotter API to make horizontal axis.
The function signature of the layout is restricted to:
```python
def my_layout(time_window: Tuple[int, int]) -> types.HorizontalAxis:
# your code here: create and return axis config
```
Arbitrary layout function satisfying the above format can be accepted.
"""
import warnings
from typing import List, Tuple
import numpy as np
from qiskit import circuit
from qiskit.visualization.exceptions import VisualizationError
from qiskit.visualization.timeline import types
def qreg_creg_ascending(bits: List[types.Bits]) -> List[types.Bits]:
"""Sort bits by ascending order.
Bit order becomes Q0, Q1, ..., Cl0, Cl1, ...
Args:
bits: List of bits to sort.
Returns:
Sorted bits.
"""
qregs = []
cregs = []
for bit in bits:
if isinstance(bit, circuit.Qubit):
qregs.append(bit)
elif isinstance(bit, circuit.Clbit):
cregs.append(bit)
else:
raise VisualizationError(f"Unknown bit {bit} is provided.")
with warnings.catch_warnings():
warnings.simplefilter("ignore")
qregs = sorted(qregs, key=lambda x: x.index, reverse=False)
cregs = sorted(cregs, key=lambda x: x.index, reverse=False)
return qregs + cregs
def qreg_creg_descending(bits: List[types.Bits]) -> List[types.Bits]:
"""Sort bits by descending order.
Bit order becomes Q_N, Q_N-1, ..., Cl_N, Cl_N-1, ...
Args:
bits: List of bits to sort.
Returns:
Sorted bits.
"""
qregs = []
cregs = []
for bit in bits:
if isinstance(bit, circuit.Qubit):
qregs.append(bit)
elif isinstance(bit, circuit.Clbit):
cregs.append(bit)
else:
raise VisualizationError(f"Unknown bit {bit} is provided.")
qregs = sorted(qregs, key=lambda x: x.index, reverse=True)
cregs = sorted(cregs, key=lambda x: x.index, reverse=True)
return qregs + cregs
def time_map_in_dt(time_window: Tuple[int, int]) -> types.HorizontalAxis:
"""Layout function for the horizontal axis formatting.
Generate equispaced 6 horizontal axis ticks.
Args:
time_window: Left and right edge of this graph.
Returns:
Axis formatter object.
"""
# shift time axis
t0, t1 = time_window
# axis label
axis_loc = np.linspace(max(t0, 0), t1, 6)
axis_label = axis_loc.copy()
# consider time resolution
label = "System cycle time (dt)"
formatted_label = [f"{val:.0f}" for val in axis_label]
return types.HorizontalAxis(
window=(t0, t1), axis_map=dict(zip(axis_loc, formatted_label)), label=label
)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')
|
https://github.com/JackHidary/quantumcomputingbook
|
JackHidary
|
# install latest version
!pip install cirq==0.5 --quiet
# Alternatively, install directly from HEAD on github:
# !pip install git+https://github.com/quantumlib/Cirq.git --quiet
import cirq
import numpy as np
import matplotlib
print(cirq.google.Bristlecone)
a = cirq.NamedQubit("a")
b = cirq.NamedQubit("b")
c = cirq.NamedQubit("c")
ops = [cirq.H(a), cirq.H(b), cirq.CNOT(b, c), cirq.H(b)]
circuit = cirq.Circuit.from_ops(ops)
print(circuit)
cirq.unitary(cirq.H)
for i, moment in enumerate(circuit):
print('Moment {}: {}'.format(i, moment))
print(repr(circuit))
def xor_swap(a, b):
yield cirq.CNOT(a, b)
yield cirq.CNOT(b, a)
yield cirq.CNOT(a, b)
def left_rotate(qubits):
for i in range(len(qubits) - 1):
a, b = qubits[i:i+2]
yield xor_swap(a, b)
line = cirq.LineQubit.range(5)
print(cirq.Circuit.from_ops(left_rotate(line)))
circuit = cirq.Circuit()
circuit.append([cirq.CZ(a, b)])
circuit.append([cirq.H(a), cirq.H(b), cirq.H(c)])
print(circuit)
circuit = cirq.Circuit()
circuit.append([cirq.CZ(a, b)])
circuit.append([cirq.H(c), cirq.H(b), cirq.H(b), cirq.H(a)], )
print(circuit)
#@title
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
c = cirq.NamedQubit('c')
circuit = cirq.Circuit()
circuit.append([cirq.CZ(a, b), cirq.H(c), cirq.H(a)] )
circuit.append([cirq.H(b), cirq.CZ(b, c), cirq.H(b), cirq.H(a), cirq.H(a)],
strategy=cirq.InsertStrategy.NEW_THEN_INLINE)
print(circuit)
def basic_circuit(measure=True):
sqrt_x = cirq.X**0.5
cz = cirq.CZ
yield sqrt_x(a), sqrt_x(b)
yield cz(a, b)
yield sqrt_x(a), sqrt_x(b)
if measure:
yield cirq.measure(a,b)
circuit = cirq.Circuit.from_ops(basic_circuit())
print(circuit)
simulator = cirq.Simulator()
circuit = cirq.Circuit.from_ops(basic_circuit())
result = simulator.run(circuit)
print('Measurement results')
print(result)
circuit = cirq.Circuit()
circuit.append(basic_circuit(measure=False))
result = simulator.simulate(circuit, qubit_order=[a, b])
print('Wavefunction:')
print(np.around(result.final_state, 3))
print('Dirac notation:')
print(result.dirac_notation())
circuit = cirq.Circuit.from_ops(basic_circuit())
result = simulator.run(circuit, repetitions=1000)
print(result.histogram(key='a,b'))
print(result.histogram(key='a,b', fold_func=lambda e: 'agree' if e[0] == e[1] else 'disagree'))
q0, q1 = cirq.LineQubit.range(2)
oracles = {
'0': [],
'1': [cirq.X(q1)],
'x': [cirq.CNOT(q0, q1)],
'notx': [cirq.CNOT(q0, q1), cirq.X(q1)]
}
q0, q1 = cirq.LineQubit.range(2)
oracles = {
'0': [],
'1': [cirq.X(q1)],
'x': [cirq.CNOT(q0, q1)],
'notx': [cirq.CNOT(q0, q1), cirq.X(q1)]
}
def deutsch_algorithm(oracle):
yield cirq.X(q1)
yield cirq.H(q0), cirq.H(q1)
yield oracle
yield cirq.H(q0)
yield cirq.measure(q0)
for key, oracle in oracles.items():
print('Circuit for {}...'.format(key))
print('{}\n'.format(cirq.Circuit.from_ops(deutsch_algorithm(oracle))))
simulator = cirq.Simulator()
for key, oracle in oracles.items():
result = simulator.run(cirq.Circuit.from_ops(deutsch_algorithm(oracle)),
repetitions=10)
print('oracle: {:<4} results: {}'.format(key, result))
q0, q1, q2 = cirq.LineQubit.range(3)
constant = ([], [cirq.X(q2)])
balanced = ([cirq.CNOT(q0, q2)], [cirq.CNOT(q1, q2)], [cirq.CNOT(q0, q2), cirq.CNOT(q1, q2)],
[cirq.CNOT(q0, q2), cirq.X(q2)], [ cirq.CNOT(q1, q2), cirq.X(q2)], [cirq.CNOT(q0, q2), cirq.CNOT(q1, q2), cirq.X(q2)])
for i, ops in enumerate(constant):
print('\nConstant function {}'.format(i))
print(cirq.Circuit.from_ops(ops).to_text_diagram(qubit_order=[q0, q1, q2]))
print()
for i, ops in enumerate(balanced):
print('\nBalanced function {}'.format(i))
print(cirq.Circuit.from_ops(ops).to_text_diagram(qubit_order=[q0, q1, q2]))
simulator = cirq.Simulator()
def your_circuit(oracle):
# your code here
yield oracle
# and here
yield cirq.measure(q0, q1, q2)
print('Your result on constant functions')
for oracle in constant:
result = simulator.run(cirq.Circuit.from_ops(your_circuit(oracle)), repetitions=10)
print(result)
print('Your result on balanced functions')
for oracle in balanced:
result = simulator.run(cirq.Circuit.from_ops(your_circuit(oracle)), repetitions=10)
print(result)
#@title
simulator = cirq.Simulator()
def your_circuit(oracle):
# phase kickback trick
yield cirq.X(q2), cirq.H(q2)
# equal superposition over input bits
yield cirq.H(q0), cirq.H(q1)
# query the function
yield oracle
# interference to get result, put last qubit into |1>
yield cirq.H(q0), cirq.H(q1), cirq.H(q2)
# a final OR gate to put result in final qubit
yield cirq.X(q0), cirq.X(q1), cirq.CCX(q0, q1, q2)
yield cirq.measure(q2)
print('Your result on constant functions')
for oracle in constant:
result = simulator.run(cirq.Circuit.from_ops(your_circuit(oracle)), repetitions=10)
print(result)
print('Your result on balanced functions')
for oracle in balanced:
result = simulator.run(cirq.Circuit.from_ops(your_circuit(oracle)), repetitions=10)
print(result)
q0, q1, q2 = cirq.LineQubit.range(3)
ops = [
cirq.X(q0),
cirq.Y(q1),
cirq.Z(q2),
cirq.CZ(q0,q1),
cirq.CNOT(q1,q2),
cirq.H(q0),
cirq.T(q1),
cirq.S(q2),
cirq.CCZ(q0, q1, q2),
cirq.SWAP(q0, q1),
cirq.CSWAP(q0, q1, q2),
cirq.CCX(q0, q1, q2),
cirq.ISWAP(q0, q1),
cirq.Rx(0.5 * np.pi)(q0),
cirq.Ry(.5 * np.pi)(q1),
cirq.Rz(0.5 * np.pi)(q2),
(cirq.X**0.5)(q0),
]
print(cirq.Circuit.from_ops(ops))
print(cirq.unitary(cirq.CNOT))
print(cirq.unitary(cirq.Rx(0.5 * np.pi)))
a = cirq.NamedQubit('a')
circuit = cirq.Circuit.from_ops([cirq.Rx(np.pi / 50.0)(a) for theta in range(200)])
print('Circuit is a bunch of small rotations about Pauli X axis:')
print('{}\n'.format(circuit))
p0 = []
z = []
print('We step through the circuit and plot the z component of the vector '
'as a function of index of the moment being stepped over.')
for i, step in enumerate(simulator.simulate_moment_steps(circuit)):
prob = np.abs(step.state_vector()) ** 2
z.append(i)
p0.append(prob[0])
matplotlib.pyplot.style.use('seaborn-whitegrid')
matplotlib.pyplot.plot(z, p0, 'o')
repetitions = 100
a = cirq.NamedQubit('a')
circuit = cirq.Circuit.from_ops([cirq.Rx(np.pi / 50.0)(a) for theta in range(200)])
p0 = []
z = []
for i, step in enumerate(simulator.simulate_moment_steps(circuit)):
samples = step.sample([a], repetitions=repetitions)
prob0 = np.sum(samples, axis=0)[0] / repetitions
p0.append(prob0)
z.append(i)
matplotlib.pyplot.style.use('seaborn-whitegrid')
matplotlib.pyplot.plot(z, p0, 'o')
class RationalGate(cirq.SingleQubitGate):
def _unitary_(self):
return np.array([[3 / 5, 4 / 5], [-4 / 5, 3 / 5]])
def __str__(self):
return 'ζ'
a = cirq.NamedQubit('a')
rg = RationalGate()
print(cirq.Circuit.from_ops([rg(a)]))
print(cirq.unitary(rg))
circuit = cirq.Circuit.from_ops([rg(a)])
simulator = cirq.Simulator()
result = simulator.simulate(circuit)
print(result.final_state)
class CRx(cirq.TwoQubitGate):
def __init__(self, theta):
self.theta = theta
def _unitary_(self):
return np.array([
])
pass
# Get this to print nicely in an ASCII circuit, you should also
# implement the _circuit_diagram_info_ method from the
# SupportsCircuitDiagramInfo protocol. You can return a tuple
# of strings from this method.
print(np.around(cirq.unitary(CRx(0.25 * np.pi))))
# Also get your class to print a circuit correctly.
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
op = CRx(0.25 * np.pi)(a, b)
print(cirq.Circuit.from_ops([op]))
class CRx(cirq.TwoQubitGate):
def __init__(self, theta):
self.theta = theta
def _unitary_(self):
return np.array([
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, np.cos(self.theta), -1j * np.sin(self.theta)],
[0, 0, -1j * np.sin(self.theta), np.cos(self.theta)]
])
def _circuit_diagram_info_(self, args):
return '@', 'Rx({}π)'.format(self.theta / np.pi)
print('cirq.unitary on the gate yields:')
print(np.around(cirq.unitary(CRx(0.25 * np.pi))))
print()
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
op = CRx(0.25 * np.pi)(a, b)
print('Circuit diagram:')
print(cirq.Circuit.from_ops([op]))
class HXGate(cirq.SingleQubitGate):
def _decompose_(self, qubits):
return cirq.H(*qubits), cirq.X(*qubits)
def __str__(self):
return 'HX'
HX = HXGate()
a = cirq.NamedQubit('a')
circuit = cirq.Circuit.from_ops([HX(a)])
print(circuit)
print(cirq.Circuit.from_ops(cirq.decompose(circuit)))
print(cirq.Circuit.from_ops(cirq.decompose_once(HX(a))))
def my_decompose(op):
if isinstance(op, cirq.GateOperation) and isinstance(op.gate, HXGate):
return cirq.Z(*op.qubits), cirq.H(*op.qubits)
cirq.Circuit.from_ops(cirq.decompose(HX(a), intercepting_decomposer=my_decompose))
def keep_h_and_x(op):
return isinstance(op, cirq.GateOperation) and op.gate in [cirq.H, cirq.X]
print(cirq.decompose(HX(a), keep=keep_h_and_x))
import sympy as sp
a = cirq.NamedQubit('a')
b = cirq.NamedQubit('b')
simulator = cirq.Simulator()
val = sp.Symbol('s')
pow_x_gate = cirq.X**val
circuit = cirq.Circuit()
circuit.append([pow_x_gate(a), pow_x_gate(b)])
print('Circuit with parameterized gates:')
print(circuit)
print()
for y in range(5):
result = simulator.simulate(circuit, param_resolver={'s': y / 4.0})
print('s={}: {}'.format(y, np.around(result.final_state, 2)))
resolvers = [cirq.ParamResolver({'s': y / 8.0}) for y in range(9)]
circuit = cirq.Circuit()
circuit.append([pow_x_gate(a), pow_x_gate(b)])
circuit.append([cirq.measure(a), cirq.measure(b)])
results = simulator.run_sweep(program=circuit,
params=resolvers,
repetitions=10)
for i, result in enumerate(results):
print('params: {}\n{}'.format(result.params.param_dict, result))
linspace = cirq.Linspace(start=0, stop=1.0, length=11, key='x')
for p in linspace:
print(p)
import matplotlib.pyplot as plt
plt.plot([1, 2, 3], [5, 3, 10])
# Insert your code here
circuit = cirq.Circuit.from_ops(cirq.depolarize(0.2)(a), cirq.measure(a))
print(circuit)
for i, krauss in enumerate(cirq.channel(cirq.depolarize(0.2))):
print('{}th krauss operator is {}'.format(i, krauss))
print()
for i, krauss in enumerate(cirq.channel(cirq.depolarize(0.2))):
pauli_ex = cirq.expand_matrix_in_orthogonal_basis(krauss, cirq.PAULI_BASIS)
print('{}th krauss operator is {}'.format(i, pauli_ex))
circuit = cirq.Circuit.from_ops(cirq.depolarize(0.2)(a))
print('Circuit:\n{}\n'.format(circuit))
simulator = cirq.DensityMatrixSimulator()
matrix = simulator.simulate(circuit).final_density_matrix
print('Final density matrix:\n{}'.format(matrix))
circuit = cirq.Circuit.from_ops(cirq.depolarize(0.2)(a), cirq.measure(a))
simulator = cirq.DensityMatrixSimulator()
for _ in range(5):
print(simulator.simulate(circuit).final_density_matrix)
for p, u in cirq.mixture(cirq.depolarize(0.2)):
print('prob={}\nunitary\n{}\n'.format(p, u))
d = cirq.depolarize(0.2)
print('does cirq.depolarize(0.2) have _channel_? {}'.format('yes' if getattr(d, '_channel_', None) else 'no'))
print('does cirq.depolarize(0.2) have _mixture_? {}'.format('yes' if getattr(d, '_mixture_', None) else 'no'))
circuit = cirq.Circuit.from_ops(cirq.depolarize(0.5).on(a), cirq.measure(a))
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=10)
print(result)
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.2))
circuit = cirq.Circuit.from_ops(cirq.H(a), cirq.CNOT(a, b), cirq.measure(a, b))
print('Circuit with no noise:\n{}\n'.format(circuit))
system_qubits = sorted(circuit.all_qubits())
noisy_circuit = cirq.Circuit()
for moment in circuit:
noisy_circuit.append(noise.noisy_moment(moment, system_qubits))
print('Circuit with noise:\n{}'.format(noisy_circuit))
noise = cirq.ConstantQubitNoiseModel(cirq.depolarize(0.2))
circuit = cirq.Circuit.from_ops(cirq.H(a), cirq.CNOT(a, b), cirq.measure(a, b))
simulator = cirq.DensityMatrixSimulator(noise=noise)
for i, step in enumerate(simulator.simulate_moment_steps(circuit)):
print('After step {} state was\n{}\n'.format(i, step.density_matrix()))
print(cirq.google.Bristlecone)
brissy = cirq.google.Bristlecone
op = cirq.X.on(cirq.GridQubit(5, 5))
print(brissy.duration_of(op))
q55 = cirq.GridQubit(5, 5)
q56 = cirq.GridQubit(5, 6)
q66 = cirq.GridQubit(6, 6)
q67 = cirq.GridQubit(6, 7)
ops = [cirq.CZ(q55, q56), cirq.CZ(q66, q67)]
circuit = cirq.Circuit.from_ops(ops)
print(circuit)
print('But when we validate it against the device:')
cirq.google.Bristlecone.validate_circuit(circuit)
# (this should throw an error)
ops = [cirq.CZ(q55, q56), cirq.CZ(q66, q67)]
circuit = cirq.Circuit(device=cirq.google.Bristlecone)
circuit.append(ops)
print(circuit)
# your code here
class XZOptimizer(cirq.PointOptimizer):
"""Replaces an X followed by a Z with a Y."""
def optimization_at(self, circuit, index, op):
# Is the gate an X gate?
if isinstance(op, cirq.GateOperation) and (op.gate == cirq.X):
next_op_index = circuit.next_moment_operating_on(op.qubits, index + 1)
qubit = op.qubits[0]
if next_op_index is not None:
next_op = circuit.operation_at(qubit, next_op_index)
if isinstance(next_op, cirq.GateOperation) and (next_op.gate == cirq.Z):
new_op = cirq.Y.on(qubit)
return cirq.PointOptimizationSummary(
clear_span = next_op_index - index + 1,
clear_qubits=op.qubits,
new_operations=[new_op])
opt = XZOptimizer()
circuit = cirq.Circuit.from_ops(cirq.X(a), cirq.Z(a), cirq.CZ(a, b), cirq.X(a))
print('Before\n{}\n'. format(circuit))
opt.optimize_circuit(circuit)
print('After\n{}'.format(circuit))
# Insert your code here.
# Here is a circuit to test this on.
circuit = cirq.Circuit.from_ops(cirq.H(a), cirq.H(a), cirq.H(b),
cirq.CNOT(a, b), cirq.H(a), cirq.H(b),
cirq.CZ(a, b))
# Instantiate your optimizer
# And check that it worked.
print(my_opt.optimizer_circuit(circuit))
cirq.google.is_native_xmon_op(cirq.X.on(cirq.NamedQubit('a')))
cirq.google.is_native_xmon_op(cirq.CNOT.on(cirq.NamedQubit('a'), cirq.NamedQubit('b')))
converter = cirq.google.ConvertToXmonGates()
converted = converter.convert(cirq.CNOT.on(cirq.NamedQubit('a'), cirq.NamedQubit('b')))
print(cirq.Circuit.from_ops(converted))
circuit = cirq.Circuit.from_ops([cirq.CNOT.on(cirq.NamedQubit('a'), cirq.NamedQubit('b'))])
print(cirq.google.optimized_for_xmon(circuit))
cirq.google.gate_to_proto_dict(cirq.X, [cirq.GridQubit(5, 5)])
result = cirq.experiments.rabi_oscillations(
sampler=cirq.Simulator(), # In the future, sampler could point at real hardware.
qubit=cirq.LineQubit(0)
)
result.plot()
class InconsistentXGate(cirq.SingleQubitGate):
def _decompose_(self, qubits):
yield cirq.H(qubits[0])
yield cirq.Z(qubits[0])
yield cirq.H(qubits[0])
def _unitary_(self):
return np.array([[0, -1j], [1j, 0]]) # Oops! Y instead of X!
cirq.testing.assert_decompose_is_consistent_with_unitary(InconsistentXGate())
a, b, c = cirq.LineQubit.range(3)
circuit = cirq.Circuit.from_ops(cirq.H(a), cirq.H(c), cirq.CNOT(a, b), cirq.CCZ(a, b, c))
print(circuit.to_qasm())
from cirq.contrib.quirk.export_to_quirk import circuit_to_quirk_url
print(circuit_to_quirk_url(circuit))
|
https://github.com/Slope86/QiskitExtension
|
Slope86
|
"""Module to store, manipulate and visualize quantum state vector."""
from __future__ import annotations
import copy
import itertools
import re
from typing import Iterable, List, Tuple
import numpy as np
from IPython.display import Latex
from numpy.typing import NDArray
from qiskit import QuantumCircuit
from qiskit.circuit import Instruction
from qiskit.exceptions import QiskitError
from qiskit.quantum_info import Statevector
from scipy import stats
from qiskit_extension import latex_drawer
from qiskit_extension.ket import Ket
class StateVector2(Statevector):
"""An extended class of Statevector from Qiskit:
https://qiskit.org/documentation/stubs/qiskit.quantum_info.Statevector.html
Args:
data (np.ndarray | list | Statevector | QuantumCircuit | Instruction):
Data from which the statevector can be constructed. This can be either a complex
vector, another statevector, a ``QuantumCircuit`` or ``Instruction``.
If the data is a circuit or instruction, the statevector is constructed by assuming that
all qubits are initialized to the zero state.
dims (int | tuple | list, optional): The subsystem dimension of the state.
"""
def __init__(self, data, dims: int | Iterable[int] | None = None) -> None:
if not isinstance(data, np.ndarray | list | Statevector | QuantumCircuit | Instruction):
raise QiskitError("Input only accepts np.ndarray | list | Statevector | QuantumCircuit | Instruction")
# REVERSE the order of qubits to fit textbook notation
if isinstance(data, QuantumCircuit):
data = data.reverse_bits()
elif isinstance(data, Instruction):
data = Statevector(data).reverse_qargs()
self._data: NDArray[np.complex128]
super().__init__(data, dims)
self._num_of_qubit = int(np.log2(len(self._data)))
self._basis = ["z"] * self._num_of_qubit
@classmethod
def __init__with_basis(
cls, data, dims: int | Iterable[int] | None = None, basis: List[str] | str = []
) -> StateVector2:
"""Initialize statevector with basis."""
state_vector = cls(data, dims)
state_vector.basis = list(basis) + ["z"] * (state_vector._num_of_qubit - len(basis))
return state_vector
def __repr__(self) -> str:
"""Return the official string representation of a Statevector."""
vector_str = np.array2string(self.to_matrix(), separator=", ")
return f"Statevector:\n{vector_str}"
@property
def data(self) -> NDArray[np.complex128]:
return self._data.copy()
@property
def basis(self) -> List[str]:
return self._basis.copy()
@data.setter
def data(self, data: NDArray[np.complex128]):
self._data = data.copy()
@basis.setter
def basis(self, basis: List[str]):
self._basis = basis.copy()
def copy(self) -> StateVector2:
"""Return a copy of the current statevector."""
return copy.deepcopy(self)
def to_matrix(self) -> NDArray[np.complex128]:
"""Return matrix form of statevector"""
clone = self.copy()
clone._basis_convert("z" * self._num_of_qubit)
vector = clone._data
matrix = vector[np.newaxis].T # type: ignore
return matrix
def entropy(self, state: StateVector2 | Statevector | None = None) -> float:
"""Return entropy of input statevector."""
if state is None:
state = self
return stats.entropy(state.probabilities(), base=2) # type: ignore
def evolve(self, circ: QuantumCircuit | NDArray, qargs: List[int] | None = None) -> StateVector2:
"""Evolve self(statevector) by a quantum circuit or matrix.
return the evolved state as a new statevector. (self's state will not be changed)
Args:
circ (QuantumCircuit): The circ to evolve by.
qargs (List[int], optional): A list of subsystem positions to apply the operator on.
Returns:
StateVector2: The new evolved statevector.
"""
clone = self.copy()
original_basis = clone.basis
clone._basis_convert(["z"] * self._num_of_qubit)
new_state = clone._evolve(circ, qargs)
new_state._basis_convert(original_basis)
return new_state
def _evolve(self, circ: QuantumCircuit | NDArray, qargs: List[int] | None = None) -> StateVector2:
"""Evolve self(z-basis statevector) by a quantum circuit or matrix.
return the evolved state as a new statevector. (self's state will not be changed)
Args:
circ (QuantumCircuit): The object to evolve by.
qargs (List[int], optional): A list of subsystem positions to apply the operator on.
Returns:
StateVector2: The new evolved statevector.
"""
if not isinstance(circ, QuantumCircuit | np.ndarray):
raise QiskitError("Input is not a QuantumCircuit.")
if isinstance(circ, QuantumCircuit):
circ = circ.reverse_bits() # REVERSE the order of qubits to fit textbook notation
evolve_data = super().evolve(circ, qargs).data
return StateVector2.__init__with_basis(data=evolve_data, basis=self.basis)
def measure(
self, measure: List[int] | int | str, basis: List[str] | str | None = None, shot=100
) -> List[StateVector2]:
"""measure statevector
Args:
measure (List[int] | int | str): which qubits to measure
basis (List[str] | str | None, optional): measure in what basis. Defaults to current stored basis.
shot (int, optional): number of shots. Defaults to 100.
Returns:
List[StateVector2]: list of statevector after measurement
"""
states = self._measure(measure, basis, shot)[1]
for state in states:
if state is not None:
state._basis_convert(self.basis)
return states
def _measure(
self, measure: List[int] | int | str, basis: List[str] | str | None = None, shot=100
) -> Tuple[List[StateVector2], List[StateVector2]]:
"""measure statevector
Args:
measure (List[int] | int | str): which qubits to measure
basis (List[str] | str, optional): measure in what basis. Defaults to current stored basis.
shot (int, optional): number of shots. Defaults to 100.
Returns:
Tuple[List[StateVector2], List[StateVector2]]: list of measured statevector,
list of remained statevector after measurement
"""
clone = self.copy()
if isinstance(measure, str):
measure = [int(char) for char in measure]
elif isinstance(measure, int):
measure = [measure]
if basis is not None:
convert_basis = clone.basis
for i in range(len(basis)):
convert_basis[measure[i]] = basis[i]
clone._basis_convert(convert_basis)
measure_state_list = [None] * 2 ** len(measure) # crate empty list for saving measure state
remain_state_list = [None] * 2 ** len(measure) # crate empty list for saving remain state
for _ in range(shot):
measure_ket: str
remain_state: Statevector
# REVERSE measure bit number to fit qiskit statevector measure notation
reverse_measure = [clone._num_of_qubit - 1 - i for i in measure]
measure_ket, remain_state = Statevector(clone.data).measure(qargs=reverse_measure) # type: ignore
measure_ket = measure_ket[::-1] # REVERSE the order of qubits to fit textbook notation
if measure_state_list[int(measure_ket, 2)] is None:
basis = clone.basis
measure_basis = ""
for i in measure:
measure_basis += basis[i]
basis_convert_measure_ket = ""
for b, k in zip(measure_basis, measure_ket):
match b:
case "z":
basis_convert_measure_ket += Ket.z1 if int(k) else Ket.z0
case "x":
basis_convert_measure_ket += Ket.x1 if int(k) else Ket.x0
case "y":
basis_convert_measure_ket += Ket.y1 if int(k) else Ket.y0
measure_state_list[int(measure_ket, 2)] = clone._from_label(basis_convert_measure_ket, to_z_basis=False)
remain_state_list[int(measure_ket, 2)] = StateVector2.__init__with_basis(
data=remain_state.data, basis=clone.basis
)
return (measure_state_list, remain_state_list)
def show_matrix(self):
"""show the matrix form of statevector in LaTeX"""
return latex_drawer.matrix_to_latex(self.to_matrix())
def show_state(
self,
basis: List[str] | str | None = None,
hide: List[int] | str = [],
output_length: int = 2,
output: str = "latex",
):
"""visualize statevector
Args:
basis (List[str] | str, optional): convert statevector's basis to input basis.
Defaults to skip basis convert.
hide (List[int] | str, optional): hide qubits. Default to show all qubits.
output_length (int, optional): 2^output_length = number of terms in each line. Defaults to 2(= 4 terms/line)
output (str, optional): visualization method. Defaults to "latex".
Returns:
matplotlib.Figure or str or TextMatrix or IPython.display.Latex: visualization output
"""
clone = self.copy()
if basis is not None:
clone._basis_convert(basis)
match output:
case "text":
return print(clone)
case "latex":
return latex_drawer.state_to_latex(clone, hide, output_length)
case "latex_source":
return latex_drawer.state_to_latex(clone, hide, output_length, source=True)
case _:
return clone.draw(output=output)
def show_measure(
self,
measure: List[int] | int | str,
basis: List[str] | str | None = None,
hide: List[int] | str = [],
output_length: int = 2,
remaining_basis: List[str] | str | None = None,
) -> Latex:
"""visualize measure result
Args:
measure (List[int] | int | str): qubits to measure
basis (List[int] | str, optional): measure in what basis. Defaults to z basis.
hide (List[int] | str, optional): hide qubits. Default to show all qubits.
output_length (int, optional): 2^output_length = number of terms in each line. Defaults to 2(= 4 terms/line)
remaining_basis (List[str] | str, optional): change statevector's basis to input basis before measure.
Returns:
Latex: visualization output
"""
if isinstance(hide, str):
hide = [int(char) for char in hide]
elif isinstance(hide, int):
hide = [hide]
if isinstance(measure, str):
measure = [int(char) for char in measure]
elif isinstance(measure, int):
measure = [measure]
clone = self.copy()
if remaining_basis is not None:
remaining_basis = list(remaining_basis) + ["-"] * (self._num_of_qubit - len(remaining_basis))
if basis is None:
basis = ["z"] * len(measure)
for i, b in zip(measure, basis):
remaining_basis[i] = b
clone._basis_convert(remaining_basis)
result = clone._measure(measure=measure, basis=basis, shot=4 * 2 ** len(measure))
return latex_drawer.measure_result_to_latex(result, measure + hide, output_length) # type: ignore
@classmethod
def from_int(cls, i: int, dims: int | Iterable[int]) -> StateVector2:
"""Return a computational basis statevector.
Args:
i (int): the basis state element.
dims (int | Iterable[int]): The subsystem dimensions of the statevector
Returns:
StateVector2: The statevector object.
"""
state = super().from_int(i, dims)
return cls(state.data, dims)
@classmethod
def from_instruction(cls, instruction):
"""Return the output statevector of an instruction.
The statevector is initialized in the state :math:`|{0,\\ldots,0}\\rangle` of the
same number of qubits as the input instruction or circuit, evolved
by the input instruction, and the output statevector returned.
Args:
instruction (qiskit.circuit.Instruction or QuantumCircuit): instruction or circuit
Returns:
Statevector: The final statevector.
Raises:
QiskitError: if the instruction contains invalid instructions for
the statevector simulation.
"""
if not isinstance(instruction, QuantumCircuit | Instruction):
raise QiskitError("Input is not a valid instruction or circuit.")
return cls(instruction)
@classmethod
def from_label(cls, *args: str | Tuple[complex, str]) -> StateVector2:
"""Create a state vector from input coefficient and label string.
Example:
from_label("0", "1") = (|0> + |1>)/√2,
from_label("00", "01", "10", "11") = (|00> + |01> + |10> + |11>)/2 = |++>,
from_label( (2**0.5,"0") , "+" , (-1,"-") ) = ( √2|0> + |+> - |-> )/2 = |+>
Args:
args (str | Tuple[complex, str]): The input label string or tuple of coefficient and label string.
Returns:
StateVector2: The statevector object.
Raises:
QiskitError: if labels contain invalid characters or labels have different number of qubits.
"""
coeffs: List[complex] = []
labels: List[str] = []
for i, arg in enumerate(args):
if isinstance(arg, tuple):
coeffs.append(arg[0])
labels.append(arg[1])
else:
coeffs.append(1.0)
labels.append(arg)
if not Ket.check_valid(labels[i]):
raise QiskitError("Invalid label string.")
if len(labels[0]) != len(labels[i]):
raise QiskitError("Each label's number of qubits must be the same.")
state: StateVector2 = cls._from_label(labels[0]) * coeffs[0]
for coeff, label in zip(coeffs[1:], labels[1:]):
state += cls._from_label(label) * coeff
if type(state) is not StateVector2:
raise QiskitError("Unexpected error.")
state /= super(type(state), state).trace() ** 0.5
return state
@classmethod
def _from_label(cls, label: str, to_z_basis: bool = True) -> StateVector2:
if to_z_basis:
label = label.replace(Ket.z0, "0")
label = label.replace(Ket.x0, "+")
label = label.replace(Ket.y0, "r")
label = label.replace(Ket.z1, "1")
label = label.replace(Ket.x1, "-")
label = label.replace(Ket.y1, "l")
state = super().from_label(label)
return cls(state.data)
basis = ""
for ket in label:
match ket:
case Ket.z0 | Ket.z1:
basis += "z"
case Ket.x0 | Ket.x1:
basis += "x"
case Ket.y0 | Ket.y1:
basis += "y"
label = label.replace(Ket.z0, "0")
label = label.replace(Ket.x0, "0")
label = label.replace(Ket.y0, "0")
label = label.replace(Ket.z1, "1")
label = label.replace(Ket.x1, "1")
label = label.replace(Ket.y1, "1")
state = super().from_label(label)
return cls.__init__with_basis(state.data, basis=basis)
def expand(self, other):
"""Return the tensor product state other ⊗ self.
Args:
other (Statevector2): a quantum state object.
Returns:
Statevector: the tensor product state other ⊗ self.
Raises:
QiskitError: if other is not a quantum state.
"""
clone = self.copy()
clone._basis_convert("z" * self._num_of_qubit)
other_clone = other.copy()
other_clone._basis_convert("z" * other._num_of_qubit)
state_expand = super(type(other_clone), other_clone).expand(clone)
return StateVector2(state_expand.data)
def _basis_convert(
self,
basis: List[str] | str = [],
algorithm: str = "global",
) -> None:
"""Convert basis of statevector
Args:
basis (List[str] | str, optional):new basis. Defaults to auto choose basis with minimum entropy.
algorithm (str, optional): if don't specify which basis to convert, (basis = "-")
convert basis to basis with "local" or "global" minimum entropy. Defaults to "global".
"""
# check if input is valid
target_basis = list(basis) + ["-"] * (self._num_of_qubit - len(basis))
del basis
if re.match(R"^[\-xyz]+$", "".join(target_basis)) is None:
raise QiskitError("Invalid basis.")
# convert basis using QuantumCircuit
auto_basis_index = []
circ_convert = QuantumCircuit(self._num_of_qubit)
for i in range(self._num_of_qubit):
if target_basis[i] == self._basis[i]:
continue
if target_basis[i] != "-":
self._xyz_convert_circ(self.basis[i], target_basis[i], circ_convert, i)
self._basis[i] = target_basis[i]
else:
auto_basis_index.append(i)
self._data = self._evolve(circ_convert)._data
if not auto_basis_index:
return
# if user don't specify which basis to convert, convert basis to basis with minimum entropy
match algorithm:
case "global":
if len(auto_basis_index) > 8:
print(
"Warning: global minimum entropy basis convert with more then 8 qubits might take a long time."
)
new_basis = self._global_min_entropy_basis(auto_basis_index)
case "local":
new_basis = self._local_min_entropy_basis(auto_basis_index)
case _:
raise QiskitError("Invalid min_entropy_basis_find_method.")
self._basis_convert(new_basis)
def _global_min_entropy_basis(self, auto_basis_index: List[int]) -> List[str]:
"""find basis with global minimum entropy
Args:
auto_basis_index (List[int]): index of auto-choose-basis
Returns:
List[str]: basis with global minimum entropy
"""
num_of_auto_basis = len(auto_basis_index)
min_entropy = float("inf")
min_basis = self.basis
try_basis = self.basis
for basis in itertools.product(["z", "x", "y"], repeat=num_of_auto_basis): # type: ignore
for i in range(num_of_auto_basis):
try_basis[auto_basis_index[i]] = basis[i]
try_state = self.copy()
try_state._basis_convert(try_basis)
if (entropy := try_state.entropy()) < min_entropy:
min_entropy = entropy
min_basis = try_basis.copy()
return min_basis
def _local_min_entropy_basis(self, auto_basis_index: List[int]) -> List[str]:
"""find basis with local minimum entropy
Args:
auto_basis_index (List[int]): index of auto-choose-basis
Returns:
List[str]: basis with local minimum entropy
"""
# Step 1: Change all auto-choose-basis to y, e.g. [-, -, -, -] -> [z, z, z, z], calculate entropy
# Step 2,3: Same as Step 1, but with x-basis and y-basis
# Step 4: from Step 1 to 3, choose the basis with minimum entropy.
clone_state = self.copy()
min_entropy = float("inf")
min_basis = clone_state.basis
for basis in ["z", "x", "y"]:
try_state = clone_state.copy()
try_basis = try_state.basis
for i in auto_basis_index:
try_basis[i] = basis
try_state._basis_convert(try_basis)
if (entropy := try_state.entropy()) < min_entropy:
min_entropy = entropy
min_basis = try_basis
clone_state._basis_convert(min_basis)
# Step 1: Change the first auto-choose-basis to y, e.g. [-, -, -, -] -> [y, -, -, -], calculate entropy,
# Step 2,3: Same as Step 1, but with x-basis and z-basis
# Step 4: from Step 1 to 3, choose the basis with minimum entropy.
# Step 5: Repeat Step 1 to 4 for the second auto-choose-basis, and so on. (greedy)
# e.g. [-, -, -, -] -> [x, -, -, -] -> [x, z, -, -] -> [x, z, y, -] -> [x, z, y, z]
min_entropy = float("inf")
min_basis = clone_state.basis
for i in auto_basis_index:
try_basis = clone_state.basis
for basis in ["y", "x", "z"]:
try_basis[i] = basis
try_state = clone_state.copy()
try_state._basis_convert(try_basis)
if (entropy_tmp := try_state.entropy()) < min_entropy:
min_entropy = entropy_tmp
min_basis[i] = basis
clone_state._basis_convert(min_basis)
return min_basis
@staticmethod
def _xyz_convert_circ(basis: str, new_basis: str, circ: QuantumCircuit, qubit: int) -> None:
"""Add the corresponding gate that converts different basis
Args:
basis (str): original basis
new_basis (str): new basis
circ (QuantumCircuit): quantum circuit to convert basis
Returns:
QuantumCircuit: quantum circuit to convert basis
"""
if basis == new_basis:
return
basis += new_basis
match basis:
case "zx" | "xz":
circ.h(qubit)
case "zy":
circ.sdg(qubit)
circ.h(qubit)
case "yz":
circ.h(qubit)
circ.s(qubit)
case "xy":
circ.h(qubit)
circ.sdg(qubit)
circ.h(qubit)
case "yx":
circ.h(qubit)
circ.s(qubit)
circ.h(qubit)
return
|
https://github.com/vindem/quantumMD
|
vindem
|
from qiskit.circuit.library import RealAmplitudes, EfficientSU2
efficientSU2 = EfficientSU2(1, reps=1, entanglement='linear', insert_barriers=True)
realAmplitudes = RealAmplitudes(1,reps=1)
efficientSU2.draw(output='text')
realAmplitudes.draw(output='text')
import numpy as np
rdist = np.random.rand(1, 1)
rdistt = np.transpose(rdist)
z1 = np.zeros((1, 1))
z2 = np.zeros((1, 1))
matrix = np.block([[z1, rdist], [rdistt, z2]])
from qiskit import IBMQ
from qiskit.providers.ibmq import least_busy
from qiskit.providers import JobStatus
IBMQ.load_account()
provider = IBMQ.get_provider('ibm-q-research-2','vienna-uni-tech-1','main')
backend = least_busy(
provider.backends(
filters=lambda x: x.configuration().n_qubits >= 3
and not x.configuration().simulator
and x.status().operational
and x.configuration().dynamic_reprate_enabled
)
)
print(backend.name())
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow.primitive_ops import MatrixOp
import time
matrix_op = MatrixOp(matrix)
vqe_inputs = {
'ansatz': realAmplitudes,
'operator': matrix_op,
'optimizer': COBYLA(max_iter=100, tol=0.00001),
'initial_point': np.random.random(realAmplitudes.num_parameters),
'measurement_error_mitigation': True,
'shots': 1024
}
options = {
'backend_name': backend.name(),
}
job = provider.runtime.run(program_id='vqe', inputs=vqe_inputs, options=options)
while job.status() != JobStatus.RUNNING:
pass
start = time.time()
res = job.result()
end = time.time()
print("Runtime: "+str(end-start))
from qiskit.algorithms.optimizers import COBYLA
from qiskit.opflow.primitive_ops import MatrixOp
import time
matrix_op = MatrixOp(matrix)
vqe_inputs = {
'ansatz': efficientSU2,
'operator': matrix_op,
'optimizer': COBYLA(max_iter=100, tol=0.00001),
'initial_point': np.random.random(efficientSU2.num_parameters),
'measurement_error_mitigation': True,
'shots': 1024
}
options = {
'backend_name': backend.name(),
}
job = provider.runtime.run(program_id='vqe', inputs=vqe_inputs, options=options)
while job.status() != JobStatus.RUNNING:
pass
start = time.time()
res = job.result()
end = time.time()
print("Runtime: "+str(end-start))
|
https://github.com/arian-code/nptel_quantum_assignments
|
arian-code
|
from sympy import *
from sympy.physics.quantum.state import Ket, Bra
from sympy.physics.quantum import TensorProduct
import numpy as np
init_printing(use_unicode=True)
plus=Matrix([1/sqrt(2), 1/sqrt(2)])
zero=Matrix([1, 0])
minus=Matrix([1/sqrt(2), -1/sqrt(2)])
plus, zero, minus
TensorProduct(plus, zero, minus)
|
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/ElePT/qiskit-algorithms-test
|
ElePT
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022, 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Compute-uncompute fidelity interface using primitives
"""
from __future__ import annotations
from collections.abc import Sequence
from copy import copy
from qiskit import QuantumCircuit
from qiskit.primitives import BaseSampler
from qiskit.providers import Options
from ..exceptions import AlgorithmError
from .base_state_fidelity import BaseStateFidelity
from .state_fidelity_result import StateFidelityResult
class ComputeUncompute(BaseStateFidelity):
r"""
This class leverages the sampler primitive to calculate the state
fidelity of two quantum circuits following the compute-uncompute
method (see [1] for further reference).
The fidelity can be defined as the state overlap.
.. math::
|\langle\psi(x)|\phi(y)\rangle|^2
where :math:`x` and :math:`y` are optional parametrizations of the
states :math:`\psi` and :math:`\phi` prepared by the circuits
``circuit_1`` and ``circuit_2``, respectively.
**Reference:**
[1] Havlíček, V., Córcoles, A. D., Temme, K., Harrow, A. W., Kandala,
A., Chow, J. M., & Gambetta, J. M. (2019). Supervised learning
with quantum-enhanced feature spaces. Nature, 567(7747), 209-212.
`arXiv:1804.11326v2 [quant-ph] <https://arxiv.org/pdf/1804.11326.pdf>`_
"""
def __init__(
self,
sampler: BaseSampler,
options: Options | None = None,
local: bool = False,
) -> None:
r"""
Args:
sampler: Sampler primitive instance.
options: Primitive backend runtime options used for circuit execution.
The order of priority is: options in ``run`` method > fidelity's
default options > primitive's default setting.
Higher priority setting overrides lower priority setting.
local: If set to ``True``, the fidelity is averaged over
single-qubit projectors
.. math::
\hat{O} = \frac{1}{N}\sum_{i=1}^N|0_i\rangle\langle 0_i|,
instead of the global projector :math:`|0\rangle\langle 0|^{\otimes n}`.
This coincides with the standard (global) fidelity in the limit of
the fidelity approaching 1. Might be used to increase the variance
to improve trainability in algorithms such as :class:`~.time_evolvers.PVQD`.
Raises:
ValueError: If the sampler is not an instance of ``BaseSampler``.
"""
if not isinstance(sampler, BaseSampler):
raise ValueError(
f"The sampler should be an instance of BaseSampler, " f"but got {type(sampler)}"
)
self._sampler: BaseSampler = sampler
self._local = local
self._default_options = Options()
if options is not None:
self._default_options.update_options(**options)
super().__init__()
def create_fidelity_circuit(
self, circuit_1: QuantumCircuit, circuit_2: QuantumCircuit
) -> QuantumCircuit:
"""
Combines ``circuit_1`` and ``circuit_2`` to create the
fidelity circuit following the compute-uncompute method.
Args:
circuit_1: (Parametrized) quantum circuit.
circuit_2: (Parametrized) quantum circuit.
Returns:
The fidelity quantum circuit corresponding to circuit_1 and circuit_2.
"""
if len(circuit_1.clbits) > 0:
circuit_1.remove_final_measurements()
if len(circuit_2.clbits) > 0:
circuit_2.remove_final_measurements()
circuit = circuit_1.compose(circuit_2.inverse())
circuit.measure_all()
return circuit
def _run(
self,
circuits_1: QuantumCircuit | Sequence[QuantumCircuit],
circuits_2: QuantumCircuit | Sequence[QuantumCircuit],
values_1: Sequence[float] | Sequence[Sequence[float]] | None = None,
values_2: Sequence[float] | Sequence[Sequence[float]] | None = None,
**options,
) -> StateFidelityResult:
r"""
Computes the state overlap (fidelity) calculation between two
(parametrized) circuits (first and second) for a specific set of parameter
values (first and second) following the compute-uncompute method.
Args:
circuits_1: (Parametrized) quantum circuits preparing :math:`|\psi\rangle`.
circuits_2: (Parametrized) quantum circuits preparing :math:`|\phi\rangle`.
values_1: Numerical parameters to be bound to the first circuits.
values_2: Numerical parameters to be bound to the second circuits.
options: Primitive backend runtime options used for circuit execution.
The order of priority is: options in ``run`` method > fidelity's
default options > primitive's default setting.
Higher priority setting overrides lower priority setting.
Returns:
The result of the fidelity calculation.
Raises:
ValueError: At least one pair of circuits must be defined.
AlgorithmError: If the sampler job is not completed successfully.
"""
circuits = self._construct_circuits(circuits_1, circuits_2)
if len(circuits) == 0:
raise ValueError(
"At least one pair of circuits must be defined to calculate the state overlap."
)
values = self._construct_value_list(circuits_1, circuits_2, values_1, values_2)
# The priority of run options is as follows:
# options in `evaluate` method > fidelity's default options >
# primitive's default options.
opts = copy(self._default_options)
opts.update_options(**options)
job = self._sampler.run(circuits=circuits, parameter_values=values, **opts.__dict__)
try:
result = job.result()
except Exception as exc:
raise AlgorithmError("Sampler job failed!") from exc
if self._local:
raw_fidelities = [
self._get_local_fidelity(prob_dist, circuit.num_qubits)
for prob_dist, circuit in zip(result.quasi_dists, circuits)
]
else:
raw_fidelities = [
self._get_global_fidelity(prob_dist) for prob_dist in result.quasi_dists
]
fidelities = self._truncate_fidelities(raw_fidelities)
return StateFidelityResult(
fidelities=fidelities,
raw_fidelities=raw_fidelities,
metadata=result.metadata,
options=self._get_local_options(opts.__dict__),
)
@property
def options(self) -> Options:
"""Return the union of estimator options setting and fidelity default options,
where, if the same field is set in both, the fidelity's default options override
the primitive's default setting.
Returns:
The fidelity default + estimator options.
"""
return self._get_local_options(self._default_options.__dict__)
def update_default_options(self, **options):
"""Update the fidelity's default options setting.
Args:
**options: The fields to update the default options.
"""
self._default_options.update_options(**options)
def _get_local_options(self, options: Options) -> Options:
"""Return the union of the primitive's default setting,
the fidelity default options, and the options in the ``run`` method.
The order of priority is: options in ``run`` method > fidelity's
default options > primitive's default setting.
Args:
options: The fields to update the options
Returns:
The fidelity default + estimator + run options.
"""
opts = copy(self._sampler.options)
opts.update_options(**options)
return opts
def _get_global_fidelity(self, probability_distribution: dict[int, float]) -> float:
"""Process the probability distribution of a measurement to determine the
global fidelity.
Args:
probability_distribution: Obtained from the measurement result
Returns:
The global fidelity.
"""
return probability_distribution.get(0, 0)
def _get_local_fidelity(
self, probability_distribution: dict[int, float], num_qubits: int
) -> float:
"""Process the probability distribution of a measurement to determine the
local fidelity by averaging over single-qubit projectors.
Args:
probability_distribution: Obtained from the measurement result
Returns:
The local fidelity.
"""
fidelity = 0.0
for qubit in range(num_qubits):
for bitstring, prob in probability_distribution.items():
# Check whether the bit representing the current qubit is 0
if not bitstring >> qubit & 1:
fidelity += prob / num_qubits
return fidelity
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
p = 0.2
import numpy as np
from qiskit.circuit import QuantumCircuit
class BernoulliA(QuantumCircuit):
"""A circuit representing the Bernoulli A operator."""
def __init__(self, probability):
super().__init__(1) # circuit on 1 qubit
theta_p = 2 * np.arcsin(np.sqrt(probability))
self.ry(theta_p, 0)
class BernoulliQ(QuantumCircuit):
"""A circuit representing the Bernoulli Q operator."""
def __init__(self, probability):
super().__init__(1) # circuit on 1 qubit
self._theta_p = 2 * np.arcsin(np.sqrt(probability))
self.ry(2 * self._theta_p, 0)
def power(self, k):
# implement the efficient power of Q
q_k = QuantumCircuit(1)
q_k.ry(2 * k * self._theta_p, 0)
return q_k
A = BernoulliA(p)
Q = BernoulliQ(p)
from qiskit.algorithms import EstimationProblem
problem = EstimationProblem(
state_preparation=A, # A operator
grover_operator=Q, # Q operator
objective_qubits=[0], # the "good" state Psi1 is identified as measuring |1> in qubit 0
)
from qiskit.primitives import Sampler
sampler = Sampler()
from qiskit.algorithms import AmplitudeEstimation
ae = AmplitudeEstimation(
num_eval_qubits=3, # the number of evaluation qubits specifies circuit width and accuracy
sampler=sampler,
)
ae_result = ae.estimate(problem)
print(ae_result.estimation)
import matplotlib.pyplot as plt
# plot estimated values
gridpoints = list(ae_result.samples.keys())
probabilities = list(ae_result.samples.values())
plt.bar(gridpoints, probabilities, width=0.5 / len(probabilities))
plt.axvline(p, color="r", ls="--")
plt.xticks(size=15)
plt.yticks([0, 0.25, 0.5, 0.75, 1], size=15)
plt.title("Estimated Values", size=15)
plt.ylabel("Probability", size=15)
plt.xlabel(r"Amplitude $a$", size=15)
plt.ylim((0, 1))
plt.grid()
plt.show()
print("Interpolated MLE estimator:", ae_result.mle)
ae_circuit = ae.construct_circuit(problem)
ae_circuit.decompose().draw(
"mpl", style="iqx"
) # decompose 1 level: exposes the Phase estimation circuit!
from qiskit import transpile
basis_gates = ["h", "ry", "cry", "cx", "ccx", "p", "cp", "x", "s", "sdg", "y", "t", "cz"]
transpile(ae_circuit, basis_gates=basis_gates, optimization_level=2).draw("mpl", style="iqx")
from qiskit.algorithms import IterativeAmplitudeEstimation
iae = IterativeAmplitudeEstimation(
epsilon_target=0.01, # target accuracy
alpha=0.05, # width of the confidence interval
sampler=sampler,
)
iae_result = iae.estimate(problem)
print("Estimate:", iae_result.estimation)
iae_circuit = iae.construct_circuit(problem, k=3)
iae_circuit.draw("mpl", style="iqx")
from qiskit.algorithms import MaximumLikelihoodAmplitudeEstimation
mlae = MaximumLikelihoodAmplitudeEstimation(
evaluation_schedule=3, # log2 of the maximal Grover power
sampler=sampler,
)
mlae_result = mlae.estimate(problem)
print("Estimate:", mlae_result.estimation)
from qiskit.algorithms import FasterAmplitudeEstimation
fae = FasterAmplitudeEstimation(
delta=0.01, # target accuracy
maxiter=3, # determines the maximal power of the Grover operator
sampler=sampler,
)
fae_result = fae.estimate(problem)
print("Estimate:", fae_result.estimation)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/suvoooo/Qubits-Qiskit
|
suvoooo
|
### calculate the probability for theta = 1 degree
import math
import cmath
def probs_unitary(ang):
ang = math.radians(ang) # 1 degree
y = complex(0, ang) #i1
y0 = 0.5*(1 + cmath.exp(y))
#print ('probability for getting 0: ', abs(y0)**2)
y1 = 0.5*(1 - cmath.exp(y))
#print ('probability for getting 1: ', abs(y1)**2)
return abs(y0)**2, abs(y1)**2
prob0, prob1 = probs_unitary(1)
print (r'probability for getting 0 and 1 for $\theta=1$: ', prob0, prob1)
prob0_10, prob1_10 = probs_unitary(10)
print (r'probability for getting 0 and 1 for $\theta=10$: ', prob0_10, prob1_10)
from google.colab import drive
drive.mount('/content/drive/')
!pip install qiskit
import qiskit as q
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
# from mpl_toolkits.mplot3d import proj3d
print (q.__version__)
print(matplotlib.__version__)
style = {'backgroundcolor': 'lavender', 'dpi':200, 'subfontsize':10}
PEcircuit = q.QuantumCircuit(3, 2)
PEcircuit.x(2) # this is the eigen state of S gate; in figures above this $\psi$
PEcircuit.draw()
# start by applying the H gates
for qubit in range(2):
PEcircuit.h(qubit)
PEcircuit.draw()
repetitions = 1
for counting_qubit in range(2):
for i in range(repetitions):
PEcircuit.cp(np.pi/2, counting_qubit, 2); # This is CU # QuantumCircuit.cp(theta, control_qubit, target_qubit, label=None, ctrl_state=None)
# importantly to apply controlled phase rotation we need to know the rotation angle beforehand
repetitions *= 2 # 2^{n-1} factor
PEcircuit.draw()
!pip install pylatexenc
style = {'backgroundcolor': 'lavender', 'dpi':200, 'subfontsize':10}
PEcircuit.draw(output='mpl', scale=0.8, style=style, filename='/content/drive/My Drive/Colab Notebooks/Quantum_Compute/FourierTransform/2bits_QPE_QiskitEx.png')
def qft_dagger(qc, n):
"""n-qubit inverse qft
first n qubits will be transformed
check the qft circuit implementation first
"""
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-math.pi/float(2**(j-m)), m, j)
qc.h(j)
PEcircuit.barrier()
# Apply inverse QFT
qft_dagger(PEcircuit, 2)
# Measure
PEcircuit.barrier()
for n in range(2):
PEcircuit.measure(n,n)
# PEcircuit.draw(output='mpl', style=style, filename='/content/drive/My Drive/Colab Notebooks/Quantum_Compute/FourierTransform/2bits_QPE_QiskitEx_Full.png')
aer_sim = q.Aer.get_backend('aer_simulator')
shots = 2048
t_PEcircuit = q.transpile(PEcircuit, aer_sim)
qobj = q.assemble(t_PEcircuit, shots=shots)
results = aer_sim.run(qobj).result()
answer = results.get_counts()
q.visualization.plot_histogram(answer)
PEcircuit_1 = q.QuantumCircuit(4, 3)
PEcircuit_1.x(3) # this is the eigen state of S gate; in figures above this $\psi$
for qubit in range(3):
PEcircuit_1.h(qubit)
repetitions = 1
for counting_qubit in range(3):
for i in range(repetitions):
PEcircuit_1.cp(np.pi/2, counting_qubit, 3) # This is CU # QuantumCircuit.cp(theta, control_qubit, target_qubit, label=None, ctrl_state=None)
# importantly to apply controlled phase rotation we need to know the rotation angle beforehand
repetitions *= 2 # 2^{n-1} factor
PEcircuit_1.draw()
PEcircuit_1.barrier()
# Apply inverse QFT
qft_dagger(PEcircuit_1, 3)
# Measure
PEcircuit_1.barrier()
for n in range(3):
PEcircuit_1.measure(n, n)
PEcircuit_1.draw(output='mpl', style=style, filename='/content/drive/My Drive/Colab Notebooks/Quantum_Compute/FourierTransform/3bits_QPE_QiskitEx.png')
aer_sim = q.Aer.get_backend('aer_simulator')
shots = 2048
t_PEcircuit_1 = q.transpile(PEcircuit_1, aer_sim)
qobj = q.assemble(t_PEcircuit_1, shots=shots)
results_1 = aer_sim.run(qobj).result()
answer_1 = results_1.get_counts()
q.visualization.plot_histogram(answer_1)
PEcircuit_1.num_qubits-1
def qpe_circ(nq, angle):
"""
generic qpe circuit
nq: number of qubits
angle: theta as defined in description
"""
qc = q.QuantumCircuit(nq+1, nq) # num qubits + eigen state, for measuring we need num qubits = classical bits for measure.
qc.x(nq) # apply the not gate to create state 1, i.e. eigen state at the last qubit
for qubit in range(nq):
qc.h(qubit)
repetitions = 1
for counting_qubit in range(qc.num_qubits - 1): #qc.num_qubits - 1 = nq
for i in range(repetitions):
qc.cp(np.pi *2 * angle, counting_qubit, qc.num_qubits-1); # This is CU # QuantumCircuit.cp(theta, control_qubit, target_qubit, label=None, ctrl_state=None)
# importantly to apply controlled phase rotation we need to know the rotation angle beforehand
repetitions *= 2 # 2^{n-1} factor
qc.barrier()
qft_dagger(qc, qc.num_qubits-1)
qc.barrier()
for n1 in range(qc.num_qubits -1):
qc.measure(n1, n1)
return qc
circuit_1 = qpe_circ(3, 1/5)
circuit_1.draw(output='mpl', style=style, filename='/content/drive/My Drive/Colab Notebooks/Quantum_Compute/FourierTransform/3bits_QPE_QiskitEx_NonInt_Theta.png')
aer_sim = q.Aer.get_backend('aer_simulator')
shots = 2048
t_circuit_1 = q.transpile(circuit_1, aer_sim)
qobj = q.assemble(t_circuit_1, shots=shots)
results_c1 = aer_sim.run(qobj).result()
answer_c1 = results_c1.get_counts()
q.visualization.plot_histogram(answer_c1)
circuit_2 = qpe_circ(5, 1/5)
circuit_2.draw(output='mpl', style=style, filename='/content/drive/My Drive/Colab Notebooks/Quantum_Compute/FourierTransform/5bits_QPE_QiskitEx_NonInt_Theta.png')
aer_sim = q.Aer.get_backend('aer_simulator')
shots = 2048
t_circuit_2 = q.transpile(circuit_2, aer_sim)
qobj = q.assemble(t_circuit_2, shots=shots)
results_c2 = aer_sim.run(qobj).result()
answer_c2 = results_c2.get_counts()
fig, ax = plt.subplots(figsize=(14, 6))
q.visualization.plot_histogram(answer_c2, figsize=(14, 6), color='violet', title=r'QPE Measurement Result with 5 Qubits: $\theta = 1/5$', ax=ax)
fig.savefig('/content/drive/My Drive/Colab Notebooks/Quantum_Compute/FourierTransform/5bits_QPE_QiskitEx_NonInt_Theta_Histogram.png', dpi=250)
for k, v in answer_c2.items():
print(k, v)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_optimization import QuadraticProgram
qp = QuadraticProgram()
qp.binary_var("x")
qp.binary_var("y")
qp.integer_var(lowerbound=0, upperbound=7, name="z")
qp.maximize(linear={"x": 2, "y": 1, "z": 1})
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="LE", rhs=5.5, name="xyz_leq")
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="GE", rhs=2.5, name="xyz_geq")
print(qp.prettyprint())
from qiskit_optimization.converters import InequalityToEquality
ineq2eq = InequalityToEquality()
qp_eq = ineq2eq.convert(qp)
print(qp_eq.prettyprint())
print(qp_eq.prettyprint())
from qiskit_optimization.converters import IntegerToBinary
int2bin = IntegerToBinary()
qp_eq_bin = int2bin.convert(qp_eq)
print(qp_eq_bin.prettyprint())
print(qp_eq_bin.prettyprint())
from qiskit_optimization.converters import LinearEqualityToPenalty
lineq2penalty = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(qp_eq_bin)
print(qubo.prettyprint())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-qcgpu-provider
|
qiskit-community
|
"""
Exception for errors raised by QCGPU simulators
"""
from qiskit import QiskitError
class QCGPUSimulatorError(QiskitError):
"""Base class for errors raised by simulators."""
def __init__(self, *message):
"""Set the error message"""
super().__init__(*message)
self.message = ' '.join(message)
def __str__(self):
"""Return the message"""
return repr(self.message)
|
https://github.com/Sanjay-995/Qiskit-Developer-Prep-Guide
|
Sanjay-995
|
from qiskit import IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit, Aer, execute
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram
import numpy as np
from numpy import pi
import math
from math import sqrt
import matplotlib as mpl
%matplotlib inline
qc1 = QuantumCircuit(4)
qc1.draw(output = 'mpl')
qc2 = QuantumCircuit(QuantumRegister(4))
qc2.draw(output = 'mpl')
qc3 = QuantumCircuit(4,3)
qc3.draw(output = 'mpl')
qc4 = QuantumCircuit(QuantumRegister(4),ClassicalRegister(3))
qc4.draw(output = 'mpl')
qc5 = QuantumCircuit(QuantumRegister(4, 'qr0'), QuantumRegister(2, 'qr1'))
qc5.draw(output = 'mpl')
qr = QuantumRegister(3, 'q')
anc = QuantumRegister(2, 'ancilla')
cr = ClassicalRegister(3, 'c')
qc = QuantumCircuit(qr, anc, cr)
qc.draw(output = 'mpl')
qcA = QuantumCircuit(4,4)
qcA.draw(output = 'mpl')
qcB = QuantumCircuit(4)
qcB.draw(output = 'mpl')
qcC = QuantumCircuit(QuantumRegister(4, 'qr0'), QuantumRegister(4, 'cr1'))
qcC.draw(output = 'mpl')
qcD = QuantumCircuit([4,4])
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.pulse_v2 import draw, IQXSimple
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=IQXSimple(), backend=FakeBoeblingen())
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
import warnings
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute, Aer, transpile
from qiskit.tools.monitor import job_monitor
from qiskit.circuit.library import QFT
from qiskit.visualization import plot_histogram, plot_bloch_multivector
warnings.filterwarnings("ignore", category=DeprecationWarning)
import numpy as np
pi = np.pi
def flip_endian(dict):
newdict = {}
for key in list(dict):
newdict[key[::-1]] = dict.pop(key)
return newdict
def set_measure_x(circuit, n):
for num in range(n):
circuit.h(num)
def set_measure_y(circuit, n):
for num in range(n):
circuit.sdg(num)
circuit.h(num)
def qft_rotations(circuit, n):
#if qubit amount is 0, then do nothing and return
if n == 0:
#set it to measure the x axis
set_measure_x(qc, 4)
qc.measure_all()
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
return qft_rotations(circuit, n)
backend = Aer.get_backend('aer_simulator')
qc = QuantumCircuit(4)
qc.x(0)
qft_rotations(qc,4)#call the recursive qft method
#set it to measure the x axis
set_measure_x(qc, 4)
job = execute(qc, backend, shots=100000)#run the circuit 1000000 times
print(flip_endian(job.result().get_counts()))#return the result counts
def qft_rotations(circuit, n):
#if qubit amount is 0, then do nothing and return
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
#print(n)
#print(qubit)
return qft_rotations(circuit, n)
sim = Aer.get_backend('aer_simulator')
q = QuantumRegister(4,'q')
c = ClassicalRegister(4,'c')
qc = QuantumCircuit(q,c)
qc.x(0)
qc.x(1)
qc.x(2)
#qc.x(3)
#qc.h(0)
#qc.p( 20 * pi / 180, 0)
qft_rotations(qc,4)#call the recursive qft method
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
print(statevector)
plot_bloch_multivector(statevector)
backend = Aer.get_backend('aer_simulator')
q = QuantumRegister(4,'q')
c = ClassicalRegister(1,'c')
qc = QuantumCircuit(q,c)
qc.x(0)
qft_rotations(qc,4)#call the recursive qft method
set_measure_x(qc, 4)
print(qc)
qc.measure(q[3],c)#select qubits registers to measure
job = execute(qc, backend, shots=1000000)#run the circuit 1000 times
dictRes = job.result().get_counts()#return the result counts
print(dictRes)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import GroverOptimizer, MinimumEigenOptimizer
from qiskit_optimization.translators import from_docplex_mp
from docplex.mp.model import Model
model = Model()
x0 = model.binary_var(name="x0")
x1 = model.binary_var(name="x1")
x2 = model.binary_var(name="x2")
model.minimize(-x0 + 2 * x1 - 3 * x2 - 2 * x0 * x2 - 1 * x1 * x2)
qp = from_docplex_mp(model)
print(qp.prettyprint())
grover_optimizer = GroverOptimizer(6, num_iterations=10, sampler=Sampler())
results = grover_optimizer.solve(qp)
print(results.prettyprint())
exact_solver = MinimumEigenOptimizer(NumPyMinimumEigensolver())
exact_result = exact_solver.solve(qp)
print(exact_result.prettyprint())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
from qiskit import *
from qiskit.visualization import plot_bloch_vector
qc = QuantumCircuit(1)
# z measurement of qubit 0
measure_z = QuantumCircuit(1,1)
measure_z.measure(0,0);
# x measurement of qubit 0
measure_x = QuantumCircuit(1,1)
measure_x.h(0)
measure_x.measure(0,0)
# y measurement of qubit 0
measure_y = QuantumCircuit(1,1)
measure_y.sdg(0)
measure_y.h(0)
measure_y.measure(0,0);
shots = 2**14 # number of samples used for statistics
bloch_vector = []
for measure_circuit in [measure_x, measure_y, measure_z]:
# run the circuit with a the selected measurement and get the number of samples that output each bit value
counts = execute(qc+measure_circuit,Aer.get_backend('qasm_simulator'),shots=shots).result().get_counts()
# calculate the probabilities for each bit value
probs = {}
for output in ['0','1']:
if output in counts:
probs[output] = counts[output]/shots
else:
probs[output] = 0
bloch_vector.append( probs['0'] - probs['1'] )
plot_bloch_vector( bloch_vector )
|
https://github.com/PAYAL980/Four-Algorithms-in-Qiskit
|
PAYAL980
|
# Import libraries and necessary tools
from qiskit import *
import numpy as np
import math
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta, FakeNairobi
""" Defining Diffuser (Z0) for N qubits"""
def diffuser(N):
cir = QuantumCircuit(N)
# Applying anti controlled Z gate
cir.x(range(N))
cir.h(0)
cir.mcx([iz for iz in range(1,N)], 0)
cir.h(0)
cir.x(range(N))
return cir
# Checking the diffuser function for 3 qubits
q2 = diffuser(3)
q2.draw('mpl')
""" Defining the oracle(Zf) for N qubits and inp: input string such that f(inp) = 1"""
def oracle(N, inp):
cir = QuantumCircuit(N)
# Checking the positions of '0' in the input string and applying X gate for the application of
# anti-controlled Z gate
for iz in range(N):
if inp[iz]=='0':
cir.x(N-iz-1)
# Multiple controlled Z gate
cir.h(0)
cir.mcx([iz for iz in range(1,N)], 0)
cir.h(0)
# Applying X gates to reverse the effect of above applied X gates
for iz in range(len(inp)):
if inp[iz]=='0':
cir.x(N-iz-1)
return cir
# Checking the oracle function for 3 qubits and input string '001'
q2 = oracle(3, '001')
q2.draw('mpl')
""" Defining Grover's Algorithm """
def grovers_algo_gen(N, oracle_1):
# calculating number of iterations for the Grover's operator
m = int(np.round(np.pi*np.sqrt(2**N)/4 - 0.5))
# Creating a quantum circuit of 'N' qubits
qc = QuantumCircuit(N, N)
# Applying Hadamard gates to all qubits to create superposition
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Iterating the Grover's operator 'm' times
for iz in range(m):
# Appending the oracle
qc.append(oracle_1, range(N))
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates on all qubits
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Appending the diffuser to the quantum circuit
qc.append(diffuser(N), range(N))
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates to all qubits
qc.h(range(N))
qc.barrier() # Barrier for better visualization
# Measuring all N qubits to find the desired output
qc.measure(range(N), range(N))
return qc
# Testing the algorithm for N=3 and f('101') = 1
N = 3
ora = oracle(N, '101')
ora.draw('mpl')
q1 = grovers_algo_gen(N, ora)
q1.draw('mpl')
# Running on non-noisy simulator 1
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on non-noisy simulator 2
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 1
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Running on noisy simulator 1
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
plot_histogram(counts)
# Defining a function that gives the output directly without running many cells
# inp_str - the input string corresponding to f(x) = 1
# sim: simulator on which you want to run the algorithm
#. - 1: non-noisy aer simulator
# 2: non-noisy qasm simulator
# 3: noisy simulator FakeJakarta
# 4: noisy simulator FakeBelem
# Output: counts, maximum number of counts are obtained for the secret string
def run(inp_str, sim):
N = len(inp_str)
oracle_1 = oracle(N, inp_str)
q1 = grovers_algo_gen(N, oracle_1)
count = 0
if sim==1:
backend = Aer.get_backend('aer_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 2:
backend = Aer.get_backend('qasm_simulator')
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
elif sim == 3:
backend = FakeJakarta()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
else:
backend = FakeNairobi()
job = execute(q1,backend)
results = job.result()
counts = results.get_counts()
count = counts
return counts
# Testing the algorithm for '10' on all 4 simulators
plot_histogram(run('10', 1))
plot_histogram(run('10', 2))
plot_histogram(run('10', 3))
plot_histogram(run('10', 4))
# Testing the algorithm for '1010' on all 4 simulators
plot_histogram(run('1010', 1))
plot_histogram(run('1010', 2))
plot_histogram(run('1010', 3))
plot_histogram(run('1010', 4))
# Testing the algorithm for a string of 6 bits on noisy simulator
plot_histogram(run('101011', 4))
|
https://github.com/hugoecarl/TSP-Problem-Study
|
hugoecarl
|
with open('in-exemplo.txt', 'r') as f:
print(f.read())
with open('out-exemplo.txt', 'r') as f:
print(f.read())
import time
import matplotlib.pyplot as plt
import pandas as pd
import os
import subprocess
%matplotlib inline
#Roda entradas
def roda_com_entrada(executavel, arquivo_in, envs = '1', deb = '0'):
with open(arquivo_in) as f:
start = time.perf_counter()
a = f.read()
proc = subprocess.run([executavel], input=a, text=True, capture_output=True, env=dict(OMP_NUM_THREADS=envs, DEBUG=deb, **os.environ))
end = time.perf_counter()
f.close()
ret = ''
for i in a:
if i == "\n":
break
ret += i
return (proc.stdout, end - start, int(ret))
v
#retorna tamanho do tour apartir do stdout
buf = ''
for i in out:
if i == " ":
return float(buf)
buf += i
#Cria resultados
tamanho_entradas = []
tempos = []
tempos_1 = []
tempos_2 = []
resultados1 = []
resultados2 = []
resultados3 = []
#Usando as mesmas entradas
for i in range(8):
print("Rodando entrada: "+str(i))
a = roda_com_entrada('./busca_local_antigo','busca-exaustiva/in-'+str(i)+'.txt')
b = roda_com_entrada('./busca-exaustiva/busca-exaustiva','busca-exaustiva/in-'+str(i)+'.txt')
c = roda_com_entrada('./heuristico/heuristico','busca-exaustiva/in-'+str(i)+'.txt')
tempos.append(a[1])
tempos_1.append(b[1])
tempos_2.append(c[1])
tamanho_entradas.append(a[2])
resultados1.append(tamanho_tour(a[0]))
resultados2.append(tamanho_tour(b[0]))
resultados3.append(tamanho_tour(c[0]))
#Teste com entrada um pouco maior
print("Rodando entrada: 8")
tempos.append(roda_com_entrada('./busca_local_antigo','maior.txt')[1])
tempos_1.append(roda_com_entrada('./busca-exaustiva/busca-exaustiva','maior.txt')[1])
tempos_2.append(roda_com_entrada('./heuristico/heuristico','maior.txt')[1])
tamanho_entradas.append(roda_com_entrada('./busca-local/busca-local','maior.txt')[2])
resultados1.append(tamanho_tour(roda_com_entrada('./busca_local_antigo','maior.txt')[0]))
resultados2.append(tamanho_tour(roda_com_entrada('./busca-exaustiva/busca-exaustiva','maior.txt')[0]))
resultados3.append(tamanho_tour(roda_com_entrada('./heuristico/heuristico','maior.txt')[0]))
plt.title("Comparacao Desempenho")
plt.ylabel("Tempo (s)")
plt.xlabel("Tamanho entradas")
plt.plot(tamanho_entradas, tempos_1)
plt.plot(tamanho_entradas, tempos)
plt.plot(tamanho_entradas, tempos_2)
plt.legend(["busca-exaustiva", "busca-local","heuristico"])
plt.show()
plt.title("Comparacao Desempenho")
plt.ylabel("Tempo (s)")
plt.xlabel("Tamanho entradas")
plt.plot(tamanho_entradas, tempos)
plt.plot(tamanho_entradas, tempos_2)
plt.legend(["busca-local","heuristico"])
plt.show()
df = pd.DataFrame()
df["Tamanho Entrada"] = pd.Series(tamanho_entradas)
df["busca-local-tempo"] = pd.Series(tempos)
df["busca-exaustiva-tempo"] = pd.Series(tempos_1)
df["heuristica-tempo"] = pd.Series(tempos_2)
df["busca-local-resultado"] = pd.Series(resultados1)
df["busca-exaustiva-resultado"] = pd.Series(resultados2)
df["heuristica-resultado"] = pd.Series(resultados3)
df
df.describe()
#Cria resultados
tamanho_entradas = []
tempos = []
tempos_1 = []
tempos_2 = []
tempos_3 = []
tempos_4 = []
tempos_5 = []
#Usando as mesmas entradas
for i in range(7):
print("Rodando entrada: "+str(i))
a = roda_com_entrada('./busca-local/busca-local-paralela','busca-local/in-'+str(i)+'.txt')
b = roda_com_entrada('./busca-local/busca-local-paralela','busca-local/in-'+str(i)+'.txt','2')
c = roda_com_entrada('./busca-local/busca-local-paralela','busca-local/in-'+str(i)+'.txt','3')
d = roda_com_entrada('./busca-local/busca-local-paralela','busca-local/in-'+str(i)+'.txt','4')
e = roda_com_entrada('./busca_local_antigo','busca-local/in-'+str(i)+'.txt')
f = roda_com_entrada('./busca-local/busca-local-gpu','busca-local/in-'+str(i)+'.txt')
tempos.append(a[1])
tempos_1.append(b[1])
tempos_2.append(c[1])
tempos_3.append(d[1])
tempos_4.append(e[1])
tempos_5.append(f[1])
tamanho_entradas.append(a[2])
plt.title("Comparacao Desempenho Busca Local")
plt.ylabel("Tempo (s)")
plt.xlabel("Tamanho entradas")
plt.plot(tamanho_entradas, tempos)
plt.plot(tamanho_entradas, tempos_1)
plt.plot(tamanho_entradas, tempos_2)
plt.plot(tamanho_entradas, tempos_3)
plt.legend(["1 thread otimizado", "2 threads otimizado","3 threads otimizado", "4 threads otimizado", "Sem otimizações"])
plt.show()
plt.title("Comparacao Desempenho Busca Local")
plt.ylabel("Tempo (s)")
plt.xlabel("Tamanho entradas")
plt.plot(tamanho_entradas, tempos_3)
plt.plot(tamanho_entradas, tempos_5)
plt.legend(["4 thread otimizado", "GPU"])
plt.show()
plt.title("Comparacao Desempenho Busca Local")
plt.ylabel("Tempo (s)")
plt.xlabel("Tamanho entradas")
plt.plot(tamanho_entradas, tempos)
plt.plot(tamanho_entradas, tempos_4)
plt.legend(["1 thread otimizado", "Sem otimizações"])
plt.show()
df = pd.DataFrame()
df["Tamanho Entrada"] = pd.Series(tamanho_entradas)
df["busca-local-1-thread"] = pd.Series(tempos)
df["busca-local-2-threads"] = pd.Series(tempos_1)
df["busca-local-3-threads"] = pd.Series(tempos_2)
df["busca-local-4-threads"] = pd.Series(tempos_3)
df["busca-local-gpu"] = pd.Series(tempos_5)
df["busca-local-semopt"] = pd.Series(tempos_4)
df
#Cria resultados
tamanho_entradas = []
tempos = []
tempos_1 = []
tempos_2 = []
#Usando as mesmas entradas
for i in range(8):
print("Rodando entrada: "+str(i))
if i != 7:
a = roda_com_entrada('./busca-exaustiva/busca-exaustiva','busca-exaustiva/in-'+str(i)+'.txt', '1', '1')
tempos.append(a[1])
b = roda_com_entrada('./busca-exaustiva/busca-exaustiva','busca-exaustiva/in-'+str(i)+'.txt', '8', '0')
c = roda_com_entrada('./busca-exaustiva-apenasbb','busca-exaustiva/in-'+str(i)+'.txt', '1', '0')
tempos_1.append(b[1])
tempos_2.append(c[1])
tamanho_entradas.append(a[2])
plt.title("Comparacao Desempenho Busca Exaustiva")
plt.ylabel("Tempo (s)")
plt.xlabel("Tamanho entradas")
plt.plot(tamanho_entradas[:-1], tempos)
plt.plot(tamanho_entradas[:-1], tempos_2[:-1])
plt.legend(["Exaustivo Simples", "Exaustivo Branch and Bound"])
plt.show()
plt.title("Comparacao Desempenho Busca Exaustiva")
plt.ylabel("Tempo (s)")
plt.xlabel("Tamanho entradas")
plt.plot(tamanho_entradas, tempos_1)
plt.plot(tamanho_entradas, tempos_2)
plt.legend(["Branch and Bound Paralelo", "Branch and Bound Simples"])
plt.show()
df = pd.DataFrame()
df["Tamanho Entrada"] = pd.Series(tamanho_entradas)
df["busca-exaustiva-simples"] = pd.Series(tempos)
df["busca-exaustiva-branchnbound"] = pd.Series(tempos_2)
df["busca-exaustiva-branchnbound-par"] = pd.Series(tempos_1)
df
|
https://github.com/nahumsa/volta
|
nahumsa
|
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit.circuit.library import TwoLocal
from qiskit import QuantumCircuit
import numpy as np
def _get_ansatz(n_qubits: int, reps: int = 1) -> QuantumCircuit:
"""Create a TwoLocal ansatz for `n_qubits`.
Args:
n_qubits (int, optional): number of qubits for the ansatz
Returns:
QuantumCircuit: TwoLocal circuit. defaults to 1.
"""
return TwoLocal(n_qubits, ["ry", "rz"], "cx", reps=reps)
def get_num_parameters(n_qubits: int) -> int:
"""Get the number of parameters for a TwoLocal
Ansatz.
Args:
n_qubits (int): number of qubits
Returns:
int: number of parameters
"""
return len(_get_ansatz(n_qubits).parameters)
def get_var_form(params: np.array, n_qubits: int = 2, reps: int = 1) -> QuantumCircuit:
"""Get an hardware-efficient ansatz for n_qubits
given parameters.
Args:
params (np.array): parameters to be applied on the circuit.
n_qubits (int, optional): number of qubits. Defaults to 2.
reps (int, optional): repetition for the ansatz. Defaults to 1.
Returns:
QuantumCircuit: Circuit with parameters applied
"""
# Define variational Form
var_form = _get_ansatz(n_qubits, reps)
# Get Parameters from the variational form
var_form_params = sorted(var_form.parameters, key=lambda p: p.name)
# Check if the number of parameters is compatible
assert len(var_form_params) == len(params), "The number of parameters don't match"
# Create a dictionary with the parameters and values
param_dict = dict(zip(var_form_params, params))
# Assing those values for the ansatz
wave_function = var_form.assign_parameters(param_dict)
return wave_function
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# 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.
"""Testing legacy instruction alignment pass."""
from qiskit import QuantumCircuit, pulse
from qiskit.test import QiskitTestCase
from qiskit.transpiler import InstructionDurations
from qiskit.transpiler.exceptions import TranspilerError
from qiskit.transpiler.passes import (
AlignMeasures,
ValidatePulseGates,
ALAPSchedule,
TimeUnitConversion,
)
class TestAlignMeasures(QiskitTestCase):
"""A test for measurement alignment pass."""
def setUp(self):
super().setUp()
instruction_durations = InstructionDurations()
instruction_durations.update(
[
("rz", (0,), 0),
("rz", (1,), 0),
("x", (0,), 160),
("x", (1,), 160),
("sx", (0,), 160),
("sx", (1,), 160),
("cx", (0, 1), 800),
("cx", (1, 0), 800),
("measure", None, 1600),
]
)
self.time_conversion_pass = TimeUnitConversion(inst_durations=instruction_durations)
# reproduce old behavior of 0.20.0 before #7655
# currently default write latency is 0
self.scheduling_pass = ALAPSchedule(
durations=instruction_durations,
clbit_write_latency=1600,
conditional_latency=0,
)
self.align_measure_pass = AlignMeasures(alignment=16)
def test_t1_experiment_type(self):
"""Test T1 experiment type circuit.
(input)
┌───┐┌────────────────┐┌─┐
q_0: ┤ X ├┤ Delay(100[dt]) ├┤M├
└───┘└────────────────┘└╥┘
c: 1/════════════════════════╩═
0
(aligned)
┌───┐┌────────────────┐┌─┐
q_0: ┤ X ├┤ Delay(112[dt]) ├┤M├
└───┘└────────────────┘└╥┘
c: 1/════════════════════════╩═
0
This type of experiment slightly changes delay duration of interest.
However the quantization error should be less than alignment * dt.
"""
circuit = QuantumCircuit(1, 1)
circuit.x(0)
circuit.delay(100, 0, unit="dt")
circuit.measure(0, 0)
timed_circuit = self.time_conversion_pass(circuit)
scheduled_circuit = self.scheduling_pass(timed_circuit, property_set={"time_unit": "dt"})
aligned_circuit = self.align_measure_pass(
scheduled_circuit, property_set={"time_unit": "dt"}
)
ref_circuit = QuantumCircuit(1, 1)
ref_circuit.x(0)
ref_circuit.delay(112, 0, unit="dt")
ref_circuit.measure(0, 0)
self.assertEqual(aligned_circuit, ref_circuit)
def test_hanh_echo_experiment_type(self):
"""Test Hahn echo experiment type circuit.
(input)
┌────┐┌────────────────┐┌───┐┌────────────────┐┌────┐┌─┐
q_0: ┤ √X ├┤ Delay(100[dt]) ├┤ X ├┤ Delay(100[dt]) ├┤ √X ├┤M├
└────┘└────────────────┘└───┘└────────────────┘└────┘└╥┘
c: 1/══════════════════════════════════════════════════════╩═
0
(output)
┌────┐┌────────────────┐┌───┐┌────────────────┐┌────┐┌──────────────┐┌─┐
q_0: ┤ √X ├┤ Delay(100[dt]) ├┤ X ├┤ Delay(100[dt]) ├┤ √X ├┤ Delay(8[dt]) ├┤M├
└────┘└────────────────┘└───┘└────────────────┘└────┘└──────────────┘└╥┘
c: 1/══════════════════════════════════════════════════════════════════════╩═
0
This type of experiment doesn't change duration of interest (two in the middle).
However induces slight delay less than alignment * dt before measurement.
This might induce extra amplitude damping error.
"""
circuit = QuantumCircuit(1, 1)
circuit.sx(0)
circuit.delay(100, 0, unit="dt")
circuit.x(0)
circuit.delay(100, 0, unit="dt")
circuit.sx(0)
circuit.measure(0, 0)
timed_circuit = self.time_conversion_pass(circuit)
scheduled_circuit = self.scheduling_pass(timed_circuit, property_set={"time_unit": "dt"})
aligned_circuit = self.align_measure_pass(
scheduled_circuit, property_set={"time_unit": "dt"}
)
ref_circuit = QuantumCircuit(1, 1)
ref_circuit.sx(0)
ref_circuit.delay(100, 0, unit="dt")
ref_circuit.x(0)
ref_circuit.delay(100, 0, unit="dt")
ref_circuit.sx(0)
ref_circuit.delay(8, 0, unit="dt")
ref_circuit.measure(0, 0)
self.assertEqual(aligned_circuit, ref_circuit)
def test_mid_circuit_measure(self):
"""Test circuit with mid circuit measurement.
(input)
┌───┐┌────────────────┐┌─┐┌───────────────┐┌───┐┌────────────────┐┌─┐
q_0: ┤ X ├┤ Delay(100[dt]) ├┤M├┤ Delay(10[dt]) ├┤ X ├┤ Delay(120[dt]) ├┤M├
└───┘└────────────────┘└╥┘└───────────────┘└───┘└────────────────┘└╥┘
c: 2/════════════════════════╩══════════════════════════════════════════╩═
0 1
(output)
┌───┐┌────────────────┐┌─┐┌───────────────┐┌───┐┌────────────────┐┌─┐
q_0: ┤ X ├┤ Delay(112[dt]) ├┤M├┤ Delay(10[dt]) ├┤ X ├┤ Delay(134[dt]) ├┤M├
└───┘└────────────────┘└╥┘└───────────────┘└───┘└────────────────┘└╥┘
c: 2/════════════════════════╩══════════════════════════════════════════╩═
0 1
Extra delay is always added to the existing delay right before the measurement.
Delay after measurement is unchanged.
"""
circuit = QuantumCircuit(1, 2)
circuit.x(0)
circuit.delay(100, 0, unit="dt")
circuit.measure(0, 0)
circuit.delay(10, 0, unit="dt")
circuit.x(0)
circuit.delay(120, 0, unit="dt")
circuit.measure(0, 1)
timed_circuit = self.time_conversion_pass(circuit)
scheduled_circuit = self.scheduling_pass(timed_circuit, property_set={"time_unit": "dt"})
aligned_circuit = self.align_measure_pass(
scheduled_circuit, property_set={"time_unit": "dt"}
)
ref_circuit = QuantumCircuit(1, 2)
ref_circuit.x(0)
ref_circuit.delay(112, 0, unit="dt")
ref_circuit.measure(0, 0)
ref_circuit.delay(10, 0, unit="dt")
ref_circuit.x(0)
ref_circuit.delay(134, 0, unit="dt")
ref_circuit.measure(0, 1)
self.assertEqual(aligned_circuit, ref_circuit)
def test_mid_circuit_multiq_gates(self):
"""Test circuit with mid circuit measurement and multi qubit gates.
(input)
┌───┐┌────────────────┐┌─┐ ┌─┐
q_0: ┤ X ├┤ Delay(100[dt]) ├┤M├──■───────■──┤M├
└───┘└────────────────┘└╥┘┌─┴─┐┌─┐┌─┴─┐└╥┘
q_1: ────────────────────────╫─┤ X ├┤M├┤ X ├─╫─
║ └───┘└╥┘└───┘ ║
c: 2/════════════════════════╩═══════╩═══════╩═
0 1 0
(output)
┌───┐ ┌────────────────┐┌─┐ ┌─────────────────┐ ┌─┐»
q_0: ───────┤ X ├───────┤ Delay(112[dt]) ├┤M├──■──┤ Delay(1600[dt]) ├──■──┤M├»
┌──────┴───┴──────┐└────────────────┘└╥┘┌─┴─┐└───────┬─┬───────┘┌─┴─┐└╥┘»
q_1: ┤ Delay(1872[dt]) ├───────────────────╫─┤ X ├────────┤M├────────┤ X ├─╫─»
└─────────────────┘ ║ └───┘ └╥┘ └───┘ ║ »
c: 2/══════════════════════════════════════╩═══════════════╩═══════════════╩═»
0 1 0 »
«
«q_0: ───────────────────
« ┌─────────────────┐
«q_1: ┤ Delay(1600[dt]) ├
« └─────────────────┘
«c: 2/═══════════════════
«
Delay for the other channel paired by multi-qubit instruction is also scheduled.
Delay (1872dt) = X (160dt) + Delay (100dt + extra 12dt) + Measure (1600dt).
"""
circuit = QuantumCircuit(2, 2)
circuit.x(0)
circuit.delay(100, 0, unit="dt")
circuit.measure(0, 0)
circuit.cx(0, 1)
circuit.measure(1, 1)
circuit.cx(0, 1)
circuit.measure(0, 0)
timed_circuit = self.time_conversion_pass(circuit)
scheduled_circuit = self.scheduling_pass(timed_circuit, property_set={"time_unit": "dt"})
aligned_circuit = self.align_measure_pass(
scheduled_circuit, property_set={"time_unit": "dt"}
)
ref_circuit = QuantumCircuit(2, 2)
ref_circuit.x(0)
ref_circuit.delay(112, 0, unit="dt")
ref_circuit.measure(0, 0)
ref_circuit.delay(160 + 112 + 1600, 1, unit="dt")
ref_circuit.cx(0, 1)
ref_circuit.delay(1600, 0, unit="dt")
ref_circuit.measure(1, 1)
ref_circuit.cx(0, 1)
ref_circuit.delay(1600, 1, unit="dt")
ref_circuit.measure(0, 0)
self.assertEqual(aligned_circuit, ref_circuit)
def test_alignment_is_not_processed(self):
"""Test avoid pass processing if delay is aligned."""
circuit = QuantumCircuit(2, 2)
circuit.x(0)
circuit.delay(160, 0, unit="dt")
circuit.measure(0, 0)
circuit.cx(0, 1)
circuit.measure(1, 1)
circuit.cx(0, 1)
circuit.measure(0, 0)
# pre scheduling is not necessary because alignment is skipped
# this is to minimize breaking changes to existing code.
transpiled = self.align_measure_pass(circuit, property_set={"time_unit": "dt"})
self.assertEqual(transpiled, circuit)
def test_circuit_using_clbit(self):
"""Test a circuit with instructions using a common clbit.
(input)
┌───┐┌────────────────┐┌─┐
q_0: ┤ X ├┤ Delay(100[dt]) ├┤M├──────────────
└───┘└────────────────┘└╥┘ ┌───┐
q_1: ────────────────────────╫────┤ X ├──────
║ └─╥─┘ ┌─┐
q_2: ────────────────────────╫──────╫─────┤M├
║ ┌────╨────┐└╥┘
c: 1/════════════════════════╩═╡ c_0 = T ╞═╩═
0 └─────────┘ 0
(aligned)
┌───┐ ┌────────────────┐┌─┐┌────────────────┐
q_0: ───────┤ X ├───────┤ Delay(112[dt]) ├┤M├┤ Delay(160[dt]) ├───
┌──────┴───┴──────┐└────────────────┘└╥┘└─────┬───┬──────┘
q_1: ┤ Delay(1872[dt]) ├───────────────────╫───────┤ X ├──────────
└┬────────────────┤ ║ └─╥─┘ ┌─┐
q_2: ─┤ Delay(432[dt]) ├───────────────────╫─────────╫─────────┤M├
└────────────────┘ ║ ┌────╨────┐ └╥┘
c: 1/══════════════════════════════════════╩════╡ c_0 = T ╞═════╩═
0 └─────────┘ 0
Looking at the q_0, the total schedule length T becomes
160 (x) + 112 (aligned delay) + 1600 (measure) + 160 (delay) = 2032.
The last delay comes from ALAP scheduling called before the AlignMeasure pass,
which aligns stop times as late as possible, so the start time of x(1).c_if(0)
and the stop time of measure(0, 0) become T - 160.
"""
circuit = QuantumCircuit(3, 1)
circuit.x(0)
circuit.delay(100, 0, unit="dt")
circuit.measure(0, 0)
circuit.x(1).c_if(0, 1)
circuit.measure(2, 0)
timed_circuit = self.time_conversion_pass(circuit)
scheduled_circuit = self.scheduling_pass(timed_circuit, property_set={"time_unit": "dt"})
aligned_circuit = self.align_measure_pass(
scheduled_circuit, property_set={"time_unit": "dt"}
)
self.assertEqual(aligned_circuit.duration, 2032)
ref_circuit = QuantumCircuit(3, 1)
ref_circuit.x(0)
ref_circuit.delay(112, 0, unit="dt")
ref_circuit.delay(1872, 1, unit="dt") # 2032 - 160
ref_circuit.delay(432, 2, unit="dt") # 2032 - 1600
ref_circuit.measure(0, 0)
ref_circuit.x(1).c_if(0, 1)
ref_circuit.delay(160, 0, unit="dt")
ref_circuit.measure(2, 0)
self.assertEqual(aligned_circuit, ref_circuit)
class TestPulseGateValidation(QiskitTestCase):
"""A test for pulse gate validation pass."""
def setUp(self):
super().setUp()
self.pulse_gate_validation_pass = ValidatePulseGates(granularity=16, min_length=64)
def test_invalid_pulse_duration(self):
"""Kill pass manager if invalid pulse gate is found."""
# this is invalid duration pulse
# this will cause backend error since this doesn't fit with waveform memory chunk.
custom_gate = pulse.Schedule(name="custom_x_gate")
custom_gate.insert(
0, pulse.Play(pulse.Constant(100, 0.1), pulse.DriveChannel(0)), inplace=True
)
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.add_calibration("x", qubits=(0,), schedule=custom_gate)
with self.assertRaises(TranspilerError):
self.pulse_gate_validation_pass(circuit)
def test_short_pulse_duration(self):
"""Kill pass manager if invalid pulse gate is found."""
# this is invalid duration pulse
# this will cause backend error since this doesn't fit with waveform memory chunk.
custom_gate = pulse.Schedule(name="custom_x_gate")
custom_gate.insert(
0, pulse.Play(pulse.Constant(32, 0.1), pulse.DriveChannel(0)), inplace=True
)
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.add_calibration("x", qubits=(0,), schedule=custom_gate)
with self.assertRaises(TranspilerError):
self.pulse_gate_validation_pass(circuit)
def test_short_pulse_duration_multiple_pulse(self):
"""Kill pass manager if invalid pulse gate is found."""
# this is invalid duration pulse
# however total gate schedule length is 64, which accidentally satisfies the constraints
# this should fail in the validation
custom_gate = pulse.Schedule(name="custom_x_gate")
custom_gate.insert(
0, pulse.Play(pulse.Constant(32, 0.1), pulse.DriveChannel(0)), inplace=True
)
custom_gate.insert(
32, pulse.Play(pulse.Constant(32, 0.1), pulse.DriveChannel(0)), inplace=True
)
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.add_calibration("x", qubits=(0,), schedule=custom_gate)
with self.assertRaises(TranspilerError):
self.pulse_gate_validation_pass(circuit)
def test_valid_pulse_duration(self):
"""No error raises if valid calibration is provided."""
# this is valid duration pulse
custom_gate = pulse.Schedule(name="custom_x_gate")
custom_gate.insert(
0, pulse.Play(pulse.Constant(160, 0.1), pulse.DriveChannel(0)), inplace=True
)
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.add_calibration("x", qubits=(0,), schedule=custom_gate)
# just not raise an error
self.pulse_gate_validation_pass(circuit)
def test_no_calibration(self):
"""No error raises if no calibration is addedd."""
circuit = QuantumCircuit(1)
circuit.x(0)
# just not raise an error
self.pulse_gate_validation_pass(circuit)
|
https://github.com/mnp-club/Quantum_Computing_Workshop_2020
|
mnp-club
|
# Importing standard Qiskit libraries and configuring account
from qiskit import *
from qiskit.compiler import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import scipy
import numpy as np
from IPython.display import display, Math, Latex
import qiskit.quantum_info as qi
%matplotlib inline
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.unitary_circuit import *
U = get_unitary()
print(U.shape)
fig, (ax1, ax2) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax1.imshow(np.real(U)) #plot real parts of each element
ax2.imshow(np.imag(U)) #plot imaginary parts of each element
fig, (ax3, ax4) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax3.imshow(np.abs(U)) #plot the absolute values of each element
ax4.imshow(np.angle(U)) #plot the phase angles of each element
qc1 = QuantumCircuit(4)
qc1.unitary(U,range(4))
qc1 = transpile(qc1,basis_gates=['cx','u3'],optimization_level=3)
qc1.draw('mpl')
#Run this cell for getting your circuit checked
check_circuit(qc1)
H = scipy.linalg.hadamard(16)/4 #Normalizing has to be done
HU = np.matmul(H,U)
fig, (ax1, ax2) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax1.imshow(np.real(HU)) #plot real parts of each element
ax2.imshow(np.imag(HU)) #plot imaginary parts of each element
fig, (ax3, ax4) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax3.imshow(np.abs(HU)) #plot the absolute values of each element
ax4.imshow(np.angle(HU)) #plot the phase angles of each element
qc2 = QuantumCircuit(4)
#for i in range(4):
# qc2.h(i)
qc2.unitary(HU,range(4))
for i in range(4):
qc2.h(i)
qc2 = transpile(qc2,basis_gates=['cx','u3'],optimization_level=3)
qc2.draw('mpl')
#Run this cell for getting your circuit checked
check_circuit(qc2)
HUH = np.matmul(HU,H)
fig, (ax1, ax2) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax1.imshow(np.real(HUH)) #plot real parts of each element
ax2.imshow(np.imag(HUH)) #plot imaginary parts of each element
fig, (ax3, ax4) = plotter.subplots(nrows = 1, ncols = 2, figsize=(12,6))
ax3.imshow(np.abs(HUH)) #plot the absolute values of each element
ax4.imshow(np.angle(HUH)) #plot the phase angles of each element
qc3 = QuantumCircuit(4)
for i in range(4):
qc3.h(i)
qc3.unitary(HUH,range(4))
for i in range(4):
qc3.h(i)
qc3 = transpile(qc3,basis_gates=['cx','u3'],optimization_level=3)
qc3.draw('mpl')
#Run this cell for getting your circuit checked
check_circuit(qc3)
diag = np.diag(HUH)
print(diag)
a = np.sqrt(0.5)
clean_diag = [ 1, a+(a*1j), -a+(a*1j), -1, 1j, a-(a*1j), -a-(a*1j), 1j,
-a-(a*1j), 1j, -1, a+(a*1j), a-(a*1j), 1, -1j, a-(a*1j)]
print(clean_diag)
qc31 = QuantumCircuit(4)
for i in range(4):
qc31.h(i)
qc31.diagonal(clean_diag,qc31.qubits)
for i in range(4):
qc31.h(i)
qc31 = transpile(qc31,basis_gates=['cx','u3'],optimization_level=3)
qc31.draw('mpl')
#Run this cell for getting your circuit checked
check_circuit(qc31)
func = lambda a: np.array([[1,0],[0,np.exp(1j*np.pi*a/4)]])
def checking_of_diag(diag_v):
for i in range(16):
if np.abs(diag_v[i]-clean_diag[i])>=0.001 and np.abs(diag_v[i]+clean_diag[i])>=0.001:
return False
return True
while(True):
par = np.random.randint(low=1,high=8, size=4)#We will assume that all atleast rotate by pi/4
V_test = np.kron(np.kron(func(par[0]),func(par[1])),np.kron(func(par[2]),func(par[3])))
if checking_of_diag(np.diag(V_test)):
print(par)
break
differences = np.identity(16)
for i in range(16):
if np.abs(V_test[i,i]-clean_diag[i]) >= 0.0001:
print(i)
differences[i,i] = -1
def without_global_phase(matrix: np.ndarray, atol: float = 1e-8) :
phases1 = np.angle(matrix[abs(matrix) > atol].ravel(order='F'))
if len(phases1) > 0:
matrix = np.exp(-1j * phases1[0]) * matrix
return matrix
#Function just returns norm ignoring global phase between unitaries
def norm(unitary_a: np.ndarray, unitary_b: np.ndarray) :
return np.linalg.norm(without_global_phase(unitary_b)-without_global_phase(unitary_a), ord=2)
qc_d = QuantumCircuit(4)
for i in range(64):
if (i%2) == 1:
qc_d.cz(0,1)
if (i//2)%2 == 1:
qc_d.cz(0,2)
if (i//4)%2 == 1:
qc_d.cz(0,3)
if (i//8)%2 == 1:
qc_d.cz(1,2)
if (i//16)%2 == 1:
qc_d.cz(1,3)
if (i//32)%2 == 1:
qc_d.cz(3,2)
if norm(qi.Operator(qc_d).data,differences) <= 0.001:
print(i)
break
qc_d = QuantumCircuit(4)
qc = QuantumCircuit(4)
theta1 = par[3]*np.pi/4
theta2 = par[2]*np.pi/4
theta3 = par[1]*np.pi/4
theta4 = par[0]*np.pi/4
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
qc.rz(theta1,0)
qc.rz(theta2,1)
qc.rz(theta3,2)
qc.rz(theta4,3)
qc.cz(1,3)
qc.cz(0,2)
qc.cz(0,3)
qc.h(0)
qc.h(1)
qc.h(2)
qc.h(3)
qc = transpile(qc,basis_gates=['cx','u3'],optimization_level=3)
qc.draw('mpl')
#Run this cell for getting your circuit checked
check_circuit(qc)
|
https://github.com/DRA-chaos/Quantum-Classical-Hyrid-Neural-Network-for-binary-image-classification-using-PyTorch-Qiskit-pipeline
|
DRA-chaos
|
!pip install qiskit
# check if CUDA is available
import torch
train_on_gpu = torch.cuda.is_available()
if not train_on_gpu:
print('CUDA is not available. Training on CPU ...')
else:
print('CUDA is available! Training on GPU ...')
import numpy as np
import matplotlib.pyplot as plt
import torch
from torch.autograd import Function
from torchvision import datasets, transforms
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import qiskit
from qiskit import transpile, assemble
from qiskit.visualization import *
import numpy as np
import torch
from torch.autograd import Function
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torchvision import datasets, transforms
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister, execute
from qiskit.circuit import Parameter
from qiskit import Aer
from tqdm import tqdm
from matplotlib import pyplot as plt
%matplotlib inline
def to_numbers(tensor_list):
num_list = []
for tensor in tensor_list:
num_list += [tensor.item()]
return num_list
class QuantumCircuit:
"""
This class provides a simple interface for interaction
with the quantum circuit
"""
def __init__(self, n_qubits, backend, shots):
# --- Circuit definition ---
self._circuit = qiskit.QuantumCircuit(n_qubits)
all_qubits = [i for i in range(n_qubits)]
self.theta = qiskit.circuit.Parameter('theta')
self._circuit.h(all_qubits)
self._circuit.barrier()
self._circuit.ry(self.theta, all_qubits)
self._circuit.measure_all()
# ---------------------------
self.backend = backend
self.shots = shots
def run(self, thetas):
t_qc = transpile(self._circuit,
self.backend)
qobj = assemble(t_qc,
shots=self.shots,
parameter_binds = [{self.theta: theta} for theta in thetas])
job = self.backend.run(qobj)
result = job.result().get_counts()
counts = np.array(list(result.values()))
states = np.array(list(result.keys())).astype(float)
# Compute probabilities for each state
probabilities = counts / self.shots
# Get state expectation
expectation = np.sum(states * probabilities)
return np.array([expectation])
class HybridFunction(Function):
""" Hybrid quantum - classical function definition """
@staticmethod
def forward(ctx, input, quantum_circuit, shift):
""" Forward pass computation """
ctx.shift = shift
ctx.quantum_circuit = quantum_circuit
expectation_z = ctx.quantum_circuit.run(input[0].tolist())
result = torch.tensor([expectation_z])
ctx.save_for_backward(input, result)
return result
@staticmethod
def backward(ctx, grad_output):
""" Backward pass computation """
input, expectation_z = ctx.saved_tensors
input_list = np.array(input.tolist())
shift_right = input_list + np.ones(input_list.shape) * ctx.shift
shift_left = input_list - np.ones(input_list.shape) * ctx.shift
gradients = []
for i in range(len(input_list)):
expectation_right = ctx.quantum_circuit.run(shift_right[i])
expectation_left = ctx.quantum_circuit.run(shift_left[i])
gradient = torch.tensor([expectation_right]) - torch.tensor([expectation_left])
gradients.append(gradient)
gradients = np.array([gradients]).T
return torch.tensor([gradients]).float() * grad_output.float(), None, None
class Hybrid(nn.Module):
""" Hybrid quantum - classical layer definition """
def __init__(self, backend, shots, shift):
super(Hybrid, self).__init__()
self.quantum_circuit = QuantumCircuit(1, backend, shots)
self.shift = shift
def forward(self, input):
return HybridFunction.apply(input, self.quantum_circuit, self.shift)
import torchvision
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()]) # transform images to tensors/vectors
cifar_trainset = datasets.CIFAR10(root='./data1', train=True, download=True, transform=transform)
len(cifar_trainset)
from torch.utils.data import DataLoader, random_split
#cifar_trainset = datasets.CIFAR10(root='./data1', train=True, download=True, transform=transform)
labels = cifar_trainset.targets # get the labels for the data
labels = np.array(labels)
idx1 = np.where(labels == 0) # filter on aeroplanes
idx2 = np.where(labels == 1) # filter on automobiles
# Specify number of datapoints per class (i.e. there will be n pictures of automobiles and n pictures of aeroplanes in the training set)
n=100
# concatenate the data indices
idx = np.concatenate((idx1[0][0:n],idx2[0][0:n]))
# create the filtered dataset for our training set
cifar_trainset.targets = labels[idx]
cifar_trainset.data = cifar_trainset.data[idx]
cifar_trainset, valid = random_split(cifar_trainset,[150,50])
train_loader = torch.utils.data.DataLoader(cifar_trainset, batch_size=1, shuffle=True)
valid_loader = torch.utils.data.DataLoader(valid, batch_size=1, shuffle=True)
@torch.no_grad()
def get_all_preds(model, train_loader):
all_preds = torch.tensor([])
for batch in train_loader:
images, labels = batch
preds = model(images)
all_preds = torch.cat(
(all_preds, preds)
,dim=0
)
return all_preds
import numpy as np
import matplotlib.pyplot as plt
n_samples_show = 6
data_iter = iter(train_loader)
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 2))
while n_samples_show > 0:
images, targets = data_iter.__next__()
images=images.squeeze()
axes[n_samples_show - 1].imshow(images[0].numpy(), cmap='gray')
axes[n_samples_show - 1].set_xticks([])
axes[n_samples_show - 1].set_yticks([])
axes[n_samples_show - 1].set_title("Labeled: {}".format(targets.item()))
n_samples_show -= 1
import torchvision
transform = torchvision.transforms.Compose([torchvision.transforms.ToTensor()]) # transform images to tensors/vectors
cifar_testset = datasets.CIFAR10(root='./data1', train=False, download=True, transform=transform)
labels = cifar_testset.targets # get the labels for the data
labels = np.array(labels)
idx1 = np.where(labels == 0) # filter on aeroplanes
idx2 = np.where(labels == 1) # filter on automobiles
# Specify number of datapoints per class (i.e. there will be n pictures of automobiles and n pictures of aeroplanes in the training set)
n=100
# concatenate the data indices
idx = np.concatenate((idx1[0][0:n],idx2[0][0:n]))
# create the filtered dataset for our training set
cifar_testset.targets = labels[idx]
cifar_testset.data = cifar_testset.data[idx]
test_loader = torch.utils.data.DataLoader(cifar_testset, batch_size=1, shuffle=False)
len(cifar_testset)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(3, 10, kernel_size=5)
self.conv2 = nn.Conv2d(10, 20, kernel_size=5)
self.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(500, 500)
self.fc2 = nn.Linear(500, 1)
self.hybrid = Hybrid(qiskit.Aer.get_backend('qasm_simulator'), 100, np.pi / 2)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.max_pool2d(x, 2)
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = self.dropout(x)
x = x.view(1, -1)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = self.hybrid(x)
return torch.cat((x, 1 - x), -1)
%matplotlib inline
import matplotlib.pyplot as plt
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 5
loss_list = []
loss_list_V = []
#training the model
model.train()
for epoch in range(epochs):
train_loss = []
for batch_idx, (data, target) in enumerate(train_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
loss = loss_func(output, target)
# Backward pass
loss.backward()
# Optimize the weights
optimizer.step()
train_loss.append(loss.item())
loss_list.append(sum(train_loss)/len(train_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list[-1]))
#Validate the model
model.eval()
for epoch in range(epochs):
valid_loss = []
for batch_idx, (data, target) in enumerate(valid_loader):
optimizer.zero_grad()
# Forward pass
output = model(data)
# Calculating loss
validation_loss = loss_func(output, target)
# Backward pass
validation_loss.backward()
# Optimize the weights
optimizer.step()
valid_loss.append(validation_loss.item())
loss_list_V.append(sum(valid_loss)/len(valid_loss))
#print('Training [{:.0f}%]\tLoss: {:.4f}'.format(100. * (epoch + 1) / epochs, loss_list_V[-1]))
print('Epoch: {} \tTraining Loss: {:.6f} \tValidation Loss: {:.6f}'.format(
epoch, loss_list[-1], loss_list_V[-1]))
#Now plotting the training graph
plt.plot(loss_list,label='Training Loss')
plt.plot(loss_list_V,label='Validation Loss')
plt.legend()
plt.show()
total_loss=[]
model.eval()
with torch.no_grad():
correct = 0
for batch_idx, (data, target) in enumerate(test_loader):
output = model(data)
pred = output.argmax(dim=1, keepdim=True)
correct += pred.eq(target.view_as(pred)).sum().item()
loss = loss_func(output, target)
total_loss.append(loss.item())
print('Performance on train data:\n\tLoss: {:.4f}\n\tAccuracy: {:.1f}%'.format(
sum(total_loss) / len(total_loss),
correct / len(test_loader) * 100)
)
|
https://github.com/msramalho/Teach-Me-Quantum
|
msramalho
|
from qsvm_datasets import *
from qiskit_aqua.utils import split_dataset_to_data_and_labels, map_label_to_class_name
from qiskit_aqua.input import get_input_instance
from qiskit_aqua import run_algorithm
# setup aqua logging
import logging
from qiskit_aqua._logging import set_logging_config, build_logging_config
# set_logging_config(build_logging_config(logging.DEBUG)) # choose INFO, DEBUG to see the log
from qiskit import IBMQ
IBMQ.load_accounts()
feature_dim=2 # we support feature_dim 2 or 3
sample_Total, training_input, test_input, class_labels = ad_hoc_data(training_size=20, test_size=10, n=feature_dim, gap=0.3, PLOT_DATA=True)
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
print(class_to_label)
params = {
'problem': {'name': 'svm_classification', 'random_seed': 10598},
'algorithm': {
'name': 'QSVM.Kernel'
},
'backend': {'name': 'qasm_simulator', 'shots': 1024},
'feature_map': {'name': 'SecondOrderExpansion', 'depth': 2, 'entanglement': 'linear'}
}
algo_input = get_input_instance('SVMInput')
algo_input.training_dataset = training_input
algo_input.test_dataset = test_input
algo_input.datapoints = datapoints[0] # 0 is data, 1 is labels
result = run_algorithm(params, algo_input)
print("testing success ratio: ", result['testing_accuracy'])
print("predicted classes:", result['predicted_classes'])
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r')
plt.show()
sample_Total, training_input, test_input, class_labels = Breast_cancer(training_size=20, test_size=10, n=2, PLOT_DATA=True)
# n =2 is the dimension of each data point
datapoints, class_to_label = split_dataset_to_data_and_labels(test_input)
label_to_class = {label:class_name for class_name, label in class_to_label.items()}
print(class_to_label, label_to_class)
algo_input = get_input_instance('SVMInput')
algo_input.training_dataset = training_input
algo_input.test_dataset = test_input
algo_input.datapoints = datapoints[0]
result = run_algorithm(params, algo_input)
print("testing success ratio: ", result['testing_accuracy'])
print("ground truth: {}".format(map_label_to_class_name(datapoints[1], label_to_class)))
print("predicted: {}".format(result['predicted_classes']))
print("kernel matrix during the training:")
kernel_matrix = result['kernel_matrix_training']
img = plt.imshow(np.asmatrix(kernel_matrix),interpolation='nearest',origin='upper',cmap='bone_r')
plt.show()
|
https://github.com/deadshot8086/quantum-grover-boolean-sat
|
deadshot8086
|
from qiskit import QuantumCircuit
from math import pi, sqrt, acos
# creates final grover's circuit, based of number of solutions
class SATCircuit:
def __init__(self, n, cnf, M, grover_operator):
eq = len(cnf)
total = n + eq + 1
circuit = QuantumCircuit(total, n)
circuit.h(range(n))
circuit.h(total - 1)
circuit.z(total - 1)
itr = round(((pi / (2 * acos(sqrt((pow(2, n) - M) / pow(2, n))))) - 1) / 2)
if itr == 0:
raise SystemExit("No solution found")
for x in range(itr):
circuit = circuit.compose(grover_operator)
circuit.measure(range(n), range(n))
self.main_circuit = circuit
|
https://github.com/qclib/qclib
|
qclib
|
# Copyright 2021 qclib project.
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
# http://www.apache.org/licenses/LICENSE-2.0
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
""" Test bidirectional state preparation """
from unittest import TestCase
import numpy as np
from qiskit import ClassicalRegister
from qiskit_aer import AerSimulator
from qclib.state_preparation import BdspInitialize
from qclib.util import measurement
backend = AerSimulator()
SHOTS = 8192
class TestBdsp(TestCase):
""" Testing bdsp """
@staticmethod
def bdsp_experiment(state, split=None):
""" Run bdsp experiment """
opt_params = {'split': split}
circuit = BdspInitialize(state, opt_params=opt_params).definition
n_qubits = int(np.log2(len(state)))
classical_register = ClassicalRegister(n_qubits)
circuit.add_register(classical_register)
return measurement(circuit, n_qubits, classical_register, backend, SHOTS)
def test_bottom_up(self):
""" Testing bdsp """
vector = np.random.rand(16) + np.random.rand(16) * 1j
vector = vector / np.linalg.norm(vector)
state = TestBdsp.bdsp_experiment(vector, 1)
self.assertTrue(np.allclose(np.power(np.abs(vector), 2), state, rtol=1e-01, atol=0.005))
def test_top_down(self):
""" Testing bdsp """
vector = np.random.rand(16) + np.random.rand(16) * 1j
vector = vector / np.linalg.norm(vector)
state = TestBdsp.bdsp_experiment(vector, int(np.log2(len(vector))))
self.assertTrue(np.allclose(np.power(np.abs(vector), 2), state, rtol=1e-01, atol=0.005))
def test_sublinear(self):
""" Testing bdsp """
vector = np.random.rand(16) + np.random.rand(16) * 1j
vector = vector / np.linalg.norm(vector)
state = TestBdsp.bdsp_experiment(vector)
self.assertTrue(np.allclose(np.power(np.abs(vector), 2), state, rtol=1e-01, atol=0.005))
|
https://github.com/bagmk/qiskit-quantum-state-classifier
|
bagmk
|
import numpy as np
import pandas as pd
import json as json
from scipy import stats
from statsmodels.formula.api import ols
from o_plot import opl # a small local package dedicated to this project
import sys
print(sys.executable)
# loading the data
file_name = 'QAD_data_new.json'
f = open(file_name)
All_data = json.load(f)
#defining the pandas data frame for statistics
df_All= pd.DataFrame(All_data,columns=['shots', 'device', 'fidelity',
'mitigation','model','id_gates',
'QV', 'metric'])
# any shot number >= 488 indicates that the curve calculation was ended after reaching n = 500:
df_All.loc[df_All.shots>=488,"shots"]=np.nan
# add the variable neperian log of safe shot number:
df_All['log_shots'] = np.log(df_All['shots'])
stat_model = ols("log_shots ~ metric + mitigation + model + fidelity + QV + id_gates + device",
df_All.query("device != 'ideal_device' ")).fit()
print(stat_model.summary())
# this for Jensen-Shannon metric
s_metric = 'jensenshannon'
sm = np.array([96])
SAD=0
# ! will be unselected by running the next cell
# main option for metric: squared euclidean distance
# skip this cell if you don't want this option
s_metric = 'sqeuclidean'
sm = np.array([97])
SAD=2
# this for measurement mitigation
mit = 'yes'
MIT=0
# ! will be unselected by running the next cell
# main option: no mitigation
# skip this cell if you don't want this option
mit = 'no'
MIT=-4
# select data according to the options
df_mod = df_All[df_All.mitigation == mit][df_All.metric == s_metric]
print("mitigation:",mit," metric:",s_metric )
df_mod.groupby('device')[['shots','log_shots']].describe(percentiles=[0.5])
ADD=0+SAD+MIT
opl.plot_curves(All_data, np.append(sm,ADD+np.array([4,5,12,13,20,21,28,29,36,37,44,45])),
"No noise simulator vs empirical model - $\epsilon=0.001$ - no delay",
["metric","mitigation"],
["device","model"], right_xlimit = 70)
print("mitigation:",mit," metric:",s_metric )
stat_model = ols("log_shots ~ model + fidelity ", df_mod.query("id_gates == 0.0 ")).fit()
print(stat_model.summary())
ADD=48+SAD+MIT
opl.plot_curves(All_data, np.append(sm,ADD+np.array([4,5,12,13,20,21,28,29,36,37,44,45])),
"No noise simulator vs empirical model - $\epsilon=0.001$ - with delay",
["metric","mitigation"],
["device","model"], right_xlimit = 70)
print("mitigation:",mit," metric:",s_metric )
stat_model = ols("log_shots ~ model + fidelity", df_mod.query("id_gates == 256.0")).fit()
print(stat_model.summary())
print("mitigation:",mit," metric:",s_metric )
stat_model = ols("log_shots ~ model + fidelity + id_gates",
df_mod).fit()
print(stat_model.summary())
# rem: in this figure, the ideal device calculated value is shown
# but not included in the regression model
df_short = df_All.query("model == 'empirical' & id_gates == 0.0")
df_short = df_short[df_short.metric == s_metric]
# here for adding the "ideal device" observation (11 shots for fidelity = 1.0)
df_ideal= df_All.query("device == 'ideal_device' ")
df_ideal = df_ideal[df_ideal.metric == s_metric]
df_short = df_short[df_short['mitigation']==mit]
tit_head = "$\ln \; n_s$ for $\epsilon$ = 0.001 vs "
tit_tail = "mitigation:"+mit+ " metric:"+s_metric+" model: empirical, no delay"
opl.plot_scatter(df_ideal.append(df_short),"fidelity",
tit_head + "quantum readout error fidelity\n" +tit_tail,
left_xlimit = 0.6, right_xlimit = 1.01,
bottom_ylimit = 2, top_ylimit = 6)
print("mitigation:",mit," metric:",s_metric )
stat_model = ols("log_shots ~ fidelity",
df_mod.query("id_gates == 0.0 & model == 'empirical'")).fit()
print(stat_model.summary())
# check if python linregress (figure) and OLS stat_model (table) agree
round(np.sqrt(stat_model.rsquared),3)
# calculate the expected value of n_s for a theoretical fidelity equal to 1.0
# to be compared to the oracle derived value for an ideal device: n_s = 11
alpha, beta = stat_model.params
n_ideal = np.exp(alpha+beta)
n_ideal
ADD=0+SAD+MIT
opl.plot_curves(All_data, np.append(sm,ADD+np.array([4,12,20,28,36,44])),
"Empirical model - $\epsilon=0.001$ - no delay",
["metric","mitigation"],
["device","model"], right_xlimit = 45, top_ylimit = 0.5)
opl.plot_scatter(df_short, "QV",
tit_head + "quantum volume\n" + tit_tail,
left_xlimit = 0, right_xlimit = 33,
bottom_ylimit = 2, top_ylimit = 6)
print("mitigation:",mit," metric:",s_metric )
stat_model = ols("log_shots ~ QV",
df_mod.query("id_gates == 0.0 & model == 'empirical'")).fit()
print(stat_model.summary())
# # check if python linregress (figure) and OLS stat_model (table) agree
round(np.sqrt(stat_model.rsquared),3)
|
https://github.com/VGGatGitHub/2020-QISKit-Summer-Jam
|
VGGatGitHub
|
#%pip uninstall qiskit
%pip install qiskit #==0.16
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit import Aer
from qiskit.tools.visualization import plot_histogram
#VGG todo 1: the equivalent run_algorithm and EnergyInput versions updates
#from qiskit.aqua.translators.ising import max_cut, tsp
#from qiskit.aqua import run_algorithm
#from qiskit.aqua.input import EnergyInput
#old v0.16# from qiskit.optimization.ising import max_cut, tsp
#old v0.16# from qiskit.optimization.ising.common import sample_most_likely
#older# from qiskit.optimization.ising import docplex
from qiskit.optimization.applications.ising import max_cut, tsp
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.optimization.applications.ising import docplex
from qiskit.aqua.algorithms import VQE
from qiskit.aqua.algorithms import NumPyEigensolver as ExactEigensolver
from qiskit.aqua.components.optimizers import SPSA
#from qiskit.aqua.components.variational_forms import RY #RealAmplitudes
from qiskit.circuit.library import RealAmplitudes as RY
from qiskit.aqua import QuantumInstance
# setup aqua logging
import logging
from qiskit.aqua import set_qiskit_aqua_logging
# set_qiskit_aqua_logging(logging.DEBUG) # choose INFO, DEBUG to see the log
#from qiskit import IBMQ
#provider = IBMQ.load_account()
#VGG select the backend for coupling_map
try:
backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex')
#backend = provider.get_backend('ibmq_london')#'ibmq_16_melbourne')#'ibmq_essex')
except:
backend = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
coupling_map = backend.configuration().coupling_map
print(coupling_map)
from typing import List, Tuple
seed = 19120623
np.random.seed(seed)
#VGG: function adopted from the Rigetti's MaxCutQAOA.ipynb
def generate_ising_graph(edges: List[Tuple[int, int]]) -> nx.Graph:
graph = nx.from_edgelist(edges)
weights: np.ndarray = np.random.rand(graph.number_of_edges()) #VGG the old [-1,1] range into [0,1]
weights /= np.linalg.norm(weights)
nx.set_edge_attributes(graph, {e: {'weight': w} for e, w in zip(graph.edges, weights)})
return graph
if coupling_map != None:
G=generate_ising_graph(coupling_map)
n=G.number_of_nodes()
print(n)
# Generating a graph if there were no coupling_map
if coupling_map== None:
#define the edges / coupling_map
#'ibmq_16_melbourne'
elist=[[0, 1], [0, 14], [1, 0], [1, 2], [1, 13], [2, 1], [2, 3], [2, 12],
[3, 2], [3, 4], [3, 11], [4, 3], [4, 5], [4, 10], [5, 4], [5, 6],
[5, 9], [6, 5], [6, 8], [7, 8], [8, 6], [8, 7], [8, 9], [9, 5], [9, 8],
[9, 10], [10, 4], [10, 9], [10, 11], [11, 3], [11, 10], [11, 12], [12, 2],
[12, 11], [12, 13], [13, 1], [13, 12], [13, 14], [14, 0], [14, 13]]
#elist=[[0,1],[0,2],[0,3],[1,2],[2,3],[0,4],[0,2], [4, 3],[1,5],[3,5]]
elist=[[0,1],[0,2],[0,3],[1,2],[2,3],[0,4],[0,2], [4, 3]]
G=generate_ising_graph(elist)
n=G.number_of_nodes()
#other ways to define the graph
#n=5 # Number of nodes in graph
#G=nx.Graph()
#G.add_nodes_from(np.arange(0,n,1))
#ewlist=[(0,1,1.),(0,2,.5),(0,3,0),(1,2,1.0),(0,3,1.0)]
#G1 = nx.from_edgelist(elist)
#G1.add_weighted_edges_from(ewlist)
#Visulaize
print(G.number_of_nodes(),G.number_of_edges())
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
nx.drawing.nx_pylab.draw(G)
elist=G.edges()
print("elist=",elist)
ewlist=[(i,j,G.get_edge_data(i,j,default=0)['weight']) for i,j in G.edges()]
print('ewlist=',ewlist)
def issymmetric(Matrix):
dim=Matrix.shape[0]
if Matrix.shape[1] != dim:
print("Shape Error!")
return False
for i in range(dim):
for j in range(i,dim):
if Matrix[i,j]!=Matrix[j,i]:
print("Shape Error:",(i,j),Matrix[i,j],Matrix[j,i],"difference:",Matrix[i,j]-Matrix[j,i])
return False
return True
# Computing the weight matrix from the random graph
w = np.zeros([n,n])
w = np.eye(n)
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i,j,default=0)
if temp != 0:
w[i,j] = temp['weight']
w/=np.linalg.det(w)**(1/n)
print("Symmetric:",issymmetric(w),"Norm:",np.linalg.norm(w))
print("Eignvlues:",np.linalg.eigvals(w),"det:",np.linalg.det(w))
print(w)
np.sum(w)/4 #the offset value
def Max_Cut_BF(W,*x0):
best_cost_brute = 0
xbest_brute=np.array([1]*n)
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]
cost = 0
for h in x0:
cost -= np.dot(h,x)/n #VGG don't give free samples to those with h==1
for i in range(n):
cost +=(2-np.dot(x,x))/n/2 #VGG try to favor fewer free samples
for j in range(n):
cost += W[i,j]*x[i]*(1-x[j])
if np.isclose(cost,best_cost_brute):
if sum(x)<sum(xbest_brute):
best_cost_brute = cost
xbest_brute = x
else:
if best_cost_brute < cost:
best_cost_brute = cost
xbest_brute = x
if 1==2:
print('case = ' + str(x)+ ' cost = ' + str(cost))
return best_cost_brute, xbest_brute
%%time
if n < 10:
best_cost_brute, xbest_brute = Max_Cut_BF(w)
colors = ['r' if xbest_brute[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos)
print('\nBest solution = ' + str(xbest_brute) + ' cost = ' + str(best_cost_brute))
np.set_printoptions(precision=3)
print(w)
def market_simulations(m,*opt):
free_samples=0
boughten=0
Mw2 = np.zeros([n,n])+w
relations=np.zeros([n,n])
x_free_samples=np.zeros(n)
np.set_printoptions(precision=2)
if 'q' in opt:
print("Using Max_Cut option:",'q')
print("submiting for results using:",backend)
elif 'dcplx' in opt:
print("Using Max_Cut option:",'Docplex')
else:
print("Using Max_Cut_BF")
if n > 10 :
print("It may take too long to do Brute Force Calulations - skiping!")
return
print("day"," [free samples]"," [buyers distribution]"," [to be used as constrain]"," the two totals"," w-det")
for i in range(m):
if sum(x_free_samples)>n/3:
x_free_samples=np.zeros(n)
x=np.array([0]*n)
xbest_brute=np.array([0]*n)
tmp1=Mw2/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,]) #sum probaility contributions
tmp2=tmp
else:
if 'q' in opt:
best_cost_brute, xbest_brute = Max_Cut_IBMQ(Mw2,x_free_samples)
elif 'dcplx' in opt:
best_cost_brute, xbest_brute = Max_Cut_Dcplx(Mw2,x_free_samples)
else:
best_cost_brute, xbest_brute = Max_Cut_BF(Mw2,x_free_samples)
x=np.array(xbest_brute)
x_free_samples+=x
free_samples+=sum(x)
tmp1=Mw2[x==1]/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,],(np.array([1]*n)-x)) #sum probaility contributions
tmp-=np.array([1]*n) #push to negative those with free samples
#print(tmp)
ab=sum(tmp[tmp > 0])
for j in range(n):
test=np.random.uniform()*ab/2
if tmp[j] > test: #buy the product
x[j]+=1
boughten+=1
x0=np.array(xbest_brute)
x-=x0
relation_today=x.reshape(n,1) @ x0.reshape(1,n)
relation_today+=relation_today.T
relations+=relation_today
#print(x0,x,"\n",relation_today)
#print(x0,x,x_free_samples,tmp)
print(i,x0,x,x_free_samples,free_samples, boughten,np.linalg.det(Mw2))
if i%7==0 : #weekely updates of the w matrix
Mw2+=(np.eye(n)+relations)/n/100 #update the w matrix
relations=np.zeros([n,n])
if issymmetric(Mw2) and np.linalg.det(Mw2)>0.:
Mw2/=np.linalg.det(Mw2)**(1/n)
else:
Mw2/=np.linalg.norm(Mw2,ord='fro')
print("\nlast day configuration record:\n")
print(x0,tmp)
print()
print(x,free_samples, boughten, np.linalg.norm(Mw2),np.linalg.det(Mw2))
print()
print(Mw2)
return
%time market_simulations(10)
#VGG qubitOp, offset = max_cut.get_max_cut_qubitops(w)
qubitOp, offset = max_cut.get_operator(w)
#algo_input = EnergyInput(qubitOp)
offset
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = ExactEigensolver(qubitOp, k=3)
result = ee.run()
print("energys:",result['eigenvalues'].real)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstates'][0])
print('energy:', result['eigenvalues'][0],', offset:',offset)
print('max-cut objective:', result['eigenvalues'][0] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
#VGG note that the other runs had implemeneted soft constrains!
from docplex.mp.model import Model
#VGG from qiskit.aqua.translators.ising import docplex
#older# from qiskit.optimization.ising import docplex
# Create an instance of a model and variables.
mdl = Model(name='max_cut')
y = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
# Object function
#VGG added y[i]/100 term to split the degenerate 1<->0 states in favor of less free samples
max_cut_func = mdl.sum(y[i]/50+w[i,j]* y[i] * ( 1 - y[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
# No constraints for Max-Cut problems.
qubitOp_docplex, offset_docplex = docplex.get_operator(mdl)
offset_docplex
#VGG define the above as a function
def set_up_Dcplx_model(W,*c_x0):
mdl = Model(name='max_cut')
y = {i: mdl.binary_var(name='y_{0}'.format(i)) for i in range(n)}
#VGG try to favor fewer free samples using (2-np.dot(x,x))/n/2
#VGG split the degenerate 1<->0 states in favor of less free samples using x[i]/n**2
max_cut_func=mdl.sum((-1)*(2-y[i])*0.5+(-0)*y[i]/100 for i in range(n))
#VGG don't give free samples to those with h==1
max_cut_func+=mdl.sum(h[i]*y[i]*0.5 for i in range(n) for h in c_x0)
max_cut_func+=mdl.sum(W[i,j]* y[i] * ( 1 - y[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
qubitOp, offset = docplex.get_operator(mdl)
return qubitOp, offset
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w)
print(offset_docplex,x)
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = ExactEigensolver(qubitOp_docplex, k=3)
result = ee.run()
print("energys:",result['eigenvalues'].real)
x = sample_most_likely(result['eigenstates'][0])
print('energy:', result['eigenvalues'][0].real)
print('max-cut objective:', result['eigenvalues'][0].real + offset_docplex)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
x=max_cut.get_graph_solution(x).tolist()
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
#VGG note if you keep executing this cell you can see diferent configurations
#VGG define the above as a function
def Max_Cut_Dcplx(W,*c_x0):
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W)
for h in c_x0:
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W,h)
ee = ExactEigensolver(qubitOp_docplex,k=3)
result = ee.run()
x=sample_most_likely(result['eigenstates'][0])
x_dcplx=max_cut.get_graph_solution(x).tolist()
cost_dcplx=result['eigenvalues'][0].real
#cost_dcplx=max_cut.max_cut_value(x, W)
return cost_dcplx, x_dcplx
%time market_simulations(10,'dcplx')
seed = 10598
model=qubitOp_docplex
#model=qubitOp
spsa = SPSA(max_trials=30)
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
backend1 = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend1, seed_simulator=seed, seed_transpiler=seed)
print(backend1)
result = vqe.run(quantum_instance)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
# run quantum algorithm with shots
seed = 10598
spsa = SPSA(max_trials=300)
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
backend2 = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
quantum_instance = QuantumInstance(backend2, shots=1024, seed_simulator=seed, seed_transpiler=seed)
print(backend2)
result = vqe.run(quantum_instance)
"""declarative approach, update the param from the previous cell.
params['backend']['provider'] = 'qiskit.BasicAer'
params['backend']['name'] = 'qasm_simulator'
params['backend']['shots'] = 1024
result = run_algorithm(params, algo_input)
"""
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
plot_histogram(result['eigenstate'])
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
backend
# run quantum algorithm with shots
seed = 10598
spsa = SPSA(max_trials=30) #VGG 300
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
#backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)
print("submiting for results using:",backend)
result = vqe.run(quantum_instance)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
plot_histogram(result['eigenstate'])
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
#VGG define the above as a function
def Max_Cut_IBMQ(W,*c_x0):
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W)
for h in c_x0:
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W,h)
model=qubitOp_docplex
spsa = SPSA(max_trials=30) #VGG 300
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)
result = vqe.run(quantum_instance)
x = sample_most_likely(result['eigenstate'])
cost_vqe=max_cut.max_cut_value(x, W)
x_vqe =np.int_(max_cut.get_graph_solution(x)).tolist()
return cost_vqe, x_vqe
%time market_simulations(10)
%time market_simulations(10,'dcplx')
#backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = Aer.get_backend('statevector_simulator')
%time market_simulations(10,'q')
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit import Parameter
from qiskit import QuantumCircuit
theta = Parameter('$\\theta$')
chsh_circuits_no_meas = QuantumCircuit(2)
chsh_circuits_no_meas.h(0)
chsh_circuits_no_meas.cx(0, 1)
chsh_circuits_no_meas.ry(theta, 0)
chsh_circuits_no_meas.draw('mpl')
import numpy as np
number_of_phases = 21
phases = np.linspace(0, 2*np.pi, number_of_phases)
# Phases need to be expressed as list of lists in order to work
individual_phases = [[ph] for ph in phases]
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = "ibmq_qasm_simulator" # use the simulator
from qiskit_ibm_runtime import Estimator, Session
from qiskit.quantum_info import SparsePauliOp
ZZ = SparsePauliOp.from_list([("ZZ", 1)])
ZX = SparsePauliOp.from_list([("ZX", 1)])
XZ = SparsePauliOp.from_list([("XZ", 1)])
XX = SparsePauliOp.from_list([("XX", 1)])
ops = [ZZ, ZX, XZ, XX]
chsh_est_sim = []
# Simulator
with Session(service=service, backend=backend):
estimator = Estimator()
for op in ops:
job = estimator.run(
circuits=[chsh_circuits_no_meas]*len(individual_phases),
observables=[op]*len(individual_phases),
parameter_values=individual_phases)
est_result = job.result()
chsh_est_sim.append(est_result)
# <CHSH1> = <AB> - <Ab> + <aB> + <ab>
chsh1_est_sim = chsh_est_sim[0].values - chsh_est_sim[1].values + chsh_est_sim[2].values + chsh_est_sim[3].values
# <CHSH2> = <AB> + <Ab> - <aB> + <ab>
chsh2_est_sim = chsh_est_sim[0].values + chsh_est_sim[1].values - chsh_est_sim[2].values + chsh_est_sim[3].values
import matplotlib.pyplot as plt
import matplotlib.ticker as tck
fig, ax = plt.subplots(figsize=(10, 6))
# results from a simulator
ax.plot(phases/np.pi, chsh1_est_sim, 'o-', label='CHSH1 Simulation')
ax.plot(phases/np.pi, chsh2_est_sim, 'o-', label='CHSH2 Simulation')
# classical bound +-2
ax.axhline(y=2, color='r', linestyle='--')
ax.axhline(y=-2, color='r', linestyle='--')
# quantum bound, +-2√2
ax.axhline(y=np.sqrt(2)*2, color='b', linestyle='-.')
ax.axhline(y=-np.sqrt(2)*2, color='b', linestyle='-.')
# set x tick labels to the unit of pi
ax.xaxis.set_major_formatter(tck.FormatStrFormatter('%g $\pi$'))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))
# set title, labels, and legend
plt.title('Violation of CHSH Inequality')
plt.xlabel('Theta')
plt.ylabel('CHSH witness')
plt.legend()
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/akashktesla/qiskit_testing
|
akashktesla
|
from qiskit import QuantumCircuit
import matplotlib.pyplot as plt
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
# qc.draw('mpl',style='iqp')
# plt.show()
from qiskit.quantum_info import Pauli
ZZ = Pauli('ZZ')
ZI = Pauli('ZI')
IZ = Pauli('IZ')
XX = Pauli('XX')
XI = Pauli('XI')
IX = Pauli('IX')
observables = [ZZ,ZI,IZ,XX,XI,IX]
#execute
from qiskit_aer.primitives import Estimator
estimator = Estimator()
job = estimator.run([qc]*len(observables),observables)
# print(job.result())
#plotting
data = ['ZZ', 'ZI', 'IZ', 'XX', 'XI', 'IX']
values = job.result().values
plt.plot(data,values,'-o')
plt.xlabel('Observables')
plt.ylabel('Expected values')
plt.show()
|
https://github.com/kurtchahn/QiskitPrx
|
kurtchahn
|
import qiskit as qk
import qiskit_aer as qaer
import numpy as np
import math
sSimulator = qaer.Aer.backends(name="statevector_simulator")[0]
mSimulator = qaer.Aer.backends(name="qasm_simulator")[0]
qr = qk.QuantumRegister(1)
helloQubit = qk.QuantumCircuit(qr)
## identity operator on q0
helloQubit.id(qr[0])
job = sSimulator.run(helloQubit)
result = job.result()
result.get_statevector()
helloQubit.draw("mpl")
qr = qk.QuantumRegister(3)
qc = qk.QuantumCircuit(qr)
qc.id(qr[0])
qc.id(qr[1])
qc.id(qr[2])
job = sSimulator.run(qc)
result = job.result()
result.get_statevector()
qc.draw("mpl")
qr = qk.QuantumRegister(1)
cr = qk.ClassicalRegister(1)
qc = qk.QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.measure(qr, cr)
job = mSimulator.run(qc)
result = job.result()
result.get_counts(qc)
qc.draw("mpl")
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.h(qr[1])
qc.measure(qr, cr)
counts = mSimulator.run(qc).result().get_counts(qc)
print(counts)
qc.draw("mpl")
## Partial Measurement
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr, cr)
qc.h(qr[0])
qc.h(qr[1])
qc.measure(qr[0], cr[0])
counts = mSimulator.run(qc).result().get_counts(qc)
print(counts)
def perfect_coinflip(numFlips):
qr = qk.QuantumRegister(1)
cr = qk.ClassicalRegister(1)
coin = qk.QuantumCircuit(qr, cr)
coin.h(qr[0])
coin.measure(qr, cr)
counts = mSimulator.run(coin, shots=numFlips).result().get_counts(coin)
heads = counts["0"]
tails = counts["1"]
return heads, tails
numHeads, numTails = perfect_coinflip(100)
print(f"Heads: {numHeads}")
print(f"Tails: {numTails}")
|
https://github.com/usamisaori/quantum-expressibility-entangling-capability
|
usamisaori
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
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_optimization.algorithms import MinimumEigenOptimizer
from qiskit.utils import algorithm_globals
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit_optimization.applications.vertex_cover import VertexCover
import networkx as nx
seed = 123
algorithm_globals.random_seed = seed
graph = nx.random_regular_graph(d=3, n=6, seed=seed)
pos = nx.spring_layout(graph, seed=seed)
prob = VertexCover(graph)
prob.draw(pos=pos)
qp = prob.to_quadratic_program()
print(qp.prettyprint())
# Numpy Eigensolver
meo = MinimumEigenOptimizer(min_eigen_solver=NumPyMinimumEigensolver())
result = meo.solve(qp)
print(result.prettyprint())
print("\nsolution:", prob.interpret(result))
prob.draw(result, pos=pos)
# QAOA
meo = MinimumEigenOptimizer(min_eigen_solver=QAOA(reps=1, sampler=Sampler(), optimizer=COBYLA()))
result = meo.solve(qp)
print(result.prettyprint())
print("\nsolution:", prob.interpret(result))
print("\ntime:", result.min_eigen_solver_result.optimizer_time)
prob.draw(result, pos=pos)
from qiskit_optimization.applications import Knapsack
prob = Knapsack(values=[3, 4, 5, 6, 7], weights=[2, 3, 4, 5, 6], max_weight=10)
qp = prob.to_quadratic_program()
print(qp.prettyprint())
# Numpy Eigensolver
meo = MinimumEigenOptimizer(min_eigen_solver=NumPyMinimumEigensolver())
result = meo.solve(qp)
print(result.prettyprint())
print("\nsolution:", prob.interpret(result))
# QAOA
meo = MinimumEigenOptimizer(min_eigen_solver=QAOA(reps=1, sampler=Sampler(), optimizer=COBYLA()))
result = meo.solve(qp)
print(result.prettyprint())
print("\nsolution:", prob.interpret(result))
print("\ntime:", result.min_eigen_solver_result.optimizer_time)
from qiskit_optimization.converters import QuadraticProgramToQubo
# the same knapsack problem instance as in the previous section
prob = Knapsack(values=[3, 4, 5, 6, 7], weights=[2, 3, 4, 5, 6], max_weight=10)
qp = prob.to_quadratic_program()
print(qp.prettyprint())
# intermediate QUBO form of the optimization problem
conv = QuadraticProgramToQubo()
qubo = conv.convert(qp)
print(qubo.prettyprint())
# qubit Hamiltonian and offset
op, offset = qubo.to_ising()
print(f"num qubits: {op.num_qubits}, offset: {offset}\n")
print(op)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-sat-synthesis
|
qiskit-community
|
%load_ext autoreload
%autoreload 2
!pip install git+https://github.com/qiskit-community/qiskit-sat-synthesis
import numpy as np
# Qiskit includes
from qiskit.circuit import QuantumCircuit
from qiskit.circuit.library import LinearFunction, PermutationGate
from qiskit.quantum_info import Clifford
from qiskit.transpiler import CouplingMap
from qiskit.compiler import transpile
from qiskit.transpiler.passes.synthesis.high_level_synthesis import HLSConfig
from qiskit.transpiler.passes import HighLevelSynthesis
from qiskit.transpiler.passes.synthesis import high_level_synthesis_plugin_names
print(f'Clifford plugin names: {high_level_synthesis_plugin_names("clifford")}')
print(f'LinearFunction plugin names: {high_level_synthesis_plugin_names("linear_function")}')
print(f'PermutationGate plugin names: {high_level_synthesis_plugin_names("permutation")}')
mat = np.array(
[
[1, 1, 0, 1, 1],
[0, 1, 1, 1, 1],
[0, 0, 1, 1, 0],
[0, 0, 0, 1, 1],
[1, 0, 1, 1, 0],
]
)
mat
qc = QuantumCircuit(5)
qc.append(LinearFunction(mat), [0, 1, 2, 3, 4])
qc.draw("mpl")
# Transpile (default)
tqc = transpile(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_count", {})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(
linear_function=[("sat_depth", {"optimize_1q_gates": True, "verbosity": 1})]
)
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {"allow_final_permutation": True})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {"allow_layout_permutation": True})])
tqc = transpile(qc, hls_config=hls_config)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(linear_function=[("sat_depth", {})])
coupling_map = CouplingMap.from_line(5)
tqc = HighLevelSynthesis(hls_config=hls_config, coupling_map=coupling_map, use_qubit_indices=True)(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
# This is cyclic shift: 1->0, 2->1, 0->2
pattern = [1, 2, 3, 4, 5, 6, 7, 0]
qc = QuantumCircuit(8)
qc.append(PermutationGate(pattern), [0, 1, 2, 3, 4, 5, 6, 7])
qc.draw(output='mpl')
hls_config = HLSConfig(permutation=[("sat_depth", {"optimize_2q_gates": True})])
coupling_map = CouplingMap.from_full(8)
tqc = HighLevelSynthesis(hls_config=hls_config, coupling_map=coupling_map, use_qubit_indices=True)(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
hls_config = HLSConfig(permutation=[("sat_depth", {"optimize_2q_gates": True})])
coupling_map = CouplingMap.from_line(8)
tqc = HighLevelSynthesis(hls_config=hls_config, coupling_map=coupling_map, use_qubit_indices=True)(qc)
print(f"ops: {tqc.count_ops()}, depth: {tqc.depth()}")
tqc.draw("mpl")
print(mat)
from qiskit_sat_synthesis.synthesize_linear import synthesize_linear_depth, synthesize_linear_count
line5 = list(CouplingMap.from_line(5).get_edges()) # line connectivity
full5 = list(CouplingMap.from_full(5).get_edges()) # all-to-all connectivity
res = synthesize_linear_depth(mat, coupling_map=full5, verbosity=0, allow_final_permutation=True)
res.circuit.draw("mpl")
res.circuit_with_permutations.draw(output='mpl')
print(res.solutions[0].final_permutation)
LinearFunction(res.circuit_with_permutations) == LinearFunction(mat)
res = synthesize_linear_depth(mat, coupling_map=full5, verbosity=1, allow_final_permutation=True, print_solutions=False, max_solutions=5)
for i, solution in enumerate(res.solutions):
print(f"Solution {i+1}:")
print(solution.circuit)
from qiskit_sat_synthesis.synthesize_superposed import (
synthesize_superposed_count,
synthesize_superposed_depth,
)
coupling_map = [(0, 1), (1, 0), (1, 2), (2, 1), (2, 3), (3, 2), (3, 4), (4, 3), (4, 5), (5, 4), (5, 6), (6, 5), (6, 7), (7, 6), (7, 8), (8, 7)] # line connectivity
result = synthesize_superposed_depth(
[1, 0, 1, 0, 1, 0, 1, 0, 1],
coupling_map=coupling_map,
optimize_2q_gates=True,
print_solutions=False,
verbosity=0,
max_depth2q=10,
)
result.circuit.draw('mpl')
hor9 = [[0, 1], [3, 4], [6, 7], [1, 0], [4, 3], [7, 6], [1, 2], [4, 5], [7, 8], [2, 1], [5, 4], [8, 7]]
ver9 = [[0, 3], [1, 4], [2, 5], [3, 0], [4, 1], [5, 2], [3, 6], [4, 7], [5, 8], [6, 3], [7, 4], [8, 5]]
all9 = hor9 + ver9
state = [1, 0, 0, 0, 0, 0, 0, 0, 1]
res = synthesize_superposed_depth(
state,
coupling_map=all9,
print_solutions=False,
check_solutions=True,
optimize_2q_gates=True,
verbosity=0,
)
res.circuit.draw(output='mpl')
res = synthesize_superposed_depth(
state,
coupling_map_list=[hor9, ver9],
print_solutions=False,
check_solutions=True,
optimize_2q_gates=True,
verbosity=0,
)
res.circuit.draw(output='mpl')
mat1 = np.array(
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[0, 0, 1, 0],
[1, 1, 1, 1],
]
)
mat2 = np.array(
[
[1, 0, 0, 0],
[0, 1, 0, 0],
[1, 0, 1, 0],
[1, 1, 1, 1],
]
)
from qiskit_sat_synthesis.sat_problem_linear import SatProblemLinear
def create_custom_problem(k):
nq = 4
coupling_map = [[0, 1], [1, 0], [1, 2], [2, 1], [2, 3], [3, 2]]
sat_problem = SatProblemLinear(nq, verbosity=0)
sat_problem.set_init_matrix(mat1)
for _ in range(k):
sat_problem.add_layer(
gates=["CX"],
coupling_maps=[coupling_map],
)
sat_problem.set_final_matrix(mat2)
sat_problem.set_optimize_2q_gate(True)
return sat_problem
from qiskit_sat_synthesis.synthesize import SynthesisResult, synthesize_optimal
res = synthesize_optimal(create_sat_problem_fn=create_custom_problem, verbosity=1)
print(res.circuit)
def create_cx_swap_problem(k, mat):
nq = len(mat)
coupling_map = list(CouplingMap.from_line(nq).get_edges())
sat_problem = SatProblemLinear(nq, verbosity=0)
sat_problem.set_init_matrix_to_identity(nq)
for _ in range(k):
sat_problem.add_layer(
gates=["CX", "SWAP"],
coupling_maps=[coupling_map],
)
sat_problem.set_final_matrix(mat)
return sat_problem
mat = np.array(
[
[1, 1, 0, 1, 1],
[0, 1, 1, 1, 1],
[0, 0, 1, 1, 0],
[0, 0, 0, 1, 1],
[1, 0, 1, 1, 0],
]
)
from functools import partial
res = synthesize_optimal(
create_sat_problem_fn=partial(create_cx_swap_problem, mat=mat), verbosity=1
)
res.circuit.draw(output='mpl')
print(LinearFunction(res.circuit) == LinearFunction(mat))
def create_cx_swap_problem(k, mat):
nq = len(mat)
coupling_map = list(CouplingMap.from_line(nq).get_edges())
sat_problem = SatProblemLinear(nq, verbosity=0)
sat_problem.set_init_matrix_to_identity(nq)
for _ in range(k):
layer_id = sat_problem.add_layer(gates=["CX", "SWAP"], coupling_maps=[coupling_map])
sat_problem.add_nonempty_constraint(layer_id)
sat_problem.set_final_matrix(mat)
return sat_problem
res = synthesize_optimal(
create_sat_problem_fn=partial(create_cx_swap_problem, mat=mat), verbosity=1
)
res.circuit.draw(output='mpl')
|
https://github.com/Tojarieh97/VQE
|
Tojarieh97
|
from qiskit.algorithms import VQE
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
seed = 50
algorithm_globals.random_seed = seed
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend=backend, shots=800, seed_transpiler=seed, seed_simulator=seed)
from qiskit.algorithms.optimizers import L_BFGS_B
bfgs_optimizer = L_BFGS_B(maxiter=60)
import numpy as np
from qiskit.opflow import X, Z, I
a_1 = np.random.random_sample()
a_2 = np.random.random_sample()
J_21 = np.random.random_sample()
H_transverse_ising = a_1*(I^X) + a_2*(X^I) + J_21*(Z^Z)
print("========== Transverse Ising Model Hamiltonian for Two Qubits ==========\n")
print(H_transverse_ising.to_matrix())
print()
H2_molecule_Hamiltonian = -0.5053051899926562*(I^I) + \
-0.3277380754984016*(Z^I) + \
0.15567463610622564*(Z^Z) + \
-0.3277380754984016*(I^Z)
print("========== H2 Molecule Hamiltonian for Two Qubits ==========\n")
print(H2_molecule_Hamiltonian.to_matrix())
print()
from qiskit.circuit.library import EfficientSU2
def minimum_eigenvalue_by_vqe(num_qubits, ansatz_entanglement, optimizer, quantum_instance, hamiltonian):
ansatz = EfficientSU2(num_qubits=num_qubits, entanglement=entanglement)
vqe = VQE(ansatz, optimizer, quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(hamiltonian)
print(result)
num_qubits = 2
entanglement = "linear"
minimum_eigenvalue_by_vqe(num_qubits, entanglement, bfgs_optimizer, quantum_instance, H_transverse_ising)
num_qubits = 2
entanglement = "full"
minimum_eigenvalue_by_vqe(num_qubits, entanglement, bfgs_optimizer, quantum_instance, H_transverse_ising)
num_qubits = 2
entanglement = "linear"
minimum_eigenvalue_by_vqe(num_qubits, entanglement, bfgs_optimizer, quantum_instance, H2_molecule_Hamiltonian)
num_qubits = 2
entanglement = "full"
minimum_eigenvalue_by_vqe(num_qubits, entanglement, bfgs_optimizer, quantum_instance, H2_molecule_Hamiltonian)
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
# Quantum Computation
import qiskit
print(qiskit.__version__)
import qiskit.quantum_info as qi
from qiskit.circuit.library import FourierChecking
from qiskit.visualization import plot_histogram
f = [1, -1, -1, -1]
g = [1, 1, -1, -1]
# How co-related fourier transform of function g to function f.
# we will check for probability '00', if p(f,g) >= 0.05, then,
# fourier transform of function g co-related to function f.
circ = FourierChecking(f=f,g=g)
circ.draw()
zero = qi.Statevector.from_label('00') # '00' or '01' or '10' or '11'
sv = zero.evolve(circ)
probs = sv.probabilities_dict()
plot_histogram(probs)
|
https://github.com/lynnlangit/learning-quantum
|
lynnlangit
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
qreg_alice = QuantumRegister(1, 'alice')
qreg_fiber = QuantumRegister(1, 'fiber')
qreg_bob = QuantumRegister(1, 'bob')
creg_ahad = ClassicalRegister(1, 'ahad')
creg_aval = ClassicalRegister(1, 'aval')
creg_fval = ClassicalRegister(1, 'fval')
creg_bhad = ClassicalRegister(1, 'bhad')
creg_bval = ClassicalRegister(1, 'bval')
circuit = QuantumCircuit(qreg_alice, qreg_fiber, qreg_bob, creg_ahad, creg_aval, creg_fval, creg_bhad, creg_bval)
circuit.reset(qreg_alice[0])
circuit.h(qreg_alice[0]) # HAD Alice's qubit
circuit.measure(qreg_alice[0], creg_ahad[0]) # READ Alice's qubit value into Ahad
circuit.reset(qreg_alice[0])
circuit.h(qreg_alice[0]) # HAD Alice's qubit
circuit.measure(qreg_alice[0], creg_aval[0]) # READ Alice's qubit value into Aval
circuit.reset(qreg_alice[0])
circuit.x(qreg_alice[0]).c_if(creg_aval, 1) # NOT Alice's qubit if Aval is 1
circuit.h(qreg_alice[0]).c_if(creg_ahad, 1) # HAD Alice's qubit if Ahad is 1
circuit.swap(qreg_alice[0], qreg_fiber[0]) # SWAP Alice's qubit value into Fiber qubit
circuit.barrier(qreg_alice[0], qreg_fiber[0], qreg_bob[0]) # PREVENT transformations accross this source line
circuit.h(qreg_fiber[0]) # HAD Fiber qubit
circuit.measure(qreg_fiber[0], creg_fval[0]) # READ Fiber qubit value into Fval
circuit.reset(qreg_fiber[0])
circuit.x(qreg_fiber[0]).c_if(creg_fval, 1) # NOT Fiber qubit if Fval is 1
circuit.h(qreg_fiber[0]) # HAD Fiber qubit
circuit.barrier(qreg_alice[0], qreg_fiber[0], qreg_bob[0]) # PREVENT transformations accross this source line
circuit.reset(qreg_bob[0])
circuit.h(qreg_bob[0]) # HAD Bob's qubit
circuit.measure(qreg_bob[0], creg_bhad[0]) # READ Bob's qubit value into Bhad
circuit.swap(qreg_fiber[0], qreg_bob[0]) # SWAP Fiber qubit value into Bob's qubit
circuit.h(qreg_bob[0]).c_if(creg_bhad, 1) # HAD Bob's qubit if Bhad is 1
circuit.measure(qreg_bob[0], creg_bval[0]) # READ Bob's qubit value into Bval
editor = CircuitComposer(circuit=circuit)
editor
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
# Create a circuit with a register of three qubits
circ = QuantumCircuit(3)
# H gate on qubit 0, putting this qubit in a superposition of |0> + |1>.
circ.h(0)
# A CX (CNOT) gate on control qubit 0 and target qubit 1 generating a Bell state.
circ.cx(0, 1)
# CX (CNOT) gate on control qubit 0 and target qubit 2 resulting in a GHZ state.
circ.cx(0, 2)
# Draw the circuit
circ.draw('mpl')
|
https://github.com/usamisaori/Grover
|
usamisaori
|
import qiskit
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
import math
import numpy as np
from qiskit import execute, Aer
simulator = Aer.get_backend('qasm_simulator')
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
state_0 = np.array([1, 0])
state_1 = np.array([0, 1])
from functools import reduce
Dag = lambda matrix: matrix.conj().T
Kron = lambda *matrices: reduce(np.kron, matrices)
def getMeasurements(n):
psi_0 = np.array([1.0, 0.0])
psi_1 = np.array([0.0, 1.0])
I = np.eye(2)
M_0 = psi_0.reshape([2, 1]) @ psi_0.reshape([1, 2]).conj()
M_1 = psi_1.reshape([2, 1]) @ psi_1.reshape([1, 2]).conj()
M = [M_0, M_1]
measurements = []
for i in range(2 ** n):
binnum = bin(i)[2:].rjust(n, '0')
temp = []
indices = map(lambda x: int(x), list(binnum))
for index in indices:
temp.append(M[index])
measurements.append( Kron(*temp) )
return measurements
def measure(M, state):
return Dag(state) @ Dag(M) @ M @ state
initState = Kron(
state_0, state_0, state_0, state_0, state_0,
state_0, state_0, state_0, state_0
)
H = np.array([[1,1], [1,-1]]) / (np.sqrt(2))
H_8 = Kron(H, H, H, H, H, H, H, H)
H_9 = Kron(H, H, H, H, H, H, H, H, H)
N = 2 ** 9
def createTargetState(n):
states = []
s = bin(n)[2:].rjust(9, "0")
for i in list(s):
if i == '0':
states.append(state_0)
else:
states.append(state_1)
return Kron(*states)
def createTargetStates(p):
n = math.floor(p * N)
state = createTargetState(0)
for i in range(1, n):
state = state + createTargetState(i)
return state / (np.sqrt(n))
target_states = [
[createTargetStates(0.05), 0.05], # 0.05
[createTargetStates(0.1), 0.1], # 0.1
[createTargetStates(0.15), 0.15], # 0.15
[createTargetStates(0.2), 0.2], # 0.2
[createTargetStates(0.25), 0.25], # 0.25
[createTargetStates(0.3), 0.3], # 0.3
[createTargetStates(0.35), 0.35], # 0.35
[createTargetStates(0.4), 0.4], # 0.4
[createTargetStates(0.45), 0.45], # 0.45
[createTargetStates(0.5), 0.5], # 0.5
[createTargetStates(0.55), 0.55], # 0.55
[createTargetStates(0.6), 0.6], # 0.6
[createTargetStates(0.65), 0.65], # 0.65
[createTargetStates(0.7), 0.7], # 0.7
[createTargetStates(0.75), 0.75], # 0.75
[createTargetStates(0.8), 0.8], # 0.8
[createTargetStates(0.85), 0.85], # 0.85
[createTargetStates(0.9), 0.9], # 0.9
[createTargetStates(0.95), 0.95], # 0.95
[createTargetStates(1), 1] # 1
]
def createOriginalOracle(target_state):
O = np.eye(N) - 2 * ( Dag(target_state).reshape(N, 1) @ target_state.reshape(1, N) )
return O
def createOriginalDiffuser():
R = 2 * (
Dag(initState).reshape(N, 1) @
initState.reshape(1, N)
) - np.eye(N)
return H_9 @ R @ Dag(H_9)
def createHalfPIOracle(target_state):
alpha = np.pi / 2
alpha_phase = np.exp(alpha * 1j)
# Oracle = I - (1 - e^(αi))|target><target|
O = np.eye(N) - (1 - alpha_phase) * \
( Dag(target_state).reshape(N, 1) @ target_state.reshape(1, N) )
return O
def createHalfPIDiffuser():
beta = -np.pi / 2
beta_phase = np.exp(beta * 1j)
# R = (1 - e^(βi))|0><0| + e^(βi)I
R = (1 - beta_phase) * (
Dag(initState).reshape(N, 1) @
initState.reshape(1, N)
) + beta_phase * np.eye(N)
return H_9 @ R @ Dag(H_9)
def createOneTenthPIOracle(target_state):
alpha = np.pi / 10
alpha_phase = np.exp(alpha * 1j)
# Oracle = I - (1 - e^(αi))|target><target|
O = np.eye(N) - (1 - alpha_phase) * \
( Dag(target_state).reshape(N, 1) @ target_state.reshape(1, N) )
return O
def createOneTenthPIDiffuser():
beta = -np.pi / 10
beta_phase = np.exp(beta * 1j)
# R = (1 - e^(βi))|0><0| + e^(βi)I
R = (1 - beta_phase) * (
Dag(initState).reshape(N, 1) @
initState.reshape(1, N)
) + beta_phase * np.eye(N)
return H_9 @ R @ Dag(H_9)
def createYouneOracle(n):
O = np.eye(N)
for i in range(n):
O[i][i] = 0
O[i][i + N // 2] = 1
O[i + N // 2][i + N // 2] = 0
O[i + N // 2][i] = 1
return O
def createYouneDiffuser():
R = (2 * Dag(initState).reshape(N, 1) @
initState.reshape(1, N) - np.eye(N))
return Kron(np.eye(2), H_8) @ R @ Dag(Kron(np.eye(2), H_8))
measurements = getMeasurements(9)
# test: one grover iteration
x_o = []
y_o = []
for target_state, p in target_states:
n = math.floor(p * N)
O = createOriginalOracle(target_state)
diff = createOriginalDiffuser()
final_state = diff @ O @ H_9 @ initState
probability = 0.0
for i in range(N):
if i < n:
probability = probability + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_o.append(p)
y_o.append(probability)
plt.title("Original Grover - apply one iterator")
plt.scatter(x_o, y_o, color="#66CCCC")
# test: best probability
x_o_best = []
y_o_best = []
for target_state, p in target_states:
n = math.floor(p * N)
O = createOriginalOracle(target_state)
diff = createOriginalDiffuser()
final_state = H_9 @ initState
theta = math.degrees( math.asin(math.sqrt(p)) )
k_tilde = math.floor( 180 / (4 * theta) - 0.5 )
for i in range(k_tilde):
final_state = diff @ O @ final_state
probability = 0.0
for i in range(N):
if i < n:
probability = probability + measure(measurements[i], final_state)
final_state = diff @ O @ final_state
probability2 = 0.0
for i in range(N):
if i < n:
probability2 = probability2 + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_o_best.append(p)
y_o_best.append(max(probability, probability2))
plt.title("Original Grover - best Probability")
x = np.arange(-0,1,0.01)
y = 1 - x
plt.plot(x, y, ls='--', color="#FFCC00")
plt.ylim(0, 1.05)
plt.scatter(x_o_best, y_o_best, color="#66CCCC")
# test: one grover iteration
x_half_pi = []
y_half_pi= []
for target_state, p in target_states:
n = math.floor(p * N)
O = createHalfPIOracle(target_state)
diff = createHalfPIDiffuser()
final_state = diff @ O @ H_9 @ initState
probability = 0.0
for i in range(N):
if i < n:
probability = probability + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_half_pi.append(p)
y_half_pi.append(probability)
plt.title("pi/2 Grover - apply one iterator")
plt.scatter(x_half_pi, y_half_pi, color="#66CCCC")
# one grover iteration - pi/2 vs origin
fig, ax = plt.subplots()
plt.title("Apply one iteration")
plt.axvline(1/3, linestyle='--', color="#FFCCCC", label="t/N = 1/3")
plt.axhline(0.925, linestyle='--', color="#FFCC00", label="P=0.925")
plt.scatter(x_o, y_o, color="#66CCCC", label="Original Grover")
plt.scatter(x_half_pi, y_half_pi, color="#FF6666", label="pi/2 phase based Grover")
ax.legend()
# test: one grover iteration
x_ot_pi = []
y_ot_pi= []
for target_state, p in target_states:
n = math.floor(p * N)
O = createOneTenthPIOracle(target_state)
diff = createOneTenthPIDiffuser()
final_state = diff @ O @ H_9 @ initState
probability = 0.0
for i in range(N):
if i < n:
probability = probability + measure(measurements[i], final_state)
# print(f'p={p}, probability={probability}')
x_ot_pi.append(p)
y_ot_pi.append(probability)
plt.title("0.1pi Grover - apply one iteration")
plt.scatter(x_ot_pi, y_ot_pi, color="#66CCCC")
# test: best probability
x_ot_best = []
y_ot_best = []
diff = createOneTenthPIDiffuser()
for target_state, p in target_states:
n = math.floor(p * N)
O = createOneTenthPIOracle(target_state)
# diff = createOneTenthPIDiffuser()
final_state = H_9 @ initState
p_best = 0.0
k_tilde = math.floor( 5 * np.sqrt(N) )
for i in range(k_tilde):
final_state = diff @ O @ final_state
probability = 0.0
for i in range(N):
if i < n:
probability = probability + measure(measurements[i], final_state)
p_best = max(p_best, probability)
# print(f'p={p}, probability={probability}')
x_ot_best.append(p)
y_ot_best.append(p_best)
plt.title("0.1pi Grover - best Probability")
plt.ylim(0, 1)
plt.scatter(x_ot_best, y_ot_best, color="#66CCCC")
# best probability - 0.1pi vs origin
fig, ax = plt.subplots()
plt.title("Best Probability")
x = np.arange(-0,1,0.01)
y = 1 - x
plt.plot(x, y, ls='--', color="#FFCC00")
plt.ylim(0, 1.05)
plt.scatter(x_o_best, y_o_best, color="#66CCCC", label="Original Grover")
plt.scatter(x_ot_best, y_ot_best, color="#FF6666", label="0.1pi phase based Grover")
ax.legend()
# test: best probability
x_y_best = []
y_y_best = []
for _, p in target_states:
n = math.floor(p * (N // 2))
O = createYouneOracle(n)
diff = createYouneDiffuser()
final_state = Kron( np.eye(2), H_8) @ initState
p_best = 0.0
k_tilde = math.floor(np.pi / (2 * np.sqrt(2)) * np.sqrt((N // 2) / n))
for i in range(k_tilde):
final_state = diff @ O @ final_state
probability = 0.0
for i in range(N // 2):
if i < n:
probability = probability + measure(measurements[i], final_state) + measure(measurements[i + N // 2], final_state)
# print(f'p={p}, probability={probability}')
x_y_best.append(p)
y_y_best.append(probability)
fig, ax = plt.subplots()
plt.title("Best Probability")
x = np.arange(-0, 1, 0.01)
y = 1 - x
plt.plot(x, y, ls='--', color="#FFCC00")
plt.axhline(0.8472, linestyle='--', color="#99CCFF", label="P=0.8472")
plt.axvline(0.308, linestyle='--', color="#FFCCCC", label="P=0.308")
plt.ylim(0, 1.05)
plt.scatter(x_y_best, y_y_best, color="#FF6666", label="Youne")
plt.scatter(x_o_best, y_o_best, color="#66CCCC", label="Original Grover")
ax.legend()
|
https://github.com/PabloAMC/Qiskit_meetup_2021
|
PabloAMC
|
%matplotlib inline
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
#from iqx import *
from qiskit.aqua.circuits import PhaseEstimationCircuit
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.chemistry.core import Hamiltonian
from qiskit.circuit.library import PhaseEstimation
from qiskit import QuantumCircuit, execute, Aer
from qiskit.circuit import QuantumRegister, Qubit, Gate, ClassicalRegister
from qiskit.quantum_info import Statevector
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
from qiskit.chemistry.drivers import PySCFDriver, UnitsType, Molecule, PSI4Driver
molecule = Molecule(geometry=[['H', [0., 0., 0.]],
['H', [0., 0., 0.735]]],
charge=0, multiplicity=1)
driver = PySCFDriver(molecule = molecule, unit=UnitsType.ANGSTROM, basis='sto3g')
qmol = driver.run()
print(qmol.one_body_integrals)
print(qmol.two_body_integrals)
from qiskit.chemistry.transformations import (FermionicTransformation,
FermionicTransformationType,
FermionicQubitMappingType)
fermionic_transformation = FermionicTransformation(
transformation=FermionicTransformationType.FULL,
qubit_mapping=FermionicQubitMappingType.JORDAN_WIGNER,
two_qubit_reduction=False,
freeze_core=False)
qubit_op, _ = fermionic_transformation.transform(driver)
print('Qubit operator is', qubit_op)
# Complete here! Perhaps you will find some information in the VQE tutorial
num_orbitals = # To complete
num_particles = # To complete
qubit_mapping = # To complete
two_qubit_reduction = # To complete
z2_symmetries = # To complete
# Use the previous variables to create a Hartree Fock state
initial_state = # To complete
initial_circ = initial_state.construct_circuit()
print(initial_state.bitstr)
initial_circ.draw()
qubit_op, _ = fermionic_transformation.transform(driver)
print(qubit_op)
num_evaluation_qubits = 5
normalization_factor = 1/2 # Since the min energy will be approx -1.8 we need to normalize it so that it is smaller in absolute value than 1
### Complete here! Perhaps look for how to exponentiate an operator and create a circuit
unitary = (normalization_factor*#something).#something
### Look for Phase Estimation in the Qiskit documentation!
phase_estimation = #something
print(phase_estimation.qubits)
dir(phase_estimation)
phase_estimation.draw()
circ = initial_circ.combine(phase_estimation)
classical_eval = ClassicalRegister(num_evaluation_qubits, name = 'class_eval')
circ = circ + QuantumCircuit(classical_eval)
print(circ.qregs)
circ.measure(circ.qregs[1], classical_eval)
circ.draw()
# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
# Execute the circuit on the qasm simulator.
# We've set the number of repeats of the circuit
# to be 1024, which is the default.
job_sim = execute(circ, backend_sim, shots=1024)
# Grab the results from the job.
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
print(counts)
maxkey = '0'*num_evaluation_qubits
maxvalue = 0
for key, value in counts.items():
if value > maxvalue:
maxvalue = value
maxkey = key
energy = 0
for i,s in zip(range(num_evaluation_qubits), maxkey[::-1]):
energy -= (int(s)/2**(i))/normalization_factor
print('The energy is', energy, 'Hartrees')
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test the decompose pass"""
from numpy import pi
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.transpiler.passes import Decompose
from qiskit.converters import circuit_to_dag
from qiskit.circuit.library import HGate, CCXGate, U2Gate
from qiskit.quantum_info.operators import Operator
from qiskit.test import QiskitTestCase
class TestDecompose(QiskitTestCase):
"""Tests the decompose pass."""
def setUp(self):
super().setUp()
# example complex circuit
# ┌────────┐ ┌───┐┌─────────────┐
# q2_0: ┤0 ├────────────■──┤ H ├┤0 ├
# │ │ │ └───┘│ circuit-57 │
# q2_1: ┤1 gate1 ├────────────■───────┤1 ├
# │ │┌────────┐ │ └─────────────┘
# q2_2: ┤2 ├┤0 ├──■──────────────────────
# └────────┘│ │ │
# q2_3: ──────────┤1 gate2 ├──■──────────────────────
# │ │┌─┴─┐
# q2_4: ──────────┤2 ├┤ X ├────────────────────
# └────────┘└───┘
circ1 = QuantumCircuit(3)
circ1.h(0)
circ1.t(1)
circ1.x(2)
my_gate = circ1.to_gate(label="gate1")
circ2 = QuantumCircuit(3)
circ2.h(0)
circ2.cx(0, 1)
circ2.x(2)
my_gate2 = circ2.to_gate(label="gate2")
circ3 = QuantumCircuit(2)
circ3.x(0)
q_bits = QuantumRegister(5)
qc = QuantumCircuit(q_bits)
qc.append(my_gate, q_bits[:3])
qc.append(my_gate2, q_bits[2:])
qc.mct(q_bits[:4], q_bits[4])
qc.h(0)
qc.append(circ3, [0, 1])
self.complex_circuit = qc
def test_basic(self):
"""Test decompose a single H into u2."""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
dag = circuit_to_dag(circuit)
pass_ = Decompose(HGate)
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 1)
self.assertEqual(op_nodes[0].name, "u2")
def test_decompose_none(self):
"""Test decompose a single H into u2."""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
dag = circuit_to_dag(circuit)
pass_ = Decompose()
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 1)
self.assertEqual(op_nodes[0].name, "u2")
def test_decompose_only_h(self):
"""Test to decompose a single H, without the rest"""
qr = QuantumRegister(2, "qr")
circuit = QuantumCircuit(qr)
circuit.h(qr[0])
circuit.cx(qr[0], qr[1])
dag = circuit_to_dag(circuit)
pass_ = Decompose(HGate)
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 2)
for node in op_nodes:
self.assertIn(node.name, ["cx", "u2"])
def test_decompose_toffoli(self):
"""Test decompose CCX."""
qr1 = QuantumRegister(2, "qr1")
qr2 = QuantumRegister(1, "qr2")
circuit = QuantumCircuit(qr1, qr2)
circuit.ccx(qr1[0], qr1[1], qr2[0])
dag = circuit_to_dag(circuit)
pass_ = Decompose(CCXGate)
after_dag = pass_.run(dag)
op_nodes = after_dag.op_nodes()
self.assertEqual(len(op_nodes), 15)
for node in op_nodes:
self.assertIn(node.name, ["h", "t", "tdg", "cx"])
def test_decompose_conditional(self):
"""Test decompose a 1-qubit gates with a conditional."""
qr = QuantumRegister(1, "qr")
cr = ClassicalRegister(1, "cr")
circuit = QuantumCircuit(qr, cr)
circuit.h(qr).c_if(cr, 1)
circuit.x(qr).c_if(cr, 1)
dag = circuit_to_dag(circuit)
pass_ = Decompose(HGate)
after_dag = pass_.run(dag)
ref_circuit = QuantumCircuit(qr, cr)
ref_circuit.append(U2Gate(0, pi), [qr[0]]).c_if(cr, 1)
ref_circuit.x(qr).c_if(cr, 1)
ref_dag = circuit_to_dag(ref_circuit)
self.assertEqual(after_dag, ref_dag)
def test_decompose_oversized_instruction(self):
"""Test decompose on a single-op gate that doesn't use all qubits."""
# ref: https://github.com/Qiskit/qiskit-terra/issues/3440
qc1 = QuantumCircuit(2)
qc1.x(0)
gate = qc1.to_gate()
qc2 = QuantumCircuit(2)
qc2.append(gate, [0, 1])
output = qc2.decompose()
self.assertEqual(qc1, output)
def test_decomposition_preserves_qregs_order(self):
"""Test decomposing a gate preserves it's definition registers order"""
qr = QuantumRegister(2, "qr1")
qc1 = QuantumCircuit(qr)
qc1.cx(1, 0)
gate = qc1.to_gate()
qr2 = QuantumRegister(2, "qr2")
qc2 = QuantumCircuit(qr2)
qc2.append(gate, qr2)
expected = QuantumCircuit(qr2)
expected.cx(1, 0)
self.assertEqual(qc2.decompose(), expected)
def test_decompose_global_phase_1q(self):
"""Test decomposition of circuit with global phase"""
qc1 = QuantumCircuit(1)
qc1.rz(0.1, 0)
qc1.ry(0.5, 0)
qc1.global_phase += pi / 4
qcd = qc1.decompose()
self.assertEqual(Operator(qc1), Operator(qcd))
def test_decompose_global_phase_2q(self):
"""Test decomposition of circuit with global phase"""
qc1 = QuantumCircuit(2, global_phase=pi / 4)
qc1.rz(0.1, 0)
qc1.rxx(0.2, 0, 1)
qcd = qc1.decompose()
self.assertEqual(Operator(qc1), Operator(qcd))
def test_decompose_global_phase_1q_composite(self):
"""Test decomposition of circuit with global phase in a composite gate."""
circ = QuantumCircuit(1, global_phase=pi / 2)
circ.x(0)
circ.h(0)
v = circ.to_gate()
qc1 = QuantumCircuit(1)
qc1.append(v, [0])
qcd = qc1.decompose()
self.assertEqual(Operator(qc1), Operator(qcd))
def test_decompose_only_h_gate(self):
"""Test decomposition parameters so that only a certain gate is decomposed."""
circ = QuantumCircuit(2, 1)
circ.h(0)
circ.cz(0, 1)
decom_circ = circ.decompose(["h"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 2)
self.assertEqual(dag.op_nodes()[0].name, "u2")
self.assertEqual(dag.op_nodes()[1].name, "cz")
def test_decompose_only_given_label(self):
"""Test decomposition parameters so that only a given label is decomposed."""
decom_circ = self.complex_circuit.decompose(["gate2"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 7)
self.assertEqual(dag.op_nodes()[0].op.label, "gate1")
self.assertEqual(dag.op_nodes()[1].name, "h")
self.assertEqual(dag.op_nodes()[2].name, "cx")
self.assertEqual(dag.op_nodes()[3].name, "x")
self.assertEqual(dag.op_nodes()[4].name, "mcx")
self.assertEqual(dag.op_nodes()[5].name, "h")
self.assertRegex(dag.op_nodes()[6].name, "circuit-")
def test_decompose_only_given_name(self):
"""Test decomposition parameters so that only given name is decomposed."""
decom_circ = self.complex_circuit.decompose(["mcx"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 13)
self.assertEqual(dag.op_nodes()[0].op.label, "gate1")
self.assertEqual(dag.op_nodes()[1].op.label, "gate2")
self.assertEqual(dag.op_nodes()[2].name, "h")
self.assertEqual(dag.op_nodes()[3].name, "cu1")
self.assertEqual(dag.op_nodes()[4].name, "rcccx")
self.assertEqual(dag.op_nodes()[5].name, "h")
self.assertEqual(dag.op_nodes()[6].name, "h")
self.assertEqual(dag.op_nodes()[7].name, "cu1")
self.assertEqual(dag.op_nodes()[8].name, "rcccx_dg")
self.assertEqual(dag.op_nodes()[9].name, "h")
self.assertEqual(dag.op_nodes()[10].name, "c3sx")
self.assertEqual(dag.op_nodes()[11].name, "h")
self.assertRegex(dag.op_nodes()[12].name, "circuit-")
def test_decompose_mixture_of_names_and_labels(self):
"""Test decomposition parameters so that mixture of names and labels is decomposed"""
decom_circ = self.complex_circuit.decompose(["mcx", "gate2"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 15)
self.assertEqual(dag.op_nodes()[0].op.label, "gate1")
self.assertEqual(dag.op_nodes()[1].name, "h")
self.assertEqual(dag.op_nodes()[2].name, "cx")
self.assertEqual(dag.op_nodes()[3].name, "x")
self.assertEqual(dag.op_nodes()[4].name, "h")
self.assertEqual(dag.op_nodes()[5].name, "cu1")
self.assertEqual(dag.op_nodes()[6].name, "rcccx")
self.assertEqual(dag.op_nodes()[7].name, "h")
self.assertEqual(dag.op_nodes()[8].name, "h")
self.assertEqual(dag.op_nodes()[9].name, "cu1")
self.assertEqual(dag.op_nodes()[10].name, "rcccx_dg")
self.assertEqual(dag.op_nodes()[11].name, "h")
self.assertEqual(dag.op_nodes()[12].name, "c3sx")
self.assertEqual(dag.op_nodes()[13].name, "h")
self.assertRegex(dag.op_nodes()[14].name, "circuit-")
def test_decompose_name_wildcards(self):
"""Test decomposition parameters so that name wildcards is decomposed"""
decom_circ = self.complex_circuit.decompose(["circuit-*"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 9)
self.assertEqual(dag.op_nodes()[0].name, "h")
self.assertEqual(dag.op_nodes()[1].name, "t")
self.assertEqual(dag.op_nodes()[2].name, "x")
self.assertEqual(dag.op_nodes()[3].name, "h")
self.assertRegex(dag.op_nodes()[4].name, "cx")
self.assertEqual(dag.op_nodes()[5].name, "x")
self.assertEqual(dag.op_nodes()[6].name, "mcx")
self.assertEqual(dag.op_nodes()[7].name, "h")
self.assertEqual(dag.op_nodes()[8].name, "x")
def test_decompose_label_wildcards(self):
"""Test decomposition parameters so that label wildcards is decomposed"""
decom_circ = self.complex_circuit.decompose(["gate*"])
dag = circuit_to_dag(decom_circ)
self.assertEqual(len(dag.op_nodes()), 9)
self.assertEqual(dag.op_nodes()[0].name, "h")
self.assertEqual(dag.op_nodes()[1].name, "t")
self.assertEqual(dag.op_nodes()[2].name, "x")
self.assertEqual(dag.op_nodes()[3].name, "h")
self.assertEqual(dag.op_nodes()[4].name, "cx")
self.assertEqual(dag.op_nodes()[5].name, "x")
self.assertEqual(dag.op_nodes()[6].name, "mcx")
self.assertEqual(dag.op_nodes()[7].name, "h")
self.assertRegex(dag.op_nodes()[8].name, "circuit-")
def test_decompose_empty_gate(self):
"""Test a gate where the definition is an empty circuit is decomposed."""
empty = QuantumCircuit(1)
circuit = QuantumCircuit(1)
circuit.append(empty.to_gate(), [0])
decomposed = circuit.decompose()
self.assertEqual(len(decomposed.data), 0)
def test_decompose_reps(self):
"""Test decompose reps function is decomposed correctly"""
decom_circ = self.complex_circuit.decompose(reps=2)
decomposed = self.complex_circuit.decompose().decompose()
self.assertEqual(decom_circ, decomposed)
def test_decompose_single_qubit_clbit(self):
"""Test the decomposition of a block with a single qubit and clbit works.
Regression test of Qiskit/qiskit-terra#8591.
"""
block = QuantumCircuit(1, 1)
block.h(0)
circuit = QuantumCircuit(1, 1)
circuit.append(block, [0], [0])
decomposed = circuit.decompose()
self.assertEqual(decomposed, block)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.drivers import Molecule
from qiskit_nature.drivers.second_quantization import (
ElectronicStructureDriverType,
ElectronicStructureMoleculeDriver,
PySCFDriver,
)
from qiskit_nature.problems.second_quantization import ElectronicStructureProblem
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
from qiskit_nature.settings import settings
settings.dict_aux_operators = True
molecule = Molecule(
geometry=[["H", [0.0, 0.0, 0.0]], ["H", [0.0, 0.0, 0.735]]], charge=0, multiplicity=1
)
driver = ElectronicStructureMoleculeDriver(
molecule, basis="sto3g", driver_type=ElectronicStructureDriverType.PYSCF
)
# or equivalently:
driver = PySCFDriver.from_molecule(molecule, basis="sto3g")
transformer = FreezeCoreTransformer()
problem = ElectronicStructureProblem(driver, transformers=[transformer])
# Note: at this point, `driver.run()` has NOT been called yet. We can trigger this indirectly like so:
second_q_ops = problem.second_q_ops()
hamiltonian = second_q_ops["ElectronicEnergy"]
print(hamiltonian)
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.formats.molecule_info import MoleculeInfo
from qiskit_nature.second_q.transformers import FreezeCoreTransformer
molecule = MoleculeInfo(["H", "H"], [(0.0, 0.0, 0.0), (0.0, 0.0, 0.735)], charge=0, multiplicity=1)
driver = PySCFDriver.from_molecule(molecule, basis="sto3g")
# this is now done explicitly
problem = driver.run()
transformer = FreezeCoreTransformer()
# and you also apply transformers explicitly
problem = transformer.transform(problem)
hamiltonian = problem.hamiltonian.second_q_op()
print("\n".join(str(hamiltonian).splitlines()[:10] + ["..."]))
from qiskit_nature.drivers import Molecule
from qiskit_nature.drivers.second_quantization import PySCFDriver
molecule = Molecule(
geometry=[["H", [0.0, 0.0, 0.0]], ["H", [0.0, 0.0, 0.735]]], charge=0, multiplicity=1
)
driver = PySCFDriver.from_molecule(molecule)
result = driver.run()
print(type(result))
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.formats.molecule_info import MoleculeInfo
molecule = MoleculeInfo(["H", "H"], [(0.0, 0.0, 0.0), (0.0, 0.0, 0.735)], charge=0, multiplicity=1)
driver = PySCFDriver.from_molecule(molecule, basis="sto3g")
result = driver.run()
print(type(result))
from qiskit_nature.drivers.second_quantization import FCIDumpDriver
path_to_fcidump = "aux_files/h2.fcidump"
driver = FCIDumpDriver(path_to_fcidump)
result = driver.run()
print(type(result))
from qiskit_nature.second_q.formats.fcidump import FCIDump
path_to_fcidump = "aux_files/h2.fcidump"
fcidump = FCIDump.from_file(path_to_fcidump)
print(type(fcidump))
from qiskit_nature.second_q.formats.fcidump_translator import fcidump_to_problem
problem = fcidump_to_problem(fcidump)
print(type(problem))
from qiskit_nature.drivers.second_quantization import PySCFDriver
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
transformer = FreezeCoreTransformer()
driver = PySCFDriver()
transformed_result = transformer.transform(driver.run())
print(type(transformed_result))
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.transformers import FreezeCoreTransformer
transformer = FreezeCoreTransformer()
driver = PySCFDriver()
transformed_result = transformer.transform(driver.run())
print(type(transformed_result))
from qiskit_nature.drivers.second_quantization import PySCFDriver
from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem
from qiskit_nature.transformers.second_quantization.electronic import FreezeCoreTransformer
driver = PySCFDriver()
transformer = FreezeCoreTransformer()
problem = ElectronicStructureProblem(driver, transformers=[transformer])
# we trigger driver.run() implicitly like so:
second_q_ops = problem.second_q_ops()
hamiltonian_op = second_q_ops.pop("ElectronicEnergy")
aux_ops = second_q_ops
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.transformers import FreezeCoreTransformer
driver = PySCFDriver()
problem = driver.run()
transformer = FreezeCoreTransformer()
problem = transformer.transform(problem)
hamiltonian_op, aux_ops = problem.second_q_ops()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from __future__ import annotations
import numpy as np
import networkx as nx
num_nodes = 4
w = np.array([[0., 1., 1., 0.],
[1., 0., 1., 1.],
[1., 1., 0., 1.],
[0., 1., 1., 0.]])
G = nx.from_numpy_array(w)
layout = nx.random_layout(G, seed=10)
colors = ['r', 'g', 'b', 'y']
nx.draw(G, layout, node_color=colors)
labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos=layout, edge_labels=labels);
def objective_value(x: np.ndarray, w: np.ndarray) -> float:
"""Compute the value of a cut.
Args:
x: Binary string as numpy array.
w: Adjacency matrix.
Returns:
Value of the cut.
"""
X = np.outer(x, (1 - x))
w_01 = np.where(w != 0, 1, 0)
return np.sum(w_01 * X)
def bitfield(n: int, L: int) -> list[int]:
result = np.binary_repr(n, L)
return [int(digit) for digit in result] # [2:] to chop off the "0b" part
# use the brute-force way to generate the oracle
L = num_nodes
max = 2**L
sol = np.inf
for i in range(max):
cur = bitfield(i, L)
how_many_nonzero = np.count_nonzero(cur)
if how_many_nonzero * 2 != L: # not balanced
continue
cur_v = objective_value(np.array(cur), w)
if cur_v < sol:
sol = cur_v
print(f'Objective value computed by the brute-force method is {sol}')
from qiskit.quantum_info import Pauli, SparsePauliOp
def get_operator(weight_matrix: np.ndarray) -> tuple[SparsePauliOp, float]:
r"""Generate Hamiltonian for the graph partitioning
Notes:
Goals:
1 Separate the vertices into two set of the same size.
2 Make sure the number of edges between the two set is minimized.
Hamiltonian:
H = H_A + H_B
H_A = sum\_{(i,j)\in E}{(1-ZiZj)/2}
H_B = (sum_{i}{Zi})^2 = sum_{i}{Zi^2}+sum_{i!=j}{ZiZj}
H_A is for achieving goal 2 and H_B is for achieving goal 1.
Args:
weight_matrix: Adjacency matrix.
Returns:
Operator for the Hamiltonian
A constant shift for the obj function.
"""
num_nodes = len(weight_matrix)
pauli_list = []
coeffs = []
shift = 0
for i in range(num_nodes):
for j in range(i):
if weight_matrix[i, j] != 0:
x_p = np.zeros(num_nodes, dtype=bool)
z_p = np.zeros(num_nodes, dtype=bool)
z_p[i] = True
z_p[j] = True
pauli_list.append(Pauli((z_p, x_p)))
coeffs.append(-0.5)
shift += 0.5
for i in range(num_nodes):
for j in range(num_nodes):
if i != j:
x_p = np.zeros(num_nodes, dtype=bool)
z_p = np.zeros(num_nodes, dtype=bool)
z_p[i] = True
z_p[j] = True
pauli_list.append(Pauli((z_p, x_p)))
coeffs.append(1.0)
else:
shift += 1
return SparsePauliOp(pauli_list, coeffs=coeffs), shift
qubit_op, offset = get_operator(w)
from qiskit.algorithms.minimum_eigensolvers import QAOA
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import TwoLocal
from qiskit.primitives import Sampler
from qiskit.quantum_info import Pauli, Statevector
from qiskit.result import QuasiDistribution
from qiskit.utils import algorithm_globals
sampler = Sampler()
def sample_most_likely(state_vector: QuasiDistribution | Statevector) -> np.ndarray:
"""Compute the most likely binary string from state vector.
Args:
state_vector: State vector or quasi-distribution.
Returns:
Binary string as an array of ints.
"""
if isinstance(state_vector, QuasiDistribution):
values = list(state_vector.values())
else:
values = state_vector
n = int(np.log2(len(values)))
k = np.argmax(np.abs(values))
x = bitfield(k, n)
x.reverse()
return np.asarray(x)
algorithm_globals.random_seed = 10598
optimizer = COBYLA()
qaoa = QAOA(sampler, optimizer, reps=2)
result = qaoa.compute_minimum_eigenvalue(qubit_op)
x = sample_most_likely(result.eigenstate)
print(x)
print(f'Objective value computed by QAOA is {objective_value(x, w)}')
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit.quantum_info import Operator
npme = NumPyMinimumEigensolver()
result = npme.compute_minimum_eigenvalue(Operator(qubit_op))
x = sample_most_likely(result.eigenstate)
print(x)
print(f'Objective value computed by the NumPyMinimumEigensolver is {objective_value(x, w)}')
from qiskit.algorithms.minimum_eigensolvers import SamplingVQE
from qiskit.circuit.library import TwoLocal
from qiskit.utils import algorithm_globals
algorithm_globals.random_seed = 10598
optimizer = COBYLA()
ansatz = TwoLocal(qubit_op.num_qubits, "ry", "cz", reps=2, entanglement="linear")
sampling_vqe = SamplingVQE(sampler, ansatz, optimizer)
result = sampling_vqe.compute_minimum_eigenvalue(qubit_op)
x = sample_most_likely(result.eigenstate)
print(x)
print(f"Objective value computed by VQE is {objective_value(x, w)}")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/AbeerVaishnav13/Quantum-Programs
|
AbeerVaishnav13
|
from qiskit import *
%matplotlib inline
import numpy as np
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.draw('mpl')
from qiskit.visualization import plot_state_hinton
sim = Aer.get_backend('statevector_simulator') # qasm_simulator, statevector_simulator, unitary_simulator
result = execute(qc, backend=sim).result()
state = result.get_statevector(qc)
plot_state_hinton(state)
from qiskit.visualization import *
from matplotlib import style
style.use('bmh')
style.use('dark_background')
plot_state_city(state)
plot_state_paulivec(result.get_statevector(qc))
from qiskit import IBMQ
IBMQ.load_account()
from qiskit.tools.monitor import job_monitor
provider = IBMQ.get_provider(hub='ibm-q', group='open')
backend = provider.get_backend('ibmq_santiago')
job = execute(qc, backend=backend, shots=8192)
job_monitor(job)
from qiskit.visualization import plot_histogram
result = job.result()
plot_histogram(result.get_counts(qc))
|
https://github.com/nicomeyer96/qiskit-torch-module
|
nicomeyer96
|
# This code is part of the Qiskit-Torch-Module.
#
# If used in your project please cite this work as described in the README file.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import numpy as np
import torch
import torch.nn as nn
from collections.abc import Sequence
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter, ParameterVector
from . import QuantumModule
class HybridModule(nn.Module):
""" This class implements a hybrid torch-module, by embedding a quantum module (with Pauli-Z observables on all
individual qubits) between two linear layers.
args:
circuit: Quantum circuit ansatz
encoding_params: Parameters used for data encoding, must be present in circuit | None if the circuit does
not use data encoding
variational_params: Parameters used for training, must be present in circuit
input_size: Dimensionality of input (does NOT need to correspond to number of encoding parameters)
output_size: Dimensionality of output (does NOT need to correspond to number of observables /qubits)
variational_params_names: Names for the trainable parameter sets (default: `variational_#`)
variational_params_initial: Initializers for the trainable parameter sets (default: 'uniform')
choices: constant(val=1.0) | uniform(a=0.0, b=2*pi) | normal(mean=0.0, std=1.0)
seed_init: Generate initial parameters with fixed seed (default: None)
num_threads_forward: Number of parallel threads for forward computation (default: all available threads)
num_threads_backward: Number of parallel threads for backward computation (default: all available threads)
"""
def __init__(
self,
circuit: QuantumCircuit,
encoding_params: Sequence[Parameter] | ParameterVector | None,
variational_params: Sequence[Sequence[Parameter]] | Sequence[ParameterVector] | Sequence[Parameter] | ParameterVector,
input_size: int,
output_size: int,
variational_params_names: Sequence[str] | str = None,
variational_params_initial: str | tuple[str, dict[str: float]] | Sequence[float, np.floating] |
Sequence[str | tuple[str, dict[str: float]] | Sequence[float]] = 'uniform',
seed_init: int = None,
num_threads_forward: int = 0,
num_threads_backward: int = 0,
):
super(HybridModule, self).__init__()
# save torch.random state from before
torch_random_state_ = torch.random.get_rng_state()
if seed_init is not None:
torch.random.manual_seed(seed_init)
# initialize classical preprocessing layer (keep this order to ensure printing in right order)
self._preprocessing = nn.Linear(in_features=input_size, out_features=len(encoding_params), bias=True)
self._input_size = input_size
# initialize quantum module
# - single-qubit observables have to be evaluated on all qubits, as this is assumed by the postprocessing NN
# - gradients w.r.t. input parameters have to be computed in order to propagate them to the preprocessing NN
# - the seed is set to None, as a `global` seed can also be set in the hybrid module
self._quantum_module = QuantumModule(
circuit=circuit,
encoding_params=encoding_params,
variational_params=variational_params,
variational_params_names=variational_params_names,
variational_params_initial=variational_params_initial,
observables='individualZ',
num_threads_forward=num_threads_forward,
num_threads_backward=num_threads_backward,
encoding_gradients_flag=True,
seed_init=None
)
# initialize classical postprocessing layer
self._postprocessing = nn.Linear(in_features=self._quantum_module.output_size, out_features=output_size, bias=True)
self._output_size = output_size
# re-set seed to restore previous behaviour (i.e. don't interfere with potential other (un)set seeds)
if seed_init is not None:
torch.random.set_rng_state(torch_random_state_)
def forward(
self,
input_tensor: torch.Tensor
) -> torch.Tensor:
""" Forward pass through preprocessing linear layer, quantum module, and post-processing linear layer
Args:
input_tensor: Input to the quantum module
Returns:
Result of forward pass
"""
# Make sure everything is realized as Tensor (dtype=torch.float32 to enhance efficiency)
if not torch.is_tensor(input_tensor):
if isinstance(input_tensor, list):
# conversion list -> np.array -> torch.tensor is faster than directly list -> torch.tensor
input_tensor = np.array(input_tensor)
input_tensor = torch.FloatTensor(input_tensor)
else:
input_tensor = input_tensor.to(dtype=torch.float32)
input_tensor = self._preprocessing(input_tensor)
input_tensor = self._quantum_module(input_tensor)
input_tensor = self._postprocessing(input_tensor)
return input_tensor
@property
def quantum_module(self):
""" Returns underlying quantum module
"""
return self._quantum_module
@property
def pre_parameters_(self):
""" Returns a handle of the trainable parameters in the preprocessing NN (weights + bias)
"""
return self._preprocessing.parameters()
@property
def quantum_parameters_(self):
""" Returns a handle of the trainable parameters in the quantum module
(only for convenience, can also be accessed via the methods of the `quantum_module`)
Can be used to initialize a torch optimizer, e.g.:
torchHQNN = HybridModule(...)
opt = torch.optim.SGD([{'params': torchHQNN.pre_parameters}, {'params': torchHQNN.quantum_parameters_},
{'params': torchHQNN.post_parameters_}], lr=0.1)
This is equivalent to:
opt = torch.optim.SGD(torchHQNN.parameters(), lr=0.1)
One can also use the class members to access the individual parameter sets of the quantum module
(omitting the classical parameters for now, which can be handled in a similar fashion)
opt = torch.optim.SGD([{'params': qtmModel.quantum_module.variational_0},
{'params': qtmModel.quantum_module.variational_1}], lr=0.1)
or
opt = torch.optim.SGD([{'params': qtmModel.quantum_parameters_[0]},
{'params': qtmModel.quantum_parameters_[0]}], lr=0.1)
In this case equivalent to above, but can be used to set e.g. different learning rates for parameter sets.
A summary of all available parameter sets can also be visualized:
print(torchHQNN)
"""
return self._quantum_module.variational_
@property
def post_parameters_(self):
""" Returns a handle of the trainable parameters in the preprocessing NN (weights + bias)
"""
return self._postprocessing.parameters()
@property
def num_trainable_parameters_quantum(self):
""" Returns number of trainable parameters in the quantum part if the hybrid module.
"""
return self._quantum_module.num_trainable_parameters
@property
def num_trainable_parameters_classical(self):
""" Returns number of trainable parameters in the quantum part if the hybrid module.
"""
pre_parameters = filter(lambda p: p.requires_grad, self._preprocessing.parameters())
post_parameters = filter(lambda p: p.requires_grad, self._postprocessing.parameters())
return sum([np.prod(p.size()) for p in pre_parameters]) + sum([np.prod(p.size()) for p in post_parameters])
@property
def num_trainable_parameters(self):
""" Returns number of trainable parameters in the hybrid module
"""
return self.num_trainable_parameters_quantum + self.num_trainable_parameters_classical
@property
def input_size(self) -> int:
""" Returns the input size of the hybrid module
"""
return self._input_size
@property
def output_size(self) -> int:
""" Returns the output size of the hybrid module
"""
return self._output_size
|
https://github.com/zeynepCankara/Introduction-Quantum-Programming
|
zeynepCankara
|
#
# your solution is here
#
import numpy as np
random_arr = np.random.randn(3,3)
random_arr = np.abs(random_arr)
sum_elements = np.sum(random_arr)
random_arr = random_arr / sum_elements
print(random_arr)
print("verify the probabilistic state from sum of elements: " + str(np.sum(random_arr)))
#
# your solution is here
#
prob_operator = np.array([[0.6, 0.3], [0.4, 0.7]])
prob_state = np.array([1, 0])
new_prob_state = np.matmul(prob_operator, prob_state)
print("1st state transition: " + str(new_prob_state))
new_prob_state = np.matmul(prob_operator, new_prob_state)
print("2nd state transition: " + str(new_prob_state))
# operator for the test
A = [
[0.4,0.6,0],
[0.2,0.1,0.7],
[0.4,0.3,0.3]
]
# state for test
v = [0.1,0.3,0.6]
#
# your solution is here
#
# v = [1,0,0]
def find_new_state(A, v):
return np.matmul(A, v)
new_state = find_new_state(A, v)
print(new_state)
# the initial state
initial = [0.5, 0, 0.5, 0]
# probabilistic operator for symbol a
A = [
[0.5, 0, 0, 0],
[0.25, 1, 0, 0],
[0, 0, 1, 0],
[0.25, 0, 0, 1]
]
# probabilistic operator for symbol b
B = [
[1, 0, 0, 0],
[0, 1, 0.25, 0],
[0, 0, 0.5, 0],
[0, 0, 0.25, 1]
]
#
# your solution is here
#
def find_new_state(operator, initial):
return np.matmul(operator, initial)
def read_string(string_to_read):
for c in string_to_read:
|
https://github.com/lmarza/QuantumDeskCalculator
|
lmarza
|
import math
from qiskit import *
from utils import bcolors, executeQFT, evolveQFTStateSub, inverseQFT
pie = math.pi
def sub(a, b, qc):
n = len(a)
#Compute the Fourier transform of register a
for i in range(0, n):
executeQFT(qc, a, n-(i+1), pie)
#Add the two numbers by evolving the Fourier transform F(ψ(reg_a))>
#to |F(ψ(reg_a-reg_b))>
for i in range(0, n):
evolveQFTStateSub(qc, a, b, n-(i+1), pie)
#Compute the inverse Fourier transform of register a
for i in range(0, n):
inverseQFT(qc, a, i, pie)
|
https://github.com/Advanced-Research-Centre/QPULBA
|
Advanced-Research-Centre
|
import numpy as np
import random
from qiskit import QuantumCircuit, Aer, execute
from math import log2, ceil, pi
from numpy import savetxt, save, savez_compressed
#=====================================================================================================================
simulator = Aer.get_backend('statevector_simulator')
def disp_isv(circ, msg="", all=True, precision=1e-8):
sim_res = execute(circ, simulator).result()
statevector = sim_res.get_statevector(circ)
qb = int(log2(len(statevector)))
print("\n============ State Vector ============", msg)
s = 0
for i in statevector:
if (all == True): print(' ({:+.5f}) |{:0{}b}>'.format(i,s,qb))
else:
if (abs(i) > precision): print(' ({:+.5f}) |{:0{}b}>'.format(i,s,qb))
s = s+1
print("============..............============")
return
# 24 qubits with Hadamard on 12 qubits log size: 880 MB csv, 816 MB txt, 256 MB npy, 255 KB npz
def save_isv(statevector, mode=1):
if (mode == 1): savez_compressed('output.npz', statevector)
elif (mode == 2): save('output.npy', statevector)
elif (mode == 3):
qb = int(log2(len(statevector)))
f = open("output.txt", "w")
f.write("============ State Vector ============\n")
s = 0
for i in statevector:
f.write(' ({:+.5f}) |{:0{}b}>'.format(i,s,qb)+'\n')
s = s+1
f.write("============..............============")
f.close()
elif (mode == 4): savetxt('output.csv', statevector, delimiter=',')
else: print('Invalid mode selected')
return
#=====================================================================================================================
def nCX(k,c,t,b):
nc = len(c)
if nc == 1:
k.cx(c[0], t[0])
elif nc == 2:
k.toffoli(c[0], c[1], t[0])
else:
nch = ceil(nc/2)
c1 = c[:nch]
c2 = c[nch:]
c2.append(b[0])
nCX(k,c1,b,[nch+1])
nCX(k,c2,t,[nch-1])
nCX(k,c1,b,[nch+1])
nCX(k,c2,t,[nch-1])
return
#=====================================================================================================================
def U_init(qcirc, circ_width, fsm):
for i in fsm:
qcirc.h(i)
return
def U_read(qcirc, read, head, tape, ancilla):
# Reset read (prepz measures superposed states... need to uncompute)
for cell in range(0, len(tape)):
enc = format(cell, '#0'+str(len(head)+2)+'b') # 2 for '0b' prefix
for i in range(2, len(enc)):
if(enc[i] == '0'):
qcirc.x(head[(len(head)-1)-(i-2)])
nCX(qcirc, head+[tape[cell]], read, [ancilla[0]])
for i in range(2, len(enc)):
if(enc[i] == '0'):
qcirc.x(head[(len(head)-1)-(i-2)])
qcirc.barrier()
return
def U_fsm(qcirc, tick, fsm, state, read, write, move, ancilla):
# Description Number Encoding: {Q/M/W}{QR}
# [ Q11 M11 W11 Q10 M10 W10 Q01 M01 W01 Q00 M00 W00 ] LSQ = W00 = fsm[0]
qcirc.x(state[tick]) # If s == 0
qcirc.x(read[0]) # If s == 0 && read == 0
nCX(qcirc, [state[tick],fsm[0],read[0]], write, [ancilla[0]]) # Update write
nCX(qcirc, [state[tick],fsm[1],read[0]], move, [ancilla[0]]) # Update move
nCX(qcirc, [state[tick],fsm[2],read[0]], [state[tick+1]], [ancilla[0]]) # Update state
qcirc.x(read[0]) # If s == 0 && read == 1
nCX(qcirc, [state[tick],fsm[3],read[0]], write, [ancilla[0]]) # Update write
nCX(qcirc, [state[tick],fsm[4],read[0]], move, [ancilla[0]]) # Update move
nCX(qcirc, [state[tick],fsm[5],read[0]], [state[tick+1]], [ancilla[0]]) # Update state
qcirc.x(state[tick]) # If s == 1
qcirc.x(read[0]) # If s == 1 && read == 0
nCX(qcirc, [state[tick],fsm[6],read[0]], write, [ancilla[0]]) # Update write
nCX(qcirc, [state[tick],fsm[7],read[0]], move, [ancilla[0]]) # Update move
nCX(qcirc, [state[tick],fsm[8],read[0]], [state[tick+1]], [ancilla[0]]) # Update state
qcirc.x(read[0]) # If s == 1 && read == 1
nCX(qcirc, [state[tick],fsm[9],read[0]], write, [ancilla[0]]) # Update write
nCX(qcirc, [state[tick],fsm[10],read[0]], move, [ancilla[0]]) # Update move
nCX(qcirc, [state[tick],fsm[11],read[0]], [state[tick+1]], [ancilla[0]]) # Update state
return
def U_write(qcirc, write, head, tape, ancilla):
# Reset write (prepz measures superposed states... need to uncompute)
for cell in range(0, len(tape)):
enc = format(cell, '#0'+str(len(head)+2)+'b') # 2 for '0b' prefix
for i in range(2, len(enc)):
if(enc[i] == '0'):
qcirc.x(head[(len(head)-1)-(i-2)])
nCX(qcirc, head+write, [tape[cell]], [ancilla[0]])
for i in range(2, len(enc)):
if(enc[i] == '0'):
qcirc.x(head[(len(head)-1)-(i-2)])
return
def U_move(qcirc, move, head, ancilla):
# Increment/Decrement using Adder
reg_a = move.copy()
reg_a.extend([-1]*(len(head)-len(move)))
reg_b = head.copy()
reg_c = [-1] # No initial carry
reg_c.extend(ancilla)
reg_c.append(-1) # Ignore Head position under/overflow. Trim bits. Last carry not accounted, All-ones overflows to All-zeros
def q_carry(qcirc, q0, q1, q2, q3):
if (q1 != -1 and q2 != -1 and q3 != -1): qcirc.toffoli(q1, q2, q3)
if (q1 != -1 and q2 != -1): qcirc.cx(q1, q2)
if (q0 != -1 and q2 != -1 and q3 != -1): qcirc.toffoli(q0, q2, q3)
def q_mid(qcirc, q0, q1):
if (q0 != -1 and q1 != -1): qcirc.cx(q0, q1)
def q_sum(qcirc, q0, q1, q2):
if (q0 != -1 and q2 != -1): qcirc.cx(q0, q2)
if (q1 != -1 and q2 != -1): qcirc.cx(q1, q2)
def q_rcarry(qcirc, q0, q1, q2, q3):
if (q0 != -1 and q2 != -1 and q3 != -1): qcirc.toffoli(q0, q2, q3)
if (q1 != -1 and q2 != -1): qcirc.cx(q1, q2)
if (q1 != -1 and q2 != -1 and q3 != -1): qcirc.toffoli(q1, q2, q3)
# Quantum Adder
for i in range(0,len(head)):
q_carry(qcirc,reg_c[i],reg_a[i],reg_b[i],reg_c[i+1])
q_mid(qcirc,reg_a[i],reg_b[i])
q_sum(qcirc,reg_c[i],reg_a[i],reg_b[i])
for i in range(len(head)-2,-1,-1):
q_rcarry(qcirc,reg_c[i],reg_a[i],reg_b[i],reg_c[i+1])
q_sum(qcirc,reg_c[i],reg_a[i],reg_b[i])
qcirc.barrier(move, head, ancilla)
qcirc.x(reg_a[0])
# Quantum Subtractor
for i in range(0,len(head)-1):
q_sum(qcirc,reg_c[i],reg_a[i],reg_b[i])
q_carry(qcirc,reg_c[i],reg_a[i],reg_b[i],reg_c[i+1])
q_sum(qcirc,reg_c[i+1],reg_a[i+1],reg_b[i+1])
q_mid(qcirc,reg_a[i+1],reg_b[i+1])
for i in range(len(head)-2,-1,-1):
q_rcarry(qcirc,reg_c[i],reg_a[i],reg_b[i],reg_c[i+1])
qcirc.x(reg_a[0])
qcirc.barrier()
return
def U_rst(qcirc, tick, fsm, state, read, write, move, ancilla):
# Reset write and move
qcirc.x(state[tick])
qcirc.x(read[0])
nCX(qcirc, [state[tick],fsm[0],read[0]], write, [ancilla[0]])
nCX(qcirc, [state[tick],fsm[1],read[0]], move, [ancilla[0]])
qcirc.x(read[0])
nCX(qcirc, [state[tick],fsm[3],read[0]], write, [ancilla[0]])
nCX(qcirc, [state[tick],fsm[4],read[0]], move, [ancilla[0]])
qcirc.x(state[tick])
qcirc.x(read[0])
nCX(qcirc, [state[tick],fsm[6],read[0]], write, [ancilla[0]])
nCX(qcirc, [state[tick],fsm[7],read[0]], move, [ancilla[0]])
qcirc.x(read[0])
nCX(qcirc, [state[tick],fsm[9],read[0]], write, [ancilla[0]])
nCX(qcirc, [state[tick],fsm[10],read[0]], move, [ancilla[0]])
# Maintain computation history
qcirc.swap(state[0],state[tick+1])
return
#=====================================================================================================================
def Test_cfg(block):
global fsm, state, move, head, read, write, tape, ancilla, test
if (block == 'none'):
return
elif (block == 'read'):
fsm = []
state = []
move = []
head = [0,1,2,3]
read = [4]
write = []
tape = [5,6,7,8,9,10,11,12,13,14,15,16]
ancilla = [17]
test = [18]
elif (block == 'fsm'):
fsm = [0,1,2,3,4,5,6,7,8,9,10,11]
state = [12,13]
move = [14]
head = []
read = [15]
write = [16]
tape = []
ancilla = [17]
test = [18,19,20]
elif (block == 'move'):
fsm = []
state = []
move = [0]
head = [1,2,3,4]
read = []
write = []
tape = []
ancilla = [5,6,7]
test = [8,9,10,11]
elif (block == 'write'):
fsm = []
state = []
move = []
head = [0,1,2,3]
read = []
write = [4]
tape = [5,6,7,8,9,10,11,12,13,14,15,16]
ancilla = [17]
test = []#[18,19,20,21,22,23,24,25,26,27,28,29]
elif (block == 'rst'):
fsm = [0,1,2,3,4,5,6,7,8,9,10,11]
state = [12,13]
move = [14]
head = []
read = [15]
write = [16]
tape = []
ancilla = [17]
test = [18,19,20,21]
print("\n\nTEST CONFIGURATION\n\tFSM\t:",fsm,"\n\tSTATE\t:",state,"\n\tMOVE\t:",move,"\n\tHEAD\t:",head,"\n\tREAD\t:",read,"\n\tWRITE\t:",write,"\n\tTAPE\t:",tape,"\n\tANCILLA :",ancilla,"\n\tTEST\t:",test)
def Test_read(qcirc, read, head, tape, ancilla, test):
# Test using full superposition of head and some random tape qubits
# Test associated to read
for i in range(0,len(head)):
qcirc.h(head[i])
# Create random binary string of length tape
randbin = ""
for i in range(len(tape)): randbin += str(random.randint(0, 1))
for i in range(0,len(tape)):
if (randbin[i] == '1'):
qcirc.h(tape[i]) # Replace H with X for ease
qcirc.cx(read[0],test[0])
print("Test tape:",randbin)
qcirc.barrier()
return
def Test_fsm(qcirc, tick, fsm, state, read, write, move, ancilla, test):
# Test using full superposition of fsm, current state, read
# Test associated to move, write, new state
# fsm superposition part of U_init
qcirc.barrier()
qcirc.h(state[0])
qcirc.h(read[0])
qcirc.barrier()
qcirc.cx(write[0],test[0])
qcirc.cx(move[0],test[1])
qcirc.cx(state[1],test[2])
qcirc.barrier()
return
def Test_write(qcirc, write, head, tape, ancilla, test):
# Test using full superposition of head and write
# Test associated to tape (optional)
for i in range(0,len(head)):
qcirc.h(head[i])
qcirc.h(write)
# for i in range(0,len(tape)):
# qcirc.cx(tape[i],test[i])
return
def Test_move(qcirc, move, head, ancilla, test):
# Test using full superposition of head, both inc/dec
# Test associated to head
for i in range(0,len(head)):
qcirc.ry(round(np.pi * random.random(),2),head[i])
qcirc.cx(head[i],test[i])
qcirc.ry(round(np.pi * random.random(),2),move[0])
qcirc.barrier()
return
def Test_rst(qcirc, tick, fsm, state, read, write, move, ancilla, test):
# Test using full superposition of fsm, current state, read
# Test associated to move, write, new state
# fsm superposition part of U_init
for i in range(0,len(state)):
qcirc.h(state[i])
qcirc.h(read[0])
qcirc.h(write[0])
qcirc.h(move[0])
qcirc.barrier()
for i in range(0,len(state)):
qcirc.cx(state[i],test[i])
qcirc.cx(write[0],test[len(state)])
qcirc.cx(move[0],test[len(state)+1])
qcirc.barrier()
return
#=====================================================================================================================
ssz = 2 # State size (Initial state is all 0)
asz = 2 # Alphabet size: Binary (0 is blank/default)
tdim = 1 # Tape dimension
csz = ceil(log2(asz)) # Character symbol size
senc = ceil(log2(ssz)) # State encoding size
transitions = ssz * asz # Number of transition arrows in FSM
dsz = transitions * (tdim + csz + senc) # Description size
machines = 2 ** dsz
print("\nNumber of "+str(ssz)+"-state "+str(asz)+"-symbol "+str(tdim)+"-dimension Quantum Parallel Universal Linear Bounded Automata: "+str(machines))
tsz = dsz # Turing Tape size (same as dsz to estimating self-replication and algorithmic probability)
hsz = ceil(log2(tsz)) # Head size
sim_tick = tsz # Number of ticks of the FSM before abort
sim_tick = 1 # Just 1 QPULBA cycle for proof-of-concept
tlog = (sim_tick+1) * senc # Transition log # required?
nanc = 3
qnos = [dsz, tlog, tdim, hsz, csz, csz, tsz, nanc]
fsm = list(range(sum(qnos[0:0]),sum(qnos[0:1])))
state = list(range(sum(qnos[0:1]),sum(qnos[0:2]))) # States (Binary coded)
move = list(range(sum(qnos[0:2]),sum(qnos[0:3])))
head = list(range(sum(qnos[0:3]),sum(qnos[0:4]))) # Binary coded, 0-MSB 2-LSB, [001] refers to Tape pos 1, not 4
read = list(range(sum(qnos[0:4]),sum(qnos[0:5])))
write = list(range(sum(qnos[0:5]),sum(qnos[0:6]))) # Can be MUXed with read?
tape = list(range(sum(qnos[0:6]),sum(qnos[0:7])))
ancilla = list(range(sum(qnos[0:7]),sum(qnos[0:8])))
print("\nFSM\t:",fsm,"\nSTATE\t:",state,"\nMOVE\t:",move,"\nHEAD\t:",head,"\nREAD\t:",read,"\nWRITE\t:",write,"\nTAPE\t:",tape,"\nANCILLA :",ancilla)
#=====================================================================================================================
test = []
unit = 'all' # 'all', read', 'fsm', 'write', 'move', 'rst'
Test_cfg(unit)
qcirc_width = len(fsm) + len(state) + len(move) + len(head) + len(read) + len(write) + len(tape) + len(ancilla) + len(test)
qcirc = QuantumCircuit(qcirc_width)
qcirc.barrier()
# 1. Initialize
U_init(qcirc, qcirc_width, fsm)
# 2. Run machine for n-iterations:
for tick in range(0, sim_tick):
# 2.1 {read} << U_read({head, tape})
if (unit == 'read'): Test_read(qcirc, read, head, tape, ancilla, test)
if (unit == 'read' or unit == 'all'): U_read(qcirc, read, head, tape, ancilla)
# 2.2 {write, state, move} << U_fsm({read, state, fsm})
if (unit == 'fsm'): Test_fsm(qcirc, tick, fsm, state, read, write, move, ancilla, test)
if (unit == 'fsm' or unit == 'all'): U_fsm(qcirc, tick, fsm, state, read, write, move, ancilla)
# 2.3 {tape} << U_write({head, write})
if (unit == 'write'): Test_write(qcirc, write, head, tape, ancilla, test)
if (unit == 'write' or unit == 'all'): U_write(qcirc, write, head, tape, ancilla)
# 2.4 {head, err} << U_move({head, move})
if (unit == 'move'): Test_move(qcirc, move, head, ancilla, test)
if (unit == 'move' or unit == 'all'): U_move(qcirc, move, head, ancilla)
# 2.5 reset
if (unit == 'rst'): Test_rst(qcirc, tick, fsm, state, read, write, move, ancilla, test)
if (unit == 'rst' or unit == 'all'): U_rst(qcirc, tick, fsm, state, read, write, move, ancilla)
print()
print(qcirc.draw())
#print(qcirc.qasm())
#disp_isv(qcirc, "Step: Test "+unit, all=False, precision=1e-4) # Full simulation doesn't work
#=====================================================================================================================
|
https://github.com/mballarin97/mps_qnn
|
mballarin97
|
from qiskit import *
from oracle_generation import generate_oracle
get_bin = lambda x, n: format(x, 'b').zfill(n)
def gen_circuits(min,max,size):
circuits = []
secrets = []
ORACLE_SIZE = size
for i in range(min,max+1):
cur_str = get_bin(i,ORACLE_SIZE-1)
(circuit, secret) = generate_oracle(ORACLE_SIZE,False,3,cur_str)
circuits.append(circuit)
secrets.append(secret)
return (circuits, secrets)
|
https://github.com/quantumyatra/quantum_computing
|
quantumyatra
|
# Useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from math import pi
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.tools.visualization import circuit_drawer
from qiskit.quantum_info import state_fidelity
from qiskit import BasicAer
backend = BasicAer.get_backend('unitary_simulator')
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cu1(pi/2,q[0], q[1])
qc.draw(output='mpl')
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[0])
qc.cu1(pi/2,q[0], q[1])
qc.u3(pi/2,pi/2,pi/2,q[1])
qc.cu1(pi/2,q[1], q[2])
qc.u3(pi/2,pi/2,pi/2,q[2])
qc.draw(output='mpl')
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
q = QuantumRegister(4)
qc = QuantumCircuit(q)
qc.u3(pi/2,pi/2,pi/2,q[0])
qc.cu1(pi/2,q[0], q[1])
qc.u2(pi/2,pi/2,q[1])
qc.u1(pi/2,q[2])
qc.x(q[0])
qc.ccx(q[1],q[2],q[3])
qc.y(q[1])
qc.z(q[2])
qc.cx(q[2],q[3])
qc.z(q[3])
qc.h(q[3])
qc.s(q[0])
qc.cu1(pi/2,q[1], q[2])
qc.swap(q[0],q[2])
qc.cswap(q[0],q[1],q[3])
qc.draw(output='mpl')
job = execute(qc, backend)
job.result().get_unitary(qc, decimals=3)
|
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.algorithms.minimum_eigensolvers import NumPyMinimumEigensolver
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import GroverOptimizer, MinimumEigenOptimizer
from qiskit_optimization.translators import from_docplex_mp
from docplex.mp.model import Model
model = Model()
x0 = model.binary_var(name="x0")
x1 = model.binary_var(name="x1")
x2 = model.binary_var(name="x2")
model.minimize(-x0 + 2 * x1 - 3 * x2 - 2 * x0 * x2 - 1 * x1 * x2)
qp = from_docplex_mp(model)
print(qp.prettyprint())
grover_optimizer = GroverOptimizer(6, num_iterations=10, sampler=Sampler())
results = grover_optimizer.solve(qp)
print(results.prettyprint())
exact_solver = MinimumEigenOptimizer(NumPyMinimumEigensolver())
exact_result = exact_solver.solve(qp)
print(exact_result.prettyprint())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
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.
"""Durations of instructions, one of transpiler configurations."""
from __future__ import annotations
from typing import Optional, List, Tuple, Union, Iterable
import qiskit.circuit
from qiskit.circuit import Barrier, Delay
from qiskit.circuit import Instruction, Qubit, ParameterExpression
from qiskit.circuit.duration import duration_in_dt
from qiskit.providers import Backend
from qiskit.transpiler.exceptions import TranspilerError
from qiskit.utils.deprecation import deprecate_arg
from qiskit.utils.units import apply_prefix
def _is_deprecated_qubits_argument(qubits: Union[int, list[int], Qubit, list[Qubit]]) -> bool:
if isinstance(qubits, (int, Qubit)):
qubits = [qubits]
return isinstance(qubits[0], Qubit)
class InstructionDurations:
"""Helper class to provide durations of instructions for scheduling.
It stores durations (gate lengths) and dt to be used at the scheduling stage of transpiling.
It can be constructed from ``backend`` or ``instruction_durations``,
which is an argument of :func:`transpile`. The duration of an instruction depends on the
instruction (given by name), the qubits, and optionally the parameters of the instruction.
Note that these fields are used as keys in dictionaries that are used to retrieve the
instruction durations. Therefore, users must use the exact same parameter value to retrieve
an instruction duration as the value with which it was added.
"""
def __init__(
self, instruction_durations: "InstructionDurationsType" | None = None, dt: float = None
):
self.duration_by_name: dict[str, tuple[float, str]] = {}
self.duration_by_name_qubits: dict[tuple[str, tuple[int, ...]], tuple[float, str]] = {}
self.duration_by_name_qubits_params: dict[
tuple[str, tuple[int, ...], tuple[float, ...]], tuple[float, str]
] = {}
self.dt = dt
if instruction_durations:
self.update(instruction_durations)
def __str__(self):
"""Return a string representation of all stored durations."""
string = ""
for k, v in self.duration_by_name.items():
string += k
string += ": "
string += str(v[0]) + " " + v[1]
string += "\n"
for k, v in self.duration_by_name_qubits.items():
string += k[0] + str(k[1])
string += ": "
string += str(v[0]) + " " + v[1]
string += "\n"
return string
@classmethod
def from_backend(cls, backend: Backend):
"""Construct an :class:`InstructionDurations` object from the backend.
Args:
backend: backend from which durations (gate lengths) and dt are extracted.
Returns:
InstructionDurations: The InstructionDurations constructed from backend.
Raises:
TranspilerError: If dt and dtm is different in the backend.
"""
# All durations in seconds in gate_length
instruction_durations = []
backend_properties = backend.properties()
if hasattr(backend_properties, "_gates"):
for gate, insts in backend_properties._gates.items():
for qubits, props in insts.items():
if "gate_length" in props:
gate_length = props["gate_length"][0] # Throw away datetime at index 1
instruction_durations.append((gate, qubits, gate_length, "s"))
for q, props in backend.properties()._qubits.items():
if "readout_length" in props:
readout_length = props["readout_length"][0] # Throw away datetime at index 1
instruction_durations.append(("measure", [q], readout_length, "s"))
try:
dt = backend.configuration().dt
except AttributeError:
dt = None
return InstructionDurations(instruction_durations, dt=dt)
def update(self, inst_durations: "InstructionDurationsType" | None, dt: float = None):
"""Update self with inst_durations (inst_durations overwrite self).
Args:
inst_durations: Instruction durations to be merged into self (overwriting self).
dt: Sampling duration in seconds of the target backend.
Returns:
InstructionDurations: The updated InstructionDurations.
Raises:
TranspilerError: If the format of instruction_durations is invalid.
"""
if dt:
self.dt = dt
if inst_durations is None:
return self
if isinstance(inst_durations, InstructionDurations):
self.duration_by_name.update(inst_durations.duration_by_name)
self.duration_by_name_qubits.update(inst_durations.duration_by_name_qubits)
self.duration_by_name_qubits_params.update(
inst_durations.duration_by_name_qubits_params
)
else:
for i, items in enumerate(inst_durations):
if not isinstance(items[-1], str):
items = (*items, "dt") # set default unit
if len(items) == 4: # (inst_name, qubits, duration, unit)
inst_durations[i] = (*items[:3], None, items[3])
else:
inst_durations[i] = items
# assert (inst_name, qubits, duration, parameters, unit)
if len(inst_durations[i]) != 5:
raise TranspilerError(
"Each entry of inst_durations dictionary must be "
"(inst_name, qubits, duration) or "
"(inst_name, qubits, duration, unit) or"
"(inst_name, qubits, duration, parameters) or"
"(inst_name, qubits, duration, parameters, unit) "
f"received {inst_durations[i]}."
)
if inst_durations[i][2] is None:
raise TranspilerError(f"None duration for {inst_durations[i]}.")
for name, qubits, duration, parameters, unit in inst_durations:
if isinstance(qubits, int):
qubits = [qubits]
if isinstance(parameters, (int, float)):
parameters = [parameters]
if qubits is None:
self.duration_by_name[name] = duration, unit
elif parameters is None:
self.duration_by_name_qubits[(name, tuple(qubits))] = duration, unit
else:
key = (name, tuple(qubits), tuple(parameters))
self.duration_by_name_qubits_params[key] = duration, unit
return self
@deprecate_arg(
"qubits",
deprecation_description=(
"Using a Qubit or List[Qubit] for the ``qubits`` argument to InstructionDurations.get()"
),
additional_msg="Instead, use an integer for the qubit index.",
since="0.19.0",
predicate=_is_deprecated_qubits_argument,
)
def get(
self,
inst: str | qiskit.circuit.Instruction,
qubits: int | list[int] | Qubit | list[Qubit] | list[int | Qubit],
unit: str = "dt",
parameters: list[float] | None = None,
) -> float:
"""Get the duration of the instruction with the name, qubits, and parameters.
Some instructions may have a parameter dependent duration.
Args:
inst: An instruction or its name to be queried.
qubits: Qubits or its indices that the instruction acts on.
unit: The unit of duration to be returned. It must be 's' or 'dt'.
parameters: The value of the parameters of the desired instruction.
Returns:
float|int: The duration of the instruction on the qubits.
Raises:
TranspilerError: No duration is defined for the instruction.
"""
if isinstance(inst, Barrier):
return 0
elif isinstance(inst, Delay):
return self._convert_unit(inst.duration, inst.unit, unit)
if isinstance(inst, Instruction):
inst_name = inst.name
else:
inst_name = inst
if isinstance(qubits, (int, Qubit)):
qubits = [qubits]
if isinstance(qubits[0], Qubit):
qubits = [q.index for q in qubits]
try:
return self._get(inst_name, qubits, unit, parameters)
except TranspilerError as ex:
raise TranspilerError(
f"Duration of {inst_name} on qubits {qubits} is not found."
) from ex
def _get(
self,
name: str,
qubits: list[int],
to_unit: str,
parameters: Iterable[float] | None = None,
) -> float:
"""Get the duration of the instruction with the name, qubits, and parameters."""
if name == "barrier":
return 0
if parameters is not None:
key = (name, tuple(qubits), tuple(parameters))
else:
key = (name, tuple(qubits))
if key in self.duration_by_name_qubits_params:
duration, unit = self.duration_by_name_qubits_params[key]
elif key in self.duration_by_name_qubits:
duration, unit = self.duration_by_name_qubits[key]
elif name in self.duration_by_name:
duration, unit = self.duration_by_name[name]
else:
raise TranspilerError(f"No value is found for key={key}")
return self._convert_unit(duration, unit, to_unit)
def _convert_unit(self, duration: float, from_unit: str, to_unit: str) -> float:
if from_unit.endswith("s") and from_unit != "s":
duration = apply_prefix(duration, from_unit)
from_unit = "s"
# assert both from_unit and to_unit in {'s', 'dt'}
if from_unit == to_unit:
return duration
if self.dt is None:
raise TranspilerError(
f"dt is necessary to convert durations from '{from_unit}' to '{to_unit}'"
)
if from_unit == "s" and to_unit == "dt":
if isinstance(duration, ParameterExpression):
return duration / self.dt
return duration_in_dt(duration, self.dt)
elif from_unit == "dt" and to_unit == "s":
return duration * self.dt
else:
raise TranspilerError(f"Conversion from '{from_unit}' to '{to_unit}' is not supported")
def units_used(self) -> set[str]:
"""Get the set of all units used in this instruction durations.
Returns:
Set of units used in this instruction durations.
"""
units_used = set()
for _, unit in self.duration_by_name_qubits.values():
units_used.add(unit)
for _, unit in self.duration_by_name.values():
units_used.add(unit)
return units_used
InstructionDurationsType = Union[
List[Tuple[str, Optional[Iterable[int]], float, Optional[Iterable[float]], str]],
List[Tuple[str, Optional[Iterable[int]], float, Optional[Iterable[float]]]],
List[Tuple[str, Optional[Iterable[int]], float, str]],
List[Tuple[str, Optional[Iterable[int]], float]],
InstructionDurations,
]
"""List of tuples representing (instruction name, qubits indices, parameters, duration)."""
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.units import DistanceUnit
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver(
atom="H 0 0 0; H 0 0 0.735",
basis="sto3g",
charge=0,
spin=0,
unit=DistanceUnit.ANGSTROM,
)
es_problem = driver.run()
from qiskit_nature.second_q.mappers import JordanWignerMapper
mapper = JordanWignerMapper()
from qiskit.algorithms.eigensolvers import NumPyEigensolver
numpy_solver = NumPyEigensolver(filter_criterion=es_problem.get_default_filter_criterion())
from qiskit.algorithms.minimum_eigensolvers import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit_nature.second_q.algorithms import GroundStateEigensolver, QEOM
from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD
ansatz = UCCSD(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
initial_state=HartreeFock(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
mapper,
),
)
estimator = Estimator()
# This first part sets the ground state solver
# see more about this part in the ground state calculation tutorial
solver = VQE(estimator, ansatz, SLSQP())
solver.initial_point = [0.0] * ansatz.num_parameters
gse = GroundStateEigensolver(mapper, solver)
# The qEOM algorithm is simply instantiated with the chosen ground state solver and Estimator primitive
qeom_excited_states_solver = QEOM(gse, estimator, "sd")
from qiskit_nature.second_q.algorithms import ExcitedStatesEigensolver
numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, numpy_solver)
numpy_results = numpy_excited_states_solver.solve(es_problem)
qeom_results = qeom_excited_states_solver.solve(es_problem)
print(numpy_results)
print("\n\n")
print(qeom_results)
import numpy as np
def filter_criterion(eigenstate, eigenvalue, aux_values):
return np.isclose(aux_values["ParticleNumber"][0], 2.0)
new_numpy_solver = NumPyEigensolver(filter_criterion=filter_criterion)
new_numpy_excited_states_solver = ExcitedStatesEigensolver(mapper, new_numpy_solver)
new_numpy_results = new_numpy_excited_states_solver.solve(es_problem)
print(new_numpy_results)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qBraid/qBraid
|
qBraid
|
# Copyright (C) 2024 qBraid
#
# This file is part of the qBraid-SDK
#
# The qBraid-SDK is free software released under the GNU General Public License v3
# or later. You can redistribute and/or modify it under the terms of the GPL v3.
# See the LICENSE file in the project root or <https://www.gnu.org/licenses/gpl-3.0.html>.
#
# THERE IS NO WARRANTY for the qBraid-SDK, as per Section 15 of the GPL v3.
"""
Module defining QiskitBackend Class
"""
from typing import TYPE_CHECKING, Optional, Union
from qiskit_ibm_runtime import QiskitRuntimeService
from qbraid.programs import load_program
from qbraid.runtime.device import QuantumDevice
from qbraid.runtime.enums import DeviceStatus, DeviceType
from .job import QiskitJob
if TYPE_CHECKING:
import qiskit
import qiskit_ibm_runtime
import qbraid.runtime.qiskit
class QiskitBackend(QuantumDevice):
"""Wrapper class for IBM Qiskit ``Backend`` objects."""
def __init__(
self,
profile: "qbraid.runtime.TargetProfile",
service: "Optional[qiskit_ibm_runtime.QiskitRuntimeService]" = None,
):
"""Create a QiskitBackend."""
super().__init__(profile=profile)
self._service = service or QiskitRuntimeService()
self._backend = self._service.backend(self.id, instance=self.profile.get("instance"))
def __str__(self):
"""Official string representation of QuantumDevice object."""
return f"{self.__class__.__name__}('{self.id}')"
def status(self):
"""Return the status of this Device.
Returns:
str: The status of this Device
"""
if self.device_type == DeviceType.LOCAL_SIMULATOR:
return DeviceStatus.ONLINE
status = self._backend.status()
if status.operational:
if status.status_msg == "active":
return DeviceStatus.ONLINE
return DeviceStatus.UNAVAILABLE
return DeviceStatus.OFFLINE
def queue_depth(self) -> int:
"""Return the number of jobs in the queue for the ibm backend"""
if self.device_type == DeviceType.LOCAL_SIMULATOR:
return 0
return self._backend.status().pending_jobs
def transform(self, run_input: "qiskit.QuantumCircuit") -> "qiskit.QuantumCircuit":
"""Transpile a circuit for the device."""
program = load_program(run_input)
program.transform(self)
return program.program
def submit(
self,
run_input: "Union[qiskit.QuantumCircuit, list[qiskit.QuantumCircuit]]",
*args,
**kwargs,
) -> "qbraid.runtime.qiskit.QiskitJob":
"""Runs circuit(s) on qiskit backend via :meth:`~qiskit.execute`
Uses the :meth:`~qiskit.execute` method to create a :class:`~qiskit.providers.QuantumJob`
object, applies a :class:`~qbraid.runtime.qiskit.QiskitJob`, and return the result.
Args:
run_input: A circuit object to run on the IBM device.
Keyword Args:
shots (int): The number of times to run the task on the device. Default is 1024.
Returns:
qbraid.runtime.qiskit.QiskitJob: The job like object for the run.
"""
backend = self._backend
shots = kwargs.pop("shots", backend.options.get("shots"))
memory = kwargs.pop("memory", True) # Needed to get measurements
job = backend.run(run_input, *args, shots=shots, memory=memory, **kwargs)
return QiskitJob(job.job_id(), job=job, device=self)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.