repo
stringclasses 885
values | file
stringclasses 741
values | content
stringlengths 4
215k
|
|---|---|---|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(12)
for idx in range(5):
qc.h(idx)
qc.cx(idx, idx+5)
qc.cx(1, 7)
qc.x(8)
qc.cx(1, 9)
qc.x(7)
qc.cx(1, 11)
qc.swap(6, 11)
qc.swap(6, 9)
qc.swap(6, 10)
qc.x(6)
qc.draw('mpl')
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
A two-ways dict to represent a layout.
Layout is the relation between virtual (qu)bits and physical (qu)bits.
Virtual (qu)bits are tuples, e.g. `(QuantumRegister(3, 'qr'), 2)` or simply `qr[2]`.
Physical (qu)bits are integers.
"""
from __future__ import annotations
from typing import List
from dataclasses import dataclass
from qiskit import circuit
from qiskit.circuit.quantumregister import Qubit, QuantumRegister
from qiskit.transpiler.exceptions import LayoutError
from qiskit.converters import isinstanceint
class Layout:
"""Two-ways dict to represent a Layout."""
__slots__ = ("_regs", "_p2v", "_v2p")
def __init__(self, input_dict=None):
"""construct a Layout from a bijective dictionary, mapping
virtual qubits to physical qubits"""
self._regs = []
self._p2v = {}
self._v2p = {}
if input_dict is not None:
if not isinstance(input_dict, dict):
raise LayoutError("Layout constructor takes a dict")
self.from_dict(input_dict)
def __repr__(self):
"""Representation of a Layout"""
str_list = []
for key, val in self._p2v.items():
str_list.append(f"{key}: {val},")
if str_list:
str_list[-1] = str_list[-1][:-1]
return "Layout({\n" + "\n".join(str_list) + "\n})"
def from_dict(self, input_dict):
"""Populates a Layout from a dictionary.
The dictionary must be a bijective mapping between
virtual qubits (tuple) and physical qubits (int).
Args:
input_dict (dict):
e.g.::
{(QuantumRegister(3, 'qr'), 0): 0,
(QuantumRegister(3, 'qr'), 1): 1,
(QuantumRegister(3, 'qr'), 2): 2}
Can be written more concisely as follows:
* virtual to physical::
{qr[0]: 0,
qr[1]: 1,
qr[2]: 2}
* physical to virtual::
{0: qr[0],
1: qr[1],
2: qr[2]}
"""
for key, value in input_dict.items():
virtual, physical = Layout.order_based_on_type(key, value)
self._p2v[physical] = virtual
if virtual is None:
continue
self._v2p[virtual] = physical
@staticmethod
def order_based_on_type(value1, value2):
"""decides which one is physical/virtual based on the type. Returns (virtual, physical)"""
if isinstanceint(value1) and isinstance(value2, (Qubit, type(None))):
physical = int(value1)
virtual = value2
elif isinstanceint(value2) and isinstance(value1, (Qubit, type(None))):
physical = int(value2)
virtual = value1
else:
raise LayoutError(
"The map (%s -> %s) has to be a (Bit -> integer)"
" or the other way around." % (type(value1), type(value2))
)
return virtual, physical
def __getitem__(self, item):
if item in self._p2v:
return self._p2v[item]
if item in self._v2p:
return self._v2p[item]
raise KeyError(f"The item {item} does not exist in the Layout")
def __contains__(self, item):
return item in self._p2v or item in self._v2p
def __setitem__(self, key, value):
virtual, physical = Layout.order_based_on_type(key, value)
self._set_type_checked_item(virtual, physical)
def _set_type_checked_item(self, virtual, physical):
old = self._v2p.pop(virtual, None)
self._p2v.pop(old, None)
old = self._p2v.pop(physical, None)
self._v2p.pop(old, None)
self._p2v[physical] = virtual
if virtual is not None:
self._v2p[virtual] = physical
def __delitem__(self, key):
if isinstance(key, int):
del self._v2p[self._p2v[key]]
del self._p2v[key]
elif isinstance(key, Qubit):
del self._p2v[self._v2p[key]]
del self._v2p[key]
else:
raise LayoutError(
"The key to remove should be of the form"
" Qubit or integer) and %s was provided" % (type(key),)
)
def __len__(self):
return len(self._p2v)
def __eq__(self, other):
if isinstance(other, Layout):
return self._p2v == other._p2v and self._v2p == other._v2p
return False
def copy(self):
"""Returns a copy of a Layout instance."""
layout_copy = type(self)()
layout_copy._regs = self._regs.copy()
layout_copy._p2v = self._p2v.copy()
layout_copy._v2p = self._v2p.copy()
return layout_copy
def add(self, virtual_bit, physical_bit=None):
"""
Adds a map element between `bit` and `physical_bit`. If `physical_bit` is not
defined, `bit` will be mapped to a new physical bit.
Args:
virtual_bit (tuple): A (qu)bit. For example, (QuantumRegister(3, 'qr'), 2).
physical_bit (int): A physical bit. For example, 3.
"""
if physical_bit is None:
if len(self._p2v) == 0:
physical_bit = 0
else:
max_physical = max(self._p2v)
# Fill any gaps in the existing bits
for physical_candidate in range(max_physical):
if physical_candidate not in self._p2v:
physical_bit = physical_candidate
break
# If there are no free bits in the allocated physical bits add new ones
else:
physical_bit = max_physical + 1
self[virtual_bit] = physical_bit
def add_register(self, reg):
"""Adds at the end physical_qubits that map each bit in reg.
Args:
reg (Register): A (qu)bit Register. For example, QuantumRegister(3, 'qr').
"""
self._regs.append(reg)
for bit in reg:
if bit not in self:
self.add(bit)
def get_registers(self):
"""
Returns the registers in the layout [QuantumRegister(2, 'qr0'), QuantumRegister(3, 'qr1')]
Returns:
Set: A set of Registers in the layout
"""
return set(self._regs)
def get_virtual_bits(self):
"""
Returns the dictionary where the keys are virtual (qu)bits and the
values are physical (qu)bits.
"""
return self._v2p
def get_physical_bits(self):
"""
Returns the dictionary where the keys are physical (qu)bits and the
values are virtual (qu)bits.
"""
return self._p2v
def swap(self, left, right):
"""Swaps the map between left and right.
Args:
left (tuple or int): Item to swap with right.
right (tuple or int): Item to swap with left.
Raises:
LayoutError: If left and right have not the same type.
"""
if type(left) is not type(right):
raise LayoutError("The method swap only works with elements of the same type.")
temp = self[left]
self[left] = self[right]
self[right] = temp
def combine_into_edge_map(self, another_layout):
"""Combines self and another_layout into an "edge map".
For example::
self another_layout resulting edge map
qr_1 -> 0 0 <- q_2 qr_1 -> q_2
qr_2 -> 2 2 <- q_1 qr_2 -> q_1
qr_3 -> 3 3 <- q_0 qr_3 -> q_0
The edge map is used to compose dags via, for example, compose.
Args:
another_layout (Layout): The other layout to combine.
Returns:
dict: A "edge map".
Raises:
LayoutError: another_layout can be bigger than self, but not smaller.
Otherwise, raises.
"""
edge_map = {}
for virtual, physical in self._v2p.items():
if physical not in another_layout._p2v:
raise LayoutError(
"The wire_map_from_layouts() method does not support when the"
" other layout (another_layout) is smaller."
)
edge_map[virtual] = another_layout[physical]
return edge_map
def reorder_bits(self, bits) -> list[int]:
"""Given an ordered list of bits, reorder them according to this layout.
The list of bits must exactly match the virtual bits in this layout.
Args:
bits (list[Bit]): the bits to reorder.
Returns:
List: ordered bits.
"""
order = [0] * len(bits)
# the i-th bit is now sitting in position j
for i, v in enumerate(bits):
j = self[v]
order[i] = j
return order
@staticmethod
def generate_trivial_layout(*regs):
"""Creates a trivial ("one-to-one") Layout with the registers and qubits in `regs`.
Args:
*regs (Registers, Qubits): registers and qubits to include in the layout.
Returns:
Layout: A layout with all the `regs` in the given order.
"""
layout = Layout()
for reg in regs:
if isinstance(reg, QuantumRegister):
layout.add_register(reg)
else:
layout.add(reg)
return layout
@staticmethod
def from_intlist(int_list, *qregs):
"""Converts a list of integers to a Layout
mapping virtual qubits (index of the list) to
physical qubits (the list values).
Args:
int_list (list): A list of integers.
*qregs (QuantumRegisters): The quantum registers to apply
the layout to.
Returns:
Layout: The corresponding Layout object.
Raises:
LayoutError: Invalid input layout.
"""
if not all(isinstanceint(i) for i in int_list):
raise LayoutError("Expected a list of ints")
if len(int_list) != len(set(int_list)):
raise LayoutError("Duplicate values not permitted; Layout is bijective.")
num_qubits = sum(reg.size for reg in qregs)
# Check if list is too short to cover all qubits
if len(int_list) != num_qubits:
raise LayoutError(
f"Integer list length ({len(int_list)}) must equal number of qubits "
f"in circuit ({num_qubits}): {int_list}."
)
out = Layout()
main_idx = 0
for qreg in qregs:
for idx in range(qreg.size):
out[qreg[idx]] = int_list[main_idx]
main_idx += 1
out.add_register(qreg)
if main_idx != len(int_list):
for int_item in int_list[main_idx:]:
out[int_item] = None
return out
@staticmethod
def from_qubit_list(qubit_list, *qregs):
"""
Populates a Layout from a list containing virtual
qubits, Qubit or None.
Args:
qubit_list (list):
e.g.: [qr[0], None, qr[2], qr[3]]
*qregs (QuantumRegisters): The quantum registers to apply
the layout to.
Returns:
Layout: the corresponding Layout object
Raises:
LayoutError: If the elements are not Qubit or None
"""
out = Layout()
for physical, virtual in enumerate(qubit_list):
if virtual is None:
continue
if isinstance(virtual, Qubit):
if virtual in out._v2p:
raise LayoutError("Duplicate values not permitted; Layout is bijective.")
out[virtual] = physical
else:
raise LayoutError("The list should contain elements of the Bits or NoneTypes")
for qreg in qregs:
out.add_register(qreg)
return out
def compose(self, other: Layout, qubits: List[Qubit]) -> Layout:
"""Compose this layout with another layout.
If this layout represents a mapping from the P-qubits to the positions of the Q-qubits,
and the other layout represents a mapping from the Q-qubits to the positions of
the R-qubits, then the composed layout represents a mapping from the P-qubits to the
positions of the R-qubits.
Args:
other: The existing :class:`.Layout` to compose this :class:`.Layout` with.
qubits: A list of :class:`.Qubit` objects over which ``other`` is defined,
used to establish the correspondence between the positions of the ``other``
qubits and the actual qubits.
Returns:
A new layout object the represents this layout composed with the ``other`` layout.
"""
other_v2p = other.get_virtual_bits()
return Layout({virt: other_v2p[qubits[phys]] for virt, phys in self._v2p.items()})
def inverse(self, source_qubits: List[Qubit], target_qubits: List[Qubit]):
"""Finds the inverse of this layout.
This is possible when the layout is a bijective mapping, however the input
and the output qubits may be different (in particular, this layout may be
the mapping from the extended-with-ancillas virtual qubits to physical qubits).
Thus, if this layout represents a mapping from the P-qubits to the positions
of the Q-qubits, the inverse layout represents a mapping from the Q-qubits
to the positions of the P-qubits.
Args:
source_qubits: A list of :class:`.Qubit` objects representing the domain
of the layout.
target_qubits: A list of :class:`.Qubit` objects representing the image
of the layout.
Returns:
A new layout object the represents the inverse of this layout.
"""
source_qubit_to_position = {q: p for p, q in enumerate(source_qubits)}
return Layout(
{
target_qubits[pos_phys]: source_qubit_to_position[virt]
for virt, pos_phys in self._v2p.items()
}
)
def to_permutation(self, qubits: List[Qubit]):
"""Creates a permutation corresponding to this layout.
This is possible when the layout is a bijective mapping with the same
source and target qubits (for instance, a "final_layout" corresponds
to a permutation of the physical circuit qubits). If this layout is
a mapping from qubits to their new positions, the resulting permutation
describes which qubits occupy the positions 0, 1, 2, etc. after
applying the permutation.
For example, suppose that the list of qubits is ``[qr_0, qr_1, qr_2]``,
and the layout maps ``qr_0`` to ``2``, ``qr_1`` to ``0``, and
``qr_2`` to ``1``. In terms of positions in ``qubits``, this maps ``0``
to ``2``, ``1`` to ``0`` and ``2`` to ``1``, with the corresponding
permutation being ``[1, 2, 0]``.
"""
perm = [None] * len(qubits)
for i, q in enumerate(qubits):
pos = self._v2p[q]
perm[pos] = i
return perm
@dataclass
class TranspileLayout:
r"""Layout attributes for the output circuit from transpiler.
The :mod:`~qiskit.transpiler` is unitary-preserving up to the "initial layout"
and "final layout" permutations. The initial layout permutation is caused by
setting and applying the initial layout during the :ref:`layout_stage`.
The final layout permutation is caused by :class:`~.SwapGate` insertion during
the :ref:`routing_stage`. This class provides an interface to reason about these
permutations using a variety of helper methods.
During the layout stage, the transpiler can potentially remap the order of the
qubits in the circuit as it fits the circuit to the target backend. For example,
let the input circuit be:
.. plot:
:include-source:
from qiskit.circuit import QuantumCircuit, QuantumRegister
qr = QuantumRegister(3, name="MyReg")
qc = QuantumCircuit(qr)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
qc.draw("mpl")
Suppose that during the layout stage the transpiler reorders the qubits to be:
.. plot:
:include-source:
from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(2)
qc.cx(2, 1)
qc.cx(2, 0)
qc.draw("mpl")
Then the output of the :meth:`.initial_virtual_layout` method is
equivalent to::
Layout({
qr[0]: 2,
qr[1]: 1,
qr[2]: 0,
})
(it is also this attribute in the :meth:`.QuantumCircuit.draw` and
:func:`.circuit_drawer` which is used to display the mapping of qubits to
positions in circuit visualizations post-transpilation).
Building on the above example, suppose that during the routing stage
the transpiler needs to insert swap gates, and the output circuit
becomes:
.. plot:
:include-source:
from qiskit import QuantumCircuit
qc = QuantumCircuit(3)
qc.h(2)
qc.cx(2, 1)
qc.swap(0, 1)
qc.cx(2, 1)
qc.draw("mpl")
Then the output of the :meth:`routing_permutation` method is::
[1, 0, 2]
which maps positions of qubits before routing to their final positions
after routing.
There are three public attributes associated with the class, however these
are mostly provided for backwards compatibility and represent the internal
state from the transpiler. They are defined as:
* :attr:`initial_layout` - This attribute is used to model the
permutation caused by the :ref:`layout_stage`. It is a
:class:`~.Layout` object that maps the input :class:`~.QuantumCircuit`\s
:class:`~.circuit.Qubit` objects to the position in the output
:class:`.QuantumCircuit.qubits` list.
* :attr:`input_qubit_mapping` - This attribute is used to retain
input ordering of the original :class:`~.QuantumCircuit` object. It
maps the virtual :class:`~.circuit.Qubit` object from the original circuit
(and :attr:`initial_layout`) to its corresponding position in
:attr:`.QuantumCircuit.qubits` in the original circuit. This
is needed when computing the permutation of the :class:`Operator` of
the circuit (and used by :meth:`.Operator.from_circuit`).
* :attr:`final_layout` - This attribute is used to model the
permutation caused by the :ref:`routing_stage`. It is a
:class:`~.Layout` object that maps the output circuit's qubits from
:class:`.QuantumCircuit.qubits` in the output circuit to their final
positions after routing. Importantly, this only represents the
permutation caused by inserting :class:`~.SwapGate`\s into
the :class:`~.QuantumCircuit` during the :ref:`routing_stage`.
It is **not** a mapping from the original input circuit's position
to the final position at the end of the transpiled circuit.
If you need this, you can use the :meth:`.final_index_layout` to generate this.
If :attr:`final_layout` is set to ``None``, this indicates that routing was not
run, and can be considered equivalent to a trivial layout with the qubits from
the output circuit's :attr:`~.QuantumCircuit.qubits` list.
"""
initial_layout: Layout
input_qubit_mapping: dict[circuit.Qubit, int]
final_layout: Layout | None = None
_input_qubit_count: int | None = None
_output_qubit_list: List[Qubit] | None = None
def initial_virtual_layout(self, filter_ancillas: bool = False) -> Layout:
"""Return a :class:`.Layout` object for the initial layout.
This returns a mapping of virtual :class:`~.circuit.Qubit` objects in the input
circuit to the positions of the physical qubits selected during layout.
This is analogous to the :attr:`.initial_layout` attribute.
Args:
filter_ancillas: If set to ``True`` only qubits in the input circuit
will be in the returned layout. Any ancilla qubits added to the
output circuit will be filtered from the returned object.
Returns:
A layout object mapping the input circuit's :class:`~.circuit.Qubit`
objects to the positions of the selected physical qubits.
"""
if not filter_ancillas:
return self.initial_layout
return Layout(
{
k: v
for k, v in self.initial_layout.get_virtual_bits().items()
if self.input_qubit_mapping[k] < self._input_qubit_count
}
)
def initial_index_layout(self, filter_ancillas: bool = False) -> List[int]:
"""Generate an initial layout as an array of integers.
Args:
filter_ancillas: If set to ``True`` any ancilla qubits added
to the transpiler will not be included in the output.
Return:
A layout array that maps a position in the array to its new position in the output
circuit.
"""
virtual_map = self.initial_layout.get_virtual_bits()
if filter_ancillas:
output = [None] * self._input_qubit_count
else:
output = [None] * len(virtual_map)
for index, (virt, phys) in enumerate(virtual_map.items()):
if filter_ancillas and index >= self._input_qubit_count:
break
pos = self.input_qubit_mapping[virt]
output[pos] = phys
return output
def routing_permutation(self) -> List[int]:
"""Generate a final layout as an array of integers.
If there is no :attr:`.final_layout` attribute present then that indicates
there was no output permutation caused by routing or other transpiler
transforms. In this case the function will return a list of ``[0, 1, 2, .., n]``.
Returns:
A layout array that maps a position in the array to its new position in the output
circuit.
"""
if self.final_layout is None:
return list(range(len(self._output_qubit_list)))
virtual_map = self.final_layout.get_virtual_bits()
return [virtual_map[virt] for virt in self._output_qubit_list]
def final_index_layout(self, filter_ancillas: bool = True) -> List[int]:
"""Generate the final layout as an array of integers.
This method will generate an array of final positions for each qubit in the input circuit.
For example, if you had an input circuit like::
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
and the output from the transpiler was::
tqc = QuantumCircuit(3)
tqc.h(2)
tqc.cx(2, 1)
tqc.swap(0, 1)
tqc.cx(2, 1)
then the :meth:`.final_index_layout` method returns::
[2, 0, 1]
This can be seen as follows. Qubit 0 in the original circuit is mapped to qubit 2
in the output circuit during the layout stage, which is mapped to qubit 2 during the
routing stage. Qubit 1 in the original circuit is mapped to qubit 1 in the output
circuit during the layout stage, which is mapped to qubit 0 during the routing
stage. Qubit 2 in the original circuit is mapped to qubit 0 in the output circuit
during the layout stage, which is mapped to qubit 1 during the routing stage.
The output list length will be as wide as the input circuit's number of qubits,
as the output list from this method is for tracking the permutation of qubits in the
original circuit caused by the transpiler.
Args:
filter_ancillas: If set to ``False`` any ancillas allocated in the output circuit will be
included in the layout.
Returns:
A list of final positions for each input circuit qubit.
"""
if self._input_qubit_count is None:
# TODO: After there is a way to differentiate the ancilla qubits added by the transpiler
# don't use the ancilla name anymore.See #10817 for discussion on this.
num_source_qubits = len(
[
x
for x in self.input_qubit_mapping
if getattr(x, "_register", "").startswith("ancilla")
]
)
else:
num_source_qubits = self._input_qubit_count
if self._output_qubit_list is None:
circuit_qubits = list(self.final_layout.get_virtual_bits())
else:
circuit_qubits = self._output_qubit_list
pos_to_virt = {v: k for k, v in self.input_qubit_mapping.items()}
qubit_indices = []
if filter_ancillas:
num_qubits = num_source_qubits
else:
num_qubits = len(self._output_qubit_list)
for index in range(num_qubits):
qubit_idx = self.initial_layout[pos_to_virt[index]]
if self.final_layout is not None:
qubit_idx = self.final_layout[circuit_qubits[qubit_idx]]
qubit_indices.append(qubit_idx)
return qubit_indices
def final_virtual_layout(self, filter_ancillas: bool = True) -> Layout:
"""Generate the final layout as a :class:`.Layout` object.
This method will generate an array of final positions for each qubit in the input circuit.
For example, if you had an input circuit like::
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0, 1)
qc.cx(0, 2)
and the output from the transpiler was::
tqc = QuantumCircuit(3)
tqc.h(2)
tqc.cx(2, 1)
tqc.swap(0, 1)
tqc.cx(2, 1)
then the return from this function would be a layout object::
Layout({
qc.qubits[0]: 2,
qc.qubits[1]: 0,
qc.qubits[2]: 1,
})
This can be seen as follows. Qubit 0 in the original circuit is mapped to qubit 2
in the output circuit during the layout stage, which is mapped to qubit 2 during the
routing stage. Qubit 1 in the original circuit is mapped to qubit 1 in the output
circuit during the layout stage, which is mapped to qubit 0 during the routing
stage. Qubit 2 in the original circuit is mapped to qubit 0 in the output circuit
during the layout stage, which is mapped to qubit 1 during the routing stage.
The output list length will be as wide as the input circuit's number of qubits,
as the output list from this method is for tracking the permutation of qubits in the
original circuit caused by the transpiler.
Args:
filter_ancillas: If set to ``False`` any ancillas allocated in the output circuit will be
included in the layout.
Returns:
A layout object mapping to the final positions for each qubit.
"""
res = self.final_index_layout(filter_ancillas=filter_ancillas)
pos_to_virt = {v: k for k, v in self.input_qubit_mapping.items()}
return Layout({pos_to_virt[index]: phys for index, phys in enumerate(res)})
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.ignis.mitigation import expectation_value
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("./")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
scale_factors = [1.0, 2.0, 3.0]
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="lq")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder_init110(qc, targets=[0, 1, 2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = zne_wrapper(t3_st_qcs, scale_factors = scale_factors)
print("created zne_qcs (length:", len(zne_qcs), ")")
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
t3_zne_qcs[-3].draw("mpl")
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
# print("provider:", provider)
# backend = provider.get_backend("ibmq_jakarta")
shots = 1 << 13
reps = 8 # unused
jobs = []
for _ in range(reps):
job = execute(t3_zne_qcs, backend, shots=shots) # 毎回チェック: ここちゃんと変えた？
print('Job ID', job.job_id())
jobs.append(job)
# QREM
shots = 1 << 13
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
fids = []
for job in jobs:
mit_results = meas_fitter.filter.apply(job.result())
zne_expvals = zne_decoder(num_qubits, mit_results, scale_factors = scale_factors)
rho = expvals_to_valid_rho(num_qubits, zne_expvals)
fid = state_fidelity(rho, target_state)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Example on how to load a file into a QuantumCircuit."""
from qiskit import QuantumCircuit
from qiskit import execute, BasicAer
circ = QuantumCircuit.from_qasm_file("examples/qasm/entangled_registers.qasm")
print(circ)
# See the backend
sim_backend = BasicAer.get_backend("qasm_simulator")
# Compile and run the Quantum circuit on a local simulator backend
job_sim = execute(circ, sim_backend)
sim_result = job_sim.result()
# Show the results
print("simulation: ", sim_result)
print(sim_result.get_counts(circ))
|
https://github.com/AllenGabrielMarchen/HHL_implementation
|
AllenGabrielMarchen
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
import numpy as np
import circuit as circ
import tools
def My_HHL(CU,b,n_l,n_b,backend,delta,shots,A,details = True,chevyshev = False):
#b_sol = np.hstack((b,np.zeros_like((np.shape(A)[0]-np.shape(b)[0],1))))
#circuit initialization
n_f = 1
nb = int(np.log2(b.shape))
nl_rg = QuantumRegister(n_l, "l")
nb_rg = QuantumRegister(n_b, "b")
na_rg = QuantumRegister(n_l, "a")
nf_rg = QuantumRegister(n_f, "f")
cf = ClassicalRegister(n_f, "classical_f")
cb = ClassicalRegister(n_b, "classical_b")
qc = QuantumCircuit(nf_rg,nl_rg, nb_rg, na_rg, cf, cb)
qc.isometry(b/np.linalg.norm(b), list(range(nb)), None)
#qc.h(nb_rg[0])
qc.barrier(nf_rg,nl_rg,nb_rg)
if details == True:
qc = qc.compose(circ.QPE(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc = qc.compose(circ.Eigenvalue_inversion(n_l,delta,chevyshev),[nl_rg[2]]+[nl_rg[1]]+[nl_rg[0]]+nf_rg[:])
qc = qc.compose(circ.QPE_dagger(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.barrier(nf_rg[:]+nl_rg[:]+nb_rg[:])
qc.measure(nf_rg,cf)
qc.measure(nb_rg,cb)
answer = circ.measurement(qc,n_l,n_b,CU,backend,shots)
qc.draw(output = 'mpl').savefig('./outputs/qc_HHL')
else:
qc.append(circ.QPE(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.append(circ.Eigenvalue_inversion(n_l),[nl_rg[2]]+[nl_rg[1]]+[nl_rg[0]]+nf_rg[:])
qc.append(circ.QPE_dagger(n_l,n_b,CU),nl_rg[:]+nb_rg[:])
qc.barrier(nf_rg[:]+nl_rg[:]+nb_rg[:])
qc.measure(nf_rg,cf)
qc.measure(nb_rg,cb)
answer = circ.measurement(qc,n_l,n_b,CU,backend,shots)
qc.draw(output = 'mpl').savefig('./outputs/qc_HHL')
#Obtaining Normalized answer
normalized_result = tools.normalize_vector(answer, n_b)
#Obtaining Real Answer
constant = b/(A @ normalized_result)
constant = (constant[0]+constant[1])/2
constant = np.mean(constant)
print('<My_HHL>')
print('Normalized Answer : {0}'.format(normalized_result))
print('Un-normalized Answer : {0}'.format(normalized_result * constant))
print('Normalize Constant: ' ,constant)
return [normalized_result,normalized_result * constant]
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, QuantumRegister
from qiskit.circuit.library.standard_gates import HGate
qr = QuantumRegister(3)
qc = QuantumCircuit(qr)
c3h_gate = HGate().control(2)
qc.append(c3h_gate, qr)
qc.draw('mpl')
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
from qiskit import *
import numpy as np
import math
import qiskit
nshots = 8192
IBMQ.load_account()
#provider= qiskit.IBMQ.get_provider(hub='ibm-q-research-2',group='federal-uni-sant-1',project='main')
provider = qiskit.IBMQ.get_provider(hub='ibm-q', group='open', project='main')
device = provider.get_backend('ibmq_belem')
simulator = Aer.get_backend('qasm_simulator')
from qiskit.tools.monitor import job_monitor
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
dth = math.pi/10
th = np.arange(0,math.pi+dth,dth)
ph = 0; lb = 0
N = len(th)
F_the = np.zeros(N); F_sim = np.zeros(N); F_exp = np.zeros(N)
for j in range(0,N):
F_the[j] = math.cos(th[j]/2)**2
qr = QuantumRegister(3)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr,cr)
qc.u(th[j],ph,lb,qr[2])
qc.h(qr[0])
qc.cswap(qr[0],qr[1],qr[2])
qc.h(qr[0])
qc.measure(qr[0],cr[0])
job_sim = execute(qc, backend=simulator, shots=nshots)
counts = job_sim.result().get_counts(qc)
if '0' in counts:
F_sim[j] = 2*counts['0']/nshots - 1
job_exp = execute(qc, backend=device, shots=nshots)
print(job_exp.job_id())
job_monitor(job_exp)
counts = job_exp.result().get_counts(qc)
if '0' in counts:
F_exp[j] = 2*counts['0']/nshots - 1
qc.draw('mpl')
qc.decompose().decompose().draw('mpl') # o circuito é "profundo" por causa da swap controlada
F_the, F_sim, F_exp
from matplotlib import pyplot as plt
plt.plot(th, F_the, label=r'$F_{the}$')
plt.plot(th, F_sim, '*', label=r'$F_{sim}$')
plt.plot(th, F_exp, 'o', label=r'$F_{exp}$')
plt.xlabel(r'$\theta$')
plt.legend()
plt.show()
|
https://github.com/shesha-raghunathan/DATE2019-qiskit-tutorial
|
shesha-raghunathan
|
from math import pi
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.tools.visualization import matplotlib_circuit_drawer as drawer, qx_color_scheme
# We recommend the following options for Jupter notebook
%matplotlib inline
# Create a Quantum Register called "q" with 3 qubits
qr = QuantumRegister(3, 'q')
# Create a Classical Register called "c" with 3 bits
cr = ClassicalRegister(3, 'c')
# Create a Quantum Circuit called involving "qr" and "cr"
circuit = QuantumCircuit(qr, cr)
circuit.x(qr[0]).c_if(cr, 3)
circuit.z(qr[0])
circuit.u2(pi/2, 2*pi/3, qr[1])
circuit.cu1(pi, qr[0], qr[1])
# Barrier to seperator the input from the circuit
circuit.barrier(qr[0])
circuit.barrier(qr[1])
circuit.barrier(qr[2])
# Toffoli gate from qubit 0,1 to qubit 2
circuit.ccx(qr[0], qr[1], qr[2])
# CNOT (Controlled-NOT) gate from qubit 0 to qubit 1
circuit.cx(qr[0], qr[1])
circuit.swap(qr[0], qr[2])
# measure gate from qr to cr
circuit.measure(qr, cr)
QASM_source = circuit.qasm()
print(QASM_source)
drawer(circuit)
drawer(circuit, basis='u1,u2,u3,id,cx', scale=1.0)
my_style = {'plotbarrier': True}
drawer(circuit, style=my_style)
my_style = {'cregbundle': True}
drawer(circuit, style=my_style)
my_style = {'showindex': True}
drawer(circuit, style=my_style)
my_style = {'compress': True}
drawer(circuit, style=my_style)
my_style = {'fold': 6}
drawer(circuit, style=my_style)
my_style = {'usepiformat': True}
drawer(circuit, style=my_style)
qr = QuantumRegister(1, 'q')
circuit_xyz = QuantumCircuit(qr)
circuit_xyz.x(qr[0])
circuit_xyz.y(qr[0])
circuit_xyz.z(qr[0])
drawer(circuit_xyz)
my_style = {'displaytext': {'x': '😺', 'y': '\Sigma', 'z': '✈'}}
drawer(circuit_xyz, style=my_style)
qr = QuantumRegister(2, 'q')
circuit_cucz = QuantumCircuit(qr)
circuit_cucz.cz(qr[0], qr[1])
circuit_cucz.cu1(pi, qr[0], qr[1])
drawer(circuit_cucz)
my_style = {'latexdrawerstyle': False}
drawer(circuit_cucz, style=my_style)
qr = QuantumRegister(3, 'q')
cr = ClassicalRegister(3, 'c')
circuit_all = QuantumCircuit(qr, cr)
circuit_all.x(qr[0])
circuit_all.y(qr[0])
circuit_all.z(qr[0])
circuit_all.barrier(qr[0])
circuit_all.barrier(qr[1])
circuit_all.barrier(qr[2])
circuit_all.h(qr[0])
circuit_all.s(qr[0])
circuit_all.sdg(qr[0])
circuit_all.t(qr[0])
circuit_all.tdg(qr[0])
circuit_all.iden(qr[0])
circuit_all.reset(qr[0])
circuit_all.rx(pi, qr[0])
circuit_all.ry(pi, qr[0])
circuit_all.rz(pi, qr[0])
circuit_all.u0(pi, qr[0])
circuit_all.u1(pi, qr[0])
circuit_all.u2(pi, pi, qr[0])
circuit_all.u3(pi, pi, pi, qr[0])
circuit_all.swap(qr[0], qr[1])
circuit_all.cx(qr[0], qr[1])
circuit_all.cy(qr[0], qr[1])
circuit_all.cz(qr[0], qr[1])
circuit_all.ch(qr[0], qr[1])
circuit_all.cu1(pi, qr[0], qr[1])
circuit_all.cu3(pi, pi, pi, qr[0], qr[1])
circuit_all.crz(pi, qr[0], qr[1])
circuit_all.ccx(qr[0], qr[1], qr[2])
circuit_all.cswap(qr[0], qr[1], qr[2])
circuit_all.measure(qr, cr)
drawer(circuit_all)
cmp_style = qx_color_scheme()
cmp_style
drawer(circuit_all, style=cmp_style)
cmp_style.update({
'usepiformat': True,
'showindex': True,
'cregbundle': True,
'compress': True,
'fold': 17
})
drawer(circuit_all, filename='circuit.pdf', style=cmp_style)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.utils import algorithm_globals
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import (
MinimumEigenOptimizer,
RecursiveMinimumEigenOptimizer,
SolutionSample,
OptimizationResultStatus,
)
from qiskit_optimization import QuadraticProgram
from qiskit.visualization import plot_histogram
from typing import List, Tuple
import numpy as np
# create a QUBO
qubo = QuadraticProgram()
qubo.binary_var("x")
qubo.binary_var("y")
qubo.binary_var("z")
qubo.minimize(linear=[1, -2, 3], quadratic={("x", "y"): 1, ("x", "z"): -1, ("y", "z"): 2})
print(qubo.prettyprint())
op, offset = qubo.to_ising()
print("offset: {}".format(offset))
print("operator:")
print(op)
qp = QuadraticProgram()
qp.from_ising(op, offset, linear=True)
print(qp.prettyprint())
algorithm_globals.random_seed = 10598
qaoa_mes = QAOA(sampler=Sampler(), optimizer=COBYLA(), initial_point=[0.0, 0.0])
exact_mes = NumPyMinimumEigensolver()
qaoa = MinimumEigenOptimizer(qaoa_mes) # using QAOA
exact = MinimumEigenOptimizer(exact_mes) # using the exact classical numpy minimum eigen solver
exact_result = exact.solve(qubo)
print(exact_result.prettyprint())
qaoa_result = qaoa.solve(qubo)
print(qaoa_result.prettyprint())
print("variable order:", [var.name for var in qaoa_result.variables])
for s in qaoa_result.samples:
print(s)
def get_filtered_samples(
samples: List[SolutionSample],
threshold: float = 0,
allowed_status: Tuple[OptimizationResultStatus] = (OptimizationResultStatus.SUCCESS,),
):
res = []
for s in samples:
if s.status in allowed_status and s.probability > threshold:
res.append(s)
return res
filtered_samples = get_filtered_samples(
qaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)
)
for s in filtered_samples:
print(s)
fvals = [s.fval for s in qaoa_result.samples]
probabilities = [s.probability for s in qaoa_result.samples]
np.mean(fvals)
np.std(fvals)
samples_for_plot = {
" ".join(f"{qaoa_result.variables[i].name}={int(v)}" for i, v in enumerate(s.x)): s.probability
for s in filtered_samples
}
samples_for_plot
plot_histogram(samples_for_plot)
rqaoa = RecursiveMinimumEigenOptimizer(qaoa, min_num_vars=1, min_num_vars_optimizer=exact)
rqaoa_result = rqaoa.solve(qubo)
print(rqaoa_result.prettyprint())
filtered_samples = get_filtered_samples(
rqaoa_result.samples, threshold=0.005, allowed_status=(OptimizationResultStatus.SUCCESS,)
)
samples_for_plot = {
" ".join(f"{rqaoa_result.variables[i].name}={int(v)}" for i, v in enumerate(s.x)): s.probability
for s in filtered_samples
}
samples_for_plot
plot_histogram(samples_for_plot)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/arnavdas88/QuGlassyIsing
|
arnavdas88
|
#Assign these values as per your requirements.
global min_qubits,max_qubits,skip_qubits,max_circuits,num_shots,Noise_Inclusion
min_qubits=1
max_qubits=3
skip_qubits=1
max_circuits=3
num_shots=1000
use_XX_YY_ZZ_gates = True
Noise_Inclusion = False
saveplots = False
Memory_utilization_plot = True
Type_of_Simulator = "built_in" #Inputs are "built_in" or "FAKE" or "FAKEV2"
backend_name = "FakeGuadalupeV2" #Can refer to the README files for the available backends
gate_counts_plots = True
#Change your Specification of Simulator in Declaring Backend Section
#By Default : built_in -> qasm_simulator and FAKE -> FakeSantiago() and FAKEV2 -> FakeSantiagoV2()
import numpy as np
import os,json
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, Aer, transpile, execute
import time
import matplotlib.pyplot as plt
# Import from Qiskit Aer noise module
from qiskit_aer.noise import (NoiseModel, QuantumError, ReadoutError,pauli_error, depolarizing_error, thermal_relaxation_error,reset_error)
# Benchmark Name
benchmark_name = "Hamiltonian Simulation"
# Selection of basis gate set for transpilation
# Note: selector 1 is a hardware agnostic gate set
basis_selector = 1
basis_gates_array = [
[],
['rx', 'ry', 'rz', 'cx'], # a common basis set, default
['cx', 'rz', 'sx', 'x'], # IBM default basis set
['rx', 'ry', 'rxx'], # IonQ default basis set
['h', 'p', 'cx'], # another common basis set
['u', 'cx'] # general unitaries basis gates
]
np.random.seed(0)
num_gates = 0
depth = 0
def get_QV(backend):
import json
# Assuming backend.conf_filename is the filename and backend.dirname is the directory path
conf_filename = backend.dirname + "/" + backend.conf_filename
# Open the JSON file
with open(conf_filename, 'r') as file:
# Load the JSON data
data = json.load(file)
# Extract the quantum_volume parameter
QV = data.get('quantum_volume', None)
return QV
def checkbackend(backend_name,Type_of_Simulator):
if Type_of_Simulator == "built_in":
available_backends = []
for i in Aer.backends():
available_backends.append(i.name)
if backend_name in available_backends:
platform = backend_name
return platform
else:
print(f"incorrect backend name or backend not available. Using qasm_simulator by default !!!!")
print(f"available backends are : {available_backends}")
platform = "qasm_simulator"
return platform
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2":
import qiskit.providers.fake_provider as fake_backends
if hasattr(fake_backends,backend_name) is True:
print(f"Backend {backend_name} is available for type {Type_of_Simulator}.")
backend_class = getattr(fake_backends,backend_name)
backend_instance = backend_class()
return backend_instance
else:
print(f"Backend {backend_name} is not available or incorrect for type {Type_of_Simulator}. Executing with FakeSantiago!!!")
if Type_of_Simulator == "FAKEV2":
backend_class = getattr(fake_backends,"FakeSantiagoV2")
else:
backend_class = getattr(fake_backends,"FakeSantiago")
backend_instance = backend_class()
return backend_instance
if Type_of_Simulator == "built_in":
platform = checkbackend(backend_name,Type_of_Simulator)
#By default using "Qasm Simulator"
backend = Aer.get_backend(platform)
QV_=None
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"backend version is {backend.backend_version}")
elif Type_of_Simulator == "FAKE":
basis_selector = 0
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.properties().backend_name +"-"+ backend.properties().backend_version #Replace this string with the backend Provider's name as this is used for Plotting.
max_qubits=backend.configuration().n_qubits
print(f"{platform} device is capable of running {backend.configuration().n_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
elif Type_of_Simulator == "FAKEV2":
basis_selector = 0
if "V2" not in backend_name:
backend_name = backend_name+"V2"
backend = checkbackend(backend_name,Type_of_Simulator)
QV_ = get_QV(backend)
platform = backend.name +"-" +backend.backend_version
max_qubits=backend.num_qubits
print(f"{platform} device is capable of running {backend.num_qubits}")
print(f"{platform} has QV={QV_}")
if max_qubits > 30:
print(f"Device is capable with max_qubits = {max_qubits}")
max_qubit = 30
print(f"Using fake backend {platform} with max_qubits {max_qubits}")
else:
print("Enter valid Simulator.....")
# saved circuits and subcircuits for display
QC_ = None
XX_ = None
YY_ = None
ZZ_ = None
XXYYZZ_ = None
# import precalculated data to compare against
filename = os.path.join("precalculated_data.json")
with open(filename, 'r') as file:
data = file.read()
precalculated_data = json.loads(data)
############### Circuit Definition
def HamiltonianSimulation(n_spins, K, t, w, h_x, h_z):
'''
Construct a Qiskit circuit for Hamiltonian Simulation
:param n_spins:The number of spins to simulate
:param K: The Trotterization order
:param t: duration of simulation
:return: return a Qiskit circuit for this Hamiltonian
'''
num_qubits = n_spins
secret_int = f"{K}-{t}"
# allocate qubits
qr = QuantumRegister(n_spins); cr = ClassicalRegister(n_spins);
qc = QuantumCircuit(qr, cr, name=f"hamsim-{num_qubits}-{secret_int}")
tau = t / K
# start with initial state of 1010101...
for k in range(0, n_spins, 2):
qc.x(qr[k])
qc.barrier()
# loop over each trotter step, adding gates to the circuit defining the hamiltonian
for k in range(K):
# the Pauli spin vector product
[qc.rx(2 * tau * w * h_x[i], qr[i]) for i in range(n_spins)]
[qc.rz(2 * tau * w * h_z[i], qr[i]) for i in range(n_spins)]
qc.barrier()
# Basic implementation of exp(i * t * (XX + YY + ZZ))
if _use_XX_YY_ZZ_gates:
# XX operator on each pair of qubits in linear chain
for j in range(2):
for i in range(j%2, n_spins - 1, 2):
qc.append(xx_gate(tau).to_instruction(), [qr[i], qr[(i + 1) % n_spins]])
# YY operator on each pair of qubits in linear chain
for j in range(2):
for i in range(j%2, n_spins - 1, 2):
qc.append(yy_gate(tau).to_instruction(), [qr[i], qr[(i + 1) % n_spins]])
# ZZ operation on each pair of qubits in linear chain
for j in range(2):
for i in range(j%2, n_spins - 1, 2):
qc.append(zz_gate(tau).to_instruction(), [qr[i], qr[(i + 1) % n_spins]])
# Use an optimal XXYYZZ combined operator
# See equation 1 and Figure 6 in https://arxiv.org/pdf/quant-ph/0308006.pdf
else:
# optimized XX + YY + ZZ operator on each pair of qubits in linear chain
for j in range(2):
for i in range(j % 2, n_spins - 1, 2):
qc.append(xxyyzz_opt_gate(tau).to_instruction(), [qr[i], qr[(i + 1) % n_spins]])
qc.barrier()
# measure all the qubits used in the circuit
for i_qubit in range(n_spins):
qc.measure(qr[i_qubit], cr[i_qubit])
# save smaller circuit example for display
global QC_
if QC_ == None or n_spins <= 6:
if n_spins < 9: QC_ = qc
return qc
############### XX, YY, ZZ Gate Implementations
# Simple XX gate on q0 and q1 with angle 'tau'
def xx_gate(tau):
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name="xx_gate")
qc.h(qr[0])
qc.h(qr[1])
qc.cx(qr[0], qr[1])
qc.rz(3.1416*tau, qr[1])
qc.cx(qr[0], qr[1])
qc.h(qr[0])
qc.h(qr[1])
# save circuit example for display
global XX_
XX_ = qc
return qc
# Simple YY gate on q0 and q1 with angle 'tau'
def yy_gate(tau):
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name="yy_gate")
qc.s(qr[0])
qc.s(qr[1])
qc.h(qr[0])
qc.h(qr[1])
qc.cx(qr[0], qr[1])
qc.rz(3.1416*tau, qr[1])
qc.cx(qr[0], qr[1])
qc.h(qr[0])
qc.h(qr[1])
qc.sdg(qr[0])
qc.sdg(qr[1])
# save circuit example for display
global YY_
YY_ = qc
return qc
# Simple ZZ gate on q0 and q1 with angle 'tau'
def zz_gate(tau):
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name="zz_gate")
qc.cx(qr[0], qr[1])
qc.rz(3.1416*tau, qr[1])
qc.cx(qr[0], qr[1])
# save circuit example for display
global ZZ_
ZZ_ = qc
return qc
# Optimal combined XXYYZZ gate (with double coupling) on q0 and q1 with angle 'tau'
def xxyyzz_opt_gate(tau):
alpha = tau; beta = tau; gamma = tau
qr = QuantumRegister(2); qc = QuantumCircuit(qr, name="xxyyzz_opt")
qc.rz(3.1416/2, qr[1])
qc.cx(qr[1], qr[0])
qc.rz(3.1416*gamma - 3.1416/2, qr[0])
qc.ry(3.1416/2 - 3.1416*alpha, qr[1])
qc.cx(qr[0], qr[1])
qc.ry(3.1416*beta - 3.1416/2, qr[1])
qc.cx(qr[1], qr[0])
qc.rz(-3.1416/2, qr[0])
# save circuit example for display
global XXYYZZ_
XXYYZZ_ = qc
return qc
# Create an empty noise model
noise_parameters = NoiseModel()
if Type_of_Simulator == "built_in":
# Add depolarizing error to all single qubit gates with error rate 0.05% and to all two qubit gates with error rate 0.5%
depol_one_qb_error = 0.05
depol_two_qb_error = 0.005
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(depol_two_qb_error, 2), ['cx'])
# Add amplitude damping error to all single qubit gates with error rate 0.0% and to all two qubit gates with error rate 0.0%
amp_damp_one_qb_error = 0.0
amp_damp_two_qb_error = 0.0
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_one_qb_error, 1), ['rx', 'ry', 'rz'])
noise_parameters.add_all_qubit_quantum_error(depolarizing_error(amp_damp_two_qb_error, 2), ['cx'])
# Add reset noise to all single qubit resets
reset_to_zero_error = 0.005
reset_to_one_error = 0.005
noise_parameters.add_all_qubit_quantum_error(reset_error(reset_to_zero_error, reset_to_one_error),["reset"])
# Add readout error
p0given1_error = 0.000
p1given0_error = 0.000
error_meas = ReadoutError([[1 - p1given0_error, p1given0_error], [p0given1_error, 1 - p0given1_error]])
noise_parameters.add_all_qubit_readout_error(error_meas)
#print(noise_parameters)
elif Type_of_Simulator == "FAKE"or"FAKEV2":
noise_parameters = NoiseModel.from_backend(backend)
#print(noise_parameters)
### Analysis methods to be expanded and eventually compiled into a separate analysis.py file
import math, functools
def hellinger_fidelity_with_expected(p, q):
""" p: result distribution, may be passed as a counts distribution
q: the expected distribution to be compared against
References:
`Hellinger Distance @ wikipedia <https://en.wikipedia.org/wiki/Hellinger_distance>`_
Qiskit Hellinger Fidelity Function
"""
p_sum = sum(p.values())
q_sum = sum(q.values())
if q_sum == 0:
print("ERROR: polarization_fidelity(), expected distribution is invalid, all counts equal to 0")
return 0
p_normed = {}
for key, val in p.items():
p_normed[key] = val/p_sum
# if p_sum != 0:
# p_normed[key] = val/p_sum
# else:
# p_normed[key] = 0
q_normed = {}
for key, val in q.items():
q_normed[key] = val/q_sum
total = 0
for key, val in p_normed.items():
if key in q_normed.keys():
total += (np.sqrt(val) - np.sqrt(q_normed[key]))**2
del q_normed[key]
else:
total += val
total += sum(q_normed.values())
# in some situations (error mitigation) this can go negative, use abs value
if total < 0:
print(f"WARNING: using absolute value in fidelity calculation")
total = abs(total)
dist = np.sqrt(total)/np.sqrt(2)
fidelity = (1-dist**2)**2
return fidelity
def polarization_fidelity(counts, correct_dist, thermal_dist=None):
"""
Combines Hellinger fidelity and polarization rescaling into fidelity calculation
used in every benchmark
counts: the measurement outcomes after `num_shots` algorithm runs
correct_dist: the distribution we expect to get for the algorithm running perfectly
thermal_dist: optional distribution to pass in distribution from a uniform
superposition over all states. If `None`: generated as
`uniform_dist` with the same qubits as in `counts`
returns both polarization fidelity and the hellinger fidelity
Polarization from: `https://arxiv.org/abs/2008.11294v1`
"""
num_measured_qubits = len(list(correct_dist.keys())[0])
#print(num_measured_qubits)
counts = {k.zfill(num_measured_qubits): v for k, v in counts.items()}
# calculate hellinger fidelity between measured expectation values and correct distribution
hf_fidelity = hellinger_fidelity_with_expected(counts,correct_dist)
# to limit cpu and memory utilization, skip noise correction if more than 16 measured qubits
if num_measured_qubits > 16:
return { 'fidelity':hf_fidelity, 'hf_fidelity':hf_fidelity }
# if not provided, generate thermal dist based on number of qubits
if thermal_dist == None:
thermal_dist = uniform_dist(num_measured_qubits)
# set our fidelity rescaling value as the hellinger fidelity for a depolarized state
floor_fidelity = hellinger_fidelity_with_expected(thermal_dist, correct_dist)
# rescale fidelity result so uniform superposition (random guessing) returns fidelity
# rescaled to 0 to provide a better measure of success of the algorithm (polarization)
new_floor_fidelity = 0
fidelity = rescale_fidelity(hf_fidelity, floor_fidelity, new_floor_fidelity)
return { 'fidelity':fidelity, 'hf_fidelity':hf_fidelity }
## Uniform distribution function commonly used
def rescale_fidelity(fidelity, floor_fidelity, new_floor_fidelity):
"""
Linearly rescales our fidelities to allow comparisons of fidelities across benchmarks
fidelity: raw fidelity to rescale
floor_fidelity: threshold fidelity which is equivalent to random guessing
new_floor_fidelity: what we rescale the floor_fidelity to
Ex, with floor_fidelity = 0.25, new_floor_fidelity = 0.0:
1 -> 1;
0.25 -> 0;
0.5 -> 0.3333;
"""
rescaled_fidelity = (1-new_floor_fidelity)/(1-floor_fidelity) * (fidelity - 1) + 1
# ensure fidelity is within bounds (0, 1)
if rescaled_fidelity < 0:
rescaled_fidelity = 0.0
if rescaled_fidelity > 1:
rescaled_fidelity = 1.0
return rescaled_fidelity
def uniform_dist(num_state_qubits):
dist = {}
for i in range(2**num_state_qubits):
key = bin(i)[2:].zfill(num_state_qubits)
dist[key] = 1/(2**num_state_qubits)
return dist
from matplotlib.patches import Rectangle
import matplotlib.cm as cm
from matplotlib.colors import ListedColormap, LinearSegmentedColormap, Normalize
from matplotlib.patches import Circle
############### Color Map functions
# Create a selection of colormaps from which to choose; default to custom_spectral
cmap_spectral = plt.get_cmap('Spectral')
cmap_greys = plt.get_cmap('Greys')
cmap_blues = plt.get_cmap('Blues')
cmap_custom_spectral = None
# the default colormap is the spectral map
cmap = cmap_spectral
cmap_orig = cmap_spectral
# current cmap normalization function (default None)
cmap_norm = None
default_fade_low_fidelity_level = 0.16
default_fade_rate = 0.7
# Specify a normalization function here (default None)
def set_custom_cmap_norm(vmin, vmax):
global cmap_norm
if vmin == vmax or (vmin == 0.0 and vmax == 1.0):
print("... setting cmap norm to None")
cmap_norm = None
else:
print(f"... setting cmap norm to [{vmin}, {vmax}]")
cmap_norm = Normalize(vmin=vmin, vmax=vmax)
# Remake the custom spectral colormap with user settings
def set_custom_cmap_style(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
#print("... set custom map style")
global cmap, cmap_custom_spectral, cmap_orig
cmap_custom_spectral = create_custom_spectral_cmap(
fade_low_fidelity_level=fade_low_fidelity_level, fade_rate=fade_rate)
cmap = cmap_custom_spectral
cmap_orig = cmap_custom_spectral
# Create the custom spectral colormap from the base spectral
def create_custom_spectral_cmap(
fade_low_fidelity_level=default_fade_low_fidelity_level,
fade_rate=default_fade_rate):
# determine the breakpoint from the fade level
num_colors = 100
breakpoint = round(fade_low_fidelity_level * num_colors)
# get color list for spectral map
spectral_colors = [cmap_spectral(v/num_colors) for v in range(num_colors)]
#print(fade_rate)
# create a list of colors to replace those below the breakpoint
# and fill with "faded" color entries (in reverse)
low_colors = [0] * breakpoint
#for i in reversed(range(breakpoint)):
for i in range(breakpoint):
# x is index of low colors, normalized 0 -> 1
x = i / breakpoint
# get color at this index
bc = spectral_colors[i]
r0 = bc[0]
g0 = bc[1]
b0 = bc[2]
z0 = bc[3]
r_delta = 0.92 - r0
#print(f"{x} {bc} {r_delta}")
# compute saturation and greyness ratio
sat_ratio = 1 - x
#grey_ratio = 1 - x
''' attempt at a reflective gradient
if i >= breakpoint/2:
xf = 2*(x - 0.5)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (yf + 0.5)
else:
xf = 2*(0.5 - x)
yf = pow(xf, 1/fade_rate)/2
grey_ratio = 1 - (0.5 - yf)
'''
grey_ratio = 1 - math.pow(x, 1/fade_rate)
#print(f" {xf} {yf} ")
#print(f" {sat_ratio} {grey_ratio}")
r = r0 + r_delta * sat_ratio
g_delta = r - g0
b_delta = r - b0
g = g0 + g_delta * grey_ratio
b = b0 + b_delta * grey_ratio
#print(f"{r} {g} {b}\n")
low_colors[i] = (r,g,b,z0)
#print(low_colors)
# combine the faded low colors with the regular spectral cmap to make a custom version
cmap_custom_spectral = ListedColormap(low_colors + spectral_colors[breakpoint:])
#spectral_colors = [cmap_custom_spectral(v/10) for v in range(10)]
#for i in range(10): print(spectral_colors[i])
#print("")
return cmap_custom_spectral
# Make the custom spectral color map the default on module init
set_custom_cmap_style()
# Arrange the stored annotations optimally and add to plot
def anno_volumetric_data(ax, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True):
# sort all arrays by the x point of the text (anno_offs)
global x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos
all_annos = sorted(zip(x_anno_offs, y_anno_offs, anno_labels, x_annos, y_annos))
x_anno_offs = [a for a,b,c,d,e in all_annos]
y_anno_offs = [b for a,b,c,d,e in all_annos]
anno_labels = [c for a,b,c,d,e in all_annos]
x_annos = [d for a,b,c,d,e in all_annos]
y_annos = [e for a,b,c,d,e in all_annos]
#print(f"{x_anno_offs}")
#print(f"{y_anno_offs}")
#print(f"{anno_labels}")
for i in range(len(anno_labels)):
x_anno = x_annos[i]
y_anno = y_annos[i]
x_anno_off = x_anno_offs[i]
y_anno_off = y_anno_offs[i]
label = anno_labels[i]
if i > 0:
x_delta = abs(x_anno_off - x_anno_offs[i - 1])
y_delta = abs(y_anno_off - y_anno_offs[i - 1])
if y_delta < 0.7 and x_delta < 2:
y_anno_off = y_anno_offs[i] = y_anno_offs[i - 1] - 0.6
#x_anno_off = x_anno_offs[i] = x_anno_offs[i - 1] + 0.1
ax.annotate(label,
xy=(x_anno+0.0, y_anno+0.1),
arrowprops=dict(facecolor='black', shrink=0.0,
width=0.5, headwidth=4, headlength=5, edgecolor=(0.8,0.8,0.8)),
xytext=(x_anno_off + labelpos[0], y_anno_off + labelpos[1]),
rotation=labelrot,
horizontalalignment='left', verticalalignment='baseline',
color=(0.2,0.2,0.2),
clip_on=True)
if saveplots == True:
plt.savefig("VolumetricPlotSample.jpg")
# Plot one group of data for volumetric presentation
def plot_volumetric_data(ax, w_data, d_data, f_data, depth_base=2, label='Depth',
labelpos=(0.2, 0.7), labelrot=0, type=1, fill=True, w_max=18, do_label=False, do_border=True,
x_size=1.0, y_size=1.0, zorder=1, offset_flag=False,
max_depth=0, suppress_low_fidelity=False):
# since data may come back out of order, save point at max y for annotation
i_anno = 0
x_anno = 0
y_anno = 0
# plot data rectangles
low_fidelity_count = True
last_y = -1
k = 0
# determine y-axis dimension for one pixel to use for offset of bars that start at 0
(_, dy) = get_pixel_dims(ax)
# do this loop in reverse to handle the case where earlier cells are overlapped by later cells
for i in reversed(range(len(d_data))):
x = depth_index(d_data[i], depth_base)
y = float(w_data[i])
f = f_data[i]
# each time we star a new row, reset the offset counter
# DEVNOTE: this is highly specialized for the QA area plots, where there are 8 bars
# that represent time starting from 0 secs. We offset by one pixel each and center the group
if y != last_y:
last_y = y;
k = 3 # hardcoded for 8 cells, offset by 3
#print(f"{i = } {x = } {y = }")
if max_depth > 0 and d_data[i] > max_depth:
#print(f"... excessive depth (2), skipped; w={y} d={d_data[i]}")
break;
# reject cells with low fidelity
if suppress_low_fidelity and f < suppress_low_fidelity_level:
if low_fidelity_count: break
else: low_fidelity_count = True
# the only time this is False is when doing merged gradation plots
if do_border == True:
# this case is for an array of x_sizes, i.e. each box has different width
if isinstance(x_size, list):
# draw each of the cells, with no offset
if not offset_flag:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size[i], y_size=y_size, zorder=zorder))
# use an offset for y value, AND account for x and width to draw starting at 0
else:
ax.add_patch(box_at((x/2 + x_size[i]/4), y + k*dy, f, type=type, fill=fill, x_size=x+ x_size[i]/2, y_size=y_size, zorder=zorder))
# this case is for only a single cell
else:
ax.add_patch(box_at(x, y, f, type=type, fill=fill, x_size=x_size, y_size=y_size))
# save the annotation point with the largest y value
if y >= y_anno:
x_anno = x
y_anno = y
i_anno = i
# move the next bar down (if using offset)
k -= 1
# if no data rectangles plotted, no need for a label
if x_anno == 0 or y_anno == 0:
return
x_annos.append(x_anno)
y_annos.append(y_anno)
anno_dist = math.sqrt( (y_anno - 1)**2 + (x_anno - 1)**2 )
# adjust radius of annotation circle based on maximum width of apps
anno_max = 10
if w_max > 10:
anno_max = 14
if w_max > 14:
anno_max = 18
scale = anno_max / anno_dist
# offset of text from end of arrow
if scale > 1:
x_anno_off = scale * x_anno - x_anno - 0.5
y_anno_off = scale * y_anno - y_anno
else:
x_anno_off = 0.7
y_anno_off = 0.5
x_anno_off += x_anno
y_anno_off += y_anno
# print(f"... {xx} {yy} {anno_dist}")
x_anno_offs.append(x_anno_off)
y_anno_offs.append(y_anno_off)
anno_labels.append(label)
if do_label:
ax.annotate(label, xy=(x_anno+labelpos[0], y_anno+labelpos[1]), rotation=labelrot,
horizontalalignment='left', verticalalignment='bottom', color=(0.2,0.2,0.2))
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# init arrays to hold annotation points for label spreading
def vplot_anno_init ():
global x_annos, y_annos, x_anno_offs, y_anno_offs, anno_labels
x_annos = []
y_annos = []
x_anno_offs = []
y_anno_offs = []
anno_labels = []
# Number of ticks on volumetric depth axis
max_depth_log = 22
# average transpile factor between base QV depth and our depth based on results from QV notebook
QV_transpile_factor = 12.7
# format a number using K,M,B,T for large numbers, optionally rounding to 'digits' decimal places if num > 1
# (sign handling may be incorrect)
def format_number(num, digits=0):
if isinstance(num, str): num = float(num)
num = float('{:.3g}'.format(abs(num)))
sign = ''
metric = {'T': 1000000000000, 'B': 1000000000, 'M': 1000000, 'K': 1000, '': 1}
for index in metric:
num_check = num / metric[index]
if num_check >= 1:
num = round(num_check, digits)
sign = index
break
numstr = f"{str(num)}"
if '.' in numstr:
numstr = numstr.rstrip('0').rstrip('.')
return f"{numstr}{sign}"
# Return the color associated with the spcific value, using color map norm
def get_color(value):
# if there is a normalize function installed, scale the data
if cmap_norm:
value = float(cmap_norm(value))
if cmap == cmap_spectral:
value = 0.05 + value*0.9
elif cmap == cmap_blues:
value = 0.00 + value*1.0
else:
value = 0.0 + value*0.95
return cmap(value)
# Return the x and y equivalent to a single pixel for the given plot axis
def get_pixel_dims(ax):
# transform 0 -> 1 to pixel dimensions
pixdims = ax.transData.transform([(0,1),(1,0)])-ax.transData.transform((0,0))
xpix = pixdims[1][0]
ypix = pixdims[0][1]
#determine x- and y-axis dimension for one pixel
dx = (1 / xpix)
dy = (1 / ypix)
return (dx, dy)
############### Helper functions
# return the base index for a circuit depth value
# take the log in the depth base, and add 1
def depth_index(d, depth_base):
if depth_base <= 1:
return d
if d == 0:
return 0
return math.log(d, depth_base) + 1
# draw a box at x,y with various attributes
def box_at(x, y, value, type=1, fill=True, x_size=1.0, y_size=1.0, alpha=1.0, zorder=1):
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Rectangle((x - (x_size/2), y - (y_size/2)), x_size, y_size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5*y_size,
zorder=zorder)
# draw a circle at x,y with various attributes
def circle_at(x, y, value, type=1, fill=True):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.5,0.5,0.5)
return Circle((x, y), size/2,
alpha = 0.7, # DEVNOTE: changed to 0.7 from 0.5, to handle only one cell
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.5)
def box4_at(x, y, value, type=1, fill=True, alpha=1.0):
size = 1.0
value = min(value, 1.0)
value = max(value, 0.0)
fc = get_color(value)
ec = (0.3,0.3,0.3)
ec = fc
return Rectangle((x - size/8, y - size/2), size/4, size,
alpha=alpha,
edgecolor = ec,
facecolor = fc,
fill=fill,
lw=0.1)
# Draw a Quantum Volume rectangle with specified width and depth, and grey-scale value
def qv_box_at(x, y, qv_width, qv_depth, value, depth_base):
#print(f"{qv_width} {qv_depth} {depth_index(qv_depth, depth_base)}")
return Rectangle((x - 0.5, y - 0.5), depth_index(qv_depth, depth_base), qv_width,
edgecolor = (value,value,value),
facecolor = (value,value,value),
fill=True,
lw=1)
def bkg_box_at(x, y, value=0.9):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (value,value,value),
fill=True,
lw=0.5)
def bkg_empty_box_at(x, y):
size = 0.6
return Rectangle((x - size/2, y - size/2), size, size,
edgecolor = (.75,.75,.75),
facecolor = (1.0,1.0,1.0),
fill=True,
lw=0.5)
# Plot the background for the volumetric analysis
def plot_volumetric_background(max_qubits=11, QV=32, depth_base=2, suptitle=None, avail_qubits=0, colorbar_label="Avg Result Fidelity"):
if suptitle == None:
suptitle = f"Volumetric Positioning\nCircuit Dimensions and Fidelity Overlaid on Quantum Volume = {QV}"
QV0 = QV
qv_estimate = False
est_str = ""
if QV == 0: # QV = 0 indicates "do not draw QV background or label"
QV = 2048
elif QV < 0: # QV < 0 indicates "add est. to label"
QV = -QV
qv_estimate = True
est_str = " (est.)"
if avail_qubits > 0 and max_qubits > avail_qubits:
max_qubits = avail_qubits
max_width = 13
if max_qubits > 11: max_width = 18
if max_qubits > 14: max_width = 20
if max_qubits > 16: max_width = 24
if max_qubits > 24: max_width = 33
#print(f"... {avail_qubits} {max_qubits} {max_width}")
plot_width = 6.8
plot_height = 0.5 + plot_width * (max_width / max_depth_log)
#print(f"... {plot_width} {plot_height}")
# define matplotlib figure and axis; use constrained layout to fit colorbar to right
fig, ax = plt.subplots(figsize=(plot_width, plot_height), constrained_layout=True)
plt.suptitle(suptitle)
plt.xlim(0, max_depth_log)
plt.ylim(0, max_width)
# circuit depth axis (x axis)
xbasis = [x for x in range(1,max_depth_log)]
xround = [depth_base**(x-1) for x in xbasis]
xlabels = [format_number(x) for x in xround]
ax.set_xlabel('Circuit Depth')
ax.set_xticks(xbasis)
plt.xticks(xbasis, xlabels, color='black', rotation=45, ha='right', va='top', rotation_mode="anchor")
# other label options
#plt.xticks(xbasis, xlabels, color='black', rotation=-60, ha='left')
#plt.xticks(xbasis, xlabels, color='black', rotation=-45, ha='left', va='center', rotation_mode="anchor")
# circuit width axis (y axis)
ybasis = [y for y in range(1,max_width)]
yround = [1,2,3,4,5,6,7,8,10,12,15] # not used now
ylabels = [str(y) for y in yround] # not used now
#ax.set_ylabel('Circuit Width (Number of Qubits)')
ax.set_ylabel('Circuit Width')
ax.set_yticks(ybasis)
#create simple line plot (not used right now)
#ax.plot([0, 10],[0, 10])
log2QV = math.log2(QV)
QV_width = log2QV
QV_depth = log2QV * QV_transpile_factor
# show a quantum volume rectangle of QV = 64 e.g. (6 x 6)
if QV0 != 0:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.87, depth_base))
else:
ax.add_patch(qv_box_at(1, 1, QV_width, QV_depth, 0.91, depth_base))
# the untranspiled version is commented out - we do not show this by default
# also show a quantum volume rectangle un-transpiled
# ax.add_patch(qv_box_at(1, 1, QV_width, QV_width, 0.80, depth_base))
# show 2D array of volumetric cells based on this QV_transpiled
# DEVNOTE: we use +1 only to make the visuals work; s/b without
# Also, the second arg of the min( below seems incorrect, needs correction
maxprod = (QV_width + 1) * (QV_depth + 1)
for w in range(1, min(max_width, round(QV) + 1)):
# don't show VB squares if width greater than known available qubits
if avail_qubits != 0 and w > avail_qubits:
continue
i_success = 0
for d in xround:
# polarization factor for low circuit widths
maxtest = maxprod / ( 1 - 1 / (2**w) )
# if circuit would fail here, don't draw box
if d > maxtest: continue
if w * d > maxtest: continue
# guess for how to capture how hardware decays with width, not entirely correct
# # reduce maxtext by a factor of number of qubits > QV_width
# # just an approximation to account for qubit distances
# if w > QV_width:
# over = w - QV_width
# maxtest = maxtest / (1 + (over/QV_width))
# draw a box at this width and depth
id = depth_index(d, depth_base)
# show vb rectangles; if not showing QV, make all hollow (or less dark)
if QV0 == 0:
#ax.add_patch(bkg_empty_box_at(id, w))
ax.add_patch(bkg_box_at(id, w, 0.95))
else:
ax.add_patch(bkg_box_at(id, w, 0.9))
# save index of last successful depth
i_success += 1
# plot empty rectangle after others
d = xround[i_success]
id = depth_index(d, depth_base)
ax.add_patch(bkg_empty_box_at(id, w))
# Add annotation showing quantum volume
if QV0 != 0:
t = ax.text(max_depth_log - 2.0, 1.5, f"QV{est_str}={QV}", size=12,
horizontalalignment='right', verticalalignment='center', color=(0.2,0.2,0.2),
bbox=dict(boxstyle="square,pad=0.3", fc=(.9,.9,.9), ec="grey", lw=1))
# add colorbar to right of plot
plt.colorbar(cm.ScalarMappable(cmap=cmap), cax=None, ax=ax,
shrink=0.6, label=colorbar_label, panchor=(0.0, 0.7))
return ax
# Function to calculate circuit depth
def calculate_circuit_depth(qc):
# Calculate the depth of the circuit
depth = qc.depth()
return depth
def calculate_transpiled_depth(qc,basis_selector):
# use either the backend or one of the basis gate sets
if basis_selector == 0:
qc = transpile(qc, backend)
else:
basis_gates = basis_gates_array[basis_selector]
qc = transpile(qc, basis_gates=basis_gates, seed_transpiler=0)
transpiled_depth = qc.depth()
return transpiled_depth,qc
def plot_fidelity_data(fidelity_data, Hf_fidelity_data, title):
avg_fidelity_means = []
avg_Hf_fidelity_means = []
avg_num_qubits_values = list(fidelity_data.keys())
# Calculate the average fidelity and Hamming fidelity for each unique number of qubits
for num_qubits in avg_num_qubits_values:
avg_fidelity = np.average(fidelity_data[num_qubits])
avg_fidelity_means.append(avg_fidelity)
avg_Hf_fidelity = np.mean(Hf_fidelity_data[num_qubits])
avg_Hf_fidelity_means.append(avg_Hf_fidelity)
return avg_fidelity_means,avg_Hf_fidelity_means
list_of_gates = []
def list_of_standardgates():
import qiskit.circuit.library as lib
from qiskit.circuit import Gate
import inspect
# List all the attributes of the library module
gate_list = dir(lib)
# Filter out non-gate classes (like functions, variables, etc.)
gates = [gate for gate in gate_list if isinstance(getattr(lib, gate), type) and issubclass(getattr(lib, gate), Gate)]
# Get method names from QuantumCircuit
circuit_methods = inspect.getmembers(QuantumCircuit, inspect.isfunction)
method_names = [name for name, _ in circuit_methods]
# Map gate class names to method names
gate_to_method = {}
for gate in gates:
gate_class = getattr(lib, gate)
class_name = gate_class.__name__.replace('Gate', '').lower() # Normalize class name
for method in method_names:
if method == class_name or method == class_name.replace('cr', 'c-r'):
gate_to_method[gate] = method
break
# Add common operations that are not strictly gates
additional_operations = {
'Measure': 'measure',
'Barrier': 'barrier',
}
gate_to_method.update(additional_operations)
for k,v in gate_to_method.items():
list_of_gates.append(v)
def update_counts(gates,custom_gates):
operations = {}
for key, value in gates.items():
operations[key] = value
for key, value in custom_gates.items():
if key in operations:
operations[key] += value
else:
operations[key] = value
return operations
def get_gate_counts(gates,custom_gate_defs):
result = gates.copy()
# Iterate over the gate counts in the quantum circuit
for gate, count in gates.items():
if gate in custom_gate_defs:
custom_gate_ops = custom_gate_defs[gate]
# Multiply custom gate operations by the count of the custom gate in the circuit
for _ in range(count):
result = update_counts(result, custom_gate_ops)
# Remove the custom gate entry as we have expanded it
del result[gate]
return result
dict_of_qc = dict()
custom_gates_defs = dict()
# Function to count operations recursively
def count_operations(qc):
dict_of_qc.clear()
circuit_traverser(qc)
operations = dict()
operations = dict_of_qc[qc.name]
del dict_of_qc[qc.name]
# print("operations :",operations)
# print("dict_of_qc :",dict_of_qc)
for keys in operations.keys():
if keys not in list_of_gates:
for k,v in dict_of_qc.items():
if k in operations.keys():
custom_gates_defs[k] = v
operations=get_gate_counts(operations,custom_gates_defs)
custom_gates_defs.clear()
return operations
def circuit_traverser(qc):
dict_of_qc[qc.name]=dict(qc.count_ops())
for i in qc.data:
if str(i.operation.name) not in list_of_gates:
qc_1 = i.operation.definition
circuit_traverser(qc_1)
def get_memory():
import resource
usage = resource.getrusage(resource.RUSAGE_SELF)
max_mem = usage.ru_maxrss/1024 #in MB
return max_mem
def analyzer(num_qubits):
# we have precalculated the correct distribution that a perfect quantum computer will return
# it is stored in the json file we import at the top of the code
correct_dist = precalculated_data[f"Qubits - {num_qubits}"]
return correct_dist
num_state_qubits=1 #(default) not exposed to users
def run (min_qubits=min_qubits, max_qubits=max_qubits, skip_qubits=skip_qubits,
max_circuits=max_circuits, num_shots=num_shots, use_XX_YY_ZZ_gates = use_XX_YY_ZZ_gates):
creation_times = []
elapsed_times = []
quantum_times = []
circuit_depths = []
transpiled_depths = []
fidelity_data = {}
Hf_fidelity_data = {}
numckts = []
mem_usage = []
algorithmic_1Q_gate_counts = []
algorithmic_2Q_gate_counts = []
transpiled_1Q_gate_counts = []
transpiled_2Q_gate_counts = []
print(f"{benchmark_name} Benchmark Program - {platform}")
#defining all the standard gates supported by qiskit in a list
if gate_counts_plots == True:
list_of_standardgates()
# validate parameters (smallest circuit is 2 qubits)
max_qubits = max(2, max_qubits)
min_qubits = min(max(2, min_qubits), max_qubits)
if min_qubits % 2 == 1: min_qubits += 1 # min_qubits must be even
skip_qubits = max(1, skip_qubits)
#print(f"min, max qubits = {min_qubits} {max_qubits}")
global _use_XX_YY_ZZ_gates
_use_XX_YY_ZZ_gates = use_XX_YY_ZZ_gates
if _use_XX_YY_ZZ_gates:
print("... using unoptimized XX YY ZZ gates")
global max_ckts
max_ckts = max_circuits
global min_qbits,max_qbits,skp_qubits
min_qbits = min_qubits
max_qbits = max_qubits
skp_qubits = skip_qubits
print(f"min, max qubits = {min_qubits} {max_qubits}")
# Execute Benchmark Program N times for multiple circuit sizes
for num_qubits in range(min_qubits, max_qubits + 1, skip_qubits):
fidelity_data[num_qubits] = []
Hf_fidelity_data[num_qubits] = []
# reset random seed
np.random.seed(0)
# determine number of circuits to execute for this group
num_circuits = max(1, max_circuits)
print(f"Executing [{num_circuits}] circuits with num_qubits = {num_qubits}")
numckts.append(num_circuits)
# parameters of simulation
#### CANNOT BE MODIFIED W/O ALSO MODIFYING PRECALCULATED DATA #########
w = precalculated_data['w'] # strength of disorder
k = precalculated_data['k'] # Trotter error.
# A large Trotter order approximates the Hamiltonian evolution better.
# But a large Trotter order also means the circuit is deeper.
# For ideal or noise-less quantum circuits, k >> 1 gives perfect hamiltonian simulation.
t = precalculated_data['t'] # time of simulation
#######################################################################
for circuit_id in range(num_circuits):
print("*********************************************")
print(f"qc of {num_qubits} qubits for circuit_id: {circuit_id}")
#creation of Quantum Circuit.
ts = time.time()
h_x = precalculated_data['h_x'][:num_qubits] # precalculated random numbers between [-1, 1]
h_z = precalculated_data['h_z'][:num_qubits]
qc = HamiltonianSimulation(num_qubits, K=k, t=t, w=w, h_x= h_x, h_z=h_z)
#creation time
creation_time = time.time() - ts
creation_times.append(creation_time)
print(f"creation time = {creation_time*1000} ms")
# Calculate gate count for the algorithmic circuit (excluding barriers and measurements)
if gate_counts_plots == True:
operations = count_operations(qc)
n1q = 0; n2q = 0
if operations != None:
for key, value in operations.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c") or key.startswith("mc"):
n2q += value
else:
n1q += value
algorithmic_1Q_gate_counts.append(n1q)
algorithmic_2Q_gate_counts.append(n2q)
# collapse the sub-circuit levels used in this benchmark (for qiskit)
qc=qc.decompose()
#print(qc)
# Calculate circuit depth
depth = calculate_circuit_depth(qc)
circuit_depths.append(depth)
# Calculate transpiled circuit depth
transpiled_depth,qc = calculate_transpiled_depth(qc,basis_selector)
transpiled_depths.append(transpiled_depth)
#print(qc)
print(f"Algorithmic Depth = {depth} and Normalized Depth = {transpiled_depth}")
if gate_counts_plots == True:
# Calculate gate count for the transpiled circuit (excluding barriers and measurements)
tr_ops = qc.count_ops()
#print("tr_ops = ",tr_ops)
tr_n1q = 0; tr_n2q = 0
if tr_ops != None:
for key, value in tr_ops.items():
if key == "measure": continue
if key == "barrier": continue
if key.startswith("c"): tr_n2q += value
else: tr_n1q += value
transpiled_1Q_gate_counts.append(tr_n1q)
transpiled_2Q_gate_counts.append(tr_n2q)
print(f"Algorithmic 1Q gates = {n1q} ,Algorithmic 2Q gates = {n2q}")
print(f"Normalized 1Q gates = {tr_n1q} ,Normalized 2Q gates = {tr_n2q}")
#execution
if Type_of_Simulator == "built_in":
#To check if Noise is required
if Noise_Inclusion == True:
noise_model = noise_parameters
else:
noise_model = None
ts = time.time()
job = execute(qc, backend, shots=num_shots, noise_model=noise_model)
elif Type_of_Simulator == "FAKE" or Type_of_Simulator == "FAKEV2" :
ts = time.time()
job = backend.run(qc,shots=num_shots, noise_model=noise_parameters)
#retrieving the result
result = job.result()
#print(result)
#calculating elapsed time
elapsed_time = time.time() - ts
elapsed_times.append(elapsed_time)
# Calculate quantum processing time
quantum_time = result.time_taken
quantum_times.append(quantum_time)
print(f"Elapsed time = {elapsed_time*1000} ms and Quantum Time = {quantum_time*1000} ms")
#counts in result object
counts = result.get_counts()
#Correct distribution to compare with counts
correct_dist = analyzer(num_qubits)
#fidelity calculation comparision of counts and correct_dist
fidelity_dict = polarization_fidelity(counts, correct_dist)
fidelity_data[num_qubits].append(fidelity_dict['fidelity'])
Hf_fidelity_data[num_qubits].append(fidelity_dict['hf_fidelity'])
#maximum memory utilization (if required)
if Memory_utilization_plot == True:
max_mem = get_memory()
print(f"Maximum Memory Utilized: {max_mem} MB")
mem_usage.append(max_mem)
print("*********************************************")
##########
# print a sample circuit
print("Sample Circuit:"); print(QC_ if QC_ != None else " ... too large!")
if _use_XX_YY_ZZ_gates:
print("\nXX, YY, ZZ =")
print(XX_); print(YY_); print(ZZ_)
else:
print("\nXXYYZZ_opt =")
print(XXYYZZ_)
return (creation_times, elapsed_times, quantum_times, circuit_depths, transpiled_depths,
fidelity_data, Hf_fidelity_data, numckts , algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts,
transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage)
# Execute the benchmark program, accumulate metrics, and calculate circuit depths
(creation_times, elapsed_times, quantum_times, circuit_depths,transpiled_depths, fidelity_data, Hf_fidelity_data, numckts,
algorithmic_1Q_gate_counts, algorithmic_2Q_gate_counts, transpiled_1Q_gate_counts, transpiled_2Q_gate_counts,mem_usage) = run()
# Define the range of qubits for the x-axis
num_qubits_range = range(min_qbits, max_qbits+1,skp_qubits)
print("num_qubits_range =",num_qubits_range)
# Calculate average creation time, elapsed time, quantum processing time, and circuit depth for each number of qubits
avg_creation_times = []
avg_elapsed_times = []
avg_quantum_times = []
avg_circuit_depths = []
avg_transpiled_depths = []
avg_1Q_algorithmic_gate_counts = []
avg_2Q_algorithmic_gate_counts = []
avg_1Q_Transpiled_gate_counts = []
avg_2Q_Transpiled_gate_counts = []
max_memory = []
start = 0
for num in numckts:
avg_creation_times.append(np.mean(creation_times[start:start+num]))
avg_elapsed_times.append(np.mean(elapsed_times[start:start+num]))
avg_quantum_times.append(np.mean(quantum_times[start:start+num]))
avg_circuit_depths.append(np.mean(circuit_depths[start:start+num]))
avg_transpiled_depths.append(np.mean(transpiled_depths[start:start+num]))
if gate_counts_plots == True:
avg_1Q_algorithmic_gate_counts.append(int(np.mean(algorithmic_1Q_gate_counts[start:start+num])))
avg_2Q_algorithmic_gate_counts.append(int(np.mean(algorithmic_2Q_gate_counts[start:start+num])))
avg_1Q_Transpiled_gate_counts.append(int(np.mean(transpiled_1Q_gate_counts[start:start+num])))
avg_2Q_Transpiled_gate_counts.append(int(np.mean(transpiled_2Q_gate_counts[start:start+num])))
if Memory_utilization_plot == True:max_memory.append(np.max(mem_usage[start:start+num]))
start += num
# Calculate the fidelity data
avg_f, avg_Hf = plot_fidelity_data(fidelity_data, Hf_fidelity_data, "Fidelity Comparison")
# Plot histograms for average creation time, average elapsed time, average quantum processing time, and average circuit depth versus the number of qubits
# Add labels to the bars
def autolabel(rects,ax,str='{:.3f}',va='top',text_color="black"):
for rect in rects:
height = rect.get_height()
ax.annotate(str.format(height), # Formatting to two decimal places
xy=(rect.get_x() + rect.get_width() / 2, height / 2),
xytext=(0, 0),
textcoords="offset points",
ha='center', va=va,color=text_color,rotation=90)
bar_width = 0.3
# Determine the number of subplots and their arrangement
if Memory_utilization_plot and gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6, ax7) = plt.subplots(7, 1, figsize=(18, 30))
# Plotting for both memory utilization and gate counts
# ax1, ax2, ax3, ax4, ax5, ax6, ax7 are available
elif Memory_utilization_plot:
fig, (ax1, ax2, ax3, ax6, ax7) = plt.subplots(5, 1, figsize=(18, 30))
# Plotting for memory utilization only
# ax1, ax2, ax3, ax6, ax7 are available
elif gate_counts_plots:
fig, (ax1, ax2, ax3, ax4, ax5, ax6) = plt.subplots(6, 1, figsize=(18, 30))
# Plotting for gate counts only
# ax1, ax2, ax3, ax4, ax5, ax6 are available
else:
fig, (ax1, ax2, ax3, ax6) = plt.subplots(4, 1, figsize=(18, 30))
# Default plotting
# ax1, ax2, ax3, ax6 are available
fig.suptitle(f"General Benchmarks : {platform} - {benchmark_name}", fontsize=16)
for i in range(len(avg_creation_times)): #converting seconds to milli seconds by multiplying 1000
avg_creation_times[i] *= 1000
ax1.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax1.bar(num_qubits_range, avg_creation_times, color='deepskyblue')
autolabel(ax1.patches, ax1)
ax1.set_xlabel('Number of Qubits')
ax1.set_ylabel('Average Creation Time (ms)')
ax1.set_title('Average Creation Time vs Number of Qubits',fontsize=14)
ax2.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
for i in range(len(avg_elapsed_times)): #converting seconds to milli seconds by multiplying 1000
avg_elapsed_times[i] *= 1000
for i in range(len(avg_quantum_times)): #converting seconds to milli seconds by multiplying 1000
avg_quantum_times[i] *= 1000
Elapsed= ax2.bar(np.array(num_qubits_range) - bar_width / 2, avg_elapsed_times, width=bar_width, color='cyan', label='Elapsed Time')
Quantum= ax2.bar(np.array(num_qubits_range) + bar_width / 2, avg_quantum_times,width=bar_width, color='deepskyblue',label ='Quantum Time')
autolabel(Elapsed,ax2,str='{:.1f}')
autolabel(Quantum,ax2,str='{:.1f}')
ax2.set_xlabel('Number of Qubits')
ax2.set_ylabel('Average Time (ms)')
ax2.set_title('Average Time vs Number of Qubits')
ax2.legend()
ax3.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized = ax3.bar(np.array(num_qubits_range) - bar_width / 2, avg_transpiled_depths, color='cyan', label='Normalized Depth', width=bar_width) # Adjust width here
Algorithmic = ax3.bar(np.array(num_qubits_range) + bar_width / 2,avg_circuit_depths, color='deepskyblue', label='Algorithmic Depth', width=bar_width) # Adjust width here
autolabel(Normalized,ax3,str='{:.2f}')
autolabel(Algorithmic,ax3,str='{:.2f}')
ax3.set_xlabel('Number of Qubits')
ax3.set_ylabel('Average Circuit Depth')
ax3.set_title('Average Circuit Depth vs Number of Qubits')
ax3.legend()
if gate_counts_plots == True:
ax4.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_1Q_counts = ax4.bar(np.array(num_qubits_range) - bar_width / 2, avg_1Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_1Q_counts = ax4.bar(np.array(num_qubits_range) + bar_width / 2, avg_1Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_1Q_counts,ax4,str='{}')
autolabel(Algorithmic_1Q_counts,ax4,str='{}')
ax4.set_xlabel('Number of Qubits')
ax4.set_ylabel('Average 1-Qubit Gate Counts')
ax4.set_title('Average 1-Qubit Gate Counts vs Number of Qubits')
ax4.legend()
ax5.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Normalized_2Q_counts = ax5.bar(np.array(num_qubits_range) - bar_width / 2, avg_2Q_Transpiled_gate_counts, color='cyan', label='Normalized Gate Counts', width=bar_width) # Adjust width here
Algorithmic_2Q_counts = ax5.bar(np.array(num_qubits_range) + bar_width / 2, avg_2Q_algorithmic_gate_counts, color='deepskyblue', label='Algorithmic Gate Counts', width=bar_width) # Adjust width here
autolabel(Normalized_2Q_counts,ax5,str='{}')
autolabel(Algorithmic_2Q_counts,ax5,str='{}')
ax5.set_xlabel('Number of Qubits')
ax5.set_ylabel('Average 2-Qubit Gate Counts')
ax5.set_title('Average 2-Qubit Gate Counts vs Number of Qubits')
ax5.legend()
ax6.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
Hellinger = ax6.bar(np.array(num_qubits_range) - bar_width / 2, avg_Hf, width=bar_width, label='Hellinger Fidelity',color='cyan') # Adjust width here
Normalized = ax6.bar(np.array(num_qubits_range) + bar_width / 2, avg_f, width=bar_width, label='Normalized Fidelity', color='deepskyblue') # Adjust width here
autolabel(Hellinger,ax6,str='{:.2f}')
autolabel(Normalized,ax6,str='{:.2f}')
ax6.set_xlabel('Number of Qubits')
ax6.set_ylabel('Average Value')
ax6.set_title("Fidelity Comparison")
ax6.legend()
if Memory_utilization_plot == True:
ax7.set_xticks(range(min(num_qubits_range), max(num_qubits_range)+1, skp_qubits))
x = ax7.bar(num_qubits_range, max_memory, color='turquoise', width=bar_width, label="Memory Utilizations")
autolabel(ax7.patches, ax7)
ax7.set_xlabel('Number of Qubits')
ax7.set_ylabel('Maximum Memory Utilized (MB)')
ax7.set_title('Memory Utilized vs Number of Qubits',fontsize=14)
plt.tight_layout(rect=[0, 0, 1, 0.96])
if saveplots == True:
plt.savefig("ParameterPlotsSample.jpg")
plt.show()
# Quantum Volume Plot
Suptitle = f"Volumetric Positioning - {platform}"
appname=benchmark_name
if QV_ == None:
QV=2048
else:
QV=QV_
depth_base =2
ax = plot_volumetric_background(max_qubits=max_qbits, QV=QV,depth_base=depth_base, suptitle=Suptitle, colorbar_label="Avg Result Fidelity")
w_data = num_qubits_range
# determine width for circuit
w_max = 0
for i in range(len(w_data)):
y = float(w_data[i])
w_max = max(w_max, y)
d_tr_data = avg_transpiled_depths
f_data = avg_f
plot_volumetric_data(ax, w_data, d_tr_data, f_data, depth_base, fill=True,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, w_max=w_max)
anno_volumetric_data(ax, depth_base,label=appname, labelpos=(0.4, 0.6), labelrot=15, type=1, fill=False)
|
https://github.com/entropicalabs/OpenQAOA-Challenge---Qiskit-Fall-Fest-2022-Mexico
|
entropicalabs
|
# Methods to use in the notebook
%load_ext autoreload
%autoreload 2
from IPython.display import clear_output
# Libaries to manipulate, print, plot, and save the data.
import matplotlib.pyplot as plt
import numpy as np
# Random generator for the problem
from random import seed,randrange, randint
# OpenQAOA libraries to design, execute the algorithm in different backends and optimisers
from openqaoa.problems.problem import Knapsack
from openqaoa.workflows.optimizer import QAOA
from openqaoa.devices import create_device
from openqaoa.optimizers.qaoa_optimizer import available_optimizers
from openqaoa.utilities import ground_state_hamiltonian
# Import the method to plot the graph
from openqaoa.utilities import plot_graph
np.random.seed(1)
num_items = 3 # number of items
weight_capacity = 10 # max weight of a bin
penalty = 1.0
values = np.random.randint(1, weight_capacity, num_items)
weights = np.random.randint(1, weight_capacity, num_items)
print(values,weights,weight_capacity,penalty)
qubo = Knapsack(values, weights, weight_capacity,penalty).get_qubo_problem()
qubo.asdict()
# In OpenQAOA you can use different devices either local
# or from different cloud backends such as Qiskit, Pyquil.
sim = create_device(location='local', name='vectorized')
# Init the object QAOA and certain of its properties can be modified
q = QAOA()
q.set_device(sim)
q.compile(qubo)
# Execute the quantum algorithm
q.optimize()
print("solution bitstring: ",q.results.most_probable_states['solutions_bitstrings'])
print("ground state: ",ground_state_hamiltonian(q.cost_hamil)[1])
optimisers = available_optimizers()['scipy']+ available_optimizers()['custom_scipy_gradient']
optimisers
jac = ['finite_difference', 'param_shift','grad_spsa', 'stoch_param_shift']
hess = jac[0]
|
https://github.com/Qiskit/feedback
|
Qiskit
|
%matplotlib inline
import numpy as np
from qiskit_experiments.visualization import (
CurvePlotter,
IQPlotter,
MplDrawer,
PlotStyle,
)
from generate_data import generate_data
data = generate_data()
data_keys = set()
for _, x in data.items():
data_keys.update(x.keys())
print(data_keys)
# Create plotter and set options and style.
plotter = CurvePlotter(MplDrawer())
plotter.set_options(
plot_sigma=[
(1.0, 0.5)
], # Controls confidence-intervals for `y_interp_err` data-keys.
)
plotter.set_figure_options(
series_params={
"A": {"symbol": "o", "color": "C0", "label": "Qubit 0"},
"B": {"symbol": "X", "color": "C1", "label": "Qubit 1"},
"C": {"symbol": "v", "color": "k", "label": "Ideal 0"},
"D": {"symbol": "^", "color": "k", "label": "Ideal 1"},
},
xlabel="Parameter",
ylabel="${\\langle{}Z\\rangle{}}$",
figure_title="Expectation Values",
)
plotter.figure()
plotter.set_series_data("A", x=data["A"]["x"], y=data["A"]["y"])
plotter.figure()
plotter.set_series_data(
"A",
x=data["A"]["x"],
y=data["A"]["y"],
x_interp=data["A"]["x_interp"],
y_interp=data["A"]["y_interp"],
y_interp_err=data["A"]["y_interp_err"],
)
plotter.figure()
plotter.set_series_data(
"B",
x=data["B"]["x"],
y=data["B"]["y"],
x_interp=data["B"]["x_interp"],
y_interp=data["B"]["y_interp"],
y_interp_err=data["B"]["y_interp_err"],
)
plotter.figure()
plotter.set_series_data(
"C",
x=data["C"]["x"],
y=data["C"]["y"],
x_interp=data["C"]["x_interp"],
y_interp=data["C"]["y_interp"],
)
plotter.set_series_data(
"D",
x=data["D"]["x"],
y=data["D"]["y"],
x_interp=data["D"]["x_interp"],
y_interp=data["D"]["y_interp"],
)
plotter.set_options(
style=PlotStyle(legend_loc="lower left"),
)
plotter.figure()
plotter.set_options(subplots=(2, 1))
plotter.set_figure_options(
series_params={
"A": {
"symbol": "o",
"color": "C0",
"label": "Qubit 0",
"canvas": 0,
}, # Here we add "canvas"
"B": {
"symbol": "X",
"color": "C1",
"label": "Qubit 1",
"canvas": 1,
}, # entries to the
"C": {
"symbol": "v",
"color": "k",
"label": "Ideal 0",
"canvas": 0,
}, # `series_params` figure
"D": {"symbol": "^", "color": "k", "label": "Ideal 1", "canvas": 1}, # option.
},
)
plotter.figure()
from generate_data import generate_iq_data
iq_data, iq_discriminator = generate_iq_data()
data_keys = set()
for _, x in iq_data.items():
data_keys.update(x.keys())
print(data_keys)
# Create plotter
iq_plotter = IQPlotter(MplDrawer())
# Set options.
iq_plotter.set_options(
style=PlotStyle(
figsize=(6, 4),
legend_loc=None,
textbox_rel_pos=(0.18, -0.30),
),
)
iq_plotter.set_figure_options(
series_params={
"0": {"label": "$|0>$"},
"1": {"label": "$|1>$"},
"2": {"label": "$|2>$"},
},
xlabel="In-Phase",
ylabel="Quad.",
xval_unit="Arb.",
yval_unit="Arb.",
figure_title="Single-Shots",
)
# Set data.
for series, series_data in iq_data.items():
iq_plotter.set_series_data(series, **series_data)
# Generate figure.
iq_plotter.figure()
iq_plotter.set_supplementary_data(discriminator=iq_discriminator)
iq_plotter.figure()
import matplotlib.pyplot as plt
fig, axes = plt.subplots(1, 2, figsize=(10, 6))
plotter.set_options(axis=axes[1])
iq_plotter.set_options(axis=axes[0])
# Generate both figures, which adds graphics to each subplot.
plotter.figure()
iq_plotter.figure()
# Tighten layout
plt.tight_layout()
|
https://github.com/qiskit-community/qiskit-dell-runtime
|
qiskit-community
|
# 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.
# Copyright 2021 Dell (www.dell.com)
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from dell_runtime.emulator_runtime_job import EmulatorRuntimeJob
import unittest
from qiskit import QuantumCircuit, execute, transpile
from dell_runtime import DellRuntimeProvider
from qiskit.providers import JobStatus
from time import sleep
import os
import logging
import json
import requests
from urllib.parse import urljoin
from qiskit.providers.ibmq.runtime.utils import RuntimeDecoder
logger = logging.getLogger(__name__)
RUNTIME_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
user_messenger.publish({'results': 'intermittently'})
circuits = transpile(
circuits,
)
if not isinstance(circuits, list):
circuits = [circuits]
# Compute raw results
result = backend.run(circuits, **kwargs).result()
user_messenger.publish({'results': 'finally'})
user_messenger.publish(result.to_dict(), final=True)
print("job complete successfully")
"""
FAIL_PROGRAM = """
from qiskit.compiler import transpile, schedule
def main(
backend,
user_messenger,
circuits,
**kwargs,
):
raise Exception('test failure')
"""
VQE_PROGRAM = """
from qiskit import Aer
from qiskit.opflow import X, Z, I
from qiskit.utils import QuantumInstance, algorithm_globals
from qiskit.providers.ibmq.runtime.utils import RuntimeEncoder
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
import json
def result_to_jsonstr(res):
resd = {}
resd['eigenvalue'] = res.eigenvalue
resd['opt_time'] = res.optimizer_time
return json.dumps(resd, cls=RuntimeEncoder)
def main(backend, user_messenger, **kwargs):
H2_op = (-1.052373245772859 * I ^ I) + \
(0.39793742484318045 * I ^ Z) + \
(-0.39793742484318045 * Z ^ I) + \
(-0.01128010425623538 * Z ^ Z) + \
(0.18093119978423156 * X ^ X)
# seed = random.randint(0, 1000)
# print(seed)
seed = kwargs['seed']
algorithm_globals.random_seed = seed
qi = QuantumInstance(backend, seed_transpiler=seed, seed_simulator=seed, shots=kwargs['shots'])
ansatz = TwoLocal(rotation_blocks='ry', entanglement_blocks='cz')
slsqp = SLSQP(maxiter=1000)
vqe = VQE(ansatz, optimizer=slsqp, quantum_instance=qi, include_custom=kwargs['include_custom'])
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
result = result_to_jsonstr(result)
user_messenger.publish(result, final=True)
"""
RUNTIME_PROGRAM_METADATA = {
"max_execution_time": 600,
"description": "Qiskit test program"
}
PROGRAM_PREFIX = 'qiskit-test'
SERVER_URL = os.getenv('SERVER_URL')
class AcceptanceTest(unittest.TestCase):
def test_circuit_runner(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
# program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
def test_remote_fail(self):
exc = False
try:
provider = DellRuntimeProvider()
provider.remote("http://thisurldoesntexist.com")
except Exception:
exc = True
self.assertTrue(exc)
def test_upload(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
proglist = provider.runtime.programs()
self.assertIsNotNone(proglist[program_id])
findProgId = False
logger.debug(proglist)
if program_id in proglist:
findProgId = True
self.assertTrue(findProgId)
def test_view_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
runtime_program = provider.runtime.program(program_id)
self.assertEqual(runtime_program.description, "Qiskit test program")
self.assertEqual(runtime_program.program_id, program_id)
def test_view_program_refresh(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
prog_list = provider.runtime.programs(refresh=False)
self.assertTrue(len(prog_list) >= 1)
new_program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
new_prog_list = provider.runtime.programs(refresh=False)
self.assertEqual(len(prog_list), len(new_prog_list))
newnew_prog_list = provider.runtime.programs(refresh=True)
self.assertGreater(len(newnew_prog_list), len(prog_list))
def test_run_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
self.assertEqual(job.host, SERVER_URL)
def test_get_results(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
response = job.result(timeout=180)
logger.debug("through")
# print(json.dumps(results))
# results['results'] = json.loads(results['results'])
results = response['results'][0]
self.assertIsNotNone(results)
self.assertTrue(results['success'])
self.assertTrue(results['success'])
self.assertEqual("DONE", results['status'])
shots = results['shots']
count = results['data']['counts']['0x0']
self.assertGreater(count, (0.45 * shots))
self.assertLess(count, (0.55 * shots))
def test_delete_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
prog_list = provider.runtime.programs(refresh=False)
self.assertTrue(len(prog_list) >= 1)
deleted = provider.runtime.delete_program(program_id)
self.assertTrue(deleted)
new_prog_list = provider.runtime.programs(refresh=True)
self.assertGreater(len(prog_list), len(new_prog_list))
def test_update_program(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
new_meta = {'description': 'Qiskit Test Update', 'max_execution_time': RUNTIME_PROGRAM_METADATA['max_execution_time']}
updated = provider.runtime.update_program(program_id, name='Test Update', metadata=new_meta)
self.assertTrue(updated)
program2 = provider.runtime.program(program_id, refresh=True)
self.assertEqual('Qiskit Test Update', program2.description)
self.assertEqual('Test Update', program2.name)
def test_intermittent_results(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
result = job.result(timeout=120)
messages = job.get_unread_messages()
logger.debug(f'unread messages {messages}')
self.assertEqual(len(messages), 2)
self.assertEqual("intermittently", messages[0]['results'])
self.assertEqual("finally", messages[1]['results'])
messages = job.get_unread_messages()
self.assertEqual(0, len(messages))
def test_get_status(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
status = job.status()
correct_status = status == "Creating" or status == "Pending" or status == "Running"
self.assertTrue(correct_status)
job.result(timeout=120)
status = job.status()
self.assertEqual(status, "Completed")
def test_get_failed_status(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(FAIL_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
status = job.status()
self.assertTrue(status == "Creating" or status == "Pending")
while status == "Running" or status == "Creating" or status == "Pending":
status = job.status()
sleep(5)
self.assertEqual(status, "Failed")
def test_cancel_job(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
# runtime_program = provider.runtime.program(program_id)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
res = job.cancel()
self.assertTrue(res)
status = job.status()
self.assertEqual(status, "Canceled")
def test_pprint_programs(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
pr_id_1 = provider.runtime.upload_program("fake-program1", metadata=RUNTIME_PROGRAM_METADATA)
import sys
import io
old_stdout = sys.stdout
new_stdout = io.StringIO()
sys.stdout = new_stdout
provider.runtime.pprint_programs()
output = new_stdout.getvalue()
sys.stdout = old_stdout
print(output)
self.assertTrue(
'''==================================================
{}:
Name: {}'''.format(pr_id_1,pr_id_1)
in output)
def test_dir_circuit_runner(self):
from . import dir_circuit_runner as dcr
try:
dcr.main()
except Exception as e:
self.fail("should pass")
def test_upload_file(self):
provider = DellRuntimeProvider()
self.assertIsNotNone(provider)
self.assertIsNotNone(provider.runtime)
here = os.path.dirname(os.path.realpath(__file__))
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(here + "/program.py", metadata=RUNTIME_PROGRAM_METADATA)
self.assertGreaterEqual(len(provider.runtime.programs()), 1)
runtime_program = provider.runtime.program(program_id)
self.assertIsNotNone(runtime_program)
try:
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
result = job.result(timeout=90)
self.assertIsNotNone(result)
except Exception:
self.fail("should pass")
def test_reserved_names(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
try:
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/dirfail/", metadata=RUNTIME_PROGRAM_METADATA)
self.fail("Should not allow upload")
except Exception:
self.assertTrue(True)
def test_large_directory(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
here = os.path.dirname(os.path.realpath(__file__))
program_id = provider.runtime.upload_program(here + "/qkad", metadata=RUNTIME_PROGRAM_METADATA)
job = provider.runtime.run(program_id, options=None, inputs={'garbage': 'nonsense'})
res = job.result(timeout=600)
self.assertTrue("aligned_kernel_parameters" in res)
self.assertTrue("aligned_kernel_matrix" in res)
def test_callback_function(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
import sys
import io
old_stdout = sys.stdout
new_stdout = io.StringIO()
sys.stdout = new_stdout
job = provider.runtime.run(program_id, options=None, inputs=program_inputs,callback=print)
result =job.result(timeout=120)
output = new_stdout.getvalue()
sys.stdout = old_stdout
print(output)
self.assertTrue("{'results': 'intermittently'}" in output)
def test_reconnect(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
qc = QuantumCircuit(2, 2)
qc.h(0)
qc.cx(0, 1)
qc.measure([0, 1], [0, 1])
program_inputs = {
'circuits': qc,
}
del(provider)
# delete session and sign back in via SSO
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
job = provider.runtime.run(program_id, options=None, inputs=program_inputs)
response = job.result(timeout=120)
logger.debug("through")
results = response['results'][0]
self.assertIsNotNone(results)
self.assertTrue(results['success'])
self.assertTrue(results['success'])
self.assertEqual("DONE", results['status'])
shots = results['shots']
count = results['data']['counts']['0x0']
self.assertGreater(count, (0.45 * shots))
self.assertLess(count, (0.55 * shots))
def test_data_security(self):
provider = DellRuntimeProvider()
provider.remote(SERVER_URL)
program_id = provider.runtime.upload_program(RUNTIME_PROGRAM, metadata=RUNTIME_PROGRAM_METADATA)
url = urljoin(SERVER_URL, f'/program/{program_id}/data')
res = requests.get(url)
self.assertEqual(res.text, "Id and token not presented")
self.assertEqual(res.status_code, 401)
def test_block_nonsso_on_sso_server(self):
res = requests.get(urljoin(SERVER_URL, '/sso_enabled'))
sso_enabled = json.loads(res.text)
if sso_enabled:
url = urljoin(SERVER_URL, '/new_user')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/existing_user/2187121124')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
def test_block_sso_on_nonsso_server(self):
res = requests.get(urljoin(SERVER_URL, '/sso_enabled'))
sso_enabled = json.loads(res.text)
if not sso_enabled:
url = urljoin(SERVER_URL, '/login')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/authenticate')
res = requests.post(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/tokeninfo/109129612')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
url = urljoin(SERVER_URL, '/callback')
res = requests.get(url)
self.assertEqual(res.status_code, 401)
def test_vqe_emulation(self):
vqe_inputs = {
'shots': 2,
'seed': 10,
'include_custom': True
}
provider = DellRuntimeProvider()
provider.remote(os.getenv("SERVER_URL"))
program_id = provider.runtime.upload_program(VQE_PROGRAM)
job = provider.runtime.run(
program_id=program_id,
inputs=vqe_inputs,
options=None)
# result = job.result()
result = job.result(timeout=100)
result = json.loads(job.result(), cls=RuntimeDecoder)
self.assertEqual(-1.8572748921516753, result['eigenvalue'])
self.assertLessEqual(result['opt_time'], 0.4)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test the EnlargeWithAncilla pass"""
import unittest
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.transpiler import Layout
from qiskit.transpiler.passes import EnlargeWithAncilla
from qiskit.converters import circuit_to_dag
from qiskit.test import QiskitTestCase
class TestEnlargeWithAncilla(QiskitTestCase):
"""Tests the EnlargeWithAncilla pass."""
def setUp(self):
super().setUp()
self.qr3 = QuantumRegister(3, "qr")
circuit = QuantumCircuit(self.qr3)
circuit.h(self.qr3)
self.dag = circuit_to_dag(circuit)
def test_no_extension(self):
"""There are no virtual qubits to extend."""
layout = Layout({self.qr3[0]: 0, self.qr3[1]: 1, self.qr3[2]: 2})
pass_ = EnlargeWithAncilla()
pass_.property_set["layout"] = layout
after = pass_.run(self.dag)
qregs = list(after.qregs.values())
self.assertEqual(1, len(qregs))
self.assertEqual(self.qr3, qregs[0])
def test_with_extension(self):
"""There are 2 virtual qubit to extend."""
ancilla = QuantumRegister(2, "ancilla")
layout = Layout(
{0: self.qr3[0], 1: ancilla[0], 2: self.qr3[1], 3: ancilla[1], 4: self.qr3[2]}
)
layout.add_register(ancilla)
pass_ = EnlargeWithAncilla()
pass_.property_set["layout"] = layout
after = pass_.run(self.dag)
qregs = list(after.qregs.values())
self.assertEqual(2, len(qregs))
self.assertEqual(self.qr3, qregs[0])
self.assertEqual(ancilla, qregs[1])
if __name__ == "__main__":
unittest.main()
|
https://github.com/ashishpatel26/IBM-Quantum-Challenge-Fall-2021
|
ashishpatel26
|
#Let us begin by importing necessary libraries.
from qiskit import Aer
from qiskit.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import *
from qiskit.circuit.library import TwoLocal
from qiskit.utils import QuantumInstance
from qiskit.utils import algorithm_globals
from qiskit_finance import QiskitFinanceError
from qiskit_finance.applications.optimization import PortfolioOptimization
from qiskit_finance.data_providers import *
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.applications import OptimizationApplication
from qiskit_optimization.converters import QuadraticProgramToQubo
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import datetime
import warnings
from sympy.utilities.exceptions import SymPyDeprecationWarning
warnings.simplefilter("ignore", SymPyDeprecationWarning)
### Set parameters for assets and risk factor ###
num_assets = 4 # Number of assets to n = 4
q = 0.5 # Risk factor to q= 0.5
budget = 2 # set budget as defined in the problem (2 stands for budget)
seed = 132 #set random seed (point´s clarity)
### Generate time series data ###
stocks = [ ("STOCK%s" % i) for i in range(num_assets)]
data = RandomDataProvider(tickers=stocks,
start=datetime.datetime(1955,11,5),
end=datetime.datetime(1985,10,26),
seed=seed)
data.run()
# Stocks
stocks
data._tickers
### Let's plot our finanical data ###
for (cnt, s) in enumerate(data._tickers):
plt.plot(data._data[cnt], label=s)
plt.legend()
plt.xticks(rotation=90)
plt.xlabel('days')
plt.ylabel('stock value')
plt.show()
### Let's calculate the expected return for our problem data ###
# Returns a vector containing the mean value of each asset's expected return.
mu = data.get_period_return_mean_vector()
print(mu)
### Let's plot our covariance matrix Σ（sigma）###
sigma = data.get_period_return_covariance_matrix() #Returns the covariance matrix of the four assets
print(sigma)
fig, ax = plt.subplots(1,1)
im = plt.imshow(sigma, extent=[-1,1,-1,1])
x_label_list = ['stock3', 'stock2', 'stock1', 'stock0']
y_label_list = ['stock3', 'stock2', 'stock1', 'stock0']
ax.set_xticks([-0.75,-0.25,0.25,0.75])
ax.set_yticks([0.75,0.25,-0.25,-0.75])
ax.set_xticklabels(x_label_list)
ax.set_yticklabels(y_label_list)
plt.colorbar()
plt.clim(-0.000002, 0.00001)
plt.show()
##############################
### Provide your code here ###
from qiskit_finance.applications.optimization import PortfolioOptimization
mu = data.get_period_return_mean_vector() # Expected Return
sigma = data.get_period_return_covariance_matrix() # Covariance
q = 0.5 # Risk factor to q= 0.5
budget = 2 # set budget as defined in the problem (2 stands for budget)
portfolio_ = PortfolioOptimization(expected_returns=mu,
covariances=sigma,
risk_factor=q,budget=budget)
# Transform Portfolio into Quadratic Program
qp = portfolio_.to_quadratic_program()
##############################
print(qp)
# Check your answer and submit using the following code
from qc_grader import grade_ex1a
grade_ex1a(qp)
exact_mes = NumPyMinimumEigensolver()
exact_eigensolver = MinimumEigenOptimizer(exact_mes)
result = exact_eigensolver.solve(qp)
print(result)
optimizer = SLSQP(maxiter=1000)
algorithm_globals.random_seed = 1234
backend = Aer.get_backend('statevector_simulator')
##############################
# Provide your code here
from qiskit.algorithms import VQE
vqe = VQE(optimizer=optimizer, quantum_instance=backend)
##############################
vqe_meo = MinimumEigenOptimizer(vqe) #please do not change this code
result = vqe_meo.solve(qp) #please do not change this code
print(result) #please do not change this code
# Check your answer and submit using the following code
from qc_grader import grade_ex1b
grade_ex1b(vqe, qp)
#Step 1: Let us begin by importing necessary libraries
import qiskit
from qiskit import Aer
from qiskit.algorithms import VQE, QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import *
from qiskit.circuit.library import TwoLocal
from qiskit.utils import QuantumInstance
from qiskit.utils import algorithm_globals
from qiskit_finance import QiskitFinanceError
from qiskit_finance.applications.optimization import *
from qiskit_finance.data_providers import *
from qiskit_optimization.algorithms import MinimumEigenOptimizer
from qiskit_optimization.applications import OptimizationApplication
from qiskit_optimization.converters import QuadraticProgramToQubo
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
import datetime
import warnings
from sympy.utilities.exceptions import SymPyDeprecationWarning
warnings.simplefilter("ignore",SymPyDeprecationWarning)
# Step 2. Generate time series data for four assets.
# Do not change start/end dates specified to generate problem data.
seed = 132
num_assets = 4
stocks = [("STOCK%s" % i) for i in range(num_assets)]
data = RandomDataProvider(tickers=stocks,
start=datetime.datetime(1955,11,5),
end=datetime.datetime(1985,10,26),
seed=seed)
data.run()
# Let's plot our finanical data (We are generating the same time series data as in the previous example.)
for (cnt, s) in enumerate(data._tickers):
plt.plot(data._data[cnt], label=s)
plt.legend()
plt.xticks(rotation=90)
plt.xlabel('days')
plt.ylabel('stock value')
plt.show()
# Step 3. Calculate mu and sigma for this problem
mu2 = data.get_period_return_mean_vector() #Returns a vector containing the mean value of each asset.
sigma2 = data.get_period_return_covariance_matrix() #Returns the covariance matrix associated with the assets.
print(mu2, sigma2)
# Step 4. Set parameters and constraints based on this challenge 1c
##############################
# Provide your code here
q2 = 0.5 #Set risk factor to 0.5
budget2 = 3 #Set budget to 3
##############################
# Step 5. Complete code to generate the portfolio instance
##############################
# Provide your code here
#The bounds must be a list of tuples of integers.
portfolio2 = PortfolioOptimization(expected_returns=mu2,
covariances=sigma2,
risk_factor=q2,budget=budget2,
bounds = [(0,2), (0,2), (0,2), (0,2)]
)
qp2 = portfolio2.to_quadratic_program()
##############################
# Step 6. Now let's use QAOA to solve this problem.
optimizer = SLSQP(maxiter=1000)
algorithm_globals.random_seed = 1234
backend = Aer.get_backend('statevector_simulator')
##############################
# Provide your code here
qaoa = QAOA(optimizer =optimizer, reps=3, quantum_instance=backend)
##############################
qaoa_meo = MinimumEigenOptimizer(qaoa) #please do not change this code
result2 = qaoa_meo.solve(qp2) #please do not change this code
print(result2) #please do not change this code
# Check your answer and submit using the following code
from qc_grader import grade_ex1c
grade_ex1c(qaoa, qp2)
|
https://github.com/benkoehlL/Qiskit_Playground
|
benkoehlL
|
'''
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/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import matplotlib.pyplot as plt
from docplex.mp.model import Model
from qiskit.algorithms.minimum_eigensolvers import QAOA, NumPyMinimumEigensolver
from qiskit.algorithms.optimizers import COBYLA
from qiskit.primitives import Sampler
from qiskit_optimization.algorithms import CobylaOptimizer, MinimumEigenOptimizer
from qiskit_optimization.algorithms.admm_optimizer import ADMMParameters, ADMMOptimizer
from qiskit_optimization.translators import from_docplex_mp
# If CPLEX is installed, you can uncomment this line to import the CplexOptimizer.
# CPLEX can be used in this tutorial to solve the convex continuous problem,
# but also as a reference to solve the QUBO, or even the full problem.
#
# from qiskit.optimization.algorithms import CplexOptimizer
# define COBYLA optimizer to handle convex continuous problems.
cobyla = CobylaOptimizer()
# define QAOA via the minimum eigen optimizer
qaoa = MinimumEigenOptimizer(QAOA(sampler=Sampler(), optimizer=COBYLA()))
# exact QUBO solver as classical benchmark
exact = MinimumEigenOptimizer(NumPyMinimumEigensolver()) # to solve QUBOs
# in case CPLEX is installed it can also be used for the convex problems, the QUBO,
# or as a benchmark for the full problem.
#
# cplex = CplexOptimizer()
# construct model using docplex
mdl = Model("ex6")
v = mdl.binary_var(name="v")
w = mdl.binary_var(name="w")
t = mdl.binary_var(name="t")
u = mdl.continuous_var(name="u")
mdl.minimize(v + w + t + 5 * (u - 2) ** 2)
mdl.add_constraint(v + 2 * w + t + u <= 3, "cons1")
mdl.add_constraint(v + w + t >= 1, "cons2")
mdl.add_constraint(v + w == 1, "cons3")
# load quadratic program from docplex model
qp = from_docplex_mp(mdl)
print(qp.prettyprint())
admm_params = ADMMParameters(
rho_initial=1001, beta=1000, factor_c=900, maxiter=100, three_block=True, tol=1.0e-6
)
# define QUBO optimizer
qubo_optimizer = exact
# qubo_optimizer = cplex # uncomment to use CPLEX instead
# define classical optimizer
convex_optimizer = cobyla
# convex_optimizer = cplex # uncomment to use CPLEX instead
# initialize ADMM with classical QUBO and convex optimizer
admm = ADMMOptimizer(
params=admm_params, qubo_optimizer=qubo_optimizer, continuous_optimizer=convex_optimizer
)
# run ADMM to solve problem
result = admm.solve(qp)
print(result.prettyprint())
plt.plot(result.state.residuals)
plt.xlabel("Iterations")
plt.ylabel("Residuals")
plt.show()
# define QUBO optimizer
qubo_optimizer = qaoa
# define classical optimizer
convex_optimizer = cobyla
# convex_optimizer = cplex # uncomment to use CPLEX instead
# initialize ADMM with quantum QUBO optimizer and classical convex optimizer
admm_q = ADMMOptimizer(
params=admm_params, qubo_optimizer=qubo_optimizer, continuous_optimizer=convex_optimizer
)
# run ADMM to solve problem
result_q = admm_q.solve(qp)
print(result.prettyprint())
plt.clf()
plt.plot(result_q.state.residuals)
plt.xlabel("Iterations")
plt.ylabel("Residuals")
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2 * dt, 0)
qc.rz(2 * dt, 1)
qc.h(1)
qc.cx(1, 0)
qc.rz(-2 * dt, 0)
qc.rx(-2 * dt, 1)
qc.rz(2 * dt, 1)
qc.cx(1, 0)
qc.h(1)
qc.rz(2 * dt, 0)
return qc.to_instruction() if to_instruction else qc
dt = Parameter('(-2t/n)')
trotter_gate(dt, to_instruction=False).draw("mpl")
dt = Parameter('2t/n')
mdt = Parameter('-2t/n')
qc = QuantumCircuit(2)
qc.rx(dt, 0)
qc.rz(dt, 1)
qc.h(1)
qc.cx(1, 0)
qc.rz(mdt, 0)
qc.rx(mdt, 1)
qc.rz(dt, 1)
qc.cx(1, 0)
qc.h(1)
qc.rz(dt, 0)
qc.draw("mpl")
dt = Parameter('2t/n')
mdt = Parameter('-2t/n')
qc = QuantumCircuit(2)
qc.h(1)
qc.cx(1, 0)
qc.rz(mdt, 0)
qc.rx(mdt, 1)
qc.rz(dt, 1)
qc.cx(1, 0)
qc.h(1)
qc.rx(dt, 1)
qc.draw("mpl")
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
def make_initial_state(qc, initial_state):
"""
logical qubit index
little endian
"""
for i, state in enumerate(initial_state):
if state == "1":
qc.x(i)
qc = QuantumCircuit(3)
make_initial_state(qc, "110")
qc.draw("mpl")
def subspace_encoder(qc, targets):
"""
naive method, can be optimized for init state |110>
little endian
"""
n = qc.num_qubits
qc.cx(targets[2],targets[1])
qc.cx(targets[1],targets[0])
def subspace_encoder_init110(qc, targets):
"""
optimized encoder for init state |110>
endian: |q_0, q_1, q_2> (little endian)
encode |110> to |0>|10>
"""
n = qc.num_qubits
qc.x(targets[0])
def subspace_decoder(qc, targets):
"""
naive method
little endian
"""
n = qc.num_qubits
qc.cx(targets[1], targets[0])
qc.cx(targets[2], targets[1])
qc = QuantumCircuit(3)
make_initial_state(qc, "110")
subspace_encoder_init110(qc, targets=[0,1,2])
qc.draw("mpl")
def trotterize(qc, trot_gate, num_steps, targets):
for _ in range(num_steps):
qc.append(trot_gate, qargs = targets)
qc = QuantumCircuit(3)
make_initial_state(qc, "110")
subspace_encoder_init110(qc, targets=[0,1,2])
qc.barrier()
trotterize(qc, trotter_gate(np.pi / 6), 1, targets=[1, 2])
qc = transpile(qc, optimization_level = 3, basis_gates=["sx", "rz", "cx"])
qc.draw("mpl")
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
st_qcs_list = []
# Number of trotter steps
max_trotter_step = 50 ### CAN BE >= 4
trotter_steps = list(range(1, max_trotter_step + 1, 3))
for num_steps in trotter_steps:
print("trotter step: ", num_steps)
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="lq")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder(qc, targets=[0,1,2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time / num_steps})
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
st_qcs_list.append(t3_st_qcs)
st_qcs_list[-1][-1].draw("mpl")
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
# print("provider:", provider)
# backend = provider.get_backend("ibmq_jakarta")
jobs = []
shots = 1 << 13
# Number of trotter steps
for i, num_steps in enumerate(trotter_steps):
print("trotter step: ", num_steps)
# execute: reps = 1
job = execute(st_qcs_list[i], backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
print()
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
cal_results = cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
results = []
for job in jobs:
results.append( job.result() )
mit_results = []
for job in jobs:
mit_results.append( meas_fitter.filter.apply(job.result()) )
print(len(results), len(mit_results))
# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits
def state_tomo(result, st_qcs):
# The expected final state; necessary to determine state tomography fidelity
target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Fit state tomography results
tomo_fitter = StateTomographyFitter(result, st_qcs)
rho_fit = tomo_fitter.fit(method='lstsq')
# Compute fidelity
fid = state_fidelity(rho_fit, target_state)
return fid
# Compute tomography fidelities for each repetition
raw_fids = []
for result in results:
fid = state_tomo(result, st_qcs)
raw_fids.append(fid)
# print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
# Compute tomography fidelities for each repetition
fids = []
for result in mit_results:
fid = state_tomo(result, st_qcs)
fids.append(fid)
# print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
plt.clf()
plt.style.use('ggplot')
plt.figure(dpi=200)
plt.title("state fidelity from Trotter step 1 to "+str(trotter_steps))
plt.plot(trotter_steps, raw_fids, label="raw fidelity")
plt.plot(trotter_steps, fids, label="fidelity after QREM")
plt.xlabel("number of trotter steps")
plt.ylabel("fidelity")
plt.grid(linestyle='dotted')
for step, fid in zip(trotter_steps, raw_fids):
print(step, fid)
for step, fid in zip(trotter_steps, fids):
print(step, fid)
|
https://github.com/kaelynj/Qiskit-IsingModel
|
kaelynj
|
%reset -f
#%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, QuantumRegister
from qiskit.providers.aer import QasmSimulator, StatevectorSimulator, UnitarySimulator
from qiskit.compiler import transpile, assemble
from qiskit.tools.monitor import job_monitor
import matplotlib.pyplot as plt
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.quantum_info import *
import numpy as np
provider = IBMQ.load_account()
# Loading your IBM Q account(s)
#provider = IBMQ.load_account()
#constants
n = 4
lambd = 1.2
def thetak(k,lamb):
num = lamb - np.cos(2*np.pi*k/n)
denom = np.sqrt( (lamb-np.cos(2*np.pi*k/n))**2 + np.sin(2*np.pi*k/n)**2)
theta = np.arccos(num/denom)
return theta
#Create functions based on the decomposition included in appendix of Ising paper
def bog(qcirc, q1, q2, theta):
qcirc.x(q2)
qcirc.cx(q2, q1)
#Controlled RX gate
qcirc.rz(np.pi/2, q2)
qcirc.ry(theta/2, q2)
qcirc.cx(q1, q2)
qcirc.ry(-theta/2, q2)
qcirc.cx(q1, q2) #changed from qc to qcirc here - Bruna
qcirc.rz(-np.pi/2, q2)
#####################
qcirc.cx(q2, q1)
qcirc.x(q2)
qcirc.barrier()
return qcirc
def fourier(qcirc, q1, q2, phase):
qcirc.rz(phase, q1)
qcirc.cx(q1, q2)
#Controlled Hadamard
qcirc.sdg(q1)
qcirc.h(q1)
qcirc.tdg(q1)
qcirc.cx(q2, q1)
qcirc.t(q1)
qcirc.h(q1)
qcirc.s(q1)
####################
qcirc.cx(q1, q2)
qcirc.cz(q1, q2)
qcirc.barrier()
return qcirc
def digit_sum(n):
num_str = str(n)
sum = 0
for i in range(0, len(num_str)):
sum += int(num_str[i])
return sum
def ground_state(lamb, backend_name): # backend is now an imput, so we can plot
# different ones easily - Bruna
qc = QuantumCircuit(4, 4)
#Set correct ground state if lambda < 1
if lamb < 1:
qc.x(3)
qc.barrier()
#magnetization
mag = []
#Apply disentangling gates
qc = bog(qc, 0, 1, thetak(1.,lamb))
qc = fourier(qc, 0, 1, 2*np.pi/n)
qc = fourier(qc, 2, 3, 0.)
qc = fourier(qc, 0, 1, 0.)
qc = fourier(qc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
qc.measure(i,i)
backend = Aer.get_backend(backend_name)
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
##while not '0000' in counts:
# job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
# job_monitor(job)
# result = job.result()
# counts = result.get_counts(qc)
#Check what ground state is based on lambda
r1=list(counts.keys())
r2=list(counts.values())
M=0
for j in range(0,len(r1)):
M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots
#print("$\lambda$: ",lam,", $<\sigma_{z}>$: ",M/4)
mag.append(M/4)
return mag
# if lamb < 1:
# return counts['0001']
# return counts['0000']/shots # it does not always works, sometimes it returns keyword error
# maybe we can add another else for the possibility of other states, but
# do not use it for plotting - Bruna
print(ground_state(lambd, 'qasm_simulator'))
#print(ground_state(.8,'statevector_simulator'))
lmbd = np.arange(.2, 1.75, 0.1)
sigmaz = []
for l in lmbd:
sigmaz.append(ground_state(l, 'qasm_simulator'))
print(sigmaz)
plt.plot(lmbd, sigmaz,'bo')
plt.ylabel("$\sigma_z$")
plt.xlabel("$\lambda$")
plt.ylim(0., 1.1)
plt.xlim(0., 1.8)
#Start up and initialize circuit
#Measurement
qc = QuantumCircuit(4, 4)
#Set correct ground state if lambda < 1
if lambd < 1:
qc.x(3)
qc.barrier()
#Apply disentangling gates
qc = bog(qc, 0, 1, thetak(1.,1.2))
qc = fourier(qc, 0, 1, 2*np.pi/n)
qc = fourier(qc, 2, 3, 0.)
qc = fourier(qc, 0, 1, 0.)
qc = fourier(qc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
qc.measure(i,i)
#Choose provider and backend
#provider = IBMQ.get_provider()
#provider = AerProvider()
#backend = Aer.get_backend('statevector_simulator')
backend = Aer.get_backend('qasm_simulator')
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = provider.get_backend('ibmqx4')
#backend = provider.get_backend('ibmqx2')
#backend = provider.get_backend('ibmq_16_melbourne')
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(qc)
#print(counts['0000'])
plot_histogram(counts)
# had to comment this part because qc is a local variable in groundstate function now - Bruna
phi = np.arccos(lambd/np.sqrt(1+lambd**2))/2
#print(result.get_statevector(qc))
print("|0000> probability should be: ",np.cos(phi)**2)
print("|0011> probability should be: ",np.sin(phi)**2 )
#print(counts['0000'])
def Time_Evo(t, lamb, backend_name):
quc = QuantumCircuit(4, 4)
#step 1. we are already in the |111> state
# time evolution of computational basis, step 2
quc.u3(np.arccos(lamb/np.sqrt(1+lamb**2)), np.pi/2 + 4*t*np.sqrt(1+lamb**2),0,0)
quc.cx(0,1)
#magnetization
mag = []
#step 3
#Apply disentangling gates
quc = bog(quc, 0, 1, thetak(1.,lamb))
quc = fourier(quc, 0, 1, 2*np.pi/n)
quc = fourier(quc, 2, 3, 0.)
quc = fourier(quc, 0, 1, 0.)
quc = fourier(quc, 2, 3, 0.)
#Set measurement step
for i in range(0,4):
quc.measure(i,i)
#provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main')
backend = provider.get_backend(backend_name)
#backend = Aer.get_backend('statevector_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = provider.get_backend('ibmqx4')
#backend = provider.get_backend('ibmqx2')
#backend = provider.get_backend('ibmq_16_melbourne')
shots = 1024
max_credits = 10 #Max number of credits to spend on execution
job = execute(quc, backend=backend, shots=shots, max_credits=max_credits)
job_monitor(job)
result = job.result()
counts = result.get_counts(quc)
##while not '0000' in counts:
# job = execute(qc, backend=backend, shots=shots, max_credits=max_credits)
# job_monitor(job)
# result = job.result()
# counts = result.get_counts(qc)
#Check what ground state is based on lambda
r1=list(counts.keys())
r2=list(counts.values())
M=0
for j in range(0,len(r1)):
M=M+(4-2*digit_sum(r1[j]))*r2[j]/shots
#print("$\lambda$: ",lam,", $<\sigma_{z}>$: ",M/4)
mag.append(M/4)
return mag
#f = Time_Evo(qc,1,lambd,'qasm_simulator')
#print(f)
#
ti = 0
tf = 2
time = np.arange(ti,tf,(tf-ti)/10)
f = []
for t in time:
f.append(Time_Evo(t,0.5,'ibmq_athens'))
#step 4
plt.plot(time, f)
plt.ylim(0., 1)
plt.xlim(0., 1.8)
plt.ylabel("Magnetization")
plt.xlabel("t")
plt.show()
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
import math
import numpy as np
from scipy import linalg
import matplotlib.pyplot as plt
# swap is 2x2 matrix
swap = np.array([[0, 1], [1, 0]], dtype=complex)
# Hadamard coin
c_Hadamard = (1/math.sqrt(2))*np.array([[1, 1], [1, -1]], dtype=complex)
# Balanced coin (not used)
c_bal = (1/math.sqrt(2))*np.array([[1, 1j], [1j, 1]], dtype=complex)
# step with swap and coin
s_coin = c_Hadamard.dot(swap)
# Number of nodes (should be odd)
n_nodes = 15
# Step 1 includes swap and coin for first partition
Step1 = np.identity(n_nodes, dtype=complex)
for i in range(0,n_nodes-1,2):
for i1 in range(0,2):
for i2 in range(0,2):
Step1[i+i1,i+i2] = s_coin[i1,i2]
# Step 2 includes swap for second partition
Step2 = np.identity(n_nodes, dtype=complex)
for i in range(1,n_nodes,2):
for i1 in range(0,2):
for i2 in range(0,2):
Step2[i+i1,i+i2] = swap[i1,i2]
# Vector with chain nodes
ch = np.zeros(n_nodes, dtype=complex)
# Initial distribution for symmetric walk with Hadamard coin
# two central nodes
n_pos = n_nodes//2
ch[n_pos] = 1/math.sqrt(2)
ch[n_pos+1] = 1j/math.sqrt(2)
# Alternative initial distribution also could be used
#ch[0] = 1
# Probability from complex amplitude
def abs2(x):
return x.real**2 + x.imag**2
# Vector with probabilities
ch2 = np.zeros(n_nodes, dtype = float)
# Number of steps
n_step=12
for i in range(0,n_step):
if i > 0: # step = 0 doing nothing, only draw
if i%2 == 1 :
ch = Step1.dot(ch) # odd steps 1 3 5 ...
else:
ch = Step2.dot(ch) # even steps 2 4 6 ...
ch2 = abs2(ch) # calculate probabilities
print(ch2)
if i%2 == 0 : # plot for even steps 0 2 4 ...
plt.plot(ch2)
plt.show()
|
https://github.com/Cortexelus/qubit-audio-synthesis
|
Cortexelus
|
import numpy as np
pi = np.pi
import matplotlib.pyplot as plt
import librosa
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ, ClassicalRegister, QuantumRegister
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
from qiskit.quantum_info import Pauli, state_fidelity, basis_state, process_fidelity
from qiskit.providers.aer import StatevectorSimulator
import soundfile as sf
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Construct quantum circuit
sr = 44100 # sample rate of audio
f = 90 # frequency
n = int(np.ceil(sr/f)) # number of samples in wavetable
print(n)
qclist = []
for i in range(n):
# for evey sample
qc = QuantumCircuit(1,1)
# phase clock
qc.h(0)
qc.ry(i/n * 2*pi,0)
# begin "creative" section..
# make an arbitrary quantum circuit here
qc.rz(3.6 * i/n * 9*pi,0)
qc.rx(7 * i/n * 0.9*pi,0)
qc.s(0)
# ..end "creative" section
# the output is the amplitude of the statevector
# todo: collapse to classical register when running on real computer
qclist.append(qc)
# Select the StatevectorSimulator from the Aer provider
simulator = Aer.get_backend('statevector_simulator')
# Execute and get counts
result = execute(qclist, simulator).result()
# convert statevector results into a list of magnitudes
wavetable = []
for i in range(n):
sv = result.get_statevector(qclist[i])
mag = np.power(np.abs(sv),2)
assert mag[0]+mag[1]-1 < 1e-9
wavetable.append(mag[0])
plt.plot(wavetable)
## add noise to the waveform
## by simulating multiple shots
## you could also achieve this by collapsing the output qubit statevector to a classical register
## which you need to do if you're running it on a real quantum computer
shots = 10
wavetable_r = []
for i in range(len(wavetable)):
mag = wavetable[i]
r = np.random.binomial(shots,mag,1)/shots
wavetable_r.append(r)
plt.plot(wavetable_r)
# repeat the waveform to fill an audio file
# use the clean one
# w = wavetable
# use the noisy one
w = wavetable_r
ylen = 5 # the output wave file is __ seconds long
ysamps = ylen * sr # the length of the output wave file in samples
yreps = int(np.ceil(ysamps / len(w))) # how many repeats of the waveform
w = np.tile(np.squeeze(np.array(w)), yreps)
print(yreps, w.shape)
w = w[:ysamps] # trim
#print(w.shape)
plt.plot(w)
plt.show()
# normalize
w -= 0.5
w /= np.max(np.abs(w))
print(w.shape)
# write to wave
sf.write('quantum_test.wav', w, 44100, 'PCM_24')
|
https://github.com/1chooo/Quantum-Oracle
|
1chooo
|
#Program 7.1 Show Bloch sphere for computational basis and Fourier basis
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.quantum_info import Statevector
print('='*60,'\nBelow are computational bases:')
cb = QuantumRegister(2,'computational_basis')
qc1 = QuantumCircuit(cb)
qc1.x(1)
display(qc1.draw('mpl'))
state1 = Statevector.from_instruction(qc1)
display(state1.draw('bloch'))
print('='*60,'\nBelow are Fourier bases:')
fb = QuantumRegister(2,'fourier_basis')
qc2 = QuantumCircuit(fb)
qc2.x(1)
qc2.h([0,1])
display(qc2.draw('mpl'))
state2 = Statevector.from_instruction(qc2)
display(state2.draw('bloch'))
#Program 7.2 Build 2-qubit QFT quantum circuit
from qiskit import QuantumRegister, QuantumCircuit
from math import pi
ar = QuantumRegister(2,'a')
qc = QuantumCircuit(ar)
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0,1)
print('Below is the quantum Fourier transform (QFT) circuit:')
display(qc.draw('mpl'))
#Program 7.3 Apply QFT to qubit with various initial state
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import array_to_latex
from math import pi
two_bits = ['00','01','10','11']
for bits in two_bits:
ar = QuantumRegister(2,'a')
qc = QuantumCircuit(ar)
qc.initialize(bits,ar)
state1 = Statevector.from_instruction(qc)
print('='*75,'\nBelow is for qubits: q0 =',bits[0],'; q1 =',bits[1])
display(array_to_latex(state1, prefix='\\text{Statevector before QFT: }'))
display(state1.draw('bloch'))
qc.h(1)
qc.cp(pi/2, 0, 1)
qc.h(0)
qc.swap(0,1)
state2 = Statevector.from_instruction(qc)
#print('Below is the state after QFT')
display(array_to_latex(state2, prefix='\\text{Statevector after QFT: }'))
display(state2.draw('bloch'))
#Program 7.4 Define funciton to build n-qubit QFT quantum circuit
from qiskit import QuantumRegister, QuantumCircuit
from math import pi
def qft(n):
ar = QuantumRegister(n,'a')
qc = QuantumCircuit(ar)
for hbit in range(n-1,-1,-1):
qc.h(hbit)
for cbit in range(hbit):
qc.cp(pi/2**(hbit-cbit), cbit, hbit)
for bit in range(n//2):
qc.swap(bit,n-bit-1)
return qc
for i in range(1,5):
print('Below is the QFT circuit of',i,'qubit(s):')
display(qft(i).draw('mpl'))
#Program 7.5 Define function to build n-qubit IQFT quantum circuit
from qiskit import QuantumRegister, QuantumCircuit
from math import pi
def iqft(n):
br = QuantumRegister(n,'b')
qc = QuantumCircuit(br)
for sbit in range(n//2): #sbit: for swap qubit
qc.swap(sbit,n-sbit-1)
for hbit in range(0,n,1): #hbit: for h-gate qubit
for cbit in range(hbit-1,-1,-1): #cbit: for count qubit
qc.cp(-pi/2**(hbit-cbit), cbit, hbit)
qc.h(hbit)
# qc.name = "IQFT"
return qc
for i in range(1,5):
print('Below is the IQFT circuit of',i,'qubit(s):')
display(iqft(i).draw('mpl'))
#Program 7.6 Apply QFT and then IQFT to qubit
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(4)
qc.initialize('1011',range(4))
state0 = Statevector.from_instruction(qc)
qc.append(qft(4).to_gate(label='QFT'),range(4))
state1 = Statevector.from_instruction(qc)
qc.append(iqft(4).to_gate(label='IQFT'),range(4))
state2 = Statevector.from_instruction(qc)
display(qc.draw('mpl'))
print('Statevector before QFT:')
display(state0.draw('bloch'))
print('Statevector after QFT:')
display(state1.draw('bloch'))
print('Statevector after IQFT:')
display(state2.draw('bloch'))
#Program 7.7 Use QPE to estimate phase of S-gate
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister, execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
from math import pi
count_no = 2 #the number of count qubits
countreg = QuantumRegister(count_no,'count')
psireg = QuantumRegister(1,'psi')
creg = ClassicalRegister(count_no,'c')
qc = QuantumCircuit(countreg,psireg,creg)
for countbit in range(count_no):
qc.h(countbit)
qc.x(psireg)
repeat = 1
for countbit in range(count_no):
for r in range(repeat):
qc.cp(pi/2,countbit,psireg)
repeat *= 2
qc.barrier()
for sbit in range(count_no//2): #sbit: for swap qubit
qc.swap(sbit,count_no-sbit-1)
for hbit in range(0,count_no,1): #hbit: for h-gate qubit
for cbit in range(hbit-1,-1,-1): #cbit: for count qubit
qc.cp(-pi/2**(hbit-cbit), cbit, hbit)
qc.h(hbit)
qc.barrier()
qc.measure(range(count_no),range(count_no))
display(qc.draw('mpl'))
sim = AerSimulator()
job=execute(qc, backend=sim, shots=1000)
result = job.result()
counts = result.get_counts(qc)
print("Total counts for qubit states are:",counts)
plot_histogram(counts)
#Program 7.8 Classical Shor Algorithm
from random import randint
from math import gcd
def period_finding(a,N):
for r in range(1,N):
if (a**r) % N == 1:
return r
def shor_alg(N):
while True:
a=randint(2,N-1)
g=gcd(a,N)
if g!=1:
p=g
q=N//g
return p,q
else:
r=period_finding(a,N)
if r % 2 != 0:
continue
elif a**(r//2) % N == -1 % N:
continue
else:
p=gcd(a**(r//2)+1,N)
if p==1 or p==N:
p=gcd(a**(r//2)-1,N)
q=N//p
return p,q
for N in [15, 21, 35, 913, 2257, 10999]:
print(f'Factors of {N}: {shor_alg(N)}')
#Program 7.9 Define function to build modular exponentiation quantum circuit
from qiskit import QuantumRegister, QuantumCircuit
def qc_mod15(a, power, show=False):
assert a in [2,4,7,8,11,13], 'Invalid value of argument a:'+str(a)
qrt = QuantumRegister(4,'target')
U = QuantumCircuit(qrt)
for i in range(power):
if a in [2,13]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
if a in [7,8]:
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
if a in [4, 11]:
U.swap(1,3)
U.swap(0,2)
if a in [7,11,13]:
for j in range(4):
U.x(j)
if show:
print('Below is the circuit of U of '+f'"{a}^{power} mod 15":')
display(U.draw('mpl'))
U = U.to_gate()
U.name = f'{a}^{power} mod 15'
C_U = U.control()
return C_U
power_arg=2
for a_arg in [2,4,7,8,11,13]:
qrc = QuantumRegister(1,'control')
qrt = QuantumRegister(4,'target')
qc = QuantumCircuit(qrc,qrt)
qc.append(qc_mod15(a_arg, power_arg, show=True),[0,1,2,3,4])
print('Below is the circuit of controlled U of '+f'"{a_arg}^{power_arg} mod 15":')
display(qc.draw('mpl'))
#Program 7.10: Define quantum period finding function with N=15
from qiskit import QuantumRegister,ClassicalRegister,QuantumCircuit
def qpf15(count_no,a):
qrc = QuantumRegister(count_no,'count')
qry = QuantumRegister(4,'y') #for input of qc_mod15 gate
clr = ClassicalRegister(count_no,'c')
qc = QuantumCircuit(qrc, qry, clr)
for cbit in range(count_no):
qc.h(cbit)
qc.x(qry[0]) #Set the input of qc_mod15 as |1> with y0 as LSB
for cbit in range(count_no): #Add controlled-qc_mod15 gates
qc.append(qc_mod15(a, 2**cbit), [cbit] + list(range(count_no, count_no+4)))
qc.append(iqft(count_no).to_gate(label='IQFT'), range(count_no))
qc.measure(range(count_no), range(count_no))
return qc
display(qpf15(count_no=3,a=13).draw('mpl'))
#Program 7.11 Run quantum period finding function with N=15
from qiskit import execute
from qiskit.providers.aer import AerSimulator
from qiskit.visualization import plot_histogram
from fractions import Fraction
sim = AerSimulator()
count_no=3
cir = qpf15(count_no=count_no,a=13)
job=execute(cir, backend=sim, shots=1000)
result = job.result()
counts = result.get_counts(cir)
display(plot_histogram(counts))
print('Total counts for qubit states are:',counts,'\n')
print('%10s %10s %10s %10s %10s' % ('Binary','Decimal','Phase','Fraction','Period'))
for akey in counts.keys():
dec=int(akey,base=2)
phase=dec/(2**count_no)
frac=Fraction(phase).limit_denominator(15)
period=frac.denominator
print('%10s %10d %10f %10s %10d' % (akey,dec,phase,frac,period))
|
https://github.com/hrahman12/IBM-Variational-Algorithm-Design-Challenge
|
hrahman12
|
answers = [2,3]
from qc_grader.challenges.algorithm_design import grade_problem_4
grade_problem_4(answers)
|
https://github.com/Heisenbug-s-Dog/qnn_visualization
|
Heisenbug-s-Dog
|
# OpenMP: number of parallel threads.
%env OMP_NUM_THREADS=1
# Plotting
%matplotlib inline
import matplotlib.pyplot as plt
# PyTorch
import torch
import torch.nn as nn
import torch.optim as optim
from torch.optim import lr_scheduler
import torchvision
from torchvision import datasets, models, transforms
# Pennylane
import pennylane as qml
from pennylane import numpy as np
# Other tools
import time
import copy
filtered_classes = ['cat', 'dog'] # Subset of CIFAR ('plane', 'car', 'bird', 'cat','deer', 'dog', 'frog', 'horse', 'ship', 'truck')
n_qubits = 4 # Number of qubits
# An enterily classical net (defined by the next parameter).
classical_model = '512_nq_n' # Possible choices: '512_n','512_nq_n','551_512_n'. [nq=n_qubits, n=num_filtered_classes]
step = 0.001 # Learning rate
batch_size = 256 # Number of samples for each training step
num_epochs = 3 # Number of training epochs
q_depth = 5 # Depth of the quantum circuit (number of variational layers)
gamma_lr_scheduler = 1 # Learning rate reduction applied every 10 epochs.
max_layers = 15 # Keep 15 even if not all are used.
q_delta = 0.01 # Initial spread of random quantum weights
rng_seed = 0 # Seed for random number generator
start_time = time.time() # start of the computation timer
torch.manual_seed(rng_seed)
dev = qml.device('default.qubit', wires=n_qubits)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
#device = torch.device("cpu")
def H_layer(nqubits):
"""Layer of single-qubit Hadamard gates.
"""
for idx in range(nqubits):
qml.Hadamard(wires=idx)
def RY_layer(w):
"""Layer of parametrized qubit rotations around the y axis.
"""
for idx, element in enumerate(w):
qml.RY(element, wires=idx)
def entangling_layer(nqubits):
"""Layer of CNOTs followed by another shifted layer of CNOT.
"""
# In other words it should apply something like :
# CNOT CNOT CNOT CNOT... CNOT
# CNOT CNOT CNOT... CNOT
for i in range(0, nqubits - 1, 2): # Loop over even indices: i=0,2,...N-2
qml.CNOT(wires=[i, i + 1])
for i in range(1, nqubits - 1,2): # Loop over odd indices: i=1,3,...N-3
qml.CNOT(wires=[i, i + 1])
@qml.qnode(dev, interface='torch')
def q_net(q_in, q_weights_flat):
# Reshape weights
q_weights = q_weights_flat.reshape(max_layers, n_qubits)
# Start from state |+> , unbiased w.r.t. |0> and |1>
H_layer(n_qubits)
# Embed features in the quantum node
RY_layer(q_in)
# Sequence of trainable variational layers
for k in range(q_depth):
entangling_layer(n_qubits)
RY_layer(q_weights[k+1])
# Expectation values in the Z basis
return [qml.expval(qml.PauliZ(j)) for j in range(n_qubits)]
class Quantumnet(nn.Module):
def __init__(self):
super().__init__()
self.pre_net = nn.Linear(512, n_qubits)
self.q_params = nn.Parameter(q_delta * torch.randn(max_layers * n_qubits))
self.post_net = nn.Linear(n_qubits, len(filtered_classes))
def forward(self, input_features):
pre_out = self.pre_net(input_features)
q_in = torch.tanh(pre_out) * np.pi / 2.0
# Apply the quantum circuit to each element of the batch, and append to q_out
q_out = torch.Tensor(0, n_qubits)
q_out = q_out.to(device)
for elem in q_in:
q_out_elem = q_net(elem,self.q_params).float().unsqueeze(0)
q_out = torch.cat((q_out, q_out_elem))
return self.post_net(q_out)
class Quantumnet_Cut(nn.Module):
def __init__(self):
super().__init__()
self.pre_net = nn.Linear(512, n_qubits)
self.q_params = nn.Parameter(q_delta * torch.randn(max_layers * n_qubits))
def forward(self, input_features):
pre_out = self.pre_net(input_features)
q_in = torch.tanh(pre_out) * np.pi / 2.0
# Apply the quantum circuit to each element of the batch, and append to q_out
q_out = torch.Tensor(0, n_qubits)
q_out = q_out.to(device)
for elem in q_in:
q_out_elem = q_net(elem,self.q_params).float().unsqueeze(0)
q_out = torch.cat((q_out, q_out_elem))
return q_out
class Quantumnet_Classical_Cut(nn.Module):
def __init__(self):
super().__init__()
self.pre_net = nn.Linear(512, n_qubits)
self.q_params = nn.Parameter(q_delta * torch.randn(max_layers * n_qubits))
def forward(self, input_features):
pre_out = self.pre_net(input_features)
q_in = torch.tanh(pre_out) * np.pi / 2.0
return q_in
# Build Hybrid Model
model_hybrid = torchvision.models.resnet18(pretrained=True)
for param in model_hybrid.parameters():
param.requires_grad = False
model_hybrid.fc = Quantumnet()
# Use CUDA or CPU according to the "device" object.
model_hybrid = model_hybrid.to(device)
model_classical_cut = torchvision.models.resnet18(pretrained=True)
model_classical_cut.fc = Quantumnet_Classical_Cut()
for param in model_classical_cut.parameters():
param.requires_grad = False
# Use CUDA or CPU according to the "device" object.
model_classical_cut = model_classical_cut.to(device)
model_cut = torchvision.models.resnet18(pretrained=True)
model_cut.fc = Quantumnet_Cut()
for param in model_cut.parameters():
param.requires_grad = False
# Use CUDA or CPU according to the "device" object.
model_cut = model_cut.to(device)
# Load model from file
path = './'
model_hybrid.load_state_dict(torch.load(path+'quantum_' + filtered_classes[0] + '_' + filtered_classes[1] + '.pt'))
model_dict = model_hybrid.state_dict()
model_cut_dict = model_cut.state_dict()
model_cut_dict = {k: v for k, v in model_dict.items() if k in model_cut_dict}
model_cut.load_state_dict(model_cut_dict)
model_classical_cut_dict = model_classical_cut.state_dict()
model_classical_cut_dict = {k: v for k, v in model_dict.items() if k in model_classical_cut_dict}
model_classical_cut.load_state_dict(model_classical_cut_dict)
# Fixed pre-processing operations
data_transforms = {
'train': transforms.Compose([
#transforms.RandomResizedCrop(224), # uncomment for data augmentation
#transforms.RandomHorizontalFlip(), # uncomment for data augmentation
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
# Normalize input channels using mean values and standard deviations of ImageNet.
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
'val': transforms.Compose([
transforms.Resize(256),
transforms.CenterCrop(224),
transforms.ToTensor(),
transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])
]),
}
# =================== begin CIFAR dataset loading ===================
trainset_full = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=data_transforms['train'])
testset_full = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=data_transforms['val'])
image_datasets_full={'train': trainset_full, 'val': testset_full}
# CIFAR classes
class_names = ('plane', 'car', 'bird', 'cat',
'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# Get indices of samples associated to filtered_classes
filtered_labels=[class_names.index(cl) for cl in filtered_classes]
sub_indices={'train': [], 'val': []}
for phase in ['train', 'val']:
for idx, label in enumerate(image_datasets_full[phase].targets):
if label in filtered_labels:
sub_indices[phase].append(idx)
# Initialize sub-datasets according to filtered indices
image_datasets = {x: torch.utils.data.Subset(image_datasets_full[x], sub_indices[x])
for x in ['train', 'val']}
def labels_to_filtered(labels):
"""Maps CIFAR labels (0,1,2,3,4,5,6,7,8,9) to the index of filtered_labels"""
return [filtered_labels.index(label) for label in labels]
# =================== end CIFAR dataset loading ==========================
# Number of samples
dataset_sizes = {x: len(image_datasets[x]) for x in ['train', 'val']}
# Initialize dataloader
dataloaders = {x: torch.utils.data.DataLoader(image_datasets[x],
batch_size=batch_size, shuffle=True, num_workers=0) for x in ['train', 'val']}
# Function to plot images from tensors
def imshow(inp, title=None):
"""Imshow for Tensor."""
inp = inp.numpy().transpose((1, 2, 0))
# We apply the inverse of the initial normalization operation.
mean = np.array([0.485, 0.456, 0.406])
std = np.array([0.229, 0.224, 0.225])
inp = std * inp + mean
inp = np.clip(inp, 0, 1)
plt.imshow(inp)
if title is not None:
plt.title(title)
# Get a batch of training data
X, y_cifar = next(iter(dataloaders['val']))
y = torch.tensor(labels_to_filtered(y_cifar))
X, y = X.to(device), y.to(device)
# Slice Models
network = model_hybrid
layers = list(network.children())
hybrid_feats = []
for i in range(9):
model_sliced = nn.Sequential(*layers[: i]) #Max: 9
hybrid_feats.append(torch.flatten(model_sliced(X), 1, 3).detach().cpu().numpy())
hybrid_feats.append(model_classical_cut(X).detach().cpu().numpy())
hybrid_feats.append(model_cut(X).detach().cpu().numpy())
import umap.umap_ as umap
def normalize_layout(layout, min_percentile=1, max_percentile=99, relative_margin=0.1):
"""Removes outliers and scales layout to between [0,1]."""
# compute percentiles
mins = np.percentile(layout, min_percentile, axis=(0))
maxs = np.percentile(layout, max_percentile, axis=(0))
# add margins
mins -= relative_margin * (maxs - mins)
maxs += relative_margin * (maxs - mins)
# `clip` broadcasts, `[None]`s added only for readability
clipped = np.clip(layout, mins, maxs)
# embed within [0,1] along both axes
clipped -= clipped.min(axis=0)
clipped /= clipped.max(axis=0)
return clipped
layout = umap.UMAP(n_components=2, verbose=True, n_neighbors=20, min_dist=0.01, metric="cosine").fit_transform(result)
## You can optionally use TSNE as well
# layout = TSNE(n_components=2, verbose=True, metric="cosine", learning_rate=10, perplexity=50).fit_transform(d)
layout = normalize_layout(layout)
plt.figure(figsize=(10, 10))
plt.scatter(x=layout[:,0],y=layout[:,1], s=2)
plt.savefig('quantum_activation_result.png')
def whiten(full_activations):
correl = np.matmul(full_activations.T, full_activations) / len(full_activations)
correl = correl.astype("float32")
S = np.linalg.inv(correl)
S = S.astype("float32")
return S
S = whiten(result)
plt.imshow(S, cmap='gray')
plt.savefig('quantum_activation_whitening.png')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import math
from qiskit import pulse
from qiskit.providers.fake_provider import FakeOpenPulse3Q
# TODO: This example should use a real mock backend.
backend = FakeOpenPulse3Q()
d2 = pulse.DriveChannel(2)
with pulse.build(backend) as bell_prep:
pulse.u2(0, math.pi, 0)
pulse.cx(0, 1)
with pulse.build(backend) as decoupled_bell_prep_and_measure:
# We call our bell state preparation schedule constructed above.
with pulse.align_right():
pulse.call(bell_prep)
pulse.play(pulse.Constant(bell_prep.duration, 0.02), d2)
pulse.barrier(0, 1, 2)
registers = pulse.measure_all()
decoupled_bell_prep_and_measure.draw()
|
https://github.com/MonitSharma/Learn-Quantum-Machine-Learning
|
MonitSharma
|
import pennylane as qml
import jax
from jax import numpy as np
jax.config.update("jax_platform_name", "cpu")
dev = qml.device('default.qubit', wires=2)
x = np.array([0.1, 0.2, 0.3])
@qml.qnode(dev, diff_method="adjoint")
def circuit(a):
qml.RX(a[0], wires=0)
qml.CNOT(wires=(0,1))
qml.RY(a[1], wires=1)
qml.RZ(a[2], wires=1)
return qml.expval(qml.PauliX(wires=1))
n_gates = 4
n_params = 3
ops = [
qml.RX(x[0], wires=0),
qml.CNOT(wires=(0,1)),
qml.RY(x[1], wires=1),
qml.RZ(x[2], wires=1)
]
M = qml.PauliX(wires=1)
from pennylane.devices.qubit import create_initial_state, apply_operation
state = create_initial_state((0, 1))
for op in ops:
state = apply_operation(op, state)
print(state)
bra = apply_operation(M, state)
ket = state
M_expval = np.vdot(bra, ket)
print("vdot : ", M_expval)
print("QNode : ", circuit(x))
bra_n = create_initial_state((0, 1))
for op in ops:
bra_n = apply_operation(op, bra_n)
bra_n = apply_operation(M, bra_n)
bra_n = apply_operation(qml.adjoint(ops[-1]), bra_n)
ket_n = create_initial_state((0, 1))
for op in ops[:-1]: # don't apply last operation
ket_n = apply_operation(op, ket_n)
M_expval_n = np.vdot(bra_n, ket_n)
print(M_expval_n)
bra_n_v2 = apply_operation(M, state)
ket_n_v2 = state
adj_op = qml.adjoint(ops[-1])
bra_n_v2 = apply_operation(adj_op, bra_n_v2)
ket_n_v2 = apply_operation(adj_op, ket_n_v2)
M_expval_n_v2 = np.vdot(bra_n_v2, ket_n_v2)
print(M_expval_n_v2)
bra_loop = apply_operation(M, state)
ket_loop = state
for op in reversed(ops):
adj_op = qml.adjoint(op)
bra_loop = apply_operation(adj_op, bra_loop)
ket_loop = apply_operation(adj_op, ket_loop)
print(np.vdot(bra_loop, ket_loop))
grad_op0 = qml.operation.operation_derivative(ops[0])
print(grad_op0)
bra = apply_operation(M, state)
ket = state
grads = []
for op in reversed(ops):
adj_op = qml.adjoint(op)
ket = apply_operation(adj_op, ket)
# Calculating the derivative
if op.num_params != 0:
dU = qml.operation.operation_derivative(op)
ket_temp = apply_operation(qml.QubitUnitary(dU, op.wires), ket)
dM = 2 * np.real(np.vdot(bra, ket_temp))
grads.append(dM)
bra = apply_operation(adj_op, bra)
# Finally reverse the order of the gradients
# since we calculated them in reverse
grads = grads[::-1]
print("our calculation: ", [float(grad) for grad in grads])
grad_compare = jax.grad(circuit)(x)
print("comparison: ", grad_compare)
dev_lightning = qml.device('lightning.qubit', wires=2)
@qml.qnode(dev_lightning, diff_method="adjoint")
def circuit_adjoint(a):
qml.RX(a[0], wires=0)
qml.CNOT(wires=(0,1))
qml.RY(a[1], wires=1)
qml.RZ(a[2], wires=1)
return qml.expval(M)
print(jax.grad(circuit_adjoint)(x))
|
https://github.com/Harcipan/QAI_GroverSim
|
Harcipan
|
# Importing standard Qiskit libraries
from qiskit import QuantumCircuit, transpile
from qiskit_ibm_provider import IBMProvider
import qiskit_ibm_provider.jupyter
#provider = IBMProvider('ibm-q')
#backend = provider.get_backend('ibmq_vigo')
from qiskit.visualization import *
from ibm_quantum_widgets import *
# qiskit-ibmq-provider has been deprecated.
# Please see the Migration Guides in https://ibm.biz/provider_migration_guide for more detail.
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Estimator, Session, Options
# Loading your IBM Quantum account(s)
service = QiskitRuntimeService(channel="ibm_quantum")
# Invoke a primitive. For more details see https://qiskit.org/documentation/partners/qiskit_ibm_runtime/tutorials.html
# result = Sampler("ibmq_qasm_simulator").run(circuits).result()# Built-in modules
import math
# Imports from Qiskit
from qiskit import QuantumCircuit
from qiskit.circuit.library import GroverOperator, MCMT, ZGate
from qiskit.visualization import plot_distribution
# Imports from Qiskit Runtime
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Session
from qiskit.providers.basic_provider import BasicProvider
from qiskit.visualization import plot_histogram
from qiskit import transpile
from qiskit.providers.fake_provider import GenericBackendV2
def grover_oracle(marked_states, i, j, k):
if not isinstance(marked_states, list):
marked_states = [marked_states]
num_qubits = len(marked_states[0])
qc = QuantumCircuit(num_qubits)
for target in marked_states:
rev_target = target[::-1]
zero_inds = [ind for ind in range(num_qubits) if rev_target.startswith("0", ind)]
qc.x(zero_inds)
"""ZAJ 1"""
qc.rx(0.1*i,zero_inds)
qc.ry(0.1*j,zero_inds)
qc.rz(0.1*k,zero_inds)
qc.compose(MCMT(ZGate(), num_qubits - 1, 1), inplace=True)
qc.x(zero_inds)
return qc
marked_states = ["011", "100"]
printToConsole = False
for i in range(0,10):
for j in range(0,10):
for k in range(0,10):
oracle = grover_oracle(marked_states, i, j, k)
grover_op = GroverOperator(oracle)
optimal_num_iterations = math.floor(
math.pi / 4 * math.sqrt(2**grover_op.num_qubits / len(marked_states))
)
qc = QuantumCircuit(grover_op.num_qubits)
# Create even superposition of all basis states
qc.h(range(grover_op.num_qubits))
# Apply Grover operator the optimal number of times
qc.compose(grover_op.power(optimal_num_iterations), inplace=True)
"""ZAJ 2"""
#qc.x(range(grover_op.num_qubits))
# Measure all qubits
qc.measure_all()
#qc.draw('mpl')
grover_op.decompose().draw("mpl")
backend = GenericBackendV2(num_qubits=5)
transpiled_circuit = transpile(qc, backend)
job = backend.run(transpiled_circuit)
counts = job.result().get_counts()
# Format counts data
formatted_output = ""
for state in ['000', '001', '010', '011', '100', '101', '110', '111']:
formatted_output += f"{counts.get(state, 0)} "
# Write counts data to a text file
with open('counts_data.txt', 'a') as file:
file.write(formatted_output + "\n")
"""# Write counts data to a text file
with open('counts_data.txt', 'a') as file:
file.write(f"i={i}j={j}k={k}")
file.write("State,Count\n")
for state, count in counts.items():
file.write(f"{state},{count}\n")
if(printToConsole):
# Print counts data
print(counts)
print("State,Count\n")
for state, count in counts.items():
print(f"{state},{count}\n")
#plot_histogram(counts)"""
print("All done")
|
https://github.com/mnp-club/Quantum_Computing_Workshop_2020
|
mnp-club
|
%matplotlib inline
# Importing standard Qiskit libraries
import random
from qiskit import execute, Aer, IBMQ
from qiskit.tools.jupyter import *
from qiskit.visualization import *
#Get the library to check the answers
%pip install -I git+https://github.com/mnp-club/MnP_QC_Workshop.git
from mnp_qc_workshop_2020.bb84 import *
# Configuring account
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_qasm_simulator') # with this simulator it wouldn't work \
# Initial setup
random.seed(64) # do not change this seed, otherwise you will get a different key
# This is your 'random' bit string that determines your bases
numqubits = 16
bob_bases = str('{0:016b}'.format(random.getrandbits(numqubits)))
def bb84():
print('Bob\'s bases:', bob_bases)
# Now Alice will send her bits one by one...
all_qubit_circuits = []
for qubit_index in range(numqubits):
# This is Alice creating the qubit
thisqubit_circuit = alice_prepare_qubit(qubit_index)
# This is Bob finishing the protocol below
bob_measure_qubit(bob_bases, qubit_index, thisqubit_circuit)
# We collect all these circuits and put them in an array
all_qubit_circuits.append(thisqubit_circuit)
# Now execute all the circuits for each qubit
results = execute(all_qubit_circuits, backend=backend, shots=1).result()
# And combine the results
bits = ''
for qubit_index in range(numqubits):
bits += [measurement for measurement in results.get_counts(qubit_index)][0]
return bits
# Here is your task
def bob_measure_qubit(bob_bases, qubit_index, qubit_circuit):
if(bob_bases[qubit_index] == '1'):
qubit_circuit.h(0)#Just change basis to +,- and then measure
qubit_circuit.measure(0,0)
bits = bb84()
print('Bob\'s bits: ', bits)
check_bits(bits)
alice_bases = '0100000101011100' # Alice's bases bits
key = ''
for i in range(16):
if alice_bases[i]==bob_bases[i]:
key = key + bits[i]#The key is only added to for the case where the bases are the same
print(key)
check_key(key)
message = get_message()# encrypted message
decrypted = ''
for i in range(344):
if key[i%8] == '1':
if message[i] == '0':
m = '1'
else:
m = '0'
decrypted = decrypted + m
else:
decrypted = decrypted + message[i]
#The key is sort of applied like a mask over each of the 43 8 bit sequences
#of the 344 bitstring and its just a xor operation here
print(decrypted)
check_decrypted(decrypted)
decrypted_to_string_ASCII = ''
for i in range(43):
decrypted_to_string_ASCII += str(chr(int(decrypted[(i*8):(i*8)+8],2)))#sequentially taking the 8 bit sequences
print(decrypted_to_string_ASCII)
check_message(decrypted_to_string_ASCII)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import BasicAer, transpile, QuantumRegister, ClassicalRegister, QuantumCircuit
qr = QuantumRegister(1)
cr = ClassicalRegister(1)
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.measure(0, 0)
qc.draw('mpl')
|
https://github.com/Qiskit/qiskit-neko
|
Qiskit
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022, 2024.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test ground state solvers."""
import unittest
from qiskit_algorithms import NumPyMinimumEigensolver, VQE
from qiskit_algorithms.optimizers import SLSQP
from qiskit.primitives import Estimator
import qiskit_nature
from qiskit_nature.second_q.algorithms import GroundStateEigensolver
from qiskit_nature.second_q.circuit.library import HartreeFock, UCCSD
from qiskit_nature.second_q.drivers import PySCFDriver
from qiskit_nature.second_q.mappers import JordanWignerMapper
from qiskit_neko.tests import base
from qiskit_neko import decorators
class TestGroundStateSolvers(base.BaseTestCase):
"""Test the use of the execute() method in qiskit-terra."""
@unittest.skipIf(
tuple(map(int, qiskit_nature.__version__.split(".")[:2])) < (0, 7),
"This test is incompatible with qiskit_nature versions below 0.7.0",
)
@decorators.component_attr("terra", "backend", "nature", "algorithms")
def test_ground_state_solver(self):
"""Test the execution of a bell circuit with an explicit shot count."""
driver = PySCFDriver(atom="H 0.0 0.0 0.0; H 0.0 0.0 0.735", basis="sto3g")
es_problem = driver.run()
qubit_mapper = JordanWignerMapper()
estimator = Estimator()
optimizer = SLSQP()
ansatz = UCCSD(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
qubit_mapper,
initial_state=HartreeFock(
es_problem.num_spatial_orbitals,
es_problem.num_particles,
qubit_mapper,
),
)
vqe_solver = VQE(estimator, ansatz, optimizer)
vqe_solver.initial_point = [0.0] * ansatz.num_parameters
calc = GroundStateEigensolver(qubit_mapper, vqe_solver)
result = calc.solve(es_problem)
# Calculate expected result from numpy solver
numpy_solver = NumPyMinimumEigensolver()
np_calc = GroundStateEigensolver(qubit_mapper, numpy_solver)
expected = np_calc.solve(es_problem)
self.assertAlmostEqual(result.hartree_fock_energy, expected.hartree_fock_energy)
self.assertEqual(len(result.total_energies), 1)
self.assertAlmostEqual(result.total_energies[0], expected.total_energies[0], delta=0.02)
|
https://github.com/Seanaventure/HighErrorRateRouting
|
Seanaventure
|
import matplotlib.pyplot as plt
import networkx as nx
import qiskit
import HERR
from qiskit.transpiler import CouplingMap
from qiskit.transpiler.passes.routing import *
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.converters import dag_to_circuit
from math import pi
from qiskit.compiler import transpile, assemble
from qiskit.providers.aer.noise import NoiseModel
import qiskit.providers.aer.noise as noise
from qiskit.tools.visualization import dag_drawer
import random
from qiskit.circuit.instruction import Instruction
import time
couplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
couplingList.append([i, j])
provider = IBMQ.load_account()
backend = provider.get_backend('ibmq_lima')
basis_gates = backend.configuration().basis_gates
couplingMap = CouplingMap(couplingList)
squareCouplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
if abs(i-j) == 1:
squareCouplingList.append([i, j])
squareCouplingList.append(([0, 3]))
squareCouplingList.append(([3, 0]))
squareCouplingMap = CouplingMap(squareCouplingList)
gridCouplingList = list()
for i in range(4):
for j in range(4):
if i is not j:
if abs(i-j) == 1:
gridCouplingList.append([i, j])
for i in range(4,8):
for j in range(4,8):
if i is not j:
if abs(i-j) == 1:
gridCouplingList.append([i, j])
gridCouplingList.append(([0, 4]))
gridCouplingList.append(([4, 0]))
gridCouplingList.append(([1, 5]))
gridCouplingList.append(([5, 1]))
gridCouplingList.append(([2, 6]))
gridCouplingList.append(([6, 2]))
gridCouplingList.append(([3, 7]))
gridCouplingList.append(([7, 3]))
gridCouplingMap = CouplingMap(gridCouplingList)
jakatraCouplingList = [[0, 1], [1, 0], [1, 2], [2, 1], [1, 3], [3, 1], [3,5], [5,3], [4,5], [5,4], [6,5], [5,6]]
jakatraCouplingMap = CouplingMap(jakatraCouplingList)
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cp(pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
swap_registers(circuit, n)
return circuit
def inverse_qft(circuit, n):
"""Does the inverse QFT on the first n qubits in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(n), n)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits in our existing circuit
circuit.append(invqft_circ, circuit.qubits[:n])
return circuit.decompose() # .decompose() allows us to see the individual gates
def countTwoQubitGates(transpiledCircuit):
num = 0
for gate in transpiledCircuit.data:
# print(type(gate[0]))
if issubclass(type(gate[0]), Instruction):
if gate[0].name == "cx":
num += 1
return num
s = '10111011'
n = len(s)
# Let's see how it looks:
circuit = QuantumCircuit(n)
for ii, yesno in enumerate(reversed(s)):
if yesno == '1':
circuit.x(ii)
qft(circuit, n)
circuit = inverse_qft(circuit, n)
circuit.measure_all()
circDag = circuit_to_dag(circuit)
targetCouplingMap = gridCouplingMap
bSwap = BasicSwap(targetCouplingMap)
baseTime = time.perf_counter()
bSwap.run(circDag)
bSwapTime = time.perf_counter() - baseTime
sabreSwap = SabreSwap(targetCouplingMap)
baseTime = time.perf_counter()
sabreSwap.run(circDag)
sabreSwapTime = time.perf_counter() - baseTime
stochasticSwap = StochasticSwap(targetCouplingMap)
baseTime = time.perf_counter()
stochasticSwap.run(circDag)
stochasticSwapTime = time.perf_counter() - baseTime
lookAheadSwap = LookaheadSwap(targetCouplingMap)
baseTime = time.perf_counter()
lookAheadSwap.run(circDag)
lookAheadSwapTime = time.perf_counter() - baseTime
for i in range(200):
# Create a noise model for the simulations
noise_model = noise.NoiseModel()
errorRates = list()
qiskitErrors = list()
for i in range(len(gridCouplingList)//2):
errorRates.append(random.randrange(1, 10, 1)/100.0)
qiskitErrors.append(noise.depolarizing_error(errorRates[i], 2))
edges = targetCouplingMap.get_edges()
uniqueEdges = set()
for edge in edges:
uniqueEdges.add(tuple(sorted(edge)))
noiseGraph = nx.Graph()
noiseGraph.add_nodes_from([0, 7])
errorIdex = 0
for edge in uniqueEdges:
noise_model.add_quantum_error(qiskitErrors[errorIdex], ['cx'], edge)
noiseGraph.add_edge(edge[0], edge[1], weight=1-errorRates[errorIdex])
errorIdex += 1
herr = HERR.HERR(targetCouplingMap, noiseGraph)
basSwap = BasicSwap(targetCouplingMap)
#print(gridCouplingMap)
# Run HERR
baseTime = time.perf_counter()
HERRRes = herr.run(circDag)
HERRSwapTime = time.perf_counter() - baseTime
updatedCirc = dag_to_circuit(HERRRes)
print(str(HERRSwapTime) + " " + str(bSwapTime) + " " + str(sabreSwapTime) + " " + str(stochasticSwapTime) + " " + str(lookAheadSwapTime))
|
https://github.com/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
%matplotlib inline
from qiskit import *
from qiskit.visualization import *
from qiskit.tools.monitor import *
from qiskit.aqua import *
from qiskit.aqua.algorithms import *
shor = Shor(N=15, a = 2)
backend = Aer.get_backend('qasm_simulator')
quantum_instance = QuantumInstance(backend)
result = shor.run(quantum_instance)
print(result)
from math import gcd
N=15
print("N=",N)
for a in range(2,N):
print()
print("***** a=",a)
print()
f = gcd(N,a)
if f==1:
shor = Shor(N,a)
result = shor.run(quantum_instance)
print(result["factors"])
else:
print("A factor of",N,"is",f)
|
https://github.com/deadshot8086/quantum-grover-boolean-sat
|
deadshot8086
|
from qiskit import QuantumCircuit, Aer, execute
from qiskit.visualization import plot_histogram
# simulate in statevector_simulator
def simulateStatevector(circuit):
backend = Aer.get_backend('statevector_simulator')
result = execute(circuit.remove_final_measurements(inplace=False), backend, shots=1).result()
counts = result.get_counts()
return result.get_statevector(circuit)
# return plot_histogram(counts, color='midnightblue', title="StateVector Histogram")
# simulate in qasm_simulator
def simulateQasm(circuit, count=1024):
backend = Aer.get_backend('qasm_simulator')
result = execute(circuit, backend, shots=count).result()
counts = result.get_counts()
return plot_histogram(counts, color='midnightblue', title="Qasm Histogram")
|
https://github.com/anirban-m/qiskit-superstaq
|
anirban-m
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
from typing import Any, List, Union
import qiskit
import requests
import qiskit_superstaq as qss
class SuperstaQBackend(qiskit.providers.BackendV1):
def __init__(
self, provider: "qss.superstaq_provider.SuperstaQProvider", url: str, backend: str
) -> None:
self.url = url
self._provider = provider
self.configuration_dict = {
"backend_name": backend,
"backend_version": "n/a",
"n_qubits": -1,
"basis_gates": None,
"gates": [],
"local": False,
"simulator": False,
"conditional": False,
"open_pulse": False,
"memory": False,
"max_shots": -1,
"coupling_map": None,
}
super().__init__(
configuration=qiskit.providers.models.BackendConfiguration.from_dict(
self.configuration_dict
),
provider=provider,
)
@classmethod
def _default_options(cls) -> qiskit.providers.Options:
return qiskit.providers.Options(shots=1000)
def __eq__(self, other: Any) -> bool:
if not isinstance(other, qss.superstaq_backend.SuperstaQBackend):
return False
return (
self._provider == other._provider
and self.configuration_dict == other.configuration_dict
)
def run(
self, circuits: Union[qiskit.QuantumCircuit, List[qiskit.QuantumCircuit]], **kwargs: int
) -> "qss.superstaq_job.SuperstaQJob":
if isinstance(circuits, qiskit.QuantumCircuit):
circuits = [circuits]
superstaq_json = {
"qasm_strings": [circuit.qasm() for circuit in circuits],
"backend": self.name(),
"shots": kwargs.get("shots"),
"ibmq_token": kwargs.get("ibmq_token"),
"ibmq_hub": kwargs.get("ibmq_hub"),
"ibmq_group": kwargs.get("ibmq_group"),
"ibmq_project": kwargs.get("ibmq_project"),
"ibmq_pulse": kwargs.get("ibmq_pulse"),
}
headers = {
"Authorization": self._provider.get_access_token(),
"Content-Type": "application/json",
}
res = requests.post(
self.url + "/" + qss.API_VERSION + "/qasm_strings_multi_job",
json=superstaq_json,
headers=headers,
verify=(self.url == qss.API_URL),
)
res.raise_for_status()
response = res.json()
if "job_ids" not in response:
raise Exception
# we make a virtual job_id that aggregates all of the individual jobs
# into a single one, that comma-separates the individual jobs:
job_id = ",".join(response["job_ids"])
job = qss.superstaq_job.SuperstaQJob(self, job_id)
return job
|
https://github.com/GIRISHBELANI/QC_Benchmarks_using_dm-simulator
|
GIRISHBELANI
|
# -*- coding: utf-8 -*-
"""
sparse Hamiltonian simulation
"""
from math import pi
import numpy as np
from scipy.linalg import expm
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
def Ham_sim(H, t):
"""
H : sparse matrix
t : time parameter
returns : QuantumCircuit for e^(-i*H*t)
"""
# read in number of qubits
N = len(H)
n = int(np.log2(N))
# read in matrix elements
#diag_el = H[0,0]
for j in range(1,N):
if H[0,j] != 0:
off_diag_el = H[0,j]
break
j_bin = np.binary_repr(j, width=n)
sign = (-1)**((j_bin.count('1'))%2)
# create registers
qreg_a = QuantumRegister(n, name='q_a')
creg = ClassicalRegister(n, name='c')
qreg_b = QuantumRegister(n, name='q_b') # ancilla register
anc_reg = QuantumRegister(1, name='q_anc')
qc = QuantumCircuit(qreg_a, qreg_b, anc_reg, creg)
# apply sparse H oracle gate
qc = V_gate(qc, H, qreg_a, qreg_b)
# apply W gate that diagonalizes SWAP operator and Toffoli
for q in range(n):
qc = W_gate(qc, qreg_a[q], qreg_b[q])
qc.x(qreg_b[q])
qc.ccx(qreg_a[q], qreg_b[q], anc_reg[0])
# phase
qc.p(sign*2*t*off_diag_el, anc_reg[0])
# uncompute
for q in range(n):
j = n-1-q
qc.ccx(qreg_a[j], qreg_b[j], anc_reg[0])
qc.x(qreg_b[j])
qc = W_gate(qc, qreg_a[j], qreg_b[j])
# sparse H oracle gate is its own inverse
qc = V_gate(qc, H, qreg_a, qreg_b)
# measure
#qc.barrier()
#qc.measure(qreg_a[0:], creg[0:])
return qc
def control_Ham_sim(n, H, t):
"""
H : sparse matrix
t : time parameter
returns : QuantumCircuit for control-e^(-i*H*t)
"""
qreg = QuantumRegister(n)
qreg_b = QuantumRegister(n)
control_reg = QuantumRegister(1)
anc_reg = QuantumRegister(1)
qc = QuantumCircuit(qreg, qreg_b, control_reg, anc_reg)
control = control_reg[0]
anc = anc_reg[0]
# read in number of qubits
N = len(H)
n = int(np.log2(N))
# read in matrix elements
diag_el = H[0,0]
for j in range(1,N):
if H[0,j] != 0:
off_diag_el = H[0,j]
break
j_bin = np.binary_repr(j, width=n)
sign = (-1)**((j_bin.count('1'))%2)
# use ancilla for phase kickback to simulate diagonal part of H
qc.x(anc)
qc.cp(-t*(diag_el+sign*off_diag_el), control, anc)
qc.x(anc)
# apply sparse H oracle gate
qc = V_gate(qc, H, qreg, qreg_b)
# apply W gate that diagonalizes SWAP operator and Toffoli
for q in range(n):
qc = W_gate(qc, qreg[q], qreg_b[q])
qc.x(qreg_b[q])
qc.ccx(qreg[q], qreg_b[q], anc)
# phase
qc.cp((sign*2*t*off_diag_el), control, anc)
# uncompute
for q in range(n):
j = n-1-q
qc.ccx(qreg[j], qreg_b[j], anc)
qc.x(qreg_b[j])
qc = W_gate(qc, qreg[j], qreg_b[j])
# sparse H oracle gate is its own inverse
qc = V_gate(qc, H, qreg, qreg_b)
return qc
def V_gate(qc, H, qreg_a, qreg_b):
"""
Hamiltonian oracle V|a,b> = |a,b+v(a)>
"""
# index of non-zero off diagonal in first row of H
n = qreg_a.size
N = len(H)
for i in range(1,N):
if H[0,i] != 0:
break
i_bin = np.binary_repr(i, width=n)
for q in range(n):
a, b = qreg_a[q], qreg_b[q]
if i_bin[n-1-q] == '1':
qc.x(a)
qc.cx(a,b)
qc.x(a)
else:
qc.cx(a,b)
return qc
def W_gate(qc, q0, q1):
"""
W : |00> -> |00>
|01> -> |01> + |10>
|10> -> |01> - |10>
|11> -> |11>
"""
qc.rz(-pi,q1)
qc.rz(-3*pi/2,q0)
qc.ry(-pi/2,q1)
qc.ry(-pi/2,q0)
qc.rz(-pi,q1)
qc.rz(-3*pi/2,q0)
qc.cx(q0,q1)
qc.rz(-7*pi/4,q1)
qc.rx(-pi/2,q0)
qc.rx(-pi,q1)
qc.rz(-3*pi/2,q0)
qc.cx(q0,q1)
qc.ry(-pi/2,q1)
qc.rx(-pi/4,q1)
qc.cx(q1,q0)
qc.rz(-3*pi/2,q0)
return qc
def qc_unitary(qc):
simulator = Aer.get_backend('unitary_simulator')
result = execute(qc, simulator).result()
U = np.array(result.get_unitary(qc))
return U
def sim_circuit(qc, shots):
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator, shots=shots).result()
outcomes = result.get_counts(qc)
return outcomes
def true_distr(H, t, psi0=0):
N = len(H)
n = int(np.log2(N))
U = expm(-1j*H*t)
psi = U[:,psi0]
probs = np.array([np.abs(amp)**2 for amp in psi])
probs_bin = {}
for j, p in enumerate(probs):
if p > 0:
j_bin = np.binary_repr(j, width=n)
probs_bin[j_bin] = p
return probs_bin
def generate_sparse_H(n, k, diag_el=0.75, off_diag_el=-0.25):
"""
n (int) : number of qubits. H will be 2^n by 2^n
k (int) : between 1,...,2^n-1. determines which H will
be generated in class of matrices
generates 2-sparse H with 1.5 on diagonal and 0.5 on
off diagonal
"""
N = 2**n
k_bin = np.binary_repr(k, width=n)
# initialize H
H = np.diag(diag_el*np.ones(N))
pairs = []
tot_indices = []
for i in range(N):
i_bin = np.binary_repr(i, width=n)
j_bin = ''
for q in range(n):
if i_bin[q] == k_bin[q]:
j_bin += '0'
else:
j_bin += '1'
j = int(j_bin,2)
if i not in tot_indices and j not in tot_indices:
pairs.append([i,j])
tot_indices.append(i)
tot_indices.append(j)
# fill in H
for pair in pairs:
i, j = pair[0], pair[1]
H[i,j] = off_diag_el
H[j,i] = off_diag_el
return H
def condition_number(A):
evals = np.linalg.eigh(A)[0]
abs_evals = [abs(e) for e in evals]
if min(abs_evals) == 0.0:
return 'inf'
else:
k = max(abs_evals)/min(abs_evals)
return k
|
https://github.com/crabster/qiskit-learning
|
crabster
|
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/aryashah2k/Quantum-Computing-Collection-Of-Resources
|
aryashah2k
|
#Uncomment the below line
#!pip install qiskit
#!pip install qiskit[visualization]
import numpy as np
import qiskit
qiskit.__qiskit_version__
#Import everything from qiskit
from qiskit import *
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector([0,0,1],title = 'spinup')
plot_bloch_vector([1,0,0])
ket_zero = np.array([[1],[0]])
ket_one = np.array([[0],[1]])
np.kron(ket_one,ket_zero)
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2022, 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests for BackendSampler."""
import math
import unittest
from unittest.mock import patch
from test import combine
from test.python.transpiler._dummy_passes import DummyTP
import numpy as np
from ddt import ddt
from qiskit import QuantumCircuit
from qiskit.circuit.library import RealAmplitudes
from qiskit.primitives import BackendSampler, SamplerResult
from qiskit.providers import JobStatus, JobV1
from qiskit.providers.fake_provider import FakeNairobi, FakeNairobiV2
from qiskit.providers.basicaer import QasmSimulatorPy
from qiskit.test import QiskitTestCase
from qiskit.transpiler import PassManager
from qiskit.utils import optionals
BACKENDS = [FakeNairobi(), FakeNairobiV2()]
@ddt
class TestBackendSampler(QiskitTestCase):
"""Test BackendSampler"""
def setUp(self):
super().setUp()
hadamard = QuantumCircuit(1, 1)
hadamard.h(0)
hadamard.measure(0, 0)
bell = QuantumCircuit(2)
bell.h(0)
bell.cx(0, 1)
bell.measure_all()
self._circuit = [hadamard, bell]
self._target = [
{0: 0.5, 1: 0.5},
{0: 0.5, 3: 0.5, 1: 0, 2: 0},
]
self._pqc = RealAmplitudes(num_qubits=2, reps=2)
self._pqc.measure_all()
self._pqc2 = RealAmplitudes(num_qubits=2, reps=3)
self._pqc2.measure_all()
self._pqc_params = [[0.0] * 6, [1.0] * 6]
self._pqc_target = [{0: 1}, {0: 0.0148, 1: 0.3449, 2: 0.0531, 3: 0.5872}]
self._theta = [
[0, 1, 1, 2, 3, 5],
[1, 2, 3, 4, 5, 6],
[0, 1, 2, 3, 4, 5, 6, 7],
]
def _generate_circuits_target(self, indices):
if isinstance(indices, list):
circuits = [self._circuit[j] for j in indices]
target = [self._target[j] for j in indices]
else:
raise ValueError(f"invalid index {indices}")
return circuits, target
def _generate_params_target(self, indices):
if isinstance(indices, int):
params = self._pqc_params[indices]
target = self._pqc_target[indices]
elif isinstance(indices, list):
params = [self._pqc_params[j] for j in indices]
target = [self._pqc_target[j] for j in indices]
else:
raise ValueError(f"invalid index {indices}")
return params, target
def _compare_probs(self, prob, target):
if not isinstance(prob, list):
prob = [prob]
if not isinstance(target, list):
target = [target]
self.assertEqual(len(prob), len(target))
for p, targ in zip(prob, target):
for key, t_val in targ.items():
if key in p:
self.assertAlmostEqual(p[key], t_val, delta=0.1)
else:
self.assertAlmostEqual(t_val, 0, delta=0.1)
@combine(backend=BACKENDS)
def test_sampler_run(self, backend):
"""Test Sampler.run()."""
bell = self._circuit[1]
sampler = BackendSampler(backend=backend)
job = sampler.run(circuits=[bell], shots=1000)
self.assertIsInstance(job, JobV1)
result = job.result()
self.assertIsInstance(result, SamplerResult)
self.assertEqual(result.quasi_dists[0].shots, 1000)
self.assertEqual(result.quasi_dists[0].stddev_upper_bound, math.sqrt(1 / 1000))
self._compare_probs(result.quasi_dists, self._target[1])
@combine(backend=BACKENDS)
def test_sample_run_multiple_circuits(self, backend):
"""Test Sampler.run() with multiple circuits."""
# executes three Bell circuits
# Argument `parameters` is optional.
bell = self._circuit[1]
sampler = BackendSampler(backend=backend)
result = sampler.run([bell, bell, bell]).result()
# print([q.binary_probabilities() for q in result.quasi_dists])
self._compare_probs(result.quasi_dists[0], self._target[1])
self._compare_probs(result.quasi_dists[1], self._target[1])
self._compare_probs(result.quasi_dists[2], self._target[1])
@combine(backend=BACKENDS)
def test_sampler_run_with_parameterized_circuits(self, backend):
"""Test Sampler.run() with parameterized circuits."""
# parameterized circuit
pqc = self._pqc
pqc2 = self._pqc2
theta1, theta2, theta3 = self._theta
sampler = BackendSampler(backend=backend)
result = sampler.run([pqc, pqc, pqc2], [theta1, theta2, theta3]).result()
# result of pqc(theta1)
prob1 = {
"00": 0.1309248462975777,
"01": 0.3608720796028448,
"10": 0.09324865232050054,
"11": 0.41495442177907715,
}
self.assertDictAlmostEqual(result.quasi_dists[0].binary_probabilities(), prob1, delta=0.1)
# result of pqc(theta2)
prob2 = {
"00": 0.06282290651933871,
"01": 0.02877144385576705,
"10": 0.606654494132085,
"11": 0.3017511554928094,
}
self.assertDictAlmostEqual(result.quasi_dists[1].binary_probabilities(), prob2, delta=0.1)
# result of pqc2(theta3)
prob3 = {
"00": 0.1880263994380416,
"01": 0.6881971261189544,
"10": 0.09326232720582443,
"11": 0.030514147237179892,
}
self.assertDictAlmostEqual(result.quasi_dists[2].binary_probabilities(), prob3, delta=0.1)
@combine(backend=BACKENDS)
def test_run_1qubit(self, backend):
"""test for 1-qubit cases"""
qc = QuantumCircuit(1)
qc.measure_all()
qc2 = QuantumCircuit(1)
qc2.x(0)
qc2.measure_all()
sampler = BackendSampler(backend=backend)
result = sampler.run([qc, qc2]).result()
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 2)
self.assertDictAlmostEqual(result.quasi_dists[0], {0: 1}, 0.1)
self.assertDictAlmostEqual(result.quasi_dists[1], {1: 1}, 0.1)
@combine(backend=BACKENDS)
def test_run_2qubit(self, backend):
"""test for 2-qubit cases"""
qc0 = QuantumCircuit(2)
qc0.measure_all()
qc1 = QuantumCircuit(2)
qc1.x(0)
qc1.measure_all()
qc2 = QuantumCircuit(2)
qc2.x(1)
qc2.measure_all()
qc3 = QuantumCircuit(2)
qc3.x([0, 1])
qc3.measure_all()
sampler = BackendSampler(backend=backend)
result = sampler.run([qc0, qc1, qc2, qc3]).result()
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 4)
self.assertDictAlmostEqual(result.quasi_dists[0], {0: 1}, 0.1)
self.assertDictAlmostEqual(result.quasi_dists[1], {1: 1}, 0.1)
self.assertDictAlmostEqual(result.quasi_dists[2], {2: 1}, 0.1)
self.assertDictAlmostEqual(result.quasi_dists[3], {3: 1}, 0.1)
@combine(backend=BACKENDS)
def test_run_errors(self, backend):
"""Test for errors"""
qc1 = QuantumCircuit(1)
qc1.measure_all()
qc2 = RealAmplitudes(num_qubits=1, reps=1)
qc2.measure_all()
sampler = BackendSampler(backend=backend)
with self.assertRaises(ValueError):
sampler.run([qc1], [[1e2]]).result()
with self.assertRaises(ValueError):
sampler.run([qc2], [[]]).result()
with self.assertRaises(ValueError):
sampler.run([qc2], [[1e2]]).result()
@combine(backend=BACKENDS)
def test_run_empty_parameter(self, backend):
"""Test for empty parameter"""
n = 5
qc = QuantumCircuit(n, n - 1)
qc.measure(range(n - 1), range(n - 1))
sampler = BackendSampler(backend=backend)
with self.subTest("one circuit"):
result = sampler.run([qc], shots=1000).result()
self.assertEqual(len(result.quasi_dists), 1)
for q_d in result.quasi_dists:
quasi_dist = {k: v for k, v in q_d.items() if v != 0.0}
self.assertDictAlmostEqual(quasi_dist, {0: 1.0}, delta=0.1)
self.assertEqual(len(result.metadata), 1)
with self.subTest("two circuits"):
result = sampler.run([qc, qc], shots=1000).result()
self.assertEqual(len(result.quasi_dists), 2)
for q_d in result.quasi_dists:
quasi_dist = {k: v for k, v in q_d.items() if v != 0.0}
self.assertDictAlmostEqual(quasi_dist, {0: 1.0}, delta=0.1)
self.assertEqual(len(result.metadata), 2)
@combine(backend=BACKENDS)
def test_run_numpy_params(self, backend):
"""Test for numpy array as parameter values"""
qc = RealAmplitudes(num_qubits=2, reps=2)
qc.measure_all()
k = 5
params_array = np.random.rand(k, qc.num_parameters)
params_list = params_array.tolist()
params_list_array = list(params_array)
sampler = BackendSampler(backend=backend)
target = sampler.run([qc] * k, params_list).result()
with self.subTest("ndarrary"):
result = sampler.run([qc] * k, params_array).result()
self.assertEqual(len(result.metadata), k)
for i in range(k):
self.assertDictAlmostEqual(result.quasi_dists[i], target.quasi_dists[i], delta=0.1)
with self.subTest("list of ndarray"):
result = sampler.run([qc] * k, params_list_array).result()
self.assertEqual(len(result.metadata), k)
for i in range(k):
self.assertDictAlmostEqual(result.quasi_dists[i], target.quasi_dists[i], delta=0.1)
@combine(backend=BACKENDS)
def test_run_with_shots_option(self, backend):
"""test with shots option."""
params, target = self._generate_params_target([1])
sampler = BackendSampler(backend=backend)
result = sampler.run(
circuits=[self._pqc], parameter_values=params, shots=1024, seed=15
).result()
self._compare_probs(result.quasi_dists, target)
@combine(backend=BACKENDS)
def test_primitive_job_status_done(self, backend):
"""test primitive job's status"""
bell = self._circuit[1]
sampler = BackendSampler(backend=backend)
job = sampler.run(circuits=[bell])
_ = job.result()
self.assertEqual(job.status(), JobStatus.DONE)
def test_primitive_job_size_limit_backend_v2(self):
"""Test primitive respects backend's job size limit."""
class FakeNairobiLimitedCircuits(FakeNairobiV2):
"""FakeNairobiV2 with job size limit."""
@property
def max_circuits(self):
return 1
qc = QuantumCircuit(1)
qc.measure_all()
qc2 = QuantumCircuit(1)
qc2.x(0)
qc2.measure_all()
sampler = BackendSampler(backend=FakeNairobiLimitedCircuits())
result = sampler.run([qc, qc2]).result()
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 2)
self.assertDictAlmostEqual(result.quasi_dists[0], {0: 1}, 0.1)
self.assertDictAlmostEqual(result.quasi_dists[1], {1: 1}, 0.1)
def test_primitive_job_size_limit_backend_v1(self):
"""Test primitive respects backend's job size limit."""
backend = FakeNairobi()
config = backend.configuration()
config.max_experiments = 1
backend._configuration = config
qc = QuantumCircuit(1)
qc.measure_all()
qc2 = QuantumCircuit(1)
qc2.x(0)
qc2.measure_all()
sampler = BackendSampler(backend=backend)
result = sampler.run([qc, qc2]).result()
self.assertIsInstance(result, SamplerResult)
self.assertEqual(len(result.quasi_dists), 2)
self.assertDictAlmostEqual(result.quasi_dists[0], {0: 1}, 0.1)
self.assertDictAlmostEqual(result.quasi_dists[1], {1: 1}, 0.1)
@unittest.skipUnless(optionals.HAS_AER, "qiskit-aer is required to run this test")
def test_circuit_with_dynamic_circuit(self):
"""Test BackendSampler with QuantumCircuit with a dynamic circuit"""
from qiskit_aer import Aer
qc = QuantumCircuit(2, 1)
with qc.for_loop(range(5)):
qc.h(0)
qc.cx(0, 1)
qc.measure(0, 0)
qc.break_loop().c_if(0, True)
backend = Aer.get_backend("aer_simulator")
backend.set_options(seed_simulator=15)
sampler = BackendSampler(backend, skip_transpilation=True)
sampler.set_transpile_options(seed_transpiler=15)
result = sampler.run(qc).result()
self.assertDictAlmostEqual(result.quasi_dists[0], {0: 0.5029296875, 1: 0.4970703125})
def test_sequential_run(self):
"""Test sequential run."""
qc = QuantumCircuit(1)
qc.measure_all()
qc2 = QuantumCircuit(1)
qc2.x(0)
qc2.measure_all()
sampler = BackendSampler(backend=FakeNairobi())
result = sampler.run([qc]).result()
self.assertDictAlmostEqual(result.quasi_dists[0], {0: 1}, 0.1)
result2 = sampler.run([qc2]).result()
self.assertDictAlmostEqual(result2.quasi_dists[0], {1: 1}, 0.1)
result3 = sampler.run([qc, qc2]).result()
self.assertDictAlmostEqual(result3.quasi_dists[0], {0: 1}, 0.1)
self.assertDictAlmostEqual(result3.quasi_dists[1], {1: 1}, 0.1)
def test_outcome_bitstring_size(self):
"""Test that the result bitstrings are properly padded.
E.g. measuring '0001' should not get truncated to '1'.
"""
qc = QuantumCircuit(4)
qc.x(0)
qc.measure_all()
# We need a noise-free backend here (shot noise is fine) to ensure that
# the only bit string measured is "0001". With device noise, it could happen that
# strings with a leading 1 are measured and then the truncation cannot be tested.
sampler = BackendSampler(backend=QasmSimulatorPy())
result = sampler.run(qc).result()
probs = result.quasi_dists[0].binary_probabilities()
self.assertIn("0001", probs.keys())
self.assertEqual(len(probs), 1)
def test_bound_pass_manager(self):
"""Test bound pass manager."""
with self.subTest("Test single circuit"):
dummy_pass = DummyTP()
with patch.object(DummyTP, "run", wraps=dummy_pass.run) as mock_pass:
bound_pass = PassManager(dummy_pass)
sampler = BackendSampler(backend=FakeNairobi(), bound_pass_manager=bound_pass)
_ = sampler.run(self._circuit[0]).result()
self.assertEqual(mock_pass.call_count, 1)
with self.subTest("Test circuit batch"):
dummy_pass = DummyTP()
with patch.object(DummyTP, "run", wraps=dummy_pass.run) as mock_pass:
bound_pass = PassManager(dummy_pass)
sampler = BackendSampler(backend=FakeNairobi(), bound_pass_manager=bound_pass)
_ = sampler.run([self._circuit[0], self._circuit[0]]).result()
self.assertEqual(mock_pass.call_count, 2)
if __name__ == "__main__":
unittest.main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_nature.second_q.drivers import PySCFDriver
driver = PySCFDriver()
problem = driver.run()
print(problem)
from qiskit_nature.second_q.problems import ElectronicBasis
driver.run_pyscf()
problem = driver.to_problem(basis=ElectronicBasis.MO, include_dipole=True)
print(problem.basis)
ao_problem = driver.to_problem(basis=ElectronicBasis.AO)
print(ao_problem.basis)
from qiskit_nature.second_q.formats.qcschema_translator import qcschema_to_problem
qcschema = driver.to_qcschema()
ao_problem = qcschema_to_problem(qcschema, basis=ElectronicBasis.AO)
from qiskit_nature.second_q.formats.qcschema_translator import get_ao_to_mo_from_qcschema
basis_transformer = get_ao_to_mo_from_qcschema(qcschema)
mo_problem = basis_transformer.transform(ao_problem)
print(mo_problem.basis)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/we-taper/qiskit-pyzx
|
we-taper
|
import qiskit
%matplotlib inline
qiskit.__qiskit_version__
len = 4
q_r = qiskit.QuantumRegister(len, 'q')
c_r = qiskit.ClassicalRegister(len, 'c')
q_c = qiskit.QuantumCircuit(q_r, c_r)
q_c.h([q_r[0],q_r[3]])
q_c.x([q_r[0],q_r[3]])
q_c.ccx(q_r[0],q_r[3],q_r[1])
q_c.x([q_r[0],q_r[3]])
q_c.ccx(q_r[0],q_r[3],q_r[2])
q_c.cx(q_r[2],q_r[0])
q_c.cx(q_r[2],q_r[3])
#q_c.barrier()
q_c.measure(q_r,c_r)
q_c.draw(output='latex', line_length=300, scale=0.5)
sim = qiskit.BasicAer.get_backend('qasm_simulator')
job = qiskit.execute(q_c, backend = sim, shots = 1000)
res = job.result().get_counts()
print(res)
qiskit.visualization.plot_histogram(res)
print(q_c.qasm())
|
https://github.com/ritamsarmah/cs239
|
ritamsarmah
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/JavaFXpert/think2020
|
JavaFXpert
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
# Create a quantum circuit containing three quantum bits, and three classical bits to hold measurement results.
qc = QuantumCircuit(3, 3)
qc.h(0)
qc.h(1)
qc.h(2)
qc.measure(range(3),range(3))
qc.draw()
def answer(result):
for key in result.keys():
state = key
print('The Quantum 8-ball says:')
if state == '000':
print('It is certain.')
elif state == '001':
print('Without a doubt.')
elif state == '010':
print('Yes - definitely.')
elif state == '011':
print('Most likely.')
elif state == '100':
print("Don't count on it.")
elif state == '101':
print('My reply is no.')
elif state == '110':
print('Very doubtful.')
else:
print('Concentrate and ask again.')
job = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots=1)
counts = job.result().get_counts(qc)
answer(counts)
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(3)
qc.h(0)
qc.h(1)
qc.h(2)
sv = Statevector.from_instruction(qc)
counts = sv.sample_counts(shots = 1)
answer(counts)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, execute
from qiskit.visualization import plot_error_map
from qiskit.providers.fake_provider import FakeVigoV2
backend = FakeVigoV2()
plot_error_map(backend)
|
https://github.com/mnp-club/Quantum_Computing_Workshop_2020
|
mnp-club
|
!pip install qiskit
from qiskit import *
from qiskit.tools.jupyter import *
from qiskit.visualization import *
import matplotlib.pyplot as plotter
import numpy as np
from IPython.display import display, Math, Latex
import qiskit.quantum_info as qi
%matplotlib inline
# Loading your IBM Q account(s)
provider = IBMQ.load_account()
def run_circuit(qc):
backend = Aer.get_backend('qasm_simulator') # we choose the simulator as our backend
result = execute(qc, backend, shots = 200000).result() # we run the simulation
counts = result.get_counts() # we get the counts
return counts
def qft_rotations(circuit, n):
"""Performs qft on the first n qubits in circuit (without swaps)"""
if n == 0:
return circuit
n -= 1
circuit.h(n)
for qubit in range(n):
circuit.cu1(np.pi/2**(n-qubit), qubit, n)
# At the end of our function, we call the same function again on
# the next qubits (we reduced n by one earlier in the function)
qft_rotations(circuit, n)
def swap_registers(circuit, n):
for qubit in range(n//2):
circuit.swap(qubit, n-qubit-1)
return circuit
def qft(circuit, n):
"""QFT on the first n qubits in circuit"""
qft_rotations(circuit, n)
def inverse_qft(circuit, n):
"""Does the inverse QFT on the first n qubits in circuit"""
# First we create a QFT circuit of the correct size:
qft_circ = qft(QuantumCircuit(n), n)
# Then we take the inverse of this circuit
invqft_circ = qft_circ.inverse()
# And add it to the first n qubits in our existing circuit
circuit.append(invqft_circ, circuit.qubits[:n])
return circuit.decompose() # .decompose() allows us to see the individual gates
swap_registers(circuit, n)
return circuit
# Basically change the values of n starting from 1,2(you know which aren't I),3,... We will start with 3
a = 0
n = 3
while a==0:
c = ClassicalRegister(5)
q = QuantumRegister(5)
qc = QuantumCircuit(q,c)
for i in range(n):
qft(qc,5)
qc.measure(range(5),range(5))
counts = run_circuit(qc)
if len(counts.keys()) == 1:
if '00000' in counts.keys():
a=1
print(n)
n = n+1
# Actually due to qiskit using reverse order for bit strings sometimes produces weird results when it comes to such matrices repeatedly.
# Nevertheless, you can search up on the internet for QFT matrix and you can calculate that QFT^4 indeed equals I.
# The matrix can be easily solved theoretically and can be found on the internet, Here we will get the matrix according to the qiskit nomenclature.
qc = QuantumCircuit(2)
qft(qc, 2)
qft(qc, 2)
with np.printoptions(precision=3, suppress=True):
print(qi.Operator(qc).data)
# The required function. Also recall that T^2 = S, S^2 = Z.
def Modulo_increment(qc): # 4 bit circuit where q3 is MSB
qft(qc,4)
qc.rz(np.pi/8,0)
qc.t(1)
qc.s(2)
qc.z(3)
inverse_qft(qc,4)
return qc
# Then you can check for different values.
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
top = QuantumCircuit(1)
top.x(0);
bottom = QuantumCircuit(2)
bottom.cry(0.2, 0, 1);
tensored = bottom.tensor(top)
tensored.draw('mpl')
|
https://github.com/sebasmos/QuantumVE
|
sebasmos
|
from __future__ import print_function
import argparse
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import random_split
from torch.utils.data import Subset, DataLoader, random_split
from torchvision import datasets, transforms
import torch.optim as optim
from torch.optim.lr_scheduler import StepLR
import matplotlib.pyplot as plt
import os
import numpy as np
from sklearn.metrics import confusion_matrix, classification_report
import pandas as pd
# from MAE code
from util.datasets import build_dataset
import argparse
import util.misc as misc
import argparse
import datetime
import json
import numpy as np
import os
import time
from pathlib import Path
import torch
import torch.backends.cudnn as cudnn
from torch.utils.tensorboard import SummaryWriter
import timm
assert timm.__version__ == "0.3.2" # version check
from timm.models.layers import trunc_normal_
from timm.data.mixup import Mixup
from timm.loss import LabelSmoothingCrossEntropy, SoftTargetCrossEntropy
import util.lr_decay as lrd
import util.misc as misc
from util.datasets import build_dataset
from util.pos_embed import interpolate_pos_embed
from util.misc import NativeScalerWithGradNormCount as NativeScaler
import models_vit
import sys
import os
import torch
import numpy as np
import matplotlib.pyplot as plt
from PIL import Image
import models_mae
import torch; print(f'numpy version: {np.__version__}\nCUDA version: {torch.version.cuda} - Torch versteion: {torch.__version__} - device count: {torch.cuda.device_count()}')
from engine_finetune import train_one_epoch, evaluate
from timm.data import Mixup
from timm.utils import accuracy
from sklearn.metrics import confusion_matrix, classification_report
import seaborn as sns
from sklearn.preprocessing import LabelBinarizer
from sklearn.metrics import roc_curve, auc
import matplotlib.pyplot as plt
from itertools import cycle
import numpy as np
from sklearn.metrics import precision_score, recall_score, f1_score
imagenet_mean = np.array([0.485, 0.456, 0.406])
imagenet_std = np.array([0.229, 0.224, 0.225])
def show_image(image, title=''):
# image is [H, W, 3]
assert image.shape[2] == 3
plt.imshow(torch.clip((image * imagenet_std + imagenet_mean) * 255, 0, 255).int())
plt.title(title, fontsize=16)
plt.axis('off')
return
def prepare_model(chkpt_dir, arch='mae_vit_large_patch16'):
# build model
model = getattr(models_mae, arch)()
# load model
checkpoint = torch.load(chkpt_dir, map_location='cpu')
msg = model.load_state_dict(checkpoint['model'], strict=False)
print(msg)
return model
def run_one_image(img, model):
x = torch.tensor(img)
# make it a batch-like
x = x.unsqueeze(dim=0)
x = torch.einsum('nhwc->nchw', x)
# run MAE
loss, y, mask = model(x.float(), mask_ratio=0.75)
y = model.unpatchify(y)
y = torch.einsum('nchw->nhwc', y).detach().cpu()
# visualize the mask
mask = mask.detach()
mask = mask.unsqueeze(-1).repeat(1, 1, model.patch_embed.patch_size[0]**2 *3) # (N, H*W, p*p*3)
mask = model.unpatchify(mask) # 1 is removing, 0 is keeping
mask = torch.einsum('nchw->nhwc', mask).detach().cpu()
x = torch.einsum('nchw->nhwc', x)
# masked image
im_masked = x * (1 - mask)
# MAE reconstruction pasted with visible patches
im_paste = x * (1 - mask) + y * mask
# make the plt figure larger
plt.rcParams['figure.figsize'] = [24, 24]
plt.subplot(1, 4, 1)
show_image(x[0], "original")
plt.subplot(1, 4, 2)
show_image(im_masked[0], "masked")
plt.subplot(1, 4, 3)
show_image(y[0], "reconstruction")
plt.subplot(1, 4, 4)
show_image(im_paste[0], "reconstruction + visible")
plt.show()
# Set the seed for PyTorch
torch.manual_seed(42)
parser = argparse.ArgumentParser('MAE fine-tuning for image classification', add_help=False)
parser.add_argument('--batch_size', default=32, type=int,
help='Batch size per GPU (effective batch size is batch_size * accum_iter * # gpus')
parser.add_argument('--epochs', default=100, type=int)
parser.add_argument('--accum_iter', default=4, type=int,
help='Accumulate gradient iterations (for increasing the effective batch size under memory constraints)')
# Model parameters
parser.add_argument('--model', default='vit_base_patch16', type=str, metavar='MODEL',
help='Name of model to train')
parser.add_argument('--input_size', default=224, type=int,
help='images input size')
parser.add_argument('--drop_path', type=float, default=0.1, metavar='PCT',
help='Drop path rate (default: 0.1)')
# Optimizer parameters
parser.add_argument('--clip_grad', type=float, default=None, metavar='NORM',
help='Clip gradient norm (default: None, no clipping)')
parser.add_argument('--weight_decay', type=float, default=0.05,
help='weight decay (default: 0.05)')
parser.add_argument('--lr', type=float, default=None, metavar='LR',
help='learning rate (absolute lr)')
parser.add_argument('--blr', type=float, default=5e-4, metavar='LR',
help='base learning rate: absolute_lr = base_lr * total_batch_size / 256')
parser.add_argument('--layer_decay', type=float, default=0.65,
help='layer-wise lr decay from ELECTRA/BEiT')
parser.add_argument('--min_lr', type=float, default=1e-6, metavar='LR',
help='lower lr bound for cyclic schedulers that hit 0')
parser.add_argument('--warmup_epochs', type=int, default=5, metavar='N',
help='epochs to warmup LR')
# Augmentation parameters
parser.add_argument('--color_jitter', type=float, default=None, metavar='PCT',
help='Color jitter factor (enabled only when not using Auto/RandAug)')
parser.add_argument('--aa', type=str, default='rand-m9-mstd0.5-inc1', metavar='NAME',
help='Use AutoAugment policy. "v0" or "original". " + "(default: rand-m9-mstd0.5-inc1)'),
parser.add_argument('--smoothing', type=float, default=0.1,
help='Label smoothing (default: 0.1)')
# * Random Erase params
parser.add_argument('--reprob', type=float, default=0.25, metavar='PCT',
help='Random erase prob (default: 0.25)')
parser.add_argument('--remode', type=str, default='pixel',
help='Random erase mode (default: "pixel")')
parser.add_argument('--recount', type=int, default=1,
help='Random erase count (default: 1)')
parser.add_argument('--resplit', action='store_true', default=False,
help='Do not random erase first (clean) augmentation split')
# * Mixup params
parser.add_argument('--mixup', type=float, default=0.8,
help='mixup alpha, mixup enabled if > 0.')
parser.add_argument('--cutmix', type=float, default=1.0,
help='cutmix alpha, cutmix enabled if > 0.')
parser.add_argument('--cutmix_minmax', type=float, nargs='+', default=None,
help='cutmix min/max ratio, overrides alpha and enables cutmix if set (default: None)')
parser.add_argument('--mixup_prob', type=float, default=1.0,
help='Probability of performing mixup or cutmix when either/both is enabled')
parser.add_argument('--mixup_switch_prob', type=float, default=0.5,
help='Probability of switching to cutmix when both mixup and cutmix enabled')
parser.add_argument('--mixup_mode', type=str, default='batch',
help='How to apply mixup/cutmix params. Per "batch", "pair", or "elem"')
# * Finetuning params
parser.add_argument('--finetune', default='mae_pretrain_vit_base.pth',
help='finetune from checkpoint')
parser.add_argument('--global_pool', action='store_true')
parser.set_defaults(global_pool=True)
parser.add_argument('--cls_token', action='store_false', dest='global_pool',
help='Use class token instead of global pool for classification')
# Dataset parameters
parser.add_argument('--data_path', default='/media/enc/vera1/sebastian/data/Datos_Entrenamiento/', type=str,
help='dataset path')
parser.add_argument('--nb_classes', default=7, type=int,
help='number of the classification types')
parser.add_argument('--output_dir', default='EXP_base_biggest_dataset',
help='path where to save, empty for no saving')
parser.add_argument('--log_dir', default='./output_dir',
help='path where to tensorboard log')
parser.add_argument('--device', default='cuda',
help='device to use for training / testing')
parser.add_argument('--seed', default=0, type=int)
parser.add_argument('--resume', default='',
help='resume from checkpoint')
parser.add_argument('--start_epoch', default=0, type=int, metavar='N',
help='start epoch')
parser.add_argument('--eval',default=True, action='store_true',
help='Perform evaluation only')
parser.add_argument('--dist_eval', action='store_true', default=False,
help='Enabling distributed evaluation (recommended during training for faster monitor')
parser.add_argument('--num_workers', default=10, type=int)
parser.add_argument('--pin_mem', action='store_true',
help='Pin CPU memory in DataLoader for more efficient (sometimes) transfer to GPU.')
parser.add_argument('--no_pin_mem', action='store_false', dest='pin_mem')
parser.set_defaults(pin_mem=True)
# distributed training parameters
parser.add_argument('--world_size', default=1, type=int,
help='number of distributed processes')
parser.add_argument('--local_rank', default=-1, type=int)
parser.add_argument('--dist_on_itp', action='store_true')
parser.add_argument('--dist_url', default='env://',
help='url used to set up distributed training')
args, unknown = parser.parse_known_args()
misc.init_distributed_mode(args)
print("{}".format(args).replace(', ', ',\n'))
device = torch.device(args.device)
misc.init_distributed_mode(args)
# print('job dir: {}'.format(os.path.dirname(os.path.realpath(__file__))))
print("{}".format(args).replace(', ', ',\n'))
device = torch.device(args.device)
# fix the seed for reproducibility
seed = args.seed + misc.get_rank()
torch.manual_seed(seed)
np.random.seed(seed)
cudnn.benchmark = True
dataset_train = build_dataset(is_train=True, args=args)
dataset_val = build_dataset(is_train=False, args=args)
if True: # args.distributed:
num_tasks = misc.get_world_size()
global_rank = misc.get_rank()
sampler_train = torch.utils.data.DistributedSampler(
dataset_train, num_replicas=num_tasks, rank=global_rank, shuffle=True
)
print("Sampler_train = %s" % str(sampler_train))
if args.dist_eval:
if len(dataset_val) % num_tasks != 0:
print('Warning: Enabling distributed evaluation with an eval dataset not divisible by process number. '
'This will slightly alter validation results as extra duplicate entries are added to achieve '
'equal num of samples per-process.')
sampler_val = torch.utils.data.DistributedSampler(
dataset_val, num_replicas=num_tasks, rank=global_rank, shuffle=True) # shuffle=True to reduce monitor bias
else:
sampler_val = torch.utils.data.SequentialSampler(dataset_val)
else:
sampler_train = torch.utils.data.RandomSampler(dataset_train)
sampler_val = torch.utils.data.SequentialSampler(dataset_val)
if global_rank == 0 and args.log_dir is not None and not args.eval:
os.makedirs(args.log_dir, exist_ok=True)
log_writer = SummaryWriter(log_dir=args.log_dir)
else:
log_writer = None
data_loader_train = torch.utils.data.DataLoader(
dataset_train, sampler=sampler_train,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=args.pin_mem,
drop_last=True,
)
data_loader_val = torch.utils.data.DataLoader(
dataset_val, sampler=sampler_val,
batch_size=args.batch_size,
num_workers=args.num_workers,
pin_memory=args.pin_mem,
drop_last=False
)
# #Liberia Validacion cruzada
# from sklearn.model_selection import KFold
# # K-fold cross-validation
# num_splits = 5 # ajusta el número de splits según tus necesidades
# kf = KFold(n_splits=num_splits, shuffle=True, random_state=42)
# for fold, (train_index, val_index) in enumerate(kf.split(dataset_train)):
# print(f"\nTraining on Fold {fold + 1}/{num_splits}:")
# # create train and validation sets for this fold
# train_dataset_fold = Subset(dataset_train, train_index)
# val_dataset_fold = Subset(dataset_train, val_index)
# data_loader_train = torch.utils.data.DataLoader(
# train_dataset_fold, sampler=torch.utils.data.RandomSampler(train_dataset_fold),
# batch_size=args.batch_size,
# num_workers=args.num_workers,
# pin_memory=args.pin_mem,
# drop_last=True,
# )
# data_loader_val = torch.utils.data.DataLoader(
# val_dataset_fold, sampler=torch.utils.data.SequentialSampler(val_dataset_fold),
# batch_size=args.batch_size,
# num_workers=args.num_workers,
# pin_memory=args.pin_mem,
# drop_last=False
# )
mixup_fn = None
mixup_active = args.mixup > 0 or args.cutmix > 0. or args.cutmix_minmax is not None
if mixup_active:
print("Mixup is activated!")
mixup_fn = Mixup(
mixup_alpha=args.mixup, cutmix_alpha=args.cutmix, cutmix_minmax=args.cutmix_minmax,
prob=args.mixup_prob, switch_prob=args.mixup_switch_prob, mode=args.mixup_mode,
label_smoothing=args.smoothing, num_classes=args.nb_classes)
model = models_vit.__dict__[args.model](
num_classes=args.nb_classes,
drop_path_rate=args.drop_path,
global_pool=args.global_pool,
)
if args.finetune and not args.eval:
checkpoint = torch.load(args.finetune, map_location='cpu')
print("Load pre-trained checkpoint from: %s" % args.finetune)
checkpoint_model = checkpoint['model']
state_dict = model.state_dict()
for k in ['head.weight', 'head.bias']:
if k in checkpoint_model and checkpoint_model[k].shape != state_dict[k].shape:
print(f"Removing key {k} from pretrained checkpoint")
del checkpoint_model[k]
# interpolate position embedding
interpolate_pos_embed(model, checkpoint_model)
# load pre-trained model
msg = model.load_state_dict(checkpoint_model, strict=False)
print(msg)
if args.global_pool:
assert set(msg.missing_keys) == {'head.weight', 'head.bias', 'fc_norm.weight', 'fc_norm.bias'}
else:
assert set(msg.missing_keys) == {'head.weight', 'head.bias'}
# manually initialize fc layer
trunc_normal_(model.head.weight, std=2e-5)
model.to(device)
model_without_ddp = model
n_parameters = sum(p.numel() for p in model.parameters() if p.requires_grad)
print("Model = %s" % str(model_without_ddp))
print('number of params (M): %.2f' % (n_parameters / 1.e6))
eff_batch_size = args.batch_size * args.accum_iter * misc.get_world_size()
if args.lr is None: # only base_lr is specified
args.lr = args.blr * eff_batch_size / 256
print("base lr: %.2e" % (args.lr * 256 / eff_batch_size))
print("actual lr: %.2e" % args.lr)
print("accumulate grad iterations: %d" % args.accum_iter)
print("effective batch size: %d" % eff_batch_size)
if args.distributed:
model = torch.nn.parallel.DistributedDataParallel(model, device_ids=[args.gpu])
model_without_ddp = model.module
# build optimizer with layer-wise lr decay (lrd)
param_groups = lrd.param_groups_lrd(model_without_ddp, args.weight_decay,
no_weight_decay_list=model_without_ddp.no_weight_decay(),
layer_decay=args.layer_decay
)
optimizer = torch.optim.AdamW(param_groups, lr=args.lr)
loss_scaler = NativeScaler()
if mixup_fn is not None:
# smoothing is handled with mixup label transform
criterion = SoftTargetCrossEntropy()
elif args.smoothing > 0.:
criterion = LabelSmoothingCrossEntropy(smoothing=args.smoothing)
else:
criterion = torch.nn.CrossEntropyLoss()
print("criterion = %s" % str(criterion))
misc.load_model(args=args, model_without_ddp=model_without_ddp, optimizer=optimizer, loss_scaler=loss_scaler)
if args.eval:
test_stats = evaluate(data_loader_val, model, device)
print(f"Accuracy of the network on the {len(dataset_val)} test images: {test_stats['acc1']:.1f}%")
# exit(0)
train = False
if train:
print(f"Start training for {args.epochs} epochs")
start_time = time.time()
max_accuracy = 0.0
for epoch in range(args.start_epoch, args.epochs):
if args.distributed:
data_loader_train.sampler.set_epoch(epoch)
train_stats = train_one_epoch(
model, criterion, data_loader_train,
optimizer, device, epoch, loss_scaler,
args.clip_grad, mixup_fn,
log_writer=log_writer,
args=args
)
if args.output_dir:
misc.save_model(
args=args, model=model, model_without_ddp=model_without_ddp, optimizer=optimizer,
loss_scaler=loss_scaler, epoch=epoch)
test_stats = evaluate(data_loader_val, model, device)
print(f"Accuracy of the network on the {len(dataset_val)} test images: {test_stats['acc1']:.1f}%")
max_accuracy = max(max_accuracy, test_stats["acc1"])
print(f'Max accuracy: {max_accuracy:.2f}%')
if log_writer is not None:
log_writer.add_scalar('perf/test_acc1', test_stats['acc1'], epoch)
log_writer.add_scalar('perf/test_acc5', test_stats['acc5'], epoch)
log_writer.add_scalar('perf/test_loss', test_stats['loss'], epoch)
log_stats = {**{f'train_{k}': v for k, v in train_stats.items()},
**{f'test_{k}': v for k, v in test_stats.items()},
'epoch': epoch,
'n_parameters': n_parameters}
if args.output_dir and misc.is_main_process():
if log_writer is not None:
log_writer.flush()
with open(os.path.join(args.output_dir, "log.txt"), mode="a", encoding="utf-8") as f:
f.write(json.dumps(log_stats) + "\n")
total_time = time.time() - start_time
total_time_str = str(datetime.timedelta(seconds=int(total_time)))
print('Training time {}'.format(total_time_str))
EXPERIMENT_NAME = "eval_vit_base"
saving_model = f"{EXPERIMENT_NAME}/models"
os.makedirs(saving_model, exist_ok = True)
os.makedirs(EXPERIMENT_NAME, exist_ok=True)
if args.eval:
test_stats = evaluate(data_loader_val, model, device)
print(f"Accuracy of the network on the {len(dataset_val)} test images: {test_stats['acc1']:.1f}%")
@torch.no_grad()
def evaluate_test(data_loader, model, device):
criterion = torch.nn.CrossEntropyLoss()
metric_logger = misc.MetricLogger(delimiter=" ")
header = 'Test:'
# switch to evaluation mode
model.eval()
all_predictions = []
all_labels = []
for batch in metric_logger.log_every(data_loader, 10, header):
images = batch[0]
target = batch[-1]
images = images.to(device, non_blocking=True)
target = target.to(device, non_blocking=True)
# compute output
with torch.cuda.amp.autocast():
output = model(images)
loss = criterion(output, target)#
pred = output.argmax(dim=1)
all_predictions.append(pred.cpu().numpy())# ADDED
all_labels.append(target.cpu().numpy())# ADDED
acc1, acc5 = accuracy(output, target, topk=(1, 5))
batch_size = images.shape[0]
metric_logger.update(loss=loss.item())
metric_logger.meters['acc1'].update(acc1.item(), n=batch_size)
metric_logger.meters['acc5'].update(acc5.item(), n=batch_size)
all_predictions = np.array(all_predictions)#.squeeze(0)
all_labels = np.array(all_labels)#.squeeze(0)
# gather the stats from all processes
metric_logger.synchronize_between_processes()
print('* Acc@1 {top1.global_avg:.3f} Acc@5 {top5.global_avg:.3f} loss {losses.global_avg:.3f}'
.format(top1=metric_logger.acc1, top5=metric_logger.acc5, losses=metric_logger.loss))
# return
return {k: meter.global_avg for k, meter in metric_logger.meters.items()}, np.concatenate(all_predictions, axis=0), np.concatenate(all_labels, axis=0)
metrics, all_predictions, all_labels = evaluate_test(data_loader_val, model, device)
# print(f"Accuracy of the network on the {len(dataset_val)} test images: {test_stats['acc1']:.1f}%")
metrics
all_predictions
unique_classes = np.unique(np.concatenate((all_labels, all_predictions)))
unique_classes
confusion_mat = confusion_matrix(all_labels, all_predictions, labels=unique_classes)
conf_matrix = pd.DataFrame(confusion_mat, index=unique_classes, columns=unique_classes)
conf_matrix
unique_classes = np.unique(np.concatenate((all_labels, all_predictions)))
confusion_mat = confusion_matrix(all_labels, all_predictions, labels=unique_classes)
conf_matrix = pd.DataFrame(confusion_mat, index=unique_classes, columns=unique_classes)
# Plot the confusion matrix using seaborn
plt.figure(figsize=(5, 4))
ax = sns.heatmap(conf_matrix, annot=True, fmt='.1f', cmap=sns.cubehelix_palette(as_cmap=True), linewidths=0.1, cbar=True)
# Set labels and ticks
ax.set_xlabel('Predicted Labels')
ax.set_ylabel('True Labels')
# Set x and y ticks using the unique classes
ax.set_xticks(range(len(unique_classes)))
ax.set_yticks(range(len(unique_classes)))
# Set x and y ticks at the center of the cells
ax.set_xticks([i + 0.5 for i in range(len(unique_classes))])
ax.set_yticks([i + 0.5 for i in range(len(unique_classes))])
plt.show()
def plot_multiclass_roc_curve(all_labels, all_predictions, EXPERIMENT_NAME="."):
# Step 1: Label Binarization
label_binarizer = LabelBinarizer()
y_onehot = label_binarizer.fit_transform(all_labels)
all_predictions_hot = label_binarizer.transform(all_predictions)
# Step 2: Calculate ROC curves
fpr = dict()
tpr = dict()
roc_auc = dict()
unique_classes = range(y_onehot.shape[1])
for i in unique_classes:
fpr[i], tpr[i], _ = roc_curve(y_onehot[:, i], all_predictions_hot[:, i])
roc_auc[i] = auc(fpr[i], tpr[i])
# Step 3: Plot ROC curves
fig, ax = plt.subplots(figsize=(8, 8))
# Micro-average ROC curve
fpr_micro, tpr_micro, _ = roc_curve(y_onehot.ravel(), all_predictions_hot.ravel())
roc_auc_micro = auc(fpr_micro, tpr_micro)
plt.plot(
fpr_micro,
tpr_micro,
label=f"micro-average ROC curve (AUC = {roc_auc_micro:.2f})",
color="deeppink",
linestyle=":",
linewidth=4,
)
# Macro-average ROC curve
all_fpr = np.unique(np.concatenate([fpr[i] for i in unique_classes]))
mean_tpr = np.zeros_like(all_fpr)
for i in unique_classes:
mean_tpr += np.interp(all_fpr, fpr[i], tpr[i])
mean_tpr /= len(unique_classes)
fpr_macro = all_fpr
tpr_macro = mean_tpr
roc_auc_macro = auc(fpr_macro, tpr_macro)
plt.plot(
fpr_macro,
tpr_macro,
label=f"macro-average ROC curve (AUC = {roc_auc_macro:.2f})",
color="navy",
linestyle=":",
linewidth=4,
)
# Individual class ROC curves with unique colors
colors = plt.cm.rainbow(np.linspace(0, 1, len(unique_classes)))
for class_id, color in zip(unique_classes, colors):
plt.plot(
fpr[class_id],
tpr[class_id],
color=color,
label=f"ROC curve for Class {class_id} (AUC = {roc_auc[class_id]:.2f})",
linewidth=2,
)
plt.plot([0, 1], [0, 1], color='gray', linestyle='--', linewidth=2) # Add diagonal line for reference
plt.axis("equal")
plt.xlabel("False Positive Rate")
plt.ylabel("True Positive Rate")
plt.title("Extension of Receiver Operating Characteristic\n to One-vs-Rest multiclass")
plt.legend()
plt.savefig(f'{EXPERIMENT_NAME}/roc_curve.png')
plt.show()
# Example usage:
plot_multiclass_roc_curve(all_labels, all_predictions, EXPERIMENT_NAME)
# def visualize_predictions(model, val_loader, device, type_label=None, dataset_type=1, unique_classes=np.array([0, 1, 2, 3, 4, 5, 6])):
# criterion = torch.nn.CrossEntropyLoss()
# metric_logger = misc.MetricLogger(delimiter=" ")
# header = 'Test:'
# # switch to evaluation mode
# model.eval()
# all_predictions = []
# all_labels = []
# for batch in metric_logger.log_every(val_loader, 10, header):
# images = batch[0]
# target = batch[-1]
# images = images.to(device, non_blocking=True)
# target = target.to(device, non_blocking=True)
# # compute output
# with torch.cuda.amp.autocast():
# output = model(images)
# loss = criterion(output, target)#
# pred = output.argmax(dim=1)
# all_predictions.append(pred.cpu().numpy())# ADDED
# all_labels.append(target.cpu().numpy())# ADDED
# acc1, acc5 = accuracy(output, target, topk=(1, 5))
# batch_size = images.shape[0]
# metric_logger.update(loss=loss.item())
# metric_logger.meters['acc1'].update(acc1.item(), n=batch_size)
# metric_logger.meters['acc5'].update(acc5.item(), n=batch_size)
# all_predictions = np.array(all_predictions)#.squeeze(0)
# all_labels = np.array(all_labels)#.squeeze(0)
# if type_label is None:
# type_label = unique_classes
# # Create a 4x4 grid for visualization
# num_rows = 4
# num_cols = 4
# plt.figure(figsize=(12, 12))
# for i in range(num_rows * num_cols):
# plt.subplot(num_rows, num_cols, i + 1)
# idx = np.random.randint(len(all_labels))
# import pdb;pdb.set_trace()
# plt.imshow(images[idx].cpu().numpy().squeeze(), cmap='gray')
# # Use the class names instead of numeric labels for Fashion MNIST
# if dataset_type == 1:
# class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']
# predicted_class = class_names[all_predictions[idx]]
# actual_class = class_names[all_labels[idx]]
# else:
# predicted_class = all_predictions[idx]
# actual_class = all_labels[idx]
# plt.title(f'Pred: {predicted_class}\nActual: {actual_class}')
# plt.axis('off')
# plt.tight_layout()
# plt.show()
# visualize_predictions(model, data_loader_val, device, dataset_type=2, unique_classes=unique_classes)
unique_classes
report = classification_report(all_labels, all_predictions, target_names=unique_classes,output_dict=True)# Mostrar el informe de
df = pd.DataFrame(report).transpose()
df.to_csv(os.path.join(EXPERIMENT_NAME, "confusion_matrix.csv"))
print(df)
# Calculate precision, recall, and specificity (micro-averaged)
precision = precision_score(all_labels, all_predictions, average='micro')
recall = recall_score(all_labels, all_predictions, average='micro')
# Calculate true negatives, false positives, and specificity (micro-averaged)
tn = np.sum((all_labels != 1) & (all_predictions != 1))
fp = np.sum((all_labels != 1) & (all_predictions == 1))
specificity = tn / (tn + fp)
# Calculate F1 score (weighted average)
f1 = f1_score(all_labels, all_predictions, average='weighted')
evaluation_metrics = {
"Acc1": metrics['acc1'], # Add acc1 metric
"Acc5": metrics['acc5'], # Add acc5 metric
"loss": metrics['loss'], # Add acc5 metric
"F1 Score": [f1],
"Precision": [precision],
"Recall": [recall],
"Specificity": [specificity]
}
evaluation_metrics
# Create a DataFrame from the dictionary
df = pd.DataFrame(evaluation_metrics)
# Save the DataFrame to a CSV file
df.to_csv(f'{EXPERIMENT_NAME}/evaluation_metrics_for_table.csv', index=False)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
#General imports
import numpy as np
#Operator Imports
from qiskit.opflow import Z, X, I, StateFn, CircuitStateFn, SummedOp
from qiskit.opflow.gradients import Gradient, NaturalGradient, QFI, Hessian
#Circuit imports
from qiskit.circuit import QuantumCircuit, QuantumRegister, Parameter, ParameterVector, ParameterExpression
from qiskit.circuit.library import EfficientSU2
# Instantiate the quantum state
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Instantiate the Hamiltonian observable
H = (2 * X) + Z
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# Print the operator corresponding to the expectation value
print(op)
params = [a, b]
# Define the values to be assigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi}
# Convert the operator and the gradient target params into the respective operator
grad = Gradient().convert(operator = op, params = params)
# Print the operator corresponding to the Gradient
print(grad)
# Assign the parameters and evaluate the gradient
grad_result = grad.assign_parameters(value_dict).eval()
print('Gradient', grad_result)
# Define the Hamiltonian with fixed coefficients
H = 0.5 * X - 1 * Z
# Define the parameters w.r.t. we want to compute the gradients
params = [a, b]
# Define the values to be assigned to the parameters
value_dict = { a: np.pi / 4, b: np.pi}
# Combine the Hamiltonian observable and the state into an expectation value operator
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
print(op)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameters using
# the parameter shift method.
state_grad = Gradient(grad_method='param_shift').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with parameter shift', state_grad_result)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the linear combination of unitaries method.
state_grad = Gradient(grad_method='lin_comb').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with the linear combination method', state_grad_result)
# Convert the expectation value into an operator corresponding to the gradient w.r.t. the state parameter using
# the finite difference method.
state_grad = Gradient(grad_method='fin_diff').convert(operator=op, params=params)
# Print the operator corresponding to the gradient
print(state_grad)
# Assign the parameters and evaluate the gradient
state_grad_result = state_grad.assign_parameters(value_dict).eval()
print('State gradient computed with finite difference', state_grad_result)
# Besides the method to compute the circuit gradients resp. QFI, a regularization method can be chosen:
# `ridge` or `lasso` with automatic parameter search or `perturb_diag_elements` or `perturb_diag`
# which perturb the diagonal elements of the QFI.
nat_grad = NaturalGradient(grad_method='lin_comb', qfi_method='lin_comb_full', regularization='ridge').convert(
operator=op, params=params)
# Assign the parameters and evaluate the gradient
nat_grad_result = nat_grad.assign_parameters(value_dict).eval()
print('Natural gradient computed with linear combination of unitaries', nat_grad_result)
# Instantiate the Hamiltonian observable
H = X
# Instantiate the quantum state with two parameters
a = Parameter('a')
b = Parameter('b')
q = QuantumRegister(1)
qc = QuantumCircuit(q)
qc.h(q)
qc.rz(a, q[0])
qc.rx(b, q[0])
# Combine the Hamiltonian observable and the state
op = ~StateFn(H) @ CircuitStateFn(primitive=qc, coeff=1.)
# Convert the operator and the hessian target coefficients into the respective operator
hessian = Hessian().convert(operator = op, params = [a, b])
# Define the values to be assigned to the parameters
value_dict = {a: np.pi / 4, b: np.pi/4}
# Assign the parameters and evaluate the Hessian w.r.t. the Hamiltonian coefficients
hessian_result = hessian.assign_parameters(value_dict).eval()
print('Hessian \n', np.real(np.array(hessian_result)))
# Define parameters
params = [a, b]
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='param_shift').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the parameter shift method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian
state_hess = Hessian(hess_method='lin_comb').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed using the linear combination of unitaries method\n', (np.array(hessian_result)))
# Get the operator object representing the Hessian using finite difference
state_hess = Hessian(hess_method='fin_diff').convert(operator=op, params=params)
# Assign the parameters and evaluate the Hessian
hessian_result = state_hess.assign_parameters(value_dict).eval()
print('Hessian computed with finite difference\n', (np.array(hessian_result)))
# Wrap the quantum circuit into a CircuitStateFn
state = CircuitStateFn(primitive=qc, coeff=1.)
# Convert the state and the parameters into the operator object that represents the QFI
qfi = QFI(qfi_method='lin_comb_full').convert(operator=state, params=params)
# Define the values for which the QFI is to be computed
values_dict = {a: np.pi / 4, b: 0.1}
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('full QFI \n', np.real(np.array(qfi_result)))
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'block_diagonal'
qfi = QFI('overlap_block_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Block-diagonal QFI \n', np.real(np.array(qfi_result)))
# Convert the state and the parameters into the operator object that represents the QFI
# and set the approximation to 'diagonal'
qfi = QFI('overlap_diag').convert(operator=state, params=params)
# Assign the parameters and evaluate the QFI
qfi_result = qfi.assign_parameters(values_dict).eval()
print('Diagonal QFI \n', np.real(np.array(qfi_result)))
# Execution Imports
from qiskit import Aer
from qiskit.utils import QuantumInstance
# Algorithm Imports
from qiskit.algorithms import VQE
from qiskit.algorithms.optimizers import CG
from qiskit.opflow import I, X, Z
from qiskit.circuit import QuantumCircuit, ParameterVector
from scipy.optimize import minimize
# Instantiate the system Hamiltonian
h2_hamiltonian = -1.05 * (I ^ I) + 0.39 * (I ^ Z) - 0.39 * (Z ^ I) - 0.01 * (Z ^ Z) + 0.18 * (X ^ X)
# This is the target energy
h2_energy = -1.85727503
# Define the Ansatz
wavefunction = QuantumCircuit(2)
params = ParameterVector('theta', length=8)
it = iter(params)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
wavefunction.cx(0, 1)
wavefunction.ry(next(it), 0)
wavefunction.ry(next(it), 1)
wavefunction.rz(next(it), 0)
wavefunction.rz(next(it), 1)
# Define the expectation value corresponding to the energy
op = ~StateFn(h2_hamiltonian) @ StateFn(wavefunction)
grad = Gradient(grad_method='lin_comb')
qi_sv = QuantumInstance(Aer.get_backend('aer_simulator_statevector'),
shots=1,
seed_simulator=2,
seed_transpiler=2)
#Conjugate Gradient algorithm
optimizer = CG(maxiter=50)
# Gradient callable
vqe = VQE(wavefunction, optimizer=optimizer, gradient=grad, quantum_instance=qi_sv)
result = vqe.compute_minimum_eigenvalue(h2_hamiltonian)
print('Result:', result.optimal_value, 'Reference:', h2_energy)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-pocket-guide
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
statevector = Statevector(qc)
print(statevector.data)
import numpy as np
from qiskit.quantum_info import Statevector
statevector = Statevector([1, 0, 0, 1] / np.sqrt(2))
print(statevector.data)
from qiskit.quantum_info import Statevector
statevector = Statevector.from_label('01-')
print(statevector.data)
from qiskit.quantum_info import Statevector
statevector = Statevector.from_label('+-')
print(statevector.data)
statevector.draw("qsphere")
print(statevector.probabilities())
print(statevector.sample_counts(1000))
from qiskit import QuantumCircuit
from qiskit.quantum_info import DensityMatrix
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.z(1)
dens_mat = DensityMatrix(qc)
print(dens_mat.data)
from qiskit.quantum_info import DensityMatrix, \
Operator
dens_mat = 0.5*DensityMatrix.from_label('11') + \
0.5*DensityMatrix.from_label('+0')
print(dens_mat.data)
tt_op = Operator.from_label('TT')
dens_mat = dens_mat.evolve(tt_op)
dens_mat.draw('city')
print(dens_mat.probabilities())
print(dens_mat.sample_counts(1000))
|
https://github.com/Pitt-JonesLab/slam_decomposition
|
Pitt-JonesLab
|
# this notebook is going to test for randomly sampled locally equivalent gate, whether the basis gate set is sufficient to reconstruct the unitary with smushed gates
# we are going to test sqiswap, cnot, and syc as the 3 basis gates realized from gainconversion, CR, and fsim hamiltonians
import logging
logger = logging.getLogger()
logger.setLevel(logging.INFO)
# %matplotlib widget
import numpy as np
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import random_unitary
from slam.basisv2 import CircuitTemplateV2
from slam.utils.gates.custom_gates import ConversionGainSmushGate, ConversionGainGate
from slam.sampler import GateSample
from qiskit.extensions import UnitaryGate
from qiskit.quantum_info import Operator
from slam.optimizer import TemplateOptimizer
from slam.cost_function import BasicCost, SquareCost, MakhlinFunctionalCost
t = 1
timesteps = 4
duration_1q = t / timesteps
bounds_1q = 2 * np.pi
vz_only = False
# fixing these to be iterated over
gc, gg = (1 * np.pi / 2, 0 * np.pi / 4)
varg_offset = (
0 # set to 4 if want to use phase, and change 0s to vargs in pp2 constructor below
)
pp2 = lambda *vargs: ConversionGainSmushGate(
0,
0,
gc,
gg,
vargs[varg_offset : varg_offset + round(t / duration_1q)],
vargs[varg_offset + round(t / duration_1q) :],
t_el=t,
)
basis = CircuitTemplateV2(
n_qubits=2,
base_gates=[pp2],
edge_params=[[(0, 1)]],
vz_only=vz_only,
param_vec_expand=[varg_offset, round(t / duration_1q), round(t / duration_1q)],
)
basis_str = "CG2Q"
# varg_offset = 2
# pp3 =lambda *vargs: ConversionGainSmushGate(vargs[0], vargs[1], gc, gg, vargs[varg_offset:varg_offset+round(t/duration_1q)], vargs[varg_offset+round(t/duration_1q):], t_el=t)
# basis = CircuitTemplateV2(n_qubits=2, base_gates = [pp3], edge_params=[[(0,1)]], vz_only=True, param_vec_expand=[varg_offset,round(t/duration_1q),round(t/duration_1q)])
# basis_str = "CG2Q+P"
basis.build(1)
basis.spanning_range = range(1, 2)
# for all smush gates make bounds
for el in basis.circuit.parameters:
s_el = str(el)
if "Q" in s_el:
basis.add_bound(s_el, bounds_1q, -1 * bounds_1q)
# # manually set the gc, gg bounds
# for el in basis.circuit.parameters:
# s_el = str(el)
# if s_el in ["Q0", "Q1", "Q22", "Q23", "Q44", "Q45"]:
# basis.add_bound(s_el, .5, 0)
# #basis.add_bound(s_el, 0.5*np.pi, 0) #XXX when using riswapgate should be 0.5, but when using ConversionGain should be np.pi/2 !!! BAD BAD BAD
# construct the locally variant target
qc = QuantumCircuit(2)
# qc.append(random_unitary(2), [0])
# qc.append(random_unitary(2), [1])
g = ConversionGainGate(0, 0, gc, gg, t_el=t)
qc.append(g, [0, 1])
# qc.append(random_unitary(2), [0])
# qc.append(random_unitary(2), [1])
# qc.rx(-np.pi/2, 0)
# qc.rx(-np.pi/2, 1)
# qc.draw('mpl');
gate_data = Operator(qc).data
from slam.utils.gates.custom_gates import CanonicalGate
sampler = GateSample(CanonicalGate(np.pi / 4, np.pi / 8, np.pi / 8))
from qiskit.circuit.library import CXGate, SwapGate, CPhaseGate
gate_data = CXGate()
# gate_data = SwapGate()
# gate_data = CPhaseGate(np.pi/2)
sampler = GateSample(UnitaryGate(gate_data))
s = [s for s in sampler][0]
# objective1 = SquareCost()
objective1 = MakhlinFunctionalCost()
optimizer3 = TemplateOptimizer(
basis=basis,
objective=objective1,
use_callback=True,
override_fail=True,
success_threshold=1e-7,
training_restarts=5,
override_method="Nelder-Mead",
)
basis.circuit.draw(output="mpl")
_ret3 = optimizer3.approximate_from_distribution(sampler)
from slam.utils.visualize import optimizer_training_plot
fig = optimizer_training_plot(_ret3[0], _ret3[1])
# save fig as svg
fig.savefig("local_smush_test.svg")
# _ret3 = optimizer3.approximate_target_U(s)
# ret3[2] gets the target_data list, [0] returns the first element over the sampler distribution (we only put one in)
transp1 = basis.reconstruct(_ret3[2][0])
transp1.draw()
# replace the smush gate with smaller gates
from slam.utils.gates.custom_gates import ConversionGainSmushGate
transp2 = QuantumCircuit(2)
# iterate gates in transp1
for gate in transp1:
# if the gate is a smush gate
if isinstance(gate[0], ConversionGainSmushGate):
# get the parameters of the smush gate
params = gate[0].params
# get the qubits of the smush gate
qubits = gate[1]
# replace the smush gate with the smaller set of gates
for i in range(timesteps):
d_gate = ConversionGainSmushGate(
params[0],
params[1],
params[2],
params[3],
[params[4 + i]],
[params[4 + timesteps + i]],
t_el=Parameter(f"t{i}"),
)
transp2.append(d_gate, qubits)
else:
# if the gate is not a smush gate, just append it
transp2.append(gate[0], gate[1])
transp2.draw()
from weylchamber import c1c2c3
endpoints = [2, 3, 4, 5, 6, 7, 9] # XXX hardcoded
# endpoints = [2,3,4,5,6,8]
coordinate_list = []
for end in endpoints:
qc = QuantumCircuit(2)
for gate in transp2[0:end]:
qc.append(gate[0], gate[1])
qc2 = qc.copy()
# if we stop on a 2Q gate
if end in endpoints[1:-1]: # XXX hardcoded
# for all prior 2Q gates, set time parameter to full length
for i in [el for el in endpoints[1:-1] if el < end]:
qc2 = qc2.bind_parameters({qc2[i - 1][0].params[-1]: duration_1q})
# for current 2Q gate, iterate over time and append coordinate
for t in np.linspace(0, duration_1q, 25):
qc3 = qc2.bind_parameters({qc2[end - 1][0].params[-1]: t})
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc3).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
coordinate_list.append(c)
# if we stop on a 1Q gate
else:
# for all prior 2Q gates, set time parameter to full length
for i in [el for el in endpoints[1:-1] if el < end]:
qc2 = qc2.bind_parameters({qc2[i - 1][0].params[-1]: duration_1q})
# eliminating x-axis symmetry
c = list(c1c2c3(Operator(qc2).data))
if c[0] > 0.5:
c[0] = -1 * c[0] + 1
# append coordinate for duration of 1Q gate
for t in np.linspace(0, duration_1q, 25):
coordinate_list.append(c)
# qc2.draw(output='mpl');
from slam.utils.visualize import coordinate_2dlist_weyl
coordinate_2dlist_weyl(
*[coordinate_list[i : i + 25] for i in [0, 25, 50, 75, 100, 125]]
) # , c=np.linspace(0, 1+2*duration_1q, len(coordinate_list)));
from slam.utils.visualize import coordinate_2dlist_weyl
fig = coordinate_2dlist_weyl(
coordinate_list[:150]
) # , c=np.linspace(0, 1+2*duration_1q, len(coordinate_list)));
# save fig as pdf
fig.savefig("cnot_derived_traj.pdf")
# for sqiswap making SWAP, we append a normal sqiswap gate, borrowed from the basic decomposition after we reach this middle point
# XXX hardcoded from decomp_trajectory.ipynb
coordinate_list.extend(
[
[0.49997065, 0.24999824, 0.24997135],
[0.49997065, 0.26041491, 0.26038801],
[0.49997065, 0.27083157, 0.27080468],
[0.49997065, 0.28124824, 0.28122135],
[0.49997065, 0.29166491, 0.29163801],
[0.49997065, 0.30208157, 0.30205468],
[0.49997065, 0.31249824, 0.31247135],
[0.49997065, 0.32291491, 0.32288801],
[0.49997065, 0.33333157, 0.33330468],
[0.49997065, 0.34374824, 0.34372135],
[0.49997065, 0.35416491, 0.35413801],
[0.49997065, 0.36458157, 0.36455468],
[0.49997065, 0.37499824, 0.37497135],
[0.49997065, 0.38541491, 0.38538801],
[0.49997065, 0.39583157, 0.39580468],
[0.49997065, 0.40624824, 0.40622135],
[0.49997065, 0.41666491, 0.41663801],
[0.49997065, 0.42708157, 0.42705468],
[0.49997065, 0.43749824, 0.43747135],
[0.49997065, 0.44791491, 0.44788801],
[0.49997065, 0.45833157, 0.45830468],
[0.49997065, 0.46874824, 0.46872135],
[0.49997065, 0.47916491, 0.47913801],
[0.49997065, 0.48958157, 0.48955468],
[0.49999821, 0.49997201, 0.49996939],
]
)
for t in np.linspace(0, duration_1q, 25):
coordinate_list.append((0.5, 0.5, 0.5))
coordinate_2dlist_weyl(coordinate_list, c=np.linspace(0, 1.8, len(coordinate_list)));
import weylchamber
import numpy as np
from weylchamber import WeylChamber
w = WeylChamber()
# remove all labels
w.labels = {}
# w.labels["I"] = np.array([-0.025, 0. , 0.02 ])
# w.labels["CX"] = np.array([0.425, 0. , 0.01 ])
# w.labels[r"\sqrt{iSwap}"] = np.array([0.25, 0.26, 0.03])
w.plot()
len(coordinate_list)
|
https://github.com/mrvee-qC-bee/NTUQuantum2023
|
mrvee-qC-bee
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.compiler import transpile
from qiskit_ibm_runtime import QiskitRuntimeService
import numpy as np
################# MAKE SURE YOUR API TOKEN IS SAVED ##########################
#Store your API token locally (only need to do once)
#QiskitRuntimeService.save_account(channel='ibm_quantum', token='$API_TOKEN')
##############################################################################
#make sure your qiskit version is up to date
import qiskit.tools.jupyter
%qiskit_version_table
# Create a Quantum Circuit acting on a quantum register of two qubits
circ = QuantumCircuit(2)
print(circ)
# Add a H gate on qubit 0, putting this qubit in superposition.
circ.h(0)
# Add a CX (CNOT) gate on control qubit 0 and target qubit 1, putting
# the qubits in a Bell state.
circ.cx(0, 1)
circ.draw('mpl', style="iqp")
#One can also draw this as an ascii drawing
circ.draw()
#Create the circuit
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
# we can also write "qc = QuantumCircuit(2,2)"
#Add the hadamard and CNOT gates to the circuit
qc.h(0)
qc.cx(0, 1)
qc.draw('mpl', style="iqp")
# Import the SparesPauliOp class and create our observables variable
from qiskit.quantum_info import SparsePauliOp
observable = SparsePauliOp(["II", "XX", "YY", "ZZ"], coeffs=[1, 1, -1, 1])
# Import qiskit primitives
from qiskit.primitives import Estimator
estimator = Estimator()
job = estimator.run(qc, observable)
result = job.result()
print(result)
print(f"Expectation Value of <II+XX-YY+ZZ> = {result.values[0]:.3f}")
from qiskit_ibm_runtime import Estimator, Session
#Initialize a QiskitRuntimeService object
service = QiskitRuntimeService()
#We will use the 127-qubit ibm_nazca backend
backend = service.get_backend('ibm_nazca')
# create a Runtime session for efficient execution (optional)
session = Session(service=service, backend=backend)
# estimator = Estimator(backend=backend)
estimator = Estimator(session=session)
#Here we can get some status information about the backend
status = backend.status()
is_operational = status.operational
jobs_in_queue = status.pending_jobs
print('Operational?: {} \n Jobs in Queue: {}\n'.format(is_operational, jobs_in_queue))
# We can also obtain some configuration information
config = backend.configuration()
print(64*"#","\nConfiguration for: {}, version: {}".format(config.backend_name, config.backend_version))
print(" Number of Qubits: {}".format(config.n_qubits))
print(" Basis Gates: {}".format(config.basis_gates))
print(" OpenPulse Enabled: {}".format(config.open_pulse))
job = estimator.run(qc, observable)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Session ID: {job.session_id}")
print(f">>> Job Status: {job.status()}")
# Use a job id from a previous result
job = service.job("cncfk64xswgg0087jbj0")
print(f">>> Job Status: {job.status()}")
#Examine our results once the job has completed
result = job.result()
print(f">>> {result}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.primitives import Sampler
#Instantiate a new Sampler object
sampler = Sampler()
#We'll also need to add measurement
circ = QuantumCircuit(2)
circ.h(0)
circ.cx(0, 1)
# Insert measurements on all qubits
circ.measure_all()
circ.draw('mpl', style='iqp')
# Now run the job and examine the results
sampler_job = sampler.run(circ)
result = sampler_job.result()
print(f"Job Result:\n>>> {result}")
print(f" > Quasi-probability distribution (integer): {result.quasi_dists[0]}")
print(f" > Quasi-probability distribution (bits): {result.quasi_dists[0].binary_probabilities(2)}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit_ibm_runtime import Sampler
#Initialize a QiskitRuntimeService object
service = QiskitRuntimeService()
#We will use the 127-qubit ibm_nazca backend
backend = service.get_backend('ibm_nazca')
# sampler = Sampler(backend=backend)
sampler = Sampler(session=session)
job = sampler.run(circ)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Session ID: {job.session_id}")
print(f">>> Job Status: {job.status()}")
# Use a job id from a previous result
job = service.job("cncfm89hga30008f2660")
print(f">>> Job Status: {job.status()}")
result = job.result()
print(f"Job Result:\n>>> {result}")
print(f" > Quasi-probability distribution (integer): {result.quasi_dists[0]}")
print(f" > Quasi-probability distribution (bits): {result.quasi_dists[0].binary_probabilities(2)}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.visualization import plot_distribution
import matplotlib.pyplot as plt
plt.style.use('dark_background')
#plot_distribution(result.quasi_dists[0])
plot_distribution(result.quasi_dists[0].binary_probabilities(2))
from qiskit_ibm_runtime import Options
# To set our resilience and optimization level we need to create this `Options` object
options = Options()
options.resilience_level = 2
options.optimization_level = 3
# We'll prepare the same example circuit as before
qr = QuantumRegister(2)
cr = ClassicalRegister(2)
qc = QuantumCircuit(qr, cr)
# we can also write "qc = QuantumCircuit(2,2)"
#Add the hadamard and CNOT gates to the circuit
qc.h(0)
qc.cx(0, 1)
# We'll also instantiate a new Runtime Estimator() object
# estimator = Estimator(options=options, backend=backend)
estimator = Estimator(options=options, session=session)
# and use the same observable as before
observable = SparsePauliOp(["II", "XX", "YY", "ZZ"], coeffs=[1, 1, -1, 1])
job = estimator.run(circuits=qc, observables=observable)
print(f">>> Job ID: {job.job_id()}")
print(f">>> Session ID: {job.session_id}")
print(f">>> Job Status: {job.status()}")
# Use a job id from a previous result
job = service.job("cn9ee48q2k7g0088qvzg")
print(f">>> Job Status: {job.status()}")
#Examine our results once the job has completed
result = job.result()
print(f">>> {result}")
print(f" > Expectation value: {result.values[0]}")
print(f" > Metadata: {result.metadata[0]}")
from qiskit.providers.fake_provider import FakeSherbrooke
from qiskit import QuantumCircuit
backend = FakeSherbrooke()
print(backend.operation_names)
qc = QuantumCircuit(2)
qc.swap(0, 1)
qc.draw('mpl', style='iqp')
qc.decompose().draw('mpl')
qc = QuantumCircuit(3)
qc.ccx(0, 1, 2)
qc.draw('mpl')
qc.decompose().draw('mpl')
|
https://github.com/WhenTheyCry96/qiskitHackathon2022
|
WhenTheyCry96
|
import warnings
warnings.filterwarnings('ignore')
from qiskit_metal import designs, MetalGUI
design = designs.DesignPlanar()
design.overwrite_enabled = True
design.chips.main.size_x = '12mm'
design.chips.main.size_y = '10mm'
gui = MetalGUI(design)
from qiskit_metal.qlibrary.qubits.transmon_pocket_cl import TransmonPocketCL
design.delete_all_components()
design_span_x = 5
design_span_y = 3
half_chip_width = design_span_x / 2
half_chip_height = design_span_y / 2
connection_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
b = dict(loc_W=1, loc_H=1),
c = dict(loc_W=-1, loc_H=-1)
)
connection23_pads_options = dict(
a = dict(loc_W=1, loc_H=-1),
c = dict(loc_W=-1, loc_H=-1)
)
transmons = []
transmons.append(TransmonPocketCL(design, 'Q1',
options=dict(pos_x=f'-{half_chip_width}mm',
pos_y=f'{-half_chip_height}mm',
connection_pads=dict(**connection_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q2',
options=dict(pos_x=f'0mm',
pos_y=f'{half_chip_height}mm',
orientation=-90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q3',
options=dict(pos_x=f'0mm',
pos_y=f'{-half_chip_height}mm',
orientation=90,
connection_pads=dict(d=dict(loc_W=-1, loc_H=1), **connection23_pads_options))))
transmons.append(TransmonPocketCL(design, 'Q4',
options=dict(pos_x=f'{half_chip_width}mm',
pos_y=f'{half_chip_height}mm',
orientation=180,
connection_pads=dict(**connection_pads_options))))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.meandered import RouteMeander
from qiskit_metal import Dict
fillet='99.99um'
options = Dict(
meander=Dict(
lead_start='0.1mm',
lead_end='0.1mm',
asymmetry='0 um')
)
def connect(component_name: str, component1: str, pin1: str, component2: str, pin2: str,
length: str,
asymmetry='0 um', start_strght='0 um', end_strght='0 um', flip=False):
"""Connect two pins with a CPW."""
myoptions = Dict(
pin_inputs=Dict(
start_pin=Dict(
component=component1,
pin=pin1),
end_pin=Dict(
component=component2,
pin=pin2)),
lead=Dict(
start_straight=start_strght,
end_straight=end_strght
),
total_length=length,
fillet = '99.9um')
myoptions.update(options)
myoptions.meander.asymmetry = asymmetry
myoptions.meander.lead_direction_inverted = 'true' if flip else 'false'
return RouteMeander(design, component_name, myoptions)
asym_h = 100
asym_v = 100
cpw = []
cpw.append(connect('cpw1', 'Q1', 'b', 'Q2', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw3', 'Q4', 'b', 'Q3', 'a', '8 mm', f'+{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw4', 'Q3', 'd', 'Q1', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
cpw.append(connect('cpw5', 'Q2', 'd', 'Q4', 'a', '8 mm', f'-{asym_h}um', '0.1mm', '0.1mm'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.terminations.launchpad_wb_coupled import LaunchpadWirebondCoupled
readouts_lwc = []
control_lwc = []
offset_x = 0
offset_y = 1
#Readouts
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R1',
options = dict(
pos_x = '-5mm',
pos_y = f'-{half_chip_height+offset_y}mm',
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R2',
options = dict(
pos_x = '-1mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R3',
options = dict(
pos_x = '1mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
readouts_lwc.append(LaunchpadWirebondCoupled(design, 'R4',
options = dict(
pos_x = '5mm',
pos_y = f'{half_chip_height+offset_y}mm',
orientation = 180,
lead_length = '30um')))
#Controls
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL1',
options = dict(
pos_x = '-5mm',
pos_y = '2mm',
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL2',
options = dict(
pos_x = '4mm',
pos_y = '4mm',
orientation = -90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL3',
options = dict(
pos_x = '-4mm',
pos_y = '-4mm',
orientation = 90,
lead_length = '30um')))
control_lwc.append(LaunchpadWirebondCoupled(design, 'CL4',
options = dict(
pos_x = '5mm',
pos_y = '-2mm',
orientation = 180,
lead_length = '30um')))
gui.rebuild()
gui.autoscale()
readout_lines = []
asym_14 = 700
asym_23 = 700
options = Dict(
lead=Dict(
start_straight='330um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol1', 'Q1', 'c', 'R1', 'tie', '8 mm', f'{asym_14}um'))
options = Dict(
lead=Dict(
start_straight='430um',
end_straight='0um'),
fillet='99.99um')
readout_lines.append(connect('ol2', 'Q2', 'c', 'R2', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol3', 'Q3', 'c', 'R3', 'tie', '8 mm', f'{asym_23}um'))
readout_lines.append(connect('ol4', 'Q4', 'c', 'R4', 'tie', '8 mm', f'{asym_14}um'))
gui.rebuild()
gui.autoscale()
from qiskit_metal.qlibrary.tlines.anchored_path import RouteAnchors
from collections import OrderedDict
import numpy as np
control_lines = []
def connectRouteAnchor(name: str,
component1: str, pin1: str, component2: str, pin2: str,
anchor_points: OrderedDict) -> RouteAnchors:
options_line_cl = dict(
pin_inputs = dict(start_pin = dict(component = component1, pin = pin1),
end_pin = dict(component = component2, pin = pin2)),
anchors = anchor_points,
lead = dict(start_straight = '200um',
end_straight = '225um'),
fillet = fillet
)
return RouteAnchors(design, name, options_line_cl)
anchors1c = OrderedDict()
anchors1c[0] = np.array([-4, -1.42])
anchors1c[1] = np.array([-4, 2])
control_lines.append(connectRouteAnchor('line_cl1', 'Q1', 'Charge_Line', 'CL1', 'tie', anchors1c))
anchors2c = OrderedDict()
anchors2c[0] = np.array([0.08, 3.25])
anchors2c[1] = np.array([4, 3.25])
control_lines.append(connectRouteAnchor('line_cl2', 'Q2', 'Charge_Line', 'CL2', 'tie', anchors2c))
anchors3c = OrderedDict()
anchors3c[0] = np.array([-0.08, -3.25])
anchors3c[1] = np.array([-4, -3.25])
control_lines.append(connectRouteAnchor('line_cl3', 'Q3', 'Charge_Line', 'CL3', 'tie', anchors3c))
anchors4c = OrderedDict()
anchors4c[0] = np.array([4, 1.42])
anchors4c[1] = np.array([4, -2])
control_lines.append(connectRouteAnchor('line_cl4', 'Q4', 'Charge_Line', 'CL4', 'tie', anchors4c))
gui.rebuild()
gui.autoscale()
gui.autoscale()
gui.screenshot(name="full_design")
import numpy as np
from scipy.constants import c, h, pi, hbar, e
from qiskit_metal.analyses.em.cpw_calculations import guided_wavelength
# constants:
phi0 = h/(2*e)
varphi0 = phi0/(2*pi)
# project target parameters
f_qList = np.around(np.linspace(5.25, 5.75, 4),2) # GHz
f_rList = f_qList + 1.8 # GHz
L_JJList = np.around(varphi0**2/((f_qList*1e9+300e6)**2/(8*300e6))/h*1e9, 2) # nH
# initial CPW readout lengths
def find_resonator_length(frequency, line_width, line_gap, N):
#frequency in GHz
#line_width/line_gap in um
#N -> 2 for lambda/2, 4 for lambda/4
[lambdaG, etfSqrt, q] = guided_wavelength(frequency*10**9, line_width*10**-6,
line_gap*10**-6, 750*10**-6, 200*10**-9)
return str(lambdaG/N*10**3)+" mm"
find_resonator_length(f_rList, 10, 6, 2)
find_resonator_length(np.around(np.linspace(8, 9.2, 4), 2), 10, 6, 2)
transmons[0].options.pad_gap = '40um'
transmons[0].options.pad_width = '550um' # 405
transmons[0].options.pad_height = '120um'
transmons[1].options.pad_gap = '40um'
transmons[1].options.pad_width = '500um' # 405
transmons[1].options.pad_height = '120um'
transmons[2].options.pad_gap = '40um'
transmons[2].options.pad_width = '370um' # 405
transmons[2].options.pad_height = '120um'
transmons[2].options.connection_pads.d.pad_gap='10um'
transmons[2].options.connection_pads.a.pad_gap='10um'
transmons[2].options.connection_pads.c.pad_gap='10um'
transmons[3].options.pad_gap = '40um'
transmons[3].options.pad_width = '440um' # 405
transmons[3].options.pad_height = '120um'
readout_lines[0].options.total_length = '8.63mm'
readout_lines[1].options.total_length = '8.42mm'
readout_lines[2].options.total_length = '8.24mm'
readout_lines[3].options.total_length = '8.06mm'
cpw[0].options.total_length = '7mm'
cpw[1].options.total_length = '7mm'
cpw[2].options.total_length = '7mm'
cpw[3].options.total_length = '7mm'
gui.rebuild()
gui.autoscale()
qcomps = design.components # short handle (alias)
qcomps['Q1'].options['hfss_inductance'] = 'Lj1'
qcomps['Q1'].options['hfss_capacitance'] = 'Cj1'
qcomps['Q2'].options['hfss_inductance'] = 'Lj2'
qcomps['Q2'].options['hfss_capacitance'] = 'Cj2'
qcomps['Q3'].options['hfss_inductance'] = 'Lj3'
qcomps['Q3'].options['hfss_capacitance'] = 'Cj3'
qcomps['Q4'].options['hfss_inductance'] = 'Lj4'
qcomps['Q4'].options['hfss_capacitance'] = 'Cj4'
from qiskit_metal.analyses.quantization import EPRanalysis, LOManalysis
from qiskit_metal.analyses.quantization.lumped_capacitive import load_q3d_capacitance_matrix
from qiskit_metal.analyses.quantization.lom_core_analysis import CompositeSystem, Cell, Subsystem, QuantumSystemRegistry
c1 = LOManalysis(design, "q3d")
q3d1 = c1.sim.renderer
q3d1.start()
q3d1.activate_ansys_design("Q3only_busopen_370_gap_reduced", 'capacitive')
q3d1.render_design(['Q3', 'R3', 'cpw3', 'cpw4', 'ol3', 'line_cl3', 'CL3'], [('cpw3', 'start'),('cpw4', 'end')])
q3d1.add_q3d_setup(name="Setup", max_passes=15, min_converged_passes=5,percent_error=0.05)
q3d1.analyze_setup("Setup")
c1.sim.capacitance_matrix, c1.sim.units = q3d1.get_capacitance_matrix()
c1.sim.capacitance_all_passes, _ = q3d1.get_capacitance_all_passes()
c1.sim.capacitance_matrix
t3_mat = c1.sim.capacitance_matrix
path3 = "./capacitance_matrices/Project19_Q3only_busopen_460.txt"
t3_mat, _, _, _ = load_q3d_capacitance_matrix(path3)
t3_mat
opt3 = dict(
cap_mat = t3_mat,
ind_dict = {('pad_top_Q3', 'pad_bot_Q3'): 12}, # junction inductance in nH
jj_dict = {('pad_top_Q3', 'pad_bot_Q3'): 'j3'},
cj_dict = {('pad_top_Q3', 'pad_bot_Q3'): 1}, # junction capacitance in fF
)
cell_3 = Cell(opt3)
transmon3 = Subsystem(name='transmon3', sys_type='TRANSMON', nodes=['j3'])
# Resonator Subsystems
from scipy.constants import speed_of_light as c_light
q_opts = dict(
Z0 = 50, # characteristic impedance in Ohm
vp = 0.404314 * c_light # phase velocity
)
ro3 = Subsystem(name='c_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['c_connector_pad_Q3'], q_opts=dict(f_res = 7.38, **q_opts))
coup34 = Subsystem(name='a_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['a_connector_pad_Q3'], q_opts=dict(f_res = 7.5, **q_opts))
coup31 = Subsystem(name='d_connector_pad_Q3', sys_type='TL_RESONATOR', nodes=['d_connector_pad_Q3'], q_opts=dict(f_res = 7.5, **q_opts))
composite_sys = CompositeSystem(
subsystems=[transmon3, ro3, coup34, coup31],
cells=[cell_3],
grd_node='ground_main_plane',
nodes_force_keep=['c_connector_pad_Q3', 'a_connector_pad_Q3', 'd_connector_pad_Q3']
)
cg = composite_sys.circuitGraph()
print(cg)
hilbertspace = composite_sys.create_hilbertspace()
print(hilbertspace)
# Convert the hilbert space into
# "Interaction Picture"
hilbertspace = composite_sys.add_interaction()
hilbertspace.hamiltonian()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
hamiltonian_results = composite_sys.hamiltonian_results(hilbertspace, evals_count=30)
composite_sys.compute_gs()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
# Build a quantum circuit
circuit = QuantumCircuit(3, 3)
circuit.x(1)
circuit.h(range(3))
circuit.cx(0, 1)
circuit.measure(range(3), range(3));
print(circuit)
circuit.draw()
# Matplotlib Drawing
circuit.draw(output='mpl')
# Draw a new circuit with barriers and more registers
q_a = QuantumRegister(3, name='qa')
q_b = QuantumRegister(5, name='qb')
c_a = ClassicalRegister(3)
c_b = ClassicalRegister(5)
circuit = QuantumCircuit(q_a, q_b, c_a, c_b)
circuit.x(q_a[1])
circuit.x(q_b[1])
circuit.x(q_b[2])
circuit.x(q_b[4])
circuit.barrier()
circuit.h(q_a)
circuit.barrier(q_a)
circuit.h(q_b)
circuit.cswap(q_b[0], q_b[1], q_b[2])
circuit.cswap(q_b[2], q_b[3], q_b[4])
circuit.cswap(q_b[3], q_b[4], q_b[0])
circuit.barrier(q_b)
circuit.measure(q_a, c_a)
circuit.measure(q_b, c_b);
# Draw the circuit
circuit.draw(output='mpl')
# Draw the circuit with reversed bit order
circuit.draw(output='mpl', reverse_bits=True)
# Draw the circuit without barriers
circuit.draw(output='mpl', plot_barriers=False)
# Draw the circuit without barriers and reverse bit order
circuit.draw(output='mpl', plot_barriers=False, reverse_bits=True)
# Set line length to 80 for above circuit
circuit.draw(output='text')
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
circuit.draw(output='mpl', style=style)
# Scale the mpl output to 1/2 the normal size
circuit.draw(output='mpl', scale=0.5)
from qiskit.tools.visualization import circuit_drawer
circuit_drawer(circuit, output='mpl', plot_barriers=False)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/pathakis/Introduction-To-Qiskit
|
pathakis
|
from collections import namedtuple
import matplotlib.pyplot as plt
import numpy as np
import qutip
from qutip import Qobj, Bloch, basis, ket, tensor
import seaborn as sns
sns.set_theme(style="whitegrid")
%matplotlib inline
from qiskit import QuantumCircuit, Aer, transpile, assemble
from qiskit.visualization import plot_histogram
from math import gcd
from numpy.random import randint
import pandas as pd
from fractions import Fraction
print("Imports Successful")
b = Bloch()
up = ket("0")
down = ket("1")
b.add_states([up, down])
b.show()
b = Bloch()
b0 = (up+(0+1j)*down)/np.sqrt(2) # (|0> + |1>) / √2 (green)
b1 = (up-(0+1j)*down)/np.sqrt(2) # (|0> - |1>) / √2 (orange)
b.add_states([b0, b1])
b.show()
qc = QuantumCircuit(1)
qc.h(0)
qc.draw()
def c_amod15(a, power):
"""Controlled multiplication by a mod 15"""
if a not in [2,7,8,11,13]:
raise ValueError("'a' must be 2,7,8,11 or 13")
U = QuantumCircuit(4)
for iteration in range(power):
if a in [2,13]:
U.swap(0,1)
U.swap(1,2)
U.swap(2,3)
if a in [7,8]:
U.swap(2,3)
U.swap(1,2)
U.swap(0,1)
if a == 11:
U.swap(1,3)
U.swap(0,2)
if a in [7,11,13]:
for q in range(4):
U.x(q)
U = U.to_gate()
U.name = "%i^%i mod 15" % (a, power)
c_U = U.control()
return c_U
# Specify variables
n_count = 8 # number of counting qubits
a = 7
def qft_dagger(n):
"""n-qubit QFTdagger the first n qubits in circ"""
qc = QuantumCircuit(n)
# Don't forget the Swaps!
for qubit in range(n//2):
qc.swap(qubit, n-qubit-1)
for j in range(n):
for m in range(j):
qc.cp(-np.pi/float(2**(j-m)), m, j)
qc.h(j)
qc.name = "QFT†"
return qc
# Create QuantumCircuit with n_count counting qubits
# plus 4 qubits for U to act on
qc = QuantumCircuit(n_count + 4, n_count)
# Initialise counting qubits
# in state |+>
for q in range(n_count):
qc.h(q)
# And auxiliary register in state |1>
qc.x(3+n_count)
# Do controlled-U operations
for q in range(n_count):
qc.append(c_amod15(a, 2**q),
[q] + [i+n_count for i in range(4)])
# Do inverse-QFT
qc.append(qft_dagger(n_count), range(n_count))
# Measure circuit
qc.measure(range(n_count), range(n_count))
qc.draw(fold=-1) # -1 means 'do not fold'
qasm_sim = Aer.get_backend('qasm_simulator')
t_qc = transpile(qc, qasm_sim)
qobj = assemble(t_qc)
results = qasm_sim.run(qobj).result()
counts = results.get_counts()
plot_histogram(counts)
rows, measured_phases = [], []
for output in counts:
decimal = int(output, 2) # Convert (base 2) string to decimal
phase = decimal/(2**n_count) # Find corresponding eigenvalue
measured_phases.append(phase)
# Add these values to the rows in our table:
rows.append([f"{output}(bin) = {decimal:>3}(dec)",
f"{decimal}/{2**n_count} = {phase:.2f}"])
# Print the rows in a table
headers=["Register Output", "Phase"]
df = pd.DataFrame(rows, columns=headers)
print(df)
Fraction(0.666)
# Get fraction that most closely resembles 0.666
# with denominator < 15
Fraction(0.666).limit_denominator(15)
rows = []
for phase in measured_phases:
frac = Fraction(phase).limit_denominator(15)
rows.append([phase, f"{frac.numerator}/{frac.denominator}", frac.denominator])
# Print as a table
headers=["Phase", "Fraction", "Guess for r"]
df = pd.DataFrame(rows, columns=headers)
print(df)
N = 15
np.random.seed(1) # This is to make sure we get reproduceable results
a = randint(2, 15)
print(a)
from math import gcd # greatest common divisor
gcd(a, N)
def qpe_amod15(a):
n_count = 8
qc = QuantumCircuit(4+n_count, n_count)
for q in range(n_count):
qc.h(q) # Initialise counting qubits in state |+>
qc.x(3+n_count) # And auxiliary register in state |1>
for q in range(n_count): # Do controlled-U operations
qc.append(c_amod15(a, 2**q),
[q] + [i+n_count for i in range(4)])
qc.append(qft_dagger(n_count), range(n_count)) # Do inverse-QFT
qc.measure(range(n_count), range(n_count))
# Simulate Results
qasm_sim = Aer.get_backend('qasm_simulator')
# Setting memory=True below allows us to see a list of each sequential reading
t_qc = transpile(qc, qasm_sim)
obj = assemble(t_qc, shots=1)
result = qasm_sim.run(qobj, memory=True).result()
readings = result.get_memory()
print("Register Reading: " + readings[0])
phase = int(readings[0],2)/(2**n_count)
print("Corresponding Phase: %f" % phase)
return phase
phase = qpe_amod15(a) # Phase = s/r
Fraction(phase).limit_denominator(15) # Denominator should (hopefully!) tell us r
frac = Fraction(phase).limit_denominator(15)
s, r = frac.numerator, frac.denominator
print(r)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
print(guesses)
start = time.perf_counter()
a = 7
factor_found = False
attempt = 0
while not factor_found:
attempt += 1
print("\nAttempt %i:" % attempt)
phase = qpe_amod15(a) # Phase = s/r
frac = Fraction(phase).limit_denominator(N) # Denominator should (hopefully!) tell us r
r = frac.denominator
print("Result: r = %i" % r)
if phase != 0:
# Guesses for factors are gcd(x^{r/2} ±1 , 15)
guesses = [gcd(a**(r//2)-1, N), gcd(a**(r//2)+1, N)]
print("Guessed Factors: %i and %i" % (guesses[0], guesses[1]))
for guess in guesses:
if guess not in [1,N] and (N % guess) == 0: # Check to see if guess is a factor
print("*** Non-trivial factor found: %i ***" % guess)
factor_found = True
elapsed = time.perf_counter() - start
print('Elapsed %.3f seconds.' % elapsed)
from matplotlib import pyplot
import numpy as np
import timeit
from functools import partial
import random
def fsquare(N):
"""
O(n^2) function
"""
for i in range(N):
for j in range(N):
x = i*j
def flog(N):
for i in range(N):
np.log(N)
def plotTC(fn, nMin, nMax, nInc, nTests):
"""
Run timer and plot time complexity
"""
x = []
y = []
for i in range(nMin, nMax, nInc):
N = i
testNTimer = timeit.Timer(partial(fn, N))
t = testNTimer.timeit(number=nTests)
x.append(i)
y.append(t)
p1 = pyplot.plot(x, y, 'o')
# main() function
def main():
print('Analyzing Algorithms...')
plotTC(fsquare, 10, 1000, 10, 10)
plotTC(flog, 10,1000,10,10)
pyplot.xlabel('N')
pyplot.ylabel('O Complexity')
pyplot.show()
if __name__ == '__main__':
main()
|
https://github.com/sergiogh/qpirates-qiskit-notebooks
|
sergiogh
|
from qiskit.quantum_info import Operator
from qiskit import QuantumCircuit
import numpy as np
def phase_oracle(n, solutions, name = 'Oracle'):
qc = QuantumCircuit(n, name=name)
oracle_matrix = np.identity(2**n)
for solution in solutions:
oracle_matrix[solution, solution] = -1
qc.unitary(Operator(oracle_matrix), range(n))
return qc
def diffuser(n):
qc = QuantumCircuit(n, name='Diffuser')
qc.h(range(n))
qc.append(phase_oracle(n, [0]), range(n))
qc.h(range(n))
return qc
def Grover(n, solutions):
qc = QuantumCircuit(n, n)
r = int(np.floor(np.pi/4*np.sqrt(2**n/len(solutions))))
print(f'{n} qubits, basis states {solutions} marked, {r} rounds')
qc.h(range(n))
for _ in range(r):
qc.append(phase_oracle(n, solutions), range(n))
qc.append(diffuser(n), range(n))
qc.measure(range(n), range(n))
return qc
circuit = Grover(8, [1, 42, 120, 199, 250])
circuit.draw(output='text')
from qiskit import Aer, execute
simulator = Aer.get_backend('qasm_simulator')
counts = execute(circuit, backend=simulator).result().get_counts(circuit)
from qiskit.visualization import plot_histogram
plot_histogram(counts)
|
https://github.com/ctuning/ck-qiskit
|
ctuning
|
# 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.
"""
Example use of the initialize gate to prepare arbitrary pure states.
"""
import math
from qiskit import QuantumCircuit, execute, BasicAer
###############################################################
# Make a quantum circuit for state initialization.
###############################################################
circuit = QuantumCircuit(4, 4, name="initializer_circ")
desired_vector = [
1 / math.sqrt(4) * complex(0, 1),
1 / math.sqrt(8) * complex(1, 0),
0,
0,
0,
0,
0,
0,
1 / math.sqrt(8) * complex(1, 0),
1 / math.sqrt(8) * complex(0, 1),
0,
0,
0,
0,
1 / math.sqrt(4) * complex(1, 0),
1 / math.sqrt(8) * complex(1, 0),
]
circuit.initialize(desired_vector, [0, 1, 2, 3])
circuit.measure([0, 1, 2, 3], [0, 1, 2, 3])
print(circuit)
###############################################################
# Execute on a simulator backend.
###############################################################
shots = 10000
# Desired vector
print("Desired probabilities: ")
print([format(abs(x * x), ".3f") for x in desired_vector])
# Initialize on local simulator
sim_backend = BasicAer.get_backend("qasm_simulator")
job = execute(circuit, sim_backend, shots=shots)
result = job.result()
counts = result.get_counts(circuit)
qubit_strings = [format(i, "04b") for i in range(2**4)]
print("Probabilities from simulator: ")
print([format(counts.get(s, 0) / shots, ".3f") for s in qubit_strings])
|
https://github.com/jonasmaziero/computacao_quantica_qiskit
|
jonasmaziero
|
%run init.ipynb
|
https://github.com/matteoacrossi/oqs-jupyterbook
|
matteoacrossi
|
from qiskit import QuantumRegister, QuantumCircuit
# Quantum register
q = QuantumRegister(2, name='q')
# Quantum circuit
bell = QuantumCircuit(q)
# Create a Bell state
bell.x(q[0])
bell.x(q[1])
bell.h(q[0])
bell.cx(q[0], q[1])
# Draw circuit
bell.draw(output = 'mpl')
# Quantum register
q = QuantumRegister(2, name='q')
# Quantum circuit
entangled = QuantumCircuit(q)
# Entangled state
entangled.h(q[0])
entangled.s(q[0])
entangled.cx(q[0], q[1])
entangled.h(q[0])
# Draw circuit
entangled.draw(output='mpl')
# Quantum register
q = QuantumRegister(2, name='q')
# Quantum circuit
channel = QuantumCircuit(q)
# CNOT gate
channel.cx(q[0], q[1])
# Draw circuit
channel.draw(output='mpl')
# Quantum register
q = QuantumRegister(2, name='q')
# Quantum circuit
channel = QuantumCircuit(q)
# CNOT gate
channel.h(q[1])
channel.cz(q[0], q[1])
channel.cx(q[1], q[0])
# Draw circuit
channel.draw(output='mpl')
from qiskit import IBMQ, execute
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit.tools.visualization import plot_histogram, plot_state_city
IBMQ.load_account()
backend = IBMQ.get_provider().get_backend('ibmqx2')
# qiskit-ignis provides tools for noise mitigation
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter, MeasurementFilter
# For visualizing the circuits
import matplotlib.pyplot as plt
# Suppose we have a 5-qubit quantum computer, and we want to perform measurements on qubits 0 and 2
# We first initialize a 5-qubit quantum register
q = QuantumRegister(5)
# Next, we generate the calibration circuits
meas_calibs, state_labels = complete_meas_cal(qubit_list=[0,2], qr=q)
# We can plot them
fig, axes = plt.subplots(1, 4)
for i, circuit in enumerate(meas_calibs):
circuit.draw(output='mpl', ax=axes[i], scale=2)
print("State labels:",state_labels)
# We now perform the calibration on the real device
job_calibration = execute(meas_calibs, backend=backend)
cal_results = job_calibration.result()
# We now calculate the calibration matrix from the outcomes
meas_fitter = CompleteMeasFitter(cal_results, state_labels)
meas_fitter.plot_calibration()
# What is the measurement fidelity?
print("Average Measurement Fidelity: %f" % meas_fitter.readout_fidelity())
# Make a 2Q Bell state between Q0 and Q2
c = ClassicalRegister(2)
bell = QuantumCircuit(q)
bell.x(q[0])
bell.x(q[2])
bell.h(q[0])
bell.cx(q[0], q[2])
meas = QuantumCircuit(q, c)
meas.measure(q[0],c[0])
meas.measure(q[2],c[1])
qc = bell + meas
qc.draw(output='mpl')
# We execute the circuit
job = execute(qc, backend=backend, shots=5000)
results = job.result()
# We also simulate the circuit in a noiseless case
from qiskit import Aer
simjob = execute(qc, backend=Aer.get_backend('qasm_simulator'), shots=10000)
simresults = simjob.result()
# We get the raw counts
raw_counts = results.get_counts()
sim_counts = simresults.get_counts()
# ... and the mitigated counts
# First we need to get the measurement filter object
meas_filter = meas_fitter.filter
# and then we apply it to the results
mitigated_results = meas_filter.apply(results)
mitigated_counts = mitigated_results.get_counts(0)
plot_histogram([sim_counts, raw_counts, mitigated_counts], legend=['simulated', 'raw', 'mitigated'])
# We import the required classes from ignis.
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.tools.qi.qi import partial_trace
job_state_vec = execute(bell, Aer.get_backend('statevector_simulator'))
state_vec = partial_trace(job_state_vec.result().get_statevector(), [1, 3, 4])
plot_state_city(state_vec)
# We construct all the tomographic circuits
qst = state_tomography_circuits(bell, [q[0], q[2]])
# We can plot them
fig, axes = plt.subplots(3, 3)
for i, circuit in enumerate(qst):
row = i // 3
col = i % 3
circuit.draw(output='mpl', ax=axes[row, col], scale=2)
# We execute the tomography circuits on the real device
job = execute(qst, backend=backend)
# We create a StateTomographyFitter from the job result and the tomography circuit
tomo_fitter = StateTomographyFitter(job.result(), qst)
# To obtain the
rho_tomo = tomo_fitter.fit()
plot_state_city(rho_tomo)
plot_state_city(state_vec)
# Import the state_fidelity function
from qiskit.quantum_info import state_fidelity
# Exercise code:
# ...
# ...
|
https://github.com/hephaex/Quantum-Computing-Awesome-List
|
hephaex
|
import cirq
import random
def main(qubit_count = 8):
circuit_sample_count = 3
# Choose qubits to use.
input_qubits = [cirq.GridQubit(i, 0) for i in range(qubit_count)]
output_qubit = cirq.GridQubit(qubit_count, 0)
# Pick coefficients for the oracle and create a circuit to query it.
secret_bias_bit = random.randint(0, 1)
secret_factor_bits = [random.randint(0, 1) for _ in range(qubit_count)]
oracle = make_oracle(input_qubits,
output_qubit,
secret_factor_bits,
secret_bias_bit)
print('Secret function:\nf(a) = a·<{}> + {} (mod 2)'.format(
', '.join(str(e) for e in secret_factor_bits),
secret_bias_bit))
# Embed the oracle into a special quantum circuit querying it exactly once.
circuit = make_bernstein_vazirani_circuit(
input_qubits, output_qubit, oracle)
print('Circuit:')
print(circuit)
# Sample from the circuit a couple times.
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=circuit_sample_count)
frequencies = result.histogram(key='result', fold_func=bitstring)
print('Sampled results:\n{}'.format(frequencies))
# Check if we actually found the secret value.
most_common_bitstring = frequencies.most_common(1)[0][0]
print('Most common matches secret factors:\n{}'.format(
most_common_bitstring == bitstring(secret_factor_bits)))
def make_oracle(input_qubits,
output_qubit,
secret_factor_bits,
secret_bias_bit):
"""Gates implementing the function f(a) = a·factors + bias (mod 2)."""
if secret_bias_bit:
yield cirq.X(output_qubit)
for qubit, bit in zip(input_qubits, secret_factor_bits):
if bit:
yield cirq.CNOT(qubit, output_qubit)
def make_bernstein_vazirani_circuit(input_qubits, output_qubit, oracle):
"""Solves for factors in f(a) = a·factors + bias (mod 2) with one query."""
c = cirq.Circuit()
# Initialize qubits.
c.append([
cirq.X(output_qubit),
cirq.H(output_qubit),
cirq.H.on_each(*input_qubits),
])
# Query oracle.
c.append(oracle)
# Measure in X basis.
c.append([
cirq.H.on_each(*input_qubits),
cirq.measure(*input_qubits, key='result')
])
return c
def bitstring(bits):
return ''.join(str(int(b)) for b in bits)
if __name__ == '__main__':
main()
|
https://github.com/orpgol/quantum_algorithms_qiskit
|
orpgol
|
"""Python implementation of Grovers algorithm through use of the Qiskit library to find the value 3 (|11>)
out of four possible values."""
#import numpy and plot library
import matplotlib.pyplot as plt
import numpy as np
# importing Qiskit
from qiskit import IBMQ, Aer, QuantumCircuit, ClassicalRegister, QuantumRegister, execute
from qiskit.providers.ibmq import least_busy
from qiskit.quantum_info import Statevector
# import basic plot tools
from qiskit.visualization import plot_histogram
# define variables, 1) initialize qubits to zero
n = 2
grover_circuit = QuantumCircuit(n)
#define initialization function
def initialize_s(qc, qubits):
'''Apply a H-gate to 'qubits' in qc'''
for q in qubits:
qc.h(q)
return qc
### begin grovers circuit ###
#2) Put qubits in equal state of superposition
grover_circuit = initialize_s(grover_circuit, [0,1])
# 3) Apply oracle reflection to marked instance x_0 = 3, (|11>)
grover_circuit.cz(0,1)
statevec = job_sim.result().get_statevector()
from qiskit_textbook.tools import vector2latex
vector2latex(statevec, pretext="|\\psi\\rangle =")
# 4) apply additional reflection (diffusion operator)
grover_circuit.h([0,1])
grover_circuit.z([0,1])
grover_circuit.cz(0,1)
grover_circuit.h([0,1])
# 5) measure the qubits
grover_circuit.measure_all()
# Load IBM Q account and get the least busy backend device
provider = IBMQ.load_account()
device = least_busy(provider.backends(filters=lambda x: x.configuration().n_qubits >= 3 and
not x.configuration().simulator and x.status().operational==True))
print("Running on current least busy device: ", device)
from qiskit.tools.monitor import job_monitor
job = execute(grover_circuit, backend=device, shots=1024, optimization_level=3)
job_monitor(job, interval = 2)
results = job.result()
answer = results.get_counts(grover_circuit)
plot_histogram(answer)
#highest amplitude should correspond with marked value x_0 (|11>)
|
https://github.com/GabrielPontolillo/Quantum_Algorithm_Implementations
|
GabrielPontolillo
|
# importing Qiskit
from qiskit import Aer, transpile, assemble
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit.visualization import plot_histogram, plot_bloch_multivector
from qiskit.visualization import plot_state_paulivec, plot_state_hinton, plot_state_city
from qiskit.visualization import plot_state_qsphere
# import basic plot tools
from qiskit.visualization import plot_histogram, plot_bloch_multivector
import matplotlib.pyplot as plt
#get backend simulator
sim = Aer.get_backend('aer_simulator')
qc = QuantumCircuit(3)
qc.h(0)
qc.cx(0,1)
qc.h(2)
qc.s(2)
#print circuit
print(qc)
#draw bloch spheres
qc.save_statevector()
statevector = sim.run(qc).result().get_statevector()
print("\n")
print(statevector)
print("\n")
plot_bloch_multivector(statevector)
plot_state_city(statevector)
plot_state_qsphere(statevector)
|
https://github.com/hrahman12/IBM-Variational-Algorithm-Design-Challenge
|
hrahman12
|
answers = [1, 2]
from qc_grader.challenges.algorithm_design import grade_problem_1
grade_problem_1(answers)
|
https://github.com/geduardo/Q-Snake-Qiskitcamp-Europe-2019
|
geduardo
|
import numpy as np
from qiskit import *
q = QuantumRegister(1)
# Create a Quantum Circuit acting on a quantum register of n qubits
qc = QuantumCircuit(q)
diag = qc.draw(output="mpl")
diag.savefig("1.png", format="png")
qc.h(0)
diag = qc.draw(output="mpl")
diag.savefig("2.png", format="png")
qc.z(0)
diag = qc.draw(output="mpl")
diag.savefig("3.png", format="png")
qc.h(0)
diag = qc.draw(output="mpl")
diag.savefig("4.png", format="png")
#Cropping images
!pip3 install Pillow
crp = [0,7,17,25]
from PIL import Image
for i in range(1,5):
image = Image.open(str(i)+".png")
w,h = image.size
image.crop((20+crp[i-1],20,w,h-20)).save(str(i)+"c.png")
qc.measure(0,0)
qc.draw()
from qiskit.visualization import plot_bloch_vector
plot_bloch_vector([0,0,1], title='Intial state')
plot_bloch_vector([1,0,0], title='H gate')
plot_bloch_vector([-1,0,0], title='Z gate')
plot_bloch_vector([0,0,-1], title='H gate')
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Clifford, random_clifford
qc = QuantumCircuit(3)
cliff = random_clifford(2)
qc.append(cliff, [0, 1])
qc.ccx(0, 1, 2)
qc.draw('mpl')
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Tests for SuperOp quantum channel representation class."""
import copy
import unittest
import numpy as np
from numpy.testing import assert_allclose
from qiskit import QiskitError, QuantumCircuit
from qiskit.quantum_info.states import DensityMatrix
from qiskit.quantum_info.operators import Operator
from qiskit.quantum_info.operators.channel import SuperOp
from .channel_test_case import ChannelTestCase
class TestSuperOp(ChannelTestCase):
"""Tests for SuperOp channel representation."""
def test_init(self):
"""Test initialization"""
chan = SuperOp(self.sopI)
assert_allclose(chan.data, self.sopI)
self.assertEqual(chan.dim, (2, 2))
self.assertEqual(chan.num_qubits, 1)
mat = np.zeros((4, 16))
chan = SuperOp(mat)
assert_allclose(chan.data, mat)
self.assertEqual(chan.dim, (4, 2))
self.assertIsNone(chan.num_qubits)
chan = SuperOp(mat.T)
assert_allclose(chan.data, mat.T)
self.assertEqual(chan.dim, (2, 4))
self.assertIsNone(chan.num_qubits)
# Wrong input or output dims should raise exception
self.assertRaises(QiskitError, SuperOp, mat, input_dims=[4], output_dims=[4])
def test_circuit_init(self):
"""Test initialization from a circuit."""
# Test tensor product of 1-qubit gates
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.x(1)
circuit.ry(np.pi / 2, 2)
op = SuperOp(circuit)
y90 = (1 / np.sqrt(2)) * np.array([[1, -1], [1, 1]])
target = SuperOp(Operator(np.kron(y90, np.kron(self.UX, self.UH))))
self.assertEqual(target, op)
# Test decomposition of Controlled-Phase gate
lam = np.pi / 4
circuit = QuantumCircuit(2)
circuit.cp(lam, 0, 1)
op = SuperOp(circuit)
target = SuperOp(Operator(np.diag([1, 1, 1, np.exp(1j * lam)])))
self.assertEqual(target, op)
# Test decomposition of controlled-H gate
circuit = QuantumCircuit(2)
circuit.ch(0, 1)
op = SuperOp(circuit)
target = SuperOp(
Operator(np.kron(self.UI, np.diag([1, 0])) + np.kron(self.UH, np.diag([0, 1])))
)
self.assertEqual(target, op)
def test_circuit_init_except(self):
"""Test initialization from circuit with measure raises exception."""
circuit = self.simple_circuit_with_measure()
self.assertRaises(QiskitError, SuperOp, circuit)
def test_equal(self):
"""Test __eq__ method"""
mat = self.rand_matrix(4, 4)
self.assertEqual(SuperOp(mat), SuperOp(mat))
def test_copy(self):
"""Test copy method"""
mat = np.eye(4)
with self.subTest("Deep copy"):
orig = SuperOp(mat)
cpy = orig.copy()
cpy._data[0, 0] = 0.0
self.assertFalse(cpy == orig)
with self.subTest("Shallow copy"):
orig = SuperOp(mat)
clone = copy.copy(orig)
clone._data[0, 0] = 0.0
self.assertTrue(clone == orig)
def test_clone(self):
"""Test clone method"""
mat = np.eye(4)
orig = SuperOp(mat)
clone = copy.copy(orig)
clone._data[0, 0] = 0.0
self.assertTrue(clone == orig)
def test_evolve(self):
"""Test evolve method."""
input_rho = DensityMatrix([[0, 0], [0, 1]])
# Identity channel
chan = SuperOp(self.sopI)
target_rho = DensityMatrix([[0, 0], [0, 1]])
self.assertEqual(input_rho.evolve(chan), target_rho)
# Hadamard channel
mat = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
chan = SuperOp(np.kron(mat.conj(), mat))
target_rho = DensityMatrix(np.array([[1, -1], [-1, 1]]) / 2)
self.assertEqual(input_rho.evolve(chan), target_rho)
# Completely depolarizing channel
chan = SuperOp(self.depol_sop(1))
target_rho = DensityMatrix(np.eye(2) / 2)
self.assertEqual(input_rho.evolve(chan), target_rho)
def test_evolve_subsystem(self):
"""Test subsystem evolve method."""
# Single-qubit random superoperators
op_a = SuperOp(self.rand_matrix(4, 4))
op_b = SuperOp(self.rand_matrix(4, 4))
op_c = SuperOp(self.rand_matrix(4, 4))
id1 = SuperOp(np.eye(4))
id2 = SuperOp(np.eye(16))
rho = DensityMatrix(self.rand_rho(8))
# Test evolving single-qubit of 3-qubit system
op = op_a
# Evolve on qubit 0
full_op = id2.tensor(op_a)
rho_targ = rho.evolve(full_op)
rho_test = rho.evolve(op, qargs=[0])
self.assertEqual(rho_test, rho_targ)
# Evolve on qubit 1
full_op = id1.tensor(op_a).tensor(id1)
rho_targ = rho.evolve(full_op)
rho_test = rho.evolve(op, qargs=[1])
self.assertEqual(rho_test, rho_targ)
# Evolve on qubit 2
full_op = op_a.tensor(id2)
rho_targ = rho.evolve(full_op)
rho_test = rho.evolve(op, qargs=[2])
self.assertEqual(rho_test, rho_targ)
# Test 2-qubit evolution
op = op_b.tensor(op_a)
# Evolve on qubits [0, 2]
full_op = op_b.tensor(id1).tensor(op_a)
rho_targ = rho.evolve(full_op)
rho_test = rho.evolve(op, qargs=[0, 2])
self.assertEqual(rho_test, rho_targ)
# Evolve on qubits [2, 0]
full_op = op_a.tensor(id1).tensor(op_b)
rho_targ = rho.evolve(full_op)
rho_test = rho.evolve(op, qargs=[2, 0])
self.assertEqual(rho_test, rho_targ)
# Test 3-qubit evolution
op = op_c.tensor(op_b).tensor(op_a)
# Evolve on qubits [0, 1, 2]
full_op = op
rho_targ = rho.evolve(full_op)
rho_test = rho.evolve(op, qargs=[0, 1, 2])
self.assertEqual(rho_test, rho_targ)
# Evolve on qubits [2, 1, 0]
full_op = op_a.tensor(op_b).tensor(op_c)
rho_targ = rho.evolve(full_op)
rho_test = rho.evolve(op, qargs=[2, 1, 0])
self.assertEqual(rho_test, rho_targ)
def test_is_cptp(self):
"""Test is_cptp method."""
self.assertTrue(SuperOp(self.depol_sop(0.25)).is_cptp())
# Non-CPTP should return false
self.assertFalse(SuperOp(1.25 * self.sopI - 0.25 * self.depol_sop(1)).is_cptp())
def test_conjugate(self):
"""Test conjugate method."""
mat = self.rand_matrix(4, 4)
chan = SuperOp(mat)
targ = SuperOp(np.conjugate(mat))
self.assertEqual(chan.conjugate(), targ)
def test_transpose(self):
"""Test transpose method."""
mat = self.rand_matrix(4, 4)
chan = SuperOp(mat)
targ = SuperOp(np.transpose(mat))
self.assertEqual(chan.transpose(), targ)
def test_adjoint(self):
"""Test adjoint method."""
mat = self.rand_matrix(4, 4)
chan = SuperOp(mat)
targ = SuperOp(np.transpose(np.conj(mat)))
self.assertEqual(chan.adjoint(), targ)
def test_compose_except(self):
"""Test compose different dimension exception"""
self.assertRaises(QiskitError, SuperOp(np.eye(4)).compose, SuperOp(np.eye(16)))
self.assertRaises(QiskitError, SuperOp(np.eye(4)).compose, 2)
def test_compose(self):
"""Test compose method."""
# UnitaryChannel evolution
chan1 = SuperOp(self.sopX)
chan2 = SuperOp(self.sopY)
chan = chan1.compose(chan2)
targ = SuperOp(self.sopZ)
self.assertEqual(chan, targ)
# 50% depolarizing channel
chan1 = SuperOp(self.depol_sop(0.5))
chan = chan1.compose(chan1)
targ = SuperOp(self.depol_sop(0.75))
self.assertEqual(chan, targ)
# Random superoperator
mat1 = self.rand_matrix(4, 4)
mat2 = self.rand_matrix(4, 4)
chan1 = SuperOp(mat1)
chan2 = SuperOp(mat2)
targ = SuperOp(np.dot(mat2, mat1))
self.assertEqual(chan1.compose(chan2), targ)
self.assertEqual(chan1 & chan2, targ)
targ = SuperOp(np.dot(mat1, mat2))
self.assertEqual(chan2.compose(chan1), targ)
self.assertEqual(chan2 & chan1, targ)
# Compose different dimensions
chan1 = SuperOp(self.rand_matrix(16, 4))
chan2 = SuperOp(
self.rand_matrix(4, 16),
)
chan = chan1.compose(chan2)
self.assertEqual(chan.dim, (2, 2))
chan = chan2.compose(chan1)
self.assertEqual(chan.dim, (4, 4))
def test_dot(self):
"""Test dot method."""
# UnitaryChannel evolution
chan1 = SuperOp(self.sopX)
chan2 = SuperOp(self.sopY)
targ = SuperOp(self.sopZ)
self.assertEqual(chan1.dot(chan2), targ)
self.assertEqual(chan1 @ chan2, targ)
# 50% depolarizing channel
chan1 = SuperOp(self.depol_sop(0.5))
targ = SuperOp(self.depol_sop(0.75))
self.assertEqual(chan1.dot(chan1), targ)
self.assertEqual(chan1 @ chan1, targ)
# Random superoperator
mat1 = self.rand_matrix(4, 4)
mat2 = self.rand_matrix(4, 4)
chan1 = SuperOp(mat1)
chan2 = SuperOp(mat2)
targ = SuperOp(np.dot(mat2, mat1))
self.assertEqual(chan2.dot(chan1), targ)
targ = SuperOp(np.dot(mat1, mat2))
# Compose different dimensions
chan1 = SuperOp(self.rand_matrix(16, 4))
chan2 = SuperOp(self.rand_matrix(4, 16))
chan = chan1.dot(chan2)
self.assertEqual(chan.dim, (4, 4))
chan = chan1 @ chan2
self.assertEqual(chan.dim, (4, 4))
chan = chan2.dot(chan1)
self.assertEqual(chan.dim, (2, 2))
chan = chan2 @ chan1
self.assertEqual(chan.dim, (2, 2))
def test_compose_front(self):
"""Test front compose method."""
# DEPRECATED
# UnitaryChannel evolution
chan1 = SuperOp(self.sopX)
chan2 = SuperOp(self.sopY)
chan = chan1.compose(chan2, front=True)
targ = SuperOp(self.sopZ)
self.assertEqual(chan, targ)
# 50% depolarizing channel
chan1 = SuperOp(self.depol_sop(0.5))
chan = chan1.compose(chan1, front=True)
targ = SuperOp(self.depol_sop(0.75))
self.assertEqual(chan, targ)
# Random superoperator
mat1 = self.rand_matrix(4, 4)
mat2 = self.rand_matrix(4, 4)
chan1 = SuperOp(mat1)
chan2 = SuperOp(mat2)
targ = SuperOp(np.dot(mat2, mat1))
self.assertEqual(chan2.compose(chan1, front=True), targ)
targ = SuperOp(np.dot(mat1, mat2))
self.assertEqual(chan1.compose(chan2, front=True), targ)
# Compose different dimensions
chan1 = SuperOp(self.rand_matrix(16, 4))
chan2 = SuperOp(self.rand_matrix(4, 16))
chan = chan1.compose(chan2, front=True)
self.assertEqual(chan.dim, (4, 4))
chan = chan2.compose(chan1, front=True)
self.assertEqual(chan.dim, (2, 2))
def test_compose_subsystem(self):
"""Test subsystem compose method."""
# 3-qubit superoperator
mat = self.rand_matrix(64, 64)
mat_a = self.rand_matrix(4, 4)
mat_b = self.rand_matrix(4, 4)
mat_c = self.rand_matrix(4, 4)
iden = SuperOp(np.eye(4))
op = SuperOp(mat)
op1 = SuperOp(mat_a)
op2 = SuperOp(mat_b).tensor(SuperOp(mat_a))
op3 = SuperOp(mat_c).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
# op3 qargs=[0, 1, 2]
full_op = SuperOp(mat_c).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
targ = np.dot(full_op.data, mat)
self.assertEqual(op.compose(op3, qargs=[0, 1, 2]), SuperOp(targ))
self.assertEqual(op & op3([0, 1, 2]), SuperOp(targ))
# op3 qargs=[2, 1, 0]
full_op = SuperOp(mat_a).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_c))
targ = np.dot(full_op.data, mat)
self.assertEqual(op.compose(op3, qargs=[2, 1, 0]), SuperOp(targ))
self.assertEqual(op & op3([2, 1, 0]), SuperOp(targ))
# op2 qargs=[0, 1]
full_op = iden.tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
targ = np.dot(full_op.data, mat)
self.assertEqual(op.compose(op2, qargs=[0, 1]), SuperOp(targ))
self.assertEqual(op & op2([0, 1]), SuperOp(targ))
# op2 qargs=[2, 0]
full_op = SuperOp(mat_a).tensor(iden).tensor(SuperOp(mat_b))
targ = np.dot(full_op.data, mat)
self.assertEqual(op.compose(op2, qargs=[2, 0]), SuperOp(targ))
self.assertEqual(op & op2([2, 0]), SuperOp(targ))
# op1 qargs=[0]
full_op = iden.tensor(iden).tensor(SuperOp(mat_a))
targ = np.dot(full_op.data, mat)
self.assertEqual(op.compose(op1, qargs=[0]), SuperOp(targ))
self.assertEqual(op & op1([0]), SuperOp(targ))
# op1 qargs=[1]
full_op = iden.tensor(SuperOp(mat_a)).tensor(iden)
targ = np.dot(full_op.data, mat)
self.assertEqual(op.compose(op1, qargs=[1]), SuperOp(targ))
self.assertEqual(op & op1([1]), SuperOp(targ))
# op1 qargs=[2]
full_op = SuperOp(mat_a).tensor(iden).tensor(iden)
targ = np.dot(full_op.data, mat)
self.assertEqual(op.compose(op1, qargs=[2]), SuperOp(targ))
self.assertEqual(op & op1([2]), SuperOp(targ))
def test_dot_subsystem(self):
"""Test subsystem dot method."""
# 3-qubit operator
mat = self.rand_matrix(64, 64)
mat_a = self.rand_matrix(4, 4)
mat_b = self.rand_matrix(4, 4)
mat_c = self.rand_matrix(4, 4)
iden = SuperOp(np.eye(4))
op = SuperOp(mat)
op1 = SuperOp(mat_a)
op2 = SuperOp(mat_b).tensor(SuperOp(mat_a))
op3 = SuperOp(mat_c).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
# op3 qargs=[0, 1, 2]
full_op = SuperOp(mat_c).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.dot(op3, qargs=[0, 1, 2]), SuperOp(targ))
# op3 qargs=[2, 1, 0]
full_op = SuperOp(mat_a).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_c))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.dot(op3, qargs=[2, 1, 0]), SuperOp(targ))
# op2 qargs=[0, 1]
full_op = iden.tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.dot(op2, qargs=[0, 1]), SuperOp(targ))
# op2 qargs=[2, 0]
full_op = SuperOp(mat_a).tensor(iden).tensor(SuperOp(mat_b))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.dot(op2, qargs=[2, 0]), SuperOp(targ))
# op1 qargs=[0]
full_op = iden.tensor(iden).tensor(SuperOp(mat_a))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.dot(op1, qargs=[0]), SuperOp(targ))
# op1 qargs=[1]
full_op = iden.tensor(SuperOp(mat_a)).tensor(iden)
targ = np.dot(mat, full_op.data)
self.assertEqual(op.dot(op1, qargs=[1]), SuperOp(targ))
# op1 qargs=[2]
full_op = SuperOp(mat_a).tensor(iden).tensor(iden)
targ = np.dot(mat, full_op.data)
self.assertEqual(op.dot(op1, qargs=[2]), SuperOp(targ))
def test_compose_front_subsystem(self):
"""Test subsystem front compose method."""
# 3-qubit operator
mat = self.rand_matrix(64, 64)
mat_a = self.rand_matrix(4, 4)
mat_b = self.rand_matrix(4, 4)
mat_c = self.rand_matrix(4, 4)
iden = SuperOp(np.eye(4))
op = SuperOp(mat)
op1 = SuperOp(mat_a)
op2 = SuperOp(mat_b).tensor(SuperOp(mat_a))
op3 = SuperOp(mat_c).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
# op3 qargs=[0, 1, 2]
full_op = SuperOp(mat_c).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.compose(op3, qargs=[0, 1, 2], front=True), SuperOp(targ))
# op3 qargs=[2, 1, 0]
full_op = SuperOp(mat_a).tensor(SuperOp(mat_b)).tensor(SuperOp(mat_c))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.compose(op3, qargs=[2, 1, 0], front=True), SuperOp(targ))
# op2 qargs=[0, 1]
full_op = iden.tensor(SuperOp(mat_b)).tensor(SuperOp(mat_a))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.compose(op2, qargs=[0, 1], front=True), SuperOp(targ))
# op2 qargs=[2, 0]
full_op = SuperOp(mat_a).tensor(iden).tensor(SuperOp(mat_b))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.compose(op2, qargs=[2, 0], front=True), SuperOp(targ))
# op1 qargs=[0]
full_op = iden.tensor(iden).tensor(SuperOp(mat_a))
targ = np.dot(mat, full_op.data)
self.assertEqual(op.compose(op1, qargs=[0], front=True), SuperOp(targ))
# op1 qargs=[1]
full_op = iden.tensor(SuperOp(mat_a)).tensor(iden)
targ = np.dot(mat, full_op.data)
self.assertEqual(op.compose(op1, qargs=[1], front=True), SuperOp(targ))
# op1 qargs=[2]
full_op = SuperOp(mat_a).tensor(iden).tensor(iden)
targ = np.dot(mat, full_op.data)
self.assertEqual(op.compose(op1, qargs=[2], front=True), SuperOp(targ))
def test_expand(self):
"""Test expand method."""
rho0, rho1 = np.diag([1, 0]), np.diag([0, 1])
rho_init = DensityMatrix(np.kron(rho0, rho0))
chan1 = SuperOp(self.sopI)
chan2 = SuperOp(self.sopX)
# X \otimes I
chan = chan1.expand(chan2)
rho_targ = DensityMatrix(np.kron(rho1, rho0))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
# I \otimes X
chan = chan2.expand(chan1)
rho_targ = DensityMatrix(np.kron(rho0, rho1))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
def test_tensor(self):
"""Test tensor method."""
rho0, rho1 = np.diag([1, 0]), np.diag([0, 1])
rho_init = DensityMatrix(np.kron(rho0, rho0))
chan1 = SuperOp(self.sopI)
chan2 = SuperOp(self.sopX)
# X \otimes I
chan = chan2.tensor(chan1)
rho_targ = DensityMatrix(np.kron(rho1, rho0))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
chan = chan2 ^ chan1
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
# I \otimes X
chan = chan1.tensor(chan2)
rho_targ = DensityMatrix(np.kron(rho0, rho1))
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
chan = chan1 ^ chan2
self.assertEqual(chan.dim, (4, 4))
self.assertEqual(rho_init.evolve(chan), rho_targ)
def test_power(self):
"""Test power method."""
# 10% depolarizing channel
p_id = 0.9
depol = SuperOp(self.depol_sop(1 - p_id))
# Compose 3 times
p_id3 = p_id**3
chan3 = depol.power(3)
targ3 = SuperOp(self.depol_sop(1 - p_id3))
self.assertEqual(chan3, targ3)
def test_add(self):
"""Test add method."""
mat1 = 0.5 * self.sopI
mat2 = 0.5 * self.depol_sop(1)
chan1 = SuperOp(mat1)
chan2 = SuperOp(mat2)
targ = SuperOp(mat1 + mat2)
self.assertEqual(chan1._add(chan2), targ)
self.assertEqual(chan1 + chan2, targ)
targ = SuperOp(mat1 - mat2)
self.assertEqual(chan1 - chan2, targ)
def test_add_qargs(self):
"""Test add method with qargs."""
mat = self.rand_matrix(8**2, 8**2)
mat0 = self.rand_matrix(4, 4)
mat1 = self.rand_matrix(4, 4)
op = SuperOp(mat)
op0 = SuperOp(mat0)
op1 = SuperOp(mat1)
op01 = op1.tensor(op0)
eye = SuperOp(self.sopI)
with self.subTest(msg="qargs=[0]"):
value = op + op0([0])
target = op + eye.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1]"):
value = op + op0([1])
target = op + eye.tensor(op0).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2]"):
value = op + op0([2])
target = op + op0.tensor(eye).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 1]"):
value = op + op01([0, 1])
target = op + eye.tensor(op1).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1, 0]"):
value = op + op01([1, 0])
target = op + eye.tensor(op0).tensor(op1)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 2]"):
value = op + op01([0, 2])
target = op + op1.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2, 0]"):
value = op + op01([2, 0])
target = op + op0.tensor(eye).tensor(op1)
self.assertEqual(value, target)
def test_sub_qargs(self):
"""Test subtract method with qargs."""
mat = self.rand_matrix(8**2, 8**2)
mat0 = self.rand_matrix(4, 4)
mat1 = self.rand_matrix(4, 4)
op = SuperOp(mat)
op0 = SuperOp(mat0)
op1 = SuperOp(mat1)
op01 = op1.tensor(op0)
eye = SuperOp(self.sopI)
with self.subTest(msg="qargs=[0]"):
value = op - op0([0])
target = op - eye.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1]"):
value = op - op0([1])
target = op - eye.tensor(op0).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2]"):
value = op - op0([2])
target = op - op0.tensor(eye).tensor(eye)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 1]"):
value = op - op01([0, 1])
target = op - eye.tensor(op1).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[1, 0]"):
value = op - op01([1, 0])
target = op - eye.tensor(op0).tensor(op1)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[0, 2]"):
value = op - op01([0, 2])
target = op - op1.tensor(eye).tensor(op0)
self.assertEqual(value, target)
with self.subTest(msg="qargs=[2, 0]"):
value = op - op01([2, 0])
target = op - op0.tensor(eye).tensor(op1)
self.assertEqual(value, target)
def test_add_except(self):
"""Test add method raises exceptions."""
chan1 = SuperOp(self.sopI)
chan2 = SuperOp(np.eye(16))
self.assertRaises(QiskitError, chan1._add, chan2)
self.assertRaises(QiskitError, chan1._add, 5)
def test_multiply(self):
"""Test multiply method."""
chan = SuperOp(self.sopI)
val = 0.5
targ = SuperOp(val * self.sopI)
self.assertEqual(chan._multiply(val), targ)
self.assertEqual(val * chan, targ)
targ = SuperOp(self.sopI * val)
self.assertEqual(chan * val, targ)
def test_multiply_except(self):
"""Test multiply method raises exceptions."""
chan = SuperOp(self.sopI)
self.assertRaises(QiskitError, chan._multiply, "s")
self.assertRaises(QiskitError, chan.__rmul__, "s")
self.assertRaises(QiskitError, chan._multiply, chan)
self.assertRaises(QiskitError, chan.__rmul__, chan)
def test_negate(self):
"""Test negate method"""
chan = SuperOp(self.sopI)
targ = SuperOp(-self.sopI)
self.assertEqual(-chan, targ)
if __name__ == "__main__":
unittest.main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit, transpile
from qiskit.visualization import plot_circuit_layout
from qiskit.providers.fake_provider import FakeVigo
backend = FakeVigo()
ghz = QuantumCircuit(3, 3)
ghz.h(0)
ghz.cx(0,range(1,3))
ghz.barrier()
ghz.measure(range(3), range(3))
# Virtual -> physical
# 0 -> 3
# 1 -> 4
# 2 -> 2
my_ghz = transpile(ghz, backend, initial_layout=[3, 4, 2])
plot_circuit_layout(my_ghz, backend)
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
# pylint: disable=missing-docstring,invalid-name,no-member
# pylint: disable=attribute-defined-outside-init
import itertools
from qiskit import QuantumRegister, QuantumCircuit
from qiskit.circuit import Parameter
def build_circuit(width, gates):
qr = QuantumRegister(width)
qc = QuantumCircuit(qr)
while len(qc) < gates:
for k in range(width):
qc.h(qr[k])
for k in range(width - 1):
qc.cx(qr[k], qr[k + 1])
return qc
class CircuitConstructionBench:
params = ([1, 2, 5, 8, 14, 20], [8, 128, 2048, 8192, 32768, 131072])
param_names = ["width", "gates"]
timeout = 600
def setup(self, width, gates):
self.empty_circuit = build_circuit(width, 0)
self.sample_circuit = build_circuit(width, gates)
def time_circuit_construction(self, width, gates):
build_circuit(width, gates)
def time_circuit_extend(self, _, __):
self.empty_circuit.extend(self.sample_circuit)
def time_circuit_copy(self, _, __):
self.sample_circuit.copy()
def build_parameterized_circuit(width, gates, param_count):
params = [Parameter("param-%s" % x) for x in range(param_count)]
param_iter = itertools.cycle(params)
qr = QuantumRegister(width)
qc = QuantumCircuit(qr)
while len(qc) < gates:
for k in range(width):
param = next(param_iter)
qc.u2(0, param, qr[k])
for k in range(width - 1):
param = next(param_iter)
qc.crx(param, qr[k], qr[k + 1])
return qc, params
class ParameterizedCircuitConstructionBench:
params = ([20], [8, 128, 2048, 8192, 32768, 131072], [8, 128, 2048, 8192, 32768, 131072])
param_names = ["width", "gates", "number of params"]
timeout = 600
def setup(self, _, gates, params):
if params > gates:
raise NotImplementedError
def time_build_parameterized_circuit(self, width, gates, params):
build_parameterized_circuit(width, gates, params)
class ParameterizedCircuitBindBench:
params = ([20], [8, 128, 2048, 8192, 32768, 131072], [8, 128, 2048, 8192, 32768, 131072])
param_names = ["width", "gates", "number of params"]
timeout = 600
def setup(self, width, gates, params):
if params > gates:
raise NotImplementedError
self.circuit, self.params = build_parameterized_circuit(width, gates, params)
def time_bind_params(self, _, __, ___):
self.circuit.bind_parameters({x: 3.14 for x in self.params})
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# Necessary imports
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import ZFeatureMap, RealAmplitudes
from qiskit.utils import algorithm_globals
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
from qiskit_machine_learning.neural_networks import EffectiveDimension, LocalEffectiveDimension
from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN
# set random seed
algorithm_globals.random_seed = 42
num_qubits = 3
# create a feature map
feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
# create a variational circuit
ansatz = RealAmplitudes(num_qubits, reps=1)
# combine feature map and ansatz into a single circuit
qc = QuantumCircuit(num_qubits)
qc.append(feature_map, range(num_qubits))
qc.append(ansatz, range(num_qubits))
qc.decompose().draw("mpl")
# parity maps bitstrings to 0 or 1
def parity(x):
return "{:b}".format(x).count("1") % 2
output_shape = 2 # corresponds to the number of classes, possible outcomes of the (parity) mapping.
# construct QNN
qnn = SamplerQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=output_shape,
sparse=False,
)
# we can set the total number of input samples and weight samples for random selection
num_input_samples = 10
num_weight_samples = 10
global_ed = EffectiveDimension(
qnn=qnn, weight_samples=num_weight_samples, input_samples=num_input_samples
)
# we can also provide user-defined samples and parameters
input_samples = algorithm_globals.random.normal(0, 1, size=(10, qnn.num_inputs))
weight_samples = algorithm_globals.random.uniform(0, 1, size=(10, qnn.num_weights))
global_ed = EffectiveDimension(qnn=qnn, weight_samples=weight_samples, input_samples=input_samples)
# finally, we will define ranges to test different numbers of data, n
n = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]
global_eff_dim_0 = global_ed.get_effective_dimension(dataset_size=n[0])
d = qnn.num_weights
print("Data size: {}, global effective dimension: {:.4f}".format(n[0], global_eff_dim_0))
print(
"Number of weights: {}, normalized effective dimension: {:.4f}".format(d, global_eff_dim_0 / d)
)
global_eff_dim_1 = global_ed.get_effective_dimension(dataset_size=n)
print("Effective dimension: {}".format(global_eff_dim_1))
print("Number of weights: {}".format(d))
# plot the normalized effective dimension for the model
plt.plot(n, np.array(global_eff_dim_1) / d)
plt.xlabel("Number of data")
plt.ylabel("Normalized GLOBAL effective dimension")
plt.show()
num_inputs = 3
num_samples = 50
X, y = make_classification(
n_samples=num_samples,
n_features=num_inputs,
n_informative=3,
n_redundant=0,
n_clusters_per_class=1,
class_sep=2.0,
)
X = MinMaxScaler().fit_transform(X)
y = 2 * y - 1 # labels in {-1, 1}
estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# callback function that draws a live plot when the .fit() method is called
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
# construct classifier
initial_point = algorithm_globals.random.random(estimator_qnn.num_weights)
estimator_classifier = NeuralNetworkClassifier(
neural_network=estimator_qnn,
optimizer=COBYLA(maxiter=80),
initial_point=initial_point,
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function (callback)
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
estimator_classifier.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
estimator_classifier.score(X, y)
trained_weights = estimator_classifier.weights
# get Local Effective Dimension for set of trained weights
local_ed_trained = LocalEffectiveDimension(
qnn=estimator_qnn, weight_samples=trained_weights, input_samples=X
)
local_eff_dim_trained = local_ed_trained.get_effective_dimension(dataset_size=n)
print(
"normalized local effective dimensions for trained QNN: ",
local_eff_dim_trained / estimator_qnn.num_weights,
)
# get Local Effective Dimension for set of untrained weights
local_ed_untrained = LocalEffectiveDimension(
qnn=estimator_qnn, weight_samples=initial_point, input_samples=X
)
local_eff_dim_untrained = local_ed_untrained.get_effective_dimension(dataset_size=n)
print(
"normalized local effective dimensions for untrained QNN: ",
local_eff_dim_untrained / estimator_qnn.num_weights,
)
# plot the normalized effective dimension for the model
plt.plot(n, np.array(local_eff_dim_trained) / estimator_qnn.num_weights, label="trained weights")
plt.plot(
n, np.array(local_eff_dim_untrained) / estimator_qnn.num_weights, label="untrained weights"
)
plt.xlabel("Number of data")
plt.ylabel("Normalized LOCAL effective dimension")
plt.legend()
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit_optimization import QuadraticProgram
qp = QuadraticProgram()
qp.binary_var("x")
qp.binary_var("y")
qp.integer_var(lowerbound=0, upperbound=7, name="z")
qp.maximize(linear={"x": 2, "y": 1, "z": 1})
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="LE", rhs=5.5, name="xyz_leq")
qp.linear_constraint(linear={"x": 1, "y": 1, "z": 1}, sense="GE", rhs=2.5, name="xyz_geq")
print(qp.prettyprint())
from qiskit_optimization.converters import InequalityToEquality
ineq2eq = InequalityToEquality()
qp_eq = ineq2eq.convert(qp)
print(qp_eq.prettyprint())
print(qp_eq.prettyprint())
from qiskit_optimization.converters import IntegerToBinary
int2bin = IntegerToBinary()
qp_eq_bin = int2bin.convert(qp_eq)
print(qp_eq_bin.prettyprint())
print(qp_eq_bin.prettyprint())
from qiskit_optimization.converters import LinearEqualityToPenalty
lineq2penalty = LinearEqualityToPenalty()
qubo = lineq2penalty.convert(qp_eq_bin)
print(qubo.prettyprint())
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
import pickle
# plt.rcParams.update({'font.size': 16}) # enlarge matplotlib fonts
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.providers.aer import QasmSimulator
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
# Suppress warnings
import warnings
warnings.filterwarnings('ignore')
def trotter_gate(dt, to_instruction = True):
qc = QuantumCircuit(2)
qc.rx(2*dt,0)
qc.rz(2*dt,1)
qc.h(1)
qc.cx(1,0)
qc.rz(-2*dt, 0)
qc.rx(-2*dt, 1)
qc.rz(2*dt, 1)
qc.cx(1,0)
qc.h(1)
qc.rz(2*dt, 0)
return qc.to_instruction() if to_instruction else qc
trotter_gate(np.pi / 6, to_instruction=False).draw("mpl")
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
Trot_gate = trotter_gate(dt)
# Number of trotter steps
trotter_steps = 15 ### CAN BE >= 4
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(7)
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
qc.x([5]) # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Simulate time evolution under H_heis3 Hamiltonian
for _ in range(trotter_steps):
qc.append(Trot_gate, [qr[3], qr[5]])
qc.cx(qr[3], qr[1])
qc.cx(qr[5], qr[3])
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time/trotter_steps})
t3_qc = transpile(qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_qc = transpile(t3_qc, optimization_level=3, basis_gates=["sx", "cx", "rz"])
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(t3_qc, [qr[1], qr[3], qr[5]])
# Display circuit for confirmation
# st_qcs[-1].decompose().draw() # view decomposition of trotter gates
st_qcs[-1].draw("mpl") # only view trotter gates
# from qiskit.test.mock import FakeJakarta
# backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-utokyo', group='internal', project='hirashi-jst')
provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
print("provider:", provider)
backend = provider.get_backend("ibmq_jakarta")
shots = 8192
reps = 8
jobs = []
for _ in range(reps):
# execute
job = execute(st_qcs, backend, shots=shots)
print('Job ID', job.job_id())
jobs.append(job)
# QREM
qr = QuantumRegister(num_qubits)
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout=[5,3,1])
print('Job ID', cal_job.job_id())
dt_now = datetime.datetime.now()
print(dt_now)
with open("jobs_jakarta_50step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"jobs": jobs, "cal_job": cal_job}, f)
with open("job_ids_jakarta_50step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump({"job_ids": [job.job_id() for job in jobs], "cal_job_id": cal_job.job_id()}, f)
with open("properties_jakarta" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
pickle.dump(backend.properties(), f)
with open("jakarta_50step.pkl", "rb") as f:
job_list = pickle.load(f)
jobs = job_list["jobs"]
cal_job = job_list["cal_job"]
cal_results = cal_job.result()
print("retrieved cal_results")
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
mit_results = []
for i, job in enumerate(jobs):
mit_results.append( meas_fitter.filter.apply(job.result()) )
print("retrieved", i, "th results")
# Compute the state tomography based on the st_qcs quantum circuits and the results from those ciricuits
def state_tomo(result, st_qcs):
# The expected final state; necessary to determine state tomography fidelity
target_state = (One^One^Zero).to_matrix() # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
# Fit state tomography results
tomo_fitter = StateTomographyFitter(result, st_qcs)
rho_fit = tomo_fitter.fit(method='lstsq')
# Compute fidelity
fid = state_fidelity(rho_fit, target_state)
return fid
# Compute tomography fidelities for each repetition
fids = []
for result in mit_results:
fid = state_tomo(result, st_qcs)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# 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.
"""Tests for unitary simulator."""
import unittest
import numpy as np
from qiskit import execute
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister
from qiskit.providers.basicaer import UnitarySimulatorPy
from qiskit.quantum_info.operators.predicates import matrix_equal
from qiskit.test import ReferenceCircuits
from qiskit.test import providers
from qiskit.quantum_info.random import random_unitary
from qiskit.quantum_info import process_fidelity, Operator
class BasicAerUnitarySimulatorPyTest(providers.BackendTestCase):
"""Test BasicAer unitary simulator."""
backend_cls = UnitarySimulatorPy
circuit = ReferenceCircuits.bell_no_measure()
def test_basicaer_unitary_simulator_py(self):
"""Test unitary simulator."""
circuits = self._test_circuits()
job = execute(circuits, backend=self.backend)
sim_unitaries = [job.result().get_unitary(circ) for circ in circuits]
reference_unitaries = self._reference_unitaries()
for u_sim, u_ref in zip(sim_unitaries, reference_unitaries):
self.assertTrue(matrix_equal(u_sim, u_ref, ignore_phase=True))
def _test_circuits(self):
"""Return test circuits for unitary simulator"""
qr = QuantumRegister(3)
cr = ClassicalRegister(3)
qc1 = QuantumCircuit(qr, cr)
qc2 = QuantumCircuit(qr, cr)
qc3 = QuantumCircuit(qr, cr)
qc4 = QuantumCircuit(qr, cr)
qc5 = QuantumCircuit(qr, cr)
# Test circuit 1: HxHxH
qc1.h(qr)
# Test circuit 2: IxCX
qc2.cx(qr[0], qr[1])
# Test circuit 3: CXxY
qc3.y(qr[0])
qc3.cx(qr[1], qr[2])
# Test circuit 4: (CX.I).(IxCX).(IxIxX)
qc4.h(qr[0])
qc4.cx(qr[0], qr[1])
qc4.cx(qr[1], qr[2])
# Test circuit 5 (X.Z)x(Z.Y)x(Y.X)
qc5.x(qr[0])
qc5.y(qr[0])
qc5.y(qr[1])
qc5.z(qr[1])
qc5.z(qr[2])
qc5.x(qr[2])
return [qc1, qc2, qc3, qc4, qc5]
def _reference_unitaries(self):
"""Return reference unitaries for test circuits"""
# Gate matrices
gate_h = np.array([[1, 1], [1, -1]]) / np.sqrt(2)
gate_x = np.array([[0, 1], [1, 0]])
gate_y = np.array([[0, -1j], [1j, 0]])
gate_z = np.array([[1, 0], [0, -1]])
gate_cx = np.array([[1, 0, 0, 0], [0, 0, 0, 1], [0.0, 0, 1, 0], [0, 1, 0, 0]])
# Unitary matrices
target_unitary1 = np.kron(np.kron(gate_h, gate_h), gate_h)
target_unitary2 = np.kron(np.eye(2), gate_cx)
target_unitary3 = np.kron(gate_cx, gate_y)
target_unitary4 = np.dot(
np.kron(gate_cx, np.eye(2)),
np.dot(np.kron(np.eye(2), gate_cx), np.kron(np.eye(4), gate_h)),
)
target_unitary5 = np.kron(
np.kron(np.dot(gate_x, gate_z), np.dot(gate_z, gate_y)), np.dot(gate_y, gate_x)
)
return [target_unitary1, target_unitary2, target_unitary3, target_unitary4, target_unitary5]
def test_unitary(self):
"""Test unitary gate instruction"""
num_trials = 10
max_qubits = 3
# Test 1 to max_qubits for random n-qubit unitary gate
for i in range(max_qubits):
num_qubits = i + 1
unitary_init = Operator(np.eye(2**num_qubits))
qr = QuantumRegister(num_qubits, "qr")
for _ in range(num_trials):
# Create random unitary
unitary = random_unitary(2**num_qubits)
# Compute expected output state
unitary_target = unitary.dot(unitary_init)
# Simulate output on circuit
circuit = QuantumCircuit(qr)
circuit.unitary(unitary, qr)
job = execute(circuit, self.backend)
result = job.result()
unitary_out = Operator(result.get_unitary(0))
fidelity = process_fidelity(unitary_target, unitary_out)
self.assertGreater(fidelity, 0.999)
def test_global_phase(self):
"""Test global phase for XZH
See https://github.com/Qiskit/qiskit-terra/issues/3083"""
q = QuantumRegister(1)
circuit = QuantumCircuit(q)
circuit.h(q[0])
circuit.z(q[0])
circuit.x(q[0])
job = execute(circuit, self.backend)
result = job.result()
unitary_out = result.get_unitary(circuit)
unitary_target = np.array(
[[-1 / np.sqrt(2), 1 / np.sqrt(2)], [1 / np.sqrt(2), 1 / np.sqrt(2)]]
)
self.assertTrue(np.allclose(unitary_out, unitary_target))
if __name__ == "__main__":
unittest.main()
|
https://github.com/QuTech-Delft/quantuminspire
|
QuTech-Delft
|
""" Quantum Inspire SDK
Copyright 2022 QuTech Delft
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
import unittest
from unittest.mock import Mock
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.compiler import assemble
from quantuminspire.qiskit.backend_qx import QuantumInspireBackend
from quantuminspire.exceptions import QiskitBackendError
from quantuminspire.qiskit.measurements import Measurements
class TestMeasurements(unittest.TestCase):
@staticmethod
def _circuit_to_qobj(circuit):
run_config_dict = {'shots': 25, 'memory': True}
backend = QuantumInspireBackend(Mock(), Mock())
qobj = assemble(circuit, backend, **run_config_dict)
return qobj
@staticmethod
def _circuit_to_experiment(circuit):
qobj = TestMeasurements._circuit_to_qobj(circuit)
return qobj.experiments[0]
def test_from_experiment(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.measure(0, 1)
qc.measure(1, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
expected_result = {'measurements_state': [[1, 0], [0, 1]],
'measurements_reg': [[0, 1], [1, 0]],
'number_of_qubits': 2,
'number_of_clbits': 2
}
self.assertDictEqual(measurements.to_dict(), expected_result)
self.assertEqual(measurements.nr_of_qubits, 2)
self.assertEqual(measurements.nr_of_clbits, 2)
def test_collect_measurements_without_measurements(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
expected_result = {'measurements_state': [[0, 0], [1, 1]],
'measurements_reg': [[0, 0], [1, 1]],
'number_of_qubits': 2,
'number_of_clbits': 2
}
self.assertDictEqual(measurements.to_dict(), expected_result)
self.assertEqual(measurements.nr_of_qubits, 2)
self.assertEqual(measurements.nr_of_clbits, 2)
def test_validate_nr_classical_qubits_less_than_needed_for_storing_measured_qubits(self):
q = QuantumRegister(2, 'q')
c = ClassicalRegister(1, 'c')
qc = QuantumCircuit(q, c, name='conditional')
qc.cx(q[0], q[1])
experiment = self._circuit_to_experiment(qc)
self.assertRaisesRegex(QiskitBackendError, 'Number of classical bits \(1\) is not sufficient for storing the '
'outcomes of the experiment',
Measurements.from_experiment, experiment)
def test_invalid_number_of_classical_bits(self):
qc = QuantumCircuit(2, 2)
qc.measure(1, 0)
qobj = self._circuit_to_qobj(qc)
qobj.experiments[0].header.memory_slots = 0
experiment = qobj.experiments[0]
self.assertRaisesRegex(QiskitBackendError, 'Invalid number of classical bits \(0\)!',
Measurements.from_experiment, experiment)
def test_max_measurement_index(self):
qr = QuantumRegister(5)
cr = ClassicalRegister(3)
cr_ghz = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr, cr_ghz)
circuit.measure(2, 3)
circuit.measure(3, 4)
circuit.measure([0, 1, 4], cr)
circuit.measure([2, 3], cr_ghz)
experiment = self._circuit_to_experiment(circuit)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.max_measurement_index, 4)
def test_max_measurement_index_less_than_nr_of_clbits(self):
qr = QuantumRegister(5)
cr = ClassicalRegister(3)
cr_ghz = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr, cr_ghz)
circuit.measure(2, 3)
circuit.measure([0, 1, 4], cr)
circuit.measure([2], cr_ghz[0])
experiment = self._circuit_to_experiment(circuit)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.max_measurement_index, 3)
def test_get_qreg_for_conditional_creg(self):
qr = QuantumRegister(5)
cr = ClassicalRegister(3)
cr_ghz = ClassicalRegister(2)
circuit = QuantumCircuit(qr, cr, cr_ghz)
circuit.measure(2, 3)
circuit.measure([1, 4], [1, 2])
circuit.measure([2], cr_ghz[0])
experiment = self._circuit_to_experiment(circuit)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.get_qreg_for_conditional_creg(3), 2)
self.assertEqual(measurements.get_qreg_for_conditional_creg(1), 1)
self.assertEqual(measurements.get_qreg_for_conditional_creg(2), 4)
self.assertEqual(measurements.get_qreg_for_conditional_creg(0), 0)
self.assertRaisesRegex(QiskitBackendError, 'Classical bit 4 used in a conditional gate is not measured and the '
'equivalent qubit 4 is measured to another classical bit 2',
measurements.get_qreg_for_conditional_creg, 4)
def test_from_dict(self):
input = {'measurements_state': [[0, 0], [1, 1]],
'measurements_reg': [[0, 0], [1, 1]],
'number_of_qubits': 2,
'number_of_clbits': 2
}
measurements = Measurements.from_dict(input)
self.assertEqual(measurements.nr_of_qubits, 2)
self.assertEqual(measurements.nr_of_clbits, 2)
self.assertDictEqual(measurements.to_dict(), input)
def test_measurement_2_qubits_to_1_classical_bit(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.measure(0, 0)
qc.x(0)
qc.measure(1, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertRaisesRegex(QiskitBackendError, 'Measurement of different qubits to the same classical '
'register 0 is not supported',
measurements.validate_unsupported_measurements)
def test_measurement_1_qubit_to_2_classical_bits(self):
qc = QuantumCircuit(2, 2)
qc.cx(0, 1)
qc.measure(1, 1)
qc.measure(0, 0)
qc.x(0)
qc.measure(1, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertRaisesRegex(QiskitBackendError, 'Measurement of qubit 1 to different classical registers '
'is not supported',
measurements.validate_unsupported_measurements)
def test_qubit_to_classical_hex(self):
qc = QuantumCircuit(4, 4)
qc.measure(0, 0)
qc.measure(1, 1)
qc.measure(2, 2)
qc.measure(3, 3)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.qubit_to_classical_hex('3'), '0x3')
self.assertEqual(measurements.qubit_to_classical_hex('7'), '0x7')
self.assertEqual(measurements.qubit_to_classical_hex('10'), '0xa')
def test_qubit_to_classical_hex_reversed(self):
qc = QuantumCircuit(4, 4)
qc.measure(0, 3)
qc.measure(1, 2)
qc.measure(2, 1)
qc.measure(3, 0)
experiment = self._circuit_to_experiment(qc)
measurements = Measurements.from_experiment(experiment)
self.assertEqual(measurements.qubit_to_classical_hex('3'), '0xc')
self.assertEqual(measurements.qubit_to_classical_hex('7'), '0xe')
self.assertEqual(measurements.qubit_to_classical_hex('10'), '0x5')
|
https://github.com/rickapocalypse/final_paper_qiskit_sat
|
rickapocalypse
|
from qiskit.providers.aer import QasmSimulator
from multiprocessing import Barrier
from qiskit import*
from qiskit import circuit
import matplotlib.pyplot as plt
from qiskit.tools.visualization import plot_histogram
from qiskit.tools.monitor import job_monitor
circuit = QuantumCircuit(2,2)
circuit.h([0,1])
circuit.barrier()
circuit.cx(0,1)
circuit.measure([0,1],[0,1])
result = execute(circuit, backend= QasmSimulator()).result()
counts = result.get_counts(circuit)
IBMQ.load_account()
host = IBMQ.get_provider('ibm-q')
quantum_computer = host.get_backend('ibmq_belem')
result_qcomputer = execute(circuit, backend= quantum_computer)
print(result_qcomputer.job_id())
job_monitor(result_qcomputer)
result = result_qcomputer.result()
plot_histogram(result.get_counts(circuit))
plt.ylabel(counts)
plt.show()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
q = QuantumRegister(1)
c = ClassicalRegister(1)
qc = QuantumCircuit(q, c)
qc.h(q)
qc.measure(q, c)
qc.draw(output='mpl', style={'backgroundcolor': '#EEEEEE'})
|
https://github.com/qiskit-community/qiskit-cold-atom
|
qiskit-community
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Module for cold-atom spin backends."""
from abc import ABC
from qiskit.providers import BackendV1 as Backend
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit_cold_atom import QiskitColdAtomError
class BaseSpinBackend(Backend, ABC):
"""Abstract base class for atomic mixture backends."""
def get_empty_circuit(self) -> QuantumCircuit:
"""
Convenience function to set up an empty circuit with the right QuantumRegisters.
For each atomic species specified in the config file, a quantum register is added to the circuit.
Returns:
qc: An empty quantum circuit ready to use in spin-based cold-atom setups.
Raises:
QiskitColdAtomError:
- If backend has no config file.
- If number of wires of the backend config is not a multiple of the atomic species.
"""
config = self.configuration().to_dict()
try:
num_wires = config["n_qubits"]
num_species = len(config["atomic_species"])
except NameError as name_error:
raise QiskitColdAtomError(
"backend needs to be initialized with config file first"
) from name_error
if not (isinstance(num_wires, int) and num_wires % num_species == 0):
raise QiskitColdAtomError(
"num_wires {num_wires} must be multiple of num_species {num_species}"
)
qregs = [
QuantumRegister(num_wires / num_species, species)
for species in config["atomic_species"]
]
class_reg = ClassicalRegister(num_wires, "c{}".format(num_wires))
empty_circuit = QuantumCircuit(*qregs, class_reg)
return empty_circuit
def draw(self, qc: QuantumCircuit, **draw_options):
"""Modified circuit drawer to better display atomic mixture quantum circuits.
For now this method is just an alias to `QuantumCircuit.draw()` but in the future this method
may be modified and tailored to spin quantum circuits.
Args:
qc: The quantum circuit to draw.
draw_options: Key word arguments for the drawing of circuits.
"""
qc.draw(**draw_options)
|
https://github.com/quantumyatra/quantum_computing
|
quantumyatra
|
%matplotlib inline
# Importing standard Qiskit libraries and configuring account
from qiskit import QuantumCircuit,QuantumRegister,ClassicalRegister, execute, Aer, IBMQ
from qiskit.compiler import transpile, assemble
from qiskit.tools.jupyter import *
from qiskit.visualization import *
def qft_1():
n=1
qc = QuantumCircuit()
q = QuantumRegister(n, 'q')
c = ClassicalRegister(n, 'c')
qc.add_register(q)
qc.add_register(c)
qc.h(q[0])
return qc,q,c
qc,q,c = qft_1()
qc.measure(q[0], c[0])
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
qc.draw(output='mpl', style = style)
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator).result()
counts = result.get_counts(qc)
plot_histogram(counts, title='QFT counts')
from qiskit.providers.aer import UnitarySimulator
qc,q,c = qft_1()
# Select the UnitarySimulator from the Aer provider
simulator = Aer.get_backend('unitary_simulator')
# Execute and get counts
result = execute(qc, simulator).result()
unitary = result.get_unitary(qc)
print( unitary)
HI = np.array([[1,0,1,0],[0,1,0,1],[1,0,-1,0],[0,1,0,-1]])
CU1 = np.array([[1,0,0,0],[0,1,0,0],[0,0,1,0],[0,0,0,0.+1.j]])
IH = np.array([[1,1,0,0],[1,-1,0,0],[0,0,1,1],[0,0,1,-1]])
SWAP = np.array([[1,0,0,0],[0,0,1,0],[0,1,0,0],[0,0,0,1]])
np.dot(HI,np.dot(CU1,np.dot(IH,SWAP)))
import numpy as np
def qft_2():
n=2
qc = QuantumCircuit()
q = QuantumRegister(n, 'q')
c = ClassicalRegister(n, 'c')
qc.add_register(q)
qc.add_register(c)
qc.h(q[1])
qc.cu1(np.pi / 2, q[0], q[1])
qc.h(q[0])
qc.swap(q[0], q[1])
return qc,q,c
qc,q,c = qft_2()
qc.measure(q, c)
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
qc.draw(output='mpl', style = style)
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator).result()
counts = result.get_counts(qc)
plot_histogram(counts, title='QFT counts')
from qiskit.providers.aer import UnitarySimulator
qc,q,c = qft_2()
# Select the UnitarySimulator from the Aer provider
simulator = Aer.get_backend('unitary_simulator')
# Execute and get counts
result = execute(qc, simulator).result()
unitary = result.get_unitary(qc)
print( unitary)
def qft_3():
n = 3
qc = QuantumCircuit()
q = QuantumRegister(n, 'q')
c = ClassicalRegister(n, 'c')
qc.add_register(q)
qc.add_register(c)
qc.h(q[2])
qc.cu1(np.pi / 2, q[1], q[2])
qc.h(q[1])
qc.cu1(np.pi / 4, q[0], q[2])
qc.cu1(np.pi / 2, q[0], q[1])
qc.h(q[0])
qc.swap(q[0], q[2])
return qc,q,c
qc,q,c = qft_3()
qc.measure(q,c)
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
qc.draw(output='mpl', style = style)
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator).result()
counts = result.get_counts(qc)
plot_histogram(counts, title='QFT counts')
from qiskit.providers.aer import UnitarySimulator
qc,q,c = qft_3()
# Select the UnitarySimulator from the Aer provider
simulator = Aer.get_backend('unitary_simulator')
# Execute and get counts
result = execute(qc, simulator).result()
unitary = result.get_unitary(qc)
print( unitary)
def qft_4():
n = 4
qc = QuantumCircuit()
q = QuantumRegister(n, 'q')
c = ClassicalRegister(n, 'c')
qc.add_register(q)
qc.add_register(c)
qc.h(q[3])
qc.cu1(np.pi / 2, q[2], q[3])
qc.h(q[2])
qc.cu1(np.pi / 4, q[1], q[3])
qc.cu1(np.pi / 2, q[1], q[2])
qc.h(q[1])
qc.cu1(np.pi / 8, q[0], q[3])
qc.cu1(np.pi / 4, q[0], q[2])
qc.cu1(np.pi / 2, q[0], q[1])
qc.h(q[0])
qc.swap(q[0], q[3])
qc.swap(q[1], q[2])
return qc,q,c
qc,q,c = qft_4()
qc.measure(q,c)
# Change the background color in mpl
style = {'backgroundcolor': 'lightgreen'}
qc.draw(output='mpl', style = style)
simulator = Aer.get_backend('qasm_simulator')
result = execute(qc, simulator).result()
counts = result.get_counts(qc)
plot_histogram(counts, title='QFT counts')
import numpy as np
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister
from qiskit import Aer, execute
from qiskit.providers.aer import UnitarySimulator
qc = qft_circuit(4)
# Select the UnitarySimulator from the Aer provider
simulator = Aer.get_backend('unitary_simulator')
# Execute and get counts
result = execute(qc, simulator).result()
unitary = result.get_unitary(qc)
print( unitary)
|
https://github.com/quantum-tokyo/qiskit-handson
|
quantum-tokyo
|
import math
import numpy as np
import matplotlib.pyplot as plt
#from fractions import Fraction
from quantum_computer_math_guide_trigonometric_intro_exercise_answer import *
ans1 = # こちらに値を書いてください
print(check_answer_exercise(ans1,"ans1"))
ans2 = # こちらに値を書いてください。
print(check_answer_exercise(ans2,"ans2"))
ans3 = # こちらに値を書いてください。
print(check_answer_exercise(ans3,"ans3"))
ans4 = # こちらに値を書いてください。
print(check_answer_exercise(ans4,"ans4"))
ans5 = # こちらに値を書いてください。
print(check_answer_exercise(ans5,"ans5"))
ans6 = # こちらに値を書いてください。
print(check_answer_exercise(ans6,"ans6"))
ans7 = # こちらに値を書いてください。
print(check_answer_exercise(ans7,"ans7"))
ans8 = # こちらに値を書いてください。
print(check_answer_exercise(ans8,"ans8"))
ans9 = # こちらに値を書いてください。
print(check_answer_exercise(ans9,"ans9"))
ans10 = # こちらに値を書いてください。
print(check_answer_exercise(ans10,"ans10"))
ans11 = # こちらに値を書いてください。
print(check_answer_exercise(ans11,"ans11"))
ans12 = # こちらに度数法での値を書いてください（「°」は省略してください。）
print(check_answer_exercise(ans12,"ans12"))
ans13 = # こちらに度数法での値を書いてください（「°」は省略してください。）
print(check_answer_exercise(ans13,"ans13"))
ans14 = # こちらに度数法での値を書いてください（「°」は省略してください。）
print(check_answer_exercise(ans14,"ans14"))
ans15 = # こちらに値を書いてください
print(check_answer_exercise(ans15,"ans15"))
ans16 = # こちらに値を書いてください
print(check_answer_exercise(ans16,"ans16"))
ans1_deg = math.sin(math.radians(ここに度数を入力)) # こちらに度数法の計算式を書いてください。
ans1_rad = math.sin(np.pi*(ここに弧度数を入力)) # こちらに弧度法の計算式を書いてください。
print("ans1 =", round(ans1,3)," : ans1_deg = ", round(ans1_deg,3)," : ans1_rad = ", round(ans1_rad,3))
ans2_deg = # こちらに度数法の計算式を書いてください。
ans2_rad = # こちらに弧度法の計算式を書いてください。
print("ans2 =", round(ans2,3)," : ans2_deg = ", round(ans2_deg,3)," : ans2_rad = ", round(ans2_rad,3))
ans3_deg = # こちらに度数法の計算式を書いてください。
ans3_rad = # こちらに弧度法の計算式を書いてください。
print("ans3 =", round(ans3,3)," : ans3_deg = ", round(ans3_deg,3)," : ans3_rad = ", round(ans3_rad,3))
ans4_deg = # こちらに度数法の計算式を書いてください。
ans4_rad = # こちらに弧度法の計算式を書いてください。
print("ans4 =", round(ans4,3)," : ans4_deg = ", round(ans4_deg,3)," : ans4_rad = ", round(ans4_rad,3))
ans5_deg = # こちらに度数法の計算式を書いてください。
ans5_rad = # こちらに弧度法の計算式を書いてください。
print("ans5 =", round(ans5,3)," : ans5_deg = ", round(ans5_deg,3)," : ans5_rad = ", round(ans5_rad,3))
ans6_deg = # こちらに度数法の計算式を書いてください。
ans6_rad = # こちらに弧度法の計算式を書いてください。
print("ans6 =", round(ans6,3)," : ans6_deg = ", round(ans6_deg,3)," : ans6_rad = ", round(ans6_rad,3))
ans7_deg = # こちらに度数法の計算式を書いてください。
ans7_rad = # こちらに弧度法の計算式を書いてください。
print("ans7 =", round(ans7,3)," : ans7_deg = ", round(ans7_deg,3)," : ans7_rad = ", round(ans7_rad,3))
ans8_deg = # こちらに度数法の計算式を書いてください。
ans8_rad = # こちらに弧度法の計算式を書いてください。
print("ans8 =", round(ans8,3)," : ans8_deg = ", round(ans8_deg,3)," : ans8_rad = ", round(ans8_rad,3))
ans9_deg = # こちらに度数法の計算式を書いてください。
ans9_rad = # こちらに弧度法の計算式を書いてください。
print("ans9 =", round(ans9,3)," : ans9_deg = ", round(ans9_deg,3)," : ans9_rad = ", round(ans9_rad,3))
ans10_deg = # こちらに度数法の計算式を書いてください。
ans10_rad = # こちらに弧度法の計算式を書いてください。
print("ans10 =", round(ans10,3)," : ans10_deg = ", round(ans10_deg,3)," : ans10_rad = ", round(ans10_rad,3))
ans11_deg = # こちらに度数法の計算式を書いてください。
ans11_rad = # こちらに弧度法の計算式を書いてください。
print("ans11 =", round(ans11,3)," : ans11_deg = ", round(ans11_deg,3)," : ans11_rad = ", round(ans11_rad,3))
ans12_deg = # こちらに度数法の計算式を書いてください。
print("ans12 =", round(ans12,3)," : ans12_deg = ", round(ans12_deg,3))
ans13_deg = # こちらに度数法の計算式を書いてください。
print("ans13 =", round(ans13,3)," : ans13_deg = ", round(ans13_deg,3))
ans14_deg = # こちらに度数法の計算式を書いてください。
print("ans14 =", round(ans14,3)," : ans14_deg = ", round(ans14_deg,3))
ans15_deg = # こちらに度数法の計算式を書いてください。
ans15_rad = # こちらに弧度法の計算式を書いてください。
print("ans15 =", round(ans15,3)," : ans15_deg = ", round(ans15_deg,3)," : ans15_rad = ", round(ans15_rad,3))
ans16_deg = # こちらに度数法の計算式を書いてください。
ans16_rad = # こちらに弧度法の計算式を書いてください。
print("ans16 =", round(ans16,3)," : ans16_deg = ", round(ans16_deg,3)," : ans16_rad = ", round(ans16_rad,3))
import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-np.pi, np.pi)
plt.plot(x, np.sin(x), color='b', label='sin') # color = 'r': red, 'g': green
plt.xlim(-np.pi, np.pi)
plt.ylim(-1.5, 1.5)
plt.axhline(0, ls='-', c='b', lw=0.5)
plt.axvline(0, ls='-', c='b', lw=0.5)
plt.legend()
plt.xlabel('x')
plt.ylabel('y')
plt.title('Graphs')
plt.show()
class GraphClass:
# x_start:x軸の最小値
# x_end:x軸の最大値
# x_start、x_endは表示する関数のデフォルトの定義域
# y_start:y軸の最小値
# y_end:y軸の最大値
def __init__(self, x_start, x_end, y_start , y_end):
self.x_start = x_start
self.x_end = x_end
self.y_start = y_start
self.y_end = y_end
self.x = np.linspace(x_start,x_end)
self.plt = plt
# オーバーライドする。自分が表示したいグラフを定義する
def setGraph(self):
pass
# グラフを表示する
def displayGraph(self):
self.setGraph()
self.__setBasicConfig()
self.plt.show()
# sinグラフを表示する
def displaySin(self):
self.plt.plot(self.x, np.sin(self.x), color='b', label='sin')
self.__setBasicConfig()
self.plt.show()
# cosグラフを表示する
def displayCos(self):
self.plt.plot(self.x, np.cos(self.x), color='r', label='cos')
self.__setBasicConfig()
self.plt.show()
# tanグラフを表示する
def displayTan(self):
self.plt.plot(self.x, np.tan(self.x), color='y', label='tan')
self.__setBasicConfig()
self.plt.show()
# 基本的な設定
def __setBasicConfig(self):
self.plt.xlim(self.x_start, self.x_end)
self.plt.ylim(self.y_start, self.y_end)
self.plt.gca().set_aspect('equal', adjustable='box')
self.plt.axhline(0, ls='-', c='b', lw=0.5)
self.plt.axvline(0, ls='-', c='b', lw=0.5)
self.plt.xticks(rotation=45)
self.plt.legend()
self.plt.xlabel('x')
self.plt.ylabel('y')
self.plt.title('Graphs')
# 自分のクラスを定義する 以下はサンプル
class MyGraphClass(GraphClass):
def __init__(self, x_start, x_end, y_start , y_end):
super().__init__(x_start, x_end, y_start , y_end)
# オーバーライドする
def setGraph(self):
#sin
self.plt.plot(self.x, 2*np.sin(self.x), color='b', label='sin')
#cos
self.plt.plot(self.x, np.cos(self.x), color='g', label='cos')
#単位円 デフォルトとは異なる定義域にする。
r=1
x = np.linspace(-r, r)
self.plt.plot(x, np.sqrt(r ** 2 - x ** 2), color='r', label='x^2+y^2')
self.plt.plot(x, -np.sqrt(r ** 2 - x ** 2), color='r', label='x^2+y^2')
# 点を入れる
self.plt.plot(np.cos(math.radians(30)), np.sin(math.radians(30)), marker='X', markersize=20)
#tan
#self.plt.plot(self.x, np.tan(self.x), color='y', label='tan')
#exp
#self.plt.plot(self.x, np.exp(self.x), color='m', label='exp')
myGraphClass = MyGraphClass(-1,1,-1,1)
myGraphClass.displayGraph()
#myGraphClass.displaySin()
#myGraphClass.displayCos()
#myGraphClass.displayTan()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.visualization.timeline import draw as timeline_draw
from qiskit import QuantumCircuit, transpile
from qiskit.providers.fake_provider import FakeBoeblingen
backend = FakeBoeblingen()
ghz = QuantumCircuit(5)
ghz.h(0)
ghz.cx(0,range(1,5))
circ = transpile(ghz, backend, scheduling_method="asap")
timeline_draw(circ)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_city
qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0,1)
# plot using a Statevector
state = Statevector(qc)
plot_state_city(state)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
import numpy as np
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import BasicAer
from qiskit.compiler import transpile
from qiskit.quantum_info.operators import Operator, Pauli
from qiskit.quantum_info import process_fidelity
from qiskit.extensions import RXGate, XGate, CXGate
XX = Operator([[0, 0, 0, 1], [0, 0, 1, 0], [0, 1, 0, 0], [1, 0, 0, 0]])
XX
XX.data
input_dim, output_dim = XX.dim
input_dim, output_dim
op = Operator(np.random.rand(2 ** 1, 2 ** 2))
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
op = Operator(np.random.rand(6, 6))
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
# Force input dimension to be (4,) rather than (2, 2)
op = Operator(np.random.rand(2 ** 1, 2 ** 2), input_dims=[4])
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
# Specify system is a qubit and qutrit
op = Operator(np.random.rand(6, 6),
input_dims=[2, 3], output_dims=[2, 3])
print('Input dimensions:', op.input_dims())
print('Output dimensions:', op.output_dims())
print('Dimension of input system 0:', op.input_dims([0]))
print('Dimension of input system 1:', op.input_dims([1]))
# Create an Operator from a Pauli object
pauliXX = Pauli('XX')
Operator(pauliXX)
# Create an Operator for a Gate object
Operator(CXGate())
# Create an operator from a parameterized Gate object
Operator(RXGate(np.pi / 2))
# Create an operator from a QuantumCircuit object
circ = QuantumCircuit(10)
circ.h(0)
for j in range(1, 10):
circ.cx(j-1, j)
# Convert circuit to an operator by implicit unitary simulation
Operator(circ)
# Create an operator
XX = Operator(Pauli('XX'))
# Add to a circuit
circ = QuantumCircuit(2, 2)
circ.append(XX, [0, 1])
circ.measure([0,1], [0,1])
circ.draw('mpl')
backend = BasicAer.get_backend('qasm_simulator')
circ = transpile(circ, backend, basis_gates=['u1','u2','u3','cx'])
job = backend.run(circ)
job.result().get_counts(0)
# Add to a circuit
circ2 = QuantumCircuit(2, 2)
circ2.append(Pauli('XX'), [0, 1])
circ2.measure([0,1], [0,1])
circ2.draw()
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.tensor(B)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.expand(B)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.compose(B)
A = Operator(Pauli('X'))
B = Operator(Pauli('Z'))
A.compose(B, front=True)
# Compose XZ with an 3-qubit identity operator
op = Operator(np.eye(2 ** 3))
XZ = Operator(Pauli('XZ'))
op.compose(XZ, qargs=[0, 2])
# Compose YX in front of the previous operator
op = Operator(np.eye(2 ** 3))
YX = Operator(Pauli('YX'))
op.compose(XZ, qargs=[0, 2], front=True)
XX = Operator(Pauli('XX'))
YY = Operator(Pauli('YY'))
ZZ = Operator(Pauli('ZZ'))
op = 0.5 * (XX + YY - 3 * ZZ)
op
op.is_unitary()
# Compose with a matrix passed as a list
Operator(np.eye(2)).compose([[0, 1], [1, 0]])
Operator(Pauli('X')) == Operator(XGate())
Operator(XGate()) == np.exp(1j * 0.5) * Operator(XGate())
# Two operators which differ only by phase
op_a = Operator(XGate())
op_b = np.exp(1j * 0.5) * Operator(XGate())
# Compute process fidelity
F = process_fidelity(op_a, op_b)
print('Process fidelity =', F)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/swe-train/qiskit__qiskit
|
swe-train
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test the DenseLayout pass"""
import unittest
import numpy as np
from qiskit import QuantumRegister, QuantumCircuit, ClassicalRegister
from qiskit.circuit import Parameter, Qubit
from qiskit.circuit.library import CXGate, UGate, ECRGate, RZGate
from qiskit.transpiler import CouplingMap, Target, InstructionProperties, TranspilerError
from qiskit.transpiler.passes import DenseLayout
from qiskit.converters import circuit_to_dag
from qiskit.test import QiskitTestCase
from qiskit.providers.fake_provider import FakeTokyo
from qiskit.transpiler.passes.layout.dense_layout import _build_error_matrix
class TestDenseLayout(QiskitTestCase):
"""Tests the DenseLayout pass"""
def setUp(self):
super().setUp()
self.cmap20 = FakeTokyo().configuration().coupling_map
self.target_19 = Target()
rng = np.random.default_rng(12345)
instruction_props = {
edge: InstructionProperties(
duration=rng.uniform(1e-7, 1e-6), error=rng.uniform(1e-4, 1e-3)
)
for edge in CouplingMap.from_heavy_hex(3).get_edges()
}
self.target_19.add_instruction(CXGate(), instruction_props)
def test_5q_circuit_20q_coupling(self):
"""Test finds dense 5q corner in 20q coupling map."""
qr = QuantumRegister(5, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[3], qr[1])
circuit.cx(qr[0], qr[2])
dag = circuit_to_dag(circuit)
pass_ = DenseLayout(CouplingMap(self.cmap20))
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertEqual(layout[qr[0]], 11)
self.assertEqual(layout[qr[1]], 10)
self.assertEqual(layout[qr[2]], 6)
self.assertEqual(layout[qr[3]], 5)
self.assertEqual(layout[qr[4]], 0)
def test_6q_circuit_20q_coupling(self):
"""Test finds dense 5q corner in 20q coupling map."""
qr0 = QuantumRegister(3, "q0")
qr1 = QuantumRegister(3, "q1")
circuit = QuantumCircuit(qr0, qr1)
circuit.cx(qr0[0], qr1[2])
circuit.cx(qr1[1], qr0[2])
dag = circuit_to_dag(circuit)
pass_ = DenseLayout(CouplingMap(self.cmap20))
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertEqual(layout[qr0[0]], 11)
self.assertEqual(layout[qr0[1]], 10)
self.assertEqual(layout[qr0[2]], 6)
self.assertEqual(layout[qr1[0]], 5)
self.assertEqual(layout[qr1[1]], 1)
self.assertEqual(layout[qr1[2]], 0)
def test_5q_circuit_19q_target_with_noise(self):
"""Test layout works finds a dense 5q subgraph in a 19q heavy hex target."""
qr = QuantumRegister(5, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[3], qr[1])
circuit.cx(qr[0], qr[2])
dag = circuit_to_dag(circuit)
pass_ = DenseLayout(target=self.target_19)
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertEqual(layout[qr[0]], 9)
self.assertEqual(layout[qr[1]], 3)
self.assertEqual(layout[qr[2]], 11)
self.assertEqual(layout[qr[3]], 15)
self.assertEqual(layout[qr[4]], 4)
def test_5q_circuit_19q_target_without_noise(self):
"""Test layout works finds a dense 5q subgraph in a 19q heavy hex target with no noise."""
qr = QuantumRegister(5, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[3], qr[1])
circuit.cx(qr[0], qr[2])
dag = circuit_to_dag(circuit)
instruction_props = {edge: None for edge in CouplingMap.from_heavy_hex(3).get_edges()}
noiseless_target = Target()
noiseless_target.add_instruction(CXGate(), instruction_props)
pass_ = DenseLayout(target=noiseless_target)
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertEqual(layout[qr[0]], 1)
self.assertEqual(layout[qr[1]], 13)
self.assertEqual(layout[qr[2]], 0)
self.assertEqual(layout[qr[3]], 9)
self.assertEqual(layout[qr[4]], 3)
def test_ideal_target_no_coupling(self):
"""Test pass fails as expected if a target without edge constraints exists."""
qr = QuantumRegister(5, "q")
circuit = QuantumCircuit(qr)
circuit.cx(qr[0], qr[3])
circuit.cx(qr[3], qr[4])
circuit.cx(qr[3], qr[1])
circuit.cx(qr[0], qr[2])
dag = circuit_to_dag(circuit)
target = Target(num_qubits=19)
target.add_instruction(CXGate())
layout_pass = DenseLayout(target=target)
with self.assertRaises(TranspilerError):
layout_pass.run(dag)
def test_target_too_small_for_circuit(self):
"""Test error is raised when target is too small for circuit."""
target = Target()
target.add_instruction(
CXGate(), {edge: None for edge in CouplingMap.from_line(3).get_edges()}
)
dag = circuit_to_dag(QuantumCircuit(5))
layout_pass = DenseLayout(target=target)
with self.assertRaises(TranspilerError):
layout_pass.run(dag)
def test_19q_target_with_noise_error_matrix(self):
"""Test the error matrix construction works for a just cx target."""
expected_error_mat = np.zeros((19, 19))
for qargs, props in self.target_19["cx"].items():
error = props.error
expected_error_mat[qargs[0]][qargs[1]] = error
error_mat = _build_error_matrix(
self.target_19.num_qubits,
{i: i for i in range(self.target_19.num_qubits)},
target=self.target_19,
)[0]
np.testing.assert_array_equal(expected_error_mat, error_mat)
def test_multiple_gate_error_matrix(self):
"""Test error matrix ona small target with multiple gets on each qubit generates"""
target = Target(num_qubits=3)
phi = Parameter("phi")
lam = Parameter("lam")
theta = Parameter("theta")
target.add_instruction(
RZGate(phi), {(i,): InstructionProperties(duration=0, error=0) for i in range(3)}
)
target.add_instruction(
UGate(theta, phi, lam),
{(i,): InstructionProperties(duration=1e-7, error=1e-2) for i in range(3)},
)
cx_props = {
(0, 1): InstructionProperties(error=1e-3),
(0, 2): InstructionProperties(error=1e-3),
(1, 0): InstructionProperties(error=1e-3),
(1, 2): InstructionProperties(error=1e-3),
(2, 0): InstructionProperties(error=1e-3),
(2, 1): InstructionProperties(error=1e-3),
}
target.add_instruction(CXGate(), cx_props)
ecr_props = {
(0, 1): InstructionProperties(error=2e-2),
(1, 2): InstructionProperties(error=2e-2),
(2, 0): InstructionProperties(error=2e-2),
}
target.add_instruction(ECRGate(), ecr_props)
expected_error_matrix = np.array(
[
[1e-2, 2e-2, 1e-3],
[1e-3, 1e-2, 2e-2],
[2e-2, 1e-3, 1e-2],
]
)
error_mat = _build_error_matrix(
target.num_qubits, {i: i for i in range(target.num_qubits)}, target=target
)[0]
np.testing.assert_array_equal(expected_error_matrix, error_mat)
def test_5q_circuit_20q_with_if_else(self):
"""Test layout works finds a dense 5q subgraph in a 19q heavy hex target."""
qr = QuantumRegister(5, "q")
cr = ClassicalRegister(5)
circuit = QuantumCircuit(qr, cr)
true_body = QuantumCircuit(qr, cr)
false_body = QuantumCircuit(qr, cr)
true_body.cx(qr[0], qr[3])
true_body.cx(qr[3], qr[4])
false_body.cx(qr[3], qr[1])
false_body.cx(qr[0], qr[2])
circuit.if_else((cr, 0), true_body, false_body, qr, cr)
circuit.cx(0, 4)
dag = circuit_to_dag(circuit)
pass_ = DenseLayout(CouplingMap(self.cmap20))
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertEqual(layout[qr[0]], 11)
self.assertEqual(layout[qr[1]], 10)
self.assertEqual(layout[qr[2]], 6)
self.assertEqual(layout[qr[3]], 5)
self.assertEqual(layout[qr[4]], 0)
def test_loose_bit_circuit(self):
"""Test dense layout works with loose bits outside a register."""
bits = [Qubit() for _ in range(5)]
circuit = QuantumCircuit()
circuit.add_bits(bits)
circuit.h(3)
circuit.cx(3, 4)
circuit.cx(3, 2)
circuit.cx(3, 0)
circuit.cx(3, 1)
dag = circuit_to_dag(circuit)
pass_ = DenseLayout(CouplingMap(self.cmap20))
pass_.run(dag)
layout = pass_.property_set["layout"]
self.assertEqual(layout[bits[0]], 11)
self.assertEqual(layout[bits[1]], 10)
self.assertEqual(layout[bits[2]], 6)
self.assertEqual(layout[bits[3]], 5)
self.assertEqual(layout[bits[4]], 0)
if __name__ == "__main__":
unittest.main()
|
https://github.com/VGGatGitHub/2020-QISKit-Summer-Jam
|
VGGatGitHub
|
import warnings
#warnings.filterwarnings('ignore', 'DeprecationWarning')
warnings.filterwarnings('once')
#%pip uninstall qiskit
#%pip install qiskit #==0.16
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
# useful additional packages
import matplotlib.pyplot as plt
import matplotlib.axes as axes
%matplotlib inline
import numpy as np
import networkx as nx
from qiskit import Aer
from qiskit.tools.visualization import plot_histogram
#VGG todo 1: the equivalent run_algorithm and EnergyInput versions updates
#from qiskit.aqua.translators.ising import max_cut, tsp
#from qiskit.aqua import run_algorithm
#from qiskit.aqua.input import EnergyInput
#old v0.16# from qiskit.optimization.ising import max_cut, tsp
#old v0.16# from qiskit.optimization.ising.common import sample_most_likely
#older# from qiskit.optimization.ising import docplex
from qiskit.optimization.applications.ising import max_cut, tsp
from qiskit.optimization.applications.ising.common import sample_most_likely
from qiskit.optimization.applications.ising import docplex
from qiskit.aqua.algorithms import VQE
from qiskit.aqua.algorithms import NumPyEigensolver as ExactEigensolver
from qiskit.aqua.components.optimizers import SPSA
#from qiskit.aqua.components.variational_forms import RY #RealAmplitudes
from qiskit.circuit.library import RealAmplitudes as RY
from qiskit.aqua import QuantumInstance
# setup aqua logging
import logging
from qiskit.aqua import set_qiskit_aqua_logging
# set_qiskit_aqua_logging(logging.DEBUG) # choose INFO, DEBUG to see the log
from qiskit import IBMQ
provider = IBMQ.load_account()
#VGG select the backend for coupling_map
try:
backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex')
#backend = provider.get_backend('ibmq_london')#'ibmq_16_melbourne')#'ibmq_essex')
#backend = provider.get_backend('ibmq_5_yorktown')#'ibmq_london')#'ibmq_16_melbourne')#'ibmq_essex')
except:
backend = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
coupling_map = backend.configuration().coupling_map
print(coupling_map)
#VGG we will generate a diferent coupling_map for the graph
#coupling_map=None
from typing import List, Tuple
seed = 19120623
np.random.seed(seed)
#VGG: function adopted from the Rigetti's MaxCutQAOA.ipynb
def generate_ising_graph(edges: List[Tuple[int, int]]) -> nx.Graph:
graph = nx.from_edgelist(edges)
weights: np.ndarray = np.random.rand(graph.number_of_edges()) #VGG the old [-1,1] range into [0,1]
weights /= np.linalg.norm(weights)
nx.set_edge_attributes(graph, {e: {'weight': w} for e, w in zip(graph.edges, weights)})
return graph
if coupling_map != None:
G=generate_ising_graph(coupling_map)
n=G.number_of_nodes()
print(n)
# Generating a graph if there were no coupling_map
if coupling_map== None:
#define the edges / coupling_map
#'ibmq_16_melbourne'
elist=[[0, 1], [0, 14], [1, 0], [1, 2], [1, 13], [2, 1], [2, 3], [2, 12],
[3, 2], [3, 4], [3, 11], [4, 3], [4, 5], [4, 10], [5, 4], [5, 6],
[5, 9], [6, 5], [6, 8], [7, 8], [8, 6], [8, 7], [8, 9], [9, 5], [9, 8],
[9, 10], [10, 4], [10, 9], [10, 11], [11, 3], [11, 10], [11, 12], [12, 2],
[12, 11], [12, 13], [13, 1], [13, 12], [13, 14], [14, 0], [14, 13]]
#elist=[[0,1],[0,2],[0,3],[1,2],[2,3],[0,4],[0,2], [4, 3],[1,5],[3,5]]
elist=[[0,1],[0,2],[0,3],[1,2],[2,3],[0,4],[0,2], [4, 3]]
G=generate_ising_graph(elist)
n=G.number_of_nodes()
#other ways to define the graph
#n=5 # Number of nodes in graph
#G=nx.Graph()
#G.add_nodes_from(np.arange(0,n,1))
#ewlist=[(0,1,1.),(0,2,.5),(0,3,0),(1,2,1.0),(0,3,1.0)]
#G1 = nx.from_edgelist(elist)
#G1.add_weighted_edges_from(ewlist)
coupling_map = backend.configuration().coupling_map
#Visulaize
print(G.number_of_nodes(),G.number_of_edges())
colors = ['r' for node in G.nodes()]
pos = nx.spring_layout(G)
default_axes = plt.axes(frameon=True)
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, ax=default_axes, pos=pos)
nx.drawing.nx_pylab.draw(G)
elist=G.edges()
print("elist=",elist)
ewlist=[(i,j,G.get_edge_data(i,j,default=0)['weight']) for i,j in G.edges()]
print('ewlist=',ewlist)
def issymmetric(Matrix):
dim=Matrix.shape[0]
if Matrix.shape[1] != dim:
print("Shape Error!")
return False
for i in range(dim):
for j in range(i,dim):
if Matrix[i,j]!=Matrix[j,i]:
print("Shape Error:",(i,j),Matrix[i,j],Matrix[j,i],"difference:",Matrix[i,j]-Matrix[j,i])
return False
return True
# Computing the weight matrix from the random graph
w = np.zeros([n,n])
w = np.eye(n)
for i in range(n):
for j in range(n):
temp = G.get_edge_data(i,j,default=0)
if temp != 0:
w[i,j] = temp['weight']
w/=np.linalg.det(w)**(1/n)
print("Symmetric:",issymmetric(w),"Norm:",np.linalg.norm(w))
print("Eignvlues:",np.linalg.eigvals(w),"det:",np.linalg.det(w))
print(w)
np.sum(w)/4 #the offset value
def Max_Cut_BF(W,*x0):
best_cost_brute = 0
xbest_brute=np.array([1]*n)
for b in range(2**n):
x = [int(t) for t in reversed(list(bin(b)[2:].zfill(n)))]
cost = 0
for h in x0:
cost -= np.dot(h,x)/n #VGG don't give free samples to those with h==1
for i in range(n):
cost +=(2-np.dot(x,x))/n/2 #VGG try to favor fewer free samples
for j in range(n):
cost += W[i,j]*x[i]*(1-x[j])
if np.isclose(cost,best_cost_brute):
if sum(x)<sum(xbest_brute):
best_cost_brute = cost
xbest_brute = x
else:
if best_cost_brute < cost:
best_cost_brute = cost
xbest_brute = x
if 1==2:
print('case = ' + str(x)+ ' cost = ' + str(cost))
return best_cost_brute, xbest_brute
%%time
if n < 10:
best_cost_brute, xbest_brute = Max_Cut_BF(w)
colors = ['r' if xbest_brute[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha=.8, pos=pos)
print('\nBest solution = ' + str(xbest_brute) + ' cost = ' + str(best_cost_brute))
np.set_printoptions(precision=3)
print(w)
def market_simulations(m,*opt):
free_samples=0
boughten=0
Mw2 = np.zeros([n,n])+w
relations=np.zeros([n,n])
x_free_samples=np.int_(np.zeros(n))
np.set_printoptions(precision=2)
if 'q' in opt:
print("Using Max_Cut option:",'q')
print("submiting for results using:",backend)
elif 'dcplx' in opt:
print("Using Max_Cut option:",'Docplex')
else:
print("Using Max_Cut_BF")
if n > 10 :
print("It may take too long to do Brute Force Calulations - skiping!")
return
print("day"," [free samples]"," [buyers distribution]"," [to be used as constrain]"," the two totals"," w-det")
for i in range(m):
if sum(x_free_samples)>n*2/3:
#VGG In the future one can consider giving out to these who have not recived yet!
x_free_samples = np.array([1]*n)-np.int_(x_free_samples!=0)
if (x_free_samples==0).all:
x=np.array([0]*n)
xbest_brute=np.array([0]*n)
tmp1=Mw2/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,]) #sum probaility contributions
else:
x=x_free_samples
free_samples+=sum(x)
tmp1=Mw2[x==1]/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,],(np.array([1]*n)-x)) #sum probaility contributions
tmp-=np.array([1]*n) #push to negative those with free samples
else:
if 'q' in opt:
best_cost_brute, xbest_brute = Max_Cut_IBMQ(Mw2,x_free_samples)
elif 'dcplx' in opt:
best_cost_brute, xbest_brute = Max_Cut_Dcplx(Mw2,x_free_samples)
else:
best_cost_brute, xbest_brute = Max_Cut_BF(Mw2,x_free_samples)
x=np.array(xbest_brute)
x_free_samples+=x
free_samples+=sum(x)
tmp1=Mw2[x==1]/np.linalg.norm(Mw2) #select only those rows that recived free samples
tmp=sum(tmp1[:,],(np.array([1]*n)-x)) #sum probaility contributions
tmp-=np.array([1]*n) #push to negative those with free samples
#print(tmp)
ab=sum(tmp[tmp > 0])
for j in range(n):
test=np.random.uniform()*ab/2
if tmp[j] > test: #buy the product
x[j]+=1
boughten+=1
x0=np.array(xbest_brute)
x-=x0
relation_today=x.reshape(n,1) @ x0.reshape(1,n)
relation_today+=relation_today.T
relations+=relation_today
#print(x0,x,"\n",relation_today)
#print(x0,x,x_free_samples,tmp)
print(i,x0,x,x_free_samples,free_samples, boughten,'{:6.4f}'.format(np.linalg.det(Mw2)))
if i%4==0 : #weekely updates of the w matrix
Mw2+=(np.eye(n)+relations)/n/100 #update the w matrix
relations=np.zeros([n,n])
if issymmetric(Mw2) and np.linalg.det(Mw2)>0.:
Mw2/=np.linalg.det(Mw2)**(1/n)
else:
Mw2/=np.linalg.norm(Mw2,ord='fro')
print("\nlast day configuration record:\n")
print(x0,tmp)
print()
print(x,free_samples, boughten, '{:6.4f}'.format(np.linalg.norm(Mw2)),'{:6.4f}'.format(np.linalg.det(Mw2)))
print()
print(Mw2)
return
%time market_simulations(10)
#VGG qubitOp, offset = max_cut.get_max_cut_qubitops(w)
qubitOp, offset = max_cut.get_operator(w)
#algo_input = EnergyInput(qubitOp)
offset
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = ExactEigensolver(qubitOp, k=3)
result = ee.run()
print("energys:",result['eigenvalues'].real)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstates'][0])
print('energy:', result['eigenvalues'][0],', offset:',offset)
print('max-cut objective:', result['eigenvalues'][0] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
#VGG note that the other runs had implemeneted soft constrains!
from docplex.mp.model import Model
#VGG from qiskit.aqua.translators.ising import docplex
#older# from qiskit.optimization.ising import docplex
# Create an instance of a model and variables.
mdl = Model(name='max_cut')
y = {i: mdl.binary_var(name='x_{0}'.format(i)) for i in range(n)}
# Object function
#VGG added y[i]/100 term to split the degenerate 1<->0 states in favor of less free samples
max_cut_func = mdl.sum(y[i]/50+w[i,j]* y[i] * ( 1 - y[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
# No constraints for Max-Cut problems.
qubitOp_docplex, offset_docplex = docplex.get_operator(mdl)
offset_docplex
#VGG define the above as a function
def set_up_Dcplx_model(W,*c_x0):
mdl = Model(name='max_cut')
y = {i: mdl.binary_var(name='y_{0}'.format(i)) for i in range(n)}
#VGG try to favor fewer free samples using (2-np.dot(x,x))/n/2
#VGG split the degenerate 1<->0 states in favor of less free samples using x[i]/n**2
max_cut_func=mdl.sum((-1)*(2-y[i])*0.5+(-0)*y[i]/100 for i in range(n))
#VGG don't give free samples to those with h==1
max_cut_func+=mdl.sum(h[i]*y[i]*0.55 for i in range(n) for h in c_x0)
max_cut_func+=mdl.sum(W[i,j]* y[i] * ( 1 - y[j] ) for i in range(n) for j in range(n))
mdl.maximize(max_cut_func)
qubitOp, offset = docplex.get_operator(mdl)
return qubitOp, offset
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w)
print(offset_docplex,x)
#Making the Hamiltonian in its full form and getting the lowest eigenvalue and eigenvector
ee = ExactEigensolver(qubitOp_docplex, k=3)
result = ee.run()
print("energys:",result['eigenvalues'].real)
x = sample_most_likely(result['eigenstates'][0])
print('energy:', result['eigenvalues'][0].real)
print('max-cut objective:', result['eigenvalues'][0].real + offset_docplex)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
x=max_cut.get_graph_solution(x).tolist()
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
#VGG note if you keep executing this cell you can see diferent configurations
#VGG define the above as a function
def Max_Cut_Dcplx(W,*c_x0):
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W)
for h in c_x0:
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W,h)
ee = ExactEigensolver(qubitOp_docplex,k=3)
result = ee.run()
x=sample_most_likely(result['eigenstates'][0])
x_dcplx=max_cut.get_graph_solution(x).tolist()
cost_dcplx=result['eigenvalues'][0].real
#cost_dcplx=max_cut.max_cut_value(x, W)
return cost_dcplx, x_dcplx
%time market_simulations(10,'dcplx')
warnings.filterwarnings('once')
model=qubitOp_docplex
#model=qubitOp
backend1 = Aer.get_backend('statevector_simulator')
backend2 = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
seed = 10598
spsa = SPSA(max_trials=10)
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
#VGG backend1 = Aer.get_backend('statevector_simulator')
quantum_instance = QuantumInstance(backend2, seed_simulator=seed, seed_transpiler=seed)
print(backend2)
result = vqe.run(quantum_instance)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
x=max_cut.get_graph_solution(x).tolist()
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
#warnings.filterwarnings('ignore', 'DeprecationWarning')
warnings.filterwarnings('once')
# run quantum algorithm with shots
seed = 10598
spsa = SPSA(max_trials=30)
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
backend2 = Aer.get_backend('qasm_simulator') #VGG it was 'BasicAer.get_backend' ibmq_16_melbourne
quantum_instance = QuantumInstance(backend2, shots=1024, seed_simulator=seed, seed_transpiler=seed)
print(backend2)
result = vqe.run(quantum_instance)
"""declarative approach, update the param from the previous cell.
params['backend']['provider'] = 'qiskit.BasicAer'
params['backend']['name'] = 'qasm_simulator'
params['backend']['shots'] = 1024
result = run_algorithm(params, algo_input)
"""
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
plot_histogram(result['eigenstate'])
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
x=max_cut.get_graph_solution(x).tolist()
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(w,x)
print(x,offset_docplex)
plot_histogram(result['eigenstate'])
backend_old=backend
#backend=backend2
#warnings.filterwarnings('ignore', 'DeprecationWarning')
# run quantum algorithm with shots
seed = 10598
spsa = SPSA(max_trials=10) #VGG 300
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
#backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)
print("submiting for results using:",backend)
result = vqe.run(quantum_instance)
#VGG# x = max_cut.sample_most_likely(result['eigvecs'][0])
x = sample_most_likely(result['eigenstate'])
print('energy:', result['eigenvalue'])
print('time:', result['optimizer_time'])
print('max-cut objective:', result['eigenvalue'] + offset)
print('solution:', max_cut.get_graph_solution(x))
print('solution objective:', max_cut.max_cut_value(x, w))
colors = ['r' if max_cut.get_graph_solution(x)[i] == 0 else 'b' for i in range(n)]
nx.draw_networkx(G, node_color=colors, node_size=600, alpha = .8, pos=pos)
plot_histogram(result['eigenstate'])
#VGG define the above as a function
def Max_Cut_IBMQ(W,*c_x0):
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W)
for h in c_x0:
qubitOp_docplex, offset_docplex = set_up_Dcplx_model(W,h)
model=qubitOp_docplex
spsa = SPSA(max_trials=10) #VGG 300
ry = RY(model.num_qubits, entanglement='linear') #depth=5,
vqe = VQE(model, ry, spsa)
quantum_instance = QuantumInstance(backend, shots=1024, seed_simulator=seed, seed_transpiler=seed)
result = vqe.run(quantum_instance)
x = sample_most_likely(result['eigenstate'])
cost_vqe=max_cut.max_cut_value(x, W)
x_vqe =np.int_(max_cut.get_graph_solution(x)).tolist()
return cost_vqe, x_vqe
%time market_simulations(10)
%time market_simulations(10,'dcplx')
print(backend)
backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = Aer.get_backend('statevector_simulator')
print(backend)
backend = provider.get_backend('ibmq_16_melbourne')#'ibmq_16_melbourne')#'ibmq_essex' # ibmq_london
#backend = provider.get_backend('ibmq_qasm_simulator')
#backend = Aer.get_backend('qasm_simulator')
#backend = Aer.get_backend('statevector_simulator')
%time market_simulations(10,'q')
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/HermanniH/QRAKEN
|
HermanniH
|
## QRAKEN: Quantum Random Keys via Entanglement. QRAKEN is a certified quantum random number generator for the Qiskit framework.
## Repository: https://github.com/HermanniH/QRAKEN
## Qiskit backend code written by Tobias Haug, comments to tobias.haug@u.nus.edu
## QRAKEN members: Tobias Haug, Hermanni Heimonen, Kishor Bharti
%matplotlib inline
# standard-ish Qiskit libraries
import qiskit
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit, execute, Aer, IBMQ
import os
#Insert IBMQ account string here
#IBMQ.save_account('',overwrite=True) #save access code locally
#IBMQ.enable_account('') # access code only saved in memory
import time
import pickle
import numpy as np
import binascii
# about transpiling, compiling, and executing
from qiskit.compiler import transpile
# For graphs
from qiskit.tools.jupyter import *
from qiskit.visualization import *
# Aer noise models
from qiskit.providers.aer import noise
#Load credentials
IBMQ.load_account()
def flatten(l):
return [item for sublist in l for item in sublist]
qiskit.__qiskit_version__
#set parameters
local=False #run locally (simulation) or on IBM (actual quantum machine)
machine='ibmqx2' #which IBM machine to use #ibmqx2 #ibmq_vigo #'ibmq_ourense'#'ibmq_16_melbourne' #qasm_simulator
dataset='myrandom' #name of dataset
#howToFindLayout="greedy" #Get best pairs by sorting them according to their errors, then picking them top down,
howToFindLayout="recursive" #find recursivly all layouts with highest number of possible pairs, pick one with lowest error. Slower for many qubits
#howToFindLayout="manual" #set them manually in designate_coupling_map_pair
## More specialized options below, can be left on default value
maxQubitPairs=0 #Restrict maximal number of selected qubit pairs, set to 0 if no restriction
x_boost=True #if True, adds x gates after the CNOT gate to increases performance. Set False to not add additional x gates after CNOT gate.
mode=0 #For mode, there are two options, default is 0. The experiment can be run with a perfect Bell-state that maximally violates the CHSH inequality. Mode 0 is explained [here](https://github.com/Qiskit/qiskit-community-tutorials/blob/master/terra/qis_adv/entangled_measurement.ipynb). With mode 1, an alternative gate set creates a Bell state of lower fidelity with less violation and is explained [here](https://decpieibmquantumexperience.blogspot.com/2017/10/chsh-experiment-on-quantum-computer.html)
provider_choice = "" #"copy-paste string in double quotes" (nothing else!), if empty, default is: hub='ibm-q', group='open', project='main'
Nrepeatcircuits=0 #re-run measurement circuits in order to increase number of data gathered in one run. set to 0 to run maximal amount of time
if(howToFindLayout=="manual"): #check if coupling map valid if
designate_coupling_map_pair=[] #for howToFindLayout="manual", manually choose qubit pairs to run.
#designate_coupling_map_pair=[[0,1],[3,4]] #set which qubits to use on machine, enter as a pair of two coupled together, must be of form [[0,1]] or [[0,1],[3,4]]
for i in range(len(designate_coupling_map_pair)):
if(len(designate_coupling_map_pair[i])!=2):
raise NameError("designate_coupling_map_pair should empty list or a list of consisting of a list of two numbers, e.g. [[0,1]] or [[0,1],[3,4]]")
#add parameters to dataset
dataset+="_"+machine+"_"
dataset+=howToFindLayout #add howToFindLayout to dataset name
if(maxQubitPairs!=0):
dataset+="_"+"Pmax"+str(maxQubitPairs)
dataset+="_"+'boost'+str(int(x_boost))
if(mode!=0): #add mode to dataset name
dataset+="m"+str(mode)
if(local==True): #flag dataset if run locally
dataset="Simulated_"+dataset
parametersLog={"local":local,"machine":machine,"howToFindLayout":howToFindLayout,
"maxQubitPairs":maxQubitPairs,"x_boost":x_boost,"mode":mode,"provider_choice":provider_choice,
"Nrepeatcircuits":Nrepeatcircuits}
floatformat='02.7f' #format to print out floats
NmeasurementSettings=4 #number of circuits of Bell inequality
Nbits=2 #consider two bits for a pair, set to 2
dimPair=2**Nbits #number of states in a pair
memory=True #get data of all shots
if(local==True): #run on local simulator
backendRun = Aer.get_backend('qasm_simulator')
#get noise and coupling map for simulation
backend = IBMQ.get_provider().get_backend(machine)
backendConfig=backend.configuration()
properties = backend.properties()
coupling_map = backendConfig.coupling_map
noise_model = noise.device.basic_device_noise_model(properties)
basis_gates = noise_model.basis_gates
else: #send job to IBM quantum device
if provider_choice == "":
provider = IBMQ.get_provider(hub='ibm-q', group='open', project='main') #Choose default provider
backend = provider.get_backend(machine) #get IBM backend
else:
#This is poorly written code, but fast to write.
provider_info = provider_choice.split()
provider = IBMQ.get_provider(hub=provider_info[0][5:-2], group=provider_info[1][7:-2], project=provider_info[2][9:-1]) #get IBM backend
backend = provider.get_backend(machine) #get IBM backend
backendRun=backend
backendConfig=backend.configuration()
properties = backend.properties()
""" #Test using saved setup
infile=open( "x.pcl", "rb" )
[properties,backendConfig]=pickle.load(infile)
infile.close()
"""
coupling_map = backendConfig.coupling_map
shots=backendConfig.max_shots #should not be larger than 8192 or 2**13
if(Nrepeatcircuits==0):
Nrepeatcircuits=backendConfig.max_experiments//NmeasurementSettings #Set repeat circuits to maximal possible amount
NallCircuits=Nrepeatcircuits*NmeasurementSettings #should not be larger than backend.configuration().max_experiments
maxqubits=backendConfig.n_qubits #maximum number of qubits allowed in machine
if(memory==True):
if(backendConfig.memory==False):
print("Error: Memory not supported by machine",machine, "cannot output any bitstrings for randon number generation")
memory=False
if(local==False):
print("Max shots set",shots,", Max shots allowed",backendConfig.max_shots)
print("repeated circuits (Nrepeatcircuits)",Nrepeatcircuits,", Maximum value allowed for Nrepeatcircuits",backendConfig.max_experiments//NmeasurementSettings)
print("Number circuits set",NallCircuits,", Max circuits allowed",backendConfig.max_experiments)
if(shots>backendConfig.max_shots):
raise NameError("shots number not supported by machine, reduce to",backendConfig.max_shots)
if(NallCircuits>backendConfig.max_experiments):
raise NameError("Number of circuits too large, try reducing Nrepeatcircuits to",backendConfig.max_experiments//NmeasurementSettings)
if(howToFindLayout=="manual"):
if(len(flatten(designate_coupling_map_pair))>maxqubits):
raise NameError("Number of parallelized qubit pairs too large, try reducing designate_coupling_map_pair to an empty list or restrict entries to",maxqubits)
try:
%qiskit_backend_overview #Plot overview over all backends
except:
print('WARN: Overview over backends does not work')
backend #Plot used backend
if(howToFindLayout=="manual"):
if(len(designate_coupling_map_pair)!=0): #Choose manually defined layout of qubits
print("Use user-defined qubit pairs",designate_coupling_map_pair)
coupling_map_pair=designate_coupling_map_pair
else:
raise NameError("No coupling map defined by user...")
else: #choose best layout from error map
print("Find best Layout of qubit pairs from read-out errors, single-qubit errors and CNOT errors")
#Check for Errors in different qubits and couplings, and choose best ones
propertiesQubits=properties.qubits
readout_errorList=[] #readout error from each qubit
for i in range(maxqubits):
for j in range(len(propertiesQubits[i])):
if(propertiesQubits[i][j].name=="readout_error"):
readout_errorList.append(propertiesQubits[i][j].value)
couplingMapFull=np.unique(np.sort(coupling_map,axis=1),axis=0) #returns coupling map of only unique entries
graphStructure=couplingMapFull
propertiesGates=properties.gates
cNotErrorUnsortedList=[] #CNOT error of coupled qubits
u3ErrorList=[None for i in range(maxqubits)]
for i in range(len(propertiesGates)):
if(propertiesGates[i].gate=="cx"): #Check if CNOT gate
for j in range(len(couplingMapFull)):
if(np.all(np.sort(propertiesGates[i].qubits)==couplingMapFull[j])): #Select which coupling it corresonds to
for k in range(len(propertiesGates[i].parameters)):
if(propertiesGates[i].parameters[k].name=="gate_error"):
cNotErrorUnsortedList.append([couplingMapFull[j],propertiesGates[i].parameters[k].value])
if(propertiesGates[i].gate=="u3"): #Check if single qubit rotation
for k in range(len(propertiesGates[i].parameters)):
if(propertiesGates[i].parameters[k].name=="gate_error"):
u3ErrorList[propertiesGates[i].qubits[0]]=propertiesGates[i].parameters[k].value
sortedcNotErrorIndex=np.unique([cNotErrorUnsortedList[i][0] for i in range(len(cNotErrorUnsortedList))],return_index=True,axis=0)[1] #remove from cNotError lis doubled entries
cNotErrorList=[cNotErrorUnsortedList[sortedcNotErrorIndex[i]] for i in range(len(sortedcNotErrorIndex))]
#estimate error for a specific qubit pair by adding measurement errors, single qubit u3 error and CNOT error
def estimateError(coupling,readout_errorList,cNotErrorList,u3ErrorList):
error=0
for i in range(len(cNotErrorList)):
if(np.all(cNotErrorList[i][0]==coupling)):
error+=cNotErrorList[i][1]
error+=readout_errorList[coupling[0]]+readout_errorList[coupling[1]]+u3ErrorList[coupling[0]]+u3ErrorList[coupling[1]]
return error
estimatedErrorMap=[]
for i in range(len(couplingMapFull)):
estimatedErrorMap.append([couplingMapFull[i],estimateError(couplingMapFull[i],readout_errorList,cNotErrorList,u3ErrorList)])
if(howToFindLayout=="greedy"):
print("Find layout for pairs by sorting them according to error estimate, then picking them in ascending order and removing unavailable couplings")
#Gets best pairs, by sorting them according to error in a list and picking them one after the other, if qubits of pair are still available. Result may not maximize number of possible pairs
#Nmaxpairs restrict number of maximal pairs, set to zero if no restriction
def runGetBestPairsOnly(estimatedErrorMap,Nmaxpairs=0):
bestCouplings=[]
bestErrors=[]
nPairs=0
argsortError=np.argsort([estimatedErrorMap[i][1] for i in range(len(estimatedErrorMap))])
sortedErorMap=[estimatedErrorMap[argsortError[i]] for i in range(len(estimatedErrorMap))]
while(len(sortedErorMap)>0): # go through all possible couplings
bestCouplings.append(sortedErorMap[0][0])
bestErrors.append(sortedErorMap[0][1])
tempCouplings=np.array([sortedErorMap[i][0] for i in range(len(sortedErorMap))])
deleteUnavailableCouplings=np.nonzero((tempCouplings==tempCouplings[0][0]) | (tempCouplings==tempCouplings[0][1]))[0]
sortedErorMap=np.delete(sortedErorMap,deleteUnavailableCouplings,axis=0) #delete all couplings which are now unavailable after this choice of new pair
nPairs+=1
if(Nmaxpairs!=0 and nPairs>=Nmaxpairs):
break
return bestCouplings,bestErrors
allLayouts=[runGetBestPairsOnly(estimatedErrorMap,Nmaxpairs=maxQubitPairs)[0]]
elif(howToFindLayout=="recursive"):
print("Find layout for pairs by recursivly finding all coupling maps with highest number of pairs")
if(maxqubits>17):
minPairs=0 #minimum number of couplings
maxPairs=maxQubitPairs #maximum number of couplings
getNotFilledSolutions=False #Get solutions which have left over possible couplings
targetNumberPairs=0 #Get specific number of pairs if nonzero
onlyReturnHighestFound=True # only return highest number of couplings
randomizeSearch=3 #randomize coupling_map at every recurisve call if >0, number gives number of restarts of algorithm
maxsolutions=0 #find only this many solutions, then abort
maxtime=20 #maximal runtime in seconds
if(targetNumberPairs>0):
minPairs=targetNumberPairs
maxPairs=targetNumberPairs
getNotFilledSolutions=True
else:
minPairs=0 #minimum number of couplings
maxPairs=maxQubitPairs #maximum number of couplings
getNotFilledSolutions=False #Get solutions which have left over possible couplings
targetNumberPairs=0 #Get specific number of pairs if nonzero
onlyReturnHighestFound=True # only return highest number of couplings
randomizeSearch=1 #randomize coupling_map at every recurisve call if >0, number gives number of restarts of algorithm
maxsolutions=0 #find only this many solutions, then abort
maxtime=10000 #maximal runtime in seconds
if(targetNumberPairs>0):
minPairs=targetNumberPairs
maxPairs=targetNumberPairs
getNotFilledSolutions=True
#recursive function to find pairs of couplings. Given a number of selected pairs already, selects all possible next choice of pair, then recursivly calls itself.
def recursiveFindPairs(selectedPairs,couplingMap,ini=1,highestnumberPairsReached=0): # make sure ini=1 for call
global _highestnumberPairsReached,_solutionsFound,_starttimerec
if(ini==1): #Initialize internal counter that is shared inside the recursive algorithm
_highestnumberPairsReached=highestnumberPairsReached
_solutionsFound=0
_starttimerec=time.time()
newSelectedPairsList=[]
currentLengthPairs=len(selectedPairs)
leftoverPairs=len(couplingMap)
if(randomizeSearch>0): #Randomize order to achieve different results in each run
x=np.arange(leftoverPairs)
np.random.shuffle(x)
couplingMap=couplingMap[x]
levelCouplingMap=couplingMap
if(leftoverPairs>0): #if still pairs available
if(_highestnumberPairsReached<currentLengthPairs+1): #calculate highest pair found so far
_highestnumberPairsReached=currentLengthPairs+1
#print(_highestnumberPairsReached)
for i in range(len(couplingMap)): # go through all possible couplings at this point
#levelCouplingMap=np.array(levelCouplingMap) #copy available couplings to new array
newSelectedPairs=np.array(selectedPairs)
if(len(selectedPairs)>0): #check if this is first pair
newSelectedPairs=np.append(newSelectedPairs,[couplingMap[i]],axis=0) #append new coupling pair
else:
newSelectedPairs=np.array([couplingMap[i]]) #make first pair
levelCouplingMap=np.delete(levelCouplingMap,0,axis=0) #delete selected pair from list of couplings
deleteUnavailableCouplings=np.nonzero((levelCouplingMap==couplingMap[i][0]) | (levelCouplingMap==couplingMap[i][1]))[0]
newCouplingMap=np.delete(levelCouplingMap,deleteUnavailableCouplings,axis=0) #delete all couplings which are now unavailable after this choice of new pair
if(onlyReturnHighestFound==False or (len(newSelectedPairs)+len(newCouplingMap))>=_highestnumberPairsReached): # if onlyReturnHighestFound==True check if number of theoretical possible pairs is equal or higher than highestnumberPairsReached
if(len(newCouplingMap)>0): #if still pairs available
if(getNotFilledSolutions==True and len(newSelectedPairs)>=minPairs and (len(newSelectedPairs)<=maxPairs or maxPairs==0)): #add this solution although other pairs still available if getNotFilledSolutions==True
newSelectedPairsList.append(newSelectedPairs)
_solutionsFound+=1
if(_solutionsFound%100==0): #print to monitor progress
print(_solutionsFound)
if(maxsolutions!=0 and _solutionsFound>=maxsolutions): #stop if found enough solutions
break
if(time.time()-_starttimerec>maxtime): #stop if out of time
break
if(len(newSelectedPairs)<maxPairs or maxPairs==0):
newSelectedPairsList+=recursiveFindPairs(newSelectedPairs,newCouplingMap,ini=0) #next recursive step
if(maxsolutions!=0 and _solutionsFound>=maxsolutions):
break
if(time.time()-_starttimerec>maxtime):
break
else:
if(len(newSelectedPairs)>=minPairs and (len(newSelectedPairs)<=maxPairs or maxPairs==0)): # if all pairs selected, append to list of solutions
newSelectedPairsList.append(newSelectedPairs)
_solutionsFound+=1
if(_solutionsFound%100==0): #print to monitor progress
print(_solutionsFound)
if(maxsolutions!=0 and _solutionsFound>=maxsolutions): #stop if found enough solutions
break
if(time.time()-_starttimerec>maxtime): #stop if out of time
break
return newSelectedPairsList
startrec=time.time()
allLayouts=recursiveFindPairs([],couplingMapFull) #all possible layouts of qubit pairs in circuit
for i in range(randomizeSearch-1): #if randomize is greater 1, re-run algorithm to try different randomized paths
print("Restart recursive algorithm to try different path")
allLayouts+=recursiveFindPairs([],couplingMapFull,highestnumberPairsReached=_highestnumberPairsReached) #all possible layouts of qubit pairs in circuit
print('Time recursive search',time.time()-startrec)
#allLayouts
#get layouts with maximal number of pairs
if(len(allLayouts)==0):
raise NameError("ERROR: Could not find any suitable layouts")
maxLayout=np.amax([len(allLayouts[i]) for i in range(len(allLayouts))])
maxLayoutIndexList=np.nonzero([len(allLayouts[i])==maxLayout for i in range(len(allLayouts))])[0]
maxLayoutList=[allLayouts[maxLayoutIndexList[i]] for i in range(len(maxLayoutIndexList))]
print("Maximal number of pairs found",maxLayout, ", found",len(maxLayoutList),"possible solutions")
#print(maxLayoutList)
print("Estimate errors of possible layout solutions")
estimateErrorList=[np.sum([estimateError(coupling,readout_errorList,cNotErrorList,u3ErrorList) for coupling in maxLayoutList[i]]) for i in range(len(maxLayoutList))]
bestIndex=np.argsort(estimateErrorList)[0]
bestLayout=maxLayoutList[bestIndex]
print("Best Layout with estimated Error", estimateErrorList[bestIndex])
coupling_map_pair=bestLayout
bestLayout
initial_layout=flatten(coupling_map_pair) #layout of physical qubits used
newstring="_I"
for i in range(len(initial_layout)):
newstring+="_"+str(initial_layout[i])
if(dataset.find(newstring)==-1):
dataset+=newstring
if not os.path.exists(dataset):
print('Generating folder',dataset,', store all results here.')
os.makedirs(dataset)
else:
print('Folder',dataset,'already exists, store all results here.')
#get errors for qubit pairs actually used
print("Show error for qubits used")
QubitsUsedMeasurementError=[]
u3UsedError=[]
for i in range(len(coupling_map_pair)):
for j in range(2):
QubitsUsedMeasurementError.append([2*i+j,coupling_map_pair[i][j],readout_errorList[coupling_map_pair[i][j]]])
u3UsedError.append([2*i+j,coupling_map_pair[i][j],u3ErrorList[coupling_map_pair[i][j]]])
print("Error of qbit number",2*i+j,"physical position",coupling_map_pair[i][j],"Readout Error",readout_errorList[coupling_map_pair[i][j]],"U3 error",u3ErrorList[coupling_map_pair[i][j]])
print("")
CNOTsUsedError=[]
for i in range(len(coupling_map_pair)):
for j in range(len(couplingMapFull)):
if(np.all(cNotErrorList[j][0]==np.sort(coupling_map_pair[i]))):
CNOTsUsedError.append([i,coupling_map_pair[i],cNotErrorList[j][1]])
print(i,coupling_map_pair[i],"CNOT Error",cNotErrorList[j][1])
print("")
print("Estimated error for each pair")
for i in range(len(coupling_map_pair)):
print("pair",i,coupling_map_pair[i],estimateError(coupling_map_pair[i],readout_errorList,cNotErrorList,u3ErrorList))
##QubitsUsedMeasurementError[2*i][2]+QubitsUsedMeasurementError[2*i+1][2]+CNOTsUsedError[i][2]+u3UsedError[2*i][2]+u3UsedError[2*i+1][2])
Nqubitpairs=len(coupling_map_pair)
print("Bits Generated per run", Nqubitpairs*NallCircuits*shots*Nbits)
InequalityTheory=2*np.sqrt(2) #theoretic maximal value for CHSH inequality
InequalityClassicBound=2 #classic bound for CHSH inequality
circuitstring=['00','01','10','11'] #measurement settings
dictStates=['00','01','10','11'] #output states of two pairs
#maps measurement results for two quibit measurement 0 or 1 to either +1 or -1. This is used to generate the expectation value.
#stands for bit result ket(00) --> 1, ket(01)-->-1 ket(10)-->-1 ket(11)-->1
mappingBitResultToPM=np.array([1,-1,-1,1])
#define CHSHS inequality. We have 4 terms ZZ, ZX, XZ, XX, each generated by one of the circuits. We now assign three terms with +1, and one with -1.
# The factors are multiplied with the average value of the respective circuits
if(mode==0):
CHSHfactors=np.array([1,1,1,-1])
elif(mode==1):
CHSHfactors=np.array([1,1,-1,1])
circuit=[None for i in range(NmeasurementSettings)]
#first step generates Bell state 00 + 11 by using a Hadamard and CNOT
qr = QuantumRegister(Nbits*Nqubitpairs, 'qr')
cr = ClassicalRegister(Nbits*Nqubitpairs, 'cr')
for i in range(NmeasurementSettings):
circuit[i] = QuantumCircuit(qr, cr)
for j in range(Nqubitpairs):
circuit[i].h(qr[2*j])
circuit[i].cx(qr[2*j], qr[2*j+1])
if x_boost: #add sinlge qubit gates to correct errors introduced by CNOT
circuit[i].barrier(qr[2*j+1])
circuit[i].barrier(qr[2*j])
circuit[i].x(qr[2*j])
circuit[i].x(qr[2*j+1])
circuit[i].barrier(qr[2*j+1])
circuit[i].barrier(qr[2*j])
#Next, implement measurements settings
#Here, we generate circuits that implement rotations in the desired basis, and then measure in the computation basis
#two ways to generate CHSH circuit
if(mode==0): #maximal violation
#four measurement settings, generate four circuits
#ZW
current=0
for j in range(Nqubitpairs):
circuit[current].s(qr[2*j+1])
circuit[current].h(qr[2*j+1])
circuit[current].t(qr[2*j+1])
circuit[current].h(qr[2*j+1])
#ZV
current=1
for j in range(Nqubitpairs):
circuit[current].s(qr[2*j+1])
circuit[current].h(qr[2*j+1])
circuit[current].tdg(qr[2*j+1])
circuit[current].h(qr[2*j+1])
#XW
current=2
for j in range(Nqubitpairs):
circuit[current].h(qr[2*j])
circuit[current].s(qr[2*j+1])
circuit[current].h(qr[2*j+1])
circuit[current].t(qr[2*j+1])
circuit[current].h(qr[2*j+1])
#ZV
current=3
for j in range(Nqubitpairs):
circuit[current].h(qr[2*j])
circuit[current].s(qr[2*j+1])
circuit[current].h(qr[2*j+1])
circuit[current].tdg(qr[2*j+1])
circuit[current].h(qr[2*j+1])
elif(mode==1): #does not generate maximal violation, only up to 2.77
theta=-3*np.pi/16
for i in range(NmeasurementSettings):
for j in range(Nqubitpairs):
circuit[i].u3(theta,0,0,qr[2*j])
#ZZ gate
#ZX gate
for j in range(Nqubitpairs):
circuit[1].h(qr[2*j+1])
#XZ gate
circuit[2].h(qr[2*j])
#XX
circuit[3].h(qr[2*j])
circuit[3].h(qr[2*j+1])
for i in range(NmeasurementSettings):
circuit[i].barrier()
#generate circuits with measurements
circuitMeas=[circuit[i].copy() for i in range(NmeasurementSettings)]
for i in range(NmeasurementSettings):
circuitMeas[i].measure(qr, cr)
for i in range(NmeasurementSettings):
print(circuit[i].draw()) #draw circuits without measurements
plotmeas=3 #Plots circuit number plotmeas nicely
fig=circuitMeas[plotmeas].draw(scale = 1,output='mpl')
fig
#Simulate circuit exactly as a reference using statevector_simulator backend
if(dimPair**Nqubitpairs<=2**14):# only run if system small enough
simNqubitpairs=Nqubitpairs
# Run the quantum circuit on a statevector simulator backend
sv_simulator = Aer.get_backend('statevector_simulator')
#The states outputed by the IBM machine are encoded as hex integer, and order of qubits is reversed, e.g. qubit 0 corresponds to last bit of state. Here, we reverse the order to get the right result, e.g. first physical qubit corresponds to first bit of state
allStates=[] #all states measured in circuit
for i in range(dimPair**simNqubitpairs):
allStates.append(format(i, '0'+str(simNqubitpairs*2)+'b'))
#sets all states k to one that identify with state of pair j for parallel measured qubit pair i mapStatesToParallel[i][j][k]
mapStatesToParallel=np.zeros([simNqubitpairs,NmeasurementSettings,dimPair**simNqubitpairs])
for i in range(simNqubitpairs):
for j in range(dimPair):
for k in range(dimPair**simNqubitpairs):
if(allStates[k][2*i:2*(i+1)]==dictStates[j]):
mapStatesToParallel[i][j][k]=1
#to generate state, use circuits without measurement
outputvector=[None for i in range(NmeasurementSettings)]
for i in range(NmeasurementSettings):
# Execute the circuit
jobStatevector = execute(circuit[i], sv_simulator)
# Get the result
resultStatevector = jobStatevector.result()
outputstate = resultStatevector.get_statevector(circuit[i], decimals=20)
outputvector[i]=outputstate
#print(outputvector)
probabilities=np.abs(np.array(outputvector))**2 #probablities of all states
#map probabilities to one pair of 00,01,10,11
probabilitiesMappedToPairTheory=[np.sum(np.sum(mapStatesToParallel,axis=0)*probabilities[i],axis=1)/simNqubitpairs for i in range(NmeasurementSettings)]
theoryCountsMappedToPair=[{} for i in range(NmeasurementSettings)]
for i in range(NmeasurementSettings):
for m in range(dimPair):
theoryCountsMappedToPair[i][dictStates[m]]=probabilitiesMappedToPairTheory[i][m]
mappedtoZZSimulated=probabilitiesMappedToPairTheory*mappingBitResultToPM #map each state to a expectation Value of ZZ
summedOverEachTermSimulated=np.sum(mappedtoZZSimulated,axis=1) #sum over result of each measurement Setting
InequalitySimulated=np.sum(summedOverEachTermSimulated*CHSHfactors) #mulitiply with CHSH factors
print("S from statevector",InequalitySimulated,"S from theory",InequalityTheory,"Difference",InequalityTheory-InequalitySimulated)
print("Probabilities for each measurement setting and state")
print(probabilitiesMappedToPairTheory)
else: #Use pre-calculated values
if(mode==0):
probabilitiesMappedToPairTheory=[np.array([0.4267767, 0.0732233, 0.0732233, 0.4267767]), np.array([0.4267767, 0.0732233, 0.0732233, 0.4267767]), np.array([0.4267767, 0.0732233, 0.0732233, 0.4267767]), np.array([0.0732233, 0.4267767, 0.4267767, 0.0732233])]
elif(mode==1):
probabilitiesMappedToPairTheory=[np.array([0.4578674, 0.0421326, 0.0421326, 0.4578674]), np.array([0.38889256, 0.11110744, 0.11110744, 0.38889256]), np.array([0.11110744, 0.38889256, 0.38889256, 0.11110744]), np.array([0.4578674, 0.0421326, 0.0421326, 0.4578674])]
#we run the NmeasurementSettings each Nrepeatcircuits times to generate more data per run on the IBM machine
print('Prepare circuits for submission')
allcircuits=flatten([[circuitMeas[j].copy() for j in range(NmeasurementSettings)] for i in range(Nrepeatcircuits)])
for i in range(Nrepeatcircuits):
for j in range(NmeasurementSettings):
allcircuits[i*NmeasurementSettings+j].name="CircuitSetting"+str(j)+"Repeat"+str(i)
#
#construct layout format, mapping virtual qubits qr[i] to physical qubits of initial_layout
layout={}
for i in range(len(initial_layout)):
layout[qr[i]]=int(initial_layout[i])
#layout
#generate transpiler
#if(len(initial_layout)==0):
# trans=transpile(allcircuits,backend)#,initial_layout=[0,1]
#else:
# trans=transpile(allcircuits,backend,initial_layout=initial_layout)
#Submit job
#jobIBMqx2 = execute(circuitMeas, ibmqx2, shots=shots,memory=True)#,meas_return='single',meas_level=0
startSubmissiontime=time.time()
if(local==True):
print("Run with noise models of",machine,"locally")
if(len(layout)==0):
job = execute(allcircuits, backendRun, shots=shots,memory=memory,
coupling_map=coupling_map,
noise_model=noise_model,
basis_gates=basis_gates)
else:
job = execute(allcircuits, backendRun, shots=shots,memory=memory,
coupling_map=coupling_map,
noise_model=noise_model,
basis_gates=basis_gates,initial_layout=layout)
else:
print("Run on IBM backend",machine)
if(len(layout)==0):
print("Run without initial_layout")
job =execute(allcircuits,backendRun, shots=shots,memory=memory)
else:
print("Run with initial_layout",initial_layout)
job =execute(allcircuits,backendRun, shots=shots,memory=memory,initial_layout=layout)
print("time taken to submit to IBM machine",machine,"queue",time.time()-startSubmissiontime)
#Check status of current job
#job = backend.retrieve_job(jobID) #retrieve job if jobID is known
## get the last 10 jobs on backend
#jobs = backend.jobs()
jobID=job.job_id()
print('Job ID: ', jobID)
print('Job status: ', job.status())
if(local==False):
print("Queue position",job.queue_position())
print("number jobs waiting",backendRun.status().pending_jobs)
# Grab the results from the job.
print("Waiting for job to finish and retrieve data")
startRetrievalTime=time.time()
result = job.result()
waittime=time.time()-startRetrievalTime
print("wait time for retrieval",waittime)
date=result.date
try:
time_taken=result.time_taken
print("Time taken to run on machine",time_taken)
except:
print("WARN: Cannot get time_taken from machine...")
time_taken=0
#Evaluate data
totalshots=shots*Nrepeatcircuits #total shots for each measurement setting
counts=[{} for i in range(NmeasurementSettings)] #store counts for each measurement state here
countsPairState=[[{} for i in range(NmeasurementSettings)] for p in range(Nqubitpairs)] #store counts for each measurement state here
totalcounts=np.zeros([Nqubitpairs,NmeasurementSettings])
#if(len(allStates)<2**10):
# for i in range(NmeasurementSettings):
# for m in range(len(allStates)):
# counts[i][allStates[m]]=0
#countsVec=[None for i in range(NmeasurementSettings)] #counts ordered in a numpy vector
#measuredProbablity=[None for i in range(NmeasurementSettings)] #counts normalized to one
measuredProbabilityPairState=np.zeros([Nqubitpairs,NmeasurementSettings,dimPair])
shotsResult=[[None for i in range(NmeasurementSettings)] for p in range(Nqubitpairs)] #outputs 0 or 1 for each measurement result
measSetting=[[None for i in range(NmeasurementSettings)] for p in range(Nqubitpairs)]#outputs 0 or 1 for each measurement Setting applied
print("Start evaluation of data")
for i in range(NmeasurementSettings):#add up counts from each measurement
for k in range(Nrepeatcircuits): #add up counts from each repeated measurement setting
tempgetcounts=result.get_counts(k*NmeasurementSettings+i) #dict of results from measurements in form state : counts
for key in tempgetcounts.keys(): #iterate over counts for each measured state in tempgetcounts
if key in counts[i]:
counts[i][key]+=tempgetcounts[key] #add results to i measurement setting
else:
counts[i][key]=tempgetcounts[key] #create new key in dict if not exist yet
for state in counts[i]:
for p in range(Nqubitpairs):
measuredProbabilityPairState[Nqubitpairs-1-p,i,int(state[Nbits*p:Nbits*(p+1)][::-1],2)]+=counts[i][state] #extract meausred pair from state, and add to counts for each Nqubitpairs. Reverse order of string due to Qiskit inverse ordering of states
totalcounts[:,i]=np.sum(measuredProbabilityPairState[:,i,:],axis=-1) #total counts per measurement setting and qubit pair
for p in range(Nqubitpairs):
measuredProbabilityPairState[p,i,:]/=totalcounts[p,i] #Divide by total counts to get probabilities
#make dict of measured state pairs
for p in range(Nqubitpairs):
for m in range(len(dictStates)):
countsPairState[p][i][dictStates[m]]=measuredProbabilityPairState[p,i,m]
if(memory==True): #get actual results for each shot
for k in range(Nrepeatcircuits):
if(k==0):
memoryResult=result.data(k*NmeasurementSettings+i)['memory'] #list of which state has been measured in hex format
else:
memoryResult+=result.data(k*NmeasurementSettings+i)['memory']
for p in range(Nqubitpairs):
#shotsResult[p][i]=[orderStates[int(memoryResult[j],16)][Nbits*p:Nbits*(p+1)] for j in range(totalshots)] #convert hex to int, then reorder states to canonical format and give string
shotsResult[p][i]=[format(int(memoryResult[j],16), '0'+str(Nqubitpairs*Nbits)+'b')[::-1][Nbits*p:Nbits*(p+1)] for j in range(totalshots)] #convert hex to int, then reorder states to canonical format and give string
measSetting[p][i]=[circuitstring[i] for j in range(totalshots)] #record measurement setting
InequalityMeasured=[]
compareExact=[]
for p in range(Nqubitpairs):
mappedtoZZResult=measuredProbabilityPairState[p]*mappingBitResultToPM #multiply probablity distribution with prefactor of expectation value of <ZZ>
summedOverEachTermResult=np.sum(mappedtoZZResult,axis=1) #get each term of the inequality
InequalityMeasured.append(np.sum(summedOverEachTermResult*CHSHfactors)) #multiply terms of inequality with prefactor of CHSH
compareExact.append([np.transpose([measuredProbabilityPairState[p,i],probabilitiesMappedToPairTheory[i]]) for i in range(NmeasurementSettings)]) #compares result of each state for each measurementSetting against theory result
print("For parallel qubit pair",p,"inequality measured",InequalityMeasured[p],"Theoretic value",InequalityTheory,"Difference",InequalityTheory-InequalityMeasured[p], 'Violation of classic bound', InequalityMeasured[p]-InequalityClassicBound)
if(InequalityMeasured[p]-InequalityClassicBound<0):
print("WARNING: qubit pair",p,'does not violate classic bound, randomness of numbers is not guaranteed!')
#print("Shows experiment and theory for each measurement setting and state")
#print("[measured probability, theoretic probability]")
#for p in range(Nqubitpairs):
# print("Parallel qubit pair",p)
# for i in range(NmeasurementSettings):
# print("Measurement setting",i)
# print(compareExact[p][i])
#histogram of measured counts, for each term of the inequality
for p in range(Nqubitpairs):
fig=plot_histogram(countsPairState[p])
fig.savefig(os.path.join(dataset,"Hist_p"+str(p)+"_S"+format(InequalityMeasured[p],floatformat).replace(".","_")+".pdf"))
display(fig)
fig=plot_histogram(theoryCountsMappedToPair)
fig.savefig(os.path.join(dataset,"Hist_"+"theory"+"_"+"_S"+format(InequalityTheory,floatformat).replace(".","_")+".pdf"))
display(fig)
#Output data
resultA=[[] for i in range(Nqubitpairs)] #alice measuremnt result
resultB=[[] for i in range(Nqubitpairs)] #bob measurement result
measSettingA=[[] for i in range(Nqubitpairs)] #alice measurement Setting
measSettingB=[[] for i in range(Nqubitpairs)] #bob measurement Setting
if(memory==True):
for p in range(Nqubitpairs):
print("Output qubit pair",p,"of parallel run")
print("Generating output bits of measurement results and settings for Alice and Bob")
shuffleCircuits=flatten([np.ones(totalshots,dtype=int)*i for i in range(NmeasurementSettings)]) #shuffle differen measurement types
np.random.shuffle(shuffleCircuits)
for i in range(NmeasurementSettings):
for j in range(totalshots):
circuitindex=shuffleCircuits[i*totalshots+j] #use shuffled index
resultA[p]+=shotsResult[p][circuitindex][j][0]
resultB[p]+=shotsResult[p][circuitindex][j][1]
measSettingA[p]+=measSetting[p][circuitindex][j][0]
measSettingB[p]+=measSetting[p][circuitindex][j][1]
#output
#first file contains Alice Result, Bob result, Alice Measurement settings and Bob measurement Settings
with open(os.path.join(dataset,'MeasurementsAndSettings_'+"Pair_"+str(p)+"_S"+format(InequalityMeasured[p],floatformat).replace(".","_")+'.txt'), 'w') as the_file:
the_file.write("".join(resultA[p])+"\n")
the_file.write("".join(resultB[p])+"\n")
the_file.write("".join(measSettingA[p])+"\n")
the_file.write("".join(measSettingB[p]))
#contains Alice Results and Bob results. Use this for the Extractor
with open(os.path.join(dataset,'Measurements_'+"Pair_"+str(p)+"_S"+format(InequalityMeasured[p],floatformat).replace(".","_")+'.txt'), 'w') as the_file:
the_file.write("".join(resultA[p])+"\n")
the_file.write("".join(resultB[p]))
#dump all data in pickle
outfile=open( os.path.join(dataset,"outputCHSH_"+".pcl"), "wb" )
pickledict={"date":date,"parametersLog":parametersLog,'jobID':jobID,"shots":shots,"Nrepeatcircuits":Nrepeatcircuits,
"dimPair":dimPair,"Nqubitpairs":Nqubitpairs,"time_taken":time_taken,"coupling_map_pair":coupling_map_pair,
"QubitsUsedMeasurementError":QubitsUsedMeasurementError,"CNOTsUsedError":CNOTsUsedError,
"u3UsedError":u3UsedError,"result":result,"InequalityMeasured":InequalityMeasured,"InequalityTheory":InequalityTheory,'InequalityClassicBound':InequalityClassicBound,"compareExact":compareExact
}
#pickle.dump([date,mode,machine,shots,Nrepeatcircuits,dimPair,Nqubitpairs,time_taken,coupling_map_pair,QubitsUsedMeasurementError,CNOTsUsedError,u3UsedError,result,InequalityMeasured,InequalityTheory,compareExact], outfile)
pickle.dump(pickledict, outfile)
outfile.close()
print("Finish output")
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_bloch_multivector
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
state = Statevector(qc)
plot_bloch_multivector(state)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
# Necessary imports
import matplotlib.pyplot as plt
import numpy as np
from IPython.display import clear_output
from qiskit import QuantumCircuit
from qiskit.algorithms.optimizers import COBYLA
from qiskit.circuit.library import ZFeatureMap, RealAmplitudes
from qiskit.utils import algorithm_globals
from sklearn.datasets import make_classification
from sklearn.preprocessing import MinMaxScaler
from qiskit_machine_learning.algorithms.classifiers import NeuralNetworkClassifier
from qiskit_machine_learning.neural_networks import EffectiveDimension, LocalEffectiveDimension
from qiskit_machine_learning.neural_networks import SamplerQNN, EstimatorQNN
# set random seed
algorithm_globals.random_seed = 42
num_qubits = 3
# create a feature map
feature_map = ZFeatureMap(feature_dimension=num_qubits, reps=1)
# create a variational circuit
ansatz = RealAmplitudes(num_qubits, reps=1)
# combine feature map and ansatz into a single circuit
qc = QuantumCircuit(num_qubits)
qc.append(feature_map, range(num_qubits))
qc.append(ansatz, range(num_qubits))
qc.decompose().draw("mpl")
# parity maps bitstrings to 0 or 1
def parity(x):
return "{:b}".format(x).count("1") % 2
output_shape = 2 # corresponds to the number of classes, possible outcomes of the (parity) mapping.
# construct QNN
qnn = SamplerQNN(
circuit=qc,
input_params=feature_map.parameters,
weight_params=ansatz.parameters,
interpret=parity,
output_shape=output_shape,
sparse=False,
)
# we can set the total number of input samples and weight samples for random selection
num_input_samples = 10
num_weight_samples = 10
global_ed = EffectiveDimension(
qnn=qnn, weight_samples=num_weight_samples, input_samples=num_input_samples
)
# we can also provide user-defined samples and parameters
input_samples = algorithm_globals.random.normal(0, 1, size=(10, qnn.num_inputs))
weight_samples = algorithm_globals.random.uniform(0, 1, size=(10, qnn.num_weights))
global_ed = EffectiveDimension(qnn=qnn, weight_samples=weight_samples, input_samples=input_samples)
# finally, we will define ranges to test different numbers of data, n
n = [5000, 8000, 10000, 40000, 60000, 100000, 150000, 200000, 500000, 1000000]
global_eff_dim_0 = global_ed.get_effective_dimension(dataset_size=n[0])
d = qnn.num_weights
print("Data size: {}, global effective dimension: {:.4f}".format(n[0], global_eff_dim_0))
print(
"Number of weights: {}, normalized effective dimension: {:.4f}".format(d, global_eff_dim_0 / d)
)
global_eff_dim_1 = global_ed.get_effective_dimension(dataset_size=n)
print("Effective dimension: {}".format(global_eff_dim_1))
print("Number of weights: {}".format(d))
# plot the normalized effective dimension for the model
plt.plot(n, np.array(global_eff_dim_1) / d)
plt.xlabel("Number of data")
plt.ylabel("Normalized GLOBAL effective dimension")
plt.show()
num_inputs = 3
num_samples = 50
X, y = make_classification(
n_samples=num_samples,
n_features=num_inputs,
n_informative=3,
n_redundant=0,
n_clusters_per_class=1,
class_sep=2.0,
)
X = MinMaxScaler().fit_transform(X)
y = 2 * y - 1 # labels in {-1, 1}
estimator_qnn = EstimatorQNN(
circuit=qc, input_params=feature_map.parameters, weight_params=ansatz.parameters
)
# callback function that draws a live plot when the .fit() method is called
def callback_graph(weights, obj_func_eval):
clear_output(wait=True)
objective_func_vals.append(obj_func_eval)
plt.title("Objective function value against iteration")
plt.xlabel("Iteration")
plt.ylabel("Objective function value")
plt.plot(range(len(objective_func_vals)), objective_func_vals)
plt.show()
# construct classifier
initial_point = algorithm_globals.random.random(estimator_qnn.num_weights)
estimator_classifier = NeuralNetworkClassifier(
neural_network=estimator_qnn,
optimizer=COBYLA(maxiter=80),
initial_point=initial_point,
callback=callback_graph,
)
# create empty array for callback to store evaluations of the objective function (callback)
objective_func_vals = []
plt.rcParams["figure.figsize"] = (12, 6)
# fit classifier to data
estimator_classifier.fit(X, y)
# return to default figsize
plt.rcParams["figure.figsize"] = (6, 4)
# score classifier
estimator_classifier.score(X, y)
trained_weights = estimator_classifier.weights
# get Local Effective Dimension for set of trained weights
local_ed_trained = LocalEffectiveDimension(
qnn=estimator_qnn, weight_samples=trained_weights, input_samples=X
)
local_eff_dim_trained = local_ed_trained.get_effective_dimension(dataset_size=n)
print(
"normalized local effective dimensions for trained QNN: ",
local_eff_dim_trained / estimator_qnn.num_weights,
)
# get Local Effective Dimension for set of untrained weights
local_ed_untrained = LocalEffectiveDimension(
qnn=estimator_qnn, weight_samples=initial_point, input_samples=X
)
local_eff_dim_untrained = local_ed_untrained.get_effective_dimension(dataset_size=n)
print(
"normalized local effective dimensions for untrained QNN: ",
local_eff_dim_untrained / estimator_qnn.num_weights,
)
# plot the normalized effective dimension for the model
plt.plot(n, np.array(local_eff_dim_trained) / estimator_qnn.num_weights, label="trained weights")
plt.plot(
n, np.array(local_eff_dim_untrained) / estimator_qnn.num_weights, label="untrained weights"
)
plt.xlabel("Number of data")
plt.ylabel("Normalized LOCAL effective dimension")
plt.legend()
plt.show()
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/C2QA/bosonic-qiskit
|
C2QA
|
# To use the package locally, add the C2QA repository's root folder to the path prior to importing c2qa.
import os
import sys
module_path = os.path.abspath(os.path.join("../.."))
if module_path not in sys.path:
sys.path.append(module_path)
# Cheat to get MS Visual Studio Code Jupyter server to recognize Python venv
module_path = os.path.abspath(os.path.join("../../venv/Lib/site-packages"))
if module_path not in sys.path:
sys.path.append(module_path)
import c2qa
import qiskit
import numpy as np
from scipy.stats.contingency import margins
from matplotlib import pyplot as plt
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode = 4)
circuit = c2qa.CVCircuit(qmr)
circuit.cv_initialize(5, qmr[0])
state, _, _ = c2qa.util.simulate(circuit)
c2qa.wigner.plot_wigner(circuit, state)
circuit.cv_initialize(1/np.sqrt(2)*np.array([1,0,0,0,1]), qmr[0])
state, _, _ = c2qa.util.simulate(circuit)
c2qa.wigner.plot_wigner(circuit, state)
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode = 6)
qbr = qiskit.QuantumRegister(1)
cr = qiskit.ClassicalRegister(1)
circuit = c2qa.CVCircuit(qmr, qbr, cr)
circuit.initialize([1,0], qbr[0])
circuit.cv_initialize(0, qmr[0])
alpha = 2
circuit.h(qbr[0])
circuit.cv_c_d(alpha, qmr[0], qbr[0])
circuit.h(qbr[0])
circuit.measure(qbr, cr)
state, _, _ = c2qa.util.simulate(circuit)
c2qa.wigner.plot_wigner(circuit, state)
#set the number of qubits for simulation. Try setting this to 4 and observe the result!
n = 7
qmr = c2qa.QumodeRegister(1, num_qubits_per_qumode=n)
circuit = c2qa.CVCircuit(qmr)
#Parameter of the coherent state
alpha = 1-1j
#Prepare the coherent state by displacing the vacuum
circuit.cv_d(alpha, qmr[0])
#Simulate the circuit
state, _, _ = c2qa.util.simulate(circuit)
#Get the wigner distribution in units with hbar=1
ax_min = -6
ax_max = 6
steps = 200
w = c2qa.wigner.wigner(state, axes_max= ax_max, axes_min= ax_min, axes_steps = steps)
#Compute the marginals
x_dist, y_dist = margins(w.T)
#normalize the distributions
x_dist *= (ax_max-ax_min)/200
y_dist *= (ax_max-ax_min)/200
#This cell is mostly plotting
fig = plt.figure(figsize=(6,6))
gs = fig.add_gridspec(2, 2, width_ratios=(3, 1), height_ratios=(1, 3),
left=0.1, right=0.9, bottom=0.1, top=0.9,
wspace=0.05, hspace=0.05)
ax = fig.add_subplot(gs[1,0])
ax_x = fig.add_subplot(gs[0,0])
ax_y = fig.add_subplot(gs[1,1])
absmax = max(np.max(w), np.abs(np.min(w)))
color_levels = np.linspace(-absmax, absmax, 100)
#Plot the wigner function of the coherent state in the main panel with a colormap
xaxis = np.linspace(ax_min, ax_max, steps)
yaxis = np.linspace(ax_min, ax_max, steps)
cont = ax.contourf(xaxis, yaxis, w, color_levels, cmap = "RdBu_r")
#compute the expected means and variance of the two distributions
mux = np.sqrt(2)*np.real(alpha)
muy = np.sqrt(2)*np.imag(alpha)
sigma = .5
#plot the distributions against the (normalized) marginals of the wigner function
ax_x.plot(xaxis, x_dist, label = r"$|\psi_\alpha(x)|^2$", c= "b")
ax_x.plot(xaxis, 1/np.sqrt(2*np.pi*sigma)*np.exp(-(xaxis-mux)**2/(2*sigma)), c ="k", linestyle = "--", label="pred.")
ax_y.plot(y_dist.T, yaxis, label = r"$|\phi_\alpha(p)|^2$", c = "r")
ax_y.plot(1/np.sqrt(2*np.pi*sigma)*np.exp(-(yaxis-muy)**2/(2*sigma)), yaxis, c="k", linestyle = "--", label = "pred.")
ax.set(xlabel=r"$\hat x$", ylabel=r"$\hat p$")
ax_x.legend()
ax_y.legend()
ax_x.set_xticklabels([]);
ax_y.set_yticklabels([]);
|
https://github.com/BOBO1997/osp_solutions
|
BOBO1997
|
import numpy as np
import matplotlib.pyplot as plt
import itertools
from pprint import pprint
import pickle
import time
import datetime
# Import qubit states Zero (|0>) and One (|1>), and Pauli operators (X, Y, Z)
from qiskit.opflow import Zero, One, I, X, Y, Z
from qiskit import QuantumCircuit, QuantumRegister, IBMQ, execute, transpile, Aer
from qiskit.tools.monitor import job_monitor
from qiskit.circuit import Parameter
from qiskit.transpiler.passes import RemoveBarriers
# Import QREM package
from qiskit.ignis.mitigation.measurement import complete_meas_cal, CompleteMeasFitter
from qiskit.ignis.mitigation import expectation_value
# Import mitiq for zne
import mitiq
# Import state tomography modules
from qiskit.ignis.verification.tomography import state_tomography_circuits, StateTomographyFitter
from qiskit.quantum_info import state_fidelity
import sys
import importlib
sys.path.append("../utils/")
import circuit_utils, zne_utils, tomography_utils, sgs_algorithm
importlib.reload(circuit_utils)
importlib.reload(zne_utils)
importlib.reload(tomography_utils)
importlib.reload(sgs_algorithm)
from circuit_utils import *
from zne_utils import *
from tomography_utils import *
from sgs_algorithm import *
# Combine subcircuits into a single multiqubit gate representing a single trotter step
num_qubits = 3
# The final time of the state evolution
target_time = np.pi
# Parameterize variable t to be evaluated at t=pi later
dt = Parameter('t')
# Convert custom quantum circuit into a gate
trot_gate = trotter_gate(dt)
# initial layout
initial_layout = [5,3,1]
# Number of trotter steps
num_steps = 100
print("trotter step: ", num_steps)
scale_factors = [1.0, 2.0, 3.0]
# Initialize quantum circuit for 3 qubits
qr = QuantumRegister(num_qubits, name="q")
qc = QuantumCircuit(qr)
# Prepare initial state (remember we are only evolving 3 of the 7 qubits on jakarta qubits (q_5, q_3, q_1) corresponding to the state |110>)
make_initial_state(qc, "110") # DO NOT MODIFY (|q_5,q_3,q_1> = |110>)
subspace_encoder_init110(qc, targets=[0, 1, 2]) # encode
trotterize(qc, trot_gate, num_steps, targets=[1, 2]) # Simulate time evolution under H_heis3 Hamiltonian
subspace_decoder_init110(qc, targets=[0, 1, 2]) # decode
# Evaluate simulation at target_time (t=pi) meaning each trotter step evolves pi/trotter_steps in time
qc = qc.bind_parameters({dt: target_time / num_steps})
print("created qc")
# Generate state tomography circuits to evaluate fidelity of simulation
st_qcs = state_tomography_circuits(qc, [0, 1, 2][::-1]) #! state tomography requires === BIG ENDIAN ===
print("created st_qcs (length:", len(st_qcs), ")")
# remove barriers
st_qcs = [RemoveBarriers()(qc) for qc in st_qcs]
print("removed barriers from st_qcs")
# optimize circuit
t3_st_qcs = transpile(st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
t3_st_qcs = transpile(t3_st_qcs, optimization_level=3, basis_gates=["sx", "cx", "rz"])
print("created t3_st_qcs (length:", len(t3_st_qcs), ")")
# zne wrapping
zne_qcs = t3_st_qcs
# zne_qcs = zne_wrapper(t3_st_qcs, scale_factors = scale_factors, pt = False)
# print("created zne_qcs (length:", len(zne_qcs), ")")
# optimization_level must be 0
# feed initial_layout here to see the picture of the circuits before casting the job
t3_zne_qcs = transpile(zne_qcs, optimization_level=0, basis_gates=["sx", "cx", "rz"], initial_layout=initial_layout)
print("created t3_zne_qcs (length:", len(t3_zne_qcs), ")")
t3_zne_qcs[-3].draw("mpl")
from qiskit.test.mock import FakeJakarta
backend = FakeJakarta()
# backend = Aer.get_backend("qasm_simulator")
# IBMQ.load_account()
# provider = IBMQ.get_provider(hub='ibm-q-community', group='ibmquantumawards', project='open-science-22')
# print("provider:", provider)
# backend = provider.get_backend("ibmq_jakarta")
print(str(backend))
shots = 1 << 13
reps = 8 # unused
jobs = []
for _ in range(reps):
#! CHECK: run t3_zne_qcs, with optimization_level = 0 and straightforward initial_layout
job = execute(t3_zne_qcs, backend, shots=shots, optimization_level=0)
print('Job ID', job.job_id())
jobs.append(job)
# QREM
qr = QuantumRegister(num_qubits, name="calq")
meas_calibs, state_labels = complete_meas_cal(qr=qr, circlabel='mcal')
# we have to feed initial_layout to calibration matrix
cal_job = execute(meas_calibs, backend=backend, shots=shots, optimization_level=3, initial_layout = initial_layout)
print('Job ID', cal_job.job_id())
meas_calibs[0].draw("mpl")
dt_now = datetime.datetime.now()
print(dt_now)
filename = "job_ids_" + str(backend) + "_100step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl"
print(filename)
# with open("jobs_" + str(backend) + "_100step_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
# pickle.dump({"jobs": jobs, "cal_job": cal_job}, f)
# with open(filename, "wb") as f:
# pickle.dump({"job_ids": [job.job_id() for job in jobs], "cal_job_id": cal_job.job_id()}, f)
# with open("properties_" + str(backend) + "_" + dt_now.strftime('%Y%m%d_%H%M%S') + "_.pkl", "wb") as f:
# pickle.dump(backend.properties(), f)
retrieved_jobs = jobs
retrieved_cal_job = cal_job
cal_results = retrieved_cal_job.result()
meas_fitter = CompleteMeasFitter(cal_results, state_labels, circlabel='mcal')
target_state = (One^One^Zero).to_matrix() # DO NOT CHANGE!!!
fids = []
for job in retrieved_jobs:
# mit_results = meas_fitter.filter.apply(job.result())
rho = StateTomographyFitter(job.result(), t3_zne_qcs).fit(method='lstsq')
fid = state_fidelity(rho, target_state)
fids.append(fid)
print('state tomography fidelity = {:.4f} \u00B1 {:.4f}'.format(np.mean(fids), np.std(fids)))
|
https://github.com/xtophe388/QISKIT
|
xtophe388
|
# useful additional packages
import matplotlib.pyplot as plt
%matplotlib inline
import numpy as np
# useful math functions
from math import pi, cos, acos, sqrt
# importing the QISKit
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
from qiskit import available_backends, execute, register, get_backend
import sys, getpass
try:
sys.path.append("../../") # go to parent dir
import Qconfig
qx_config = {
"APItoken": Qconfig.APItoken,
"url": Qconfig.config['url']}
print('Qconfig loaded from %s.' % Qconfig.__file__)
except:
APItoken = getpass.getpass('Please input your token and hit enter: ')
qx_config = {
"APItoken": APItoken,
"url":"https://quantumexperience.ng.bluemix.net/api"}
print('Qconfig.py not found in qiskit-tutorial directory; Qconfig loaded using user input.')
# import basic plot tools
from qiskit.tools.visualization import plot_histogram
M = 16 # Maximum number of physical qubits available
numberOfCoins = 8 # This number should be up to M-1, where M is the number of qubits available
indexOfFalseCoin = 6 # This should be 0, 1, ..., numberOfCoins - 1, where we use Python indexing
if numberOfCoins < 4 or numberOfCoins >= M:
raise Exception("Please use numberOfCoins between 4 and ", M-1)
if indexOfFalseCoin < 0 or indexOfFalseCoin >= numberOfCoins:
raise Exception("indexOfFalseCoin must be between 0 and ", numberOfCoins-1)
# Creating registers
# numberOfCoins qubits for the binary query string and 1 qubit for working and recording the result of quantum balance
qr = QuantumRegister(numberOfCoins+1)
# for recording the measurement on qr
cr = ClassicalRegister(numberOfCoins+1)
circuitName = "QueryStateCircuit"
queryStateCircuit = QuantumCircuit(qr, cr)
N = numberOfCoins
# Create uniform superposition of all strings of length N
for i in range(N):
queryStateCircuit.h(qr[i])
# Perform XOR(x) by applying CNOT gates sequentially from qr[0] to qr[N-1] and storing the result to qr[N]
for i in range(N):
queryStateCircuit.cx(qr[i], qr[N])
# Measure qr[N] and store the result to cr[N]. We continue if cr[N] is zero, or repeat otherwise
queryStateCircuit.measure(qr[N], cr[N])
# we proceed to query the quantum beam balance if the value of cr[0]...cr[N] is all zero
# by preparing the Hadamard state of |1>, i.e., |0> - |1> at qr[N]
queryStateCircuit.x(qr[N]).c_if(cr, 0)
queryStateCircuit.h(qr[N]).c_if(cr, 0)
# we rewind the computation when cr[N] is not zero
for i in range(N):
queryStateCircuit.h(qr[i]).c_if(cr, 2**N)
k = indexOfFalseCoin
# Apply the quantum beam balance on the desired superposition state (marked by cr equal to zero)
queryStateCircuit.cx(qr[k], qr[N]).c_if(cr, 0)
# Apply Hadamard transform on qr[0] ... qr[N-1]
for i in range(N):
queryStateCircuit.h(qr[i]).c_if(cr, 0)
# Measure qr[0] ... qr[N-1]
for i in range(N):
queryStateCircuit.measure(qr[i], cr[i])
backend = "local_qasm_simulator"
shots = 1 # We perform a one-shot experiment
results = execute(queryStateCircuit, backend=backend, shots=shots).result()
answer = results.get_counts()
for key in answer.keys():
if key[0:1] == "1":
raise Exception("Fail to create desired superposition of balanced query string. Please try again")
plot_histogram(answer)
from collections import Counter
for key in answer.keys():
normalFlag, _ = Counter(key[1:]).most_common(1)[0] #get most common label
for i in range(2,len(key)):
if key[i] != normalFlag:
print("False coin index is: ", len(key) - i - 1)
|
https://github.com/mentesniker/Quantum-error-mitigation
|
mentesniker
|
from qiskit import QuantumCircuit, QuantumRegister, Aer, execute, ClassicalRegister
from qiskit.ignis.verification.topological_codes import RepetitionCode
from qiskit.ignis.verification.topological_codes import lookuptable_decoding
from qiskit.ignis.verification.topological_codes import GraphDecoder
from qiskit.providers.aer.noise import NoiseModel
from qiskit.providers.aer.noise.errors import pauli_error, depolarizing_error
from qiskit.ignis.mitigation.measurement import (complete_meas_cal,CompleteMeasFitter)
from qiskit.visualization import plot_histogram
import random
backend = Aer.get_backend('qasm_simulator')
#These two functions were taken from https://stackoverflow.com/questions/10237926/convert-string-to-list-of-bits-and-viceversa
def tobits(s):
result = []
for c in s:
bits = bin(ord(c))[2:]
bits = '00000000'[len(bits):] + bits
result.extend([int(b) for b in bits])
return ''.join([str(x) for x in result])
def frombits(bits):
chars = []
for b in range(int(len(bits) / 8)):
byte = bits[b*8:(b+1)*8]
chars.append(chr(int(''.join([str(bit) for bit in byte]), 2)))
return ''.join(chars)
def get_noise(circuit,probability,qubits):
random_number = random.uniform(0, 1)
if(random_number <= probability):
qubit = random.randint(0,len(qubits)-1)
if(random.randint(0,3) == 0):
circuit.x(qubit)
if(random.randint(0,3) == 1):
circuit.y(qubit)
if(random.randint(0,3) == 2):
circuit.z(qubit)
return circuit
def codificate(bitString):
qubits = list()
for i in range(len(bitString)):
mycircuit = QuantumCircuit(1,1)
if(bitString[i] == "1"):
mycircuit.x(0)
mycircuit.h(0)
qubits.append(mycircuit)
return qubits
m0 = tobits("I like dogs")
qubits = codificate(m0)
measurements = list()
for i in range(len(qubits)):
qubit = qubits[i]
qubit.h(0)
qubit.measure(0,0)
result = execute(qubit, backend, shots=1, memory=True).result()
measurements.append(int(result.get_memory()[0]))
print(frombits(measurements))
for i in range(len(qubits)):
cb = QuantumRegister(1,'code_qubit')
lq = QuantumRegister(8,'ancilla_qubit')
out = ClassicalRegister(1,'output_bit')
mycircuit = QuantumCircuit(cb,lq,out)
if(m0[i] == "1"):
mycircuit.x(0)
mycircuit.cx(0,[3,6])
mycircuit.h([0,3,6])
mycircuit.cx(0,[1,2])
mycircuit.cx(3,[4,5])
mycircuit.cx(6,[7,8])
mycircuit.barrier()
mycircuit = get_noise(mycircuit,0.2,range(9))
mycircuit.barrier()
mycircuit.cx(0,[1,2])
mycircuit.cx(3,[4,5])
mycircuit.cx(6,[7,8])
mycircuit.ccx(2,1,0)
mycircuit.ccx(5,4,3)
mycircuit.ccx(8,7,6)
mycircuit.h([0,3,6])
mycircuit.cx(0,[3,6])
mycircuit.ccx(6,2,0)
mycircuit.measure(0,0)
qubits[i] = mycircuit
qubits[0].draw()
raw_bits = list()
for i in range(len(qubits)):
qubit = qubits[i]
qubit.measure(0,0)
result = execute(qubit, backend, shots=1, memory=True).result()
bits = result.get_memory()[0]
raw_bits.append(int(bits[0]))
print("with error correction the string was: " + frombits(raw_bits))
|
https://github.com/martynscn/Masters-Thesis-on-Quantum-Cryptography
|
martynscn
|
# This code has been adapted and modified from IBM Qiskit 2021 and also from https://github.com/ttlion/ShorAlgQiskit.
# It uses the implementation as contained in the work of Stephane Beauregard (https://arxiv.org/abs/quant-ph/0205095)
# Many thanks to IBM Qiskit team, Tiago Miguel (ttlion), Qubit by Qubit, Peter Shor and Stephane Beauregard.
from typing import Optional, Union, Tuple, List
import math
import array
import fractions
import logging
import numpy as np
from qiskit import ClassicalRegister, QuantumCircuit, QuantumRegister, execute, IBMQ, transpile,BasicAer, Aer, assemble
from qiskit.circuit import Gate, Instruction, ParameterVector
from qiskit.circuit.library import QFT
from qiskit.providers import BaseBackend, Backend
from qiskit.quantum_info import partial_trace
from qiskit.utils import summarize_circuits
from qiskit.utils.arithmetic import is_power
from qiskit.utils.validation import validate_min
from qiskit.utils.quantum_instance import QuantumInstance
import qiskit.visualization
from qiskit.providers.aer import QasmSimulator
from datetime import datetime
import csv
# provider = IBMQ.enable_account("PUT TOKEN HERE")
backend = QasmSimulator()
from IPython.core.interactiveshell import InteractiveShell
InteractiveShell.ast_node_interactivity = "all" #"last_expr" or "all"
# """ Function to check if N is of type q^p"""
def check_if_power(N):
# """ Check if N is a perfect power in O(n^3) time, n=ceil(logN) """
b=2
while (2**b) <= N:
a = 1
c = N
while (c-a) >= 2:
m = int( (a+c)/2 )
if (m**b) < (N+1):
p = int( (m**b) )
else:
p = int(N+1)
if int(p) == int(N):
print('N is {0}^{1}'.format(int(m),int(b)) )
return True
if p<N:
a = int(m)
else:
c = int(m)
b=b+1
return False
def egcd(a, b):
if a == 0:
return (b, 0, 1)
else:
g, y, x = egcd(b % a, a)
return (g, x - (b // a) * y, y)
def modinv(a, m):
g, x, y = egcd(a, m)
if g != 1:
raise Exception('modular inverse does not exist')
else:
return x % m
def create_QFT(circuit,up_reg,n,with_swaps):
i=n-1
while i>=0:
circuit.h(up_reg[i])
j=i-1
while j>=0:
if (np.pi)/(pow(2,(i-j))) > 0:
circuit.cu1( (np.pi)/(pow(2,(i-j))) , up_reg[i] , up_reg[j] )
j=j-1
i=i-1
if with_swaps==1:
i=0
while i < ((n-1)/2):
circuit.swap(up_reg[i], up_reg[n-1-i])
i=i+1
def create_inverse_QFT(circuit,up_reg,n,with_swaps):
if with_swaps==1:
i=0
while i < ((n-1)/2):
circuit.swap(up_reg[i], up_reg[n-1-i])
i=i+1
i=0
while i<n:
circuit.h(up_reg[i])
if i != n-1:
j=i+1
y=i
while y>=0:
if (np.pi)/(pow(2,(j-y))) > 0:
circuit.cu1( - (np.pi)/(pow(2,(j-y))) , up_reg[j] , up_reg[y] )
y=y-1
i=i+1
def getAngle(a, N):
s=bin(int(a))[2:].zfill(N)
angle = 0
for i in range(0, N):
if s[N-1-i] == '1':
angle += math.pow(2, -(N-i))
angle *= np.pi
return angle
def getAngles(a,N):
s=bin(int(a))[2:].zfill(N)
angles=np.zeros([N])
for i in range(0, N):
for j in range(i,N):
if s[j]=='1':
angles[N-i-1]+=math.pow(2, -(j-i))
angles[N-i-1]*=np.pi
return angles
def ccphase(circuit, angle, ctl1, ctl2, tgt):
circuit.cu1(angle/2,ctl1,tgt)
circuit.cx(ctl2,ctl1)
circuit.cu1(-angle/2,ctl1,tgt)
circuit.cx(ctl2,ctl1)
circuit.cu1(angle/2,ctl2,tgt)
def phiADD(circuit, q, a, N, inv):
angle=getAngles(a,N)
for i in range(0,N):
if inv==0:
circuit.u1(angle[i],q[i])
else:
circuit.u1(-angle[i],q[i])
def cphiADD(circuit, q, ctl, a, n, inv):
angle=getAngles(a,n)
for i in range(0,n):
if inv==0:
circuit.cu1(angle[i],ctl,q[i])
else:
circuit.cu1(-angle[i],ctl,q[i])
def ccphiADD(circuit,q,ctl1,ctl2,a,n,inv):
angle=getAngles(a,n)
for i in range(0,n):
if inv==0:
ccphase(circuit,angle[i],ctl1,ctl2,q[i])
else:
ccphase(circuit,-angle[i],ctl1,ctl2,q[i])
def ccphiADDmodN(circuit, q, ctl1, ctl2, aux, a, N, n):
ccphiADD(circuit, q, ctl1, ctl2, a, n, 0)
phiADD(circuit, q, N, n, 1)
# phiADD(circuit, q, a,N, 1)
create_inverse_QFT(circuit, q, n, 0)
circuit.cx(q[n-1],aux)
create_QFT(circuit,q,n,0)
cphiADD(circuit, q, aux, N, n, 0)
# cphiADD(circuit, q, aux, a, n, 0)
ccphiADD(circuit, q, ctl1, ctl2, a, n, 1)
create_inverse_QFT(circuit, q, n, 0)
circuit.x(q[n-1])
circuit.cx(q[n-1], aux)
circuit.x(q[n-1])
create_QFT(circuit,q,n,0)
ccphiADD(circuit, q, ctl1, ctl2, a, n, 0)
def ccphiADDmodN_inv(circuit, q, ctl1, ctl2, aux, a, N, n):
ccphiADD(circuit, q, ctl1, ctl2, a, n, 1)
create_inverse_QFT(circuit, q, n, 0)
circuit.x(q[n-1])
circuit.cx(q[n-1],aux)
circuit.x(q[n-1])
create_QFT(circuit, q, n, 0)
ccphiADD(circuit, q, ctl1, ctl2, a, n, 0)
cphiADD(circuit, q, aux, N, n, 1)
# cphiADD(circuit, q, aux, a, n, 1)
create_inverse_QFT(circuit, q, n, 0)
circuit.cx(q[n-1], aux)
create_QFT(circuit, q, n, 0)
phiADD(circuit, q, N, n, 0)
# phiADD(circuit, q, a, N, 0)
ccphiADD(circuit, q, ctl1, ctl2, a, n, 1)
def cMULTmodN(circuit, ctl, q, aux, a, N, n):
# up_reg = QuantumRegister(1, name = "up_reg")
# down_reg = QuantumRegister(n, name = "down_reg")
# up_classic = ClassicalRegister(2*n, name="up_classic")
# c_aux = ClassicalRegister(1, name = "aux_classic")
# cMULTmodN_circuit = QuantumCircuit(
# up_reg ,down_reg , aux,up_classic, c_aux,
# name=r"${0}^{{{1}^{{{2}}}}} mod{3}$".format(2,2,int(math.log(math.log(a,2),2)), N)
# )
# create_QFT(cMULTmodN_circuit,aux,n+1,0)
# for i in range(0, n):
# ccphiADDmodN(cMULTmodN_circuit, aux, q[i], ctl, aux[n+1], (2**i)*a % N, N, n+1)
# create_inverse_QFT(cMULTmodN_circuit, aux, n+1, 0)
# for i in range(0, n):
# circuit.cswap(ctl,q[i],aux[i])
# cMULTmodN_circuit.cswap(ctl,q[i],aux[i])
# create_QFT(cMULTmodN_circuit, aux, n+1, 0)
# ccphiADDmodN_inv(cMULTmodN_circuit, aux, q[i], ctl, aux[n+1], math.pow(2,i)*a_inv % N, N, n+1)
# create_inverse_QFT(cMULTmodN_circuit, aux, n+1, 0)
# cMULTmodN_circuit_instruction = cMULTmodN_circuit.to_instruction()
# circuit.append(cMULTmodN_circuit_instruction, [ctl, *down_reg, *aux])
create_QFT(circuit,aux,n+1,0)
for i in range(0, n):
ccphiADDmodN(circuit, aux, q[i], ctl, aux[n+1], (2**i)*a % N, N, n+1)
create_inverse_QFT(circuit, aux, n+1, 0)
for i in range(0, n):
circuit.cswap(ctl,q[i],aux[i])
a_inv = modinv(a, N)
create_QFT(circuit, aux, n+1, 0)
i = n-1
while i >= 0:
ccphiADDmodN_inv(circuit, aux, q[i], ctl, aux[n+1], math.pow(2,i)*a_inv % N, N, n+1)
i -= 1
create_inverse_QFT(circuit, aux, n+1, 0)
def calculate_continued_fraction(b: array.array) -> int:
# """Calculate the continued fraction of x/T from the current terms of expansion b."""
x_over_T = 0
for i in reversed(range(len(b) - 1)):
x_over_T = 1 / (b[i + 1] + x_over_T)
x_over_T += b[0]
frac = fractions.Fraction(x_over_T).limit_denominator()
return frac.denominator
def get_factors(N: int, a: int, measurement: str) -> Optional[List[int]]:
# """Apply the continued fractions to find r and the gcd to find the desired factors."""
x_final = int(measurement, 2)
#print('In decimal, x_final value for this result is: {}.'.format(x_final))
if x_final <= 0:
fail_reason = 'x_final value is <= 0, there are no continued fractions.'
else:
fail_reason = None
#print('Running continued fractions for this case.')
# Calculate T and x/T
T_upper = len(measurement)
T = pow(2, T_upper)
x_over_T = x_final / T ## this is our theta
# Cycle in which each iteration corresponds to putting one more term in the
# calculation of the Continued Fraction (CF) of x/T
# Initialize the first values according to CF rule
i = 0
b = array.array('i')
t = array.array('f')
b.append(math.floor(x_over_T))
t.append(x_over_T - b[i])
exponential = 0.0
while i < N and fail_reason is None:
# From the 2nd iteration onwards, calculate the new terms of the CF based on the previous terms as the rule suggests
if i > 0:
try:
b_temp = math.floor(1 / t[i - 1])
except ZeroDivisionError as err:
b_temp = 0
b.append(b_temp)
try:
t_temp = (1 / t[i - 1]) - b[i]
except ZeroDivisionError as err:
t_temp = 0
t.append(t_temp) # type: ignore
# Calculate the denominator of the CF using the known terms
denominator = calculate_continued_fraction(b)
# Increment i for next iteration
i += 1
if denominator % 2 == 1:
#print('Odd denominator, will try next iteration of continued fractions.')
continue
# Denominator is even, try to get factors of N. Get the exponential a^(r/2)
if denominator < 1000:
try:
exponential = pow(a, denominator / 2)
except OverflowError as err:
exponential = 999999999
# Check if the value is too big or not
if exponential > 1000000:
if exponential == 999999999:
fail_reason = 'OverflowError'
else:
fail_reason = 'denominator of continued fraction is too big (> 10^3).'
else:
# The value is not too big, get the right values and do the proper gcd()
putting_plus = int(exponential + 1)
putting_minus = int(exponential - 1)
one_factor = math.gcd(putting_plus, N)
other_factor = math.gcd(putting_minus, N)
# Check if the factors found are trivial factors or are the desired factors
if any(factor in {1, N} for factor in (one_factor, other_factor)):
#print('Found just trivial factors, not good enough.')
# Check if the number has already been found, (use i - 1 because i was already incremented)
if t[i - 1] == 0:
fail_reason = 'the continued fractions found exactly x_final/(2^(2n)).'
else:
return sorted((one_factor, other_factor))
return None
def process_results(sim_result, circuit, shots, N, a, n):
counts_result = sim_result.get_counts(circuit)
total_counts = len(counts_result)
counts_result_sorted = sorted(counts_result.items(), key=lambda x: x[1], reverse=True)
counts_result_keys = list(counts_result.keys())
counts_result_values = list(counts_result.values())
prob_success=0
prob_failure=0
result_successful_counts = 0
result_failure_counts = 0
for initial_undesired_measurement, frequency in counts_result_sorted:
measurement = initial_undesired_measurement.split(" ")[1]
x_value = int(measurement, 2)
prob_this_result = 100 * frequency/shots
factors = get_factors(N, a, measurement)
if factors:
prob_success = prob_success + prob_this_result
result_successful_counts = result_successful_counts + 1
if factors not in result_factors:
result_factors.append(factors)
elif not factors:
prob_failure = prob_failure + prob_this_result
result_failure_counts = result_failure_counts + 1
return [result_factors, prob_success, prob_failure, total_counts, result_successful_counts,result_failure_counts]
def my_shor(a,N,shots):
start_time_number = datetime.now()
start_time = start_time_number.strftime("%H:%M:%S")
summary_result = dict()
validate_min('N', N, 3)
validate_min('a', a, 2)
if N < 1 or N % 2 == 0:
raise ValueError('The input needs to be an odd integer greater than 1.')
if a >= N or math.gcd(a, N) != 1:
raise ValueError('The integer a needs to satisfy a < N and gcd(a, N) = 1.')
n = math.ceil(math.log(N,2))
global result_factors
result_factors = []
tf, b, p = is_power(N, return_decomposition=True)
if tf:
print('The input integer is a power: {0}={1}^{2}.'.format(N, b, p))
result_factors.append(b)
# """auxilliary quantum register used in addition and multiplication"""
aux = QuantumRegister(size = n+2, name="aux_reg")
# """single qubit where the sequential QFT is performed"""
up_reg = QuantumRegister(1, name = "up_reg")
down_reg = QuantumRegister(n, name = "down_reg")
# """classical register where the measured values of the sequential QFT are stored"""
up_classic = ClassicalRegister(2*n, name="up_classic")
# """classical bit used to reset the state of the top qubit to 0 if the previous measurement was 1"""
c_aux = ClassicalRegister(1, name = "aux_classic")
# """ Create Quantum Circuit """
circuit = QuantumCircuit(up_reg ,down_reg , aux,up_classic, c_aux)
circuit.x(down_reg[0])
# circuit.draw(filename = "shor_semiclassical_QFT_initialization")
for i in range(0, 2*n):
circuit.x(up_reg).c_if(c_aux, 1)
circuit.h(up_reg)
cMULTmodN(circuit, up_reg[0], down_reg, aux, a**(2**(2*n-1-i)), N, n)
# later confirm if this should be up_reg[i] instead of up_reg[0]
for j in range(0, 2**i):
circuit.u1(getAngle(j, i), up_reg[0]).c_if(up_classic, j)
circuit.h(up_reg)
circuit.measure(up_reg[0], up_classic[i])
circuit.measure(up_reg[0], c_aux[0])
# circuit.draw(filename = "shor_semiclassical_QFT_final_circuit")
circuit.draw()
qc_compiled = transpile(circuit, backend, optimization_level = 3)
job_sim_1 = backend.run(qc_compiled, shots=shots)
sim_result=job_sim_1.result()
# counts_result = sim_result.get_counts(circuit)
# len(counts_result)
# measurement_plot = qiskit.visualization.plot_histogram(counts_result,figsize=(20, 12) ,number_to_keep = 30,bar_labels=True, title = "Measurement results from shor_standard_QFT circuit variant" )
# measurement_plot.savefig("shor_semiclassical_QFT_measurement_result")
# measurement_plot
processed_result = process_results(sim_result, circuit, shots, N, a, n)
end_time_number = datetime.now()
end_time = end_time_number.strftime("%H:%M:%S")
duration = end_time_number - start_time_number
print("Current Start Time =", start_time)
print(processed_result)
print("Current End Time =", end_time)
circuit_count_ops = circuit.count_ops()
circuit_decomposed = circuit.decompose()
circuit_decomposed_count_ops = circuit_decomposed.count_ops()
qc_compiled_count_ops = qc_compiled.count_ops()
summary_result["num_qubits"] = n
summary_result["Number(N)"] = N
summary_result["a"] = a
summary_result["start_time"] = start_time
summary_result["end_time"] = end_time
summary_result["duration"] = duration
summary_result["result_factors"] = processed_result[0]
summary_result["prob_success"] = processed_result[1]
summary_result["prob_failure"] = processed_result[2]
summary_result["total_counts"] = processed_result[3]
summary_result["result_successful_counts"] = processed_result[4]
summary_result["result_failure_counts"] = processed_result[5]
summary_result["circuit_width"] = circuit.width()
summary_result["circuit_depth"] = circuit.depth()
summary_result["circuit_size"] = circuit.size()
summary_result["circuit_num_nonlocal_gates"] = circuit.num_nonlocal_gates()
summary_result["circuit_num_ancillas"] = circuit.num_ancillas
summary_result["circuit_num_clbits"] = circuit.num_clbits
summary_result["circuit_num_qubits"] = circuit.num_qubits
summary_result["circuit_num_ancillas"] = circuit.num_ancillas
summary_result["circuit_num_of_count_ops"] = len(circuit_count_ops)
summary_result["circuit_num_of_x"] = circuit_count_ops.get('x')
summary_result["circuit_num_of_measure"] = circuit_count_ops.get('measure')
summary_result["circuit_num_of_h"] = circuit_count_ops.get('h')
summary_result["circuit_num_of_cswap"] = circuit_count_ops.get('cswap')
summary_result["circuit_num_of_swap"] = circuit_count_ops.get('swap')
summary_result["circuit_num_of_cx"] = circuit_count_ops.get('cx')
summary_result["circuit_num_of_toffoli"] = circuit_count_ops.get('toffoli')
summary_result["circuit_num_of_p"] = circuit_count_ops.get('p')
summary_result["circuit_num_of_t"] = circuit_count_ops.get('t')
summary_result["circuit_decomposed_width"] = circuit_decomposed.width()
summary_result["circuit_decomposed_depth"] = circuit_decomposed.depth()
summary_result["circuit_decomposed_size"] = circuit_decomposed.size()
summary_result["circuit_decomposed_num_nonlocal_gates"] = circuit_decomposed.num_nonlocal_gates()
summary_result["circuit_decomposed_num_ancillas"] = circuit_decomposed.num_ancillas
summary_result["circuit_decomposed_num_clbits"] = circuit_decomposed.num_clbits
summary_result["circuit_decomposed_num_qubits"] = circuit_decomposed.num_qubits
summary_result["circuit_decomposed_num_ancillas"] = circuit_decomposed.num_ancillas
summary_result["circuit_decomposed_num_of_count_ops"] = len(circuit_decomposed_count_ops)
summary_result["circuit_decomposed_num_of_x"] = circuit_decomposed_count_ops.get('x')
summary_result["circuit_decomposed_num_of_measure"] = circuit_decomposed_count_ops.get('measure')
summary_result["circuit_decomposed_num_of_h"] = circuit_decomposed_count_ops.get('h')
summary_result["circuit_decomposed_num_of_cswap"] = circuit_decomposed_count_ops.get('cswap')
summary_result["circuit_decomposed_num_of_swap"] = circuit_decomposed_count_ops.get('swap')
summary_result["circuit_decomposed_num_of_cx"] = circuit_decomposed_count_ops.get('cx')
summary_result["circuit_decomposed_num_of_toffoli"] = circuit_decomposed_count_ops.get('toffoli')
summary_result["circuit_decomposed_num_of_p"] = circuit_decomposed_count_ops.get('p')
summary_result["circuit_decomposed_num_of_t"] = circuit_decomposed_count_ops.get('t')
summary_result["qc_compiled_width"] = qc_compiled.width()
summary_result["qc_compiled_depth"] = qc_compiled.depth()
summary_result["qc_compiled_size"] = qc_compiled.size()
summary_result["qc_compiled_num_nonlocal_gates"] = qc_compiled.num_nonlocal_gates()
summary_result["qc_compiled_num_ancillas"] = qc_compiled.num_ancillas
summary_result["qc_compiled_num_clbits"] = qc_compiled.num_clbits
summary_result["qc_compiled_num_qubits"] = qc_compiled.num_qubits
summary_result["qc_compiled_num_ancillas"] = qc_compiled.num_ancillas
summary_result["qc_compiled_num_of_count_ops"] = len(qc_compiled_count_ops)
summary_result["qc_compiled_num_of_x"] = qc_compiled_count_ops.get('x')
summary_result["qc_compiled_num_of_measure"] = qc_compiled_count_ops.get('measure')
summary_result["qc_compiled_num_of_h"] = qc_compiled_count_ops.get('h')
summary_result["qc_compiled_num_of_cswap"] = qc_compiled_count_ops.get('cswap')
summary_result["qc_compiled_num_of_swap"] = qc_compiled_count_ops.get('swap')
summary_result["qc_compiled_num_of_cx"] = qc_compiled_count_ops.get('cx')
summary_result["qc_compiled_num_of_toffoli"] = qc_compiled_count_ops.get('toffoli')
summary_result["qc_compiled_num_of_p"] = qc_compiled_count_ops.get('p')
summary_result["qc_compiled_num_of_t"] = qc_compiled_count_ops.get('t')
return summary_result
# Run for just a single number N
%%time
N = 21
shots = 1024
global result_factors
all_summary_result_temp = []
for random_a in range(2, N):
if math.gcd(random_a,N) > 1:
continue
a = random_a
summary_result = my_shor(a,N,shots)
print("Finished running for a = {} and N = {}\n".format(a, N))
all_summary_result_temp.append(summary_result)
summary_result_list = []
for key, value in summary_result.items():
summary_result_list.append([key,value])
summary_result_list
with open("a({0})_N({1})_semiclassical.csv".format(a, N), 'a') as myfile:
write = csv.writer(myfile)
#write.writerow(fields)
write.writerows(summary_result_list)
all_summary_result_temp
# Run for many numbers N.
%%time
shots = 1024
global result_factors
all_summary_result = []
for N in [15, 21, 33, 35, 39, 51, 55, 57]:
for a in range(2, N):
if math.gcd(a,N) > 1:
continue
print("Beginning running for a = {} and N = {}".format(a, N))
summary_result = my_shor(a,N,shots)
print("Finished running for a = {} and N = {}\n\n".format(a, N))
all_summary_result.append(summary_result)
all_summary_result
%qiskit_copyright
|
https://github.com/vm6502q/qiskit-qrack-provider
|
vm6502q
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2018, 2019.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Quantum Voluming benchmark suite"""
# Write the benchmarking functions here.
# See "Writing benchmarks" in the asv docs for more information.
from qiskit import QiskitError
from qiskit.compiler import transpile, assemble
from qiskit.providers.aer import QasmSimulator
from .tools import quantum_volume_circuit, mixed_unitary_noise_model, \
reset_noise_model, kraus_noise_model, no_noise
class QuantumVolumeTimeSuite:
"""
Benchmarking times for Quantum Volume with various noise configurations
- ideal (no noise)
- mixed state
- reset
- kraus
For each noise model, we want to test various configurations of number of
qubits
The methods defined in this class will be executed by ASV framework as many
times as the combination of all parameters exist in `self.params`, for
exmaple: self.params = ([1,2,3],[4,5,6]), will run all methdos 9 times:
time_method(1,4)
time_method(1,5)
time_method(1,6)
time_method(2,4)
time_method(2,5)
time_method(2,6)
time_method(3,4)
time_method(3,5)
time_method(3,6)
"""
def __init__(self):
self.timeout = 60 * 20
self.qv_circuits = []
self.backend = QasmSimulator()
for num_qubits in (5, 10, 15):
for depth in (10, ):
# We want always the same seed, as we want always the same
# circuits for the same value pairs of qubits and depth
circ = quantum_volume_circuit(num_qubits, depth, seed=1)
circ = transpile(circ, basis_gates=['u1', 'u2', 'u3', 'cx'],
optimization_level=0, seed_transpiler=1)
qobj = assemble(circ, self.backend, shots=1)
self.qv_circuits.append(qobj)
self.param_names = ["Quantum Volume", "Noise Model"]
# This will run every benchmark for one of the combinations we have:
# bench(qv_circuits, None) => bench(qv_circuits, mixed()) =>
# bench(qv_circuits, reset) => bench(qv_circuits, kraus())
self.params = (self.qv_circuits, [
no_noise(),
mixed_unitary_noise_model(),
reset_noise_model(),
kraus_noise_model()
])
def setup(self, qobj, noise_model_wrapper):
""" Setup enviornment before running the tests """
def time_quantum_volume(self, qobj, noise_model_wrapper):
""" Benchmark for quantum volume """
result = self.backend.run(
qobj, noise_model=noise_model_wrapper()
).result()
if result.status != 'COMPLETED':
raise QiskitError("Simulation failed. Status: " + result.status)
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.circuit.library import MCXGate
gate = MCXGate(4)
from qiskit import QuantumCircuit
circuit = QuantumCircuit(5)
circuit.append(gate, [0, 1, 4, 2, 3])
circuit.draw('mpl')
|
https://github.com/1ucian0/qiskit-openqasm2
|
1ucian0
|
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""
Created on Wed Mar 11 18:03:12 2020
Functional interface to Qasm2 source loading and exporting
Supersede QuantumCircuit member functions
Provide for pluggable qasm translator
Based on conversation with Dr. Luciano Bello
@author: jax
"""
from importlib import import_module
from os import linesep
from typing import List, BinaryIO, TextIO
from qiskit import QuantumCircuit, QiskitError
from qiskit_openqasm2 import Qasm
from .funhelp import qasm_load, qasm_export
def _load_from_string(qasm_src: str or List[str],
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
qasm_src : str or List[str]
Qasm program source as string or list of string.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Raises
------
QiskitError
If unknown loader.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
if isinstance(qasm_src, list):
qasm_src = ''.join(s + linesep for s in qasm_src)
qasm = Qasm(data=qasm_src)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(data=qasm_src,
include_path=include_path)
return circ
def _load_from_file(filename: str,
loader: str = None,
include_path: str = '') -> QuantumCircuit:
"""
Parameters
----------
filename : str
Filepath to qasm program source.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is ''.
Returns
-------
QuantumCircuit
Circuit factoried from Qasm src.
"""
circ = None
if not loader:
qasm = Qasm(filename=filename)
circ = qasm_load(qasm)
else:
m_m = import_module(loader)
circ = getattr(m_m, 'load')(filename=filename,
include_path=include_path)
return circ
def load(data: str or List[str] = None,
filename: str = None,
loader: str = None,
include_path: str = None) -> QuantumCircuit:
"""
Parameters
----------
data : str or List[str], optional
Qasm program source as string or list of string. The default is None.
filename : str, optional
Filepath to qasm program source. The default is None.
loader : str, optional
Name of module with functional attribute
load(filename: str = None,
data: str = None,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
include_path : str, optional
Loader-specific include path for qasm include directives.
The default is None.
Raises
------
QiskitError
If both filename and data or neither filename nor data.
Returns
-------
QuantumCircuit
The factoried circuit.
"""
if (not data and not filename) or (data and filename):
raise QiskitError("To load, either filename or data (and not both) must be provided.")
circ = None
if data:
circ = _load_from_string(data, loader=loader, include_path=include_path)
elif filename:
circ = _load_from_file(filename, loader=loader, include_path=include_path)
return circ
def export(qc: QuantumCircuit,
exporter: str = None,
file: BinaryIO or TextIO = None,
filename: str = None,
include_path: str = None,) -> str:
"""
Decompile a QuantumCircuit into Return OpenQASM string
Parameters
----------
qc : QuantumCircuit
Circuit to decompile ("export")
exporter : str, optional
Name of module with functional attribute
export(qc: QuantumCircuit,
include_path: str = None) -> QuantumCircuit:
... to use for qasm translation.
None means "use Qiskit qasm"
The default is None.
file : BinaryIO or TextIO, optional
File object to write to as well as return str
Written in UTF-8
Caller must close file.
Mutually exclusive with filename=
The default is None.
filename : str, optional
Name of file to write export to as well as return str
Mutually exclusive with file=
The default is None.
include_path: str, optional
Unloader-specific include path for qasm include directives
Raises
------
QiskitError
If both filename and file
Returns
-------
str
OpenQASM source for circuit.
"""
if filename and file:
raise QiskitError("export: file= and filename= are mutually exclusive")
qasm_src = None
if not exporter:
qasm_src = qasm_export(qc)
else:
m_m = import_module(exporter)
qasm_src = getattr(m_m, 'export')(qc, include_path=include_path)
if filename:
f_f = open(filename, 'w')
f_f.write(qasm_src)
f_f.close()
elif file:
if 'b' in file.mode:
file.write(bytes(qasm_src, 'utf-8'))
else:
file.write(qasm_src)
return qasm_src
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit.algorithms.optimizers import SLSQP
from qiskit.circuit.library import TwoLocal
num_qubits = 2
ansatz = TwoLocal(num_qubits, "ry", "cz")
optimizer = SLSQP(maxiter=1000)
ansatz.decompose().draw("mpl", style="iqx")
from qiskit.primitives import Estimator
estimator = Estimator()
from qiskit.algorithms.minimum_eigensolvers import VQE
vqe = VQE(estimator, ansatz, optimizer)
from qiskit.quantum_info import SparsePauliOp
H2_op = SparsePauliOp.from_list([
("II", -1.052373245772859),
("IZ", 0.39793742484318045),
("ZI", -0.39793742484318045),
("ZZ", -0.01128010425623538),
("XX", 0.18093119978423156)
])
result = vqe.compute_minimum_eigenvalue(H2_op)
print(result)
from qiskit.algorithms.optimizers import SPSA
estimator = Estimator(options={"shots": 1000})
vqe.estimator = estimator
vqe.optimizer = SPSA(maxiter=100)
result = vqe.compute_minimum_eigenvalue(operator=H2_op)
print(result)
import qiskit.tools.jupyter
%qiskit_version_table
%qiskit_copyright
|
https://github.com/tomtuamnuq/compare-qiskit-ocean
|
tomtuamnuq
|
import os, shutil, time
from random_qubo.random_qubo import RandomQubo
DIR = 'TEST_DATA' + "/" + time.strftime("%d_%m_%Y")
def getPath(filename = "", directory = ""):
return DIR + "/" + directory + "/" + filename
bounds = {"matrix_q_lb": -5, "matrix_q_ub": 5, "c_lb": -5, "c_ub": 5}
DIR
shutil.rmtree(DIR, ignore_errors=True)
os.makedirs(getPath(directory = "SPARSE"))
os.makedirs(getPath(directory = "DENSE"))
os.makedirs(getPath(directory = "MULTIPLE"))
os.makedirs(getPath(directory = "CPLEX"))
# create sparse random qubos
# 3 variables connected
# start with 3x1 qubits
qaoa_max_qubits = 27 # number of qubits in Falcon r5.1 processors
var = 3
multiple = 1
while True:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "SPARSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(multiple)
break
multiple = multiple + 1
# create dense random qubos
# start with 3 variables
while True:
qp = RandomQubo.create_random_qubo("test_" + str(var), var, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "DENSE"))
if qp.get_num_vars() > qaoa_max_qubits :
print(var)
break
var = var + 3
# create more test data for pegasus
# instances with several times the last instance which Mumbai is able to solve
# 27 variables each
# start with 27x2 qubits
var = qaoa_max_qubits
multiples = [2, 5, 10, 20]
for multiple in multiples:
qp = RandomQubo.create_random_qubo("test_" + str(multiple), var, multiple=multiple, **bounds)
qp.write_to_lp_file(getPath(qp.name, directory = "MULTIPLE"))
qp = RandomQubo.create_random_qubo("test_cplex", 100, **bounds) # used 10 for test data
qp.write_to_lp_file(getPath(qp.name, directory = "CPLEX"))
|
https://github.com/indian-institute-of-science-qc/qiskit-aakash
|
indian-institute-of-science-qc
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2017, 2018.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test Qiskit's gates in QASM2."""
import unittest
from math import pi
import re
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.test import QiskitTestCase
from qiskit.circuit import Parameter, Qubit, Clbit, Gate
from qiskit.circuit.library import C3SXGate, CCZGate, CSGate, CSdgGate, PermutationGate
from qiskit.qasm.exceptions import QasmError
# Regex pattern to match valid OpenQASM identifiers
VALID_QASM2_IDENTIFIER = re.compile("[a-z][a-zA-Z_0-9]*")
class TestCircuitQasm(QiskitTestCase):
"""QuantumCircuit QASM2 tests."""
def test_circuit_qasm(self):
"""Test circuit qasm() method."""
qr1 = QuantumRegister(1, "qr1")
qr2 = QuantumRegister(2, "qr2")
cr = ClassicalRegister(3, "cr")
qc = QuantumCircuit(qr1, qr2, cr)
qc.p(0.3, qr1[0])
qc.u(0.3, 0.2, 0.1, qr2[1])
qc.s(qr2[1])
qc.sdg(qr2[1])
qc.cx(qr1[0], qr2[1])
qc.barrier(qr2)
qc.cx(qr2[1], qr1[0])
qc.h(qr2[1])
qc.x(qr2[1]).c_if(cr, 0)
qc.y(qr1[0]).c_if(cr, 1)
qc.z(qr1[0]).c_if(cr, 2)
qc.barrier(qr1, qr2)
qc.measure(qr1[0], cr[0])
qc.measure(qr2[0], cr[1])
qc.measure(qr2[1], cr[2])
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
qreg qr1[1];
qreg qr2[2];
creg cr[3];
p(0.3) qr1[0];
u(0.3,0.2,0.1) qr2[1];
s qr2[1];
sdg qr2[1];
cx qr1[0],qr2[1];
barrier qr2[0],qr2[1];
cx qr2[1],qr1[0];
h qr2[1];
if(cr==0) x qr2[1];
if(cr==1) y qr1[0];
if(cr==2) z qr1[0];
barrier qr1[0],qr2[0],qr2[1];
measure qr1[0] -> cr[0];
measure qr2[0] -> cr[1];
measure qr2[1] -> cr[2];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_qasm_with_composite_circuit(self):
"""Test circuit qasm() method when a composite circuit instruction
is included within circuit.
"""
composite_circ_qreg = QuantumRegister(2)
composite_circ = QuantumCircuit(composite_circ_qreg, name="composite_circ")
composite_circ.h(0)
composite_circ.x(1)
composite_circ.cx(0, 1)
composite_circ_instr = composite_circ.to_instruction()
qr = QuantumRegister(2, "qr")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.cx(0, 1)
qc.barrier()
qc.append(composite_circ_instr, [0, 1])
qc.measure([0, 1], [0, 1])
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
gate composite_circ q0,q1 { h q0; x q1; cx q0,q1; }
qreg qr[2];
creg cr[2];
h qr[0];
cx qr[0],qr[1];
barrier qr[0],qr[1];
composite_circ qr[0],qr[1];
measure qr[0] -> cr[0];
measure qr[1] -> cr[1];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_qasm_with_multiple_same_composite_circuits(self):
"""Test circuit qasm() method when a composite circuit is added
to the circuit multiple times
"""
composite_circ_qreg = QuantumRegister(2)
composite_circ = QuantumCircuit(composite_circ_qreg, name="composite_circ")
composite_circ.h(0)
composite_circ.x(1)
composite_circ.cx(0, 1)
composite_circ_instr = composite_circ.to_instruction()
qr = QuantumRegister(2, "qr")
cr = ClassicalRegister(2, "cr")
qc = QuantumCircuit(qr, cr)
qc.h(0)
qc.cx(0, 1)
qc.barrier()
qc.append(composite_circ_instr, [0, 1])
qc.append(composite_circ_instr, [0, 1])
qc.measure([0, 1], [0, 1])
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
gate composite_circ q0,q1 { h q0; x q1; cx q0,q1; }
qreg qr[2];
creg cr[2];
h qr[0];
cx qr[0],qr[1];
barrier qr[0],qr[1];
composite_circ qr[0],qr[1];
composite_circ qr[0],qr[1];
measure qr[0] -> cr[0];
measure qr[1] -> cr[1];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_qasm_with_multiple_composite_circuits_with_same_name(self):
"""Test circuit qasm() method when multiple composite circuit instructions
with the same circuit name are added to the circuit
"""
my_gate = QuantumCircuit(1, name="my_gate")
my_gate.h(0)
my_gate_inst1 = my_gate.to_instruction()
my_gate = QuantumCircuit(1, name="my_gate")
my_gate.x(0)
my_gate_inst2 = my_gate.to_instruction()
my_gate = QuantumCircuit(1, name="my_gate")
my_gate.x(0)
my_gate_inst3 = my_gate.to_instruction()
qr = QuantumRegister(1, name="qr")
circuit = QuantumCircuit(qr, name="circuit")
circuit.append(my_gate_inst1, [qr[0]])
circuit.append(my_gate_inst2, [qr[0]])
my_gate_inst2_id = id(circuit.data[-1].operation)
circuit.append(my_gate_inst3, [qr[0]])
my_gate_inst3_id = id(circuit.data[-1].operation)
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
gate my_gate q0 {{ h q0; }}
gate my_gate_{1} q0 {{ x q0; }}
gate my_gate_{0} q0 {{ x q0; }}
qreg qr[1];
my_gate qr[0];
my_gate_{1} qr[0];
my_gate_{0} qr[0];\n""".format(
my_gate_inst3_id, my_gate_inst2_id
)
self.assertEqual(circuit.qasm(), expected_qasm)
def test_circuit_qasm_with_composite_circuit_with_children_composite_circuit(self):
"""Test circuit qasm() method when composite circuits with children
composite circuits in the definitions are added to the circuit"""
child_circ = QuantumCircuit(2, name="child_circ")
child_circ.h(0)
child_circ.cx(0, 1)
parent_circ = QuantumCircuit(3, name="parent_circ")
parent_circ.append(child_circ, range(2))
parent_circ.h(2)
grandparent_circ = QuantumCircuit(4, name="grandparent_circ")
grandparent_circ.append(parent_circ, range(3))
grandparent_circ.x(3)
qc = QuantumCircuit(4)
qc.append(grandparent_circ, range(4))
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
gate child_circ q0,q1 { h q0; cx q0,q1; }
gate parent_circ q0,q1,q2 { child_circ q0,q1; h q2; }
gate grandparent_circ q0,q1,q2,q3 { parent_circ q0,q1,q2; x q3; }
qreg q[4];
grandparent_circ q[0],q[1],q[2],q[3];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_qasm_pi(self):
"""Test circuit qasm() method with pi params."""
circuit = QuantumCircuit(2)
circuit.cz(0, 1)
circuit.u(2 * pi, 3 * pi, -5 * pi, 0)
qasm_str = circuit.qasm()
circuit2 = QuantumCircuit.from_qasm_str(qasm_str)
self.assertEqual(circuit, circuit2)
def test_circuit_qasm_with_composite_circuit_with_one_param(self):
"""Test circuit qasm() method when a composite circuit instruction
has one param
"""
original_str = """OPENQASM 2.0;
include "qelib1.inc";
gate nG0(param0) q0 { h q0; }
qreg q[3];
creg c[3];
nG0(pi) q[0];\n"""
qc = QuantumCircuit.from_qasm_str(original_str)
self.assertEqual(original_str, qc.qasm())
def test_circuit_qasm_with_composite_circuit_with_many_params_and_qubits(self):
"""Test circuit qasm() method when a composite circuit instruction
has many params and qubits
"""
original_str = """OPENQASM 2.0;
include "qelib1.inc";
gate nG0(param0,param1) q0,q1 { h q0; h q1; }
qreg q[3];
qreg r[3];
creg c[3];
creg d[3];
nG0(pi,pi/2) q[0],r[0];\n"""
qc = QuantumCircuit.from_qasm_str(original_str)
self.assertEqual(original_str, qc.qasm())
def test_c3sxgate_roundtrips(self):
"""Test that C3SXGate correctly round trips.
Qiskit gives this gate a different name
('c3sx') to the name in Qiskit's version of qelib1.inc ('c3sqrtx') gate, which can lead to
resolution issues."""
qc = QuantumCircuit(4)
qc.append(C3SXGate(), qc.qubits, [])
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
qreg q[4];
c3sqrtx q[0],q[1],q[2],q[3];
"""
self.assertEqual(qasm, expected)
parsed = QuantumCircuit.from_qasm_str(qasm)
self.assertIsInstance(parsed.data[0].operation, C3SXGate)
def test_c3sxgate_qasm_deprecation_warning(self):
"""Test deprecation warning for C3SXGate."""
with self.assertWarnsRegex(DeprecationWarning, r"Correct exporting to OpenQASM 2"):
C3SXGate().qasm()
def test_cczgate_qasm(self):
"""Test that CCZ dumps definition as a non-qelib1 gate."""
qc = QuantumCircuit(3)
qc.append(CCZGate(), qc.qubits, [])
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
gate ccz q0,q1,q2 { h q2; ccx q0,q1,q2; h q2; }
qreg q[3];
ccz q[0],q[1],q[2];
"""
self.assertEqual(qasm, expected)
def test_csgate_qasm(self):
"""Test that CS dumps definition as a non-qelib1 gate."""
qc = QuantumCircuit(2)
qc.append(CSGate(), qc.qubits, [])
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
gate cs q0,q1 { p(pi/4) q0; cx q0,q1; p(-pi/4) q1; cx q0,q1; p(pi/4) q1; }
qreg q[2];
cs q[0],q[1];
"""
self.assertEqual(qasm, expected)
def test_csdggate_qasm(self):
"""Test that CSdg dumps definition as a non-qelib1 gate."""
qc = QuantumCircuit(2)
qc.append(CSdgGate(), qc.qubits, [])
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
gate csdg q0,q1 { p(-pi/4) q0; cx q0,q1; p(pi/4) q1; cx q0,q1; p(-pi/4) q1; }
qreg q[2];
csdg q[0],q[1];
"""
self.assertEqual(qasm, expected)
def test_rzxgate_qasm(self):
"""Test that RZX dumps definition as a non-qelib1 gate."""
qc = QuantumCircuit(2)
qc.rzx(0, 0, 1)
qc.rzx(pi / 2, 1, 0)
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
gate rzx(param0) q0,q1 { h q1; cx q0,q1; rz(param0) q1; cx q0,q1; h q1; }
qreg q[2];
rzx(0) q[0],q[1];
rzx(pi/2) q[1],q[0];
"""
self.assertEqual(qasm, expected)
def test_ecrgate_qasm(self):
"""Test that ECR dumps its definition as a non-qelib1 gate."""
qc = QuantumCircuit(2)
qc.ecr(0, 1)
qc.ecr(1, 0)
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
gate rzx(param0) q0,q1 { h q1; cx q0,q1; rz(param0) q1; cx q0,q1; h q1; }
gate ecr q0,q1 { rzx(pi/4) q0,q1; x q0; rzx(-pi/4) q0,q1; }
qreg q[2];
ecr q[0],q[1];
ecr q[1],q[0];
"""
self.assertEqual(qasm, expected)
def test_unitary_qasm(self):
"""Test that UnitaryGate can be dumped to OQ2 correctly."""
qc = QuantumCircuit(1)
qc.unitary([[1, 0], [0, 1]], 0)
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
gate unitary q0 { u(0,0,0) q0; }
qreg q[1];
unitary q[0];
"""
self.assertEqual(qasm, expected)
def test_multiple_unitary_qasm(self):
"""Test that multiple UnitaryGate instances can all dump successfully."""
custom = QuantumCircuit(1, name="custom")
custom.unitary([[1, 0], [0, -1]], 0)
qc = QuantumCircuit(2)
qc.unitary([[1, 0], [0, 1]], 0)
qc.unitary([[0, 1], [1, 0]], 1)
qc.append(custom.to_gate(), [0], [])
qasm = qc.qasm()
expected = re.compile(
r"""OPENQASM 2.0;
include "qelib1.inc";
gate unitary q0 { u\(0,0,0\) q0; }
gate (?P<u1>unitary_[0-9]*) q0 { u\(pi,-pi/2,pi/2\) q0; }
gate (?P<u2>unitary_[0-9]*) q0 { u\(0,pi/2,pi/2\) q0; }
gate custom q0 { (?P=u2) q0; }
qreg q\[2\];
unitary q\[0\];
(?P=u1) q\[1\];
custom q\[0\];
""",
re.MULTILINE,
)
self.assertRegex(qasm, expected)
def test_unbound_circuit_raises(self):
"""Test circuits with unbound parameters raises."""
qc = QuantumCircuit(1)
theta = Parameter("θ")
qc.rz(theta, 0)
with self.assertRaises(QasmError):
qc.qasm()
def test_gate_qasm_with_ctrl_state(self):
"""Test gate qasm() with controlled gate that has ctrl_state setting."""
from qiskit.quantum_info import Operator
qc = QuantumCircuit(2)
qc.ch(0, 1, ctrl_state=0)
qasm_str = qc.qasm()
self.assertEqual(Operator(qc), Operator(QuantumCircuit.from_qasm_str(qasm_str)))
def test_circuit_qasm_with_mcx_gate(self):
"""Test circuit qasm() method with MCXGate
See https://github.com/Qiskit/qiskit-terra/issues/4943
"""
qc = QuantumCircuit(4)
qc.mcx([0, 1, 2], 3)
# qasm output doesn't support parameterized gate yet.
# param0 for "gate mcuq(param0) is not used inside the definition
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
gate mcx q0,q1,q2,q3 { h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }
qreg q[4];
mcx q[0],q[1],q[2],q[3];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_qasm_with_mcx_gate_variants(self):
"""Test circuit qasm() method with MCXGrayCode, MCXRecursive, MCXVChain"""
import qiskit.circuit.library as cl
n = 5
qc = QuantumCircuit(2 * n - 1)
qc.append(cl.MCXGrayCode(n), range(n + 1))
qc.append(cl.MCXRecursive(n), range(n + 2))
qc.append(cl.MCXVChain(n), range(2 * n - 1))
# qasm output doesn't support parameterized gate yet.
# param0 for "gate mcuq(param0) is not used inside the definition
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
gate mcu1(param0) q0,q1,q2,q3,q4,q5 { cu1(pi/16) q4,q5; cx q4,q3; cu1(-pi/16) q3,q5; cx q4,q3; cu1(pi/16) q3,q5; cx q3,q2; cu1(-pi/16) q2,q5; cx q4,q2; cu1(pi/16) q2,q5; cx q3,q2; cu1(-pi/16) q2,q5; cx q4,q2; cu1(pi/16) q2,q5; cx q2,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q3,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q2,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q3,q1; cu1(-pi/16) q1,q5; cx q4,q1; cu1(pi/16) q1,q5; cx q1,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q2,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q1,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q2,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; cx q3,q0; cu1(-pi/16) q0,q5; cx q4,q0; cu1(pi/16) q0,q5; }
gate mcx_gray q0,q1,q2,q3,q4,q5 { h q5; mcu1(pi) q0,q1,q2,q3,q4,q5; h q5; }
gate mcx q0,q1,q2,q3 { h q3; p(pi/8) q0; p(pi/8) q1; p(pi/8) q2; p(pi/8) q3; cx q0,q1; p(-pi/8) q1; cx q0,q1; cx q1,q2; p(-pi/8) q2; cx q0,q2; p(pi/8) q2; cx q1,q2; p(-pi/8) q2; cx q0,q2; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q1,q3; p(pi/8) q3; cx q2,q3; p(-pi/8) q3; cx q0,q3; h q3; }
gate mcx_recursive q0,q1,q2,q3,q4,q5,q6 { mcx q0,q1,q2,q6; mcx q3,q4,q6,q5; mcx q0,q1,q2,q6; mcx q3,q4,q6,q5; }
gate mcx_vchain q0,q1,q2,q3,q4,q5,q6,q7,q8 { rccx q0,q1,q6; rccx q2,q6,q7; rccx q3,q7,q8; ccx q4,q8,q5; rccx q3,q7,q8; rccx q2,q6,q7; rccx q0,q1,q6; }
qreg q[9];
mcx_gray q[0],q[1],q[2],q[3],q[4],q[5];
mcx_recursive q[0],q[1],q[2],q[3],q[4],q[5],q[6];
mcx_vchain q[0],q[1],q[2],q[3],q[4],q[5],q[6],q[7],q[8];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_qasm_with_registerless_bits(self):
"""Test that registerless bits do not have naming collisions in their registers."""
initial_registers = [QuantumRegister(2), ClassicalRegister(2)]
qc = QuantumCircuit(*initial_registers, [Qubit(), Clbit()])
# Match a 'qreg identifier[3];'-like QASM register declaration.
register_regex = re.compile(r"\s*[cq]reg\s+(\w+)\s*\[\d+\]\s*", re.M)
qasm_register_names = set()
for statement in qc.qasm().split(";"):
match = register_regex.match(statement)
if match:
qasm_register_names.add(match.group(1))
self.assertEqual(len(qasm_register_names), 4)
# Check that no additional registers were added to the circuit.
self.assertEqual(len(qc.qregs), 1)
self.assertEqual(len(qc.cregs), 1)
# Check that the registerless-register names are recalculated after adding more registers,
# to avoid naming clashes in this case.
generated_names = qasm_register_names - {register.name for register in initial_registers}
for generated_name in generated_names:
qc.add_register(QuantumRegister(1, name=generated_name))
qasm_register_names = set()
for statement in qc.qasm().split(";"):
match = register_regex.match(statement)
if match:
qasm_register_names.add(match.group(1))
self.assertEqual(len(qasm_register_names), 6)
def test_circuit_qasm_with_repeated_instruction_names(self):
"""Test that qasm() doesn't change the name of the instructions that live in circuit.data,
but a copy of them when there are repeated names."""
qc = QuantumCircuit(2)
qc.h(0)
qc.x(1)
# Create some random custom gate and name it "custom"
custom = QuantumCircuit(1)
custom.h(0)
custom.y(0)
gate = custom.to_gate()
gate.name = "custom"
# Another random custom gate named "custom" as well
custom2 = QuantumCircuit(2)
custom2.x(0)
custom2.z(1)
gate2 = custom2.to_gate()
gate2.name = "custom"
# Append custom gates with same name to original circuit
qc.append(gate, [0])
qc.append(gate2, [1, 0])
# Expected qasm string will append the id to the second gate with repeated name
expected_qasm = f"""OPENQASM 2.0;
include "qelib1.inc";
gate custom q0 {{ h q0; y q0; }}
gate custom_{id(gate2)} q0,q1 {{ x q0; z q1; }}
qreg q[2];
h q[0];
x q[1];
custom q[0];
custom_{id(gate2)} q[1],q[0];\n"""
# Check qasm() produced the correct string
self.assertEqual(expected_qasm, qc.qasm())
# Check instruction names were not changed by qasm()
names = ["h", "x", "custom", "custom"]
for idx, instruction in enumerate(qc._data):
self.assertEqual(instruction.operation.name, names[idx])
def test_circuit_qasm_with_invalid_identifiers(self):
"""Test that qasm() detects and corrects invalid OpenQASM gate identifiers,
while not changing the instructions on the original circuit"""
qc = QuantumCircuit(2)
# Create some gate and give it an invalid name
custom = QuantumCircuit(1)
custom.x(0)
custom.u(0, 0, pi, 0)
gate = custom.to_gate()
gate.name = "A[$]"
# Another gate also with invalid name
custom2 = QuantumCircuit(2)
custom2.x(0)
custom2.append(gate, [1])
gate2 = custom2.to_gate()
gate2.name = "invalid[name]"
# Append gates
qc.append(gate, [0])
qc.append(gate2, [1, 0])
# Expected qasm with valid identifiers
expected_qasm = "\n".join(
[
"OPENQASM 2.0;",
'include "qelib1.inc";',
"gate gate_A___ q0 { x q0; u(0,0,pi) q0; }",
"gate invalid_name_ q0,q1 { x q0; gate_A___ q1; }",
"qreg q[2];",
"gate_A___ q[0];",
"invalid_name_ q[1],q[0];",
"",
]
)
# Check qasm() produces the correct string
self.assertEqual(expected_qasm, qc.qasm())
# Check instruction names were not changed by qasm()
names = ["A[$]", "invalid[name]"]
for idx, instruction in enumerate(qc._data):
self.assertEqual(instruction.operation.name, names[idx])
def test_circuit_qasm_with_duplicate_invalid_identifiers(self):
"""Test that qasm() corrects invalid identifiers and the de-duplication
code runs correctly, without altering original instructions"""
base = QuantumCircuit(1)
# First gate with invalid name, escapes to "invalid__"
clash1 = QuantumCircuit(1, name="invalid??")
clash1.x(0)
base.append(clash1, [0])
# Second gate with invalid name that also escapes to "invalid__"
clash2 = QuantumCircuit(1, name="invalid[]")
clash2.z(0)
base.append(clash2, [0])
# Check qasm is correctly produced
names = set()
for match in re.findall(r"gate (\S+)", base.qasm()):
self.assertTrue(VALID_QASM2_IDENTIFIER.fullmatch(match))
names.add(match)
self.assertEqual(len(names), 2)
# Check instruction names were not changed by qasm()
names = ["invalid??", "invalid[]"]
for idx, instruction in enumerate(base._data):
self.assertEqual(instruction.operation.name, names[idx])
def test_circuit_qasm_escapes_register_names(self):
"""Test that registers that have invalid OpenQASM 2 names get correctly escaped, even when
they would escape to the same value."""
qc = QuantumCircuit(QuantumRegister(2, "?invalid"), QuantumRegister(2, "!invalid"))
qc.cx(0, 1)
qc.cx(2, 3)
qasm = qc.qasm()
match = re.fullmatch(
rf"""OPENQASM 2.0;
include "qelib1.inc";
qreg ({VALID_QASM2_IDENTIFIER.pattern})\[2\];
qreg ({VALID_QASM2_IDENTIFIER.pattern})\[2\];
cx \1\[0\],\1\[1\];
cx \2\[0\],\2\[1\];
""",
qasm,
)
self.assertTrue(match)
self.assertNotEqual(match.group(1), match.group(2))
def test_circuit_qasm_escapes_reserved(self):
"""Test that the OpenQASM 2 exporter won't export reserved names."""
qc = QuantumCircuit(QuantumRegister(1, "qreg"))
gate = Gate("gate", 1, [])
gate.definition = QuantumCircuit(1)
qc.append(gate, [qc.qubits[0]])
qasm = qc.qasm()
match = re.fullmatch(
rf"""OPENQASM 2.0;
include "qelib1.inc";
gate ({VALID_QASM2_IDENTIFIER.pattern}) q0 {{ }}
qreg ({VALID_QASM2_IDENTIFIER.pattern})\[1\];
\1 \2\[0\];
""",
qasm,
)
self.assertTrue(match)
self.assertNotEqual(match.group(1), "gate")
self.assertNotEqual(match.group(1), "qreg")
def test_circuit_qasm_with_double_precision_rotation_angle(self):
"""Test that qasm() emits high precision rotation angles per default."""
from qiskit.circuit.tools.pi_check import MAX_FRAC
qc = QuantumCircuit(1)
qc.p(0.123456789, 0)
qc.p(pi * pi, 0)
qc.p(MAX_FRAC * pi + 1, 0)
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
qreg q[1];
p(0.123456789) q[0];
p(9.869604401089358) q[0];
p(51.26548245743669) q[0];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_qasm_with_rotation_angles_close_to_pi(self):
"""Test that qasm() properly rounds values closer than 1e-12 to pi."""
qc = QuantumCircuit(1)
qc.p(pi + 1e-11, 0)
qc.p(pi + 1e-12, 0)
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
qreg q[1];
p(3.141592653599793) q[0];
p(pi) q[0];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_circuit_raises_on_single_bit_condition(self):
"""OpenQASM 2 can't represent single-bit conditions, so test that a suitable error is
printed if this is attempted."""
qc = QuantumCircuit(1, 1)
qc.x(0).c_if(0, True)
with self.assertRaisesRegex(QasmError, "OpenQASM 2 can only condition on registers"):
qc.qasm()
def test_circuit_raises_invalid_custom_gate_no_qubits(self):
"""OpenQASM 2 exporter of custom gates with no qubits.
See: https://github.com/Qiskit/qiskit-terra/issues/10435"""
legit_circuit = QuantumCircuit(5, name="legit_circuit")
empty_circuit = QuantumCircuit(name="empty_circuit")
legit_circuit.append(empty_circuit)
with self.assertRaisesRegex(QasmError, "acts on zero qubits"):
legit_circuit.qasm()
def test_circuit_raises_invalid_custom_gate_clbits(self):
"""OpenQASM 2 exporter of custom instruction.
See: https://github.com/Qiskit/qiskit-terra/issues/7351"""
instruction = QuantumCircuit(2, 2, name="inst")
instruction.cx(0, 1)
instruction.measure([0, 1], [0, 1])
custom_instruction = instruction.to_instruction()
qc = QuantumCircuit(2, 2)
qc.append(custom_instruction, [0, 1], [0, 1])
with self.assertRaisesRegex(QasmError, "acts on 2 classical bits"):
qc.qasm()
def test_circuit_qasm_with_permutations(self):
"""Test circuit qasm() method with Permutation gates."""
qc = QuantumCircuit(4)
qc.append(PermutationGate([2, 1, 0]), [0, 1, 2])
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
gate permutation__2_1_0_ q0,q1,q2 { swap q0,q2; }
qreg q[4];
permutation__2_1_0_ q[0],q[1],q[2];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_multiple_permutation(self):
"""Test that multiple PermutationGates can be added to a circuit."""
custom = QuantumCircuit(3, name="custom")
custom.append(PermutationGate([2, 1, 0]), [0, 1, 2])
custom.append(PermutationGate([0, 1, 2]), [0, 1, 2])
qc = QuantumCircuit(4)
qc.append(PermutationGate([2, 1, 0]), [0, 1, 2], [])
qc.append(PermutationGate([1, 2, 0]), [0, 1, 2], [])
qc.append(custom.to_gate(), [1, 3, 2], [])
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
gate permutation__2_1_0_ q0,q1,q2 { swap q0,q2; }
gate permutation__1_2_0_ q0,q1,q2 { swap q1,q2; swap q0,q2; }
gate permutation__0_1_2_ q0,q1,q2 { }
gate custom q0,q1,q2 { permutation__2_1_0_ q0,q1,q2; permutation__0_1_2_ q0,q1,q2; }
qreg q[4];
permutation__2_1_0_ q[0],q[1],q[2];
permutation__1_2_0_ q[0],q[1],q[2];
custom q[1],q[3],q[2];
"""
self.assertEqual(qasm, expected)
def test_circuit_qasm_with_reset(self):
"""Test circuit qasm() method with Reset."""
qc = QuantumCircuit(2)
qc.reset([0, 1])
expected_qasm = """OPENQASM 2.0;
include "qelib1.inc";
qreg q[2];
reset q[0];
reset q[1];\n"""
self.assertEqual(qc.qasm(), expected_qasm)
def test_nested_gate_naming_clashes(self):
"""Test that gates that have naming clashes but only appear in the body of another gate
still get exported correctly."""
# pylint: disable=missing-class-docstring
class Inner(Gate):
def __init__(self, param):
super().__init__("inner", 1, [param])
def _define(self):
self._definition = QuantumCircuit(1)
self._definition.rx(self.params[0], 0)
class Outer(Gate):
def __init__(self, param):
super().__init__("outer", 1, [param])
def _define(self):
self._definition = QuantumCircuit(1)
self._definition.append(Inner(self.params[0]), [0], [])
qc = QuantumCircuit(1)
qc.append(Outer(1.0), [0], [])
qc.append(Outer(2.0), [0], [])
qasm = qc.qasm()
expected = re.compile(
r"""OPENQASM 2\.0;
include "qelib1\.inc";
gate inner\(param0\) q0 { rx\(1\.0\) q0; }
gate outer\(param0\) q0 { inner\(1\.0\) q0; }
gate (?P<inner1>inner_[0-9]*)\(param0\) q0 { rx\(2\.0\) q0; }
gate (?P<outer1>outer_[0-9]*)\(param0\) q0 { (?P=inner1)\(2\.0\) q0; }
qreg q\[1\];
outer\(1\.0\) q\[0\];
(?P=outer1)\(2\.0\) q\[0\];
""",
re.MULTILINE,
)
self.assertRegex(qasm, expected)
def test_opaque_output(self):
"""Test that gates with no definition are exported as `opaque`."""
custom = QuantumCircuit(1, name="custom")
custom.append(Gate("my_c", 1, []), [0])
qc = QuantumCircuit(2)
qc.append(Gate("my_a", 1, []), [0])
qc.append(Gate("my_a", 1, []), [1])
qc.append(Gate("my_b", 2, [1.0]), [1, 0])
qc.append(custom.to_gate(), [0], [])
qasm = qc.qasm()
expected = """OPENQASM 2.0;
include "qelib1.inc";
opaque my_a q0;
opaque my_b(param0) q0,q1;
opaque my_c q0;
gate custom q0 { my_c q0; }
qreg q[2];
my_a q[0];
my_a q[1];
my_b(1.0) q[1],q[0];
custom q[0];
"""
self.assertEqual(qasm, expected)
def test_sequencial_inner_gates_with_same_name(self):
"""Test if inner gates sequentially added with the same name result in the correct qasm"""
qubits_range = range(3)
gate_a = QuantumCircuit(3, name="a")
gate_a.h(qubits_range)
gate_a = gate_a.to_instruction()
gate_b = QuantumCircuit(3, name="a")
gate_b.append(gate_a, qubits_range)
gate_b.x(qubits_range)
gate_b = gate_b.to_instruction()
qc = QuantumCircuit(3)
qc.append(gate_b, qubits_range)
qc.z(qubits_range)
gate_a_id = id(qc.data[0].operation)
expected_output = f"""OPENQASM 2.0;
include "qelib1.inc";
gate a q0,q1,q2 {{ h q0; h q1; h q2; }}
gate a_{gate_a_id} q0,q1,q2 {{ a q0,q1,q2; x q0; x q1; x q2; }}
qreg q[3];
a_{gate_a_id} q[0],q[1],q[2];
z q[0];
z q[1];
z q[2];
"""
self.assertEqual(qc.qasm(), expected_output)
def test_empty_barrier(self):
"""Test that a blank barrier statement in _Qiskit_ acts over all qubits, while an explicitly
no-op barrier (assuming Qiskit continues to allow this) is not output to OQ2 at all, since
the statement requires an argument in the spec."""
qc = QuantumCircuit(QuantumRegister(2, "qr1"), QuantumRegister(3, "qr2"))
qc.barrier() # In Qiskit land, this affects _all_ qubits.
qc.barrier([]) # This explicitly affects _no_ qubits (so is totally meaningless).
expected = """\
OPENQASM 2.0;
include "qelib1.inc";
qreg qr1[2];
qreg qr2[3];
barrier qr1[0],qr1[1],qr2[0],qr2[1],qr2[2];
"""
self.assertEqual(qc.qasm(), expected)
def test_small_angle_valid(self):
"""Test that small angles do not get converted to invalid OQ2 floating-point values."""
# OQ2 _technically_ requires a decimal point in all floating-point values, even ones that
# are followed by an exponent.
qc = QuantumCircuit(1)
qc.rx(0.000001, 0)
expected = """\
OPENQASM 2.0;
include "qelib1.inc";
qreg q[1];
rx(1.e-06) q[0];
"""
self.assertEqual(qc.qasm(), expected)
if __name__ == "__main__":
unittest.main()
|
https://github.com/pedroripper/qiskit_tutoriais
|
pedroripper
|
from qiskit import *
global x
x = QuantumCircuit(2,2)
def ua(bit_0 , bit_1):
global x
if(bit_0 == 1 and bit_1 == 0):
x.cx(0,1)
ua(0,0)
x.draw()
0 == 0
0 == 1
|
https://github.com/Tojarieh97/VQE
|
Tojarieh97
|
%load_ext autoreload
%autoreload 2
import nbimporter
from typing import Dict, Tuple, List
import numpy as np
from tqdm import tqdm
QUBITS_NUM = 4
N = 2**QUBITS_NUM
K = 4
w = 0.5
NUM_SHOTS = 1024
NUM_ITERATIONS = 100
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
from qiskit import Aer
from qiskit.utils import QuantumInstance, algorithm_globals
seed = 50
algorithm_globals.random_seed = seed
simulator_backend = Aer.get_backend('qasm_simulator')
from scipy.optimize import minimize
from utiles import *
input_states = get_first_k_eigenvectors_from_n_computational_basis(K, N)
from ansatz_circuit_item2 import get_full_variational_quantum_circuit
init_circuit_params = {
"thetas": np.random.uniform(low=0, high=2*np.pi, size=8),
"phis": np.random.uniform(low=0, high=2*np.pi, size=4),
"D1": 2,
"D2": 6
}
def prepare_circuit_params(thetas) -> Dict:
return {
"thetas": thetas[4:],
"phis": thetas[:4],
"D1": 2,
"D2": 6
}
def get_ansatz_state(circuit_params, input_state):
circuit_params_with_input_state = {**circuit_params, "input_state": input_state}
return get_full_variational_quantum_circuit(**circuit_params_with_input_state)
def transfrom_hamiltonian_into_pauli_strings(hamiltonian) -> List:
pauli_operators = hamiltonian.to_pauli_op().settings['oplist']
pauli_coeffs = list(map(lambda pauli_operator: pauli_operator.coeff, pauli_operators))
pauli_strings = list(map(lambda pauli_operator: pauli_operator.primitive, pauli_operators))
return pauli_coeffs, pauli_strings
from qiskit.circuit.library.standard_gates import HGate, SGate
from qiskit import QuantumCircuit, ClassicalRegister, QuantumRegister
reducing_to_pauli_z_mapping = {
'I': 'I',
'Z': 'Z',
'X': 'Z',
'Y': 'Z'
}
def reduce_pauli_matrixes_into_sigma_z(pauli_string) -> str:
reduced_pauli_string = ""
for matrix_index in range(QUBITS_NUM):
pauli_matrix = str(pauli_string[matrix_index])
reduced_pauli_matrix = reducing_to_pauli_z_mapping[pauli_matrix]
reduced_pauli_string = reduced_pauli_matrix + reduced_pauli_string
return reduced_pauli_string
def add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string, quantum_circuit):
quantum_registers = QuantumRegister(QUBITS_NUM, name="qubit")
additional_circuit_layer = QuantumCircuit(quantum_registers)
for quantum_register_index, pauli_matrix in enumerate(pauli_string):
if pauli_matrix == "X":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
if pauli_string == "Y":
additional_circuit_layer.append(HGate(), [quantum_registers[quantum_register_index]])
additional_circuit_layer.append(SGate(), [quantum_registers[quantum_register_index]])
extended_quantum_circuit = quantum_circuit.compose(additional_circuit_layer)
return extended_quantum_circuit
def get_probability_distribution(counts: Dict) -> Dict:
proba_distribution = {state: (count / NUM_SHOTS) for state, count in counts.items()}
return proba_distribution
def calculate_probabilities_of_measurments_in_computational_basis(quantum_state_circuit) -> Dict:
quantum_state_circuit.measure_all()
transpiled_quantum_state_circuit = transpile(quantum_state_circuit, simulator_backend)
Qobj = assemble(transpiled_quantum_state_circuit)
result = simulator_backend.run(Qobj).result()
counts = result.get_counts(quantum_state_circuit)
return get_probability_distribution(counts)
def sort_probas_dict_by_qubits_string_keys(proba_distribution: Dict) -> Dict:
return dict(sorted(proba_distribution.items()))
def reset_power_of_minus_1(power_of_minus_1):
power_of_minus_1 = 0
return power_of_minus_1
def convert_pauli_string_into_str(pauli_string) -> str:
return str(pauli_string)
def calculate_expectation_value_of_pauli_string_by_measurments_probas(pauli_string, ansatz_circuit):
pauli_string_expectation_value = 0
power_of_minus_1 = 0
pauli_string_str = convert_pauli_string_into_str(pauli_string)
extended_ansatz_circuit = add_layer_of_gates_for_reducing_paulis_to_sigma_z(pauli_string_str, ansatz_circuit)
probas_distribution = calculate_probabilities_of_measurments_in_computational_basis(extended_ansatz_circuit)
reduced_pauli_string = reduce_pauli_matrixes_into_sigma_z(pauli_string)
sorted_probas_distribuition = sort_probas_dict_by_qubits_string_keys(probas_distribution)
for qubits_string, proba in sorted_probas_distribuition.items():
for string_index in range(QUBITS_NUM):
if(str(qubits_string[string_index])=="1" and str(reduced_pauli_string[string_index])=="Z"):
power_of_minus_1 += 1
pauli_string_expectation_value += pow(-1, power_of_minus_1)*proba
power_of_minus_1 = reset_power_of_minus_1(power_of_minus_1)
return pauli_string_expectation_value
def get_expectation_value(ansatz_circuit, pauli_coeffs, pauli_strings):
total_expection_value = 0
for pauli_coeff, pauli_string in zip(pauli_coeffs, pauli_strings):
total_expection_value += pauli_coeff*calculate_expectation_value_of_pauli_string_by_measurments_probas(
pauli_string, ansatz_circuit)
return total_expection_value
from qiskit import assemble, transpile
def cost_function(thetas, hamiltonian):
circuit_params = prepare_circuit_params(thetas)
computational_eigenvectors = get_first_k_eigenvectors_from_n_computational_basis(K, N)
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
k_ansatz_state = get_ansatz_state(circuit_params, computational_eigenvectors[K-1])
approximated_energey = get_expectation_value(k_ansatz_state, pauli_coeffs, pauli_strings)
insert_approximated_energy_to_list_of_all_approximated_energies(approximated_energey)
L_w = w*approximated_energey
for j in range(K-1):
ansatz_state = get_ansatz_state(circuit_params, computational_eigenvectors[j])
L_w += get_expectation_value(ansatz_state, pauli_coeffs, pauli_strings)
return L_w
def get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian):
initial_thetas = np.random.uniform(low=0, high=2*np.pi, size=PARAMS_NUM)
optimizer_result = minimize(cost_function,
x0=initial_thetas,
args=(hamiltonian),
method="BFGS",
options={"maxiter":NUM_ITERATIONS,
"disp": True})
optimal_thetas = optimizer_result.x
return optimal_thetas
def get_approximated_eigenvalue_of_hamiltonian(hamiltonian):
optimal_thetas = get_optimal_thetas_of_ansatz_circuit_for_hamiltonian(hamiltonian)
print("### The optimal parameters found by the optimizer ###")
print(optimal_thetas)
optimal_circuit_params = prepare_circuit_params(optimal_thetas)
computational_eigenvectors = get_first_k_eigenvectors_from_n_computational_basis(K, N)
optimal_ansatz_state = get_ansatz_state(optimal_circuit_params, computational_eigenvectors[K-1])
pauli_coeffs, pauli_strings = transfrom_hamiltonian_into_pauli_strings(hamiltonian)
approximated_eigenvalue = get_expectation_value(optimal_ansatz_state, pauli_coeffs, pauli_strings)
return approximated_eigenvalue
from numpy import linalg as LA
def get_approximation_error(exact_eigenvalue, approximated_eigenvalue):
return abs(abs(exact_eigenvalue)-abs(approximated_eigenvalue))/abs(exact_eigenvalue)
def get_minimum_exact_eigenvalue_of_hamiltonian(hamiltonian):
eigen_values = LA.eigvals(hamiltonian.to_matrix())
print(sorted(eigen_values))
return min(sorted(eigen_values))
def compare_exact_and_approximated_eigenvalue(hamiltonian, approximated_eigenvalue):
exact_eigenvalue = get_minimum_exact_eigenvalue_of_hamiltonian(hamiltonian)
print("Exact Eigenvalue:")
print(exact_eigenvalue)
print("\nApproximated Eigenvalue:")
print(approximated_eigenvalue)
print("\nApproximation Error")
print(get_approximation_error(exact_eigenvalue, approximated_eigenvalue))
plot_convergence_of_optimization_process(approximated_energies, exact_eigenvalue, margin=3)
approximated_energies = []
def insert_approximated_energy_to_list_of_all_approximated_energies(energy):
approximated_energies.append(energy)
import matplotlib.pyplot as plt
def plot_convergence_of_optimization_process(approximated_energies, exact_eigenvalue, margin):
plt.title("convergence of optimization process to the exact eigenvalue")
plt.margins(0, margin)
plt.plot(approximated_energies[-NUM_ITERATIONS:])
plt.axhline(y = exact_eigenvalue, color = 'r', linestyle = '-')
plt.grid()
plt.xlabel("# of iterations")
plt.ylabel("Energy")
def plot_fidelity():
plt.plot(LiH_approximated_energies)
plt.xlabel("# of iterations")
plt.ylabel("Energy")
from qiskit.opflow import X, Z, I, H, Y
LiH_molecule_4_qubits = -7.49894690201071*(I^I^I^I) + \
-0.0029329964409502266*(X^X^Y^Y) + \
0.0029329964409502266*(X^Y^Y^X) + \
0.01291078027311749*(X^Z^X^I) + \
-0.0013743761078958677*(X^Z^X^Z) + \
0.011536413200774975*(X^I^X^I) + \
0.0029329964409502266*(Y^X^X^Y) + \
-0.0029329964409502266*(Y^Y^X^X) + \
0.01291078027311749*(Y^Z^Y^I) + \
-0.0013743761078958677*(Y^Z^Y^Z) + \
0.011536413200774975*(Y^I^Y^I) + \
0.16199475388004184*(Z^I^I^I) + \
0.011536413200774975*(Z^X^Z^X) + \
0.011536413200774975*(Z^Y^Z^Y) + \
0.12444770133137588*(Z^Z^I^I) + \
0.054130445793298836*(Z^I^Z^I) + \
0.05706344223424907*(Z^I^I^Z) + \
0.012910780273117487*(I^X^Z^X) + \
-0.0013743761078958677*(I^X^I^X) + \
0.012910780273117487*(I^Y^Z^Y) + \
-0.0013743761078958677*(I^Y^I^Y) + \
0.16199475388004186*(I^Z^I^I) + \
0.05706344223424907*(I^Z^Z^I) + \
0.054130445793298836*(I^Z^I^Z) + \
-0.013243698330265966*(I^I^Z^I) + \
0.08479609543670981*(I^I^Z^Z) + \
-0.013243698330265952*(I^I^I^Z)
%%time
LiH_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(LiH_molecule_4_qubits)
compare_exact_and_approximated_eigenvalue(LiH_molecule_4_qubits, LiH_approximated_eigenvalue)
H2_molecule_Hamiltonian_4_qubits = -0.8105479805373279 * (I^I^I^I) \
+ 0.1721839326191554 * (I^I^I^Z) \
- 0.22575349222402372 * (I^I^Z^I) \
+ 0.17218393261915543 * (I^Z^I^I) \
- 0.2257534922240237 * (Z^I^I^I) \
+ 0.12091263261776627 * (I^I^Z^Z) \
+ 0.16892753870087907 * (I^Z^I^Z) \
+ 0.045232799946057826 * (Y^Y^Y^Y) \
+ 0.045232799946057826 * (X^X^Y^Y) \
+ 0.045232799946057826 * (Y^Y^X^X) \
+ 0.045232799946057826 * (X^X^X^X) \
+ 0.1661454325638241 * (Z^I^I^Z) \
+ 0.1661454325638241 * (I^Z^Z^I) \
+ 0.17464343068300453 * (Z^I^Z^I) \
+ 0.12091263261776627 * (Z^Z^I^I)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_4_qubits)
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_4_qubits, H2_approximated_eigenvalue)
transverse_ising_4_qubits = 0.0 * (I^I^I^I) \
+ 0.8398088405253477 * (X^I^I^I) \
+ 0.7989496312070936 * (I^X^I^I) \
+ 0.38189710487113193 * (Z^Z^I^I) \
+ 0.057753122422666725 * (I^I^X^I) \
+ 0.5633292636970458 * (Z^I^Z^I) \
+ 0.3152740621483513 * (I^Z^Z^I) \
+ 0.07209487981989715 * (I^I^I^X) \
+ 0.17892334004292654 * (Z^I^I^Z) \
+ 0.2273896497668042 * (I^Z^I^Z) \
+ 0.09762902934216211 * (I^I^Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_4_qubits)
compare_exact_and_approximated_eigenvalue(transverse_ising_4_qubits, TI_approximated_eigenvalue)
QUBITS_NUM = 3
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
NUM_ITERATIONS = 100
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
from qiskit.opflow import X, Z, I
transverse_ising_3_qubits = 0.0 * (I^I^I) \
+ 0.012764169333459807 * (X^I^I) \
+ 0.7691573729160869 * (I^X^I) \
+ 0.398094746026449 * (Z^Z^I) \
+ 0.15250261906586637 * (I^I^X) \
+ 0.2094051920882264 * (Z^I^Z) \
+ 0.5131291860752999 * (I^Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_3_qubits)
compare_exact_and_approximated_eigenvalue(transverse_ising_3_qubits, TI_approximated_eigenvalue)
QUBITS_NUM = 2
N = 2**QUBITS_NUM
NUM_SHOTS = 1024
NUM_ITERATIONS = 100
CIRCUIT_DEPTH = 3
PARAMS_NUM = 2*QUBITS_NUM*(CIRCUIT_DEPTH+1)
transverse_ising_2_qubits = 0.13755727363376802 * (I^X) \
+ 0.43305656297810435 * (X^I) \
+ 0.8538597608997253 * (Z^Z)
%%time
TI_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(transverse_ising_2_qubits)
compare_exact_and_approximated_eigenvalue(transverse_ising_2_qubits, TI_approximated_eigenvalue)
from qiskit.opflow import X, Z, I
H2_molecule_Hamiltonian_2_qubits = -0.5053051899926562*(I^I) + \
-0.3277380754984016*(Z^I) + \
0.15567463610622564*(Z^Z) + \
-0.3277380754984016*(I^Z)
%%time
H2_approximated_eigenvalue = get_approximated_eigenvalue_of_hamiltonian(H2_molecule_Hamiltonian_2_qubits)
compare_exact_and_approximated_eigenvalue(H2_molecule_Hamiltonian_2_qubits, H2_approximated_eigenvalue)
|
https://github.com/swe-bench/Qiskit__qiskit
|
swe-bench
|
# This code is part of Qiskit.
#
# (C) Copyright IBM 2023.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.
"""Test CZ circuits synthesis functions."""
import unittest
from test import combine
import numpy as np
from ddt import ddt
from qiskit import QuantumCircuit
from qiskit.circuit.library import Permutation
from qiskit.synthesis.linear_phase import synth_cz_depth_line_mr
from qiskit.synthesis.linear.linear_circuits_utils import check_lnn_connectivity
from qiskit.quantum_info import Clifford
from qiskit.test import QiskitTestCase
@ddt
class TestCZSynth(QiskitTestCase):
"""Test the linear reversible circuit synthesis functions."""
@combine(num_qubits=[3, 4, 5, 6, 7])
def test_cz_synth_lnn(self, num_qubits):
"""Test the CZ synthesis code for linear nearest neighbour connectivity."""
seed = 1234
rng = np.random.default_rng(seed)
num_gates = 10
num_trials = 5
for _ in range(num_trials):
mat = np.zeros((num_qubits, num_qubits))
qctest = QuantumCircuit(num_qubits)
# Generate a random CZ circuit
for _ in range(num_gates):
i = rng.integers(num_qubits)
j = rng.integers(num_qubits)
if i != j:
qctest.cz(i, j)
if j > i:
mat[i][j] = (mat[i][j] + 1) % 2
else:
mat[j][i] = (mat[j][i] + 1) % 2
qc = synth_cz_depth_line_mr(mat)
# Check that the output circuit 2-qubit depth equals to 2*n+2
depth2q = qc.depth(filter_function=lambda x: x.operation.num_qubits == 2)
self.assertTrue(depth2q == 2 * num_qubits + 2)
# Check that the output circuit has LNN connectivity
self.assertTrue(check_lnn_connectivity(qc))
# Assert that we get the same element, up to reverse order of qubits
perm = Permutation(num_qubits=num_qubits, pattern=range(num_qubits)[::-1])
qctest = qctest.compose(perm)
self.assertEqual(Clifford(qc), Clifford(qctest))
if __name__ == "__main__":
unittest.main()
|
https://github.com/qiskit-community/qiskit-translations-staging
|
qiskit-community
|
from qiskit import QuantumCircuit
qc = QuantumCircuit(12)
for idx in range(5):
qc.h(idx)
qc.cx(idx, idx+5)
qc.cx(1, 7)
qc.x(8)
qc.cx(1, 9)
qc.x(7)
qc.cx(1, 11)
qc.swap(6, 11)
qc.swap(6, 9)
qc.swap(6, 10)
qc.x(6)
qc.draw('mpl')
|
https://github.com/victor-onofre/Quantum_Algorithms
|
victor-onofre
|
from qiskit import QuantumCircuit, QuantumRegister, ClassicalRegister, execute, Aer, IBMQ, BasicAer
from qiskit.visualization import plot_bloch_multivector,plot_bloch_vector, plot_histogram
from qiskit.quantum_info import Statevector
import numpy as np
import matplotlib
backend = BasicAer.get_backend('qasm_simulator')
shots = 1024
style = {'backgroundcolor': 'lightyellow'} # Style of the circuits
qreg1 = QuantumRegister(2) # The quantum register of the qubits, in this case 2 qubits
register1 = ClassicalRegister(1)
qc = QuantumCircuit(qreg1, register1)
#qc.x(0)
qc.x(1)
qc.barrier()
qc.draw(output='mpl', style=style)
qc.h(0)
qc.h(1)
qc.barrier()
qc.draw(output='mpl', style=style)
qc.cx(0,1)
qc.barrier()
qc.draw(output='mpl', style=style)
qc.h(0)
qc.draw(output='mpl', style=style)
qc.measure(qreg1[0],register1)
qc.draw(output='mpl', style=style)
results = execute(qc, backend=backend, shots=shots).result()
answer = results.get_counts()
plot_histogram(answer)
def oracleBalance1(qcir):
qcir.cx(0,1)
qcir.barrier()
return qcir
def oracleBalance2(qcir):
qcir.x(1)
qcir.cx(0,1)
qcir.barrier()
return qcir
def oracleConstant1(qcir):
qcir.x(1)
qcir.barrier()
return qcir
def oracleConstant2(qcir):
qcir.barrier()
return qcir
def deutsch(oracle):
Qreg = QuantumRegister(2)
Creg = ClassicalRegister(1)
qcirc = QuantumCircuit(Qreg, Creg)
qcirc.x(1)
qcirc.h(0)
qcirc.h(1)
qcirc.barrier()
qcirc = oracle(qcirc)
qcirc.h(0)
qcirc.barrier()
qcirc.measure(Qreg[0],Creg)
return qcirc
resultBalanced1 = deutsch(oracleBalance1)
resultBalanced1.draw(output='mpl', style=style)
resultsB1 = execute(resultBalanced1, backend=backend, shots=shots).result()
answerB1 = resultsB1.get_counts()
plot_histogram(answerB1)
resultBalanced2 = deutsch(oracleBalance1)
resultBalanced2.draw(output='mpl', style=style)
resultsB2 = execute(resultBalanced2, backend=backend, shots=shots).result()
answerB2 = resultsB2.get_counts()
plot_histogram(answerB2)
resultConstant1 = deutsch(oracleConstant1)
resultConstant1.draw(output='mpl', style=style)
resultsC1= execute(resultConstant1, backend=backend, shots=shots).result()
answerC1 = resultsC1.get_counts()
plot_histogram(answerC1)
resultConstant2 = deutsch(oracleConstant2)
resultConstant2.draw(output='mpl', style=style)
resultsC2= execute(resultConstant2, backend=backend, shots=shots).result()
answerC2 = resultsC2.get_counts()
plot_histogram(answerC2)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.