qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/dagcircuit/dagdepnode.py

@@ -0,0 +1,160 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+# pylint: disable=redefined-builtin
+
+"""Object to represent the information at a node in the DAGCircuit."""
+from __future__ import annotations
+
+from qiskit.exceptions import QiskitError
+
+
+class DAGDepNode:
+    """Object to represent the information at a node in the DAGDependency().
+
+    It is used as the return value from `*_nodes()` functions and can
+    be supplied to functions that take a node.
+    """
+
+    __slots__ = [
+        "type",
+        "_op",
+        "name",
+        "_qargs",
+        "cargs",
+        "sort_key",
+        "node_id",
+        "successors",
+        "predecessors",
+        "reachable",
+        "matchedwith",
+        "isblocked",
+        "successorstovisit",
+        "qindices",
+        "cindices",
+    ]
+
+    def __init__(
+        self,
+        type=None,
+        op=None,
+        name=None,
+        qargs=(),
+        cargs=(),
+        successors: list[int] | None = None,
+        predecessors: list[int] | None = None,
+        reachable=None,
+        matchedwith: list[int] | None = None,
+        successorstovisit: list[int] | None = None,
+        isblocked: bool | None = None,
+        qindices: list[int] | None = None,
+        cindices: list[int] | None = None,
+        nid: int = -1,
+    ):
+
+        self.type = type
+        self._op = op
+        self.name = name
+        self._qargs = tuple(qargs) if qargs is not None else ()
+        self.cargs = tuple(cargs) if cargs is not None else ()
+        self.node_id = nid
+        self.sort_key: str = str(self._qargs)
+        self.successors: list[int] = successors if successors is not None else []
+        self.predecessors: list[int] = predecessors if predecessors is not None else []
+        self.reachable = reachable
+        self.matchedwith: list[int] = matchedwith if matchedwith is not None else []
+        self.isblocked: bool = isblocked
+        self.successorstovisit: list[int] = (
+            successorstovisit if successorstovisit is not None else []
+        )
+        self.qindices: list[int] = qindices if qindices is not None else []
+        self.cindices: list[int] = cindices if cindices is not None else []
+
+    @property
+    def op(self):
+        """Returns the Instruction object corresponding to the op for the node, else None"""
+        if not self.type or self.type != "op":
+            raise QiskitError(f"The node {str(self)} is not an op node")
+        return self._op
+
+    @op.setter
+    def op(self, data):
+        self._op = data
+
+    @property
+    def qargs(self):
+        """
+        Returns list of Qubit, else an empty list.
+        """
+        return self._qargs
+
+    @qargs.setter
+    def qargs(self, new_qargs):
+        """Sets the qargs to be the given list of qargs."""
+        self._qargs = tuple(new_qargs)
+        self.sort_key = str(new_qargs)
+
+    @staticmethod
+    def semantic_eq(node1, node2):
+        """
+        Check if DAG nodes are considered equivalent, e.g., as a node_match for nx.is_isomorphic.
+
+        Args:
+            node1 (DAGDepNode): A node to compare.
+            node2 (DAGDepNode): The other node to compare.
+
+        Return:
+            Bool: If node1 == node2
+        """
+        # For barriers, qarg order is not significant so compare as sets
+        if "barrier" == node1.name == node2.name:
+            return set(node1._qargs) == set(node2._qargs)
+
+        if node1.type == node2.type:
+            if node1._op == node2._op:
+                if node1.name == node2.name:
+                    if node1._qargs == node2._qargs:
+                        if node1.cargs == node2.cargs:
+                            if node1.type == "op":
+                                if getattr(node1._op, "condition", None) != getattr(
+                                    node2._op, "condition", None
+                                ):
+                                    return False
+                            return True
+        return False
+
+    def copy(self):
+        """
+        Function to copy a DAGDepNode object.
+        Returns:
+            DAGDepNode: a copy of a DAGDepNode object.
+        """
+
+        dagdepnode = DAGDepNode()
+
+        dagdepnode.type = self.type
+        dagdepnode._op = self.op
+        dagdepnode.name = self.name
+        dagdepnode._qargs = self._qargs
+        dagdepnode.cargs = self.cargs
+        dagdepnode.node_id = self.node_id
+        dagdepnode.sort_key = self.sort_key
+        dagdepnode.successors = self.successors
+        dagdepnode.predecessors = self.predecessors
+        dagdepnode.reachable = self.reachable
+        dagdepnode.isblocked = self.isblocked
+        dagdepnode.successorstovisit = self.successorstovisit
+        dagdepnode.qindices = self.qindices
+        dagdepnode.cindices = self.cindices
+        dagdepnode.matchedwith = self.matchedwith.copy()
+
+        return dagdepnode

qiskit/dagcircuit/dagnode.py

@@ -0,0 +1,193 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019, 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.
+
+
+"""Objects to represent the information at a node in the DAGCircuit."""
+from __future__ import annotations
+
+import typing
+import uuid
+
+import qiskit._accelerate.circuit
+from qiskit.circuit import (
+    BoxOp,
+    Clbit,
+    ClassicalRegister,
+    IfElseOp,
+    WhileLoopOp,
+    SwitchCaseOp,
+    ForLoopOp,
+    Parameter,
+    QuantumCircuit,
+)
+from qiskit.circuit.classical import expr
+
+if typing.TYPE_CHECKING:
+    from qiskit.dagcircuit import DAGCircuit
+
+
+DAGNode = qiskit._accelerate.circuit.DAGNode
+DAGOpNode = qiskit._accelerate.circuit.DAGOpNode
+DAGInNode = qiskit._accelerate.circuit.DAGInNode
+DAGOutNode = qiskit._accelerate.circuit.DAGOutNode
+
+
+def _legacy_condition_eq(cond1, cond2, bit_indices1, bit_indices2) -> bool:
+    if cond1 is cond2 is None:
+        return True
+    elif None in (cond1, cond2):
+        return False
+    target1, val1 = cond1
+    target2, val2 = cond2
+    if val1 != val2:
+        return False
+    if isinstance(target1, Clbit) and isinstance(target2, Clbit):
+        return bit_indices1[target1] == bit_indices2[target2]
+    if isinstance(target1, ClassicalRegister) and isinstance(target2, ClassicalRegister):
+        return target1.size == target2.size and all(
+            bit_indices1[t1] == bit_indices2[t2] for t1, t2 in zip(target1, target2)
+        )
+    return False
+
+
+def _circuit_to_dag(circuit: QuantumCircuit, node_qargs, node_cargs, bit_indices) -> DAGCircuit:
+    """Get a :class:`.DAGCircuit` of the given :class:`.QuantumCircuit`.  The bits in the output
+    will be ordered in a canonical order based on their indices in the outer DAG, as defined by the
+    ``bit_indices`` mapping and the ``node_{q,c}args`` arguments."""
+    from qiskit.converters import circuit_to_dag  # pylint: disable=cyclic-import
+
+    def sort_key(bits):
+        outer, _inner = bits
+        return bit_indices[outer]
+
+    return circuit_to_dag(
+        circuit,
+        copy_operations=False,
+        qubit_order=[
+            inner for _outer, inner in sorted(zip(node_qargs, circuit.qubits), key=sort_key)
+        ],
+        clbit_order=[
+            inner for _outer, inner in sorted(zip(node_cargs, circuit.clbits), key=sort_key)
+        ],
+    )
+
+
+def _make_expr_key(bit_indices):
+    def key(var):
+        if isinstance(var, Clbit):
+            return bit_indices.get(var)
+        if isinstance(var, ClassicalRegister):
+            return [bit_indices.get(bit) for bit in var]
+        return None
+
+    return key
+
+
+def _condition_op_eq(node1, node2, bit_indices1, bit_indices2):
+    cond1 = None
+    cond2 = None
+    if node1.is_control_flow():
+        cond1 = node1.op.condition
+    if node2.is_control_flow():
+        cond2 = node2.op.condition
+    if isinstance(cond1, expr.Expr) and isinstance(cond2, expr.Expr):
+        if not expr.structurally_equivalent(
+            cond1, cond2, _make_expr_key(bit_indices1), _make_expr_key(bit_indices2)
+        ):
+            return False
+    elif isinstance(cond1, expr.Expr) or isinstance(cond2, expr.Expr):
+        return False
+    elif not _legacy_condition_eq(cond1, cond2, bit_indices1, bit_indices2):
+        return False
+    return len(node1.op.blocks) == len(node2.op.blocks) and all(
+        _circuit_to_dag(block1, node1.qargs, node1.cargs, bit_indices1)
+        == _circuit_to_dag(block2, node2.qargs, node2.cargs, bit_indices2)
+        for block1, block2 in zip(node1.op.blocks, node2.op.blocks)
+    )
+
+
+def _switch_case_eq(node1, node2, bit_indices1, bit_indices2):
+    target1 = node1.op.target
+    target2 = node2.op.target
+    if isinstance(target1, expr.Expr) and isinstance(target2, expr.Expr):
+        if not expr.structurally_equivalent(
+            target1, target2, _make_expr_key(bit_indices1), _make_expr_key(bit_indices2)
+        ):
+            return False
+    elif isinstance(target1, Clbit) and isinstance(target2, Clbit):
+        if bit_indices1[target1] != bit_indices2[target2]:
+            return False
+    elif isinstance(target1, ClassicalRegister) and isinstance(target2, ClassicalRegister):
+        if target1.size != target2.size or any(
+            bit_indices1[b1] != bit_indices2[b2] for b1, b2 in zip(target1, target2)
+        ):
+            return False
+    else:
+        return False
+    cases1 = [case for case, _ in node1.op.cases_specifier()]
+    cases2 = [case for case, _ in node2.op.cases_specifier()]
+    return (
+        len(cases1) == len(cases2)
+        and all(set(labels1) == set(labels2) for labels1, labels2 in zip(cases1, cases2))
+        and len(node1.op.blocks) == len(node2.op.blocks)
+        and all(
+            _circuit_to_dag(block1, node1.qargs, node1.cargs, bit_indices1)
+            == _circuit_to_dag(block2, node2.qargs, node2.cargs, bit_indices2)
+            for block1, block2 in zip(node1.op.blocks, node2.op.blocks)
+        )
+    )
+
+
+def _for_loop_eq(node1, node2, bit_indices1, bit_indices2):
+    indexset1, param1, body1 = node1.op.params
+    indexset2, param2, body2 = node2.op.params
+    if indexset1 != indexset2:
+        return False
+    if (param1 is None and param2 is not None) or (param1 is not None and param2 is None):
+        return False
+    if param1 is not None and param2 is not None:
+        sentinel = Parameter(str(uuid.uuid4()))
+        body1 = (
+            body1.assign_parameters({param1: sentinel}, inplace=False)
+            if param1 in body1.parameters
+            else body1
+        )
+        body2 = (
+            body2.assign_parameters({param2: sentinel}, inplace=False)
+            if param2 in body2.parameters
+            else body2
+        )
+    return _circuit_to_dag(body1, node1.qargs, node1.cargs, bit_indices1) == _circuit_to_dag(
+        body2, node2.qargs, node2.cargs, bit_indices2
+    )
+
+
+def _box_eq(node1, node2, bit_indices1, bit_indices2):
+    return (
+        (node1.op.duration == node2.op.duration)
+        and (
+            _circuit_to_dag(node1.op.blocks[0], node1.qargs, node1.cargs, bit_indices1)
+            == _circuit_to_dag(node2.op.blocks[0], node2.qargs, node2.cargs, bit_indices2)
+        )
+        and (node1.op.annotations == node2.op.annotations)
+    )
+
+
+_SEMANTIC_EQ_CONTROL_FLOW = {
+    IfElseOp: _condition_op_eq,
+    WhileLoopOp: _condition_op_eq,
+    SwitchCaseOp: _switch_case_eq,
+    ForLoopOp: _for_loop_eq,
+    BoxOp: _box_eq,
+}
+
+_SEMANTIC_EQ_SYMMETRIC = frozenset({"barrier", "swap", "break_loop", "continue_loop"})

qiskit/dagcircuit/exceptions.py

@@ -0,0 +1,42 @@
+# 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.
+
+"""
+Exception for errors raised by the DAGCircuit object.
+"""
+from qiskit.exceptions import QiskitError
+
+
+class DAGCircuitError(QiskitError):
+    """Base class for errors raised by the DAGCircuit object."""
+
+    def __init__(self, *msg):
+        """Set the error message."""
+        super().__init__(*msg)
+        self.msg = " ".join(msg)
+
+    def __str__(self):
+        """Return the message."""
+        return repr(self.msg)
+
+
+class DAGDependencyError(QiskitError):
+    """Base class for errors raised by the DAGDependency object."""
+
+    def __init__(self, *msg):
+        """Set the error message."""
+        super().__init__(*msg)
+        self.msg = " ".join(msg)
+
+    def __str__(self):
+        """Return the message."""
+        return repr(self.msg)

qiskit/exceptions.py

@@ -0,0 +1,153 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+===============================================
+Top-level exceptions (:mod:`qiskit.exceptions`)
+===============================================
+
+Exceptions
+==========
+
+All Qiskit-related exceptions raised by Qiskit are subclasses of the base:
+
+.. autoexception:: QiskitError
+
+.. note::
+
+    Errors that are just general programming errors, such as incorrect typing, may still raise
+    standard Python errors such as ``TypeError``.  :exc:`QiskitError` is generally for errors raised
+    in usage that is particular to Qiskit.
+
+Many of the Qiskit subpackages define their own more granular error, to help in catching only the
+subset of errors you care about.  For example, :mod:`qiskit.circuit` almost exclusively uses
+:exc:`.CircuitError`, while both :exc:`.QASM2ExportError` and :exc:`.QASM2ParseError` derive from
+:exc:`.QASM2Error` in :mod:`qiskit.qasm2`, which is in turn a type of :exc:`.QiskitError`.
+
+Qiskit has several optional features that depend on other packages that are not required for a
+minimal install.  You can read more about those, and ways to check for their presence, in
+:mod:`qiskit.utils.optionals`.  Trying to use a feature that requires an optional extra will raise a
+particular error, which subclasses both :exc:`QiskitError` and the Python built-in ``ImportError``.
+
+.. autoexception:: MissingOptionalLibraryError
+
+Two more uncommon errors relate to failures in reading user-configuration files, or specifying a
+filename that cannot be used:
+
+.. autoexception:: QiskitUserConfigError
+.. autoexception:: InvalidFileError
+
+
+Warnings
+========
+
+Some particular features of Qiskit may raise custom warnings.  In general, Qiskit will use built-in
+Python warnings (such as :exc:`DeprecationWarning`) when appropriate, but warnings related to
+Qiskit-specific functionality will be subtypes of :exc:`QiskitWarning`.
+
+.. autoexception:: QiskitWarning
+
+Related to :exc:`MissingOptionalLibraryError`, in some cases an optional dependency might be found,
+but fail to import for some other reason.  In this case, Qiskit will continue as if the dependency
+is not present, but will raise :exc:`OptionalDependencyImportWarning` to let you know about it.
+
+.. autoexception:: OptionalDependencyImportWarning
+
+When experimental features are being used, Qiskit will raise :exc:`ExperimentalWarning`.
+
+.. warning::
+
+    Qiskit experimental features can break at any minor release and their API might change without
+    previous notification. Their use is not recommended in production.
+
+.. autoexception:: ExperimentalWarning
+
+Filtering warnings
+------------------
+
+Python has built-in mechanisms to filter warnings, described in the documentation of the
+:mod:`warnings` module.  You can use these subclasses in your warning filters from within Python to
+silence warnings you are not interested in.  For example, if you are knowingly using experimental
+features and are comfortable that they make break in later versions, you can silence
+:exc:`ExperimentalWarning` like this::
+
+    import warnings
+    from qiskit.exceptions import ExperimentalWarning
+
+    warnings.filterwarnings("ignore", category=ExperimentalWarning)
+"""
+
+from typing import Optional
+
+
+class QiskitError(Exception):
+    """Base class for errors raised by Qiskit."""
+
+    def __init__(self, *message):
+        """Set the error message."""
+        super().__init__(" ".join(message))
+        self.message = " ".join(message)
+
+    def __str__(self):
+        """Return the message."""
+        return repr(self.message)
+
+
+class QiskitUserConfigError(QiskitError):
+    """Raised when an error is encountered reading a user config file."""
+
+    message = "User config invalid"
+
+
+class MissingOptionalLibraryError(QiskitError, ImportError):
+    """Raised when an optional library is missing."""
+
+    def __init__(
+        self, libname: str, name: str, pip_install: Optional[str] = None, msg: Optional[str] = None
+    ) -> None:
+        """Set the error message.
+        Args:
+            libname: Name of missing library
+            name: Name of class, function, module that uses this library
+            pip_install: pip install command, if any
+            msg: Descriptive message, if any
+        """
+        message = [f"The '{libname}' library is required to use '{name}'."]
+        if pip_install:
+            message.append(f"You can install it with '{pip_install}'.")
+        if msg:
+            message.append(f" {msg}.")
+
+        super().__init__(" ".join(message))
+        self.message = " ".join(message)
+
+    def __str__(self) -> str:
+        """Return the message."""
+        return repr(self.message)
+
+
+class InvalidFileError(QiskitError):
+    """Raised when the file provided is not valid for the specific task."""
+
+
+class QiskitWarning(UserWarning):
+    """Common subclass of warnings for Qiskit-specific warnings being raised."""
+
+
+class OptionalDependencyImportWarning(QiskitWarning):
+    """Raised when an optional library raises errors during its import."""
+
+    # Not a subclass of `ImportWarning` because those are hidden by default.
+
+
+class ExperimentalWarning(QiskitWarning):
+    """Raised when an experimental feature is being used."""