repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/epelaaez/QuantumLibrary
|
epelaaez
|
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.circuit import Parameter
def block(n: int, param_prefix: str = "θ"):
qc = QuantumCircuit(n)
for i in range(n):
qc.ry(Parameter(param_prefix + "_" + str(i)), i)
for i in range(0, n-1, 2):
qc.cx(i, i+1)
for i in range(1, n-1, 2):
qc.cx(i, i+1)
qc.name = "block"
return qc
block(4).draw("mpl")
def alt(l: int, n: int, m: int):
if m % 2 != 0:
raise Exception("Parameter `m` must be an even number")
if n % m != 0:
raise Exception("Parameter `n` divided by `m` must be integer")
qc = QuantumCircuit(n)
for i in range(l):
if (i + 1) % 2 == 0:
qc.append(block(m//2, param_prefix=f"θ_{i}_0"), range(0, m//2))
for j in range(m//2, n-m//2, m):
qc.append(block(m, param_prefix=f"θ_{i}_{j}"), range(j, j+m))
qc.append(block(m//2, param_prefix=f"θ_{i}_{j+1}"), range(n-m//2, n))
else:
for j in range(0, n, m):
qc.append(block(m, param_prefix=f"θ_{i}_{j}"), range(j, j+m))
return qc
alt(3, 8, 4).draw("mpl")
def ten(l: int, n: int, m: int):
if m % 2 != 0:
raise Exception("Parameter `m` must be an even number")
if n % m != 0:
raise Exception("Parameter `n` divided by `m` must be integer")
qc = QuantumCircuit(n)
for i in range(l):
for j in range(0, n, m):
qc.append(block(m, param_prefix=f"θ_{i}_{j}"), range(j, j+m))
return qc
ten(3, 8, 4).draw("mpl")
from qiskit.algorithms import VQE
from qiskit.opflow import Z, I
from qiskit.providers.basicaer import QasmSimulatorPy
from qiskit.algorithms.optimizers import SPSA
from qiskit.circuit.library import TwoLocal
import matplotlib.pyplot as plt
def test_ansatz(ansatz, num_qubits, fig_title):
hamiltonian = (Z ^ Z) ^ (I ^ (num_qubits - 2))
target_energy = -1
optimizer = SPSA()
np.random.seed(2022)
initial_point = np.random.random(ansatz.num_parameters)
intermediate_info = {"nfev": [], "parameters": [], "energy": [], "stddev": []}
def callback(nfev, parameters, energy, stddev):
intermediate_info["nfev"].append(nfev)
intermediate_info["parameters"].append(parameters)
intermediate_info["energy"].append(energy)
intermediate_info["stddev"].append(stddev)
local_vqe = VQE(
ansatz=ansatz,
optimizer=optimizer,
initial_point=initial_point,
quantum_instance=QasmSimulatorPy(),
callback=callback,
)
local_result = local_vqe.compute_minimum_eigenvalue(hamiltonian)
print("Eigenvalue:", local_result.eigenvalue)
print("Target:", target_energy)
fig, ax = plt.subplots(figsize=(12, 8))
ax.plot(intermediate_info["nfev"], intermediate_info["energy"], color="red")
ax.set_xlabel("Optimization step", fontsize = 14)
ax.set_ylabel("Energy", color="red", fontsize=12)
ax2=ax.twinx()
ax2.plot(intermediate_info["nfev"], intermediate_info["stddev"], color="blue")
ax2.set_ylabel("Deviation",color="blue",fontsize=12)
plt.title(fig_title)
plt.show()
num_qubits = 8
layers = 3
block_size = 2
alt_ansatz = alt(layers, num_qubits, block_size)
test_ansatz(alt_ansatz, num_qubits, "Alternating layered ansatz")
ten_ansatz = ten(layers, num_qubits, block_size)
test_ansatz(ten_ansatz, num_qubits, "Tensor product ansatz")
two_local_ansatz = TwoLocal(num_qubits, "ry", "cx", reps=layers)
test_ansatz(two_local_ansatz, num_qubits, "Two local ansatz")
|
https://github.com/SaashaJoshi/IBM-Qiskit-Summer-School-2020
|
SaashaJoshi
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
import pickle
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("../utils/")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
scale_factors = [1.0, 2.0, 3.0]
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="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_init110(qc, targets=[0, 1, 2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_st_qcs = transpile(t3_st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = zne_wrapper(t3_st_qcs, scale_factors = scale_factors, pt = True) # Pauli Twirling
print("created zne_qcs (length:", len(zne_qcs), ")")
# optimization_level must be 0
# feed initial_layout here to see the picture of the circuits before casting the job
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
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-community', group='ibmquantumawards', project='open-science-22')
print("provider:", provider)
backend = provider.get_backend("ibmq_jakarta")
print(str(backend))
shots = 1 << 13
reps = 8 # unused
jobs = []
for _ in range(reps):
#! CHECK: run t3_zne_qcs, with optimization_level = 0 and straightforward initial_layout
job = execute(t3_zne_qcs, backend, shots=shots, optimization_level=0)
print('Job ID', job.job_id())
jobs.append(job)
# QREM
qr = QuantumRegister(num_qubits, name="calq")
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
# we have to feed initial_layout to calibration matrix
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
meas_calibs[0].draw("mpl")
dt_now = datetime.datetime.now()
print(dt_now)
filename = "job_ids_" + str(backend) + "_100step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl"
print(filename)
with open("jobs_" + str(backend) + "_100step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"jobs": jobs, "cal_job": cal_job}, f)
with open(filename, "wb") as f:
pickle.dump({"job_ids": [job.job_id() for job in jobs], "cal_job_id": cal_job.job_id()}, f)
with open("properties_" + str(backend) + "_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump(backend.properties(), f)
filename = "job_ids_ibmq_jakarta_100step_20220413_030821_.pkl" # change here
with open(filename, "rb") as f:
job_ids_dict = pickle.load(f)
job_ids = job_ids_dict["job_ids"]
cal_job_id = job_ids_dict["cal_job_id"]
retrieved_jobs = []
for job_id in job_ids:
retrieved_jobs.append(backend.retrieve_job(job_id))
retrieved_cal_job = backend.retrieve_job(cal_job_id)
cal_results = retrieved_cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
fids = []
for job in retrieved_jobs:
mit_results = meas_fitter.filter.apply(job.result())
zne_expvals = zne_decoder(num_qubits, mit_results, scale_factors = scale_factors)
rho = expvals_to_valid_rho(num_qubits, zne_expvals)
fid = state_fidelity(rho, target_state)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
import qiskit.tools.jupyter
%qiskit_version_table
|
https://github.com/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/abhik-99/Qiskit-Summer-School
|
abhik-99
|
!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/hamburgerguy/Quantum-Algorithm-Implementations
|
hamburgerguy
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/qBraid/qBraid
|
qBraid
|
# Copyright (C) 2024 qBraid
#
# This file is part of the qBraid-SDK
#
# The qBraid-SDK is free software released under the GNU General Public License v3
# or later. You can redistribute and/or modify it under the terms of the GPL v3.
# See the LICENSE file in the project root or <https://www.gnu.org/licenses/gpl-3.0.html>.
#
# THERE IS NO WARRANTY for the qBraid-SDK, as per Section 15 of the GPL v3.
# pylint: disable=redefined-outer-name
"""
Unit tests for BraketProvider class
"""
import datetime
import json
import warnings
from unittest.mock import MagicMock, Mock, patch
import numpy as np
import pytest
from braket.aws.aws_session import AwsSession
from braket.aws.queue_information import QueueDepthInfo, QueueType
from braket.circuits import Circuit
from braket.device_schema import ExecutionDay
from braket.devices import Devices, LocalSimulator
from qiskit import QuantumCircuit as QiskitCircuit
from qbraid.exceptions import QbraidError
from qbraid.interface import circuits_allclose
from qbraid.programs import ProgramSpec
from qbraid.runtime import (
DeviceActionType,
DeviceProgramTypeMismatchError,
DeviceStatus,
DeviceType,
TargetProfile,
)
from qbraid.runtime.braket.availability import _calculate_future_time
from qbraid.runtime.braket.device import BraketDevice
from qbraid.runtime.braket.job import AmazonBraketVersionError, BraketQuantumTask
from qbraid.runtime.braket.provider import BraketProvider
from qbraid.runtime.braket.result import BraketGateModelJobResult
from qbraid.runtime.exceptions import JobStateError, ProgramValidationError
from ..fixtures.braket.gates import get_braket_gates
braket_gates = get_braket_gates()
SV1_ARN = Devices.Amazon.SV1
@pytest.fixture
def braket_provider():
"""Return a BraketProvider instance."""
return BraketProvider()
@pytest.fixture
def sv1_profile():
"""Target profile for AWS SV1 device."""
return TargetProfile(
device_type=DeviceType.SIMULATOR,
num_qubits=34,
program_spec=ProgramSpec(Circuit),
provider_name="Amazon Braket",
device_id=SV1_ARN,
action_type=DeviceActionType.OPENQASM,
)
class TestAwsSession:
"""Test class for AWS session."""
def __init__(self):
self.region = "us-east-1"
def get_device(self, arn): # pylint: disable=unused-argument
"""Returns metadata for a device."""
capabilities = {
"action": {
"braket.ir.openqasm.program": "literally anything",
"paradigm": {"qubitCount": 2},
}
}
cap_json = json.dumps(capabilities)
metadata = {
"deviceType": "SIMULATOR",
"providerName": "Amazon Braket",
"deviceCapabilities": cap_json,
}
return metadata
def cancel_quantum_task(self, arn): # pylint: disable=unused-argument
"""Cancel a quantum task."""
return None
class ExecutionWindow:
"""Test class for execution window."""
def __init__(self):
self.windowStartHour = datetime.time(0)
self.windowEndHour = datetime.time(23, 59, 59)
self.executionDay = ExecutionDay.EVERYDAY
class Service:
"""Test class for braket device service."""
def __init__(self):
self.executionWindows = [ExecutionWindow()]
class TestProperties:
"""Test class for braket device properties."""
def __init__(self):
self.service = Service()
class TestAwsDevice:
"""Test class for braket device."""
def __init__(self, arn, aws_session=None):
self.arn = arn
self.name = "SV1"
self.aws_session = aws_session or TestAwsSession()
self.status = "ONLINE"
self.properties = TestProperties()
self.is_available = True
@staticmethod
def get_device_region(arn): # pylint: disable=unused-argument
"""Returns the region of a device."""
return "us-east-1"
class MockTask:
"""Mock task class."""
def __init__(self, arg):
self.id = arg
self.arn = arg
self._aws_session = TestAwsSession()
def result(self):
"""Mock result method."""
return "not a result"
def state(self):
"""Mock state method."""
return "COMPLETED" if self.id == "task1" else "RUNNING"
def cancel(self):
"""Mock cancel method."""
raise RuntimeError
@pytest.fixture
def mock_sv1():
"""Return a mock SV1 device."""
return TestAwsDevice(SV1_ARN)
@pytest.fixture
def mock_aws_configure():
"""Mock aws_conifugre function."""
with patch("qbraid.runtime.braket.provider.aws_configure") as mock:
yield mock
@pytest.mark.parametrize(
"input_keys, expected_calls",
[
(
{"aws_access_key_id": "AKIA...", "aws_secret_access_key": "secret"},
{"aws_access_key_id": "AKIA...", "aws_secret_access_key": "secret"},
),
({}, {"aws_access_key_id": "default_key", "aws_secret_access_key": "default_secret"}),
(
{"aws_access_key_id": "AKIA..."},
{"aws_access_key_id": "AKIA...", "aws_secret_access_key": "default_secret"},
),
],
)
def test_save_config(mock_aws_configure, input_keys, expected_calls):
"""Test save_config method of BraketProvider class."""
instance = BraketProvider()
instance.aws_access_key_id = "default_key"
instance.aws_secret_access_key = "default_secret"
instance.save_config(**input_keys)
mock_aws_configure.assert_called_once_with(**expected_calls)
def test_provider_get_aws_session():
"""Test getting an AWS session."""
with patch("boto3.session.Session") as mock_boto_session:
mock_boto_session.aws_access_key_id.return_value = "aws_access_key_id"
mock_boto_session.aws_secret_access_key.return_value = "aws_secret_access_key"
aws_session = BraketProvider()._get_aws_session()
assert aws_session.boto_session.region_name == "us-east-1"
assert isinstance(aws_session, AwsSession)
def test_provider_get_devices_raises(braket_provider):
"""Test raising device wrapper error due to invalid device ID."""
with pytest.raises(ValueError):
braket_provider.get_device("Id123")
def test_provider_build_runtime_profile(mock_sv1):
"""Test building a runtime profile."""
provider = BraketProvider()
profile = provider._build_runtime_profile(device=mock_sv1, extra="data")
assert profile.get("device_type") == DeviceType.SIMULATOR.name
assert profile.get("provider_name") == "Amazon Braket"
assert profile.get("device_id") == SV1_ARN
assert profile.get("extra") == "data"
@pytest.mark.parametrize(
"region_names, key, values, expected",
[(["us-west-1"], "Project", ["X"], ["arn:aws:resource1", "arn:aws:resource2"])],
)
@patch("boto3.client")
def test_provider_get_tasks_by_tag(mock_boto_client, region_names, key, values, expected):
"""Test fetching tagged resources from AWS."""
mock_client = MagicMock()
mock_boto_client.return_value = mock_client
mock_client.get_resources.return_value = {
"ResourceTagMappingList": [
{"ResourceARN": "arn:aws:resource1"},
{"ResourceARN": "arn:aws:resource2"},
]
}
provider = BraketProvider()
result = provider.get_tasks_by_tag(key, values, region_names)
# Assert the results
mock_boto_client.assert_called_with("resourcegroupstaggingapi", region_name="us-west-1")
mock_client.get_resources.assert_called_once_with(TagFilters=[{"Key": key, "Values": values}])
assert result == expected
def test_provider_get_device(mock_sv1):
"""Test getting a Braket device."""
provider = BraketProvider()
with (
patch("qbraid.runtime.braket.provider.AwsDevice") as mock_aws_device,
patch("qbraid.runtime.braket.device.AwsDevice") as mock_aws_device_2,
):
mock_aws_device.return_value = mock_sv1
mock_aws_device_2.return_value = mock_sv1
device = provider.get_device(SV1_ARN)
assert device.id == SV1_ARN
assert device.name == "SV1"
assert str(device) == "BraketDevice('Amazon Braket SV1')"
assert device.status() == DeviceStatus.ONLINE
assert isinstance(device, BraketDevice)
def test_provider_get_devices(mock_sv1):
"""Test getting list of Braket devices."""
with (
patch("qbraid.runtime.braket.provider.AwsDevice.get_devices", return_value=[mock_sv1]),
patch("qbraid.runtime.braket.device.AwsDevice") as mock_aws_device_2,
):
provider = BraketProvider()
mock_aws_device_2.return_value = mock_sv1
devices = provider.get_devices()
assert len(devices) == 1
assert devices[0].id == SV1_ARN
@patch("qbraid.runtime.braket.device.AwsDevice")
def test_device_profile_attributes(mock_aws_device, sv1_profile):
"""Test that device profile attributes are correctly set."""
mock_aws_device.return_value = Mock()
device = BraketDevice(sv1_profile)
assert device.id == sv1_profile.get("device_id")
assert device.num_qubits == sv1_profile.get("num_qubits")
assert device._target_spec == sv1_profile.get("program_spec")
assert device.device_type == DeviceType(sv1_profile.get("device_type"))
assert device.profile.get("action_type") == "OpenQASM"
@patch("qbraid.runtime.braket.device.AwsDevice")
def test_device_queue_depth(mock_aws_device, sv1_profile):
"""Test getting queue_depth BraketDevice"""
mock_aws_device.queue_depth.return_value = QueueDepthInfo(
quantum_tasks={QueueType.NORMAL: "19", QueueType.PRIORITY: "3"},
jobs="0 (3 prioritized job(s) running)",
)
device = BraketDevice(sv1_profile)
queue_depth = device.queue_depth()
assert isinstance(queue_depth, int)
@patch("qbraid.runtime.braket.device.AwsDevice")
def test_device_run_circuit_too_many_qubits(mock_aws_device, sv1_profile):
"""Test that run method raises exception when input circuit
num qubits exceeds that of wrapped AWS device."""
mock_aws_device.return_value = Mock()
device = BraketDevice(sv1_profile)
num_qubits = device.num_qubits + 10
circuit = QiskitCircuit(num_qubits)
circuit.h([0, 1])
circuit.cx(0, num_qubits - 1)
with pytest.raises(ProgramValidationError):
with warnings.catch_warnings():
warnings.simplefilter("ignore", UserWarning)
device.run(circuit)
@patch("qbraid.runtime.braket.device.AwsDevice")
def test_batch_run(mock_aws_device, sv1_profile):
"""Test batch run method of BraketDevice."""
mock_aws_device.return_value = MagicMock()
mock_aws_device.return_value.__iter__.return_value = [MockTask("task1"), MockTask("task2")]
mock_aws_device.return_value.status = "ONLINE"
device = BraketDevice(sv1_profile)
circuits = [Circuit().h(0).cnot(0, 1), Circuit().h(0).cnot(0, 1)]
tasks = device.run(circuits, shots=10)
assert isinstance(tasks, list)
@pytest.mark.parametrize(
"available_time, expected",
[
(3600, "2024-01-01T01:00:00Z"),
(1800, "2024-01-01T00:30:00Z"),
(45, "2024-01-01T00:00:45Z"),
],
)
def test_availability_future_utc_datetime(available_time, expected):
"""Test calculating future utc datetime"""
current_utc_datime = datetime.datetime(2024, 1, 1, 0, 0, 0)
_, datetime_str = _calculate_future_time(available_time, current_utc_datime)
assert datetime_str == expected
def test_device_availability_window(braket_provider, mock_sv1):
"""Test BraketDeviceWrapper avaliable output identical"""
with (
patch("qbraid.runtime.braket.provider.AwsDevice") as mock_aws_device,
patch("qbraid.runtime.braket.device.AwsDevice") as mock_aws_device_2,
):
mock_device = mock_sv1
mock_device.is_available = False
mock_aws_device.return_value = mock_device
mock_aws_device_2.return_value = mock_device
device = braket_provider.get_device(SV1_ARN)
_, is_available_time, iso_str = device.availability_window()
assert len(is_available_time.split(":")) == 3
assert isinstance(iso_str, str)
try:
datetime.datetime.strptime(iso_str, "%Y-%m-%dT%H:%M:%SZ")
except ValueError:
pytest.fail("iso_str not in expected format")
@patch("qbraid.runtime.braket.BraketProvider")
def test_device_is_available(mock_provider):
"""Test device availability function."""
provider = mock_provider.return_value
mock_device_0 = Mock()
mock_device_0.availability_window.return_value = (True, 0, 0)
mock_device_0._device.is_available = True
mock_device_1 = Mock()
mock_device_1.availability_window.return_value = (False, 0, 0)
mock_device_1._device.is_available = False
provider.get_devices.return_value = [mock_device_0, mock_device_1]
devices = provider.get_devices()
for device in devices:
is_available_bool, _, _ = device.availability_window()
assert device._device.is_available == is_available_bool
@patch("qbraid.runtime.braket.device.AwsDevice")
def test_device_transform_circuit_sv1(mock_aws_device, sv1_profile):
"""Test transform method for device with OpenQASM action type."""
mock_aws_device.return_value = Mock()
device = BraketDevice(sv1_profile)
circuit = Circuit().h(0).cnot(0, 2)
transformed_expected = Circuit().h(0).cnot(0, 1)
transformed_circuit = device.transform(circuit)
assert transformed_circuit == transformed_expected
@patch("qbraid.runtime.braket.device.AwsDevice")
def test_device_transform_raises_for_mismatch(mock_aws_device, braket_circuit):
"""Test raising exception for mismatched action type AHS and program type circuit."""
mock_aws_device.return_value = Mock()
profile = TargetProfile(
device_type=DeviceType.SIMULATOR,
num_qubits=34,
program_spec=ProgramSpec(Circuit),
provider_name="Amazon Braket",
device_id=SV1_ARN,
action_type=DeviceActionType.AHS,
)
device = BraketDevice(profile)
with pytest.raises(DeviceProgramTypeMismatchError):
device.transform(braket_circuit)
@patch("qbraid.runtime.braket.device.AwsDevice")
def test_device_ionq_transform(mock_aws_device):
"""Test converting Amazon Braket circuit to use only IonQ supprted gates"""
mock_aws_device.return_value = Mock()
profile = TargetProfile(
device_type=DeviceType.QPU,
num_qubits=11,
program_spec=ProgramSpec(Circuit),
provider_name="IonQ",
device_id="arn:aws:braket:us-east-1::device/qpu/ionq/Harmony",
action_type=DeviceActionType.OPENQASM,
)
device = BraketDevice(profile)
toffoli_circuit = Circuit().ccnot(0, 1, 2)
transformed_circuit = device.transform(toffoli_circuit)
assert isinstance(transformed_circuit, Circuit)
assert toffoli_circuit.depth == 1
assert transformed_circuit.depth == 11
assert circuits_allclose(transformed_circuit, toffoli_circuit)
@patch("qbraid.runtime.braket.BraketProvider")
def test_device_submit_task_with_tags(mock_provider):
"""Test getting tagged quantum tasks."""
provider = mock_provider.return_value
provider.REGIONS = ["us-east-1", "us-west-1"]
provider._get_default_region.return_value = "us-east-1"
alt_regions = ["us-west-1"]
mock_device = Mock()
provider.get_device.return_value = mock_device
mock_task_1 = Mock()
mock_task_1.id = "task1"
mock_task_2 = Mock()
mock_task_2.id = "task2"
circuit = Circuit().h(0).cnot(0, 1)
mock_device.run.side_effect = [mock_task_1, mock_task_2]
key, value1, value2 = "abc123", "val1", "val2"
mock_task_1.tags = {key: value1}
mock_task_2.tags = {key: value2}
provider.get_tasks_by_tag.side_effect = [
[mock_task_1.id, mock_task_2.id],
[mock_task_1.id],
[],
]
task1 = mock_device.run(circuit, shots=2, tags={key: value1})
task2 = mock_device.run(circuit, shots=2, tags={key: value2})
assert set([task1.id, task2.id]) == set(provider.get_tasks_by_tag(key))
assert len(provider.get_tasks_by_tag(key, values=[value1], region_names=["us-east-1"])) == 1
assert len(provider.get_tasks_by_tag(key, region_names=alt_regions)) == 0
@patch("qbraid.runtime.braket.job.AwsQuantumTask")
def test_job_load_completed(mock_aws_quantum_task):
"""Test is terminal state method for BraketQuantumTask."""
circuit = Circuit().h(0).cnot(0, 1)
mock_device = LocalSimulator()
mock_job = mock_device.run(circuit, shots=10)
mock_aws_quantum_task.return_value = mock_job
job = BraketQuantumTask(mock_job.id)
assert job.metadata()["job_id"] == mock_job.id
assert job.is_terminal_state()
res = job.result()
assert res.measurements() is not None
@pytest.mark.parametrize("position,expected", [(10, 10), (">2000", 2000)])
@patch("qbraid.runtime.braket.job.AwsQuantumTask")
def test_job_queue_position(mock_aws_quantum_task, position, expected):
"""Test getting queue_depth BraketDevice"""
mock_queue_position_return = MagicMock()
mock_queue_position_return.queue_position = position
mock_aws_quantum_task.return_value.queue_position.return_value = mock_queue_position_return
job = BraketQuantumTask("job_id")
assert job.queue_position() == expected
@patch("qbraid.runtime.braket.job.AwsQuantumTask")
def test_job_queue_position_raises_version_error(mock_aws_quantum_task):
"""Test handling of AttributeError leads to raising AmazonBraketVersionError."""
mock_aws_quantum_task.return_value.queue_position.side_effect = AttributeError
job = BraketQuantumTask("job_id")
with pytest.raises(AmazonBraketVersionError) as excinfo:
job.queue_position()
assert "Queue visibility is only available for amazon-braket-sdk>=1.56.0" in str(excinfo.value)
def test_job_raise_for_cancel_terminal():
"""Test raising an error when trying to cancel a completed/failed job."""
with patch("qbraid.runtime.job.QuantumJob.is_terminal_state", return_value=True):
job = BraketQuantumTask(SV1_ARN, task=Mock())
with pytest.raises(JobStateError):
job.cancel()
def test_result_measurements():
"""Test measurements method of BraketGateModelJobResult class."""
mock_measurements = np.array([[0, 1, 1], [1, 0, 1]])
mock_result = MagicMock()
mock_result.measurements = mock_measurements
result = BraketGateModelJobResult(mock_result)
expected_output = np.array([[1, 1, 0], [1, 0, 1]])
np.testing.assert_array_equal(result.measurements(), expected_output)
def test_result_raw_counts():
"""Test raw_counts method of BraketGateModelJobResult class."""
mock_measurement_counts = {(0, 1, 1): 10, (1, 0, 1): 5}
mock_result = MagicMock()
mock_result.measurement_counts = mock_measurement_counts
result = BraketGateModelJobResult(mock_result)
expected_output = {"110": 10, "101": 5}
assert result.raw_counts() == expected_output
def test_get_default_region_error():
"""Test getting default region when an exception is raised."""
with patch("qbraid.runtime.braket.provider.Session") as mock_boto_session:
mock_boto_session.side_effect = Exception
mock_boto_session.region_name.return_value = "not us-east-1"
assert BraketProvider()._get_default_region() == "us-east-1"
def test_get_s3_default_bucket():
"""Test getting default S3 bucket."""
with patch("qbraid.runtime.braket.provider.AwsSession") as mock_aws_session:
mock_instance = mock_aws_session.return_value
mock_instance.default_bucket.return_value = "default bucket"
assert BraketProvider()._get_s3_default_bucket() == "default bucket"
mock_instance.default_bucket.side_effect = Exception
assert BraketProvider()._get_s3_default_bucket() == "amazon-braket-qbraid-jobs"
def test_get_quantum_task_cost():
"""Test getting quantum task cost."""
task_mock = Mock()
task_mock.arn = "fake_arn"
task_mock.state.return_value = "COMPLETED"
job = BraketQuantumTask("task_arn", task_mock)
with patch("qbraid.runtime.braket.job.get_quantum_task_cost", return_value=0.1):
assert job.get_cost() == 0.1
def test_built_runtime_profile_fail():
"""Test building a runtime profile with invalid device."""
class FakeSession:
"""Fake Session for testing."""
def __init__(self):
self.region = "us-east-1"
def get_device(self, arn): # pylint: disable=unused-argument
"""Fake get_device method."""
return {
"deviceType": "SIMULATOR",
"providerName": "Amazon Braket",
"deviceCapabilities": "{}",
}
class FakeDevice:
"""Fake AWS Device for testing."""
def __init__(self, arn, aws_session=None):
self.arn = arn
self.aws_session = aws_session or FakeSession()
self.status = "ONLINE"
self.properties = TestProperties()
self.is_available = True
@staticmethod
def get_device_region(arn): # pylint: disable=unused-argument
"""Fake get_device_region method."""
return "us-east-1"
provider = BraketProvider(
aws_access_key_id="aws_access_key_id",
aws_secret_access_key="aws_secret_access_key",
)
device = FakeDevice(arn=SV1_ARN, aws_session=FakeSession())
with pytest.raises(QbraidError):
assert provider._build_runtime_profile(device=device)
def test_braket_result_error():
"""Test Braket result decoding error."""
task = MockTask("task1")
braket_task = BraketQuantumTask("task1", task)
with pytest.raises(ValueError):
braket_task.result()
def test_braket_job_cancel():
"""Test Braket job cancel method."""
task = MockTask("task2")
braket_task = BraketQuantumTask("task2", task)
assert braket_task.cancel() is None
def test_get_tasks_by_tag_value_error():
"""Test getting tagged quantum tasks with invalid values."""
with patch("qbraid.runtime.braket.provider.quantum_lib_proxy_state") as mock_proxy_state:
mock_proxy_state.side_effect = ValueError
provider = BraketProvider()
result = provider.get_tasks_by_tag("key", ["value1", "value2"])
assert isinstance(result, list)
def test_get_tasks_by_tag_qbraid_error():
"""Test getting tagged quantum tasks with jobs enabled."""
with patch("qbraid.runtime.braket.provider.quantum_lib_proxy_state") as mock_proxy_state:
mock_proxy_state.return_value = {"enabled": True}
provider = BraketProvider()
with pytest.raises(QbraidError):
provider.get_tasks_by_tag("key", ["value1", "value2"])
|
https://github.com/ionq-samples/getting-started
|
ionq-samples
|
%%capture
# First, we install the essential libraries to our current Python runtime.
# "%%capture" (above) captures and in this case, hides the output of this
# cell, so you can comment it out if you need help debugging this step.
%pip install cirq cirq_ionq matplotlib
import cirq, cirq_ionq, matplotlib.pyplot as plt, os
from getpass import getpass
# Before you begin, get your API key from https://cloud.ionq.com/settings/keys
# If your API key is stored as "IONQ_API_KEY" in your local environment, this
# should find it. Otherwise you'll be prompted to enter your API key manually.
api_key = os.getenv('IONQ_API_KEY') or getpass('Enter your IonQ API key: ')
service = cirq_ionq.Service(api_key=api_key, default_target='simulator')
# Now we set up our circuit. In this case, we're creating a circuit with two
# qubits, applying an H gate to qubit-0, a CXGate to both, then measuring.
q0, q1 = cirq.LineQubit.range(2)
circuit = cirq.Circuit(
cirq.H(q0), # H
cirq.CX(q0, q1), # CNOT
cirq.measure(q0, q1) # Measure both qubits
)
# Before submitting the job, we can visualize the circuit using print().
print(circuit)
result = service.run(circuit, name="Cirq example", repetitions=100)
_ = cirq.plot_state_histogram(result, plt.subplot())
plt.show()
|
https://github.com/minnukota381/Quantum-Computing-Qiskit
|
minnukota381
|
from qiskit import *
from qiskit.visualization import plot_histogram
import numpy as np
# creating a constant oracle, input has no effect on the ouput
# Create a quantum circuit with 2 qubits. One as input and other as output
constant_oracle = QuantumCircuit(2)
# get a random number from 0 or 1
output = np.random.randint(2)
# what ever get in input, its having no effect.
# the output will be the random value 0 or 1
if output == 1:
constant_oracle.x(1)
# draw the circuit
constant_oracle.draw('mpl')
# creating a balanced oracle,
# perform CNOTs with first qubit input as a control and the second qubit output as the target.
balanced_oracle = QuantumCircuit(2)
# Place X-gate for input qubit
balanced_oracle.x(0)
# Use barrier as divider
balanced_oracle.barrier()
# Place Controlled-NOT gates
balanced_oracle.cx(0, 1)
# using barrier as a divider and avoid cancelling gates by the transpiler
balanced_oracle.barrier()
# Place X-gates
balanced_oracle.x(0)
# Show oracle
balanced_oracle.draw('mpl')
#initialise the input qubits in the state |+⟩
# and the output qubit in the state |−⟩
dj_circuit = QuantumCircuit(2, 1)
# Apply H-gates
dj_circuit.h(0)
# Put qubit in state |->
dj_circuit.x(1)
dj_circuit.h(1)
dj_circuit.draw('mpl')
# define the oracle function to use
#oracle_fn = constant_oracle
oracle_fn = balanced_oracle
# Add oracle function
dj_circuit &= oracle_fn
dj_circuit.draw('mpl')
# perform H-gates on qubit and measure input register
dj_circuit.h(0)
dj_circuit.barrier()
# Measure
dj_circuit.measure(0, 0)
# Display circuit
dj_circuit.draw('mpl')
# check the output
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(dj_circuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import dimod
import numpy as np
import dwave.system
A = np.array([[0,1,2,3,4,1],
[2,1,4,1,0,2],
[1,1,1,1,0,3],
[1,5,2,3,4,1]])
m, n = A.shape
vartype = dimod.Vartype.BINARY
c = np.array([1,2,1,3,1,4])
b = np.array([1, 3, 2, 6])
# Set up linear and quadratic coefficients
L = c.T - 2 * np.matmul(b.T,A)
Q = np.matmul(A.T,A)
offset = b.T.dot(b)
bqm = dimod.as_bqm(L, Q, offset, vartype)
sampler = dwave.system.DWaveCliqueSampler()
sampleset = sampler.sample(bqm,num_reads = 2000)
sampleset.to_pandas_dataframe()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit, transpile
from qiskit.quantum_info import Kraus, SuperOp
from qiskit_aer import AerSimulator
from qiskit.tools.visualization import plot_histogram
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (NoiseModel, QuantumError, ReadoutError,
pauli_error, depolarizing_error, thermal_relaxation_error)
# Construct a 1-qubit bit-flip and phase-flip errors
p_error = 0.05
bit_flip = pauli_error([('X', p_error), ('I', 1 - p_error)])
phase_flip = pauli_error([('Z', p_error), ('I', 1 - p_error)])
print(bit_flip)
print(phase_flip)
# Compose two bit-flip and phase-flip errors
bitphase_flip = bit_flip.compose(phase_flip)
print(bitphase_flip)
# Tensor product two bit-flip and phase-flip errors with
# bit-flip on qubit-0, phase-flip on qubit-1
error2 = phase_flip.tensor(bit_flip)
print(error2)
# Convert to Kraus operator
bit_flip_kraus = Kraus(bit_flip)
print(bit_flip_kraus)
# Convert to Superoperator
phase_flip_sop = SuperOp(phase_flip)
print(phase_flip_sop)
# Convert back to a quantum error
print(QuantumError(bit_flip_kraus))
# Check conversion is equivalent to original error
QuantumError(bit_flip_kraus) == bit_flip
# Measurement miss-assignement probabilities
p0given1 = 0.1
p1given0 = 0.05
ReadoutError([[1 - p1given0, p1given0], [p0given1, 1 - p0given1]])
# Create an empty noise model
noise_model = NoiseModel()
# Add depolarizing error to all single qubit u1, u2, u3 gates
error = depolarizing_error(0.05, 1)
noise_model.add_all_qubit_quantum_error(error, ['u1', 'u2', 'u3'])
# Print noise model info
print(noise_model)
# Create an empty noise model
noise_model = NoiseModel()
# Add depolarizing error to all single qubit u1, u2, u3 gates on qubit 0 only
error = depolarizing_error(0.05, 1)
noise_model.add_quantum_error(error, ['u1', 'u2', 'u3'], [0])
# Print noise model info
print(noise_model)
# System Specification
n_qubits = 4
circ = QuantumCircuit(n_qubits)
# Test Circuit
circ.h(0)
for qubit in range(n_qubits - 1):
circ.cx(qubit, qubit + 1)
circ.measure_all()
print(circ)
# Ideal simulator and execution
sim_ideal = AerSimulator()
result_ideal = sim_ideal.run(circ).result()
plot_histogram(result_ideal.get_counts(0))
# Example error probabilities
p_reset = 0.03
p_meas = 0.1
p_gate1 = 0.05
# QuantumError objects
error_reset = pauli_error([('X', p_reset), ('I', 1 - p_reset)])
error_meas = pauli_error([('X',p_meas), ('I', 1 - p_meas)])
error_gate1 = pauli_error([('X',p_gate1), ('I', 1 - p_gate1)])
error_gate2 = error_gate1.tensor(error_gate1)
# Add errors to noise model
noise_bit_flip = NoiseModel()
noise_bit_flip.add_all_qubit_quantum_error(error_reset, "reset")
noise_bit_flip.add_all_qubit_quantum_error(error_meas, "measure")
noise_bit_flip.add_all_qubit_quantum_error(error_gate1, ["u1", "u2", "u3"])
noise_bit_flip.add_all_qubit_quantum_error(error_gate2, ["cx"])
print(noise_bit_flip)
# Create noisy simulator backend
sim_noise = AerSimulator(noise_model=noise_bit_flip)
# Transpile circuit for noisy basis gates
circ_tnoise = transpile(circ, sim_noise)
# Run and get counts
result_bit_flip = sim_noise.run(circ_tnoise).result()
counts_bit_flip = result_bit_flip.get_counts(0)
# Plot noisy output
plot_histogram(counts_bit_flip)
# T1 and T2 values for qubits 0-3
T1s = np.random.normal(50e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
T2s = np.random.normal(70e3, 10e3, 4) # Sampled from normal distribution mean 50 microsec
# Truncate random T2s <= T1s
T2s = np.array([min(T2s[j], 2 * T1s[j]) for j in range(4)])
# Instruction times (in nanoseconds)
time_u1 = 0 # virtual gate
time_u2 = 50 # (single X90 pulse)
time_u3 = 100 # (two X90 pulses)
time_cx = 300
time_reset = 1000 # 1 microsecond
time_measure = 1000 # 1 microsecond
# QuantumError objects
errors_reset = [thermal_relaxation_error(t1, t2, time_reset)
for t1, t2 in zip(T1s, T2s)]
errors_measure = [thermal_relaxation_error(t1, t2, time_measure)
for t1, t2 in zip(T1s, T2s)]
errors_u1 = [thermal_relaxation_error(t1, t2, time_u1)
for t1, t2 in zip(T1s, T2s)]
errors_u2 = [thermal_relaxation_error(t1, t2, time_u2)
for t1, t2 in zip(T1s, T2s)]
errors_u3 = [thermal_relaxation_error(t1, t2, time_u3)
for t1, t2 in zip(T1s, T2s)]
errors_cx = [[thermal_relaxation_error(t1a, t2a, time_cx).expand(
thermal_relaxation_error(t1b, t2b, time_cx))
for t1a, t2a in zip(T1s, T2s)]
for t1b, t2b in zip(T1s, T2s)]
# Add errors to noise model
noise_thermal = NoiseModel()
for j in range(4):
noise_thermal.add_quantum_error(errors_reset[j], "reset", [j])
noise_thermal.add_quantum_error(errors_measure[j], "measure", [j])
noise_thermal.add_quantum_error(errors_u1[j], "u1", [j])
noise_thermal.add_quantum_error(errors_u2[j], "u2", [j])
noise_thermal.add_quantum_error(errors_u3[j], "u3", [j])
for k in range(4):
noise_thermal.add_quantum_error(errors_cx[j][k], "cx", [j, k])
print(noise_thermal)
# Run the noisy simulation
sim_thermal = AerSimulator(noise_model=noise_thermal)
# Transpile circuit for noisy basis gates
circ_tthermal = transpile(circ, sim_thermal)
# Run and get counts
result_thermal = sim_thermal.run(circ_tthermal).result()
counts_thermal = result_thermal.get_counts(0)
# Plot noisy output
plot_histogram(counts_thermal)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/yatharth0610/Quantum-Algorithms-qiskit-
|
yatharth0610
|
!pip install tabulate
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from tabulate import tabulate
import numpy as np
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
def qft_dagger(n):
"""n-qubit QFTdagger the first n qubits in circ"""
qc = QuantumCircuit(n)
# Don't forget the Swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cu1(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
qc.name = "QFT†"
return qc
def __c_amod15(power):
"""Controlled multiplication by a mod 15"""
U = QuantumCircuit(4)
for iteration in range(power):
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
for q in range(4):
U.x(q)
U = U.to_gate()
U.name = "a^%i mod 15" % (power)
c_U = U.control()
return c_U
t=3
qc = QuantumCircuit(t+4,t)
for i in range(t):
qc.h(i) # The first t qubits are the first register (storing 'x')
qc.x(6) #The second register is in state |1>
# Oracle for the f(x) mentioned above
def Oracle(qc):
for q in range(3):
qc.append(__c_amod15(2**q), [q] + [i+3 for i in range(4)])
Oracle(qc)
qc.append(qft_dagger(t),range(t)) # inverse quantum fourier transform only of the register (first 4 qubits)
qc.measure(range(t), range(t))
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 100000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
counts = run_circuit(qc)
print(counts)
plot_histogram(counts)
rows, eigenvalues = [], []
for output in counts:
decimal = int(output, 2)
eigenvalue = decimal/(2**t)
eigenvalues.append(eigenvalue)
rows.append(["%s(bin) = %i(dec)" % (output, decimal), "%i/%i = %.2f" % (decimal, 2**t, eigenvalue)])
print(tabulate(rows, headers=["Register Output", "Phase"]))
0.333333333.as_integer_ratio()
rows = []
for eigenvalue in eigenvalues:
numerator, denominator = eigenvalue.as_integer_ratio()
rows.append([eigenvalue, "%i/%i" % (numerator, denominator), denominator])
print(tabulate(rows, headers=["Phase", "Fraction", "Guess for r"], colalign=('right','right','right')))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_hinton
qc = QuantumCircuit(2)
qc.h([0, 1])
qc.cz(0,1)
qc.ry(np.pi/3 , 0)
qc.rx(np.pi/5, 1)
state = DensityMatrix(qc)
plot_state_hinton(state, title="New Hinton Plot")
|
https://github.com/shantomborah/Quantum-Algorithms
|
shantomborah
|
# Importing Packages
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble, QuantumRegister, ClassicalRegister
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
bb = input("Enter the input string:\n")
### Using in-built "simon_oracle" from QISKIT
# importing Qiskit
from qiskit import IBMQ, Aer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, transpile, assemble
# import basic plot tools
from qiskit.visualization import plot_histogram
from qiskit_textbook.tools import simon_oracle
n = len(bb)
simon_circuit = QuantumCircuit(n*2, n)
# Apply Hadamard gates before querying the oracle
simon_circuit.h(range(n))
# Apply barrier for visual separation
simon_circuit.barrier()
simon_circuit += simon_oracle(bb)
# Apply barrier for visual separation
simon_circuit.barrier()
# Apply Hadamard gates to the input register
simon_circuit.h(range(n))
# Measure qubits
simon_circuit.measure(range(n), range(n))
simon_circuit.draw(output="mpl")
# use local simulator
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(simon_circuit, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Calculate the dot product of the results
def bdotz(b, z):
accum = 0
for i in range(len(b)):
accum += int(b[i]) * int(z[i])
return (accum % 2)
for z in counts:
print( '{}.{} = {} (mod 2)'.format(b, z, bdotz(b,z)) )
b = input("Enter a binary string:\n")
# Actual b = 011
b_rev = b[::-1]
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
qc.measure(q1,c1)
qc.draw("mpl")
aer_sim = Aer.get_backend('aer_simulator')
shots = 500
qobj = assemble(qc, shots=shots)
results = aer_sim.run(qobj).result()
counts = results.get_counts()
print(counts)
plot_histogram(counts)
# Actual b = 011
b="1"
b_rev = "1"
flagbit = b_rev.find('1')
n=len(b)
q1=QuantumRegister(n,'q1')
q2=QuantumRegister(n,'q2')
c1=ClassicalRegister(n)
qc = QuantumCircuit(q1,q2,c1)
qc.barrier()
qc.h(q1)
qc.barrier()
for i in range(n):
qc.cx(q1[i],q2[i])
qc.barrier()
if flagbit != -1:
# print("test1")
for ind, bit in enumerate(b_rev):
# print("test2")
if bit == "1":
# print("test3")
qc.cx(flagbit, q2[ind])
qc.barrier()
qc.h(q1)
qc.barrier()
# qc.measure(q1,c1)
# qc.draw("mpl")
# Simulate the unitary
usim = Aer.get_backend('aer_simulator')
qc.save_unitary()
qobj = assemble(qc)
unitary = usim.run(qobj).result().get_unitary()
# Display the results:
array_to_latex(unitary, prefix="\\text{Circuit = } ")
|
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/abbarreto/qiskit4
|
abbarreto
| |
https://github.com/MiChaelinzo/Quantum-time-travel
|
MiChaelinzo
|
import qiskit
import math
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_histogram
from qiskit_aer import Aer
def time_travel_circuit(target_time):
"""
This function creates a quantum circuit that 'sends' qubits to the target_time.
Note: This is a fictional representation and not scientifically accurate.
"""
# Initialize a quantum circuit with 6 qubits
qc = QuantumCircuit(6, 6)
# Apply Hadamard gates to the first four qubits to create superposition states
for qubit in range(6):
qc.h(qubit)
# Encode the target time into the quantum state using phase gates
# Convert the target_time to binary and pad it to ensure it has 6 bits
time_binary = bin(target_time)[2:].zfill(6)
for qubit, time_bit in enumerate(time_binary):
# Apply a phase gate if the corresponding bit in the target_time is 1
if time_bit == '1':
qc.p(math.pi, qubit)
# Entangle qubits to link them through quantum entanglement
# Create a chain of CNOT gates
qc.cx(0, 1)
qc.cx(1, 2)
qc.cx(2, 3)
# Measure the first 6 qubits
qc.measure(range(6), range(6))
return qc
# Example usage:
# Set the target time as an integer (e.g., 25 for the year 2025)
target_time = 25
# Create the time travel circuit
ttc = time_travel_circuit(target_time)
# Execute the circuit on a simulator
simulator = Aer.get_backend('qasm_simulator')
compiled_circuit = transpile(ttc, simulator)
job = simulator.run(compiled_circuit, shots=1024)
# Get the results
results = job.result()
counts = results.get_counts(ttc)
# Visualize the results
histogram = plot_histogram(counts)
# Display the histogram
print(histogram)
# Visualize the results
plot_histogram(counts)
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
from pprint import pprint
import pickle
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One
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
# unused for this file
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("../../solutions/utils/")
import circuit_utils, zne_utils, tomography_utils
importlib.reload(circuit_utils)
importlib.reload(zne_utils) # unused for this file
importlib.reload(tomography_utils) # unused for this file
from circuit_utils import *
from zne_utils import zne_wrapper, zne_decoder
from tomography_utils import expvals_to_valid_rho
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
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_list = [1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100]
print("trotter step list: ", num_steps_list)
scale_factors = [1.0, 2.0, 3.0] # unused for this file
shots = 1 << 13
reps = 8 # unused
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
# QREM
qr = QuantumRegister(num_qubits, name="calq")
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
# we have to feed initial_layout to calibration matrix
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
retrieved_cal_job = cal_job
cal_results = retrieved_cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
raw_fid_list = []
raw_stddev_list = []
qrem_fid_list = []
qrem_stddev_list = []
for num_steps in num_steps_list:
print("trotter steps: ", num_steps)
t1 = time.perf_counter()
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="q")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
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
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_st_qcs = transpile(t3_st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = t3_st_qcs
# zne_qcs = zne_wrapper(t3_st_qcs, scale_factors = scale_factors, pt = False)
# print("created zne_qcs (length:", len(zne_qcs), ")")
# optimization_level must be 0
# feed initial_layout here to see the picture of the circuits before casting the job
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
jobs = []
for _ in range(reps):
#! CHECK: run t3_zne_qcs, with optimization_level = 0 and straightforward initial_layout
job = execute(t3_zne_qcs, backend, shots=shots, optimization_level=0)
print('Job ID', job.job_id())
jobs.append(job)
retrieved_jobs = jobs
raw_fids = []
qrem_fids = []
for job in retrieved_jobs:
raw_results = job.result()
mit_results = meas_fitter.filter.apply(raw_results)
raw_rho = StateTomographyFitter(raw_results, t3_zne_qcs).fit(method='lstsq')
qrem_rho = StateTomographyFitter(mit_results, t3_zne_qcs).fit(method='lstsq')
raw_fids.append(state_fidelity(raw_rho, target_state))
qrem_fids.append(state_fidelity(qrem_rho, target_state))
raw_fid_list.append(np.mean(raw_fids))
raw_stddev_list.append(np.std(raw_fids))
qrem_fid_list.append(np.mean(qrem_fids))
qrem_stddev_list.append(np.std(qrem_fids))
t2 = time.perf_counter()
print('raw state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(raw_fids), np.std(raw_fids)))
print('qrem state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(qrem_fids), np.std(qrem_fids)))
print("time:", t2 - t1)
print()
with open("e2d1_raw.pkl", "wb") as f:
pickle.dump({"num_steps_list": num_steps_list, "fid": raw_fid_list, "stddev": raw_stddev_list}, f)
with open("e2d1_qrem.pkl", "wb") as f:
pickle.dump({"num_steps_list": num_steps_list, "fid": qrem_fid_list, "stddev": qrem_stddev_list}, f)
import qiskit.tools.jupyter
%qiskit_version_table
plt.plot(num_steps_list, raw_fid_list)
plt.plot(num_steps_list, qrem_fid_list)
|
https://github.com/hritiksauw199/Qiskit-textbook-solutions
|
hritiksauw199
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(2)
print(u)
qc = QuantumCircuit(2)
qc.iso(u, [0], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(2)
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (2):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(2)
qc.diagonal(c2, [0])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(4)
print(u)
qc = QuantumCircuit(4)
qc.iso(u, [0,1], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(4)/2
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (4):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(4)
qc.diagonal(c2, [0, 1])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(8)
print(u)
qc = QuantumCircuit(4)
qc.iso(u, [0, 1, 2], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(8)/3
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (8):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(4)
qc.diagonal(c2, [0, 1, 2])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(16)
print(u)
qc = QuantumCircuit(4)
qc.iso(u, [0, 1, 2, 3], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(16)/4
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (16):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(4)
qc.diagonal(c2, [0, 1, 2, 3])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(32)
print(u)
qc = QuantumCircuit(8)
qc.iso(u, [0, 1, 2, 3, 4], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(32)/5
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (32):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(8)
qc.diagonal(c2, [0, 1, 2, 3, 4])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(64)
print(u)
qc = QuantumCircuit(8)
qc.iso(u, [0, 1, 2, 3, 4, 5], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(64)/6
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (64):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(8)
qc.diagonal(c2, [0, 1, 2, 3, 4, 5])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(128)
print(u)
qc = QuantumCircuit(8)
qc.iso(u, [0, 1, 2, 3, 4, 5, 6], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(128)/7
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (128):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(8)
qc.diagonal(c2, [0, 1, 2, 3, 4, 5, 6])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(256)
print(u)
qc = QuantumCircuit(8)
qc.iso(u, [0, 1, 2, 3, 4, 5, 6, 7], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(256)/8
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (256):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(8)
qc.diagonal(c2, [0, 1, 2, 3, 4, 5, 6, 7])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(512)
print(u)
qc = QuantumCircuit(16)
qc.iso(u, [0, 1, 2, 3, 4, 5, 6, 7, 8], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(512)/9
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (512):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(16)
qc.diagonal(c2, [0, 1, 2, 3, 4, 5, 6, 7, 8])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy.stats import unitary_group
u = unitary_group.rvs(1024)
print(u)
qc = QuantumCircuit(16)
qc.iso(u, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], [])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
import scipy
from scipy import linalg
h = scipy.linalg.hadamard(1024)/10
import numpy as np
u1 = np.dot(h, u)
u2 = np.dot(u1, h)
c2 = []
for i in range (1024):
c2.append(u2[i,i])
print(c2)
qc = QuantumCircuit(16)
qc.diagonal(c2, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
qc = transpile(qc, basis_gates = ['u3', 'cx'], seed_transpiler=0, optimization_level=3)
circuit_drawer(qc)
|
https://github.com/kerenavnery/qmail
|
kerenavnery
|
import Protocols
ALICE_ADDR = 'localhost'
BOB_ADDR = 'localhost'
ALICE_PORT = 5005
BOB_PORT = 5006
def main():
# prepare message
message = "Hello Qiskit!"
Protocols.send_a_qmail(message, ALICE_PORT, BOB_ADDR, BOB_PORT)
pass
if __name__ == "__main__":
main()
|
https://github.com/Syed-Affan-Hussain/Solving-TSP-Using-QAOA-VQE-through-Qiskit
|
Syed-Affan-Hussain
|
from qiskit import Aer
from qiskit.algorithms.optimizers import COBYLA
from qiskit.quantum_info.operators import Operator
#from qiskit.optimization.applications.ising import tsp
from qiskit_optimization.applications import Tsp
#from qiskit.aqua.algorithms import NumPyMinimumEigensolver, QAOA
from qiskit.algorithms.minimum_eigensolvers import QAOA , NumPyMinimumEigensolver
#from qiskit.aqua import aqua_globals, QuantumInstance
from qiskit.utils import QuantumInstance
from qiskit_optimization.algorithms import MinimumEigenOptimizer
#from qiskit.optimization.problems import QuadraticProgram
from qiskit_optimization import QuadraticProgram
from qiskit_optimization.converters import QuadraticProgramToQubo
from qiskit.primitives import Sampler
import matplotlib.pyplot as plt
import networkx as nx
from qiskit.utils import algorithm_globals
# NOTE Run this Code on IBM Quantum LAB
#The below code is an implementation of solving TSP with QAOA and VQE
# the errors are in result of probable compatibitlity between Qiskit QAOA and Tsp Function.
#I have submitted the issue on GitHub
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=0.8, ax=default_axes, pos=pos)
edge_labels = nx.get_edge_attributes(G, "weight")
nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=edge_labels)
def draw_tsp_solution(G, order, colors, pos):
G2 = nx.DiGraph()
G2.add_nodes_from(G)
n = len(order)
for i in range(n):
j = (i + 1) % n
G2.add_edge(order[i], order[j], weight=G[order[i]][order[j]]["weight"])
default_axes = plt.axes(frameon=True)
nx.draw_networkx(
G2, node_color=colors, edge_color="b", node_size=600, alpha=0.8, ax=default_axes, pos=pos
)
edge_labels = nx.get_edge_attributes(G2, "weight")
nx.draw_networkx_edge_labels(G2, pos, font_color="b", edge_labels=edge_labels)
# Generating a TSP instance of n cities
n = 3
num_qubits = n**2
tsp = Tsp.create_random_instance(n, seed=123)
adj_matrix = nx.to_numpy_array(tsp.graph)
print("distance\n", adj_matrix)
colors = ["r" for node in tsp.graph.nodes]
pos = [tsp.graph.nodes[node]["pos"] for node in tsp.graph.nodes]
draw_graph(tsp.graph, colors, pos)
# Create a random TSP Hamiltonian
qp = tsp.to_quadratic_program()
print(qp.prettyprint())
qp2qubo = QuadraticProgramToQubo()
qubo = qp2qubo.convert(qp)
qubitOp, offset = qubo.to_ising()
print(qubitOp, offset)
algorithm_globals.random_seed = 10598
optimizer = COBYLA()
sampler = Sampler()
qaoa = QAOA(sampler, optimizer, reps=2)
# solving the Problem using QAOA
qaoa_result =qaoa.compute_minimum_eigenvalue(qubitOp)
print("\nQAOA:\n", qaoa_result)
#v = qaoa_result.optimal_circuit
lowest_eigen_value= qaoa_result.best_measurement['value']
print("energy:", lowest_eigen_value.real)
print("tsp objective:", lowest_eigen_value.real + offset)
print("time:", qaoa_result.optimizer_time)
sample = tsp.sample_most_likely(qaoa_result.eigenstate)
print('sameple',sample)
z = tsp.interpret(sample)
#print('tsp._draw_result(qaoa_result)',tsp._draw_result(sample,pos))
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
from qiskit.circuit.library import TwoLocal
from qiskit.algorithms.optimizers import SPSA
from qiskit.algorithms.minimum_eigensolvers import SamplingVQE
algorithm_globals.random_seed = 123
seed = 10598
optimizer = SPSA(maxiter=300)
ry = TwoLocal(qubitOp.num_qubits, "ry", "cz", reps=5, entanglement="linear")
vqe = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=optimizer)
result = vqe.compute_minimum_eigenvalue(qubitOp)
print("energy:", result.eigenvalue.real)
print("time:", result.optimizer_time)
x = tsp.sample_most_likely(result.eigenstate)
print("feasible:", qubo.is_feasible(x))
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
#There is an issue with QAOA function if you use compute_minimum_eigenvalue
#the energy its returning is not matching with VQE min energy but in the result
#dict it is giving the lowest energy in the value pair.So the above code is working based on that.
algorithm_globals.random_seed = 123
seed = 10598
optimizer = COBYLA()
sampler = Sampler()
qaoa = QAOA(sampler, optimizer, reps=2)
# solving the Problem using QAOA
qaoa_result =qaoa.compute_minimum_eigenvalue(qubitOp)
print("\nQAOA:\n", qaoa_result)
print("tsp objective:", qaoa_result.eigenvalue.real+ offset)
print("energy:", result.eigenvalue.real)
print("time:", result.optimizer_time)
x = tsp.sample_most_likely(result.eigenstate)
print("feasible:", qubo.is_feasible(x))
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
|
https://github.com/clausia/qiskit-fall-fest-peru-2022
|
clausia
|
from qiskit import QuantumRegister
qubit1 = QuantumRegister(1) # el parámetro indica cuántos qubits queremos
qubit2 = QuantumRegister(1, 'qreg') # se puede indicar un nombre al registro cuántico (parámetro opcional)
print(qubit1) # al no especificar el nombre, le asigna uno con una numeración consecutiva
print(qubit2)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(qubit1) # crear un circuito cuántico con un qubit
circuit.draw('mpl') # mostramos la representación gráfica del circuito
circ = QuantumCircuit(3, 2) # circuito con 3 qubits y 2 bits clásicos
circ.h(0) # aplicar compuerta H al qubit 0
circ.cx(0, 1) # aplicar compuerta CNOT a los qubits 0 y 1
circ.cx(0, 2) # aplicar compuerta CNOT a los qubits 0 y 2
circ.measure(0, 1) # medir el qubit 0 en el bit clásico 1
circ.measure(2, 0) # medir el qubit 2 en el bit clásico 0
circ.draw('mpl') # mostrar el circuito
circ1 = QuantumCircuit(1) # circuito con 1 qubit
circ1.x(0) # aplicar compuerta X al (único) qubit 0
circ1.draw('mpl') # mostrar el circuito
from qiskit.quantum_info import Statevector
from qiskit.visualization import array_to_latex
circ1 = QuantumCircuit(1) # circuito con 1 qubit
psi_0 = Statevector(circ1) # estado justo después de crear el circuito
circ1.x(0) # aplicar compuerta X al (único) qubit 0
psi_1 = Statevector(circ1) # estado después aplicar la compuerta X
display(circ1.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0.data))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de X:")
print("➤ en forma de vector:")
display(array_to_latex(psi_1.data))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
from qiskit.visualization import plot_bloch_multivector
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de X:")
display(plot_bloch_multivector(psi_1))
circ2 = QuantumCircuit(1) # circuito con 1 qubit
psi_0 = Statevector(circ2) # estado justo después de crear el circuito
circ2.y(0) # aplicar compuerta Y al (único) qubit 0
psi_1 = Statevector(circ2) # estado después aplicar la compuerta Y
display(circ2.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de Y:")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de Y:")
display(plot_bloch_multivector(psi_1))
circ3 = QuantumCircuit(1) # circuito con 1 qubit
circ3.x(0) # obtener el estado |1>
psi_0 = Statevector(circ3) # estado justo después de crear el circuito e iniciar el qubit en |1>
circ3.z(0) # aplicar compuerta Z al (único) qubit en la posición 0
psi_1 = Statevector(circ3) # estado después aplicar la compuerta Z
display(circ3.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de Z:")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de Z:")
display(plot_bloch_multivector(psi_1))
import numpy as np
circ4 = QuantumCircuit(1) # circuito con 1 qubit
psi_0 = Statevector(circ4) # estado justo después de crear el circuito
circ4.ry(np.pi/2, 0) # rotar pi/2 alrededor del eje y
psi_1 = Statevector(circ4) # estado después de la primera rotación
circ4.rz(np.pi/4, 0) # rotar pi/4 alrededor del eje z
psi_2 = Statevector(circ4) # estado después de la segunda rotación
circ4.rx(np.pi, 0) # rotar pi alrededor del eje x
psi_3 = Statevector(circ4) # estado después de la tercera rotación
display(circ4.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después rotación de pi/2 alrededor del eje y:")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("👉 Estado después rotación de pi/4 alrededor del eje z:")
print("➤ en forma de vector:")
display(array_to_latex(psi_2))
print("➤ en forma de ket:")
display(psi_2.draw('latex'))
print()
print("👉 Estado después rotación de pi alrededor del eje x:")
print("➤ en forma de vector:")
display(array_to_latex(psi_3))
print("➤ en forma de ket:")
display(psi_3.draw('latex'))
print()
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después rotación de pi/2 alrededor del eje y:")
display(plot_bloch_multivector(psi_1))
print("🔵 Estado después rotación de pi/4 alrededor del eje z:")
display(plot_bloch_multivector(psi_2))
print("🔵 Estado después rotación de pi alrededor del eje x:")
display(plot_bloch_multivector(psi_3))
circ5 = QuantumCircuit(1) # circuito con 1 qubit
psi_0 = Statevector(circ5) # estado justo después de crear el circuito
circ5.h(0) # apliquemos H al estado |0>, quedamos en |+>
psi_1 = Statevector(circ5) # estado justo después de aplicar H
circ5.z(0) # aplicar compuerta Z al (único) qubit 0, quedamos en el estado |->
psi_2 = Statevector(circ5) # estado después aplicar la compuerta Z
circ5.h(0) # aplicar compuerta H de nuevo, quedamos en el estado |1>
psi_3 = Statevector(circ5) # estado después aplicar la compuerta Z
display(circ5.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de primera H:")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("👉 Estado después de Z:")
print("➤ en forma de vector:")
display(array_to_latex(psi_2))
print("➤ en forma de ket:")
display(psi_2.draw('latex'))
print()
print("👉 Estado después de segunda H:")
print("➤ en forma de vector:")
display(array_to_latex(psi_3))
print("➤ en forma de ket:")
display(psi_3.draw('latex'))
print()
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de primera H:")
display(plot_bloch_multivector(psi_1))
print("🔵 Estado después de Z:")
display(plot_bloch_multivector(psi_2))
print("🔵 Estado después de segunda H:")
display(plot_bloch_multivector(psi_3))
circ6 = QuantumCircuit(1) # circuito con 1 qubit
circ6.h(0) # nos movemos al estado |+>
psi_0 = Statevector(circ6) # estado justo después de crear el circuito y posicionarse en |+>
circ6.s(0) # aplicar compuerta S, rotando pi/2
psi_1 = Statevector(circ6) # estado justo después de aplicar P
circ6.tdg(0) # aplicar compuerta T† rotanfo -pi/4
psi_2 = Statevector(circ6) # estado después aplicar la compuerta S
circ6.p(2*np.pi/3, 0) # aplicar compuerta P, rotando 2pi/3
psi_3 = Statevector(circ6) # estado después aplicar la compuerta T†
display(circ5.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial |+>:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de S:")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("👉 Estado después de T†:")
print("➤ en forma de vector:")
display(array_to_latex(psi_2))
print("➤ en forma de ket:")
display(psi_2.draw('latex'))
print()
print("👉 Estado después de P(2*pi/3):")
print("➤ en forma de vector:")
display(array_to_latex(psi_3))
print("➤ en forma de ket:")
display(psi_3.draw('latex'))
print()
print("🔵 Estado inicial |+>:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de S:")
display(plot_bloch_multivector(psi_1))
print("🔵 Estado después de T†:")
display(plot_bloch_multivector(psi_2))
print("🔵 Estado después de P(2*pi/3):")
display(plot_bloch_multivector(psi_3))
circ_u = QuantumCircuit(1) # circuito con 1 qubit
psi_0 = Statevector(circ_u) # estado justo después de crear el circuito e iniciar el qubit en |1>
circ_u.u(np.pi/3, np.pi/2, np.pi/5, 0) # aplicar compuerta U3 al (único) qubit en la posición 0
psi_1 = Statevector(circ_u) # estado después aplicar la compuerta U3
display(circ_u.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de U3(pi/3, pi/8, pi/5):")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de U3(pi/3, pi/8, pi/5):")
display(plot_bloch_multivector(psi_1))
from qiskit.quantum_info import Operator
circuit = QuantumCircuit(2) # circuito con 2 qubits
circuit.h(0) # Hadamard en q0
circuit.id(1) # Identidad en q1
display(circuit.draw('mpl'))
op = Operator(circuit)
display(array_to_latex(op))
psi = Statevector(circuit)
display(plot_bloch_multivector(psi))
circuit = QuantumCircuit(3) # circuito con 3 qubits
circuit.rx(np.pi/4, 0) # Rx de pi/4 al q0
circuit.ry(3*np.pi/5, 1) # Ry de 3pi/5 al q1
circuit.h(2) # Hadamard al q2
display(circuit.draw('mpl'))
op = Operator(circuit)
display(array_to_latex(op))
psi = Statevector(circuit)
print()
display(plot_bloch_multivector(psi))
circ7 = QuantumCircuit(2) # circuito con 2 qubits
circ7.x(0) # ponemos el control en |1> para que la compuerta sea aplicada
circ7.cx(0, 1) # CNOT con q0 como control y q1 como objetivo
print("Este es el caso para CNOT(0,1)|01> = |11>")
display(circ7.draw('mpl'))
op = Operator(circ7)
display(array_to_latex(op))
psi = Statevector(circ7)
print()
display(plot_bloch_multivector(psi))
circ8 = QuantumCircuit(2) # circuito con 2 qubits
circ8.x(1) # ponemos el control en |1> para que la compuerta sea aplicada
circ8.cx(1, 0) # CNOT con q1 como control y q0 como objetivo
print("Este es el caso para CNOT(1,0)|10> = |11>")
display(circ8.draw('mpl'))
op = Operator(circ8)
display(array_to_latex(op))
psi = Statevector(circ8)
print()
display(plot_bloch_multivector(psi))
circ9 = QuantumCircuit(2) # circuito con 2 qubits
circ9.cy(0, 1) # Y controlada, qubit control es q0, y objetivo es q1
circ9.cz(1, 0) # Z controlada, qubit control es q1, y objetivo es q0
circ9.cx(0, 1) # X controlada, qubit control es q0, y objetivo es q1
circ9.ch(0, 1) # H controlada, qubit control es q0, y objetivo es q1
circ9.crx(np.pi/8, 1, 0) # Rx controlada, ángulo de pi/8, qubit control es q1, y objetivo es q0
circ9.crz(3*np.pi/5, 0, 1) # Rz controlada, ángulo de 3pi/5, qubit control es q0, y objetivo es q1
circ9.cp(7*np.pi/9, 1, 0) # P controlada, ángulo de 7pi/9, qubit control es q1, y objetivo es q0
display(circ9.draw('mpl'))
from qiskit.extensions import UnitaryGate
matrix = [[1j, 0],
[0 , 1,]]
mi_gate = UnitaryGate(matrix, 'mi_gate')
circ10 = QuantumCircuit(2) # circuito con 2 qubits
circ10.append(mi_gate, [0]) # le agregamos al circuito la compuerta personalizada
mi_gate_controlada = mi_gate.control(1) # hacemos la version controlada de mi_gate
circ10.append(mi_gate_controlada, [0, 1]) # se indican los qubits, primero el control y luego el objetivo
display(circ10.draw('mpl'))
circ11 = QuantumCircuit(2) # circuito con 2 qubit
circ11.x(0) # obtener el estado |01>
psi_0 = Statevector(circ11) # estado justo después de crear el circuito e iniciar el qubit en |01>
circ11.swap(0, 1) # aplicar compuerta SWAP a los dos quibits existentes
psi_1 = Statevector(circ11) # estado después aplicar la compuerta Z
display(circ11.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de SWAP:")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de SWAP:")
display(plot_bloch_multivector(psi_1))
circ12 = QuantumCircuit(3) # circuito con 3 qubit
circ12.x(1) # obtener el estado |010>
circ12.x(2) # obtener el estado |110>
psi_0 = Statevector(circ12) # estado justo después de crear el circuito e iniciar el qubit en |110>
circ12.ccx(1, 2, 0) # aplicar compuerta CCX: control1, control2, objetivo
psi_1 = Statevector(circ12) # estado después aplicar la compuerta Z
display(circ12.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de CCX(1, 2, 0):")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de CCX(1, 2, 0):")
display(plot_bloch_multivector(psi_1))
circ13 = QuantumCircuit(3) # circuito con 3 qubit
circ13.x(2) # obtener el estado |100>
circ13.x(1) # obtener el estado |110>
psi_0 = Statevector(circ13) # estado justo después de crear el circuito e iniciar el qubit en |110>
circ13.cswap(2, 0, 1) # aplicar compuerta CCX: control1, objetivo1, objetivo2
psi_1 = Statevector(circ13) # estado después aplicar la compuerta Z
display(circ13.draw('mpl')) # mostrar el circuito
print("👉 Estado inicial:")
print("➤ en forma de vector:")
display(array_to_latex(psi_0))
print("➤ en forma de ket:")
display(psi_0.draw('latex'))
print()
print("👉 Estado después de SWAP(2, 0, 1):")
print("➤ en forma de vector:")
display(array_to_latex(psi_1))
print("➤ en forma de ket:")
display(psi_1.draw('latex'))
print()
print("🔵 Estado inicial:")
display(plot_bloch_multivector(psi_0))
print("🔵 Estado después de SWAP(2, 0, 1):")
display(plot_bloch_multivector(psi_1))
# Crear una comperta a partir de un circuito
qc1 = QuantumCircuit(2)
# estos dos quits serán los objetivos
qc1.x(0)
qc1.h(1)
custom = qc1.to_gate().control(2) # se indica que debe ser controlada con dos qubits
# Aplicar esa compuerta a otro circuito
qc2 = QuantumCircuit(4)
qc2.append(custom, [0, 3, 1, 2]) # primeros 2 son control, el resto a los que se aplica la compuerta
qc2.draw('mpl')
circ_bell_1 = QuantumCircuit(2) # circuito con 2 qubits
circ_bell_1.barrier()
circ_bell_1.h(0) # aplicar compuerta H al qubit 0
circ_bell_1.cx(0,1) # aplicar compuerta CNOT
psi_bell_1 = Statevector(circ_bell_1) # estado final
display(circ_bell_1.draw('mpl')) # mostrar el circuito
print("👉 Estado de Bell 1:")
print("➤ en forma de vector:")
display(array_to_latex(psi_bell_1))
print("➤ en forma de ket:")
display(psi_bell_1.draw('latex'))
circ_bell_2 = QuantumCircuit(2) # circuito con 2 qubits
circ_bell_2.x(0) # aplicar compuerta X al qubit 0
circ_bell_2.barrier()
circ_bell_2.h(0) # aplicar compuerta H al qubit 0
circ_bell_2.cx(0,1) # aplicar compuerta CNOT
psi_bell_2 = Statevector(circ_bell_2) # estado final
display(circ_bell_2.draw('mpl')) # mostrar el circuito
print("👉 Estado de Bell 2:")
print("➤ en forma de vector:")
display(array_to_latex(psi_bell_2))
print("➤ en forma de ket:")
display(psi_bell_2.draw('latex'))
circ_bell_3 = QuantumCircuit(2) # circuito con 2 qubits
circ_bell_3.x(1) # aplicar compuerta X al qubit 1
circ_bell_3.barrier()
circ_bell_3.h(0) # aplicar compuerta H al qubit 0
circ_bell_3.cx(0,1) # aplicar compuerta CNOT
psi_bell_3 = Statevector(circ_bell_3) # estado final
display(circ_bell_3.draw('mpl')) # mostrar el circuito
print("👉 Estado de Bell 2:")
print("➤ en forma de vector:")
display(array_to_latex(psi_bell_3))
print("➤ en forma de ket:")
display(psi_bell_3.draw('latex'))
circ_bell_4 = QuantumCircuit(2) # circuito con 2 qubits
circ_bell_4.x(0) # aplicar compuerta X al qubit 0
circ_bell_4.x(1) # aplicar compuerta X al qubit 1
circ_bell_4.barrier()
circ_bell_4.h(0) # aplicar compuerta H al qubit 0
circ_bell_4.cx(0,1) # aplicar compuerta CNOT
psi_bell_4 = Statevector(circ_bell_4) # estado final
display(circ_bell_4.draw('mpl')) # mostrar el circuito
print("👉 Estado de Bell 2:")
print("➤ en forma de vector:")
display(array_to_latex(psi_bell_4))
print("➤ en forma de ket:")
display(psi_bell_4.draw('latex'))
circ_ghz = QuantumCircuit(3, 3) # circuito con 3 qubits y 3 bits clásicos
circ_ghz.h(0) # aplicar compuerta H al qubit 0
circ_ghz.cx(0, 1) # aplicar compuerta CNOT a los qubits 0 y 1
circ_ghz.cx(0, 2) # aplicar compuerta CNOT a los qubits 0 y 2
circ_ghz.barrier()
circ_ghz.measure([0,1,2], [0,1,2]) # medir los 3 qubits en los 3 bits clásicos
circ_ghz.draw('mpl') # mostrar el circuito
from qiskit import execute, Aer
simulator = Aer.get_backend('aer_simulator')
job = execute(circ_ghz, simulator, shots=1) # ejecutar el circuito una sola vez
counts = job.result().get_counts(circ_ghz) # obtener los resultados de la ejecución
print(counts)
from qiskit.tools.visualization import plot_histogram
job = execute(circ_ghz, simulator, shots=1000) # ejecutar el circuito 1000 veces
counts = job.result().get_counts(circ_ghz) # obtener los resultados de la ejecución
print(counts)
plot_histogram(counts, title='Conteos del estado GHZ') # mostrar los resultados en forma de histograma
Aer.backends()
# incrementar la cantidad de 'shots' reduce la variación en el muestreo
shots = 10000
# Método de simulación: Stabilizer
sim_stabilizer = Aer.get_backend('aer_simulator_stabilizer')
job_stabilizer = sim_stabilizer.run(circ_ghz, shots=shots) #también se puede usar el método 'run' del backend
counts_stabilizer = job_stabilizer.result().get_counts(0)
# Método de simulación: Statevector
sim_statevector = Aer.get_backend('aer_simulator_statevector')
job_statevector = sim_statevector.run(circ_ghz, shots=shots)
counts_statevector = job_statevector.result().get_counts(0)
# Método de simulación: Density Matrix
sim_density = Aer.get_backend('aer_simulator_density_matrix')
job_density = sim_density.run(circ_ghz, shots=shots)
counts_density = job_density.result().get_counts(0)
# Método de simulación: Matrix Product State
sim_mps = Aer.get_backend('aer_simulator_matrix_product_state')
job_mps = sim_mps.run(circ_ghz, shots=shots)
counts_mps = job_mps.result().get_counts(0)
plot_histogram([counts_stabilizer, counts_statevector, counts_density, counts_mps],
title='Conteos para diferentes métodos de simulación',
legend=['stabilizer', 'statevector',
'density_matrix', 'matrix_product_state'])
from qiskit import IBMQ
#IBMQ.save_account('TOKEN') # guardar tu cuenta en tu disco duro
IBMQ.load_account() # cargar cuenta desde el disco duro
IBMQ.providers() # listar todos los proveedores disponibles (para tu cuenta)
provider = IBMQ.get_provider(hub='ibm-q') # obtenemos un proveedor
provider.backends()
provider = IBMQ.get_provider(hub='ibm-q') # obtenemos un proveedor
backend = provider.get_backend('ibmq_qasm_simulator') # obtenemos un backend, en este ejemplo estamos usando
# un simulador, pero uno que se encuentra en la nube,
# es decir, la ejecución no ocurrirá en nuestra máquina local
# esto para obtener un resultado de manera rápida,
# más adelante veremos cómo ejecutar en un dispositivo real
circuit = QuantumCircuit(3, 3) # creamos un circuito de 3 qubits y 3 registros clásicos
circuit.x(0) # aplicamos algunas compuertas
circuit.x(1)
circuit.ccx(0, 1, 2)
circuit.cx(0, 1)
circuit.barrier()
circuit.measure([0, 1, 2], [0, 1, 2]) # agregamos mediciones a los 3 qubits
display(circuit.draw('mpl')) # mostramos el circuito
job = backend.run(circuit) # mandamos ejecutar el circuito al backend en la nube,
# recuerda, este aún es un simulador, pero no local
# esta línea de código puede tardarse varios segundos, o
# incluso minutos dependiendo de la saturación de la red
result = job.result() # la ejecución nos regresa un 'job'
counts = result.get_counts() # al que le podemos pedir los conteos
print(counts) # imprimimos los conteos
# obtenemos todos los backends que no sean simuladores y que estén en línea
provider.backends(simulator=False, operational=True)
# obtenemos todos los backends con más de 3 qubits, que no sean simuladores y que estén en línea
provider.backends(filters=lambda x: x.configuration().n_qubits >= 3
and not x.configuration().simulator
and x.status().operational==True)
from qiskit.providers.ibmq import least_busy
devices = provider.backends(simulator=False, operational=True)
least_busy_device = least_busy(devices) # de la lista de dispositivos, averiguar cual es el menos ocupado
least_busy_device
from qiskit.compiler import transpile
circuit = QuantumCircuit(3, 3) # creamos un circuito de 3 qubits y 3 registros clásicos
circuit.x(0) # aplicamos algunas compuertas
circuit.x(1)
circuit.ccx(0, 1, 2)
circuit.cx(0, 1)
circuit.barrier()
circuit.measure([0, 1, 2], [0, 1, 2]) # agregamos mediciones a los 3 qubits
display(circuit.draw('mpl')) # mostramos el circuito
circuit = transpile(circuit, least_busy_device) # transpilamos el circuito para el backend en específico
display(circuit.draw('mpl')) # mostramos el circuito transpilado
job = least_busy_device.run(circuit) # mandamos ejecutar el circuito al backend en la nube
# guardado en la variable 'least_busy_device'
# esta línea de código puede tardarse hasta varios minutos
# dependiendo de la cantidad de 'jobs' encolados
result = job.result() # la ejecución nos regresa un 'job'
counts = result.get_counts() # al que le podemos pedir los conteos
print(counts) # imprimimos los conteos
least_busy_device.status() # su estado actual
# creamos un circuito para probar
circuit = QuantumCircuit(3, 3)
for i in range(10):
circuit.x(0)
circuit.x(1)
circuit.ccx(0, 1, 2)
circuit.cx(0, 1)
circuit.barrier()
circuit.measure_all()
display(circuit.draw('mpl'))
from qiskit.providers.jobstatus import JobStatus
from time import sleep
from IPython.display import clear_output
circuit = transpile(circuit, least_busy_device) # transpilamos el circuito para el backend en específico
job = least_busy_device.run(circuit) # creamos el 'job' al solicitar la ejecución del circuito
print("Identificador del job:\t", job.job_id()) # obtenemos el identificador del 'job'
print("Job creado el:\t\t", job.creation_date()) # preguntamos la fecha de creacion del 'job'
print()
tt = 0 # tiempo transcurrido (en segundos)
job_status = job.status() # preguntamos por el estatus del 'job'
while job_status.name not in ["DONE", "CANCELLED", "ERROR"]:
try:
job_status = job.status() # preguntamos por el estatus del 'job' nuevamente
if job_status is JobStatus.RUNNING:
print("\rEl job sigue ejecutándose, tt = " + str(tt) + " s", end="")
tt += 1
sleep(1)
except IBMApiError as ex:
print("Algo malo sucedió!: {}".format(ex))
print()
print("\n\t>>> El job ha terminado su ejecución")
print("\n\n")
print("Resultado:\t", job.result().get_counts()) # resultado de la ejecución en el dispositivo real
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import BasicAer, transpile, QuantumRegister, ClassicalRegister, QuantumCircuit
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.measure(0, 0)
qc.x(0).c_if(cr, 0)
qc.measure(0, 0)
qc.draw('mpl')
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-class-docstring
"""Test the passmanager logic"""
import copy
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.circuit.library import U2Gate
from qiskit.converters import circuit_to_dag
from qiskit.transpiler import PassManager, PropertySet, TransformationPass, FlowController
from qiskit.transpiler.passes import CommutativeCancellation
from qiskit.transpiler.passes import Optimize1qGates, Unroller
from qiskit.test import QiskitTestCase
class TestPassManager(QiskitTestCase):
"""Test Pass manager logic."""
def test_callback(self):
"""Test the callback parameter."""
qr = QuantumRegister(1, "qr")
circuit = QuantumCircuit(qr, name="MyCircuit")
circuit.h(qr[0])
circuit.h(qr[0])
circuit.h(qr[0])
expected_start = QuantumCircuit(qr)
expected_start.append(U2Gate(0, np.pi), [qr[0]])
expected_start.append(U2Gate(0, np.pi), [qr[0]])
expected_start.append(U2Gate(0, np.pi), [qr[0]])
expected_start_dag = circuit_to_dag(expected_start)
expected_end = QuantumCircuit(qr)
expected_end.append(U2Gate(0, np.pi), [qr[0]])
expected_end_dag = circuit_to_dag(expected_end)
calls = []
def callback(**kwargs):
out_dict = kwargs
out_dict["dag"] = copy.deepcopy(kwargs["dag"])
calls.append(out_dict)
passmanager = PassManager()
passmanager.append(Unroller(["u2"]))
passmanager.append(Optimize1qGates())
passmanager.run(circuit, callback=callback)
self.assertEqual(len(calls), 2)
self.assertEqual(len(calls[0]), 5)
self.assertEqual(calls[0]["count"], 0)
self.assertEqual(calls[0]["pass_"].name(), "Unroller")
self.assertEqual(expected_start_dag, calls[0]["dag"])
self.assertIsInstance(calls[0]["time"], float)
self.assertEqual(calls[0]["property_set"], PropertySet())
self.assertEqual("MyCircuit", calls[0]["dag"].name)
self.assertEqual(len(calls[1]), 5)
self.assertEqual(calls[1]["count"], 1)
self.assertEqual(calls[1]["pass_"].name(), "Optimize1qGates")
self.assertEqual(expected_end_dag, calls[1]["dag"])
self.assertIsInstance(calls[0]["time"], float)
self.assertEqual(calls[0]["property_set"], PropertySet())
self.assertEqual("MyCircuit", calls[1]["dag"].name)
def test_callback_with_pass_requires(self):
"""Test the callback with a pass with another pass requirement."""
qr = QuantumRegister(3, "qr")
circuit = QuantumCircuit(qr, name="MyCircuit")
circuit.z(qr[0])
circuit.cx(qr[0], qr[2])
circuit.z(qr[0])
expected_start = QuantumCircuit(qr)
expected_start.z(qr[0])
expected_start.cx(qr[0], qr[2])
expected_start.z(qr[0])
expected_start_dag = circuit_to_dag(expected_start)
expected_end = QuantumCircuit(qr)
expected_end.cx(qr[0], qr[2])
expected_end_dag = circuit_to_dag(expected_end)
calls = []
def callback(**kwargs):
out_dict = kwargs
out_dict["dag"] = copy.deepcopy(kwargs["dag"])
calls.append(out_dict)
passmanager = PassManager()
passmanager.append(CommutativeCancellation(basis_gates=["u1", "u2", "u3", "cx"]))
passmanager.run(circuit, callback=callback)
self.assertEqual(len(calls), 2)
self.assertEqual(len(calls[0]), 5)
self.assertEqual(calls[0]["count"], 0)
self.assertEqual(calls[0]["pass_"].name(), "CommutationAnalysis")
self.assertEqual(expected_start_dag, calls[0]["dag"])
self.assertIsInstance(calls[0]["time"], float)
self.assertIsInstance(calls[0]["property_set"], PropertySet)
self.assertEqual("MyCircuit", calls[0]["dag"].name)
self.assertEqual(len(calls[1]), 5)
self.assertEqual(calls[1]["count"], 1)
self.assertEqual(calls[1]["pass_"].name(), "CommutativeCancellation")
self.assertEqual(expected_end_dag, calls[1]["dag"])
self.assertIsInstance(calls[0]["time"], float)
self.assertIsInstance(calls[0]["property_set"], PropertySet)
self.assertEqual("MyCircuit", calls[1]["dag"].name)
def test_to_flow_controller(self):
"""Test that conversion to a `FlowController` works, and the result can be added to a
circuit and conditioned, with the condition only being called once."""
class DummyPass(TransformationPass):
def __init__(self, x):
super().__init__()
self.x = x
def run(self, dag):
return dag
def repeat(count):
def condition(_):
nonlocal count
if not count:
return False
count -= 1
return True
return condition
def make_inner(prefix):
inner = PassManager()
inner.append(DummyPass(f"{prefix} 1"))
inner.append(DummyPass(f"{prefix} 2"), condition=lambda _: False)
inner.append(DummyPass(f"{prefix} 3"), condition=lambda _: True)
inner.append(DummyPass(f"{prefix} 4"), do_while=repeat(1))
return inner.to_flow_controller()
self.assertIsInstance(make_inner("test"), FlowController)
outer = PassManager()
outer.append(make_inner("first"))
outer.append(make_inner("second"), condition=lambda _: False)
# The intent of this `condition=repeat(1)` is to ensure that the outer condition is only
# checked once and not flattened into the inner controllers; an inner pass invalidating the
# condition should not affect subsequent passes once the initial condition was met.
outer.append(make_inner("third"), condition=repeat(1))
calls = []
def callback(pass_, **_):
self.assertIsInstance(pass_, DummyPass)
calls.append(pass_.x)
outer.run(QuantumCircuit(), callback=callback)
expected = [
"first 1",
"first 3",
# it's a do-while loop, not a while, which is why the `repeat(1)` gives two calls
"first 4",
"first 4",
# If the outer pass-manager condition is called more than once, then only the first of
# the `third` passes will appear.
"third 1",
"third 3",
"third 4",
"third 4",
]
self.assertEqual(calls, expected)
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
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()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
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()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
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()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
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.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# 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)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '540um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '530um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '520um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("qubit_pad_w_550_520", 'capacitive')
q3d1.render_design([], [])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
|
https://github.com/suvoooo/Qubits-Qiskit
|
suvoooo
|
!pip3 install qiskit
# !pip install pylatexenc
import qiskit as q
import matplotlib.pyplot as plt
qr = q.QuantumRegister(2)
cr = q.ClassicalRegister(2)
circuit = q.QuantumCircuit(qr, cr)
circuit.draw()
circuit.h(qr[0]) # apply hadamard gate on first qubit.
circuit.h(qr[1]) # apply hadamard gate on second qubit.
# apply cnot gate.
circuit.cx(qr[0], qr[1]) # in qiskit cnot-- first bit is set as control bit and second as target bit.
display(circuit.draw())
#### see the state-vector
statevec = q.Aer.get_backend('statevector_simulator')
final_state = q.execute(circuit, statevec).result().get_statevector()
q.visualization.plot_bloch_multivector(final_state) # the state doesn't not change after application of the CNOT gate
circuit.measure(qr, cr)
circuit.draw(scale=2)
#### simulate result on a local computer
simulator = q.Aer.get_backend(name='qasm_simulator')
results = q.execute(circuit, backend=simulator, ).result()
q.visualization.plot_histogram(results.get_counts(circuit))
### try a different circuit where we apply X gate before applying H gate.
qr1 = q.QuantumRegister(2)
cr1 = q.ClassicalRegister(2)
circuit1 = q.QuantumCircuit(qr1, cr1)
# circuit1.draw()
circuit1.h(qr1[0]) # apply the H gate on q0
circuit1.x(qr1[1]) # apply Not gate on q_1
circuit1.h(qr1[1]) # add H gate on q_1
circuit1.cx(qr1[0], qr1[1]) # apply cx gate with control bit at 0th index
### draw the circuit
circuit1.draw()
#### plt the state vector
statevec1 = q.Aer.get_backend('statevector_simulator')
final_state1 = q.execute(circuit1, statevec1).result().get_statevector()
q.visualization.plot_bloch_multivector(final_state1) # the state doesn't not change after application of the CNOT gate
#### unchanged state as expected
circuit1.measure(qr1, cr1)
### simulate result on local computer
simulator1 = q.Aer.get_backend('qasm_simulator')
results1 = q.execute(circuit1, backend=simulator1, ).result()
q.visualization.plot_histogram(results1.get_counts(circuit1))
### try a different circuit where we apply X gate before applying H gate.
### but we do this for first qubit.
qr2 = q.QuantumRegister(2)
cr2 = q.ClassicalRegister(2)
circuit2 = q.QuantumCircuit(qr2, cr2)
# circuit2.draw()
circuit2.x(qr2[0])
circuit2.h(qr2[0])
circuit2.h(qr2[1])
circuit2.cx(qr2[0], qr2[1])
circuit2.draw()
#### plt the state vector
statevec2 = q.Aer.get_backend('statevector_simulator')
final_state2 = q.execute(circuit2, statevec2).result().get_statevector()
q.visualization.plot_bloch_multivector(final_state2)
circuit2.measure(qr2, cr2)
### simulate result on local computer
simulator2 = q.Aer.get_backend('qasm_simulator')
results2 = q.execute(circuit2, backend=simulator1, ).result()
q.visualization.plot_histogram(results2.get_counts(circuit2))
qr3 = q.QuantumRegister(2)
cr3 = q.ClassicalRegister(2)
circuit3 = q.QuantumCircuit(qr3, cr3)
# circuit3.draw()
circuit3.h(qr3[0])
circuit3.h(qr3[1])
## apply hadamard gates to both qubits.
circuit3.cx(qr3[0], qr3[1])
## till this is first circuit. Now we add one more H gate.
circuit3.h(qr3[0])
circuit3.draw(scale=2)
### plot the state vector
statevec3 = q.Aer.get_backend('statevector_simulator')
final_state3 = q.execute(circuit3, statevec3).result().get_statevector()
q.visualization.plot_bloch_multivector(final_state3)
# let's simulate this on local computer
circuit3.measure(qr3, cr3)
### simulate result on local computer
simulator3 = q.Aer.get_backend('qasm_simulator')
results3 = q.execute(circuit3, backend=simulator3, ).result()
q.visualization.plot_histogram(results3.get_counts(circuit3))
qr4 = q.QuantumRegister(2)
cr4 = q.ClassicalRegister(2)
circuit4 = q.QuantumCircuit(qr4, cr4)
circuit4.h(qr4[0])
circuit4.h(qr4[1])
## apply hadamard gates to both qubits.
circuit4.cx(qr4[0], qr4[1])
## till this is first circuit. Now we add one more H gate.
circuit4.h(qr4[1]) # but now apply the H gate to the second qubit.
circuit4.draw(scale=2)
### plot the state vector
statevec4 = q.Aer.get_backend('statevector_simulator')
final_state4 = q.execute(circuit4, statevec4).result().get_statevector()
q.visualization.plot_bloch_multivector(final_state4)
# let's simulate this on local computer
circuit4.measure(qr4, cr4)
### simulate result on local computer
simulator4 = q.Aer.get_backend('qasm_simulator')
results4 = q.execute(circuit4, backend=simulator4, ).result()
q.visualization.plot_histogram(results4.get_counts(circuit4)) ### !!! great !!! as expected
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.providers.fake_provider import FakeHanoi
backend = FakeHanoi()
config = backend.configuration()
# Basic Features
print("This backend is called {0}, and is on version {1}. It has {2} qubit{3}. It "
"{4} OpenPulse programs. The basis gates supported on this device are {5}."
"".format(config.backend_name,
config.backend_version,
config.n_qubits,
'' if config.n_qubits == 1 else 's',
'supports' if config.open_pulse else 'does not support',
config.basis_gates))
config.dt # units of seconds
config.meas_levels
config.dtm
config.meas_map
config.drive(0)
config.measure(0)
config.acquire(0)
props = backend.properties()
def describe_qubit(qubit, properties):
"""Print a string describing some of reported properties of the given qubit."""
# Conversion factors from standard SI units
us = 1e6
ns = 1e9
GHz = 1e-9
print("Qubit {0} has a \n"
" - T1 time of {1} microseconds\n"
" - T2 time of {2} microseconds\n"
" - U2 gate error of {3}\n"
" - U2 gate duration of {4} nanoseconds\n"
" - resonant frequency of {5} GHz".format(
qubit,
properties.t1(qubit) * us,
properties.t2(qubit) * us,
properties.gate_error('sx', qubit),
properties.gate_length('sx', qubit) * ns,
properties.frequency(qubit) * GHz))
describe_qubit(0, props)
defaults = backend.defaults()
q0_freq = defaults.qubit_freq_est[0] # Hz
q0_meas_freq = defaults.meas_freq_est[0] # Hz
GHz = 1e-9
print("DriveChannel(0) defaults to a modulation frequency of {} GHz.".format(q0_freq * GHz))
print("MeasureChannel(0) defaults to a modulation frequency of {} GHz.".format(q0_meas_freq * GHz))
calibrations = defaults.instruction_schedule_map
print(calibrations)
measure_schedule = calibrations.get('measure', range(config.n_qubits))
measure_schedule.draw(backend=backend)
# You can use `has` to see if an operation is defined. Ex: Does qubit 3 have an x gate defined?
calibrations.has('x', 3)
# Some circuit operations take parameters. U1 takes a rotation angle:
calibrations.get('u1', 0, P0=3.1415)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/drithidavuluri/Implementation-of-Algorithm-using-Qiskit
|
drithidavuluri
|
# initialization
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, execute, Aer
from qiskit.tools.jupyter import *
provider = IBMQ.load_account()
# import basic plot tools
from qiskit.visualization import plot_histogram
def initialize(circuit, n, m):
circuit.h(range(n)) # Hadamard transform on measurment register
circuit.x(n+m-1) # X gate on last qubit
def c_amod15(a, x):
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13") # remember that a needs to be co-prime with N
unitary = QuantumCircuit(4)
for iteration in range(x):
# bitwise arithmetic to represent modular exponentiation function
if a in [2,13]:
unitary.swap(0,1)
unitary.swap(1,2)
unitary.swap(2,3)
if a in [7,8]:
unitary.swap(2,3)
unitary.swap(1,2)
unitary.swap(0,1)
if a == 11:
unitary.swap(1,3)
unitary.swap(0,2)
if a in [7,11,13]:
for q in range(4):
unitary.x(q)
unitary = unitary.to_gate()
unitary.name = "%i^%i mod 15" % (a, x)
# But we need to make it a controlled operation for phase kickback
c_unitary = unitary.control()
return c_unitary
def modular_exponentiation(circuit, n, m, a):
for exp in range(n):
exponent = 2**exp
circuit.append(a_x_mod15(a, exponent), [exp] + list(range(n, n+m)))
from qiskit.circuit.library import QFT
def apply_iqft(circuit, measurement_qubits):
circuit.append(QFT( len(measurement_qubits), do_swaps=False).inverse(), measurement_qubits)
def shor_algo(n, m, a):
# set up the circuit
circ = QuantumCircuit(n+m, n)
# initialize the registers
initialize(circ, n, m)
circ.barrier()
# map modular exponentiation problem onto qubits
modular_exponentiation(circ, n, m, a)
circ.barrier()
# apply inverse QFT -- expose period
apply_iqft(circ, range(n))
# measure the measurement register
circ.measure(range(n), range(n))
return circ
n = 4; m = 4; a = 11
mycircuit = shor_algo(n, m, a)
mycircuit.draw('mpl')
simulator = Aer.get_backend('qasm_simulator')
counts = execute(mycircuit, backend=simulator, shots=1024).result().get_counts(mycircuit)
plot_histogram(counts)
for measured_value in counts:
print(f"Measured {int(measured_value[::-1], 2)}")
from math import gcd
from math import sqrt
from itertools import count, islice
for measured_value in counts:
measured_value_decimal = int(measured_value[::-1], 2)
print(f"Measured {measured_value_decimal}")
if measured_value_decimal % 2 != 0:
print("Failed. Measured value is not an even number")
continue
x = int((a ** (measured_value_decimal/2)) % 15)
if (x + 1) % 15 == 0:
print("Failed. x + 1 = 0 (mod N) where x = a^(r/2) (mod N)")
continue
guesses = gcd(x + 1, 15), gcd(x - 1, 15)
print(guesses)
def is_prime(n):
return n > 1 and all(n % i for i in islice(count(2), int(sqrt(n)-1)))
if is_prime(guesses[0]) and is_prime(guesses[1]):
print(f"**The prime factors are {guesses[0]} and {guesses[1]}**")
|
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/shantomborah/Quantum-Algorithms
|
shantomborah
|
import numpy as np
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, Aer, execute
from qiskit.circuit import ParameterVector
from qiskit.extensions import HamiltonianGate
from qiskit.visualization import plot_histogram
from qiskit.aqua.components.optimizers import COBYLA
class QAOA:
def __init__(self, clauses, p, num_shots=1024):
# Assign weights and clauses
if isinstance(clauses, dict):
self.clauses = list(clauses.values())
self.weights = list(clauses.keys())
else:
self.clauses = clauses
self.weights = [1] * len(clauses)
# Assign size parameters
self.m = len(self.clauses)
self.n = len(self.clauses[0])
self.p = p
# Assign auxiliary parameters
self.num_shots = num_shots
self.error = -1
# Create variational parameters
self.gamma = ParameterVector('gamma', length=p)
self.beta = ParameterVector('beta', length=p)
self.gamma_val = list(np.random.rand(p))
self.beta_val = list(np.random.rand(p))
# Create hamiltonians and variational circuit
self.C = np.diag([self.cost(z) for z in range(2 ** self.n)])
self.varckt = self.build_varckt()
self.optimize()
def cost(self, z):
# Convert to bitstr
if not isinstance(z, str):
z = format(z, '0' + str(self.n) + 'b')
z: str
# Evaluate C(z)
cost = 0
for i in range(self.m):
s = True
for j in range(self.n):
if self.clauses[i][j] != 'X' and self.clauses[i][j] != z[j]:
s = False
break
if s:
cost += self.weights[i]
# Return output
return cost
def expectation(self, beta=None, gamma=None):
# Resolve default values
if beta is None:
beta = self.beta_val
if gamma is None:
gamma = self.gamma_val
# Evaluate expectation value
circ = self.varckt.bind_parameters({self.beta: beta, self.gamma: gamma})
simulator = Aer.get_backend('qasm_simulator')
result = execute(circ, simulator, shots=self.num_shots).result()
counts = result.get_counts()
expval = sum([self.cost(z) * counts[z] / self.num_shots for z in counts.keys()])
return expval
def optimize(self):
# Define objective function
def objfunc(params):
return -self.expectation(beta=params[0:self.p], gamma=params[self.p:2*self.p])
# Optimize parameters
optimizer = COBYLA(maxiter=1000, tol=0.0001)
params = self.beta_val + self.gamma_val
ret = optimizer.optimize(num_vars=2*self.p, objective_function=objfunc, initial_point=params)
self.beta_val = ret[0][0:self.p]
self.gamma_val = ret[0][self.p:2*self.p]
self.error = ret[1]
return
def build_varckt(self):
# Build variational circuit
circ = QuantumCircuit(self.n)
circ.h(range(self.n))
for i in range(self.p):
eC = QuantumCircuit(self.n, name='$U(C,\\gamma_' + str(i + 1) + ')$')
eC.append(HamiltonianGate(self.C, self.gamma[i]), range(self.n))
eB = QuantumCircuit(self.n, name='$U(B,\\beta_' + str(i + 1) + ')$')
eB.rx(2*self.beta[i], range(self.n))
circ.append(eC.to_gate(), range(self.n))
circ.append(eB.to_gate(), range(self.n))
circ.measure_all()
return circ
def sample(self, shots=None, vis=False):
# Resolve defaults
if shots is None:
shots = self.num_shots
# Sample maximum cost value
circ = self.varckt.bind_parameters({self.beta: self.beta_val, self.gamma: self.gamma_val})
simulator = Aer.get_backend('qasm_simulator')
result = execute(circ, simulator, shots=shots).result()
counts = result.get_counts()
if vis:
plot_histogram(counts, title='Sample Output', bar_labels=False)
plt.subplots_adjust(left=0.15, right=0.85, top=0.9, bottom=0.15)
return max(counts, key=counts.get)
if __name__ == '__main__':
qaoa = QAOA(['10XX0', '11XXX'], 3)
print('Maximized Expectation Value: ' + str(qaoa.expectation()))
print('Sampled Output: ' + qaoa.sample())
qaoa.varckt.draw('mpl').suptitle('Variational Circuit', fontsize=16)
plt.show()
|
https://github.com/Qiskit/feedback
|
Qiskit
|
from numpy import pi
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
with qc.if_test((cr[1], 1)):
qc.h(0)
qc.cx(0, 1)
qc.draw()
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
with qc.if_test((cr[1], 1)) as _else:
qc.h(0)
qc.cx(0, 1)
with _else:
qc.cx(0, 1)
qc.draw()
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
with qc.if_test((cr[1], 1)) as _else:
qc.h(0)
qc.cx(0, 1)
with qc.if_test((cr[0], 0)):
qc.x(0)
with _else:
qc.cx(0, 1)
qc.draw()
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(3, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(0)
with qc.if_test((cr[1], 1)) as _else:
qc.x(0, label="X c_if").c_if(cr, 4)
with qc.if_test((cr[2], 1)):
qc.z(0)
qc.y(1)
with qc.if_test((cr[1], 1)):
qc.y(1)
qc.z(2)
with qc.if_test((cr[2], 1)):
qc.cx(0, 1)
with qc.if_test((cr[1], 1)):
qc.h(0)
qc.x(1)
with _else:
qc.y(1)
with qc.if_test((cr[2], 1)):
qc.x(0)
qc.x(1)
qr1 = QuantumRegister(2, "qr1")
cr1 = ClassicalRegister(2, "cr1")
cr2 = ClassicalRegister(2, "cr2")
circuit = QuantumCircuit(qr1, cr1, cr2)
inst = QuantumCircuit(2, 2, name="Inst").to_instruction()
qc.append(inst, [qr[0], qr[1]], [cr[0], cr[1]])
qc.x(0)
qc.draw(fold=30, style={"name": "default", "showindex": True})#,wire_order=(2, 0, 3, 1, 4, 5, 6))
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(3, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(0)
with qc.if_test((cr[1], 1)) as _else:
qc.x(0, label="X c_if").c_if(cr, 4)
with qc.if_test((cr[2], 1)):
qc.z(0)
qc.y(1)
with qc.if_test((cr[1], 1)):
qc.y(1)
qc.z(2)
with qc.if_test((cr[2], 1)):
qc.cx(0, 1)
with qc.if_test((cr[1], 1)):
qc.h(0)
qc.x(1)
with _else:
qc.y(1)
with qc.if_test((cr[2], 1)):
qc.x(0)
qc.x(1)
qr1 = QuantumRegister(2, "qr1")
cr1 = ClassicalRegister(2, "cr1")
cr2 = ClassicalRegister(2, "cr2")
circuit = QuantumCircuit(qr1, cr1, cr2)
inst = QuantumCircuit(2, 2, name="Inst").to_instruction()
qc.append(inst, [qr[0], qr[1]], [cr[0], cr[1]])
qc.x(0)
qc.draw(fold=7, style={"name": "default", "showindex": True}, scale=0.8)
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(3, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(0)
with qc.if_test((cr[1], 1)) as _else:
qc.x(0, label="X c_if").c_if(cr, 4)
with qc.if_test((cr[2], 1)):
qc.z(0)
qc.y(1)
with qc.if_test((cr[1], 1)):
qc.y(1)
qc.z(2)
with qc.if_test((cr[2], 1)):
qc.cx(0, 1)
with qc.if_test((cr[1], 1)):
qc.h(0)
qc.x(1)
with _else:
qc.y(1)
with qc.if_test((cr[2], 1)):
qc.x(0)
qc.x(1)
qr1 = QuantumRegister(2, "qr1")
cr1 = ClassicalRegister(2, "cr1")
cr2 = ClassicalRegister(2, "cr2")
circuit = QuantumCircuit(qr1, cr1, cr2)
inst = QuantumCircuit(2, 2, name="Inst").to_instruction()
qc.append(inst, [qr[0], qr[1]], [cr[0], cr[1]])
qc.x(0)
qc.draw(fold=30, style={"name": "textbook", "showindex": True})
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(3, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.measure(0, 2)
with qc.while_loop((cr[0], 0)):
qc.h(0)
qc.cx(0, 1)
qc.measure(0, 0)
with qc.if_test((cr[2], 1)):
qc.x(0)
qc.draw(style={"showindex": True})
qr = QuantumRegister(4, "q")
cr = ClassicalRegister(3, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.measure(0, 2)
with qc.for_loop((2, 4, 8, 16)) as i:
qc.h(0)
qc.cx(0, 1)
qc.rx(pi/i, 1)
qc.measure(0, 0)
with qc.if_test((cr[2], 1)):
qc.z(0)
qc.draw(style={"showindex": True})
from qiskit.circuit import QuantumCircuit, ClassicalRegister, QuantumRegister
qreg = QuantumRegister(3)
creg = ClassicalRegister(3)
qc = QuantumCircuit(qreg, creg)
qc.h([0, 1, 2])
qc.measure([0, 1, 2], [0, 1, 2])
with qc.switch(creg) as case:
with case(0, 1, 2):
qc.x(0)
with case(3, 4, 5):
qc.y(1)
qc.y(0)
qc.y(0)
with case(case.DEFAULT):
qc.cx(0, 1)
qc.h(0)
qc.draw(style={"showindex": True})
|
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_state_city
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
# plot using a Statevector
state = Statevector(qc)
plot_state_city(state)
|
https://github.com/IvanIsCoding/Quantum
|
IvanIsCoding
|
# initialization
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# importing Qiskit
from qiskit import IBMQ, BasicAer
from qiskit.providers.ibmq import least_busy
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister, execute
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
nQubits = 2 # number of physical qubits used to represent s
s = 3 # the hidden integer
# make sure that a can be represented with nqubits
s = s % 2**(nQubits)
# Creating registers
# qubits for querying the oracle and finding the hidden integer
qr = QuantumRegister(nQubits)
# bits for recording the measurement on qr
cr = ClassicalRegister(nQubits)
bvCircuit = QuantumCircuit(qr, cr)
barriers = True
# Apply Hadamard gates before querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
# Apply the inner-product oracle
for i in range(nQubits):
if (s & (1 << i)):
bvCircuit.z(qr[i])
else:
bvCircuit.iden(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
#Apply Hadamard gates after querying the oracle
for i in range(nQubits):
bvCircuit.h(qr[i])
# Apply barrier
if barriers:
bvCircuit.barrier()
# Measurement
bvCircuit.measure(qr, cr)
bvCircuit.draw(output='mpl')
# use local simulator
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
results = execute(bvCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
# Load our saved IBMQ accounts and get the least busy backend device with less than or equal to 5 qubits
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
backend = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits <= 5 and
not x.configuration().simulator and x.status().operational==True))
print("least busy backend: ", backend)
# Run our circuit on the least busy backend. Monitor the execution of the job in the queue
from qiskit.tools.monitor import job_monitor
shots = 1024
job = execute(bvCircuit, backend=backend, shots=shots)
job_monitor(job, interval = 2)
# Get the results from the computation
results = job.result()
answer = results.get_counts()
plot_histogram(answer)
import qiskit
qiskit.__qiskit_version__
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
from tsp_qaoa import test_solution
from qiskit.visualization import plot_histogram
import networkx as nx
import numpy as np
import json
import csv
# Array of JSON Objects
header = ['instance', 'iteration', 'distance']
length_instances = 40
with open('qaoa_multiple_distance.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
# write the header
writer.writerow(header)
for instance in range(length_instances):
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution()
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["mean"])
index = -1
for sample in UNIFORM_CONVERGENCE_SAMPLE:
mean = sample["mean"]
index += 1
distance_p_ground_state = np.max(np.abs(UNIFORM_CONVERGENCE_SAMPLE[0]["probabilities"] - sample["probabilities"]))
UNIFORM_CONVERGENCE_SAMPLE[index]["distance_pgs"] = distance_p_ground_state
iteration = 0
for sample in UNIFORM_CONVERGENCE_SAMPLE:
iteration += 1
mean = sample["mean"]
distance = sample["distance_pgs"]
writer.writerow([instance,iteration, distance])
|
https://github.com/IceKhan13/purplecaffeine
|
IceKhan13
|
"""Tests for Storage."""
import os
import shutil
from pathlib import Path
from unittest import TestCase
from qiskit import QuantumCircuit
from testcontainers.compose import DockerCompose
from testcontainers.localstack import LocalStackContainer
from purplecaffeine.core import Trial, LocalStorage, S3Storage, ApiStorage
from purplecaffeine.exception import PurpleCaffeineException
from .test_trial import dummy_trial
class TestStorage(TestCase):
"""TestStorage."""
def setUp(self) -> None:
"""SetUp Storage object."""
self.current_directory = os.path.dirname(os.path.abspath(__file__))
self.save_path = os.path.join(self.current_directory, "test_storage")
if not os.path.exists(self.save_path):
Path(self.save_path).mkdir(parents=True, exist_ok=True)
self.local_storage = LocalStorage(path=self.save_path)
self.my_trial = dummy_trial(name="keep_trial", storage=self.local_storage)
def test_save_get_list_local_storage(self):
"""Test save trial locally."""
# Save
self.local_storage.save(trial=self.my_trial)
self.assertTrue(
os.path.isfile(
os.path.join(self.save_path, f"trial_{self.my_trial.uuid}/trial.json")
)
)
# Get
recovered = self.local_storage.get(trial_id=self.my_trial.uuid)
self.assertTrue(isinstance(recovered, Trial))
self.assertEqual(recovered.parameters, [["test_parameter", "parameter"]])
self.assertEqual(recovered.circuits, [["test_circuit", QuantumCircuit(2)]])
self.assertEqual(recovered.texts, [["test_text", "text"]])
with self.assertRaises(ValueError):
self.local_storage.get(trial_id="999")
# List
list_trials = self.local_storage.list(query="keep_trial")
self.assertTrue(isinstance(list_trials, list))
self.assertTrue(isinstance(list_trials[0], Trial))
list_trials = self.local_storage.list(query="trial999")
self.assertTrue(isinstance(list_trials, list))
self.assertEqual(len(list_trials), 0)
def test_save_get_api_storage(self):
"""Test save trial in API."""
with DockerCompose(
filepath=os.path.join(self.current_directory, "../.."),
compose_file_name="docker-compose.yml",
build=True,
) as compose:
host = compose.get_service_host("api_server", 8000)
port = compose.get_service_port("api_server", 8000)
compose.wait_for(f"http://{host}:{port}/health_check/")
storage = ApiStorage(
host=f"http://{host}:{port}", username="admin", password="admin"
)
# Save
storage.save(trial=self.my_trial)
# Get
recovered = storage.get(trial_id="1")
self.assertTrue(isinstance(recovered, Trial))
self.assertEqual(recovered.parameters, [["test_parameter", "parameter"]])
with self.assertRaises(ValueError):
storage.get(trial_id="999")
def test_save_get_list_s3_storage(self) -> None:
"""Test of S3Storage object."""
with LocalStackContainer(image="localstack/localstack:2.0.1") as localstack:
localstack.with_services("s3")
s3_storage = S3Storage(
"bucket",
access_key="",
secret_access_key="",
endpoint_url=localstack.get_url(),
)
s3_storage.client_s3.create_bucket(Bucket=s3_storage.bucket_name)
# save
uuid = s3_storage.save(trial=self.my_trial)
# get
recovered = s3_storage.get(trial_id=uuid)
self.assertTrue(isinstance(recovered, Trial))
with self.assertRaises(PurpleCaffeineException):
s3_storage.get(trial_id="999")
# list
list_trials = s3_storage.list()
self.assertTrue(isinstance(list_trials, list))
for trial in list_trials:
self.assertTrue(isinstance(trial, Trial))
def tearDown(self) -> None:
"""TearDown Storage object."""
file_to_remove = os.path.join(self.save_path)
if os.path.exists(file_to_remove):
shutil.rmtree(file_to_remove)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# useful additional packages
import matplotlib.pyplot as plt
import numpy as np
import networkx as nx
from qiskit_aer import Aer
from qiskit.tools.visualization import plot_histogram
from qiskit.circuit.library import TwoLocal
from qiskit_optimization.applications import Maxcut, Tsp
from qiskit.algorithms.minimum_eigensolvers import SamplingVQE, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import SPSA
from qiskit.utils import algorithm_globals
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import MinimumEigenOptimizer
# Generating a graph of 4 nodes
n = 4 # Number of nodes in graph
G = nx.Graph()
G.add_nodes_from(np.arange(0, n, 1))
elist = [(0, 1, 1.0), (0, 2, 1.0), (0, 3, 1.0), (1, 2, 1.0), (2, 3, 1.0)]
# tuple is (i,j,weight) where (i,j) is the edge
G.add_weighted_edges_from(elist)
colors = ["r" for node in G.nodes()]
pos = nx.spring_layout(G)
def draw_graph(G, colors, pos):
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=0.8, ax=default_axes, pos=pos)
edge_labels = nx.get_edge_attributes(G, "weight")
nx.draw_networkx_edge_labels(G, pos=pos, edge_labels=edge_labels)
draw_graph(G, colors, pos)
# Computing the weight matrix from the random graph
w = np.zeros([n, n])
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i, j, default=0)
if temp != 0:
w[i, j] = temp["weight"]
print(w)
best_cost_brute = 0
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]
cost = 0
for i in range(n):
for j in range(n):
cost = cost + w[i, j] * x[i] * (1 - x[j])
if best_cost_brute < cost:
best_cost_brute = cost
xbest_brute = x
print("case = " + str(x) + " cost = " + str(cost))
colors = ["r" if xbest_brute[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
print("\nBest solution = " + str(xbest_brute) + " cost = " + str(best_cost_brute))
max_cut = Maxcut(w)
qp = max_cut.to_quadratic_program()
print(qp.prettyprint())
qubitOp, offset = qp.to_ising()
print("Offset:", offset)
print("Ising Hamiltonian:")
print(str(qubitOp))
# solving Quadratic Program using exact classical eigensolver
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver())
result = exact.solve(qp)
print(result.prettyprint())
# Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = NumPyMinimumEigensolver()
result = ee.compute_minimum_eigenvalue(qubitOp)
x = max_cut.sample_most_likely(result.eigenstate)
print("energy:", result.eigenvalue.real)
print("max-cut objective:", result.eigenvalue.real + offset)
print("solution:", x)
print("solution objective:", qp.objective.evaluate(x))
colors = ["r" if x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
algorithm_globals.random_seed = 123
seed = 10598
# construct SamplingVQE
optimizer = SPSA(maxiter=300)
ry = TwoLocal(qubitOp.num_qubits, "ry", "cz", reps=5, entanglement="linear")
vqe = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=optimizer)
# run SamplingVQE
result = vqe.compute_minimum_eigenvalue(qubitOp)
# print results
x = max_cut.sample_most_likely(result.eigenstate)
print("energy:", result.eigenvalue.real)
print("time:", result.optimizer_time)
print("max-cut objective:", result.eigenvalue.real + offset)
print("solution:", x)
print("solution objective:", qp.objective.evaluate(x))
# plot results
colors = ["r" if x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
# create minimum eigen optimizer based on SamplingVQE
vqe_optimizer = MinimumEigenOptimizer(vqe)
# solve quadratic program
result = vqe_optimizer.solve(qp)
print(result.prettyprint())
colors = ["r" if result.x[i] == 0 else "c" for i in range(n)]
draw_graph(G, colors, pos)
# Generating a graph of 3 nodes
n = 3
num_qubits = n**2
tsp = Tsp.create_random_instance(n, seed=123)
adj_matrix = nx.to_numpy_array(tsp.graph)
print("distance\n", adj_matrix)
colors = ["r" for node in tsp.graph.nodes]
pos = [tsp.graph.nodes[node]["pos"] for node in tsp.graph.nodes]
draw_graph(tsp.graph, colors, pos)
from itertools import permutations
def brute_force_tsp(w, N):
a = list(permutations(range(1, N)))
last_best_distance = 1e10
for i in a:
distance = 0
pre_j = 0
for j in i:
distance = distance + w[j, pre_j]
pre_j = j
distance = distance + w[pre_j, 0]
order = (0,) + i
if distance < last_best_distance:
best_order = order
last_best_distance = distance
print("order = " + str(order) + " Distance = " + str(distance))
return last_best_distance, best_order
best_distance, best_order = brute_force_tsp(adj_matrix, n)
print(
"Best order from brute force = "
+ str(best_order)
+ " with total distance = "
+ str(best_distance)
)
def draw_tsp_solution(G, order, colors, pos):
G2 = nx.DiGraph()
G2.add_nodes_from(G)
n = len(order)
for i in range(n):
j = (i + 1) % n
G2.add_edge(order[i], order[j], weight=G[order[i]][order[j]]["weight"])
default_axes = plt.axes(frameon=True)
nx.draw_networkx(
G2, node_color=colors, edge_color="b", node_size=600, alpha=0.8, ax=default_axes, pos=pos
)
edge_labels = nx.get_edge_attributes(G2, "weight")
nx.draw_networkx_edge_labels(G2, pos, font_color="b", edge_labels=edge_labels)
draw_tsp_solution(tsp.graph, best_order, colors, pos)
qp = tsp.to_quadratic_program()
print(qp.prettyprint())
from qiskit_optimization.converters import QuadraticProgramToQubo
qp2qubo = QuadraticProgramToQubo()
qubo = qp2qubo.convert(qp)
qubitOp, offset = qubo.to_ising()
print("Offset:", offset)
print("Ising Hamiltonian:")
print(str(qubitOp))
result = exact.solve(qubo)
print(result.prettyprint())
# Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = NumPyMinimumEigensolver()
result = ee.compute_minimum_eigenvalue(qubitOp)
print("energy:", result.eigenvalue.real)
print("tsp objective:", result.eigenvalue.real + offset)
x = tsp.sample_most_likely(result.eigenstate)
print("feasible:", qubo.is_feasible(x))
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
algorithm_globals.random_seed = 123
seed = 10598
optimizer = SPSA(maxiter=300)
ry = TwoLocal(qubitOp.num_qubits, "ry", "cz", reps=5, entanglement="linear")
vqe = SamplingVQE(sampler=Sampler(), ansatz=ry, optimizer=optimizer)
result = vqe.compute_minimum_eigenvalue(qubitOp)
print("energy:", result.eigenvalue.real)
print("time:", result.optimizer_time)
x = tsp.sample_most_likely(result.eigenstate)
print("feasible:", qubo.is_feasible(x))
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
algorithm_globals.random_seed = 123
seed = 10598
# create minimum eigen optimizer based on SamplingVQE
vqe_optimizer = MinimumEigenOptimizer(vqe)
# solve quadratic program
result = vqe_optimizer.solve(qp)
print(result.prettyprint())
z = tsp.interpret(x)
print("solution:", z)
print("solution objective:", tsp.tsp_value(z, adj_matrix))
draw_tsp_solution(tsp.graph, z, colors, pos)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/pbark/qiskit_tutorials
|
pbark
|
print("Hello! I'm a code cell")
print('Set up started...')
%matplotlib notebook
import sys
sys.path.append('game_engines')
import hello_quantum
print('Set up complete!')
initialize = []
success_condition = {}
allowed_gates = {'0': {'NOT': 3}, '1': {}, 'both': {}}
vi = [[1], False, False]
qubit_names = {'0':'the only bit', '1':None}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = []
success_condition = {}
allowed_gates = {'0': {}, '1': {'NOT': 0}, 'both': {}}
vi = [[], False, False]
qubit_names = {'0':'the bit on the left', '1':'the bit on the right'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '0']]
success_condition = {'IZ': -1.0}
allowed_gates = {'0': {'CNOT': 0}, '1': {'CNOT': 0}, 'both': {}}
vi = [[], False, False]
qubit_names = {'0':'the bit on the left', '1':'the bit on the right'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '0']]
success_condition = {'ZI': 1.0, 'IZ': -1.0}
allowed_gates = {'0': {'CNOT': 0}, '1': {'CNOT': 0}, 'both': {}}
vi = [[], False, False]
qubit_names = {'0':'the bit on the left', '1':'the bit on the right'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '0']]
success_condition = {'IZ': 0.0}
allowed_gates = {'0': {'CNOT': 0}, '1': {'CNOT': 0}, 'both': {}}
vi = [[], False, False]
qubit_names = {'0':'the bit on the left', '1':'the bit on the right'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '0']]
success_condition = {'ZZ': -1.0}
allowed_gates = {'0': {'NOT': 0, 'CNOT': 0}, '1': {'NOT': 0, 'CNOT': 0}, 'both': {}}
vi = [[], False, True]
qubit_names = {'0':'the bit on the left', '1':'the bit on the right'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '1']]
success_condition = {'IZ': -1.0}
allowed_gates = {'0': {'NOT': 0, 'CNOT': 0}, '1': {'NOT': 0, 'CNOT': 0}, 'both': {}}
vi = [[], False, True]
qubit_names = {'0':'the bit on the left', '1':'the bit on the right'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [ ["x","0"] ]
success_condition = {"ZI":1.0}
allowed_gates = { "0":{"x":3}, "1":{}, "both":{} }
vi = [[1],True,True]
qubit_names = {'0':'the only qubit', '1':None}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '0']]
success_condition = {'ZI': 1.0}
allowed_gates = {'0': {'x': 0}, '1': {}, 'both': {}}
vi = [[1], True, True]
qubit_names = {'0':'the only qubit', '1':None}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '1']]
success_condition = {'IZ': 1.0}
allowed_gates = {'0': {}, '1': {'x': 0}, 'both': {}}
vi = [[0], True, True]
qubit_names = {'0':None, '1':'the other qubit'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = []
success_condition = {'ZI': 0.0}
allowed_gates = {'0': {'h': 3}, '1': {}, 'both': {}}
vi = [[1], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '1']]
success_condition = {'IZ': 1.0}
allowed_gates = {'0': {}, '1': {'x': 3, 'h': 0}, 'both': {}}
vi = [[0], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '0'], ['z', '0']]
success_condition = {'XI': 1.0}
allowed_gates = {'0': {'z': 0, 'h': 0}, '1': {}, 'both': {}}
vi = [[1], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = []
success_condition = {'ZI': -1.0}
allowed_gates = {'0': {'z': 0, 'h': 0}, '1': {}, 'both': {}}
vi = [[1], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '0']]
success_condition = {'IX': 1.0}
allowed_gates = {'0': {}, '1': {'z': 0, 'h': 0}, 'both': {}}
vi = [[0], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['ry(pi/4)', '1']]
success_condition = {'IZ': -0.7071, 'IX': -0.7071}
allowed_gates = {'0': {}, '1': {'z': 0, 'h': 0}, 'both': {}}
vi = [[0], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '1']]
success_condition = {'ZI': 0.0, 'IZ': 0.0}
allowed_gates = {'0': {'x': 0, 'z': 0, 'h': 0}, '1': {'x': 0, 'z': 0, 'h': 0}, 'both': {}}
vi = [[], True, False]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h','0'],['h','1']]
success_condition = {'ZZ': -1.0}
allowed_gates = {'0': {'x': 0, 'z': 0, 'h': 0}, '1': {'x': 0, 'z': 0, 'h': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x','0']]
success_condition = {'XX': 1.0}
allowed_gates = {'0': {'x': 0, 'z': 0, 'h': 0}, '1': {'x': 0, 'z': 0, 'h': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = []
success_condition = {'XZ': -1.0}
allowed_gates = {'0': {'x': 0, 'z': 0, 'h': 0}, '1': {'x': 0, 'z': 0, 'h': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['ry(-pi/4)', '1'], ['ry(-pi/4)','0']]
success_condition = {'ZI': -0.7071, 'IZ': -0.7071}
allowed_gates = {'0': {'x': 0}, '1': {'x': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '1'], ['x','0']]
success_condition = {'XI':1, 'IX':1}
allowed_gates = {'0': {'z': 0, 'h': 0}, '1': {'z': 0, 'h': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '0']]
success_condition = {'ZI': 1.0, 'IZ': -1.0}
allowed_gates = {'0': {'cx': 0}, '1': {'cx': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '0'],['x', '1']]
success_condition = {'XI': -1.0, 'IZ': 1.0}
allowed_gates = {'0': {'h': 0, 'cz': 0}, '1': {'cx': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '0'],['x', '1'],['h', '1']]
success_condition = { }
allowed_gates = {'0':{'cz': 2}, '1':{'cz': 2}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x', '0']]
success_condition = {'IZ': -1.0}
allowed_gates = {'0': {'h':0}, '1': {'h':0}, 'both': {'cz': 0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['h', '0'],['h', '1']]
success_condition = {'XI': -1.0, 'IX': -1.0}
allowed_gates = {'0': {}, '1': {'z':0,'cx': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = []
success_condition = {'IZ': -1.0}
allowed_gates = {'0': {'x':0,'h':0,'cx':0}, '1': {'h':0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['ry(-pi/4)','0'],['ry(-pi/4)','0'],['ry(-pi/4)','0'],['x','0'],['x','1']]
success_condition = {'ZI': -1.0,'XI':0,'IZ':0.7071,'IX':-0.7071}
allowed_gates = {'0': {'h':0}, '1': {'h':0}, 'both': {'cz': 0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x','0'],['h','1']]
success_condition = {'IX':1,'ZI':-1}
allowed_gates = {'0': {'h':0}, '1': {'h':0}, 'both': {'cz':3}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names,shots=2000)
initialize = [['x','1']]
success_condition = {'IZ':1.0,'ZI':-1.0}
allowed_gates = {'0': {'h':0}, '1': {'h':0}, 'both': {'cz':0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names,shots=2000)
initialize = []
success_condition = {}
allowed_gates = {'0': {'ry(pi/4)': 4}, '1': {}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names)
initialize = [['x','0']]
success_condition = {'XX': 1.0}
allowed_gates = {'0': {'x': 0, 'z': 0, 'h': 0}, '1': {'x': 0, 'z': 0, 'h': 0}, 'both': {}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
initialize = []
success_condition = {'ZI': -1.0}
allowed_gates = {'0': {'bloch':1, 'ry(pi/4)': 0}, '1':{}, 'both': {'unbloch':0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
initialize = [['h','0'],['h','1']]
success_condition = {'ZI': -1.0,'IZ': -1.0}
allowed_gates = {'0': {'bloch':0, 'ry(pi/4)': 0, 'ry(-pi/4)': 0}, '1': {'bloch':0, 'ry(pi/4)': 0, 'ry(-pi/4)': 0}, 'both': {'unbloch':0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
initialize = [['h','0']]
success_condition = {'ZZ': 1.0}
allowed_gates = {'0': {}, '1': {'bloch':0, 'ry(pi/4)': 0, 'ry(-pi/4)': 0}, 'both': {'unbloch':0,'cz':0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
initialize = [['ry(pi/4)','0'],['ry(pi/4)','1']]
success_condition = {'ZI': 1.0,'IZ': 1.0}
allowed_gates = {'0': {'bloch':0, 'z':0, 'ry(pi/4)': 1}, '1': {'bloch':0, 'x':0, 'ry(pi/4)': 1}, 'both': {'unbloch':0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
initialize = [['x','0'],['h','1']]
success_condition = {'IZ': 1.0}
allowed_gates = {'0': {}, '1': {'bloch':0, 'cx':0, 'ry(pi/4)': 1, 'ry(-pi/4)': 1}, 'both': {'unbloch':0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
initialize = []
success_condition = {'IZ': 1.0,'IX': 1.0}
allowed_gates = {'0': {'bloch':0, 'x':0, 'z':0, 'h':0, 'cx':0, 'ry(pi/4)': 0, 'ry(-pi/4)': 0}, '1': {'bloch':0, 'x':0, 'z':0, 'h':0, 'cx':0, 'ry(pi/4)': 0, 'ry(-pi/4)': 0}, 'both': {'cz':0, 'unbloch':0}}
vi = [[], True, True]
qubit_names = {'0':'qubit 0', '1':'qubit 1'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
import random
def setup_variables ():
### Replace this section with anything you want ###
r = random.random()
A = r*(2/3)
B = r*(1/3)
### End of section ###
return A, B
def hash2bit ( variable, hash ):
### Replace this section with anything you want ###
if hash=='V':
bit = (variable<0.5)
elif hash=='H':
bit = (variable<0.25)
bit = str(int(bit))
### End of section ###
return bit
shots = 8192
def calculate_P ( ):
P = {}
for hashes in ['VV','VH','HV','HH']:
# calculate each P[hashes] by sampling over `shots` samples
P[hashes] = 0
for shot in range(shots):
A, B = setup_variables()
a = hash2bit ( A, hashes[0] ) # hash type for variable `A` is the first character of `hashes`
b = hash2bit ( B, hashes[1] ) # hash type for variable `B` is the second character of `hashes`
P[hashes] += (a!=b) / shots
return P
P = calculate_P()
print(P)
def bell_test (P):
sum_P = sum(P.values())
for hashes in P:
bound = sum_P - P[hashes]
print("The upper bound for P['"+hashes+"'] is "+str(bound))
print("The value of P['"+hashes+"'] is "+str(P[hashes]))
if P[hashes]<=bound:
print("The upper bound is obeyed :)\n")
else:
if P[hashes]-bound < 0.1:
print("This seems to have gone over the upper bound, but only by a little bit :S\nProbably just rounding errors or statistical noise.\n")
else:
print("!!!!! This has gone well over the upper bound :O !!!!!\n")
bell_test(P)
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
def initialize_program ():
qubit = QuantumRegister(2)
A = qubit[0]
B = qubit[1]
bit = ClassicalRegister(2)
a = bit[0]
b = bit[1]
qc = QuantumCircuit(qubit, bit)
return A, B, a, b, qc
def hash2bit ( variable, hash, bit, qc ):
if hash=='H':
qc.h( variable )
qc.measure( variable, bit )
initialize = []
success_condition = {'ZZ':-0.7071,'ZX':-0.7071,'XZ':-0.7071,'XX':-0.7071}
allowed_gates = {'0': {'bloch':0, 'x':0, 'z':0, 'h':0, 'cx':0, 'ry(pi/4)': 0, 'ry(-pi/4)': 0}, '1': {'bloch':0, 'x':0, 'z':0, 'h':0, 'cx':0, 'ry(pi/4)': 0, 'ry(-pi/4)': 0}, 'both': {'cz':0, 'unbloch':0}}
vi = [[], True, True]
qubit_names = {'0':'A', '1':'B'}
puzzle = hello_quantum.run_game(initialize, success_condition, allowed_gates, vi, qubit_names, mode='line')
import numpy as np
def setup_variables ( A, B, qc ):
for line in puzzle.program:
eval(line)
shots = 8192
from qiskit import execute
def calculate_P ( backend ):
P = {}
program = {}
for hashes in ['VV','VH','HV','HH']:
A, B, a, b, program[hashes] = initialize_program ()
setup_variables( A, B, program[hashes] )
hash2bit ( A, hashes[0], a, program[hashes])
hash2bit ( B, hashes[1], b, program[hashes])
# submit jobs
job = execute( list(program.values()), backend, shots=shots )
# get the results
for hashes in ['VV','VH','HV','HH']:
stats = job.result().get_counts(program[hashes])
P[hashes] = 0
for string in stats.keys():
a = string[-1]
b = string[-2]
if a!=b:
P[hashes] += stats[string] / shots
return P
device = 'qasm_simulator'
from qiskit import Aer, IBMQ
try:
IBMQ.load_accounts()
except:
pass
try:
backend = Aer.get_backend(device)
except:
backend = IBMQ.get_backend(device)
print(backend.status())
P = calculate_P( backend )
print(P)
bell_test( P )
|
https://github.com/stefan-woerner/qiskit_tutorial
|
stefan-woerner
|
from svm.datasets import *
from qiskit.aqua.input import ClassificationInput
from qiskit.aqua import run_algorithm
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import Aer, execute
from qiskit.aqua.components.optimizers.cobyla import COBYLA
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
# size of training data set
training_size = 20
# size of test data set
test_size = 10
# dimension of data sets
n = 2
# construct training and test data
# set the following flag to True for the first data set and to False for the second dataset
use_adhoc_dataset = True
if use_adhoc_dataset:
# first (artifical) data set to test the classifier
training_input, test_input, class_labels = \
ad_hoc_data(training_size=training_size, test_size=test_size, n=n, gap=0.3, plot_data=True)
else:
# second data set to test the classifier
training_input, test_input, class_labels = \
Wine(training_size=training_size, test_size=test_size, n=n, plot_data=True)
def feature_map(x, q):
# initialize quantum circuit
qc = QuantumCircuit(q)
# apply hadamards and U_Phi twice
for _ in range(2):
# apply the hadamard and Z-rotatiion to all qubits
for i in range(x.shape[0]):
qc.h(q[i])
qc.rz(2 * x[i], q[i])
# apply the two qubit gate
qc.cx(q[0], q[1])
qc.rz(2*(np.pi-x[0])*(np.pi-x[1]), q[1])
qc.cx(q[0], q[1])
# return quantum circuit
return qc
# initialize quantum register
num_qubits = 2
qr = QuantumRegister(num_qubits)
# initialize test data (x1, x2)
data = np.asarray([1.5, 0.3])
# get quantum circuit
qc_feature_map = feature_map(data, qr)
# simulate using local statevector simulator
backend = Aer.get_backend('statevector_simulator')
job_sim = execute(qc_feature_map, backend)
sim_results = job_sim.result()
print('simulation: ', sim_results)
print('statevector: ', np.round(sim_results.get_statevector(), decimals=4))
# draw circuit
qc_feature_map.draw(output='mpl', plot_barriers=False)
def variational_form(q, params, depth):
# initialize quantum circuit
qc = QuantumCircuit(q)
# first set of rotations
param_idx = 0
for qubit in range(2):
qc.ry(params[param_idx], q[qubit])
qc.rz(params[param_idx+1], q[qubit])
param_idx += 2
# entangler blocks and succeeding rotations
for block in range(depth):
qc.cz(q[0], q[1])
for qubit in range(2):
qc.ry(params[param_idx], q[qubit])
qc.rz(params[param_idx+1], q[qubit])
param_idx += 2
# return quantum circuit
return qc
# initialize quantum register
num_qubits = 2
qr = QuantumRegister(num_qubits)
# set depth, i.e. number of entangler blocks and rotations (after the initial rotation)
depth = 2
params = [0.5,-0.3, 0.2, 0.6]*(depth+1)
qc_variational_form = variational_form(qr, params, depth)
# simulate using local statevector simulator
job_sim = execute(qc_variational_form, backend)
sim_results = job_sim.result()
print('simulation: ', sim_results)
print('statevector: ', np.round(sim_results.get_statevector(), decimals=4))
# draw circuit
qc_variational_form.draw(output='mpl', plot_barriers=False)
def assign_label(bit_string, class_labels):
hamming_weight = sum([int(k) for k in list(bit_string)])
is_odd_parity = hamming_weight & 1
if is_odd_parity:
return class_labels[1]
else:
return class_labels[0]
# assigns a label
assign_label('01', class_labels)
def return_probabilities(counts, class_labels):
shots = sum(counts.values())
result = {class_labels[0]: 0,
class_labels[1]: 0}
for key, item in counts.items():
label = assign_label(key, class_labels)
result[label] += counts[key]/shots
return result
return_probabilities({'00' : 10, '01': 10}, class_labels)
def classifier_circuit(x, params, depth):
q = QuantumRegister(2)
c = ClassicalRegister(2)
qc = QuantumCircuit(q, c)
qc_feature_map = feature_map(x, q)
qc_variational_form = variational_form(q, params, depth)
qc += qc_feature_map
qc += qc_variational_form
qc.measure(q, c)
return qc
def classify(x_list, params, class_labels, depth=2, shots=100):
qc_list = []
for x in x_list:
qc = classifier_circuit(x, params, depth)
qc_list += [qc]
qasm_backend = Aer.get_backend('qasm_simulator')
jobs = execute(qc_list, qasm_backend, shots=shots)
probs = []
for qc in qc_list:
counts = jobs.result().get_counts(qc)
prob = return_probabilities(counts, class_labels)
probs += [prob]
return probs
# draw classifier circuit
qc = classifier_circuit(np.asarray([0.5, 0.5]), params, depth)
# classify test data point (using random parameters constructed earlier)
x = np.asarray([[0.5, 0.5]])
classify(x, params, class_labels, depth)
qc.draw(output='mpl', plot_barriers=False)
def cost_estimate_sigmoid(probs, expected_label):
p = probs.get(expected_label)
sig = None
if np.isclose(p, 0.0):
sig = 1
elif np.isclose(p, 1.0):
sig = 0
else:
denominator = np.sqrt(2*p*(1-p))
x = np.sqrt(200)*(0.5-p)/denominator
sig = 1/(1+np.exp(-x))
return sig
x = np.linspace(0, 1, 20)
y = [cost_estimate_sigmoid({'A': x_, 'B': 1-x_}, 'A') for x_ in x]
plt.plot(x, y)
plt.xlabel('Probability of assigning the correct class')
plt.ylabel('Cost value')
plt.show()
def cost_function(training_input, class_labels, params, depth=2, shots=100, print_value=False):
# map training input to list of labels and list of samples
cost = 0
training_labels = []
training_samples = []
for label, samples in training_input.items():
for sample in samples:
training_labels += [label]
training_samples += [sample]
# classify all samples
probs = classify(training_samples, params, class_labels, depth)
# evaluate costs for all classified samples
for i, prob in enumerate(probs):
cost += cost_estimate_sigmoid(prob, training_labels[i])
cost /= len(training_samples)
# print resulting objective function
if print_value:
print('%.4f' % cost)
# return objective value
return cost
cost_function(training_input, class_labels, params, depth)
# set depth of variational form
depth = 2
# set number of shots to evaluate the classification circuit
shots = 100
# setup the optimizer
optimizer = COBYLA()
# define objective function for training
objective_function = lambda params: cost_function(training_input, class_labels, params, depth, shots, print_value=True)
# randomly initialize the parameters
init_params = 2*np.pi*np.random.rand(num_qubits*(depth+1)*2)
# train classifier
opt_params, value, _ = optimizer.optimize(len(init_params), objective_function, initial_point=init_params)
# print results
print()
print('opt_params:', opt_params)
print('opt_value: ', value)
# collect coordinates of test data
test_label_0_x = [x[0] for x in test_input[class_labels[0]]]
test_label_0_y = [x[1] for x in test_input[class_labels[0]]]
test_label_1_x = [x[0] for x in test_input[class_labels[1]]]
test_label_1_y = [x[1] for x in test_input[class_labels[1]]]
# initialize lists for misclassified datapoints
test_label_misclassified_x = []
test_label_misclassified_y = []
# evaluate test data
for label, samples in test_input.items():
# classify samples
results = classify(samples, opt_params, class_labels, depth, shots=shots)
# analyze results
for i, result in enumerate(results):
# assign label
assigned_label = class_labels[np.argmax([p for p in result.values()])]
print('----------------------------------------------------')
print('Data point: ', samples[i])
print('Label: ', label)
print('Assigned: ', assigned_label)
print('Probabilities: ', result)
if label != assigned_label:
print('Classification:', 'INCORRECT')
test_label_misclassified_x += [samples[i][0]]
test_label_misclassified_y += [samples[i][1]]
else:
print('Classification:', 'CORRECT')
# compute fraction of misclassified samples
total = len(test_label_0_x) + len(test_label_1_x)
num_misclassified = len(test_label_misclassified_x)
print()
print(100*(1-num_misclassified/total), "% of the test data was correctly classified!")
# plot results
plt.figure()
plt.scatter(test_label_0_x, test_label_0_y, c='b', label=class_labels[0], linewidths=5)
plt.scatter(test_label_1_x, test_label_1_y, c='g', label=class_labels[1], linewidths=5)
plt.scatter(test_label_misclassified_x, test_label_misclassified_y, linewidths=20, s=1, facecolors='none', edgecolors='r')
plt.legend()
plt.show()
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
from tsp_qaoa import test_solution
from qiskit.visualization import plot_histogram
import networkx as nx
import numpy as np
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution()
plot_histogram(job_2.result().get_counts(), color='midnightblue', title="New Histogram", figsize=(30, 5))
plot_histogram(job_2.result().get_counts(), color='midnightblue', title="New Histogram", figsize=(30, 5))
G
labels = nx.get_edge_attributes(G,'weight')
labels
import json
# Array of JSON Objects
products = [{"name": "HDD", "brand": "Samsung", "price": "$100"},
{"name": "Monitor", "brand": "Dell", "price": "$120"},
{"name": "Mouse", "brand": "Logitech", "price": "$10"}]
# Print the original data
print("The original JSON data:\n{0}".format(products))
# Sort the JSON data based on the value of the brand key
products.sort(key=lambda x: x["price"])
# Print the sorted JSON data
print("The sorted JSON data based on the value of the brand:\n{0}".format(products))
_LAMBDA
UNIFORM_CONVERGENCE_SAMPLE
import json
# Array of JSON Objects
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["mean"])
# Print the sorted JSON data
UNIFORM_CONVERGENCE_SAMPLE
np.max(UNIFORM_CONVERGENCE_SAMPLE[0]["probabilities"] - UNIFORM_CONVERGENCE_SAMPLE[220]["probabilities"])
# generamos las distancias entre para la convergencia uniforme
index = -1
for sample in UNIFORM_CONVERGENCE_SAMPLE:
mean = sample["mean"]
index += 1
distance_p_ground_state = np.max(np.abs(UNIFORM_CONVERGENCE_SAMPLE[0]["probabilities"] - sample["probabilities"]))
UNIFORM_CONVERGENCE_SAMPLE[index]["distance_pgs"] = distance_p_ground_state
UNIFORM_CONVERGENCE_SAMPLE
import csv
header = ['iteration', 'state', 'probability', 'mean']
header_q = ['iteration', 'distance']
with open('qaoa_cu.csv', 'w', encoding='UTF8') as f:
with open('qaoa_distance.csv', 'w', encoding='UTF8') as q:
writer = csv.writer(f)
writer_q = csv.writer(q)
# write the header
writer.writerow(header)
writer_q.writerow(header_q)
iteration = 0
for sample in UNIFORM_CONVERGENCE_SAMPLE:
iteration += 1
mean = sample["mean"]
distance = sample["distance_pgs"]
state = 0
for probability in sample["probabilities"]:
state += 1
# write the data
data = [iteration, state, probability, mean]
writer.writerow(data)
writer_q.writerow([iteration, distance])
#plot_histogram(job_2, color='midnightblue', title=str(mean), figsize=(30, 5)).savefig(str(contador) + "_2.png")
#print(sample["mean"])
plot_histogram(job_2, color='midnightblue', title="New Histogram", figsize=(30, 5)).savefig('out.png')
|
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
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import datetime
import numpy as np
import matplotlib as mpl
import matplotlib.pyplot as plt
plt.rcParams.update({"text.usetex": True})
plt.rcParams["figure.figsize"] = (6,4)
mpl.rcParams["figure.dpi"] = 200
from qiskit_ibm_runtime import Estimator, Session, QiskitRuntimeService, Options
from qiskit.quantum_info import SparsePauliOp
from qiskit import QuantumCircuit
service = QiskitRuntimeService()
backend_simulator = "backend_simulator"
backend = "ibmq_montreal"
qubits = 4
trotter_layer = QuantumCircuit(qubits)
trotter_layer.rx(0.1, range(qubits))
trotter_layer.cx(0, 1)
trotter_layer.cx(2, 3)
trotter_layer.rz(-0.2, [1, 3])
trotter_layer.cx(0, 1)
trotter_layer.cx(2, 3)
trotter_layer.cx(1, 2)
trotter_layer.rz(-0.2, 2)
trotter_layer.cx(1, 2)
num_steps = 6
trotter_circuit_list = []
for i in range(1, num_steps):
trotter_circuit = QuantumCircuit(qubits)
for _ in range(i):
trotter_circuit = trotter_circuit.compose(trotter_layer)
trotter_circuit_list.append(trotter_circuit)
print(f'Trotter circuit with {i} Trotter steps`)
display(trotter_circuit.draw(fold=-1))
obs = SparsePauliOp("Z"*qubits)
obs_list = [obs]*len(trotter_circuit_list)
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # No optimization
options.resilience_level = 0 # No mitigation
with Session(service=service, backend=backend_simulator) as session:
estimator_sim = Estimator(session=session, options=options)
job_sim = estimator_sim.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_sim.job_id)
print(job_sim.result())
expvals_ideal = job_sim.result().values
expvals_ideal_variance = [metadata['variance']/metadata['shots'] for metadata in job_sim.result().metadata]
std_error_ideal = np.sqrt(expvals_ideal_variance)
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # No optimization
options.resilience_level = 0 # No error mitigation
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job.job_id)
print(job.result())
expvals_unmit = job.result().values
expvals_unmit_variance = [metadata['variance']/metadata['shots'] for metadata in job.result().metadata]
std_error_unmit = np.sqrt(expvals_unmit_variance)
options = Options()
options.execution.shots = 1000
options.optimization_level = 3 # Dynamical decoupling
options.resilience_level = 0 # No error mitigation
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job_dd = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_dd.job_id)
print(job_dd.result())
expvals_unmit_dd = job_dd.result().values
expvals_unmit_dd_variance = [metadata['variance']/metadata['shots'] for metadata in job_dd.result().metadata]
std_error_dd = np.sqrt(expvals_unmit_dd_variance)
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_dd, std_error_dd, fmt = 'o', linestyle = '-', capsize=4, c='blue', label='Dynamical decoupling')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
options = Options()
options.resilience_level = 1 # T-REx
options.optimization_level = 0 # No optimization
options.execution.shots = 1000
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job_trex = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_trex.job_id)
print(job_trex.result())
expvals_unmit_trex = job_trex.result().values
expvals_unmit_trex_variance = [metadata['variance']/metadata['shots'] for metadata in job_trex.result().metadata]
std_error_trex = np.sqrt(expvals_unmit_trex_variance)
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_trex, std_error_trex, fmt = 'o', linestyle = '-', capsize=4, c='violet', label='T-REx')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # No optimization
options.resilience_level = 2 # ZNE
with Session(service=service, backend=backend) as session:
estimator = Estimator(session=session, options=options)
job_zne = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_zne.job_id)
print(job_zne.result())
expvals_unmit_zne = job_zne.result().values
# Standard error: coming soon!
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_zne, [0]*(num_steps-1), fmt = 'o', linestyle = '-', capsize=4, c='cyan', label='ZNE')
plt.xlabel('No. Trotter Steps')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
def interim_results_callback(job_id, result):
now = datetime.datetime.now()
print(now, "*** Callback ***", result, "\n")
options = Options()
options.optimization_level = 0 # No optimization
options.execution.shots = 100
options.resilience_level = 3 # PEC
options.environment.callback = interim_results_callback
with Session(service=service, backend=backend) as session:
estimator_pec = Estimator(session=session, options=options)
job_pec = estimator_pec.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_pec.job_id)
expvals_pec = job_pec.result().values
std_error_pec = [metadata['standard_error'] for metadata in job_pec.result().metadata]
plt.title('Trotter circuits expectation value')
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_pec, std_error_pec, fmt = 'd', linestyle = '-', capsize=4, c='orange', label='PEC')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
print(job_pec.result())
pec_metadata = job_pec.result().metadata
fig, ax = plt.subplots()
fig.subplots_adjust(right=0.75)
twin1 = ax.twinx()
twin2 = ax.twinx()
twin3 = ax.twinx()
twin2.spines.right.set_position(("axes", 1.2))
twin3.spines.right.set_position(("axes", 1.4))
p1, = ax.plot(range(1, num_steps), [m["total_mitigated_layers"] for m in pec_metadata] , "b-", label="Total mitigated layers")
p2, = twin1.plot(range(1, num_steps), [m["sampling_overhead"] for m in pec_metadata], "r-", label="Sampling overhead")
p3, = twin2.plot(range(1, num_steps), [m["samples"] for m in pec_metadata], "g-", label="Samples")
p4, = twin3.plot(range(1, num_steps), [m["shots"] for m in pec_metadata], "c-", label="Shots")
ax.set_ylim(0, 20)
twin1.set_ylim(0, 2.8)
twin2.set_ylim(0, 300)
twin3.set_ylim(0, 35000)
ax.set_xlabel("No. Trotter Steps")
ax.set_ylabel("Total mitigated layers")
twin1.set_ylabel("Sampling overhead")
twin2.set_ylabel("Samples")
twin3.set_ylabel("Shots")
ax.yaxis.label.set_color(p1.get_color())
twin1.yaxis.label.set_color(p2.get_color())
twin2.yaxis.label.set_color(p3.get_color())
twin3.yaxis.label.set_color(p4.get_color())
tkw = dict(size=4, width=1.5)
ax.tick_params(axis='y', colors=p1.get_color(), **tkw)
twin1.tick_params(axis='y', colors=p2.get_color(), **tkw)
twin2.tick_params(axis='y', colors=p3.get_color(), **tkw)
twin3.tick_params(axis='y', colors=p4.get_color(), **tkw)
plt.xticks([1, 2, 3, 4, 5])
ax.legend(handles=[p1, p2, p3, p4])
plt.title('PEC metadata')
plt.show()
from matplotlib.pyplot import figure
plt.errorbar(range(1, num_steps), expvals_ideal, std_error_ideal, fmt = 'o', linestyle = '--', capsize=4, c='red', label='Ideal')
plt.errorbar(range(1, num_steps), expvals_unmit, std_error_unmit, fmt = 'o', linestyle = '-', capsize=4, c='green', label='No mitigation')
plt.errorbar(range(1, num_steps), expvals_unmit_trex, std_error_trex, fmt = 'o', linestyle = '-', capsize=4, c='violet', label='T-REx')
plt.errorbar(range(1, num_steps), expvals_unmit_zne, [0]*(num_steps-1), fmt = 'o', linestyle = '-', capsize=4, c='cyan', label='ZNE')
plt.errorbar(range(1, num_steps), expvals_pec, std_error_pec, fmt = 'd', linestyle = '-', capsize=4, c='orange', label='PEC')
plt.title('Trotter circuits expectation value')
plt.ylabel(f"$\langle ZZZZ \\rangle$")
plt.xlabel('No. Trotter Steps')
plt.xticks([1, 2, 3, 4, 5])
plt.legend()
plt.show()
options = Options()
options.execution.shots = 1000
options.optimization_level = 0 # no optimization
options.resilience_level = 2 # ZNE
options.resilience.noise_factors = [1, 2, 3, 4]
options.resilience.noise_amplifier = "LocalFoldingAmplifier"
options.resilience.extrapolator = "QuadraticExtrapolator"
with Session(service=service, backend='ibmq_montreal') as session:
estimator = Estimator(session=session, options=options)
job_zne_options = estimator.run(circuits=trotter_circuit_list, observables=obs_list)
print('job id:', job_zne_options.job_id)
print(job_zne_options.result())
from qiskit.tools import jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/PacktPublishing/Quantum-Computing-in-Practice-with-Qiskit-and-IBM-Quantum-Experience
|
PacktPublishing
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created Nov 2020
@author: hassi
"""
print("Ch 8: Correct for the expected")
print("------------------------------")
# Import Qiskit and load account
from qiskit import Aer, IBMQ, QuantumRegister, execute
from qiskit import QuantumCircuit
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
from IPython.core.display import display
print("Getting providers...")
if not IBMQ.active_account():
IBMQ.load_account()
provider = IBMQ.get_provider()
def select_backend():
# Get all available and operational backends.
available_backends = provider.backends(filters=lambda b: not b.configuration().simulator and b.configuration().n_qubits > 1 and b.status().operational)
# Fish out criteria to compare
print("{0:20} {1:<10} {2:<10}".format("Name","#Qubits","Pending jobs"))
print("{0:20} {1:<10} {2:<10}".format("----","-------","------------"))
for n in range(0, len(available_backends)):
backend = provider.get_backend(str(available_backends[n]))
print("{0:20} {1:<10}".format(backend.name(),backend.configuration().n_qubits),backend.status().pending_jobs)
select_backend=input("Select a backend ('exit' to end): ")
if select_backend!="exit":
backend = provider.get_backend(select_backend)
else:
backend=select_backend
return(backend)
def create_circuit():
#Create the circuit
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(0,2)
circuit.measure_all()
print("Our circuit:")
display(circuit.draw('mpl'))
return(circuit)
def simulator_results(circuit):
# Run the circuit on the local simulator
job = execute(circuit, backend=Aer.get_backend('qasm_simulator'), shots=8192)
job_monitor(job)
results = job.result()
sim_counts = results.get_counts()
print("Simulator results:\n",sim_counts)
return(sim_counts)
def noisy_results(circuit,backend):
# Select backend and run the circuit
job = execute(circuit, backend=backend, shots=8192)
job_monitor(job)
results = job.result()
noisy_counts = results.get_counts()
print(backend,"results:\n",noisy_counts)
return(noisy_counts,results)
def mitigated_results(circuit,backend,results):
# Import the required methods
from qiskit.providers.aer.noise import NoiseModel
from qiskit.ignis.mitigation.measurement import (complete_meas_cal,CompleteMeasFitter)
# Get noise model for backend
noise_model = NoiseModel.from_backend(backend)
# Create the measurement fitter
qr = QuantumRegister(circuit.num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
job = execute(meas_calibs, backend=Aer.get_backend('qasm_simulator'), shots=8192, noise_model=noise_model)
cal_results = job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
#print(meas_fitter.cal_matrix)
# Plot the calibration matrix
print("Calibration matrix")
meas_fitter.plot_calibration()
# Get the filter object
meas_filter = meas_fitter.filter
# Results with mitigation
mitigated_results = meas_filter.apply(results)
mitigated_counts = mitigated_results.get_counts(0)
print("Mitigated",backend,"results:\n",mitigated_counts)
return(mitigated_counts)
def main():
backend=select_backend()
circ=create_circuit()
sim_counts=simulator_results(circ)
noisy_counts,results=noisy_results(circ,backend)
# Analyze and error correct the measurements
mitigated_counts=mitigated_results(circ,backend,results)
# Show all results as a comparison
print("Final results:")
display(plot_histogram([sim_counts, noisy_counts, mitigated_counts], legend=['sim','noisy', 'mitigated']))
if __name__ == '__main__':
main()
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# Testing Circuits
import warnings
warnings.simplefilter("ignore")
%run "mpl/circuit/test_circuit_matplotlib_drawer.py"
# Testing Graphs
%run "mpl/graph/test_graph_matplotlib_drawer.py"
%run -i "results.py"
RESULTS_CIRCUIT
RESULTS_GRAPH
|
https://github.com/ronitd2002/IBM-Quantum-challenge-2024
|
ronitd2002
|
# Import all in one cell
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from scipy.optimize import minimize
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit.library import RealAmplitudes
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import InstructionProperties
from qiskit.visualization import plot_distribution
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.primitives import StatevectorEstimator
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import (
QiskitRuntimeService,
EstimatorV2 as Estimator,
SamplerV2 as Sampler,
EstimatorOptions
)
# qc-grader should be 0.18.12 (or higher)
import qc_grader
qc_grader.__version__
from qc_grader.challenges.iqc_2024 import (
grade_lab4_ex1,
grade_lab4_ex2,
grade_lab4_ex3,
grade_lab4_ex4,
grade_lab4_ex5,
grade_lab4_ex6,
grade_lab4_ex7
)
# Define num_qubits, the number of qubits, for the rest of the Lab
num_qubits = 5
# Load the dictionary
birds_dataset = pd.read_csv('birds_dataset.csv')
# Check if the dataset is loaded correctly - coefficients should be complex numbers
for i in range(2**num_qubits):
key = 'c%.0f' %i
birds_dataset[key] = birds_dataset[key].astype(np.complex128)
# Print the dataset
birds_dataset
isinstance(birds_dataset, pd.DataFrame)
# List to store the coefficient lists for each label
coefficients_lists = []
# Iterate over each row in the DataFrame
for index, row in birds_dataset.iterrows():
# Extract coefficients as a list
coefficients = row[1:].tolist() # Skip the label column
# Append the list of coefficients to the main list
coefficients_lists.append(coefficients)
coefficients_lists
lab_birds = [1]*5 + [0]*5
lab_birds
list_coefficients = coefficients_lists # Add your code here
list_labels = lab_birds# Add your code here
# Submit your answer using following code
grade_lab4_ex1(list_coefficients, list_labels)
index_bird = 1 # You can check different birds by changing the index
amplitudes = list_coefficients[index_bird]
# Build the amplitude embedding
qc = QuantumCircuit(5)
qc.initialize(amplitudes, range(num_qubits))
qc.measure_all()
# Draw the amplitude embedding circuit
qc.draw(output="mpl")
# Draw the decomposition of the amplitude embedding circuit
qc.decompose(reps=8).draw(output="mpl", fold=40)
num_qubits = 5 # Add your code here
reps = 1 # Add your code here
entanglement = 'full' # Add your code here
ansatz = RealAmplitudes(num_qubits=num_qubits, entanglement=entanglement, reps=reps,insert_barriers=True) # Add your code here
# Add code here to draw the ansatz circuit
ansatz.decompose(reps=6).draw(output="mpl", fold=40)
# Submit your answer using following code
grade_lab4_ex2(num_qubits, reps, entanglement)
# Define the observable
obs = SparsePauliOp("ZZZZZ")
# Define the estimator and pass manager
estimator = StatevectorEstimator() #To train we use StatevectorEstimator to get the exact simulation
pm = generate_preset_pass_manager(backend=AerSimulator(), optimization_level=3, seed_transpiler=0)
# Define the cost function
def cost_func(params, list_coefficients, list_labels, ansatz, obs, estimator, pm, callback_dict):
"""Return cost function for optimization
Parameters:
params (ndarray): Array of ansatz parameters
list_coefficients (list): List of arrays of complex coefficients
list_labels (list): List of labels
ansatz (QuantumCircuit): Parameterized ansatz circuit
obs (SparsePauliOp): Observable
estimator (EstimatorV2): Statevector estimator primitive instance
pm (PassManager): Pass manager
callback_dict (dict): Dictionary to store callback information
Returns:
float: Cost function estimate
"""
cost = 0
for amplitudes,label in zip(list_coefficients, list_labels):
qc = QuantumCircuit(num_qubits)
# Amplitude embedding
qc.initialize(amplitudes)
# Compose initial state + ansatz
classifier = qc.compose(ansatz)
# Transpile classifier
transpiled_classifier = pm.run(classifier)
# Transpile observable
transpiled_obs = obs.apply_layout(layout=transpiled_classifier.layout)
# Run estimator
pub = (transpiled_classifier, transpiled_obs, params)
job = estimator.run([pub])
# Get result
result = job.result()[0].data.evs
# Compute cost function (cumulative)
cost += np.abs(result - label)
callback_dict["iters"] += 1
callback_dict["prev_vector"] = params
callback_dict["cost_history"].append(cost)
# Print the iterations to screen on a single line
print(
"Iters. done: {} [Current cost: {}]".format(callback_dict["iters"], cost),
end="\r",
flush=True,
)
return cost
# Intialize the lists to store the results from different runs
cost_history_list = []
res_list = []
# Retrieve the initial parameters
params_0_list = np.load("params_0_list.npy")
for it, params_0 in enumerate(params_0_list):
print('Iteration number: ', it)
# Initialize a callback dictionary
callback_dict = {
"prev_vector": None,
"iters": 0,
"cost_history": [],
}
# Minimize the cost function using scipy
res = minimize(
cost_func,
params_0,
args=(list_coefficients, list_labels, ansatz, obs, estimator, pm, callback_dict),
method="cobyla", # Classical optimizer
options={'maxiter': 200}) # Maximum number of iterations
# Print the results after convergence
print(res,"\n")
# Save the results from different runs
res_list.append(res)
cost_history_list.append(callback_dict["cost_history"])
'''
fig, ax = plt.subplots(1, 1, figsize=(7,5))
ax.set_title('Cost history')
ax.set_ylabel('Cost')
ax.set_xlabel('Iterations')
# Add your code here
'''
def test_VQC(list_coefficients, list_labels, ansatz, obs, opt_params, estimator, pm):
"""Return the performance of the classifier
Parameters:
list_coefficients (list): List of arrays of complex coefficients
list_labels (list): List of labels
ansatz (QuantumCircuit): Parameterized ansatz circuit
obs (SparsePauliOp): Observable
opt_params (ndarray): Array of optimized parameters
estimator (EstimatorV2): Statevector estimator
pm (PassManager): Pass manager for transpilation
Returns:
list: List of test results
"""
### Write your code below here ###
results_test = []
for coefficients, label in zip(list_coefficients, list_labels):
test_circuit = ansatz.copy()
test_circuit.initialize(coefficients)
classifier = test_circuit.compose(ansatz)
transpiled_classifier = pm.run(classifier)
transpiled_obs = obs.apply_layout(layout = transpiled_classifier.layout)
pub = (transpiled_classifier, transpiled_obs, opt_params)
job = estimator.run([pub])
result = np.abs(job.result()[0].data.evs)
results_test.append(result)
### Don't change any code past this line ###
return results_test
def compute_performance(result_list, list_labels):
"""Return the performance of the classifier
Parameters:
result_list (list): List of results
list_labels (list): List of labels
Returns:
float: Performance of the classifier
"""
### Write your code below here ###
performance = 100* (1 - sum(np.abs(result - label) for result, label in zip(result_list, list_labels))/ (2** num_qubits))
### Don't change any code past this line ###
return performance
results_test = test_VQC(list_coefficients, list_labels, ansatz, obs, opt_params, estimator, pm)
results_test
perf = []
for index in range(len(res_list)):
opt_params = res_list[index].x
results_test = test_VQC(list_coefficients, list_labels, ansatz, obs, opt_params, estimator, pm)
perf.append(compute_performance(results_test, list_labels))
print(perf)
print(perf.index(np.max(perf)))
fig, ax = plt.subplots(1, 1, figsize=(7,5))
ax.set_title('Cost on test data')
ax.set_ylabel('Cost')
ax.set_xlabel('State index')
ax.plot(list_labels, 'k-', linewidth=3, alpha=0.6, label='Labels')
for index in range(len(res_list)):
opt_params = res_list[index].x
results_test = test_VQC(list_coefficients, list_labels, ansatz, obs, opt_params, estimator, pm)
print(f"Performance for trial {index}: {compute_performance(results_test, list_labels)}")
ax.plot(results_test, 'o--', label='Predictions trial '+str(index))
ax.legend()
plt.show()
# Submit your answer using following code
best_result_index = perf.index(np.max(perf)) # Choose the index with the best result
grade_lab4_ex3(res_list[best_result_index]) # Expected result type: OptimizeResult
fake_backend = GenericBackendV2(
num_qubits=5,
basis_gates=["id", "rz", "sx", "x", "cx"]
)
def update_error_rate(backend, error_rates):
"""Updates the error rates of the backend
Parameters:
backend (BackendV2): Backend to update
error_rates (dict): Dictionary of error rates
Returns:
None
"""
default_duration=1e-8
if "default_duration" in error_rates:
default_duration = error_rates["default_duration"]
# Update the 1-qubit gate properties
for i in range(backend.num_qubits):
qarg = (i,)
if "rz_error" in error_rates:
backend.target.update_instruction_properties('rz', qarg, InstructionProperties(error=error_rates["rz_error"], duration=default_duration))
if "x_error" in error_rates:
backend.target.update_instruction_properties('x', qarg, InstructionProperties(error=error_rates["x_error"], duration=default_duration))
if "sx_error" in error_rates:
backend.target.update_instruction_properties('sx', qarg, InstructionProperties(error=error_rates["sx_error"], duration=default_duration))
if "measure_error" in error_rates:
backend.target.update_instruction_properties('measure', qarg, InstructionProperties(error=error_rates["measure_error"], duration=default_duration))
# Update the 2-qubit gate properties (CX gate) for all edges in the chosen coupling map
if "cx_error" in error_rates:
for edge in backend.coupling_map:
backend.target.update_instruction_properties('cx', tuple(edge), InstructionProperties(error=error_rates["cx_error"], duration=default_duration))
error_rates = {
"default_duration": 1e-8,
"rz_error": 1e-8,
"x_error": 1e-8,
"sx_error": 1e-8,
"measure_error": 1e-8,
"cx_error": 1e-8
}
update_error_rate(fake_backend, error_rates)
fig, ax = plt.subplots(1, 1, figsize=(7,5))
ax.set_title('Cost on test data')
ax.set_ylabel('Cost')
ax.set_xlabel('State index')
ax.plot(list_labels, 'k-', linewidth=3, alpha=0.6, label='Labels')
error_rate_list = [1e-1, 1e-2, 1e-3, 1e-4]
fake_backend = GenericBackendV2(
num_qubits=5,
basis_gates=["id", "rz", "sx", "x", "cx"]
)
for error_rate_value in error_rate_list:
#update_error_rate(fake_backend, {"rz_error": error_rate_value, "cx_error": error_rate_value}) # Add your code here
update_error_rate(fake_backend, error_rates = {
"default_duration": 1e-8,
"rz_error": error_rate_value,
"x_error": 1e-8,
"sx_error": 1e-8,
"measure_error": 1e-8,
"cx_error": error_rate_value
}) # Add your code here
estimator = Estimator(backend= fake_backend) # Add your code here
pm = generate_preset_pass_manager(backend= fake_backend, optimization_level=3, seed_transpiler=0) # Add your code here
opt_params = res_list[best_result_index].x # Add your code here
results_test = test_VQC(list_coefficients, list_labels, ansatz, obs, opt_params, estimator, pm)
print(f"Performance for run {index}: {compute_performance(results_test, list_labels)}")
ax.plot(results_test, 'o--', label='Predictions error rate '+str(error_rate_value))
ax.legend()
# Submit your answer using following code
grade_lab4_ex4(fake_backend) # Expected answer type: BackendV2
# Choose a real backend
service = QiskitRuntimeService()
backend = service.backend("ibm_osaka")
# Define a fake backend with the same properties as the real backend
fake_backend = AerSimulator.from_backend(backend)
index_bird = 0 #you can check different birds by changing the index
qc = QuantumCircuit(num_qubits)
qc.initialize(list_coefficients[index_bird])
pm = generate_preset_pass_manager(optimization_level=3, backend=fake_backend)
transpiled_qc = pm.run(qc)
print('Depth of two-qubit gates: ', transpiled_qc.depth(lambda x: len(x.qubits) == 2))
transpiled_qc.draw(output="mpl", idle_wires=False, fold=40)
def amplitude_embedding(num_qubits, bird_index):
"""Create amplitude embedding circuit
Parameters:
num_qubits (int): Number of qubits for the ansatz
bird_index (int): Data index of the bird
Returns:
qc (QuantumCircuit): Quantum circuit with amplitude embedding of the bird
"""
def generate_GHZ(qc):
qc.h(0)
for i, j in zip(range(num_qubits-1), range(1,num_qubits)):
qc.cx(i, j)
### Write your code below here ###
qc = QuantumCircuit(num_qubits)
if bird_index < 5:
generate_GHZ(qc)
bin_string = format(bird_index, '0{0}b'.format(num_qubits))
for i in reversed(range(len(bin_string))):
if bin_string[i] == '1':
qc.x(num_qubits-i-1)
### Don't change any code past this line ###
return qc
index_bird = 2 # You can check different birds by changing the index
# Build the amplitude embedding
qc = amplitude_embedding(num_qubits, index_bird)
qc.measure_all()
# Define the backend and the pass manager
aer_sim = AerSimulator()
pm = generate_preset_pass_manager(backend=aer_sim, optimization_level=3)
isa_circuit = pm.run(qc)
# Define the sampler with the number of shots
sampler = Sampler(backend=aer_sim)
result = sampler.run([isa_circuit]).result()
samp_dist = result[0].data.meas.get_counts()
plot_distribution(samp_dist, figsize=(15, 5))
index_bird = 0 #You can check different birds by changing the index
qc = amplitude_embedding(num_qubits, index_bird)
pm = generate_preset_pass_manager(optimization_level=3, backend=fake_backend)
transpiled_qc = pm.run(qc)
print('Depth of two-qubit gates: ', transpiled_qc.depth(lambda x: len(x.qubits) == 2))
transpiled_qc.draw(output="mpl", fold=False, idle_wires=False)
# Submit your answer using following code
grade_lab4_ex5(amplitude_embedding) # Expected answer type Callable
old_ansatz = RealAmplitudes(num_qubits, reps=1, entanglement='full', insert_barriers=True)
pm = generate_preset_pass_manager(optimization_level=3, backend=fake_backend)
transpiled_ansatz = pm.run(old_ansatz)
print('Depth of two-qubit gates: ', transpiled_ansatz.depth(lambda x: len(x.qubits) == 2))
transpiled_ansatz.draw(output="mpl", idle_wires=False, fold=40)
ansatz = ansatz = RealAmplitudes(num_qubits=num_qubits, entanglement='pairwise', reps=reps,insert_barriers=True) # Add your code here
pm = generate_preset_pass_manager(optimization_level=3, backend=fake_backend)# Add your code here
transpiled_ansatz = pm.run(qc)# Add your code here
print('Depth of two-qubit gates: ', transpiled_ansatz.depth(lambda x: len(x.qubits) == 2))
transpiled_ansatz.draw(output="mpl", fold=False, idle_wires=False)
old_mapping = QuantumCircuit(num_qubits)
old_mapping.initialize(list_coefficients[index_bird])
old_classifier = old_mapping.compose(old_ansatz)
new_mapping = amplitude_embedding(num_qubits, index_bird)
new_classifier = new_mapping.compose(ansatz)
pm = generate_preset_pass_manager(optimization_level=3, backend=fake_backend)
old_transpiled_classifier = pm.run(old_classifier)
new_transpiled_classifier = pm.run(new_classifier)
print('Old depth of two-qubit gates: ', old_transpiled_classifier.depth(lambda x: len(x.qubits) == 2))
print('Current depth of two-qubit gates: ', new_transpiled_classifier.depth(lambda x: len(x.qubits) == 2))
def test_shallow_VQC(list_labels, ansatz, obs, opt_params, estimator, pm):
"""Return the performance of the classifier
Parameters:
list_labels (list): List of labels
ansatz (QuantumCircuit): Parameterized ansatz circuit
obs (SparsePauliOp): Observable
opt_params (ndarray): Array of optimized parameters
estimator (EstimatorV2): Statevector estimator
pm (PassManager): Pass manager for transpilation
Returns:
results_test (list): List of test results
"""
### Write your code below here ###
results_test = []
for bird_index, label in enumerate(list_labels):
qc = QuantumCircuit(num_qubits)
new_mapping = amplitude_embedding(num_qubits, bird_index)
classifier = new_mapping.compose(ansatz)
transpiled_classifier = pm.run(classifier)
transpiled_obs = obs.apply_layout(layout=transpiled_classifier.layout)
pub = (transpiled_classifier, transpiled_obs, opt_params)
job = estimator.run([pub])
result = abs(job.result()[0].data.evs)
results_test.append(result)
### Don't change any code past this line ###
return results_test
estimator = Estimator(backend=fake_backend)
estimator.options.default_shots = 5000
pm = generate_preset_pass_manager(optimization_level=3, backend=fake_backend)
opt_params = np.load('opt_params_shallow_VQC.npy') # Load optimal parameters
results_test = test_shallow_VQC(list_labels, ansatz, obs, opt_params, estimator, pm)
print(f"Performance: {compute_performance(results_test, list_labels)}")
fig, ax = plt.subplots(1, 1, figsize=(7,5))
ax.set_title('Cost on test data')
ax.set_ylabel('Cost')
ax.set_xlabel('State index')
ax.plot(list_labels, 'k-', linewidth=3, alpha=0.6, label='Labels')
ax.plot(results_test, 'o--', label='Fake Backend')
ax.legend()
# Submit your answer using following code
grade_lab4_ex6(results_test) # Expected answer type: list[float]
service = QiskitRuntimeService()
backend = service.backend("ibm_osaka")
def test_shallow_VQC_QPU(list_labels, anstaz, obs, opt_params, options, backend):
"""Return the performance of the classifier
Parameters:
list_labels (list): List of labels
ansatz (QuantumCircuit): Parameterized ansatz circuit
obs (SparsePauliOp): Observable
opt_params (ndarray): Array of optimized parameters
options (EstimatorOptions): Estimator options
backend (service.backend): Backend to run the job
Returns:
job_id (str): Job ID
"""
estimator = Estimator(backend=backend, options=options)
pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
pubs = []
for bird, label in enumerate(list_labels):
### Write your code below here ###
qc = QuantumCircuit(num_qubits)
new_mapping = amplitude_embedding(num_qubits, bird)
classifier = new_mapping.compose(ansatz)
transpiled_classifier = pm.run(classifier)
transpiled_obs = obs.apply_layout(layout=transpiled_classifier.layout)
pub = (transpiled_classifier, transpiled_obs, opt_params)
job = estimator.run([pub])
result = abs(job.result()[0].data.evs)
results_test.append(result)
### Don't change any code past this line ###
pub = (transpiled_classifier, transpiled_obs, opt_params)
pubs.append(pub)
job = estimator.run(pubs)
job_id = job.job_id()
print(f"Job ID: {job_id}")
print(f"Status: {job.status()}")
return job_id
## No DD, no TREX (no ZNE)
options_0 = EstimatorOptions(
default_shots= 5000,
optimization_level= 0,
resilience_level= 0,
dynamical_decoupling = {'enable': False, 'sequence_type': 'XpXm'},
twirling= {'enable_measure': False}
)#Add your code here
## DD + TREX (no ZNE)
options_1 = options_1 = EstimatorOptions()
options_1.optimization_level =0
options_1.resilience_level = 1
options_1.default_shots = 5000
options_1.dynamical_decoupling.enable = True
options_1.dynamical_decoupling.sequence_type = 'XpXm'
options_1.twirling.enable_measure = False #Add your code here
# Submit your answer using following code
grade_lab4_ex7(options_0, options_1) # Expected answer type: EstimatorOptions, EstimatorOptions
def retrieve_job(job_id):
''' Retrieve results from job_id '''
job = service.job(job_id)
results_test = []
errors_test = []
for result in job.result():
results_test.append(abs(result.data.evs))
errors_test.append(abs(result.data.stds))
return results_test, errors_test
## No DD, no TREX (no ZNE)
job_id_0 = test_shallow_VQC_QPU(list_labels, ansatz, obs, opt_params, options_0, backend)
## DD + TREX (no ZNE)
job_id_1 = test_shallow_VQC_QPU(list_labels, ansatz, obs, opt_params, options_1, backend)
results_test_0_DD, errors_test_0_DD = retrieve_job() #(Add job_id 0 here)
results_test_1_DD, errors_test_1_DD = retrieve_job() #(Add job_id 1 here)
fig, ax = plt.subplots(1, 1, figsize=(7,5))
ax.set_title('Cost on test data')
ax.set_ylabel('Cost')
ax.set_xlabel('State index')
print(f"Performance for no DD + no TREX: {compute_performance(results_test_0_DD, list_labels):.3f}")
print(f"Performance for DD + TREX: {compute_performance(results_test_1_DD, list_labels):.3f}")
ax.errorbar(range(10), results_test_0_DD, fmt='-o', yerr=errors_test_0_DD, color='tab:orange', label='Osaka no EM')
ax.errorbar(range(10), results_test_1_DD, fmt='-o', yerr=errors_test_1_DD, color='tab:blue', label='Osaka TREX + DD')
ax.plot(list_labels, 'k-', label='Labels')
ax.legend()
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=wrong-import-order
"""Main Qiskit public functionality."""
import pkgutil
# First, check for required Python and API version
from . import util
# qiskit errors operator
from .exceptions import QiskitError
# The main qiskit operators
from qiskit.circuit import ClassicalRegister
from qiskit.circuit import QuantumRegister
from qiskit.circuit import QuantumCircuit
# pylint: disable=redefined-builtin
from qiskit.tools.compiler import compile # TODO remove after 0.8
from qiskit.execute import execute
# The qiskit.extensions.x imports needs to be placed here due to the
# mechanism for adding gates dynamically.
import qiskit.extensions
import qiskit.circuit.measure
import qiskit.circuit.reset
# Allow extending this namespace. Please note that currently this line needs
# to be placed *before* the wrapper imports or any non-import code AND *before*
# importing the package you want to allow extensions for (in this case `backends`).
__path__ = pkgutil.extend_path(__path__, __name__)
# Please note these are global instances, not modules.
from qiskit.providers.basicaer import BasicAer
# Try to import the Aer provider if installed.
try:
from qiskit.providers.aer import Aer
except ImportError:
pass
# Try to import the IBMQ provider if installed.
try:
from qiskit.providers.ibmq import IBMQ
except ImportError:
pass
from .version import __version__
from .version import __qiskit_version__
|
https://github.com/anpaschool/QC-School-Fall2020
|
anpaschool
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer
from math import pi
from qiskit.visualization import plot_bloch_multivector, plot_state_qsphere
%matplotlib inline
qcx = QuantumCircuit(1)
qcx.draw('mpl')
backend = Aer.get_backend('statevector_simulator') # Tell Qiskit how to simulate our circuit
job = execute(qcx,backend).result() # Do the simulation, returning the state vector
plot_bloch_multivector(job.get_statevector()) # Display the output state vector
plot_state_qsphere(job.get_statevector(qcx))
# Let's do an X-gate on a |0> qubit
qcx.x(0)
qcx.draw('mpl')
job = execute(qcx,backend).result() # Do the simulation, returning the state vector
plot_bloch_multivector(job.get_statevector()) # Display the output state vector
plot_state_qsphere(job.get_statevector(qcx))
from IPython.display import YouTubeVideo
print("Install Qiskit")
YouTubeVideo("M4EkW4VwhcI")
print("Hello World!")
YouTubeVideo("RrUTwq5jKM4")
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
from pprint import pprint
import pickle
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One
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
# unused for this file
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("../../solutions/utils/")
import circuit_utils, zne_utils, tomography_utils
importlib.reload(circuit_utils)
importlib.reload(zne_utils) # unused for this file
importlib.reload(tomography_utils) # unused for this file
from circuit_utils import *
from zne_utils import zne_wrapper, zne_decoder
from tomography_utils import expvals_to_valid_rho
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
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_list = [1,2,3,4,5,6,7,8,9,10,20,30,40,50,60,70,80,90,100]
print("trotter step list: ", num_steps_list)
scale_factors = [1.0, 2.0, 3.0] # unused for this file
shots = 1 << 13
reps = 8 # unused
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
# QREM
qr = QuantumRegister(num_qubits, name="calq")
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
# we have to feed initial_layout to calibration matrix
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
retrieved_cal_job = cal_job
cal_results = retrieved_cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
raw_fid_list = []
raw_stddev_list = []
qrem_fid_list = []
qrem_stddev_list = []
for num_steps in num_steps_list:
print("trotter steps: ", num_steps)
t1 = time.perf_counter()
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="q")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
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
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_st_qcs = transpile(t3_st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = t3_st_qcs
# zne_qcs = zne_wrapper(t3_st_qcs, scale_factors = scale_factors, pt = False)
# print("created zne_qcs (length:", len(zne_qcs), ")")
# optimization_level must be 0
# feed initial_layout here to see the picture of the circuits before casting the job
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
jobs = []
for _ in range(reps):
#! CHECK: run t3_zne_qcs, with optimization_level = 0 and straightforward initial_layout
job = execute(t3_zne_qcs, backend, shots=shots, optimization_level=0)
print('Job ID', job.job_id())
jobs.append(job)
retrieved_jobs = jobs
raw_fids = []
qrem_fids = []
for job in retrieved_jobs:
raw_results = job.result()
mit_results = meas_fitter.filter.apply(raw_results)
raw_rho = StateTomographyFitter(raw_results, t3_zne_qcs).fit(method='lstsq')
qrem_rho = StateTomographyFitter(mit_results, t3_zne_qcs).fit(method='lstsq')
raw_fids.append(state_fidelity(raw_rho, target_state))
qrem_fids.append(state_fidelity(qrem_rho, target_state))
raw_fid_list.append(np.mean(raw_fids))
raw_stddev_list.append(np.std(raw_fids))
qrem_fid_list.append(np.mean(qrem_fids))
qrem_stddev_list.append(np.std(qrem_fids))
t2 = time.perf_counter()
print('raw state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(raw_fids), np.std(raw_fids)))
print('qrem state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(qrem_fids), np.std(qrem_fids)))
print("time:", t2 - t1)
print()
with open("e2d1_raw.pkl", "wb") as f:
pickle.dump({"num_steps_list": num_steps_list, "fid": raw_fid_list, "stddev": raw_stddev_list}, f)
with open("e2d1_qrem.pkl", "wb") as f:
pickle.dump({"num_steps_list": num_steps_list, "fid": qrem_fid_list, "stddev": qrem_stddev_list}, f)
import qiskit.tools.jupyter
%qiskit_version_table
plt.plot(num_steps_list, raw_fid_list)
plt.plot(num_steps_list, qrem_fid_list)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Arbitrary unitary circuit instruction.
"""
import numpy
from qiskit.circuit import Gate, ControlledGate
from qiskit.circuit import QuantumCircuit
from qiskit.circuit import QuantumRegister, Qubit
from qiskit.circuit.exceptions import CircuitError
from qiskit.circuit._utils import _compute_control_matrix
from qiskit.circuit.library.standard_gates import UGate
from qiskit.extensions.quantum_initializer import isometry
from qiskit.quantum_info.operators.predicates import matrix_equal
from qiskit.quantum_info.operators.predicates import is_unitary_matrix
from qiskit.quantum_info.synthesis.one_qubit_decompose import OneQubitEulerDecomposer
from qiskit.quantum_info.synthesis.two_qubit_decompose import two_qubit_cnot_decompose
from qiskit.extensions.exceptions import ExtensionError
_DECOMPOSER1Q = OneQubitEulerDecomposer("U")
class UnitaryGate(Gate):
"""Class quantum gates specified by a unitary matrix.
Example:
We can create a unitary gate from a unitary matrix then add it to a
quantum circuit. The matrix can also be directly applied to the quantum
circuit, see :meth:`.QuantumCircuit.unitary`.
.. code-block:: python
from qiskit import QuantumCircuit
from qiskit.extensions import UnitaryGate
matrix = [[0, 0, 0, 1],
[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 1, 0, 0]]
gate = UnitaryGate(matrix)
circuit = QuantumCircuit(2)
circuit.append(gate, [0, 1])
"""
def __init__(self, data, label=None):
"""Create a gate from a numeric unitary matrix.
Args:
data (matrix or Operator): unitary operator.
label (str): unitary name for backend [Default: None].
Raises:
ExtensionError: if input data is not an N-qubit unitary operator.
"""
if hasattr(data, "to_matrix"):
# If input is Gate subclass or some other class object that has
# a to_matrix method this will call that method.
data = data.to_matrix()
elif hasattr(data, "to_operator"):
# If input is a BaseOperator subclass this attempts to convert
# the object to an Operator so that we can extract the underlying
# numpy matrix from `Operator.data`.
data = data.to_operator().data
# Convert to numpy array in case not already an array
data = numpy.array(data, dtype=complex)
# Check input is unitary
if not is_unitary_matrix(data):
raise ExtensionError("Input matrix is not unitary.")
# Check input is N-qubit matrix
input_dim, output_dim = data.shape
num_qubits = int(numpy.log2(input_dim))
if input_dim != output_dim or 2**num_qubits != input_dim:
raise ExtensionError("Input matrix is not an N-qubit operator.")
# Store instruction params
super().__init__("unitary", num_qubits, [data], label=label)
def __eq__(self, other):
if not isinstance(other, UnitaryGate):
return False
if self.label != other.label:
return False
# Should we match unitaries as equal if they are equal
# up to global phase?
return matrix_equal(self.params[0], other.params[0], ignore_phase=True)
def __array__(self, dtype=None):
"""Return matrix for the unitary."""
# pylint: disable=unused-argument
return self.params[0]
def inverse(self):
"""Return the adjoint of the unitary."""
return self.adjoint()
def conjugate(self):
"""Return the conjugate of the unitary."""
return UnitaryGate(numpy.conj(self.to_matrix()))
def adjoint(self):
"""Return the adjoint of the unitary."""
return self.transpose().conjugate()
def transpose(self):
"""Return the transpose of the unitary."""
return UnitaryGate(numpy.transpose(self.to_matrix()))
def _define(self):
"""Calculate a subcircuit that implements this unitary."""
if self.num_qubits == 1:
q = QuantumRegister(1, "q")
qc = QuantumCircuit(q, name=self.name)
theta, phi, lam, global_phase = _DECOMPOSER1Q.angles_and_phase(self.to_matrix())
qc._append(UGate(theta, phi, lam), [q[0]], [])
qc.global_phase = global_phase
self.definition = qc
elif self.num_qubits == 2:
self.definition = two_qubit_cnot_decompose(self.to_matrix())
else:
from qiskit.quantum_info.synthesis.qsd import ( # pylint: disable=cyclic-import
qs_decomposition,
)
self.definition = qs_decomposition(self.to_matrix())
def control(self, num_ctrl_qubits=1, label=None, ctrl_state=None):
"""Return controlled version of gate
Args:
num_ctrl_qubits (int): number of controls to add to gate (default=1)
label (str): optional gate label
ctrl_state (int or str or None): The control state in decimal or as a
bit string (e.g. '1011'). If None, use 2**num_ctrl_qubits-1.
Returns:
UnitaryGate: controlled version of gate.
Raises:
QiskitError: Invalid ctrl_state.
ExtensionError: Non-unitary controlled unitary.
"""
mat = self.to_matrix()
cmat = _compute_control_matrix(mat, num_ctrl_qubits, ctrl_state=None)
iso = isometry.Isometry(cmat, 0, 0)
return ControlledGate(
"c-unitary",
num_qubits=self.num_qubits + num_ctrl_qubits,
params=[mat],
label=label,
num_ctrl_qubits=num_ctrl_qubits,
definition=iso.definition,
ctrl_state=ctrl_state,
base_gate=self.copy(),
)
def _qasm2_decomposition(self):
"""Return an unparameterized version of ourselves, so the OQ2 exporter doesn't choke on the
non-standard things in our `params` field."""
out = self.definition.to_gate()
out.name = self.name
return out
def validate_parameter(self, parameter):
"""Unitary gate parameter has to be an ndarray."""
if isinstance(parameter, numpy.ndarray):
return parameter
else:
raise CircuitError(f"invalid param type {type(parameter)} in gate {self.name}")
def unitary(self, obj, qubits, label=None):
"""Apply unitary gate specified by ``obj`` to ``qubits``.
Args:
obj (matrix or Operator): unitary operator.
qubits (Union[int, Tuple[int]]): The circuit qubits to apply the
transformation to.
label (str): unitary name for backend [Default: None].
Returns:
QuantumCircuit: The quantum circuit.
Raises:
ExtensionError: if input data is not an N-qubit unitary operator.
Example:
Apply a gate specified by a unitary matrix to a quantum circuit
.. code-block:: python
from qiskit import QuantumCircuit
matrix = [[0, 0, 0, 1],
[0, 0, 1, 0],
[1, 0, 0, 0],
[0, 1, 0, 0]]
circuit = QuantumCircuit(2)
circuit.unitary(matrix, [0, 1])
"""
gate = UnitaryGate(obj, label=label)
if isinstance(qubits, QuantumRegister):
qubits = qubits[:]
# for single qubit unitary gate, allow an 'int' or a 'list of ints' as qubits.
if gate.num_qubits == 1:
if isinstance(qubits, (int, Qubit)) or len(qubits) > 1:
qubits = [qubits]
return self.append(gate, qubits, [])
QuantumCircuit.unitary = unitary
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.utils import algorithm_globals
algorithm_globals.random_seed = 12345
from qiskit_machine_learning.datasets import ad_hoc_data
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(
training_size=20,
test_size=5,
n=adhoc_dimension,
gap=0.3,
plot_data=False,
one_hot=False,
include_sample_total=True,
)
import matplotlib.pyplot as plt
import numpy as np
def plot_features(ax, features, labels, class_label, marker, face, edge, label):
# A train plot
ax.scatter(
# x coordinate of labels where class is class_label
features[np.where(labels[:] == class_label), 0],
# y coordinate of labels where class is class_label
features[np.where(labels[:] == class_label), 1],
marker=marker,
facecolors=face,
edgecolors=edge,
label=label,
)
def plot_dataset(train_features, train_labels, test_features, test_labels, adhoc_total):
plt.figure(figsize=(5, 5))
plt.ylim(0, 2 * np.pi)
plt.xlim(0, 2 * np.pi)
plt.imshow(
np.asmatrix(adhoc_total).T,
interpolation="nearest",
origin="lower",
cmap="RdBu",
extent=[0, 2 * np.pi, 0, 2 * np.pi],
)
# A train plot
plot_features(plt, train_features, train_labels, 0, "s", "w", "b", "A train")
# B train plot
plot_features(plt, train_features, train_labels, 1, "o", "w", "r", "B train")
# A test plot
plot_features(plt, test_features, test_labels, 0, "s", "b", "w", "A test")
# B test plot
plot_features(plt, test_features, test_labels, 1, "o", "r", "w", "B test")
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Ad hoc dataset")
plt.show()
plot_dataset(train_features, train_labels, test_features, test_labels, adhoc_total)
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
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)
from sklearn.svm import SVC
adhoc_svc = SVC(kernel=adhoc_kernel.evaluate)
adhoc_svc.fit(train_features, train_labels)
adhoc_score_callable_function = adhoc_svc.score(test_features, test_labels)
print(f"Callable kernel classification test score: {adhoc_score_callable_function}")
adhoc_matrix_train = adhoc_kernel.evaluate(x_vec=train_features)
adhoc_matrix_test = adhoc_kernel.evaluate(x_vec=test_features, y_vec=train_features)
fig, axs = plt.subplots(1, 2, figsize=(10, 5))
axs[0].imshow(
np.asmatrix(adhoc_matrix_train), interpolation="nearest", origin="upper", cmap="Blues"
)
axs[0].set_title("Ad hoc training kernel matrix")
axs[1].imshow(np.asmatrix(adhoc_matrix_test), interpolation="nearest", origin="upper", cmap="Reds")
axs[1].set_title("Ad hoc testing kernel matrix")
plt.show()
adhoc_svc = SVC(kernel="precomputed")
adhoc_svc.fit(adhoc_matrix_train, train_labels)
adhoc_score_precomputed_kernel = adhoc_svc.score(adhoc_matrix_test, test_labels)
print(f"Precomputed kernel classification test score: {adhoc_score_precomputed_kernel}")
from qiskit_machine_learning.algorithms import QSVC
qsvc = QSVC(quantum_kernel=adhoc_kernel)
qsvc.fit(train_features, train_labels)
qsvc_score = qsvc.score(test_features, test_labels)
print(f"QSVC classification test score: {qsvc_score}")
print(f"Classification Model | Accuracy Score")
print(f"---------------------------------------------------------")
print(f"SVC using kernel as a callable function | {adhoc_score_callable_function:10.2f}")
print(f"SVC using precomputed kernel matrix | {adhoc_score_precomputed_kernel:10.2f}")
print(f"QSVC | {qsvc_score:10.2f}")
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(
training_size=25,
test_size=0,
n=adhoc_dimension,
gap=0.6,
plot_data=False,
one_hot=False,
include_sample_total=True,
)
plt.figure(figsize=(5, 5))
plt.ylim(0, 2 * np.pi)
plt.xlim(0, 2 * np.pi)
plt.imshow(
np.asmatrix(adhoc_total).T,
interpolation="nearest",
origin="lower",
cmap="RdBu",
extent=[0, 2 * np.pi, 0, 2 * np.pi],
)
# A label plot
plot_features(plt, train_features, train_labels, 0, "s", "w", "b", "B")
# B label plot
plot_features(plt, train_features, train_labels, 1, "o", "w", "r", "B")
plt.legend(bbox_to_anchor=(1.05, 1), loc="upper left", borderaxespad=0.0)
plt.title("Ad hoc dataset for clustering")
plt.show()
adhoc_feature_map = ZZFeatureMap(feature_dimension=adhoc_dimension, reps=2, entanglement="linear")
adhoc_kernel = FidelityQuantumKernel(feature_map=adhoc_feature_map)
adhoc_matrix = adhoc_kernel.evaluate(x_vec=train_features)
plt.figure(figsize=(5, 5))
plt.imshow(np.asmatrix(adhoc_matrix), interpolation="nearest", origin="upper", cmap="Greens")
plt.title("Ad hoc clustering kernel matrix")
plt.show()
from sklearn.cluster import SpectralClustering
from sklearn.metrics import normalized_mutual_info_score
adhoc_spectral = SpectralClustering(2, affinity="precomputed")
cluster_labels = adhoc_spectral.fit_predict(adhoc_matrix)
cluster_score = normalized_mutual_info_score(cluster_labels, train_labels)
print(f"Clustering score: {cluster_score}")
adhoc_dimension = 2
train_features, train_labels, test_features, test_labels, adhoc_total = ad_hoc_data(
training_size=25,
test_size=10,
n=adhoc_dimension,
gap=0.6,
plot_data=False,
one_hot=False,
include_sample_total=True,
)
plot_dataset(train_features, train_labels, test_features, test_labels, adhoc_total)
feature_map = ZZFeatureMap(feature_dimension=2, reps=2, entanglement="linear")
qpca_kernel = FidelityQuantumKernel(fidelity=fidelity, feature_map=feature_map)
matrix_train = qpca_kernel.evaluate(x_vec=train_features)
matrix_test = qpca_kernel.evaluate(x_vec=test_features, y_vec=test_features)
from sklearn.decomposition import KernelPCA
kernel_pca_rbf = KernelPCA(n_components=2, kernel="rbf")
kernel_pca_rbf.fit(train_features)
train_features_rbf = kernel_pca_rbf.transform(train_features)
test_features_rbf = kernel_pca_rbf.transform(test_features)
kernel_pca_q = KernelPCA(n_components=2, kernel="precomputed")
train_features_q = kernel_pca_q.fit_transform(matrix_train)
test_features_q = kernel_pca_q.fit_transform(matrix_test)
from sklearn.linear_model import LogisticRegression
logistic_regression = LogisticRegression()
logistic_regression.fit(train_features_q, train_labels)
logistic_score = logistic_regression.score(test_features_q, test_labels)
print(f"Logistic regression score: {logistic_score}")
fig, (q_ax, rbf_ax) = plt.subplots(1, 2, figsize=(10, 5))
plot_features(q_ax, train_features_q, train_labels, 0, "s", "w", "b", "A train")
plot_features(q_ax, train_features_q, train_labels, 1, "o", "w", "r", "B train")
plot_features(q_ax, test_features_q, test_labels, 0, "s", "b", "w", "A test")
plot_features(q_ax, test_features_q, test_labels, 1, "o", "r", "w", "A test")
q_ax.set_ylabel("Principal component #1")
q_ax.set_xlabel("Principal component #0")
q_ax.set_title("Projection of training and test data\n using KPCA with Quantum Kernel")
# Plotting the linear separation
h = 0.01 # step size in the mesh
# create a mesh to plot in
x_min, x_max = train_features_q[:, 0].min() - 1, train_features_q[:, 0].max() + 1
y_min, y_max = train_features_q[:, 1].min() - 1, train_features_q[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))
predictions = logistic_regression.predict(np.c_[xx.ravel(), yy.ravel()])
# Put the result into a color plot
predictions = predictions.reshape(xx.shape)
q_ax.contourf(xx, yy, predictions, cmap=plt.cm.RdBu, alpha=0.2)
plot_features(rbf_ax, train_features_rbf, train_labels, 0, "s", "w", "b", "A train")
plot_features(rbf_ax, train_features_rbf, train_labels, 1, "o", "w", "r", "B train")
plot_features(rbf_ax, test_features_rbf, test_labels, 0, "s", "b", "w", "A test")
plot_features(rbf_ax, test_features_rbf, test_labels, 1, "o", "r", "w", "A test")
rbf_ax.set_ylabel("Principal component #1")
rbf_ax.set_xlabel("Principal component #0")
rbf_ax.set_title("Projection of training data\n using KernelPCA")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/Qottmann/Quantum-anomaly-detection
|
Qottmann
|
import time
import itertools
import random
import numpy as np
from scipy.optimize import minimize, basinhopping
from qiskit import *
from qiskit.quantum_info import Statevector
from qiskit.algorithms.optimizers import COBYLA, L_BFGS_B, SPSA
import matplotlib.pyplot as plt
from matplotlib.ticker import MaxNLocator
from matplotlib.colors import BoundaryNorm
from modules.utils import Mag
%matplotlib inline
cmap = plt.get_cmap("plasma") #'viridis'
# from: https://tenpy.readthedocs.io/en/latest/toycodes/tfi_exact.html
import numpy as np
import scipy.sparse as sparse
import scipy.sparse.linalg.eigen.arpack as arp
import warnings
import scipy.integrate
def ising_groundstate(L, J, gx, gz=0): # gx is transverse field, gz the longitudinal
"""For comparison: obtain ground state energy from exact diagonalization.
Exponentially expensive in L, only works for small enough `L` <~ 20.
"""
if L >= 20:
warnings.warn("Large L: Exact diagonalization might take a long time!")
# get single site operaors
sx = sparse.csr_matrix(np.array([[0., 1.], [1., 0.]]))
sz = sparse.csr_matrix(np.array([[1., 0.], [0., -1.]]))
id = sparse.csr_matrix(np.eye(2))
sx_list = [] # sx_list[i] = kron([id, id, ..., id, sx, id, .... id])
sz_list = []
for i_site in range(L):
x_ops = [id] * L
z_ops = [id] * L
x_ops[i_site] = sx
z_ops[i_site] = sz
X = x_ops[0]
Z = z_ops[0]
for j in range(1, L):
X = sparse.kron(X, x_ops[j], 'csr')
Z = sparse.kron(Z, z_ops[j], 'csr')
sx_list.append(X)
sz_list.append(Z)
H_zz = sparse.csr_matrix((2**L, 2**L))
H_z = sparse.csr_matrix((2**L, 2**L))
H_x = sparse.csr_matrix((2**L, 2**L))
for i in range(L - 1):
H_zz = H_zz + sz_list[i] * sz_list[(i + 1) % L]
for i in range(L):
H_z = H_z + sz_list[i]
H_x = H_x + sx_list[i]
H = -J * H_zz - gx * H_x - gz * H_z
E, V = arp.eigsh(H, k=1, which='SA', return_eigenvectors=True, ncv=20)
return V[:,0], E[0]
init_state, E = ising_groundstate(6, 1., 1., 1.)
# Use Aer's qasm_simulator
backend_sim = Aer.get_backend('qasm_simulator')
L = 6 # system size
thetas = np.random.uniform(0, 2*np.pi, 2*L+2) # initial parameters without feature encoding
# thetas = np.random.uniform(0, 2*np.pi, (2*L+2, 2)) # initial parameters with feature encoding
def prepare_circuit(init_state=None, measurement=True):
qreg = QuantumRegister(L, 'q')
creg = ClassicalRegister(2, 'c')
circ = QuantumCircuit(qreg, creg)
entangler_map1 = [(5, 4), (5, 3), (5, 1), (4, 2), (4, 0)]
entangler_map2 = [(5, 4), (5, 2), (4, 3), (5, 0), (4, 1)]
circ += circuit.library.TwoLocal(L, 'ry', 'cz', entanglement = [entangler_map1, entangler_map2], reps=2, insert_barriers=True, skip_final_rotation_layer=True)
circ.ry(circuit.Parameter('θ1'), 4)
circ.ry(circuit.Parameter('θ2'), 5)
if measurement:
circ.measure(qreg[4], creg[0])
circ.measure(qreg[5], creg[1])
if init_state is not None: circ.initialize(init_state, qreg)
return circ
# same circuit as above (more explicit)
def prepare_circuit2(thetas, init_state=None, measurement=True):
qreg = QuantumRegister(L, 'q')
creg = ClassicalRegister(2, 'c')
circ = QuantumCircuit(qreg, creg)
if init_state is not None: circ.initialize(init_state, qreg)
for i,t in enumerate(thetas[2:(L+2)]):
# for i,t in enumerate(thetas[0:L]):
circ.ry(t, i)
circ.cz(5,4)
circ.cz(5,3)
circ.cz(5,1)
circ.cz(4,2)
circ.cz(4,0)
circ.barrier()
for i,t in enumerate(thetas[(L+2):]):
# for i,t in enumerate(thetas[L:2*L]):
circ.ry(t, i)
circ.cz(5,4)
circ.cz(5,2)
circ.cz(4,3)
circ.cz(5,0)
circ.cz(4,1)
circ.barrier()
# circ.ry(thetas[2*L], 4)
# circ.ry(thetas[2*L+1], 5)
circ.ry(thetas[0], 4)
circ.ry(thetas[1], 5)
circ.barrier()
if measurement:
circ.measure(qreg[4], creg[0])
circ.measure(qreg[5], creg[1])
return circ
def feature_encoding(thetas, x):
""" thetas: parameters to be optimized, x: Ising model parameter (eg. field) """
new_thetas = []
thetas = thetas.reshape((-1,2))
for theta in thetas:
new_thetas.append(theta[0] * x + theta[1])
return new_thetas
circ = prepare_circuit()
circ.draw('mpl') # trash qubits are at the bottom
circ = prepare_circuit2(thetas)
# circ = prepare_circuit(feature_encoding(thetas, .6))
circ.draw('mpl') # identical to above
np.random.seed(123)
def run_circuit(thetas, init_state, shots=100000):
circ = prepare_circuit2(thetas, init_state)
# Execute the circuit on the qasm simulator.
job_sim = execute(circ, backend_sim, shots=shots)#, seed_simulator=123, seed_transpiler=234)#, memory=True)
# Grab the results from the job
result_sim = job_sim.result()
counts = result_sim.get_counts(circ)
# print(counts)
# mems = result_sim.get_memory(circ)
# print(mems)
return counts
# run_circuit(thetas, init_state)['11']
init_state, E = ising_groundstate(6, 1., 1.6)
run_circuit(thetas, init_state)
def encoder_evolv(thetas, J, gx, gz, param_encoding=False, x=0):
""" full quantum state evolution with encoder part of circuit """
if param_encoding: thetas = feature_encoding(thetas, x)
circ = prepare_circuit2(thetas, measurement=False)
init_state, _ = ising_groundstate(L, J, g, gx)
state = Statevector(init_state)
state = state.evolve(circ)
traced_state = qiskit.quantum_info.partial_trace(state,range(0,4))
return traced_state
def encoder_decoder_evolv(thetas, J, gx, gz, param_encoding=False, x=0):
""" full quantum state evolution with encoder & decoder part of circuit """
if param_encoding: thetas = feature_encoding(thetas, x)
circ = prepare_circuit2(thetas, measurement=False)
circ_dagger = circ.inverse()
# encoder part
init_state, _ = ising_groundstate(L, J, gx, gz)
state = Statevector(init_state)
state = state.evolve(circ)
traced_state = qiskit.quantum_info.partial_trace(state,[4,5])
# decoder part
ancilla = np.zeros(4)
ancilla[0] = 1
ancilla = qiskit.quantum_info.DensityMatrix(ancilla)
new_state = traced_state.expand(ancilla)
final_state = new_state.evolve(circ_dagger)
fid = qiskit.quantum_info.state_fidelity(Statevector(init_state), final_state)
return final_state, init_state, fid
# old version
init_state, E = ising_groundstate(6, 1., 0.0)
circ.initialize(init_state, range(L))
# new_thetas = feature_encoding(thetas, g) # comment out when running w/o feature encoding
new_thetas = thetas
t_qc = transpile(circ, backend=backend_sim, seed_transpiler=234)
qobj = compiler.assemble(t_qc.bind_parameters(new_thetas), backend=backend_sim, seed_simulator=123, shots=100000)
result = backend_sim.run(qobj).result()
out = result.get_counts()
out
#reset random seed
np.random.seed(123)
random.seed(123)
def cost_function_single(thetas, J, gx, gz, shots=1000, param_encoding=False, x=0):
""" Optimizes circuit """
init_state, _ = ising_groundstate(L, J, gx, gz)
if param_encoding: thetas = feature_encoding(thetas, x)
out = run_circuit(thetas, init_state, shots=shots)
cost = out.get('11', 0)*2 + out.get('01', 0) + out.get('10', 0)
return cost/shots
def cost_function(thetas, ising_params, shots=1000, param_encoding=False, x=0):
""" Optimizes circuit """
cost = 0.
n_samples = len(ising_params)
for i, p in enumerate(ising_params):
J, gx, gz = p
if param_encoding:
cost += cost_function_single(thetas, J, gx, gz, shots, param_encoding, x[i])
else:
cost += cost_function_single(thetas, J, gx, gz, shots, param_encoding)
return cost/n_samples
def optimize(ising_params, thetas=None, shots=1000, max_iter=400, param_encoding=False, x=0):
np.random.seed(123)
if thetas is None:
n_params = (2*L+2)*2 if param_encoding else (2*L+2)
thetas = np.random.uniform(0, 2*np.pi, n_params) # initial parameters without feature encoding
print("Initial cost: {:.3f}".format(cost_function(thetas, ising_params, shots, param_encoding, x)))
print(thetas)
counts, values, accepted = [], [], []
def store_intermediate_result(eval_count, parameters, mean, std, ac):
# counts.append(eval_count)
values.append(mean)
accepted.append(ac)
# Initialize optimizer
# optimizer = COBYLA(maxiter=max_iter, tol=0.0001)
# optimizer = L_BFGS_B(maxfun=300, maxiter=max_iter)#, factr=10, iprint=- 1, epsilon=1e-08)
optimizer = SPSA(maxiter=max_iter,
#blocking=True,
callback=store_intermediate_result,
#learning_rate=1e-1,
#perturbation=0.4
) # recommended from qiskit (first iteraction takes quite long)
# to reduce time figure out optimal learning rate and perturbation in advance
start_time = time.time()
ret = optimizer.optimize(
num_vars=len(thetas),
objective_function=(lambda thetas: cost_function(thetas, ising_params, shots, param_encoding, x)),
initial_point=thetas
)
print("Time: {:.5f} sec".format(time.time()-start_time))
print(ret)
return ret[0], values, accepted
params = [(-1.0, 0.1, 0.1)]
thetas, loss, accepted = optimize(params, max_iter=40)
params = [(-1.0, 0.1, 0.1)]
thetas, loss, accepted = optimize(params, max_iter=40)
fig = plt.figure(figsize=(12,4))
plt.subplot(1, 2, 1)
plt.plot(loss, "x--")
# plt.yscale("log")
plt.xlabel("step")
plt.ylabel("Loss")
plt.subplot(1, 2, 2)
plt.plot(accepted, "x--")
plt.xlabel("step")
plt.ylabel("Accepted");
Js = [-1]*2
gxs = [0.1,10]
gzs = [10,0.1]
params = list(zip(Js, gxs, gzs))
thetas, loss, accepted = optimize(params)
thetas_normal_phase = thetas
thetas = thetas_normal_phase
fig = plt.figure(figsize=(12,4))
plt.subplot(1, 2, 1)
plt.plot(loss, "x--")
plt.yscale("log")
plt.xlabel("step")
plt.ylabel("Loss");
points = 50
J = -1.0
gxs = np.logspace(-2, 2, points)
gzs = np.logspace(-2, 2, points)
x,y = np.meshgrid(gxs,gzs)
cost = np.zeros((points,points))
Smags = np.zeros((points,points))
shots = 1000
for i,gx in enumerate(gxs):
for j,gz in enumerate(gzs):
cost[i,j] = cost_function_single(thetas, J, gx, gz, shots=shots)
init_state, _ = ising_groundstate(5, J, gx, gz)
Smags[i,j] = init_state.T.conj()@Mag(5,-1)@init_state
fig,axs = plt.subplots(figsize=(8,5),squeeze=False)
nbins=100
ax = axs[0,0]
levels = MaxNLocator(nbins=nbins).tick_values(cost.min(),cost.max())
norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
im = ax.pcolormesh(x, y, cost, cmap=cmap, norm=norm)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Loss",fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
fig,axs = plt.subplots(figsize=(8,5),squeeze=False)
nbins=100
ax = axs[0,0]
levels = MaxNLocator(nbins=nbins).tick_values(Smags.min(),Smags.max())
norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
im = ax.pcolormesh(x, y, Smags, cmap=cmap, norm=norm)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Staggered magnetization",fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
J = -1
gxs = np.logspace(-2, 2, 50)
gz = .01
cost1, Smags1, Smags12 = [], [], []
shots = 10000
Ll = 5
for gx in gxs:
cost1.append(cost_function_single(thetas, J, gx, gz, shots=shots))
init_state, _ = ising_groundstate(Ll, J, gx, gz)
Smags1.append(np.real(init_state.T.conj()@Mag(Ll,-1)@init_state))
init_state, _ = ising_groundstate(Ll+2, J, gx, gz)
Smags12.append(np.real(init_state.T.conj()@Mag(Ll+2,-1)@init_state))
gzs = np.logspace(-2, 2, 50)
gx = .01
cost2, Smags2, Smags22 = [], [], []
for gz in gzs:
cost2.append(cost_function_single(thetas, J, gx, gz, shots=shots))
init_state, _ = ising_groundstate(Ll, J, gx, gz)
Smags2.append(np.real(init_state.T.conj()@Mag(Ll,-1)@init_state))
init_state, _ = ising_groundstate(Ll+2, J, gx, gz)
Smags22.append(np.real(init_state.T.conj()@Mag(Ll+2,-1)@init_state))
fig = plt.figure(figsize=(12,4))
ax1 = plt.subplot(121)
ax2 = ax1.twinx()
ax3 = plt.subplot(122)
ax4 = ax3.twinx()
ax1.set_xlabel(r"$g_z$")
ax1.set_ylabel("Cost")
ax1.plot(gzs, cost1, "x--")
ax2.plot(gzs, Smags1, "g-.")
ax2.plot(gzs, Smags12, "r--")
ax2.set_ylabel("Staggered mag.")
ax2.set_xscale("log")
ax3.set_xlabel(r"$g_x$")
ax3.set_ylabel("Cost")
ax3.plot(gzs, cost2, "x--")
ax4.plot(gzs, Smags2, "g-.")
ax4.plot(gzs, Smags22, "r--")
ax4.set_xscale("log")
ax4.set_ylabel("Staggered mag.")
fig.tight_layout()
fig = plt.figure(figsize=(15,4))
plt.subplot(1, 3, 1)
J, g, gx = -1., .1, 10.
traced_state = encoder_evolv(thetas, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
plt.subplot(1, 3, 2)
J, g, gx = -1., 10., .1
traced_state = encoder_evolv(thetas, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
plt.subplot(1, 3, 3)
J, g, gx = -1., .1, .1
traced_state = encoder_evolv(thetas, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
# upper left corner corresponds to |00><00|, the first two images are the ones for which circuit was optimized
points = 50
J = 1.0
gxs = np.logspace(-2, 2, points)
gzs = np.logspace(-2, 2, points)
x,y = np.meshgrid(gxs,gzs)
cost = np.zeros((points,points))
shots = 1000
for i,gx in enumerate(gxs):
for j,gz in enumerate(gzs):
cost[i,j] = cost_function_single(thetas, J, gx, gz, shots=shots)
fig,axs = plt.subplots(figsize=(8,5),squeeze=False)
nbins=100
ax = axs[0,0]
levels = MaxNLocator(nbins=nbins).tick_values(cost.min(),cost.max())
norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
im = ax.pcolormesh(x, y, cost, cmap=cmap, norm=norm)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Loss",fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
np.random.seed(123)
thetas_random = np.random.uniform(0, 2*np.pi, 2*L+2) # initial parameters without feature encoding
points = 50
J = -1.0
gxs = np.logspace(-2, 2, points)
gzs = np.logspace(-2, 2, points)
x,y = np.meshgrid(gxs,gzs)
cost = np.zeros((points,points))
shots = 1000
for i,gx in enumerate(gxs):
for j,gz in enumerate(gzs):
cost[i,j] = cost_function_single(thetas_random, J, gx, gz, shots=shots)
fig,axs = plt.subplots(figsize=(8,5),squeeze=False)
nbins=100
ax = axs[0,0]
levels = MaxNLocator(nbins=nbins).tick_values(cost.min(),cost.max())
norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
im = ax.pcolormesh(x, y, cost, cmap=cmap, norm=norm)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Loss",fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
params = [(-1.0, 0.1, 0.1)]
thetas, loss, accepted = optimize(params)
thetas_ordered_phase = thetas
thetas = thetas_ordered_phase
fig = plt.figure(figsize=(12,4))
plt.subplot(1, 2, 1)
plt.plot(loss, "x--")
plt.yscale("log")
plt.xlabel("step")
plt.ylabel("Loss");
points = 50
J = -1.0
gxs = np.logspace(-2, 2, points)
gzs = np.logspace(-2, 2, points)
x,y = np.meshgrid(gxs,gzs)
cost = np.zeros((points,points))
Smags = np.zeros((points,points))
shots = 1000
for i,gx in enumerate(gxs):
for j,gz in enumerate(gzs):
cost[i,j] = cost_function_single(thetas, J, gx, gz, shots=shots)
init_state, _ = ising_groundstate(5, J, gx, gz)
Smags[i,j] = init_state.T.conj()@Mag(5,-1)@init_state
fig,axs = plt.subplots(figsize=(8,5),squeeze=False)
nbins=100
ax = axs[0,0]
levels = MaxNLocator(nbins=nbins).tick_values(cost.min(),cost.max())
norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
im = ax.pcolormesh(x, y, cost, cmap=cmap, norm=norm)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Loss",fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
fig,axs = plt.subplots(figsize=(8,5),squeeze=False)
nbins=100
ax = axs[0,0]
levels = MaxNLocator(nbins=nbins).tick_values(Smags.min(),Smags.max())
norm = BoundaryNorm(levels, ncolors=cmap.N, clip=True)
im = ax.pcolormesh(x, y, Smags, cmap=cmap, norm=norm)
cbar = fig.colorbar(im, ax=ax)
cbar.ax.tick_params(labelsize=20)
plt.xscale("log")
plt.yscale("log")
ax.set_title("Staggered magnetization",fontsize=20)
ax.set_xlabel(r"$g_z$",fontsize=24)
ax.set_ylabel(r"$g_x$",fontsize=24)
ax.tick_params(labelsize=20)
J = -1
gxs = np.logspace(-2, 2, 50)
gz = .01
cost1, Smags1, Smags12 = [], [], []
shots = 10000
Ll = 5
for gx in gxs:
cost1.append(cost_function_single(thetas, J, gx, gz, shots=shots))
init_state, _ = ising_groundstate(Ll, J, gx, gz)
Smags1.append(np.real(init_state.T.conj()@Mag(Ll,-1)@init_state))
init_state, _ = ising_groundstate(Ll+2, J, gx, gz)
Smags12.append(np.real(init_state.T.conj()@Mag(Ll+2,-1)@init_state))
gzs = np.logspace(-2, 2, 50)
gx = .01
cost2, Smags2, Smags22 = [], [], []
for gz in gzs:
cost2.append(cost_function_single(thetas, J, gx, gz, shots=shots))
init_state, _ = ising_groundstate(Ll, J, gx, gz)
Smags2.append(np.real(init_state.T.conj()@Mag(Ll,-1)@init_state))
init_state, _ = ising_groundstate(Ll+2, J, gx, gz)
Smags22.append(np.real(init_state.T.conj()@Mag(Ll+2,-1)@init_state))
Js = np.linspace(-10, 10, 50)
gx = 0.1
gz = 0.1
cost3, Smags3, Smags32 = [], [], []
for J in Js:
cost3.append(cost_function_single(thetas, J, gx, gz, shots=shots))
init_state, _ = ising_groundstate(Ll, J, gx, gz)
Smags3.append(np.real(init_state.T.conj()@Mag(Ll,-1)@init_state))
init_state, _ = ising_groundstate(Ll+2, J, gx, gz)
Smags32.append(np.real(init_state.T.conj()@Mag(Ll+2,-1)@init_state))
fig = plt.figure(figsize=(18,4))
ax1 = plt.subplot(131)
ax2 = ax1.twinx()
ax3 = plt.subplot(132)
ax4 = ax3.twinx()
ax5 = plt.subplot(133)
ax6 = ax5.twinx()
ax1.set_xlabel(r"$g_z$")
ax1.set_ylabel("Cost")
ax1.plot(gzs, cost1, "x--")
ax2.plot(gzs, Smags1, "g-.")
ax2.plot(gzs, Smags12, "r--")
ax2.set_ylabel("Staggered mag.")
ax2.set_xscale("log")
ax3.set_xlabel(r"$g_x$")
ax3.set_ylabel("Cost")
ax3.plot(gzs, cost2, "x--")
ax4.plot(gzs, Smags2, "g-.")
ax4.plot(gzs, Smags22, "r--")
ax4.set_xscale("log")
ax4.set_ylabel("Staggered mag.")
ax5.set_xlabel(r"$J$")
ax5.set_ylabel("Cost")
ax5.plot(Js, cost3, "x--")
ax6.plot(Js, Smags3, "g-.")
ax6.plot(Js, Smags32, "r--")
ax6.set_ylabel("Staggered mag.")
fig.tight_layout();
fig = plt.figure(figsize=(15,4))
plt.subplot(1, 3, 1)
J, g, gx = -1., .1, .1
traced_state = encoder_evolv(thetas, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
plt.subplot(1, 3, 2)
J, g, gx = -1., 2., 2.
traced_state = encoder_evolv(thetas, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
plt.subplot(1, 3, 3)
J, g, gx = 1., .1, .1
traced_state = encoder_evolv(thetas, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
# upper left corner corresponds to |00><00|, the first image is the one for which circuit was optimized
J, gx, gz = -1., .1, .1
gzs = np.logspace(-2, 2, 50)
fid1 = []
for gz in gzs:
fid1.append(encoder_decoder_evolv(thetas, J, gx, gz)[2])
J, gx, gz = -1., .1, .1
gxs = np.logspace(-2, 2, 50)
fid2 = []
for gx in gxs:
fid2.append(encoder_decoder_evolv(thetas, J, gx, gz)[2])
J, gx, gz = -1., .1, .1
Js = np.linspace(-10, 10, 50)
fid3 = []
for J in Js:
fid3.append(encoder_decoder_evolv(thetas, J, gx, gz)[2])
fig = plt.figure(figsize=(18,4))
ax1 = plt.subplot(131)
ax2 = ax1.twinx()
ax3 = plt.subplot(132)
ax4 = ax3.twinx()
ax5 = plt.subplot(133)
ax6 = ax5.twinx()
ax1.set_xlabel(r"$g_z$")
ax1.set_ylabel("Fidelity")
ax1.plot(gzs, fid1, "x--")
ax2.plot(gzs, Smags2, "g-.")
ax2.plot(gzs, Smags22, "r--")
ax2.set_ylabel("Staggered mag.")
ax2.set_xscale("log")
ax3.set_xlabel(r"$g_x$")
ax3.set_ylabel("Fidelity")
ax3.plot(gzs, fid2, "x--")
ax4.plot(gzs, Smags1, "g-.")
ax4.plot(gzs, Smags12, "r--")
ax4.set_xscale("log")
ax4.set_ylabel("Staggered mag.")
ax5.set_xlabel(r"$J$")
ax5.set_ylabel("Fidelity")
ax5.plot(Js, fid3, "x--")
ax6.plot(Js, Smags3, "g-.")
ax6.plot(Js, Smags32, "r--")
ax6.set_ylabel("Staggered mag.")
fig.tight_layout();
fig = plt.figure(figsize=(18,4))
plt.subplot(1, 3, 1)
plt.plot(gzs, fid1, "x--")
plt.xscale("log")
plt.xlabel(r"$g_z$")
plt.ylabel("Fidelity");
plt.subplot(1, 3, 2)
plt.plot(gxs, fid2, "x--")
plt.xscale("log")
plt.xlabel(r"$g_x$")
plt.ylabel("Fidelity");
plt.subplot(1, 3, 3)
plt.plot(gxs, fid3, "x--")
plt.xscale("log")
plt.xlabel(r"$g_x$")
plt.ylabel("Fidelity");
# with feature encoding
Js = [1.0]
gxs = np.linspace(0.1, 0.6, 10)
gzs = [0.01]
a = [Js, gxs, gzs]
params = list(itertools.product(*a))
thetas, loss, accepted = optimize(params, max_iter=1000, param_encoding=True, x=gxs)
thetas2 = thetas
# without feature encoding
Js = [1.0]
gxs = np.linspace(0.1, 0.6, 10)
gzs = [0.01]
a = [Js, gxs, gzs]
params = list(itertools.product(*a))
thetas, loss2, accepted = optimize(params, max_iter=200, param_encoding=False)
thetas3 = thetas
fig = plt.figure(figsize=(12,4))
plt.subplot(1, 2, 1)
plt.plot(loss, "x--")
plt.plot(loss2, "o-.")
plt.yscale("log")
plt.xlabel("step")
plt.ylabel("Loss")
J = 1.
gxs = np.linspace(0.01, 1.2, 50)
gz = .01
cost1, cost2 = [], []
shots = 10000
param_encoding=False
for gx in gxs:
cost1.append(cost_function_single(thetas2, J, gx, gz, shots=shots, param_encoding=True, x=gx))
cost2.append(cost_function_single(thetas3, J, gx, gz, shots=shots, param_encoding=False, x=gx))
fig = plt.figure(figsize=(18,4))
plt.subplot(1, 3, 1)
plt.plot(gxs, cost1, "x--")
plt.plot(gxs, cost2, "o-.")
# plt.xscale("log")
plt.vlines(0.6, 0, 1.2, colors="tab:gray", linestyles='dotted')
plt.vlines(0.1, 0, 1.2, colors="tab:gray", linestyles='dotted')
plt.xlabel(r"$g_x$")
plt.ylabel("Cost")
fig = plt.figure(figsize=(10,10))
plt.subplot(2, 2, 1)
J, g, gx = 1., .6, .01
traced_state = encoder_evolv(thetas2, J, gx, gz, param_encoding=True, x=gx)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
plt.subplot(2, 2, 2)
J, g, gx = 1., .6, .01
traced_state = encoder_evolv(thetas3, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
plt.subplot(2, 2, 3)
J, g, gx = 1., .75, .01
traced_state = encoder_evolv(thetas2, J, gx, gz, param_encoding=True, x=gx)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
plt.subplot(2, 2, 4)
J, g, gx = 1., .75, .01
traced_state = encoder_evolv(thetas3, J, gx, gz)
plt.imshow(np.real(traced_state.data), cmap='RdBu', vmin=-1.0, vmax=1.0, interpolation='none')
plt.colorbar()
plt.axis('off');
# same as Fig. 5
|
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/cjsproject/qiskit_learning
|
cjsproject
|
import numpy as np
from matplotlib.image import imread
import matplotlib.pyplot as plt
import torch
from torchvision import transforms
from torchvision.datasets import MNIST
# the data is not normalized, and needs to be converted to a np array...
digits = MNIST('data', train=True, download=False)
# converting to np array and normalizing by val/max(arr)
digits = digits.data.numpy()
digits = digits/np.max(digits)
#displaying image
display = plt.imshow(digits[0])
display.set_cmap('gray')
print(digits[0].shape)
# grab 4x4 squares of the image
im1 = digits[0]
stride = 1
mat_sq = np.zeros([28,28,4,4])
for i in range(0, len(im1)-4, stride):
for j in range(0, len(im1[i])-4, stride):
cube = im1[i:i+4, j:j+4]
mat_sq[i, j] = cube
# creates a 2d collection of matrices, where each [i, j] index contains a 4x4 matrix
print(mat_sq[14, 14])
display = plt.imshow(mat_sq[14, 14])
display.set_cmap('gray')
# find SVD of each submatrix, make unitary and assign to uni
uni = np.zeros([28,28,4,4])
for i in range(len(mat_sq)):
for j in range(len(mat_sq[i])):
U, S, VT = np.linalg.svd(mat_sq[i, j])
uni[i, j] = np.dot(U, VT)
#print(f"U =\n{U}\n S =\n{S}\n VT=\n{VT}\n")
test = uni[14,14]
# comparing unitary, they aren't the same :(
print(f"U*VT:\n{uni[14, 14]}\nOriginal:\n{mat_sq[14, 14]}")
# try graham schmidt, they're just about the same!
# seems to have detected an edge.
Q, R = np.linalg.qr(mat_sq[14, 14])
print(f"Q:\n{Q}\nOriginal:\n{mat_sq[14, 14]}\nIs Q Unitary:\n{np.matmul(Q, Q.transpose(0, 1)).round()}")
display = plt.imshow(Q)
display.set_cmap('gray')
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Non-string identifiers for circuit and record identifiers test"""
import unittest
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.circuit.exceptions import CircuitError
from qiskit.test import QiskitTestCase
class TestAnonymousIds(QiskitTestCase):
"""Test the anonymous use of registers."""
def test_create_anonymous_classical_register(self):
"""ClassicalRegister with no name."""
cr = ClassicalRegister(size=3)
self.assertIsInstance(cr, ClassicalRegister)
def test_create_anonymous_quantum_register(self):
"""QuantumRegister with no name."""
qr = QuantumRegister(size=3)
self.assertIsInstance(qr, QuantumRegister)
def test_create_anonymous_classical_registers(self):
"""Several ClassicalRegister with no name."""
cr1 = ClassicalRegister(size=3)
cr2 = ClassicalRegister(size=3)
self.assertNotEqual(cr1.name, cr2.name)
def test_create_anonymous_quantum_registers(self):
"""Several QuantumRegister with no name."""
qr1 = QuantumRegister(size=3)
qr2 = QuantumRegister(size=3)
self.assertNotEqual(qr1.name, qr2.name)
def test_create_anonymous_mixed_registers(self):
"""Several Registers with no name."""
cr0 = ClassicalRegister(size=3)
qr0 = QuantumRegister(size=3)
# Get the current index count of the registers
cr_index = int(cr0.name[1:])
qr_index = int(qr0.name[1:])
cr1 = ClassicalRegister(size=3)
_ = QuantumRegister(size=3)
qr2 = QuantumRegister(size=3)
# Check that the counters for each kind are incremented separately.
cr_current = int(cr1.name[1:])
qr_current = int(qr2.name[1:])
self.assertEqual(cr_current, cr_index + 1)
self.assertEqual(qr_current, qr_index + 2)
def test_create_circuit_noname(self):
"""Create_circuit with no name."""
qr = QuantumRegister(size=3)
cr = ClassicalRegister(size=3)
qc = QuantumCircuit(qr, cr)
self.assertIsInstance(qc, QuantumCircuit)
class TestInvalidIds(QiskitTestCase):
"""Circuits and records with invalid IDs"""
def test_invalid_type_circuit_name(self):
"""QuantumCircuit() with invalid type name."""
qr = QuantumRegister(size=3)
cr = ClassicalRegister(size=3)
self.assertRaises(CircuitError, QuantumCircuit, qr, cr, name=1)
if __name__ == "__main__":
unittest.main(verbosity=2)
|
https://github.com/usamisaori/Grover
|
usamisaori
|
import qiskit
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.quantum_info import Operator
import numpy as np
from qiskit import execute, Aer
simulator = Aer.get_backend('qasm_simulator')
import matplotlib.pyplot as plt
import warnings
warnings.filterwarnings('ignore')
# https://towardsdatascience.com/behind-oracles-grovers-algorithm-amplitude-amplification-46b928b46f1e
def createSATInitCircuit(var, clause):
# input + workspace(clause) + checker(1)
circuit = QuantumCircuit(var + clause + 1, var)
for i in range(var):
circuit.h(i)
circuit.barrier()
return circuit
SATInitCircuit = createSATInitCircuit(4, 3)
SATInitCircuit.draw(output='mpl')
def createSATOracle(var, clause):
circuit = QuantumCircuit(var + clause + 1, var)
# (a ∧ b ∧ ¬c)
circuit.x(2)
circuit.mcx([0, 1, 2], 4)
circuit.x(2)
circuit.barrier()
# (¬b ∧d )
circuit.x(1)
circuit.mcx([1, 3], 5)
circuit.x(1)
circuit.barrier()
# ¬d
circuit.x(3)
circuit.cx(3, 6)
circuit.x(3)
circuit.barrier()
# (a ∧ b ∧ ¬c) ∨ ¬(¬b ∧d ) ∨ ¬d
circuit.x(5)
circuit.mcx([4, 5, 6], 7)
circuit.x(5)
circuit.barrier()
# uncomputation
# ¬d
circuit.x(3)
circuit.cx(3, 6)
circuit.x(3)
circuit.barrier()
# (¬b ∧d )
circuit.x(1)
circuit.mcx([1, 3], 5)
circuit.x(1)
circuit.barrier()
# (a ∧ b ∧ ¬c)
circuit.x(2)
circuit.mcx([0, 1, 2], 4)
circuit.x(2)
circuit.barrier()
return circuit
SATOracleCircuit = createSATOracle(4, 3)
SATOracleCircuit.draw(output='mpl')
def createSATDiffuser(var, clause):
circuit = QuantumCircuit(var + clause + 1, var)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
circuit.x(0)
circuit.x(1)
circuit.x(2)
circuit.x(3)
circuit.mcx([0, 1, 2, 3], var + clause)
circuit.x(0)
circuit.x(1)
circuit.x(2)
circuit.x(3)
circuit.h(0)
circuit.h(1)
circuit.h(2)
circuit.h(3)
return circuit
SATDiffuserCircuit = createSATDiffuser(4, 3)
SATDiffuserCircuit.draw(output='mpl')
SATCircuit = createSATInitCircuit(4, 3).compose(createSATOracle(4, 3)).compose(createSATDiffuser(4, 3))
SATCircuit.draw(output='mpl')
SATCircuit.measure([0, 1, 2, 3], [0, 1, 2, 3])
job = execute(SATCircuit, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(SATCircuit)
print(counts)
plot_histogram(counts, figsize=(12, 5), color="#CCCCFF", title="SAT - solving (a ∧ b ∧ ¬c) ∨ ¬(¬b ∧d ) ∨ ¬d, k = 1")
SATIteration = Operator(createSATOracle(4, 3).compose(createSATDiffuser(4, 3)))
SATCircuit2 = createSATInitCircuit(4, 3)
SATCircuit2.append(SATIteration, list(range(8)))
SATCircuit2.append(SATIteration, list(range(8)))
SATCircuit2.append(SATIteration, list(range(8)))
SATCircuit2.draw(output='mpl')
SATCircuit2.measure([0, 1, 2, 3], [0, 1, 2, 3])
job = execute(SATCircuit2, simulator, shots = 10000)
results = job.result()
counts = results.get_counts(SATCircuit2)
print(counts)
plot_histogram(counts, figsize=(12, 5), color="#6666FF", title="SAT - solving (a ∧ b ∧ ¬c) ∨ ¬(¬b ∧d ) ∨ ¬d, k = 3")
import math
math.degrees( math.asin(1 / 4))
for k in range(1, 5):
print(f'k = {k}: { math.sin(math.radians( (2 * k+1) * 14.47) ) ** 2 }')
|
https://github.com/alejomonbar/Quantum-Supply-Chain-Manager
|
alejomonbar
|
%load_ext autoreload
%autoreload 2
#pip install pennyane
#improt pennylane dependnecies
import pennylane as qml
from pennylane import numpy as np
from pennylane.optimize import NesterovMomentumOptimizer
# load the csv files
import pandas as pd
# plot the historical acc and cost
import matplotlib.pyplot as plt
import seaborn as sns
from IPython.display import clear_output
clear_output(wait=False)
import os
data_train = pd.read_csv("dataset/fair_train.csv")
X_train,y_train = data_train[data_train.columns[:16]].values, data_train[data_train.columns[16]].values
data_test = pd.read_csv("dataset/classic_test.csv")
X_test,y_test = data_test[data_test.columns[:16]].values, data_test[data_test.columns[16]].values
(X_train.shape, y_train.shape),(X_test.shape, y_test.shape)
n_wires = 4
dev = qml.device("default.qubit", wires=n_wires)
def block(weights, wires):
qml.CNOT(wires=[wires[0],wires[1]])
qml.RY(weights[0], wires=wires[0])
qml.RY(weights[1], wires=wires[1])
n_block_wires = 2
n_params_block = 2
n_blocks = qml.MERA.get_n_blocks(range(n_wires),n_block_wires)
n_blocks
@qml.qnode(dev)
def circuit(weights, x):
qml.AmplitudeEmbedding(x, wires=[0,1,2,3],normalize=True,pad_with=True)
for w in weights:
qml.MERA(range(n_wires),n_block_wires,block, n_params_block, w)
#print(w)
#print(x)
return qml.expval(qml.PauliZ(1))
def variational_classifier(weights, bias, x):
return circuit(weights, x) + bias
def square_loss(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
loss = loss + (l - p) ** 2
loss = loss / len(labels)
return loss
def accuracy(labels, predictions):
loss = 0
for l, p in zip(labels, predictions):
if abs(l - p) < 1e-5:
loss = loss + 1
loss = loss / len(labels)
return loss
def cost(weights, bias, X, Y):
#print(1)
predictions = [variational_classifier(weights, bias, x) for x in X]
return square_loss(Y, predictions)
np.random.seed(0)
num_layers = 2
weights_init = 2*np.pi * np.random.randn(num_layers,n_blocks, n_params_block, requires_grad=True)
bias_init = np.array(0.0, requires_grad=True)
print(weights_init, bias_init)
print(qml.draw(circuit,expansion_strategy='device',wire_order=[0,1,2,3])(weights_init,np.asarray(X_train[0])))
for i in weights_init:
print(i[0])
y_train = np.where(y_train < 1, -1, y_train)
y_test = np.where(y_test < 1, -1, y_test)
from sklearn.utils import shuffle
X,y = shuffle(X_train, y_train, random_state=0)
from sklearn.model_selection import train_test_split
opt = NesterovMomentumOptimizer(0.4)
batch_size = 32
num_data = len(y_train)
num_train = 0.9
# train the variational classifier
weights = weights_init
bias = bias_init
print()
cost_g = []
acc_train = []
acc_test = []
plt.show()
for it in range(50):
X_train_70, X_test_30, y_train_70, y_test_30 =train_test_split(np.asarray(X), np.asarray(y), train_size=num_train, test_size=1.0-num_train, shuffle=True)
# Update the weights by one optimizer step
batch_index = np.random.randint(0, len(X_train_70), (batch_size,))
feats_train_batch = X_train_70[batch_index]
Y_train_batch = y_train_70[batch_index]
weights, bias, _, _ = opt.step(cost, weights, bias, feats_train_batch, Y_train_batch)
# Compute predictions on train and validation set
predictions_train = [np.sign(variational_classifier(weights, bias, f)) for f in X_train_70]
predictions_val = [np.sign(variational_classifier(weights, bias, f)) for f in X_test_30]
# Compute accuracy on train and validation set
acc_tra = accuracy(y_train_70, predictions_train)
acc_val = accuracy(y_test_30, predictions_val)
cost_train = cost(weights, bias,X_train, y_train)
cost_g.append(cost_train)
acc_train.append(acc_tra)
acc_test.append(acc_val)
clear_output(wait=True)
plt.plot(cost_g,label='cost')
plt.plot(acc_train,label='acc_train')
plt.plot(acc_test,label='acc_test')
plt.legend(['cost','acc_train','acc_test'])
plt.show()
print(
"Iter: {:5d} | Cost: {:0.7f} | Acc train: {:0.7f} | Acc validation: {:0.7f} "
"".format(it + 1, cost_train, acc_tra, acc_val)
)
print(weights)
x_test = []
for x in X_test.tolist():
if sum(x) == 0:
x[0]=1
x_test.append( x/ np.linalg.norm(x))
x_test[0]
y_test_pred = [np.sign(variational_classifier(weights, bias, f)) for f in x_test]
y_test_pred
from sklearn.metrics import confusion_matrix, roc_curve, auc
from sklearn.preprocessing import StandardScaler
# demonstration of calculating metrics for a neural network model using sklearn
from sklearn.metrics import accuracy_score
from sklearn.metrics import precision_score
from sklearn.metrics import recall_score
from sklearn.metrics import f1_score
from sklearn.metrics import cohen_kappa_score
from sklearn.metrics import roc_auc_score
accuracy = accuracy_score(y_test, y_test_pred)
print('Accuracy: %f' % accuracy)
# precision tp / (tp + fp)
precision = precision_score(y_test, y_test_pred)
print('Precision: %f' % precision)
# recall: tp / (tp + fn)
recall = recall_score(y_test, y_test_pred)
print('Recall: %f' % recall)
# f1: 2 tp / (2 tp + fp + fn)
f1 = f1_score(y_test, y_test_pred)
print('F1 score: %f' % f1)
# kappa
kappa = cohen_kappa_score(y_test, y_test_pred)
print('Cohens kappa: %f' % kappa)
# ROC AUC
auc = roc_auc_score(y_test, y_test_pred)
print('ROC AUC: %f' % auc)
# confusion matrix
test_matrix = confusion_matrix(y_test, y_test_pred)
print(test_matrix)
ax = sns.heatmap(test_matrix, annot=True, cmap='Blues', fmt='g')
ax.set_title('Seaborn Confusion Matrix with labels\n\n');
ax.set_xlabel('\nPredicted Values')
ax.set_ylabel('Actual Values ');
ax.xaxis.set_ticklabels(['0','1'])
ax.yaxis.set_ticklabels(['0','1'])
## Display the visualization of the Confusion Matrix.
plt.show()
y_pred_1 = [int(i) for i in y_pred ]
y_pred_1 = ["{}\n".format(i) for i in y_pred_1]
with open(r'mera_2_layers.csv', 'w') as fp:
fp.writelines(y_pred_1)
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
# checking the version of PYTHON; only support > 3.5
import sys
if sys.version_info < (3,5):
raise Exception('Please use Python version 3.5 or greater.')
# importing QISKit
from qiskit import QuantumProgram
#import Qconfig
# import basic plotting tools
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.qcvv.tomography import marginal_counts
# create a QuantumProgram object instance.
q_program = QuantumProgram()
#q_program.set_api(Qconfig.APItoken, Qconfig.config["url"]) # set the APIToken and API url
# backend
#backend = 'ibmqx2'
backend = 'local_qasm_simulator'
# quantum plain addition algorithm for 1-qubit numbers
def addition_1bit(circuit, q):
circuit.h(q[2])
circuit.cx(q[1], q[2])
circuit.tdg(q[2])
circuit.cx(q[0], q[2])
circuit.t(q[2])
circuit.cx(q[1], q[2])
circuit.tdg(q[2])
circuit.cx(q[0], q[2])
circuit.t(q[2])
circuit.h(q[2])
circuit.t(q[1])
circuit.cx(q[0], q[1])
circuit.t(q[0])
circuit.tdg(q[1])
# n-qubit number input state
def number_state(circuit, q, a, b):
if a == 1:
circuit.x(q[0]) # q[0] contains the value of a
if b == 1:
circuit.x(q[1]) # q[1] contain the value of b
# we define the values (0 or 1)
a = 1
b = 1
# one single quantum register which contains 'a' (1 qubit) and 'b' (2 qubits)
q = q_program.create_quantum_register("q", 3) # 3 qubits
# clasical register
c = q_program.create_classical_register("cr", 2) # 2 bits
# quantum circuit involving the quantum register and the classical register
add1bit_circuit = q_program.create_circuit("add", [q] ,[c])
# create the state containing a and b
number_state(add1bit_circuit, q, a, b)
# addition
addition_1bit(add1bit_circuit, q)
# measurements to see the result, which has been written in b (q[1]q[2])
add1bit_circuit.measure(q[1], c[0])
add1bit_circuit.measure(q[2], c[1])
# compile and execute the quantum program in the backend
result = q_program.execute(["add"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=999999)
# show the results
print(result)
print(result.get_data("add"))
counts = marginal_counts(result.get_counts("add"), [0, 1])
plot_histogram(counts)
print("Backend:", backend)
print("Highest probability outcome: {}".format(int(max(counts, key = lambda x: counts[x]).replace(" ", ""), 2)))
# checking the version of PYTHON; only support > 3.5
import sys
if sys.version_info < (3,5):
raise Exception('Please use Python version 3.5 or greater.')
# importing QISKit
from qiskit import QuantumProgram
# import basic plotting tools
from qiskit.tools.visualization import plot_histogram
# create a QuantumProgram object instance.
q_program = QuantumProgram()
# backend
backend = 'local_qasm_simulator'
def carry(circuit, q0, q1, q2, q3):
"carry module"
circuit.ccx(q1, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q0, q2, q3)
def carry_inv(circuit, q0, q1, q2, q3):
"carry module but running backwards"
circuit.ccx(q0, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q1, q2, q3)
def summation(circuit, q0, q1, q2):
"summation module"
circuit.cx(q1, q2)
circuit.cx(q0, q2)
# quantum plain addition algorithm for n-qubit numbers
def addition_nbit(circuit, qa, qb, qcar, n):
if n == 1:
circuit.ccx(qa[0], qb[0], qb[1])
circuit.cx(qa[0], qb[0])
else:
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
for i in range(n-2):
carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])
carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])
circuit.cx(qa[n-1], qb[n-1])
for i in range(n-1, 1, -1):
summation(circuit, qcar[i-1], qa[i], qb[i])
carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])
summation(circuit, qcar[0], qa[1], qb[1])
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
# n-qubit number input state
def number_state(circuit, q, x, n):
# integer to binary
x = "{0:b}".format(x)
x = x.zfill(n)
# creating the state
for i in range(n):
if int(x[n-1-i]) == 1:
circuit.x(q[i])
# we define the values
a = 9
b = 14
# computing the number of qubits n needed
n = len("{0:b}".format(a))
n2 = len("{0:b}".format(b))
if n2 > n:
n = n2
# classical register with n+1 bits.
c = q_program.create_classical_register("cr", n+1)
# quantum registers
qa = q_program.create_quantum_register("qa", n) # a qubits
qb = q_program.create_quantum_register("qb", n+1) # b qubits
# if n = 1, no need of carry register
if n == 1:
qcar = 0
# quantum circuit involving the quantum registers and the classical register
addnbit_circuit = q_program.create_circuit("add", [qa, qb],[c])
else:
qcar = q_program.create_quantum_register("qcar", n-1) # carry qubits
# quantum circuit involving the quantum registers and the classical register
addnbit_circuit = q_program.create_circuit("add", [qa, qb, qcar],[c])
# create the state containing a
number_state(addnbit_circuit, qa, a, n)
# create the state containing b
number_state(addnbit_circuit, qb, b, n)
# addition
addition_nbit(addnbit_circuit, qa, qb, qcar, n)
# measurements to see the result
for i in range(n+1):
addnbit_circuit.measure(qb[i], c[i])
# compile and execute the quantum program in the backend
result = q_program.execute(["add"], backend=backend, shots=1024, timeout=999999)
# show the results.
print(result)
print(result.get_data("add"))
counts = result.get_counts("add")
plot_histogram(counts)
print("Backend:", backend)
print("Highest probability outcome: {}".format(int(max(counts, key = lambda x: counts[x]).replace(" ", ""), 2)))
# checking the version of PYTHON; only support > 3.5
import sys
if sys.version_info < (3,5):
raise Exception('Please use Python version 3.5 or greater.')
# importing QISKit
from qiskit import QuantumProgram
# import basic plotting tools
from qiskit.tools.visualization import plot_histogram
# create a QuantumProgram object instance.
q_program = QuantumProgram()
# backend
backend = 'local_qasm_simulator'
def carry(circuit, q0, q1, q2, q3):
"carry module"
circuit.ccx(q1, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q0, q2, q3)
def carry_inv(circuit, q0, q1, q2, q3):
"carry module running backwards"
circuit.ccx(q0, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q1, q2, q3)
def summation(circuit, q0, q1, q2):
"summation module"
circuit.cx(q1, q2)
circuit.cx(q0, q2)
def summation_inv(circuit, q0, q1, q2):
"summation module running backwards"
circuit.cx(q0, q2)
circuit.cx(q1, q2)
# quantum plain addition algorithm for n-qubit numbers
def addition_nbit(circuit, qa, qb, qcar, n):
if n == 1:
circuit.ccx(qa[0], qb[0], qb[1])
circuit.cx(qa[0], qb[0])
else:
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
for i in range(n-2):
carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])
carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])
circuit.cx(qa[n-1], qb[n-1])
for i in range(n-1, 1, -1):
summation(circuit, qcar[i-1], qa[i], qb[i])
carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])
summation(circuit, qcar[0], qa[1], qb[1])
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
# quantum plain substraction algorithm for n-qubit numbers
def subs_nbit(circuit, qa, qb, qcar, n):
"same circuit as the plain addition but going backwards"
if n == 1:
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qb[1])
else:
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
summation_inv(circuit, qcar[0], qa[1], qb[1])
for i in range(n-2):
carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])
summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2])
circuit.cx(qa[n-1], qb[n-1])
carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])
for i in range(n-2, 0, -1):
carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i])
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
def cond_toffoli(circuit, qcond, q1, q2, q3):
"toffoli gate conditioned by an external qubit"
circuit.h(q3)
circuit.ccx(qcond, q2, q3)
circuit.tdg(q3)
circuit.ccx(qcond, q1, q3)
circuit.t(q3)
circuit.ccx(qcond, q2, q3)
circuit.tdg(q3)
circuit.ccx(qcond, q1, q3)
circuit.t(q3)
circuit.h(q3)
circuit.t(q2)
circuit.ccx(qcond, q1, q2)
circuit.t(q1)
circuit.tdg(q2)
circuit.ccx(qcond, q1, q2)
def cond_carry(circuit, q0, q1, q2, q3, qcond):
"conditional carry module"
cond_toffoli(circuit, qcond, q1, q2, q3)
circuit.ccx(qcond, q1, q2)
cond_toffoli(circuit, qcond, q0, q2, q3)
def cond_carry_inv(circuit, q0, q1, q2, q3, qcond):
"conditional carry module running backwards"
cond_toffoli(circuit, qcond, q0, q2, q3)
circuit.ccx(qcond, q1, q2)
cond_toffoli(circuit, qcond, q1, q2, q3)
def cond_summation(circuit, q0, q1, q2, qcond):
"conditional summation module"
circuit.ccx(qcond, q1, q2)
circuit.ccx(qcond, q0, q2)
def cond_summation_inv(circuit, q0, q1, q2, qcond):
"conditional summation module running backwards"
circuit.ccx(qcond, q0, q2)
circuit.ccx(qcond, q1, q2)
# quantum conditional plain addition algorithm for n-qubit numbers
def cond_addition_nbit(circuit, qa, qb, qcar, qcond, n):
"plain addition algorithm conditioned by an external qubit"
if n == 1:
cond_toffoli(circuit, qcond[0], qa[0], qb[0], qb[1])
circuit.ccx(qcond[0], qa[0], qb[0])
else:
cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])
circuit.ccx(qcond[0], qa[0], qb[0])
for i in range(n-2):
cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond[0])
cond_carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond[0])
circuit.ccx(qcond[0], qa[n-1], qb[n-1])
for i in range(n-1, 1, -1):
cond_summation(circuit, qcar[i-1], qa[i], qb[i], qcond[0])
cond_carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1], qcond[0])
cond_summation(circuit, qcar[0], qa[1], qb[1], qcond[0])
circuit.ccx(qcond[0], qa[0], qb[0])
cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])
circuit.ccx(qcond[0], qa[0], qb[0])
# quantum conditional plain substraction algorithm for n-qubit numbers
def cond_subs_nbit(circuit, qa, qb, qcar, qcond, n):
"same circuit as the conditional plain addition but going backwards"
if n == 1:
circuit.ccx(qcond[0], qa[0], qb[0])
cond_toffoli(circuit, qcond[0], qa[0], qb[0], qb[1])
else:
circuit.ccx(qcond[0], qa[0], qb[0])
cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])
circuit.ccx(qcond[0], qa[0], qb[0])
cond_summation_inv(circuit, qcar[0], qa[1], qb[1], qcond[0])
for i in range(n-2):
cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond[0])
cond_summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2], qcond[0])
circuit.ccx(qcond[0], qa[n-1], qb[n-1])
cond_carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond[0])
for i in range(n-2, 0, -1):
cond_carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i], qcond[0])
circuit.ccx(qcond[0], qa[0], qb[0])
cond_toffoli(circuit, qcond[0], qa[0], qb[0], qcar[0])
# quantum modular addition algorithm for n-qubit numbers
def mod_addition_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):
addition_nbit(circuit, qa, qb, qcar, n)
subs_nbit(circuit, qN, qb, qcar, n)
circuit.x(qb[n])
circuit.cx(qb[n], qtemp[0])
circuit.x(qb[n])
cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
addition_nbit(circuit, qN, qb, qcar, n)
cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
subs_nbit(circuit, qa, qb, qcar, n)
circuit.cx(qb[n], qtemp[0])
addition_nbit(circuit, qa, qb, qcar, n)
# n-qubit number input state
def number_state(circuit, q, x, n):
# integer to binary
x = "{0:b}".format(x)
x = x.zfill(n)
# creating the state
for i in range(n):
if int(x[n-1-i]) == 1:
circuit.x(q[i])
# we define the values
a = 2
b = 3
N = 3
# computing number of qubits n needed
n = len("{0:b}".format(a))
n2 = len("{0:b}".format(b))
n3 = len("{0:b}".format(N))
if n2 > n:
n = n2
if n3 > n:
n = n3
# classical register with n+1 bits.
c = q_program.create_classical_register("cr", n+1)
# quantum registers
qa = q_program.create_quantum_register("qa", n) # a qubits
qb = q_program.create_quantum_register("qb", n+1) # b qubits
qN = q_program.create_quantum_register("qN", n+1) # N qubits
qNtemp = q_program.create_quantum_register("qNtemp", n) # temporary N qubits
qtemp = q_program.create_quantum_register("qtemp", 1) # temporary qubit
# if n = 1, no need of carry register
if n == 1:
qcar = 0
# quantum circuit involving the quantum registers and the classical register
mod_add_circuit = q_program.create_circuit("mod_add", [qa, qb, qN, qNtemp, qtemp],[c])
else:
qcar = q_program.create_quantum_register("qcar", n-1) # carry qubits
# quantum circuit involving the quantum registers and the classical register
mod_add_circuit = q_program.create_circuit("mod_add", [qa, qb, qN, qcar, qNtemp, qtemp],[c])
# create the state containing 'a'
number_state(mod_add_circuit, qa, a, n)
# create the state containing 'b'
number_state(mod_add_circuit, qb, b, n)
# create the state containing 'N'
number_state(mod_add_circuit, qN, N, n)
# create the temporary state containing 'N'
number_state(mod_add_circuit, qNtemp, N, n)
# modular addition
mod_addition_nbit(mod_add_circuit, qa, qb, qN, qNtemp, qcar, qtemp, n)
# measurements to see the result
for i in range(n+1):
mod_add_circuit.measure(qb[i], c[i])
# compile and execute the quantum program in the backend
result = q_program.execute(["mod_add"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=999999)
# show the results.
print(result)
print(result.get_data("mod_add"))
counts = result.get_counts("mod_add")
plot_histogram(counts)
print("Backend:", backend)
print("Highest probability outcome: {}".format(int(max(counts, key = lambda x: counts[x]).replace(" ", ""), 2)))
# checking the version of PYTHON; only support > 3.5
import sys
if sys.version_info < (3,5):
raise Exception('Please use Python version 3.5 or greater.')
# importing QISKit
from qiskit import QuantumProgram
# import basic plotting tools
from qiskit.tools.visualization import plot_histogram
# create a QuantumProgram object instance.
q_program = QuantumProgram()
# backend
backend = 'local_qasm_simulator'
def carry(circuit, q0, q1, q2, q3):
"carry module"
circuit.ccx(q1, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q0, q2, q3)
def carry_inv(circuit, q0, q1, q2, q3):
"carry module running backwards"
circuit.ccx(q0, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q1, q2, q3)
def summation(circuit, q0, q1, q2):
"summation module"
circuit.cx(q1, q2)
circuit.cx(q0, q2)
def summation_inv(circuit, q0, q1, q2):
"summation module running backwards"
circuit.cx(q0, q2)
circuit.cx(q1, q2)
# quantum plain addition algorithm for n-qubit numbers
def addition_nbit(circuit, qa, qb, qcar, n):
if n == 1:
circuit.ccx(qa[0], qb[0], qb[1])
circuit.cx(qa[0], qb[0])
else:
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
for i in range(n-2):
carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])
carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])
circuit.cx(qa[n-1], qb[n-1])
for i in range(n-1, 1, -1):
summation(circuit, qcar[i-1], qa[i], qb[i])
carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])
summation(circuit, qcar[0], qa[1], qb[1])
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
# quantum plain substraction algorithm for n-qubit numbers
def subs_nbit(circuit, qa, qb, qcar, n):
"same circuit as the addition but going backwards"
if n == 1:
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qb[1])
else:
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
summation_inv(circuit, qcar[0], qa[1], qb[1])
for i in range(n-2):
carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])
summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2])
circuit.cx(qa[n-1], qb[n-1])
carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])
for i in range(n-2, 0, -1):
carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i])
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
def cond_toffoli(circuit, qcond, q1, q2, q3):
"toffoli gate conditioned by an external qubit"
circuit.h(q3)
circuit.ccx(qcond, q2, q3)
circuit.tdg(q3)
circuit.ccx(qcond, q1, q3)
circuit.t(q3)
circuit.ccx(qcond, q2, q3)
circuit.tdg(q3)
circuit.ccx(qcond, q1, q3)
circuit.t(q3)
circuit.h(q3)
circuit.t(q2)
circuit.ccx(qcond, q1, q2)
circuit.t(q1)
circuit.tdg(q2)
circuit.ccx(qcond, q1, q2)
def cond_carry(circuit, q0, q1, q2, q3, qcond):
"conditional carry module"
cond_toffoli(circuit, qcond, q1, q2, q3)
circuit.ccx(qcond, q1, q2)
cond_toffoli(circuit, qcond, q0, q2, q3)
def cond_carry_inv(circuit, q0, q1, q2, q3, qcond):
"conditional carry module running backwards"
cond_toffoli(circuit, qcond, q0, q2, q3)
circuit.ccx(qcond, q1, q2)
cond_toffoli(circuit, qcond, q1, q2, q3)
def cond_summation(circuit, q0, q1, q2, qcond):
"conditional summation module"
circuit.ccx(qcond, q1, q2)
circuit.ccx(qcond, q0, q2)
def cond_summation_inv(circuit, q0, q1, q2, qcond):
"conditional summation module running backwards"
circuit.ccx(qcond, q0, q2)
circuit.ccx(qcond, q1, q2)
# quantum conditional plain addition algorithm for n-qubit numbers
def cond_addition_nbit(circuit, qa, qb, qcar, qcond, n):
if n == 1:
cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])
circuit.ccx(qcond, qa[0], qb[0])
else:
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
circuit.ccx(qcond, qa[0], qb[0])
for i in range(n-2):
cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)
cond_carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)
circuit.ccx(qcond, qa[n-1], qb[n-1])
for i in range(n-1, 1, -1):
cond_summation(circuit, qcar[i-1], qa[i], qb[i], qcond)
cond_carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1], qcond)
cond_summation(circuit, qcar[0], qa[1], qb[1], qcond)
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
circuit.ccx(qcond, qa[0], qb[0])
# quantum conditional plain substraction algorithm for n-qubit numbers
def cond_subs_nbit(circuit, qa, qb, qcar, qcond, n):
"same circuit as the conditional plain addition but going backwards"
if n == 1:
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])
else:
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
circuit.ccx(qcond, qa[0], qb[0])
cond_summation_inv(circuit, qcar[0], qa[1], qb[1], qcond)
for i in range(n-2):
cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)
cond_summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2], qcond)
circuit.ccx(qcond, qa[n-1], qb[n-1])
cond_carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)
for i in range(n-2, 0, -1):
cond_carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i], qcond)
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
# quantum modular addition algorithm for n-qubit numbers
def mod_addition_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):
addition_nbit(circuit, qa, qb, qcar, n)
subs_nbit(circuit, qN, qb, qcar, n)
circuit.x(qb[n])
circuit.cx(qb[n], qtemp)
circuit.x(qb[n])
cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
addition_nbit(circuit, qN, qb, qcar, n)
cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
subs_nbit(circuit, qa, qb, qcar, n)
circuit.cx(qb[n], qtemp)
addition_nbit(circuit, qa, qb, qcar, n)
# quantum controlled modular multiplication algorithm for n-qubit numbers
def cont_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, qX, qext, N, n):
for i in range(n):
for j in range(n):
classical_mod = (2**(i+j))%N
cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)
mod_addition_nbit(circuit, qtempst, qb, qN, qNtemp, qcar, qtemp, n)
cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)
circuit.x(qext)
cond_addition_nbit(circuit, qX, qb, qcar, qext, n)
circuit.x(qext)
# n-qubit number input state
def number_state(circuit, q, x, n):
# integer to binary
x = "{0:b}".format(x)
x = x.zfill(n)
# creating the state
for i in range(n):
if int(x[n-1-i]) == 1:
circuit.x(q[i])
# n-qubit number input state, controlled by 2 control qubits
def cond_number_state(circuit, q, x, ext, control1, control2, n):
# integer to binary
x = "{0:b}".format(x)
x = x.zfill(n)
# creating the state
for i in range(n):
if int(x[n-1-i]) == 1:
cond_toffoli(circuit, ext, control1, control2, q[i])
# we define the values
a = 1
x = 1
N = 1
# computing number of qubits n needed
n = len("{0:b}".format(a))
n2 = len("{0:b}".format(x))
n3 = len("{0:b}".format(N))
if n2 > n:
n = n2
if n3 > n:
n = n3
# classical register with n+1 bits.
c = q_program.create_classical_register("cr", n+1)
# quantum registers
qa = q_program.create_quantum_register("qa", n) # a qubits
qb = q_program.create_quantum_register("qb", n+1) # result register
qN = q_program.create_quantum_register("qN", n+1) # N qubits
qNtemp = q_program.create_quantum_register("qNtemp", n) # temporary N qubits
qtemp = q_program.create_quantum_register("qtemp", 1) # temporary qubit
qtempst = q_program.create_quantum_register("qtempst", n) # temporary register
qX = q_program.create_quantum_register("qX", n) # x register
qext = q_program.create_quantum_register("qext", 1)
# if n = 1, no need of carry register
if n == 1:
qcar = 0
# quantum circuit involving the quantum registers and the classical register
mod_mult_circuit = q_program.create_circuit("mod_mult", [qa, qb, qN, qNtemp, qtemp, qtempst, qX, qext],[c])
else:
qcar = q_program.create_quantum_register("qcar", n-1) # carry qubits
# quantum circuit involving the quantum register and the classical register
mod_mult_circuit = q_program.create_circuit("mod_mult", [qa, qb, qN, qcar, qNtemp, qtemp, qtempst, qX, qext],[c])
# create the state containing 'a'
number_state(mod_mult_circuit, qa, a, n)
# create the state containing 'b'
number_state(mod_mult_circuit, qX, x, n)
# create the state containing 'N'
number_state(mod_mult_circuit, qN, N, n+1)
# create a temporary state containing 'N'
number_state(mod_mult_circuit, qNtemp, N, n)
mod_mult_circuit.x(qext[0]) # we set the control qubit to |1>
# controlled modular multiplication
cont_mod_mult_nbit(mod_mult_circuit, qa, qb, qN, qNtemp, qcar, qtemp[0], qtempst, qX, qext[0], N, n)
# measurements to see the result
for i in range(n+1):
mod_mult_circuit.measure(qb[i], c[i])
# compile and execute the quantum program in the backend
result = q_program.execute(["mod_mult"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=999999)
# show the results.
print(result)
print(result.get_data("mod_mult"))
counts = result.get_counts("mod_mult")
plot_histogram(counts)
print("Backend:", backend)
print("Highest probability outcome: {}".format(int(max(counts, key = lambda x: counts[x]).replace(" ", ""), 2)))
# checking the version of PYTHON; only support > 3.5
import sys
if sys.version_info < (3,5):
raise Exception('Please use Python version 3.5 or greater.')
# importing QISKit
from qiskit import QuantumProgram
# import basic plotting tools
from qiskit.tools.visualization import plot_histogram
# create a QuantumProgram object instance.
q_program = QuantumProgram()
# backend
backend = 'local_qasm_simulator'
def carry(circuit, q0, q1, q2, q3):
"carry module"
circuit.ccx(q1, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q0, q2, q3)
def carry_inv(circuit, q0, q1, q2, q3):
"carry module running backwards"
circuit.ccx(q0, q2, q3)
circuit.cx(q1, q2)
circuit.ccx(q1, q2, q3)
def summation(circuit, q0, q1, q2):
"summation module"
circuit.cx(q1, q2)
circuit.cx(q0, q2)
def summation_inv(circuit, q0, q1, q2):
"summation module running backwards"
circuit.cx(q0, q2)
circuit.cx(q1, q2)
# quantum plain addition algorithm for n-qubit numbers
def addition_nbit(circuit, qa, qb, qcar, n):
if n == 1:
circuit.ccx(qa[0], qb[0], qb[1])
circuit.cx(qa[0], qb[0])
else:
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
for i in range(n-2):
carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])
carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])
circuit.cx(qa[n-1], qb[n-1])
for i in range(n-1, 1, -1):
summation(circuit, qcar[i-1], qa[i], qb[i])
carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1])
summation(circuit, qcar[0], qa[1], qb[1])
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
# quantum plain substraction algorithm for n-qubit numbers
def subs_nbit(circuit, qa, qb, qcar, n):
"same as the plain addition but running backwards"
if n == 1:
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qb[1])
else:
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
circuit.cx(qa[0], qb[0])
summation_inv(circuit, qcar[0], qa[1], qb[1])
for i in range(n-2):
carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1])
summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2])
circuit.cx(qa[n-1], qb[n-1])
carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n])
for i in range(n-2, 0, -1):
carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i])
circuit.cx(qa[0], qb[0])
circuit.ccx(qa[0], qb[0], qcar[0])
def cond_toffoli(circuit, qcond, q1, q2, q3):
"conditional toffoli gate"
circuit.h(q3)
circuit.ccx(qcond, q2, q3)
circuit.tdg(q3)
circuit.ccx(qcond, q1, q3)
circuit.t(q3)
circuit.ccx(qcond, q2, q3)
circuit.tdg(q3)
circuit.ccx(qcond, q1, q3)
circuit.t(q3)
circuit.h(q3)
circuit.t(q2)
circuit.ccx(qcond, q1, q2)
circuit.t(q1)
circuit.tdg(q2)
circuit.ccx(qcond, q1, q2)
def cond_carry(circuit, q0, q1, q2, q3, qcond):
"conditional carry module"
cond_toffoli(circuit, qcond, q1, q2, q3)
circuit.ccx(qcond, q1, q2)
cond_toffoli(circuit, qcond, q0, q2, q3)
def cond_carry_inv(circuit, q0, q1, q2, q3, qcond):
"conditional carry module running backwards"
cond_toffoli(circuit, qcond, q0, q2, q3)
circuit.ccx(qcond, q1, q2)
cond_toffoli(circuit, qcond, q1, q2, q3)
def cond_summation(circuit, q0, q1, q2, qcond):
"conditional summation"
circuit.ccx(qcond, q1, q2)
circuit.ccx(qcond, q0, q2)
def cond_summation_inv(circuit, q0, q1, q2, qcond):
"conditional summation running backwards"
circuit.ccx(qcond, q0, q2)
circuit.ccx(qcond, q1, q2)
# quantum conditional plain addition algorithm for n-qubit numbers
def cond_addition_nbit(circuit, qa, qb, qcar, qcond, n):
if n == 1:
cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])
circuit.ccx(qcond, qa[0], qb[0])
else:
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
circuit.ccx(qcond, qa[0], qb[0])
for i in range(n-2):
cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)
cond_carry(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)
circuit.ccx(qcond, qa[n-1], qb[n-1])
for i in range(n-1, 1, -1):
cond_summation(circuit, qcar[i-1], qa[i], qb[i], qcond)
cond_carry_inv(circuit, qcar[i-2], qa[i-1], qb[i-1], qcar[i-1], qcond)
cond_summation(circuit, qcar[0], qa[1], qb[1], qcond)
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
circuit.ccx(qcond, qa[0], qb[0])
# quantum conditional plain substraction algorithm for n-qubit numbers
def cond_subs_nbit(circuit, qa, qb, qcar, qcond, n):
"same as conditional plain addition but running backwards"
if n == 1:
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qb[1])
else:
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
circuit.ccx(qcond, qa[0], qb[0])
cond_summation_inv(circuit, qcar[0], qa[1], qb[1], qcond)
for i in range(n-2):
cond_carry(circuit, qcar[i], qa[i+1], qb[i+1], qcar[i+1], qcond)
cond_summation_inv(circuit, qcar[i+1], qa[i+2], qb[i+2], qcond)
circuit.ccx(qcond, qa[n-1], qb[n-1])
cond_carry_inv(circuit, qcar[n-2], qa[n-1], qb[n-1], qb[n], qcond)
for i in range(n-2, 0, -1):
cond_carry_inv(circuit, qcar[i-1], qa[i], qb[i], qcar[i], qcond)
circuit.ccx(qcond, qa[0], qb[0])
cond_toffoli(circuit, qcond, qa[0], qb[0], qcar[0])
# quantum modular addition algorithm for n-qubit numbers
def mod_addition_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):
addition_nbit(circuit, qa, qb, qcar, n)
subs_nbit(circuit, qN, qb, qcar, n)
circuit.x(qb[n])
circuit.cx(qb[n], qtemp)
circuit.x(qb[n])
cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
addition_nbit(circuit, qN, qb, qcar, n)
cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
subs_nbit(circuit, qa, qb, qcar, n)
circuit.cx(qb[n], qtemp)
addition_nbit(circuit, qa, qb, qcar, n)
# quantum modular substraction algorithm for n-qubit numbers
def mod_subs_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, n):
"same as modular addition but running backwards"
subs_nbit(circuit, qa, qb, qcar, n)
circuit.cx(qb[n], qtemp)
addition_nbit(circuit, qa, qb, qcar, n)
cond_subs_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
subs_nbit(circuit, qN, qb, qcar, n)
cond_addition_nbit(circuit, qNtemp, qN, qcar, qtemp, n)
circuit.x(qb[n])
circuit.cx(qb[n], qtemp)
circuit.x(qb[n])
addition_nbit(circuit, qN, qb, qcar, n)
subs_nbit(circuit, qa, qb, qcar, n)
# quantum controlled modular multiplication algorithm for n-qubit numbers
def cont_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, qX, qext, N, n):
for i in range(n):
for j in range(n):
classical_mod = (2**(i+j))%N
cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)
mod_addition_nbit(circuit, qtempst, qb, qN, qNtemp, qcar, qtemp, n)
cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)
circuit.x(qext)
cond_addition_nbit(circuit, qX, qb, qcar, qext, n)
circuit.x(qext)
def cont_inv_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, qX, qext, N, n):
"same as the controlled modular multiplication but running backwards"
circuit.x(qext)
cond_subs_nbit(circuit, qX, qb, qcar, qext, n)
circuit.x(qext)
for i in range(n):
for j in range(n):
classical_mod = (2**(i+j))%N
cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)
mod_subs_nbit(circuit, qtempst, qb, qN, qNtemp, qcar, qtemp, n)
cond_number_state(circuit, qtempst, classical_mod, qext, qa[i], qX[j], n)
# quantum modular exponentiation algorithm for n-qubit numbers
def mod_exp_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, q1, qX, N, a, n):
for k in range(len(qX)):
clas_value = (a**(2**(k)))%N
if k % 2 == 0:
number_state(circuit, qa, clas_value, n)
cont_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, q1, qX[k], N, n)
number_state(circuit, qa, clas_value, n)
clas_value = modinv(a**(2**(k)), N)
number_state(circuit, qa, clas_value, n)
cont_inv_mod_mult_nbit(circuit, qa, q1, qN, qNtemp, qcar, qtemp, qtempst, qb, qX[k], N, n)
number_state(circuit, qa, clas_value, n)
else:
number_state(circuit, qa, clas_value, n)
cont_mod_mult_nbit(circuit, qa, q1, qN, qNtemp, qcar, qtemp, qtempst, qb, qX[k], N, n)
number_state(circuit, qa, clas_value, n)
clas_value = modinv(a**(2**(k)), N)
number_state(circuit, qa, clas_value, n)
cont_inv_mod_mult_nbit(circuit, qa, qb, qN, qNtemp, qcar, qtemp, qtempst, q1, qX[k], N, n)
number_state(circuit, qa, clas_value, n)
# n-qubit number input state
def number_state(circuit, q, x, n):
# integer to binary
x = "{0:b}".format(x)
x = x.zfill(n)
# creating the state
for i in range(n):
if int(x[n-1-i]) == 1:
circuit.x(q[i])
# n-qubit number input state, controlled by 2 control qubits
def cond_number_state(circuit, q, x, ext, control1, control2, n):
# integer to binary
x = "{0:b}".format(x)
x = x.zfill(n)
# creating the state
for i in range(n):
if int(x[n-1-i]) == 1:
cond_toffoli(circuit, ext, control1, control2, q[i])
# efficient algorithm for computing the modular multiplicative inverse a^-1 mod m
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
# we define the values, a and N must be coprimes
a = 1
x = 1
N = 1
# computing number of qubits n needed
n = len("{0:b}".format(a))
n2 = len("{0:b}".format(x))
n3 = len("{0:b}".format(N))
if n3 > n:
n = n3
# classical register with n+1 bits.
c = q_program.create_classical_register("cr", n+1)
# quantum registers
qa = q_program.create_quantum_register("qa", n) # a qubits
qb = q_program.create_quantum_register("qb", n+1) # initial state |0>
qN = q_program.create_quantum_register("qN", n+1) # N qubits
qNtemp = q_program.create_quantum_register("qNtemp", n) # temporary N qubits
qtemp = q_program.create_quantum_register("qtemp", 1) # temporary qubit
qtempst = q_program.create_quantum_register("qtempst", n) # temporary register
q1 = q_program.create_quantum_register("q1", n+1) # initial state |1>
qX = q_program.create_quantum_register("qX", n2) # x register
# if n = 1, no need of carry register
if n == 1:
qcar = 0
# quantum circuit involving the quantum registers and the classical register
mod_exp_circuit = q_program.create_circuit("mod_exp", [qa, qb, qN, qNtemp, qtemp, qtempst, q1, qX],[c])
else:
qcar = q_program.create_quantum_register("qcar", n-1) # carry qubits
# quantum circuit involving the quantum registers and the classical register
mod_exp_circuit = q_program.create_circuit("mod_exp", [qa, qb, qN, qcar, qNtemp, qtemp, qtempst, q1, qX],[c])
# create the initial state |1>. If N = 1, initial state is |0>
if N != 1:
number_state(mod_exp_circuit, q1, 1, 1)
# create the state containing 'x'
number_state(mod_exp_circuit, qX, x, n2)
# create the state containing 'N'
number_state(mod_exp_circuit, qN, N, n+1)
# create a temporary state containing 'N'
number_state(mod_exp_circuit, qNtemp, N, n)
# modular exponentiation
mod_exp_nbit(mod_exp_circuit, qa, qb, qN, qNtemp, qcar, qtemp[0], qtempst, q1, qX, N, a, n)
# measurements to see the result, the result would be in one of those registers, q1 or qb
if n2 % 2 == 0:
for i in range(n+1):
mod_exp_circuit.measure(q1[i], c[i])
else:
for i in range(n+1):
mod_exp_circuit.measure(qb[i], c[i])
# compile and execute the quantum program in the backend
result = q_program.execute(["mod_exp"], backend=backend, shots=1024, max_credits=3, wait=10, timeout=9999999)
# show the results.
print(result)
print(result.get_data("mod_exp"))
counts = result.get_counts("mod_exp")
plot_histogram(counts)
print("Backend:", backend)
print("Highest probability outcome: {}".format(int(max(counts, key = lambda x: counts[x]).replace(" ", ""), 2)))
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
import numpy as np
import networkx as nx
import qiskit
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, assemble
from qiskit.quantum_info import Statevector
from qiskit.aqua.algorithms import NumPyEigensolver
from qiskit.quantum_info import Pauli
from qiskit.aqua.operators import op_converter
from qiskit.aqua.operators import WeightedPauliOperator
from qiskit.visualization import plot_histogram
from qiskit.providers.aer.extensions.snapshot_statevector import *
from thirdParty.classical import rand_graph, classical, bitstring_to_path, calc_cost
from utils import mapeo_grafo
from collections import defaultdict
from operator import itemgetter
from scipy.optimize import minimize
import matplotlib.pyplot as plt
LAMBDA = 10
SEED = 10
SHOTS = 10000
# returns the bit index for an alpha and j
def bit(i_city, l_time, num_cities):
return i_city * num_cities + l_time
# e^(cZZ)
def append_zz_term(qc, q_i, q_j, gamma, constant_term):
qc.cx(q_i, q_j)
qc.rz(2*gamma*constant_term,q_j)
qc.cx(q_i, q_j)
# e^(cZ)
def append_z_term(qc, q_i, gamma, constant_term):
qc.rz(2*gamma*constant_term, q_i)
# e^(cX)
def append_x_term(qc,qi,beta):
qc.rx(-2*beta, qi)
def get_not_edge_in(G):
N = G.number_of_nodes()
not_edge = []
for i in range(N):
for j in range(N):
if i != j:
buffer_tupla = (i,j)
in_edges = False
for edge_i, edge_j in G.edges():
if ( buffer_tupla == (edge_i, edge_j) or buffer_tupla == (edge_j, edge_i)):
in_edges = True
if in_edges == False:
not_edge.append((i, j))
return not_edge
def get_classical_simplified_z_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# z term #
z_classic_term = [0] * N**2
# first term
for l in range(N):
for i in range(N):
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += -1 * _lambda
# second term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_jl
z_jl_index = bit(j, l, N)
z_classic_term[z_jl_index] += _lambda / 2
# third term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 2
# z_ij
z_ij_index = bit(i, j, N)
z_classic_term[z_ij_index] += _lambda / 2
# fourth term
not_edge = get_not_edge_in(G) # include order tuples ej = (1,0), (0,1)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
z_classic_term[z_il_index] += _lambda / 4
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
z_classic_term[z_jlplus_index] += _lambda / 4
# fifthy term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
z_classic_term[z_il_index] += weight_ij / 4
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
z_classic_term[z_il_index] += weight_ji / 4
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
z_classic_term[z_jlplus_index] += weight_ji / 4
return z_classic_term
def tsp_obj_2(x, G,_lambda):
# obtenemos el valor evaluado en f(x_1, x_2,... x_n)
not_edge = get_not_edge_in(G)
N = G.number_of_nodes()
tsp_cost=0
#Distancia
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# x_il
x_il_index = bit(edge_i, l, N)
# x_jlplus
l_plus = (l+1) % N
x_jlplus_index = bit(edge_j, l_plus, N)
tsp_cost+= int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ij
# add order term because G.edges() do not include order tuples #
# x_i'l
x_il_index = bit(edge_j, l, N)
# x_j'lplus
x_jlplus_index = bit(edge_i, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * weight_ji
#Constraint 1
for l in range(N):
penal1 = 1
for i in range(N):
x_il_index = bit(i, l, N)
penal1 -= int(x[x_il_index])
tsp_cost += _lambda * penal1**2
#Contstraint 2
for i in range(N):
penal2 = 1
for l in range(N):
x_il_index = bit(i, l, N)
penal2 -= int(x[x_il_index])
tsp_cost += _lambda*penal2**2
#Constraint 3
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# x_il
x_il_index = bit(i, l, N)
# x_j(l+1)
l_plus = (l+1) % N
x_jlplus_index = bit(j, l_plus, N)
tsp_cost += int(x[x_il_index]) * int(x[x_jlplus_index]) * _lambda
return tsp_cost
def get_classical_simplified_zz_term(G, _lambda):
# recorrer la formula Z con datos grafo se va guardando en diccionario que acumula si coinciden los terminos
N = G.number_of_nodes()
E = G.edges()
# zz term #
zz_classic_term = [[0] * N**2 for i in range(N**2) ]
# first term
for l in range(N):
for j in range(N):
for i in range(N):
if i < j:
# z_il
z_il_index = bit(i, l, N)
# z_jl
z_jl_index = bit(j, l, N)
zz_classic_term[z_il_index][z_jl_index] += _lambda / 2
# second term
for i in range(N):
for l in range(N):
for j in range(N):
if l < j:
# z_il
z_il_index = bit(i, l, N)
# z_ij
z_ij_index = bit(i, j, N)
zz_classic_term[z_il_index][z_ij_index] += _lambda / 2
# third term
not_edge = get_not_edge_in(G)
for edge in not_edge:
for l in range(N):
i = edge[0]
j = edge[1]
# z_il
z_il_index = bit(i, l, N)
# z_j(l+1)
l_plus = (l+1) % N
z_jlplus_index = bit(j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += _lambda / 4
# fourth term
weights = nx.get_edge_attributes(G,'weight')
for edge_i, edge_j in G.edges():
weight_ij = weights.get((edge_i,edge_j))
weight_ji = weight_ij
for l in range(N):
# z_il
z_il_index = bit(edge_i, l, N)
# z_jlplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_j, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ij / 4
# add order term because G.edges() do not include order tuples #
# z_i'l
z_il_index = bit(edge_j, l, N)
# z_j'lplus
l_plus = (l+1) % N
z_jlplus_index = bit(edge_i, l_plus, N)
zz_classic_term[z_il_index][z_jlplus_index] += weight_ji / 4
return zz_classic_term
def get_classical_simplified_hamiltonian(G, _lambda):
# z term #
z_classic_term = get_classical_simplified_z_term(G, _lambda)
# zz term #
zz_classic_term = get_classical_simplified_zz_term(G, _lambda)
return z_classic_term, zz_classic_term
def get_cost_circuit(G, gamma, _lambda):
N = G.number_of_nodes()
N_square = N**2
qc = QuantumCircuit(N_square,N_square)
z_classic_term, zz_classic_term = get_classical_simplified_hamiltonian(G, _lambda)
# z term
for i in range(N_square):
if z_classic_term[i] != 0:
append_z_term(qc, i, gamma, z_classic_term[i])
# zz term
for i in range(N_square):
for j in range(N_square):
if zz_classic_term[i][j] != 0:
append_zz_term(qc, i, j, gamma, zz_classic_term[i][j])
return qc
def get_mixer_operator(G,beta):
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
for n in range(N**2):
append_x_term(qc, n, beta)
return qc
def get_QAOA_circuit(G, beta, gamma, _lambda):
assert(len(beta)==len(gamma))
N = G.number_of_nodes()
qc = QuantumCircuit(N**2,N**2)
# init min mix state
qc.h(range(N**2))
p = len(beta)
for i in range(p):
qc = qc.compose(get_cost_circuit(G, gamma[i], _lambda))
qc = qc.compose(get_mixer_operator(G, beta[i]))
qc.barrier(range(N**2))
qc.snapshot_statevector("final_state")
qc.measure(range(N**2),range(N**2))
return qc
def invert_counts(counts):
return {k[::-1] :v for k,v in counts.items()}
# Sample expectation value
def compute_tsp_energy_2(counts, G):
energy = 0
get_counts = 0
total_counts = 0
for meas, meas_count in counts.items():
obj_for_meas = tsp_obj_2(meas, G, LAMBDA)
energy += obj_for_meas*meas_count
total_counts += meas_count
mean = energy/total_counts
return mean
def get_black_box_objective_2(G,p):
backend = Aer.get_backend('qasm_simulator')
sim = Aer.get_backend('aer_simulator')
# function f costo
def f(theta):
beta = theta[:p]
gamma = theta[p:]
# Anzats
qc = get_QAOA_circuit(G, beta, gamma, LAMBDA)
result = execute(qc, backend, seed_simulator=SEED, shots= SHOTS).result()
final_state_vector = result.data()["snapshots"]["statevector"]["final_state"][0]
state_vector = Statevector(final_state_vector)
probabilities = state_vector.probabilities()
probabilities_states = invert_counts(state_vector.probabilities_dict())
expected_value = 0
for state,probability in probabilities_states.items():
cost = tsp_obj_2(state, G, LAMBDA)
expected_value += cost*probability
counts = result.get_counts()
mean = compute_tsp_energy_2(invert_counts(counts),G)
return mean
return f
def crear_grafo(cantidad_ciudades):
pesos, conexiones = None, None
mejor_camino = None
while not mejor_camino:
pesos, conexiones = rand_graph(cantidad_ciudades)
mejor_costo, mejor_camino = classical(pesos, conexiones, loop=False)
G = mapeo_grafo(conexiones, pesos)
return G, mejor_costo, mejor_camino
def run_QAOA(p,ciudades, grafo):
if grafo == None:
G, mejor_costo, mejor_camino = crear_grafo(ciudades)
print("Mejor Costo")
print(mejor_costo)
print("Mejor Camino")
print(mejor_camino)
print("Bordes del grafo")
print(G.edges())
print("Nodos")
print(G.nodes())
print("Pesos")
labels = nx.get_edge_attributes(G,'weight')
print(labels)
else:
G = grafo
intial_random = []
# beta, mixer Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,np.pi))
# gamma, cost Hammiltonian
for i in range(p):
intial_random.append(np.random.uniform(0,2*np.pi))
init_point = np.array(intial_random)
obj = get_black_box_objective_2(G,p)
res_sample = minimize(obj, init_point,method="COBYLA",options={"maxiter":2500,"disp":True})
print(res_sample)
if __name__ == '__main__':
# Run QAOA parametros: profundidad p, numero d ciudades,
run_QAOA(5, 3, None)
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added h gate ###
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":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# This code is part of qiskit-runtime.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""The FeatureMap class."""
import json
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister
class FeatureMap:
"""Mapping data with the feature map."""
def __init__(self, feature_dimension, entangler_map=None):
"""
Args:
feature_dimension (int): number of features (twice the number of qubits for this
encoding)
entangler_map (list[list]): connectivity of qubits with a list of [source, target],
or None for full entanglement. Note that the order in the list is the order of
applying the two-qubit gate.
Raises:
ValueError: If the value of ``feature_dimension`` is odd.
"""
if isinstance(feature_dimension, int):
if feature_dimension % 2 == 0:
self._feature_dimension = feature_dimension
else:
raise ValueError("Feature dimension must be an even integer.")
else:
raise ValueError("Feature dimension must be an even integer.")
self._num_qubits = int(feature_dimension / 2)
if entangler_map is None:
self._entangler_map = [
[i, j] for i in range(self._num_qubits) for j in range(i + 1, self._num_qubits)
]
else:
self._entangler_map = entangler_map
self._num_parameters = self._num_qubits
def construct_circuit(self, x=None, parameters=None, q=None, inverse=False, name=None):
"""Construct the feature map circuit.
Args:
x (numpy.ndarray): data vector of size feature_dimension
parameters (numpy.ndarray): optional parameters in feature map
q (QauntumRegister): the QuantumRegister object for the circuit
inverse (bool): whether or not to invert the circuit
name (str): The name to use for the constructed ``QuantumCircuit`` object
Returns:
QuantumCircuit: a quantum circuit transforming data x
Raises:
ValueError: If the input parameters or vector are invalid
"""
if parameters is not None:
if isinstance(parameters, (int, float)):
raise ValueError("Parameters must be a list.")
if len(parameters) == 1:
parameters = parameters * np.ones(self._num_qubits)
else:
if len(parameters) != self._num_parameters:
raise ValueError(
"The number of feature map parameters must be {}.".format(
self._num_parameters
)
)
if len(x) != self._feature_dimension:
raise ValueError(
"The input vector must be of length {}.".format(self._feature_dimension)
)
if q is None:
q = QuantumRegister(self._num_qubits, name="q")
circuit = QuantumCircuit(q, name=name)
for i in range(self._num_qubits):
circuit.ry(-parameters[i], q[i])
for source, target in self._entangler_map:
circuit.cz(q[source], q[target])
for i in range(self._num_qubits):
circuit.rz(-2 * x[2 * i + 1], q[i])
circuit.rx(-2 * x[2 * i], q[i])
if inverse:
return circuit.inverse()
else:
return circuit
def to_json(self):
"""Return JSON representation of this object.
Returns:
str: JSON string representing this object.
"""
return json.dumps(
{"feature_dimension": self._feature_dimension, "entangler_map": self._entangler_map}
)
@classmethod
def from_json(cls, data):
"""Return an instance of this class from the JSON representation.
Args:
data (str): JSON string representing an object.
Returns:
FeatureMap: An instance of this class.
"""
return cls(**json.loads(data))
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile, schedule
from qiskit.visualization.pulse_v2 import draw
from qiskit.providers.fake_provider import FakeBoeblingen
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()
qc = transpile(qc, FakeBoeblingen(), layout_method='trivial')
sched = schedule(qc, FakeBoeblingen())
draw(sched, backend=FakeBoeblingen())
|
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/martian17/qiskit-graph-coloring-hamiltonian
|
martian17
|
import math
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, BasicAer
from qiskit.visualization import plot_histogram
# 4,0 -> 00
# 4,1 -> 01
# 4,2 -> 10
# 4,3 -> 11
# 4, 3 -> 11
# 2,3 -> 1,1
# 1,1 -> exit
def genvec(veclen, n):
vec = []
veclen = int(veclen/2)
while veclen > 0:
if veclen <= n:
n = n - veclen
vec.append(1)
else:
vec.append(0)
veclen = int(veclen/2)
vec.reverse()
return vec
def convertToState(v): # converts from [0,0,1,0] to [1,0]
# initializing the returning vector
lenv = len(v)
for i in range(lenv):
if v[i] != 0:
return genvec(lenv,i)
return False
def mcts(circuit, controls, target, ancilla, activq):# multi cubit toffoli select
for i in range(len(controls)):
if activq[i] == 0:
circuit.x(controls[i])
circuit.mct(controls, target, ancilla, 'basic')
for i in range(len(controls)):
if activq[i] == 0:
circuit.x(controls[i])
def all0(v):
for e in v:
if e != 0:
return False
return True
def fnon0(v):
for e in v:
if e != 0:
return e
return False
def vdeg(v):
for i in range(len(v)):
e = v[i]
if e != 0:
return i
return False
def vecinfo(v):
for i in range(len(v)):
e = v[i]
if e != 0:
return [e,i]
return False
def gate_mw(hamil,N,q1,q2,q3,q4,ancils):
circuit = QuantumCircuit(q1,q2,q3,q4,ancils)
matlen = len(hamil)
# w
for i in range(matlen):
if all0(hamil[i]):
continue # if there is no correcponding state
else:
# find the target
val = fnon0(hamil[i])
targetLocation = genvec(matlen,val) # weight
# print(hamil[i],i,targetLocation)
for j in range(N):# for each controlled output
if targetLocation[j] == 1:
# print(matlen,j,i)
mcts(circuit, q1, q4[j], ancils, genvec(matlen,i))
circuit.barrier()
# print("b")
# m
for i in range(matlen):
if all0(hamil[i]):
continue # if there is no correcponding state
else:
# find the target
val = fnon0(hamil[i])
targetLocation = convertToState(hamil[i]) # multiplication result
# print(hamil[i],i,targetLocation)
for j in range(N):# for each controlled output
if targetLocation[j] == 1:
# print(matlen,j,i)
mcts(circuit, q1, q2[j], ancils, genvec(matlen,i))
return circuit
def gate_aza(circuit,N,q1,q2,q3,q4):
matrix = [[1, 0, 0, 0], [0, 1/math.sqrt(2), 1/math.sqrt(2), 0], [0, 1/math.sqrt(2), -1/math.sqrt(2), 0], [0,0,0,1]]
for i in range(N):
circuit.unitary(matrix,[q1[i],q2[i]])
circuit.barrier()
for i in range(N):
circuit.x(q2[i])
circuit.ccx(q1[i],q2[i],q3)
circuit.x(q2[i])
circuit.barrier()
#hogehoge
circuit.x(q3)
for i in range(N):
circuit.cu1(-2**i, q3, q4[i])
circuit.x(q3)
for i in range(N):
circuit.cu1(2**i, q3, q4[i])
circuit.barrier()
for i in range(N):
circuit.x(q2[i])
circuit.ccx(q1[i],q2[i],q3)
circuit.x(q2[i])
circuit.barrier()
for i in range(N):
circuit.unitary(matrix,[q1[i],q2[i]])
def entire_circuit(hamil):
matlen = len(hamil)
N = int(math.log(matlen,2))
q1 = QuantumRegister(N)
q2 = QuantumRegister(N)
q3 = QuantumRegister(1)
q4 = QuantumRegister(N)
ancils = QuantumRegister(N)
cr = ClassicalRegister(N)
circuit = QuantumCircuit(q1,q2,q3,q4,ancils,cr)
# print(q1)
# gates M and W
circuit_mw = gate_mw(hamil,N,q1,q2,q3,q4,ancils)
circuit = circuit.combine(circuit_mw)
circuit.barrier()
# gates A, Z, and their inversions
gate_aza(circuit,N,q1,q2,q3,q4)
circuit.barrier()
# mw inversion
circuit_mw_inverted = circuit_mw.inverse()
circuit = circuit.combine(circuit_mw_inverted)
return circuit
# entire_circuit(
# [
# [0,2,0,0],
# [2,0,0,0],
# [0,0,0,1],
# [0,0,1,0]
# ]
# ).draw(output = "mpl")
|
https://github.com/adityakhannaadk/qasm_py_quantum
|
adityakhannaadk
|
"""
This module contains the Quantum Fourier Transform class.
"""
from numpy import pi
from qiskit import QuantumCircuit, Aer, transpile, assemble
class QuantumFourierTransform:
"""Class for operations of the Quantum Fourier Transform."""
@staticmethod
def simulate(state: int) -> dict:
"""Simulate the QFT and iQFT.
Parameters
----------
state (int): The state to simulate.
Returns
-------
dict: The simulated state.
"""
# Get the number of qubits.
qubit_count = state.bit_length()
# Create the circuit.
circuit = QuantumCircuit(qubit_count, qubit_count)
# Apply the initial state.
for qubit in range(qubit_count):
if state & (1 << qubit):
circuit.x(qubit)
# Apply the QFT.
circuit = QuantumFourierTransform.qft(circuit)
# Apply the inverse QFT.
circuit = QuantumFourierTransform.iqft(circuit)
# Append the measurement.
circuit.measure(range(qubit_count), range(qubit_count))
# Run the simulation.
simulator = Aer.get_backend("aer_simulator")
circuit = transpile(circuit, simulator)
job = simulator.run(assemble(circuit))
result = job.result().get_counts()
answer_as_list = list(result.keys())
answer_int = int(answer_as_list[0], 2)
return {"result": answer_int}
@staticmethod
def qft(circuit: QuantumCircuit) -> QuantumCircuit:
"""Apply QFT to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the QFT to.
Returns
-------
QuantumCircuit: The circuit with the QFT applied.
"""
# Apply the QFT to the circuit.
circuit = QuantumFourierTransform._qft_append_circuit(
circuit, circuit.num_qubits - 1
)
# Apply the swaps to the circuit.
circuit = QuantumFourierTransform._qft_append_swaps(circuit)
return circuit
@staticmethod
def qft_circuit(qubit_count: int) -> QuantumCircuit:
"""Create a QFT circuit with given Qubit count.
Parameters
----------
qubit_count : int
The number of qubits to use in the circuit.
Returns
-------
QuantumCircuit
The QFT circuit.
"""
return QuantumFourierTransform.qft(QuantumCircuit(qubit_count))
@staticmethod
def iqft_circuit(qubit_count: int) -> QuantumCircuit:
"""Create a iQFT circuit with given Qubit count.
Parameters
----------
qubit_count : int
The number of qubits to use in the circuit.
Returns
-------
QuantumCircuit
The iQFT circuit.
"""
return QuantumFourierTransform.iqft(QuantumCircuit(qubit_count))
@staticmethod
def iqft(circuit: QuantumCircuit) -> QuantumCircuit:
"""Apply inverse QFT to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the IQFT to.
Returns
-------
QuantumCircuit: The circuit with the iQFT applied.
"""
# Apply the swaps to the circuit.
circuit = QuantumFourierTransform._qft_append_swaps(circuit, inverse=True)
circuit.barrier()
# Apply the QFT to the circuit.
circuit = QuantumFourierTransform._iqft_append_circuit(circuit, 0)
return circuit
@staticmethod
def _qft_append_circuit(circuit: QuantumCircuit, qubit: int) -> QuantumCircuit:
"""Apply a rotation to a qubit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the rotation to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the rotation applied.
"""
# Recursive stop condition.
if qubit < 0:
return circuit
# Construct the minimal QFT circuit.
circuit.h(qubit)
for qubit_line in reversed(range(qubit)):
circuit.cp(pi / 2 ** (qubit - qubit_line), qubit_line, qubit)
circuit.barrier()
# Recursively apply the QFT to the next qubit.
return QuantumFourierTransform._qft_append_circuit(circuit, qubit - 1)
@staticmethod
def _iqft_append_circuit(circuit: QuantumCircuit, qubit: int) -> QuantumCircuit:
"""Apply a rotation to a qubit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the rotation to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the rotation applied.
"""
# Recursive stop condition.
if qubit >= circuit.num_qubits:
return circuit
# Construct the minimal QFT circuit.
for qubit_line in range(qubit):
circuit.cp(-pi / 2 ** (qubit - qubit_line), qubit_line, qubit)
circuit.h(qubit)
circuit.barrier()
# Recursively apply the QFT to the next qubit.
return QuantumFourierTransform._iqft_append_circuit(circuit, qubit + 1)
@staticmethod
def _qft_append_swaps(
circuit: QuantumCircuit, inverse: bool = False
) -> QuantumCircuit:
"""Apply swaps to a circuit.
Parameters
----------
circuit (QuantumCircuit): The circuit to apply the swaps to.
qubit (int): The qubit to apply the rotation to.
Returns
-------
QuantumCircuit: The circuit with the swaps applied.
"""
qubit_count = circuit.num_qubits
qubits_list = (
reversed(range(qubit_count // 2))
if not inverse
else range(qubit_count // 2)
)
for qubit in qubits_list:
circuit.swap(qubit, qubit_count - qubit - 1)
return circuit
if __name__ == "__main__":
print("===================================")
print("Quantum Fourier Transform Simulator")
print("===================================")
# Get the input state as integer decimal.
state_int = int(input("> Enter the state as decimal integer: "))
# Run the algorithm.
result = QuantumFourierTransform.simulate(state_int)
print(f"iQFT result: {result['result']}")
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
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()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
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()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
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()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
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.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# 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)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7.6mm'
cpw[1].options.total_length = '7.2mm'
cpw[2].options.total_length = '6.9mm'
cpw[3].options.total_length = '6.6mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 12
eig_qb.sim.setup.max_passes = 12
eig_qb.sim.setup.vars = Dict(Lj1= '10 nH', Cj1= '2 fF',
Lj2= '10 nH', Cj2= '2 fF',
Lj3= '10 nH', Cj3= '2 fF',
Lj4= '10 nH', Cj4= '2 fF')
eig_qb.sim.run(name="4Qubits", components=[])
eig_qb.sim.plot_convergences()
del eig_qb.setup.junctions['jj']
eig_qb.setup.junctions.jj1 = Dict(rect='JJ_rect_Lj_Q1_rect_jj', line='JJ_Lj_Q1_rect_jj_',
Lj_variable='Lj1', Cj_variable='Cj1')
eig_qb.setup.junctions.jj2 = Dict(rect='JJ_rect_Lj_Q2_rect_jj', line='JJ_Lj_Q2_rect_jj_',
Lj_variable='Lj2', Cj_variable='Cj2')
eig_qb.setup.junctions.jj3 = Dict(rect='JJ_rect_Lj_Q3_rect_jj', line='JJ_Lj_Q3_rect_jj_',
Lj_variable='Lj3', Cj_variable='Cj3')
eig_qb.setup.junctions.jj4 = Dict(rect='JJ_rect_Lj_Q4_rect_jj', line='JJ_Lj_Q4_rect_jj_',
Lj_variable='Lj4', Cj_variable='Cj4')
eig_qb.setup.sweep_variable = 'Lj1'
eig_qb.setup
eig_qb.run_epr()
eig_qb.sim.plot_fields('main', eigenmode=8)
#eig_2qb.sim.save_screenshot("eigen1.png")
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit", components=['Q1'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit2", components=['Q2'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '460um' # 405
transmons[2].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit3", components=['Q3'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
gui.rebuild()
eig_qb = EPRanalysis(design, "hfss")
eig_qb.sim.setup.n_modes = 2
eig_qb.sim.run(name="Qbit4", components=['Q4'], open_terminations=[], box_plus_buffer = False)
eig_qb.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[0].options.total_length = '11.7mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R1','ol1'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[1].options.total_length = '11.2mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R2','ol2'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[2].options.total_length = '10.6mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R3','ol3'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_rd = EPRanalysis(design, "hfss")
readout_lines[3].options.total_length = '10mm'
gui.rebuild()
eig_rd.sim.setup.n_modes = 2
eig_rd.sim.setup.max_passes = 10
eig_rd.sim.run(name="Readout",
components=['R4','ol4'])
eig_rd.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[0].options.total_length = '10mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW1",
components=['cpw1'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[1].options.total_length = '9.6mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW2",
components=['cpw3'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[2].options.total_length = '9.3mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW4",
components=['cpw4'])
eig_c.sim.plot_convergences()
from qiskit_metal.analyses.quantization import EPRanalysis
eig_c = EPRanalysis(design, "hfss")
cpw[3].options.total_length = '9mm'
gui.rebuild()
eig_c.sim.setup.n_modes = 2
eig_c.sim.setup.passes = 10
eig_c.sim.run(name="CPW5",
components=['cpw5'])
eig_c.sim.plot_convergences()
|
https://github.com/apcarrik/qiskit-dev
|
apcarrik
|
# Create VQE Optimizer circuit to find minimum eigenvalue
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
num_qubits = 2
ansatz = TwoLocal(num_qubits, 'ry', 'cz')
opt = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=opt)
ansatz.draw('mpl').show()
# Run algorithm on backend
from qiskit import Aer
backend = Aer.get_backend('aer_simulator_statevector')
from qiskit.utils import QuantumInstance
backend = Aer.get_backend('aer_simulator')
quantum_instance = QuantumInstance(backend=backend, shots=800, seed_simulator=99)
# vqe = VQE(ansatz, optimizer=opt, quantum_instance=quantum_instance)
# operator = #TODO: Figure out what operator is
# min_eigen = vqe.compute_minimum_eigenvalue(operator)
# print(min_eigen)
# Complete working example - create operator
from qiskit.opflow import X, Z, I
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
# run VQE and print result object it returns
from qiskit.utils import algorithm_globals
seed = 50
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi)
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
### Using VQE Setting QuantumInstance after Construciton
# Create VQE instance without quantum instance
algorithm_globals.random_seed = seed
qi = QuantumInstance(Aer.get_backend('statevector_simulator'), seed_transpiler=seed, seed_simulator=seed)
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp)
vqe.quantum_instance = qi
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
|
https://github.com/PavanCyborg/Quantum-Algorithms-Benchmarking
|
PavanCyborg
|
#Assign these values as per your requirements.
global min_qubits,max_qubits,skip_qubits,max_circuits,num_shots,Noise_Inclusion
min_qubits=3
max_qubits=31
skip_qubits=1
max_circuits=2
num_shots=1000
method=1 #Use method=2 for another approach of Benchmarking (default->1)
num_resets = 2 # Variable for number of resets to perform after mid circuit measurements (default->1) Only for method-2
input_value=None #assign any number to it to perform benchmark for that number.(Default->None)
Noise_Inclusion = False
saveplots = False
Memory_utilization_plot = True
gate_counts_plots = True
Type_of_Simulator = "built_in" #Inputs are "built_in" or "FAKE" or "FAKEV2"
backend_name = "FakeGuadalupeV2"
#Change your Specification of Simulator in Declaring Backend Section
#By Default : built_in -> qasm_simulator and FAKE -> FakeSantiago() and FAKEV2 -> FakeSantiagoV2()
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, transpile, execute
import time
import matplotlib.pyplot as plt
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (NoiseModel, QuantumError, ReadoutError,pauli_error, depolarizing_error, thermal_relaxation_error,reset_error)
benchmark_name = "Bernstein-Vazirani"
# Selection of basis gate set for transpilation
# Note: selector 1 is a hardware agnostic gate set
basis_selector = 1
basis_gates_array = [
[],
['rx', 'ry', 'rz', 'cx'], # a common basis set, default
['cx', 'rz', 'sx', 'x'], # IBM default basis set
['rx', 'ry', 'rxx'], # IonQ default basis set
['h', 'p', 'cx'], # another common basis set
['u', 'cx'] # general unitaries basis gates
]
np.random.seed(0)
def get_QV(backend):
import json
# Assuming backend.conf_filename is the filename and backend.dirname is the directory path
conf_filename = backend.dirname + "/" + backend.conf_filename
# Open the JSON file
with open(conf_filename, 'r') as file:
# Load the JSON data
data = json.load(file)
# Extract the quantum_volume parameter
QV = data.get('quantum_volume', None)
return QV
def checkbackend(backend_name,Type_of_Simulator):
if Type_of_Simulator == "built_in":
available_backends = []
for i in Aer.backends():
available_backends.append(i.name)
if backend_name in available_backends:
platform = backend_name
return platform
else:
print(f"incorrect backend name or backend not available. Using qasm_simulator by default !!!!")
print(f"available backends are : {available_backends}")
platform = "qasm_simulator"
return platform
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2":
import qiskit.providers.fake_provider as fake_backends
if hasattr(fake_backends,backend_name) is True:
print(f"Backend {backend_name} is available for type {Type_of_Simulator}.")
backend_class = getattr(fake_backends,backend_name)
backend_instance = backend_class()
return backend_instance
else:
print(f"Backend {backend_name} is not available or incorrect for type {Type_of_Simulator}. Executing with FakeSantiago!!!")
if Type_of_Simulator == "FAKEV2":
backend_class = getattr(fake_backends,"FakeSantiagoV2")
else:
backend_class = getattr(fake_backends,"FakeSantiago")
backend_instance = backend_class()
return backend_instance
if Type_of_Simulator == "built_in":
platform = checkbackend(backend_name,Type_of_Simulator)
#By default using "Qasm Simulator"
backend = Aer.get_backend(platform)
QV_=None
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"backend version is {backend.backend_version}")
elif Type_of_Simulator == "FAKE":
basis_selector = 0
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.properties().backend_name +"-"+ backend.properties().backend_version #Replace this string with the backend Provider's name as this is used for Plotting.
max_qubits=backend.configuration().n_qubits
print(f"{platform} device is capable of running {backend.configuration().n_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
elif Type_of_Simulator == "FAKEV2":
basis_selector = 0
if "V2" not in backend_name:
backend_name = backend_name+"V2"
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.name +"-" +backend.backend_version
max_qubits=backend.num_qubits
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
else:
print("Enter valid Simulator.....")
# 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="Uf")
# perform CX for each qubit that matches a bit in secret string
s = ('{0:0' + str(input_size) + 'b}').format(secret_int)
print("s = ",s)
print("input size in oracle =",input_size)
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
# Create an empty noise model
noise_parameters = NoiseModel()
if Type_of_Simulator == "built_in":
# Add depolarizing error to all single qubit gates with error rate 0.05% and to all two qubit gates with error rate 0.5%
depol_one_qb_error = 0.05
depol_two_qb_error = 0.005
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_two_qb_error, 2), ['cx'])
# Add amplitude damping error to all single qubit gates with error rate 0.0% and to all two qubit gates with error rate 0.0%
amp_damp_one_qb_error = 0.0
amp_damp_two_qb_error = 0.0
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_two_qb_error, 2), ['cx'])
# Add reset noise to all single qubit resets
reset_to_zero_error = 0.005
reset_to_one_error = 0.005
noise_parameters.add_all_qubit_quantum_error(reset_error(reset_to_zero_error, reset_to_one_error),["reset"])
# Add readout error
p0given1_error = 0.000
p1given0_error = 0.000
error_meas = ReadoutError([[1 - p1given0_error, p1given0_error], [p0given1_error, 1 - p0given1_error]])
noise_parameters.add_all_qubit_readout_error(error_meas)
#print(noise_parameters)
elif Type_of_Simulator == "FAKE"or"FAKEV2":
noise_parameters = NoiseModel.from_backend(backend)
#print(noise_parameters)
## Uniform distribution function commonly used
def rescale_fidelity(fidelity, floor_fidelity, new_floor_fidelity):
"""
Linearly rescales our fidelities to allow comparisons of fidelities across benchmarks
fidelity: raw fidelity to rescale
floor_fidelity: threshold fidelity which is equivalent to random guessing
new_floor_fidelity: what we rescale the floor_fidelity to
Ex, with floor_fidelity = 0.25, new_floor_fidelity = 0.0:
1 -> 1;
0.25 -> 0;
0.5 -> 0.3333;
"""
rescaled_fidelity = (1-new_floor_fidelity)/(1-floor_fidelity) * (fidelity - 1) + 1
# ensure fidelity is within bounds (0, 1)
if rescaled_fidelity < 0:
rescaled_fidelity = 0.0
if rescaled_fidelity > 1:
rescaled_fidelity = 1.0
return rescaled_fidelity
def uniform_dist(num_state_qubits):
dist = {}
for i in range(2**num_state_qubits):
key = bin(i)[2:].zfill(num_state_qubits)
dist[key] = 1/(2**num_state_qubits)
return dist
### Analysis methods to be expanded and eventually compiled into a separate analysis.py file
import math, functools
def hellinger_fidelity_with_expected(p, q):
""" p: result distribution, may be passed as a counts distribution
q: the expected distribution to be compared against
References:
`Hellinger Distance @ wikipedia <https://en.wikipedia.org/wiki/Hellinger_distance>`_
Qiskit Hellinger Fidelity Function
"""
p_sum = sum(p.values())
q_sum = sum(q.values())
if q_sum == 0:
print("ERROR: polarization_fidelity(), expected distribution is invalid, all counts equal to 0")
return 0
p_normed = {}
for key, val in p.items():
p_normed[key] = val/p_sum
# if p_sum != 0:
# p_normed[key] = val/p_sum
# else:
# p_normed[key] = 0
q_normed = {}
for key, val in q.items():
q_normed[key] = val/q_sum
total = 0
for key, val in p_normed.items():
if key in q_normed.keys():
total += (np.sqrt(val) - np.sqrt(q_normed[key]))**2
del q_normed[key]
else:
total += val
total += sum(q_normed.values())
# in some situations (error mitigation) this can go negative, use abs value
if total < 0:
print(f"WARNING: using absolute value in fidelity calculation")
total = abs(total)
dist = np.sqrt(total)/np.sqrt(2)
fidelity = (1-dist**2)**2
return fidelity
def polarization_fidelity(counts, correct_dist, thermal_dist=None):
"""
Combines Hellinger fidelity and polarization rescaling into fidelity calculation
used in every benchmark
counts: the measurement outcomes after `num_shots` algorithm runs
correct_dist: the distribution we expect to get for the algorithm running perfectly
thermal_dist: optional distribution to pass in distribution from a uniform
superposition over all states. If `None`: generated as
`uniform_dist` with the same qubits as in `counts`
returns both polarization fidelity and the hellinger fidelity
Polarization from: `https://arxiv.org/abs/2008.11294v1`
"""
num_measured_qubits = len(list(correct_dist.keys())[0])
#print(num_measured_qubits)
counts = {k.zfill(num_measured_qubits): v for k, v in counts.items()}
# calculate hellinger fidelity between measured expectation values and correct distribution
hf_fidelity = hellinger_fidelity_with_expected(counts,correct_dist)
# to limit cpu and memory utilization, skip noise correction if more than 16 measured qubits
if num_measured_qubits > 16:
return { 'fidelity':hf_fidelity, 'hf_fidelity':hf_fidelity }
# if not provided, generate thermal dist based on number of qubits
if thermal_dist == None:
thermal_dist = uniform_dist(num_measured_qubits)
# set our fidelity rescaling value as the hellinger fidelity for a depolarized state
floor_fidelity = hellinger_fidelity_with_expected(thermal_dist, correct_dist)
# rescale fidelity result so uniform superposition (random guessing) returns fidelity
# rescaled to 0 to provide a better measure of success of the algorithm (polarization)
new_floor_fidelity = 0
fidelity = rescale_fidelity(hf_fidelity, floor_fidelity, new_floor_fidelity)
return { 'fidelity':fidelity, 'hf_fidelity':hf_fidelity }
from matplotlib.patches import Rectangle
import matplotlib.cm as cm
from matplotlib.colors import ListedColormap, LinearSegmentedColormap, Normalize
from matplotlib.patches import Circle
############### Color Map functions
# Create a selection of colormaps from which to choose; default to custom_spectral
cmap_spectral = plt.get_cmap('Spectral')
cmap_greys = plt.get_cmap('Greys')
cmap_blues = plt.get_cmap('Blues')
cmap_custom_spectral = None
# the default colormap is the spectral map
cmap = cmap_spectral
cmap_orig = cmap_spectral
# current cmap normalization function (default None)
cmap_norm = None
default_fade_low_fidelity_level = 0.16
default_fade_rate = 0.7
# Specify a normalization function here (default None)
def set_custom_cmap_norm(vmin, vmax):
global cmap_norm
if vmin == vmax or (vmin == 0.0 and vmax == 1.0):
print("... setting cmap norm to None")
cmap_norm = None
else:
print(f"... setting cmap norm to [{vmin}, {vmax}]")
cmap_norm = Normalize(vmin=vmin, vmax=vmax)
# Remake the custom spectral colormap with user settings
def set_custom_cmap_style(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
#print("... set custom map style")
global cmap, cmap_custom_spectral, cmap_orig
cmap_custom_spectral = create_custom_spectral_cmap(
fade_low_fidelity_level=fade_low_fidelity_level, fade_rate=fade_rate)
cmap = cmap_custom_spectral
cmap_orig = cmap_custom_spectral
# Create the custom spectral colormap from the base spectral
def create_custom_spectral_cmap(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
# determine the breakpoint from the fade level
num_colors = 100
breakpoint = round(fade_low_fidelity_level * num_colors)
# get color list for spectral map
spectral_colors = [cmap_spectral(v/num_colors) for v in range(num_colors)]
#print(fade_rate)
# create a list of colors to replace those below the breakpoint
# and fill with "faded" color entries (in reverse)
low_colors = [0] * breakpoint
#for i in reversed(range(breakpoint)):
for i in range(breakpoint):
# x is index of low colors, normalized 0 -> 1
x = i / breakpoint
# get color at this index
bc = spectral_colors[i]
r0 = bc[0]
g0 = bc[1]
b0 = bc[2]
z0 = bc[3]
r_delta = 0.92 - r0
#print(f"{x} {bc} {r_delta}")
# compute saturation and greyness ratio
sat_ratio = 1 - x
#grey_ratio = 1 - x
''' attempt at a reflective gradient
if i >= breakpoint/2:
xf = 2*(x - 0.5)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (yf + 0.5)
else:
xf = 2*(0.5 - x)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (0.5 - yf)
'''
grey_ratio = 1 - math.pow(x, 1/fade_rate)
#print(f" {xf} {yf} ")
#print(f" {sat_ratio} {grey_ratio}")
r = r0 + r_delta * sat_ratio
g_delta = r - g0
b_delta = r - b0
g = g0 + g_delta * grey_ratio
b = b0 + b_delta * grey_ratio
#print(f"{r} {g} {b}\n")
low_colors[i] = (r,g,b,z0)
#print(low_colors)
# combine the faded low colors with the regular spectral cmap to make a custom version
cmap_custom_spectral = ListedColormap(low_colors + spectral_colors[breakpoint:])
#spectral_colors = [cmap_custom_spectral(v/10) for v in range(10)]
#for i in range(10): print(spectral_colors[i])
#print("")
return cmap_custom_spectral
# Make the custom spectral color map the default on module init
set_custom_cmap_style()
# Arrange the stored annotations optimally and add to plot
def anno_volumetric_data(ax, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True):
# sort all arrays by the x point of the text (anno_offs)
global x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos
all_annos = sorted(zip(x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos))
x_anno_offs = [a for a,b,c,d,e in all_annos]
y_anno_offs = [b for a,b,c,d,e in all_annos]
anno_labels = [c for a,b,c,d,e in all_annos]
x_annos = [d for a,b,c,d,e in all_annos]
y_annos = [e for a,b,c,d,e in all_annos]
#print(f"{x_anno_offs}")
#print(f"{y_anno_offs}")
#print(f"{anno_labels}")
for i in range(len(anno_labels)):
x_anno = x_annos[i]
y_anno = y_annos[i]
x_anno_off = x_anno_offs[i]
y_anno_off = y_anno_offs[i]
label = anno_labels[i]
if i > 0:
x_delta = abs(x_anno_off - x_anno_offs[i - 1])
y_delta = abs(y_anno_off - y_anno_offs[i - 1])
if y_delta < 0.7 and x_delta < 2:
y_anno_off = y_anno_offs[i] = y_anno_offs[i - 1] - 0.6
#x_anno_off = x_anno_offs[i] = x_anno_offs[i - 1] + 0.1
ax.annotate(label,
xy=(x_anno+0.0, y_anno+0.1),
arrowprops=dict(facecolor='black', shrink=0.0,
width=0.5, headwidth=4, headlength=5, edgecolor=(0.8,0.8,0.8)),
xytext=(x_anno_off + labelpos[0], y_anno_off + labelpos[1]),
rotation=labelrot,
horizontalalignment='left', verticalalignment='baseline',
color=(0.2,0.2,0.2),
clip_on=True)
if saveplots == True:
plt.savefig("VolumetricPlotSample.jpg")
# Plot one group of data for volumetric presentation
def plot_volumetric_data(ax, w_data, d_data, f_data, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True, w_max=18, do_label=False, do_border=True,
x_size=1.0, y_size=1.0, zorder=1, offset_flag=False,
max_depth=0, suppress_low_fidelity=False):
# since data may come back out of order, save point at max y for annotation
i_anno = 0
x_anno = 0
y_anno = 0
# plot data rectangles
low_fidelity_count = True
last_y = -1
k = 0
# determine y-axis dimension for one pixel to use for offset of bars that start at 0
(_, dy) = get_pixel_dims(ax)
# do this loop in reverse to handle the case where earlier cells are overlapped by later cells
for i in reversed(range(len(d_data))):
x = depth_index(d_data[i], depth_base)
y = float(w_data[i])
f = f_data[i]
# each time we star a new row, reset the offset counter
# DEVNOTE: this is highly specialized for the QA area plots, where there are 8 bars
# that represent time starting from 0 secs. We offset by one pixel each and center the group
if y != last_y:
last_y = y;
k = 3 # hardcoded for 8 cells, offset by 3
#print(f"{i = } {x = } {y = }")
if max_depth > 0 and d_data[i] > max_depth:
#print(f"... excessive depth (2), skipped; w={y} d={d_data[i]}")
break;
# reject cells with low fidelity
if suppress_low_fidelity and f < suppress_low_fidelity_level:
if low_fidelity_count: break
else: low_fidelity_count = True
# the only time this is False is when doing merged gradation plots
if do_border == True:
# this case is for an array of x_sizes, i.e. each box has different width
if isinstance(x_size, list):
# draw each of the cells, with no offset
if not offset_flag:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size[i], y_size=y_size, zorder=zorder))
# use an offset for y value, AND account for x and width to draw starting at 0
else:
ax.add_patch(box_at((x/2 + x_size[i]/4), y + k*dy, f, type=type, fill=fill, x_size=x+ x_size[i]/2, y_size=y_size, zorder=zorder))
# this case is for only a single cell
else:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size, y_size=y_size))
# save the annotation point with the largest y value
if y >= y_anno:
x_anno = x
y_anno = y
i_anno = i
# move the next bar down (if using offset)
k -= 1
# if no data rectangles plotted, no need for a label
if x_anno == 0 or y_anno == 0:
return
x_annos.append(x_anno)
y_annos.append(y_anno)
anno_dist = math.sqrt( (y_anno - 1)**2 + (x_anno - 1)**2 )
# adjust radius of annotation circle based on maximum width of apps
anno_max = 10
if w_max > 10:
anno_max = 14
if w_max > 14:
anno_max = 18
scale = anno_max / anno_dist
# offset of text from end of arrow
if scale > 1:
x_anno_off = scale * x_anno - x_anno - 0.5
y_anno_off = scale * y_anno - y_anno
else:
x_anno_off = 0.7
y_anno_off = 0.5
x_anno_off += x_anno
y_anno_off += y_anno
# print(f"... {xx} {yy} {anno_dist}")
x_anno_offs.append(x_anno_off)
y_anno_offs.append(y_anno_off)
anno_labels.append(label)
if do_label:
ax.annotate(label, xy=(x_anno+labelpos[0], y_anno+labelpos[1]), rotation=labelrot,
horizontalalignment='left', verticalalignment='bottom', color=(0.2,0.2,0.2))
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# init arrays to hold annotation points for label spreading
def vplot_anno_init ():
global x_annos, y_annos, x_anno_offs, y_anno_offs, anno_labels
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# Number of ticks on volumetric depth axis
max_depth_log = 22
# average transpile factor between base QV depth and our depth based on results from QV notebook
QV_transpile_factor = 12.7
# format a number using K,M,B,T for large numbers, optionally rounding to 'digits' decimal places if num > 1
# (sign handling may be incorrect)
def format_number(num, digits=0):
if isinstance(num, str): num = float(num)
num = float('{:.3g}'.format(abs(num)))
sign = ''
metric = {'T': 1000000000000, 'B': 1000000000, 'M': 1000000, 'K': 1000, '': 1}
for index in metric:
num_check = num / metric[index]
if num_check >= 1:
num = round(num_check, digits)
sign = index
break
numstr = f"{str(num)}"
if '.' in numstr:
numstr = numstr.rstrip('0').rstrip('.')
return f"{numstr}{sign}"
# Return the color associated with the spcific value, using color map norm
def get_color(value):
# if there is a normalize function installed, scale the data
if cmap_norm:
value = float(cmap_norm(value))
if cmap == cmap_spectral:
value = 0.05 + value*0.9
elif cmap == cmap_blues:
value = 0.00 + value*1.0
else:
value = 0.0 + value*0.95
return cmap(value)
# Return the x and y equivalent to a single pixel for the given plot axis
def get_pixel_dims(ax):
# transform 0 -> 1 to pixel dimensions
pixdims = ax.transData.transform([(0,1),(1,0)])-ax.transData.transform((0,0))
xpix = pixdims[1][0]
ypix = pixdims[0][1]
#determine x- and y-axis dimension for one pixel
dx = (1 / xpix)
dy = (1 / ypix)
return (dx, dy)
############### Helper functions
# return the base index for a circuit depth value
# take the log in the depth base, and add 1
def depth_index(d, depth_base):
if depth_base <= 1:
return d
if d == 0:
return 0
return math.log(d, depth_base) + 1
# draw a box at x,y with various attributes
def box_at(x, y, value, type=1, fill=True, x_size=1.0, y_size=1.0, alpha=1.0, zorder=1):
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Rectangle((x - (x_size/2), y - (y_size/2)), x_size, y_size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5*y_size,
zorder=zorder)
# draw a circle at x,y with various attributes
def circle_at(x, y, value, type=1, fill=True):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Circle((x, y), size/2,
alpha = 0.7, # DEVNOTE: changed to 0.7 from 0.5, to handle only one cell
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5)
def box4_at(x, y, value, type=1, fill=True, alpha=1.0):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.3,0.3,0.3)
ec = fc
return Rectangle((x - size/8, y - size/2), size/4, size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.1)
# Draw a Quantum Volume rectangle with specified width and depth, and grey-scale value
def qv_box_at(x, y, qv_width, qv_depth, value, depth_base):
#print(f"{qv_width} {qv_depth} {depth_index(qv_depth, depth_base)}")
return Rectangle((x - 0.5, y - 0.5), depth_index(qv_depth, depth_base), qv_width,
edgecolor = (value,value,value),
facecolor = (value,value,value),
fill=True,
lw=1)
def bkg_box_at(x, y, value=0.9):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (value,value,value),
fill=True,
lw=0.5)
def bkg_empty_box_at(x, y):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (1.0,1.0,1.0),
fill=True,
lw=0.5)
# Plot the background for the volumetric analysis
def plot_volumetric_background(max_qubits=11, QV=32, depth_base=2, suptitle=None, avail_qubits=0, colorbar_label="Avg Result Fidelity"):
if suptitle == None:
suptitle = f"Volumetric Positioning\nCircuit Dimensions and Fidelity Overlaid on Quantum Volume = {QV}"
QV0 = QV
qv_estimate = False
est_str = ""
if QV == 0: # QV = 0 indicates "do not draw QV background or label"
QV = 2048
elif QV < 0: # QV < 0 indicates "add est. to label"
QV = -QV
qv_estimate = True
est_str = " (est.)"
if avail_qubits > 0 and max_qubits > avail_qubits:
max_qubits = avail_qubits
max_width = 13
if max_qubits > 11: max_width = 18
if max_qubits > 14: max_width = 20
if max_qubits > 16: max_width = 24
if max_qubits > 24: max_width = 33
#print(f"... {avail_qubits} {max_qubits} {max_width}")
plot_width = 6.8
plot_height = 0.5 + plot_width * (max_width / max_depth_log)
#print(f"... {plot_width} {plot_height}")
# define matplotlib figure and axis; use constrained layout to fit colorbar to right
fig, ax = plt.subplots(figsize=(plot_width, plot_height), constrained_layout=True)
plt.suptitle(suptitle)
plt.xlim(0, max_depth_log)
plt.ylim(0, max_width)
# circuit depth axis (x axis)
xbasis = [x for x in range(1,max_depth_log)]
xround = [depth_base**(x-1) for x in xbasis]
xlabels = [format_number(x) for x in xround]
ax.set_xlabel('Circuit Depth')
ax.set_xticks(xbasis)
plt.xticks(xbasis, xlabels, color='black', rotation=45, ha='right', va='top', rotation_mode="anchor")
# other label options
#plt.xticks(xbasis, xlabels, color='black', rotation=-60, ha='left')
#plt.xticks(xbasis, xlabels, color='black', rotation=-45, ha='left', va='center', rotation_mode="anchor")
# circuit width axis (y axis)
ybasis = [y for y in range(1,max_width)]
yround = [1,2,3,4,5,6,7,8,10,12,15] # not used now
ylabels = [str(y) for y in yround] # not used now
#ax.set_ylabel('Circuit Width (Number of Qubits)')
ax.set_ylabel('Circuit Width')
ax.set_yticks(ybasis)
#create simple line plot (not used right now)
#ax.plot([0, 10],[0, 10])
log2QV = math.log2(QV)
QV_width = log2QV
QV_depth = log2QV * QV_transpile_factor
# show a quantum volume rectangle of QV = 64 e.g. (6 x 6)
if QV0 != 0:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.87, depth_base))
else:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.91, depth_base))
# the untranspiled version is commented out - we do not show this by default
# also show a quantum volume rectangle un-transpiled
# ax.add_patch(qv_box_at(1, 1, QV_width, QV_width, 0.80, depth_base))
# show 2D array of volumetric cells based on this QV_transpiled
# DEVNOTE: we use +1 only to make the visuals work; s/b without
# Also, the second arg of the min( below seems incorrect, needs correction
maxprod = (QV_width + 1) * (QV_depth + 1)
for w in range(1, min(max_width, round(QV) + 1)):
# don't show VB squares if width greater than known available qubits
if avail_qubits != 0 and w > avail_qubits:
continue
i_success = 0
for d in xround:
# polarization factor for low circuit widths
maxtest = maxprod / ( 1 - 1 / (2**w) )
# if circuit would fail here, don't draw box
if d > maxtest: continue
if w * d > maxtest: continue
# guess for how to capture how hardware decays with width, not entirely correct
# # reduce maxtext by a factor of number of qubits > QV_width
# # just an approximation to account for qubit distances
# if w > QV_width:
# over = w - QV_width
# maxtest = maxtest / (1 + (over/QV_width))
# draw a box at this width and depth
id = depth_index(d, depth_base)
# show vb rectangles; if not showing QV, make all hollow (or less dark)
if QV0 == 0:
#ax.add_patch(bkg_empty_box_at(id, w))
ax.add_patch(bkg_box_at(id, w, 0.95))
else:
ax.add_patch(bkg_box_at(id, w, 0.9))
# save index of last successful depth
i_success += 1
# plot empty rectangle after others
d = xround[i_success]
id = depth_index(d, depth_base)
ax.add_patch(bkg_empty_box_at(id, w))
# Add annotation showing quantum volume
if QV0 != 0:
t = ax.text(max_depth_log - 2.0, 1.5, f"QV{est_str}={QV}", size=12,
horizontalalignment='right', verticalalignment='center', color=(0.2,0.2,0.2),
bbox=dict(boxstyle="square,pad=0.3", fc=(.9,.9,.9), ec="grey", lw=1))
# add colorbar to right of plot
plt.colorbar(cm.ScalarMappable(cmap=cmap), cax=None, ax=ax,
shrink=0.6, label=colorbar_label, panchor=(0.0, 0.7))
return ax
# Function to calculate circuit depth
def calculate_circuit_depth(qc):
# Calculate the depth of the circuit
depth = qc.depth()
return depth
def calculate_transpiled_depth(qc,basis_selector):
# use either the backend or one of the basis gate sets
if basis_selector == 0:
qc = transpile(qc, backend)
else:
basis_gates = basis_gates_array[basis_selector]
qc = transpile(qc, basis_gates=basis_gates, seed_transpiler=0)
transpiled_depth = qc.depth()
return transpiled_depth,qc
def plot_fidelity_data(fidelity_data, Hf_fidelity_data, title):
avg_fidelity_means = []
avg_Hf_fidelity_means = []
avg_num_qubits_values = list(fidelity_data.keys())
# Calculate the average fidelity and Hamming fidelity for each unique number of qubits
for num_qubits in avg_num_qubits_values:
avg_fidelity = np.average(fidelity_data[num_qubits])
avg_fidelity_means.append(avg_fidelity)
avg_Hf_fidelity = np.mean(Hf_fidelity_data[num_qubits])
avg_Hf_fidelity_means.append(avg_Hf_fidelity)
return avg_fidelity_means,avg_Hf_fidelity_means
list_of_gates = []
def list_of_standardgates():
import qiskit.circuit.library as lib
from qiskit.circuit import Gate
import inspect
# List all the attributes of the library module
gate_list = dir(lib)
# Filter out non-gate classes (like functions, variables, etc.)
gates = [gate for gate in gate_list if isinstance(getattr(lib, gate), type) and issubclass(getattr(lib, gate), Gate)]
# Get method names from QuantumCircuit
circuit_methods = inspect.getmembers(QuantumCircuit, inspect.isfunction)
method_names = [name for name, _ in circuit_methods]
# Map gate class names to method names
gate_to_method = {}
for gate in gates:
gate_class = getattr(lib, gate)
class_name = gate_class.__name__.replace('Gate', '').lower() # Normalize class name
for method in method_names:
if method == class_name or method == class_name.replace('cr', 'c-r'):
gate_to_method[gate] = method
break
# Add common operations that are not strictly gates
additional_operations = {
'Measure': 'measure',
'Barrier': 'barrier',
}
gate_to_method.update(additional_operations)
for k,v in gate_to_method.items():
list_of_gates.append(v)
def update_counts(gates,custom_gates):
operations = {}
for key, value in gates.items():
operations[key] = value
for key, value in custom_gates.items():
if key in operations:
operations[key] += value
else:
operations[key] = value
return operations
def get_gate_counts(gates,custom_gate_defs):
result = gates.copy()
# Iterate over the gate counts in the quantum circuit
for gate, count in gates.items():
if gate in custom_gate_defs:
custom_gate_ops = custom_gate_defs[gate]
# Multiply custom gate operations by the count of the custom gate in the circuit
for _ in range(count):
result = update_counts(result, custom_gate_ops)
# Remove the custom gate entry as we have expanded it
del result[gate]
return result
dict_of_qc = dict()
custom_gates_defs = dict()
# Function to count operations recursively
def count_operations(qc):
circuit_traverser(qc)
operations = dict()
operations = dict_of_qc[qc.name]
del dict_of_qc[qc.name]
# print("operations :",operations)
# print("dict_of_qc :",dict_of_qc)
for keys in operations.keys():
if keys not in list_of_gates:
for k,v in dict_of_qc.items():
if k in operations.keys():
custom_gates_defs[k] = v
operations=get_gate_counts(operations,custom_gates_defs)
custom_gates_defs.clear()
return operations
def circuit_traverser(qc):
dict_of_qc[qc.name]=dict(qc.count_ops())
for i in qc.data:
if str(i.operation.name) not in list_of_gates:
qc_1 = i.operation.definition
circuit_traverser(qc_1)
def get_memory():
import resource
usage = resource.getrusage(resource.RUSAGE_SELF)
max_mem = usage.ru_maxrss/1024 #in MB
return max_mem
def analyzer(num_qubits,s_int):
input_size = num_qubits-1
secret_int = int(s_int)
# 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}
return correct_dist
def run (min_qubits=min_qubits, max_qubits=max_qubits, skip_qubits=skip_qubits,
max_circuits=max_circuits, num_shots=num_shots):
creation_times = []
elapsed_times = []
quantum_times = []
circuit_depths = []
transpiled_depths = []
fidelity_data = {}
Hf_fidelity_data = {}
numckts = []
mem_usage = []
algorithmic_1Q_gate_counts = []
algorithmic_2Q_gate_counts = []
transpiled_1Q_gate_counts = []
transpiled_2Q_gate_counts = []
print(f"{benchmark_name} Benchmark Program - {platform}")
#defining all the standard gates supported by qiskit in a list
if gate_counts_plots == True:
list_of_standardgates()
# 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)
# 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
global max_ckts
max_ckts = max_circuits
global min_qbits,max_qbits,skp_qubits
min_qbits = min_qubits
max_qbits = max_qubits
skp_qubits = skip_qubits
print(f"min, max qubits = {min_qubits} {max_qubits}")
# Execute Benchmark Program N times for multiple circuit sizes
for num_qubits in range(min_qubits, max_qubits + 1, skip_qubits):
input_size = num_qubits - 1
fidelity_data[num_qubits] = []
Hf_fidelity_data[num_qubits] = []
num_circuits = min(2**(input_size), max_circuits)
print(f"Executing [{num_circuits}] circuits with num_qubits = {num_qubits}")
numckts.append(num_circuits)
# 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)
for s_int in s_range:
print("*********************************************")
if input_value is not None:
s_int = input_value
# 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)
print(f"qc of {num_qubits} qubits with secret integer {s_int}")
#creation of Quantum Circuit.
ts = time.time()
qc = BersteinVazirani(num_qubits, s_int, method)
#creation time
creation_time = time.time() - ts
creation_times.append(creation_time)
#print(qc)
print(f"creation time = {creation_time*1000} ms")
# Calculate gate count for the algorithmic circuit (excluding barriers and measurements)
if gate_counts_plots == True:
operations = count_operations(qc)
n1q = 0; n2q = 0
if operations != None:
for key, value in operations.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c") or key.startswith("mc"):
n2q += value
else:
n1q += value
algorithmic_1Q_gate_counts.append(n1q)
algorithmic_2Q_gate_counts.append(n2q)
# collapse the sub-circuit levels used in this benchmark (for qiskit)
qc=qc.decompose()
#print(qc)
# Calculate circuit depth
depth = calculate_circuit_depth(qc)
circuit_depths.append(depth)
# Calculate transpiled circuit depth
transpiled_depth,qc = calculate_transpiled_depth(qc,basis_selector)
transpiled_depths.append(transpiled_depth)
#print(qc)
print(f"Algorithmic Depth = {depth} and Normalized Depth = {transpiled_depth}")
if gate_counts_plots == True:
# Calculate gate count for the transpiled circuit (excluding barriers and measurements)
tr_ops = qc.count_ops()
#print("tr_ops = ",tr_ops)
tr_n1q = 0; tr_n2q = 0
if tr_ops != None:
for key, value in tr_ops.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c"): tr_n2q += value
else: tr_n1q += value
transpiled_1Q_gate_counts.append(tr_n1q)
transpiled_2Q_gate_counts.append(tr_n2q)
print(f"Algorithmic 1Q gates = {n1q} ,Algorithmic 2Q gates = {n2q}")
print(f"Normalized 1Q gates = {tr_n1q} ,Normalized 2Q gates = {tr_n2q}")
#execution
if Type_of_Simulator == "built_in":
#To check if Noise is required
if Noise_Inclusion == True:
noise_model = noise_parameters
else:
noise_model = None
ts = time.time()
job = execute(qc, backend, shots=num_shots, noise_model=noise_model)
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2" :
ts = time.time()
job = backend.run(qc,shots=num_shots, noise_model=noise_parameters)
#retrieving the result
result = job.result()
#print(result)
#calculating elapsed time
elapsed_time = time.time() - ts
elapsed_times.append(elapsed_time)
# Calculate quantum processing time
quantum_time = result.time_taken
quantum_times.append(quantum_time)
print(f"Elapsed time = {elapsed_time*1000} ms and Quantum Time = {quantum_time *1000} ms")
#counts in result object
counts = result.get_counts()
#Correct distribution to compare with counts
correct_dist = analyzer(num_qubits, s_int)
#fidelity calculation comparision of counts and correct_dist
fidelity_dict = polarization_fidelity(counts, correct_dist)
fidelity_data[num_qubits].append(fidelity_dict['fidelity'])
Hf_fidelity_data[num_qubits].append(fidelity_dict['hf_fidelity'])
#maximum memory utilization (if required)
if Memory_utilization_plot == True:
max_mem = get_memory()
print(f"Maximum Memory Utilized: {max_mem} MB")
mem_usage.append(max_mem)
print("*********************************************")
# 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!")
return (creation_times, elapsed_times, quantum_times, circuit_depths, transpiled_depths,
fidelity_data, Hf_fidelity_data, numckts , algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts,
transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage)
# Execute the benchmark program, accumulate metrics, and calculate circuit depths
(creation_times, elapsed_times, quantum_times, circuit_depths,transpiled_depths, fidelity_data, Hf_fidelity_data, numckts,
algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts, transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage) = run()
# Define the range of qubits for the x-axis
num_qubits_range = range(min_qbits, max_qbits+1,skp_qubits)
print("num_qubits_range =",num_qubits_range)
# Calculate average creation time, elapsed time, quantum processing time, and circuit depth for each number of qubits
avg_creation_times = []
avg_elapsed_times = []
avg_quantum_times = []
avg_circuit_depths = []
avg_transpiled_depths = []
avg_1Q_algorithmic_gate_counts = []
avg_2Q_algorithmic_gate_counts = []
avg_1Q_Transpiled_gate_counts = []
avg_2Q_Transpiled_gate_counts = []
max_memory = []
start = 0
for num in numckts:
avg_creation_times.append(np.mean(creation_times[start:start+num]))
avg_elapsed_times.append(np.mean(elapsed_times[start:start+num]))
avg_quantum_times.append(np.mean(quantum_times[start:start+num]))
avg_circuit_depths.append(np.mean(circuit_depths[start:start+num]))
avg_transpiled_depths.append(np.mean(transpiled_depths[start:start+num]))
if gate_counts_plots == True:
avg_1Q_algorithmic_gate_counts.append((np.mean(algorithmic_1Q_gate_counts[start:start+num])))
avg_2Q_algorithmic_gate_counts.append((np.mean(algorithmic_2Q_gate_counts[start:start+num])))
avg_1Q_Transpiled_gate_counts.append((np.mean(transpiled_1Q_gate_counts[start:start+num])))
avg_2Q_Transpiled_gate_counts.append((np.mean(transpiled_2Q_gate_counts[start:start+num])))
if Memory_utilization_plot == True:max_memory.append(np.max(mem_usage[start:start+num]))
start += num
# Calculate the fidelity data
avg_f, avg_Hf = plot_fidelity_data(fidelity_data, Hf_fidelity_data, "Fidelity Comparison")
# Plot histograms for average creation time, average elapsed time, average quantum processing time, and average circuit depth versus the number of qubits
# Add labels to the bars
def autolabel(rects,ax,str='{:.3f}',va='top',text_color="black"):
for rect in rects:
height = rect.get_height()
ax.annotate(str.format(height), # Formatting to two decimal places
xy=(rect.get_x() + rect.get_width() / 2, height / 2),
xytext=(0, 0),
textcoords="offset points",
ha='center', va=va,color=text_color,rotation=90)
bar_width = 0.3
# Determine the number of subplots and their arrangement
if Memory_utilization_plot and gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6, ax7) = plt.subplots(7, 1, figsize=(18, 30))
# Plotting for both memory utilization and gate counts
# ax1, ax2, ax3, ax4, ax5, ax6, ax7 are available
elif Memory_utilization_plot:
fig, (ax1, ax2, ax3, ax6, ax7) = plt.subplots(5, 1, figsize=(18, 30))
# Plotting for memory utilization only
# ax1, ax2, ax3, ax6, ax7 are available
elif gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6) = plt.subplots(6, 1, figsize=(18, 30))
# Plotting for gate counts only
# ax1, ax2, ax3, ax4, ax5, ax6 are available
else:
fig, (ax1, ax2, ax3, ax6) = plt.subplots(4, 1, figsize=(18, 30))
# Default plotting
# ax1, ax2, ax3, ax6 are available
fig.suptitle(f"General Benchmarks : {platform} - {benchmark_name}", fontsize=16)
for i in range(len(avg_creation_times)): #converting seconds to milli seconds by multiplying 1000
avg_creation_times[i] *= 1000
ax1.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax1.bar(num_qubits_range, avg_creation_times, color='deepskyblue')
autolabel(ax1.patches, ax1)
ax1.set_xlabel('Number of Qubits')
ax1.set_ylabel('Average Creation Time (ms)')
ax1.set_title('Average Creation Time vs Number of Qubits',fontsize=14)
ax2.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
for i in range(len(avg_elapsed_times)): #converting seconds to milli seconds by multiplying 1000
avg_elapsed_times[i] *= 1000
for i in range(len(avg_quantum_times)): #converting seconds to milli seconds by multiplying 1000
avg_quantum_times[i] *= 1000
Elapsed= ax2.bar(np.array(num_qubits_range) - bar_width / 2, avg_elapsed_times, width=bar_width, color='cyan', label='Elapsed Time')
Quantum= ax2.bar(np.array(num_qubits_range) + bar_width / 2, avg_quantum_times,width=bar_width, color='deepskyblue',label ='Quantum Time')
autolabel(Elapsed,ax2,str='{:.1f}')
autolabel(Quantum,ax2,str='{:.1f}')
ax2.set_xlabel('Number of Qubits')
ax2.set_ylabel('Average Time (ms)')
ax2.set_title('Average Time vs Number of Qubits')
ax2.legend()
ax3.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized = ax3.bar(np.array(num_qubits_range) - bar_width / 2, avg_transpiled_depths, color='cyan', label='Normalized Depth', width=bar_width) # Adjust width here
Algorithmic = ax3.bar(np.array(num_qubits_range) + bar_width / 2,avg_circuit_depths, color='deepskyblue', label='Algorithmic Depth', width=bar_width) # Adjust width here
autolabel(Normalized,ax3,str='{:.2f}')
autolabel(Algorithmic,ax3,str='{:.2f}')
ax3.set_xlabel('Number of Qubits')
ax3.set_ylabel('Average Circuit Depth')
ax3.set_title('Average Circuit Depth vs Number of Qubits')
ax3.legend()
if gate_counts_plots == True:
ax4.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_1Q_counts = ax4.bar(np.array(num_qubits_range) - bar_width / 2, avg_1Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_1Q_counts = ax4.bar(np.array(num_qubits_range) + bar_width / 2, avg_1Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_1Q_counts,ax4,str='{}')
autolabel(Algorithmic_1Q_counts,ax4,str='{}')
ax4.set_xlabel('Number of Qubits')
ax4.set_ylabel('Average 1-Qubit Gate Counts')
ax4.set_title('Average 1-Qubit Gate Counts vs Number of Qubits')
ax4.legend()
ax5.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_2Q_counts = ax5.bar(np.array(num_qubits_range) - bar_width / 2, avg_2Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_2Q_counts = ax5.bar(np.array(num_qubits_range) + bar_width / 2, avg_2Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_2Q_counts,ax5,str='{}')
autolabel(Algorithmic_2Q_counts,ax5,str='{}')
ax5.set_xlabel('Number of Qubits')
ax5.set_ylabel('Average 2-Qubit Gate Counts')
ax5.set_title('Average 2-Qubit Gate Counts vs Number of Qubits')
ax5.legend()
ax6.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Hellinger = ax6.bar(np.array(num_qubits_range) - bar_width / 2, avg_Hf, width=bar_width, label='Hellinger Fidelity',color='cyan') # Adjust width here
Normalized = ax6.bar(np.array(num_qubits_range) + bar_width / 2, avg_f, width=bar_width, label='Normalized Fidelity', color='deepskyblue') # Adjust width here
autolabel(Hellinger,ax6,str='{:.2f}')
autolabel(Normalized,ax6,str='{:.2f}')
ax6.set_xlabel('Number of Qubits')
ax6.set_ylabel('Average Value')
ax6.set_title("Fidelity Comparison")
ax6.legend()
if Memory_utilization_plot == True:
ax7.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax7.bar(num_qubits_range, max_memory, color='turquoise', width=bar_width, label="Memory Utilizations")
autolabel(ax7.patches, ax7)
ax7.set_xlabel('Number of Qubits')
ax7.set_ylabel('Maximum Memory Utilized (MB)')
ax7.set_title('Memory Utilized vs Number of Qubits',fontsize=14)
plt.tight_layout(rect=[0, 0, 1, 0.96])
if saveplots == True:
plt.savefig("ParameterPlotsSample.jpg")
plt.show()
# Quantum Volume Plot
Suptitle = f"Volumetric Positioning - {platform}"
appname=benchmark_name
if QV_ == None:
QV=2048
else:
QV=QV_
depth_base =2
ax = plot_volumetric_background(max_qubits=max_qbits, QV=QV,depth_base=depth_base, suptitle=Suptitle, colorbar_label="Avg Result Fidelity")
w_data = num_qubits_range
# determine width for circuit
w_max = 0
for i in range(len(w_data)):
y = float(w_data[i])
w_max = max(w_max, y)
d_tr_data = avg_transpiled_depths
f_data = avg_f
plot_volumetric_data(ax, w_data, d_tr_data, f_data, depth_base, fill=True,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, w_max=w_max)
anno_volumetric_data(ax, depth_base,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, fill=False)
|
https://github.com/menegolli/Quantum_synth
|
menegolli
|
from qiskit import *
import numpy as np
import operator
import socket
import argparse
import random
import time
import logging
from backends_select import ChooseBackEnd
from SuperpositionGates import *
from RenormalizeProbability import *
from pythonosc import udp_client
UDP_IP_SERVER="127.0.0.1"#change this accordingly
UDP_PORT_SERVER=7001
# global functions
log = logging.getLogger('udp_server')
def sender(results,name):
parser = argparse.ArgumentParser()
parser.add_argument("--ip", default=UDP_IP_SERVER,
help="The ip of the OSC server")
parser.add_argument("--port", type=int, default=7000,
help="The port the OSC server is listening on")
args = parser.parse_args()
client = udp_client.SimpleUDPClient(args.ip, args.port)
# for k in sorted(results):
# print(k, results[k])
# client.send_message(k, results[k])
client.send_message(name, results)
return True
def server(host='0.0.0.0', port=UDP_PORT_SERVER):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
log.info("Listening on udp %s:%s" % (host, port))
s.bind((host, port))
return s
def grover4(target, backendType, RealDeviceName,noisePresent=False,number=12):
listForMusic = GroverSequence(target=target, initialLength=4, backendType=backendType, RealDeviceName=RealDeviceName, noisePresent=noisePresent)
message = ""
for k in listForMusic:
# ii = 0
print(k)
if number== 12:
k=RedistributeCell(k)
print(k)
for l in k:
message = message + str(l) + " "
# ii = ii + 1
# if ii == 12:
# print(ii)
# break
print(message)
sender(results=message, name="grover")
def hadamard(backendType, RealDeviceName, noisePresent,numberShots,number=12):
circuit=QuantumCircuit(4,4)
Hadamard(circuit, listOfQubits=range(4))
listForMusic = ChooseBackEnd(circuit, backendType=backendType, qubitsToBeMeasured=range(4), numberShots=numberShots, noisePresent=noisePresent, RealDeviceName=RealDeviceName,number=number)
print(listForMusic)
if number==12:
listForMusic = RedistributeCell(listForMusic)
print(listForMusic)
sender(results=listForMusic, name="prob")
del(circuit)
def Bell(backendType, RealDeviceName, noisePresent,numberShots,number=12):
circuit=QuantumCircuit(4,4)
BellStateGenerationTwoQubits(circuit)
listForMusic = ChooseBackEnd(circuit, backendType=backendType, qubitsToBeMeasured=range(4), numberShots=numberShots, noisePresent=noisePresent, RealDeviceName=RealDeviceName)
print(listForMusic)
if number==12:
listForMusic = RedistributeCell(listForMusic)
print(listForMusic)
sender(results=listForMusic, name="prob")
del(circuit)
def SeperPosition(backendType, RealDeviceName, noisePresent,numberShots,number=12,notes=range(4)):
circuit=QuantumCircuit(4,4)
ChooseEqualSuperposition(circuit,states=notes)#we have to check togather
listForMusic = ChooseBackEnd(circuit, backendType=backendType, qubitsToBeMeasured=range(4), numberShots=numberShots, noisePresent=noisePresent, RealDeviceName=RealDeviceName)
print(listForMusic)
if number==12:
listForMusic = RedistributeCell(listForMusic)
print(listForMusic)
sender(results=listForMusic, name="prob")
del(circuit)
if __name__ == '__main__':
# app.run()
# test=hello_world()
FORMAT_CONS = '%(asctime)s %(name)-12s %(levelname)8s\t%(message)s'
logging.basicConfig(level=logging.DEBUG, format=FORMAT_CONS)
# music = QuantumCircuit(4,4)
# ['qasm_simulator', 'ibmq_16_melbourne', 'ChooseEqualSuperposition', '1936', '0']
s=server()
while True:
while True:
(mystr, addr) = s.recvfrom(128*1024)
print("Message from MAX:{}".format(mystr))
mystr=str(mystr)
mystr = mystr.split("'")
mystr = mystr[1]
mystr = mystr.split("stop")
mystr = mystr[0]
mystr = mystr.split("run")
mystr = mystr[1]
mystr=mystr.strip()
mystr = mystr.split(" ")
print(mystr)
#targ=format(3,'#06b')[2:]
targ=mystr[6]
targ="0"*(4-len(targ))+targ
print(targ)
# listForMusic = ChooseBackEnd(music, backendType=mystr[0], qubitsToBeMeasured=range(4), numberShots=int(mystr[3]), noisePresent=True, RealDeviceName=mystr[1])
if mystr[4]=='1':
noise=True
elif mystr[4]=='1':
noise=False
else:
noise=False
print(int(mystr[6],2))
if mystr[2]=="Hadamard":
hadamard(backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,numberShots=int(mystr[3]),number=int(mystr[5]))
elif mystr[2]=="BellStateGenerationTwoQubits":
Bell(backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,numberShots=int(mystr[3]),number=int(mystr[5]))
elif mystr[2]=="ChooseEqualSuperposition":
SeperPosition(backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,numberShots=int(mystr[3]),number=int(mystr[5]))
elif mystr[2]=="Grover":
grover4(target=targ, backendType=mystr[0], RealDeviceName=mystr[1], noisePresent=noise,number=int(mystr[5]))
else:
print("Command Not defined")
|
https://github.com/Dynamic-Vector/Qubit-Visualizer
|
Dynamic-Vector
|
from tkinter import *
import tkinter as tk
import numpy as np
from qiskit import QuantumCircuit
from qiskit.visualization import visualize_transition
from tkinter import LEFT,END,DISABLED,NORMAL
import warnings
warnings.filterwarnings('ignore')
#Initalize the Quantum circuit
def initialize_circuit():
"""
Initializes the Quantum Circuit
"""
global circuit
circuit=QuantumCircuit(1)
initialize_circuit()
theta=0
#Define Display Function
def display_gate(gate_input):
"""
Adds a corresponding gate notation in the display to track the operations.
If the number of operation reach ten,all gate buttons are disabled.
"""
#Insert the defined gate
display.insert(END,gate_input)
#Check if the number of operations has reached ten,if yes,
#disable all the gate buttons
input_gates = display.get()
num_gates_pressed = len(input_gates)
list_input_gates= list(input_gates)
search_word = ["R","D"]
count_double_valued_gates = [list_input_gates.count(i) for i in search_word]
num_gates_pressed -= sum(count_double_valued_gates)
if num_gates_pressed == 10:
gates=[x,y,z,s,sd,h,t,td]
for gate in gates:
gate.config(state=DISABLED)
#Define Del Function
def clear(circuit):
"""
clears the display!
Reintializes the Quantum circuit for fresh calculation!
Checks if the gate buttons are disabled,if so,enables the buttons
"""
#clear the display
display.delete(0,END)
#reset the circuit to initial state |0>
initialize_circuit()
#Checks if the buttons are disabled and if so,enables them
if x['state']== DISABLED:
gates=[x,y,z,s,sd,h,t,td]
for gate in gates:
gate.config(state=NORMAL)
def user_input(circuit,key):
"""Take the user input for rotation for paramaterized
Rotation gates Rx,Ry,Rz
"""
#Initialize adn define the properties of window
get=tk.Tk()
get.title("Enter theta")
get.geometry("320x80")
get.resizable(0,0)
val1=tk.Button(get,height=2,width=10,text="PI/4",command=lambda:change_theta(0.25,get,circuit,key))
val1.grid(row=0,column=0)
val2=tk.Button(get,height=2,width=10,text="PI/2",command=lambda:change_theta(0.50,get,circuit,key))
val2.grid(row=0,column=1)
val3=tk.Button(get,height=2,width=10,text="PI",command=lambda:change_theta(1.0,get,circuit,key))
val3.grid(row=0,column=2)
val4=tk.Button(get,height=2,width=10,text="2*PI",command=lambda:change_theta(2.0,get,circuit,key))
val4.grid(row=0,column=3,sticky='w')
val5=tk.Button(get,height=2,width=10,text="-PI/4",command=lambda:change_theta(-0.25,get,circuit,key))
val5.grid(row=1,column=0)
val6=tk.Button(get,height=2,width=10,text="-PI/2",command=lambda:change_theta(-0.50,get,circuit,key))
val6.grid(row=1,column=1)
val7=tk.Button(get,height=2,width=10,text="-PI",command=lambda:change_theta(-1.0,get,circuit,key))
val7.grid(row=1,column=2)
val8=tk.Button(get,height=2,width=10,text="-2*PI",command=lambda:change_theta(-2.0,get,circuit,key))
val8.grid(row=1,column=3,sticky='w')
get.mainloop()
def change_theta(num,window,circuit,key):
global theta
theta = num* np.pi
if key=='x':
circuit.rx(theta,0)
thera=0
elif key=='y':
circuit.ry(theta,0)
theta=0
else :
circuit.rz(theta,0)
theta=0
window.destroy()
#Attributes
background='#2c94c8'
buttons='#d9d9d9'
special_buttons='#bc3454'
button_font=('Roboto',18,)
display_font=('Roboto',28)
#Define Window
window = tk.Tk()
window.iconbitmap(default='res/logo.ico')
window.title("Quantum Labs")
window.geometry("816x560")
window.configure(bg = "#ffffff")
canvas = Canvas(
window,
bg = "#ffffff",
height = 560,
width = 816,
bd = 0,
highlightthickness = 0,
relief = "ridge")
canvas.place(x = 0, y = 0)
background_img = PhotoImage(file = f"res/background.png")
background = canvas.create_image(
260, 279,
image=background_img)
#Add the display
text_box_bg = tk.PhotoImage("res/TextBox_Bg.png")
display_img = canvas.create_image(650.5, 267.5, image=text_box_bg)
display = tk.Entry(bd=0, bg="#bfc0de",font=display_font, highlightthickness=0)
display.place(x=485, y=125, width=270, height=45)
#Add the buttons
x = Button(
window,
text = "X",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('X'),circuit.x(0)])
x.place(x = 485, y = 200
, width = 60, height = 30)
y= Button(
window,
text = "Y",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('Y'),circuit.y(0)])
y.place(x = 590, y = 200
, width = 60, height = 30)
z= Button(
window,
text = "Z",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('Z'),circuit.z(0)])
z.place(x = 695, y = 200
, width = 60, height = 30)
s= Button(
window,
text = "S",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('S'),circuit.s(0)])
s.place(x = 485, y = 275
, width = 60, height = 30)
sd= Button(
window,
text = "SD",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('SD'),circuit.sdg(0)])
sd.place(x = 590, y = 275
, width = 60, height = 30)
h= Button(
window,
text = "H",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('H'),circuit.h(0)])
h.place(x = 695, y = 275
, width = 60, height = 30)
rx= Button(
window,
text = "RX",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('RX'),user_input(circuit, 'x')])
rx.place(x = 485, y = 350
, width = 60, height = 30)
ry= Button(
window,
text = "RY",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('RY'),user_input(circuit, 'y')])
ry.place(x = 590, y = 350,
width = 60, height = 30)
rz= Button(
window,
text = "RZ",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('RZ'),user_input(circuit, 'z')])
rz.place(x = 695, y = 350,
width = 60, height = 30)
t= Button(
window,
text = "T",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('T'),circuit.t(0)])
t.place(x = 485, y = 425
, width = 60, height = 30)
td= Button(
window,
text = "TD",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:[display_gate('TD'),circuit.tdg(0)])
td.place(x = 590, y = 425,
width = 60, height = 30)
clean = Button(
window,
text = "DEL",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command=lambda:clear(circuit))
clean.place(x = 695, y = 425
, width = 60, height = 30)
visualize = Button(
window,
text = "VISUALIZE",
font = button_font,
bg = buttons,
bd = 0,
highlightthickness = 0,
relief = "ridge",
command =lambda:visualize_transition(circuit,trace=False,saveas=None,spg=2,fpg=100))
visualize.place(x = 540, y = 490
, width = 160, height = 40)
window.resizable(False, False)
window.mainloop()
|
https://github.com/ctuning/ck-qiskit
|
ctuning
|
#--------------------------------------------------------------------------------------------------------------
# This module contains basic gates that can be used while developing circuits on IBM QExperience
#--------------------------------------------------------------------------------------------------------------
#--------------------------------------------------------------------------------------------------------------
# Import necessary modules
#--------------------------------------------------------------------------------------------------------------
from qiskit import QuantumProgram
import Qconfig
#--------------------------------------------------------------------------------------------------------------
# The CSWAP gate
# Input : Quantum program object, the Circuit name, the quantum register name, control bit number and target
# bit numbers.
# Output : Quantum_program_object with the relevant connections
# Circuit implemented - CSWAP
#--------------------------------------------------------------------------------------------------------------
def CSWAP(Quantum_program_object,Circuit_name,Quantum_register_name,Control_bit_number,Target_bit_numbers):
# Get the circuit and the quantum register by name
qc = Quantum_program_object.get_circuit(Circuit_name)
qr = Quantum_program_object.get_quantum_register(Quantum_register_name)
# Get control bit numbers and the target bit number for the addressing the qubits
Control = Control_bit_number
Target_1 = Target_bit_numbers[0]
Target_2 = Target_bit_numbers[1]
# Implement CSWAP using 3 CCNOT implementations
# Implement CCNOT on Control,Target_1 and Target_2 using decomposition given by Nelson and Chuang
qc.h(qr[Target_2])
qc.cx(qr[Target_1],qr[Target_2])
qc.tdg(qr[Target_2])
qc.cx(qr[Control],qr[Target_2])
qc.t(qr[Target_2])
qc.cx(qr[Target_1],qr[Target_2])
qc.tdg(qr[Target_2])
qc.cx(qr[Control],qr[Target_2])
qc.tdg(qr[Target_1])
qc.t(qr[Target_2])
qc.h(qr[Target_2])
qc.cx(qr[Control],qr[Target_1])
qc.tdg(qr[Target_1])
qc.cx(qr[Control],qr[Target_1])
qc.t(qr[Control])
qc.s(qr[Target_1])
# Implement CCNOT on Control,Target_2 and Target_1 using decomposition given by Nelson and Chuang
qc.h(qr[Target_1])
qc.cx(qr[Target_2],qr[Target_1])
qc.tdg(qr[Target_1])
qc.cx(qr[Control],qr[Target_1])
qc.t(qr[Target_1])
qc.cx(qr[Target_2],qr[Target_1])
qc.tdg(qr[Target_1])
qc.cx(qr[Control],qr[Target_1])
qc.tdg(qr[Target_2])
qc.t(qr[Target_1])
qc.h(qr[Target_1])
qc.cx(qr[Control],qr[Target_2])
qc.tdg(qr[Target_2])
qc.cx(qr[Control],qr[Target_2])
qc.t(qr[Control])
qc.s(qr[Target_2])
# Implement CCNOT on Control,Target_1 and Target_2 using decomposition given by Nelson and Chuang
qc.h(qr[Target_2])
qc.cx(qr[Target_1],qr[Target_2])
qc.tdg(qr[Target_2])
qc.cx(qr[Control],qr[Target_2])
qc.t(qr[Target_2])
qc.cx(qr[Target_1],qr[Target_2])
qc.tdg(qr[Target_2])
qc.cx(qr[Control],qr[Target_2])
qc.tdg(qr[Target_1])
qc.t(qr[Target_2])
qc.h(qr[Target_2])
qc.cx(qr[Control],qr[Target_1])
qc.tdg(qr[Target_1])
qc.cx(qr[Control],qr[Target_1])
qc.t(qr[Control])
qc.s(qr[Target_1])
# Return the program object
return Quantum_program_object
#--------------------------------------------------------------------------------------------------------------
# The CCNOT gate
# Input : Quantum program object, the Circuit name, the quantum register name, control bit numbers and target
# bit number.
# Output : Quantum_program_object with the relevant connections
# Circuit implemented - CCNOT
#--------------------------------------------------------------------------------------------------------------
def CCNOT(Quantum_program_object,Circuit_name,Quantum_register_name,Control_bit_numbers,Target_bit_number):
# Get the circuit and the quantum register by name
qc = Quantum_program_object.get_circuit(Circuit_name)
qr = Quantum_program_object.get_quantum_register(Quantum_register_name)
# Get control bit numbers and the target bit number for the addressing the qubits
Control_1 = Control_bit_numbers[0]
Control_2 = Control_bit_numbers[1]
Target = Target_bit_number
# Implement Hadamard on target qubits
qc.h(qr[Target])
# Implement CNOT between Control_2 and Target
qc.cx(qr[Control_2],qr[Target])
# Implement T (dagger) on target qubits
qc.tdg(qr[Target])
# Implement CNOT between Control_1 and Target
qc.cx(qr[Control_1],qr[Target])
# Implement T on target qubits
qc.t(qr[Target])
# Implement CNOT between Control_2 and Target
qc.cx(qr[Control_2],qr[Target])
# Implement T (dagger) on target qubits
qc.tdg(qr[Target])
# Implement CNOT between Control_1 and Target
qc.cx(qr[Control_1],qr[Target])
# Implement T (dagger) on Control_2, T and H on Target
qc.tdg(qr[Control_2])
qc.t(qr[Target])
qc.h(qr[Target])
# Implement CNOT from Control_1 to Control_2 followed by T (dagger) on Control_2
qc.cx(qr[Control_1],qr[Control_2])
qc.tdg(qr[Control_2])
# Implement CNOT from Control_1 to Control_2 followed by T on Control_1 and S on Control_2
qc.cx(qr[Control_1],qr[Control_2])
qc.t(qr[Control_1])
qc.s(qr[Control_2])
# Return the program object
return Quantum_program_object
|
https://github.com/snow0369/qiskit_tutorial_2021_summerschool
|
snow0369
|
import numpy as np
from qiskit import transpile, QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.algorithms.phase_estimators import PhaseEstimation
from qiskit.providers.aer import AerProvider
from qiskit.tools.visualization import plot_histogram
from qiskit.utils import QuantumInstance
num_unitary_qubits = 2
unitary_qubit = QuantumRegister(num_unitary_qubits)
unitary_circuit = QuantumCircuit(unitary_qubit)
for i in range(num_unitary_qubits):
unitary_circuit.rx(0.5*np.pi, i)
for i in range(num_unitary_qubits - 1):
unitary_circuit.cx(i, i+1)
for i in range(num_unitary_qubits):
unitary_circuit.rz(0.5*np.pi, i)
print("depth = ", unitary_circuit.depth())
unitary_circuit.draw('mpl')
state_prep = QuantumCircuit(unitary_qubit)
state_prep.h(unitary_qubit)
state_prep.draw('mpl')
num_evaluation_qubits = 3
qasm_backend = AerProvider().get_backend("qasm_simulator")
qpe = PhaseEstimation(num_evaluation_qubits=num_evaluation_qubits,
quantum_instance=QuantumInstance(backend=qasm_backend,
shots=4096,
optimization_level=3))
ckt = qpe.construct_circuit(unitary_circuit, state_preparation=state_prep)
ckt = transpile(ckt, backend=qasm_backend)
print(f"depth = {ckt.depth()}")
ckt.draw('mpl')
res = qpe.estimate(unitary_circuit, state_prep)
plot_histogram(res.phases)
phase_list = sorted(res.phases.keys(), key=lambda x: res.phases[x], reverse=True)
for p in sorted(phase_list):
bin_p = int(p, 2) / 2**num_evaluation_qubits
print(f"phase[rad] : {2*bin_p*np.pi}, occurence : {res.phases[p]}")
unitary_simulator = AerProvider().get_backend('unitary_simulator')
job_unitary = unitary_simulator.run(unitary_circuit)
mat = job_unitary.result().get_unitary()
print(mat)
eigval, eigvec = np.linalg.eig(mat)
assert all(np.isclose(np.abs(eigval), 1.0))
eigph = np.angle(eigval)
for i, p in enumerate(eigph):
if p < 0:
eigph[i] = 2*np.pi + p
print("eig phase = ", sorted(eigph))
for i, v in enumerate(eigvec):
print(f"eigvec {i} = {v/np.linalg.norm(v, ord=2)}")
from qiskit.test.mock import FakeRome
fake_rome = FakeRome()
# 측정게이트 추가
eval_qubits = ckt.qregs[0]
creg = ClassicalRegister(len(eval_qubits))
ckt.add_register(creg)
ckt.measure(eval_qubits, creg)
ckt_lv0 = transpile(ckt, backend=fake_rome, optimization_level=0)
ckt_lv1 = transpile(ckt, backend=fake_rome, optimization_level=1)
ckt_lv2 = transpile(ckt, backend=fake_rome, optimization_level=2)
ckt_lv3 = transpile(ckt, backend=fake_rome, optimization_level=3)
for i, ckt_opt in enumerate([ckt_lv0, ckt_lv1, ckt_lv2, ckt_lv3]):
cnot_count = ckt_opt.count_ops()['cx'] if 'cx' in ckt_opt.count_ops() else 0
print(f"opt_level={i}, depth={ckt_opt.depth()}, cnot_count={cnot_count}")
|
https://github.com/Keerthiraj-Nagaraj/IBM-quantum-challenge-2020
|
Keerthiraj-Nagaraj
|
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
from qiskit.visualization import plot_bloch_multivector
# If you run this code outside IBM Quantum Experience,
# run the following commands to store your API token locally.
# Please refer https://qiskit.org/documentation/install.html#access-ibm-quantum-systems
# IBMQ.save_account('MY_API_TOKEN')
# Loading your IBM Q account(s)
IBMQ.load_account()
# Let's do an X-gate on a |0> qubit
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.x(q[0])
qc.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result().get_statevector(qc, decimals=3)
plot_bloch_multivector(result)
# Let's do an H-gate on a |0> qubit
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q[0])
qc.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result().get_statevector(qc, decimals=3)
plot_bloch_multivector(result)
# Let's do an Z-gate on |+>
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q[0])
qc.z(q[0])
qc.draw(output='mpl')
# Let's see the result
backend = Aer.get_backend('statevector_simulator')
result = execute(qc, backend).result().get_statevector(qc, decimals=3)
plot_bloch_multivector(result)
# Let's do an CX-gate on |00>
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cx(q[0],q[1])
qc.draw(output='mpl')
# Let's do an CZ-gate on |00>
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.cz(q[0],q[1])
qc.draw(output='mpl')
# Let's make CZ-gate with CX-gate and H-gate
q = QuantumRegister(2)
qc = QuantumCircuit(q)
qc.h(q[1])
qc.cx(q[0],q[1])
qc.h(q[1])
qc.draw(output='mpl')
# Let's do an CCX-gate on |000>
q = QuantumRegister(3)
qc = QuantumCircuit(q)
qc.ccx(q[0],q[1],q[2])
qc.draw(output='mpl')
# Create a Quantum Circuit with 1 quantum register and 1 classical register
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.x(q[0])
qc.measure(q[0], c[0]) # Map the quantum measurement to the classical bits
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.ccx(q[0], q[1], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.ccx(q[0], q[1], q[2])
qc.x(q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.ccx(q[0], q[1], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
q = QuantumRegister(3)
c = ClassicalRegister(1)
qc = QuantumCircuit(q,c)
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.ccx(q[0], q[1], q[2])
qc.x(q[2])
qc.measure(q[2], c[0])
qc.draw(output='mpl')
#Define registers and a quantum circuit
q = QuantumRegister(4)
c = ClassicalRegister(2)
qc = QuantumCircuit(q,c)
#XOR
qc.cx(q[1], q[2])
qc.cx(q[0], q[2])
qc.barrier()
#AND
qc.ccx(q[0], q[1], q[3])
qc.barrier()
#Sum
qc.measure(q[2], c[0])
#Carry out
qc.measure(q[3], c[1])
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer, execute
from qiskit.quantum_info import Pauli, state_fidelity, process_fidelity
q = QuantumRegister(4, 'q0')
c = ClassicalRegister(1, 'c0')
qc = QuantumCircuit(q, c)
qc.ccx(q[0], q[1], q[2])
qc.cx(q[3], q[1])
qc.h(q[3])
qc.ccx(q[3], q[2], q[1])
qc.measure(q[3],c[0])
qc.draw(output='mpl')
qc.count_ops()
from qiskit.transpiler import PassManager
from qiskit.transpiler.passes import Unroller
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
new_circuit.draw(output='mpl')
new_circuit.count_ops()
q = QuantumRegister(3, 'q0')
c = ClassicalRegister(1, 'c0')
qc = QuantumCircuit(q, c)
qc.ccx(q[0], q[1], q[2])
qc.draw(output='mpl')
pass_ = Unroller(['u3', 'cx'])
pm = PassManager(pass_)
new_circuit = pm.run(qc)
new_circuit.draw(output='mpl')
new_circuit.count_ops()
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit import IBMQ, Aer, execute
##### build your quantum circuit here
# execute the circuit by qasm_simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend, shots=1000)
result = job.result()
count =result.get_counts()
print(count)
qc.draw(output='mpl')
# Check your answer using following code
from qc_grader import grade_ex1a
grade_ex1a(qc)
# Submit your answer. You can re-submit at any time.
from qc_grader import submit_ex1a
submit_ex1a(qc)
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Utils for reading a user preference config files."""
import configparser
import os
from qiskit import exceptions
DEFAULT_FILENAME = os.path.join(os.path.expanduser("~"),
'.qiskit', 'settings.conf')
class UserConfig:
"""Class representing a user config file
The config file format should look like:
[default]
circuit_drawer = mpl
"""
def __init__(self, filename=None):
"""Create a UserConfig
Args:
filename (str): The path to the user config file. If one isn't
specified ~/.qiskit/settings.conf is used.
"""
if filename is None:
self.filename = DEFAULT_FILENAME
else:
self.filename = filename
self.settings = {}
self.config_parser = configparser.ConfigParser()
def read_config_file(self):
"""Read config file and parse the contents into the settings attr."""
if not os.path.isfile(self.filename):
return
self.config_parser.read(self.filename)
if 'default' in self.config_parser.sections():
circuit_drawer = self.config_parser.get('default',
'circuit_drawer')
if circuit_drawer:
if circuit_drawer not in ['text', 'mpl', 'latex',
'latex_source']:
raise exceptions.QiskitUserConfigError(
"%s is not a valid circuit drawer backend. Must be "
"either 'text', 'mpl', 'latex', or 'latex_source'"
% circuit_drawer)
self.settings['circuit_drawer'] = circuit_drawer
def get_config():
"""Read the config file from the default location or env var
It will read a config file at either the default location
~/.qiskit/settings.conf or if set the value of the QISKIT_SETTINGS env var.
It will return the parsed settings dict from the parsed config file.
Returns:
dict: The settings dict from the parsed config file.
"""
filename = os.getenv('QISKIT_SETTINGS', DEFAULT_FILENAME)
if not os.path.isfile(filename):
return {}
user_config = UserConfig(filename)
user_config.read_config_file()
return user_config.settings
|
https://github.com/nielsaNTNU/qiskit_utilities
|
nielsaNTNU
|
import qiskit.tools.jupyter
import matplotlib as ml
from GenerateRandomCircuit import *
backends_dict={}
backendname_sim = 'qasm_simulator'
backends_dict[backendname_sim] = Aer.get_backend(backendname_sim)
#load IBMQ account
#IBMQ.save_account('yourAPItoken')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
for backendname in ['ibmq_16_melbourne', 'ibmqx2']:
backends_dict[backendname] = provider.get_backend(backendname)
G_qasm_simulator=createGraph(backends_dict['qasm_simulator'],5)
nx.draw_networkx(G_qasm_simulator)
G_ibmqx2=createGraph(backends_dict['ibmqx2'])
nx.draw_networkx(G_ibmqx2)
G_melbourne=createGraph(backends_dict['ibmq_16_melbourne'])
nx.draw_networkx(G_melbourne)
circ = randomCircuit(G_ibmqx2)
circ.draw(output='mpl')
circ = randomCircuit(G_ibmqx2, cnots=9)
circ.draw(output='mpl')
circ = randomCircuit(G_ibmqx2, depth=10)
circ.draw(output='mpl')
circ = randomCircuit(G_ibmqx2, cnots=13, depth=2)
circ.draw(output='mpl')
circ = randomCircuit(G_ibmqx2, cnots=3, depth=9)
circ.draw(output='mpl')
circ = randomCircuit(G_ibmqx2, cnots=14, depth=9)
circ.draw(output='mpl')
circ = randomCircuit(G_ibmqx2, cnots=14, depth=9, barrier=True)
circ.draw(output='mpl')
circ = randomCircuit(G_ibmqx2, cnots=16, depth=33)
circ.draw(output='mpl')
circ = randomCircuit(G_qasm_simulator, depth=10)
circ.draw(output='mpl')
circ = randomCircuit(G_melbourne, depth=10)
circ.draw(output='mpl')
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import re
import itertools
import numpy as np
import random
random.seed(42)
import mitiq
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.ignis.mitigation import expectation_value
# Pauli Twirling
def pauli_twirling(circ: QuantumCircuit) -> QuantumCircuit:
"""
[internal function]
This function takes a quantum circuit and return a new quantum circuit with Pauli Twirling around the CNOT gates.
Args:
circ: QuantumCircuit
Returns:
QuantumCircuit
"""
def apply_pauli(num: int, qb: int) -> str:
if (num == 0):
return f''
elif (num == 1):
return f'x q[{qb}];\n'
elif (num == 2):
return f'y q[{qb}];\n'
else:
return f'z q[{qb}];\n'
paulis = [(i,j) for i in range(0,4) for j in range(0,4)]
paulis.remove((0,0))
paulis_map = [(0, 1), (3, 2), (3, 3), (1, 1), (1, 0), (2, 3), (2, 2), (2, 1), (2, 0), (1, 3), (1, 2), (3, 0), (3, 1), (0, 2), (0, 3)]
new_circ = ''
ops = circ.qasm().splitlines(True) #! split the quantum circuit into qasm operators
for op in ops:
if (op[:2] == 'cx'): # add Pauli Twirling around the CNOT gate
num = random.randrange(len(paulis))
qbs = re.findall('q\[(.)\]', op)
new_circ += apply_pauli(paulis[num][0], qbs[0])
new_circ += apply_pauli(paulis[num][1], qbs[1])
new_circ += op
new_circ += apply_pauli(paulis_map[num][0], qbs[0])
new_circ += apply_pauli(paulis_map[num][1], qbs[1])
else:
new_circ += op
return QuantumCircuit.from_qasm_str(new_circ)
def zne_wrapper(qcs, scale_factors = [1.0, 2.0, 3.0], pt = False):
"""
This function outputs the circuit list for zero-noise extrapolation.
Args:
qcs: List[QuantumCircuit], the input quantum circuits.
scale_factors: List[float], to what extent the noise scales are investigated.
pt: bool, whether add Pauli Twirling or not.
Returns:
folded_qcs: List[QuantumCircuit]
"""
folded_qcs = [] #! ZNE用の回路
for qc in qcs:
folded_qcs.append([mitiq.zne.scaling.fold_gates_at_random(qc, scale) for scale in scale_factors]) #! ここでmitiqを使用
folded_qcs = list(itertools.chain(*folded_qcs)) #! folded_qcsを平坦化
if pt:
folded_qcs = [pauli_twirling(circ) for circ in folded_qcs]
return folded_qcs
def make_stf_basis(n, basis_elements = ["X","Y","Z"]):
"""
[internal function]
This function outputs all the combinations of length n string for given basis_elements.
When basis_elements is X, Y, and Z (default), the output becomes the n-qubit Pauli basis.
Args:
n: int
basis_elements: List[str]
Returns:
basis: List[str]
"""
if n == 1:
return basis_elements
basis = []
for i in basis_elements:
sub_basis = make_stf_basis(n - 1, basis_elements)
basis += [i + j for j in sub_basis]
return basis
def reduce_hist(hist, poses):
"""
[internal function]
This function returns the reduced histogram to the designated positions.
Args:
hist: Dict[str, float]
poses: List[int]
Returns:
ret_hist: Dict[str, float]
"""
n = len(poses)
ret_hist = {format(i, "0" + str(n) + "b"): 0 for i in range(1 << n)}
for k, v in hist.items():
pos = ""
for i in range(n):
pos += k[poses[i]]
ret_hist[pos] += v
return ret_hist
def make_stf_expvals(n, stf_hists):
"""
[internal function]
This function create the expectations under expanded basis, which are used to reconstruct the density matrix.
Args:
n: int, the size of classical register in the measurement results.
stf_hists: List[Dict[str, float]], the input State Tomography Fitter histograms.
Returns:
st_expvals: List[float], the output State Tomography expectation values.
"""
assert len(stf_hists) == 3 ** n
stf_basis = make_stf_basis(n, basis_elements=["X","Y","Z"])
st_basis = make_stf_basis(n, basis_elements=["I","X","Y","Z"])
stf_hists_dict = {basis: hist for basis, hist in zip(stf_basis, stf_hists)}
st_hists_dict = {basis: stf_hists_dict.get(basis, None) for basis in st_basis}
# remaining
for basis in sorted(set(st_basis) - set(stf_basis)):
if basis == "I" * n:
continue
reduction_poses = []
reduction_basis = ""
for i, b in enumerate(basis):
if b != "I":
reduction_poses.append(n - 1 - i) # big endian
reduction_basis += b # こっちはそのまま(なぜならラベルはlittle endianだから)
else:
reduction_basis += "Z"
st_hists_dict[basis] = reduce_hist(stf_hists_dict[reduction_basis], reduction_poses)
st_expvals = dict()
for basis, hist in st_hists_dict.items():
if basis == "I" * n:
st_expvals[basis] = 1.0
continue
st_expvals[basis], _ = expectation_value(hist)
return st_expvals
def zne_decoder(n, result, scale_factors=[1.0, 2.0, 3.0], fac_type="lin"):
"""
This function applies the zero-noise extrapolation to the measured results and output the mitigated zero-noise expectation values.
Args:
n: int, the size of classical register in the measurement results.
result: Result, the returned results from job.
scale_factors: List[float], this should be the same as the zne_wrapper.
fac_type: str, "lin" or "exp", whether to use LinFactory option or ExpFactory option in mitiq, to extrapolate the expectation values.
Returns:
zne_expvals: List[float], the mitigated zero-noise expectation values.
"""
hists = result.get_counts()
num_scale_factors = len(scale_factors)
assert len(hists) % num_scale_factors == 0
scale_wise_expvals = [] # num_scale_factors * 64
for i in range(num_scale_factors):
scale_wise_hists = [hists[3 * j + i] for j in range(len(hists) // num_scale_factors)]
st_expvals = make_stf_expvals(n, scale_wise_hists)
scale_wise_expvals.append( list(st_expvals.values()) )
scale_wise_expvals = np.array(scale_wise_expvals)
linfac = mitiq.zne.inference.LinearFactory(scale_factors)
expfac = mitiq.zne.ExpFactory(scale_factors)
zne_expvals = []
for i in range(4 ** n):
if fac_type == "lin":
zne_expvals.append( linfac.extrapolate(scale_factors, scale_wise_expvals[:, i]) )
else:
zne_expvals.append( expfac.extrapolate(scale_factors, scale_wise_expvals[:, i]) )
return zne_expvals
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from scipy.interpolate import griddata
%matplotlib inline
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, AncillaRegister, transpile
from qiskit.algorithms import IterativeAmplitudeEstimation, EstimationProblem
from qiskit.circuit.library import WeightedAdder, LinearAmplitudeFunction
from qiskit_aer.primitives import Sampler
from qiskit_finance.circuit.library import LogNormalDistribution
# number of qubits per dimension to represent the uncertainty
num_uncertainty_qubits = 2
# parameters for considered random distribution
S = 2.0 # initial spot price
vol = 0.4 # volatility of 40%
r = 0.05 # annual interest rate of 4%
T = 40 / 365 # 40 days to maturity
# resulting parameters for log-normal distribution
mu = (r - 0.5 * vol**2) * T + np.log(S)
sigma = vol * np.sqrt(T)
mean = np.exp(mu + sigma**2 / 2)
variance = (np.exp(sigma**2) - 1) * np.exp(2 * mu + sigma**2)
stddev = np.sqrt(variance)
# lowest and highest value considered for the spot price; in between, an equidistant discretization is considered.
low = np.maximum(0, mean - 3 * stddev)
high = mean + 3 * stddev
# map to higher dimensional distribution
# for simplicity assuming dimensions are independent and identically distributed)
dimension = 2
num_qubits = [num_uncertainty_qubits] * dimension
low = low * np.ones(dimension)
high = high * np.ones(dimension)
mu = mu * np.ones(dimension)
cov = sigma**2 * np.eye(dimension)
# construct circuit
u = LogNormalDistribution(num_qubits=num_qubits, mu=mu, sigma=cov, bounds=list(zip(low, high)))
# plot PDF of uncertainty model
x = [v[0] for v in u.values]
y = [v[1] for v in u.values]
z = u.probabilities
# z = map(float, z)
# z = list(map(float, z))
resolution = np.array([2**n for n in num_qubits]) * 1j
grid_x, grid_y = np.mgrid[min(x) : max(x) : resolution[0], min(y) : max(y) : resolution[1]]
grid_z = griddata((x, y), z, (grid_x, grid_y))
plt.figure(figsize=(10, 8))
ax = plt.axes(projection="3d")
ax.plot_surface(grid_x, grid_y, grid_z, cmap=plt.cm.Spectral)
ax.set_xlabel("Spot Price $S_T^1$ (\$)", size=15)
ax.set_ylabel("Spot Price $S_T^2$ (\$)", size=15)
ax.set_zlabel("Probability (\%)", size=15)
plt.show()
# determine number of qubits required to represent total loss
weights = []
for n in num_qubits:
for i in range(n):
weights += [2**i]
# create aggregation circuit
agg = WeightedAdder(sum(num_qubits), weights)
n_s = agg.num_sum_qubits
n_aux = agg.num_qubits - n_s - agg.num_state_qubits # number of additional qubits
# set the strike price (should be within the low and the high value of the uncertainty)
strike_price = 3.5
# map strike price from [low, high] to {0, ..., 2^n-1}
max_value = 2**n_s - 1
low_ = low[0]
high_ = high[0]
mapped_strike_price = (
(strike_price - dimension * low_) / (high_ - low_) * (2**num_uncertainty_qubits - 1)
)
# set the approximation scaling for the payoff function
c_approx = 0.25
# setup piecewise linear objective fcuntion
breakpoints = [0, mapped_strike_price]
slopes = [0, 1]
offsets = [0, 0]
f_min = 0
f_max = 2 * (2**num_uncertainty_qubits - 1) - mapped_strike_price
basket_objective = LinearAmplitudeFunction(
n_s,
slopes,
offsets,
domain=(0, max_value),
image=(f_min, f_max),
rescaling_factor=c_approx,
breakpoints=breakpoints,
)
# define overall multivariate problem
qr_state = QuantumRegister(u.num_qubits, "state") # to load the probability distribution
qr_obj = QuantumRegister(1, "obj") # to encode the function values
ar_sum = AncillaRegister(n_s, "sum") # number of qubits used to encode the sum
ar = AncillaRegister(max(n_aux, basket_objective.num_ancillas), "work") # additional qubits
objective_index = u.num_qubits
basket_option = QuantumCircuit(qr_state, qr_obj, ar_sum, ar)
basket_option.append(u, qr_state)
basket_option.append(agg, qr_state[:] + ar_sum[:] + ar[:n_aux])
basket_option.append(basket_objective, ar_sum[:] + qr_obj[:] + ar[: basket_objective.num_ancillas])
print(basket_option.draw())
print("objective qubit index", objective_index)
# plot exact payoff function (evaluated on the grid of the uncertainty model)
x = np.linspace(sum(low), sum(high))
y = np.maximum(0, x - strike_price)
plt.plot(x, y, "r-")
plt.grid()
plt.title("Payoff Function", size=15)
plt.xlabel("Sum of Spot Prices ($S_T^1 + S_T^2)$", size=15)
plt.ylabel("Payoff", size=15)
plt.xticks(size=15, rotation=90)
plt.yticks(size=15)
plt.show()
# evaluate exact expected value
sum_values = np.sum(u.values, axis=1)
exact_value = np.dot(
u.probabilities[sum_values >= strike_price],
sum_values[sum_values >= strike_price] - strike_price,
)
print("exact expected value:\t%.4f" % exact_value)
num_state_qubits = basket_option.num_qubits - basket_option.num_ancillas
print("state qubits: ", num_state_qubits)
transpiled = transpile(basket_option, basis_gates=["u", "cx"])
print("circuit width:", transpiled.width())
print("circuit depth:", transpiled.depth())
basket_option_measure = basket_option.measure_all(inplace=False)
sampler = Sampler()
job = sampler.run(basket_option_measure)
# evaluate the result
value = 0
probabilities = job.result().quasi_dists[0].binary_probabilities()
for i, prob in probabilities.items():
if prob > 1e-4 and i[-num_state_qubits:][0] == "1":
value += prob
# map value to original range
mapped_value = (
basket_objective.post_processing(value) / (2**num_uncertainty_qubits - 1) * (high_ - low_)
)
print("Exact Operator Value: %.4f" % value)
print("Mapped Operator value: %.4f" % mapped_value)
print("Exact Expected Payoff: %.4f" % exact_value)
# set target precision and confidence level
epsilon = 0.01
alpha = 0.05
problem = EstimationProblem(
state_preparation=basket_option,
objective_qubits=[objective_index],
post_processing=basket_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)
/ (2**num_uncertainty_qubits - 1)
* (high_ - low_)
)
print("Exact value: \t%.4f" % exact_value)
print(
"Estimated value: \t%.4f"
% (result.estimation_processed / (2**num_uncertainty_qubits - 1) * (high_ - low_))
)
print("Confidence interval:\t[%.4f, %.4f]" % tuple(conf_int))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeAuckland
backend = FakeAuckland()
ghz = QuantumCircuit(15)
ghz.h(0)
ghz.cx(0, range(1, 15))
ghz.draw(output='mpl')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit.tools.visualization import plot_histogram
import random
circ = QuantumCircuit(40, 40)
# Initialize with a Hadamard layer
circ.h(range(40))
# Apply some random CNOT and T gates
qubit_indices = [i for i in range(40)]
for i in range(10):
control, target, t = random.sample(qubit_indices, 3)
circ.cx(control, target)
circ.t(t)
circ.measure(range(40), range(40))
# Create statevector method simulator
statevector_simulator = AerSimulator(method='statevector')
# Transpile circuit for backend
tcirc = transpile(circ, statevector_simulator)
# Try and run circuit
statevector_result = statevector_simulator.run(tcirc, shots=1).result()
print('This succeeded?: {}'.format(statevector_result.success))
print('Why not? {}'.format(statevector_result.status))
# Create extended stabilizer method simulator
extended_stabilizer_simulator = AerSimulator(method='extended_stabilizer')
# Transpile circuit for backend
tcirc = transpile(circ, extended_stabilizer_simulator)
extended_stabilizer_result = extended_stabilizer_simulator.run(tcirc, shots=1).result()
print('This succeeded?: {}'.format(extended_stabilizer_result.success))
small_circ = QuantumCircuit(2, 2)
small_circ.h(0)
small_circ.cx(0, 1)
small_circ.t(0)
small_circ.measure([0, 1], [0, 1])
# This circuit should give 00 or 11 with equal probability...
expected_results ={'00': 50, '11': 50}
tsmall_circ = transpile(small_circ, extended_stabilizer_simulator)
result = extended_stabilizer_simulator.run(
tsmall_circ, shots=100).result()
counts = result.get_counts(0)
print('100 shots in {}s'.format(result.time_taken))
plot_histogram([expected_results, counts],
legend=['Expected', 'Extended Stabilizer'])
# Add runtime options for extended stabilizer simulator
opts = {'extended_stabilizer_approximation_error': 0.03}
reduced_error = extended_stabilizer_simulator.run(
tsmall_circ, shots=100, **opts).result()
reduced_error_counts = reduced_error.get_counts(0)
print('100 shots in {}s'.format(reduced_error.time_taken))
plot_histogram([expected_results, reduced_error_counts],
legend=['Expected', 'Extended Stabilizer'])
print("The circuit above, with 100 shots at precision 0.03 "
"and default mixing time, needed {}s".format(int(reduced_error.time_taken)))
opts = {
'extended_stabilizer_approximation_error': 0.03,
'extended_stabilizer_mixing_time': 100
}
optimized = extended_stabilizer_simulator.run(
tsmall_circ, shots=100, **opts).result()
print('Dialing down the mixing time, we completed in just {}s'.format(optimized.time_taken))
# We set these options here only to make the example run more quickly.
opts = {'extended_stabilizer_mixing_time': 100}
multishot = extended_stabilizer_simulator.run(
tcirc, shots=100, **opts).result()
print("100 shots took {} s".format(multishot.time_taken))
opts = {
'extended_stabilizer_measure_sampling': True,
'extended_stabilizer_mixing_time': 100
}
measure_sampling = extended_stabilizer_simulator.run(
circ, shots=100, **opts).result()
print("With the optimization, 100 shots took {} s".format(result.time_taken))
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
#!/usr/bin/env python
# coding: utf-8
# In[1]:
from qiskit.test.ibmq_mock import mock_get_backend
mock_get_backend('FakeVigo')
# In[2]:
from qiskit import IBMQ
from qiskit.providers.ibmq.visualization import iplot_error_map
IBMQ.load_account()
provider = IBMQ.get_provider(group='open', project='main')
backend = provider.get_backend('ibmq_vigo')
iplot_error_map(backend, as_widget=True)
|
https://github.com/mspronesti/qlearnkit
|
mspronesti
|
from qiskit import QuantumCircuit
from typing import Optional
class SwaptestCircuit(QuantumCircuit):
r"""
Constructs a swap test circuit employing a controlled
swap:
.. parsed-literal::
┌───┐ ┌───┐┌─┐
q_0: ────┤ H ├─────■─┤ H ├┤M├
┌───┴───┴───┐ │ └───┘└╥┘
q_1: ┤ circuit-0 ├─X───────╫─
├───────────┤ │ ║
q_2: ┤ circuit-1 ├─X───────╫─
└───────────┘ ║
c: 1/══════════════════════╩═
0
A swap test circuit allows to measure the fidelity between two quantum
states, which can be interpreted as a distance measure of some sort.
In other words, given two quanutm states :math:`|\alpha\rangle, \ |\beta\rangle`,
it measures how symmetric the state :math:`|\alpha\rangle \otimes |\beta\rangle` is
"""
def __init__(self,
qc_state_1: QuantumCircuit,
qc_state_2: QuantumCircuit,
name: Optional[str] = None):
n_total = qc_state_1.num_qubits + qc_state_2.num_qubits
super().__init__(n_total + 1, 1, name=name)
range_qc1 = [i + 1 for i in range(qc_state_1.num_qubits)]
range_qc2 = [i + qc_state_1.num_qubits + 1 for i in range(qc_state_1.num_qubits)]
self.compose(qc_state_1, range_qc1, inplace=True)
self.compose(qc_state_2, range_qc2, inplace=True)
# first apply hadamard
self.h(0)
# then perform controlled swaps
for index, qubit in enumerate(range_qc1):
self.cswap(0, qubit, range_qc2[index])
# eventually reapply hadamard
self.h(0)
# Measurement on the auxiliary qubit
self.barrier()
self.measure(0, 0)
|
https://github.com/TheGupta2012/QPE-Algorithms
|
TheGupta2012
|
from qiskit.providers.ibmq.managed import IBMQJobManager
from qiskit import IBMQ
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q-education')
from qiskit import QuantumCircuit, execute, transpile, Aer
from qiskit.extensions import UnitaryGate,Initialize
from qiskit.quantum_info import Statevector
from qiskit.tools.visualization import plot_bloch_vector
from qiskit.tools.visualization import plot_histogram,plot_bloch_multivector
import numpy as np
from time import sleep
import sys
sys.path.append("..")
from scipy.stats import unitary_group
import matplotlib.pyplot as plt
%matplotlib inline
from Modules.changed_SPEA import bundled_changed_SPEA
q = QuantumCircuit(2)
q.cp(2*np.pi*(1/9),0,1)
q.draw('mpl')
spe = bundled_changed_SPEA(q,resolution=20,error = 3,max_iters=10)
jakarta = provider.get_backend('ibmq_jakarta')
thetas = []
for k in range(5):
result = spe.get_eigen_pair(backend=jakarta,progress=True)
print("Result is :",result)
thetas.append(result['theta'])
thetas
plt.title("Plot for returned Eigenvalues",fontsize = 16)
plt.xlabel("Experiment number")
plt.ylabel("Eigenvalues")
plt.plot([0,6],[0,0],color = 'black')
plt.plot([0,6],[1,1],color = 'black')
plt.plot([0,6],[0.111,0.111],color = 'black')
plt.plot(list(range(5)), thetas, label = 'Estimates', color = 'cyan', linewidth = 2, marker = 's')
plt.legend()
plt.grid()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
circ = QuantumCircuit(2, 2)
circ.h(0)
circ.cx(0, 1)
circ.measure(0, 0)
circ.measure(1, 1)
circ.draw('mpl')
from qiskit import pulse
from qiskit.pulse.library import Gaussian
from qiskit.providers.fake_provider import FakeValencia
backend = FakeValencia()
with pulse.build(backend, name='hadamard') as h_q0:
pulse.play(Gaussian(duration=128, amp=0.1, sigma=16), pulse.drive_channel(0))
h_q0.draw()
circ.add_calibration('h', [0], h_q0)
from qiskit import transpile
from qiskit.providers.fake_provider import FakeHanoi
backend = FakeHanoi()
circ = transpile(circ, backend)
print(backend.configuration().basis_gates)
circ.draw('mpl', idle_wires=False)
from qiskit import QuantumCircuit
from qiskit.circuit import Gate
circ = QuantumCircuit(1, 1)
custom_gate = Gate('my_custom_gate', 1, [3.14, 1])
# 3.14 is an arbitrary parameter for demonstration
circ.append(custom_gate, [0])
circ.measure(0, 0)
circ.draw('mpl')
with pulse.build(backend, name='custom') as my_schedule:
pulse.play(Gaussian(duration=64, amp=0.2, sigma=8), pulse.drive_channel(0))
circ.add_calibration('my_custom_gate', [0], my_schedule, [3.14, 1])
# Alternatively: circ.add_calibration(custom_gate, [0], my_schedule)
circ = transpile(circ, backend)
circ.draw('mpl', idle_wires=False)
circ = QuantumCircuit(2, 2)
circ.append(custom_gate, [1])
from qiskit import QiskitError
try:
circ = transpile(circ, backend)
except QiskitError as e:
print(e)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/JanLahmann/RasQberry
|
JanLahmann
|
#!/usr/bin/env python
# coding: utf-8
# Credits: https://github.com/wmazin/Visualizing-Quantum-Computing-using-fractals
# |
# | Library imports
# └───────────────────────────────────────────────────────────────────────────────────────────────────────
# Importing standard python libraries
from threading import Thread
from pathlib import Path
from typing import Optional
from copy import deepcopy
from io import BytesIO
import traceback
import timeit
import sys
# Externally installed libraries
import matplotlib.pyplot as plt
import numpy as np
from selenium.common.exceptions import WebDriverException, NoSuchWindowException
from selenium.webdriver.common.by import By
from celluloid import Camera
from numpy import complex_, complex64, ndarray, ushort, bool_
from PIL import Image
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit
from qiskit.visualization import plot_bloch_multivector
# self-coded libraries
from fractal_webclient import WebClient
from fractal_julia_calculations import JuliaSet
from fractal_quantum_circuit import QuantumFractalCircuit
# |
# | Global settings for the script
# └───────────────────────────────────────────────────────────────────────────────────────────────────────
# Julia set calculation values
julia_iterations: int = 100
julia_escape_val: int = 2
# Image generation and animation values
GIF_ms_intervals: int = 200 # 200ms = 5 fps
number_of_frames: int = 60 # Total number of frames to generate
# Coordinate values in the Julia Set fractal image/frame
frame_resolution: int = 200 # Height and width
height: int = frame_resolution
width: int = frame_resolution
zoom: float = 1.0
x_start: float = 0
x_width: float = 1.5
x_min: float = x_start - x_width / zoom
x_max: float = x_start + x_width / zoom
y_start: float = 0
y_width: float = 1.5
y_min: float = y_start - y_width / zoom
y_max: float = y_start + y_width / zoom
# Create the basis 2D array for the fractal
x_arr = np.linspace(start=x_min, stop=x_max, num=width).reshape((1, width))
y_arr = np.linspace(start=y_min, stop=y_max, num=height).reshape((height, 1))
z_arr = np.array(x_arr + 1j * y_arr, dtype=complex64)
# Create array to keep track in which iteration the points have diverged
div_arr = np.zeros(z_arr.shape, dtype=np.uint8)
# Create Array to keep track on which points have not converged
con_arr = np.full(z_arr.shape, True, dtype=bool_)
# Dictionary to keep track of time pr. loop
timer = {"QuantumCircuit": 0.0, "Julia_calculations": 0.0, "Animation": 0.0, "Image": 0.0, "Bloch_data": 0.0}
acc_timer = timer
# |
# | Pathing, default folder and generated files, webclient
# └───────────────────────────────────────────────────────────────────────────────────────────────────────
# Set default path values
temp_image_folder = Path(Path.cwd(), "img")
browser_file_path = f"file://{temp_image_folder}"
default_image_url = f"{browser_file_path}/2cn2.png"
# Start the Chromedriver and redirect to default image before removal
driver = WebClient(default_image_url=default_image_url).get_driver() # ChromeDriver
# Remove previously generated files
if temp_image_folder.exists():
try:
for image in temp_image_folder.glob("*.*"):
Path(image).unlink()
except FileNotFoundError:
pass
else:
temp_image_folder.mkdir(parents=True, exist_ok=True)
# |
# | Defining the animation class to generate the images for the Quantum Fractal
# └───────────────────────────────────────────────────────────────────────────────────────────────────────
class QuantumFractalImages:
"""Calculate and generate Quantum Fractal Images using Julia Set formulas"""
def __init__(self):
# Define the result variables for the three Julia Set calculations
self.res_1cn: Optional[np.ndarray[np.int_, np.int_]] = None
self.res_2cn1: Optional[np.ndarray[np.int_, np.int_]] = None
self.res_2cn2: Optional[np.ndarray[np.int_, np.int_]] = None
# Save the QuantumCircuit as class variable
self.circuit: Optional[BytesIO] = None
# Save the GIF variables in class variables to keep the state for the lifetime of this class
# in contrary to qf_images which requires the variables to be defined for each iteration
self.gif_fig, self.gif_ax = plt.subplots(1, 4, figsize=(20, 5))
self.gif_cam = Camera(self.gif_fig)
def qfi_julia_calculation(self, sv_custom: complex_, sv_list: ndarray[complex_]) -> None:
"""Calculate the results for all three of the Julia-set formulas"""
timer['Julia_calculations'] = timeit.default_timer()
julia = JuliaSet(sv_custom=sv_custom, sv_list=sv_list, z=z_arr, con=con_arr, div=div_arr)
# Define the three julia-set formulas for each of their own threads
threads = [Thread(target=julia.set_1cn), Thread(target=julia.set_2cn1), Thread(target=julia.set_2cn2)]
# Start the threads and wait for threads to complete
[thread.start() for thread in threads]
[thread.join() for thread in threads]
# Define the results from the three calculations
self.res_1cn = julia.res_1cn
self.res_2cn1 = julia.res_2cn1
self.res_2cn2 = julia.res_2cn2
timer['Julia_calculations'] = timeit.default_timer() - timer['Julia_calculations']
def qfi_quantum_circuit(self, quantum_circuit: Optional[QuantumCircuit] = None) -> None:
"""Generate the Bloch Sphere image from the Quantum Circuit and convert to Bytes"""
timer['Bloch_data'] = timeit.default_timer()
bloch_data = BytesIO()
plot_bloch_multivector(quantum_circuit).savefig(bloch_data, format='png')
bloch_data.seek(0)
self.circuit = bloch_data
del bloch_data
timer['Bloch_data'] = timeit.default_timer() - timer['Bloch_data']
def qfi_animations(self) -> None:
"""Generate Animation of the Quantum Fractal Images"""
timer['Animation'] = timeit.default_timer()
# Plot Bloch sphere
self.gif_ax[0].imshow(Image.open(deepcopy(self.circuit)))
self.gif_ax[0].set_title('Bloch sphere', fontsize=20, pad=15.0)
# Plot 1st Julia Fractal
self.gif_ax[1].imshow(self.res_1cn, cmap='magma')
# Plot 2nd Julia Fractal
self.gif_ax[2].imshow(self.res_2cn1, cmap='magma')
self.gif_ax[2].set_title('3 types of Julia set fractals based on the superposition H-gate', fontsize=20, pad=15.0)
# Plot 3rd Julia Fractal
self.gif_ax[3].figure.set_size_inches(16, 5)
self.gif_ax[3].imshow(self.res_2cn2, cmap='magma')
self.gif_ax[3].figure.supxlabel('ibm.biz/quantum-fractals-blog ibm.biz/quantum-fractals', fontsize=20)
# Turn off axis values for all columns of images
for col in range(0, self.gif_ax[0].get_gridspec().ncols):
self.gif_ax[col].axis('off')
# Snap a picture of the image outcome and close the plt object
self.gif_cam.snap()
plt.close()
timer['Animation'] = timeit.default_timer() - timer['Animation']
def qfi_images(self) -> None:
"""Generate an image for each iteration of the Quantum Fractals"""
img_fig, img_ax = plt.subplots(1, 4, figsize=(20, 5))
# Secondly (b), generate the images based on the Julia set results
timer['Image'] = timeit.default_timer()
# Plot Bloch sphere
img_ax[0].imshow(Image.open(deepcopy(self.circuit)))
img_ax[0].set_title('Bloch sphere', fontsize=20, pad=15.0)
# Plot 1st Julia Fractal
img_ax[1].imshow(self.res_1cn, cmap='magma')
# Plot 2nd Julia Fractal
img_ax[2].imshow(self.res_2cn1, cmap='magma')
img_ax[2].set_title('3 types of Julia set fractals based on the superposition H-gate', fontsize=20, pad=15.0)
# Plot 3rd Julia Fractal
img_ax[3].figure.set_size_inches(16, 5)
img_ax[3].imshow(self.res_2cn2, cmap='magma')
img_ax[3].figure.supxlabel('ibm.biz/quantum-fractals-blog ibm.biz/quantum-fractals', fontsize=20)
# Turn off axis values for all columns of images
for col in range(0, img_ax[0].get_gridspec().ncols):
img_ax[col].axis('off')
# Save image locally and open image in browser and close the plt object
img_ax[3].figure.savefig(Path(temp_image_folder, "2cn2.png"))
driver.get(default_image_url)
plt.close('all')
del img_fig, img_ax
timer['Image'] = timeit.default_timer() - timer['Image']
# |
# | Running the script
# └───────────────────────────────────────────────────────────────────────────────────────────────────────
QFC = QuantumFractalCircuit(number_of_qubits=1, number_of_frames=number_of_frames)
QFI = QuantumFractalImages()
for i in range(number_of_frames):
try:
# Firstly, get the complex numbers from the complex circuit
timer['QuantumCircuit'] = timeit.default_timer()
ccc = QFC.get_quantum_circuit(frame_iteration=i)
timer['QuantumCircuit'] = timeit.default_timer() - timer['QuantumCircuit']
# Secondly, run the animation and image creation
QFI.qfi_julia_calculation(sv_custom=ccc[0], sv_list=ccc[2])
QFI.qfi_quantum_circuit(quantum_circuit=ccc[1])
QFI.qfi_animations()
QFI.qfi_images()
# Console logging output:
complex_numb = round(ccc[0].real, 2) + round(ccc[0].imag, 2) * 1j
complex_amp1 = round(ccc[2][0].real, 2) + round(ccc[2][0].imag, 2) * 1j
complex_amp2 = round(ccc[2][1].real, 2) + round(ccc[2][1].imag, 2) * 1j
print(f"Loop i = {i:>2} | One complex no: ({complex_numb:>11.2f}) | "
f"Complex amplitude one: ({complex_amp1:>11.2f}) and two: ({complex_amp2:>11.2f}) | "
f"QuantumCircuit: {round(timer['QuantumCircuit'], 4):>6.4f} | "
f"Julia_calc: {round(timer['Julia_calculations'], 4):>6.4f} | "
f"Anim: {round(timer['Animation'], 4):>6.4f} | Img: {round(timer['Image'], 4):>6.4f} | "
f"Bloch: {round(timer['Bloch_data'], 4):>6.4f} |")
acc_timer = {key: acc_timer[key] + val for key, val in timer.items()}
except (NoSuchWindowException, WebDriverException):
print("Error, Browser window closed during generation of images")
raise traceback.format_exc()
# Print the accumulated time
print("Accumulated time:", ", ".join([f"{key}: {value:.3f} seconds" for key, value in acc_timer.items()]))
# Quit the currently running driver and prepare for the animation
driver.quit()
print("\nStarting - Saving the current animation state in GIF")
anim = QFI.gif_cam.animate(blit=True, interval=GIF_ms_intervals)
anim.save(f'{temp_image_folder}/1qubit_simulator_4animations_H_{number_of_frames}.gif', writer='pillow')
gif_url = f"{browser_file_path}/1qubit_simulator_4animations_H_{number_of_frames}.gif"
print("Finished - Saving the current animation state in GIF")
# Define a fresh instance of the ChromeDriver to retrieve the image
driver = WebClient(default_image_url).get_driver() # ChromeDriver
driver.get(gif_url)
# check if the browser window is closed
while True:
try:
driver.find_element(By.TAG_NAME, 'body')
except (NoSuchWindowException, WebDriverException):
print("Error, Browser window closed, quitting the program")
driver.quit()
sys.exit()
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
%matplotlib inline
# Para facilitar a visualização dos nossos circuitos podemos usar .barrier() para criar
# "separadores" nos circuitos
# Essas barras tem uma outra função que pode ser vista no futuro, mas por enquanto podemos
# usar apenas para separar partes do circuito
qc = QuantumCircuit(2,2)
qc.x(0)
qc.y(0)
qc.z(0)
qc.x(1)
qc.y(0)
qc.z(1)
qc.draw(output='mpl')
# Agora vamos separar essa parte
qc.barrier()
qc.draw(output='mpl')
# Com isso podemos continuar a segunda parte do circuito
qc.x(0)
qc.y(0)
qc.z(0)
qc.x(1)
qc.y(0)
qc.z(1)
qc.draw(output='mpl')
|
https://github.com/LFL-Lab/metal-library
|
LFL-Lab
|
import metal_library as mlib
print(mlib.supported_components)
reader = mlib.Reader(component_name='TransmonCross')
print(reader)
reader.component_types
reader.get_characteristic_info(component_type="QubitOnly");
reader.get_characteristic_info(component_type="QubitCavity");
reader.get_characteristic_info(component_type="QubitDriveline");
reader = mlib.Reader(component_name='TransmonCross')
reader.read_library(component_type='QubitOnly')
#### REMINDER: don't skip the previous cell!
selector = mlib.Selector(reader)
print(selector)
# You can find the supported metrics here...
selector.__supported_metrics__
indexes, chars, best_geoms = selector.find_closest(target_params={"Qubit_Frequency_GHz": 5,
"Qubit_Anharmonicity_MHz": 200},
num_top=3,
metric="Euclidian",
display=True)
%load_ext autoreload
%autoreload 2
# Qiskit Metal imports
import qiskit_metal as metal
from qiskit_metal import designs, draw
from qiskit_metal import MetalGUI, Dict
design = designs.DesignPlanar()
gui = MetalGUI(design)
reader.component_name
from qiskit_metal.qlibrary.qubits.transmon_cross import TransmonCross
# Parsing the best geometries
best_options = best_geoms[0]
second_best_options = best_geoms[1]
third_best_options = best_geoms[2]
# and so on.. so on...
TransmonCross(design, "transmon", options=best_options)
gui.rebuild()
gui.zoom_on_components(['transmon'])
gui.screenshot()
reader = mlib.Reader(component_name='TransmonCross')
reader.read_library(component_type='QubitCavity') # Note, we've change it from "QubitOnly" -> "QubitCavity"
selector = mlib.Selector(reader)
indexes, chars, best_geoms = selector.find_closest(target_params={"Qubit_Frequency_GHz": 5,
"Qubit_Anharmonicity_MHz": 200,
"Cavity_Frequency_GHz": 7,
"Coupling_Strength_MHz": 70,
"Cavity_Wavelength": "half", # acceptable inputs ["half", "quarter"], refers to wavelength of resonator
"Feedline_Coupling": 'capacitive' #acceptable inputs ["capacitive", "inductive"], refers to
}
num_top=3,
metric="Euclidian",
display=True)
%load_ext autoreload
%autoreload 2
# Qiskit Metal imports
import qiskit_metal as metal
from qiskit_metal import designs, draw
from qiskit_metal import MetalGUI, Dict
design = designs.DesignPlanar()
gui = MetalGUI(design)
from metal_library.components import QubitCavity
# Parsing the best geometries
best_options = best_geoms[0]
second_best_options = best_geoms[1]
# and so on...
design = QubitCavity(design, options=best_options)
gui.rebuild()
gui.autoscale()
gui.screenshot()
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests for the wrapper functionality."""
import os
import sys
import unittest
from qiskit.utils import optionals
from qiskit.test import Path, QiskitTestCase, slow_test
# Timeout (in seconds) for a single notebook.
TIMEOUT = 1000
# Jupyter kernel to execute the notebook in.
JUPYTER_KERNEL = "python3"
@unittest.skipUnless(optionals.HAS_IBMQ, "requires IBMQ provider")
@unittest.skipUnless(optionals.HAS_JUPYTER, "involves running Jupyter notebooks")
class TestJupyter(QiskitTestCase):
"""Notebooks test case."""
def setUp(self):
super().setUp()
self.execution_path = os.path.join(Path.SDK.value, "..")
self.notebook_dir = os.path.join(
os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
"notebooks",
)
def _execute_notebook(self, filename):
import nbformat
from nbconvert.preprocessors import ExecutePreprocessor
# Create the preprocessor.
execute_preprocessor = ExecutePreprocessor(timeout=TIMEOUT, kernel_name=JUPYTER_KERNEL)
# Read the notebook.
with open(filename) as file_:
notebook = nbformat.read(file_, as_version=4)
top_str = """
import qiskit
import qiskit.providers.ibmq
import sys
from unittest.mock import create_autospec, MagicMock
from qiskit.providers.fake_provider import FakeProviderFactory
from qiskit.providers import basicaer
fake_prov = FakeProviderFactory()
qiskit.IBMQ = fake_prov
ibmq_mock = create_autospec(basicaer)
ibmq_mock.IBMQJobApiError = MagicMock()
sys.modules['qiskit.providers.ibmq'] = ibmq_mock
sys.modules['qiskit.providers.ibmq.job'] = ibmq_mock
sys.modules['qiskit.providers.ibmq.job.exceptions'] = ibmq_mock
"""
top = nbformat.notebooknode.NotebookNode(
{
"cell_type": "code",
"execution_count": 0,
"metadata": {},
"outputs": [],
"source": top_str,
}
)
notebook.cells = [top] + notebook.cells
# Run the notebook into the folder containing the `qiskit/` module.
execute_preprocessor.preprocess(notebook, {"metadata": {"path": self.execution_path}})
@unittest.skipIf(
sys.platform != "linux",
"Fails with Python >=3.8 on osx and windows",
)
def test_jupyter_jobs_pbars(self):
"""Test Jupyter progress bars and job status functionality"""
self._execute_notebook(os.path.join(self.notebook_dir, "test_pbar_status.ipynb"))
@unittest.skipIf(not optionals.HAS_MATPLOTLIB, "matplotlib not available.")
@slow_test
def test_backend_tools(self):
"""Test Jupyter backend tools."""
self._execute_notebook(os.path.join(self.notebook_dir, "test_backend_tools.ipynb"))
if __name__ == "__main__":
unittest.main(verbosity=2)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_optimization import QuadraticProgram
qp = QuadraticProgram()
qp.binary_var("x")
qp.binary_var("y")
qp.integer_var(lowerbound=0, upperbound=7, name="z")
qp.maximize(linear={"x": 2, "y": 1, "z": 1})
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="LE", rhs=5.5, name="xyz_leq")
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="GE", rhs=2.5, name="xyz_geq")
print(qp.prettyprint())
from qiskit_optimization.converters import InequalityToEquality
ineq2eq = InequalityToEquality()
qp_eq = ineq2eq.convert(qp)
print(qp_eq.prettyprint())
print(qp_eq.prettyprint())
from qiskit_optimization.converters import IntegerToBinary
int2bin = IntegerToBinary()
qp_eq_bin = int2bin.convert(qp_eq)
print(qp_eq_bin.prettyprint())
print(qp_eq_bin.prettyprint())
from qiskit_optimization.converters import LinearEqualityToPenalty
lineq2penalty = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(qp_eq_bin)
print(qubo.prettyprint())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
import sys
if sys.version_info < (3,5):
raise Exception('Please use Python version 3.5 or greater.')
from pprint import pprint
import math
# importing the QISKit
from qiskit import QuantumProgram
# To use API
#import Qconfig
# Definition of matchgate
def gate_mu3(qcirc,theta,phi,lam,a,b):
qcirc.cx(a,b)
qcirc.cu3(theta,phi,lam,b,a)
qcirc.cx(a,b)
# Number of qubits (should be odd)
n_nodes = 5
# Number of steps
n_step = 2
# Histogram
hist = True
# Quantum Sphere
#hist = False
# Creating Programs
qp = QuantumProgram()
# Creating Registers
qr = qp.create_quantum_register('qr', n_nodes)
cr = qp.create_classical_register('cr', n_nodes)
# Creating Circuits
qc = qp.create_circuit('QWalk', [qr], [cr])
# Initial state
qc.x(qr[0])
# Creating of two partitions with M1' and M2
# Repeating that n_step times
for k in range(0,n_step):
for i in range(0,n_nodes-1,2):
gate_mu3(qc,math.pi, math.pi, 0, qr[i], qr[i+1])
for i in range(1,n_nodes,2):
gate_mu3(qc,math.pi/2, 0, 0, qr[i], qr[i+1])
if hist:
for i in range(0,n_nodes):
qc.measure(qr[i], cr[i])
# To print the circuit
# QASM_source = qp.get_qasm('QWalk')
# print(QASM_source)
# To use API
# qp.set_api(Qconfig.APItoken, Qconfig.config['url'])
backend = 'local_qasm_simulator'
if hist:
shots = 4096
else:
shots = 1 # backend 'trick': produces amplitudes instead of probabilities
qobj=qp.compile(['QWalk'], backend = backend, shots = shots ) # Compile quantum walk
result = qp.run(qobj)
print(result)
# execute this cell twice to see the result due to an issue with matplotlib
# import state tomography functions
from qiskit.tools.visualization import plot_histogram, plot_state
import numpy as np
if hist:
plot_histogram(result.get_counts('QWalk'))
else:
data_ampl = result.get_data('QWalk')
state_walk = data_ampl['quantum_state']
rho_walk = np.outer(state_walk,state_walk.conj())
plot_state(rho_walk,'qsphere')
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
rp = np.arange(0,1.1,0.1); vth = 2*np.arccos(np.sqrt(rp)); rp, vth
def ket_rp(th,phi):
return Matrix([[cos(th/2)],[(cos(ph)+1j*sin(ph))*sin(th/2)]])
def ket_rm(th,phi):
return Matrix([[sin(th/2)],[-(cos(ph)+1j*sin(ph))*cos(th/2)]])
rp,th,ph = symbols('r_{+} theta phi', Real=True); ket_rp(th,ph), ket_rm(th,ph)
def rho(rp,rm,th,ph):
return rp*proj(ket_rp(th,ph)) + rm*proj(ket_rm(th,ph))
rp,rm,th,ph = symbols('r_{+} r_{-} theta phi', Real=True); simplify(rho(rp,rm,th,ph))
rp = 1/2; vth = 2*math.acos(sqrt(rp)); th = 0*math.pi/4; ph = 0*math.pi/3
simplify(rho(rp,1-rp,th,ph))
print(rp, vth, th, ph)
import qiskit
qiskit.IBMQ.load_account()
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
simulator = provider.get_backend('ibmq_qasm_simulator')
device = provider.get_backend('ibmq_belem')
nshots = 8192
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.monitor import job_monitor
def pTraceL_num(dl, dr, rhoLR):
# Returns the left partial trace over the 'left' subsystem of rhoLR
rhoR = np.zeros((dr, dr), dtype=complex)
for j in range(0, dr):
for k in range(j, dr):
for l in range(0, dl):
rhoR[j,k] += rhoLR[l*dr+j,l*dr+k]
if j != k:
rhoR[k,j] = np.conj(rhoR[j,k])
return rhoR
qr = qiskit.QuantumRegister(2); qc = qiskit.QuantumCircuit(qr)
qc.u(vth,0,0,qr[0]); qc.cx(qr[0],qr[1]); qc.u(th,ph,math.pi,qr[0]);
qc.draw()
qstc = state_tomography_circuits(qc, [qr[0],qr[1]]); # circuito para TEQ
job = qiskit.execute(qstc, backend = simulator, shots = nshots) # executa no simulador
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); rhoA = pTraceL_num(2, 2, rhoBA); rhoA
qc.draw()
job = qiskit.execute(qstc, backend = device, shots = nshots)
print(job.job_id()); job_monitor(job)
qstf = StateTomographyFitter(job.result(), qstc) # ajusta os dados
rhoBA = qstf.fit(method='lstsq'); # extrai o operador densidade
rhoA = pTraceL_num(2, 2, rhoBA); rhoA
a,b,c,d = symbols('a,b,c,d', Real=True, Positive=True);
z,w = symbols('z,w', Real=True)
rhoX = Matrix([[a,0,0,w],[0,b,z,0],[0,z,c,0],[w,0,0,d]]); rhoX
rhoX.eigenvals()
rhoX.eigenvects()
a,b,g = symbols('alpha beta gamma', Real = True, Positive = True)
p00 = (cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2
p01 = (cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2
p10 = (cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2
p11 = (cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2
p00,p01,p10,p11
simplify(p00+p01+p10+p11) # ok
th,ph = symbols('theta phi', Real = True, Positive = True)
psi00 = cos(th)*tp(cb(2,0),cb(2,0)) + sin(th)*tp(cb(2,1),cb(2,1))
psi10 = -sin(th)*tp(cb(2,0),cb(2,0)) + cos(th)*tp(cb(2,1),cb(2,1))
psi01 = sin(ph)*tp(cb(2,0),cb(2,1)) + cos(ph)*tp(cb(2,1),cb(2,0))
psi11 = cos(ph)*tp(cb(2,0),cb(2,1)) - sin(ph)*tp(cb(2,1),cb(2,0))
psi00, psi10, psi01, psi11
rho23 = p00*proj(psi00) + p01*proj(psi01) + p10*proj(psi10) + p11*proj(psi11);
simplify(rho23)
p00,p01,p10,p11 = symbols('p_{00},p_{01},p_{10},p_{11}')
rho23 = p00*proj(psi00) + p01*proj(psi01) + p10*proj(psi10) + p11*proj(psi11);
rho23
nonlinsolve([((cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2)*cos(th)**2 + (cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2*sin(th)**2 - a,
((cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2)*sin(ph)**2 + ((cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2)*cos(ph)**2 - b,
((cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2)*cos(ph)**2 + ((cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2)*sin(ph)**2 - c,
((cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2)*sin(ph)**2 + (cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2*cos(th)**2 - d,
((cos(a)*cos(b)*sin(g) - sin(a)*sin(b)*cos(g))**2-(cos(a)*sin(b)*sin(g) + sin(a)*cos(b)*cos(g))**2)*sin(ph)*cos(ph) - z,
((cos(a)*cos(b)*cos(g) + sin(a)*sin(b)*sin(g))**2-(cos(a)*sin(b)*cos(g) - sin(a)*cos(b)*sin(g))**2)*sin(th)*cos(th) - w],
[th,ph,a,b,g])
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.opflow import I, X, Y, Z
print(I, X, Y, Z)
print(1.5 * I)
print(2.5 * X)
print(X + 2.0 * Y)
print(X^Y^Z)
print(X @ Y @ Z)
print((X + Y) @ (Y + Z))
print((X + Y) ^ (Y + Z))
(I, X)
2.0 * X^Y^Z
print(1.1 * ((1.2 * X)^(Y + (1.3 * Z))))
from qiskit.opflow import (StateFn, Zero, One, Plus, Minus, H,
DictStateFn, VectorStateFn, CircuitStateFn, OperatorStateFn)
print(Zero, One)
print(Plus, Minus)
print(Zero.eval('0'))
print(Zero.eval('1'))
print(One.eval('1'))
print(Plus.eval('0'))
print(Minus.eval('1'))
One.adjoint()
~One
(2.0 + 3.0j) * Zero
print(Zero + One)
import math
v_zero_one = (Zero + One) / math.sqrt(2)
print(v_zero_one)
print(Plus + Minus)
print(~One @ One)
(~One @ One).eval()
(~v_zero_one @ v_zero_one).eval()
(~Minus @ One).eval()
print((~One).compose(One))
(~One).eval(One)
print(Zero^Plus)
print((Zero^Plus).to_circuit_op())
print(600 * ((One^5) + (Zero^5)))
print((One^Zero)^3)
print(((Plus^Minus)^2).to_matrix_op())
print(((Plus^One)^2).to_circuit_op())
print(((Plus^One)^2).to_matrix_op().sample())
print(StateFn({'0':1}))
print(StateFn({'0':1}) == Zero)
print(StateFn([0,1,1,0]))
from qiskit.circuit.library import RealAmplitudes
print(StateFn(RealAmplitudes(2)))
from qiskit.opflow import X, Y, Z, I, CX, T, H, S, PrimitiveOp
X
print(X.eval('0'))
X.eval('0').eval('1')
print(CX)
print(CX.to_matrix().real) # The imaginary part vanishes.
CX.eval('01') # 01 is the one in decimal. We get the first column.
CX.eval('01').eval('11') # This returns element with (zero-based) index (1, 3)
print(X @ One)
(X @ One).eval()
X.eval(One)
print(((~One^2) @ (CX.eval('01'))).eval())
print(((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2)
print((((H^5) @ ((CX^2)^I) @ (I^(CX^2)))**2) @ (Minus^5))
print(((H^I^I)@(X^I^I)@Zero))
print(~One @ Minus)
from qiskit.opflow import ListOp
print((~ListOp([One, Zero]) @ ListOp([One, Zero])))
print((~ListOp([One, Zero]) @ ListOp([One, Zero])).reduce())
print(StateFn(Z).adjoint())
StateFn(Z).adjoint()
print(StateFn(Z).adjoint().eval(Zero))
print(StateFn(Z).adjoint().eval(One))
print(StateFn(Z).adjoint().eval(Plus))
import numpy as np
from qiskit.opflow import I, X, Y, Z, H, CX, Zero, ListOp, PauliExpectation, PauliTrotterEvolution, CircuitSampler, MatrixEvolution, Suzuki
from qiskit.circuit import Parameter
from qiskit import Aer
two_qubit_H2 = (-1.0523732 * I^I) + \
(0.39793742 * I^Z) + \
(-0.3979374 * Z^I) + \
(-0.0112801 * Z^Z) + \
(0.18093119 * X^X)
print(two_qubit_H2)
evo_time = Parameter('θ')
evolution_op = (evo_time*two_qubit_H2).exp_i()
print(evolution_op) # Note, EvolvedOps print as exponentiations
print(repr(evolution_op))
h2_measurement = StateFn(two_qubit_H2).adjoint()
print(h2_measurement)
bell = CX @ (I ^ H) @ Zero
print(bell)
evo_and_meas = h2_measurement @ evolution_op @ bell
print(evo_and_meas)
trotterized_op = PauliTrotterEvolution(trotter_mode=Suzuki(order=2, reps=1)).convert(evo_and_meas)
# We can also set trotter_mode='suzuki' or leave it empty to default to first order Trotterization.
print(trotterized_op)
bound = trotterized_op.bind_parameters({evo_time: .5})
bound[1].to_circuit().draw()
# Note that XX was the only non-diagonal measurement in our H2 Observable
print(PauliExpectation(group_paulis=False).convert(h2_measurement))
print(PauliExpectation().convert(h2_measurement))
diagonalized_meas_op = PauliExpectation().convert(trotterized_op)
print(diagonalized_meas_op)
evo_time_points = list(range(8))
h2_trotter_expectations = diagonalized_meas_op.bind_parameters({evo_time: evo_time_points})
h2_trotter_expectations.eval()
sampler = CircuitSampler(backend=Aer.get_backend('aer_simulator'))
# sampler.quantum_instance.run_config.shots = 1000
sampled_trotter_exp_op = sampler.convert(h2_trotter_expectations)
sampled_trotter_energies = sampled_trotter_exp_op.eval()
print('Sampled Trotterized energies:\n {}'.format(np.real(sampled_trotter_energies)))
print('Before:\n')
print(h2_trotter_expectations.reduce()[0][0])
print('\nAfter:\n')
print(sampled_trotter_exp_op[0][0])
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import *
from qiskit.circuit import Gate
my_gate = Gate(name='my_gate', num_qubits=2, params=[])
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.append(my_gate, [qr[0], qr[1]])
circ.append(my_gate, [qr[1], qr[2]])
circ.draw()
# Build a sub-circuit
sub_q = QuantumRegister(2)
sub_circ = QuantumCircuit(sub_q, name='sub_circ')
sub_circ.h(sub_q[0])
sub_circ.crz(1, sub_q[0], sub_q[1])
sub_circ.barrier()
sub_circ.id(sub_q[1])
sub_circ.u(1, 2, -2, sub_q[0])
# Convert to a gate and stick it into an arbitrary place in the bigger circuit
sub_inst = sub_circ.to_instruction()
qr = QuantumRegister(3, 'q')
circ = QuantumCircuit(qr)
circ.h(qr[0])
circ.cx(qr[0], qr[1])
circ.cx(qr[1], qr[2])
circ.append(sub_inst, [qr[1], qr[2]])
circ.draw()
decomposed_circ = circ.decompose() # Does not modify original circuit
decomposed_circ.draw()
from qiskit.circuit import Parameter
theta = Parameter('θ')
n = 5
qc = QuantumCircuit(5, 1)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
qc.barrier()
qc.rz(theta, range(5))
qc.barrier()
for i in reversed(range(n-1)):
qc.cx(i, i+1)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
print(qc.parameters)
import numpy as np
theta_range = np.linspace(0, 2 * np.pi, 128)
circuits = [qc.bind_parameters({theta: theta_val})
for theta_val in theta_range]
circuits[-1].draw()
backend = BasicAer.get_backend('qasm_simulator')
job = backend.run(transpile(circuits, backend))
counts = job.result().get_counts()
import matplotlib.pyplot as plt
fig = plt.figure(figsize=(8,6))
ax = fig.add_subplot(111)
ax.plot(theta_range, list(map(lambda c: c.get('0', 0), counts)), '.-', label='0')
ax.plot(theta_range, list(map(lambda c: c.get('1', 0), counts)), '.-', label='1')
ax.set_xticks([i * np.pi / 2 for i in range(5)])
ax.set_xticklabels(['0', r'$\frac{\pi}{2}$', r'$\pi$', r'$\frac{3\pi}{2}$', r'$2\pi$'], fontsize=14)
ax.set_xlabel('θ', fontsize=14)
ax.set_ylabel('Counts', fontsize=14)
ax.legend(fontsize=14)
import time
from itertools import combinations
from qiskit.compiler import assemble
from qiskit.test.mock import FakeVigo
start = time.time()
qcs = []
theta_range = np.linspace(0, 2*np.pi, 32)
for n in theta_range:
qc = QuantumCircuit(5)
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(n, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qcs.append(qc)
compiled_circuits = transpile(qcs, backend=FakeVigo())
qobj = assemble(compiled_circuits, backend=FakeVigo())
end = time.time()
print('Time compiling over set of bound circuits: ', end-start)
start = time.time()
qc = QuantumCircuit(5)
theta = Parameter('theta')
for k in range(8):
for i,j in combinations(range(5), 2):
qc.cx(i,j)
qc.rz(theta, range(5))
for i,j in combinations(range(5), 2):
qc.cx(i,j)
transpiled_qc = transpile(qc, backend=FakeVigo())
qobj = assemble([transpiled_qc.bind_parameters({theta: n})
for n in theta_range], backend=FakeVigo())
end = time.time()
print('Time compiling over parameterized circuit, then binding: ', end-start)
phi = Parameter('phi')
sub_circ1 = QuantumCircuit(2, name='sc_1')
sub_circ1.rz(phi, 0)
sub_circ1.rx(phi, 1)
sub_circ2 = QuantumCircuit(2, name='sc_2')
sub_circ2.rx(phi, 0)
sub_circ2.rz(phi, 1)
qc = QuantumCircuit(4)
qr = qc.qregs[0]
qc.append(sub_circ1.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[0], qr[1]])
qc.append(sub_circ2.to_instruction(), [qr[2], qr[3]])
print(qc.draw())
# The following raises an error: "QiskitError: 'Name conflict on adding parameter: phi'"
# phi2 = Parameter('phi')
# qc.u3(0.1, phi2, 0.3, 0)
p = Parameter('p')
qc = QuantumCircuit(3, name='oracle')
qc.rz(p, 0)
qc.cx(0, 1)
qc.rz(p, 1)
qc.cx(1, 2)
qc.rz(p, 2)
theta = Parameter('theta')
phi = Parameter('phi')
gamma = Parameter('gamma')
qr = QuantumRegister(9)
larger_qc = QuantumCircuit(qr)
larger_qc.append(qc.to_instruction({p: theta}), qr[0:3])
larger_qc.append(qc.to_instruction({p: phi}), qr[3:6])
larger_qc.append(qc.to_instruction({p: gamma}), qr[6:9])
print(larger_qc.draw())
print(larger_qc.decompose().draw())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
from tsp_qaoa import test_solution
from qiskit.visualization import plot_histogram
import networkx as nx
import numpy as np
import json
import csv
# Array of JSON Objects
header = ['p', 'state', 'probability', 'mean']
length_p = 10
with open('qaoa_multiple_p.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
# write the header
writer.writerow(header)
first_p = False
for p in range(length_p):
p = p+1
if first_p == False:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(p=p)
first_p = True
else:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["mean"])
mean = UNIFORM_CONVERGENCE_SAMPLE[0]["mean"]
print(mean)
state = 0
for probability in UNIFORM_CONVERGENCE_SAMPLE[0]["probabilities"]:
state += 1
writer.writerow([p,state, probability,mean])
|
https://github.com/Innanov/Qiskit-Global-Summer-School-2022
|
Innanov
|
from qiskit.circuit.library import RealAmplitudes
ansatz = RealAmplitudes(num_qubits=2, reps=1, entanglement='linear')
ansatz.draw('mpl', style='iqx')
from qiskit.opflow import Z, I
hamiltonian = Z ^ Z
from qiskit.opflow import StateFn
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
import numpy as np
point = np.random.random(ansatz.num_parameters)
index = 2
from qiskit import Aer
from qiskit.utils import QuantumInstance
backend = Aer.get_backend('qasm_simulator')
q_instance = QuantumInstance(backend, shots = 8192, seed_simulator = 2718, seed_transpiler = 2718)
from qiskit.circuit import QuantumCircuit
from qiskit.opflow import Z, X
H = X ^ X
U = QuantumCircuit(2)
U.h(0)
U.cx(0, 1)
# YOUR CODE HERE
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(U)
matmult_result =expectation.eval()
from qc_grader import grade_lab4_ex1
# Note that the grading function is expecting a complex number
grade_lab4_ex1(matmult_result)
from qiskit.opflow import CircuitSampler, PauliExpectation
sampler = CircuitSampler(q_instance)
# YOUR CODE HERE
sampler = CircuitSampler(q_instance) # q_instance is the QuantumInstance from the beginning of the notebook
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(U)
in_pauli_basis = PauliExpectation().convert(expectation)
shots_result = sampler.convert(in_pauli_basis).eval()
from qc_grader import grade_lab4_ex2
# Note that the grading function is expecting a complex number
grade_lab4_ex2(shots_result)
from qiskit.opflow import PauliExpectation, CircuitSampler
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
in_pauli_basis = PauliExpectation().convert(expectation)
sampler = CircuitSampler(q_instance)
def evaluate_expectation(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(in_pauli_basis, params=value_dict).eval()
return np.real(result)
eps = 0.2
e_i = np.identity(point.size)[:, index] # identity vector with a 1 at index ``index``, otherwise 0
plus = point + eps * e_i
minus = point - eps * e_i
finite_difference = (evaluate_expectation(plus) - evaluate_expectation(minus)) / (2 * eps)
print(finite_difference)
from qiskit.opflow import Gradient
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient('fin_diff', analytic=False, epsilon=eps)
grad = shifter.convert(expectation, params=ansatz.parameters[index])
print(grad)
value_dict = dict(zip(ansatz.parameters, point))
sampler.convert(grad, value_dict).eval().real
eps = np.pi / 2
e_i = np.identity(point.size)[:, index] # identity vector with a 1 at index ``index``, otherwise 0
plus = point + eps * e_i
minus = point - eps * e_i
finite_difference = (evaluate_expectation(plus) - evaluate_expectation(minus)) / 2
print(finite_difference)
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient() # parameter-shift rule is the default
grad = shifter.convert(expectation, params=ansatz.parameters[index])
sampler.convert(grad, value_dict).eval().real
expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(ansatz)
shifter = Gradient('lin_comb') # parameter-shift rule is the default
grad = shifter.convert(expectation, params=ansatz.parameters[index])
sampler.convert(grad, value_dict).eval().real
# initial_point = np.random.random(ansatz.num_parameters)
initial_point = np.array([0.43253681, 0.09507794, 0.42805949, 0.34210341])
expectation = StateFn(hamiltonian, is_measurement=True).compose(StateFn(ansatz))
gradient = Gradient().convert(expectation)
gradient_in_pauli_basis = PauliExpectation().convert(gradient)
sampler = CircuitSampler(q_instance)
def evaluate_gradient(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(gradient_in_pauli_basis, params=value_dict).eval() # add parameters in here!
return np.real(result)
# Note: The GradientDescent class will be released with Qiskit 0.28.0 and can then be imported as:
# from qiskit.algorithms.optimizers import GradientDescent
from qc_grader.gradient_descent import GradientDescent
gd_loss = []
def gd_callback(nfevs, x, fx, stepsize):
gd_loss.append(fx)
gd = GradientDescent(maxiter=300, learning_rate=0.01, callback=gd_callback)
x_opt, fx_opt, nfevs = gd.optimize(initial_point.size, # number of parameters
evaluate_expectation, # function to minimize
gradient_function=evaluate_gradient, # function to evaluate the gradient
initial_point=initial_point) # initial point
import matplotlib
import matplotlib.pyplot as plt
matplotlib.rcParams['font.size'] = 14
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, label='vanilla gradient descent')
plt.axhline(-1, ls='--', c='tab:red', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend();
from qiskit.opflow import NaturalGradient
expectation = StateFn(hamiltonian, is_measurement=True).compose(StateFn(ansatz))
natural_gradient = NaturalGradient(regularization='ridge').convert(expectation)
natural_gradient_in_pauli_basis = PauliExpectation().convert(natural_gradient)
sampler = CircuitSampler(q_instance, caching="all")
def evaluate_natural_gradient(x):
value_dict = dict(zip(ansatz.parameters, x))
result = sampler.convert(natural_gradient, params=value_dict).eval()
return np.real(result)
print('Vanilla gradient:', evaluate_gradient(initial_point))
print('Natural gradient:', evaluate_natural_gradient(initial_point))
qng_loss = []
def qng_callback(nfevs, x, fx, stepsize):
qng_loss.append(fx)
qng = GradientDescent(maxiter=300, learning_rate=0.01, callback=qng_callback)
x_opt, fx_opt, nfevs = qng.optimize(initial_point.size,
evaluate_expectation,
gradient_function=evaluate_natural_gradient,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
from qc_grader.spsa import SPSA
spsa_loss = []
def spsa_callback(nfev, x, fx, stepsize, accepted):
spsa_loss.append(fx)
spsa = SPSA(maxiter=300, learning_rate=0.01, perturbation=0.01, callback=spsa_callback)
x_opt, fx_opt, nfevs = spsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
# Note: The QNSPSA class will be released with Qiskit 0.28.0 and can then be imported as:
# from qiskit.algorithms.optimizers import QNSPSA
from qc_grader.qnspsa import QNSPSA
qnspsa_loss = []
def qnspsa_callback(nfev, x, fx, stepsize, accepted):
qnspsa_loss.append(fx)
fidelity = QNSPSA.get_fidelity(ansatz, q_instance, expectation=PauliExpectation())
qnspsa = QNSPSA(fidelity, maxiter=300, learning_rate=0.01, perturbation=0.01, callback=qnspsa_callback)
x_opt, fx_opt, nfevs = qnspsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.plot(qnspsa_loss, 'tab:green', ls='--', label='QN-SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
autospsa_loss = []
def autospsa_callback(nfev, x, fx, stepsize, accepted):
autospsa_loss.append(fx)
autospsa = SPSA(maxiter=300, learning_rate=None, perturbation=None, callback=autospsa_callback)
x_opt, fx_opt, nfevs = autospsa.optimize(initial_point.size,
evaluate_expectation,
initial_point=initial_point)
def plot_loss():
plt.figure(figsize=(12, 6))
plt.plot(gd_loss, 'tab:blue', label='vanilla gradient descent')
plt.plot(qng_loss, 'tab:green', label='quantum natural gradient')
plt.plot(spsa_loss, 'tab:blue', ls='--', label='SPSA')
plt.plot(qnspsa_loss, 'tab:green', ls='--', label='QN-SPSA')
plt.plot(autospsa_loss, 'tab:red', label='Powerlaw SPSA')
plt.axhline(-1, c='tab:red', ls='--', label='target')
plt.ylabel('loss')
plt.xlabel('iterations')
plt.legend()
plot_loss()
H_tfi = -(Z^Z^I)-(I^Z^Z)-(X^I^I)-(I^X^I)-(I^I^X)
from qc_grader import grade_lab4_ex3
# Note that the grading function is expecting a Hamiltonian
grade_lab4_ex3(H_tfi)
from qiskit.circuit.library import EfficientSU2
efficient_su2 = EfficientSU2(3, entanglement="linear", reps=2)
tfi_sampler = CircuitSampler(q_instance)
def evaluate_tfi(parameters):
exp = StateFn(H_tfi, is_measurement=True).compose(StateFn(efficient_su2))
value_dict = dict(zip(efficient_su2.parameters, parameters))
result = tfi_sampler.convert(PauliExpectation().convert(exp), params=value_dict).eval()
return np.real(result)
# target energy
tfi_target = -3.4939592074349326
# initial point for reproducibility
tfi_init = np.array([0.95667807, 0.06192812, 0.47615196, 0.83809827, 0.89022282,
0.27140831, 0.9540853 , 0.41374024, 0.92595507, 0.76150126,
0.8701938 , 0.05096063, 0.25476016, 0.71807858, 0.85661325,
0.48311132, 0.43623886, 0.6371297 ])
tfi_result = SPSA(maxiter=300, learning_rate=None, perturbation=None)
tfi_result = tfi_result.optimize(tfi_init.size, evaluate_tfi, initial_point=tfi_init)
tfi_minimum = tfi_result[1]
print("Error:", np.abs(tfi_result[1] - tfi_target))
from qc_grader import grade_lab4_ex4
# Note that the grading function is expecting a floating point number
grade_lab4_ex4(tfi_minimum)
from qiskit_machine_learning.datasets import ad_hoc_data
training_features, training_labels, test_features, test_labels = ad_hoc_data(
training_size=20, test_size=10, n=2, one_hot=False, gap=0.5
)
# the training labels are in {0, 1} but we'll use {-1, 1} as class labels!
training_labels = 2 * training_labels - 1
test_labels = 2 * test_labels - 1
def plot_sampled_data():
from matplotlib.patches import Patch
from matplotlib.lines import Line2D
import matplotlib.pyplot as plt
plt.figure(figsize=(12,6))
for feature, label in zip(training_features, training_labels):
marker = 'o'
color = 'tab:green' if label == -1 else 'tab:blue'
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
for feature, label in zip(test_features, test_labels):
marker = 's'
plt.scatter(feature[0], feature[1], marker=marker, s=100, facecolor='none', edgecolor='k')
legend_elements = [
Line2D([0], [0], marker='o', c='w', mfc='tab:green', label='A', ms=15),
Line2D([0], [0], marker='o', c='w', mfc='tab:blue', label='B', ms=15),
Line2D([0], [0], marker='s', c='w', mfc='none', mec='k', label='test features', ms=10)
]
plt.legend(handles=legend_elements, bbox_to_anchor=(1, 0.6))
plt.title('Training & test data')
plt.xlabel('$x$')
plt.ylabel('$y$')
plot_sampled_data()
from qiskit.circuit.library import ZZFeatureMap
dim = 2
feature_map = ZZFeatureMap(dim, reps=1) # let's keep it simple!
feature_map.draw('mpl', style='iqx')
ansatz = RealAmplitudes(num_qubits=dim, entanglement='linear', reps=1) # also simple here!
ansatz.draw('mpl', style='iqx')
circuit = feature_map.compose(ansatz)
circuit.draw('mpl', style='iqx')
hamiltonian = Z ^ Z # global Z operators
gd_qnn_loss = []
def gd_qnn_callback(*args):
gd_qnn_loss.append(args[2])
gd = GradientDescent(maxiter=100, learning_rate=0.01, callback=gd_qnn_callback)
from qiskit_machine_learning.neural_networks import OpflowQNN
qnn_expectation = StateFn(hamiltonian, is_measurement=True) @ StateFn(circuit)
qnn = OpflowQNN(qnn_expectation,
input_params=list(feature_map.parameters),
weight_params=list(ansatz.parameters),
exp_val=PauliExpectation(),
gradient=Gradient(), # <-- Parameter-Shift gradients
quantum_instance=q_instance)
from qiskit_machine_learning.algorithms import NeuralNetworkClassifier
#initial_point = np.array([0.2, 0.1, 0.3, 0.4])
classifier = NeuralNetworkClassifier(qnn, optimizer=gd)
classifier.fit(training_features, training_labels);
predicted = classifier.predict(test_features)
def plot_predicted():
from matplotlib.lines import Line2D
plt.figure(figsize=(12, 6))
for feature, label in zip(training_features, training_labels):
marker = 'o'
color = 'tab:green' if label == -1 else 'tab:blue'
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
for feature, label, pred in zip(test_features, test_labels, predicted):
marker = 's'
color = 'tab:green' if pred == -1 else 'tab:blue'
if label != pred: # mark wrongly classified
plt.scatter(feature[0], feature[1], marker='o', s=500, linewidths=2.5,
facecolor='none', edgecolor='tab:red')
plt.scatter(feature[0], feature[1], marker=marker, s=100, color=color)
legend_elements = [
Line2D([0], [0], marker='o', c='w', mfc='tab:green', label='A', ms=15),
Line2D([0], [0], marker='o', c='w', mfc='tab:blue', label='B', ms=15),
Line2D([0], [0], marker='s', c='w', mfc='tab:green', label='predict A', ms=10),
Line2D([0], [0], marker='s', c='w', mfc='tab:blue', label='predict B', ms=10),
Line2D([0], [0], marker='o', c='w', mfc='none', mec='tab:red', label='wrongly classified', mew=2, ms=15)
]
plt.legend(handles=legend_elements, bbox_to_anchor=(1, 0.7))
plt.title('Training & test data')
plt.xlabel('$x$')
plt.ylabel('$y$')
plot_predicted()
qng_qnn_loss = []
def qng_qnn_callback(*args):
qng_qnn_loss.append(args[2])
gd = GradientDescent(maxiter=100, learning_rate=0.01, callback=qng_qnn_callback)
qnn = OpflowQNN(qnn_expectation,
input_params=list(feature_map.parameters),
weight_params=list(ansatz.parameters),
gradient=NaturalGradient(regularization='ridge'), # <-- using Natural Gradients!
quantum_instance=q_instance)
classifier = NeuralNetworkClassifier(qnn, optimizer=gd)#, initial_point=initial_point)
classifier.fit(training_features, training_labels);
def plot_losses():
plt.figure(figsize=(12, 6))
plt.plot(gd_qnn_loss, 'tab:blue', marker='o', label='vanilla gradients')
plt.plot(qng_qnn_loss, 'tab:green', marker='o', label='natural gradients')
plt.xlabel('iterations')
plt.ylabel('loss')
plt.legend(loc='best')
plot_losses()
from qiskit.opflow import I
def sample_gradients(num_qubits, reps, local=False):
"""Sample the gradient of our model for ``num_qubits`` qubits and ``reps`` repetitions.
We sample 100 times for random parameters and compute the gradient of the first RY rotation gate.
"""
index = num_qubits - 1
# you can also exchange this for a local operator and observe the same!
if local:
operator = Z ^ Z ^ (I ^ (num_qubits - 2))
else:
operator = Z ^ num_qubits
# real amplitudes ansatz
ansatz = RealAmplitudes(num_qubits, entanglement='linear', reps=reps)
# construct Gradient we want to evaluate for different values
expectation = StateFn(operator, is_measurement=True).compose(StateFn(ansatz))
grad = Gradient().convert(expectation, params=ansatz.parameters[index])
# evaluate for 100 different, random parameter values
num_points = 100
grads = []
for _ in range(num_points):
# points are uniformly chosen from [0, pi]
point = np.random.uniform(0, np.pi, ansatz.num_parameters)
value_dict = dict(zip(ansatz.parameters, point))
grads.append(sampler.convert(grad, value_dict).eval())
return grads
num_qubits = list(range(2, 13))
reps = num_qubits # number of layers = numbers of qubits
gradients = [sample_gradients(n, r) for n, r in zip(num_qubits, reps)]
fit = np.polyfit(num_qubits, np.log(np.var(gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='measured variance')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
from qiskit.opflow import NaturalGradient
def sample_natural_gradients(num_qubits, reps):
index = num_qubits - 1
operator = Z ^ num_qubits
ansatz = RealAmplitudes(num_qubits, entanglement='linear', reps=reps)
expectation = StateFn(operator, is_measurement=True).compose(StateFn(ansatz))
grad = # TODO: ``grad`` should be the natural gradient for the parameter at index ``index``.
# Hint: Check the ``sample_gradients`` function, this one is almost the same.
grad = NaturalGradient().convert(expectation, params=ansatz.parameters[index])
num_points = 100
grads = []
for _ in range(num_points):
point = np.random.uniform(0, np.pi, ansatz.num_parameters)
value_dict = dict(zip(ansatz.parameters, point))
grads.append(sampler.convert(grad, value_dict).eval())
return grads
num_qubits = list(range(2, 13))
reps = num_qubits # number of layers = numbers of qubits
natural_gradients = [sample_natural_gradients(n, r) for n, r in zip(num_qubits, reps)]
fit = np.polyfit(num_qubits, np.log(np.var(natural_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='vanilla gradients')
plt.semilogy(num_qubits, np.var(natural_gradients, axis=1), 's-', label='natural gradients')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {float(fit[0]):.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
fixed_depth_global_gradients = [sample_gradients(n, 1) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(fixed_depth_global_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
linear_depth_local_gradients = [sample_gradients(n, n, local=True) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(linear_depth_local_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(num_qubits, np.var(linear_depth_local_gradients, axis=1), 'o-', label='local cost, linear depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = list(range(2, 13))
fixed_depth_local_gradients = [sample_gradients(n, 1, local=True) for n in num_qubits]
fit = np.polyfit(num_qubits, np.log(np.var(fixed_depth_local_gradients, axis=1)), deg=1)
x = np.linspace(num_qubits[0], num_qubits[-1], 200)
plt.figure(figsize=(12, 6))
plt.semilogy(num_qubits, np.var(gradients, axis=1), 'o-', label='global cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_global_gradients, axis=1), 'o-', label='global cost, constant depth')
plt.semilogy(num_qubits, np.var(linear_depth_local_gradients, axis=1), 'o-', label='local cost, linear depth')
plt.semilogy(num_qubits, np.var(fixed_depth_local_gradients, axis=1), 'o-', label='local cost, constant depth')
plt.semilogy(x, np.exp(fit[0] * x + fit[1]), 'r--', label=f'exponential fit w/ {fit[0]:.2f}')
plt.xlabel('number of qubits')
plt.ylabel(r'$\mathrm{Var}[\partial_{\theta 1} \langle E(\theta) \rangle]$')
plt.legend(loc='best');
num_qubits = 6
operator = Z ^ Z ^ (I ^ (num_qubits - 4))
def minimize(circuit, optimizer):
initial_point = np.random.random(circuit.num_parameters)
exp = StateFn(operator, is_measurement=True) @ StateFn(circuit)
grad = Gradient().convert(exp)
# pauli basis
exp = PauliExpectation().convert(exp)
grad = PauliExpectation().convert(grad)
sampler = CircuitSampler(q_instance, caching="all")
def loss(x):
values_dict = dict(zip(circuit.parameters, x))
return np.real(sampler.convert(exp, values_dict).eval())
def gradient(x):
values_dict = dict(zip(circuit.parameters, x))
return np.real(sampler.convert(grad, values_dict).eval())
return optimizer.optimize(circuit.num_parameters, loss, gradient, initial_point=initial_point)
circuit = RealAmplitudes(4, reps=1, entanglement='linear')
circuit.draw('mpl', style='iqx')
circuit.reps = 5
circuit.draw('mpl', style='iqx')
def layerwise_training(ansatz, max_num_layers, optimizer):
optimal_parameters = []
fopt = None
for reps in range(1, max_num_layers):
ansatz.reps = reps
# bind already optimized parameters
values_dict = dict(zip(ansatz.parameters, optimal_parameters))
partially_bound = ansatz.bind_parameters(values_dict)
xopt, fopt, _ = minimize(partially_bound, optimizer)
print('Circuit depth:', ansatz.depth(), 'best value:', fopt)
optimal_parameters += list(xopt)
return fopt, optimal_parameters
ansatz = RealAmplitudes(4, entanglement='linear')
optimizer = GradientDescent(maxiter=50)
np.random.seed(12)
fopt, optimal_parameters = layerwise_training(ansatz, 4, optimizer)
|
https://github.com/qiskit-community/community.qiskit.org
|
qiskit-community
|
import math
# importing Qiskit
from qiskit import Aer, IBMQ
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute
from qiskit.providers.ibmq import least_busy
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_histogram
IBMQ.load_account()
def input_state(circ, q, n):
"""n-qubit input state for QFT that produces output 1."""
for j in range(n):
circ.h(q[j])
circ.u1(-math.pi/float(2**(j)), q[j])
def qft(circ, q, n):
"""n-qubit QFT on q in circ."""
for j in range(n):
circ.h(q[j])
for k in range(j+1,n):
circ.cu1(math.pi/float(2**(k-j)), q[k], q[j])
circ.barrier()
q = QuantumRegister(3, 'x')
c = ClassicalRegister(3, 'c')
qft3 = QuantumCircuit(q, c)
# first, prepare the state that should return 001 and draw that circuit
input_state(qft3, q, 3)
qft3.draw(output='mpl')
# next, do a qft on the prepared state and draw the entire circuit
qft(qft3, q, 3)
for i in range(3):
qft3.measure(q[i], c[i])
qft3.draw(output='mpl')
# run on local simulator
backend = Aer.get_backend("qasm_simulator")
simulate = execute(qft3, backend=backend, shots=1024).result()
simulate.get_counts()
# Use the IBMQ Vigo device with 5 qubits
IBMQ.get_provider(hub='ibm-q')
backend = provider.get_backend('ibmq_vigo')
shots = 2048
job_exp = execute(qft3, backend=backend, shots=shots)
job_monitor(job_exp)
results = job_exp.result()
plot_histogram(results.get_counts())
import qiskit
qiskit.__qiskit_version__
|
https://github.com/2lambda123/Qiskit-qiskit
|
2lambda123
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""A container class for counts from a circuit execution."""
import re
from qiskit.result import postprocess
from qiskit import exceptions
# NOTE: A dict subclass should not overload any dunder methods like __getitem__
# this can cause unexpected behavior and issues as the cPython dict
# implementation has many standard methods in C for performance and the dunder
# methods are not always used as expected. For example, update() doesn't call
# __setitem__ so overloading __setitem__ would not always provide the expected
# result
class Counts(dict):
"""A class to store a counts result from a circuit execution."""
bitstring_regex = re.compile(r"^[01\s]+$")
def __init__(self, data, time_taken=None, creg_sizes=None, memory_slots=None):
"""Build a counts object
Args:
data (dict): The dictionary input for the counts. Where the keys
represent a measured classical value and the value is an
integer the number of shots with that result.
The keys can be one of several formats:
* A hexadecimal string of the form ``'0x4a'``
* A bit string prefixed with ``0b`` for example ``'0b1011'``
* A bit string formatted across register and memory slots.
For example, ``'00 10'``.
* A dit string, for example ``'02'``. Note for objects created
with dit strings the ``creg_sizes`` and ``memory_slots``
kwargs don't work and :meth:`hex_outcomes` and
:meth:`int_outcomes` also do not work.
time_taken (float): The duration of the experiment that generated
the counts in seconds.
creg_sizes (list): a nested list where the inner element is a list
of tuples containing both the classical register name and
classical register size. For example,
``[('c_reg', 2), ('my_creg', 4)]``.
memory_slots (int): The number of total ``memory_slots`` in the
experiment.
Raises:
TypeError: If the input key type is not an ``int`` or ``str``.
QiskitError: If a dit string key is input with ``creg_sizes`` and/or
``memory_slots``.
"""
bin_data = None
data = dict(data)
if not data:
self.int_raw = {}
self.hex_raw = {}
bin_data = {}
else:
first_key = next(iter(data.keys()))
if isinstance(first_key, int):
self.int_raw = data
self.hex_raw = {hex(key): value for key, value in self.int_raw.items()}
elif isinstance(first_key, str):
if first_key.startswith("0x"):
self.hex_raw = data
self.int_raw = {int(key, 0): value for key, value in self.hex_raw.items()}
elif first_key.startswith("0b"):
self.int_raw = {int(key, 0): value for key, value in data.items()}
self.hex_raw = {hex(key): value for key, value in self.int_raw.items()}
else:
if not creg_sizes and not memory_slots:
self.hex_raw = None
self.int_raw = None
bin_data = data
else:
hex_dict = {}
int_dict = {}
for bitstring, value in data.items():
if not self.bitstring_regex.search(bitstring):
raise exceptions.QiskitError(
"Counts objects with dit strings do not "
"currently support dit string formatting parameters "
"creg_sizes or memory_slots"
)
int_key = self._remove_space_underscore(bitstring)
int_dict[int_key] = value
hex_dict[hex(int_key)] = value
self.hex_raw = hex_dict
self.int_raw = int_dict
else:
raise TypeError(
"Invalid input key type %s, must be either an int "
"key or string key with hexademical value or bit string"
)
header = {}
self.creg_sizes = creg_sizes
if self.creg_sizes:
header["creg_sizes"] = self.creg_sizes
self.memory_slots = memory_slots
if self.memory_slots:
header["memory_slots"] = self.memory_slots
if not bin_data:
bin_data = postprocess.format_counts(self.hex_raw, header=header)
super().__init__(bin_data)
self.time_taken = time_taken
def most_frequent(self):
"""Return the most frequent count
Returns:
str: The bit string for the most frequent result
Raises:
QiskitError: when there is >1 count with the same max counts, or
an empty object.
"""
if not self:
raise exceptions.QiskitError("Can not return a most frequent count on an empty object")
max_value = max(self.values())
max_values_counts = [x[0] for x in self.items() if x[1] == max_value]
if len(max_values_counts) != 1:
raise exceptions.QiskitError(
"Multiple values have the same maximum counts: %s" % ",".join(max_values_counts)
)
return max_values_counts[0]
def hex_outcomes(self):
"""Return a counts dictionary with hexadecimal string keys
Returns:
dict: A dictionary with the keys as hexadecimal strings instead of
bitstrings
Raises:
QiskitError: If the Counts object contains counts for dit strings
"""
if self.hex_raw:
return {key.lower(): value for key, value in self.hex_raw.items()}
else:
out_dict = {}
for bitstring, value in self.items():
if not self.bitstring_regex.search(bitstring):
raise exceptions.QiskitError(
"Counts objects with dit strings do not "
"currently support conversion to hexadecimal"
)
int_key = self._remove_space_underscore(bitstring)
out_dict[hex(int_key)] = value
return out_dict
def int_outcomes(self):
"""Build a counts dictionary with integer keys instead of count strings
Returns:
dict: A dictionary with the keys as integers instead of bitstrings
Raises:
QiskitError: If the Counts object contains counts for dit strings
"""
if self.int_raw:
return self.int_raw
else:
out_dict = {}
for bitstring, value in self.items():
if not self.bitstring_regex.search(bitstring):
raise exceptions.QiskitError(
"Counts objects with dit strings do not "
"currently support conversion to integer"
)
int_key = self._remove_space_underscore(bitstring)
out_dict[int_key] = value
return out_dict
@staticmethod
def _remove_space_underscore(bitstring):
"""Removes all spaces and underscores from bitstring"""
return int(bitstring.replace(" ", "").replace("_", ""), 2)
def shots(self):
"""Return the number of shots"""
return sum(self.values())
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
from qiskit.visualization import plot_state_city
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
# plot using a DensityMatrix
state = DensityMatrix(qc)
plot_state_city(state)
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
total1 = 0
total2 = 0
for i in range(3,52,3):
total1 = total1 + i
total2 += i # shorter form
print("The summation is",total1)
print("the summation is",total2)
T = 0
current_number = 1
for i in range(9):
T = T + current_number
print("3 to",i,"is",current_number)
current_number = 3 * current_number
print("summation is",T)
# python has also exponent operator: **
# we may directly use it
T = 0
for i in range(9):
print("3 to",i,"is",3**i)
T = T + 3 ** i
print("summation is",T)
T = 0
n = 2 # this value will be first halved and then added to the summation
how_many_terms = 0
while T<=1.99:
n = n/2 # half the value of n
T = T + n # update the value of T
how_many_terms = how_many_terms + 1
print(n,T)
print("how many terms in the summation is",how_many_terms)
# our result says that there should be 8 terms in our summation
# let's calculate the summation of the first seven and the first eight terms, and verify our results
T7 = 0
n = 2 # this value will be first halved and then added to the summation
for i in range(7):
n = n/2
print(n)
T7 = T7 + n
print("the summation of the first seven terms is",T7)
T8 = 0
n = 2 # this value will be first halved and then added to the summation
for i in range(8):
n = n/2
print(n)
T8 = T8 + n
print("the summation of the first eight terms is",T8)
print("(the summation of the first seven terms is",T7,")")
from random import randrange
r = 0
attempt = 0
while r != 3: # the loop iterates as long as r is not equal to 3
r = randrange(10) # randomly pick a number
attempt = attempt + 1 # increase the number of attempts by 1
print (attempt,"->",r) # print the number of attmept and the randomly picked number at this moment
print("total number of attempt(s) is",attempt)
# be aware of single and double indentions
number_of_execution = 2000 # change this with 200, 2000, 20000, 200000 and reexecute this cell
total_attempts = 0
from random import randrange
for i in range(number_of_execution): # the outer loops iterates number_of_execution times
r = 0
attempt = 0
while r != 3: # the while-loop iterates as long as r is not equal to 3
r = randrange(10) # randomly pick a number
attempt = attempt + 1 # increase the number of attempts by 1
# I am out of scope of while-loop
total_attempts = total_attempts + attempt # update the total number of attempts
# I am out of scope of for-loop
print(number_of_execution,"->",total_attempts/number_of_execution)
# let's use triple nested loops
for number_of_execution in [20,200,2000,20000,200000]: # we will use the same code by indenting all lines one more level :-)
total_attempts = 0
for i in range(number_of_execution): # the middle loops iterates number_of_execution times
r = 0
attempt = 0
while r != 3: # the while-loop iterates as long as r is not equal to 3
r = randrange(10) # randomly pick a number
attempt = attempt + 1 # increase the number of attempts by 1
# I am out of scope of while-loop
total_attempts = total_attempts + attempt # update the total number of attempts
# I am out of scope of for-loop
print(number_of_execution,"->",total_attempts/number_of_execution)
# you can include 2 million to the list, but you should WAIT for a while to see the result
# can your computer compete with exponential growth?
# if you think "yes", please try 20 million, 200 million, and so on
|
https://github.com/PabloMartinezAngerosa/QAOA-uniform-convergence
|
PabloMartinezAngerosa
|
from tsp_qaoa import test_solution
from qiskit.visualization import plot_histogram
import networkx as nx
import numpy as np
import json
import csv
# Array of JSON Objects
header = ['instance','p','distance', 'mean']
length_p = 3
length_instances = 2
with open('qaoa_multiple_p_distance.csv', 'w', encoding='UTF8') as f:
writer = csv.writer(f)
# write the header
writer.writerow(header)
instance_index = 0
for instance in range(length_instances):
instance_index += 1
first_p = False
UNIFORM_CONVERGENCE_P = []
UNIFORM_CONVERGENCE_SAMPLE = []
for p in range(length_p):
p = p+1
if first_p == False:
print("Vuelve a llamar a test_solution")
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(p=p)
first_p = True
else:
job_2, G, UNIFORM_CONVERGENCE_SAMPLE = test_solution(grafo=G, p=p)
# Sort the JSON data based on the value of the brand key
UNIFORM_CONVERGENCE_SAMPLE.sort(key=lambda x: x["mean"])
convergence_min = UNIFORM_CONVERGENCE_SAMPLE[0]
UNIFORM_CONVERGENCE_P.append({
"mean":convergence_min["mean"],
"probabilities": convergence_min["probabilities"]
})
cauchy_function_nk = UNIFORM_CONVERGENCE_P[len(UNIFORM_CONVERGENCE_P) - 1]
p_index = 0
for p_state in UNIFORM_CONVERGENCE_P:
p_index += 1
print(p_index)
mean = p_state["mean"]
print(p_state)
print(mean)
distance_p_cauchy_function_nk = np.max(np.abs(cauchy_function_nk["probabilities"] - p_state["probabilities"]))
writer.writerow([instance_index, p_index, distance_p_cauchy_function_nk, mean])
|
https://github.com/JavierPerez21/QiskitPractice
|
JavierPerez21
|
from qiskit import *
import numpy as np
from math import pi
from qiskit.visualization import plot_histogram, plot_bloch_multivector, plot_state_qsphere, plot_state_city
from qiskit.quantum_info import Statevector
from qiskit.quantum_info import state_fidelity
import matplotlib.pyplot as plt
class RandomCircuitGenerator:
def __init__(self, qubits=1, max_depth=3):
self.qubits = np.arange(0,qubits).tolist()
self.max_depth = max_depth
self.qc = QuantumCircuit(qubits, qubits)
self.single_qubit_gates = ['x', 'z', 'y', 'h', 's', 't', 'rx', 'rz', 'ry', '']
self.multi_qubit_gates = ['cx', 'cz', 'cy', 'ch', 'cs', 'ct', 'crx', 'crz', 'cry', '']
self.angles = [0, pi / 8, pi / 4, 3 * pi / 8, pi / 2, 5 * pi / 8, 3 * pi / 4, 7 * pi / 8, pi, 9 * pi / 8,
5 * pi / 4, 11 * pi / 8, 3 * pi / 2, 13 * pi / 8, 7 * pi / 4, 15 * pi / 8, 2 * pi]
if len(self.qubits) > 1:
self.available_gates = self.single_qubit_gates + self.multi_qubit_gates
else:
self.available_gates = self.single_qubit_gates
def generate_random_circuit(self):
for i in range(0, self.max_depth):
gate = self.available_gates[np.random.randint(0, len(self.available_gates))]
self.add_gate(gate)
def add_gate(self, gate):
if gate == 'x':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.x(qubit)
elif gate == 'z':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.z(qubit)
elif gate == 'y':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.y(qubit)
elif gate == 'h':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.h(qubit)
elif gate == 's':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.s(qubit)
elif gate == 't':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.t(qubit)
elif gate == 'rx':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
angle = self.angles[np.random.randint(0, len(self.angles))]
self.qc.rx(angle, qubit)
elif gate == 'rz':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
angle = self.angles[np.random.randint(0, len(self.angles))]
self.qc.rz(angle, qubit)
elif gate == 'ry':
qubit = self.qubits[np.random.randint(0, len(self.qubits))]
angle = self.angles[np.random.randint(0, len(self.angles))]
self.qc.ry(angle, qubit)
elif gate == 'cx':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.cx(qubit1, qubit2)
elif gate == 'cz':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.cz(qubit1, qubit2)
elif gate == 'cy':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.cy(qubit1, qubit2)
elif gate == 'ch':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.ch(qubit1, qubit2)
elif gate == 'cs':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.cs(qubit1, qubit2)
elif gate == 'ct':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
self.qc.ct(qubit1, qubit2)
elif gate == 'crx':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
angle = self.angles[np.random.randint(0, len(self.angles))]
self.qc.crx(angle, qubit1, qubit2)
elif gate == 'crz':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
angle = self.angles[np.random.randint(0, len(self.angles))]
self.qc.crz(angle, qubit1, qubit2)
elif gate == 'cry':
qubit1 = self.qubits[np.random.randint(0, len(self.qubits))]
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
while qubit1 == qubit2:
qubit2 = self.qubits[np.random.randint(0, len(self.qubits))]
angle = self.angles[np.random.randint(0, len(self.angles))]
self.qc.cry(angle, qubit1, qubit2)
def show_circuit(self):
print(self.qc)
def execution_historgram(self):
qc = self.qc.copy()
qc.measure(self.qubits, self.qubits)
backend = BasicAer.get_backend('qasm_simulator')
job = execute(qc, backend)
return plot_histogram(job.result().get_counts(), color='midnightblue', title="Execution Histogram")
def bloch_sphere(self):
qc = self.qc.copy()
state = Statevector.from_instruction(qc)
return plot_bloch_multivector(state, title="Bloch Sphere", reverse_bits=False)
def q_sphere(self):
qc = self.qc.copy()
state = Statevector.from_instruction(qc)
return plot_state_qsphere(state)
def state_city(self):
qc = self.qc.copy()
backend = BasicAer.get_backend('statevector_simulator')
result = backend.run(transpile(qc, backend)).result()
psi = result.get_statevector(qc)
return plot_state_city(psi)
def add_circuit_guess(self, circuit_guess):
qc = self.qc.copy()
self.circuit_guess = circuit_guess
circuit_guess = circuit_guess.copy()
backend = BasicAer.get_backend('statevector_simulator')
qc_state = execute(qc, backend).result().get_statevector(qc)
circuit_guess_state = execute(circuit_guess, backend).result().get_statevector(circuit_guess)
print("State fidelity of your circuit: {}".format(state_fidelity(circuit_guess_state, qc_state)))
|
https://github.com/JackHidary/quantumcomputingbook
|
JackHidary
|
# install release containing NeutralAtomDevice and IonDevice classes
!pip install cirq~=0.5.0 --quiet
import cirq
import numpy as np
from matplotlib import pyplot as plt
ms = cirq.Duration(nanos=10**6)
us = cirq.Duration(nanos=10**3)
neutral_device = cirq.NeutralAtomDevice(measurement_duration = 5*ms,
gate_duration = 100*us,
control_radius = 2,
max_parallel_z = 3,
max_parallel_xy = 3,
max_parallel_c = 3,
qubits = [cirq.GridQubit(row, col)
for col in range(3)
for row in range(3)])
# Single Qubit Z rotation by Pi/5 radians
neutral_device.validate_gate(cirq.Rz(np.pi/5))
# Single Qubit rotation about axis in X-Y plane Pi/3 radians from X axis by angle of Pi/7
neutral_device.validate_gate(cirq.PhasedXPowGate(phase_exponent=np.pi/3,exponent=np.pi/7))
# Controlled gate with integer exponent
neutral_device.validate_gate(cirq.CNOT)
# Controlled Not gate with two controls
neutral_device.validate_gate(cirq.TOFFOLI)
#Controlled gate with non-integer exponent (rotation angle must be a multiple of pi)
neutral_device.validate_gate(cirq.CZ**1.5)
# Hadamard gates rotate about the X-Z axis, which isn't compatable with our single qubit rotations
neutral_device.validate_gate(cirq.H)
ms = cirq.Duration(nanos=10**6)
us = cirq.Duration(nanos=10**3)
neutral_device = cirq.NeutralAtomDevice(measurement_duration = 5*ms,
gate_duration = 100*us,
control_radius = 2,
max_parallel_z = 3,
max_parallel_xy = 3,
max_parallel_c = 3,
qubits = [cirq.GridQubit(row, col)
for col in range(3)
for row in range(3)])
# Moment/Circuit Examples
moment_circ = cirq.Circuit(device=neutral_device)
qubits = [cirq.GridQubit(row, col) for col in range(3) for row in range(3)]
# Three qubits affected by a Z gate in parallel with Three qubits affected
# by an XY gate
operation_list_one = cirq.Z.on_each(*qubits[:3])+cirq.X.on_each(*qubits[3:6])
valid_moment_one = cirq.Moment(operation_list_one)
moment_circ.append(valid_moment_one)
# A TOFFOLI gate on three qubits that are close enough to eachother
operation_list_two = [cirq.TOFFOLI.on(*qubits[:3])]
valid_moment_two = cirq.Moment(operation_list_two)
moment_circ.append(valid_moment_two)
print(moment_circ)
global_circuit = cirq.Circuit(device=neutral_device)
global_list_of_operations = cirq.X.on_each(*qubits)
global_circuit.append(global_list_of_operations)
print(global_circuit)
global_moment_circuit = cirq.Circuit(device=neutral_device)
global_moment = cirq.Moment(cirq.X.on_each(*qubits))
global_moment_circuit.append(global_moment)
print(global_moment_circuit)
parallel_gate_op_circuit = cirq.Circuit(device=neutral_device)
parallel_gate_op = cirq.ParallelGateOperation(cirq.X,qubits)
parallel_gate_op_circuit.append(parallel_gate_op)
print(parallel_gate_op_circuit)
def oracle(qubits, key_bits):
yield (cirq.X(q) for (q, bit) in zip(qubits, key_bits) if not bit)
yield cirq.CCZ(*qubits)
yield (cirq.X(q) for (q, bit) in zip(qubits, key_bits) if not bit)
# Try changing the key to see the relationship between
# the placement of the X gates and the key
key = (1, 0, 1)
qubits = [cirq.GridQubit(0,col) for col in range(3)]
oracle_example_circuit = cirq.Circuit().from_ops(oracle(qubits,key))
print(oracle_example_circuit)
def diffusion_operator(qubits):
yield cirq.H.on_each(*qubits)
yield cirq.X.on_each(*qubits)
yield cirq.CCZ(*qubits)
yield cirq.X.on_each(*qubits)
yield cirq.H.on_each(*qubits)
qubits = [cirq.GridQubit(0,col) for col in range(3)]
diffusion_circuit = cirq.Circuit().from_ops(diffusion_operator(qubits))
print(diffusion_circuit)
def initial_hadamards(qubits):
yield cirq.H.on_each(*qubits)
uncompiled_circuit = cirq.Circuit()
key = (1,0,1)
qubits = [cirq.GridQubit(0,0),cirq.GridQubit(0,1),cirq.GridQubit(0,2)]
uncompiled_circuit.append(initial_hadamards(qubits))
uncompiled_circuit.append(oracle(qubits,key))
uncompiled_circuit.append(diffusion_operator(qubits))
uncompiled_circuit.append(oracle(qubits,key))
uncompiled_circuit.append(diffusion_operator(qubits))
print(uncompiled_circuit)
def neutral_atom_initial_step(qubits):
yield cirq.ParallelGateOperation(cirq.Y**(1/2), qubits)
def neutral_atom_diffusion_operator(qubits):
yield cirq.ParallelGateOperation(cirq.Y**(1/2), qubits)
yield cirq.CCZ(*qubits)
yield cirq.ParallelGateOperation(cirq.Y**(-1/2), qubits)
ms = cirq.Duration(nanos=10**6)
us = cirq.Duration(nanos=10**3)
qubits = [cirq.GridQubit(row, col) for col in range(3) for row in range(1)]
three_qubit_device = cirq.NeutralAtomDevice(measurement_duration = 5*ms,
gate_duration = us,
control_radius = 2,
max_parallel_z = 3,
max_parallel_xy = 3,
max_parallel_c = 3,
qubits=qubits)
key = (0,1,0)
compiled_grover_circuit = cirq.Circuit(device=three_qubit_device)
compiled_grover_circuit.append(neutral_atom_initial_step(qubits))
compiled_grover_circuit.append(oracle(qubits,key))
compiled_grover_circuit.append(neutral_atom_diffusion_operator(qubits))
compiled_grover_circuit.append(oracle(qubits,key))
compiled_grover_circuit.append(neutral_atom_diffusion_operator(qubits))
print(compiled_grover_circuit)
def grover_circuit_with_n_repetitions(n, key):
ms = cirq.Duration(nanos=10**6)
us = cirq.Duration(nanos=10**3)
qubits = [cirq.GridQubit(row, col) for col in range(3) for row in range(1)]
three_qubit_device = cirq.NeutralAtomDevice(measurement_duration = 5*ms,
gate_duration = us,
control_radius = 2,
max_parallel_z = 3,
max_parallel_xy = 3,
max_parallel_c = 3,
qubits=qubits)
grover_circuit = cirq.Circuit(device=three_qubit_device)
grover_circuit.append(neutral_atom_initial_step(qubits))
for repetition in range(n):
grover_circuit.append(oracle(qubits,key))
grover_circuit.append(neutral_atom_diffusion_operator(qubits))
return grover_circuit
success_probabilities = []
key = (0,1,1)
N = 2**3
#Convert key from binary to a base 10 number
diag = sum(2**(2-count) for (count, val) in enumerate(key) if val)
num_points = 10
for repetitions in range(num_points):
test_circuit = grover_circuit_with_n_repetitions(repetitions, key)
sim = cirq.Simulator()
result = sim.simulate(test_circuit)
rho = result.density_matrix_of(qubits)
success_probabilities.append(np.real(rho[diag][diag]))
plt.scatter(range(num_points), success_probabilities, label="Simulation")
x = np.linspace(0, num_points, 1000)
y = np.sin((2*x+1)*np.arcsin(1/np.sqrt(N)))**2
plt.plot(x, y, label="Theoretical Curve")
plt.title("Probability of Success Vs. Number of Oracle-Diffusion Operators")
plt.ylabel("Probability of Success")
plt.xlabel("Number of Times Oracle and Diffusion Operators are Applied")
plt.legend(loc='upper right')
plt.show()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.