repo
stringclasses 900
values | file
stringclasses 754
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/NirupamKhanal/Qiskit1
|
NirupamKhanal
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.draw(output = 'mpl')
from qiskit.quantum_info import Pauli
ZZ = Pauli('ZZ')
ZI = Pauli('ZI')
IZ = Pauli('IZ')
XX = Pauli('XX')
XI = Pauli('XI')
IX = Pauli('IX')
observables = (ZZ, ZI, IZ, XX, XI, IX)
from qiskit_aer.primitives import Estimator
estimator = Estimator()
job = estimator.run([qc] * len(observables), observables)
job.result()
import matplotlib.pyplot as plt
data = ['ZZ', 'ZI', 'IZ', 'XX', 'XI', 'IX']
values = job.result().values
plt.plot(data, values, '-o')
plt.xlabel('Observables')
plt.ylabel('Expectation value')
plt.show()
def get_qc_for_n_qubit_GHZ_state(n):
qc = QuantumCircuit(n)
qc.h(0)
for i in range(n-1):
qc.cx(i, i+1)
return qc
n = 100
qc = get_qc_for_n_qubit_GHZ_state(n)
qc.draw(output='mpl')
#map operators
from qiskit.quantum_info import SparsePauliOp
operator_strings = ['Z' + 'I' * i + 'Z' + 'I' * (n-2-i) for i in range(n-1)]
print(operator_strings)
print(len(operator_strings))
operators = [SparsePauliOp(operator_string) for operator_string in operator_strings]
#optimization
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
backend_name = "ibm_brisbane"
backend = QiskitRuntimeService().get_backend(backend_name)
pass_manager = generate_preset_pass_manager(optimization_level=1, backend=backend)
qc_transpiled = pass_manager.run(qc)
operators_transpiled_list = [op.apply_layout(qc_transpiled.layout) for op in operators]
#execute on the backend
from qiskit_ibm_runtime import EstimatorV2 as Estimator
from qiskit_ibm_runtime import EstimatorOptions
options = EstimatorOptions()
options.resilience_level = 1
options.optimization_level = 0
options.dynamical_decoupling.enable = True
options.dynamical_decoupling.sequence_type = "XY4"
estimator = Estimator(backend, options=options)
job = estimator.run([(qc_transpiled, operators_transpiled_list)])
job_id = job.job_id()
print(job_id)
#Post-processing and plotting
job_id = 'csg4nzzp7n0g0086qpa0'
service = QiskitRuntimeService()
job = service.job(job_id)
import matplotlib.pyplot as plt
date = list(range(1, len(operators)+1))
result = job.result()[0]
values = result.data.evs
values = [v / values[0] for v in values]
plt.scatter(data, values, marker='o', label='100-qubit GHZ State')
plt.xlabel('Distance between qubits $i$')
plt.ylabel(r'\langle Z_0 Z_i \rangle / \langle Z_0 Z_1 \rangle$')
plt.legend()
plt.show()
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# create class that all property based tests inherit from, and add the required methods that specify input
# generation, preconditions, operations, and post conditions
from abc import ABC, abstractmethod
from qiskit import QuantumCircuit
from QiskitPBT.input_generators.input_generator import InputGenerator
class Property(ABC):
# constructor to initialise the class with the statistical analysis object
def __init__(self):
self.statistical_analysis = None
self.classical_assertion_outcome = True
# generate inputs for the test
# outputs a list of the generated inputs
@abstractmethod
def get_input_generators(self) -> list[InputGenerator]:
# specify return type as list of input generators
pass
# specify the preconditions for the test
@abstractmethod
def preconditions(self, *inputs) -> bool:
pass
# the coordinator will pass all inputs in list order to the operations method
# specify the operations to be performed on the input, assumed to be idempotent
@abstractmethod
def operations(self, *inputs) -> tuple[QuantumCircuit]:
pass
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Utils for using with Qiskit unit tests."""
import logging
import os
import unittest
from enum import Enum
from qiskit import __path__ as qiskit_path
class Path(Enum):
"""Helper with paths commonly used during the tests."""
# Main SDK path: qiskit/
SDK = qiskit_path[0]
# test.python path: qiskit/test/python/
TEST = os.path.normpath(os.path.join(SDK, '..', 'test', 'python'))
# Examples path: examples/
EXAMPLES = os.path.normpath(os.path.join(SDK, '..', 'examples'))
# Schemas path: qiskit/schemas
SCHEMAS = os.path.normpath(os.path.join(SDK, 'schemas'))
# VCR cassettes path: qiskit/test/cassettes/
CASSETTES = os.path.normpath(os.path.join(TEST, '..', 'cassettes'))
# Sample QASMs path: qiskit/test/python/qasm
QASMS = os.path.normpath(os.path.join(TEST, 'qasm'))
def setup_test_logging(logger, log_level, filename):
"""Set logging to file and stdout for a logger.
Args:
logger (Logger): logger object to be updated.
log_level (str): logging level.
filename (str): name of the output file.
"""
# Set up formatter.
log_fmt = ('{}.%(funcName)s:%(levelname)s:%(asctime)s:'
' %(message)s'.format(logger.name))
formatter = logging.Formatter(log_fmt)
# Set up the file handler.
file_handler = logging.FileHandler(filename)
file_handler.setFormatter(formatter)
logger.addHandler(file_handler)
# Set the logging level from the environment variable, defaulting
# to INFO if it is not a valid level.
level = logging._nameToLevel.get(log_level, logging.INFO)
logger.setLevel(level)
class _AssertNoLogsContext(unittest.case._AssertLogsContext):
"""A context manager used to implement TestCase.assertNoLogs()."""
# pylint: disable=inconsistent-return-statements
def __exit__(self, exc_type, exc_value, tb):
"""
This is a modified version of TestCase._AssertLogsContext.__exit__(...)
"""
self.logger.handlers = self.old_handlers
self.logger.propagate = self.old_propagate
self.logger.setLevel(self.old_level)
if exc_type is not None:
# let unexpected exceptions pass through
return False
if self.watcher.records:
msg = 'logs of level {} or higher triggered on {}:\n'.format(
logging.getLevelName(self.level), self.logger.name)
for record in self.watcher.records:
msg += 'logger %s %s:%i: %s\n' % (record.name, record.pathname,
record.lineno,
record.getMessage())
self._raiseFailure(msg)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.deutsch_jozsa.deutsch_jozsa import deutsch_jozsa_circ
from QiskitPBT.case_studies.deutsch_jozsa.dj_helpers import BalancedOracleInputGenerator
from QiskitPBT.property import Property
class DeutschJozsaWorksForBalancedFunction(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [BalancedOracleInputGenerator(5, 10)]
# specify the preconditions for the test
def preconditions(self, oracle):
return True
# specify the operations to be performed on the input
def operations(self, oracle: QuantumCircuit):
circ = deutsch_jozsa_circ(oracle)
# if oracle is constant this should be all 0
baseline = QuantumCircuit(oracle.num_qubits - 1, oracle.num_qubits - 1)
self.statistical_analysis.assert_different(self, list(range(oracle.num_qubits - 1)), circ, list(range(oracle.num_qubits - 1)), baseline, basis=["z"])
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.deutsch_jozsa.deutsch_jozsa import deutsch_jozsa_circ
from QiskitPBT.case_studies.deutsch_jozsa.dj_helpers import ConstantOracleInputGenerator
from QiskitPBT.property import Property
class DeutschJozsaWorksForConstantFunction(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [ConstantOracleInputGenerator(5, 10)]
# specify the preconditions for the test
def preconditions(self, oracle):
return True
# specify the operations to be performed on the input
def operations(self, oracle: QuantumCircuit):
circ = deutsch_jozsa_circ(oracle)
# if oracle is constant this should be all 0
baseline = QuantumCircuit(oracle.num_qubits - 1, oracle.num_qubits - 1)
self.statistical_analysis.assert_equal(self, list(range(oracle.num_qubits - 1)), circ, list(range(oracle.num_qubits - 1)), baseline, basis=["z"])
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Sep 19 19:13:26 2023
@author: abdullahalshihry
"""
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 18 19:15:12 2023
@author: abdullahalshihry
"""
import qiskit as qs
import qiskit.visualization as qv
import random
import qiskit.circuit as qf
def Deutsch_Jozsa(circuit):
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qc.x(qr[4])
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.h(qr[4])
qc.barrier(range(5))
qc = qc.compose(circuit)
qc.barrier(range(5))
qc.h(qr[0])
qc.h(qr[1])
qc.h(qr[2])
qc.h(qr[3])
qc.barrier(range(5))
qc.measure(0,0)
qc.measure(1,1)
qc.measure(2,2)
qc.measure(3,3)
job1 = qs.execute(qc, qs.Aer.get_backend('aer_simulator'), shots = 1024)
output1 = job1.result().get_counts()
print(output1)
qc.draw('mpl')
def Oracle():
qr = qs.QuantumRegister(5,'q')
cr = qs.ClassicalRegister(4,'c')
qc = qs.QuantumCircuit(qr,cr)
qq = qs.QuantumCircuit(5,name='Uf')
v = random.randint(1, 2)
if v == 1:
qc.cx(0,4)
qc.cx(1,4)
qc.cx(2,4)
qc.cx(3,4)
print('Balanced (1)')
elif v == 2:
qq.i(qr[0])
qq.i(qr[1])
qq.i(qr[2])
qq.i(qr[3])
print('Constant (0)')
qq =qq.to_gate()
qc.append(qq,[0,1,2,3,4])
return qc
Deutsch_Jozsa(Oracle())
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
from qiskit import QuantumCircuit
from QiskitPBT.input_generators.input_generator import InputGenerator
class BalancedOracleInputGenerator(InputGenerator):
def __init__(self, low, high):
self.low = low
self.high = high
def generate(self, seed):
random.seed(seed)
num_qubits = random.randint(self.low, self.high)
circuit = QuantumCircuit(num_qubits)
# make a random array of 0s and 1s
xs = [random.randint(0, 1) for _ in range(num_qubits - 1)]
# random array of 0s and 1s, but we must guarantee at least one 1
if num_qubits > 1:
rand_bits = [int(i) for i in bin(random.randint(1, 2**(num_qubits - 1) - 1))[2:]]
cxs = [0]*((num_qubits - 1) - len(rand_bits)) + rand_bits
else:
cxs = []
for idx, i in enumerate(xs):
if i == 1:
circuit.x(circuit.qubits[idx])
for idx, i in enumerate(cxs):
if i == 1:
circuit.cx(circuit.qubits[idx], circuit.qubits[-1])
for idx, i in enumerate(xs):
if i == 1:
circuit.x(circuit.qubits[idx])
return circuit
class ConstantOracleInputGenerator(InputGenerator):
def __init__(self, low, high):
self.low = low
self.high = high
def generate(self, seed):
random.seed(seed)
num_qubits = random.randint(self.low, self.high)
# randomly choose between constant 0 and constant 1
constant = random.randint(0, 1)
qc = QuantumCircuit(num_qubits)
if constant == 1:
qc.x(qc.qubits[-1])
return qc
class RandomOracleInputGenerator(InputGenerator):
def __init__(self, low, high):
self.low = low
self.high = high
def generate(self, seed):
random.seed(seed)
# randomly choose between constant 0 and constant 1
oracle_choice = random.randint(0, 1)
if oracle_choice == 1:
return ConstantOracleInputGenerator(self.low, self.high).generate(seed)
else:
return BalancedOracleInputGenerator(self.low, self.high).generate(seed)
# defines a function that vertically merges two circuits, so that the first circuit is on top of the second, with the
# last qubit of the first circuit being connected to the last qubit of the second circuit
def vmerge(circuit1, circuit2):
# as one register is merged, we need to subtract by one
new_size = circuit1.num_qubits + circuit2.num_qubits - 1
qc = QuantumCircuit(new_size)
qc.compose(circuit1, list(range(0, circuit1.num_qubits - 1)) + [new_size - 1], inplace=True)
# need to start after the first circuit ends
qc.compose(circuit2, list(range(circuit1.num_qubits - 1, new_size - 1)) + [new_size - 1], inplace=True)
return qc
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.deutsch_jozsa.deutsch_jozsa import deutsch_jozsa_circ
from QiskitPBT.case_studies.deutsch_jozsa.dj_helpers import RandomOracleInputGenerator
from QiskitPBT.property import Property
class DeutschJozsaLowerRegisterMinus(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [RandomOracleInputGenerator(3, 10)]
# specify the preconditions for the test
def preconditions(self, oracle):
return True
# specify the operations to be performed on the input
def operations(self, oracle: QuantumCircuit):
circ = deutsch_jozsa_circ(oracle)
# if oracle is constant this should be all 0
baseline = QuantumCircuit(1, 1)
baseline.x(0)
baseline.h(0)
self.statistical_analysis.assert_equal(self, [circ.num_qubits - 1], circ, [0], baseline)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.deutsch_jozsa.deutsch_jozsa import deutsch_jozsa_circ
from QiskitPBT.case_studies.deutsch_jozsa.dj_helpers import BalancedOracleInputGenerator, vmerge
from QiskitPBT.property import Property
class DeutschJozsaVMergeTwoBalancedOracles(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [BalancedOracleInputGenerator(2, 5), BalancedOracleInputGenerator(1, 5)]
# specify the preconditions for the test
def preconditions(self, oracle1, oracle2):
return True
# specify the operations to be performed on the input
def operations(self, oracle1: QuantumCircuit, oracle2: QuantumCircuit):
circ = deutsch_jozsa_circ(vmerge(oracle1, oracle2))
# if oracle is constant this should be all 0
baseline = QuantumCircuit(circ.num_qubits - 1, circ.num_qubits - 1)
self.statistical_analysis.assert_different(self, list(range(circ.num_qubits - 1)), circ, list(range(oracle1.num_qubits - 1)), baseline, basis=["z"])
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.deutsch_jozsa.deutsch_jozsa import deutsch_jozsa_circ
from QiskitPBT.case_studies.deutsch_jozsa.dj_helpers import ConstantOracleInputGenerator, vmerge
from QiskitPBT.property import Property
class DeutschJozsaVMergeTwoConstantOracles(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [ConstantOracleInputGenerator(2, 5), ConstantOracleInputGenerator(2, 5)]
# specify the preconditions for the test
def preconditions(self, oracle1, oracle2):
return True
# specify the operations to be performed on the input
def operations(self, oracle1: QuantumCircuit, oracle2: QuantumCircuit):
circ = deutsch_jozsa_circ(vmerge(oracle1, oracle2))
# if oracle is constant this should be all 0
baseline = QuantumCircuit(circ.num_qubits - 1, circ.num_qubits - 1)
self.statistical_analysis.assert_equal(self, list(range(circ.num_qubits - 1)), circ, list(range(oracle1.num_qubits - 1)), baseline, basis=["z"])
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from argparse import ArgumentParser, Namespace, BooleanOptionalAction
from qiskit import QuantumCircuit as qc
from qiskit import QuantumRegister as qr
from qiskit import transpile
from qiskit_aer import AerSimulator
from qiskit.result import Counts
from matplotlib.pyplot import show, subplots, xticks, yticks
from math import pi, sqrt
from heapq import nlargest
class GroversAlgorithm:
def __init__(self,
title: str = "Grover's Algorithm",
n_qubits: int = 5,
search: set[int] = { 11, 9, 0, 3 },
shots: int = 1000,
fontsize: int = 10,
print: bool = False,
combine_states: bool = False) -> None:
"""
_summary_
Args:
title (str, optional): Window title. Defaults to "Grover's Algorithm".
n_qubits (int, optional): Number of qubits. Defaults to 5.
search (set[int], optional): Set of nonnegative integers to search for using Grover's algorithm. Defaults to { 11, 9, 0, 3 }.
shots (int, optional): Amount of times the algorithm is simulated. Defaults to 10000.
fontsize (int, optional): Histogram's font size. Defaults to 10.
print (bool, optional): Whether or not to print quantum circuit(s). Defaults to False.
combine_states (bool, optional): Whether to combine all non-winning states into 1 bar labeled "Others" or not. Defaults to False.
"""
# Parsing command line arguments
self._parser: ArgumentParser = ArgumentParser(description = "Run grover's algorithm via command line", add_help = False)
self._init_parser(title, n_qubits, search, shots, fontsize, print, combine_states)
self._args: Namespace = self._parser.parse_args()
# Set of nonnegative ints to search for
self.search: set[int] = set(self._args.search)
# Set of m N-qubit binary strings representing target state(s) (i.e. self.search in base 2)
self._targets: set[str] = { f"{s:0{self._args.n_qubits}b}" for s in self.search }
# N-qubit quantum register
self._qubits: qr = qr(self._args.n_qubits, "qubit")
def _print_circuit(self, circuit: qc, name: str) -> None:
"""Print quantum circuit.
Args:
circuit (qc): Quantum circuit to print.
name (str): Quantum circuit's name.
"""
print(f"\n{name}:\n{circuit}")
def _oracle(self, targets: set[str]) -> qc:
"""Mark target state(s) with negative phase.
Args:
targets (set[str]): N-qubit binary string(s) representing target state(s).
Returns:
qc: Quantum circuit representation of oracle.
"""
# Create N-qubit quantum circuit for oracle
oracle = qc(self._qubits, name = "Oracle")
for target in targets:
# Reverse target state since Qiskit uses little-endian for qubit ordering
target = target[::-1]
# Flip zero qubits in target
for i in range(self._args.n_qubits):
if target[i] == "0":
# Pauli-X gate
oracle.x(i)
# Simulate (N - 1)-control Z gate
# 1. Hadamard gate
oracle.h(self._args.n_qubits - 1)
# 2. (N - 1)-control Toffoli gate
oracle.mcx(list(range(self._args.n_qubits - 1)), self._args.n_qubits - 1)
# 3. Hadamard gate
oracle.h(self._args.n_qubits - 1)
# Flip back to original state
for i in range(self._args.n_qubits):
if target[i] == "0":
# Pauli-X gate
oracle.x(i)
# Display oracle, if applicable
if self._args.print: self._print_circuit(oracle, "ORACLE")
return oracle
def _diffuser(self) -> qc:
"""Amplify target state(s) amplitude, which decreases the amplitudes of other states
and increases the probability of getting the correct solution (i.e. target state(s)).
Returns:
qc: Quantum circuit representation of diffuser (i.e. Grover's diffusion operator).
"""
# Create N-qubit quantum circuit for diffuser
diffuser = qc(self._qubits, name = "Diffuser")
# Hadamard gate
diffuser.h(self._qubits)
# Oracle with all zero target state
diffuser.append(self._oracle({"0" * self._args.n_qubits}), list(range(self._args.n_qubits)))
# Hadamard gate
diffuser.h(self._qubits)
# Display diffuser, if applicable
if self._args.print: self._print_circuit(diffuser, "DIFFUSER")
return diffuser
def _grover(self) -> qc:
"""Create quantum circuit representation of Grover's algorithm,
which consists of 4 parts: (1) state preparation/initialization,
(2) oracle, (3) diffuser, and (4) measurement of resulting state.
Steps 2-3 are repeated an optimal number of times (i.e. Grover's
iterate) in order to maximize probability of success of Grover's algorithm.
Returns:
qc: Quantum circuit representation of Grover's algorithm.
"""
# Create N-qubit quantum circuit for Grover's algorithm
grover = qc(self._qubits, name = "Grover Circuit")
# Intialize qubits with Hadamard gate (i.e. uniform superposition)
grover.h(self._qubits)
# # Apply barrier to separate steps
grover.barrier()
# Apply oracle and diffuser (i.e. Grover operator) optimal number of times
for _ in range(int((pi / 4) * sqrt((2 ** self._args.n_qubits) / len(self._targets)))):
grover.append(self._oracle(self._targets), list(range(self._args.n_qubits)))
grover.append(self._diffuser(), list(range(self._args.n_qubits)))
# Measure all qubits once finished
grover.measure_all()
# Display grover circuit, if applicable
if self._args.print: self._print_circuit(grover, "GROVER CIRCUIT")
return grover
def _outcome(self, winners: list[str], counts: Counts) -> None:
"""Print top measurement(s) (state(s) with highest frequency)
and target state(s) in binary and decimal form, determine
if top measurement(s) equals target state(s), then print result.
Args:
winners (list[str]): State(s) (N-qubit binary string(s))
with highest probability of being measured.
counts (Counts): Each state and its respective frequency.
"""
print("WINNER(S):")
print(f"Binary = {winners}\nDecimal = {[ int(key, 2) for key in winners ]}\n")
print("TARGET(S):")
print(f"Binary = {self._targets}\nDecimal = {self.search}\n")
if not all(key in self._targets for key in winners): print("Target(s) not found...")
else:
winners_frequency, total = 0, 0
for value, frequency in counts.items():
if value in winners:
winners_frequency += frequency
total += frequency
print(f"Target(s) found with {winners_frequency / total:.2%} accuracy!")
def _show_histogram(self, histogram_data) -> None:
"""Print outcome and display histogram of simulation results.
Args:
data: Each state and its respective frequency.
"""
# State(s) with highest count and their frequencies
winners = { winner : histogram_data.get(winner) for winner in nlargest(len(self._targets), histogram_data, key = histogram_data.get) }
# Print outcome
self._outcome(list(winners.keys()), histogram_data)
# X-axis and y-axis value(s) for winners, respectively
winners_x_axis = [ str(winner) for winner in [*winners] ]
winners_y_axis = [ *winners.values() ]
# All other states (i.e. non-winners) and their frequencies
others = { state : frequency for state, frequency in histogram_data.items() if state not in winners }
# X-axis and y-axis value(s) for all other states, respectively
other_states_x_axis = "Others" if self._args.combine else [*others]
other_states_y_axis = [ sum([*others.values()]) ] if self._args.combine else [ *others.values() ]
# Create histogram for simulation results
figure, axes = subplots(num = "Grover's Algorithm β Results", layout = "constrained")
axes.bar(winners_x_axis, winners_y_axis, color = "green", label = "Target")
axes.bar(other_states_x_axis, other_states_y_axis, color = "red", label = "Non-target")
axes.legend(fontsize = self._args.fontsize)
axes.grid(axis = "y", ls = "dashed")
axes.set_axisbelow(True)
# Set histogram title, x-axis title, and y-axis title respectively
axes.set_title(f"Outcome of {self._args.shots} Simulations", fontsize = int(self._args.fontsize * 1.45))
axes.set_xlabel("States (Qubits)", fontsize = int(self._args.fontsize * 1.3))
axes.set_ylabel("Frequency", fontsize = int(self._args.fontsize * 1.3))
# Set font properties for x-axis and y-axis labels respectively
xticks(fontsize = self._args.fontsize, family = "monospace", rotation = 0 if self._args.combine else 70)
yticks(fontsize = self._args.fontsize, family = "monospace")
# Set properties for annotations displaying frequency above each bar
annotation = axes.annotate("",
xy = (0, 0),
xytext = (5, 5),
xycoords = "data",
textcoords = "offset pixels",
ha = "center",
va = "bottom",
family = "monospace",
weight = "bold",
fontsize = self._args.fontsize,
bbox = dict(facecolor = "white", alpha = 0.4, edgecolor = "None", pad = 0)
)
def _hover(event) -> None:
"""Display frequency above each bar upon hovering over it.
Args:
event: Matplotlib event.
"""
visibility = annotation.get_visible()
if event.inaxes == axes:
for bars in axes.containers:
for bar in bars:
cont, _ = bar.contains(event)
if cont:
x, y = bar.get_x() + bar.get_width() / 2, bar.get_y() + bar.get_height()
annotation.xy = (x, y)
annotation.set_text(y)
annotation.set_visible(True)
figure.canvas.draw_idle()
return
if visibility:
annotation.set_visible(False)
figure.canvas.draw_idle()
# Display histogram
id = figure.canvas.mpl_connect("motion_notify_event", _hover)
show()
figure.canvas.mpl_disconnect(id)
def run(self) -> None:
"""
Run Grover's algorithm simulation.
"""
# Simulate Grover's algorithm locally
backend = AerSimulator(method = "density_matrix")
# Generate optimized grover circuit for simulation
transpiled_circuit = transpile(self._grover(), backend, optimization_level = 2)
# Run Grover's algorithm simulation
job = backend.run(transpiled_circuit, shots = self._args.shots)
# Get simulation results
results = job.result()
# Get each state's histogram data (including frequency) from simulation results
data = results.get_counts()
# Display simulation results
self._show_histogram(data)
def _init_parser(self,
title: str,
n_qubits: int,
search: set[int],
shots: int,
fontsize: int,
print: bool,
combine_states: bool) -> None:
"""
Helper method to initialize command line argument parser.
Args:
title (str): Window title.
n_qubits (int): Number of qubits.
search (set[int]): Set of nonnegative integers to search for using Grover's algorithm.
shots (int): Amount of times the algorithm is simulated.
fontsize (int): Histogram's font size.
print (bool): Whether or not to print quantum circuit(s).
combine_states (bool): Whether to combine all non-winning states into 1 bar labeled "Others" or not.
"""
self._parser.add_argument("-H, --help",
action = "help",
help = "show this help message and exit")
self._parser.add_argument("-T, --title",
type = str,
default = title,
dest = "title",
metavar = "<title>",
help = f"window title (default: \"{title}\")")
self._parser.add_argument("-n, --n-qubits",
type = int,
default = n_qubits,
dest = "n_qubits",
metavar = "<n_qubits>",
help = f"number of qubits (default: {n_qubits})")
self._parser.add_argument("-s, --search",
default = search,
type = int,
nargs = "+",
dest = "search",
metavar = "<search>",
help = f"nonnegative integers to search for with Grover's algorithm (default: {search})")
self._parser.add_argument("-S, --shots",
type = int,
default = shots,
dest = "shots",
metavar = "<shots>",
help = f"amount of times the algorithm is simulated (default: {shots})")
self._parser.add_argument("-f, --font-size",
type = int,
default = fontsize,
dest = "fontsize",
metavar = "<font_size>",
help = f"histogram's font size (default: {fontsize})")
self._parser.add_argument("-p, --print",
action = BooleanOptionalAction,
type = bool,
default = print,
dest = "print",
help = f"whether or not to print quantum circuit(s) (default: {print})")
self._parser.add_argument("-c, --combine",
action = BooleanOptionalAction,
type = bool,
default = combine_states,
dest = "combine",
help = f"whether to combine all non-winning states into 1 bar labeled \"Others\" or not (default: {combine_states})")
if __name__ == "__main__":
GroversAlgorithm().run()
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
import random
from QiskitPBT.input_generators import InputGenerator
class RandomGroversOracleMarkedStatesPairGenerator(InputGenerator):
def __init__(self, low: int, high: int, marked_states: str | int = "random"):
if low < 2:
raise ValueError("Low must be greater than or equal to 2")
self.low = low
self.high = high
self.marked_states = marked_states
# generate a random grover's oracle with less than half of the states marked
def generate(self, seed):
random.seed(seed)
num_qubits = random.randint(self.low, self.high)
circuit = QuantumCircuit(num_qubits)
N = 2**(num_qubits-1)
if self.marked_states == "random":
# choose to generate a random number of marked states, guaranteed to be less than 1/2 N states
M = random.randint(1, (N//2)-1)
elif self.marked_states == "too_many":
M = random.randint((N//2)+1, N-1)
else:
M = self.marked_states
# chooses M random states to mark from the set of all states that can be marked with the given number of qubits
marked_states = tuple(random.sample(range(N - 1), M))
for state in marked_states:
marking_circ = marking_circuit(num_qubits, state)
circuit = circuit.compose(marking_circ)
return circuit, marked_states
# this is under the assumption that the MSB is q_0
def marking_circuit(num_qubits: int, integer_to_mark: int):
assert 0 <= integer_to_mark < 2 ** (num_qubits-1), f"tried to mark a state :{integer_to_mark} that is larger than: {2**(num_qubits-1) - 1} for the number of upper register qubits {num_qubits-1}"
circuit = QuantumCircuit(num_qubits)
# print(integer_to_mark)
binary = bin(integer_to_mark)[2:]
binary = '0' * (num_qubits - 1 - len(binary)) + binary
binary = binary[::-1]
for idx, bit in enumerate(binary):
if bit == '0':
circuit.x(idx)
# control over all qubits in the circuit (minus workspace register)
circuit.mcx(list(range(num_qubits - 1)), num_qubits - 1)
# uncompute the marked state
for idx, bit in enumerate(binary):
if bit == '0':
circuit.x(idx)
return circuit
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
import numpy as np
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.grovers_algorithm.grovers_algorithm import grovers_algorithm
from QiskitPBT.case_studies.grovers_algorithm.grovers_algorithm_helpers import RandomGroversOracleMarkedStatesPairGenerator
from QiskitPBT.property import Property
class GroversAlgorithmLowerRegisterMinus(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [RandomGroversOracleMarkedStatesPairGenerator(4, 6)]
# specify the preconditions for the test
def preconditions(self, oracle_pair):
oracle, marked_states = oracle_pair
if len(marked_states) == 0 or len(marked_states) > 2**(oracle.num_qubits - 1) - 1:
return False
return True
# specify the operations to be performed on the input
def operations(self, oracle_pair):
oracle, marked_states = oracle_pair
# one qubit is workspace
N = 2**(oracle.num_qubits-1)
# number of marked states is used to identify the number of grover iterations to apply
M = len(marked_states)
# src Nielsen and Chuang, quantum computation and quantum information
n_iterations = int(np.floor((np.pi/4) * np.sqrt((N/M))))
circ = grovers_algorithm(oracle, n_iterations)
# should be -
baseline = QuantumCircuit(1, 1)
baseline.x(0)
baseline.h(0)
self.statistical_analysis.assert_equal(self, [circ.num_qubits - 1], circ, [0], baseline)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
import numpy as np
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.grovers_algorithm.grovers_algorithm import grovers_algorithm
from QiskitPBT.case_studies.grovers_algorithm.grovers_algorithm_helpers import RandomGroversOracleMarkedStatesPairGenerator
from QiskitPBT.property import Property
class GroversAlgorithmMostFrequentNotMarkedIfTooManyMarked(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [RandomGroversOracleMarkedStatesPairGenerator(4, 7, "too_many")]
# specify the preconditions for the test
def preconditions(self, oracle_pair):
oracle, marked_states = oracle_pair
# need more than half for this property to hold
if len(marked_states) < 2**(oracle.num_qubits//2):
return False
return True
# specify the operations to be performed on the input
def operations(self, oracle_pair):
oracle, marked_states = oracle_pair
# for this case to work out, we need to apply at least 1 grover iteration (we would otherwise get 0)
n_iterations = 1
circ = grovers_algorithm(oracle, n_iterations)
# invert most frequent list to get the list of states that are not marked
not_marked_states = list(set(range(2**(circ.num_qubits-1))) - set(marked_states))
not_marked_binary_states = []
# marked states to binary strings to check
for state in not_marked_states:
binary = bin(state)[2:]
binary = '0' * (oracle.num_qubits - 1 - len(binary)) + binary
binary = binary[::-1]
not_marked_binary_states.append(binary)
# TODO: need to implement this assert most frequent, or something like it, all i know about the output state
# is that the most frequent state should be from the list of marked, and (roughly) all should have the same distribution
# but maybe testing that is not easy to implement with what we have
self.statistical_analysis.assert_most_frequent(self, list(range(circ.num_qubits-1)), circ, not_marked_binary_states, basis=["z"])
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
import random
import numpy as np
from qiskit import QuantumCircuit
from QiskitPBT.case_studies.grovers_algorithm.grovers_algorithm import grovers_algorithm
from QiskitPBT.case_studies.grovers_algorithm.grovers_algorithm_helpers import RandomGroversOracleMarkedStatesPairGenerator
from QiskitPBT.property import Property
class GroversAlgorithmMostFrequentMarked(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
return [RandomGroversOracleMarkedStatesPairGenerator(4, 6)]
# specify the preconditions for the test
def preconditions(self, oracle_pair):
oracle, marked_states = oracle_pair
if len(marked_states) == 0 or len(marked_states) > 2**(oracle.num_qubits - 1) - 1:
return False
return True
# specify the operations to be performed on the input
def operations(self, oracle_pair):
oracle, marked_states = oracle_pair
# one qubit is workspace
N = 2**(oracle.num_qubits-1)
# number of marked states is used to identify the number of grover iterations to apply
M = len(marked_states)
binary_states = []
# marked states to binary strings to check
for state in marked_states:
binary = bin(state)[2:]
binary = '0' * (oracle.num_qubits - 1 - len(binary)) + binary
binary = binary[::-1]
binary_states.append(binary)
# src Nielsen and Chuang, quantum computation and quantum information
n_iterations = int(np.floor((np.pi/4) * np.sqrt((N/M))))
circ = grovers_algorithm(oracle, n_iterations)
# TODO: need to implement this assert most frequent, or something like it, all i know about the output state
# is that the most frequent state should be from the list of marked, and (roughly) all should have the same distribution
# but maybe testing that is not easy to implement with what we have
self.statistical_analysis.assert_most_frequent(self, list(range(circ.num_qubits-1)), circ, binary_states, basis=["z"])
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators.random_unitary import RandomUnitary
from QiskitPBT.case_studies.quantum_fourier_transform.quantum_fourier_transform import qft_general
class IdentityProperty(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
unitary = RandomUnitary(1, 10)
return [unitary]
# specify the preconditions for the test
def preconditions(self, unitary):
return True
# specify the operations to be performed on the input
def operations(self, unitary):
n = unitary.num_qubits
# perform Uxn ( Hxn ( QFT (0xn)) )
# QFT (0xn)
qft = qft_general(n)
# Hxn
for i in range(n):
qft.h(i)
# Uxn
qft.append(unitary, range(n))
# perform Uxn (0xn)
qc = QuantumCircuit(n, n)
qc.append(unitary, range(n))
self.statistical_analysis.assert_equal(self, list(range(n)), qft, list(range(n)), qc)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
import numpy as np
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators.random_pauli_basis_state import RandomPauliBasisState
from QiskitPBT.case_studies.quantum_fourier_transform.quantum_fourier_transform import qft_general
class LinearShiftToPhaseShift(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
state = RandomPauliBasisState(1, 5, tuple("z"))
return [state]
# specify the preconditions for the test
def preconditions(self, state):
return True
# specify the operations to be performed on the input
def operations(self, state):
n = state.num_qubits
qft_1 = QuantumCircuit(n, n)
qft_1.initialize(state, reversed(range(n)))
qft_1 = qft_1.compose(qft_general(n, swap=False))
qft_1 = phase_shift(qft_1)
init_state = state.data
# make the first element the last element, and vice versa
shifted_vector = np.roll(init_state, -1)
qft_2 = QuantumCircuit(n, n)
qft_2.initialize(shifted_vector, reversed(range(n)))
qft_2 = qft_2.compose(qft_general(n, swap=False))
self.statistical_analysis.assert_equal(self, list(range(n)), qft_1, list(range(n)), qft_2)
def phase_shift(qc):
for i in range(qc.num_qubits):
qc.p(-np.pi / 2 ** (qc.num_qubits - 1 - i), i)
return qc
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
import numpy as np
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomFourierTransformState
from QiskitPBT.case_studies.quantum_fourier_transform.quantum_fourier_transform import qft_general
class PhaseShiftToLinearShift(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
state = RandomFourierTransformState(1, 5)
return [state]
# specify the preconditions for the test
def preconditions(self, state):
return True
# specify the operations to be performed on the input
def operations(self, state):
n = state.num_qubits
qft_1 = QuantumCircuit(n, n)
qft_1.initialize(state, range(n))
qft_1 = qft_1.compose(qft_general(n, swap=True).inverse(), reversed(range(n)))
qft_1 = linear_shift(qft_1)
qft_2 = QuantumCircuit(n, n)
qft_2.initialize(state, range(n))
qft_2 = phase_shift(qft_2)
qft_2 = qft_2.compose(qft_general(n, swap=True).inverse(), reversed(range(n)))
self.statistical_analysis.assert_equal(self, list(range(n)), qft_1, list(range(n)), qft_2)
def phase_shift(qc):
# we instead apply a positive phase shift to the qubits as the linear shift adds 1 (down shift instead of up)
for i in range(qc.num_qubits):
qc.p(np.pi / 2 ** (qc.num_qubits - 1 - i), i)
return qc
# Apply a series of controlled gates to perform the addition of 1
def linear_shift(qc):
# this
n = qc.num_qubits
for i in reversed(range(1, n)):
qubit_list = [j for j in range(i)]
qc.mcx(qubit_list, i)
qc.x(0)
return qc
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
'''
This program implements the quantum Fourier transform (QFT)
'''
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, IBMQ
from qiskit.visualization import circuit_drawer as drawer
from qiskit.tools.visualization import plot_histogram
from qiskit import execute
from qiskit import Aer
import numpy as np
import time, os, shutil
from matplotlib.pyplot import plot, draw, show
def QFT(q, c, n):
qc = QuantumCircuit(q,c)
# First get the most significant bit
for k in range(n):
j = n - k
# now add the Hadamard transform to qubit j-1
qc.h(q[j-1])
# now each qubit from the lowest significance
# takes one conditional phase shift
for i in reversed(range(j-1)):
qc.cp(2*np.pi/2**(j-i), q[i], q[j-1])
# Finally swap the qubits
for i in range(n//2):
qc.swap(q[i], q[n-i-1])
return qc
# QFT is represented in a matrix form with 2^n rows and columns
# where n represents the number of qubits
def QFTmatrix(n):
qft = np.zeros([2**n,2**n], dtype=complex)
for i in range(2**n):
for k in range(2**n):
qft[i,k] = np.exp(i*k*2*2j*np.pi/(2**n))
return(1/np.sqrt(2**n)*qft)
def QFTcircuit(n):
q = QuantumRegister(n, "q")
c = ClassicalRegister(n, "c")
qc = QFT(q, c, n)
backend = Aer.get_backend('unitary_simulator')
job = execute(qc, backend)
actual = job.result().get_unitary()
np.around(actual, 2)
expected = QFTmatrix(n)
delta = actual - expected
print("Deviation: ", round(np.linalg.norm(delta), 10))
return qc
LaTex_folder_QFT = str(os.getcwd())+'/Latex_quantum_gates/Quantum_Fourier_transform/'
if not os.path.exists(LaTex_folder_QFT):
os.makedirs(LaTex_folder_QFT)
else:
shutil.rmtree(LaTex_folder_QFT)
os.makedirs(LaTex_folder_QFT)
n=4
qc = QFTcircuit(n)
# create a LaTex file for the algorithm
LaTex_code = qc.draw(output='latex_source', initial_state=True, justify=None) # draw the circuit
f_name = 'Quantum_Four_transform_'+str(n)+'qubits.tex'
with open(LaTex_folder_QFT+f_name, 'w') as f:
f.write(LaTex_code)
n = 4
q = QuantumRegister(n, "x")
c = ClassicalRegister(n, "c")
qftCircuit = QFT(q, c, n)
initCircuit = QuantumCircuit(q, c)
for qubit in q:
initCircuit.h(qubit)
initCircuit.barrier(q)
qc = QuantumCircuit.compose(initCircuit, qftCircuit)
qc.barrier(q)
qc.measure(q, c)
# on simulator
backend = Aer.get_backend('qasm_simulator')
job = execute(qc, backend)
k = job.result().get_counts()
print(k)
# on a real quantum computer
provider = IBMQ.load_account()
backend = provider.backend.ibmq_lima
print("Status of backened: ", backend.status())
job = execute(qc, backend=backend, shots = 1024)
lapse = 0
print("This step might take some time.")
time.sleep(3)
interval = 60
while((job.status().name != 'DONE')
and (job.status().name != 'Cancelled')
and (job.status().name != 'ERROR')):
print('Status @ {} seconds'.format(interval * lapse))
print(job.status())
print(job.queue_position())
time.sleep(interval)
lapse +=1
print(job.status())
plt = plot_histogram(job.result().get_counts())
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
import numpy as np
from qiskit.circuit.library import UnitaryGate
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomEigenvectorUnitaryPair, RandomUnitary, Integer
from QiskitPBT.case_studies.quantum_phase_estimation.quantum_phase_estimation import qpe_general
class LowerRegisterUnchangedByEigenvector(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
eigenvector_unitary_pair = RandomEigenvectorUnitaryPair(RandomUnitary(1, 2), 1)
estimation_qubits = Integer(1, 3)
return [eigenvector_unitary_pair, estimation_qubits]
# specify the preconditions for the test
def preconditions(self, eigenvector_unitary_pair, estimation_qubits):
return True
# specify the operations to be performed on the input
def operations(self, eigenvector_unitary_pair, estimation_qubits):
eigenvectors, unitary = eigenvector_unitary_pair
n = unitary.num_qubits
# perform qpe on with an eigenvector in lower register
qpe = qpe_general(estimation_qubits, UnitaryGate(unitary), eigenvectors[0][0])
# state should be the unchanged eigenvector
qpe2 = QuantumCircuit(n, n)
qpe2.initialize(eigenvectors[0][0], list(range(n)))
self.statistical_analysis.assert_equal(self, list(range(estimation_qubits, estimation_qubits+unitary.num_qubits)), qpe, list(range(n)), qpe2)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
import random
import numpy as np
import cmath
from fractions import Fraction
from qiskit.circuit.library import UnitaryGate
from qiskit.quantum_info import Operator, Statevector
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomEigenvectorUnitaryPair, RandomUnitaryLimitedDecimals, InputGenerator
from QiskitPBT.case_studies.quantum_phase_estimation.quantum_phase_estimation import qpe_general
class PhaseCorrectlyEstimatedEnoughQubits(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# here we need to generate inputs i.e. an eigenvector with eigenvalues that are specific fractions of 2pi
# so if we have enough qubits, we can estimate the phase correctly
generator_set = FixedEigenvectorUnitaryWithLimitedQubits(1, 2, 2, 2)
return [generator_set]
# specify the preconditions for the test
def preconditions(self, fixed_eigenvector_unitary_with_limited_qubits):
return True
# specify the operations to be performed on the input
def operations(self, fixed_eigenvector_unitary_with_limited_qubits):
eigenvectors, unitary, estimation_qubits = fixed_eigenvector_unitary_with_limited_qubits
# perform qpe on with an eigenvector in lower register
qpe = qpe_general(estimation_qubits, UnitaryGate(unitary), eigenvectors[0][0])
# # state should be the computational basis state corresponding to the phase
# need to get the phase from eigenvalue, make computational state from eigenvalue
ph = cmath.phase(eigenvectors[0][1])
# if problems come up, this should be the first place to look
# essentially the code below needs to initialise the expected state // last issue was that i needed to reverse the qubits in the statevector
if ph == 0:
binary_fraction = "0" * estimation_qubits
else:
# ensure phase between 0 and 1
ph = ph / (2 * np.pi)
ph = (ph + 1) % 1
# should be number of estimation qubits
frac = Fraction(ph).limit_denominator(2 ** estimation_qubits)
decimal_value = float(frac)
# Convert fractional part to binary
binary_fraction = ""
# limit to number of estimation qubits
while decimal_value > 0 and len(binary_fraction) <= estimation_qubits: # limit to prevent infinite loop
decimal_value *= 2
bit = int(decimal_value)
binary_fraction += str(bit)
decimal_value -= bit
# we need to pad the end with 0's to make the binary string the correct length
binary_fraction = binary_fraction + "0" * (estimation_qubits - len(binary_fraction))
qpe2 = QuantumCircuit(estimation_qubits, estimation_qubits)
qpe2.initialize(Statevector.from_label(binary_fraction), list(range(estimation_qubits)))
# need to reverse qubit order to get it to work, probably due to endianness
self.statistical_analysis.assert_equal(self, list(range(estimation_qubits)), qpe, list(reversed(range(estimation_qubits))), qpe2)
# add input generator for this specific scenario
class FixedEigenvectorUnitaryWithLimitedQubits(InputGenerator):
# choose the fraction of 2pi to limit the decimals to
def __init__(self, unitary_qubits_low, unitary_qubits_high, estimation_qubits_low, estimation_qubits_high):
self.unitary_qubits_low = unitary_qubits_low
self.unitary_qubits_high = unitary_qubits_high
self.estimation_qubits_low = estimation_qubits_low
self.estimation_qubits_high = estimation_qubits_high
def generate(self, seed):
random.seed(seed)
estimation_qubits = random.randint(self.estimation_qubits_low, self.estimation_qubits_high)
eigenvector_vector_value_pairs, unitary = RandomEigenvectorUnitaryPair(
RandomUnitaryLimitedDecimals(
self.unitary_qubits_low,
self.unitary_qubits_high,
estimation_qubits), 1).generate(seed)
return eigenvector_vector_value_pairs, unitary, estimation_qubits
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
import numpy as np
from qiskit.circuit.library import UnitaryGate
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomEigenvectorUnitaryPair, RandomTensorProductOfUnitary, Integer
from QiskitPBT.case_studies.quantum_phase_estimation.quantum_phase_estimation import qpe_general
class PhaseEstimationSumEigenvectors(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
eigenvector_unitary_pair = RandomEigenvectorUnitaryPair(RandomTensorProductOfUnitary(1, 2), 2)
estimation_qubits = Integer(1, 3)
return [eigenvector_unitary_pair, estimation_qubits]
# specify the preconditions for the test
def preconditions(self, eigenvector_unitary_pair, estimation_qubits):
# TODO: this is truly a poor implementation.
# to fix, make a pseudorandom unitary generator to pass to RandomEigenvectorUnitaryPair, which allows for a range of eigenvalues
# but not infinite, as to allow for multiple eigenvectors with the same eigenvalue
# then send all the eigenvectors here instead of an already chosen pair
# check that the eigenvectors have the same eigenvalue
return eigenvector_unitary_pair[0][0][1] == eigenvector_unitary_pair[0][1][1]
# specify the operations to be performed on the input
def operations(self, eigenvector_unitary_pair, estimation_qubits):
eigenvectors, unitary = eigenvector_unitary_pair
for eigenvector, eigenvalue in eigenvectors:
print(eigenvalue)
n = unitary.num_qubits
# perform qpe on with an eigenvector in lower register
qpe = qpe_general(estimation_qubits, UnitaryGate(unitary), eigenvectors[0][0])
# sum of eigenvectors, then normalize
normalized_sum_eigenvectors = (eigenvectors[0][0] + eigenvectors[1][0]) / np.sqrt(2)
qpe2 = qpe_general(estimation_qubits, UnitaryGate(unitary), normalized_sum_eigenvectors)
print(qpe)
print(qpe2)
self.statistical_analysis.assert_equal(self, list(range(estimation_qubits)), qpe,
list(range(estimation_qubits)), qpe2)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from qiskit import QuantumCircuit, transpile, assemble
from qiskit.circuit.library import QFT
class CtrlMultCircuit(QuantumCircuit):
def __init__(self, a, binary_power, N):
super().__init__(N.bit_length())
self.a = a
self.power = 2 ** binary_power # Convert binary to decimal
self.N = N
self.name = f'{self.a}^{self.power} mod {self.N}'
self._create_circuit()
def _create_circuit(self):
for dec_power in range(self.power):
a_exp = self.a ** dec_power % self.N
for i in range(self.num_qubits):
if a_exp >> i & 1: self.x(i)
for j in range(i + 1, self.num_qubits):
if a_exp >> j & 1: self.swap(i, j)
class QPECircuit(QuantumCircuit):
def __init__(self, a, N):
super().__init__(2 * N.bit_length(), N.bit_length())
self.a = a
self.N = N
self._create_circuit()
def _modular_exponentiation(self):
for qbit_idx in range(self.num_qubits // 2):
self.append(
CtrlMultCircuit(self.a, qbit_idx, self.N).to_gate().control(),
[qbit_idx] + list(range(self.num_qubits // 2, 2 * self.num_qubits // 2))
)
def _create_circuit(self):
self.h(range(self.num_qubits // 2)) # Apply Hadamard gates to the first n qubits
self.x(self.num_qubits - 1)
self.barrier()
self._modular_exponentiation() # Apply controlled modular exponentiation
self.barrier()
self.append(
QFT(self.num_qubits // 2, inverse=True),
range(self.num_qubits // 2) # Apply inverse QFT to the first n qubits
)
def collapse(self, simulator):
self.measure(range(self.num_qubits // 2), range(self.num_qubits // 2))
transpiled_circuit = transpile(self, simulator)
self.collapse_result = simulator.run(transpiled_circuit, memory=True).result()
return self.collapse_result
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomState
from QiskitPBT.case_studies.quantum_teleportation.quantum_teleportation import quantum_teleportation
class Inq0EqualOutq2(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
state = RandomState(1)
return [state]
# specify the preconditions for the test
def preconditions(self, q0):
return True
# specify the operations to be performed on the input
def operations(self, q0):
qc = QuantumCircuit(3, 3)
qc.initialize(q0, [0])
qt = quantum_teleportation()
# stitch qc and quantum_teleportation together
qc = qc.compose(qt)
# initialise qubit to compare to:
qc2 = QuantumCircuit(1, 1)
qc2.initialize(q0, [0])
self.statistical_analysis.assert_equal(self, 2, qc, 0, qc2)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomState
from QiskitPBT.case_studies.quantum_teleportation.quantum_teleportation import quantum_teleportation
class NotTeleportedPlus(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
state = RandomState(1)
return [state]
# specify the preconditions for the test
def preconditions(self, q0):
return True
# specify the operations to be performed on the input
def operations(self, q0):
# breaks if classical register is not explicitly defined?
qc = QuantumCircuit(3, 3)
qc.initialize(q0, [0])
qt = quantum_teleportation()
# stitch qc and quantum_teleportation together
qc = qc.compose(qt)
# initialise another circuit to |++> state
# breaks if classical register is not explicitly defined?
qc2 = QuantumCircuit(2, 2)
qc2.h(0)
qc2.h(1)
self.statistical_analysis.assert_equal(self, [0, 1], qc, [0, 1], qc2)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
'''
This is a implementation of the quantum teleportation algorithm
'''
from qiskit import *
from qiskit.visualization import plot_histogram
import os, shutil, numpy
from matplotlib.pyplot import plot, draw, show
LaTex_folder_Quantum_Teleportation = str(os.getcwd())+'/Latex_quantum_gates/Quantum_Teleportation/'
if not os.path.exists(LaTex_folder_Quantum_Teleportation):
os.makedirs(LaTex_folder_Quantum_Teleportation)
else:
shutil.rmtree(LaTex_folder_Quantum_Teleportation)
os.makedirs(LaTex_folder_Quantum_Teleportation)
qc = QuantumCircuit(3,3)
## prepare the state to be teleported
phi = 0*numpy.pi
theta= 0.5*numpy.pi
lam = 0*numpy.pi
qc.u(phi=phi, theta=theta,lam=lam,qubit=0)
## teleport the state
qc.barrier()
qc.h(1)
qc.cx(1,2)
qc.cz(0,1)
qc.h(0)
qc.h(1)
qc.barrier()
qc.measure([0,1],[0,1])
qc.barrier()
qc.x(2).c_if(0,1)
qc.z(2).c_if(1,1)
qc.h(2)
qc.measure(2,2)
LaTex_code = qc.draw(output='latex_source', initial_state=True, justify=None) # draw the circuit
f_name = 'quantum_teleportation.tex'
with open(LaTex_folder_Quantum_Teleportation+f_name, 'w') as f:
f.write(LaTex_code)
# simulation
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, backend=simulator, shots=100000).result()
counts = {'0':0,
'1': 0}
print(result.get_counts().keys())
for key, value in result.get_counts().items():
if(key[0] == '0'):
counts['0'] += value
else:
counts['1'] += value
print(counts)
plt = plot_histogram(counts)
draw()
show(block=True)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomState, RandomUnitary
from QiskitPBT.case_studies.quantum_teleportation.quantum_teleportation import quantum_teleportation
class UnitaryBeforeAndAfterTeleport(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
state = RandomState(1)
unitary = RandomUnitary(1, 1)
return [state, unitary]
# specify the preconditions for the test
def preconditions(self, q0, unitary):
return True
# specify the operations to be performed on the input
def operations(self, q0, unitary):
# apply unitary on first qubit then teleport
qc = QuantumCircuit(3, 3)
qc.initialize(q0, [0])
qc.append(unitary, [0])
qt = quantum_teleportation()
# stitch qc and quantum_teleportation together
qc = qc.compose(qt)
# apply teleport then apply unitary on third qubit
qc2 = QuantumCircuit(3, 3)
qc2.initialize(q0, [0])
qt2 = quantum_teleportation()
# stitch qc and quantum_teleportation together
qc2 = qc2.compose(qt2)
qc2.append(unitary, [2])
self.statistical_analysis.assert_equal(self, [0, 1, 2], qc, [0, 1, 2], qc2)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from uuid import uuid4
from qiskit import QuantumCircuit
from QiskitPBT.stats.measurement_configuration import MeasurementConfiguration
from QiskitPBT.utils import HashableQuantumCircuit
class ExecutionOptimizer:
def __init__(self) -> None:
self.measurement_info_for_unique_circuits: dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]] = {}
self.unoptimized_measurement_info: dict[HashableQuantumCircuit, list[tuple[str, dict[int, QuantumCircuit]]]] = {}
def add_measurement_configuration(self, measurement_config: MeasurementConfiguration) -> None:
base_circuits = measurement_config.get_measured_circuits()
for circuit in base_circuits:
if circuit in self.unoptimized_measurement_info:
self._ensure_unique_measurement_specifications_insertion(circuit, measurement_config.get_measurements_for_circuit(circuit))
else:
self.unoptimized_measurement_info[circuit] = measurement_config.get_measurements_for_circuit(circuit)
# we probably dont need this as this would get optimized later on with circuits, but its probably cheaper like this then with circuit comparisons
def _ensure_unique_measurement_specifications_insertion(self, circuit: HashableQuantumCircuit, measurement_specifications: list[tuple[str, dict[int, QuantumCircuit]]]):
for measurement_id, qubits_measurements in measurement_specifications:
unique = True
# we assume the circuit is in the dict as its only called in context of self.add_measurement_configuration
for stored_measurement_id, stored_qubits_measurements in self.unoptimized_measurement_info[circuit]:
if measurement_id == stored_measurement_id and qubits_measurements == stored_qubits_measurements:
unique = False
break
if unique:
self.unoptimized_measurement_info[circuit].append((measurement_id, stored_qubits_measurements))
def _optimize(self) -> list[HashableQuantumCircuit]:
"""TODO (write this properly):
2. this optimize has to do squashing / optimizing twice:
1. get unique base circuits (and a list of all identical circuit objects for each unique circuit)
2. generate some best effort measurement circuits from measurement config (non overlapping qubit sets go together)
3. once again optimize the resulting circuits (and keep a list of all identical circuit objects)
4. probably flatten/generate a list of really unique circuits to original base circuits and their measurement info
"""
# get unique base circuits:
base_circuits = self.unoptimized_measurement_info.keys()
unique_base_circuits = []
# since we hash by reference, keep track of all duplicated circuits to feed back in get_measurement_info
unique_circuits_to_all: dict[HashableQuantumCircuit, list[HashableQuantumCircuit]] = {}
for circuit in base_circuits:
try:
inserted_circuit_idx = unique_base_circuits.index(circuit)
unique_circuits_to_all[unique_base_circuits[inserted_circuit_idx]].append(circuit)
except ValueError:
unique_base_circuits.append(circuit)
unique_circuits_to_all[circuit] = [circuit]
# generate full circuits, we greedily add measurements to a circuit until we cannot add any more
full_circuits: dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]] = {}
for unique_circuit in unique_base_circuits:
full_circuits.update(self._get_full_circuits(unique_circuit, unique_circuits_to_all[unique_circuit]))
# remove duplicates
full_unique_circuits = []
for full_circuit in full_circuits.keys():
try:
circ_idx = full_unique_circuits.index(full_circuit)
self.measurement_info_for_unique_circuits[full_unique_circuits[circ_idx]].extend(full_circuits[full_circuit])
except ValueError:
full_unique_circuits.append(full_circuit)
self.measurement_info_for_unique_circuits[full_circuit] = full_circuits[full_circuit]
return full_unique_circuits
def _get_full_circuits(self, unique_circuit: HashableQuantumCircuit, duplicate_circuits: HashableQuantumCircuit) -> dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]]:
all_measurement_specifications = []
for circuit in duplicate_circuits:
for measurement_id, qubit_spec in self.unoptimized_measurement_info[circuit]:
all_measurement_specifications.append((measurement_id, qubit_spec, circuit))
measurement_specification_inserted = [False for _ in all_measurement_specifications]
full_circuits: dict[HashableQuantumCircuit, list[tuple[str, HashableQuantumCircuit]]] = {}
while True:
qc = unique_circuit.copy()
qc.reset_hash()
inserted_qubits = {}
measurement_specifications_in_circuit = []
if False not in measurement_specification_inserted:
return full_circuits
for i in range(len(all_measurement_specifications)):
if measurement_specification_inserted[i]:
continue
measurement_id, qubit_measurement_map, original_circuit = all_measurement_specifications[i]
overlapping_qubits = set(inserted_qubits.keys()).intersection(qubit_measurement_map.keys())
should_append_circuit = True
for qubit in overlapping_qubits:
if inserted_qubits[qubit] != qubit_measurement_map[qubit]:
should_append_circuit = False
break
if not should_append_circuit:
continue
else:
measurement_specifications_in_circuit.append((measurement_id, original_circuit))
measurement_specification_inserted[i] = True
for qubit, measurement in qubit_measurement_map.items():
if qubit not in inserted_qubits:
qc.compose(measurement, (qubit,), (qubit,), inplace=True)
inserted_qubits.update(qubit_measurement_map)
full_circuits[qc] = measurement_specifications_in_circuit
def get_circuits_to_execute(self) -> list[QuantumCircuit]:
"""
Returns:
list[QuantumCircuit]: list of unique circuits to be executed based on all measurement configs added to optimizer so far
"""
return [self._get_executable_circuit(circuit) for circuit in self._optimize()]
def get_measurement_info(self, circuit: QuantumCircuit) -> list[tuple[str, HashableQuantumCircuit]]:
"""
Args:
circuit (QuantumCircuit): one of circuits returned by get_circuits_to_execute
Returns:
list[tuple[str, HashableQuantumCircuit]]: list of tuples (measurement_id, original circuit)
- data from measurement configuration provided to the optimizer
"""
return self.measurement_info_for_unique_circuits[self._get_hashable_circuit(circuit)]
def _get_hashable_circuit(self, circuit: QuantumCircuit) -> HashableQuantumCircuit:
circ = circuit.copy()
circ.__class__ = HashableQuantumCircuit
return circ
def _get_executable_circuit(self, circuit: HashableQuantumCircuit) -> QuantumCircuit:
circ = circuit.copy()
circ.__class__ = QuantumCircuit
return circ
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from typing import Sequence
from qiskit import QuantumCircuit
from QiskitPBT.utils import HashableQuantumCircuit
class MeasurementConfiguration:
def __init__(self) -> None:
self._data: dict[HashableQuantumCircuit, list[tuple[str, dict[int, QuantumCircuit]]]] = {}
def add_measurement(self, measurement_id: str, circuit: QuantumCircuit, measurement_specification: dict[int, QuantumCircuit]) -> None:
if circuit in self._data:
self._data[circuit].append((measurement_id, measurement_specification))
else:
self._data[circuit] = [(measurement_id, measurement_specification)]
def get_measured_circuits(self) -> tuple[HashableQuantumCircuit]:
return tuple(self._data.keys())
def get_measurements_for_circuit(self, circuit: HashableQuantumCircuit) -> list[tuple[str, dict[int, QuantumCircuit]]]:
return self._data[circuit]
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from typing import Sequence
from qiskit import QuantumCircuit, transpile
from qiskit.providers.basic_provider import BasicSimulator
from qiskit.providers import Backend
from QiskitPBT.property import Property
from QiskitPBT.stats.assert_entangled import AssertEntangled
from QiskitPBT.utils import HashableQuantumCircuit
from QiskitPBT.stats.assertion import StatisticalAssertion, StandardAssertion, Assertion
from QiskitPBT.stats.measurements import Measurements
from QiskitPBT.stats.single_qubit_distributions.assert_equal import AssertEqual
from QiskitPBT.stats.single_qubit_distributions.assert_different import AssertDifferent
from QiskitPBT.stats.assert_most_frequent import AssertMostFrequent
from QiskitPBT.stats.utils.corrections import holm_bonferroni_correction
from QiskitPBT.stats.execution_optimizer import ExecutionOptimizer
class StatisticalAnalysisCoordinator:
def __init__(self, number_of_measurements=2000, family_wise_p_value=0.05) -> None:
self.assertions_for_property: dict[Property, list[Assertion]] = {}
self.results: dict[Property, bool] = {}
self.number_of_measurements = number_of_measurements
self.family_wise_p_value = family_wise_p_value
self.circuits_executed = 0 # for statistics
#Assertions
def assert_equal(self, property: Property, qubits1: int | Sequence[int], circuit1: QuantumCircuit, qubits2: int | Sequence[int], circuit2: QuantumCircuit, basis = ["x", "y", "z"]):
# parse qubits so that assert equals always gets sequences of qubits
if not isinstance(qubits1, Sequence):
qubits1 = (qubits1, )
if not isinstance(qubits2, Sequence):
qubits2 = (qubits2, )
# hack to make circuits in assert equals be usable as dictionary keys (by ref)
circ1 = circuit1.copy()
circ1.__class__ = HashableQuantumCircuit
circ2 = circuit2.copy()
circ2.__class__ = HashableQuantumCircuit
if property in self.assertions_for_property:
self.assertions_for_property[property].append(AssertEqual(qubits1, circ1, qubits2, circ2, basis))
else:
self.assertions_for_property[property] = [AssertEqual(qubits1, circ1, qubits2, circ2, basis)]
def assert_different(self, property: Property, qubits1: int | Sequence[int], circuit1: QuantumCircuit, qubits2: int | Sequence[int], circuit2: QuantumCircuit, basis = ["x", "y", "z"]):
# parse qubits so that assert equals always gets sequences of qubits
if not isinstance(qubits1, Sequence):
qubits1 = (qubits1, )
if not isinstance(qubits2, Sequence):
qubits2 = (qubits2, )
# hack to make circuits in assert equals be usable as dictionary keys (by ref)
circ1 = circuit1.copy()
circ1.__class__ = HashableQuantumCircuit
circ2 = circuit2.copy()
circ2.__class__ = HashableQuantumCircuit
if property in self.assertions_for_property:
self.assertions_for_property[property].append(AssertDifferent(qubits1, circ1, qubits2, circ2, basis))
else:
self.assertions_for_property[property] = [AssertDifferent(qubits1, circ1, qubits2, circ2, basis)]
def assert_entangled(self, property: Property, qubits: Sequence[int], circuit: QuantumCircuit, basis = ["z"]):
# parse qubits so that assert equals always gets sequences of qubits
if not isinstance(qubits, Sequence):
qubits = (qubits,)
# hack to make circuits in assert equals be usable as dictionary keys (by ref)
circ = circuit.copy()
circ.__class__ = HashableQuantumCircuit
if property in self.assertions_for_property:
self.assertions_for_property[property].append(AssertEntangled(qubits, circ, basis))
else:
self.assertions_for_property[property] = [AssertEntangled(qubits, circ, basis)]
def assert_most_frequent(self, property: Property, qubits: int | Sequence[int], circuit: QuantumCircuit, states: str | Sequence[str], basis = ["z"]):
# parse qubits so that assert equals always gets sequences of qubits / bitstrings
if not isinstance(qubits, Sequence):
qubits = (qubits,)
if not isinstance(states, Sequence):
marked_states = (states, )
# hack to make circuits in assert equals be usable as dictionary keys (by ref)
circ = circuit.copy()
circ.__class__ = HashableQuantumCircuit
if property in self.assertions_for_property:
self.assertions_for_property[property].append(AssertMostFrequent(qubits, circ, states, basis))
else:
self.assertions_for_property[property] = [AssertMostFrequent(qubits, circ, states, basis)]
# Entrypoint for analysis
def perform_analysis(self, properties: list[Property], backend: Backend=BasicSimulator()) -> None:
execution_optimizer = ExecutionOptimizer()
# classical assertion failed dont run quantum
for property in properties:
if not property.classical_assertion_outcome:
self.results[property] = False
continue
for assertion in self.assertions_for_property[property]:
execution_optimizer.add_measurement_configuration(assertion.get_measurement_configuration())
measurements = self._perform_measurements(execution_optimizer, backend)
p_values = {}
for property in properties:
if property.classical_assertion_outcome and property not in self.results:
p_values[property] = {}
for assertion in self.assertions_for_property[property]:
if isinstance(assertion, StatisticalAssertion):
p_value = assertion.calculate_p_values(measurements)
p_values[property][assertion] = p_value
elif not isinstance(assertion, Assertion):
raise ValueError("Assertion must be a subclass of Assertion")
# perform family wise error rate correction
# Ideally, we need to sort all of the p-values from all assertions, then pass back the corrected alpha values to compare them to in a list
# Only do Holm Bonferroni Correction if there are p_values to correct (preconditions pass)
if p_values:
expected_p_values = holm_bonferroni_correction(self.assertions_for_property, p_values, self.family_wise_p_value)
# calculate the outcome of each assertion
for property in properties:
if property not in self.results:
self.results[property] = True
for assertion in self.assertions_for_property[property]:
if isinstance(assertion, StandardAssertion):
self.results[property] = (self.results[property] and assertion.calculate_outcome(measurements))
elif isinstance(assertion, StatisticalAssertion):
self.results[property] = (self.results[property] and assertion.calculate_outcome(p_values[property][assertion], expected_p_values[property][assertion]))
else:
raise ValueError("The provided assertions must be a subclass of Assertion")
# creates a dictionary of measurements for each assertion,
def _perform_measurements(self, execution_optimizer: ExecutionOptimizer, backend: Backend) -> dict[StatisticalAssertion, Measurements]:
measurements = Measurements()
for circuit in execution_optimizer.get_circuits_to_execute():
# TODO: get counts actually returns (or used to) unparsed bit strings, so if there are 2 quantum registers there is a space in there - this may need some attention
# this is necessary for measure to work
counts = backend.run(transpile(circuit, backend), shots=self.number_of_measurements).result().get_counts()
self.circuits_executed += 1
# get the original circuit, as well as basis measurements, and what assertions it is linked to
for measurement_name, original_circuit in execution_optimizer.get_measurement_info(circuit):
measurements.add_measurement(original_circuit, measurement_name, counts)
return measurements
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
from qiskit import QuantumCircuit
def measure_y() -> QuantumCircuit:
circuit = QuantumCircuit(1, 1)
circuit.sdg(0)
circuit.h(0)
circuit.measure(0, 0)
return circuit
def measure_z() -> QuantumCircuit:
circuit = QuantumCircuit(1, 1)
circuit.measure(0, 0)
return circuit
def measure_x() -> QuantumCircuit:
circuit = QuantumCircuit(1, 1)
circuit.h(0)
circuit.measure(0, 0)
return circuit
def ry_then_measure(theta) -> QuantumCircuit:
circuit = QuantumCircuit(1, 1)
circuit.ry(theta, 0)
circuit.measure(0, 0)
return circuit
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators import RandomState
class EntangledPrecondition(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# The assumption of our code is that we need at least one input generator, if we do not include it,
# the code breaks in the test runner - also its a fine assumption to include, property based testing requires inputs
return [RandomState(2)]
# specify the preconditions for the test
def preconditions(self, mock):
return True
# specify the operations to be performed on the input
def operations(self, mock):
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
self.statistical_analysis.assert_entangled(self, [0, 1], qc)
class EntangledCheckOnUnentangledState(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# The assumption of our code is that we need at least one input generator, if we do not include it,
# the code breaks in the test runner - also its a fine assumption to include, property based testing requires inputs
return [RandomState(2)]
# specify the preconditions for the test
def preconditions(self, mock):
return True
# specify the operations to be performed on the input
def operations(self, mock):
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.h(1)
self.statistical_analysis.assert_entangled(self, [0, 1], qc)
class EntangledCheckOnGHZState(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# The assumption of our code is that we need at least one input generator, if we do not include it,
# the code breaks in the test runner - also its a fine assumption to include, property based testing requires inputs
return [RandomState(2)]
# specify the preconditions for the test
def preconditions(self, mock):
return True
# specify the operations to be performed on the input
def operations(self, mock):
qc = QuantumCircuit(3, 3)
qc.h(0)
qc.cx(0, 1)
qc.cx(1, 2)
self.statistical_analysis.assert_entangled(self, [0, 1, 2], qc, basis=["z"])
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators.random_state import RandomState
from QiskitPBT.case_studies.quantum_teleportation.quantum_teleportation import quantum_teleportation
class FailingPrecondition(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
state = RandomState(1)
return [state]
# specify the preconditions for the test
def preconditions(self, q0):
return False
# specify the operations to be performed on the input
def operations(self, q0):
qc = QuantumCircuit(3, 3)
qc.initialize(q0, [0])
qt = quantum_teleportation()
# stitch qc and quantum_teleportation together
qc = qc.compose(qt)
# initialise qubit to compare to:
qc2 = QuantumCircuit(1, 1)
qc2.initialize(q0, [0])
self.statistical_analysis.assert_equal(self, 2, qc, 0, qc2)
|
https://github.com/GabrielPontolillo/QiskitPBT
|
GabrielPontolillo
|
# class that inherits from property based test
from qiskit import QuantumCircuit
from QiskitPBT.property import Property
from QiskitPBT.input_generators import Integer
import random
class FrequencyProperty(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# The assumption of our code is that we need at least one input generator, if we do not include it,
# the code breaks in the test runner - also its a fine assumption to include, property based testing requires inputs
return [Integer(0, 255), Integer(0, 3)]
# specify the preconditions for the test
def preconditions(self, state, padding):
return True
# specify the operations to be performed on the input
def operations(self, state, padding):
padding = 2
binary = bin(state)[2:]
binary = '0' * padding + binary
qc = QuantumCircuit(len(binary), len(binary))
binary_to_mark(qc, binary)
print(qc)
self.statistical_analysis.assert_most_frequent(self, list(range(qc.num_qubits)), qc, [binary], basis=["z"])
class UncertainFrequencyProperty(Property):
# specify the inputs that are to be generated
def get_input_generators(self):
# The assumption of our code is that we need at least one input generator, if we do not include it,
# the code breaks in the test runner - also its a fine assumption to include, property based testing requires inputs
return [Integer(0, 255), Integer(0, 3)]
# specify the preconditions for the test
def preconditions(self, state, padding):
return True
# specify the operations to be performed on the input
def operations(self, state, padding):
padding = 2
binary = bin(state)[2:]
binary = '0' * padding + binary
qc = QuantumCircuit(len(binary), len(binary))
binary_to_mark(qc, binary)
# insert a random hadamard at a random position
index = random.randint(0, len(binary) - 1)
qc.h(index)
# list with two possible outcomes after hadamard
states = [binary[:index] + "0" + binary[index + 1:], binary[:index] + "1" + binary[index + 1:]]
self.statistical_analysis.assert_most_frequent(self, list(range(qc.num_qubits)), qc, states, basis=["z"])
def binary_to_mark(qc: QuantumCircuit, binary_string: str):
"""
Construct a circuit to mark a binary string.
"""
for idx, bit in enumerate(binary_string):
if bit == "1":
qc.x(qc.qubits[idx])
|
https://github.com/neelkamath/quantum-experiments
|
neelkamath
|
import sys
sys.path.append('../')
from circuits import sampleCircuitA, sampleCircuitB1, sampleCircuitB2,\
sampleCircuitB3, sampleCircuitC, sampleCircuitD, sampleCircuitE,\
sampleCircuitF
from entanglement import Ent
import warnings
warnings.filterwarnings('ignore')
labels = [
'Circuit A', 'Circuit B1', 'Circuit B2', 'Circuit B3',
'Circuit C', 'Circuit D', 'Circuit E', 'Circuit F'
]
samplers = [
sampleCircuitA,
sampleCircuitB1,
sampleCircuitB2,
sampleCircuitB3,
sampleCircuitC,
sampleCircuitD,
sampleCircuitE,
sampleCircuitF
]
q = 4
for layer in range(1, 4):
print(f'qubtis: {q}')
print('-' * 25)
for (label, sampler) in zip(labels, samplers):
expr = Ent(sampler, layer=layer, epoch=3000)
print(f'{label}(layer={layer}): {expr}')
print()
|
https://github.com/neelkamath/quantum-experiments
|
neelkamath
|
# Do the necessary imports
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, BasicAer, IBMQ
from qiskit.visualization import plot_histogram, plot_bloch_multivector
### Creating 3 qubit and 2 classical bits in each separate register
qr = QuantumRegister(3)
crz = ClassicalRegister(1)
crx = ClassicalRegister(1)
teleportation_circuit = QuantumCircuit(qr, crz, crx)
### A third party eve helps to create an entangled state
def create_bell_pair(qc, a, b):
qc.h(a)
qc.cx(a, b)
create_bell_pair(teleportation_circuit, 1, 2)
teleportation_circuit.draw()
def alice_gates(qc, a, b):
qc.cx(a, b)
qc.h(a)
teleportation_circuit.barrier()
alice_gates(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def measure_and_send(qc, a, b):
qc.barrier()
qc.measure(a,0)
qc.measure(b,1)
teleportation_circuit.barrier()
measure_and_send(teleportation_circuit, 0, 1)
teleportation_circuit.draw()
def bob_gates(qc, qubit, crz, crx):
qc.x(qubit).c_if(crx, 1)
qc.z(qubit).c_if(crz, 1)
teleportation_circuit.barrier()
bob_gates(teleportation_circuit, 2, crz, crx)
teleportation_circuit.draw()
from qiskit.extensions import Initialize
import math
qc = QuantumCircuit(1)
initial_state = [0,1]
init_gate = Initialize(initial_state)
# qc.append(initialize_qubit, [0])
qr = QuantumRegister(3) # Protocol uses 3 qubits
crz = ClassicalRegister(1) # and 2 classical registers
crx = ClassicalRegister(1)
qc = QuantumCircuit(qr, crz, crx)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
# Alice then sends her classical bits to Bob
measure_and_send(qc, 0, 1)
# Bob decodes qubits
bob_gates(qc, 2, crz, crx)
qc.draw()
backend = BasicAer.get_backend('statevector_simulator')
out_vector = execute(qc, backend).result().get_statevector()
plot_bloch_multivector(out_vector)
inverse_init_gate = init_gate.gates_to_uncompute()
qc.append(inverse_init_gate, [2])
qc.draw()
cr_result = ClassicalRegister(1)
qc.add_register(cr_result)
qc.measure(2,2)
qc.draw()
backend = BasicAer.get_backend('qasm_simulator')
counts = execute(qc, backend, shots=1024).result().get_counts()
plot_histogram(counts)
def bob_gates(qc, a, b, c):
qc.cz(a, c)
qc.cx(b, c)
qc = QuantumCircuit(3,1)
# First, let's initialise Alice's q0
qc.append(init_gate, [0])
qc.barrier()
# Now begins the teleportation protocol
create_bell_pair(qc, 1, 2)
qc.barrier()
# Send q1 to Alice and q2 to Bob
alice_gates(qc, 0, 1)
qc.barrier()
# Alice sends classical bits to Bob
bob_gates(qc, 0, 1, 2)
# We undo the initialisation process
qc.append(inverse_init_gate, [2])
# See the results, we only care about the state of qubit 2
qc.measure(2,0)
# View the results:
qc.draw()
from qiskit import IBMQ
IBMQ.save_account('### IMB TOKEN ')
IBMQ.load_account()
provider = IBMQ.get_provider(hub='ibm-q')
provider.backends()
from qiskit.providers.ibmq import least_busy
backend = least_busy(provider.backends(filters=lambda b: b.configuration().n_qubits >= 3 and
not b.configuration().simulator and b.status().operational==True))
job_exp = execute(qc, backend=backend, shots=8192)
exp_result = job_exp.result()
exp_measurement_result = exp_result.get_counts(qc)
print(exp_measurement_result)
plot_histogram(exp_measurement_result)
error_rate_percent = sum([exp_measurement_result[result] for result in exp_measurement_result.keys() if result[0]=='1']) \
* 100./ sum(list(exp_measurement_result.values()))
print("The experimental error rate : ", error_rate_percent, "%")
|
https://github.com/neelkamath/quantum-experiments
|
neelkamath
|
from qiskit import *
from qiskit.tools.visualization import plot_histogram
%matplotlib inline
secretnumber = '11100011'
circuit = QuantumCircuit(len(secretnumber)+1,len(secretnumber))
circuit.h(range(len(secretnumber)))
circuit.x(len(secretnumber))
circuit.h(len(secretnumber))
circuit.barrier()
for ii, yesno in enumerate(reversed(secretnumber)):
if yesno == '1':
circuit.cx(ii,len(secretnumber))
circuit.barrier()
circuit.h(range(len(secretnumber)))
circuit.barrier()
circuit.measure(range(len(secretnumber)),range(len(secretnumber)))
circuit.draw(output = 'mpl')
|
https://github.com/USCqserver/DD_experiments_qiskit_QEC_course
|
USCqserver
|
### Create an account on https://quantum-computing.ibm.com/login
### Copy the API token from the homepage once logged in.
token = '4c009ac74d75aae40b28b1c22af444fc6da3730bb13b4735263cb69cff1535ec999e9a604e60eaa0b0c6953428e83d2119040d18ff3a81a345e0f44c6a17f460'
!pip install -U -r requirements.txt
from IPython.display import clear_output
clear_output()
import qiskit
import numpy
import matplotlib
import qiskit_ibm_provider
print("Qiskit version:", qiskit.__version__)
print("NumPy version:", numpy.__version__)
print("Matplotlib version:", matplotlib.__version__)
print("provider version:", qiskit_ibm_provider.__version__)
from qiskit import Aer, QuantumCircuit, QuantumRegister, ClassicalRegister, transpile
from qiskit.visualization import plot_gate_map, timeline_drawer
import numpy as np
from IPython.display import display
import matplotlib.pyplot as plt
from qiskit_ibm_provider import IBMProvider
IBMProvider.save_account(token=token, overwrite=True)
# IBMProvider.saved_accounts()
provider = IBMProvider()
backends = provider.backends()
backends
backend = provider.get_backend('ibm_lagos')
plot_gate_map(backend, figsize=(3,3),qubit_size = 30, font_size = 15, plot_directed=True)
properties = backend.properties()
# Extract T1 and T2 times
# Extract data from the properties
t1s = [qubit_data[0].value for qubit_data in properties.qubits]
t2s = [qubit_data[1].value for qubit_data in properties.qubits]
readout_errors = [qubit_data[4].value for qubit_data in properties.qubits]
import matplotlib.pyplot as plt
qubit_indices = [i for i, _ in enumerate(t1s)]
plt.figure(figsize=(10,6))
plt.bar(qubit_indices, t1s, width=-0.4, align='edge', label='T1')
plt.bar(qubit_indices, t2s, width=0.4, align='edge', label='T2')
plt.xlabel('Qubit#')
plt.ylabel('Time (us)') # Changed to microseconds based on your sample
plt.title('T1 and T2 values for each Qubit')
plt.legend()
plt.show()
plt.figure(figsize=(10,6))
plt.bar(qubit_indices, readout_errors, align='center', label='Readout Error')
plt.xlabel('Qubit#')
plt.ylabel('Measurement Error (%)')
plt.show()
two_qubit_gate_errors = []
for gate in properties.gates:
if gate.gate == 'cx':
gate_error = next((item.value for item in gate.parameters if item.name == 'gate_error'), None)
if gate_error:
two_qubit_gate_errors.append((gate.qubits, gate_error))
# Extract data for plotting
gate_names = [f"cx_{gate[0][0]}_{gate[0][1]}" for gate in two_qubit_gate_errors]
errors = [gate[1] for gate in two_qubit_gate_errors]
# Plot
plt.figure(figsize=(7,5))
plt.barh(gate_names, errors, align='center', color='skyblue')
plt.xlabel('Two-Qubit Gate Errors (%)')
plt.xlim(0,0.1)
plt.gca().invert_yaxis() # to display the top qubit pairs at the top
plt.show()
def GHZ_prep(n):
circuits = []
qc = QuantumCircuit(n,n)
mid = int(n/2)
qc.h(mid)
for i in range(mid):
qc.cx(mid-i,mid-i-1)
if mid+i+1<n:
qc.cx(mid+i,mid+i+1)
qc.barrier()
qc.measure(range(n),range(n))
return qc
GHZ_ckts = [GHZ_prep(n) for n in range(2,6)]
GHZ_ckts
for i in range(len(GHZ_ckts)):
display(GHZ_ckts[i].draw('mpl', style="clifford"))
def GHZ_prep_with_inverse(n):
circuits = []
qc = QuantumCircuit(n, n)
mid = int(n / 2)
# GHZ State Preparation
qc.h(mid)
for i in range(mid):
qc.cx(mid - i, mid - i - 1)
if mid + i + 1 < n:
qc.cx(mid + i, mid + i + 1)
qc.barrier()
# Inverse GHZ State Preparation
for i in reversed(range(mid)):
if mid + i + 1 < n:
qc.cx(mid + i, mid + i + 1)
qc.cx(mid - i, mid - i - 1)
qc.h(mid)
qc.barrier()
# Measurement
qc.measure(range(n), range(n))
return qc
GHZ_ckts2 = [GHZ_prep_with_inverse(n) for n in range(2,6)]
GHZ_ckts2
from IPython.display import display
for i in range(len(GHZ_ckts2)):
display(GHZ_ckts2[i].draw('mpl', style="clifford"))
layout = [0,1,3,5,6]
GHZ_5 = GHZ_prep_with_inverse(5)
GHZ_ckts_transpiled = transpile(GHZ_5, backend, initial_layout=layout, optimization_level=0)
GHZ_ckts_transpiled.draw('mpl',style="clifford")
from qiskit_ibm_provider.transpiler.passes.scheduling import DynamicCircuitInstructionDurations
from qiskit_ibm_provider.transpiler.passes.scheduling import ALAPScheduleAnalysis
from qiskit.circuit.library import XGate, RZGate
from qiskit_ibm_provider.transpiler.passes.scheduling import PadDynamicalDecoupling as PDDDynamic
from qiskit.transpiler import PassManager
dd_sequence_2 = [XGate(), XGate()]
dd_sequence_4 = [XGate(), XGate(),XGate(), XGate()]
durations = DynamicCircuitInstructionDurations.from_backend(backend)
pm_dynamic_2X = PassManager(
[
ALAPScheduleAnalysis(durations),
PDDDynamic(durations, dd_sequence_2, spacings = [1/4, 1/2, 1/4],
sequence_min_length_ratios =[2], extra_slack_distribution='edges'),
])
pm_dynamic_4X = PassManager(
[
ALAPScheduleAnalysis(durations),
PDDDynamic(durations, dd_sequence_4, spacings = [1/8, 1/4, 1/4, 1/4, 1/8],
sequence_min_length_ratios =[1], extra_slack_distribution='edges'),
])
circuit_dd_2X = pm_dynamic_2X.run(GHZ_ckts_transpiled)
circuit_dd_4X = pm_dynamic_4X.run(GHZ_ckts_transpiled)
circuit_dd_4X.draw('mpl', style="clifford")
ckt_sched = transpile(circuit_dd_4X, backend=backend, scheduling_method='alap', routing_method=None)
timeline_drawer(ckt_sched, show_idle=False)
shots = 4000
all_ckts = [GHZ_ckts_transpiled, circuit_dd_2X, circuit_dd_4X]
job = backend.run(all_ckts, shots=shots)
job.status()
print(job.job_id())
job_id = 'cn99vd5n6vt000847y30'
job_reloaded = provider.backend.retrieve_job(job_id)
job_reloaded.status()
result = job_reloaded.result()
counts = result.get_counts()
len(counts)
counts[0]['00000']/ sum(counts[0].values()) ## No DD
counts[1]['00000']/ sum(counts[1].values()) ## X2 DD
counts[2]['00000']/ sum(counts[2].values()) ## X4 DD
|
https://github.com/orionhunts-ai/QiskitRuskit
|
orionhunts-ai
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator
# Create a new circuit with two qubits (first argument) and two classical
# bits (second argument)
qc = QuantumCircuit(2)
# Add a Hadamard gate to qubit 0
qc.h(0)
# Perform a controlled-X gate on qubit 1, controlled by qubit 0
qc.cx(0, 1)
# Return a drawing of the circuit using MatPlotLib ("mpl"). This is the
# last line of the cell, so the drawing appears in the cell output.
# Remove the "mpl" argument to get a text drawing.
qc.draw("mpl")
|
https://github.com/orionhunts-ai/QiskitRuskit
|
orionhunts-ai
|
#IRIS QML Example in Mojo
import os
import wandb
import qiskit
import qiskit_
wandb = impy.import_module("wandb")
|
https://github.com/meherafrozantar/QiskitClass
|
meherafrozantar
|
!pip install qiskit qiskit-aer
!pip install qiskit
!pip install pylatexenc
from qiskit import *
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_state_qsphere
from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex
# create a circuit
circuit = QuantumCircuit (1)
# Apply hadamard gate
circuit.h(0)
circuit.h(0)
#draw circuit
circuit.draw(output = 'mpl', initial_state = True)
# select a simulator
simulator = Aer.get_backend('aer_simulator')
# save statevector
circuit.save_statevector()
# assemble our circuit
qobj = assemble(circuit)
# run on simulator
job = simulator.run(qobj)
# monitoring the process
job_monitor(job)
# get results from job
result = job.result()
# get statevector from result
final_state = result.get_statevector()
print(final_state)
array_to_latex(final_state)
# this vector is in which state of quantum?
plot_bloch_multivector(final_state)
# create a circuit
circuit = QuantumCircuit(1)
# Apply a gate
circuit.h(0)
circuit.h(0)
# draw circuit
circuit.draw(output = 'mpl', initial_state=True)
# select a simulator
simulator = Aer.get_backend('aer_simulator')
# save unitary
circuit.save_unitary()
# assemble our circuit
qobj = assemble(circuit)
# run on simulator
job = simulator.run(qobj)
# monitoring the process
job_monitor(job)
# get results from job
result = job.result()
# get the unitary
unitary = result.get_unitary()
print (unitary)
array_to_latex(unitary)
|
https://github.com/meherafrozantar/QiskitClass
|
meherafrozantar
|
!pip install qiskit qiskit-aer
!pip install qiskit
!pip install pylatexenc
from qiskit import *
from qiskit.tools.monitor import job_monitor
from qiskit.tools.visualization import plot_state_qsphere
from qiskit.visualization import plot_histogram, plot_bloch_multivector, array_to_latex
# create a circuit
circuit = QuantumCircuit(1,1)
# Apply Gate
circuit.h(0)
# apply measurement
circuit.measure(0,0)
# draw circuit
circuit.draw(output = 'mpl', initial_state = True)
# select a simulator
simulator = Aer.get_backend('aer_simulator')
# assemble our circuit
qobj = assemble(circuit)
# run on simulator
job = simulator.run(qobj)
# monitoring the process
job_monitor(job)
# get results from job
result = job.result()
# colllect histogram data
count = result.get_counts()
plot_histogram(count)
# import library from QC
from qiskit import IBMQ
# Save API Token
IBMQ.save_account('737fd5837bd6099f57e56b04978b745c124a13757839bf80b239192c46a5e46d516b297fecf9524320e12303ec1b0392ea164895bcfef7e43cd5413f1f0dd179')
# Load account
IBMQ.load_account()
# Select provider
provider = IBMQ.get_provider
|
https://github.com/Hayatto9217/Qiskit11
|
Hayatto9217
|
pip install qiskit-aer
import numpy as np
from qiskit import QuantumCircuit
from qiskit import Aer, transpile
from qiskit.tools.visualization import plot_histogram, plot_state_city
import qiskit.quantum_info as pi
Aer.backends()
simulator = Aer.get_backend('aer_simulator')
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0,1)
circ.measure_all()
simulator = Aer.get_backend('aer_simulator')
circ =transpile(circ, simulator)
result =simulator.run(circ).result()
counts =result.get_counts(circ)
plot_histogram(counts, title= "Bell-State counts")
result =simulator.run(circ,shots=10, memory=True).result()
memory =result.get_memory(circ)
print(memory)
shots = 10000
sim_stabilizer = Aer.get_backend('aer_simulator_stabilizer')
job_stabilizer = sim_stabilizer.run(circ, shots=shots)
counts_stabilizer = job_stabilizer.result().get_counts(0)
sim_statevector = Aer.get_backend('aer_simulator_statevector')
job_statevector =sim_statevector.run(circ, shots=shots)
counts_statevector = job_statevector.result().get_counts(0)
sim_density = Aer.get_backend('aer_simulator_density_matrix')
job_density = sim_density.run(circ, shots=shots)
counts_density = job_density.result().get_counts(0)
sim_mps = Aer.get_backend('aer_simulator_matrix_product_state')
job_mps = sim_mps.run(circ, shots=shots)
counts_mps =job_mps.result().get_counts(0)
plot_histogram([counts_stabilizer, counts_statevector, counts_density, counts_mps],
title='Counts for different simulation methods',
legend=['stabilizer', 'statevector',
'density_matrix', 'matrix_product_state'])
from qiskit_aer import AerError
try:
simulator_gpu = Aer.get_backend('aer_simulator')
simulator_gpu.set_options(device='GPU')
except AerError as e:
print(e)
simulator = Aer.get_backend('aer_simulator_statevector')
simulator.set_options(precision='single')
result =simulator.run(circ).result()
counts =result.get_counts(circ)
print(counts)
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0, 1)
circ.save_statevector()
simulator = Aer.get_backend('aer_simulator')
circ =transpile(circ, simulator)
result =simulator.run(circ).result()
statevector= result.get_statevector(circ)
plot_state_city(statevector,title='Bell state')
steps = 5
circ = QuantumCircuit(1)
for i in range(steps):
circ.save_statevector(label=f'psi_{i}')
circ.rx(i * np.pi / steps, 0)
circ.save_statevector(label=f'psi_{steps}')
simulator = Aer.get_backend('aer_simulator')
circ =transpile(circ, simulator)
result =simulator.run(circ).result()
data =result.data(0)
data
# Generate a random statevector
num_qubits = 2
psi = random_statevector(2 ** num_qubits, seed=100)
# Set initial state to generated statevector
circ = QuantumCircuit(num_qubits)
circ.set_statevector(psi)
circ.save_state()
# Transpile for simulator
simulator = Aer.get_backend('aer_simulator')
circ = transpile(circ, simulator)
# Run and get saved data
result = simulator.run(circ).result()
result.data(0)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/ardieb/QiskitPlayground
|
ardieb
|
from qiskit import *
from qiskit.quantum_info import *
from qiskit.visualization import *
from qiskit.circuit.library import *
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import itertools
import collections
import typing
%matplotlib inline
Array = np.ndarray
def teleporter(phi: Array):
assert phi.shape[0] == 2, "initialized state must have 2 entries (single qubit)"
qr = QuantumRegister(3, 'q')
crz = ClassicalRegister(1, 'crz')
crx = ClassicalRegister(1, 'crx')
circ = QuantumCircuit(qr, crz, crx)
circ.reset(qr[1])
circ.reset(qr[2])
circ.h(qr[1])
circ.cx(qr[1], qr[2])
circ.initialize(phi, qr[0])
circ.barrier()
circ.cx(qr[0], qr[1])
circ.h(qr[0])
circ.barrier()
circ.measure(qr[1], crx)
circ.measure(qr[0], crz)
circ.barrier()
circ.x(qr[2]).c_if(crx, 1)
circ.z(qr[2]).c_if(crz, 1)
return circ
sv_simulator = Aer.get_backend('statevector_simulator')
# Let's teleport the state 1/sqrt(2) [1, exp(i pi / 4)]
phi = np.array([1/np.sqrt(2), 1/np.sqrt(2) * np.exp(1j * np.pi / 4)])
circ = teleporter(phi)
display(circ.draw('mpl'))
result = execute(circ, sv_simulator).result()
display(plot_bloch_multivector(result.get_statevector(circ, decimals = 3)))
def key_update(a: int, b: int, c: int, d: int):
assert all(0 <= x <= 1 for x in [a,b,c,d]), "inputs must be an integer modulo 2"
return {'H': f'{b}{a}', 'X': f'{a}{b}', 'Z': f'{a}{b}', 'S': f'{a}{a ^ b}', 'cX': f'{a}{b ^ d}{a ^ c}{d}'}
df = []
for a in (0, 1):
for b in (0, 1):
for c in (0, 1):
for d in (0, 1):
update = key_update(a, b, c, d)
update['abcd'] = f'{a}{b}{c}{d}'
df.append(update)
df = pd.DataFrame(df)
df.set_index('abcd', inplace = True)
print(df)
# rho = 1/2 * np.array([[1,3], [3, 1]])
# tau = 0.8
qr = QuantumRegister(5, 'q')
cr = ClassicalRegister(5, 'c')
qpce = QuantumCircuit(qr, cr)
# prepare the state
theta1, theta2, alpha = 0.643, 2.498, 2.094
qpce.h(qr[3])
qpce.x(qr[3])
qpce.cu(theta1, 0, 0, 0, qr[3], qr[4])
qpce.x(qr[3])
qpce.cu(theta2, 0, 0, 0, qr[3], qr[4])
qpce.barrier()
# phase estimation
qpce.h(qr[1])
qpce.h(qr[2])
qpce.cu(-np.pi/2, -np.pi/2, np.pi/2, 0, qr[2], qr[3])
qpce.p(3*np.pi/4, qr[2])
qpce.cx(qr[1], qr[3])
qpce.swap(qr[1], qr[2])
qpce.h(qr[2])
qpce.cp(-np.pi/2, qr[1], qr[2])
qpce.h(qr[1])
qpce.barrier()
# Controlled rotation
qpce.cx(qr[1], qr[2])
qpce.cu(alpha, 0, 0, 0, qr[1], qr[0])
qpce.cu(alpha, 0, 0, 0, qr[2], qr[0])
qpce.cx(qr[1], qr[2])
qpce.barrier()
# Inverse phase estimation
qpce.h(qr[1])
qpce.cp(np.pi/2, qr[1], qr[2])
qpce.h(qr[2])
qpce.swap(qr[1], qr[2])
qpce.cx(qr[1], qr[3])
qpce.h(qr[1])
qpce.p(-3*np.pi/4, qr[2])
qpce.cu(-np.pi/2, -np.pi/2, np.pi/2, 0, qr[2], qr[3])
qpce.h(qr[2])
qpce.barrier()
# Measurement
qpce.measure(qr[0], cr[0])
qpce.measure(qr[1], cr[1])
qpce.measure(qr[2], cr[2])
qpce.measure(qr[3], cr[3])
qpce.measure(qr[4], cr[4])
qpce.draw('mpl')
qasm_simulator = Aer.get_backend('qasm_simulator')
result = execute(qpce, qasm_simulator, shots=2048).result()
display(plot_histogram(result.get_counts()))
# The operation is HTHT
# a0, b0 = 1, 1
qr = QuantumRegister(5, 'q')
cr = ClassicalRegister(5, 'c')
qku = QuantumCircuit(qr, cr)
# initialize
qku.reset(qr[0])
qku.reset(qr[1])
qku.reset(qr[3])
qku.h(qr[0])
qku.h(qr[1])
qku.h(qr[3])
qku.x(qr[0])
qku.cx(qr[1], qr[2])
qku.cx(qr[3], qr[4])
qku.z(qr[0])
qku.t(qr[0])
qku.swap(qr[0], qr[1])
qku.h(qr[0])
qku.s(qr[1])
qku.t(qr[0])
qku.cx(qr[1], qr[2])
qku.h(qr[1])
qku.swap(qr[0], qr[3])
qku.h(qr[0])
qku.s(qr[3])
qku.cx(qr[3], qr[4])
qku.h(qr[3])
qku.barrier()
qku.measure(qr[4], cr[4])
qku.measure(qr[3], cr[3])
qku.measure(qr[2], cr[2])
qku.measure(qr[1], cr[1])
qku.measure(qr[0], cr[0])
qku.draw('mpl')
result = execute(qku, qasm_simulator, shots=2048).result()
display(plot_histogram(result.get_counts(), figsize=(10,10)))
# The operation is HTHT
# a0, b0 = 0, 1
qr = QuantumRegister(5, 'q')
cr = ClassicalRegister(5, 'c')
qku = QuantumCircuit(qr, cr)
# initialize
qku.reset(qr[0])
qku.reset(qr[1])
qku.reset(qr[3])
qku.h(qr[0])
qku.h(qr[1])
qku.h(qr[3])
# qku.x(qr[0]) a = 0
qku.cx(qr[1], qr[2])
qku.cx(qr[3], qr[4])
qku.z(qr[0])
qku.t(qr[0])
qku.swap(qr[0], qr[1])
qku.h(qr[0])
qku.s(qr[1])
qku.t(qr[0])
qku.cx(qr[1], qr[2])
qku.h(qr[1])
qku.swap(qr[0], qr[3])
qku.h(qr[0])
qku.s(qr[3])
qku.cx(qr[3], qr[4])
qku.h(qr[3])
qku.barrier()
#ra(2)
qku.measure(qr[4], cr[4])
#rb(2)
qku.measure(qr[3], cr[3])
#ra(1)
qku.measure(qr[2], cr[2])
#rb(1)
qku.measure(qr[1], cr[1])
#q0
qku.measure(qr[0], cr[0])
qku.draw('mpl')
result = execute(qku, qasm_simulator, shots=2048).result()
display(plot_histogram(result.get_counts(), figsize=(10,10)))
# Select 4 measurements with high probability, here we choose > 0.05
import random
sample = []
counts = list(result.get_counts().items())
total = sum(x for _, x in counts)
while len(sample) < 4:
state, count = counts[random.randint(0,len(counts)-1)]
if count / total >= 0.05:
sample.append(state)
print(sample)
a0, b0 = 0, 1
for state in sample:
ra2, rb2, ra1, rb1, q0 = [int(c) for c in state]
af = b0 ^ ra1 ^ rb1 ^ rb2
bf = a0 ^ b0 ^ rb1 ^ ra2
print(f'Measurements are {state}')
print(f'Final decyption keys: {af}, {bf}')
print(f'Final state measurement: {q0}')
# here we find the opposite of the researchers result, where if af = 0 we measure q0 = 0 and if af = 1 we measure q0 = 1
|
https://github.com/ardieb/QiskitPlayground
|
ardieb
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
from qiskit.quantum_info import Statevector, random_statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere, plot_state_city
from qiskit.circuit.library import iSwapGate
import numpy as np
import matplotlib.pyplot as plt
import itertools
%matplotlib inline
sim = Aer.get_backend('statevector_simulator')
toffoli = QuantumCircuit(3)
toffoli.h([2])
toffoli.cx([1], [2])
toffoli.tdg([2])
toffoli.cx([0], [2])
toffoli.t([2])
toffoli.cx([1], [2])
toffoli.tdg([2])
toffoli.cx([0], [2])
toffoli.tdg([1])
toffoli.t([2])
toffoli.cx([0], [1])
toffoli.h([2])
toffoli.tdg([1])
toffoli.cx([0], [1])
toffoli.t([0])
toffoli.s([1])
results = []
circuits = []
basis_states = [''.join(s) for s in itertools.product('01', repeat=3)]
for state in basis_states:
circ = QuantumCircuit(3)
circ.initialize(Statevector.from_label(state).data, [0,1,2])
circ = circ + toffoli
circuits.append(circ)
results.append(execute(circ, sim).result())
toffoli.draw('mpl')
for state, res in zip(basis_states, results):
print(f'Input state: {state}')
display(plot_histogram(res.get_counts()))
toffoli2 = QuantumCircuit(3)
toffoli2.ry(np.pi/4, [2])
toffoli2.cx([1], [2])
toffoli2.ry(np.pi/4, [2])
toffoli2.cx([0], [2])
toffoli2.ry(-np.pi/4, [2])
toffoli2.cx([1], [2])
toffoli2.ry(-np.pi/4, [2])
results2 = []
circuits2 = []
for state in basis_states:
circ = QuantumCircuit(3)
circ.initialize(Statevector.from_label(state).data, [0,1,2])
circ = circ + toffoli2
circuits2.append(circ)
results2.append(execute(circ, sim).result())
toffoli2.draw('mpl')
for state, res in zip(basis_states, results2):
print(f'Input state: {state}')
display(plot_histogram(res.get_counts()))
# Compare the results
for state, res1, circ1, res2, circ2 in zip(basis_states, results, circuits, results2, circuits2):
print(f'Input state: {state}')
s1, s2 = res1.get_statevector(circ1, decimals=3), res2.get_statevector(circ2, decimals=3)
print(f'Output of toffoli is: {s1}')
print(f'Output of phase offset toffoli is: {s2}')
print('\n')
circ1 = QuantumCircuit(2)
circ1.reset([0])
circ1.reset([1])
circ1.ry(np.pi/2, [1])
circ1.ry(np.pi/2, [0])
circ1.x([1])
circ1.cz([0], [1])
circ1.x([1])
circ1.ry(np.pi/2,[0])
circ2 = QuantumCircuit(2)
circ2.reset([0])
circ2.reset([1])
circ2.h([0])
circ2.cx([0],[1])
res1, res2 = execute(circ1, sim).result(), execute(circ2, sim).result()
display(circ1.draw('mpl'))
display(circ2.draw('mpl'))
# They both Produce the bell state
sv1 = res1.get_statevector(circ1, decimals=3)
sv2 = res2.get_statevector(circ2, decimals=3)
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
# But they don't evalaute the same on the entire basis...
circ1 = QuantumCircuit(2)
circ1.initialize(Statevector.from_label('01').data, [0, 1])
circ1.ry(np.pi/2, [1])
circ1.ry(np.pi/2, [0])
circ1.x([1])
circ1.cz([0], [1])
circ1.x([1])
circ1.ry(np.pi/2,[0])
circ2 = QuantumCircuit(2)
circ2.initialize(Statevector.from_label('01').data, [0, 1])
circ2.h([0])
circ2.cx([0],[1])
res1, res2 = execute(circ1, sim).result(), execute(circ2, sim).result()
sv1 = res1.get_statevector(circ1, decimals=3)
sv2 = res2.get_statevector(circ2, decimals=3)
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
circ1 = QuantumCircuit(3)
circ1.ry(np.pi/2, [0])
circ1.ry(np.pi/2, [1])
circ1.ry(np.pi/2, [2])
circ1.x([1])
circ1.cz([0], [1])
circ1.x([1])
circ1.x([1])
circ1.cz([2], [1])
circ1.x([1])
circ1.ry(np.pi/2, [0])
circ1.ry(np.pi/2, [2])
circ2 = QuantumCircuit(3)
circ2.ry(np.pi/2, [0])
circ2.ry(np.pi/2, [1])
circ2.ry(np.pi/2, [2])
# we defined the iSwapGate in class to be the inverse of what qiskit defined it as
circ2.append(iSwapGate().inverse(), [[0], [1]], [])
circ2.append(iSwapGate().inverse(), [[1], [2]], [])
circ2.rx(-np.pi/2, [0])
circ2.rx(-np.pi/2, [1])
circ3 = QuantumCircuit(3)
circ3.h([0])
circ3.cx([0], [1])
circ3.cx([1], [2])
# On the state 000
results = []
circuits = []
for c in (circ1, circ2, circ3):
circ = QuantumCircuit(3)
circ.reset([0])
circ.reset([1])
circ.reset([2])
circ = circ + c
display(circ.draw('mpl'))
circuits.append(circ)
results.append(execute(circ, sim).result())
sv1, sv2, sv3 = (results[i].get_statevector(circuits[i], decimals=3) for i in range(3))
res1, res2, res3 = results
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
display(plot_histogram(res3.get_counts()))
display(plot_state_city(sv3))
# but they're not the same on all basis states
results = []
circuits = []
for c in (circ1, circ2, circ3):
circ = QuantumCircuit(3)
circ.initialize(Statevector.from_label('010').data, [0,1,2])
circ = circ + c
circuits.append(circ)
results.append(execute(circ, sim).result())
sv1, sv2, sv3 = (results[i].get_statevector(circuits[i], decimals=3) for i in range(3))
res1, res2, res3 = results
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
display(plot_histogram(res3.get_counts()))
display(plot_state_city(sv3))
# First need to make the exponential matrix operator
from scipy.linalg import expm
from qiskit.extensions import UnitaryGate
sx = np.array([[0, 1],[1, 0]])
sy = np.array([[0, -1j],[1j, 0]])
sz = np.array([[1, 0],[0, -1]])
S = .5 * (np.kron(np.eye(2), np.kron(sx, sx)) + np.kron(sx, np.kron(np.eye(2), sx)) + np.kron(sx, np.kron(sx, np.eye(2)))
+ np.kron(np.eye(2), np.kron(sy, sy)) + np.kron(sy, np.kron(np.eye(2), sy)) + np.kron(sy, np.kron(sy, np.eye(2))))
G = UnitaryGate(expm(-1j * np.pi/2 * 4/9 * S), label = 'Exp')
wcircuit = QuantumCircuit(3)
wcircuit.reset([0])
wcircuit.reset([1])
wcircuit.reset([2])
wcircuit.x([1])
wcircuit.append(G, [[0], [1], [2]])
wcircuit.rz(4 * np.pi/3, [1])
wcircuit.draw('mpl')
res = execute(wcircuit, sim).result()
sv = res.get_statevector(wcircuit, decimals=3)
display(plot_histogram(res.get_counts()))
display(plot_state_city(sv))
a = '11'
initphi = QuantumCircuit(3, 2)
initphi.reset([0])
initphi.reset([1])
initphi.reset([2])
initphi.x([2])
initphi.h([0, 1, 2])
uf = QuantumCircuit(3, 2)
uf.ccx([0], [1], [2])
grover = QuantumCircuit(3, 2)
grover.h([0, 1])
grover.x([0, 1])
grover.cz([0], [1])
grover.x([0, 1])
grover.h([0, 1])
display(initphi.draw('mpl'))
display(uf.draw('mpl'))
display(grover.draw('mpl'))
iterations = int((np.pi/4) * 2**2/2)
circ = initphi
for _ in range(iterations):
circ = circ + uf + grover
circ.measure([0, 1], [0, 1])
# on a qasm simulator
qasm_sim = Aer.get_backend('qasm_simulator')
shots = 1024
res = execute(circ, backend=qasm_sim, shots=shots).result()
plot_histogram(res.get_counts())
# random state for testing
rng_state = random_statevector(4)
plot_state_qsphere(rng_state.data)
circ1 = QuantumCircuit(4, 2)
circ1.reset([0])
circ1.reset([1])
circ1.initialize(rng_state.data, [2, 3])
circ1.h([0, 1])
circ1.cx([0], [2])
circ1.cx([0], [3])
circ1.cz([1], [2])
circ1.cz([1], [3])
circ1.h([0, 1])
circ1.measure([0, 1], [0, 1])
circ2 = QuantumCircuit(4, 2)
circ2.reset([0])
circ2.reset([1])
circ2.initialize(rng_state.data, [2, 3])
circ2.h([0])
circ2.cx([0], [2])
circ2.cx([0], [3])
circ2.h([0])
circ2.cx([2], [1])
circ2.cx([3], [1])
circ2.measure([0, 1], [0, 1])
display(circ1.draw('mpl'))
display(circ2.draw('mpl'))
# check that these circuits produce the same measurements
shots = 1024
res = execute(circ1, backend=qasm_sim, shots=shots).result()
plot_histogram(res.get_counts())
shots = 1024
res = execute(circ2, backend=qasm_sim, shots=shots).result()
plot_histogram(res.get_counts())
psi = random_statevector(2)
qr = QuantumRegister(4, 'q')
cr = [ClassicalRegister(1, 'a'), ClassicalRegister(1, 'b')]
circ = QuantumCircuit(qr)
circ.add_register(cr[0])
circ.add_register(cr[1])
circ.reset(qr[0])
circ.reset(qr[2])
circ.reset(qr[3])
circ.initialize(psi.data, qr[1])
circ.t(qr[2])
circ.h(qr[0])
circ.cz(qr[0], qr[1])
circ.cz(qr[0], qr[2])
circ.h(qr[0])
circ.measure(qr[0], cr[0])
# This was my answer on the hw
#circ.x(qr[1]).c_if(cr[0], 1)
#circ.z(qr[1]).c_if(cr[0], 1)
#circ.x(qr[1]).c_if(cr[0], 1)
circ.unitary(UnitaryGate(expm(2 * 1j * np.pi/4 * sz)), [qr[1]],).c_if(cr[0], 1)
circ.h(qr[3])
circ.cx(qr[3], qr[2])
circ.h(qr[3])
circ.measure(qr[3], cr[1])
#circ.x(qr[1]).c_if(cr[1], 1)
#circ.z(qr[1]).c_if(cr[1], 1)
#circ.x(qr[1]).c_if(cr[1], 1)
circ.z(qr[1]).c_if(cr[1], 1)
display(circ.draw('mpl'))
result = execute(circ, sim).result()
plot_histogram(result.get_counts())
sv = result.get_statevector(circ, decimals=3)
print(sv)
display(plot_state_qsphere(sv))
display(plot_bloch_multivector(sv))
# compare to just T gate
circ2 = QuantumCircuit(1)
circ2.initialize(psi.data, [0])
circ2.t([0])
result2 = execute(circ2, sim).result()
sv2 = result2.get_statevector(circ2, decimals=3)
plot_bloch_multivector(sv2)
plot_histogram(result2.get_counts())
from qiskit.circuit.library import TGate, ZGate, RZGate
circ1 = QuantumCircuit(3)
circ1.cx([2], [1])
circ1.cx([1], [0])
circ1.t([0])
circ1.tdg([1])
circ1.t([2])
circ1.cx([2], [1])
circ1.cx([1], [0])
circ1.tdg([0])
circ1.cx([2], [0])
circ2 = QuantumCircuit(3)
circ2.append(TGate().inverse().power(2).control(1, label='$S^\dagger$'), [0, 1])
circ2.append(ZGate().control(2), [0, 1, 2])
circ3 = QuantumCircuit(3)
circ3.append(RZGate(np.pi).control(2), [0, 1, 2]) # equiv to -iZ
display(circ1.draw('mpl'))
display(circ2.draw('mpl'))
display(circ3.draw('mpl'))
# eval on random state
psi = random_statevector(8)
circuits = []
results = []
for c in (circ1, circ2, circ3):
circ = QuantumCircuit(3)
circ.initialize(psi.data, [0, 1, 2])
circ = circ + c
circuits.append(circ)
results.append(execute(circ, sim).result())
sv1, sv2, sv3 = [res.get_statevector(circ, decimals=3) for circ, res in zip(circuits, results)]
res1, res2, res3 = results
plot_histogram(res1.get_counts())
plot_histogram(res2.get_counts())
plot_histogram(res3.get_counts())
# I'll use a 7 bit circuit ==> P operates on 4 qubits, operators chosen at random
from qiskit.circuit.library import XGate, YGate, ZGate
import random
from time import time
random.seed(time())
# random composition of gates
P = [[None, XGate(), YGate(), ZGate()][random.randint(0, 3)] for _ in range(4)]
qr = QuantumRegister(7, 'q')
cr = [ClassicalRegister(1, 'a'), ClassicalRegister(1, 'b')]
circ = QuantumCircuit(qr)
circ.add_register(cr[0])
circ.add_register(cr[1])
# initial states
for i in range(7):
circ.reset(qr[i])
# theta = pi/4
circ.t(qr[5])
# arbitrary input state to apply Ptheta to
circ.x(qr[1])
circ.h(qr[2])
circ.x(qr[3])
circ.y(qr[4])
circ.h(qr[0])
for i, u in enumerate(P):
if u is not None:
circ.append(u.control(1), [qr[0],qr[i+1]])
circ.cz(qr[0], qr[5])
circ.h(qr[0])
circ.measure(qr[0], cr[0])
circ.h(qr[6])
circ.cx(qr[6], qr[5])
circ.h(qr[6])
circ.measure(qr[6], cr[1])
# O1
for i, u in enumerate(P):
if u is not None:
circ.append(UnitaryGate(expm(2 * 1j * np.pi/4 * u.to_matrix())).c_if(cr[0], 1), [qr[i + 1]])
# O2
for i, u in enumerate(P):
if u is not None:
circ.append(u.c_if(cr[1], 1), [qr[i+1]])
circ.draw('mpl')
result = execute(circ, sim).result()
sv = result.get_statevector(circ, decimals=3)
print(sv)
plot_histogram(result.get_counts())
plot_bloch_multivector(sv)
|
https://github.com/ardieb/QiskitPlayground
|
ardieb
|
from qiskit import *
from qiskit.quantum_info import *
from qiskit.visualization import *
from qiskit.circuit.library import *
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import itertools
import collections
import typing
%matplotlib inline
Array = np.ndarray
def teleporter(phi: Array):
assert phi.shape[0] == 2, "initialized state must have 2 entries (single qubit)"
qr = QuantumRegister(3, 'q')
crz = ClassicalRegister(1, 'crz')
crx = ClassicalRegister(1, 'crx')
circ = QuantumCircuit(qr, crz, crx)
circ.reset(qr[1])
circ.reset(qr[2])
circ.h(qr[1])
circ.cx(qr[1], qr[2])
circ.initialize(phi, qr[0])
circ.barrier()
circ.cx(qr[0], qr[1])
circ.h(qr[0])
circ.barrier()
circ.measure(qr[1], crx)
circ.measure(qr[0], crz)
circ.barrier()
circ.x(qr[2]).c_if(crx, 1)
circ.z(qr[2]).c_if(crz, 1)
return circ
sv_simulator = Aer.get_backend('statevector_simulator')
# Let's teleport the state 1/sqrt(2) [1, exp(i pi / 4)]
phi = np.array([1/np.sqrt(2), 1/np.sqrt(2) * np.exp(1j * np.pi / 4)])
circ = teleporter(phi)
display(circ.draw('mpl'))
result = execute(circ, sv_simulator).result()
display(plot_bloch_multivector(result.get_statevector(circ, decimals = 3)))
def key_update(a: int, b: int, c: int, d: int):
assert all(0 <= x <= 1 for x in [a,b,c,d]), "inputs must be an integer modulo 2"
return {'H': f'{b}{a}', 'X': f'{a}{b}', 'Z': f'{a}{b}', 'S': f'{a}{a ^ b}', 'cX': f'{a}{b ^ d}{a ^ c}{d}'}
df = []
for a in (0, 1):
for b in (0, 1):
for c in (0, 1):
for d in (0, 1):
update = key_update(a, b, c, d)
update['abcd'] = f'{a}{b}{c}{d}'
df.append(update)
df = pd.DataFrame(df)
df.set_index('abcd', inplace = True)
print(df)
# rho = 1/2 * np.array([[1,3], [3, 1]])
# tau = 0.8
qr = QuantumRegister(5, 'q')
cr = ClassicalRegister(5, 'c')
qpce = QuantumCircuit(qr, cr)
# prepare the state
theta1, theta2, alpha = 0.643, 2.498, 2.094
qpce.h(qr[3])
qpce.x(qr[3])
qpce.cu(theta1, 0, 0, 0, qr[3], qr[4])
qpce.x(qr[3])
qpce.cu(theta2, 0, 0, 0, qr[3], qr[4])
qpce.barrier()
# phase estimation
qpce.h(qr[1])
qpce.h(qr[2])
qpce.cu(-np.pi/2, -np.pi/2, np.pi/2, 0, qr[2], qr[3])
qpce.p(3*np.pi/4, qr[2])
qpce.cx(qr[1], qr[3])
qpce.swap(qr[1], qr[2])
qpce.h(qr[2])
qpce.cp(-np.pi/2, qr[1], qr[2])
qpce.h(qr[1])
qpce.barrier()
# Controlled rotation
qpce.cx(qr[1], qr[2])
qpce.cu(alpha, 0, 0, 0, qr[1], qr[0])
qpce.cu(alpha, 0, 0, 0, qr[2], qr[0])
qpce.cx(qr[1], qr[2])
qpce.barrier()
# Inverse phase estimation
qpce.h(qr[1])
qpce.cp(np.pi/2, qr[1], qr[2])
qpce.h(qr[2])
qpce.swap(qr[1], qr[2])
qpce.cx(qr[1], qr[3])
qpce.h(qr[1])
qpce.p(-3*np.pi/4, qr[2])
qpce.cu(-np.pi/2, -np.pi/2, np.pi/2, 0, qr[2], qr[3])
qpce.h(qr[2])
qpce.barrier()
# Measurement
qpce.measure(qr[0], cr[0])
qpce.measure(qr[1], cr[1])
qpce.measure(qr[2], cr[2])
qpce.measure(qr[3], cr[3])
qpce.measure(qr[4], cr[4])
qpce.draw('mpl')
qasm_simulator = Aer.get_backend('qasm_simulator')
result = execute(qpce, qasm_simulator, shots=2048).result()
display(plot_histogram(result.get_counts()))
# The operation is HTHT
# a0, b0 = 1, 1
qr = QuantumRegister(5, 'q')
cr = ClassicalRegister(5, 'c')
qku = QuantumCircuit(qr, cr)
# initialize
qku.reset(qr[0])
qku.reset(qr[1])
qku.reset(qr[3])
qku.h(qr[0])
qku.h(qr[1])
qku.h(qr[3])
qku.x(qr[0])
qku.cx(qr[1], qr[2])
qku.cx(qr[3], qr[4])
qku.z(qr[0])
qku.t(qr[0])
qku.swap(qr[0], qr[1])
qku.h(qr[0])
qku.s(qr[1])
qku.t(qr[0])
qku.cx(qr[1], qr[2])
qku.h(qr[1])
qku.swap(qr[0], qr[3])
qku.h(qr[0])
qku.s(qr[3])
qku.cx(qr[3], qr[4])
qku.h(qr[3])
qku.barrier()
qku.measure(qr[4], cr[4])
qku.measure(qr[3], cr[3])
qku.measure(qr[2], cr[2])
qku.measure(qr[1], cr[1])
qku.measure(qr[0], cr[0])
qku.draw('mpl')
result = execute(qku, qasm_simulator, shots=2048).result()
display(plot_histogram(result.get_counts(), figsize=(10,10)))
# The operation is HTHT
# a0, b0 = 0, 1
qr = QuantumRegister(5, 'q')
cr = ClassicalRegister(5, 'c')
qku = QuantumCircuit(qr, cr)
# initialize
qku.reset(qr[0])
qku.reset(qr[1])
qku.reset(qr[3])
qku.h(qr[0])
qku.h(qr[1])
qku.h(qr[3])
# qku.x(qr[0]) a = 0
qku.cx(qr[1], qr[2])
qku.cx(qr[3], qr[4])
qku.z(qr[0])
qku.t(qr[0])
qku.swap(qr[0], qr[1])
qku.h(qr[0])
qku.s(qr[1])
qku.t(qr[0])
qku.cx(qr[1], qr[2])
qku.h(qr[1])
qku.swap(qr[0], qr[3])
qku.h(qr[0])
qku.s(qr[3])
qku.cx(qr[3], qr[4])
qku.h(qr[3])
qku.barrier()
#ra(2)
qku.measure(qr[4], cr[4])
#rb(2)
qku.measure(qr[3], cr[3])
#ra(1)
qku.measure(qr[2], cr[2])
#rb(1)
qku.measure(qr[1], cr[1])
#q0
qku.measure(qr[0], cr[0])
qku.draw('mpl')
result = execute(qku, qasm_simulator, shots=2048).result()
display(plot_histogram(result.get_counts(), figsize=(10,10)))
# Select 4 measurements with high probability, here we choose > 0.05
import random
sample = []
counts = list(result.get_counts().items())
total = sum(x for _, x in counts)
while len(sample) < 4:
state, count = counts[random.randint(0,len(counts)-1)]
if count / total >= 0.05:
sample.append(state)
print(sample)
a0, b0 = 0, 1
for state in sample:
ra2, rb2, ra1, rb1, q0 = [int(c) for c in state]
af = b0 ^ ra1 ^ rb1 ^ rb2
bf = a0 ^ b0 ^ rb1 ^ ra2
print(f'Measurements are {state}')
print(f'Final decyption keys: {af}, {bf}')
print(f'Final state measurement: {q0}')
# here we find the opposite of the researchers result, where if af = 0 we measure q0 = 0 and if af = 1 we measure q0 = 1
|
https://github.com/ardieb/QiskitPlayground
|
ardieb
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, execute
from qiskit.quantum_info import Statevector, random_statevector
from qiskit.visualization import plot_bloch_multivector, plot_histogram, plot_state_qsphere, plot_state_city
from qiskit.circuit.library import iSwapGate
import numpy as np
import matplotlib.pyplot as plt
import itertools
%matplotlib inline
sim = Aer.get_backend('statevector_simulator')
toffoli = QuantumCircuit(3)
toffoli.h([2])
toffoli.cx([1], [2])
toffoli.tdg([2])
toffoli.cx([0], [2])
toffoli.t([2])
toffoli.cx([1], [2])
toffoli.tdg([2])
toffoli.cx([0], [2])
toffoli.tdg([1])
toffoli.t([2])
toffoli.cx([0], [1])
toffoli.h([2])
toffoli.tdg([1])
toffoli.cx([0], [1])
toffoli.t([0])
toffoli.s([1])
results = []
circuits = []
basis_states = [''.join(s) for s in itertools.product('01', repeat=3)]
for state in basis_states:
circ = QuantumCircuit(3)
circ.initialize(Statevector.from_label(state).data, [0,1,2])
circ = circ + toffoli
circuits.append(circ)
results.append(execute(circ, sim).result())
toffoli.draw('mpl')
for state, res in zip(basis_states, results):
print(f'Input state: {state}')
display(plot_histogram(res.get_counts()))
toffoli2 = QuantumCircuit(3)
toffoli2.ry(np.pi/4, [2])
toffoli2.cx([1], [2])
toffoli2.ry(np.pi/4, [2])
toffoli2.cx([0], [2])
toffoli2.ry(-np.pi/4, [2])
toffoli2.cx([1], [2])
toffoli2.ry(-np.pi/4, [2])
results2 = []
circuits2 = []
for state in basis_states:
circ = QuantumCircuit(3)
circ.initialize(Statevector.from_label(state).data, [0,1,2])
circ = circ + toffoli2
circuits2.append(circ)
results2.append(execute(circ, sim).result())
toffoli2.draw('mpl')
for state, res in zip(basis_states, results2):
print(f'Input state: {state}')
display(plot_histogram(res.get_counts()))
# Compare the results
for state, res1, circ1, res2, circ2 in zip(basis_states, results, circuits, results2, circuits2):
print(f'Input state: {state}')
s1, s2 = res1.get_statevector(circ1, decimals=3), res2.get_statevector(circ2, decimals=3)
print(f'Output of toffoli is: {s1}')
print(f'Output of phase offset toffoli is: {s2}')
print('\n')
circ1 = QuantumCircuit(2)
circ1.reset([0])
circ1.reset([1])
circ1.ry(np.pi/2, [1])
circ1.ry(np.pi/2, [0])
circ1.x([1])
circ1.cz([0], [1])
circ1.x([1])
circ1.ry(np.pi/2,[0])
circ2 = QuantumCircuit(2)
circ2.reset([0])
circ2.reset([1])
circ2.h([0])
circ2.cx([0],[1])
res1, res2 = execute(circ1, sim).result(), execute(circ2, sim).result()
display(circ1.draw('mpl'))
display(circ2.draw('mpl'))
# They both Produce the bell state
sv1 = res1.get_statevector(circ1, decimals=3)
sv2 = res2.get_statevector(circ2, decimals=3)
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
# But they don't evalaute the same on the entire basis...
circ1 = QuantumCircuit(2)
circ1.initialize(Statevector.from_label('01').data, [0, 1])
circ1.ry(np.pi/2, [1])
circ1.ry(np.pi/2, [0])
circ1.x([1])
circ1.cz([0], [1])
circ1.x([1])
circ1.ry(np.pi/2,[0])
circ2 = QuantumCircuit(2)
circ2.initialize(Statevector.from_label('01').data, [0, 1])
circ2.h([0])
circ2.cx([0],[1])
res1, res2 = execute(circ1, sim).result(), execute(circ2, sim).result()
sv1 = res1.get_statevector(circ1, decimals=3)
sv2 = res2.get_statevector(circ2, decimals=3)
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
circ1 = QuantumCircuit(3)
circ1.ry(np.pi/2, [0])
circ1.ry(np.pi/2, [1])
circ1.ry(np.pi/2, [2])
circ1.x([1])
circ1.cz([0], [1])
circ1.x([1])
circ1.x([1])
circ1.cz([2], [1])
circ1.x([1])
circ1.ry(np.pi/2, [0])
circ1.ry(np.pi/2, [2])
circ2 = QuantumCircuit(3)
circ2.ry(np.pi/2, [0])
circ2.ry(np.pi/2, [1])
circ2.ry(np.pi/2, [2])
# we defined the iSwapGate in class to be the inverse of what qiskit defined it as
circ2.append(iSwapGate().inverse(), [[0], [1]], [])
circ2.append(iSwapGate().inverse(), [[1], [2]], [])
circ2.rx(-np.pi/2, [0])
circ2.rx(-np.pi/2, [1])
circ3 = QuantumCircuit(3)
circ3.h([0])
circ3.cx([0], [1])
circ3.cx([1], [2])
# On the state 000
results = []
circuits = []
for c in (circ1, circ2, circ3):
circ = QuantumCircuit(3)
circ.reset([0])
circ.reset([1])
circ.reset([2])
circ = circ + c
display(circ.draw('mpl'))
circuits.append(circ)
results.append(execute(circ, sim).result())
sv1, sv2, sv3 = (results[i].get_statevector(circuits[i], decimals=3) for i in range(3))
res1, res2, res3 = results
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
display(plot_histogram(res3.get_counts()))
display(plot_state_city(sv3))
# but they're not the same on all basis states
results = []
circuits = []
for c in (circ1, circ2, circ3):
circ = QuantumCircuit(3)
circ.initialize(Statevector.from_label('010').data, [0,1,2])
circ = circ + c
circuits.append(circ)
results.append(execute(circ, sim).result())
sv1, sv2, sv3 = (results[i].get_statevector(circuits[i], decimals=3) for i in range(3))
res1, res2, res3 = results
display(plot_histogram(res1.get_counts()))
display(plot_state_city(sv1))
display(plot_histogram(res2.get_counts()))
display(plot_state_city(sv2))
display(plot_histogram(res3.get_counts()))
display(plot_state_city(sv3))
# First need to make the exponential matrix operator
from scipy.linalg import expm
from qiskit.extensions import UnitaryGate
sx = np.array([[0, 1],[1, 0]])
sy = np.array([[0, -1j],[1j, 0]])
sz = np.array([[1, 0],[0, -1]])
S = .5 * (np.kron(np.eye(2), np.kron(sx, sx)) + np.kron(sx, np.kron(np.eye(2), sx)) + np.kron(sx, np.kron(sx, np.eye(2)))
+ np.kron(np.eye(2), np.kron(sy, sy)) + np.kron(sy, np.kron(np.eye(2), sy)) + np.kron(sy, np.kron(sy, np.eye(2))))
G = UnitaryGate(expm(-1j * np.pi/2 * 4/9 * S), label = 'Exp')
wcircuit = QuantumCircuit(3)
wcircuit.reset([0])
wcircuit.reset([1])
wcircuit.reset([2])
wcircuit.x([1])
wcircuit.append(G, [[0], [1], [2]])
wcircuit.rz(4 * np.pi/3, [1])
wcircuit.draw('mpl')
res = execute(wcircuit, sim).result()
sv = res.get_statevector(wcircuit, decimals=3)
display(plot_histogram(res.get_counts()))
display(plot_state_city(sv))
a = '11'
initphi = QuantumCircuit(3, 2)
initphi.reset([0])
initphi.reset([1])
initphi.reset([2])
initphi.x([2])
initphi.h([0, 1, 2])
uf = QuantumCircuit(3, 2)
uf.ccx([0], [1], [2])
grover = QuantumCircuit(3, 2)
grover.h([0, 1])
grover.x([0, 1])
grover.cz([0], [1])
grover.x([0, 1])
grover.h([0, 1])
display(initphi.draw('mpl'))
display(uf.draw('mpl'))
display(grover.draw('mpl'))
iterations = int((np.pi/4) * 2**2/2)
circ = initphi
for _ in range(iterations):
circ = circ + uf + grover
circ.measure([0, 1], [0, 1])
# on a qasm simulator
qasm_sim = Aer.get_backend('qasm_simulator')
shots = 1024
res = execute(circ, backend=qasm_sim, shots=shots).result()
plot_histogram(res.get_counts())
# random state for testing
rng_state = random_statevector(4)
plot_state_qsphere(rng_state.data)
circ1 = QuantumCircuit(4, 2)
circ1.reset([0])
circ1.reset([1])
circ1.initialize(rng_state.data, [2, 3])
circ1.h([0, 1])
circ1.cx([0], [2])
circ1.cx([0], [3])
circ1.cz([1], [2])
circ1.cz([1], [3])
circ1.h([0, 1])
circ1.measure([0, 1], [0, 1])
circ2 = QuantumCircuit(4, 2)
circ2.reset([0])
circ2.reset([1])
circ2.initialize(rng_state.data, [2, 3])
circ2.h([0])
circ2.cx([0], [2])
circ2.cx([0], [3])
circ2.h([0])
circ2.cx([2], [1])
circ2.cx([3], [1])
circ2.measure([0, 1], [0, 1])
display(circ1.draw('mpl'))
display(circ2.draw('mpl'))
# check that these circuits produce the same measurements
shots = 1024
res = execute(circ1, backend=qasm_sim, shots=shots).result()
plot_histogram(res.get_counts())
shots = 1024
res = execute(circ2, backend=qasm_sim, shots=shots).result()
plot_histogram(res.get_counts())
psi = random_statevector(2)
qr = QuantumRegister(4, 'q')
cr = [ClassicalRegister(1, 'a'), ClassicalRegister(1, 'b')]
circ = QuantumCircuit(qr)
circ.add_register(cr[0])
circ.add_register(cr[1])
circ.reset(qr[0])
circ.reset(qr[2])
circ.reset(qr[3])
circ.initialize(psi.data, qr[1])
circ.t(qr[2])
circ.h(qr[0])
circ.cz(qr[0], qr[1])
circ.cz(qr[0], qr[2])
circ.h(qr[0])
circ.measure(qr[0], cr[0])
# This was my answer on the hw
#circ.x(qr[1]).c_if(cr[0], 1)
#circ.z(qr[1]).c_if(cr[0], 1)
#circ.x(qr[1]).c_if(cr[0], 1)
circ.unitary(UnitaryGate(expm(2 * 1j * np.pi/4 * sz)), [qr[1]],).c_if(cr[0], 1)
circ.h(qr[3])
circ.cx(qr[3], qr[2])
circ.h(qr[3])
circ.measure(qr[3], cr[1])
#circ.x(qr[1]).c_if(cr[1], 1)
#circ.z(qr[1]).c_if(cr[1], 1)
#circ.x(qr[1]).c_if(cr[1], 1)
circ.z(qr[1]).c_if(cr[1], 1)
display(circ.draw('mpl'))
result = execute(circ, sim).result()
plot_histogram(result.get_counts())
sv = result.get_statevector(circ, decimals=3)
print(sv)
display(plot_state_qsphere(sv))
display(plot_bloch_multivector(sv))
# compare to just T gate
circ2 = QuantumCircuit(1)
circ2.initialize(psi.data, [0])
circ2.t([0])
result2 = execute(circ2, sim).result()
sv2 = result2.get_statevector(circ2, decimals=3)
plot_bloch_multivector(sv2)
plot_histogram(result2.get_counts())
from qiskit.circuit.library import TGate, ZGate, RZGate
circ1 = QuantumCircuit(3)
circ1.cx([2], [1])
circ1.cx([1], [0])
circ1.t([0])
circ1.tdg([1])
circ1.t([2])
circ1.cx([2], [1])
circ1.cx([1], [0])
circ1.tdg([0])
circ1.cx([2], [0])
circ2 = QuantumCircuit(3)
circ2.append(TGate().inverse().power(2).control(1, label='$S^\dagger$'), [0, 1])
circ2.append(ZGate().control(2), [0, 1, 2])
circ3 = QuantumCircuit(3)
circ3.append(RZGate(np.pi).control(2), [0, 1, 2]) # equiv to -iZ
display(circ1.draw('mpl'))
display(circ2.draw('mpl'))
display(circ3.draw('mpl'))
# eval on random state
psi = random_statevector(8)
circuits = []
results = []
for c in (circ1, circ2, circ3):
circ = QuantumCircuit(3)
circ.initialize(psi.data, [0, 1, 2])
circ = circ + c
circuits.append(circ)
results.append(execute(circ, sim).result())
sv1, sv2, sv3 = [res.get_statevector(circ, decimals=3) for circ, res in zip(circuits, results)]
res1, res2, res3 = results
plot_histogram(res1.get_counts())
plot_histogram(res2.get_counts())
plot_histogram(res3.get_counts())
# I'll use a 7 bit circuit ==> P operates on 4 qubits, operators chosen at random
from qiskit.circuit.library import XGate, YGate, ZGate
import random
from time import time
random.seed(time())
# random composition of gates
P = [[None, XGate(), YGate(), ZGate()][random.randint(0, 3)] for _ in range(4)]
qr = QuantumRegister(7, 'q')
cr = [ClassicalRegister(1, 'a'), ClassicalRegister(1, 'b')]
circ = QuantumCircuit(qr)
circ.add_register(cr[0])
circ.add_register(cr[1])
# initial states
for i in range(7):
circ.reset(qr[i])
# theta = pi/4
circ.t(qr[5])
# arbitrary input state to apply Ptheta to
circ.x(qr[1])
circ.h(qr[2])
circ.x(qr[3])
circ.y(qr[4])
circ.h(qr[0])
for i, u in enumerate(P):
if u is not None:
circ.append(u.control(1), [qr[0],qr[i+1]])
circ.cz(qr[0], qr[5])
circ.h(qr[0])
circ.measure(qr[0], cr[0])
circ.h(qr[6])
circ.cx(qr[6], qr[5])
circ.h(qr[6])
circ.measure(qr[6], cr[1])
# O1
for i, u in enumerate(P):
if u is not None:
circ.append(UnitaryGate(expm(2 * 1j * np.pi/4 * u.to_matrix())).c_if(cr[0], 1), [qr[i + 1]])
# O2
for i, u in enumerate(P):
if u is not None:
circ.append(u.c_if(cr[1], 1), [qr[i+1]])
circ.draw('mpl')
result = execute(circ, sim).result()
sv = result.get_statevector(circ, decimals=3)
print(sv)
plot_histogram(result.get_counts())
plot_bloch_multivector(sv)
|
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### added x gate ###
qc.x(qubit)
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added y gate ###
qc.y(0)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
### added x gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added z gate ###
qc.z(1)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
import qiskit
#Code based on Qiskit offcial Textbook
#Create the circuit for the Bernstein-Vazirani algorithm
def bv_algorithm(bitstring: str, num_qubits: int) -> qiskit.QuantumCircuit:
#Create the quantum circuit
bv_circuit = qiskit.QuantumCircuit(num_qubits + 1, num_qubits)
#Apply H-gate to the output qubit
bv_circuit.h(num_qubits)
#Apply Z-gate to the output qubit
bv_circuit.z(num_qubits)
#Apply H-gates to all qubits
for qubit in range(num_qubits):
bv_circuit.h(qubit)
#Reverse the order of the bitstring
s = bitstring[::-1]
for qubit in range(num_qubits):
if s[qubit] == '0':
#If the position equals to 0, apply an I-gate
bv_circuit.i(qubit)
else:
#Else, apply CX-gates
bv_circuit.cx(qubit, num_qubits)
#Apply H-gates to all qubits
for qubit in range(num_qubits):
bv_circuit.h(qubit)
#Measure all the qubits
for qubit in range(num_qubits):
bv_circuit.measure(qubit, qubit)
return bv_circuit
#Run the simulation with the given circuit
def bernstein_azirani(bitstring: str, num_qubits: int) -> qiskit.QuantumCircuit:
#Get the simulator
simulator = qiskit.Aer.get_backend('qasm_simulator')
#Get the circuit
circuit = bv_algorithm(bitstring, num_qubits)
#Execute the Bernstein-Vazirani algorithm
job = qiskit.execute(circuit, simulator, shots=1000)
#Get results
result = job.result().get_counts()
return result
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### removed z gate ###
pass
return qc
def decode_message(qc):
### removed cx gate ###
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
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)
### removed h gate ###
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### replaced cx gate ###
qc.cy(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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
### replaced x gate ###
qc.x(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)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### added x gate ###
qc.x(qubit)
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added y gate ###
qc.y(0)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
### added x gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added z gate ###
qc.z(1)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
import numpy as np
import qiskit as q
#Code based on Qiskit offcial Textbook
#Create the oracle for the Deutsch-Jozsa Algorithm
def dj_oracle(case: str, num_qubits: int) -> q.QuantumCircuit:
#Create the circuit
oracle_qc = q.QuantumCircuit(num_qubits + 1)
#Create the balanced oracle
if case == "balanced":
#Ganerate a random binary string
b = np.random.randint(1, 2 ** num_qubits)
b_str = format(b, f"0{num_qubits}b")
for index, bit in enumerate(b_str):
if bit == "1":
#If the position is equal to 1, apply X-gate
oracle_qc.x(index)
for index in range(num_qubits):
#For all the qubits, apply CX-gate
oracle_qc.cx(index, num_qubits)
for index, bit in enumerate(b_str):
if bit == "1":
#If the position is equal to 1, apply X-gate
oracle_qc.x(index)
#Create the the constant oracle
if case == "constant":
#Set the output to 0 or 1 randomly
output = np.random.randint(2)
if output == 1:
#If the position is equal to 1, apply X-gate
oracle_qc.x(num_qubits)
#Create the Gate
oracle_gate = oracle_qc.to_gate()
return oracle_gate
#Carry out the Deutsch-Jozsa Algorithm
def dj_algorithm(oracle: q.QuantumCircuit, num_qubits: int) -> q.QuantumCircuit:
#Create a quantum circuit
dj_circuit = q.QuantumCircuit(num_qubits + 1, num_qubits)
#Apply X-gates to the output qubit
dj_circuit.x(num_qubits)
#Apply H-gates to the output qubit
dj_circuit.h(num_qubits)
#Apply H-gate to all qubits
for qubit in range(num_qubits):
dj_circuit.h(qubit)
#Apply the oracle created
dj_circuit.append(oracle, range(num_qubits + 1))
#Apply H-gate to all qubits
for qubit in range(num_qubits):
dj_circuit.h(qubit)
#Measure all the qubits
for i in range(num_qubits):
dj_circuit.measure(i, i)
return dj_circuit
#Run the simulation with the created circuit
def deutsch_jozsa(case: str, num_qubits: int) -> q.result.counts.Counts:
#Get the simulator
simulator = q.Aer.get_backend("qasm_simulator")
#Get the oracle
oracle = dj_oracle(case, num_qubits)
#Ger the circuit
dj_circuit = dj_algorithm(oracle, num_qubits)
#Performe the algorithm
job = q.execute(dj_circuit, simulator, shots=1000)
return job.result().get_counts(dj_circuit)
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### removed z gate ###
pass
return qc
def decode_message(qc):
### removed cx gate ###
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
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)
### removed h gate ###
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### replaced cx gate ###
qc.cy(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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
### replaced x gate ###
qc.x(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)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### added x gate ###
qc.x(qubit)
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added y gate ###
qc.y(0)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### added y gate ###
qc.cx(0, 1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
### added h gate ###
qc.h(0)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
### added x gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### added z gate ###
qc.z(1)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### removed x gate ###
pass
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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### removed h gate ###
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### removed z gate ###
pass
return qc
def decode_message(qc):
### removed cx gate ###
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### removed cx gate ###
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)
### removed h gate ###
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
### replaced cx gate ###
qc.cy(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/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
qc.x(qubit)
if msg[0] == "1":
qc.z(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
### replaced x gate ###
qc.x(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)
### replaced x gate ###
qc.x(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
from qiskit import QuantumCircuit
def create_bell_pair():
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
return qc
def encode_message(qc, qubit, msg):
if len(msg) != 2 or not set([0,1]).issubset({0,1}):
raise ValueError(f"message '{msg}' is invalid")
if msg[1] == "1":
### replaced x gate ###
qc.z(qubit)
if msg[0] == "1":
### replaced z gate ###
qc.x(qubit)
return qc
def decode_message(qc):
qc.cx(1, 0)
qc.h(1)
return qc
|
https://github.com/urwin419/QiskitChecker
|
urwin419
|
import numpy as np
import qiskit
#Create the oracle for the secret string
def oracle(circuit: qiskit.QuantumCircuit, bitstring: str):
#Get the length of the bitstring
length = len(bitstring)
#Copy every qubit from the first register to the second register
for i in range(length):
circuit.cx(i, length+i)
#Create a 1-to-1 or 2-to-1 mapping:
#Get the index of the last 1 in bitstring
l = bitstring.rfind('1')
#Flip the qubit with index in the second register for bitstring[index] is 1
for index, s in enumerate(bitstring):
if s == '1' and l != -1:
circuit.cx(l, length+index)
#Create a random permutation
#Get random permutation of n qubits
permutation = list(np.random.permutation(length))
#Record initial positions
ini_p = list(range(length))
for i in range(length-1):
if ini_p[i] != permutation[i]:
j = permutation.index(ini_p[i])
#Swap qubits
circuit.swap(length+i, length+j)
#Record the positions of swapped qubits
ini_p[i], ini_p[j] = ini_p[j], ini_p[i]
#Flip the qubits randomly
for i in range(length):
if np.random.random() > 0.5:
circuit.x(length+i)
return circuit
#Create the circuit for the Simon's algorithm
def algorithm(bitstring: str):
#Get the length of the bitstring
length = len(bitstring)
#Create the quantum circuits
simon_circuit = qiskit.QuantumCircuit(length*2, length)
#Apply H-gates to all qubits
simon_circuit.h(range(length))
#Apply the oracle created
simon_circuit = oracle(simon_circuit,bitstring)
#Apply H-gates to all qubits
simon_circuit.h(range(length))
#Measure all the qubits
simon_circuit.measure(range(length), range(length))
return simon_circuit
#Calculate the dot-product
def dotp(bitstring, result):
#Calculate the dot-product by mutiply each position and add them together
accum = 0
for i in range(len(bitstring)):
accum += int(bitstring[i]) * int(result[i])
#Return the result by modulo 2
return accum % 2
#Run the simulation with the given circuit
def simon(bitstring:str):
#Get the simulator
qasm_simulator = qiskit.Aer.get_backend('qasm_simulator')
#Execute the Simon's algorithm
job = qiskit.execute(algorithm(bitstring),qasm_simulator, shots=10000)
# Get results
result = job.result().get_counts()
return result
|
https://github.com/Hayatto9217/Qiskit9
|
Hayatto9217
|
from qiskit import QuantumCircuit
circ = QuantumCircuit(2, 2)
circ.h(0)
circ.cx(0,1)
circ.measure([0, 1], [0, 1])
circ.draw("mpl")
from qiskit import transpile, schedule as build_schedule
from qiskit.providers.fake_provider import FakeHanoi
backend = FakeHanoi()
transpiled_circ = transpile(circ, backend)
schedule =build_schedule(transpiled_circ, backend)
schedule.draw()
from qiskit import pulse
with pulse.build() as h_q0:
pulse.play(pulse.library.Gaussian(duration=256, amp=0.3, sigma=50, name='custom'),pulse.DriveChannel(0))
circ.add_calibration('h', [0], h_q0)
schedule =build_schedule(circ, backend)
schedule.draw()
#γ‘γ½γγ
circ = QuantumCircuit(2, 2)
circ.x(0)
circ.x(0)
circ.x(1)
circ.measure([0, 1], [0,1])
circ.draw('mpl')
#duration = 160dt
schedule = build_schedule(circ, backend, method="as_late_as_possible")
schedule.filter(channels=[pulse.DriveChannel(0), pulse.DriveChannel(1)]).draw()
#time = 0
schedule = build_schedule(circ, backend, method="as_soon_as_possible")
schedule.filter(channels=[pulse.DriveChannel(0), pulse.DriveChannel(1
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!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/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
!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/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
import json
from typing import Any, Callable, Optional, Tuple, Union
from urllib.parse import urljoin
from qiskit import QuantumCircuit, execute
from qiskit.providers import JobStatus
from qiskit.providers.ibmq.job import IBMQJob
from .api import get_server_endpoint, send_request, get_access_token, get_submission_endpoint
from .exercises import get_question_id
from .util import compute_cost, get_provider, get_job, circuit_to_json, get_job_urls, uses_multiqubit_gate
def _circuit_criteria(
circuit: QuantumCircuit,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[int], Optional[int]]:
if max_qubits is not None and circuit.num_qubits > max_qubits:
print(f'Your circuit has {circuit.num_qubits} qubits, which exceeds the maximum allowed.')
print(f'Please reduce the number of qubits in your circuit to below {max_qubits}.')
return None, None
try:
if check_gates and not uses_multiqubit_gate(circuit):
print('Your circuit appears to not use any multi-quibit gates.')
print('Please review your circuit and try again.')
return None, None
cost = compute_cost(circuit)
if min_cost is not None and cost < min_cost:
print(f'Your circuit cost ({cost}) is too low. But if you are convinced that your circuit\n'
'is correct, please let us know in the `#ibm-quantum-challenge-2020` Slack channel.')
return None, None
return circuit.num_qubits, cost
except Exception as err:
print(f'Unable to compute cost: {err}')
return None, None
def _circuit_grading(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False,
max_qubits: Optional[int] = None,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
payload = None
server = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or '
'the grading servers are down right now.')
return None, None
else:
server = None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
payload = {
'answer': circuit_to_json(circuit)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _job_grading(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(job_or_id, IBMQJob) and not isinstance(job_or_id, str):
print(f'Expected an IBMQJob or a job ID, but was given {type(job_or_id)}')
print(f'Please submit a job as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading '
'servers are down right now.')
return None, None
else:
server = None
job = get_job(job_or_id) if isinstance(job_or_id, str) else job_or_id
if not job:
print('An invalid or non-existent job was specified.')
return None, None
job_status = job.status()
if job_status in [JobStatus.CANCELLED, JobStatus.ERROR]:
print(f'Job did not successfully complete: {job_status.value}.')
return None, None
elif job_status is not JobStatus.DONE:
print(f'Job has not yet completed: {job_status.value}.')
print(f'Please wait for the job (id: {job.job_id()}) to complete then try again.')
return None, None
header = job.result().header.to_dict()
if 'qc_cost' not in header:
if is_submit:
print('An unprepared answer was specified. '
'Please prepare() and grade() answer before submitting.')
else:
print('An unprepared answer was specified. Please prepare() answer before grading.')
return None, None
download_url, result_url = get_job_urls(job)
if not download_url or not result_url:
print('Unable to obtain job URLs')
return None, None
payload = {
'answer': json.dumps({
'download_url': download_url,
'result_url': result_url
})
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def _number_grading(
answer: int,
lab_id: str,
ex_id: str,
is_submit: Optional[bool] = False
) -> Tuple[Optional[dict], Optional[str]]:
if not isinstance(answer, int):
print(f'Expected a integer, but was given {type(answer)}')
print(f'Please provide a number as your answer.')
return None, None
if not is_submit:
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server '
'or the grading servers are down right now.')
return None, None
else:
server = None
payload = {
'answer': str(answer)
}
if is_submit:
payload['questionNumber'] = get_question_id(lab_id, ex_id)
else:
payload['question_id'] = get_question_id(lab_id, ex_id)
return payload, server
def prepare_circuit(
circuit: QuantumCircuit,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not isinstance(circuit, QuantumCircuit):
print(f'Expected a QuantumCircuit, but was given {type(circuit)}')
print(f'Please provide a circuit.')
return None
_, cost = _circuit_criteria(
circuit,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if cost is not None:
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiment. Please wait...')
job = execute(
circuit,
qobj_header={
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def prepare_solver(
solver_func: Callable,
lab_id: str,
ex_id: str,
problem_set: Optional[Any] = None,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None,
check_gates: Optional[bool] = False,
**kwargs
) -> Optional[IBMQJob]:
job = None
if not callable(solver_func):
print(f'Expected a function, but was given {type(solver_func)}')
print(f'Please provide a function that returns a QuantumCircuit.')
return None
server = get_server_endpoint(lab_id, ex_id)
if not server:
print('Could not find a valid grading server or the grading servers are down right now.')
return
endpoint = server + 'problem-set'
index, value = get_problem_set(lab_id, ex_id, endpoint)
print(f'Running {solver_func.__name__}...')
qc_1 = solver_func(problem_set)
_, cost = _circuit_criteria(
qc_1,
max_qubits=max_qubits,
min_cost=min_cost,
check_gates=check_gates
)
if value and index is not None and index >= 0 and cost is not None:
qc_2 = solver_func(value)
if 'backend' not in kwargs:
kwargs['backend'] = get_provider().get_backend('ibmq_qasm_simulator')
# execute experiments
print('Starting experiments. Please wait...')
job = execute(
[qc_1, qc_2],
qobj_header={
'qc_index': [None, index],
'qc_cost': cost
},
**kwargs
)
print(f'You may monitor the job (id: {job.job_id()}) status '
'and proceed to grading when it successfully completes.')
return job
def grade_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, server = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=False,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_job(
job_or_id: Union[IBMQJob, str],
lab_id: str,
ex_id: str
) -> bool:
payload, server = _job_grading(job_or_id, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def grade_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, server = _number_grading(answer, lab_id, ex_id, is_submit=False)
if payload:
print('Grading your answer. Please wait...')
return grade_answer(
payload,
server + 'validate-answer'
)
return False
def submit_circuit(
circuit: QuantumCircuit,
lab_id: str,
ex_id: str,
max_qubits: Optional[int] = 28,
min_cost: Optional[int] = None
) -> bool:
payload, _ = _circuit_grading(
circuit,
lab_id,
ex_id,
is_submit=True,
max_qubits=max_qubits,
min_cost=min_cost
)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_job(
job_or_id: IBMQJob,
lab_id: str,
ex_id: str,
) -> bool:
payload, _ = _job_grading(job_or_id, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def submit_number(
answer: int,
lab_id: str,
ex_id: str
) -> bool:
payload, _ = _number_grading(answer, lab_id, ex_id, is_submit=True)
if payload:
print('Submitting your answer. Please wait...')
return submit_answer(payload)
return False
def get_problem_set(
lab_id: str, ex_id: str, endpoint: str
) -> Tuple[Optional[int], Optional[Any]]:
problem_set_response = None
try:
payload = {'question_id': get_question_id(lab_id, ex_id)}
problem_set_response = send_request(endpoint, query=payload, method='GET')
except Exception as err:
print('Unable to obtain the problem set')
if problem_set_response:
status = problem_set_response.get('status')
if status == 'valid':
try:
index = problem_set_response.get('index')
value = json.loads(problem_set_response.get('value'))
return index, value
except Exception as err:
print(f'Problem set could not be processed: {err}')
else:
cause = problem_set_response.get('cause')
print(f'Problem set failed: {cause}')
return None, None
def grade_answer(payload: dict, endpoint: str, cost: Optional[int] = None) -> bool:
try:
answer_response = send_request(endpoint, body=payload)
status = answer_response.get('status', None)
cause = answer_response.get('cause', None)
score = cost if cost else answer_response.get('score', None)
handle_grade_response(status, score=score, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def submit_answer(payload: dict) -> bool:
try:
access_token = get_access_token()
baseurl = get_submission_endpoint()
endpoint = urljoin(baseurl, './challenges/answers')
submit_response = send_request(
endpoint,
body=payload,
query={'access_token': access_token}
)
status = submit_response.get('status', None)
if status is None:
status = submit_response.get('valid', None)
cause = submit_response.get('cause', None)
handle_submit_response(status, cause=cause)
return status == 'valid' or status is True
except Exception as err:
print(f'Failed: {err}')
return False
def handle_grade_response(
status: Optional[str], score: Optional[int] = None, cause: Optional[str] = None
) -> None:
if status == 'valid':
print('\nCongratulations π! Your answer is correct.')
if score is not None:
print(f'Your score is {score}.')
elif status == 'invalid':
print(f'\nOops π! {cause}')
print('Please review your answer and try again.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete then try again.')
else:
print(f'Failed: {cause}')
print('Unable to grade your answer.')
def handle_submit_response(
status: Union[str, bool], cause: Optional[str] = None
) -> None:
if status == 'valid' or status is True:
print('\nSuccess π! Your answer has been submitted.')
elif status == 'invalid' or status is False:
print(f'\nOops π! {"Your answer is incorrect" if cause is None else cause}')
print('Make sure your answer is correct and successfully graded before submitting.')
elif status == 'notFinished':
print(f'Job has not finished: {cause}')
print(f'Please wait for the job to complete, grade it, and then try to submit again.')
else:
print(f'Failed: {cause}')
print('Unable to submit your answer at this time.')
|
https://github.com/theflyingrahul/qiskitsummerschool2020
|
theflyingrahul
|
# -*- 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__
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.