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
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/mareksubocz/QRBM-qiskit
|
mareksubocz
|
from qiskit import IBMQ
# IBMQ.save_account(MY_API_TOKEN)
import qiskit
qiskit.__version__
import scipy
import numpy as np
import random
from sklearn import preprocessing
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.quantum_info.operators import Operator
from qiskit import(QuantumCircuit, execute, Aer)
from qiskit.visualization import plot_histogram
from qiskit.extensions import Initialize # Import the Inititialize function
from qiskit.aqua.circuits.gates import multi_control_toffoli_gate
from qiskit.aqua.circuits.gates import multi_control_multi_target_gate
import torch
from torch.autograd import Function
import torch.optim as optim
import torch.nn as nn
import torch.nn.functional as F
from torchvision import datasets, transforms
import timeit
import matplotlib.pyplot as plt
%matplotlib inline
plt.rcParams['image.cmap'] = 'gray'
import pandas as pd
from skimage import data, color
from skimage.transform import rescale, resize, downscale_local_mean
from skimage import img_as_bool
import cv2 as cv
image_height = 14
image_width = 14
len_x = image_height * image_width
len_y = 0
mnist_dataset = pd.read_csv('../data/mnist_train.csv')
X_train = mnist_dataset.values[:,1:]
img = np.resize(X_train[1], (28, 28))
def random_image(dataset):
return random.choice(dataset)
X_train = mnist_dataset.values[:,1:]
X_train2 = mnist_dataset.values[:,:]
# print(mnist_dataset.values[:,0])
X_train3 = mnist_dataset.values[np.where(mnist_dataset.values[:,0] < 2), 1:]
labels =mnist_dataset.values[np.where(mnist_dataset.values[:,0] < 2), 0]
# print(labels)
# print(X_train3)
image = random_image(X_train3[0])
print(len(X_train3[0]))
imgs = np.resize(X_train3[0], (len(X_train3[0]), 28, 28)) / 255
print(len(imgs))
plt.imshow(imgs[0])
plt.show()
# print([img for img in imgs)
images_resized = [resize(img, (14, 14), anti_aliasing=True) for img in imgs]
# print(images_resized)
plt.imshow(images_resized[8])
plt.show()
# print(image_resized)
# # img = np.array(data).reshape(image_height, -1)
# print(len(X_train[0]))
# # plt.imshow(np.resize(X_train[0], (28, 28)))
# plt.show()
plt.imshow(images_resized[7])
plt.show()
plt.imshow(images_resized[8])
plt.show()
plt.imshow(images_resized[9])
plt.show()
images_normalized = [cv.normalize(image_resized, image_resized, 0, 255, cv.NORM_MINMAX) for image_resized in images_resized]
print(len(images_normalized))
plt.imshow(images_normalized[0])
plt.show()
data = [np.where(image_resized > 0.1, 1, 0) for image_resized in images_resized]
print(len(data))
print(data[0])
plt.imshow(data[0])
plt.show()
# data = np.reshape(data, (image_height*image_height))
data = [x.flatten().tolist() for x in data]
# len_y = len(X_train3[0])
print(data[0])
def exctract_single_qubit_measurment(dict_of_counts, qubit_range):
# print(dict_of_counts)
# print(len(list(dict_of_counts.keys())[0]))
num_qubits = len(list(dict_of_counts.keys())[0])
# result = np.zeros(len(qubit_range))
result = np.zeros(num_qubits)
# print(result)
for el in dict_of_counts:
for i in range(num_qubits):
# print("i", i)
# print("el[i]", el[i])
if i in qubit_range and el[i] == '1':
result[i] += dict_of_counts[el]
# print(result)
# print(result[qubit_range])
return result[qubit_range]
# TUTAJ ZACZYNAM KOD
class QMLCircuit():
def __init__(self, visible, hidden, num_shots=1000):
self.visible = visible
self.hidden = hidden
self.ancilla = visible-1
self.qr = QuantumRegister((self.visible + self.hidden + self.ancilla), 'q')
self.cr = ClassicalRegister(self.hidden, 'c')
self.qc = QuantumCircuit(self.qr, self.cr)
self.num_shots = num_shots
# def run(self, thetas):
def circuit_function(self, x, weight_matrix):
self.qc.data = []
# inicjalizacja wartości qubitów wejściowych (x)
initial_state = [[np.sqrt(1-x[i]), np.sqrt(x[i])] for i in range(len(x))]
# inicjalizacja wartości qubitów wejściowych i bramka Hadamarda
for i in range(visible):
initialize_qubit = Initialize(initial_state[i])
self.qc.append(initialize_qubit, [i])
self.qc.h(i)
# ciąg bramek CNOT i bramek rotacji R (zależnych od parametrów)
for i in range(self.hidden):
for j in range(self.visible):
self.qc.ry(weight_matrix[j][i], j)
print([self.qr[k] for k in range(self.visible)])
print(self.qr[self.visible + i])
print([self.qr[i] for i in range(self.visible + self.hidden, self.visible + self.hidden + self.ancilla)])
multi_control_toffoli_gate.mct(self.qc, [self.qr[k] for k in range(self.visible)], self.qr[self.visible + i], [self.qr[i] for i in range(self.visible + self.hidden, self.visible + self.hidden + self.ancilla)], mode='basic')
# pomiar linii visible
self.qc.measure(list(range(visible, visible+hidden)), list(range(hidden)))
#eksperyment:
simulator = Aer.get_backend('qasm_simulator')
job = execute(self.qc, simulator, shots=self.num_shots)
result = job.result()
counts = result.get_counts(self.qc)
ph = exctract_single_qubit_measurment(counts, list(range(self.hidden))) / self.num_shots
# print("\nProbabilities are:",ph)
return ph
visible = 2
hidden = 1
QMLC = QMLCircuit(visible, hidden, 1000)
#definicja wejścia (x)oraz inicjalizacja macierzy wag
x = np.array([random.uniform(0, 1) for n in range(visible)])
weight_matrix = np.random.rand(visible, hidden) * np.pi
print(QMLC.circuit_function(x, weight_matrix))
QMLC.qc.draw()
class QFunction(Function):
""" Hybrid quantum - classical function definition """
@staticmethod
def forward(ctx, input, QMLC, epsilon):
""" Forward pass computation """
ctx.epsilon = epsilon
ctx.QMLC = QMLC
print(input)
ph = ctx.QMLC(input[0].tolist())
result = torch.tensor([ph])
ctx.save_for_backward(input, result)
return result
@staticmethod
def backward(ctx, grad_output):
# def update(ph, expected_ph, weight_matrix, lr):
input, ph = ctx.saved_tensors
input_list = np.array(input.tolist())
gradients = []
gradient_row = []
for j, el in enumerate(row):
weight_matrix[i][j] += epsilon
result_plus = circuit_function(qc, weight_matrix)
weight_matrix[i][j] -= 2*epsilon
result_minus = circuit_function(qc, weight_matrix)
weight_matrix[i][j] += epsilon
# result_zero = circuit_function(qc, weight_matrix)
# print("ph", result_zero)
# print("exp_ph", expected_ph)
# print("el final:", el)
# print(result_plus - result_minus)
result = (result_plus - result_minus)/(2*epsilon) * lr * (ph - expected_ph)
gradient_row.append(result)
gradient.append(gradient_row)
# print("gradient", gradient)
weight_matrix = weight_matrix - gradient
return weight_matrix
""" Backward pass computation """
input, ph = ctx.saved_tensors
input_list = np.array(input.tolist())
shift_right = input_list + np.ones(input_list.shape) * ctx.epsilon
shift_left = input_list - np.ones(input_list.shape) * ctx.epsilon
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 QuantumLayer(nn.Module):
""" Hybrid quantum - classical layer definition """
def __init__(self, backend, shots, epsilon):
super(QuantumLayer, self).__init__()
self.QMLC = QMLCircuit(1, 1, 1000)
self.epsilon = epsilon
def forward(self, input):
return QFunction.apply(input, self.QMLC, self.epsilon)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
self.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(256, 64)
self.fc2 = nn.Linear(64, 1)
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = self.dropout(x)
x = x.view(-1, 256)
x = F.relu(self.fc1(x))
x = self.fc2(x)
return torch.cat((x, 1 - x), -1)
# Concentrating on the first 100 samples
n_samples = 100
X_train = datasets.MNIST(root='./data', train=True, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
# Leaving only labels 0 and 1
idx = np.append(np.where(X_train.targets == 0)[0][:n_samples],
np.where(X_train.targets == 1)[0][:n_samples])
X_train.data = X_train.data[idx]
X_train.targets = X_train.targets[idx]
train_loader = torch.utils.data.DataLoader(X_train, batch_size=1, shuffle=True)
n_samples_show = 6
data_iter = iter(train_loader)
fig, axes = plt.subplots(nrows=1, ncols=n_samples_show, figsize=(10, 3))
while n_samples_show > 0:
images, targets = data_iter.__next__()
axes[n_samples_show - 1].imshow(images[0].numpy().squeeze(), 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
n_samples = 50
X_test = datasets.MNIST(root='./data', train=False, download=True,
transform=transforms.Compose([transforms.ToTensor()]))
idx = np.append(np.where(X_test.targets == 0)[0][:n_samples],
np.where(X_test.targets == 1)[0][:n_samples])
X_test.data = X_test.data[idx]
X_test.targets = X_test.targets[idx]
test_loader = torch.utils.data.DataLoader(X_test, batch_size=1, shuffle=True)
model = Net()
optimizer = optim.Adam(model.parameters(), lr=0.001)
loss_func = nn.NLLLoss()
epochs = 20
loss_list = []
model.train()
for epoch in range(epochs):
total_loss = []
print(i for i in enumerate(train_loader))
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()
total_loss.append(loss.item())
loss_list.append(sum(total_loss)/len(total_loss))
print('Training [{:.0f}%]\tLoss: {:.4f}'.format(
100. * (epoch + 1) / epochs, loss_list[-1]))
for epoch in range(epochs):
total_loss = []
print(i for i in enumerate(train_loader))
for batch_idx, something in enumerate(train_loader):
print(batch_idx)
print(something)
print(something)
class QuantumCircuit:
"""
This class provides a simple interface for interaction
with the quantum circuit
"""
def __init__(self, visible, hidden, backend, shots):
# --- Circuit definition ---
self.qc = qiskit.QuantumCircuit(visible + hidden)
all_qubits = [i for i in range(visible+hidden)]
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):
job = qiskit.execute(self._circuit,
self.backend,
shots = self.shots,
parameter_binds = [{self.theta: theta} for theta in thetas])
result = job.result().get_counts(self._circuit)
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])
simulator = qiskit.Aer.get_backend('qasm_simulator')
circuit = QuantumCircuit(1, 1, simulator, 100)
print('Expected value for rotation pi {}'.format(circuit.run([np.pi])[0]))
circuit._circuit.draw()
epsilon = 0.01
def update(ph, expected_ph, weight_matrix, lr):
gradient = []
for i, row in enumerate(weight_matrix):
gradient_row = []
for j, el in enumerate(row):
weight_matrix[i][j] += epsilon
result_plus = circuit_function(qc, weight_matrix)
weight_matrix[i][j] -= 2*epsilon
result_minus = circuit_function(qc, weight_matrix)
weight_matrix[i][j] += epsilon
# result_zero = circuit_function(qc, weight_matrix)
# print("ph", result_zero)
# print("exp_ph", expected_ph)
# print("el final:", el)
# print(result_plus - result_minus)
result = (result_plus - result_minus)/(2*epsilon) * lr * (ph - expected_ph)
gradient_row.append(result)
gradient.append(gradient_row)
# print("gradient", gradient)
weight_matrix = weight_matrix - gradient
return weight_matrix
# 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): #MOJE circuit_funcion()
# job = qiskit.execute(self._circuit,
# self.backend,
# shots = self.shots,
# parameter_binds = [{self.theta: theta} for theta in thetas])
# result = job.result().get_counts(self._circuit)
# 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 QuantumFunction(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
ph = 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 QuantumLayer(nn.Module):
""" Hybrid quantum - classical layer definition """
def __init__(self, backend, shots, shift):
super(QuantumLayer, self).__init__()
self.quantum_circuit = QuantumCircuit(1, backend, shots)
self.shift = shift
def forward(self, input):
return QuantumFunction.apply(input, self.quantum_circuit, self.shift)
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1 = nn.Conv2d(1, 32, kernel_size=5)
self.conv2 = nn.Conv2d(32, 64, kernel_size=5)
self.dropout = nn.Dropout2d()
self.fc1 = nn.Linear(256, 64)
self.fc2 = nn.Linear(64, 1)
self.quantum_layer = Quantum_Layer()
def forward(self, x):
x = F.relu(self.conv1(x))
x = F.relu(self.conv2(x))
x = F.max_pool2d(x, 2)
x = self.dropout(x)
x = x.view(-1, 256)
x = F.relu(self.fc1(x))
x = self.fc2(x)
x = self.quantum_layer(x)
return torch.cat((x, 1 - x), -1)
net = Net()
print(net)
def exctract_single_qubit_measurment(dict_of_counts, qubit_range):
# print(dict_of_counts)
# print(len(list(dict_of_counts.keys())[0]))
num_qubits = len(list(dict_of_counts.keys())[0])
# result = np.zeros(len(qubit_range))
result = np.zeros(num_qubits)
# print(result)
for el in dict_of_counts:
for i in range(num_qubits):
# print("i", i)
# print("el[i]", el[i])
if i in qubit_range and el[i] == '1':
result[i] += dict_of_counts[el]
# print(result)
# print(result[qubit_range])
return result[qubit_range]
def create_dataset(dataset_size):
dataset = []
for i in range(dataset_size):
x = np.array([random.choice([0,1]), random.choice([0,1])])
y = 1
if np.array_equal(x, np.array([0,0])) or np.array_equal(x, np.array([1,1])):
y = 0
dataset.append({"x": x, "y": y})
return dataset
dataset = create_dataset(4)
print(dataset)
class QuantumCircuit():
def __init__(self, visible=1, hidden=1, num_shots=1000):
self._visible = visible
self._hidden = hidden
print(self._visible + self._hidden + ancilla)
qr = QuantumRegister((self._visible + self._hidden), 'q')
cr = ClassicalRegister(self._hidden, 'c')
self._qc = QuantumCircuit(qr, cr)
self._num_shots = num_shots
# def run(self, thetas):
def circuit_function(qc, x, weight_matrix):
qc.data = []
# inicjalizacja wartości qubitów wejściowych (x)
initial_state = [[np.sqrt(1-x[i]), np.sqrt(x[i])] for i in range(len(x))]
# inicjalizacja wartości qubitów wejściowych i bramka Hadamarda
for i in range(visible):
initialize_qubit = Initialize(initial_state[i])
qc.append(initialize_qubit, [i])
qc.h(i)
# ciąg bramek CNOT i bramek rotacji R (zależnych od parametrów)
for i in range(hidden):
for j in range(visible):
qc.ry(weight_matrix[j][i], j)
multi_control_toffoli_gate.mct(qc, [qr[k] for k in range(visible)], qr[visible + i], [qr[i] for i in range(visible + hidden, visible + hidden + ancilla)], mode='basic')
# pomiar linii visible
qc.measure(list(range(visible, visible+hidden)), list(range(hidden)))
#eksperyment:
simulator = Aer.get_backend('qasm_simulator')
job = execute(qc, simulator, shots=num_shots)
result = job.result()
counts = result.get_counts(qc)
ph = exctract_single_qubit_measurment(counts, list(range(hidden))) / num_shots
# print("\nProbabilities are:",ph)
return ph[0]
epsilon = 0.01
def update(ph, expected_ph, weight_matrix, lr):
gradient = []
for i, row in enumerate(weight_matrix):
gradient_row = []
for j, el in enumerate(row):
weight_matrix[i][j] += epsilon
result_plus = circuit_function(qc, weight_matrix)
weight_matrix[i][j] -= 2*epsilon
result_minus = circuit_function(qc, weight_matrix)
weight_matrix[i][j] += epsilon
# result_zero = circuit_function(qc, weight_matrix)
# print("ph", result_zero)
# print("exp_ph", expected_ph)
# print("el final:", el)
# print(result_plus - result_minus)
result = (result_plus - result_minus)/(2*epsilon) * lr * (ph - expected_ph)
gradient_row.append(result)
gradient.append(gradient_row)
# print("gradient", gradient)
weight_matrix = weight_matrix - gradient
return weight_matrix
visible = 2
hidden = 1
ancilla = visible-1
num_shots = 1000
qc = QuantumCircuit(visible, hidden, 1000)
# template do uczenia
import matplotlib.pyplot as plt
%matplotlib inline
#definicja rozmiaru sieci
visible = 2
hidden = 1
ancilla = visible-1
#definicja wejścia (x)oraz inicjalizacja macierzy wag
# x = np.array([random.uniform(0, 1) for n in range(visible)])
dataset = create_dataset(10)
print(dataset[0]["x"][0])
print(dataset[0]["x"][1])
print([n for n in range(visible)])
weight_matrix = np.random.rand(visible, hidden) * np.pi
#definicja parametrów uczenia
num_shots = 1000
num_epochs = 100
qr = QuantumRegister(visible + hidden + ancilla, 'q')
cr = ClassicalRegister(hidden, 'c')
qc = QuantumCircuit(qr, cr)
cost_function_data = []
lr = 0.05
for epoch in range(num_epochs):
print("epoch: ", epoch)
for i, element in enumerate(dataset):
# print(element)
x = np.array([dataset[i]["x"][n] for n in range(visible)])
exp_ph = dataset[i]["y"]
ph = circuit_function(qc, weight_matrix)
weight_matrix = update(ph, exp_ph, weight_matrix, lr)
# print("exp_ph", exp_ph, "ph", ph, "weight_matrix", weight_matrix, "cost_function", 0.5 * (ph - exp_ph)**2)
cost_function_data.append(0.5 * (ph - exp_ph)**2)
qc.draw()
plt.xlabel('number of epochs')
plt.ylabel('cost')
plt.plot(cost_function_data)
for i in range(len(dataset)):
x = np.array([dataset[i]["x"][n] for n in range(visible)])
exp_ph = dataset[i]["y"]
ph = circuit_function(qc, weight_matrix)
print(ph)
print(exp_ph, "\n")
qc.draw()
ph = circuit_function(qc, weight_matrix)
print(ph)
|
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import random
from qiskit.quantum_info import Statevector
secret = random.randint(0,7) # the owner is randomly picked
secret_string = format(secret, '03b') # format the owner in 3-bit string
oracle = Statevector.from_label(secret_string) # let the oracle know the owner
from qiskit.algorithms import AmplificationProblem
problem = AmplificationProblem(oracle, is_good_state=secret_string)
from qiskit.algorithms import Grover
grover_circuits = []
for iteration in range(1,3):
grover = Grover(iterations=iteration)
circuit = grover.construct_circuit(problem)
circuit.measure_all()
grover_circuits.append(circuit)
# Grover's circuit with 1 iteration
grover_circuits[0].draw()
# Grover's circuit with 2 iterations
grover_circuits[1].draw()
from qiskit_ibm_runtime import QiskitRuntimeService
service = QiskitRuntimeService()
backend = "ibmq_qasm_simulator" # use the simulator
from qiskit_ibm_runtime import Sampler, Session
with Session(service=service, backend=backend):
sampler = Sampler()
job = sampler.run(circuits=grover_circuits, shots=1000)
result = job.result()
print(result)
from qiskit.tools.visualization import plot_histogram
# Extract bit string with highest probability from results as the answer
result_dict = result.quasi_dists[1].binary_probabilities()
answer = max(result_dict, key=result_dict.get)
print(f"As you can see, the quantum computer returned '{answer}' as the answer with highest probability.\n"
"And the results with 2 iterations have higher probability than the results with 1 iteration."
)
# Plot the results
plot_histogram(result.quasi_dists, legend=['1 iteration', '2 iterations'])
# Print the results and the correct answer.
print(f"Quantum answer: {answer}")
print(f"Correct answer: {secret_string}")
print('Success!' if answer == secret_string else 'Failure!')
import qiskit_ibm_runtime
qiskit_ibm_runtime.version.get_version_info()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
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=unused-import
"""Test Qiskit's inverse gate operation."""
import os
import tempfile
import unittest
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.test import QiskitTestCase
from qiskit.extensions.standard import TGate, SGate
class TestCircuitQasm(QiskitTestCase):
"""QuantumCircuit Qasm tests."""
def test_circuit_qasm(self):
"""Test circuit qasm() method.
"""
qr = QuantumRegister(1, 'qr')
cr = ClassicalRegister(1, 'cr')
circuit = QuantumCircuit(qr, cr)
circuit.s(qr)
circuit.s(qr)
circuit.append(SGate().inverse(), qr[:])
circuit.s(qr)
circuit.append(TGate().inverse(), qr[:])
circuit.t(qr)
circuit.measure(qr, cr)
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
qreg qr[1];
creg cr[1];
s qr[0];
s qr[0];
sdg qr[0];
s qr[0];
tdg qr[0];
t qr[0];
measure qr[0] -> cr[0];\n"""
self.assertEqual(circuit.qasm(), expected_qasm)
if __name__ == '__main__':
unittest.main()
|
https://github.com/mnp-club/Quantum_Computing_Workshop_2020
|
mnp-club
|
from qiskit import *
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
qc1 = QuantumCircuit(3,3)
# All initialized to '0' by default.
qc1.x(0) #This is for the purpose of setting the control qubit to '1'
qc1.x(2) #As a result, the second target qubit becomes '1' while the first remains '0'. Now, lets's try swapping them.
#Fredkin gate:
def fredkin(qc):
qc.toffoli(0,1,2)
qc.toffoli(0,2,1)
qc.toffoli(0,1,2)
fredkin(qc1)
qc1.draw('mpl')
#First let's measure all three qubits.
#We're using the classical bits to store the result obtained on measuring each corresponding qubit.
qc1.measure(0,0)
qc1.measure(1,1)
qc1.measure(2,2)
#Now we use the same function we defined yesterday to run a quantum circuit
def run_circuit(qc2):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc2, backend, shots = 2000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts1=run_circuit(qc1)
print(counts1)
plot_histogram(counts1)
qc2 = QuantumCircuit(3,3)
# All initialized to '0' by default.
qc2.x(2) #The second target qubit is initialised to '1'
fredkin(qc2)
qc2.measure(0,0)
qc2.measure(1,1)
qc2.measure(2,2)
qc2.draw('mpl')
counts2=run_circuit(qc2)
print(counts2)
plot_histogram(counts2)
qc = QuantumCircuit(1)
#This is how we apply the rotation operators in Qiskit, mentioning the angle of rotation and qubit no. as parameters
qc.rx(np.pi/2,0)
qc.draw('mpl')
def final_vector(qc):
backend = Aer.get_backend('statevector_simulator')
job = execute(qc, backend)
result = job.result()
outputstate = result.get_statevector(qc, decimals=3)
return outputstate
print(final_vector(qc))
# This prints the vector obtained on applying the above gate to the qubit state '0'
#Verifying for the X gate
qc3=QuantumCircuit(1)
qc3.x(0)
qc3.ry(np.pi/8,0)
#Enter an angle of your choice
qc3.x(0)
print(final_vector(qc3))
qc3=QuantumCircuit(1)
qc3.ry(-np.pi/8,0)
print(final_vector(qc3))
#Run this code for different values of theta and see if the two vectors printed are equal in each case
#Verifying for the H gate
qc3=QuantumCircuit(1)
qc3.h(0)
qc3.ry(np.pi/8,0)
#Enter an angle of your choice
qc3.h(0)
print(final_vector(qc3))
qc3=QuantumCircuit(1)
qc3.ry(-np.pi/8,0)
print(final_vector(qc3))
#Run this code for different values of theta and see if the two vectors printed are equal in each case
gamma = np.pi/2
alpha = np.pi/2
beta= 0
delta = np.pi
def A(qc,b,g,q):
qc.ry(g/2,q)
qc.rz(b,q)
def B(qc,g,d,b,q):
qc.rz((-d-b)/2,q)
qc.ry(-g/2,q)
def C(qc,d,b,q):
qc.rz((d-b)/2,q)
#Initialising the unitary matrix for the global phase
#exp(i pi/2) = i
U = np.array([[1j, 0],[0, 1j]])
#Let us now apply the transformation
qc4 = QuantumCircuit(1)
C(qc4,delta,beta,0)
qc4.x(0)
B(qc4,gamma,delta,beta,0)
qc4.x(0)
A(qc4,beta,gamma,0)
qc4.unitary(U, [0], 0)
print(final_vector(qc4))
#Reinitialise the Quantum Circuit
qc4 = QuantumCircuit(1)
qc4.h(0)
print(final_vector(qc4))
#We get that exp(i alpha) AXBXC = H, thus the decomposition is correct
#Note: We will be accepting solutions which differ in global phase
qc5=QuantumCircuit(2,2)
qc5.x(0)
C(qc5,delta,beta,1)
qc5.cx(0,1)
B(qc5,gamma,delta,beta,1)
qc5.cx(0,1)
A(qc5,beta,gamma,1)
qc5.u1(alpha,0)
qc5.measure(0,0)
qc5.measure(1,1)
qc5.draw('mpl')
#Note: You don't need to draw the circuit, we're just displaying it for clarity
counts5=run_circuit(qc5)
print(counts5)
plot_histogram(counts5)
#We have succesfully implemented the controlled Hadamard gate
qc_u3=QuantumCircuit(1)
qc_u3.u3(np.pi/6,-np.pi/2,np.pi/2,0)
print(final_vector(qc_u3))
qc_rx=QuantumCircuit(1)
qc_rx.rx(np.pi/6,0)
print(final_vector(qc_rx))
#Getting the same results will verify our observation stated above
#Let's first build controlled V and controlled V dagger gates
def V(qc,q0,qt):
C(qc,np.pi/2,3*np.pi/2,qt)
qc.cx(q0,qt)
B(qc,np.pi/2,np.pi/2,3*np.pi/2,qt)
qc.cx(q0,qt)
A(qc,3*np.pi/2,np.pi/2,qt)
qc.u1(5*np.pi/4,q0)
def Vdag(qc,q0,qt):
C(qc,3*np.pi/2,np.pi/2,qt)
qc.cx(q0,qt)
B(qc,np.pi/2,3*np.pi/2,np.pi/2,qt)
qc.cx(q0,qt)
A(qc,np.pi/2,np.pi/2,qt)
qc.u1(3*np.pi/4,q0)
#Now we can build the Toffoli gate
def toffoli(qc,q0,q1,q2):
V(qc,q1,q2)
qc.cx(q0,q1)
Vdag(qc,q1,q2)
qc.cx(q0,q1)
V(qc,q0,q2)
qch=QuantumCircuit(8,5)
#The 3 qubits from fifth to seventh will be used as work qubits
#To check the final vector, let's just set all qubits to |1>
for i in range(4):
qch.x(i)
toffoli(qch,0,1,4)
toffoli(qch,2,4,5)
toffoli(qch,3,5,6)
#The seventh qubit, ie, q6 will be used as the control qubit in the controlled Hadamard
#Let's just copy paste the code of the controlled Hadamard gate
gamma = np.pi/2
alpha = np.pi/2
beta= 0
delta = np.pi
C(qch,delta,beta,7)
qch.cx(6,7)
B(qch,gamma,delta,beta,7)
qch.cx(6,7)
A(qch,beta,gamma,7)
qch.u1(alpha,6)
#Let's undo the Toffolis
toffoli(qch,0,1,4)
toffoli(qch,2,4,5)
toffoli(qch,3,5,6)
qch.measure(0,0)
qch.measure(1,1)
qch.measure(2,2)
qch.measure(3,3)
qch.measure(7,4)
qch.draw('mpl')
countsh=run_circuit(qch)
print(countsh)
plot_histogram(countsh)
#Hence we have successfully applied the C^4(H) gate
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeBoeblingen
backend = FakeBoeblingen()
ghz = QuantumCircuit(5)
ghz.h(0)
ghz.cx(0,range(1,5))
circ = transpile(ghz, backend, scheduling_method="asap")
circ.draw(output='mpl')
|
https://github.com/martynscn/Masters-Thesis-on-Quantum-Cryptography
|
martynscn
|
# This code has been adapted and modified from IBM Qiskit 2021 and also from https://github.com/ttlion/ShorAlgQiskit.
# It uses the implementation as contained in the work of Stephane Beauregard (https://arxiv.org/abs/quant-ph/0205095)
# Many thanks to IBM Qiskit team, Tiago Miguel (ttlion), Qubit by Qubit, Peter Shor and Stephane Beauregard.
from typing import Optional, Union, Tuple, List
import math
import array
import fractions
import logging
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister, execute, IBMQ, transpile,BasicAer, Aer, assemble
from qiskit.circuit import Gate, Instruction, ParameterVector
from qiskit.circuit.library import QFT
from qiskit.providers import BaseBackend, Backend
from qiskit.quantum_info import partial_trace
from qiskit.utils import summarize_circuits
from qiskit.utils.arithmetic import is_power
from qiskit.utils.validation import validate_min
from qiskit.utils.quantum_instance import QuantumInstance
import qiskit.visualization
from qiskit.providers.aer import QasmSimulator
from datetime import datetime
import csv
# provider = IBMQ.enable_account("PUT TOKEN HERE")
backend = QasmSimulator()
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all" #"last_expr" or "all"
def get_angles(a: int, n) -> np.ndarray:
# """Calculates the array of angles to be used in the addition in Fourier Space."""
s = bin(int(a))[2:].zfill(n + 1)
angles = np.zeros([n + 1])
for i in range(0, n + 1):
for j in range(i, n + 1):
if s[j] == '1':
angles[n - i] += math.pow(2, -(j - i))
angles[n - i] *= np.pi
return angles[::-1]
# This returns the angles in the opposite order
def my_create_QFT(qft_num_qubits,approximation_degree: int = 0,do_swaps: bool = False,insert_barriers: bool = True, name: str = 'qft'):
# up_reg = QuantumRegister(size = qft_num_qubits, name="aux")
circuit_qft = QuantumCircuit(qft_num_qubits)
i=qft_num_qubits-1
while i>=0:
# circuit_qft.h(up_reg[i])
circuit_qft.h(i)
j=i-1
while j>=0:
if (np.pi)/(pow(2,(i-j))) > approximation_degree:
# circuit_qft.cu1( (np.pi)/(pow(2,(i-j))) , up_reg[i] , up_reg[j] )
circuit_qft.cu1( (np.pi)/(pow(2,(i-j))) , i , j )
j=j-1
if insert_barriers:
circuit_qft.barrier()
i=i-1
""" If specified, apply the Swaps at the end """
if do_swaps:
i=0
while i < ((qft_num_qubits-1)/2):
# circuit_qft.swap(up_reg[i], up_reg[qft_num_qubits-1-i])
circuit_qft.swap(i, qft_num_qubits-1-i)
i=i+1
circuit_qft.name = "QFT"
return circuit_qft
def my_create_inverse_QFT(qft_num_qubits,approximation_degree: int = 0,do_swaps: bool = False,insert_barriers: bool = True, name: str = 'iqft'):
my_create_QFT_circuit = my_create_QFT(qft_num_qubits,approximation_degree,do_swaps,insert_barriers, name)
my_create_inverse_QFT_circuit = my_create_QFT_circuit.inverse()
my_create_inverse_QFT_circuit.name = "QFT†"
return my_create_inverse_QFT_circuit
def phi_add_gate(size: int, angles: Union[np.ndarray, ParameterVector]) -> Gate:
# """Gate that performs addition by a in Fourier Space."""
circuit = QuantumCircuit(size, name="phi_add")
for i, angle in enumerate(angles):
circuit.p(angle, i)
return circuit.to_gate()
def double_controlled_phi_add_mod_N(num_qubits: int, angles: Union[np.ndarray, ParameterVector],reg_size, a, N, n) -> QuantumCircuit:
# """Creates a circuit which implements double-controlled modular addition by a."""
circuit = QuantumCircuit(num_qubits, name="ccphi_add_mod_N")
ctl_up = 0
ctl_down = 1
ctl_aux = 2
# get qubits from aux register, omitting the control qubit
qubits = range(3, num_qubits)
# store the gates representing addition/subtraction by a in Fourier Space
phi_add_a = phi_add_gate(len(qubits), angles)
iphi_add_a = phi_add_a.inverse()
phi_add_N = phi_add_gate(reg_size - 1, get_angles(N, n))
iphi_add_N = phi_add_N.inverse()
circuit.append(phi_add_a.control(2), [ctl_up, ctl_down, *qubits])
circuit.append(iphi_add_N, qubits)
qft = QFT(n + 1).to_instruction()
# qft = my_create_QFT(n + 1).to_instruction()
iqft = QFT(n + 1).inverse().to_instruction()
# iqft = my_create_inverse_QFT(n + 1).to_instruction()
circuit.append(iqft, qubits)
circuit.cx(qubits[0], ctl_aux)
circuit.append(qft, qubits)
circuit.append(phi_add_N, qubits)
circuit.append(iphi_add_a.control(2), [ctl_up, ctl_down, *qubits])
circuit.append(iqft, qubits)
circuit.x(qubits[0])
circuit.cx(qubits[0], ctl_aux)
circuit.x(qubits[0])
circuit.append(qft, qubits)
circuit.append(phi_add_a.control(2), [ctl_up, ctl_down, *qubits])
return circuit
# """Circuit that implements single controlled modular multiplication by a"""
def controlled_multiple_mod_N(num_qubits: int, N: int, a: int, n, aux_reg_size):
# """Implements modular multiplication by a as an instruction."""
circuit = QuantumCircuit(
num_qubits,
# name="multiply_by_{}_mod_{}".format(a % N, N),
name=r"${0}^{{{1}^{{{2}}}}} mod{3}$".format(2,2,int(math.log(math.log(a,2),2)), N)
)
# label = r"${0}^{{{1}^{{{2}}}}} mod{3}$".format("†","y")
down = circuit.qubits[1: n + 1]
aux = circuit.qubits[n + 1:]
qubits = [aux[i] for i in reversed(range(n + 1))]
ctl_up = 0
ctl_aux = aux[-1]
angle_params = ParameterVector("angles", length=len(aux) - 1)
double_controlled_phi_add = double_controlled_phi_add_mod_N(
len(aux) + 2, angle_params, aux_reg_size, a, N, n
)
idouble_controlled_phi_add = double_controlled_phi_add.inverse()
qft_circuit = QFT(n + 1).to_instruction()
# qft_circuit = my_create_QFT(n + 1).to_instruction()
iqft_circuit = QFT(n + 1).inverse().to_instruction()
# iqft_circuit = my_create_inverse_QFT(n + 1).to_instruction()
circuit.append(qft_circuit, qubits)
# perform controlled addition by a on the aux register in Fourier space
for i, ctl_down in enumerate(down):
a_exp = (2 ** i) * a % N
angles = get_angles(a_exp, n)
bound = double_controlled_phi_add.assign_parameters({angle_params: angles})
circuit.append(bound, [ctl_up, ctl_down, ctl_aux, *qubits])
circuit.append(iqft_circuit, qubits)
# perform controlled subtraction by a in Fourier space on both the aux and down register
for j in range(n):
circuit.cswap(ctl_up, down[j], aux[j])
circuit.append(qft_circuit, qubits)
a_inv = modinv(a, N)
for i in reversed(range(len(down))):
a_exp = (2 ** i) * a_inv % N
angles = get_angles(a_exp, n)
bound = idouble_controlled_phi_add.assign_parameters({angle_params: angles})
circuit.append(bound, [ctl_up, down[i], ctl_aux, *qubits])
circuit.append(iqft_circuit, qubits)
return circuit
def modinv(a: int, m: int) -> int:
# """Returns the modular multiplicative inverse of a with respect to the modulus m."""
def egcd(a: int, b: int) -> Tuple[int, int, int]:
if a == 0:
return b, 0, 1
else:
g, y, x = egcd(b % a, a)
return g, x - (b // a) * y, y
g, x, _ = egcd(a, m)
if g != 1:
raise ValueError("The greatest common divisor of {} and {} is {}, so the "
"modular inverse does not exist.".format(a, m, g))
return x % m
def get_factors(N: int, a: int, measurement: str) -> Optional[List[int]]:
# """Apply the continued fractions to find r and the gcd to find the desired factors."""
x_final = int(measurement, 2)
#print('In decimal, x_final value for this result is: {}.'.format(x_final))
if x_final <= 0:
fail_reason = 'x_final value is <= 0, there are no continued fractions.'
else:
fail_reason = None
#print('Running continued fractions for this case.')
# Calculate T and x/T
T_upper = len(measurement)
T = pow(2, T_upper)
x_over_T = x_final / T ## this is our theta
# Cycle in which each iteration corresponds to putting one more term in the
# calculation of the Continued Fraction (CF) of x/T
# Initialize the first values according to CF rule
i = 0
b = array.array('i')
t = array.array('f')
b.append(math.floor(x_over_T))
t.append(x_over_T - b[i])
exponential = 0.0
while i < N and fail_reason is None:
# From the 2nd iteration onwards, calculate the new terms of the CF based on the previous terms as the rule suggests
if i > 0:
try:
b_temp = math.floor(1 / t[i - 1])
except ZeroDivisionError as err:
b_temp = 0
b.append(b_temp)
try:
t_temp = (1 / t[i - 1]) - b[i]
except ZeroDivisionError as err:
t_temp = 0
t.append(t_temp) # type: ignore
# Calculate the denominator of the CF using the known terms
denominator = calculate_continued_fraction(b)
# Increment i for next iteration
i += 1
if denominator % 2 == 1:
#print('Odd denominator, will try next iteration of continued fractions.')
continue
# Denominator is even, try to get factors of N. Get the exponential a^(r/2)
if denominator < 1000:
try:
exponential = pow(a, denominator / 2)
except OverflowError as err:
exponential = 999999999
# Check if the value is too big or not
if exponential > 1000000:
if exponential == 999999999:
fail_reason = 'OverflowError'
else:
fail_reason = 'denominator of continued fraction is too big (> 10^9).'
else:
# The value is not too big, get the right values and do the proper gcd()
putting_plus = int(exponential + 1)
putting_minus = int(exponential - 1)
one_factor = math.gcd(putting_plus, N)
other_factor = math.gcd(putting_minus, N)
# Check if the factors found are trivial factors or are the desired factors
if any(factor in {1, N} for factor in (one_factor, other_factor)):
#print('Found just trivial factors, not good enough.')
# Check if the number has already been found, (use i - 1 because i was already incremented)
if t[i - 1] == 0:
fail_reason = 'the continued fractions found exactly x_final/(2^(2n)).'
else:
return sorted((one_factor, other_factor))
# Search for factors failed, write the reason for failure to the debug logs
#print('Cannot find factors from measurement {0} because {1}'.format(measurement, fail_reason or 'it took too many attempts.'))
return None
def calculate_continued_fraction(b: array.array) -> int:
# """Calculate the continued fraction of x/T from the current terms of expansion b."""
x_over_T = 0
for i in reversed(range(len(b) - 1)):
x_over_T = 1 / (b[i + 1] + x_over_T)
x_over_T += b[0]
frac = fractions.Fraction(x_over_T).limit_denominator()
#print('Approximation number %s of continued fractions:'.format(len(b)))
#print("Numerator:{0} \t\t Denominator: {1}.".format(frac.numerator, frac.denominator))
return frac.denominator
def process_results(sim_result, circuit, shots, N, a, n):
counts_result = sim_result.get_counts(circuit)
total_counts = len(counts_result)
counts_result_sorted = sorted(counts_result.items(), key=lambda x: x[1], reverse=True)
# """ Print info to user from the simulation results """
# print('Printing the various results followed by how many times they happened (out of the {} cases):\n'.format(shots))
counts_result_keys = list(counts_result.keys())
counts_result_values = list(counts_result.values())
#i=0
#while i < len(counts_result):
#print('Result \"{0}\" happened {1} times out of {2}\n'.format(list(sim_result.get_counts().keys())[i],list(sim_result.get_counts().values())[i],shots))
#print('Result \"{0}\" happened {1} times out of {2}\n'.format(counts_result_keys[i],counts_result_values[i],shots))
#i=i+1
prob_success=0
prob_failure=0
result_successful_counts = 0
result_failure_counts = 0
# len(counts_result_sorted)
# For each simulation result, print proper info to user and try to calculate the factors of N
#for measurement in counts_result_keys:
for measurement, frequency in counts_result_sorted:
# Get the x_final value from the final state qubits
x_value = int(measurement, 2)
#prob_this_result = 100 * ( int(counts_result[measurement] ) ) / (shots)
prob_this_result = 100 * frequency/shots
# print("------> Analyzing result {0}. This result happened in {1:.4f} % of all cases\nIn decimal, x_final value for this result is: {2}".format(measurement,prob_this_result,x_value))
factors = get_factors(N, a, measurement)
if factors:
prob_success = prob_success + prob_this_result
# print('Found factors {0} from measurement {1} which is {2} in decimal.\n'.format(factors, measurement, x_value))
result_successful_counts = result_successful_counts + 1
if factors not in result_factors:
result_factors.append(factors)
elif not factors:
prob_failure = prob_failure + prob_this_result
result_failure_counts = result_failure_counts + 1
return [result_factors, prob_success, prob_failure, total_counts, result_successful_counts,result_failure_counts]
def my_shor(a,N,shots):
start_time_number = datetime.now()
start_time = start_time_number.strftime("%H:%M:%S")
summary_result = dict()
validate_min('N', N, 3)
validate_min('a', a, 2)
if N < 1 or N % 2 == 0:
raise ValueError('The input needs to be an odd integer greater than 1.')
if a >= N or math.gcd(a, N) != 1:
raise ValueError('The integer a needs to satisfy a < N and gcd(a, N) = 1.')
n = math.ceil(math.log(N,2))
global result_factors
result_factors = []
tf, b, p = is_power(N, return_decomposition=True)
if tf:
print('The input integer is a power: {0}={1}^{2}.'.format(N, b, p))
result_factors.append(b)
# """auxilliary quantum register used in addition and multiplication"""
aux_reg = QuantumRegister(size = n+2, name="aux_reg")
up_reg = QuantumRegister(2*n, name = "up_reg")
# """quantum register where the multiplications are made"""
down_reg = QuantumRegister(n, name = "down_reg")
# """classical register where the measured values of the QFT are stored"""
up_classic = ClassicalRegister(2*n, name="up_classic")
# """ Create Quantum Circuit """
circuit = QuantumCircuit(up_reg ,down_reg ,aux_reg, up_classic, name="Shor circuit(N={}, a={})".format(N, a))
# phi_add_N_gate = phiADD(circuit,q,a,N,inv)
phi_add_N_gate = phi_add_gate(aux_reg.size - 1, get_angles(N,n))
iphi_add_N_gate = phi_add_N_gate.inverse()
# """ Initialize down register to 1 and create maximal superposition in top register """
circuit.h(up_reg)
circuit.x(down_reg[0])
# circuit.draw(filename = "shor_standard_QFT")
# """ Apply the multiplication gates as showed in the report in order to create the exponentiation """
for i, ctl_up in enumerate(up_reg): # type: ignore
a_aux = int(pow(a, pow(2, i)))
controlled_multiple_mod_N_circuit = controlled_multiple_mod_N(
len(down_reg) + len(aux_reg) + 1, N, a_aux,n,aux_reg.size
)
controlled_multiple_mod_N_result = controlled_multiple_mod_N_circuit.to_instruction()
circuit.append(
controlled_multiple_mod_N_result, [ctl_up, *down_reg, *aux_reg]
)
# circuit.draw()
iqft = QFT(len(up_reg)).inverse().to_instruction()
# iqft = my_create_inverse_QFT(len(up_reg)).to_instruction()
# iqft = my_create_inverse_QFT(len(up_reg), insert_barriers = False).to_gate(label = r"$QFT^{{{0}}}$".format("†"))
circuit.append(iqft, up_reg)
circuit.measure(up_reg, up_classic)
# circuit.draw(filename = "shor_standard_QFT_final_circuit",fold = -1 )
# print(summarize_circuits(circuit))
# circuit.draw()
print('Running with N={0} and a={1} with number of qubits n={2}'.format(N, a, 4*n + 2))
qc_compiled = transpile(circuit, backend, optimization_level = 3)
job_sim_1 = backend.run(qc_compiled, shots=shots)
sim_result=job_sim_1.result()
# counts_result = sim_result.get_counts(circuit)
# len(counts_result)
# measurement_plot = qiskit.visualization.plot_histogram(counts_result,figsize=(20, 12) ,number_to_keep = 30,bar_labels=True, title = "Measurement results from shor_standard_QFT circuit variant" )
# measurement_plot.savefig("shor_standard_QFT_measurement")
# measurement_plot
processed_result = process_results(sim_result, circuit, shots, N, a, n)
end_time_number = datetime.now()
end_time = end_time_number.strftime("%H:%M:%S")
duration = end_time_number - start_time_number
print("Current Start Time =", start_time)
print(processed_result)
print("Current End Time =", end_time)
circuit_count_ops = circuit.count_ops()
circuit_decomposed = circuit.decompose()
circuit_decomposed_count_ops = circuit_decomposed.count_ops()
qc_compiled_count_ops = qc_compiled.count_ops()
summary_result["num_qubits"] = n
summary_result["Number(N)"] = N
summary_result["a"] = a
summary_result["start_time"] = start_time
summary_result["end_time"] = end_time
summary_result["duration"] = duration
summary_result["result_factors"] = processed_result[0]
summary_result["prob_success"] = processed_result[1]
summary_result["prob_failure"] = processed_result[2]
summary_result["total_counts"] = processed_result[3]
summary_result["result_successful_counts"] = processed_result[4]
summary_result["result_failure_counts"] = processed_result[5]
summary_result["circuit_width"] = circuit.width()
summary_result["circuit_depth"] = circuit.depth()
summary_result["circuit_size"] = circuit.size()
summary_result["circuit_num_nonlocal_gates"] = circuit.num_nonlocal_gates()
summary_result["circuit_num_ancillas"] = circuit.num_ancillas
summary_result["circuit_num_clbits"] = circuit.num_clbits
summary_result["circuit_num_qubits"] = circuit.num_qubits
summary_result["circuit_num_ancillas"] = circuit.num_ancillas
summary_result["circuit_num_of_count_ops"] = len(circuit_count_ops)
summary_result["circuit_num_of_x"] = circuit_count_ops.get('x')
summary_result["circuit_num_of_measure"] = circuit_count_ops.get('measure')
summary_result["circuit_num_of_h"] = circuit_count_ops.get('h')
summary_result["circuit_num_of_cswap"] = circuit_count_ops.get('cswap')
summary_result["circuit_num_of_swap"] = circuit_count_ops.get('swap')
summary_result["circuit_num_of_cx"] = circuit_count_ops.get('cx')
summary_result["circuit_num_of_toffoli"] = circuit_count_ops.get('toffoli')
summary_result["circuit_num_of_p"] = circuit_count_ops.get('p')
summary_result["circuit_num_of_t"] = circuit_count_ops.get('t')
summary_result["circuit_decomposed_width"] = circuit_decomposed.width()
summary_result["circuit_decomposed_depth"] = circuit_decomposed.depth()
summary_result["circuit_decomposed_size"] = circuit_decomposed.size()
summary_result["circuit_decomposed_num_nonlocal_gates"] = circuit_decomposed.num_nonlocal_gates()
summary_result["circuit_decomposed_num_ancillas"] = circuit_decomposed.num_ancillas
summary_result["circuit_decomposed_num_clbits"] = circuit_decomposed.num_clbits
summary_result["circuit_decomposed_num_qubits"] = circuit_decomposed.num_qubits
summary_result["circuit_decomposed_num_ancillas"] = circuit_decomposed.num_ancillas
summary_result["circuit_decomposed_num_of_count_ops"] = len(circuit_decomposed_count_ops)
summary_result["circuit_decomposed_num_of_x"] = circuit_decomposed_count_ops.get('x')
summary_result["circuit_decomposed_num_of_measure"] = circuit_decomposed_count_ops.get('measure')
summary_result["circuit_decomposed_num_of_h"] = circuit_decomposed_count_ops.get('h')
summary_result["circuit_decomposed_num_of_cswap"] = circuit_decomposed_count_ops.get('cswap')
summary_result["circuit_decomposed_num_of_swap"] = circuit_decomposed_count_ops.get('swap')
summary_result["circuit_decomposed_num_of_cx"] = circuit_decomposed_count_ops.get('cx')
summary_result["circuit_decomposed_num_of_toffoli"] = circuit_decomposed_count_ops.get('toffoli')
summary_result["circuit_decomposed_num_of_p"] = circuit_decomposed_count_ops.get('p')
summary_result["circuit_decomposed_num_of_t"] = circuit_decomposed_count_ops.get('t')
summary_result["qc_compiled_width"] = qc_compiled.width()
summary_result["qc_compiled_depth"] = qc_compiled.depth()
summary_result["qc_compiled_size"] = qc_compiled.size()
summary_result["qc_compiled_num_nonlocal_gates"] = qc_compiled.num_nonlocal_gates()
summary_result["qc_compiled_num_ancillas"] = qc_compiled.num_ancillas
summary_result["qc_compiled_num_clbits"] = qc_compiled.num_clbits
summary_result["qc_compiled_num_qubits"] = qc_compiled.num_qubits
summary_result["qc_compiled_num_ancillas"] = qc_compiled.num_ancillas
summary_result["qc_compiled_num_of_count_ops"] = len(qc_compiled_count_ops)
summary_result["qc_compiled_num_of_x"] = qc_compiled_count_ops.get('x')
summary_result["qc_compiled_num_of_measure"] = qc_compiled_count_ops.get('measure')
summary_result["qc_compiled_num_of_h"] = qc_compiled_count_ops.get('h')
summary_result["qc_compiled_num_of_cswap"] = qc_compiled_count_ops.get('cswap')
summary_result["qc_compiled_num_of_swap"] = qc_compiled_count_ops.get('swap')
summary_result["qc_compiled_num_of_cx"] = qc_compiled_count_ops.get('cx')
summary_result["qc_compiled_num_of_toffoli"] = qc_compiled_count_ops.get('toffoli')
summary_result["qc_compiled_num_of_p"] = qc_compiled_count_ops.get('p')
summary_result["qc_compiled_num_of_t"] = qc_compiled_count_ops.get('t')
return summary_result
# Run for just a single number N
%%time
N = 33
shots = 1024
global result_factors
all_summary_result_temp = []
for random_a in range(16, 17):
if math.gcd(random_a,N) > 1:
continue
a = random_a
summary_result = my_shor(a,N,shots)
print("Finished running for a = {} and N = {}\n".format(a, N))
all_summary_result_temp.append(summary_result)
summary_result_list = []
for key, value in summary_result.items():
summary_result_list.append([key,value])
summary_result_list
with open("a({0})_N({1})_standard.csv".format(a, N), 'a') as myfile:
write = csv.writer(myfile)
#write.writerow(fields)
write.writerows(summary_result_list)
all_summary_result_temp
# Run for many numbers N.
%%time
shots = 1024
global result_factors
all_summary_result = []
for N in [15, 21, 33, 35, 39, 51, 55, 57]:
for a in range(2, N):
if math.gcd(a,N) > 1:
continue
print("Beginning running for a = {} and N = {}".format(a, N))
summary_result = my_shor(a,N,shots)
print("Finished running for a = {} and N = {}\n\n".format(a, N))
all_summary_result.append(summary_result)
all_summary_result
%qiskit_copyright
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import qiskit
qiskit.__qiskit_version__
#initialization
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# Load the saved IBMQ accounts
IBMQ.load_account()
s = "010101" # the hidden bitstring
assert 1 < len(s) < 20, "The length of s must be between 2 and 19"
for c in s:
assert c == "0" or c == "1", "s must be a bitstring of '0' and '1'"
n = len(s) #the length of the bitstring
# Step 1
# Creating registers
# qubits for querying the oracle and recording its output
qr = QuantumRegister(2*n)
# for recording the measurement on the first register of qr
cr = ClassicalRegister(n)
circuitName = "Simon"
simonCircuit = QuantumCircuit(qr, cr)
# Step 2
# Apply Hadamard gates before querying the oracle
for i in range(n):
simonCircuit.h(qr[i])
# Apply barrier to mark the beginning of the blackbox function
simonCircuit.barrier()
# Step 3 query the blackbox function
# copy the content of the first register to the second register
for i in range(n):
simonCircuit.cx(qr[i], qr[n+i])
# get the least index j such that s_j is "1"
j = -1
for i, c in enumerate(s):
if c == "1":
j = i
break
# Creating 1-to-1 or 2-to-1 mapping with the j-th qubit of x as control to XOR the second register with s
for i, c in enumerate(s):
if c == "1" and j >= 0:
simonCircuit.cx(qr[j], qr[n+i]) #the i-th qubit is flipped if s_i is 1
# get random permutation of n qubits
perm = list(np.random.permutation(n))
#initial position
init = list(range(n))
i = 0
while i < n:
if init[i] != perm[i]:
k = perm.index(init[i])
simonCircuit.swap(qr[n+i], qr[n+k]) #swap qubits
init[i], init[k] = init[k], init[i] #marked swapped qubits
else:
i += 1
# randomly flip the qubit
for i in range(n):
if np.random.random() > 0.5:
simonCircuit.x(qr[n+i])
# Apply the barrier to mark the end of the blackbox function
simonCircuit.barrier()
# Step 4 apply Hadamard gates to the first register
for i in range(n):
simonCircuit.h(qr[i])
# Step 5 perform measurement on the first register
for i in range(n):
simonCircuit.measure(qr[i], cr[i])
#draw the circuit
simonCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend("qasm_simulator")
# the number of shots is twice the length of the bitstring
shots = 2*n
job = execute(simonCircuit, backend=backend, shots=shots)
answer = job.result().get_counts()
plot_histogram(answer)
# Post-processing step
# Constructing the system of linear equations Y s = 0
# By k[::-1], we reverse the order of the bitstring
lAnswer = [ (k[::-1],v) for k,v in answer.items() if k != "0"*n ] #excluding the trivial all-zero
#Sort the basis by their probabilities
lAnswer.sort(key = lambda x: x[1], reverse=True)
Y = []
for k, v in lAnswer:
Y.append( [ int(c) for c in k ] )
#import tools from sympy
from sympy import Matrix, pprint, MatrixSymbol, expand, mod_inverse
Y = Matrix(Y)
#pprint(Y)
#Perform Gaussian elimination on Y
Y_transformed = Y.rref(iszerofunc=lambda x: x % 2==0) # linear algebra on GF(2)
#to convert rational and negatives in rref of linear algebra on GF(2)
def mod(x,modulus):
numer, denom = x.as_numer_denom()
return numer*mod_inverse(denom,modulus) % modulus
Y_new = Y_transformed[0].applyfunc(lambda x: mod(x,2)) #must takecare of negatives and fractional values
#pprint(Y_new)
print("The hidden bistring s[ 0 ], s[ 1 ]....s[",n-1,"] is the one satisfying the following system of linear equations:")
rows, cols = Y_new.shape
for r in range(rows):
Yr = [ "s[ "+str(i)+" ]" for i, v in enumerate(list(Y_new[r,:])) if v == 1 ]
if len(Yr) > 0:
tStr = " + ".join(Yr)
print(tStr, "= 0")
#Use one of the available backends
backend = IBMQ.get_backend("ibmq_16_melbourne")
# show the status of the backend
print("Status of", backend, "is", backend.status())
shots = 10*n #run more experiments to be certain
max_credits = 3 # Maximum number of credits to spend on executions.
simonCompiled = transpile(simonCircuit, backend=backend, optimization_level=1)
job_exp = execute(simonCompiled, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job_exp)
results = job_exp.result()
answer = results.get_counts(simonCircuit)
plot_histogram(answer)
# Post-processing step
# Constructing the system of linear equations Y s = 0
# By k[::-1], we reverse the order of the bitstring
lAnswer = [ (k[::-1][:n],v) for k,v in answer.items() ] #excluding the qubits that are not part of the inputs
#Sort the basis by their probabilities
lAnswer.sort(key = lambda x: x[1], reverse=True)
Y = []
for k, v in lAnswer:
Y.append( [ int(c) for c in k ] )
Y = Matrix(Y)
#Perform Gaussian elimination on Y
Y_transformed = Y.rref(iszerofunc=lambda x: x % 2==0) # linear algebra on GF(2)
Y_new = Y_transformed[0].applyfunc(lambda x: mod(x,2)) #must takecare of negatives and fractional values
#pprint(Y_new)
print("The hidden bistring s[ 0 ], s[ 1 ]....s[",n-1,"] is the one satisfying the following system of linear equations:")
rows, cols = Y_new.shape
for r in range(rows):
Yr = [ "s[ "+str(i)+" ]" for i, v in enumerate(list(Y_new[r,:])) if v == 1 ]
if len(Yr) > 0:
tStr = " + ".join(Yr)
print(tStr, "= 0")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import json
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit import ParameterVector
from qiskit.circuit.library import ZFeatureMap
from qiskit.quantum_info import SparsePauliOp
from qiskit.utils import algorithm_globals
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
from qiskit_machine_learning.neural_networks import EstimatorQNN
from sklearn.model_selection import train_test_split
algorithm_globals.random_seed = 12345
# We now define a two qubit unitary as defined in [3]
def conv_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
target.cx(1, 0)
target.rz(np.pi / 2, 0)
return target
# Let's draw this circuit and see what it looks like
params = ParameterVector("θ", length=3)
circuit = conv_circuit(params)
circuit.draw("mpl")
def conv_layer(num_qubits, param_prefix):
qc = QuantumCircuit(num_qubits, name="Convolutional Layer")
qubits = list(range(num_qubits))
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits * 3)
for q1, q2 in zip(qubits[0::2], qubits[1::2]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
for q1, q2 in zip(qubits[1::2], qubits[2::2] + [0]):
qc = qc.compose(conv_circuit(params[param_index : (param_index + 3)]), [q1, q2])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, qubits)
return qc
circuit = conv_layer(4, "θ")
circuit.decompose().draw("mpl")
def pool_circuit(params):
target = QuantumCircuit(2)
target.rz(-np.pi / 2, 1)
target.cx(1, 0)
target.rz(params[0], 0)
target.ry(params[1], 1)
target.cx(0, 1)
target.ry(params[2], 1)
return target
params = ParameterVector("θ", length=3)
circuit = pool_circuit(params)
circuit.draw("mpl")
def pool_layer(sources, sinks, param_prefix):
num_qubits = len(sources) + len(sinks)
qc = QuantumCircuit(num_qubits, name="Pooling Layer")
param_index = 0
params = ParameterVector(param_prefix, length=num_qubits // 2 * 3)
for source, sink in zip(sources, sinks):
qc = qc.compose(pool_circuit(params[param_index : (param_index + 3)]), [source, sink])
qc.barrier()
param_index += 3
qc_inst = qc.to_instruction()
qc = QuantumCircuit(num_qubits)
qc.append(qc_inst, range(num_qubits))
return qc
sources = [0, 1]
sinks = [2, 3]
circuit = pool_layer(sources, sinks, "θ")
circuit.decompose().draw("mpl")
def generate_dataset(num_images):
images = []
labels = []
hor_array = np.zeros((6, 8))
ver_array = np.zeros((4, 8))
j = 0
for i in range(0, 7):
if i != 3:
hor_array[j][i] = np.pi / 2
hor_array[j][i + 1] = np.pi / 2
j += 1
j = 0
for i in range(0, 4):
ver_array[j][i] = np.pi / 2
ver_array[j][i + 4] = np.pi / 2
j += 1
for n in range(num_images):
rng = algorithm_globals.random.integers(0, 2)
if rng == 0:
labels.append(-1)
random_image = algorithm_globals.random.integers(0, 6)
images.append(np.array(hor_array[random_image]))
elif rng == 1:
labels.append(1)
random_image = algorithm_globals.random.integers(0, 4)
images.append(np.array(ver_array[random_image]))
# Create noise
for i in range(8):
if images[-1][i] == 0:
images[-1][i] = algorithm_globals.random.uniform(0, np.pi / 4)
return images, labels
images, labels = generate_dataset(50)
train_images, test_images, train_labels, test_labels = train_test_split(
images, labels, test_size=0.3
)
fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={"xticks": [], "yticks": []})
for i in range(4):
ax[i // 2, i % 2].imshow(
train_images[i].reshape(2, 4), # Change back to 2 by 4
aspect="equal",
)
plt.subplots_adjust(wspace=0.1, hspace=0.025)
feature_map = ZFeatureMap(8)
feature_map.decompose().draw("mpl")
feature_map = ZFeatureMap(8)
ansatz = QuantumCircuit(8, name="Ansatz")
# First Convolutional Layer
ansatz.compose(conv_layer(8, "с1"), list(range(8)), inplace=True)
# First Pooling Layer
ansatz.compose(pool_layer([0, 1, 2, 3], [4, 5, 6, 7], "p1"), list(range(8)), inplace=True)
# Second Convolutional Layer
ansatz.compose(conv_layer(4, "c2"), list(range(4, 8)), inplace=True)
# Second Pooling Layer
ansatz.compose(pool_layer([0, 1], [2, 3], "p2"), list(range(4, 8)), inplace=True)
# Third Convolutional Layer
ansatz.compose(conv_layer(2, "c3"), list(range(6, 8)), inplace=True)
# Third Pooling Layer
ansatz.compose(pool_layer([0], [1], "p3"), list(range(6, 8)), inplace=True)
# Combining the feature map and ansatz
circuit = QuantumCircuit(8)
circuit.compose(feature_map, range(8), inplace=True)
circuit.compose(ansatz, range(8), inplace=True)
observable = SparsePauliOp.from_list([("Z" + "I" * 7, 1)])
# we decompose the circuit for the QNN to avoid additional data copying
qnn = EstimatorQNN(
circuit=circuit.decompose(),
observables=observable,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
)
circuit.draw("mpl")
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
with open("11_qcnn_initial_point.json", "r") as f:
initial_point = json.load(f)
classifier = NeuralNetworkClassifier(
qnn,
optimizer=COBYLA(maxiter=200), # Set max iterations here
callback=callback_graph,
initial_point=initial_point,
)
x = np.asarray(train_images)
y = np.asarray(train_labels)
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
classifier.fit(x, y)
# score classifier
print(f"Accuracy from the train data : {np.round(100 * classifier.score(x, y), 2)}%")
y_predict = classifier.predict(test_images)
x = np.asarray(test_images)
y = np.asarray(test_labels)
print(f"Accuracy from the test data : {np.round(100 * classifier.score(x, y), 2)}%")
# Let's see some examples in our dataset
fig, ax = plt.subplots(2, 2, figsize=(10, 6), subplot_kw={"xticks": [], "yticks": []})
for i in range(0, 4):
ax[i // 2, i % 2].imshow(test_images[i].reshape(2, 4), aspect="equal")
if y_predict[i] == -1:
ax[i // 2, i % 2].set_title("The QCNN predicts this is a Horizontal Line")
if y_predict[i] == +1:
ax[i // 2, i % 2].set_title("The QCNN predicts this is a Vertical Line")
plt.subplots_adjust(wspace=0.1, hspace=0.5)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.circuit.library import UCCSD
ansatz = UCCSD()
ansatz.num_spin_orbitals = 10
from qiskit_nature.second_q.circuit.library import UCCSD
ansatz = UCCSD()
ansatz.num_spatial_orbitals = 5
from qiskit_nature.circuit.library import UCC, UVCC
ucc = UCC(qubit_converter=None, num_particles=None, num_spin_orbitals=None, excitations=None)
uvcc = UVCC(qubit_converter=None, num_modals=None, excitations=None)
from qiskit_nature.second_q.circuit.library import UCC, UVCC
ucc = UCC(num_spatial_orbitals=None, num_particles=None, excitations=None, qubit_converter=None)
uvcc = UVCC(num_modals=None, excitations=None, qubit_converter=None)
from qiskit_nature.circuit.library import HartreeFock, VSCF
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import DirectMapper, JordanWignerMapper
hf = HartreeFock(
num_spin_orbitals=4, num_particles=(1, 1), qubit_converter=QubitConverter(JordanWignerMapper())
)
vscf = VSCF(num_modals=[2, 2])
from qiskit_nature.second_q.circuit.library import HartreeFock, VSCF
from qiskit_nature.second_q.mappers import DirectMapper, JordanWignerMapper, QubitConverter
hf = HartreeFock()
hf.num_spatial_orbitals = 2
hf.num_particles = (1, 1)
hf.qubit_converter = QubitConverter(JordanWignerMapper())
vscf = VSCF()
vscf.num_modals = [2, 2]
from qiskit.providers.basicaer import BasicAer
from qiskit.utils import QuantumInstance
from qiskit_nature.algorithms.ground_state_solvers import VQEUCCFactory
quantum_instance = QuantumInstance(BasicAer.get_backend("statevector_simulator"))
vqe_factory = VQEUCCFactory(quantum_instance=quantum_instance)
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit_nature.second_q.circuit.library import UCCSD
from qiskit_nature.second_q.algorithms.ground_state_solvers import VQEUCCFactory
estimator = Estimator()
ansatz = UCCSD()
optimizer = SLSQP()
vqe_factory = VQEUCCFactory(estimator, ansatz, optimizer)
from qiskit_nature.algorithms.ground_state_solvers import GroundStateEigensolver, VQEUCCFactory
from qiskit_nature.algorithms.excited_states_solvers import QEOM
from qiskit_nature.converters.second_quantization import QubitConverter
from qiskit_nature.mappers.second_quantization import JordanWignerMapper
vqe_factory = VQEUCCFactory()
converter = QubitConverter(JordanWignerMapper())
ground_state_solver = GroundStateEigensolver(converter, vqe_factory)
qeom = QEOM(ground_state_solver)
from qiskit.algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
from qiskit_nature.second_q.circuit.library import UCCSD
from qiskit_nature.second_q.algorithms.ground_state_solvers import (
GroundStateEigensolver,
VQEUCCFactory,
)
from qiskit_nature.second_q.algorithms.excited_states_solvers import QEOM
from qiskit_nature.second_q.mappers import JordanWignerMapper, QubitConverter
estimator = Estimator()
ansatz = UCCSD()
optimizer = SLSQP()
vqe_factory = VQEUCCFactory(estimator, ansatz, optimizer)
converter = QubitConverter(JordanWignerMapper())
ground_state_solver = GroundStateEigensolver(converter, vqe_factory)
qeom = QEOM(ground_state_solver, estimator)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit import *
from qiskit.tools.visualization import plot_histogram
from IPython.display import display, Math, Latex
def BuildGHZ(n):
U = QuantumCircuit(n)
U.h(0)
for i in range(1, n):
U.cx(0, i)
U = U.to_gate()
U.name = 'Build GHZ'
#ctl_U = U.control() make it a controlled gate
return U
n = 5
mc = QuantumCircuit(n, n)
U = BuildGHZ(n)
mc.append(U, range(n))
mc.measure(range(n), range(n))
backend = BasicAer.get_backend('qasm_simulator')
atp = 1024
res = execute(mc, backend=backend, shots=atp).result()
ans = res.get_counts()
mc.draw('mpl')
plot_histogram(ans)
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
import random
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit import ParameterVector
from qiskit.quantum_info import state_fidelity
from qiskit.quantum_info import Statevector, DensityMatrix, Operator
class Compressor:
def __init__(self, ensemble, block_size):
# Initialize parameters
self.ensemble = ensemble
self.n = block_size
self.m = block_size
self.theta = ParameterVector('theta', length=block_size)
self.phi = ParameterVector('phi', length=block_size)
# Initialize density matrix properties
self.rho = np.zeros((2, 2))
self.s0 = np.array([0, 0])
self.s1 = np.array([0, 0])
self.entropy = 1
self.initialize_density_matrix()
self.noise = ParameterVector('noise', length=self.m)
# Build subcircuits
self.ns_ckt = QuantumCircuit(self.n, name='$Noise$')
self.source = QuantumCircuit(self.n, name='$Src$')
self.tx_ckt = QuantumCircuit(self.n, name='$Tx$')
self.rx_ckt = QuantumCircuit(self.n, name='$Rx$')
self.initialize_subcircuits()
def initialize_density_matrix(self):
# Evaluate density matrix and list of states
for key in self.ensemble.keys():
theta = key[0]
phi = key[1]
state = np.array([np.cos(theta/2), np.sin(theta/2) * np.exp(phi*complex(1, 0))])
self.rho = self.rho + self.ensemble[key] * np.outer(state, state)
# Evaluate spectrum
self.rho: np.ndarray
v, w = np.linalg.eig(self.rho)
s0 = Statevector(w[:, 0])
s1 = Statevector(w[:, 1])
self.rho = DensityMatrix(self.rho)
# Evaluate entropy and typical basis
if state_fidelity(s0, self.rho) > state_fidelity(s1, self.rho):
self.s0 = s0
self.s1 = s1
else:
self.s0 = s1
self.s1 = s0
self.entropy = -np.real(sum([p * np.log2(p) for p in v]))
self.m = int(np.ceil(self.entropy * self.n))
def initialize_subcircuits(self):
# Build source
self.source.reset(range(self.n))
for i in range(self.n):
self.source.ry(self.theta[i], i)
self.source.rz(self.phi[i], i)
# Build typical basis change operator
U = Operator(np.column_stack((self.s0.data, self.s1.data))).adjoint()
for i in range(self.n):
self.tx_ckt.unitary(U, [i], label='$Basis$')
# Build permutation operator
data = list(range(2 ** self.n))
data = [("{0:0" + str(self.n) + "b}").format(i) for i in data]
data = sorted(data, key=lambda x: x.count('1'))
data = [int(x, 2) for x in data]
V = np.zeros((2 ** self.n, 2 ** self.n))
for i in range(2 ** self.n):
V[i, data[i]] = 1
self.tx_ckt.unitary(V, list(range(self.n)), label='$Perm$')
# Build bit flip noisy channel
for i in range(self.m):
self.ns_ckt.u3(self.noise[i], 0, self.noise[i], i)
# Build receiver
self.rx_ckt.reset(range(self.m, self.n))
self.rx_ckt.append(self.tx_ckt.to_gate().inverse(), list(range(self.n)))
def simulate(self, num_shots=1, bit_flip_prob=0.0):
# Get backend and circuit
simulator = Aer.get_backend('statevector_simulator')
circ = self.source + self.tx_ckt + self.ns_ckt + self.rx_ckt
fid_list = []
for i in range(num_shots):
# Acquire parameters
states = random.choices(list(self.ensemble.keys()), self.ensemble.values(), k=self.n)
noise = random.choices([0, np.pi], [1-bit_flip_prob, bit_flip_prob], k=self.m)
theta = [p[0] for p in states]
phi = [p[1] for p in states]
circ1 = self.source.bind_parameters({self.theta: theta, self.phi: phi})
circ2 = circ.bind_parameters({self.theta: theta, self.phi: phi, self.noise: noise})
# Simulate
ini_state = execute(circ1, simulator).result().get_statevector()
fin_state = execute(circ2, simulator).result().get_statevector()
fid_list.append(state_fidelity(ini_state, fin_state))
# Return results
return fid_list
def visualize(self):
# Draw components
self.source.draw('mpl', reverse_bits=True).suptitle('Source Circuit')
self.tx_ckt.draw('mpl', reverse_bits=True).suptitle('Tx Circuit')
self.rx_ckt.draw('mpl', reverse_bits=True).suptitle('Rx Circuit')
(self.source + self.tx_ckt + self.ns_ckt + self.rx_ckt).draw('mpl', reverse_bits=True).suptitle('Full Circuit')
plt.show()
if __name__ == '__main__':
ensemble = {(0, 0): 0.5, (np.pi/2, 0): 0.5}
com = Compressor(ensemble, 3)
com.visualize()
fid1 = com.simulate(num_shots=100)
fid2 = com.simulate(num_shots=100, bit_flip_prob=0.1)
print('Noiseless System Fidelity: ', np.mean(fid1))
print('Noisy (p = 0.1) System Fidelity: ', np.mean(fid2))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
# You can reverse the order of the qubits.
from qiskit.quantum_info import DensityMatrix
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.t(1)
qc.s(0)
qc.cx(0,1)
matrix = DensityMatrix(qc)
plot_bloch_multivector(matrix, title='My Bloch Spheres', reverse_bits=True)
|
https://github.com/carstenblank/dc-qiskit-algorithms
|
carstenblank
|
# Copyright 2018 Carsten Blank
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import logging
from itertools import tee
from typing import List, Tuple, Union, Callable, Iterable
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.circuit import Gate, Instruction, Qubit, Clbit, InstructionSet
from qiskit.extensions import HGate, RZGate, RYGate, CXGate
from scipy import sparse
log = logging.getLogger('UniformRotation')
# noinspection PyPep8Naming
def binary_codes(number_qubits):
# type: (int) -> List[int]
"""
Convenience function to get a list of numbers from 0 to 2**number_qubits - 1
:param number_qubits: exponent
:return: list of numbers
"""
N = int(2**number_qubits)
return list(range(N))
def gray_code(number):
# type: (int) -> int
"""
Cyclic Gray Code of number
:param number: input number
:return: Gray Code
"""
return (number >> 1) ^ number
# noinspection PyPep8Naming
def matrix_M_entry(row, col):
# type: (int, int) -> float
"""
The matrix for the angle computation
:param row: row number (one based!)
:param col: column number (one based!)
:return: matrix entry
"""
b_and_g = row & gray_code(col)
sum_of_ones = 0
while b_and_g > 0:
if b_and_g & 0b1:
sum_of_ones += 1
b_and_g = b_and_g >> 1
return (-1)**sum_of_ones
def compute_theta(alpha):
# type: (sparse.dok_matrix) -> sparse.dok_matrix
"""
Compute the rotational angles from alpha
:param alpha: the input uniform rotation angles
:return: the single qubit rotation angles
"""
k = np.log2(alpha.shape[0])
factor = 2**(-k)
theta = sparse.dok_matrix(alpha.shape, dtype=np.float64) # type: sparse.dok_matrix
for row in range(alpha.shape[0]):
# Use transpose of M:
entry = sum([matrix_M_entry(col, row) * a for (col, _), a in alpha.items()])
entry *= factor
if abs(entry) > 1e-6:
theta[row, 0] = entry
return theta
def pairwise(iterable):
# type: (Iterable) -> Iterable[Tuple]
"""
Calculates pairwise consecutive pairs of an iterable
s -> (s0,s1), (s1,s2), (s2, s3), ...
:param iterable: any iterable
:return: an iterable of tuples
"""
a, b = tee(iterable)
next(b, None)
return zip(a, b)
class UniformRotationGate(Gate):
"""Uniform rotation gate (Möttönen)."""
def __init__(self, gate, alpha):
# type: (Callable[[float], Gate], sparse.dok_matrix) -> None
"""
Create new uniform rotation gate.
:param gate: A single qubit rotation gate (typically rx, ry, rz)
:param alpha: The conditional rotation angles
"""
number_of_control_qubits = int(np.ceil(np.log2(alpha.shape[0])))
vector_str = ",".join([f'{v:.2f}' for v in alpha.toarray()[:, 0]])
label = f'uni_rot_{gate(0).name}({vector_str})' if len(alpha) <= 16 else None
super().__init__(f'uni_rot_{gate(0).name}', num_qubits=number_of_control_qubits + 1, params=[], label=label)
self.alpha = alpha # type: sparse.dok_matrix
self.gate = gate # type: Callable[[float], Gate]
def _define(self):
q = QuantumRegister(self.num_qubits, "q")
qc = QuantumCircuit(q, name=self.name)
theta = compute_theta(self.alpha) # type: sparse.dok_matrix
gray_code_rank = self.num_qubits - 1
if gray_code_rank == 0:
qc.append(self.gate(theta[0, 0]), [q[0]], [])
else:
from sympy.combinatorics.graycode import GrayCode
gc = GrayCode(gray_code_rank) # type: GrayCode
current_gray = gc.current
for i in range(gc.selections):
qc.append(self.gate(theta[i, 0]), [q[-1]], [])
next_gray = gc.next(i + 1).current
control_index = int(np.log2(int(current_gray, 2) ^ int(next_gray, 2)))
qc.append(CXGate(), [q[control_index], q[-1]], [])
current_gray = next_gray
self._definition = qc
def uni_rot(self, rotation_gate, alpha, control_qubits, tgt):
# type: (QuantumCircuit, Callable[[float], Gate], Union[List[float], sparse.dok_matrix], Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> InstructionSet
"""
Apply a generic uniform rotation with rotation gate.
:param self: either a composite gate or a circuit
:param rotation_gate: A single qubit rotation gate
:param alpha: conditional rotation angles
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
if not isinstance(alpha, sparse.dok_matrix):
alpha = sparse.dok_matrix([alpha]).transpose()
if isinstance(tgt, QuantumRegister):
tgt = tgt[0]
if isinstance(control_qubits, QuantumRegister):
control_qubits = list(control_qubits)
return self.append(UniformRotationGate(rotation_gate, alpha), control_qubits + [tgt], [])
def uni_rot_dg(self, rotation_gate, alpha, control_qubits, tgt):
# type: (QuantumCircuit, Callable[[float], Gate], Union[List[float], sparse.dok_matrix], Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> Instruction
"""
Apply the dagger (inverse) of a generic uniform rotation with rotation gate.
:param self: either a composite gate or a circuit
:param rotation_gate: A single qubit rotation gate
:param alpha: conditional rotation angles
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
return uni_rot(self, rotation_gate, alpha, control_qubits, tgt).inverse()
def unirz(self, alpha, control_qubits, tgt):
# type: (QuantumCircuit, Union[List[float], sparse.dok_matrix], Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> InstructionSet
"""
Apply a uniform rotation around z.
:param self: either a composite gate or a circuit
:param alpha: conditional rotation angles
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
return uni_rot(self, RZGate, alpha, control_qubits, tgt)
def unirz_dg(self, alpha, control_qubits, tgt):
# type: (QuantumCircuit, Union[List[float], sparse.dok_matrix], Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> Instruction
"""
Apply dagger (inverse) of a uniform rotation around z.
:param self: either a composite gate or a circuit
:param alpha: conditional rotation angles
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
return unirz(self, alpha, control_qubits, tgt).inverse()
def uniry(self, alpha, control_qubits, tgt):
# type: (QuantumCircuit, Union[List[float], sparse.dok_matrix], Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> InstructionSet
"""
Apply a uniform rotation around y.
:param self: either a composite gate or a circuit
:param alpha: conditional rotation angles
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
return uni_rot(self, RYGate, alpha, control_qubits, tgt)
def uniry_dg(self, alpha, control_qubits, tgt):
# type: (QuantumCircuit, Union[List[float], sparse.dok_matrix], Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> Instruction
"""
Apply the dagger (inverse) of a uniform rotation around y.
:param self: either a composite gate or a circuit
:param alpha: conditional rotation angles
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
return uniry(self, alpha, control_qubits, tgt).inverse()
def cnry(self, theta, control_qubits, tgt):
# type: (QuantumCircuit, float, Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> InstructionSet
"""
Apply a multiple controlled y rotation on the target qubit.
:param self: either a composite gate or a circuit
:param theta: rotation angle
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
length = 2**len(control_qubits)
alpha = sparse.dok_matrix((length, 1), dtype=np.float64)
alpha[-1] = theta
return uniry(self, alpha, control_qubits, tgt)
def cnry_dg(self, theta, control_qubits, tgt):
# type: (QuantumCircuit, float, Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> Instruction
"""
Apply the dagger (inverse) of a multiple controlled y rotation on the target qubit.
:param self: either a composite gate or a circuit
:param theta: rotation angle
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
return cnry(self, theta, control_qubits, tgt).inverse()
class MultiControlledXGate(Gate):
"""Multi-Controlled X-Gate (via Möttönen)."""
def __init__(self, conditional_case, control_qubits):
# type: (int, int) -> None
"""
Create a new multi-controlled X gate according to the conditional (binary) case
:param conditional_case: binary representation of 0/1 control case
:param control_qubits: control qubits
"""
super().__init__("ccx_uni_rot", params=[conditional_case], num_qubits=control_qubits + 1)
self.conditional_case = conditional_case
self.control_qubits = control_qubits
def _define(self):
q = QuantumRegister(self.num_qubits, "q")
qc = QuantumCircuit(q, name=self.name)
length = 2 ** self.control_qubits
alpha = sparse.dok_matrix((length, 1), dtype=np.float64)
alpha[self.conditional_case] = np.pi
qc.append(HGate(), [q[-1]], [])
qc.append(UniformRotationGate(RYGate, alpha), list(q), [])
qc.append(HGate(), [q[-1]], [])
self.definition = qc
def ccx_uni_rot(self, conditional_case, control_qubits, tgt):
# type: (QuantumCircuit, int, Union[List[Qubit], QuantumRegister], Union[Qubit, QuantumRegister]) -> Instruction
"""
Apply a multi-controlled X gate depending on conditional binary representation
:param self: either a composite gate or a circuit
:param conditional_case: the controlled case (1 or 0) in binary
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
if isinstance(tgt, QuantumRegister):
tgt = tgt[0]
if isinstance(control_qubits, QuantumRegister):
control_qubits = list(control_qubits)
return self.append(MultiControlledXGate(conditional_case, len(control_qubits)), control_qubits + [tgt])
def ccx_uni_rot_dg(self, conditional_case, control_qubits, tgt):
# type: (QuantumCircuit, int, Union[List[Qubit],QuantumRegister], Union[Qubit, QuantumRegister]) -> Instruction
"""
Apply the dagger (inverse) a multi-controlled X gate depending on conditional binary representation
:param self: either a composite gate or a circuit
:param conditional_case: the controlled case (1 or 0) in binary
:param control_qubits: control qubits
:param tgt: target
:return: applied composite gate or circuit
"""
return ccx_uni_rot(self, conditional_case, control_qubits, tgt).inverse()
QuantumCircuit.uniry = uniry
QuantumCircuit.uniry_dg = uniry_dg
QuantumCircuit.unirz = unirz
QuantumCircuit.unirz_dg = unirz_dg
QuantumCircuit.cnry = cnry
QuantumCircuit.cnry_dg = cnry_dg
QuantumCircuit.ccx_uni_rot = ccx_uni_rot
QuantumCircuit.ccx_uni_rot_dg = ccx_uni_rot_dg
|
https://github.com/Pitt-JonesLab/clonk_transpilation
|
Pitt-JonesLab
|
import sys
sys.path.append("..")
# the following is from Qiskits two_qubit_decomp, (doesn't work as import since need to adjust parameters and return vals)
import cmath
from qiskit.quantum_info.synthesis.two_qubit_decompose import *
import scipy.linalg as la
_ipx = np.array([[0, 1j], [1j, 0]], dtype=complex)
_ipy = np.array([[0, 1], [-1, 0]], dtype=complex)
_ipz = np.array([[1j, 0], [0, -1j]], dtype=complex)
_id = np.array([[1, 0], [0, 1]], dtype=complex)
def KAKDecomp(unitary_matrix, *, fidelity=(1.0 - 1.0e-9)):
"""Perform the Weyl chamber decomposition, and optionally choose a specialized subclass.
The flip into the Weyl Chamber is described in B. Kraus and J. I. Cirac, Phys. Rev. A 63,
062309 (2001).
FIXME: There's a cleaner-seeming method based on choosing branch cuts carefully, in Andrew
M. Childs, Henry L. Haselgrove, and Michael A. Nielsen, Phys. Rev. A 68, 052311, but I
wasn't able to get that to work.
The overall decomposition scheme is taken from Drury and Love, arXiv:0806.4015 [quant-ph].
"""
pi = np.pi
pi2 = np.pi / 2
pi4 = np.pi / 4
# Make U be in SU(4)
U = np.array(unitary_matrix, dtype=complex, copy=True)
detU = la.det(U)
U *= detU ** (-0.25)
global_phase = cmath.phase(detU) / 4
Up = transform_to_magic_basis(U, reverse=True)
M2 = Up.T.dot(Up)
# M2 is a symmetric complex matrix. We need to decompose it as M2 = P D P^T where
# P ∈ SO(4), D is diagonal with unit-magnitude elements.
#
# We can't use raw `eig` directly because it isn't guaranteed to give us real or othogonal
# eigenvectors. Instead, since `M2` is complex-symmetric,
# M2 = A + iB
# for real-symmetric `A` and `B`, and as
# M2^+ @ M2 = A^2 + B^2 + i [A, B] = 1
# we must have `A` and `B` commute, and consequently they are simultaneously diagonalizable.
# Mixing them together _should_ account for any degeneracy problems, but it's not
# guaranteed, so we repeat it a little bit. The fixed seed is to make failures
# deterministic; the value is not important.
state = np.random.default_rng(2020)
for _ in range(100): # FIXME: this randomized algorithm is horrendous
M2real = state.normal() * M2.real + state.normal() * M2.imag
_, P = np.linalg.eigh(M2real)
D = P.T.dot(M2).dot(P).diagonal()
if np.allclose(P.dot(np.diag(D)).dot(P.T), M2, rtol=0, atol=1.0e-13):
break
else:
raise ValueError
d = -np.angle(D) / 2
d[3] = -d[0] - d[1] - d[2]
cs = np.mod((d[:3] + d[3]) / 2, 2 * np.pi)
# Reorder the eigenvalues to get in the Weyl chamber
cstemp = np.mod(cs, pi2)
np.minimum(cstemp, pi2 - cstemp, cstemp)
order = np.argsort(cstemp)[[1, 2, 0]]
cs = cs[order]
d[:3] = d[order]
P[:, :3] = P[:, order]
# Fix the sign of P to be in SO(4)
if np.real(la.det(P)) < 0:
P[:, -1] = -P[:, -1]
# Find K1, K2 so that U = K1.A.K2, with K being product of single-qubit unitaries
K1 = transform_to_magic_basis(Up @ P @ np.diag(np.exp(1j * d)))
K2 = transform_to_magic_basis(P.T)
K1l, K1r, phase_l = decompose_two_qubit_product_gate(K1)
K2l, K2r, phase_r = decompose_two_qubit_product_gate(K2)
global_phase += phase_l + phase_r
K1l = K1l.copy()
# Flip into Weyl chamber
if cs[0] > pi2:
cs[0] -= 3 * pi2
K1l = K1l.dot(_ipy)
K1r = K1r.dot(_ipy)
global_phase += pi2
if cs[1] > pi2:
cs[1] -= 3 * pi2
K1l = K1l.dot(_ipx)
K1r = K1r.dot(_ipx)
global_phase += pi2
conjs = 0
if cs[0] > pi4:
cs[0] = pi2 - cs[0]
K1l = K1l.dot(_ipy)
K2r = _ipy.dot(K2r)
conjs += 1
global_phase -= pi2
if cs[1] > pi4:
cs[1] = pi2 - cs[1]
K1l = K1l.dot(_ipx)
K2r = _ipx.dot(K2r)
conjs += 1
global_phase += pi2
if conjs == 1:
global_phase -= pi
if cs[2] > pi2:
cs[2] -= 3 * pi2
K1l = K1l.dot(_ipz)
K1r = K1r.dot(_ipz)
global_phase += pi2
if conjs == 1:
global_phase -= pi
if conjs == 1:
cs[2] = pi2 - cs[2]
K1l = K1l.dot(_ipz)
K2r = _ipz.dot(K2r)
global_phase += pi2
if cs[2] > pi4:
cs[2] -= pi2
K1l = K1l.dot(_ipz)
K1r = K1r.dot(_ipz)
global_phase -= pi2
a, b, c = cs[1], cs[0], cs[2]
return global_phase, (a, b, c), K1l, K1r, K2l, K2r
from qiskit.circuit import Parameter
class ParamIter:
def __iter__(self):
self.index = 0
return self
def __next__(self):
x = self.index
self.index += 1
return Parameter(f"p{x}")
# print(next(myiter))
# print(next(myiter))
from clonk.utils.riswap_gates.riswap import RiSwapGate
"""
Efficient compiler consturction of parameterized circuits
https://qiskit.org/documentation/tutorials/circuits_advanced/01_advanced_circuits.html
"""
def template_circuit(param_list, base=None):
myiter = iter(ParamIter())
if base is None:
qc = QuantumCircuit(2)
qc.u(*[next(myiter) for _ in range(3)], 0)
qc.u(*[next(myiter) for _ in range(3)], 1)
else:
qc = base.copy()
for param in param_list:
qc.append(RiSwapGate(1 / param), [0, 1])
qc.u(*[next(myiter) for _ in range(3)], 0)
qc.u(*[next(myiter) for _ in range(3)], 1)
return qc
qc = template_circuit([2])
qc.draw()
from qiskit.quantum_info import random_unitary, Operator
from qiskit import QuantumCircuit
target_qc = QuantumCircuit(2)
target_qc.append(random_unitary(dims=(2, 2)), [0, 1])
global_phase, (a, b, c), K1l, K1r, K2l, K2r = KAKDecomp(Operator(target_qc).data)
target_coordinates = (a, b, c)
print(target_coordinates)
def unitary_distance_function(A, B):
# return (1 - np.abs(np.sum(np.multiply(B,np.conj(np.transpose(A))))) / 4)
# return (1 - (np.abs(np.sum(np.multiply(B,np.conj(A)))))**2+4 / 20) # quantum volume paper
return 1 - np.abs(np.sum(np.multiply(B, np.conj(A)))) / 4
%matplotlib inline
from scipy.optimize import minimize
def sample(param_list, N=1000):
#
iter = []
current_best = []
nuop_distance = []
#
minimum_qc = None
min_distance = None
modified_template = None
for template_index in range(0, len(param_list)):
modified_params = param_list[: 1 + template_index]
template_qc = template_circuit(modified_params, base=modified_template)
initial_guess = np.random.random(len(template_qc.parameters)) * 2 * np.pi
#
qc = template_circuit(modified_params, base=modified_template)
def min_fun(x):
temp_qc = qc.assign_parameters(
{parameter: i for parameter, i in zip(qc.parameters, x)}
)
_, (a, b, c), _, _, _, _ = KAKDecomp(Operator(temp_qc).data)
temp_coordinates = (a, b, c)
return np.linalg.norm(
np.array(target_coordinates) - np.array(temp_coordinates)
)
min_result = minimize(fun=min_fun, x0=initial_guess)
# #
# for _ in range(N):
# qc = template_circuit(modified_params, base=modified_template)
# parameters = qc.parameters
# temp_qc = qc.assign_parameters({parameter:np.random.random()*2*np.pi for parameter in parameters})
# global_phase, (a, b, c), K1l, K1r, K2l, K2r = KAKDecomp(Operator(temp_qc).data)
# temp_coordinates = (a,b,c)
# temp_dist = np.linalg.norm(np.array(target_coordinates)-np.array(temp_coordinates))
# if min_distance is None or temp_dist < min_distance:
# minimum_qc = temp_qc
# min_distance = temp_dist
# #
# current_best.append(min_distance)
# nuop_distance.append(unitary_distance_function(Operator(minimum_qc).data, Operator(target_qc).data))
# #
# modified_template = template_qc.assign_parameters({parameter:i for parameter,i in zip(template_qc.parameters,min_result.x)})
min_distance = min_result.fun
print(min_distance)
modified_template = template_qc.assign_parameters(
{parameter: i for parameter, i in zip(template_qc.parameters, min_result.x)}
)
# import matplotlib.pyplot as plt
# plt.plot(range(len(current_best)), current_best, label="coords")
# plt.plot(range(len(current_best)), nuop_distance, label="nuop")
# plt.yscale('log')
return modified_template, min_result.fun
minimum_qc, min_distance = sample([2, 4, 8])
print(min_distance)
minimum_qc.draw(output="mpl")
%matplotlib inline
from scipy.optimize import minimize
def sample(param_list, N=1000):
#
iter = []
current_best = []
nuop_distance = []
#
minimum_qc = None
min_distance = None
modified_template = None
for template_index in range(0, len(param_list)):
modified_params = param_list[template_index : 1 + template_index]
template_qc = template_circuit(modified_params, base=modified_template)
initial_guess = np.random.random(len(template_qc.parameters)) * 2 * np.pi
#
qc = template_circuit(modified_params, base=modified_template)
def min_fun(x):
temp_qc = qc.assign_parameters(
{parameter: i for parameter, i in zip(qc.parameters, x)}
)
_, (a, b, c), _, _, _, _ = KAKDecomp(Operator(temp_qc).data)
temp_coordinates = (a, b, c)
return np.linalg.norm(
np.array(target_coordinates) - np.array(temp_coordinates)
)
min_result = minimize(fun=min_fun, x0=initial_guess)
# #
# for _ in range(N):
# qc = template_circuit(modified_params, base=modified_template)
# parameters = qc.parameters
# temp_qc = qc.assign_parameters({parameter:np.random.random()*2*np.pi for parameter in parameters})
# global_phase, (a, b, c), K1l, K1r, K2l, K2r = KAKDecomp(Operator(temp_qc).data)
# temp_coordinates = (a,b,c)
# temp_dist = np.linalg.norm(np.array(target_coordinates)-np.array(temp_coordinates))
# if min_distance is None or temp_dist < min_distance:
# minimum_qc = temp_qc
# min_distance = temp_dist
# #
# current_best.append(min_distance)
# nuop_distance.append(unitary_distance_function(Operator(minimum_qc).data, Operator(target_qc).data))
# #
modified_template = template_qc.assign_parameters(
{parameter: i for parameter, i in zip(template_qc.parameters, min_result.x)}
)
min_distance = min_result.fun
print(min_distance)
modified_template = template_qc.assign_parameters(
{parameter: i for parameter, i in zip(template_qc.parameters, min_result.x)}
)
# import matplotlib.pyplot as plt
# plt.plot(range(len(current_best)), current_best, label="coords")
# plt.plot(range(len(current_best)), nuop_distance, label="nuop")
# plt.yscale('log')
return modified_template, min_result.fun
minimum_qc, min_distance = sample([2, 2, 2])
print(min_distance)
minimum_qc.draw(output="mpl")
def sample(param_list, N=1000):
# want to characterize the vectors from 2,2, template
qc = template_circuit(param_list[:1])
temp_qc = qc.assign_parameters(
{parameter: np.random.random() * 2 * np.pi for parameter in qc.parameters}
)
global_phase, (a, b, c), K1l, K1r, K2l, K2r = KAKDecomp(Operator(temp_qc).data)
starting_coordinates = (a, b, c)
list_coordinates = []
for _ in range(N):
qc = template_circuit(param_list)
parameters = qc.parameters
temp_qc = qc.assign_parameters(
{parameter: np.random.random() * 2 * np.pi for parameter in parameters}
)
global_phase, (a, b, c), K1l, K1r, K2l, K2r = KAKDecomp(Operator(temp_qc).data)
temp_coordinates = (a, b, c)
list_coordinates.append(temp_coordinates)
c1, c2, c3 = weylchamber.c1c2c3(gate)
w.add_point(c1, c2, c3)
temp_vector = np.array(temp_coordinates) - np.array(starting_coordinates)
# print(temp_vector)
return list_coordinates
w = WeylChamber()
list_coordinates = sample(param_list=[3, 2])
w.plot()
# print(list_coordinates)
import scipy.spatial as ss
import numpy as np
hull = ss.ConvexHull(list_coordinates)
print("volume inside points is: ", hull.volume)
import numpy as np
import qutip
import matplotlib
import matplotlib.pylab as plt
import weylchamber
from weylchamber.visualize import WeylChamber
WeylChamber().plot()
IDENTITY = qutip.identity([2, 2])
CNOT = qutip.qip.operations.cnot()
CPHASE = qutip.qip.operations.cphase(np.pi)
BGATE = qutip.qip.operations.berkeley()
iSWAP = qutip.qip.operations.iswap()
sqrtISWAP = qutip.qip.operations.sqrtiswap()
sqrtSWAP = qutip.qip.operations.sqrtswap()
MGATE = weylchamber.canonical_gate(3 / 4, 1 / 4, 0)
w = WeylChamber()
list_of_gates = [
("Identity", IDENTITY),
("CNOT", CNOT),
("CPHASE", CPHASE),
("BGATE", BGATE),
("iSWAP", iSWAP),
("sqrtISWAP", sqrtISWAP),
("sqrtSWAP", sqrtSWAP),
("MGATE", MGATE),
]
print("Weyl Chamber Coordinates")
print("----------------------------------")
for name, gate in list_of_gates:
c1, c2, c3 = weylchamber.c1c2c3(gate)
print("%10s: \t%.2fπ %.2fπ %.2fπ" % (name, c1, c2, c3))
w.add_point(c1, c2, c3)
w.plot()
w.scatter(
*zip(
*[
weylchamber.c1c2c3(qutip.qip.operations.cphase(phase))
for phase in np.linspace(0, 2 * np.pi, 20)
]
)
)
w.plot()
print("Local Invariants")
print("----------------------------------")
for name, gate in list_of_gates:
g1, g2, g3 = weylchamber.g1g2g3(gate)
print("%10s: \t%5.2f %5.2f %5.2f" % (name, g1, g2, g3))
|
https://github.com/sooodos/Quantum-Computing-Learning-Gate
|
sooodos
|
from qiskit import QuantumCircuit
class CnotOracle:
@classmethod
def create_cnot_oracle(cls, input_string, input_length, eval_mode: bool) -> QuantumCircuit:
balanced_oracle = QuantumCircuit(input_length + 1)
# Place X-gates
for qubit in range(len(input_string)):
if input_string[qubit] == '1':
balanced_oracle.x(qubit)
# Use barrier as divider
balanced_oracle.barrier()
# Controlled-NOT gates
for qubit in range(input_length):
balanced_oracle.cx(qubit, input_length)
balanced_oracle.barrier()
# Place X-gates
for qubit in range(len(input_string)):
if input_string[qubit] == '1':
balanced_oracle.x(qubit)
if not eval_mode:
# Show oracle
print("This is the oracle function, aka the black box. NORMALLY THIS WOULD BE HIDDEN!")
print(balanced_oracle)
return balanced_oracle
|
https://github.com/Spintronic6889/Introduction-of-Quantum-walk-its-application-on-search-and-decision-making
|
Spintronic6889
|
!python --version
!pip install qiskit
!pip install pylatexenc
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer
from qiskit.visualization import plot_histogram
from qiskit.visualization import plot_state_city
from random import randrange
from qiskit.tools.monitor import job_monitor
%matplotlib inline
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
import random
import math
#discrete time quantum random walk with a hadamard coin
n=2
steps=1
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
#discrete time quantum random walk with a hadamard coin
n=2
steps=2
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
#discrete time quantum random walk with a hadamard coin
n=2
steps=3
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_city
#discrete time quantum random walk with a hadamard coin
n=3
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
state = DensityMatrix.from_instruction(QC)
plot_state_city(state,figsize=(15, 8), color=['midnightblue', 'midnightblue'],
title="New State City")
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
# Import Aer
from qiskit import Aer
# Run the quantum circuit on a statevector simulator backend
backend = Aer.get_backend('statevector_simulator')
# Create a Quantum Program for execution
job = execute(QC, backend)
result = job.result()
outputstate = result.get_statevector(QC, decimals=3)
print(outputstate)
#discrete time quantum random walk with a hadamard coin
n=6
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized coin |0>
#QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
#discrete time quantum random walk with a hadamard coin
n=6
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
#initialized coin |1>
QC.x(qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
from qiskit import *
%matplotlib inline
#discrete time quantum random walk with a hadamard coin
n=6
steps=11
qpos = QuantumRegister(n,'qpos')
qcoin = QuantumRegister(1,'qcoin')
cpos = ClassicalRegister(n,'cr')
QC = QuantumCircuit(qpos, qcoin)
pi=math.pi
#initialized coin Ugate
QC.u(pi/2, 3*pi/2, 0, qcoin[0])
for i in range(steps):
#coin
QC.h(qcoin[0])
QC.barrier()
#increment gate operator
for i in range(n):
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
QC.barrier()
#decrement gate operator
QC.x(qcoin[0])
for i in range(n):
if i+1 < n: QC.x(qpos[i+1:])
QC.mct([qcoin[0]]+qpos[i+1:], qpos[i], None, mode='noancilla')
if i+1 < n: QC.x(qpos[i+1:])
QC.barrier()
a=n/2
p=math.floor(a)
#print(p)
for k in range(n):
if(k<p):
QC.swap(qpos[n-1-k],qpos[k])
#print(a)
display(QC.draw(output="mpl"))
QC.measure_all()
# # Execute the circuit on the qasm simulator
job = execute(QC,Aer.get_backend('aer_simulator'),shots=10000)
counts = job.result().get_counts(QC)
print(counts)
plot_histogram(counts, figsize=(10, 2), color='midnightblue', title="New Histogram")
#aer_sim = Aer.get_backend('aer_simulator')
#qobj = assemble(had)
#result = aer_sim.run(qobj).result()
#counts = result.get_counts()
#plot_histogram(counts)
|
https://github.com/MuhammadMiqdadKhan/Quantum-Teleportation-Using-Qiskit-and-Real-Quantum-Computer-Tutorial
|
MuhammadMiqdadKhan
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical bits
crx = ClassicalRegister(1) # in 2 different registers
teleportation_circuit = QuantumCircuit(qr, crz, crx)
def create_bell_pair(qc, a, b):
"""Creates a bell pair in qc using qubits a & b"""
qc.h(a) # Put qubit a into state |+>
qc.cx(a,b) # CNOT with a as control and b as target
# In our case, Eve entangles qubits q1 and q2
# Let's apply this to our circuit:
create_bell_pair(teleportation_circuit, 1, 2)
# And view the circuit so far:
teleportation_circuit.draw()
def alice_gates(qc, psi, a):
qc.cx(psi, a)
qc.h(psi)
# Let's apply this to our circuit:
teleportation_circuit.barrier() # Use barrier to separate steps
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
"""Measures qubits a & b and 'sends' the results to Bob"""
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
measure_and_send(teleportation_circuit, 0 ,1)
teleportation_circuit.draw()
# This function takes a QuantumCircuit (qc), integer (qubit)
# and ClassicalRegisters (crz & crx) to decide which gates to apply
def bob_gates(qc, qubit, crz, crx):
# Here we use c_if to control our gates with a classical
# bit instead of a qubit
qc.z(qubit).c_if(crz, 1) # Apply gates if the registers
qc.x(qubit).c_if(crx, 1) # are in the state '1'
# Let's apply this to our circuit:
teleportation_circuit.barrier() # Use barrier to separate steps
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit_textbook.tools import random_state, vector2latex
# Create random 1-qubit state
psi = random_state(1)
# Display it nicely
vector2latex(psi, pretext="|\\psi\\rangle =")
# Show it on a Bloch sphere
plot_bloch_multivector(psi)
from qiskit.extensions import Initialize
init_gate = Initialize(psi)
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
# Need to add a new ClassicalRegister
# to see the result
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
# First, see what devices we are allowed to use by loading our saved accounts
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
# get the least-busy backend at IBM and run the quantum circuit there
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
# Get the results and display them
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
import qiskit
qiskit.__qiskit_version__
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import *
qc = QuantumCircuit(2)
qc.h(i)
qc.crz (PI/4, 0, 1)
|
https://github.com/mlvqc/Byskit
|
mlvqc
|
#initialization
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, assemble, transpile
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.providers.ibmq import least_busy
# import basic plot tools
from qiskit.visualization import plot_histogram
n = 2
grover_circuit = QuantumCircuit(n)
def initialize_s(qc, qubits):
"""Apply a H-gate to 'qubits' in qc"""
for q in qubits:
qc.h(q)
return qc
def diffuser(nqubits):
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
# We will return the diffuser as a gate
U_s = qc.to_gate()
U_s.name = "U$_s$"
return U_s
grover_circuit = initialize_s(grover_circuit, [0,1])
grover_circuit.draw(output="mpl")
grover_circuit.cz(0,1) # Oracle
grover_circuit.draw(output="mpl")
# Diffusion operator (U_s)
grover_circuit.append(diffuser(n),[0,1])
grover_circuit.draw(output="mpl")
sim = Aer.get_backend('aer_simulator')
# we need to make a copy of the circuit with the 'save_statevector'
# instruction to run on the Aer simulator
grover_circuit_sim = grover_circuit.copy()
grover_circuit_sim.save_statevector()
qobj = assemble(grover_circuit_sim)
result = sim.run(qobj).result()
statevec = result.get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
grover_circuit.measure_all()
aer_sim = Aer.get_backend('aer_simulator')
qobj = assemble(grover_circuit)
result = aer_sim.run(qobj).result()
counts = result.get_counts()
plot_histogram(counts)
nqubits = 4
qc = QuantumCircuit(nqubits)
# Apply transformation |s> -> |00..0> (H-gates)
for qubit in range(nqubits):
qc.h(qubit)
# Apply transformation |00..0> -> |11..1> (X-gates)
for qubit in range(nqubits):
qc.x(qubit)
qc.barrier()
# Do multi-controlled-Z gate
qc.h(nqubits-1)
qc.mct(list(range(nqubits-1)), nqubits-1) # multi-controlled-toffoli
qc.h(nqubits-1)
qc.barrier()
# Apply transformation |11..1> -> |00..0>
for qubit in range(nqubits):
qc.x(qubit)
# Apply transformation |00..0> -> |s>
for qubit in range(nqubits):
qc.h(qubit)
qc.draw(output="mpl")
from qiskit.circuit import classical_function, Int1
# define a classical function f(x): this returns 1 for the solutions of the problem
# in this case, the solutions are 1010 and 1100
@classical_function
def f(x1: Int1, x2: Int1, x3: Int1, x4: Int1) -> Int1:
return (x1 and not x2 and x3 and not x4) or (x1 and x2 and not x3 and not x4)
nqubits = 4
Uf = f.synth() # turn it into a circuit
oracle = QuantumCircuit(nqubits+1)
oracle.compose(Uf, inplace=True)
oracle.draw(output="mpl")
# We will return the diffuser as a gate
#U_f = oracle.to_gate()
# U_f.name = "U$_f$"
# return U_f
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
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 import RXGate, XGate, CXGate
XX = Operator([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
XX
XX.data
input_dim, output_dim = XX.dim
input_dim, output_dim
op = Operator(np.random.rand(2 ** 1, 2 ** 2))
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
op = Operator(np.random.rand(6, 6))
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
# Force input dimension to be (4,) rather than (2, 2)
op = Operator(np.random.rand(2 ** 1, 2 ** 2), input_dims=[4])
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
# Specify system is a qubit and qutrit
op = Operator(np.random.rand(6, 6),
input_dims=[2, 3], output_dims=[2, 3])
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
print('Dimension of input system 0:', op.input_dims([0]))
print('Dimension of input system 1:', op.input_dims([1]))
# Create an Operator from a Pauli object
pauliXX = Pauli('XX')
Operator(pauliXX)
# Create an Operator for a Gate object
Operator(CXGate())
# Create an operator from a parameterized Gate object
Operator(RXGate(np.pi / 2))
# Create an operator from a QuantumCircuit object
circ = QuantumCircuit(10)
circ.h(0)
for j in range(1, 10):
circ.cx(j-1, j)
# Convert circuit to an operator by implicit unitary simulation
Operator(circ)
# Create an operator
XX = Operator(Pauli('XX'))
# Add to a circuit
circ = QuantumCircuit(2, 2)
circ.append(XX, [0, 1])
circ.measure([0,1], [0,1])
circ.draw('mpl')
backend = BasicAer.get_backend('qasm_simulator')
circ = transpile(circ, backend, basis_gates=['u1','u2','u3','cx'])
job = backend.run(circ)
job.result().get_counts(0)
# Add to a circuit
circ2 = QuantumCircuit(2, 2)
circ2.append(Pauli('XX'), [0, 1])
circ2.measure([0,1], [0,1])
circ2.draw()
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.tensor(B)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.expand(B)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.compose(B)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.compose(B, front=True)
# Compose XZ with an 3-qubit identity operator
op = Operator(np.eye(2 ** 3))
XZ = Operator(Pauli('XZ'))
op.compose(XZ, qargs=[0, 2])
# Compose YX in front of the previous operator
op = Operator(np.eye(2 ** 3))
YX = Operator(Pauli('YX'))
op.compose(XZ, qargs=[0, 2], front=True)
XX = Operator(Pauli('XX'))
YY = Operator(Pauli('YY'))
ZZ = Operator(Pauli('ZZ'))
op = 0.5 * (XX + YY - 3 * ZZ)
op
op.is_unitary()
# Compose with a matrix passed as a list
Operator(np.eye(2)).compose([[0, 1], [1, 0]])
Operator(Pauli('X')) == Operator(XGate())
Operator(XGate()) == np.exp(1j * 0.5) * Operator(XGate())
# Two operators which differ only by phase
op_a = Operator(XGate())
op_b = np.exp(1j * 0.5) * Operator(XGate())
# Compute process fidelity
F = process_fidelity(op_a, op_b)
print('Process fidelity =', F)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
import numpy as np
from qiskit import BasicAer
from qiskit.tools.visualization import plot_histogram
from qiskit.aqua import QuantumInstance, run_algorithm
from qiskit.aqua.algorithms import Grover
from qiskit.aqua.components.oracles import LogicalExpressionOracle, TruthTableOracle
input_3sat = '''
c example DIMACS-CNF 3-SAT
p cnf 3 5
-1 -2 -3 0
1 -2 3 0
1 2 -3 0
1 -2 -3 0
-1 2 3 0
'''
oracle = LogicalExpressionOracle(input_3sat)
grover = Grover(oracle)
backend = BasicAer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024)
result = grover.run(quantum_instance)
print(result['result'])
plot_histogram(result['measurement'])
# Load our saved IBMQ accounts and get the ibmq_16_melbourne backend
from qiskit import IBMQ
IBMQ.load_account()
IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_16_melbourne')
from qiskit.compiler import transpile
# transpile the circuit for ibmq_16_melbourne
grover_compiled = transpile(result['circuit'], backend=backend, optimization_level=3)
print('gates = ', grover_compiled.count_ops())
print('depth = ', grover_compiled.depth())
import qiskit
qiskit.__qiskit_version__
|
https://github.com/mmetcalf14/Hamiltonian_Downfolding_IBM
|
mmetcalf14
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from qiskit import QuantumRegister, QuantumCircuit
import numpy as np
from qiskit.aqua.components.initial_states import InitialState
class Zero(InitialState):
"""A zero (null/vacuum) state."""
CONFIGURATION = {
'name': 'ZERO',
'description': 'Zero initial state',
'input_schema': {
'$schema': 'http://json-schema.org/schema#',
'id': 'zero_state_schema',
'type': 'object',
'properties': {
},
'additionalProperties': False
}
}
def __init__(self, num_qubits):
"""Constructor.
Args:
num_qubits (int): number of qubits.
"""
super().__init__()
self._num_qubits = num_qubits
def construct_circuit(self, mode, register=None):
"""
Construct the statevector of desired initial state.
Args:
mode (string): `vector` or `circuit`. The `vector` mode produces the vector.
While the `circuit` constructs the quantum circuit corresponding that
vector.
register (QuantumRegister): register for circuit construction.
Returns:
QuantumCircuit or numpy.ndarray: statevector.
Raises:
ValueError: when mode is not 'vector' or 'circuit'.
"""
if mode == 'vector':
return np.array([1.0] + [0.0] * (np.power(2, self._num_qubits) - 1))
elif mode == 'circuit':
if register is None:
register = QuantumRegister(self._num_qubits, name='q')
quantum_circuit = QuantumCircuit(register)
return quantum_circuit
else:
raise ValueError('Mode should be either "vector" or "circuit"')
|
https://github.com/Qottmann/Quantum-anomaly-detection
|
Qottmann
|
import sys
sys.path.insert(1, '..') # sets the import path to the parent folder
import time
import numpy as np
#import qiskit
#from qiskit.opflow import X,Z,I
#from qiskit.opflow.state_fns import StateFn, CircuitStateFn
#from qiskit.providers.aer import StatevectorSimulator, AerSimulator
#from qiskit.algorithms import VQE
#from qiskit.algorithms.optimizers import COBYLA, SLSQP, SPSA
import matplotlib.pyplot as plt
from scipy import sparse
import scipy.sparse.linalg.eigen.arpack as arp
#from modules.utils import *
from tenpy.networks.mps import MPS
from tenpy.models.hubbard import BoseHubbardChain
from tenpy.algorithms import dmrg
from tenpy.linalg import np_conserved
%matplotlib inline
def DMRG_EBH(L, V, t_list, chi_max=30, bc_MPS='infinite'):
model_params = dict(n_max=1, filling=0.5, bc_MPS=bc_MPS, t=t_list,
L=L, V=V, mu=0, conserve='N', verbose=0)
M = BoseHubbardChain(model_params)
vector=[]
for i in range(M.lat.N_sites):
if i%2:
vector.append(1)
else:
vector.append(0)
psi = MPS.from_product_state(M.lat.mps_sites(), vector, bc=M.lat.bc_MPS)
dmrg_params = {
'mixer': True,
'trunc_params': {
'chi_max': chi_max,
},
'max_E_err': 1.e-16,
'verbose': 0
}
info = dmrg.run(psi, M, dmrg_params)
return info['E'], psi
chi = 50
V_list = np.linspace(2,8,10)
deltat_list = np.linspace(-1,1,10)
L = 4
mu = 0
deltat = 0.5
site = 0
psi_array = []
for deltat in deltat_list:
print('deltat', deltat)
t_list = np.ones(L)
for i in range(len(t_list)):
t_list[i] -= deltat*(-1)**i
psi_0 = []
for V in V_list:
print('V', V)
E0, psi0 = DMRG_EBH(L, V, t_list, chi_max=chi)
psi_0 = np.append(psi_0, psi0)
psi_array.append(psi_0)
np.save('data/BH_MPS.npy', psi_array)
psi_array = np.load('data/BH_MPS.npy', allow_pickle=True)
ES_array = []
parity_array = []
dd_array = []
V_list = np.linspace(2,8,10)
deltat_list = np.linspace(-1,1,10)
for j,deltat in enumerate(deltat_list):
ES_list = []
parity_list = []
dd_list = []
psi_list = psi_array[j]
for i,V in enumerate(V_list):
psi = psi_list[i]
ES = np.exp(-np.array(psi.entanglement_spectrum()[2]))
dES = -np.sum(ES[::2])+np.sum(ES[1::2])
ES_list.append(dES)
dd = psi.expectation_value('dN')[2]
dd_list.append(dd)
dd_array.append(dd_list)
ES_array.append(ES_list)
V_list = np.linspace(2,8,10)
deltat_list = np.linspace(-1,1,10)
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(V_list, deltat_list, np.abs(dd_array), cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_title("density-density correlation",fontsize=20)
ax.set_xlabel(r"$V$",fontsize=24)
ax.set_ylabel(r"$\delta t$",fontsize=24)
ax.tick_params(labelsize=20)
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(V_list, deltat_list, np.abs(ES_array), cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_title("Degeneracy entanglement spectrum",fontsize=20)
ax.set_xlabel(r"$V$",fontsize=24)
ax.set_ylabel(r"$\delta t$",fontsize=24)
ax.tick_params(labelsize=20)
chi = 50
V_list = np.logspace(-2,2,10)
delta_listp= (1-np.logspace(-2,0,5))[::-1]
delta_listn = np.logspace(-2,0,5)-1
deltat_list = np.append(delta_listn, delta_listp)
#deltat_list = np.linspace(-0.95,0.95,10)
L = 10
mu = 0
site = 0
psi_array = []
for deltat in deltat_list:
print('deltat', deltat)
t_list = np.ones(L-1)
for i in range(len(t_list)):
t_list[i] -= deltat*(-1)**i
psi_0 = []
for V in V_list:
print('V', V)
E0, psi0 = DMRG_EBH(L, V, t_list, chi_max=chi, bc_MPS='finite')
psi_0 = np.append(psi_0, psi0)
psi_array.append(psi_0)
np.save('data/BH_MPS_L%.0f_logV_logDeltat.npy' %L, psi_array)
wf_array = []
V_array = []
deltat_array = []
for i, deltat in enumerate(deltat_list):
for j, V in enumerate(V_list):
psi = psi_array[i][j]
wf = psi.get_theta(0,L).to_ndarray().reshape(-1)
wf_array.append(wf)
V_array.append(V)
deltat_array.append(deltat)
np.savez(f'data/wf_BH_L%.0f_logV_logDeltat.npz' %(L), deltat_array=deltat_array, V_array=V_array, wf_array = wf_array)
L = 12
psi_array = np.load('../data/BH_MPS_L%.0f_logV_50x50.npy' %L, allow_pickle=True)
V_list = np.logspace(-2,2,50)
deltat_list = np.linspace(-0.95,0.95,50)
ES_array = []
parity_array = []
dd_array = []
for j,deltat in enumerate(deltat_list):
ES_list = []
parity_list = []
dd_list = []
psi_list = psi_array[j]
for i,V in enumerate(V_list):
psi = psi_list[i]
ES = np.exp(-np.array(psi.entanglement_spectrum()[int(L/2)+1]))
dES = -np.sum(ES[::2])+np.sum(ES[1::2])
ES_list.append(abs(dES))
dd = 0
for i,dd_el in enumerate(psi.expectation_value('dN')[:int(L/2)]):
dd += (-1)**i*dd_el
dd_list.append(dd/(L-6))
dd_array.append(dd_list)
ES_array.append(ES_list)
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(V_list, deltat_list, dd_array, cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_title("density-density correlation",fontsize=20)
ax.set_xlabel(r"$V$",fontsize=24)
ax.set_ylabel(r"$\delta t$",fontsize=24)
ax.tick_params(labelsize=20)
plt.xscale("log")
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(V_list, deltat_list, ES_array, cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_title("Degeneracy entanglement spectrum",fontsize=20)
ax.set_xlabel(r"$V$",fontsize=24)
ax.set_ylabel(r"$\delta t$",fontsize=24)
ax.tick_params(labelsize=20)
plt.xscale("log")
path = "../data/BH_phase-diagrams-and-loss/data_rike/"
np.save(path + "es2.npy", ES_array)
np.save(path + "dd2.npy", dd_array)
L = 12
psi_array = np.load('data/BH_MPS_L%.0f_logV_50x50.npy' %L, allow_pickle=True)
V_list = np.logspace(-2,2,50)
deltat_list = np.linspace(-0.95,0.95,50)
psi = psi_array[0][0]
plt.figure()
plt.ylim(-1,1)
plt.plot(psi.expectation_value('dN'), 'o-')
plt.title('V = %.2f, deltat= %.2f' %(V_list[0], deltat_list[0]))
psi = psi_array[49][0]
plt.figure()
plt.ylim(-1,1)
plt.plot(psi.expectation_value('dN'), 'o-')
plt.title('V = %.2f, deltat= %.2f' %(V_list[0], deltat_list[9]))
psi = psi_array[25][49]
plt.figure()
plt.ylim(-1,1)
plt.plot(psi.expectation_value('dN'), 'o-')
plt.title('V = %.2f, deltat= %.2f' %(V_list[9], deltat_list[5]))
L = 11
psi_array = np.load('data/BH_MPS_L%.0f_logV_25x25.npy' %L, allow_pickle=True)
V_list = np.logspace(-2,2,25)
deltat_list = np.linspace(-0.95,0.95,25)
ES_array = []
parity_array = []
dd_array = []
for j,deltat in enumerate(deltat_list):
ES_list = []
parity_list = []
dd_list = []
psi_list = psi_array[j]
for i,V in enumerate(V_list):
psi = psi_list[i]
ES = np.exp(-np.array(psi.entanglement_spectrum()[int(L/2)]))
dES = -np.sum(ES[::2])+np.sum(ES[1::2])
ES_list.append(dES)
dd = 0
for dd_el in psi.expectation_value('dN')[3:L-3]:
dd += (-1)**i*dd_el
#dd = np.sum(abs(psi.expectation_value('dN')[3:L-3]))
dd_list.append(dd)
dd_array.append(dd_list)
ES_array.append(ES_list)
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(V_list, deltat_list, np.abs(dd_array), cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_title("density-density correlation",fontsize=20)
ax.set_xlabel(r"$V$",fontsize=24)
ax.set_ylabel(r"$\delta t$",fontsize=24)
ax.tick_params(labelsize=20)
plt.xscale("log")
fig,ax = plt.subplots(figsize=(8,5))
cmap = plt.get_cmap("plasma") #'viridis'
im = ax.pcolormesh(V_list, deltat_list, np.abs(ES_array), cmap=cmap)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
ax.set_title("Degeneracy entanglement spectrum",fontsize=20)
ax.set_xlabel(r"$V$",fontsize=24)
ax.set_ylabel(r"$\delta t$",fontsize=24)
ax.tick_params(labelsize=20)
plt.xscale("log")
L = 11
psi_array = np.load('data/BH_MPS_L%.0f_logV_25x25.npy' %L, allow_pickle=True)
V_list = np.logspace(-2,2,25)
deltat_list = np.linspace(-0.95,0.95,25)
psi = psi_array[0][0]
plt.figure()
plt.ylim(-1,1)
plt.plot(psi.expectation_value('dN'), 'o-')
plt.title('V = %.2f, deltat= %.2f' %(V_list[0], deltat_list[0]))
psi = psi_array[24][0]
plt.figure()
plt.ylim(-1,1)
plt.plot(psi.expectation_value('dN'), 'o-')
plt.title('V = %.2f, deltat= %.2f' %(V_list[0], deltat_list[9]))
psi = psi_array[15][24]
plt.figure()
plt.ylim(-1,1)
plt.plot(psi.expectation_value('dN'), 'o-')
plt.title('V = %.2f, deltat= %.2f' %(V_list[9], deltat_list[5]))
|
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.
# pylint: disable=missing-function-docstring
"""
Tests for the default UnitarySynthesis transpiler pass.
"""
from test import combine
import unittest
import numpy as np
from ddt import ddt, data
from qiskit import transpile
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import FakeVigo, FakeMumbaiFractionalCX, FakeBelemV2
from qiskit.providers.fake_provider.fake_backend_v2 import FakeBackendV2, FakeBackend5QV2
from qiskit.circuit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.circuit.library import QuantumVolume
from qiskit.converters import circuit_to_dag, dag_to_circuit
from qiskit.transpiler.passes import UnitarySynthesis
from qiskit.quantum_info.operators import Operator
from qiskit.quantum_info.random import random_unitary
from qiskit.transpiler import PassManager, CouplingMap, Target, InstructionProperties
from qiskit.transpiler.exceptions import TranspilerError
from qiskit.exceptions import QiskitError
from qiskit.transpiler.passes import (
Collect2qBlocks,
ConsolidateBlocks,
Optimize1qGates,
SabreLayout,
Unroll3qOrMore,
CheckMap,
BarrierBeforeFinalMeasurements,
SabreSwap,
TrivialLayout,
)
from qiskit.circuit.library import (
IGate,
CXGate,
RZGate,
RXGate,
SXGate,
XGate,
iSwapGate,
ECRGate,
UGate,
ZGate,
RYYGate,
RZZGate,
RXXGate,
)
from qiskit.circuit import Measure
from qiskit.circuit.controlflow import IfElseOp
from qiskit.circuit import Parameter, Gate
@ddt
class TestUnitarySynthesis(QiskitTestCase):
"""Test UnitarySynthesis pass."""
def test_empty_basis_gates(self):
"""Verify when basis_gates is None, we do not synthesize unitaries."""
qc = QuantumCircuit(3)
op_1q = random_unitary(2, seed=0)
op_2q = random_unitary(4, seed=0)
op_3q = random_unitary(8, seed=0)
qc.unitary(op_1q.data, [0])
qc.unitary(op_2q.data, [0, 1])
qc.unitary(op_3q.data, [0, 1, 2])
out = UnitarySynthesis(basis_gates=None, min_qubits=2)(qc)
self.assertEqual(out.count_ops(), {"unitary": 3})
@data(
["u3", "cx"],
["u1", "u2", "u3", "cx"],
["rx", "ry", "rxx"],
["rx", "rz", "iswap"],
["u3", "rx", "rz", "cz", "iswap"],
)
def test_two_qubit_synthesis_to_basis(self, basis_gates):
"""Verify two qubit unitaries are synthesized to match basis gates."""
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell_op = Operator(bell)
qc = QuantumCircuit(2)
qc.unitary(bell_op, [0, 1])
dag = circuit_to_dag(qc)
out = UnitarySynthesis(basis_gates).run(dag)
self.assertTrue(set(out.count_ops()).issubset(basis_gates))
def test_two_qubit_synthesis_to_directional_cx_from_gate_errors(self):
"""Verify two qubit unitaries are synthesized to match basis gates."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap(conf.coupling_map)
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_swap_synthesis_to_directional_cx(self):
"""Verify two qubit unitaries are synthesized to match basis gates."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap(conf.coupling_map)
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.swap(qr[0], qr[1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_multiple_registers(self):
"""Verify two qubit unitaries are synthesized to match basis gates
across multiple registers."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr0 = QuantumRegister(1)
qr1 = QuantumRegister(1)
coupling_map = CouplingMap(conf.coupling_map)
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr0, qr1)
qc.unitary(random_unitary(4, seed=12), [qr0[0], qr1[0]])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=None,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_from_coupling_map(self):
"""Verify natural cx direction is used when specified in coupling map."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
# the decomposer defaults to the [1, 0] direction but the coupling
# map specifies a [0, 1] direction. Check that this is respected.
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
self.assertTrue(
all(((qr[0], qr[1]) == instr.qubits for instr in qc_out_nat.get_instructions("cx")))
)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_from_coupling_map_natural_none(self):
"""Verify natural cx direction is used when specified in coupling map
when natural_direction is None."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=None,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
# the decomposer defaults to the [1, 0] direction but the coupling
# map specifies a [0, 1] direction. Check that this is respected.
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
self.assertTrue(
all(((qr[0], qr[1]) == instr.qubits for instr in qc_out_nat.get_instructions("cx")))
)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_to_directional_cx_from_coupling_map_natural_false(self):
"""Verify natural cx direction is used when specified in coupling map
when natural_direction is None."""
# TODO: should make check more explicit e.g. explicitly set gate
# direction in test instead of using specific fake backend
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
unisynth_pass_nat = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=False,
)
pm_nat = PassManager([triv_layout_pass, unisynth_pass_nat])
qc_out_nat = pm_nat.run(qc)
# the decomposer defaults to the [1, 0] direction but the coupling
# map specifies a [0, 1] direction. Check that this is respected.
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
self.assertTrue(
all(((qr[1], qr[0]) == instr.qubits for instr in qc_out_nat.get_instructions("cx")))
)
self.assertEqual(Operator(qc), Operator(qc_out))
self.assertEqual(Operator(qc), Operator(qc_out_nat))
def test_two_qubit_synthesis_not_pulse_optimal(self):
"""Verify not attempting pulse optimal decomposition when pulse_optimize==False."""
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=False,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
if isinstance(qc_out, QuantumCircuit):
num_ops = qc_out.count_ops()
else:
num_ops = qc_out[0].count_ops()
self.assertIn("sx", num_ops)
self.assertGreaterEqual(num_ops["sx"], 16)
def test_two_qubit_pulse_optimal_true_raises(self):
"""Verify raises if pulse optimal==True but cx is not in the backend basis."""
backend = FakeVigo()
conf = backend.configuration()
# this assumes iswawp pulse optimal decomposition doesn't exist
conf.basis_gates = [gate if gate != "cx" else "iswap" for gate in conf.basis_gates]
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
with self.assertRaises(QiskitError):
pm.run(qc)
def test_two_qubit_natural_direction_true_duration_fallback(self):
"""Verify not attempting pulse optimal decomposition when pulse_optimize==False."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
# conf.basis_gates = [gate if gate != "cx" else "iswap" for gate in conf.basis_gates]
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 0], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
self.assertTrue(
all(((qr[0], qr[1]) == instr.qubits for instr in qc_out.get_instructions("cx")))
)
def test_two_qubit_natural_direction_true_gate_length_raises(self):
"""Verify not attempting pulse optimal decomposition when pulse_optimize==False."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
for _, nduv in backend.properties()._gates["cx"].items():
nduv["gate_length"] = (4e-7, nduv["gate_length"][1])
nduv["gate_error"] = (7e-3, nduv["gate_error"][1])
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 0], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
backend_props=backend.properties(),
pulse_optimize=True,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
with self.assertRaises(TranspilerError):
pm.run(qc)
def test_two_qubit_pulse_optimal_none_optimal(self):
"""Verify pulse optimal decomposition when pulse_optimize==None."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=None,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
qc_out = pm.run(qc)
if isinstance(qc_out, QuantumCircuit):
num_ops = qc_out.count_ops()
else:
num_ops = qc_out[0].count_ops()
self.assertIn("sx", num_ops)
self.assertLessEqual(num_ops["sx"], 12)
def test_two_qubit_pulse_optimal_none_no_raise(self):
"""Verify pulse optimal decomposition when pulse_optimize==None doesn't
raise when pulse optimal decomposition unknown."""
# this assumes iswawp pulse optimal decomposition doesn't exist
backend = FakeVigo()
conf = backend.configuration()
conf.basis_gates = [gate if gate != "cx" else "iswap" for gate in conf.basis_gates]
qr = QuantumRegister(2)
coupling_map = CouplingMap([[0, 1], [1, 2], [1, 3], [3, 4]])
triv_layout_pass = TrivialLayout(coupling_map)
qc = QuantumCircuit(qr)
qc.unitary(random_unitary(4, seed=12), [0, 1])
unisynth_pass = UnitarySynthesis(
basis_gates=conf.basis_gates,
coupling_map=coupling_map,
backend_props=backend.properties(),
pulse_optimize=None,
natural_direction=True,
)
pm = PassManager([triv_layout_pass, unisynth_pass])
try:
qc_out = pm.run(qc)
except QiskitError:
self.fail("pulse_optimize=None raised exception unexpectedly")
if isinstance(qc_out, QuantumCircuit):
num_ops = qc_out.count_ops()
else:
num_ops = qc_out[0].count_ops()
self.assertIn("sx", num_ops)
self.assertLessEqual(num_ops["sx"], 14)
def test_qv_natural(self):
"""check that quantum volume circuit compiles for natural direction"""
qv64 = QuantumVolume(5, seed=15)
def construct_passmanager(basis_gates, coupling_map, synthesis_fidelity, pulse_optimize):
seed = 2
_map = [SabreLayout(coupling_map, max_iterations=2, seed=seed)]
_unroll3q = Unroll3qOrMore()
_swap_check = CheckMap(coupling_map)
_swap = [
BarrierBeforeFinalMeasurements(),
SabreSwap(coupling_map, heuristic="lookahead", seed=seed),
]
_optimize = [
Collect2qBlocks(),
ConsolidateBlocks(basis_gates=basis_gates),
UnitarySynthesis(
basis_gates,
synthesis_fidelity,
coupling_map,
pulse_optimize=pulse_optimize,
natural_direction=True,
),
Optimize1qGates(basis_gates),
]
pm = PassManager()
pm.append(_map) # map to hardware by inserting swaps
pm.append(_unroll3q)
pm.append(_swap_check)
pm.append(_swap)
pm.append(_optimize)
return pm
coupling_map = CouplingMap([[0, 1], [1, 2], [3, 2], [3, 4], [5, 4]])
basis_gates = ["rz", "sx", "cx"]
pm1 = construct_passmanager(
basis_gates=basis_gates,
coupling_map=coupling_map,
synthesis_fidelity=0.99,
pulse_optimize=True,
)
pm2 = construct_passmanager(
basis_gates=basis_gates,
coupling_map=coupling_map,
synthesis_fidelity=0.99,
pulse_optimize=False,
)
qv64_1 = pm1.run(qv64.decompose())
qv64_2 = pm2.run(qv64.decompose())
edges = [list(edge) for edge in coupling_map.get_edges()]
self.assertTrue(
all(
[qv64_1.qubits.index(qubit) for qubit in instr.qubits] in edges
for instr in qv64_1.get_instructions("cx")
)
)
self.assertEqual(Operator(qv64_1), Operator(qv64_2))
@data(1, 2, 3)
def test_coupling_map_transpile(self, opt):
"""test natural_direction works with transpile/execute"""
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [0, 1])
circ_01 = transpile(
circ, basis_gates=["rz", "sx", "cx"], optimization_level=opt, coupling_map=[[0, 1]]
)
circ_10 = transpile(
circ, basis_gates=["rz", "sx", "cx"], optimization_level=opt, coupling_map=[[1, 0]]
)
circ_01_index = {qubit: index for index, qubit in enumerate(circ_01.qubits)}
circ_10_index = {qubit: index for index, qubit in enumerate(circ_10.qubits)}
self.assertTrue(
all(
(
(1, 0) == (circ_10_index[instr.qubits[0]], circ_10_index[instr.qubits[1]])
for instr in circ_10.get_instructions("cx")
)
)
)
self.assertTrue(
all(
(
(0, 1) == (circ_01_index[instr.qubits[0]], circ_01_index[instr.qubits[1]])
for instr in circ_01.get_instructions("cx")
)
)
)
@combine(
opt_level=[0, 1, 2, 3],
bidirectional=[True, False],
dsc=(
"test natural_direction works with transpile using opt_level {opt_level} on"
" target with multiple 2q gates with bidirectional={bidirectional}"
),
name="opt_level_{opt_level}_bidirectional_{bidirectional}",
)
def test_coupling_map_transpile_with_backendv2(self, opt_level, bidirectional):
backend = FakeBackend5QV2(bidirectional)
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [0, 1])
circ_01 = transpile(
circ, backend=backend, optimization_level=opt_level, layout_method="trivial"
)
circ_01_index = {qubit: index for index, qubit in enumerate(circ_01.qubits)}
self.assertGreaterEqual(len(circ_01.get_instructions("cx")), 1)
for instr in circ_01.get_instructions("cx"):
self.assertEqual(
(0, 1), (circ_01_index[instr.qubits[0]], circ_01_index[instr.qubits[1]])
)
@data(1, 2, 3)
def test_coupling_map_unequal_durations(self, opt):
"""Test direction with transpile/execute with backend durations."""
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
backend = FakeVigo()
tqc = transpile(
circ,
backend=backend,
optimization_level=opt,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertTrue(
all(
(
(0, 1) == (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]])
for instr in tqc.get_instructions("cx")
)
)
)
@combine(
opt_level=[0, 1, 2, 3],
bidirectional=[True, False],
dsc=(
"Test direction with transpile using opt_level {opt_level} on"
" target with multiple 2q gates with bidirectional={bidirectional}"
"direction [0, 1] is lower error and should be picked."
),
name="opt_level_{opt_level}_bidirectional_{bidirectional}",
)
def test_coupling_unequal_duration_with_backendv2(self, opt_level, bidirectional):
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
backend = FakeBackend5QV2(bidirectional)
tqc = transpile(
circ,
backend=backend,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("cx")), 1)
for instr in tqc.get_instructions("cx"):
self.assertEqual((0, 1), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
@combine(
opt_level=[0, 1, 2, 3],
dsc=(
"Test direction with transpile using opt_level {opt_level} on"
" target with multiple 2q gates"
),
name="opt_level_{opt_level}",
)
def test_non_overlapping_kak_gates_with_backendv2(self, opt_level):
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
backend = FakeBackendV2()
tqc = transpile(
circ,
backend=backend,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("ecr")), 1)
for instr in tqc.get_instructions("ecr"):
self.assertEqual((1, 0), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
def test_fractional_cx_with_backendv2(self):
"""Test fractional CX gets used if present in target."""
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [0, 1])
backend = FakeMumbaiFractionalCX()
synth_pass = UnitarySynthesis(target=backend.target)
tqc = synth_pass(circ)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("rzx")), 1)
for instr in tqc.get_instructions("rzx"):
self.assertEqual((0, 1), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
@combine(
opt_level=[0, 1, 2, 3],
dsc=(
"Test direction with transpile using opt_level {opt_level} on"
"target with multiple 2q gates available in reverse direction"
),
name="opt_level_{opt_level}",
)
def test_reverse_direction(self, opt_level):
target = Target(2)
target.add_instruction(CXGate(), {(0, 1): InstructionProperties(error=1.2e-6)})
target.add_instruction(ECRGate(), {(0, 1): InstructionProperties(error=1.2e-7)})
target.add_instruction(
UGate(Parameter("theta"), Parameter("phi"), Parameter("lam")), {(0,): None, (1,): None}
)
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
tqc = transpile(
circ,
target=target,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
tqc_index = {qubit: index for index, qubit in enumerate(tqc.qubits)}
self.assertGreaterEqual(len(tqc.get_instructions("ecr")), 1)
for instr in tqc.get_instructions("ecr"):
self.assertEqual((0, 1), (tqc_index[instr.qubits[0]], tqc_index[instr.qubits[1]]))
@combine(
opt_level=[0, 1, 2, 3],
dsc=("Test controlled but not supercontrolled basis"),
name="opt_level_{opt_level}",
)
def test_controlled_basis(self, opt_level):
target = Target(2)
target.add_instruction(RYYGate(np.pi / 8), {(0, 1): InstructionProperties(error=1.2e-6)})
target.add_instruction(
UGate(Parameter("theta"), Parameter("phi"), Parameter("lam")), {(0,): None, (1,): None}
)
qr = QuantumRegister(2)
circ = QuantumCircuit(qr)
circ.append(random_unitary(4, seed=1), [1, 0])
tqc = transpile(
circ,
target=target,
optimization_level=opt_level,
translation_method="synthesis",
layout_method="trivial",
)
self.assertGreaterEqual(len(tqc.get_instructions("ryy")), 1)
self.assertEqual(Operator(tqc), Operator(circ))
def test_approximation_controlled(self):
target = Target(2)
target.add_instruction(RZZGate(np.pi / 10), {(0, 1): InstructionProperties(error=0.006)})
target.add_instruction(RXXGate(np.pi / 3), {(0, 1): InstructionProperties(error=0.01)})
target.add_instruction(
UGate(Parameter("theta"), Parameter("phi"), Parameter("lam")),
{(0,): InstructionProperties(error=0.001), (1,): InstructionProperties(error=0.002)},
)
circ = QuantumCircuit(2)
circ.append(random_unitary(4, seed=7), [1, 0])
dag = circuit_to_dag(circ)
dag_100 = UnitarySynthesis(target=target, approximation_degree=1.0).run(dag)
dag_99 = UnitarySynthesis(target=target, approximation_degree=0.99).run(dag)
self.assertGreaterEqual(dag_100.depth(), dag_99.depth())
self.assertEqual(Operator(dag_to_circuit(dag_100)), Operator(circ))
def test_if_simple(self):
"""Test a simple if statement."""
basis_gates = {"u", "cx"}
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc_uni = QuantumCircuit(2)
qc_uni.h(0)
qc_uni.cx(0, 1)
qc_uni_mat = Operator(qc_uni)
qc_true_body = QuantumCircuit(2)
qc_true_body.unitary(qc_uni_mat, [0, 1])
qc = QuantumCircuit(qr, cr)
qc.if_test((cr, 1), qc_true_body, [0, 1], [])
dag = circuit_to_dag(qc)
cdag = UnitarySynthesis(basis_gates=basis_gates).run(dag)
cqc = dag_to_circuit(cdag)
cbody = cqc.data[0].operation.params[0]
self.assertEqual(cbody.count_ops().keys(), basis_gates)
self.assertEqual(qc_uni_mat, Operator(cbody))
def test_nested_control_flow(self):
"""Test unrolling nested control flow blocks."""
qr = QuantumRegister(2)
cr = ClassicalRegister(1)
qc_uni1 = QuantumCircuit(2)
qc_uni1.swap(0, 1)
qc_uni1_mat = Operator(qc_uni1)
qc = QuantumCircuit(qr, cr)
with qc.for_loop(range(3)):
with qc.while_loop((cr, 0)):
qc.unitary(qc_uni1_mat, [0, 1])
dag = circuit_to_dag(qc)
cdag = UnitarySynthesis(basis_gates=["u", "cx"]).run(dag)
cqc = dag_to_circuit(cdag)
cbody = cqc.data[0].operation.params[2].data[0].operation.params[0]
self.assertEqual(cbody.count_ops().keys(), {"u", "cx"})
self.assertEqual(qc_uni1_mat, Operator(cbody))
def test_mapping_control_flow(self):
"""Test that inner dags use proper qubit mapping."""
qr = QuantumRegister(3, "q")
qc = QuantumCircuit(qr)
# Create target that supports CX only between 0 and 2.
fake_target = Target()
fake_target.add_instruction(CXGate(), {(0, 2): None})
fake_target.add_instruction(
UGate(Parameter("t"), Parameter("p"), Parameter("l")),
{
(0,): None,
(1,): None,
(2,): None,
},
)
qc_uni1 = QuantumCircuit(2)
qc_uni1.swap(0, 1)
qc_uni1_mat = Operator(qc_uni1)
loop_body = QuantumCircuit(2)
loop_body.unitary(qc_uni1_mat, [0, 1])
# Loop body uses qubits 0 and 2, mapped to 0 and 1 in the block.
# If synthesis doesn't handle recursive mapping, it'll incorrectly
# look for a CX on (0, 1) instead of on (0, 2).
qc.for_loop((0,), None, loop_body, [0, 2], [])
dag = circuit_to_dag(qc)
UnitarySynthesis(basis_gates=["u", "cx"], target=fake_target).run(dag)
def test_single_qubit_with_target(self):
"""Test input circuit with only 1q works with target."""
qc = QuantumCircuit(1)
qc.append(ZGate(), [qc.qubits[0]])
dag = circuit_to_dag(qc)
unitary_synth_pass = UnitarySynthesis(target=FakeBelemV2().target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(qc, result_qc)
def test_single_qubit_identity_with_target(self):
"""Test input single qubit identity works with target."""
qc = QuantumCircuit(1)
qc.unitary([[1.0, 0.0], [0.0, 1.0]], 0)
dag = circuit_to_dag(qc)
unitary_synth_pass = UnitarySynthesis(target=FakeBelemV2().target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(result_qc, QuantumCircuit(1))
def test_unitary_synthesis_with_ideal_and_variable_width_ops(self):
"""Test unitary synthesis works with a target that contains ideal and variadic ops."""
qc = QuantumCircuit(2)
qc.unitary(np.eye(4), [0, 1])
dag = circuit_to_dag(qc)
target = FakeBelemV2().target
target.add_instruction(IfElseOp, name="if_else")
target.add_instruction(ZGate())
target.add_instruction(ECRGate())
unitary_synth_pass = UnitarySynthesis(target=target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(result_qc, QuantumCircuit(2))
def test_unitary_synthesis_custom_gate_target(self):
qc = QuantumCircuit(2)
qc.unitary(np.eye(4), [0, 1])
dag = circuit_to_dag(qc)
class CustomGate(Gate):
"""Custom Opaque Gate"""
def __init__(self):
super().__init__("custom", 2, [])
target = Target(num_qubits=2)
target.add_instruction(
UGate(Parameter("t"), Parameter("p"), Parameter("l")), {(0,): None, (1,): None}
)
target.add_instruction(CustomGate(), {(0, 1): None, (1, 0): None})
unitary_synth_pass = UnitarySynthesis(target=target)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertEqual(result_qc, qc)
def test_default_does_not_fail_on_no_syntheses(self):
qc = QuantumCircuit(1)
qc.unitary(np.eye(2), [0])
pass_ = UnitarySynthesis(["unknown", "gates"])
self.assertEqual(qc, pass_(qc))
def test_iswap_no_cx_synthesis_succeeds(self):
"""Test basis set with iswap but no cx can synthesize a circuit"""
target = Target()
theta = Parameter("theta")
i_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
}
target.add_instruction(IGate(), i_props)
rz_props = {
(0,): InstructionProperties(duration=0, error=0),
(1,): InstructionProperties(duration=0, error=0),
}
target.add_instruction(RZGate(theta), rz_props)
sx_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
}
target.add_instruction(SXGate(), sx_props)
x_props = {
(0,): InstructionProperties(duration=35.5e-9, error=0.000413),
(1,): InstructionProperties(duration=35.5e-9, error=0.000502),
}
target.add_instruction(XGate(), x_props)
iswap_props = {
(0, 1): InstructionProperties(duration=519.11e-9, error=0.01201),
(1, 0): InstructionProperties(duration=554.66e-9, error=0.01201),
}
target.add_instruction(iSwapGate(), iswap_props)
measure_props = {
(0,): InstructionProperties(duration=5.813e-6, error=0.0751),
(1,): InstructionProperties(duration=5.813e-6, error=0.0225),
}
target.add_instruction(Measure(), measure_props)
qc = QuantumCircuit(2)
cxmat = Operator(CXGate()).to_matrix()
qc.unitary(cxmat, [0, 1])
unitary_synth_pass = UnitarySynthesis(target=target)
dag = circuit_to_dag(qc)
result_dag = unitary_synth_pass.run(dag)
result_qc = dag_to_circuit(result_dag)
self.assertTrue(np.allclose(Operator(result_qc.to_gate()).to_matrix(), cxmat))
def test_parameterized_basis_gate_in_target(self):
"""Test synthesis with parameterized RXX gate."""
theta = Parameter("θ")
lam = Parameter("λ")
target = Target(num_qubits=2)
target.add_instruction(RZGate(lam))
target.add_instruction(RXGate(theta))
target.add_instruction(RXXGate(theta))
qc = QuantumCircuit(2)
qc.cp(np.pi / 2, 0, 1)
qc_transpiled = transpile(qc, target=target, optimization_level=3, seed_transpiler=42)
opcount = qc_transpiled.count_ops()
self.assertTrue(set(opcount).issubset({"rz", "rx", "rxx"}))
self.assertTrue(np.allclose(Operator(qc_transpiled), Operator(qc)))
if __name__ == "__main__":
unittest.main()
|
https://github.com/bibscore/qiskit_kindergarten
|
bibscore
|
import os
from qiskit import *
import qiskit.tools.visualization as qt
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from numpy import pi
import matplotlib.pyplot as plt
%matplotlib inline
qreg_q = QuantumRegister(2, 'q')
creg_c = ClassicalRegister(2, 'c')
circuits = []
for i in range(0, 4):
circuits.append(QuantumCircuit(qreg_q, creg_c))
circuits[0].reset(qreg_q[0])
circuits[0].reset(qreg_q[1])
circuits[0].cx(qreg_q[0], qreg_q[1])
circuits[0].measure(qreg_q[0], creg_c[0])
circuits[0].measure(qreg_q[1], creg_c[1])
circuits[0].draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
result00 = execute(circuits[0], backend = simulator, shots = 1).result()
counts00 = result00.get_counts()
print(counts00)
qt.plot_histogram(counts00, title="Histogram with the evaluating of |00> state under CNOT transformation")
circuits[1].reset(qreg_q[0])
circuits[1].x(qreg_q[1])
circuits[1].cx(qreg_q[0], qreg_q[1])
circuits[1].measure(qreg_q[0], creg_c[0])
circuits[1].measure(qreg_q[1], creg_c[1])
circuits[1].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result01 = execute(circuits[1], backend = simulator, shots = 1).result()
counts01 = result01.get_counts()
print(counts01)
qt.plot_histogram(counts01, title="Histogram with the evaluating of |01> state under CNOT transformation")
circuits[2].x(qreg_q[0])
circuits[2].reset(qreg_q[1])
circuits[2].cx(qreg_q[0], qreg_q[1])
circuits[2].measure(qreg_q[0], creg_c[0])
circuits[2].measure(qreg_q[1], creg_c[1])
circuits[2].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result10 = execute(circuits[2], backend = simulator, shots = 1).result()
counts10 = result10.get_counts()
print(counts10)
qt.plot_histogram(counts10, title="Histogram with the evaluating of |10> state under CNOT transformation")
circuits[3].x(qreg_q[0])
circuits[3].x(qreg_q[1])
circuits[3].cx(qreg_q[0], qreg_q[1])
circuits[3].measure(qreg_q[0], creg_c[0])
circuits[3].measure(qreg_q[1], creg_c[1])
circuits[3].draw(output="mpl")
simulator = Aer.get_backend('qasm_simulator')
result11 = execute(circuits[3], backend = simulator, shots = 1).result()
counts11 = result11.get_counts()
print(counts11)
qt.plot_histogram(counts11, title="Histogram with the evaluating of |11> state under CNOT transformation")
|
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import pulse
with pulse.build(name='my_example') as my_program:
# Add instructions here
pass
my_program
from qiskit.pulse import DriveChannel
channel = DriveChannel(0)
from qiskit.providers.fake_provider import FakeValencia
backend = FakeValencia()
with pulse.build(backend=backend, name='backend_aware') as backend_aware_program:
channel = pulse.drive_channel(0)
print(pulse.num_qubits())
# Raises an error as backend only has 5 qubits
#pulse.drive_channel(100)
with pulse.build(backend) as delay_5dt:
pulse.delay(5, channel)
from qiskit.pulse import library
amp = 1
sigma = 10
num_samples = 128
gaus = pulse.library.Gaussian(num_samples, amp, sigma,
name="Parametric Gaus")
gaus.draw()
import numpy as np
times = np.arange(num_samples)
gaussian_samples = np.exp(-1/2 *((times - num_samples / 2) ** 2 / sigma**2))
gaus = library.Waveform(gaussian_samples, name="WF Gaus")
gaus.draw()
gaus = library.gaussian(duration=num_samples, amp=amp, sigma=sigma, name="Lib Gaus")
gaus.draw()
with pulse.build() as schedule:
pulse.play(gaus, channel)
schedule.draw()
with pulse.build() as schedule:
pulse.play([0.001*i for i in range(160)], channel)
schedule.draw()
with pulse.build(backend) as schedule:
pulse.set_frequency(4.5e9, channel)
with pulse.build(backend) as schedule:
pulse.shift_phase(np.pi, channel)
from qiskit.pulse import Acquire, AcquireChannel, MemorySlot
with pulse.build(backend) as schedule:
pulse.acquire(1200, pulse.acquire_channel(0), MemorySlot(0))
with pulse.build(backend, name='Left align example') as program:
with pulse.align_left():
gaussian_pulse = library.gaussian(100, 0.5, 20)
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='Right align example') as program:
with pulse.align_right():
gaussian_pulse = library.gaussian(100, 0.5, 20)
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='example') as program:
gaussian_pulse = library.gaussian(100, 0.5, 20)
with pulse.align_equispaced(2*gaussian_pulse.duration):
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='example') as program:
with pulse.align_sequential():
gaussian_pulse = library.gaussian(100, 0.5, 20)
pulse.play(gaussian_pulse, pulse.drive_channel(0))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
pulse.play(gaussian_pulse, pulse.drive_channel(1))
program.draw()
with pulse.build(backend, name='Offset example') as program:
with pulse.phase_offset(3.14, pulse.drive_channel(0)):
pulse.play(gaussian_pulse, pulse.drive_channel(0))
with pulse.frequency_offset(10e6, pulse.drive_channel(0)):
pulse.play(gaussian_pulse, pulse.drive_channel(0))
program.draw()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/BoxiLi/qiskit-CR-calibration
|
BoxiLi
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(current_dir)
from quantum_circuit import QuantumCircuit
# import qiskit.providers.fake_provider
from qiskit.transpiler import CouplingMap
import qiskit_ibm_runtime.fake_provider
from Backend.backend import Backend
class FakeBackend(Backend):
def __init__(self, backend_name : str) -> None:
self.backend = FakeBackend.get_ibm_fake_backend(backend_name=backend_name)
@staticmethod
def get_ibm_fake_backend_name_list() -> list[str]:
ibm_dir = dir(qiskit_ibm_runtime.fake_provider)
return [val for val in ibm_dir if '__' not in val and 'Fake' in val]
@staticmethod
def get_ibm_fake_backend(backend_name : str):
try:
return getattr(qiskit_ibm_runtime.fake_provider, backend_name)()
except: pass
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
if backend.name == backend_name:
return backend
except: pass
return None
@staticmethod
def get_ibm_fake_backend_names_with_limit(min_qubit : int = 1, max_qubit: int = float('inf')) -> list[str]:
limited_backend = []
fake_backend_name = FakeBackend.get_ibm_fake_backend_name_list()
for backend in fake_backend_name:
backend = FakeBackend.get_ibm_fake_backend(backend)
if backend is not None:
try:
num_qubit = backend.num_qubits
if num_qubit >= min_qubit and num_qubit <= max_qubit:
limited_backend.append(backend.name)
except: pass
return limited_backend
if __name__ == "__main__":
print(FakeBackend.get_ibm_fake_backend_name_list())
backend = FakeBackend('fake_auckland')
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
qc.measure_all()
print(qc.draw())
job = backend.run(qc)
print(job.result())
qc_transpile = backend.traspile_qiskit(qc)[0]
print(qc_transpile.draw())
job = backend.run(qc_transpile)
print(job.result())
|
https://github.com/sarthag/Quantum-Algos-using-Qiskit
|
sarthag
|
import numpy as np
from numpy import pi
# importing Qiskit
from qiskit import QuantumCircuit, transpile, assemble, Aer
from qiskit.visualization import plot_histogram, plot_bloch_multivector
qc = QuantumCircuit(3)
qc.h(2)
qc.cp(pi/2, 1, 2)
qc.cp(pi/4, 0, 2)
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0, 2)
qc.draw()
def qft_rotations(circuit, n):
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
qc = QuantumCircuit(4)
qft(qc,4)
qc.draw()
# Create the circuit
qc = QuantumCircuit(3)
# Encode the state 5 (101 in binary)
qc.x(0)
qc.x(2)
qc.draw()
sim = Aer.get_backend("aer_simulator")
qc_init = qc.copy()
qc_init.save_statevector()
statevector = sim.run(qc_init).result().get_statevector()
plot_bloch_multivector(statevector)
qft(qc, 3)
qc.draw()
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
plot_bloch_multivector(statevector)
|
https://github.com/qcware/qusetta
|
qcware
|
import numpy as np
from qiskit.optimization.applications.ising.common import random_graph
np.random.seed(123)
num_nodes = 22
w = random_graph(num_nodes, edge_prob=0.8, weight_range=10)
from qiskit.optimization.applications.ising import vertex_cover
from qiskit.aqua.algorithms import QAOA
qubit_op, offset = vertex_cover.get_operator(w)
p = 10
qaoa = QAOA(qubit_op, p=p)
import qiskit
from typing import List
def create_qiskit_circuit(params: List[float]) -> qiskit.QuantumCircuit:
assert len(params) == 2 * p, "invalid number of angles"
return qaoa.var_form.construct_circuit(params)
import qusetta as qs
import cirq
def create_cirq_circuit(params: List[float]) -> cirq.Circuit:
qiskit_circuit = create_qiskit_circuit(params)
return qs.Qiskit.to_cirq(qiskit_circuit)
import quasar
def create_quasar_circuit(params: List[float]) -> quasar.Circuit:
qiskit_circuit = create_qiskit_circuit(params)
return qs.Qiskit.to_quasar(qiskit_circuit)
c = create_quasar_circuit([0.] * (2*p))
print("Number of qubits :", c.nqubit)
print("Number of gates :", c.ngate)
def expectation_value(statevector: np.ndarray) -> float:
# note that the second element (eg [1]) is the standard deviation
return offset + qubit_op.evaluate_with_statevector(statevector)[0].real
from qiskit.optimization.applications.ising.common import sample_most_likely
def get_size_cover(statevector: np.ndarray) -> int:
return int(sum(
vertex_cover.get_graph_solution(sample_most_likely(statevector))
))
from typing import Callable
import time
f_type = Callable[[List[float]], np.ndarray]
def info_decorator(function: f_type) -> f_type:
# `function` will be one of statevector_from_qiskit,
# statevector_from_quasar, statevector_from_cirq, or statevector_from_vulcan.
def f(params: List[float]) -> np.ndarray:
print('='*40)
print("Simulating with", function.__name__)
print('-'*40)
t0 = time.time()
statevector = function(params)
print("Time to completion : ", round(time.time() - t0, 2), "seconds")
print("Expectation value : ", round(expectation_value(statevector), 2))
print("Size of cover : ", get_size_cover(statevector))
print('='*40, "\n")
return statevector
return f
@info_decorator
def statevector_from_qiskit(params: List[float]) -> np.ndarray:
return qiskit.execute(
create_qiskit_circuit(params),
qiskit.BasicAer.get_backend('statevector_simulator')
).result().get_statevector()
@info_decorator
def statevector_from_cirq(params: List[float]) -> np.ndarray:
return cirq.Simulator(dtype=np.complex128).simulate(
create_cirq_circuit(params)
).final_state
@info_decorator
def statevector_from_quasar(params: List[float]) -> np.ndarray:
return quasar.QuasarSimulatorBackend().run_statevector(
circuit=create_quasar_circuit(params)
)
import qcware
from qcware.circuits.quasar_backend import QuasarBackend
qcware.config.set_api_key('Put your API key here!')
@info_decorator
def statevector_from_vulcan(params: List[float]) -> np.ndarray:
return QuasarBackend("vulcan/simulator").run_statevector(
circuit=create_quasar_circuit(params)
)
params = list(np.random.random(2*p) * np.pi)
qiskit_statevector = statevector_from_qiskit(params)
cirq_statevector = statevector_from_cirq(params)
quasar_statevector = statevector_from_quasar(params)
vulcan_statevector = statev
ector_from_vulcan(params)
# check that probability vectors are the same
np.testing.assert_allclose(np.abs(qiskit_statevector)**2, np.abs(quasar_statevector)**2)
np.testing.assert_allclose(np.abs(cirq_statevector)**2, np.abs(quasar_statevector)**2)
np.testing.assert_allclose(np.abs(vulcan_statevector)**2, np.abs(quasar_statevector)**2)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_aer.utils import approximate_quantum_error, approximate_noise_model
import numpy as np
# Import Aer QuantumError functions that will be used
from qiskit_aer.noise import amplitude_damping_error, reset_error, pauli_error
from qiskit.quantum_info import Kraus
gamma = 0.23
error = amplitude_damping_error(gamma)
results = approximate_quantum_error(error, operator_string="reset")
print(results)
p = (1 + gamma - np.sqrt(1 - gamma)) / 2
q = 0
print("")
print("Expected results:")
print("P(0) = {}".format(1-(p+q)))
print("P(1) = {}".format(p))
print("P(2) = {}".format(q))
gamma = 0.23
K0 = np.array([[1,0],[0,np.sqrt(1-gamma)]])
K1 = np.array([[0,np.sqrt(gamma)],[0,0]])
results = approximate_quantum_error(Kraus([K0, K1]), operator_string="reset")
print(results)
reset_to_0 = Kraus([np.array([[1,0],[0,0]]), np.array([[0,1],[0,0]])])
reset_to_1 = Kraus([np.array([[0,0],[1,0]]), np.array([[0,0],[0,1]])])
reset_kraus = [reset_to_0, reset_to_1]
gamma = 0.23
error = amplitude_damping_error(gamma)
results = approximate_quantum_error(error, operator_list=reset_kraus)
print(results)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/dimple12M/Qiskit-Certification-Guide
|
dimple12M
|
from qiskit import QuantumCircuit,Aer,execute,transpile,BasicAer
from qiskit.visualization import *
import numpy as np
qc = QuantumCircuit(1)
qc.initialize([1/np.sqrt(2), -1/np.sqrt(2)], 0)
qc.draw(output="mpl")
backend=Aer.get_backend('statevector_simulator')
job=execute(qc,backend,shots=1024)
result=job.result()
sv=result.get_statevector()
sv.draw(output="latex")
print(sv)
plot_state_qsphere(sv,show_state_phases=True)
qc = QuantumCircuit(1)
qc.x(0)
qc.h(0)
qc.draw(output="mpl")
backend=Aer.get_backend('statevector_simulator')
job=execute(qc,backend,shots=1024)
result=job.result()
sv=result.get_statevector()
sv.draw(output="latex")
qc = QuantumCircuit(2)
qc.initialize('01', qc.qubits)
qc.draw(output="mpl")
backend = BasicAer.get_backend('statevector_simulator')
job = backend.run(transpile(qc, backend))
qc_state = job.result().get_statevector(qc)
qc_state
array_to_latex(qc_state)
qc = QuantumCircuit(2)
qc.x(0)
qc.draw(output="mpl")
backend=Aer.get_backend('statevector_simulator')
job=execute(qc,backend,shots=1024)
result=job.result()
sv=result.get_statevector()
sv.draw(output="latex")
qc = QuantumCircuit(2)
qc.initialize([0, 1/np.sqrt(2), -1.j/np.sqrt(2), 0], qc.qubits)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
job = backend.run(transpile(qc, backend))
qc_state = job.result().get_statevector(qc)
qc_state
array_to_latex(qc_state)
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
qc.cx(0,1)
qc.sdg(1)
qc.draw(output="mpl")
backend=Aer.get_backend('statevector_simulator')
job=execute(qc,backend,shots=1024)
result=job.result()
sv=result.get_statevector()
sv.draw(output="latex")
|
https://github.com/yaelbh/qiskit-sympy-provider
|
yaelbh
|
# -*- coding: utf-8 -*-
# Copyright 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
"""
Example showing how to use the Sympy Provider at level 1 (intermediate).
This example shows how an intermediate user interacts with the Sympy Provider. It builds some circuits
and compiles them. It makes a qobj object which is just a container to be
run on a backend. The same qobj can run on many backends (as shown). It is the
user responsibility to make sure it can be run. This is useful when you want to compare the same
circuits on different backends or change the compile parameters.
"""
import time
# Import the Qiskit modules
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import compile
from qiskit_addon_sympy import SympyProvider
SyQ = SympyProvider()
# Create a quantum and classical register.
qubit_reg = QuantumRegister(2, name='q')
clbit_reg = ClassicalRegister(2, name='c')
# Making first circuit: Bell state
qc1 = QuantumCircuit(qubit_reg, clbit_reg, name="bell")
qc1.h(qubit_reg[0])
qc1.cx(qubit_reg[0], qubit_reg[1])
# Making another circuit: superpositions
qc2 = QuantumCircuit(qubit_reg, clbit_reg, name="superposition")
qc2.h(qubit_reg)
# Setting up the backend
print("(Sympy Backends)")
for backend in SyQ.backends():
print(backend.status())
statevector_backend = SyQ.get_backend('statevector_simulator')
unitary_backend = SyQ.get_backend('unitary_simulator')
# Compiling the qobj for the statevector backend
qobj = compile([qc1, qc2], backend=statevector_backend)
# Running the both backends on the same qobj
statevector_job = statevector_backend.run(qobj)
unitary_job = unitary_backend.run(qobj)
lapse = 0
interval = 0.01
while statevector_job.status().name != 'DONE' or unitary_job.status().name != 'DONE':
print('Status at {} milliseconds'.format(1000 * interval * lapse))
print("Stevector simulator: ", statevector_job.status())
print("Unitary simulator: ", unitary_job.status())
time.sleep(interval)
lapse += 1
print(statevector_job.status())
print(unitary_job.status())
statevector_result = statevector_job.result()
unitary_result = unitary_job.result()
# Show the results
print("Stevector simulator: ", statevector_result)
print(statevector_result.get_statevector(qc1))
print(statevector_result.get_statevector(qc2))
print("Unitary simulator: ", unitary_result)
print(unitary_result.get_unitary(qc1))
print(unitary_result.get_unitary(qc2))
|
https://github.com/iasebsil83/Grozzle
|
iasebsil83
|
#!/usr/bin/python3
# ---------------- IMPORTATIONS ----------------
#quantum lib
import qiskit as q
# ---------------- CLASS ----------------
class Qomputer:
#initialization
def __init__(self, qbit_nbr, measure_nbr):
self.simulator = q.Aer.get_backend('qasm_simulator')
self.circuit = q.QuantumCircuit(qbit_nbr, measure_nbr)
#console display
def showCircuit(self):
print( self.circuit.draw(output='text') )
#execution
def run(self, shots):
raw_results = q.execute(
self.circuit,
self.simulator,
shots=shots
).result().get_counts(
self.circuit
)
#format results
results = []
for r in raw_results:
results.append( raw_results[r] )
return results
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
This module contains the definition of a base class for quantum fourier transforms.
"""
from abc import abstractmethod
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.aqua import Pluggable, AquaError
class QFT(Pluggable):
"""Base class for QFT.
This method should initialize the module and its configuration, and
use an exception if a component of the module is
available.
Args:
configuration (dict): configuration dictionary
"""
@abstractmethod
def __init__(self, *args, **kwargs):
super().__init__()
@classmethod
def init_params(cls, params):
qft_params = params.get(Pluggable.SECTION_KEY_QFT)
kwargs = {k: v for k, v in qft_params.items() if k != 'name'}
return cls(**kwargs)
@abstractmethod
def _build_matrix(self):
raise NotImplementedError
@abstractmethod
def _build_circuit(self, qubits=None, circuit=None, do_swaps=True):
raise NotImplementedError
def construct_circuit(self, mode='circuit', qubits=None, circuit=None, do_swaps=True):
"""Construct the circuit.
Args:
mode (str): 'matrix' or 'circuit'
qubits (QuantumRegister or qubits): register or qubits to build the circuit on.
circuit (QuantumCircuit): circuit for construction.
do_swaps (bool): include the swaps.
Returns:
The matrix or circuit depending on the specified mode.
"""
if mode == 'circuit':
return self._build_circuit(qubits=qubits, circuit=circuit, do_swaps=do_swaps)
elif mode == 'matrix':
return self._build_matrix()
else:
raise AquaError('Unrecognized mode: {}.'.format(mode))
|
https://github.com/abbarreto/qiskit2
|
abbarreto
|
%run init.ipynb
from qiskit import *
nshots = 8192
IBMQ.load_account()
provider = IBMQ.get_provider(hub = 'ibm-q-research-2', group = 'federal-uni-sant-1', project = 'main')
device = provider.get_backend('ibm_nairobi')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor, backend_overview, backend_monitor
from qiskit.tools.visualization import plot_histogram
q0 = QuantumRegister(1); q1 = QuantumRegister(1); q2 = QuantumRegister(1); q3 = QuantumRegister(1)
c0 = ClassicalRegister(1); c1 = ClassicalRegister(1); c2 = ClassicalRegister(1); c3 = ClassicalRegister(1)
qc = QuantumCircuit(q0,q1,q2,q3,c0,c1,c2,c3)
# q0 e q1 estao com Alice, q2 com Charlies e q3 com Bob
qc.h(q1); qc.cx(q1,q2); qc.cx(q2,q3) # prepara o estado GHZ
qc.barrier()
#qc.sdg(q0); qc.h(q0) # prepara o estado a ser teletransportado (y+)
# prepara o estado |0>
qc.barrier()
qc.cx(q0,q1); qc.h(q0); qc.measure(q0,c0); qc.measure(q1,c1) # Medida de Alice na base de Bell
qc.h(q2); qc.measure(q2,c2) # medida de Charlie na base +,-
qc.barrier()
qc.z(q3).c_if(c0, 1) # acao de Bob condicionada no 1º cbit enviado por Alice
qc.x(q3).c_if(c1, 1) # acao de Bob condicionada no 2º cbit enviado por Alice
qc.z(q3).c_if(c2, 1) # acao de Bob condicionada no cbit enviado por Charlie
qc.barrier()
#qc.sdg(q3); qc.h(q3); qc.measure(q3,c3) # passa da base circular pra computacional
qc.measure(q3,c3) # mede na base computacional
qc.draw(output='mpl')
jobS = execute(qc, backend = simulator, shots = nshots)
plot_histogram(jobS.result().get_counts(qc))
jobE = execute(qc, backend = device, shots = nshots)
job_monitor(jobE)
tqc = transpile(qc, device)
jobE = device.run(tqc)
job_monitor(jobE)
plot_histogram([jobS.result().get_counts(0), jobE.result().get_counts(0)],
bar_labels = False, legend = ['sim', 'exp'])
|
https://github.com/anpaschool/QC-School-Fall2020
|
anpaschool
|
#An attempt by N Malakar
#Aug 27, 2020
# Thanks QC class, Especially Shree and Sovit
#References: https://github.com/anpaschool/QC-School-Fall2020/blob/master/Tuesday-Formal/Lecture2-QC-Fall2020.ipynb
#https://qiskit.org/textbook/ch-states/representing-qubit-states.html
from qiskit import QuantumCircuit, execute,QuantumCircuit, ClassicalRegister, QuantumRegister, Aer
from qiskit.visualization import plot_histogram, plot_bloch_vector, plot_bloch_multivector,plot_state_qsphere
from math import sqrt, pi
import numpy as np
%matplotlib inline
qc = QuantumCircuit(1) # Create a quantum circuit with one qubit
initial_state = [0,1] # Define initial_state as |1>
qc.initialize(initial_state, 0) # Apply initialisation operation to the 0th qubit
qc.draw('text') # Let's view our circuit (text drawing is required for the 'Initialize' gate due to a known bug in qiskit)
backend = Aer.get_backend('statevector_simulator') # Tell Qiskit how to simulate our circuit
job = execute(qc,backend).result() # Do the simulation, returning the state vector
print(job.get_statevector())
out_state = job.get_statevector()
qc.measure_all()
qc.draw('text')
result = execute(qc,backend).result()
counts = result.get_counts()
plot_histogram(counts)
#print(out_state) # Display the output state vector
#plot_bloch_multivector(job.get_statevector()) # Display the output state vector
initial_state = [1/sqrt(2), 1j/sqrt(2)] # Define state |q>
qc = QuantumCircuit(1) # Must redefine qc
qc.initialize(initial_state, 0) # Initialise the 0th qubit in the state `initial_state`
qc.draw('text')
state = execute(qc,backend).result().get_statevector() # Execute the circuit
print(state) # Print the result
#-------------
results = execute(qc,backend).result().get_counts()
plot_histogram(results)
state = execute(qc, backend).result().get_statevector()
print("Qubit State = " + str(state))
qc.measure_all()
qc.draw('text')
# Installed https://github.com/qiskit-community/qiskit-textbookpip
# install ./qiskit-textbook-src
from qiskit_textbook.widgets import plot_bloch_vector_spherical
coords = [0,pi/2,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
#Use plot_bloch_vector() or plot_bloch_sphere_spherical() to plot a qubit in the states: |0>
coords = [0,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
#or, use plot_bloch_vector
from qiskit.visualization import plot_bloch_vector
%matplotlib inline
plot_bloch_vector([0,0,1], title="This is $|0>$")
coords = [ pi ,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
#alternatively,
plot_bloch_vector([0,0,-1], title="This is $|1>$")
# the theta is pi/2, phi is 0, r is 1
coords = [ pi/2 ,0,1] # [Theta, Phi, Radius]
plot_bloch_vector_spherical(coords) # Bloch Vector with spherical coordinates
#plot_bloch_vector([1 ,0 ,0] , title="This is $|1>$") ???
# the multivector plot is having issues in this version...see https://github.com/Qiskit/qiskit-terra/issues/4982
# https://qiskit.org/documentation/stubs/qiskit.visualization.plot_bloch_multivector.html#qiskit.visualization.plot_bloch_multivector
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import io
import numpy as np
from numpy import pi
import pydot
from PIL import Image
import retworkx as rx
from qiskit import IBMQ, QuantumRegister, ClassicalRegister, QuantumCircuit, transpile
from qiskit.test.mock import FakeManhattan
def create_qaoa_circuit() -> QuantumCircuit:
""" taken from IBMQ Experience """
qreg_q = QuantumRegister(3, 'q')
circuit = QuantumCircuit(qreg_q)
circuit.h(qreg_q[0])
circuit.h(qreg_q[1])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.rz(-0.06942544294642758, qreg_q[0])
circuit.cx(qreg_q[1], qreg_q[0])
circuit.rz(-0.20827632883928274, qreg_q[0])
circuit.rx(0.7530122052855767, qreg_q[0])
circuit.h(qreg_q[2])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.rz(1.2496579730356965, qreg_q[1])
circuit.cx(qreg_q[2], qreg_q[1])
circuit.rz(-0.20827632883928274, qreg_q[1])
circuit.rx(0.7530122052855767, qreg_q[1])
circuit.rx(0.7530122052855767, qreg_q[2])
return circuit
# transpile circuit for ibmq_manhattan
device = FakeManhattan()
conf = device.configuration()
print(conf.basis_gates)
qc = create_qaoa_circuit()
circuit_transpiled = transpile(qc, backend=device, optimization_level=3)
circuit_transpiled.draw(output='mpl')
graph = rx.PyGraph(multigraph=False)
coupling_map = [tuple(edge) for edge in conf.coupling_map]
graph.add_nodes_from([i for i in range(65)])
graph.add_edges_from_no_data(coupling_map)
circuit_nodes = [19, 20, 21]
neighbor_nodes = [12, 18, 22, 25]
def node_attr(node):
kwargs = dict(style='filled', shape="circle", fontsize="14", fixedsize="true", width="0.4", height="0.4")
if node in circuit_nodes:
kwargs.update(fillcolor='green')
elif node in neighbor_nodes:
kwargs.update(fillcolor='lightblue', label="")
else:
kwargs.update(fillcolor='darkblue', label="")
return kwargs
dot_str = graph.to_dot(node_attr)
dot = pydot.graph_from_dot_data(dot_str)[0]
png = dot.create_png(prog='neato')
Image.open(io.BytesIO(png))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Clifford, random_clifford
qc = QuantumCircuit(3)
cliff = random_clifford(2)
qc.append(cliff, [0, 1])
qc.ccx(0, 1, 2)
qc.draw('mpl')
|
https://github.com/unif2/Quantum-Computing-Mentorship-Task-4-Code
|
unif2
|
import numpy as np
from numpy import kron
import qiskit as qk
def decomposition(H):
"""Decompose any 4x4 Hermitian matrix into a sum of tensor products of two Pauli matrices
"""
identity = np.array([[1, 0],[ 0, 1]], dtype=np.complex128)
x = np.array([[0, 1], [ 1, 0]], dtype=np.complex128)
y = np.array([[0, -1j],[1j, 0]], dtype=np.complex128)
z = np.array([[1, 0], [0, -1]], dtype=np.complex128)
S = [identity, x, y, z]
labels = ['I', 'sigma_x', 'sigma_y', 'sigma_z']
d = {'00': 'I product I', '01': 'I product sigma_x', '02': 'I product sigma_y', '03': 'I product sigma_z',
'10': 'sigma_x product I', '11': 'sigma_x product sigma_x', '12': 'sigma_x product sigma_y',
'13': 'sigma_x product sigma_z', '20': 'sigma_y product I', '21': 'sigma_y product sigma_x',
'22': 'sigma_y product sigma_y', '23': 'sigma_y product sigma_z', '30': 'sigma_z product I',
'31': 'sigma_z product sigma_x', '32': 'sigma_z product sigma_y', '33': 'sigma_z product sigma_z'}
for i in range(4):
for j in range(4):
a_ij = 0.25 * np.dot(kron(S[i], S[j]), H).trace()
if a_ij != 0.0:
print(str(a_ij) + ' * ' + d[str(i)+str(j)])
H = np.array([[0,0,0,0],[0,-1,1,0],[0,1,-1,0],[0,0,0,0]])
decomposition(H)
def prepare_state(theta, n=3):
"""
Prepare three 2-qubit states with 3 associated quantum registers, 3 associated classical registers,
and 3 quantum circuits. We will prepare the state with the ansatz mentioned in the notes in which we act on
the first qubit with the Hadamard operator, then with the R_z operator, then we act on the 2-qubit state
with the CNOT gate, and then on the second qubit in each terms of the superposition with the sigma_x operator.
After that, we will take the first circuit and act on each qubit with the R_y(pi/2) operator, and take the second
circuit and act on each qubit with the R_x(-pi/2) operator as explained in the notes. We do this so that those
qubits will be in the basis of eigenvectors of sigma_x and sigma_y as explained in the notes. We can measure
the qubits in the other circuit as-is because we need the expectation value of sigma_z and the qubits are already
in the computational basis.
"""
qr0 = qk.QuantumRegister(2)
cr0 = qk.ClassicalRegister(2)
qc0 = qk.QuantumCircuit(qr0,cr0)
qr1 = qk.QuantumRegister(2)
cr1 = qk.ClassicalRegister(2)
qc1 = qk.QuantumCircuit(qr1,cr1)
qr2 = qk.QuantumRegister(2)
cr2 = qk.ClassicalRegister(2)
qc2 = qk.QuantumCircuit(qr2,cr2)
qregisters = [qr0,qr1,qr2]
cregisters = [cr0,cr1,cr2]
qcircuits = [qc0,qc1,qc2]
for i in range(n):
qcircuits[i].h(qregisters[i][0])
for i in range(n):
qcircuits[i].rz(theta, qregisters[i][0])
for i in range(n):
qcircuits[i].cx(qregisters[i][0], qregisters[i][1])
for i in range(n):
qcircuits[i].x(qregisters[i][1])
qcircuits[0].ry((np.pi)/2, qregisters[0][0])
qcircuits[0].ry((np.pi)/2, qregisters[0][1])
qcircuits[1].rx(-(np.pi)/2, qregisters[1][0])
qcircuits[1].rx(-(np.pi)/2, qregisters[1][1])
return qregisters, cregisters, qcircuits
qregisters, cregisters, qcircuits = prepare_state(np.pi, n=3)
qcircuits[0].draw(output='mpl')
qcircuits[1].draw(output='mpl')
qcircuits[2].draw(output='mpl')
def expectation(qcircuits, cregisters, qregisters, n_shots, n=3):
"""
For each circuit, execute and measure it using the classical simulator 5000 times as explained above. Multiply
each of the three expectation values by 0.5, add them up, and subtract -0.5. Return the result.
"""
expect = -0.5
for i in range(n):
qcircuits[i].measure(qregisters[i],cregisters[i])
qk.Aer.backends()
sim = qk.Aer.get_backend('qasm_simulator')
res = qk.execute(qcircuits[i], sim, shots=n_shots).result()
counts = res.get_counts()
sum = 0
for k,v in counts.items():
if k=='01' or k=='10':
sum += (-1)*v/n_shots
elif k=='00' or k=='11':
sum += v/n_shots
sum = 0.5*sum
expect += sum
return expect
# Consider 100 values of theta, between 0 and Pi. This theta is the one used in state preparation.
thetas = np.linspace(0, np.pi, 100)
# For each theta, store the resulting expectation value in results
results = []
# For each theta, find the expectation value
for theta in thetas:
qregisters, cregisters, qcircuits = prepare_state(theta, n=3)
expect = expectation(qcircuits, cregisters, qregisters, 5000, n=3)
results.append(expect)
# Sort the results in ascending order. The first one is your minimum eigenvalue.
results.sort()
print("The minimum eigenvalue is: {}.".format(results[0]))
from qiskit import IBMQ
#IBMQ.delete_account()
IBMQ.save_account('my IBM token', overwrite=True)
IBMQ.load_account()
provider = IBMQ.get_provider()
procs=provider.backends(operational=True, simulator=False)
from qiskit.tools.jupyter import *
%qiskit_backend_overview
from qiskit.tools import monitor
backend = qk.providers.ibmq.least_busy([p for p in procs if len(p.properties().qubits) >= 2])
from qiskit.tools.monitor import backend_overview, backend_monitor
backend_monitor(backend)
def q_expectation(qcircuits, cregisters, qregisters, n_shots, n=3):
"""
For each circuit, execute and measure it using the classical simulator 5000 times as explained above. Multiply
each of the three expectation values by 0.5, add them up, and subtract -0.5. Return the result.
"""
expect = -0.5
for i in range(n):
qcircuits[i].measure(qregisters[i],cregisters[i])
qk.Aer.backends()
sim = qk.Aer.get_backend('qasm_simulator')
res = qk.execute(qcircuits[i], backend=backend, shots=n_shots).result()
#mon = monitor.job_monitor(res)
counts = res.get_counts()
sum = 0
for k,v in counts.items():
if k=='01' or k=='10':
sum += (-1)*v/n_shots
elif k=='00' or k=='11':
sum += v/n_shots
sum = 0.5*sum
expect += sum
return expect
# Consider 10 values of theta, between 0 and Pi. This theta is the one used in state preparation.
thetas = np.linspace(0, np.pi, 10)
# Use n_shots = 100
results = []
# For each theta, find the expectation value
for theta in thetas:
qregisters, cregisters, qcircuits = prepare_state(theta, n=3)
expect = q_expectation(qcircuits, cregisters, qregisters, 100, n=3)
results.append(expect)
# Sort the results in ascending order. The first one is your minimum eigenvalue.
results.sort()
print("The minimum eigenvalue is: {}.".format(results[0]))
# Use n_shots = 1000
results = []
# For each theta, find the expectation value
for theta in thetas:
qregisters, cregisters, qcircuits = prepare_state(theta, n=3)
expect = q_expectation(qcircuits, cregisters, qregisters, 1000, n=3)
results.append(expect)
# Sort the results in ascending order. The first one is your minimum eigenvalue.
results.sort()
print("The minimum eigenvalue is: {}.".format(results[0]))
# Use n_shots = 5000
results = []
# For each theta, find the expectation value
for theta in thetas:
qregisters, cregisters, qcircuits = prepare_state(theta, n=3)
expect = q_expectation(qcircuits, cregisters, qregisters, 5000, n=3)
results.append(expect)
# Sort the results in ascending order. The first one is your minimum eigenvalue.
results.sort()
print("The minimum eigenvalue is: {}.".format(results[0]))
# Use n_shots = 8192 = max allowed
results = []
thetas = [np.pi]
# For each theta, find the expectation value
for theta in thetas:
qregisters, cregisters, qcircuits = prepare_state(theta, n=3)
expect = q_expectation(qcircuits, cregisters, qregisters, 8192, n=3)
results.append(expect)
# Sort the results in ascending order. The first one is your minimum eigenvalue.
results.sort()
print("The minimum eigenvalue is: {}.".format(results[0]))
def decomposition(H):
"""Decompose any 4x4 Hermitian matrix into a sum of tensor products of two Pauli matrices
"""
A_ij = []
identity = np.array([[1, 0],[ 0, 1]], dtype=np.complex128)
x = np.array([[0, 1], [ 1, 0]], dtype=np.complex128)
y = np.array([[0, -1j],[1j, 0]], dtype=np.complex128)
z = np.array([[1, 0], [0, -1]], dtype=np.complex128)
S = [identity, x, y, z]
labels = ['I', 'sigma_x', 'sigma_y', 'sigma_z']
d = {'00': 'I product I', '01': 'I product sigma_x', '02': 'I product sigma_y', '03': 'I product sigma_z',
'10': 'sigma_x product I', '11': 'sigma_x product sigma_x', '12': 'sigma_x product sigma_y', '13': 'sigma_x product sigma_z',
'20': 'sigma_y product I', '21': 'sigma_y product sigma_x', '22': 'sigma_y product sigma_y', '23': 'sigma_y product sigma_z',
'30': 'sigma_z product I', '31': 'sigma_z product sigma_x', '32': 'sigma_z product sigma_y', '33': 'sigma_z product sigma_z'}
for i in range(4):
for j in range(4):
a_ij = 0.25 * np.dot(kron(S[i], S[j]), H).trace()
A_ij.append(a_ij)
if a_ij != 0.0:
print(str(a_ij) + ' * ' + d[str(i)+str(j)])
return np.asarray(A_ij).reshape(4,4)
def prepare_state2(A, theta):
qregisters = []
cregisters = []
qcircuits = []
identity = np.array([[1, 0],[ 0, 1]], dtype=np.complex128)
x = np.array([[0, 1], [ 1, 0]], dtype=np.complex128)
y = np.array([[0, -1j],[1j, 0]], dtype=np.complex128)
z = np.array([[1, 0], [0, -1]], dtype=np.complex128)
d = {}
for i in range(4):
for j in range(4):
if A[i,j] != 0:
if i !=0 and j!=0:
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr,cr)
qc.h(qr[0])
qc.rz(theta, qr[0])
qc.cx(qr[0], qr[1])
qc.x(qr[1])
if i==1:
qc.ry((np.pi)/2, qr[0])
if i==2:
qc.rx(-(np.pi)/2, qr[0])
if j==1:
qc.ry((np.pi)/2, qr[1])
if j==2:
qc.rx(-(np.pi)/2, qr[1])
qregisters.append(qr)
cregisters.append(cr)
qcircuits.append(qc)
d[(i,j)] = [qregisters, cregisters, qcircuits]
if i == 0 and j != 0:
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr,cr)
qc.h(qr[0])
qc.rz(theta, qr[0])
qc.cx(qr[0], qr[1])
qc.x(qr[1])
if j==1:
qc.ry((np.pi)/2, qr[1])
if j==2:
qc.rx(-(np.pi)/2, qr[1])
qregisters.append(qr)
cregisters.append(cr)
qcircuits.append(qc)
d[(i,j)] = [qregisters, cregisters, qcircuits]
if i != 0 and j == 0:
qr = qk.QuantumRegister(2)
cr = qk.ClassicalRegister(2)
qc = qk.QuantumCircuit(qr,cr)
qc.h(qr[0])
qc.rz(theta, qr[0])
qc.cx(qr[0], qr[1])
qc.x(qr[1])
if i==1:
qc.ry((np.pi)/2, qr[0])
if i==2:
qc.rx(-(np.pi)/2, qr[0])
qregisters.append(qr)
cregisters.append(cr)
qcircuits.append(qc)
d[(i,j)] = [qregisters, cregisters, qcircuits]
return d, A
def expectation2(d, A, n_shots):
"""
For each circuit, execute and measure it using the classical simulator 5000 times as explained above.
Return the result.
"""
expect = A[0,0]
qk.Aer.backends()
sim = qk.Aer.get_backend('qasm_simulator')
for k,v in d.items():
for i in range(len(v[2])):
v[2][i].measure(v[0][i],v[1][i])
res = qk.execute(v[2][i], sim, shots=n_shots).result()
counts = res.get_counts()
sum = 0
for m,n in counts.items():
if m=='01' or m=='10':
sum += (-1)*n/n_shots
elif m=='00' or m=='11':
sum += n/n_shots
sum = A[k[0],k[1]]*sum
expect += sum
return expect
thetas = np.linspace(0, np.pi, 100)
H = np.array([[0,0,0,0],[0,-1,1,0],[0,1,-1,0],[0,0,0,0]])
A = decomposition(H)
# For each theta, store the resulting expectation value in results
results = []
# For each theta, find the expectation value
for theta in thetas:
d, A = prepare_state2(A, theta)
expect = expectation2(d, A, 5000)
results.append(expect)
# Sort the results in ascending order. The first one is your minimum eigenvalue.
results.sort()
print("The minimum eigenvalue is: {}.".format(results[0]))
# -5??!! Maybe I missed something in my logic. Will continue to look into this. :-)
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
import sys
import os
current_dir = os.getcwd()
sys.path.append(current_dir)
from qiskit import ClassicalRegister
from quantum_circuit import QuantumCircuit
import math
from bit_functions import get_qubit_list
from abc import ABC, abstractmethod
from circuits import cnz, set_value_circuit
class grover_circuit(ABC):
def __init__(self):
self.calculation_qc = None
self.iteration_qc = None
self.circuit = None
self.measure_qc = None
@staticmethod
def oracle(nqubits: int, set_change_value : list=[], mode:str = 'noancilla')->QuantumCircuit:
'''Building an oracle giving the value of the qubits to go into the oracle.\n
Each element of the list is a tuple with the index of the qubit and its value = (index, value)'''
cnz_qc = cnz(nqubits, mode=mode)
value_qc = set_value_circuit(nqubits, set_change_value, rest_hadamard=False)
qc = QuantumCircuit(cnz_qc.qubits)
qubits = get_qubit_list(qc)
qc = qc.compose(value_qc, qubits)
qc.barrier(qc.qubits)
qc = qc.compose(cnz_qc, cnz_qc.qubits)
qc.barrier(qc.qubits)
qc = qc.compose(value_qc, qubits)
qc.name = 'Oracle'
return qc
@staticmethod
def diffuser(nqubits:int, mode : str='noancilla') ->QuantumCircuit:
cnz_cirq = cnz(nqubits, mode)
qc = QuantumCircuit(cnz_cirq.qubits)
qc.h(get_qubit_list(qc))
qc.x(get_qubit_list(qc))
qc.barrier(qc.qubits)
qc = qc.compose(cnz_cirq, cnz_cirq.qubits)
qc.barrier(qc.qubits)
qc.x(get_qubit_list(qc))
qc.h(get_qubit_list(qc))
qc.name = f'Diffuser {nqubits}Q'
return qc
def __prep_qubits(self, nqubits : int, prep_value : list = []) -> tuple[QuantumCircuit, int]:
'''Prepare the qubits value and returns the circuit and the size of the "world", the amount of hadamard gates on the qubits'''
qc = set_value_circuit(nqubits, qubit_value_list=prep_value, rest_hadamard=True)
qc.name = 'Prep Qubit'
return qc, dict(qc.count_ops())['h']
@staticmethod
def calculate_iterations(qubit_world : int, num_solutions : int = 1) -> None:
size_N = pow(2, qubit_world)
if num_solutions is not None and num_solutions:
if size_N < num_solutions * 2:
raise Exception("Grover won't work properly! To many solutions!")
return [math.floor((math.pi * math.sqrt(size_N / num_solutions)) / 4)]
return list(range(1, math.floor((math.pi * math.sqrt(size_N)) / 4) + 1))
def create_grover(self, num_solutions : int = 1, prep_value : list = [], block_diagram : bool = True) -> None:
if self.iteration_qc is None:
raise Exception("Iteration circuit not found!")
qubits = get_qubit_list(self.iteration_qc)
prep_qc, world_qubit_size = self.__prep_qubits(len(qubits), prep_value)
iterations = grover_circuit.calculate_iterations(world_qubit_size, num_solutions)
grover_experiments = []
for i in iterations:
qc = QuantumCircuit(self.iteration_qc.qubits)
if block_diagram:
qc.append(prep_qc, qubits)
[qc.append(self.iteration_qc, qc.qubits) for _ in range(i)]
else:
qc = qc.compose(prep_qc, qubits)
for _ in range(i):
qc = qc.compose(self.iteration_qc, qc.qubits)
qc.name = f"{self.iteration_qc.name} : Iteration {i}"
grover_experiments.append(qc)
self.circuit = grover_experiments
self.__add_qubit_measurement()
def __add_qubit_measurement(self) -> None:
'''
Measure the qubits of the circuits
'''
if self.circuit is None:
raise Exception("Circuit not found!")
self.measure_qc = []
for cur_qc in self.circuit:
qc = cur_qc.copy()
qubits = get_qubit_list(qc)
qc.add_register(ClassicalRegister(len(qubits)))
qc.measure(qubits, qc.clbits)
self.measure_qc.append(qc)
@abstractmethod
def calculation_logic(self):
pass
@abstractmethod
def build_iteration(self):
pass
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.visualization.timeline import draw as timeline_draw
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeBoeblingen
backend = FakeBoeblingen()
ghz = QuantumCircuit(5)
ghz.h(0)
ghz.cx(0,range(1,5))
circ = transpile(ghz, backend, scheduling_method="asap")
timeline_draw(circ)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list(
[
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156),
]
)
print(f"Number of qubits: {H2_op.num_qubits}")
from qiskit.algorithms import NumPyMinimumEigensolver
from qiskit.opflow import PauliSumOp
numpy_solver = NumPyMinimumEigensolver()
result = numpy_solver.compute_minimum_eigenvalue(operator=PauliSumOp(H2_op))
ref_value = result.eigenvalue.real
print(f"Reference value: {ref_value:.5f}")
# define ansatz and optimizer
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import SPSA
iterations = 125
ansatz = TwoLocal(rotation_blocks="ry", entanglement_blocks="cz")
spsa = SPSA(maxiter=iterations)
# define callback
# note: Re-run this cell to restart lists before training
counts = []
values = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
# define Aer Estimator for noiseless statevector simulation
from qiskit.utils import algorithm_globals
from qiskit_aer.primitives import Estimator as AerEstimator
seed = 170
algorithm_globals.random_seed = seed
noiseless_estimator = AerEstimator(
run_options={"seed": seed, "shots": 1024},
transpile_options={"seed_transpiler": seed},
)
# instantiate and run VQE
from qiskit.algorithms.minimum_eigensolvers import VQE
vqe = VQE(
noiseless_estimator, ansatz, optimizer=spsa, callback=store_intermediate_result
)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"VQE on Aer qasm simulator (no noise): {result.eigenvalue.real:.5f}")
print(
f"Delta from reference energy value is {(result.eigenvalue.real - ref_value):.5f}"
)
import pylab
pylab.rcParams["figure.figsize"] = (12, 4)
pylab.plot(counts, values)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Convergence with no noise")
from qiskit_aer.noise import NoiseModel
from qiskit.providers.fake_provider import FakeVigo
# fake providers contain data from real IBM Quantum devices stored in Qiskit Terra,
# and are useful for extracting realistic noise models.
device = FakeVigo()
coupling_map = device.configuration().coupling_map
noise_model = NoiseModel.from_backend(device)
print(noise_model)
noisy_estimator = AerEstimator(
backend_options={
"method": "density_matrix",
"coupling_map": coupling_map,
"noise_model": noise_model,
},
run_options={"seed": seed, "shots": 1024},
transpile_options={"seed_transpiler": seed},
)
# re-start callback variables
counts = []
values = []
vqe.estimator = noisy_estimator
result1 = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(f"VQE on Aer qasm simulator (with noise): {result1.eigenvalue.real:.5f}")
print(
f"Delta from reference energy value is {(result1.eigenvalue.real - ref_value):.5f}"
)
if counts or values:
pylab.rcParams["figure.figsize"] = (12, 4)
pylab.plot(counts, values)
pylab.xlabel("Eval count")
pylab.ylabel("Energy")
pylab.title("Convergence with noise")
print(f"Reference value: {ref_value:.5f}")
print(f"VQE on Aer qasm simulator (no noise): {result.eigenvalue.real:.5f}")
print(f"VQE on Aer qasm simulator (with noise): {result1.eigenvalue.real:.5f}")
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Manish-Sudhir/QiskitCheck
|
Manish-Sudhir
|
from qiskit import QuantumCircuit
from TestProperty import TestProperty
import cmath
import numpy as np
from math import cos, sin, radians, degrees
import random
class Generator:
"""
This method generates one concrete test case and provides the exact parameters
used to initialise the qubits
Inputs: a TestProperty
Output: a tuple containing the initialised test (a QantumCircuit),
and two dictionaries, that store the theta (first one) and phi (second one)
of each qubit in degrees
"""
def generateTest(self, testProperties: TestProperty):
preConditions = testProperties.preConditions
phiVal = {}
thetaVal = {}
#Adds 2 classical bits to read the results of any assertion
#Those bits will not interfere with the normal functioning of the program
if testProperties.minQubits == testProperties.maxQubits:
noOfQubits = testProperties.minQubits
else:
noOfQubits = np.random.randint(testProperties.minQubits, testProperties.maxQubits)
qc = QuantumCircuit(noOfQubits, testProperties.noOfClassicalBits + 2)
for key, value in preConditions.items():
#ignores the keys that are outside of the range
if key >= noOfQubits:
continue
#converts from degrees to radian
randPhi = random.randint(value.minPhi, value.maxPhi)
randTheta = random.randint(value.minTheta, value.maxTheta)
#stores the random values generated
phiVal[key] = randPhi
thetaVal[key] = randTheta
randPhiRad = radians(randPhi)
randThetaRad = radians(randTheta)
"""WHY THIS HAPPEN"""
value0 = cos(randThetaRad/2)
value1 = cmath.exp(randPhiRad * 1j) * sin(randThetaRad / 2)
qc.initialize([value0, value1], key)
return (qc, thetaVal, phiVal)
"""
This method runs self.generateTest to generate the specified amount of tests in
the TestProperty
Inputs: a TestProperty
Outputs: a list of what self.generateTests returns (a tuple containing a QuantumCircuit,
a dictionary for the thetas used and a dictionary for the phi used in degrees)
"""
def generateTests(self, testProperties: TestProperty):
return [self.generateTest(testProperties) for _ in range(testProperties.noOfTests)]
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import execute
from qiskit import BasicAer
π = np.pi
q = QuantumRegister(6)
c = ClassicalRegister(2)
hhl = QuantumCircuit(q, c)
# Superposition
hhl.h(q[1])
hhl.h(q[2])
# Controlled-U0
hhl.cu3(-π / 2, -π / 2, π / 2, q[2], q[3])
hhl.cu1(3 * π / 4, q[2], q[3])
hhl.cx(q[2], q[3])
hhl.cu1(3 * π / 4, q[2], q[3])
hhl.cx(q[2], q[3])
# Controlled-U1
hhl.cx(q[1], q[3]);
hhl.swap(q[1], q[2])
hhl.h(q[2])
hhl.cu1(-π / 2, q[1], q[2])
hhl.h(q[1]);
hhl.swap(q[1], q[2]);
hhl.cu3(0.392699, 0, 0, q[1], q[0]) # Controlled-RY0
hhl.cu3(0.19634955, 0, 0, q[2], q[0]); # Controlled-RY1
hhl.swap(q[1], q[2])
hhl.h(q[1])
hhl.cu1(π / 2, q[1], q[2]) # Inverse(Dagger(Controlled-S))
hhl.h(q[2])
hhl.swap(q[2], q[1])
# Inverse(Controlled-U1)
hhl.cx(q[1], q[3])
# Inverse(Controlled-U0)
hhl.cx(q[2], q[3])
hhl.cu1(-3 * π / 4, q[2], q[3])
hhl.cx(q[2], q[3])
hhl.cu1(-3 * π / 4, q[2], q[3])
hhl.cu3(-π / 2, π / 2, -π / 2, q[2], q[3])
# End of Inverse(Controlled-U0)
hhl.h(q[2])
hhl.h(q[1]);
# Target state preparation
hhl.rz(-π, q[4])
hhl.u1(π, q[4])
hhl.h(q[4])
hhl.ry(-0.9311623288419387, q[4])
hhl.rz(π, q[4])
# Swap test
hhl.h(q[5])
hhl.cx(q[4], q[3])
hhl.ccx(q[5], q[3], q[4])
hhl.cx(q[4], q[3])
hhl.h(q[5])
hhl.barrier(q)
hhl.measure(q[0], c[0])
hhl.measure(q[5], c[1]);
def get_psuccess(counts):
'''Compute the success probability of the HHL protocol from the statistics
:return: (float) The success probability.
'''
try:
succ_rotation_fail_swap = counts['11']
except KeyError:
succ_rotation_fail_swap = 0
try:
succ_rotation_succ_swap = counts['01']
except KeyError:
succ_rotation_succ_swap = 0
succ_rotation = succ_rotation_succ_swap + succ_rotation_fail_swap
try:
prob_swap_test_success = succ_rotation_succ_swap / succ_rotation
except ZeroDivisionError:
prob_swap_test_success = 0
return prob_swap_test_success
backend = BasicAer.get_backend('qasm_simulator')
job = execute(hhl, backend, shots=100)
result = job.result()
counts = result.get_counts(hhl)
print(get_psuccess(counts))
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import numpy as np
import pylab
from qiskit_chemistry import QiskitChemistry
# Input dictionary to configure qiskit chemistry for the chemistry problem.
qiskit_chemistry_dict = {
'problem': {'random_seed': 50},
'driver': {'name': 'PYQUANTE'},
'PYQUANTE': {'atoms': '', 'basis': 'sto3g'},
'operator': {'name': 'hamiltonian', 'qubit_mapping': 'jordan_wigner',
'two_qubit_reduction': False},
'algorithm': {'name': ''},
'optimizer': {'name': 'COBYLA', 'maxiter': 10000 },
'variational_form': {'name': 'SWAPRZ'},
'initial_state': {'name': 'HartreeFock'}
}
molecule = 'H .0 .0 -{0}; H .0 .0 {0}'
algorithms = ['VQE', 'ExactEigensolver']
start = 0.5 # Start distance
by = 0.5 # How much to increase distance by
steps = 20 # Number of steps to increase by
energies = np.empty([len(algorithms), steps+1])
hf_energies = np.empty(steps+1)
distances = np.empty(steps+1)
eval_counts = np.empty(steps+1)
print('Processing step __', end='')
for i in range(steps+1):
print('\b\b{:2d}'.format(i), end='', flush=True)
d = start + i*by/steps
qiskit_chemistry_dict['PYQUANTE']['atoms'] = molecule.format(d/2)
for j in range(len(algorithms)):
qiskit_chemistry_dict['algorithm']['name'] = algorithms[j]
solver = QiskitChemistry()
result = solver.run(qiskit_chemistry_dict)
energies[j][i] = result['energy']
hf_energies[i] = result['hf_energy']
if algorithms[j] == 'VQE':
eval_counts[i] = result['algorithm_retvals']['eval_count']
distances[i] = d
print(' --- complete')
print('Distances: ', distances)
print('Energies:', energies)
print('Hartree-Fock energies:', hf_energies)
print('VQE num evaluations:', eval_counts)
pylab.plot(distances, hf_energies, label='Hartree-Fock')
for j in range(len(algorithms)):
pylab.plot(distances, energies[j], label=algorithms[j])
pylab.xlabel('Interatomic distance')
pylab.ylabel('Energy')
pylab.title('H2 Ground State Energy')
pylab.legend(loc='upper right')
pylab.plot(distances, np.subtract(hf_energies, energies[1]), label='Hartree-Fock')
pylab.plot(distances, np.subtract(energies[0], energies[1]), label='VQE')
pylab.xlabel('Interatomic distance')
pylab.ylabel('Energy')
pylab.yscale('log')
pylab.title('Energy difference from ExactEigensolver')
pylab.legend(loc='center right')
pylab.plot(distances, eval_counts, '-o', color=[0.8500, 0.3250, 0.0980], label='VQE')
pylab.xlabel('Interatomic distance')
pylab.ylabel('Evaluations')
pylab.title('VQE number of evaluations')
pylab.legend(loc='upper left')
|
https://github.com/C2QA/bosonic-qiskit
|
C2QA
|
from pathlib import Path
import c2qa
import numpy
import qiskit
def assert_changed(state, result):
assert result.success
# print()
# print(circuit.draw("text"))
# print(state)
# TODO - better understand what the state vector results should be
assert count_nonzero(state) > 1
def count_nonzero(statevector: qiskit.quantum_info.Statevector):
"""Re-implement numpy.count_nonzero using numpy.isclose()."""
nonzero = len(statevector.data)
for state in statevector.data:
if numpy.isclose(state, 0):
nonzero -= 1
return nonzero
def create_conditional(num_qumodes: int = 2, num_qubits_per_qumode: int = 2):
qmr = c2qa.QumodeRegister(num_qumodes, num_qubits_per_qumode)
qr = qiskit.QuantumRegister(2)
circuit = c2qa.CVCircuit(qmr, qr)
for qumode in range(num_qumodes):
circuit.cv_initialize(0, qmr[qumode])
circuit.initialize([0, 1], qr[1]) # qr[0] will init to zero
return circuit, qmr, qr
def test_parameterized_displacement(capsys):
with capsys.disabled():
circuit, qmr, qr = create_conditional()
alpha = qiskit.circuit.Parameter("alpha")
circuit.cv_d(alpha, qmr[0])
bound_circuit = circuit.assign_parameters({alpha: 3.14})
state, result, fock_counts = c2qa.util.simulate(bound_circuit)
assert_changed(state, result)
def test_complex_literals(capsys):
with capsys.disabled():
# a = qiskit.circuit.Parameter('𝛼')
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode=4)
qbr = qiskit.QuantumRegister(1)
minimal_circuit = c2qa.CVCircuit(qmr, qbr)
minimal_circuit.h(qbr[0])
minimal_circuit.cv_c_d(1j * 1, qmr[0], qbr[0])
# bound_circuit = minimal_circuit.assign_parameters({a: 1})
c2qa.util.simulate(minimal_circuit)
def test_complex_parameters(capsys):
with capsys.disabled():
a = qiskit.circuit.Parameter("𝛼")
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode=4)
qbr = qiskit.QuantumRegister(1)
minimal_circuit = c2qa.CVCircuit(qmr, qbr)
minimal_circuit.h(qbr[0])
minimal_circuit.cv_c_d(1j * a, qmr[0], qbr[0])
bound_circuit = minimal_circuit.assign_parameters({a: 1})
c2qa.util.simulate(bound_circuit)
def test_complex_parameters_float(capsys):
with capsys.disabled():
a = qiskit.circuit.Parameter("𝛼")
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode=4)
qbr = qiskit.QuantumRegister(1)
minimal_circuit = c2qa.CVCircuit(qmr, qbr)
minimal_circuit.h(qbr[0])
minimal_circuit.cv_c_d(1j * a, qmr[0], qbr[0])
bound_circuit = minimal_circuit.assign_parameters({a: 2})
c2qa.util.simulate(bound_circuit)
|
https://github.com/CodeJP97/QHT-2022-WoQ
|
CodeJP97
|
import numpy as np
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ, assemble, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
#Apply the CNOT gate to the 00 state
#
qc=QuantumCircuit(2,2)
#
qc.cx(0,1)
#
qc.draw()
#Apply the CNOT gate to the 10 state
#
qc=QuantumCircuit(2,2)
#
qc.x(0)
qc.cx(0,1)
#
qc.draw()
#Apply the CNOT gate to the 00 state
#
qc=QuantumCircuit(2,2)
#
qc.h(0)
qc.cx(0,1)
#
for i in range(2):
qc.measure(i,i)
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1024).result().get_counts() # we run the simulation and get the counts
plot_histogram(counts)
#Apply the CNOT gate to the 00 state
#
qc=QuantumCircuit(2,2)
#
# FILL YOUR CODE IN HERE
qc.h(0)
qc.z(0)
qc.x(1)
qc.cx(0,1)
for i in range(2):
qc.measure(i,i)
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
counts = execute(qc, backend, shots = 1024).result().get_counts() # we run the simulation and get the counts
plot_histogram(counts)
|
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/sebasmos/QuantumVE
|
sebasmos
|
# !pip install qiskit torch torchvision matplotlib
# !pip install qiskit-machine-learning
# !pip install torchviz
# !pip install qiskit[all]
# !pip install qiskit == 0.45.2
# !pip install qiskit_algorithms == 0.7.1
# !pip install qiskit-ibm-runtime == 0.17.0
# !pip install qiskit-aer == 0.13.2
# #Quentum net draw
# !pip install pylatexenc
import os
MODEL_METADATA = "SVM"
model_name = "efficientnet_b3_embeddings_feat_space_16"#"efficientnet_v2_m"#"convnext_base"#"efficientnet_b3"#"mobileNet"
results_path = f"{model_name}/{MODEL_METADATA}"
os.makedirs(results_path, exist_ok = True)
train_path = f"{model_name}/train"
val_path = f"{model_name}/val"
os.makedirs(train_path, exist_ok = True)
os.makedirs(val_path, exist_ok=True)
from qiskit_algorithms.utils import algorithm_globals
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np
from qiskit.circuit.library import ZZFeatureMap
from qiskit.primitives import Sampler
from qiskit_algorithms.state_fidelities import ComputeUncompute
from qiskit_machine_learning.kernels import FidelityQuantumKernel
from sklearn.metrics import confusion_matrix, classification_report
algorithm_globals.random_seed = 12345
train_embeddings = pd.read_csv(f'{train_path}/train_embeddings.csv')
val_embeddings = pd.read_csv(f'{val_path}/val_embeddings.csv')
print(f"Reading embeddings from: ", train_path)
# Prepare data for training
train_features = train_embeddings.iloc[:, :-1].values # Features
y_train = train_embeddings.iloc[:, -1].values # Labels
test_features = val_embeddings.iloc[:, :-1].values # Features
y_val = val_embeddings.iloc[:, -1].values # Labels
plt.figure(figsize=(18, 5))
ax = sns.countplot(x=y_train, palette='tab10')
total = len(y_train)
for p in ax.patches:
percentage = f'{100 * p.get_height() / total:.1f}%\n'
x = p.get_x() + p.get_width() / 2
y = p.get_height()
ax.annotate(percentage, (x, y), ha='center', va='center')
plt.show()
adhoc_dimension = 16
"""
class 0 : {0,2}
class 1 : {1,3}
"""
label_map = {0: 0,
1: 1,
2: 0,
3: 1,
4: 0}
# Merge labels using the dictionary
Y_train = np.array([label_map[label] for label in y_train])
y_test = np.array([label_map[label] for label in y_val])
print("labels_train:", np.unique(Y_train))
print("test_labels:", np.unique(y_test))
plt.figure(figsize=(18, 5))
ax = sns.countplot(x=Y_train, palette='tab10')
total = len(Y_train)
for p in ax.patches:
percentage = f'{100 * p.get_height() / total:.1f}%\n'
x = p.get_x() + p.get_width() / 2
y = p.get_height()
ax.annotate(percentage, (x, y), ha='center', va='center')
plt.show()
print(train_features.shape, Y_train.shape)
print(test_features.shape, y_test.shape)
adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement="linear")
sampler = Sampler()
fidelity = ComputeUncompute(sampler=sampler)
adhoc_kernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=adhoc_feature_map)
train_features.shape
print(train_features.shape, Y_train.shape)
print(test_features.shape, y_test.shape)
train_features = train_features[:100]
test_features = test_features[:20]
Y_train = Y_train[:100]
y_test = y_test[:20]
train_features.shape, test_features.shape, Y_train.shape, y_test.shape
import time
from sklearn.metrics import accuracy_score, precision_score, f1_score, recall_score, fbeta_score
from sklearn.svm import SVC
# Start timer for training
start_train = time.time()
adhoc_svc = SVC(kernel=adhoc_kernel.evaluate)
adhoc_svc.fit(train_features, Y_train)
# End timer for training
end_train = time.time()
# Start timer for inference
start_inference = time.time()
predictions = adhoc_svc.predict(test_features)
# End timer for inference
end_inference = time.time()
accuracy = accuracy_score(y_test, predictions)
precision = precision_score(y_test, predictions, average='weighted')
f1 = f1_score(y_test, predictions, average='weighted')
recall = recall_score(y_test, predictions, average='weighted')
fbeta_75 = fbeta_score(y_test, predictions, beta=0.75, average='weighted')
# Print metrics and time
print(f"Accuracy: {accuracy} Precision: {precision} F1 Score: {f1} Recall: {recall} F0.75 Score: {fbeta_75}")
print(f"Training time: {end_train - start_train} seconds")
print(f"Inference time: {end_inference - start_inference} seconds")
unique_classes = np.unique(np.concatenate(((predictions, y_test))))
confusion_mat = confusion_matrix(predictions, y_test, labels=unique_classes)
conf_matrix = pd.DataFrame(confusion_mat, index=unique_classes, columns=unique_classes)
# Plot the confusion matrix using seaborn
plt.figure(figsize=(5, 4))
ax = sns.heatmap(conf_matrix, annot=True, fmt='.1f', cmap=sns.cubehelix_palette(as_cmap=True), linewidths=0.1, cbar=True)
# Set labels and ticks
ax.set_xlabel('Predicted Labels')
ax.set_ylabel('True Labels')
# Set x and y ticks using the unique classes
ax.set_xticks(range(len(unique_classes)))
ax.set_yticks(range(len(unique_classes)))
# Set x and y ticks at the center of the cells
ax.set_xticks([i + 0.5 for i in range(len(unique_classes))])
ax.set_yticks([i + 0.5 for i in range(len(unique_classes))])
plt.show()
report = classification_report(y_test,predictions, target_names=unique_classes,output_dict=True)# Mostrar el informe de
df = pd.DataFrame(report).transpose()
df.to_csv(os.path.join(results_path, f"confusion_matrix_{MODEL_METADATA}.csv"))
print(df)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
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.algorithms import (
MinimumEigenOptimizer,
RecursiveMinimumEigenOptimizer,
SolutionSample,
OptimizationResultStatus,
)
from qiskit_optimization import QuadraticProgram
from qiskit.visualization import plot_histogram
from typing import List, Tuple
import numpy as np
# create a QUBO
qubo = QuadraticProgram()
qubo.binary_var("x")
qubo.binary_var("y")
qubo.binary_var("z")
qubo.minimize(linear=[1, -2, 3], quadratic={("x", "y"): 1, ("x", "z"): -1, ("y", "z"): 2})
print(qubo.prettyprint())
op, offset = qubo.to_ising()
print("offset: {}".format(offset))
print("operator:")
print(op)
qp = QuadraticProgram()
qp.from_ising(op, offset, linear=True)
print(qp.prettyprint())
algorithm_globals.random_seed = 10598
qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 0.0])
exact_mes = NumPyMinimumEigensolver()
qaoa = MinimumEigenOptimizer(qaoa_mes) # using QAOA
exact = MinimumEigenOptimizer(exact_mes) # using the exact classical numpy minimum eigen solver
exact_result = exact.solve(qubo)
print(exact_result.prettyprint())
qaoa_result = qaoa.solve(qubo)
print(qaoa_result.prettyprint())
print("variable order:", [var.name for var in qaoa_result.variables])
for s in qaoa_result.samples:
print(s)
def get_filtered_samples(
samples: List[SolutionSample],
threshold: float = 0,
allowed_status: Tuple[OptimizationResultStatus] = (OptimizationResultStatus.SUCCESS,),
):
res = []
for s in samples:
if s.status in allowed_status and s.probability > threshold:
res.append(s)
return res
filtered_samples = get_filtered_samples(
qaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)
)
for s in filtered_samples:
print(s)
fvals = [s.fval for s in qaoa_result.samples]
probabilities = [s.probability for s in qaoa_result.samples]
np.mean(fvals)
np.std(fvals)
samples_for_plot = {
" ".join(f"{qaoa_result.variables[i].name}={int(v)}" for i, v in enumerate(s.x)): s.probability
for s in filtered_samples
}
samples_for_plot
plot_histogram(samples_for_plot)
rqaoa = RecursiveMinimumEigenOptimizer(qaoa, min_num_vars=1, min_num_vars_optimizer=exact)
rqaoa_result = rqaoa.solve(qubo)
print(rqaoa_result.prettyprint())
filtered_samples = get_filtered_samples(
rqaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)
)
samples_for_plot = {
" ".join(f"{rqaoa_result.variables[i].name}={int(v)}" for i, v in enumerate(s.x)): s.probability
for s in filtered_samples
}
samples_for_plot
plot_histogram(samples_for_plot)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
qc.draw('mpl')
|
https://github.com/qiskit-community/Qiskit-Hackathon-at-World-of-QUANTUM
|
qiskit-community
|
import numpy as np
from qiskit_textbook.tools import random_state
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit,QuantumRegister, ClassicalRegister, transpile, Aer, IBMQ, assemble, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
from qiskit_textbook.tools import random_state
from qiskit.extensions import Initialize
from qiskit.providers.aer.noise import NoiseModel
import qiskit.quantum_info as qi
# Loading your IBM Quantum account(s)
provider = IBMQ.load_account()
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz = ClassicalRegister(1, name="crz") # and 2 classical bits
crx = ClassicalRegister(1, name="crx") # in 2 different register
teleportation_circuit = QuantumCircuit(qr, crz, crx)
def psi_00(circuit, q1, q2):
# FILL YOUR CODE HERE
def Bell_measurement(circuit, q1, q2,crx, crz):
# FILL YOUR CODE HERE
def conditional_gates(circuit, q0, crx, crz):
# FILL YOUR CODE HERE
qr = QuantumRegister(3, name="q") # Protocol uses 3 qubits
crz, crx = ClassicalRegister(1, name="crz"), ClassicalRegister(1, name="crx") #Classical Registers
teleportation_circuit = QuantumCircuit(qr, crz, crx)
#STEP 1: Create the Bell state between q0 and q1
psi_00(teleportation_circuit, 0, 1 )
#STEP 2: Bell Measurement
teleportation_circuit.barrier()
Bell_measurement(teleportation_circuit, 1, 2, crx, crz)
#STEP 3: Conditional Gates
teleportation_circuit.barrier()
conditional_gates(teleportation_circuit,0, crx, crz)
teleportation_circuit.draw()
|
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/mathelatics/QGSS-2023-From-Theory-to-Implementations
|
mathelatics
|
import qiskit
qiskit.__qiskit_version__
# useful additional packages
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# importing Qiskit
from qiskit import BasicAer, IBMQ
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.compiler import transpile
from qiskit.tools.monitor import job_monitor
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
# Load our saved IBMQ accounts
IBMQ.load_account()
n = 13 # the length of the first register for querying the oracle
# Choose a type of oracle at random. With probability half it is constant,
# and with the same probability it is balanced
oracleType, oracleValue = np.random.randint(2), np.random.randint(2)
if oracleType == 0:
print("The oracle returns a constant value ", oracleValue)
else:
print("The oracle returns a balanced function")
a = np.random.randint(1,2**n) # this is a hidden parameter for balanced oracle.
# Creating registers
# n qubits for querying the oracle and one qubit for storing the answer
qr = QuantumRegister(n+1) #all qubits are initialized to zero
# for recording the measurement on the first register
cr = ClassicalRegister(n)
circuitName = "DeutschJozsa"
djCircuit = QuantumCircuit(qr, cr)
# Create the superposition of all input queries in the first register by applying the Hadamard gate to each qubit.
for i in range(n):
djCircuit.h(qr[i])
# Flip the second register and apply the Hadamard gate.
djCircuit.x(qr[n])
djCircuit.h(qr[n])
# Apply barrier to mark the beginning of the oracle
djCircuit.barrier()
if oracleType == 0:#If the oracleType is "0", the oracle returns oracleValue for all input.
if oracleValue == 1:
djCircuit.x(qr[n])
else:
djCircuit.iden(qr[n])
else: # Otherwise, it returns the inner product of the input with a (non-zero bitstring)
for i in range(n):
if (a & (1 << i)):
djCircuit.cx(qr[i], qr[n])
# Apply barrier to mark the end of the oracle
djCircuit.barrier()
# Apply Hadamard gates after querying the oracle
for i in range(n):
djCircuit.h(qr[i])
# Measurement
djCircuit.barrier()
for i in range(n):
djCircuit.measure(qr[i], cr[i])
#draw the circuit
djCircuit.draw(output='mpl',scale=0.5)
backend = BasicAer.get_backend('qasm_simulator')
shots = 1000
job = execute(djCircuit, backend=backend, shots=shots)
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
backend = IBMQ.get_backend('ibmq_16_melbourne')
djCompiled = transpile(djCircuit, backend=backend, optimization_level=1)
djCompiled.draw(output='mpl',scale=0.5)
job = execute(djCompiled, backend=backend, shots=1024)
job_monitor(job)
results = job.result()
answer = results.get_counts()
threshold = int(0.01 * shots) # the threshold of plotting significant measurements
filteredAnswer = {k: v for k,v in answer.items() if v >= threshold} # filter the answer for better view of plots
removedCounts = np.sum([ v for k,v in answer.items() if v < threshold ]) # number of counts removed
filteredAnswer['other_bitstrings'] = removedCounts # the removed counts are assigned to a new index
plot_histogram(filteredAnswer)
print(filteredAnswer)
|
https://github.com/arnavdas88/QuGlassyIsing
|
arnavdas88
|
from itertools import product
from time import sleep
from typing import Callable, Optional
import matplotlib.pyplot as plt
import numpy as np
from numpy.random import RandomState
import seaborn as sns
q = 4
RANDOM_SEED = 42424
WIDTH = 15
J_c = 1 # ?
h = 1
# Python type hinting; the code works well without this
Interaction = Callable[[int, int], float]
def generate_correlated_field(rg: RandomState, correlation: float=0.3):
field = np.array(rg.randint(q, size=[WIDTH, WIDTH]), dtype=np.int8)
for i in range(field.shape[0]):
for j in range(field.shape[1]):
if i > 0 and j > 0 and rg.uniform() < correlation:
if rg.uniform() < 0.5:
field[i,j] = field[i-1,j]
else:
field[i,j] = field[i,j-1]
return field
rg = RandomState(RANDOM_SEED)
field = generate_correlated_field(rg, 0.5)
%matplotlib inline
def show_field(field: np.ndarray, title: Optional[str]=None) -> None:
sns.set()
ax = sns.heatmap(field, center=q/2, square=True, cbar=False)
if title:
ax.set_title(title)
ax.get_figure().savefig('field.png')
show_field(field, 'Test')
def kronecker(spin_1: int, spin_2: int) -> float:
return float(spin_1 == spin_2)
def energy(field: np.ndarray, interaction: Interaction) -> float:
energy = 0
for i, j in product(range(WIDTH - 1), range(WIDTH)):
energy += interaction(field[i, j], field[i + 1, j])
for i, j in product(range(WIDTH), range(WIDTH - 1)): # dim
energy += interaction(field[i, j], field[i, j + 1])
return 2 * J_c * energy + h * field.sum()
energy(field, kronecker)
def calculate_interaction_of_one_spin(field: np.ndarray, x: int, y: int, interaction: Interaction) -> float:
# factor 2 ?!
energy = 0
if x > 0: # dim!!
energy += interaction(field[x-1,y], field[x,y])
if x < WIDTH - 1:
energy += interaction(field[x,y], field[x+1,y])
if y > 0:
energy += interaction(field[x,y-1], field[x,y])
if y < WIDTH - 1:
energy += interaction(field[x,y], field[x,y+1])
return 2 * J_c * energy
def calculate_energy_difference(field: np.ndarray, x: int, y: int, new_spin: int, interaction: Interaction) -> (float, np.ndarray):
# positive return value: update would imply energetically less favorable state
current_energy = calculate_interaction_of_one_spin(field, x, y, interaction)
field_updated = field.copy() # Avoid side effects of function by copying
field_updated[x,y] = new_spin
updated_energy = calculate_interaction_of_one_spin(field_updated, x, y, interaction)
energy_difference = updated_energy - current_energy + h * (field_updated[x,y] - field[x,y])
return (updated_energy - current_energy, field_updated)
def update_metropolis(field: np.ndarray, free_energy: float, interaction: Interaction, random_state: RandomState) -> (np.ndarray, float):
random_x, random_y = random_state.randint(WIDTH, size=[2]) # dim
random_spin = random_state.randint(q)
energy_difference, field_updated = calculate_energy_difference(field, random_x, random_y, random_spin, interaction)
if energy_difference < 0 or random_state.uniform():
# free_energy_updated = free_energy - energy_difference
return field_updated, free_energy
else:
return field, free_energy
free_energy = 0
rg = RandomState(RANDOM_SEED)
field = np.array(rg.randint(q, size=[WIDTH, WIDTH]), dtype=np.int8)
for i in range(100):
for _ in range(10):
field, free_energy = update_metropolis(field, free_energy, kronecker, rg)
show_field(field, f'Free energy: {free_energy}')
sleep(0.2)
|
https://github.com/bagmk/Quantum_Machine_Learning_Express
|
bagmk
|
import numpy as np
from qiskit.quantum_info import state_fidelity, Statevector
def getStatevector(circuit):
return Statevector(circuit).data
import warnings
warnings.filterwarnings('ignore')
def P_haar(N, F):
if F == 1:
return 0
else:
return (N - 1) * ((1 - F) ** (N - 2))
def KL(P, Q):
epsilon = 1e-8
kl_divergence = 0.0
for p, q in zip(P, Q):
kl_divergence += p * np.log( (p + epsilon) / (q + epsilon) )
return abs(kl_divergence)
def expressibility(qubits, sampler, *, bins=100, epoch=3000, layer=1, encode=False, return_detail=False):
unit = 1 / bins
limits = []
probabilities = np.array([0] * bins)
for i in range(1, bins + 1):
limits.append(unit * i)
for i in range(epoch):
circuit_1 = sampler(layer=layer, qubits=qubits)
circuit_2 = sampler(layer=layer, qubits=qubits)
f = state_fidelity(
getStatevector(circuit_1),
getStatevector(circuit_2)
)
for j in range(bins):
if f <= limits[j]:
probabilities[j] += 1
break
pHaar_vqc = [ P_haar(2 ** qubits, f - (unit/2)) / bins for f in limits]
probabilities = [ p / epoch for p in probabilities ]
if return_detail:
return pHaar_vqc, probabilities
else:
return KL(probabilities, pHaar_vqc)
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qrx = QuantumRegister(1, 'q0')
qry = QuantumRegister(1, 'q1')
cr = ClassicalRegister(1, 'c')
qc = QuantumCircuit(qrx, qry, cr)
qc.h(qrx)
qc.x(qry)
qc.h(qry)
qc.barrier()
qc.x(qry)
qc.cx(qrx, qry)
qc.barrier()
qc.h(qrx)
qc.h(qry)
qc.measure(qrx, cr)
qc.draw("mpl")
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
sim = AerSimulator()
job = execute(qc, backend = sim, shots = 1000)
result = job.result()
counts = result.get_counts(qc)
print("Counts: ", counts)
plot_histogram(counts)
from qiskit import QuantumCircuit, IBMQ, execute
from qiskit.tools.monitor import job_monitor
from qiskit.visualization import plot_histogram
IBMQ.save_account('your_token')
IBMQ.load_account()
IBMQ.providers()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
qcomp = provider.get_backend('ibmq_manila')
job = execute(qc, backend = qcomp, shots = 1000)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:", counts)
plot_histogram(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
import pickle
plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2*dt,0)
qc.rz(2*dt,1)
qc.h(1)
qc.cx(1,0)
qc.rz(-2*dt, 0)
qc.rx(-2*dt, 1)
qc.rz(2*dt, 1)
qc.cx(1,0)
qc.h(1)
qc.rz(2*dt, 0)
return qc.to_instruction() if to_instruction else qc
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
Trot_gate = trotter_gate(dt)
# Number of trotter steps
trotter_steps = 100 ### CAN BE >= 4
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(7)
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
qc.x([5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(trotter_steps):
qc.append(Trot_gate, [qr[3], qr[5]])
qc.cx(qr[3], qr[1])
qc.cx(qr[5], qr[3])
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time/trotter_steps})
t3_qc = transpile(qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_qc = transpile(t3_qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(t3_qc, [qr[1], qr[3], qr[5]])
# Display circuit for confirmation
# st_qcs[-1].decompose().draw() # view decomposition of trotter gates
st_qcs[-1].draw("mpl") # only view trotter gates
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
print("provider:", provider)
backend = provider.get_backend("ibmq_jakarta")
shots = 8192
reps = 8
jobs = []
for _ in range(reps):
# execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3)
print('Job ID', cal_job.job_id())
with open("jakarta_100step_2.pkl", "wb") as f:
pickle.dump({"jobs": jobs, "cal_job": cal_job}, f)
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
mit_results = []
for job in jobs:
mit_results.append( meas_fitter.filter.apply(job.result()) )
# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits
def state_tomo(result, st_qcs):
# The expected final state; necessary to determine state tomography fidelity
target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Fit state tomography results
tomo_fitter = StateTomographyFitter(result, st_qcs)
rho_fit = tomo_fitter.fit(method='lstsq')
# Compute fidelity
fid = state_fidelity(rho_fit, target_state)
return fid
# Compute tomography fidelities for each repetition
fids = []
for result in mit_results:
fid = state_tomo(result, st_qcs)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
|
https://github.com/nikhil-kamath/quantum-crop-optimization
|
nikhil-kamath
|
import numpy as np
from qiskit import IBMQ, Aer
from qiskit.algorithms import QAOA, VQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.providers.aer.noise.noise_model import NoiseModel
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.converters import QuadraticProgramToQubo
import qiskit.test.mock as Fake
IBMQ.load_account()
IBMQ.providers()
algorithm_globals.massive = True
quadprog = QuadraticProgram("test")
quadprog.integer_var(name="x_1", lowerbound=0, upperbound=4)
quadprog.integer_var(name="x_2", lowerbound=-2, upperbound=2)
quadprog.integer_var(name="x_3", lowerbound=-2, upperbound=4)
quadprog.minimize(
linear={"x_3": -6},
quadratic={("x_1", "x_1"): 1, ("x_2", "x_2"): 1, ("x_1", "x_2"): -1}
)
quadprog.linear_constraint(linear={"x_1": 1, "x_2": 1}, sense="=", rhs=2)
quadprog.quadratic_constraint(quadratic={("x_2", "x_3"): 1}, sense=">=", rhs=1)
print(quadprog.export_as_lp_string())
def cropyield_quadratic_program(n=3):
cropyield = QuadraticProgram()
# initialize the crop types as integer variables
crops = ["Wheat", "Soybeans", "Maize", "PushPull"]
w = "Wheat"
s = "Soybeans"
m = "Maize"
p = "PushPull"
for crop in crops:
cropyield.integer_var(name=crop, lowerbound=0, upperbound=n)
l = {}
q = {}
# initialize the equation for total crop output.
# these represent how "good" each of the crop types are in terms of the final equation
# so wheat is 2x as good as soybeans and maize is 4x as good, and pushpull provides no direct benefit
l[w] = 2
l[s] = 1
l[m] = 4
# define the intercropping coefficients, aka how well certain crops will be when grown together
q[(w, s)] = 2.4
q[(w, m)] = 4
q[(w, p)] = 4
q[(s, m)] = 2
q[(s, p)] = 1
q[(m, p)] = 5
# we want to maximize the output
cropyield.maximize(linear=l, quadratic=q)
# but make sure that the sum of the number of squares is <= 3
cropyield.linear_constraint(linear={w:1, s:1, m:1, p:1}, sense="<=", rhs=n)
return cropyield
# convert the quadratic problem to a quantum problem
cropyield = cropyield_quadratic_program(n=3)
ising_operations, _ = (
QuadraticProgramToQubo()
.convert(
cropyield,
)
.to_ising()
)
print(f"Number of qubits required is {ising_operations.num_qubits}")
QuadraticProgramToQubo().convert(cropyield)
# use the Aer simulator
backend = Aer.get_backend("qasm_simulator")
algorithm_globals.random_seed = 271828
def get_classical_solution_for(quadprog: QuadraticProgram):
solver = NumPyMinimumEigensolver()
optimizer = MinimumEigenOptimizer(solver)
return optimizer.solve(quadprog)
def get_QAOA_solution_for(
quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None
):
_eval_count = 0
def callback(eval_count, parameters, mean, std):
nonlocal _eval_count
_eval_count = eval_count
solver = QAOA(
optimizer=optimizer, quantum_instance=quantumInstance, callback=callback
)
optimizer = MinimumEigenOptimizer(solver)
result = optimizer.solve(quadprog)
return result, _eval_count
def get_VQE_solution_for(
quadprog: QuadraticProgram, quantumInstance: QuantumInstance, optimizer=None,
):
_eval_count = 0
def callback(eval_count, parameters, mean, std):
nonlocal _eval_count
_eval_count = eval_count
# Create solver and optimizer
solver = VQE(
optimizer=optimizer, quantum_instance=quantumInstance, callback=callback
)
# Create optimizer for solver
optimizer = MinimumEigenOptimizer(solver)
# Get result from optimizer
result = optimizer.solve(quadprog)
return result, _eval_count
classical_result = get_classical_solution_for(cropyield)
print("Solution found using classical method:\n")
print(f"Maximum crop yield is {classical_result.fval} tons")
print("Crops used are: ")
_crops = [v.name for v in cropyield.variables]
for cropIndex, cropHectares in enumerate(classical_result.x):
print(f"\t{cropHectares} ha of {_crops[cropIndex]}")
simulator_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
qaoa_result, qaoa_eval_count = get_QAOA_solution_for(cropyield, simulator_instance)
print("Solution found using the QAOA method:\n")
print(f"Maximum crop-yield is {qaoa_result.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(qaoa_result.x, qaoa_result.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(f"\nThe solution was found within {qaoa_eval_count} evaluations of QAOA.")
# Create a QuantumInstance
simulator_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
# Get VQE result
vqe_result, vqe_eval_count = get_VQE_solution_for(
cropyield, simulator_instance)
# Format and print result
print("Solution found using the VQE method:\n")
print(f"Maximum crop-yield is {vqe_result.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(vqe_result.x, vqe_result.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(f"\nThe solution was found within {vqe_eval_count} evaluations of VQE")
problem = cropyield_quadratic_program(n=50)
for _backend in IBMQ.get_provider(hub='ibm-q', group='open', project='main').backends():
print(_backend.name())
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend_real = provider.get_backend('ibmq_qasm_simulator')
quantum_instance_real = QuantumInstance(backend_real, shots=2048)
optimizer = COBYLA(maxiter=1)
## Get result from real device with VQE
vqe_result_real, vqe_eval_count_real = get_VQE_solution_for(
problem, quantum_instance_real, optimizer=optimizer
)
# Format and print result
print("Solution found using the VQE method:\n")
print(f"Maximum crop-yield is {vqe_result_real.fval} tons")
print(f"Crops used are: ")
for cropHectares, cropName in zip(vqe_result_real.x, vqe_result_real.variable_names):
print(f"\t{cropHectares} ha of {cropName}")
print(
f"\nThe solution was found within {vqe_eval_count_real} evaluations of VQE")
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit
from qiskit import QuantumRegister
from qiskit.quantum_info import Operator
from qiskit.circuit.library.standard_gates import XGate, YGate, ZGate
class FiveQubitCode:
def __init__(self):
# Initialize Registers
self.code = QuantumRegister(5, name="code")
self.syndrm = QuantumRegister(4, name="syndrome")
# Build Circuit Components
self.encoder_ckt = self.build_encoder()
self.syndrome_ckt = self.build_syndrome()
self.correction_ckt = self.build_correction()
self.decoder_ckt = self.encoder_ckt.mirror()
# Build Noisy Channel
self.noise_ckt = QuantumCircuit(self.code, self.syndrm)
for i in range(5):
self.noise_ckt.unitary(Operator(np.eye(2)), [self.code[i]], label='noise')
# Compose Full Circuit
circ = QuantumCircuit(self.code, self.syndrm)
circ.barrier()
self.circuit = self.encoder_ckt + circ + self.noise_ckt + circ + self.syndrome_ckt
self.circuit = self.circuit + circ + self.correction_ckt + circ + self.decoder_ckt
def build_encoder(self):
# Build Encoder Circuit
circ = QuantumCircuit(self.code, self.syndrm, name="Encoder Circuit")
circ.z(self.code[4])
circ.h(self.code[4])
circ.z(self.code[4])
circ.cx(self.code[4], self.code[3])
circ.h(self.code[4])
circ.h(self.code[3])
circ.cx(self.code[4], self.code[2])
circ.cx(self.code[3], self.code[2])
circ.h(self.code[2])
circ.cx(self.code[4], self.code[1])
circ.cx(self.code[2], self.code[1])
circ.h(self.code[1])
circ.h(self.code[4])
circ.cx(self.code[4], self.code[0])
circ.cx(self.code[3], self.code[0])
circ.cx(self.code[2], self.code[0])
circ.h(self.code[3])
circ.h(self.code[4])
return circ
def build_syndrome(self):
# Build Syndrome Circuit
circ = QuantumCircuit(self.code, self.syndrm, name="Syndrome Circuit")
circ.h(self.syndrm)
circ.barrier()
circ.cz(self.syndrm[0], self.code[4])
circ.cx(self.syndrm[0], self.code[3])
circ.cx(self.syndrm[0], self.code[2])
circ.cz(self.syndrm[0], self.code[1])
circ.cx(self.syndrm[1], self.code[4])
circ.cx(self.syndrm[1], self.code[3])
circ.cz(self.syndrm[1], self.code[2])
circ.cz(self.syndrm[1], self.code[0])
circ.cx(self.syndrm[2], self.code[4])
circ.cz(self.syndrm[2], self.code[3])
circ.cz(self.syndrm[2], self.code[1])
circ.cx(self.syndrm[2], self.code[0])
circ.cz(self.syndrm[3], self.code[4])
circ.cz(self.syndrm[3], self.code[2])
circ.cx(self.syndrm[3], self.code[1])
circ.cx(self.syndrm[3], self.code[0])
circ.barrier()
circ.h(self.syndrm)
return circ
def build_correction(self):
# Build Correction Circuit
circ = QuantumCircuit(self.code, self.syndrm)
circ.append(XGate().control(4, ctrl_state='0010'), [self.syndrm[i] for i in range(4)] + [self.code[0]])
circ.append(YGate().control(4, ctrl_state='1110'), [self.syndrm[i] for i in range(4)] + [self.code[0]])
circ.append(ZGate().control(4, ctrl_state='1100'), [self.syndrm[i] for i in range(4)] + [self.code[0]])
circ.append(XGate().control(4, ctrl_state='0101'), [self.syndrm[i] for i in range(4)] + [self.code[1]])
circ.append(YGate().control(4, ctrl_state='1101'), [self.syndrm[i] for i in range(4)] + [self.code[1]])
circ.append(ZGate().control(4, ctrl_state='1000'), [self.syndrm[i] for i in range(4)] + [self.code[1]])
circ.append(XGate().control(4, ctrl_state='1010'), [self.syndrm[i] for i in range(4)] + [self.code[2]])
circ.append(YGate().control(4, ctrl_state='1011'), [self.syndrm[i] for i in range(4)] + [self.code[2]])
circ.append(ZGate().control(4, ctrl_state='0001'), [self.syndrm[i] for i in range(4)] + [self.code[2]])
circ.append(XGate().control(4, ctrl_state='0100'), [self.syndrm[i] for i in range(4)] + [self.code[3]])
circ.append(YGate().control(4, ctrl_state='0111'), [self.syndrm[i] for i in range(4)] + [self.code[3]])
circ.append(ZGate().control(4, ctrl_state='0011'), [self.syndrm[i] for i in range(4)] + [self.code[3]])
circ.append(XGate().control(4, ctrl_state='1001'), [self.syndrm[i] for i in range(4)] + [self.code[4]])
circ.append(YGate().control(4, ctrl_state='1111'), [self.syndrm[i] for i in range(4)] + [self.code[4]])
circ.append(ZGate().control(4, ctrl_state='0110'), [self.syndrm[i] for i in range(4)] + [self.code[4]])
return circ
def visualize(self):
# Draw Circuits
self.encoder_ckt.draw('mpl', reverse_bits=True).suptitle('Encoder Circuit', fontsize=16)
self.syndrome_ckt.draw('mpl', reverse_bits=True).suptitle('Syndrome Circuit', fontsize=16)
self.correction_ckt.draw('mpl', reverse_bits=True).suptitle('Error Correction', fontsize=16)
self.decoder_ckt.draw('mpl', reverse_bits=True).suptitle('Decoder Circuit', fontsize=16)
self.circuit.draw('mpl', reverse_bits=True, style={'fontsize': 4}) \
.suptitle('Five Qubit Error Correction', fontsize=16)
plt.show()
|
https://github.com/mberna/qce23-qiskit-runtime-primitives-tutorial
|
mberna
|
from qiskit_ibm_runtime import QiskitRuntimeService, Estimator, Options
# Initialize service
service = QiskitRuntimeService(channel="ibm_quantum")
# Choose a backend to run on (you can change this to another backend that is available)
backend = service.get_backend("ibm_canberra")
from pprint import pprint
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
import qiskit.quantum_info as qi
# Specify a 1D chain of device qubits to use
initial_layout = [2, 3, 5, 8]
num_qubits = len(initial_layout)
# Parameterized Trotter layer
par_rx = Parameter("a")
par_rzz = Parameter("b")
trotter_layer = QuantumCircuit(num_qubits)
trotter_layer.rx(par_rx, range(num_qubits))
for i in range(num_qubits // 2):
trotter_layer.rzz(par_rzz, 2 * i, 1 + 2 * i)
for i in range(1, num_qubits // 2 + bool(num_qubits % 2)):
trotter_layer.rzz(par_rzz, 2 * i - 1, 2 * i)
# Run for 1 to 5 steps
trotter_steps = [1, 2, 3, 4, 5]
trotter_circuit_list = []
for i in trotter_steps:
trotter_circuit = QuantumCircuit(num_qubits)
for _ in range(i):
trotter_circuit = trotter_circuit.compose(trotter_layer)
trotter_circuit_list.append(trotter_circuit)
print(f'Trotter circuit with {i} Trotter steps')
display(trotter_circuit.draw(fold=-1))
import numpy as np
import qiskit.quantum_info as qi
# Hamiltonian parameters
params = [0.1, -0.2]
params_list = [params] * len(trotter_circuit_list)
# Observable
Zs = np.eye(num_qubits, dtype=bool)
Xs = np.zeros((num_qubits, num_qubits), dtype=bool)
obs = qi.SparsePauliOp(qi.PauliList.from_symplectic(Zs, Xs), 1/num_qubits)
obs_list = [obs]*len(trotter_circuit_list)
# If True run jobs, this can be set to false to avoid re-running jobs when re-running the notebok
# If you are loading saved jobs
run_sim_jobs = True
run_device_jobs = False
# Store all jobs
if run_sim_jobs or run_device_jobs:
jobs = {}
jobs_ids = {}
import numpy as np
import scipy.linalg as la
import qiskit.quantum_info as qi
from qiskit_aer.noise import NoiseModel, coherent_unitary_error
backend_simulator = service.get_backend("ibmq_qasm_simulator")
# Noise model with measure noise, depolarizing and thermal relaxation gate noise
noise_model_rodept1 = NoiseModel.from_backend(backend())
# Noise model without measure noise, with depolarizing and thermal relaxation gate noise
noise_model_dept1 = NoiseModel.from_backend(backend(), readout_error=False, gate_error=True, thermal_relaxation=True)
# Noise model with measure noise and with depolarizing gate noise
noise_model_rodep = NoiseModel.from_backend(backend(), readout_error=True, gate_error=True, thermal_relaxation=False)
# Noise model with only measure noise
noise_model_ro = NoiseModel.from_backend(backend(), readout_error=True, gate_error=False, thermal_relaxation=False)
# Noise model with only depolarizing gate noise
noise_model_dep = NoiseModel.from_backend(backend(), readout_error=False, gate_error=True, thermal_relaxation=False)
# Noise model with only coherent CX gate noise
noise_model_coh = NoiseModel.from_backend(backend(), readout_error=False, gate_error=False, thermal_relaxation=False)
# Noise model with measure noise and coherent CX gate noise
noise_model_rocoh = NoiseModel.from_backend(backend(), readout_error=True, gate_error=False, thermal_relaxation=False)
# Construct the coherent CX noise model errors based on the process fidelity so that they have the
# same process fidelity as the depolarizing errors of the depolarizing noise model
for qubits, error in noise_model_dep._local_quantum_errors['cx'].items():
cos2 = qi.process_fidelity(error)
theta = np.arccos(np.sqrt(cos2))
cx_err = coherent_unitary_error(la.expm(-1j * 0.05 * qi.Operator.from_label("ZZ")))
noise_model_coh.add_quantum_error(cx_err, "cx", qubits)
noise_model_rocoh.add_quantum_error(cx_err, "cx", qubits)
# Labels for noise models
noise_labels = [
"Ideal",
"Measure + Depol + Relax",
"Depol + Relax",
"Measure + Depol",
"Measure",
"Depol",
"Measure + Coherent",
"Coherent",
]
# List of labeled noise models
noise_models = [
None,
noise_model_rodept1,
noise_model_dept1,
noise_model_rodep,
noise_model_ro,
noise_model_dep,
noise_model_rocoh,
noise_model_coh,
]
# Label for option configuration
label_mit = "Unmitigated"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
# Run jobs
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX wo Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX w Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX, Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX wo Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE wo TREX, Gate Twirling"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.twirling.measure = False
options.resilience.measure_noise_mitigation = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "PEC"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_sim_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 3
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
options.simulator.basis_gates = backend.configuration().basis_gates
options.simulator.coupling_map = backend.configuration().coupling_map
options.simulator.seed_simulator = 1337
for label, noise_model in zip(noise_labels, noise_models):
options.simulator.noise_model = noise_model
estimator = Estimator(backend_simulator, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "Unmitigated"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 0
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX wo Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "TREX w Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 1
options.twirling.gates = True
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX, Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE w TREX wo Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "ZNE wo TREX, Gate Twirling"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 2
options.execution.shots = 4 ** 7
options.twirling.gates = False
options.twirling.measure = False
options.resilience.measure_noise_mitigation = False
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
# Label for option configuration
label_mit = "PEC"
label = "Real Device"
if label_mit not in jobs:
jobs[label_mit] = {}
if run_device_jobs:
# Configure estimator options
options = Options()
options.resilience_level = 3
options.execution.shots = 4 ** 7
options.transpilation.initial_layout = initial_layout
options.transpilation.seed_transpiler = 1337
estimator = Estimator(backend, options=options)
job = estimator.run(trotter_circuit_list, obs_list, params_list)
jobs[label_mit][label] = job
print(job.job_id())
jobs_ids[label_mit] = {label: job.job_id() for label, job in jobs[label_mit].items()}
pprint(jobs_ids)
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
# Configure MPL for plotting
plt.rcParams.update({"text.usetex": True})
plt.rcParams["figure.figsize"] = (6, 4)
mpl.rcParams["figure.dpi"] = 200
load_sim_jobs = True
load_device_jobs = True
from qiskit_ibm_runtime import QiskitRuntimeService
# Re-initialize service if note book has been restarted since jobs ran
service = QiskitRuntimeService(channel="ibm_quantum")
jobs_ids = # Paste job IDs dict here
# Load jobs from job ids
jobs = {}
for label_mit, jids in jobs_ids.items():
jobs[label_mit] = {}
for label_noise, jid in jids.items():
if (label_noise == "Real Device" and load_device_jobs) or (label_noise != "Real Device" and load_sim_jobs):
jobs[label_mit][label_noise] = service.job(jid)
# Extract expectation value means and standard errors
means_mit = {}
stderrs_mit = {}
for label_mit, jobs_mit in jobs.items():
means_mit[label_mit] = {}
stderrs_mit[label_mit] = {}
for label_noise, job in jobs_mit.items():
_means = None
_stderrs = None
if job.done():
result = job.result()
_means = np.array(result.values)
_stderrs = np.array([metadata["standard_error"] for metadata in result.metadata])
print(f"LOADED \t| {label_mit}\t| {label_noise}")
else:
print(f"{job.status().name}\t| {label_mit}\t| {label_noise}")
means_mit[label_mit][label_noise] = _means
stderrs_mit[label_mit][label_noise] = _stderrs
# Prefix for saving figures
fig_prefix = "estimator_trotter_6q"
# Organize mitigation method labels for plotting
labels_mit = [
'Unmitigated',
'Gate Twirling',
'TREX w Gate Twirling',
'TREX wo Gate Twirling',
'ZNE wo TREX, Gate Twirling',
'ZNE w TREX wo Gate Twirling',
'ZNE w TREX, Gate Twirling',
'PEC',
]
# Organize noise model labels for plotting
labels_noise = [
'Ideal',
'Real Device',
'Measure',
'Depol',
'Depol + Relax',
'Coherent',
'Measure + Depol',
'Measure + Depol + Relax',
'Measure + Coherent',
]
# Generate subplots
fig, axs = plt.subplots(3, 3, sharex=True, sharey=True, figsize=(10, 10))
# Flatten the array of axes for easy iteration
axs = axs.ravel()
# Add error bar plots to each subplot
for label_noise in labels_noise:
if label_noise == "Real Device":
axs[0].plot([5], [0], 's-', c="red", label=label_noise)
elif label_noise == "Ideal":
continue
else:
axs[0].plot([5], [0], 'o--', label=label_noise)
axs[0].legend()
for ax, label_mit in zip(axs[1:], labels_mit):
means = means_mit[label_mit]
stderrs = stderrs_mit[label_mit]
for label_noise in labels_noise:
if label_noise != "Ideal" and means[label_noise] is not None and means["Ideal"] is not None:
ys = means["Ideal"] - means[label_noise]
yerrs = stderrs["Ideal"] + stderrs[label_noise]
xs = 1 + np.arange(len(ys))
if label_noise == "Real Device":
ax.errorbar(xs, ys, yerrs, fmt = 's-', c="red", capsize=4, label=label_noise)
else:
ax.errorbar(xs, ys, yerrs, fmt = 'o--', capsize=4, label=label_noise)
ax.plot(xs, np.zeros_like(xs), ":", c="black")
ax.set_title(label_mit)
ax.set_xticks(xs)
plt.tight_layout()
plt.savefig(f"{fig_prefix}_mit_vs_noise.pdf")
plt.show()
# Generate subplots
fig, axs = plt.subplots(3, 3, sharex=True, sharey=True, figsize=(10, 10))
# Flatten the array of axes for easy iteration
axs = axs.ravel()
# Add error bar plots to each subplot
for ax, label_noise in zip(axs, labels_noise):
for label_mit in labels_mit:
means = means_mit[label_mit]
stderrs = stderrs_mit[label_mit]
if means[label_noise] is not None and means["Ideal"] is not None:
ys = means["Ideal"] - means[label_noise]
yerrs = stderrs["Ideal"] + stderrs[label_noise]
xs = 1 + np.arange(len(ys))
if label_mit == "Unmitigated":
ax.errorbar(xs, ys, yerrs, fmt = 's-', capsize=4, label=label_mit)
else:
ax.errorbar(xs, ys, yerrs, fmt = 'o--', capsize=4, label=label_mit)
ax.plot(xs, np.zeros_like(xs), ":", c="black")
if label_noise == "Real Device":
title = label_noise
else:
title = f"{label_noise} Sim"
ax.set_title(title)
ax.set_xticks(xs)
if label_noise == "Ideal":
ax.legend()
plt.tight_layout()
plt.savefig(f"{fig_prefix}_noise_vs_mit.pdf")
plt.show()
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
from qiskit import *
# set up circuit (no measurements required)
qc = QuantumCircuit(2)
qc.h(0)
qc.h(1)
qc.rz(3.14/4,1)
# set up simulator that returns statevectors
backend = Aer.get_backend('statevector_simulator')
# run the circuit to get the state vector
state = execute(qc,backend).result().get_statevector()
# now we use some fanciness to display it in latex
from IPython.display import display, Markdown, Latex
def state2latex(state):
state_latex = '\\begin{pmatrix}'
for amplitude in state:
state_latex += str(amplitude) + '\\\\'
state_latex = state_latex[0:-4]
state_latex += '\end{pmatrix}'
display(Markdown(state_latex))
state2latex(state)
|
https://github.com/sintefmath/QuantumPoker
|
sintefmath
|
# Copyright SINTEF 2019
# Authors: Franz G. Fuchs <franzgeorgfuchs@gmail.com>,
# Christian Johnsen <christian.johnsen97@gmail.com>,
# Vemund Falch <vemfal@gmail.com>
from os.path import dirname, abspath
import sys
sys.path.append(dirname(abspath(__file__)))
from Python.interactive import InteractiveContainer
from Python.Board import Board
from Python.Buttons import InteractiveButtons
from Python.helpFiles import distributeGates
from numpy import amax, array, sum, empty, append, argwhere, copy, any, in1d, argsort, zeros
from qiskit import execute, Aer
from time import time
class PokerGame:
def __init__(self, deckOfGates, nPlayers, money, names = None, smallBlind=5, smallBlindPlayer=0,
enableEntanglement=False, seed=None):
if seed == None:
seed = int(time())
self.boards = [Board(boardSeed=seed, enableEntanglement=enableEntanglement) for i in range(nPlayers)]
self.playerGates = distributeGates(deckOfGates, nPlayers)
self.interactive = InteractiveContainer(nPlayers, self.boards[0].getSize(), deckOfGates,
[str(i) for i in range(nPlayers)] if (names is None) else names)
self.interactiveButtons = InteractiveButtons(self.boards[0], self.interactive, self.check, self.fold,
self.playerGates, deckOfGates, self.getPlayer)
self.names = names
self.nPlayers = nPlayers
self.smallBlind = smallBlind
self.allIn = empty(0, dtype=int)
self.haveRaised = False
self.playerMoney = money # Number at index i is player i's money
self.playerBets = array([0 for i in range(nPlayers)], dtype=int) # Number at index i is player i's bet
self.foldedPlayers = []
self.smallBlindPlayer = smallBlindPlayer
self.lastPlayerInRound = (smallBlindPlayer+2)%self.nPlayers
self.player = (smallBlindPlayer+2)%self.nPlayers
self.bettingRound = 0
self.lastRaiser = (smallBlindPlayer+1)%self.nPlayers
self.currentBet = self.smallBlind*2
self.gameOver = False
self.interactive.connectBets(self.interactiveButtons, self.convertRaiseToInt)
self.interactive.connectMouseclick(self.mouseClick)
self.interactive.connectShowHandButton(self.interactiveButtons)
self.doBlindBets()
def doBlindBets(self):
self.playerBets[self.smallBlindPlayer] += self.smallBlind
self.playerBets[(self.smallBlindPlayer+1) % self.nPlayers] += self.smallBlind*2
self.playerMoney[self.smallBlindPlayer] -= self.smallBlind
self.playerMoney[(self.smallBlindPlayer + 1) % self.nPlayers] -= self.smallBlind * 2
self.interactive.updateNextBet(self.playerBets[self.player], amax(self.playerBets))
self.interactive.updateCurrentBets(self.playerBets, self.playerMoney)
self.interactive.setPlayerPatchColor(self.player, self.interactive.getCurrentPlayerColor()[0])
def advanceGame(self):
"""
Moves the game to the next player and round.
:return: None
"""
if len(self.foldedPlayers) >= self.nPlayers - 1:
self.interactive.disconnectShowHandButton()
self.interactive.disconnectBets()
self.interactive.setPlayerPatchColor(self.player, self.interactive.getFoldedColor())
self.endGame(allFolded=True)
return
if len(self.foldedPlayers) + self.allIn.shape[0] == self.nPlayers and self.bettingRound < 4:
advanceRound = True
else:
advanceRound = False
firstIter = True
nextPlayer = self.player
while firstIter or nextPlayer in self.foldedPlayers or (nextPlayer in self.allIn and self.bettingRound < 4):
firstIter = False
nextPlayer = (nextPlayer + 1) % self.nPlayers
if nextPlayer == self.lastPlayerInRound:
advanceRound = True
if len(self.foldedPlayers) + self.allIn.shape[0] >= self.nPlayers - 1 and self.bettingRound < 4 and advanceRound:
self.forwardToRound4()
nextPlayer = self.lastRaiser
elif advanceRound:
if self.bettingRound == 0:
self.showCards(3)
self.interactive.connectBellAndBasis(self.interactiveButtons)
nextPlayer = self.findRoundStarter()
self.lastPlayerInRound = nextPlayer
if self.haveRaised:
self.interactive.setBetandCheck()
self.haveRaised = False
elif self.bettingRound == 1:
self.showCards(1)
nextPlayer = self.findRoundStarter()
self.lastPlayerInRound = nextPlayer
if self.haveRaised:
self.interactive.setBetandCheck()
self.haveRaised = False
elif self.bettingRound == 2:
self.showCards(1)
nextPlayer = self.findRoundStarter()
self.lastPlayerInRound = nextPlayer
if self.haveRaised:
self.interactive.setBetandCheck()
self.haveRaised = False
elif self.bettingRound == 3:
self.interactive.disconnectBets()
self.interactive.disconnectShowHandButton()
self.interactive.connectEnd(self.endGateTurn)
nextPlayer = self.lastRaiser
self.lastPlayerInRound = nextPlayer
elif self.bettingRound == 4: # "Round" in which gates were used
self.endGame()
self.interactive.setPlayerPatchColor(self.player, self.interactive.getDisconnectedColor())
self.interactive.disconnectAllGates()
self.interactive.disconnectEnd()
return
self.bettingRound += 1
if self.bettingRound == 4:
self.interactive.connectAllowedGates(self.interactiveButtons, self.playerGates[nextPlayer])
self.interactiveButtons.changePlayer(self.boards[nextPlayer])
if self.bettingRound == 4:
self.inform("Apply the desired quantum gates\nthen click the end button.")
elif self.bettingRound < 3:
self.interactive.updateNextBet(self.playerBets[nextPlayer], amax(self.playerBets))
self.inform("Place a bet or fold.")
self.updateColor(nextPlayer, self.bettingRound<4)
self.interactive.updateBoard()
self.player = nextPlayer
def findRoundStarter(self):
nextPlayer = self.smallBlindPlayer
while nextPlayer in self.allIn or nextPlayer in self.foldedPlayers:
nextPlayer = (nextPlayer+1)%self.nPlayers
return nextPlayer
def updateColor(self, nextPlayer, active):
if nextPlayer == self.player:
return
if self.player in self.allIn:
self.interactive.setPlayerPatchColor(self.player, self.interactive.getAllInColor()[0])
elif self.player in self.foldedPlayers:
self.interactive.setPlayerPatchColor(self.player, self.interactive.foldedColor)
else:
self.interactive.setPlayerPatchColor(self.player, self.interactive.disconnectedColor)
self.interactive.setPlayerPatchColor(nextPlayer, self.interactive.getCurrentPlayerColor()[0])
def forwardToRound4(self):
while self.bettingRound < 4:
if self.bettingRound == 0:
self.showCards(3)
self.interactive.connectBellAndBasis(self.interactiveButtons)
elif self.bettingRound == 1:
self.showCards(1)
elif self.bettingRound == 2:
self.showCards(1)
self.bettingRound += 1
self.interactive.disconnectBets()
self.interactive.disconnectShowHandButton()
self.interactive.connectEnd(self.endGateTurn)
def endGateTurn(self, event):
"""
Called by the "end" button when a user has finished using their gates.
:return: None
"""
if self.gameOver:
return
self.interactive.disconnectAllGates()
self.advanceGame()
def endGame(self, allFolded=False):
"""
Called when the game is supposed to end.
:return: None
"""
if allFolded:
if len(self.foldedPlayers) == self.nPlayers:
self.inform("Somehow you all folded! No winner.")
self.inform("Exit to start a new game.")
self.gameOver = True
return
for player in range(self.nPlayers):
if player not in self.foldedPlayers:
self.inform(self.names[player] + " won " + str(sum(self.playerBets)) +
" because everyone else folded.")
self.inform("Game over. Exit to start a new game.")
self.gameOver = True
self.playerMoney[player] += sum(self.playerBets)
scoresDisplay = [-1 for i in range(self.nPlayers)]
winnings = [0 for i in range(self.nPlayers)]
winnings[player] = sum(self.playerBets)
scoresDisplay[player] = -2
self.interactive.displayEndResults(scoresDisplay, winnings)
return
simulator = Aer.get_backend("qasm_simulator")
scores = [0 for i in range(self.nPlayers)]
for i in range(self.nPlayers):
if i in self.foldedPlayers:
scores[i] = -1
continue
board = self.boards[i]
board.qc.measure(board.q, board.c)
counts = execute(board.qc, simulator, shots=1).result().get_counts(board.qc)
for bitStr in list(counts.keys())[0]:
if bitStr == "1":
scores[i] += 1
print("\n---- Final scores----")
winners = []
nWinners = 0
maxScore = max(scores)
for i in range(self.nPlayers):
print("Player", i + 1, end=": ")
if scores[i] == -1:
print("Folded")
else:
print(scores[i])
if scores[i] == maxScore:
winners.append(i)
nWinners += 1
self.allIn = self.allIn[argsort(self.playerBets[self.allIn])]
pot = zeros(self.allIn.shape[0]+1, dtype=int)
for nPot in range(self.allIn.shape[0]):
currentPotBet = self.playerBets[self.allIn[nPot]]
for player in range(self.nPlayers):
betToPot = min(self.playerBets[player], currentPotBet)
pot[nPot] += betToPot
self.playerBets[player] -= betToPot
pot[-1] = sum(self.playerBets)
winnings = [0 for i in range(self.nPlayers)]
originalScore = copy(scores)
if self.allIn.shape[0] == 0 or not(any(in1d(array(winners), self.allIn))):
self.printWinners(winners, nWinners, scores, pot[0])
for i in range(len(winners)):
winnings[winners[i]] += pot[0]/nWinners
else:
for i in range(self.allIn.shape[0]):
if pot[i] == 0 or self.allIn[i] not in winners:
pot[i+1] += pot[i]
continue
self.printWinners(winners, nWinners, scores, pot[i])
for j in range(len(winners)):
winnings[winners[j]] += pot[i]/nWinners
scores[self.allIn[i]] = -1
winners = argwhere(scores == amax(scores)).flatten()
nWinners = winners.shape[0]
if not(any(in1d(array(winners), self.allIn))):
pot[-1] = sum(pot[i+1:])
break
if pot[-1] > 0:
self.printWinners(winners, nWinners, scores, pot[-1])
for j in range(len(winners)):
winnings[winners[j]] += pot[-1]/nWinners
self.interactive.displayEndResults(originalScore, winnings)
self.gameOver = True
self.inform("Game over. Exit to start a new game.")
def printWinners(self, winners, nWinners, scores, pot):
if nWinners == 0:
self.inform("No winners!")
elif nWinners == 1:
self.inform(self.names[winners[0]] + " won " + str(pot) + " with a score of " +
str(scores[winners[0]]) + ".")
self.playerMoney[winners[0]] += pot
else:
text = ""
pot /= nWinners
for i in range(nWinners):
self.playerMoney[winners[i]] += pot
text += self.names[winners[i]]
if i == nWinners - 2:
if nWinners != 2:
text += ","
text += " and "
elif i < nWinners - 1:
text += ", "
text += " each won " + str(round(pot, 2)) + " with a score of " + str(scores[winners[0]])
self.inform(text)
def fold(self):
"""
Called by the "fold" button.
:return: None
"""
if self.bettingRound > 3 or self.gameOver:
return
self.interactive.updateCurrentBets(self.playerBets, self.playerMoney)
self.foldedPlayers.append(self.player)
if self.interactiveButtons.getCurrentlyShowingPlayer():
self.interactiveButtons.showHand(None, updateBoard=False)
self.advanceGame()
def check(self):
if self.bettingRound > 3 or self.gameOver:
return
"""
Called by the "check" button.
:return: None
"""
if (self.currentBet-self.playerBets[self.player] > self.playerMoney[self.player]):
self.bet(self.playerMoney[self.player])
else:
self.bet(self.currentBet-self.playerBets[self.player])
def convertRaiseToInt(self, amountStr, text_box):
if text_box is not None:
text_box.set_val("")
try:
amount = int(amountStr)
except ValueError:
self.inform("Enter a valid number.")
return
if amount < 0:
self.inform("Enter a non-negative number.")
return
self.bet(amount + self.currentBet - self.playerBets[self.player])
def bet(self, amount):
"""
Called by the input text box when the user hits enter.
:param amountStr: String that was in the text box, text_box: input box from text
:return: None
"""
if amount == self.playerMoney[self.player]: # All In
self.allIn = append(self.allIn, self.player)
elif amount + self.playerBets[self.player] < self.currentBet:
self.inform("To bet you must either raise or check. Enter a large enough number.")
return
elif amount > self.playerMoney[self.player]:
self.inform("You cannot raise by more than " + str(self.playerMoney[self.player]+\
self.playerBets[self.player]-self.currentBet) + ".")
return
if self.interactiveButtons.getCurrentlyShowingPlayer():
self.interactiveButtons.showHand(None, updateBoard=False)
self.playerBets[self.player] += amount
self.playerMoney[self.player] -= amount
if self.playerBets[self.player] > self.currentBet:
self.currentBet = self.playerBets[self.player]
self.lastRaiser = self.player
self.lastPlayerInRound = self.player
if not (self.haveRaised):
self.interactive.setRaiseandCall()
self.haveRaised = True
self.interactive.updateCurrentBets(self.playerBets, self.playerMoney)
self.interactive.updateNextBet(self.playerBets[(self.player+1)%self.nPlayers], amax(self.playerBets))
self.advanceGame()
def showCards(self, nCards):
"""
Makes nCards more qubits visible on the board.
:param nCards: Number of additional cards to show.
:return: None
"""
self.interactiveButtons.updateQubitsShowing(nCards)
def inform(self, text):
self.interactive.updateInfoText(text)
self.interactive.fig.canvas.draw()
def mouseClick(self, qubit):
"""
Logic for mouseclick
:param qubit: the target qubit
:return: Nothing
"""
if self.gameOver:
return
isGate, button = self.interactiveButtons.mouseClick(qubit)
if isGate:
self.playerGates[self.player][button] -= 1
if self.playerGates[self.player][button] == 0:
del self.playerGates[self.player][button]
self.interactive.disconnectGate(button)
self.interactive.updatePlayerGate(self.playerGates[self.player], hover=True, showZero=True)
self.interactive.updateBoard()
def getPlayer(self):
return self.player
|
https://github.com/Shashankaubaru/NISQ-TDA
|
Shashankaubaru
|
import qiskit
from qiskit import IBMQ
from qiskit.providers.aer import AerSimulator
import qiskit.providers.aer.noise as qnoise
# Generate 3-qubit GHZ state
circ = qiskit.QuantumCircuit(3)
circ.h(0)
circ.cx(0, 1)
circ.cx(1, 2)
circ.measure_all()
# Construct an ideal simulator
aersim = AerSimulator()
# Perform an ideal simulation
result_ideal = qiskit.execute(circ, aersim).result()
counts_ideal = result_ideal.get_counts(0)
print('Counts(ideal):', counts_ideal)
# Counts(ideal): {'000': 493, '111': 531}
# Construct a noisy simulator backend from an IBMQ backend
# This simulator backend will be automatically configured
# using the device configuration and noise model
# provider = IBMQ.load_account()
# backend = provider.get_backend('ibmq_athens')
# aersim_backend = AerSimulator.from_backend(backend)
noise = [0.00001, 0.0001]
gpu = True
# Error probabilities
prob_1 = noise[0] # 1-qubit gate
prob_2 = noise[1] # 2-qubit gate
prob_mat = [[1-prob_2,prob_2],[prob_2,1-prob_2]]
# Depolarizing quantum errors
error_1 = qnoise.depolarizing_error(prob_1, 1)
error_2 = qnoise.depolarizing_error(prob_2, 2)
read_err = qnoise.ReadoutError(prob_mat)
# Add errors to noise model
noise_model = qnoise.NoiseModel()
noise_model.add_all_qubit_quantum_error(error_1, ['u1', 'u2', 'u3'])
noise_model.add_all_qubit_quantum_error(error_2, ['cx'])
noise_model.add_all_qubit_readout_error(read_err)
# Get basis gates from noise model
basis_gates = noise_model.basis_gates
if gpu:
# backend = Aer.get_backend('aer_simulator_statevector_gpu')
if noise is not None:
backend = AerSimulator(device="GPU", noise_model = noise_model, basis_gates= basis_gates,
batched_shots_gpu_max_qubits = 32)
else:
backend = AerSimulator(device="GPU", batched_shots_gpu_max_qubits = 32)
else:
# Perform noisy simulation
if noise is not None:
backend = AerSimulator(device="CPU", noise_model = noise_model, basis_gates= basis_gates)
else:
backend = AerSimulator(device="CPU")
result_noise = qiskit.execute(circ, backend).result()
counts_noise = result_noise.get_counts(0)
print('Counts(noise):', counts_noise)
|
https://github.com/ncitron/qiskit-hack
|
ncitron
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram as ph
%matplotlib inline
# Battleship Grid
## 0 1 2 3 4 5 6 7 8 9
#A - - - - - X X - - -
#B - - X - - - - X X X
#C - - X - - - - - - -
#D - - X - - X - - - -
#E - - - - - X - - - -
#F - - - - - X - - - -
#G - - - - - X - - - -
#H - - - - - - - - - -
#I - - - - - - - - - -
#J - - - - - X X X X X
#Acceptable solutions:
sol = [
'0000101',
'0000110',
'0001100',
'0010001',
'0010010',
'0010011',
'0010110',
'0100000',
'0101010',
'0101101',
'0110111',
'1000001',
'1001011',
'1101100',
'1101101',
'1101110',
'1101111'
]
tot = len(sol)
n = 7
s = []
for i in range(n-1):
s.append(i)
# 17 - 2 # 16 - 2 # 15 - 2 # 14 - 2 # 13 - 2
# 12 - 2 # 11 - 2 # 10 - 2 # 9 - 2
# 8 - 3 # 7 - 3 # 6 - 3 # 5 - 3
# 4 - 4 # 3 - 5 # 2 - 6 # 1 - 8
if tot > 8:
rep = 2
elif tot > 4:
rep = 3
elif tot == 4:
rep = 4
elif tot == 3:
rep = 5
elif tot == 2:
rep = 6
else:
rep = 8
def build_oracle(circuit, solutions):
for i in range(tot):
temp = solutions[i]
for j, yesno in enumerate(reversed(temp)):
if yesno == '0':
circuit.x(j)
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
for k, noyes in enumerate(reversed(temp)):
if noyes == '0':
circuit.x(k)
def amplify(circuit):
circuit.h(range(n))
circuit.x(range(n))
circuit.h(n-1)
circuit.mct(s, n-1)
circuit.h(n-1)
circuit.x(range(n))
circuit.h(range(n))
qc = QuantumCircuit(n)
qc.h(range(n))
for i in range(rep):
qc.barrier()
build_oracle(qc, sol)
qc.barrier()
amplify(qc)
qc.measure_all()
bknd = Aer.get_backend('qasm_simulator')
ph(execute(qc,backend=bknd,shots=1000000).result().get_counts())
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend = simulator, shots = 1).result()
counts = result.get_counts()
print(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.utils import algorithm_globals
algorithm_globals.random_seed = 123456
from sklearn.datasets import make_blobs
features, labels = make_blobs(
n_samples=20,
centers=2,
center_box=(-1, 1),
cluster_std=0.1,
random_state=algorithm_globals.random_seed,
)
from qiskit import BasicAer
from qiskit.utils import QuantumInstance
sv_qi = QuantumInstance(
BasicAer.get_backend("statevector_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
from qiskit.circuit.library import ZZFeatureMap
from qiskit_machine_learning.kernels import QuantumKernel
feature_map = ZZFeatureMap(2)
previous_kernel = QuantumKernel(feature_map=feature_map, quantum_instance=sv_qi)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC(quantum_kernel=previous_kernel)
qsvc.fit(features, labels)
qsvc.score(features, labels)
from qiskit.algorithms.state_fidelities import ComputeUncompute
from qiskit.primitives import Sampler
fidelity = ComputeUncompute(sampler=Sampler())
from qiskit_machine_learning.kernels import FidelityQuantumKernel
feature_map = ZZFeatureMap(2)
new_kernel = FidelityQuantumKernel(feature_map=feature_map, fidelity=fidelity)
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC(quantum_kernel=new_kernel)
qsvc.fit(features, labels)
qsvc.score(features, labels)
from qiskit import QuantumCircuit
from qiskit.circuit.library import RealAmplitudes
num_inputs = 2
feature_map = ZZFeatureMap(num_inputs)
ansatz = RealAmplitudes(num_inputs, reps=1)
circuit = QuantumCircuit(num_inputs)
circuit.compose(feature_map, inplace=True)
circuit.compose(ansatz, inplace=True)
def parity(x):
return "{:b}".format(x).count("1") % 2
initial_point = algorithm_globals.random.random(ansatz.num_parameters)
from qiskit_machine_learning.neural_networks import CircuitQNN
circuit_qnn = CircuitQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=2,
quantum_instance=sv_qi,
)
from qiskit.algorithms.optimizers import COBYLA
from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
classifier = NeuralNetworkClassifier(
neural_network=circuit_qnn,
loss="cross_entropy",
one_hot=True,
optimizer=COBYLA(maxiter=40),
initial_point=initial_point,
)
classifier.fit(features, labels)
classifier.score(features, labels)
from qiskit.primitives import Sampler
sampler = Sampler()
from qiskit_machine_learning.neural_networks import SamplerQNN
sampler_qnn = SamplerQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=2,
sampler=sampler,
)
classifier = NeuralNetworkClassifier(
neural_network=sampler_qnn,
loss="cross_entropy",
one_hot=True,
optimizer=COBYLA(maxiter=40),
initial_point=initial_point,
)
classifier.fit(features, labels)
classifier.score(features, labels)
import numpy as np
num_samples = 20
eps = 0.2
lb, ub = -np.pi, np.pi
features = (ub - lb) * np.random.rand(num_samples, 1) + lb
labels = np.sin(features[:, 0]) + eps * (2 * np.random.rand(num_samples) - 1)
from qiskit.circuit import Parameter
num_inputs = 1
feature_map = QuantumCircuit(1)
feature_map.ry(Parameter("input"), 0)
ansatz = QuantumCircuit(1)
ansatz.ry(Parameter("weight"), 0)
circuit = QuantumCircuit(num_inputs)
circuit.compose(feature_map, inplace=True)
circuit.compose(ansatz, inplace=True)
initial_point = algorithm_globals.random.random(ansatz.num_parameters)
from qiskit.opflow import PauliSumOp, StateFn
from qiskit_machine_learning.neural_networks import OpflowQNN
observable = PauliSumOp.from_list([("Z", 1)])
operator = StateFn(observable, is_measurement=True) @ StateFn(circuit)
opflow_qnn = OpflowQNN(
operator=operator,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
quantum_instance=sv_qi,
)
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit_machine_learning.algorithms import NeuralNetworkRegressor
regressor = NeuralNetworkRegressor(
neural_network=opflow_qnn,
optimizer=L_BFGS_B(maxiter=5),
initial_point=initial_point,
)
regressor.fit(features, labels)
regressor.score(features, labels)
from qiskit.primitives import Estimator
estimator = Estimator()
from qiskit_machine_learning.neural_networks import EstimatorQNN
estimator_qnn = EstimatorQNN(
circuit=circuit,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
estimator=estimator,
)
from qiskit.algorithms.optimizers import L_BFGS_B
from qiskit_machine_learning.algorithms import VQR
regressor = NeuralNetworkRegressor(
neural_network=estimator_qnn,
optimizer=L_BFGS_B(maxiter=5),
initial_point=initial_point,
)
regressor.fit(features, labels)
regressor.score(features, labels)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/dimple12M/Qiskit-Certification-Guide
|
dimple12M
|
from qiskit.providers.aer import AerProvider,Aer
from qiskit import QuantumCircuit
from qiskit.test.mock import FakeVigo
provider=AerProvider()
backend_list=provider.backends()
backend_list
backend_list[0].name()
for name in backend_list:
print(name)
backend=provider.backends(name='qasm_simulator')
backend
backend=provider.get_backend(name='qasm_simulator')
backend
backend.name()
type(provider.backends()[0])
provider.backends()[0].name()
print(provider.backends()[0])
print(provider.backends()[-1])
provider.backends()[0:8]
provider.backends()[8:-1]
from qiskit.providers.aer import AerSimulator
backend=AerSimulator()
backend
backend.name()
qc=QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
qc.measure_all()
qc.draw(output="mpl")
backend=AerSimulator()
result= backend.run(qc).result()
counts=result.get_counts()
print(counts)
backend=AerSimulator.from_backend(FakeVigo())
result= backend.run(qc).result()
counts=result.get_counts()
print(counts)
backend=provider.backends(name='aer_simulator')
backend
backend=provider.get_backend(name='aer_simulator')
backend
backend.name()
backend=Aer.backends(name='aer_simulator')
backend
backend=Aer.get_backend(name='aer_simulator')
backend
backend.name()
#from qiskit.providers.aer import AerSimulator
backend=AerSimulator() # creates an object of class AerSimulator
backend
backend.name()
|
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":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019, 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test Measurement Error Mitigation"""
import unittest
from test.python.algorithms import QiskitAlgorithmsTestCase
from ddt import ddt, data, unpack
import numpy as np
import rustworkx as rx
from qiskit import QuantumCircuit, execute
from qiskit.quantum_info import Pauli
from qiskit.exceptions import QiskitError
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit_algorithms import VQE, QAOA
from qiskit.opflow import I, X, Z, PauliSumOp
from qiskit_algorithms.optimizers import SPSA, COBYLA
from qiskit.circuit.library import EfficientSU2
from qiskit.utils.mitigation import CompleteMeasFitter, TensoredMeasFitter
from qiskit.utils.measurement_error_mitigation import build_measurement_error_mitigation_circuits
from qiskit.utils import optionals
if optionals.HAS_AER:
# pylint: disable=no-name-in-module
from qiskit import Aer
from qiskit.providers.aer import noise
if optionals.HAS_IGNIS:
# pylint: disable=no-name-in-module
from qiskit.ignis.mitigation.measurement import (
CompleteMeasFitter as CompleteMeasFitter_IG,
TensoredMeasFitter as TensoredMeasFitter_IG,
)
@ddt
class TestMeasurementErrorMitigation(QiskitAlgorithmsTestCase):
"""Test measurement error mitigation."""
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
@data(
("CompleteMeasFitter", None, False),
("TensoredMeasFitter", None, False),
("TensoredMeasFitter", [[0, 1]], True),
("TensoredMeasFitter", [[1], [0]], False),
)
@unpack
def test_measurement_error_mitigation_with_diff_qubit_order(
self,
fitter_str,
mit_pattern,
fails,
):
"""measurement error mitigation with different qubit order"""
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
fitter_cls = (
CompleteMeasFitter if fitter_str == "CompleteMeasFitter" else TensoredMeasFitter
)
backend = Aer.get_backend("aer_simulator")
with self.assertWarns(DeprecationWarning):
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
shots=1000,
noise_model=noise_model,
measurement_error_mitigation_cls=fitter_cls,
cals_matrix_refresh_period=0,
mit_pattern=mit_pattern,
)
# circuit
qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc2 = QuantumCircuit(2, 2)
qc2.h(0)
qc2.cx(0, 1)
qc2.measure(1, 0)
qc2.measure(0, 1)
with self.assertWarns(DeprecationWarning):
if fails:
self.assertRaisesRegex(
QiskitError,
"Each element in the mit pattern should have length 1.",
quantum_instance.execute,
[qc1, qc2],
)
else:
quantum_instance.execute([qc1, qc2])
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
# failure case
qc3 = QuantumCircuit(3, 3)
qc3.h(2)
qc3.cx(1, 2)
qc3.measure(2, 1)
qc3.measure(1, 2)
with self.assertWarns(DeprecationWarning):
self.assertRaises(QiskitError, quantum_instance.execute, [qc1, qc3])
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
@data(("CompleteMeasFitter", None), ("TensoredMeasFitter", [[0], [1]]))
def test_measurement_error_mitigation_with_vqe(self, config):
"""measurement error mitigation test with vqe"""
fitter_str, mit_pattern = config
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
fitter_cls = (
CompleteMeasFitter if fitter_str == "CompleteMeasFitter" else TensoredMeasFitter
)
backend = Aer.get_backend("aer_simulator")
with self.assertWarns(DeprecationWarning):
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=fitter_cls,
mit_pattern=mit_pattern,
)
optimizer = SPSA(maxiter=200)
ansatz = EfficientSU2(2, reps=1)
with self.assertWarns(DeprecationWarning):
h2_hamiltonian = (
-1.052373245772859 * (I ^ I)
+ 0.39793742484318045 * (I ^ Z)
- 0.39793742484318045 * (Z ^ I)
- 0.01128010425623538 * (Z ^ Z)
+ 0.18093119978423156 * (X ^ X)
)
with self.assertWarns(DeprecationWarning):
vqe = VQE(ansatz=ansatz, optimizer=optimizer, quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian)
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
def _get_operator(self, weight_matrix):
"""Generate Hamiltonian for the max-cut problem of a graph.
Args:
weight_matrix (numpy.ndarray) : adjacency matrix.
Returns:
PauliSumOp: operator for the Hamiltonian
float: a constant shift for the obj function.
"""
num_nodes = weight_matrix.shape[0]
pauli_list = []
shift = 0
for i in range(num_nodes):
for j in range(i):
if weight_matrix[i, j] != 0:
x_p = np.zeros(num_nodes, dtype=bool)
z_p = np.zeros(num_nodes, dtype=bool)
z_p[i] = True
z_p[j] = True
pauli_list.append([0.5 * weight_matrix[i, j], Pauli((z_p, x_p))])
shift -= 0.5 * weight_matrix[i, j]
opflow_list = [(pauli[1].to_label(), pauli[0]) for pauli in pauli_list]
with self.assertWarns(DeprecationWarning):
return PauliSumOp.from_list(opflow_list), shift
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
def test_measurement_error_mitigation_qaoa(self):
"""measurement error mitigation test with QAOA"""
algorithm_globals.random_seed = 167
backend = Aer.get_backend("aer_simulator")
w = rx.adjacency_matrix(
rx.undirected_gnp_random_graph(5, 0.5, seed=algorithm_globals.random_seed)
)
qubit_op, _ = self._get_operator(w)
initial_point = np.asarray([0.0, 0.0])
# Compute first without noise
with self.assertWarns(DeprecationWarning):
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
)
with self.assertWarns(DeprecationWarning):
qaoa = QAOA(
optimizer=COBYLA(maxiter=3),
quantum_instance=quantum_instance,
initial_point=initial_point,
)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
ref_eigenvalue = result.eigenvalue.real
# compute with noise
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
with self.assertWarns(DeprecationWarning):
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
noise_model=noise_model,
measurement_error_mitigation_cls=CompleteMeasFitter,
shots=10000,
)
with self.assertWarns(DeprecationWarning):
qaoa = QAOA(
optimizer=COBYLA(maxiter=3),
quantum_instance=quantum_instance,
initial_point=initial_point,
)
result = qaoa.compute_minimum_eigenvalue(operator=qubit_op)
self.assertAlmostEqual(result.eigenvalue.real, ref_eigenvalue, delta=0.05)
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
@unittest.skipUnless(optionals.HAS_IGNIS, "qiskit-ignis is required to run this test")
@data("CompleteMeasFitter", "TensoredMeasFitter")
def test_measurement_error_mitigation_with_diff_qubit_order_ignis(self, fitter_str):
"""measurement error mitigation with different qubit order"""
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
fitter_cls = (
CompleteMeasFitter_IG if fitter_str == "CompleteMeasFitter" else TensoredMeasFitter_IG
)
backend = Aer.get_backend("aer_simulator")
with self.assertWarns(DeprecationWarning):
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=1679,
seed_transpiler=167,
shots=1000,
noise_model=noise_model,
measurement_error_mitigation_cls=fitter_cls,
cals_matrix_refresh_period=0,
)
# circuit
qc1 = QuantumCircuit(2, 2)
qc1.h(0)
qc1.cx(0, 1)
qc1.measure(0, 0)
qc1.measure(1, 1)
qc2 = QuantumCircuit(2, 2)
qc2.h(0)
qc2.cx(0, 1)
qc2.measure(1, 0)
qc2.measure(0, 1)
if fitter_cls == TensoredMeasFitter_IG:
with self.assertWarnsRegex(DeprecationWarning, r".*ignis.*"):
self.assertRaisesRegex(
QiskitError,
"TensoredMeasFitter doesn't support subset_fitter.",
quantum_instance.execute,
[qc1, qc2],
)
else:
# this should run smoothly
with self.assertWarnsRegex(DeprecationWarning, r".*ignis.*"):
quantum_instance.execute([qc1, qc2])
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
# failure case
qc3 = QuantumCircuit(3, 3)
qc3.h(2)
qc3.cx(1, 2)
qc3.measure(2, 1)
qc3.measure(1, 2)
self.assertRaises(QiskitError, quantum_instance.execute, [qc1, qc3])
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
@unittest.skipUnless(optionals.HAS_IGNIS, "qiskit-ignis is required to run this test")
@data(("CompleteMeasFitter", None), ("TensoredMeasFitter", [[0], [1]]))
def test_measurement_error_mitigation_with_vqe_ignis(self, config):
"""measurement error mitigation test with vqe"""
fitter_str, mit_pattern = config
algorithm_globals.random_seed = 0
# build noise model
noise_model = noise.NoiseModel()
read_err = noise.errors.readout_error.ReadoutError([[0.9, 0.1], [0.25, 0.75]])
noise_model.add_all_qubit_readout_error(read_err)
fitter_cls = (
CompleteMeasFitter_IG if fitter_str == "CompleteMeasFitter" else TensoredMeasFitter_IG
)
backend = Aer.get_backend("aer_simulator")
with self.assertWarns(DeprecationWarning):
quantum_instance = QuantumInstance(
backend=backend,
seed_simulator=167,
seed_transpiler=167,
noise_model=noise_model,
measurement_error_mitigation_cls=fitter_cls,
mit_pattern=mit_pattern,
)
h2_hamiltonian = (
-1.052373245772859 * (I ^ I)
+ 0.39793742484318045 * (I ^ Z)
- 0.39793742484318045 * (Z ^ I)
- 0.01128010425623538 * (Z ^ Z)
+ 0.18093119978423156 * (X ^ X)
)
optimizer = SPSA(maxiter=200)
ansatz = EfficientSU2(2, reps=1)
with self.assertWarnsRegex(DeprecationWarning):
vqe = VQE(ansatz=ansatz, optimizer=optimizer, quantum_instance=quantum_instance)
result = vqe.compute_minimum_eigenvalue(operator=h2_hamiltonian)
self.assertGreater(quantum_instance.time_taken, 0.0)
quantum_instance.reset_execution_results()
self.assertAlmostEqual(result.eigenvalue.real, -1.86, delta=0.05)
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
@unittest.skipUnless(optionals.HAS_IGNIS, "qiskit-ignis is required to run this test")
def test_calibration_results(self):
"""check that results counts are the same with/without error mitigation"""
algorithm_globals.random_seed = 1679
np.random.seed(algorithm_globals.random_seed)
qc = QuantumCircuit(1)
qc.x(0)
qc_meas = qc.copy()
qc_meas.measure_all()
backend = Aer.get_backend("aer_simulator")
counts_array = [None, None]
for idx, is_use_mitigation in enumerate([True, False]):
with self.assertWarns(DeprecationWarning):
if is_use_mitigation:
quantum_instance = QuantumInstance(
backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
shots=1024,
measurement_error_mitigation_cls=CompleteMeasFitter_IG,
)
with self.assertWarnsRegex(DeprecationWarning, r".*ignis.*"):
counts_array[idx] = quantum_instance.execute(qc_meas).get_counts()
else:
quantum_instance = QuantumInstance(
backend,
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
shots=1024,
)
counts_array[idx] = quantum_instance.execute(qc_meas).get_counts()
self.assertEqual(
counts_array[0], counts_array[1], msg="Counts different with/without fitter."
)
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
def test_circuit_modified(self):
"""tests that circuits don't get modified on QI execute with error mitigation
as per issue #7449
"""
algorithm_globals.random_seed = 1679
np.random.seed(algorithm_globals.random_seed)
circuit = QuantumCircuit(1)
circuit.x(0)
circuit.measure_all()
with self.assertWarns(DeprecationWarning):
qi = QuantumInstance(
Aer.get_backend("aer_simulator"),
seed_simulator=algorithm_globals.random_seed,
seed_transpiler=algorithm_globals.random_seed,
shots=1024,
measurement_error_mitigation_cls=CompleteMeasFitter,
)
# The error happens on transpiled circuits since "execute" was changing the input array
# Non transpiled circuits didn't have a problem because a new transpiled array was created
# internally.
circuits_ref = qi.transpile(circuit) # always returns a new array
circuits_input = circuits_ref.copy()
with self.assertWarns(DeprecationWarning):
_ = qi.execute(circuits_input, had_transpiled=True)
self.assertEqual(circuits_ref, circuits_input, msg="Transpiled circuit array modified.")
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required for this test")
def test_tensor_subset_fitter(self):
"""Test the subset fitter method of the tensor fitter."""
# Construct a noise model where readout has errors of different strengths.
noise_model = noise.NoiseModel()
# big error
read_err0 = noise.errors.readout_error.ReadoutError([[0.90, 0.10], [0.25, 0.75]])
# ideal
read_err1 = noise.errors.readout_error.ReadoutError([[1.00, 0.00], [0.00, 1.00]])
# small error
read_err2 = noise.errors.readout_error.ReadoutError([[0.98, 0.02], [0.03, 0.97]])
noise_model.add_readout_error(read_err0, (0,))
noise_model.add_readout_error(read_err1, (1,))
noise_model.add_readout_error(read_err2, (2,))
mit_pattern = [[idx] for idx in range(3)]
backend = Aer.get_backend("aer_simulator")
backend.set_options(seed_simulator=123)
with self.assertWarns(DeprecationWarning):
mit_circuits = build_measurement_error_mitigation_circuits(
[0, 1, 2],
TensoredMeasFitter,
backend,
backend_config={},
compile_config={},
mit_pattern=mit_pattern,
)
result = execute(mit_circuits[0], backend, noise_model=noise_model).result()
fitter = TensoredMeasFitter(result, mit_pattern=mit_pattern)
cal_matrices = fitter.cal_matrices
# Check that permutations and permuted subsets match.
for subset in [[1, 0], [1, 2], [0, 2], [2, 0, 1]]:
with self.subTest(subset=subset):
with self.assertWarns(DeprecationWarning):
new_fitter = fitter.subset_fitter(subset)
for idx, qubit in enumerate(subset):
self.assertTrue(np.allclose(new_fitter.cal_matrices[idx], cal_matrices[qubit]))
self.assertRaisesRegex(
QiskitError,
"Qubit 3 is not in the mit pattern",
fitter.subset_fitter,
[0, 2, 3],
)
# Test that we properly correct a circuit with permuted measurements.
circuit = QuantumCircuit(3, 3)
circuit.x(range(3))
circuit.measure(1, 0)
circuit.measure(2, 1)
circuit.measure(0, 2)
result = execute(
circuit, backend, noise_model=noise_model, shots=1000, seed_simulator=0
).result()
with self.subTest(subset=subset):
with self.assertWarns(DeprecationWarning):
new_result = fitter.subset_fitter([1, 2, 0]).filter.apply(result)
# The noisy result should have a poor 111 state, the mit. result should be good.
self.assertTrue(result.get_counts()["111"] < 800)
self.assertTrue(new_result.get_counts()["111"] > 990)
if __name__ == "__main__":
unittest.main()
|
https://github.com/acfilok96/Quantum-Computation
|
acfilok96
|
from qiskit import *
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr)
%matplotlib inline
circuit.draw(output='mpl')
circuit.h(qr[0])
circuit.draw(output = 'mpl')
circuit.cx(qr[0], qr[1])
circuit.draw(output='mpl')
circuit.measure(qr, cr)
circuit.draw(output='mpl')
simulator = Aer.get_backend('qasm_simulator')
execute(circuit, backend=simulator)
result = execute(circuit, backend=simulator).result()
from qiskit.tools.visualization import plot_histogram
plot_histogram(result.get_counts(circuit))
from qiskit import IBMQ
MY_API_TOKEN = "b32678329f7f6dd426b8cf18f20bea23c2cd056b0bee2b4bcf49744b612e598f20f7170a8da4bfd99b009b6fa59d596edea7a6926fd388be158843d8e******"
IBMQ.save_account(MY_API_TOKEN, overwrite=True)
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
provider.backends()
backend = provider.get_backend('ibmq_santiago')
job =execute(circuit, backend= backend)
from qiskit.tools.monitor import job_monitor
job_monitor(job)
result = job.result()
# plot_histogram
plot_histogram(result.get_counts(circuit))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
ghz = QuantumCircuit(15)
ghz.h(0)
ghz.cx(0, range(1, 15))
ghz.draw(output='mpl')
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
%load_ext autoreload
%autoreload 2
import os
import warnings
import numpy as np
import pyEPR as epr
import qiskit_metal as metal
from collections import OrderedDict
import scqubits as scq
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal import designs, draw, MetalGUI, Dict, Headings
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from qiskit_metal.analyses.quantization import LOManalysis, EPRanalysis
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
from qiskit_metal.qlibrary.lumped.cap_3_interdigital import Cap3Interdigital
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
ws_path = os.getcwd()
warnings.filterwarnings("ignore")
design = designs.DesignPlanar()
design.overwrite_enabled = True
#constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.screenshot(name="full_design.png")
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
# CPW busline length is determined to be 7 mm
cpw[0].options.total_length = '7.0mm'
cpw[1].options.total_length = '7.0mm'
cpw[2].options.total_length = '7.0mm'
cpw[3].options.total_length = '7.0mm'
gui.rebuild()
gui.autoscale()
# qubit 1 design target f: 5.25 GHz
# readout resonator target f: 7.05 GHz
# qubit 2 design target f: 5.42 GHz
# readout resonator target f: 7.22 GHz
# qubit 3 design target f: 5.58 GHz
# readout resonator target f: 7.38 GHz
# qubit 4 design target f: 5.75 GHz
# readout resonator target f: 7.55 GHz
# tuning parameters
C_JJ4f = 2
L_JJ4f = 9.8
C_JJ4 = str(C_JJ4f)+' fF'
L_JJ4 = str(L_JJ4f)+' nH'
transmons[3].options.pad_gap = '35um'
transmons[3].options.pad_width = '510um'
transmons[3].options.pad_height = '125um'
transmons[3].options.connection_pads.c.pad_gap = '30um'
transmons[3].options.connection_pads.a.pad_gap = '15um' # cpw5
transmons[3].options.connection_pads.a.pad_width = '40um' # cpw5
transmons[3].options.connection_pads.b.pad_gap = '15um' # cpw3
transmons[3].options.connection_pads.b.pad_width = '40um' # cpw3
readout_lines[3].options.total_length = '7.5mm'
gui.rebuild()
gui.autoscale()
# EPR analysis
eig_q4 = EPRanalysis(design, "hfss")
hfss4 = eig_q4.sim.renderer
hfss4.start()
hfss4.activate_ansys_design("TransmonQ4", 'eigenmode')
hfss4.render_design(['Q4', 'ol4', 'cpw3', 'cpw5'], [('cpw3', 'end'), ('cpw5', 'start'), ('ol4', 'end')])
# Analysis properties
setup4 = hfss4.pinfo.setup
setup4.n_modes = 6
setup4.passes = 10
setup4.min_freq_ghz = 4
print(f"""
Number of eigenmodes to find = {setup4.n_modes}
Number of simulation passes = {setup4.passes}
Convergence freq max delta percent diff = {setup4.delta_f}
""")
pinfo4 = hfss4.pinfo
pinfo4.design.set_variable('Lj4', L_JJ4)
pinfo4.design.set_variable('Cj4', C_JJ4)
setup4.analyze()
eig_q4.sim.convergence_t, eig_q4.sim.convergence_f, _ = hfss4.get_convergences()
eig_q4.sim.plot_convergences()
pinfo4.junctions['jj'] = {'Lj_variable': 'Lj4', 'rect': 'JJ_rect_Lj_Q4_rect_jj',
'line': 'JJ_Lj_Q4_rect_jj_', 'Cj_variable': 'Cj4'}
pinfo4.validate_junction_info()
pinfo4.dissipative['dielectrics_bulk'] = ['main']
hfss4.set_mode(1, "Setup")
hfss4.modeler._modeler.ShowWindow()
hfss4.plot_fields('main')
eprd4 = epr.DistributedAnalysis(pinfo4)
ℰ_elec = eprd4.calc_energy_electric()
ℰ_elec_substrate = eprd4.calc_energy_electric(None, 'main')
ℰ_mag = eprd4.calc_energy_magnetic()
print(f"""
ℰ_elec_all = {ℰ_elec}
ℰ_elec_substrate = {ℰ_elec_substrate}
EPR of substrate = {ℰ_elec_substrate / ℰ_elec * 100 :.1f}%
ℰ_mag_all = {ℰ_mag}
ℰ_mag % of ℰ_elec_all = {ℰ_mag / ℰ_elec * 100 :.1f}%
""")
eprd4.do_EPR_analysis()
#epra4 = epr.QuantumAnalysis(eprd4.data_filename)
#epra4.analyze_all_variations(cos_trunc = 8, fock_trunc = 7)
c4 = LOManalysis(design, "q3d")
q3d4 = c4.sim.renderer
q3d4.start()
q3d4.activate_ansys_design("TransmonQ4_q3d", 'capacitive')
q3d4.render_design(['Q4'], [('Q4', 'a'),('Q4', 'b'),('Q4', 'c')])
q3d4.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5, percent_error=0.1)
q3d4.analyze_setup("Setup")
c4.sim.capacitance_matrix, c4.sim.units = q3d4.get_capacitance_matrix()
c4.sim.capacitance_all_passes, _ = q3d4.get_capacitance_all_passes()
c4.sim.capacitance_matrix
c4.setup.junctions = Dict({'Lj':L_JJ4f, 'Cj':C_JJ4f})
c4.setup.freq_readout = 7.45
c4.setup.freq_bus = [8.25, 8.25, 15]
c4.run_lom()
c4.lumped_oscillator_all
QuantumSystemRegistry.registry()
# Q4
path4= ws_path+"/Project71_TransmonQ4_q3d.txt"
t4_mat, _, _, _ = load_q3d_capacitance_matrix(path4)
# Cell 4 Transmon-4
opt4 = dict(
node_rename = {'a_connector_pad_Q4': 'cpw5',
'b_connector_pad_Q4': 'cpw3',
'c_connector_pad_Q4': 'readout4'},
cap_mat = t4_mat,
ind_dict = {('pad_top_Q4', 'pad_bot_Q4'): L_JJ4f}, # junction inductance in nH
jj_dict = {('pad_top_Q4', 'pad_bot_Q4'): 'j4'},
cj_dict = {('pad_top_Q4', 'pad_bot_Q4'): C_JJ4f} # junction capacitance in fF
)
cell_4 = Cell(opt4)
# subsystem 1: Transmon-4
transmon4 = Subsystem(name='transmon4', sys_type='TRANSMON', nodes=['j4'])
# Resonator Subsystems
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * 3e8 # phase velocity
)
# subsystem 3: Q2 readout resonator
ro4 = Subsystem(name='readout4', sys_type='TL_RESONATOR', nodes=['readout4'], q_opts=dict(f_res = 7.57, **q_opts))
# subsystem 4: bus3 resonator
cpw3 = Subsystem(name='cpw3', sys_type='TL_RESONATOR', nodes=['cpw3'], q_opts=dict(f_res = 8.2, **q_opts))
# subsystem 15: bus5 resonator
cpw5 = Subsystem(name='cpw5', sys_type='TL_RESONATOR', nodes=['cpw5'], q_opts=dict(f_res = 8.29, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon4, ro4, cpw3, cpw5],
cells=[cell_4],
grd_node='ground_main_plane',
nodes_force_keep=['readout4', 'cpw3', 'cpw5']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
from qiskit import QuantumCircuit,execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
import math
qc = QuantumCircuit(2,2)
qc.h(0)
qc.h(1)
qc.measure([0,1],[0,1])
print("This is |++>:")
print(qc)
simulator=AerSimulator()
job=execute(qc, backend=simulator, shots=1000)
result=job.result()
counts=result.get_counts(qc)
print("Counts:",counts)
plot_histogram(counts)
|
https://github.com/KMU-quantum-classroom/qiskit-classroom-converter
|
KMU-quantum-classroom
|
"""
QuantumCircuit to Bra-ket Notation Converter
"""
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you 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.
from typing import List
from loguru import logger
from qiskit import QuantumCircuit
from sympy import SympifyError, simplify, expand, latex
from sympy.parsing.latex import parse_latex
from qiskit_class_converter.converters.base import BaseConverter
class QuantumCircuitToBraketNotationConverter(BaseConverter):
"""
Converter class
"""
# pylint: disable-next = too-many-return-statements
def actual_convert_action(self):
self.logger.debug("quantum circuit to bra-ket notation")
self.input_value.save_statevector()
# type validate
if isinstance(self.input_value, (List, QuantumCircuit)):
result = self.qiskit_aer.AerSimulator().run(self.input_value).result()
else:
raise TypeError("QuantumCircuit is required.")
source = result.get_statevector().draw("latex_source")
try:
if (self.option.get("expression", False) == "simplify") and \
(self.option.get("print", False) == "raw"):
return latex(simplify(parse_latex(source)))
if self.option.get("expression", False) == "simplify":
return str(simplify(parse_latex(source)))
if (self.option.get("expression", False) == "expand") and \
(self.option.get("print", False) == "raw"):
return latex(expand(parse_latex(source)))
if self.option.get("expression", False) == "expand":
return str(expand(parse_latex(source)))
if self.option.get("print", False) == "raw":
return str(source)
return str(parse_latex(source))
except SympifyError:
# case : 01>
logger.warning("It caught a SympifyError, so it outputs source text.")
return source
|
https://github.com/quantum-tokyo/qiskit-handson
|
quantum-tokyo
|
# Qiskitライブラリーを導入
from qiskit import *
from qiskit.visualization import *
# 描画のためのライブラリーを導入
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# Qiskitバージョンの確認
qiskit.__qiskit_version__
q = QuantumCircuit(1) # １量子ビット回路を用意
q.x(0) # Xゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
# Hゲートを0番目の量子ビットに操作します。
q.h(0)
# 次にZゲートを0番目の量子ビットに操作します。
q.z(0)
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.s(0) # 次にSゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.t(0) # 次にTゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(1) # １量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.u1(np.pi/8,0) # 次にU1ゲートを0番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(2) # 2量子ビット回路を用意
q.h(0) # Hゲートを0番目の量子ビットに操作します。
q.h(1) # Hゲートを1番目の量子ビットに操作します。
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
q = QuantumCircuit(2) # 2量子ビット回路を用意
# q0=|1>, q1=|+>の場合：
q.x(0)
q.h(1)
# CU1ゲートの制御ビットをq0、目標ビットをq1、角度をpi/2にセットします。
q.cu1(np.pi/2,0,1)
q.draw(output="mpl") # 回路を描画
# 状態ベクトルシミュレーターの実行
backend = Aer.get_backend('statevector_simulator')
result = execute(q, backend).result().get_statevector(q, decimals=3)
print(result)
plot_bloch_multivector(result) # ブロッホ球の表示
|
https://github.com/Harcipan/QAI_GroverSim
|
Harcipan
|
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from ibm_quantum_widgets import *
# qiskit-ibmq-provider has been deprecated.
# Please see the Migration Guides in https://ibm.biz/provider_migration_guide for more detail.
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Estimator, Session, Options
# Loading your IBM Quantum account(s)
service = QiskitRuntimeService(channel="ibm_quantum")
IBMQ.load_account()
# Invoke a primitive. For more details see https://docs.quantum.ibm.com/run/primitives
# result = Sampler().run(circuits).result()
from qiskit import QuantumRegister, ClassicalRegister
from qiskit import QuantumCircuit, execute, IBMQ
from qiskit.tools.monitor import job_monitor
from qiskit.circuit.library import QFT
import numpy as np
pi = np.pi
# IBMQ.enable_account('ENTER API KEY HERE')
provider = IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_qasm_simulator')
q = QuantumRegister(5, 'q')
c = ClassicalRegister(5, 'c')
circuit = QuantumCircuit(q, c)
circuit.x(q[4])
circuit.x(q[2])
circuit.x(q[0])
qft_gate = QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=False, insert_barriers=False, name='qft')
circuit.append(qft_gate, q)
circuit.measure(q, c)
circuit.draw(output='mpl', filename='qft1.png')
print(circuit)
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
print("\n QFT Output")
print("-------------")
print(counts)
q = QuantumRegister(5,'q')
c = ClassicalRegister(5,'c')
circuit = QuantumCircuit(q,c)
circuit.x(q[4])
circuit.x(q[2])
circuit.x(q[0])
qft_gate2 = QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=False, insert_barriers=True, name='qft')
qft_gate3 = QFT(num_qubits=5, approximation_degree=0, do_swaps=True, inverse=True, insert_barriers=True, name='qft')
circuit.append(qft_gate2, q)
circuit.append(qft_gate3, q)
circuit.measure(q,c)
circuit.draw(output='mpl',filename='qft2.png')
print(circuit)
job = execute(circuit, backend, shots=1000)
job_monitor(job)
counts = job.result().get_counts()
print("\n QFT with inverse QFT Output")
print("------------------------------")
print(counts)
|
https://github.com/Ilan-Bondarevsky/qiskit_algorithm
|
Ilan-Bondarevsky
|
from qiskit import QuantumCircuit as QiskitQuantumCircuit
from qiskit.quantum_info import Operator, Statevector, DensityMatrix, StabilizerState
from qiskit import QuantumCircuit, AncillaRegister, ClassicalRegister, QuantumRegister
class QuantumCircuit(QiskitQuantumCircuit):
def get_unitary_matrix(self, input_dims=None, output_dims=None):
return Operator(self, input_dims, output_dims).data
def get_density_matrix(self, dims: int | tuple | list | None = None):
return DensityMatrix(self, dims)
def get_state_vector(self, dims: int | tuple | list | None = None):
return Statevector(self, dims)
def get_stabilizer_state(self, validate: bool = True):
return StabilizerState(self, validate)
@staticmethod
def from_qiskit_circuit(qiskit_circuit : QiskitQuantumCircuit):
custom_circuit = QuantumCircuit(qiskit_circuit.qubits)
custom_circuit.add_register(qiskit_circuit.clbits)
custom_circuit.data = qiskit_circuit.data.copy() # Copy the operations
custom_circuit.global_phase = qiskit_circuit.global_phase # Copy the global phase
custom_circuit.metadata = qiskit_circuit.metadata # Copy the metadata if any
return custom_circuit
if __name__ == "__main__":
qc = QuantumCircuit(2)
qc.x(0)
qc.h(1)
for func in [qc.draw, qc.get_unitary_matrix, qc.get_density_matrix, qc.get_stabilizer_state, qc.get_state_vector]:
print(f"### Function : {func.__name__} ###")
print(func())
print()
qc = QiskitQuantumCircuit(5)
print(qc.draw())
qc = QuantumCircuit.from_qiskit_circuit(qc)
print(qc.draw())
# print(qc.draw())
# print(qc.get_unitary_matrix())
# print(qc.get_density_matrix())
# print(qc.get_state_vector())
# print(qc.get_stabilizer_state())
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.ignis.mitigation import expectation_value
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("./")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
scale_factors = [1.0, 2.0, 3.0, 4.0, 5.0]
# 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>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder(qc, targets=[0,1,2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
t1 = time.perf_counter()
qc = qc.bind_parameters({dt: target_time / num_steps})
t2 = time.perf_counter()
print("created qc,", t2 - t1, "s")
# Generate state tomography circuits to evaluate fidelity of simulation
t1 = time.perf_counter()
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
t2 = time.perf_counter()
print("created st_qcs (length:", len(st_qcs), "),", t2 - t1, "s")
# remove barriers
t1 = time.perf_counter()
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
t2 = time.perf_counter()
print("removed barriers from st_qcs,", t2 - t1, "s")
# optimize circuit
t1 = time.perf_counter()
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t2 = time.perf_counter()
print("created t3_st_qcs (length:", len(t3_st_qcs), "),", t2 - t1, "s")
t3_st_qcs[0].draw("mpl")
# zne wrapping
t1 = time.perf_counter()
zne_qcs = zne_wrapper(t3_st_qcs, scale_factors=scale_factors)
t2 = time.perf_counter()
print("created zne_qcs (length:", len(zne_qcs), "),", t2 - t1, "s")
t1 = time.perf_counter()
zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"])
t2 = time.perf_counter()
print("decomposed zne_qcs into basis gates (length:", len(zne_qcs), "),", t2 - t1, "s")
t1 = time.perf_counter()
t3_zne_qcs = transpile(zne_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t2 = time.perf_counter()
print("optimized zne_qcs -> create t3_zne_qcs (length:", len(t3_zne_qcs), "),", t2 - t1, "s")
t1 = time.perf_counter()
t3_zne_qcs = transpile(t3_zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
t2 = time.perf_counter()
print("fit the t3_zne_qcs to the initial layoit (length:", len(t3_zne_qcs), "),", t2 - t1, "s")
t3_zne_qcs[-3].draw("mpl")
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
# print("provider:", provider)
# backend = provider.get_backend("ibmq_jakarta")
shots = 1 << 13
reps = 1 # unused
# Number of trotter steps
print("trotter step: ", num_steps)
# execute: reps = 1
job = execute(t3_zne_qcs, backend, shots=shots) # 毎回チェック: ここちゃんと変えた？
print('Job ID', job.job_id())
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
mit_results = meas_fitter.filter.apply(job.result())
zne_expvals = zne_decoder(num_qubits, mit_results, scale_factors=scale_factors)
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
rho = expvals_to_valid_rho(num_qubits, zne_expvals)
fidelity = state_fidelity(rho, target_state)
print(fidelity)
|
https://github.com/GIRISHBELANI/QC_Benchmarks_using_dm-simulator
|
GIRISHBELANI
|
"""
Bernstein-Vazirani Benchmark Program - QSim
"""
import sys
import time
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
sys.path[1:1] = [ "_common", "_common/qsim" ]
sys.path[1:1] = [ "../../_common", "../../_common/qsim" ]
import execute as ex
import metrics as metrics
from execute import BenchmarkResult
# Benchmark Name
benchmark_name = "Bernstein-Vazirani"
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
Uf_ = None
############### Circuit Definition
def create_oracle(num_qubits, input_size, secret_int):
# Initialize first n qubits and single ancilla qubit
qr = QuantumRegister(num_qubits)
qc = QuantumCircuit(qr, name=f"Uf")
# perform CX for each qubit that matches a bit in secret string
s = ('{0:0' + str(input_size) + 'b}').format(secret_int)
for i_qubit in range(input_size):
if s[input_size - 1 - i_qubit] == '1':
qc.cx(qr[i_qubit], qr[input_size])
return qc
def BersteinVazirani (num_qubits, secret_int, method = 1):
# size of input is one less than available qubits
input_size = num_qubits - 1
if method == 1:
# allocate qubits
qr = QuantumRegister(num_qubits); cr = ClassicalRegister(input_size);
qc = QuantumCircuit(qr, cr, name=f"bv({method})-{num_qubits}-{secret_int}")
# put ancilla in |1> state
qc.x(qr[input_size])
# start with Hadamard on all qubits, including ancilla
for i_qubit in range(num_qubits):
qc.h(qr[i_qubit])
qc.barrier()
#generate Uf oracle
Uf = create_oracle(num_qubits, input_size, secret_int)
qc.append(Uf,qr)
qc.barrier()
# start with Hadamard on all qubits, including ancilla
for i_qubit in range(num_qubits):
qc.h(qr[i_qubit])
# uncompute ancilla qubit, not necessary for algorithm
qc.x(qr[input_size])
qc.barrier()
# measure all data qubits
for i in range(input_size):
qc.measure(i, i)
global Uf_
if Uf_ == None or num_qubits <= 6:
if num_qubits < 9: Uf_ = Uf
elif method == 2:
# allocate qubits
qr = QuantumRegister(2); cr = ClassicalRegister(input_size); qc = QuantumCircuit(qr, cr, name="main")
# put ancilla in |-> state
qc.x(qr[1])
qc.h(qr[1])
qc.barrier()
# perform CX for each qubit that matches a bit in secret string
s = ('{0:0' + str(input_size) + 'b}').format(secret_int)
for i in range(input_size):
if s[input_size - 1 - i] == '1':
qc.h(qr[0])
qc.cx(qr[0], qr[1])
qc.h(qr[0])
qc.measure(qr[0], cr[i])
# Perform num_resets reset operations
qc.reset([0]*num_resets)
# save smaller circuit example for display
global QC_
if QC_ == None or num_qubits <= 6:
if num_qubits < 9: QC_ = qc
# return a handle on the circuit
return qc
############### Result Data Analysis
# Analyze and print measured results
# Expected result is always the secret_int, so fidelity calc is simple
def analyze_and_print_result (qc, result, num_qubits, secret_int, num_shots):
# size of input is one less than available qubits
input_size = num_qubits - 1
if result.backend_name == 'dm_simulator':
benchmark_result = BenchmarkResult(result, num_shots)
probs = benchmark_result.get_probs(num_shots) # get results as measured probability
else:
probs = result.get_counts(qc) # get results as measured counts
if verbose: print(f"For secret int {secret_int} measured: {counts}")
# create the key that is expected to have all the measurements (for this circuit)
key = format(secret_int, f"0{input_size}b")
# correct distribution is measuring the key 100% of the time
correct_dist = {key: 1.0}
# use our polarization fidelity rescaling
fidelity = metrics.polarization_fidelity(probs, correct_dist)
return probs, fidelity
################ Benchmark Loop
# Execute program with default parameters
def run (min_qubits=3, max_qubits=8, skip_qubits=1, max_circuits=3, num_shots=100,
backend_id='dm_simulator', method = 1, provider_backend=None,
#hub="ibm-q", group="open", project="main",
exec_options=None,
context=None):
print(f"{benchmark_name} ({method}) Benchmark Program - QSim")
# validate parameters (smallest circuit is 3 qubits)
max_qubits = max(3, max_qubits)
min_qubits = min(max(3, min_qubits), max_qubits)
skip_qubits = max(1, skip_qubits)
#print(f"min, max qubits = {min_qubits} {max_qubits}")
# create context identifier
if context is None: context = f"{benchmark_name} ({method}) Benchmark"
##########
# 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 = True if method ==2 else False
# 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, int(s_int), num_shots)
metrics.store_metric(num_qubits, s_int, 'fidelity', fidelity)
# 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,
context=context)
# for noiseless simulation, set noise model to be None
# ex.set_noise_model(None)
##########
# Execute Benchmark Program N times for multiple circuit sizes
# Accumulate metrics asynchronously as circuits complete
for num_qubits in range(min_qubits, max_qubits + 1, skip_qubits):
input_size = num_qubits - 1
# determine number of circuits to execute for this group
num_circuits = min(2**(input_size), max_circuits)
print(f"************\nExecuting [{num_circuits}] circuits with num_qubits = {num_qubits}")
# determine range of secret strings to loop over
if 2**(input_size) <= max_circuits:
s_range = list(range(num_circuits))
else:
s_range = np.random.choice(2**(input_size), num_circuits, False)
# loop over limited # of secret strings for this
for s_int in s_range:
# If mid circuit, then add 2 to new qubit group since the circuit only uses 2 qubits
if method == 2:
mid_circuit_qubit_group.append(2)
# create the circuit for given qubit size and secret string, store time metric
ts = time.time()
qc = BersteinVazirani(num_qubits, s_int, method).reverse_bits() #reverse_bits() is to change endianness
metrics.store_metric(num_qubits, s_int, 'create_time', time.time()-ts)
# collapse the sub-circuit levels used in this benchmark (for qiskit)
qc2 = qc.decompose()
# submit circuit for execution on target (simulator, cloud simulator, or hardware)
ex.submit_circuit(qc2, 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!")
# Plot metrics for all circuit sizes
metrics.plot_metrics(f"Benchmark Results - {benchmark_name} ({method}) - QSim",
transform_qubit_group = transform_qubit_group, new_qubit_group = mid_circuit_qubit_group)
# if main, execute method
if __name__ == '__main__':
ex.local_args() # calling local_args() needed while taking noise parameters through command line arguments (for individual benchmarks)
run()
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022.
#
# 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.
"""Auxiliary functions for SciPy Time Evolvers"""
from __future__ import annotations
import logging
from scipy.sparse import csr_matrix
from scipy.sparse.linalg import expm_multiply
import numpy as np
from qiskit.quantum_info.states import Statevector
from qiskit.quantum_info.operators.base_operator import BaseOperator
from qiskit import QuantumCircuit
from qiskit.opflow import PauliSumOp
from ..time_evolution_problem import TimeEvolutionProblem
from ..time_evolution_result import TimeEvolutionResult
from ...exceptions import AlgorithmError
from ...list_or_dict import ListOrDict
logger = logging.getLogger(__name__)
def _create_observable_output(
ops_ev_mean: np.ndarray,
evolution_problem: TimeEvolutionProblem,
) -> tuple[ListOrDict[tuple[np.ndarray, np.ndarray]], np.ndarray]:
"""Creates the right output format for the evaluated auxiliary operators.
Args:
ops_ev_mean: Array containing the expectation value of each observable at each timestep.
evolution_problem: Time Evolution Problem to create the output of.
Returns:
An output with the observables mean value at the appropriate times depending on whether
the auxiliary operators in the time evolution problem are a `list` or a `dict`.
"""
aux_ops = evolution_problem.aux_operators
time_array = np.linspace(0, evolution_problem.time, ops_ev_mean.shape[-1])
zero_array = np.zeros(ops_ev_mean.shape[-1]) # std=0 since it is an exact method
operators_number = 0 if aux_ops is None else len(aux_ops)
observable_evolution = [(ops_ev_mean[i], zero_array) for i in range(operators_number)]
if isinstance(aux_ops, dict):
observable_evolution = dict(zip(aux_ops.keys(), observable_evolution))
return observable_evolution, time_array
def _create_obs_final(
ops_ev_mean: np.ndarray,
evolution_problem: TimeEvolutionProblem,
) -> ListOrDict[tuple[complex, complex]]:
"""Creates the right output format for the final value of the auxiliary operators.
Args:
ops_ev_mean: Array containing the expectation value of each observable at the final timestep.
evolution_problem: Evolution problem to create the output of.
Returns:
An output with the observables mean value at the appropriate times depending on whether
the auxiliary operators in the evolution problem are a `list` or a `dict`.
"""
aux_ops = evolution_problem.aux_operators
aux_ops_evaluated: ListOrDict[tuple[complex, complex]] = [(op_ev, 0) for op_ev in ops_ev_mean]
if isinstance(aux_ops, dict):
aux_ops_evaluated = dict(zip(aux_ops.keys(), aux_ops_evaluated))
return aux_ops_evaluated
def _evaluate_aux_ops(
aux_ops: list[csr_matrix],
state: np.ndarray,
) -> np.ndarray:
"""Evaluates the aux operators if they are provided and stores their value.
Returns:
Mean of the aux operators for a given state.
"""
op_means = np.array([np.real(state.conjugate().dot(op.dot(state))) for op in aux_ops])
return op_means
def _operator_to_matrix(operator: BaseOperator | PauliSumOp):
if isinstance(operator, PauliSumOp):
op_matrix = operator.to_spmatrix()
else:
try:
op_matrix = operator.to_matrix(sparse=True)
except TypeError:
logger.debug(
"WARNING: operator of type `%s` does not support sparse matrices. "
"Trying dense computation",
type(operator),
)
try:
op_matrix = operator.to_matrix()
except AttributeError as ex:
raise AlgorithmError(f"Unsupported operator type `{type(operator)}`.") from ex
return op_matrix
def _build_scipy_operators(
evolution_problem: TimeEvolutionProblem, num_timesteps: int, real_time: bool
) -> tuple[np.ndarray, list[csr_matrix], csr_matrix]:
"""Returns the matrices and parameters needed for time evolution in the appropriate format.
Args:
evolution_problem: The definition of the evolution problem.
num_timesteps: Number of timesteps to be performed.
real_time: If `True`, returned operators will correspond to real time evolution,
Else, they will correspond to imaginary time evolution.
Returns:
A tuple with the initial state, the list of operators to evaluate and the operator to be
exponentiated to perform one timestep.
Raises:
ValueError: If the Hamiltonian can not be converted into a sparse matrix or dense matrix.
"""
# Convert the initial state and Hamiltonian into sparse matrices.
if isinstance(evolution_problem.initial_state, QuantumCircuit):
state = Statevector(evolution_problem.initial_state).data
else:
state = evolution_problem.initial_state.data
hamiltonian = _operator_to_matrix(operator=evolution_problem.hamiltonian)
if isinstance(evolution_problem.aux_operators, list):
aux_ops = [
_operator_to_matrix(operator=aux_op) for aux_op in evolution_problem.aux_operators
]
elif isinstance(evolution_problem.aux_operators, dict):
aux_ops = [
_operator_to_matrix(operator=aux_op)
for aux_op in evolution_problem.aux_operators.values()
]
else:
aux_ops = []
timestep = evolution_problem.time / num_timesteps
step_operator = -((1.0j) ** real_time) * timestep * hamiltonian
return state, aux_ops, step_operator
def _evolve(
evolution_problem: TimeEvolutionProblem, num_timesteps: int, real_time: bool
) -> TimeEvolutionResult:
r"""Performs either real or imaginary time evolution :math:`\exp(-i t H)|\Psi\rangle`.
Args:
evolution_problem: The definition of the evolution problem.
num_timesteps: Number of timesteps to be performed.
real_time: If `True`, returned operators will correspond to real time evolution,
Else, they will correspond to imaginary time evolution.
Returns:
Evolution result which includes an evolved quantum state.
Raises:
ValueError: If the Hamiltonian is time dependent.
ValueError: If the initial state is `None`.
"""
if num_timesteps <= 0:
raise ValueError("Variable `num_timesteps` needs to be a positive integer.")
if evolution_problem.t_param is not None:
raise ValueError("Time dependent Hamiltonians are not supported.")
if evolution_problem.initial_state is None:
raise ValueError("Initial state is `None`")
state, aux_ops, step_operator = _build_scipy_operators(
evolution_problem=evolution_problem, num_timesteps=num_timesteps, real_time=real_time
)
# Create empty arrays to store the time evolution of the aux operators.
number_operators = (
0 if evolution_problem.aux_operators is None else len(evolution_problem.aux_operators)
)
ops_ev_mean = np.empty(shape=(number_operators, num_timesteps + 1), dtype=complex)
renormalize = (
(lambda state: state) if real_time else (lambda state: state / np.linalg.norm(state))
)
# Perform the time evolution and stores the value of the operators at each timestep.
for ts in range(num_timesteps):
ops_ev_mean[:, ts] = _evaluate_aux_ops(aux_ops, state)
state = expm_multiply(A=step_operator, B=state)
state = renormalize(state)
ops_ev_mean[:, num_timesteps] = _evaluate_aux_ops(aux_ops, state)
observable_history, times = _create_observable_output(ops_ev_mean, evolution_problem)
aux_ops_evaluated = _create_obs_final(ops_ev_mean[:, -1], evolution_problem)
return TimeEvolutionResult(
evolved_state=Statevector(state),
aux_ops_evaluated=aux_ops_evaluated,
observables=observable_history,
times=times,
)
|
https://github.com/deveshq/Qiskit-Fall-Fest
|
deveshq
|
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile, Aer, IBMQ, execute
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.providers.aer import QasmSimulator
from numpy import pi
from qiskit.circuit import Parameter, ParameterVector
import numpy as np
from numpy import pi, sin, cos, exp
import cmath
degree = 1
scaling = 1
coeffs = [0.15 + 0.15j]*degree
coeff0 = 0.1
#Generate a Fourier series.
def function(x):
res = coeff0
for i,c in enumerate(coeffs):
exponent = complex(0, scaling*(i+1)*x)
conj_c = np.conjugate(c)
res += c * np.exp(exponent) + conj_c * np.exp(-exponent)
return np.real(res)
#Original data points
x = np.linspace(-6,6,70)
y_0 = np.array([function(x_) for x_ in x])
from qiskit.circuit.library import TwoLocal
from qiskit.opflow import CircuitStateFn, CircuitOp
import matplotlib.pyplot as plt
n = 2
qc = QuantumCircuit(n)
num_parameters = 8
#Data encoding circuit
def M(cir, x):
for w in range(n):
cir.rx(scaling*x, w)
return cir
#Trainable circuit block (Defining the ansatz)
def U(theta):
encode = TwoLocal(num_qubits = 2, reps = 1, rotation_blocks=['ry','rz'],
entanglement_blocks='cx', entanglement='full', insert_barriers=True)
return encode.assign_parameters(theta)
#Defining the Quantum Model. Here we are mapping the data to the fourier series.
def Quantum_model(cir, weights, x=None):
weights = weights.reshape(2,num_parameters)
cir = cir.compose(U(weights[0]))
cir = cir.compose(M(cir, x))
cir = cir.compose(U(weights[1]))
cir = CircuitStateFn(cir)
weights = weights.reshape(1,2*num_parameters)
circuit = QuantumCircuit(2)
circuit.z(0)
op = CircuitOp(circuit)
return (cir.adjoint().compose(op).compose(cir).eval().real)*scaling
scaling = 1
weight = 2*np.pi*np.random.random(size = (1,2*num_parameters))
random_y = [Quantum_model(qc, weight, x = x_) for x_ in x]
plt.plot(x,random_y, c='blue')
plt.plot(x,y_0, c = 'red')
plt.show()
def square_loss(targets, predictions):
s = 0
for t, p in zip(targets, predictions):
s = s + (t - p) ** 2
loss = s / 2*len(targets)
return loss
def cost(weights):
y = y_0
predictions = [Quantum_model(qc,weights, x=x_) for x_ in x]
return square_loss(y, predictions)
import scipy.optimize as op
weight2 = op.fmin(lambda w: cost(w), weight, xtol=0.0001, ftol=0.0001, maxiter=100,
maxfun=None, full_output=0, disp=1, retall=0, callback=None)
new_weights = np.array(weight2)
trained_y = [Quantum_model(qc, new_weights, x = x_) for x_ in x]
plt.plot(x, trained_y, c='blue')
plt.plot(x,y_0, c = 'red')
plt.show()
#Computes the first 2*K+1 Fourier coefficients of a 2*pi periodic function.
def fourier_coefficients(f, K):
n_coeffs = 2*K+1
t = np.linspace(0, 2*np.pi, n_coeffs, endpoint=False)
y = np.fft.rfft(f(t)) / t.size
return y
n_coeffs = len(new_weights)
n_samples = 100
coeffs = []
def f(x):
return np.array([Quantum_model(qc, new_weights, x=i) for i in x])
coeffs_sample = fourier_coefficients(f, n_coeffs)
coeffs.append(coeffs_sample)
coeffs = np.array(coeffs)
coeffs_real = np.real(coeffs)
coeffs_imag = np.imag(coeffs)
n_coeffs = len(coeffs_real[0])
fig, ax = plt.subplots(1, n_coeffs, figsize=(15,4))
for idx, ax_ in enumerate(ax):
ax_.set_title(r"$c_{}$".format(idx))
ax_.scatter(coeffs_real[:, idx], coeffs_imag[:, idx], s=35, facecolor='white', edgecolor='red')
ax_.set_aspect("equal")
ax_.set_ylim(-1, 1)
ax_.set_xlim(-1, 1)
plt.tight_layout(pad=0.5)
plt.show()
|
https://github.com/LohitPotnuru/TransverseIsingModelQiskit
|
LohitPotnuru
|
from qiskit import *
from scipy.optimize import minimize
import numpy as np
from pylab import *
#2^4 possible states of four qubits stored in dic
bit = ['0','1']
dic = []
for i in bit:
for j in bit:
for k in bit:
for l in bit:
dic.append(i+j+l+k)
def calcEJ(theta):
#make quantum circuit with 2 qubits
q = QuantumRegister(4)
c = ClassicalRegister(4)
circuit = QuantumCircuit(q,c)
# entangled quantum state preparation
q = circuit.qregs[0]
circuit.u(theta[0], theta[1], 0, q[0])
circuit.cx(q[0],q[1])
circuit.cx(q[0],q[2])
circuit.cx(q[0],q[3])
for i in range(0,4):
circuit.u(theta[i+2],0,0,q[i])
circuit.measure(range(4),range(4))
# Executing the circuit by qasm_simulation to caculate energy from result.get(counts)
shots=18192
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots = shots).result()
counts = result.get_counts()
#make sure that all possible values accounted for to avoid errors
for i in dic:
if i not in counts:
counts[i] = 0
#calculate expectation value in terms of sigma z of qubit i and qubit i+1
def prob(i):
t1=0
t2=0
for j in counts.keys():
if j[i]=='0': t1+=counts[j]
else: t1-=counts[j]
t1=t1/shots
for j in counts.keys():
if j[i+1]=='0': t2+=counts[j]
else: t2-=counts[j]
t2=t2/shots
E=-1*t1*t2
return E
E_J=0
for i in range(0,3): E_J+=prob(i)
return E_J
def calcEZ(theta):
#make quantum circuit with 2 qubits
q = QuantumRegister(4)
c = ClassicalRegister(4)
circuit = QuantumCircuit(q,c)
# entangled quantum state preparation
q = circuit.qregs[0]
circuit.u(theta[0], theta[1], 0, q[0])
circuit.cx(q[0],q[1])
circuit.cx(q[0],q[2])
circuit.cx(q[0],q[3])
for i in range(0,4):
circuit.u(theta[i+2],0,0,q[i])
circuit.h(range(4))
circuit.measure(range(4),range(4))
# Executing the circuit by qasm_simulation to caculate energy from result.get(counts)
shots=18192
backend = BasicAer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots = shots).result()
counts = result.get_counts()
#make sure that all possible values accounted for to avoid errors
for i in dic:
if i not in counts:
counts[i] = 0
#calculate expectation value in terms of sigma x of qubit i
def prob(i):
E=0
for j in counts.keys():
if j[i]=='0': E+=counts[j]
else: E-=counts[j]
E=E/shots
return E
E_Z=0
for i in range(0,3): E_Z+=prob(i)
return E_Z
# expectation value total
def calcE(theta):
# Summing the measurement results
classical_adder = calcEJ(theta) + h * calcEZ(theta)
return classical_adder
h=2
calcE(theta=[1.5708,0,1.10715,0,2.03444,0])
theta0=[1.5708,0,1.10715,0,2.03444,0]
tol = 1e-3 # tolerance for optimization precision.
# Get expectation energy by optimization with corresponding h = 0.1, 0.2,..., 2.9, 3.
y_vqe = []
for k in range(0,31):
h=k/10
vqe_result = minimize(calcE, theta0 , method="COBYLA", tol=tol)
y_vqe.append(vqe_result.fun)
print(y_vqe)
y_mean = np.array(y_vqe)/4
x2 = []
for k in range(0,31):
x2.append(k/10)
plot(x2,y_mean,'bs', label='VQE')
plt.xlabel('h')
plt.ylabel('E/N with N = 4')
|
https://github.com/PAYAL980/Four-Algorithms-in-Qiskit
|
PAYAL980
|
# Importing libraries
from qiskit import *
import numpy as np
import math
import random
from qiskit.visualization import plot_histogram
from qiskit.providers.fake_provider import FakeJakarta, FakeNairobi
""" Defining a general oracle for the algorithm
Input: secret_num - the secret string(to be encoded as black box)
which is to be deteremined from the Bernstein-Vazirani algorithm"""
def oracle(secret_num):
qc = QuantumCircuit(len(secret_num)+1)
for iz, val in enumerate(reversed(secret_num)): # Reversing the secret number to match the order of
# qiskit's qubits
if(val=='1'):
qc.cx(iz, len(secret_num)) # Applying cx to the qubit corresponding to 1 in secret number
return qc
# Checking the oracle function for bitstring '1101'
secret_num = '1101'
cir = oracle(secret_num)
cir.draw('mpl')
""" Defining a function for Bernstein-Vazirani algorithm
Input: N - Length of the secret bitstring to be determined
oracle1- black box encoding the secret number
Output: qc - the quantum circuit to be run on a simulator to get the final output """
def bv_algo_gen(N, oracle):
# Creating a quantum circuit of 'N+1' qubits where N is the number of bits in the input bitstring
qc = QuantumCircuit(N+1, N)
# Applying X gate on the helper qubit to change it's state from 0 to 1
qc.x(N)
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates on all qubits to create superposition and access all the possible cases at same time
qc.h(range(0,N+1))
qc.barrier() # Barrier for better visualization
# Applying the oracle for the funtion to the quantum circuit
qc.append(oracle, range(N+1))
qc.barrier() # Barrier for better visualization
# Applying Hadamard gates to all qubits
qc.h(range(N+1))
qc.barrier() # Barrier for better visualization
# Measuring first N qubits to find if the function is constant or balanced
qc.measure(range(N), range(N))
return qc
# Testing the algorithm for '1101'
secret_num = '1101'
ora = oracle(secret_num)
N = len(secret_num)
q1 = bv_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 2
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
# secret_num - the secret string(to be encoded as black box)
# 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 FakeNairobi
# Output: counts, maximum number of counts are obtained for the secret string
def run(secret_num, sim):
oracle_1 = oracle(secret_num)
N = len(secret_num)
q1 = bv_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 count
# Testing the algorithm for '10101' on all 4 simulators
plot_histogram(run('10101', 1))
plot_histogram(run('10101', 2))
plot_histogram(run('10101', 3))
plot_histogram(run('10101', 4))
# Testing the algorithm for '10101001' on all 4 simulators
plot_histogram(run('10101001', 1))
plot_histogram(run('10101001', 2))
plot_histogram(run('10101001', 3))
plot_histogram(run('10101001', 4))
|
https://github.com/DylanLi272/QiskitFinalProject
|
DylanLi272
|
from qiskit import BasicAer, Aer, IBMQ
from qiskit.aqua import QuantumInstance, aqua_globals
from qiskit.aqua.algorithms import VQE, ExactEigensolver, NumPyEigensolver
from qiskit.aqua.components.initial_states import Zero
from qiskit.aqua.components.optimizers import ADAM, AQGD, COBYLA, L_BFGS_B, SLSQP
from qiskit.aqua.components.optimizers import SPSA, TNC, POWELL, P_BFGS
from qiskit.aqua.components.optimizers import NFT, NELDER_MEAD, GSLS, CG
from qiskit.aqua.components.variational_forms import RY, RYRZ, SwapRZ
from qiskit.aqua.operators import WeightedPauliOperator, Z2Symmetries
from qiskit.chemistry import FermionicOperator
from qiskit.chemistry.drivers import PySCFDriver, UnitsType
from qiskit.chemistry.components.variational_forms import UCCSD
from qiskit.chemistry.components.initial_states import HartreeFock
from qiskit.providers.aer import QasmSimulator
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors import QuantumError, ReadoutError
from qiskit.providers.aer.noise.errors import pauli_error
from qiskit.providers.aer.noise.errors import depolarizing_error
from qiskit.providers.aer.noise.errors import thermal_relaxation_error
from qiskit.providers.aer import noise
from qiskit.tools.monitor import job_monitor
from qiskit.providers.ibmq import least_busy
import warnings
IBMQ.load_account()
provider = IBMQ.get_provider(group='open')
backend = least_busy(provider.backends(simulator=False, operational=True))
import numpy as np
import matplotlib.pyplot as plt
from functools import partial
inter_dist = 1.5108585
driver = PySCFDriver(atom='Li .0 .0 .0; H .0 .0' + str(inter_dist), unit=UnitsType.ANGSTROM, charge=0, spin=0, basis='sto3g')
# please be aware that the idx here with respective to original idx
freeze_list = [0]
remove_list = [-3, -2] # negative number denotes the reverse order
#Classically solve for the lowest eigenvalue
def exact_solver(qubitOp):
ee = ExactEigensolver(qubitOp)
result = ee.run()
ref = result['energy']
print('Reference value: {}'.format(ref))
return ref
backend = BasicAer.get_backend('statevector_simulator')
#Define our noise model based on the ibmq_essex chip
chip_name = 'ibmq_essex'
device = provider.get_backend(chip_name)
coupling_map = device.configuration().coupling_map
noise_model = noise.device.basic_device_noise_model(device.properties())
basis_gates = noise_model.basis_gates
# Classically solve for the lowest eigenvalue
# This is used just to compare how well you VQE approximation is performing
def exact_solver(qubitOp):
ee = ExactEigensolver(qubitOp)
result = ee.run()
ref = result['energy']
print('Reference value: {}'.format(ref))
return ref
counts = []
values = []
params = []
deviation = []
def store_intermediate_result(eval_count, parameters, mean, std):
counts.append(eval_count)
values.append(mean)
params.append(parameters)
deviation.append(std)
# Define your function for computing the qubit operations of LiH
def compute_LiH_qubitOp(map_type, inter_dist, basis='sto3g'):
# Specify details of our molecule
driver = PySCFDriver(atom='Li 0 0 0; H 0 0 ' + str(inter_dist), unit=UnitsType.ANGSTROM, charge=0, spin=0, basis=basis)
# Compute relevant 1 and 2 body integrals.
molecule = driver.run()
h1 = molecule.one_body_integrals
h2 = molecule.two_body_integrals
num_particles = molecule.num_alpha + molecule.num_beta
num_spin_orbitals = molecule.num_orbitals * 2
nuclear_repulsion_energy = molecule.nuclear_repulsion_energy
print("# of electrons: {}".format(num_particles))
print("# of spin orbitals: {}".format(num_spin_orbitals))
# Please be aware that the idx here with respective to original idx
freeze_list = [0,1,6,7]
remove_list = [0,1,4,5] # negative number denotes the reverse order
# Prepare full idx of freeze_list and remove_list
# Convert all negative idx to positive
num_spin_orbitals -= len(remove_list)
# Prepare fermionic hamiltonian with orbital freezing and eliminating, and then map to qubit hamiltonian
# and if PARITY mapping is selected, reduction qubits
energy_shift = 0.0
qubit_reduction = True if map_type == 'parity' else False
ferOp = FermionicOperator(h1=h1, h2=h2)
if len(freeze_list) > 0:
ferOp, energy_shift = ferOp.fermion_mode_freezing(freeze_list)
num_spin_orbitals -= len(freeze_list)
num_particles -= len(freeze_list)//2
if len(remove_list) > 0:
ferOp = ferOp.fermion_mode_elimination(remove_list)
qubitOp = ferOp.mapping(map_type)
qubitOp = Z2Symmetries.two_qubit_reduction(qubitOp, num_particles)
return qubitOp, num_spin_orbitals, num_particles, qubit_reduction, molecule, energy_shift, nuclear_repulsion_energy
map_type = 'parity'
qubitOp, num_spin_orbitals, num_particles, qubit_reduction, molecule, energy_shift, nuclear_repulsion_energy = compute_LiH_qubitOp(map_type, inter_dist)
# Classically solve for the exact solution and use that as your reference value
ref = exact_solver(qubitOp)
# Specify your initial state
init_state = HartreeFock(num_spin_orbitals, num_particles, qubit_mapping=map_type)
# Select a state preparation ansatz
# Equivalently, choose a parameterization for our trial wave function.
RY_var_form = RY(qubitOp.num_qubits, depth=2)
# Choose where to run/simulate our circuit
quantum_instance = backend
max_eval = 1000
# Choose the classical optimizer
POWELL_optimizer = POWELL(max_eval)
warnings.filterwarnings("ignore")
POWELL_vqe = VQE(qubitOp, RY_var_form, POWELL_optimizer, callback=store_intermediate_result)
POWELL_vqe_eigenvalue = np.real(POWELL_vqe.run(backend)['eigenvalue'])
# Now compare the results of different compositions of your VQE algorithm!
POWELL_vqe_result = np.real(energy_shift + POWELL_vqe_eigenvalue + nuclear_repulsion_energy)
print("==================================================")
print('Reference value: {}'.format(ref))
print("POWELL VQE energy: ", POWELL_vqe_eigenvalue)
print("HF energy: {}".format(molecule.hf_energy))
print("POWELL Reference Value Percent Error: " + str(abs((POWELL_vqe_eigenvalue-ref)/ref)*100) + "%")
print("POWELL Energy Value Percent Error: " + str(np.real(abs((POWELL_vqe_result-molecule.hf_energy)/molecule.hf_energy))*100) + "%")
print("==================================================")
pinter_d = []
pex_list = []
pv_list = []
peref_list = []
paref_list = []
for inter_dist in range(5, 41):
inter_dist /= 10.0
pinter_d.append(inter_dist)
print(inter_dist)
qubitOp, num_spin_orbitals, num_particles, qubit_reduction, molecule, energy_shift, nuclear_repulsion_energy = compute_LiH_qubitOp(map_type, inter_dist)
# Classically solve for the exact solution and use that as your reference value
ref = exact_solver(qubitOp)
# Specify your initial state
init_state = HartreeFock(num_spin_orbitals, num_particles, qubit_mapping=map_type)
# Select a state preparation ansatz
# Equivalently, choose a parameterization for our trial wave function.
RY_var_form = RY(qubitOp.num_qubits, depth=2)
# Choose where to run/simulate our circuit
quantum_instance = backend
max_eval = 1000
# Choose the classical optimizer
POWELL_optimizer = POWELL(max_eval)
warnings.filterwarnings("ignore")
POWELL_vqe = VQE(qubitOp, RY_var_form, POWELL_optimizer, callback=store_intermediate_result)
POWELL_vqe_eigenvalue = np.real(POWELL_vqe.run(backend)['eigenvalue'])
shift = energy_shift + nuclear_repulsion_energy
# Now compare the results of different compositions of your VQE algorithm!
POWELL_vqe_result = np.real(shift + POWELL_vqe_eigenvalue)
pex_list.append(molecule.hf_energy)
pv_list.append(POWELL_vqe_result)
peref_list.append(ref)
paref_list.append(POWELL_vqe_eigenvalue)
plt.figure(figsize=(15, 10))
plt.title('')
#pv_list + 2*(min(pex_list)-pv_list)
plt.plot(pinter_d, pex_list, 'b-', label='Exact Energy')
plt.plot(pinter_d, pv_list, 'r-', label='VQE Energy')
#plt.plot(inter_d, eref_list, 'g-', label='expected_ref')
#plt.plot(inter_d, aref_list, 'y-', label='actual_ref')
plt.xlabel('Interatomic Distance (Angstrom)')
plt.ylabel('Energy')
plt.legend()
plt.show()
|
https://github.com/MonitSharma/qiskit-projects
|
MonitSharma
|
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/SaashaJoshi/IBM-Qiskit-Summer-School-2020
|
SaashaJoshi
|
!pip install -U -r grading_tools/requirements.txt
from IPython.display import clear_output
clear_output()
import numpy as np; pi = np.pi
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
from copy import deepcopy as make_copy
def prepare_hets_circuit(depth, angle1, angle2):
hets_circ = QuantumCircuit(depth)
hets_circ.ry(angle1, 0)
hets_circ.rz(angle1, 0)
hets_circ.ry(angle1, 1)
hets_circ.rz(angle1, 1)
for ii in range(depth):
hets_circ.cx(0,1)
hets_circ.ry(angle2,0)
hets_circ.rz(angle2,0)
hets_circ.ry(angle2,1)
hets_circ.rz(angle2,1)
return hets_circ
hets_circuit = prepare_hets_circuit(2, pi/2, pi/2)
hets_circuit.draw()
def measure_zz_circuit(given_circuit):
zz_meas = make_copy(given_circuit)
zz_meas.measure_all()
return zz_meas
zz_meas = measure_zz_circuit(hets_circuit)
zz_meas.draw()
simulator = Aer.get_backend('qasm_simulator')
result = execute(zz_meas, backend = simulator, shots=10000).result()
counts = result.get_counts(zz_meas)
plot_histogram(counts)
def measure_zz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zz = counts['00'] + counts['11'] - counts['01'] - counts['10']
zz = zz / total_counts
return zz
zz = measure_zz(hets_circuit)
print("<ZZ> =", str(zz))
def measure_zi(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
zi = counts['00'] - counts['11'] + counts['01'] - counts['10']
zi = zi / total_counts
return zi
def measure_iz(given_circuit, num_shots = 10000):
zz_meas = measure_zz_circuit(given_circuit)
result = execute(zz_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(zz_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
iz = counts['00'] - counts['11'] - counts['01'] + counts['10']
iz = iz / total_counts
return iz
zi = measure_zi(hets_circuit)
print("<ZI> =", str(zi))
iz = measure_iz(hets_circuit)
print("<IZ> =", str(iz))
def measure_xx_circuit(given_circuit):
xx_meas = make_copy(given_circuit)
### WRITE YOUR CODE BETWEEN THESE LINES - START
xx_meas.h(0)
xx_meas.h(1)
xx_meas.measure_all()
### WRITE YOUR CODE BETWEEN THESE LINES - END
return xx_meas
xx_meas = measure_xx_circuit(hets_circuit)
xx_meas.draw()
def measure_xx(given_circuit, num_shots = 10000):
xx_meas = measure_xx_circuit(given_circuit)
result = execute(xx_meas, backend = simulator, shots = num_shots).result()
counts = result.get_counts(xx_meas)
if '00' not in counts:
counts['00'] = 0
if '01' not in counts:
counts['01'] = 0
if '10' not in counts:
counts['10'] = 0
if '11' not in counts:
counts['11'] = 0
total_counts = counts['00'] + counts['11'] + counts['01'] + counts['10']
xx = counts['00'] + counts['11'] - counts['01'] - counts['10']
xx = xx / total_counts
return xx
xx = measure_xx(hets_circuit)
print("<XX> =", str(xx))
def get_energy(given_circuit, num_shots = 10000):
zz = measure_zz(given_circuit, num_shots = num_shots)
iz = measure_iz(given_circuit, num_shots = num_shots)
zi = measure_zi(given_circuit, num_shots = num_shots)
xx = measure_xx(given_circuit, num_shots = num_shots)
energy = (-1.0523732)*1 + (0.39793742)*iz + (-0.3979374)*zi + (-0.0112801)*zz + (0.18093119)*xx
return energy
energy = get_energy(hets_circuit)
print("The energy of the trial state is", str(energy))
hets_circuit_plus = None
hets_circuit_minus = None
### WRITE YOUR CODE BETWEEN THESE LINES - START
hets_circuit_plus = prepare_hets_circuit(2, pi/2 + 0.1*pi/2, pi/2)
hets_circuit_minus = prepare_hets_circuit(2, pi/2 - 0.1*pi/2, pi/2)
### WRITE YOUR CODE BETWEEN THESE LINES - END
energy_plus = get_energy(hets_circuit_plus, num_shots=100000)
energy_minus = get_energy(hets_circuit_minus, num_shots=100000)
print(energy_plus, energy_minus)
name = 'Pon Rahul M'
email = 'ponrahul.21it@licet.ac.in'
### Do not change the lines below
from grading_tools import grade
grade(answer=measure_xx_circuit(hets_circuit), name=name, email=email, labid='lab9', exerciseid='ex1')
grade(answer=hets_circuit_plus, name=name, email=email, labid='lab9', exerciseid='ex2')
grade(answer=hets_circuit_minus, name=name, email=email, labid='lab9', exerciseid='ex3')
energy_plus_100, energy_plus_1000, energy_plus_10000 = 0, 0, 0
energy_minus_100, energy_minus_1000, energy_minus_10000 = 0, 0, 0
### WRITE YOUR CODE BETWEEN THESE LINES - START
energy_plus_100 = get_energy(hets_circuit_plus, num_shots = 100)
energy_minus_100 = get_energy(hets_circuit_minus, num_shots = 100)
energy_plus_1000 = get_energy(hets_circuit_plus, num_shots = 1000)
energy_minus_1000 = get_energy(hets_circuit_minus, num_shots = 1000)
energy_plus_10000 = get_energy(hets_circuit_plus, num_shots = 10000)
energy_minus_10000 = get_energy(hets_circuit_minus, num_shots = 10000)
### WRITE YOUR CODE BETWEEN THESE LINES - END
print(energy_plus_100, energy_minus_100, "difference = ", energy_minus_100 - energy_plus_100)
print(energy_plus_1000, energy_minus_1000, "difference = ", energy_minus_1000 - energy_plus_1000)
print(energy_plus_10000, energy_minus_10000, "difference = ", energy_minus_10000 - energy_plus_10000)
### WRITE YOUR CODE BETWEEN THESE LINES - START
I = np.array([
[1, 0],
[0, 1]
])
X = np.array([
[0, 1],
[1, 0]
])
Z = np.array([
[1, 0],
[0, -1]
])
h2_hamiltonian = (-1.0523732) * np.kron(I, I) + \
(0.39793742) * np.kron(I, Z) + \
(-0.3979374) * np.kron(Z, I) + \
(-0.0112801) * np.kron(Z, Z) + \
(0.18093119) * np.kron(X, X)
from numpy import linalg as LA
eigenvalues, eigenvectors = LA.eig(h2_hamiltonian)
for ii, eigenvalue in enumerate(eigenvalues):
print(f"Eigenvector {eigenvectors[:,ii]} has energy {eigenvalue}")
exact_eigenvector = eigenvectors[:,np.argmin(eigenvalues)]
exact_eigenvalue = np.min(eigenvalues)
print()
print("Minimum energy is", exact_eigenvalue)
### WRITE YOUR CODE BETWEEN THESE LINES - END
|
https://github.com/TexanElite/QiskitFallFest2021Project
|
TexanElite
|
%pip install qiskit
%pip install pylatexenc
%pip install matplotlib
#initialization
import matplotlib.pyplot as plt
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, BasicAer, execute, IBMQ, assemble, Aer, transpile
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_histogram, plot_state_qsphere, plot_bloch_multivector, plot_bloch_vector
import getpass
def hash_oracle(qc, qubits, clause_qubits, output, hash_value):
# Prepares the circuit to "compare" the clause_qubits to the hash_value
exp = 0
while exp < len(clause_qubits):
if not hash_value & (1 << exp) > 0:
qc.x(clause_qubits[exp])
exp += 1
qc.barrier()
# XORs every two qubits and XORs the result of that into one of the clause_qubits
for i in range(0, len(qubits), 1):
qc.cx(qubits[i], clause_qubits[i % len(clause_qubits)])
qc.cx(qubits[(i + 1) % len(qubits)], clause_qubits[i % len(clause_qubits)])
# Checks if all the clause_qubits are satisfied
qc.mct(clause_qubits, output)
# Repeat all the steps to ensure that clause_qubits are |0000>
for i in range(0, len(qubits), 1):
qc.cx(qubits[i], clause_qubits[i % len(clause_qubits)])
qc.cx(qubits[(i + 1) % len(qubits)], clause_qubits[i % len(clause_qubits)])
qc.barrier()
exp = 0
while exp < len(clause_qubits):
if not hash_value & (1 << exp) > 0:
qc.x(clause_qubits[exp])
exp += 1
def diffuser(n):
qc = QuantumCircuit(n)
for qubit in range(n):
qc.h(qubit)
for qubit in range(n):
qc.x(qubit)
qc.h(n-1)
qc.mct(list(range(n-1)), n-1)
qc.h(n-1)
for qubit in range(n):
qc.x(qubit)
for qubit in range(n):
qc.h(qubit)
d = qc.to_gate()
d.name = "Diffuser"
return d
n_qubits = 4
iterations = int(n_qubits ** (1/2))
hash_value = 10
var_qubits = QuantumRegister(n_qubits, name='v')
clause_qubits = QuantumRegister(4, name='c') # bits to store clause-checks
output_qubit = QuantumRegister(1, name='out')
cbits = ClassicalRegister(n_qubits, name='cbits')
qc = QuantumCircuit(var_qubits, clause_qubits, output_qubit, cbits)
# Initialize the output qubit to |->
qc.initialize([1, -1]/np.sqrt(2), output_qubit)
# Initialize the qubits to the state |s> (intially the equal superposition or |+> state)
qc.h(var_qubits)
qc.barrier()
# Repeat the process _iterations_ times
for iteration in range(iterations):
# Apply our oracle
hash_oracle(qc, var_qubits, clause_qubits, output_qubit, hash_value)
qc.barrier()
# Apply the diffuser
qc.append(diffuser(n_qubits), list(range(n_qubits)))
# Measure the variable qubits
qc.measure(var_qubits, cbits)
qc.draw(fold=-1)
aer_simulator = Aer.get_backend('aer_simulator')
transpiled_qc = transpile(qc, aer_simulator)
qobj = assemble(transpiled_qc)
result = aer_simulator.run(qobj).result()
plot_histogram(result.get_counts())
|
https://github.com/abbarreto/qiskit2
|
abbarreto
| |
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits to represent the uncertainty
num_uncertainty_qubits = 3
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
uncertainty_model = LogNormalDistribution(
num_uncertainty_qubits, mu=mu, sigma=sigma**2, bounds=(low, high)
)
# plot probability distribution
x = uncertainty_model.values
y = uncertainty_model.probabilities
plt.bar(x, y, width=0.2)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.grid()
plt.xlabel("Spot Price at Maturity $S_T$ (\$)", size=15)
plt.ylabel("Probability ($\%$)", size=15)
plt.show()
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 2.126
# set the approximation scaling for the payoff function
rescaling_factor = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [-1, 0]
offsets = [strike_price - low, 0]
f_min = 0
f_max = strike_price - low
european_put_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
rescaling_factor=rescaling_factor,
)
# construct A operator for QAE for the payoff function by
# composing the uncertainty model and the objective
european_put = european_put_objective.compose(uncertainty_model, front=True)
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = uncertainty_model.values
y = np.maximum(0, strike_price - x)
plt.plot(x, y, "ro-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Spot Price", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(x, size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value (normalized to the [0, 1] interval)
exact_value = np.dot(uncertainty_model.probabilities, y)
exact_delta = -sum(uncertainty_model.probabilities[x <= strike_price])
print("exact expected value:\t%.4f" % exact_value)
print("exact delta value: \t%.4f" % exact_delta)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put,
objective_qubits=[num_uncertainty_qubits],
post_processing=european_put_objective.post_processing,
)
# construct amplitude estimation
ae = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result = ae.estimate(problem)
conf_int = np.array(result.confidence_interval_processed)
print("Exact value: \t%.4f" % exact_value)
print("Estimated value: \t%.4f" % (result.estimation_processed))
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
# setup piecewise linear objective fcuntion
breakpoints = [low, strike_price]
slopes = [0, 0]
offsets = [1, 0]
f_min = 0
f_max = 1
european_put_delta_objective = LinearAmplitudeFunction(
num_uncertainty_qubits,
slopes,
offsets,
domain=(low, high),
image=(f_min, f_max),
breakpoints=breakpoints,
)
# construct circuit for payoff function
european_put_delta = european_put_delta_objective.compose(uncertainty_model, front=True)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=european_put_delta, objective_qubits=[num_uncertainty_qubits]
)
# construct amplitude estimation
ae_delta = IterativeAmplitudeEstimation(
epsilon_target=epsilon, alpha=alpha, sampler=Sampler(run_options={"shots": 100})
)
result_delta = ae_delta.estimate(problem)
conf_int = -np.array(result_delta.confidence_interval)[::-1]
print("Exact delta: \t%.4f" % exact_delta)
print("Esimated value: \t%.4f" % -result_delta.estimation)
print("Confidence interval: \t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/ichen17/Learning-Qiskit
|
ichen17
|
# Import libraries for use
from qiskit import *
import numpy as np
from random import random
from qiskit.extensions import Initialize
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit_textbook.tools import random_state, array_to_latex
## SETUP
# Protocol uses 4 qubits and 1 classical bit in a register
qr = QuantumRegister(4, name="q") # Protocol uses 4 qubits
cr = ClassicalRegister(1, name="cr") # and 1 classical bit cr
bit_flip_circuit = QuantumCircuit(qr, cr)
def encoding(qc, q0, q1, q2):
"""Creates encoding process using qubits q0 & q1 & q2"""
qc.cx(q0,q1) # CNOT with q1 as control and q0 as target (Use q1 to control q0.)
qc.cx(q0,q2) # CNOT with q2 as control and q0 as target
# initialization instruction to create
# |ψ⟩ from the state |0⟩:
p = 0.25 # p stands for the probability of fliping the state of the qubit
psi = [np.sqrt(1-p), np.sqrt(p)]
init_gate = Initialize(psi) # initialize the superposition state
init_gate.label = "init"
def error_simulation(qc, q0, q1, q2, q3):
"""Creates error simulation using qubits q0 & q1 & q2 & q3"""
qc.append(init_gate, [3]) # create the superposition state for |q3>
measure(qc, 3, 0) # measure the state on |q3>
qc.x(q0).c_if(cr, 1) # apply x gate on q0 if |1> was measured by |q3>
qc.append(init_gate, [3])
measure(qc, 3, 0)
qc.x(q1).c_if(cr, 1) # apply x gate on q1 if |1> was measured by |q3>
qc.append(init_gate, [3])
measure(qc, 3, 0)
qc.x(q2).c_if(cr, 1) # apply x gate on q2 if |1> was measured by |q3>
def measure(qc, q0, cr):
"""Measures qubit q0 """
qc.barrier()
qc.measure(q0,cr)
def decoding(qc, q0, q1, q2):
"""Creates decoding process using qubits q0 & q1 & q2"""
qc.cx(q0,q1) # CNOT with q1 as control and q0 as target
qc.cx(q0,q2) # CNOT with q2 as control and q0 as target
qc.ccx(q2,q1,q0) # Apply a Toffoli gate |011> <-> |111>
# Let's apply the process above to our circuit:
# step 1. encoding
encoding(bit_flip_circuit, 0, 1, 2)
# step 2. error simulation
error_simulation(bit_flip_circuit, 0, 1, 2, p)
bit_flip_circuit.barrier()
# step 3. decoding
decoding(bit_flip_circuit, 0, 1, 2)
# step 4. measurement
measure(bit_flip_circuit, 0, 0)
# View the circuit:
%matplotlib inline
bit_flip_circuit.draw(output='mpl')
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(bit_flip_circuit, backend, shots=1024).result().get_counts() # No. of measurement shots = 1024
plot_histogram(counts)
## SETUP
# Protocol uses 4 qubits and 1 classical bit in a register
qr = QuantumRegister(4, name="q") # Protocol uses 4 qubits
cr = ClassicalRegister(1, name="cr") # and 1 classical bit cr
bit_flip_random_circuit = QuantumCircuit(qr, cr)
# Create random 1-qubit state
psi_random = random_state(1)
# Display it nicely
array_to_latex(psi_random, pretext="|\\psi\\rangle =")
# Show it on a Bloch sphere
plot_bloch_multivector(psi_random)
# initialization instruction to create
# |ψ⟩ from the state |0⟩:
#(Initialize is technically not a gate since it contains a reset operation.)
init_gate_random = Initialize(psi_random)
init_gate_random.label = "init_random"
#Since all quantum gates are reversible,
#we can find the inverse of these gates using:
inverse_init_gate_random = init_gate_random.gates_to_uncompute()
# Let's apply the process above to our circuit:
## STEP 0
# First, let's initialize Alice's q0
bit_flip_random_circuit.append(init_gate_random, [0])
bit_flip_random_circuit.barrier()
# step 1. encoding
encoding(bit_flip_random_circuit, 0, 1, 2)
# step 2. error simulation
error_simulation(bit_flip_random_circuit, 0, 1, 2, p)
bit_flip_random_circuit.barrier()
# step 3. decoding
decoding(bit_flip_random_circuit, 0, 1, 2)
## STEP 4
# reverse the initialization process
bit_flip_random_circuit.append(inverse_init_gate_random, [0])
# step 5. measurement
measure(bit_flip_random_circuit, 0, 0)
# View the circuit:
%matplotlib inline
bit_flip_random_circuit.draw(output='mpl')
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(bit_flip_random_circuit, backend, shots=1024).result().get_counts() # No. of measurement shots = 1024
plot_histogram(counts)
|
https://github.com/Z-928/Bugs4Q
|
Z-928
|
from qiskit import *
qc = QuantumCircuit(2)
qc.h(i)
qc.crz (PI/4, 0, 1)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_circuit_layout
from qiskit.providers.fake_provider import FakeVigo
backend = FakeVigo()
ghz = QuantumCircuit(3, 3)
ghz.h(0)
ghz.cx(0,range(1,3))
ghz.barrier()
ghz.measure(range(3), range(3))
ghz.draw(output='mpl')
|
https://github.com/Dpbm/scientific-research-1-quantum-oracles
|
Dpbm
|
%matplotlib inline
from qiskit import QuantumCircuit
from utils import get_image_path
constant_oracle = QuantumCircuit(3)
constant_oracle.x([0, 2])
constant_oracle.draw('mpl', filename=get_image_path("constant-oracle.png"))
balanced_oracle = QuantumCircuit(3)
balanced_oracle.x([0, 2])
balanced_oracle.barrier()
balanced_oracle.cx(1, 2)
balanced_oracle.cx(0, 2)
balanced_oracle.barrier()
balanced_oracle.x([0, 2])
balanced_oracle.draw('mpl', filename=get_image_path("balanced-oracle.png"))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(12)
for idx in range(5):
qc.h(idx)
qc.cx(idx, idx+5)
qc.cx(1, 7)
qc.x(8)
qc.cx(1, 9)
qc.x(7)
qc.cx(1, 11)
qc.swap(6, 11)
qc.swap(6, 9)
qc.swap(6, 10)
qc.x(6)
qc.draw('mpl')
|
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))
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.