qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/dagcircuit/dagdepnode.py

@@ -0,0 +1,157 @@
+# 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 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=None,
+        predecessors=None,
+        reachable=None,
+        matchedwith=None,
+        successorstovisit=None,
+        isblocked=None,
+        qindices=None,
+        cindices=None,
+        nid=-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(self._qargs)
+        self.successors = successors if successors is not None else []
+        self.predecessors = predecessors if predecessors is not None else []
+        self.reachable = reachable
+        self.matchedwith = matchedwith if matchedwith is not None else []
+        self.isblocked = isblocked
+        self.successorstovisit = successorstovisit if successorstovisit is not None else []
+        self.qindices = qindices if qindices is not None else []
+        self.cindices = 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("The node %s is not an op node" % (str(self)))
+        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,322 @@
+# 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."""
+
+import itertools
+import uuid
+from typing import Iterable
+
+from qiskit.circuit import (
+    Qubit,
+    Clbit,
+    ClassicalRegister,
+    ControlFlowOp,
+    IfElseOp,
+    WhileLoopOp,
+    SwitchCaseOp,
+    ForLoopOp,
+    Parameter,
+)
+from qiskit.circuit.classical import expr
+
+
+def _legacy_condition_eq(cond1, cond2, bit_indices1, bit_indices2):
+    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, node_qargs, node_cargs, bit_indices):
+    """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 = node1.op.condition
+    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
+    )
+
+
+_SEMANTIC_EQ_CONTROL_FLOW = {
+    IfElseOp: _condition_op_eq,
+    WhileLoopOp: _condition_op_eq,
+    SwitchCaseOp: _switch_case_eq,
+    ForLoopOp: _for_loop_eq,
+}
+
+_SEMANTIC_EQ_SYMMETRIC = frozenset({"barrier", "swap", "break_loop", "continue_loop"})
+
+
+class DAGNode:
+    """Parent class for DAGOpNode, DAGInNode, and DAGOutNode."""
+
+    __slots__ = ["_node_id"]
+
+    def __init__(self, nid=-1):
+        """Create a node"""
+        self._node_id = nid
+
+    def __lt__(self, other):
+        return self._node_id < other._node_id
+
+    def __gt__(self, other):
+        return self._node_id > other._node_id
+
+    def __str__(self):
+        # TODO is this used anywhere other than in DAG drawing?
+        # needs to be unique as it is what pydot uses to distinguish nodes
+        return str(id(self))
+
+    @staticmethod
+    def semantic_eq(node1, node2, bit_indices1, bit_indices2):
+        """
+        Check if DAG nodes are considered equivalent, e.g., as a node_match for
+        :func:`rustworkx.is_isomorphic_node_match`.
+
+        Args:
+            node1 (DAGOpNode, DAGInNode, DAGOutNode): A node to compare.
+            node2 (DAGOpNode, DAGInNode, DAGOutNode): The other node to compare.
+            bit_indices1 (dict): Dictionary mapping Bit instances to their index
+                within the circuit containing node1
+            bit_indices2 (dict): Dictionary mapping Bit instances to their index
+                within the circuit containing node2
+
+        Return:
+            Bool: If node1 == node2
+        """
+        if not isinstance(node1, DAGOpNode) or not isinstance(node1, DAGOpNode):
+            return type(node1) is type(node2) and bit_indices1.get(node1.wire) == bit_indices2.get(
+                node2.wire
+            )
+        if isinstance(node1.op, ControlFlowOp) and isinstance(node2.op, ControlFlowOp):
+            # While control-flow operations aren't represented natively in the DAG, we have to do
+            # some unpleasant dispatching and very manual handling.  Once they have more first-class
+            # support we'll still be dispatching, but it'll look more appropriate (like the dispatch
+            # based on `DAGOpNode`/`DAGInNode`/`DAGOutNode` that already exists) and less like we're
+            # duplicating code from the `ControlFlowOp` classes.
+            if type(node1.op) is not type(node2.op):
+                return False
+            comparer = _SEMANTIC_EQ_CONTROL_FLOW.get(type(node1.op))
+            if comparer is None:  # pragma: no cover
+                raise RuntimeError(f"unhandled control-flow operation: {type(node1.op)}")
+            return comparer(node1, node2, bit_indices1, bit_indices2)
+
+        node1_qargs = [bit_indices1[qarg] for qarg in node1.qargs]
+        node1_cargs = [bit_indices1[carg] for carg in node1.cargs]
+
+        node2_qargs = [bit_indices2[qarg] for qarg in node2.qargs]
+        node2_cargs = [bit_indices2[carg] for carg in node2.cargs]
+
+        # For barriers, qarg order is not significant so compare as sets
+        if node1.op.name == node2.op.name and node1.name in _SEMANTIC_EQ_SYMMETRIC:
+            node1_qargs = set(node1_qargs)
+            node1_cargs = set(node1_cargs)
+            node2_qargs = set(node2_qargs)
+            node2_cargs = set(node2_cargs)
+
+        return (
+            node1_qargs == node2_qargs
+            and node1_cargs == node2_cargs
+            and _legacy_condition_eq(
+                getattr(node1.op, "condition", None),
+                getattr(node2.op, "condition", None),
+                bit_indices1,
+                bit_indices2,
+            )
+            and node1.op == node2.op
+        )
+
+
+class DAGOpNode(DAGNode):
+    """Object to represent an Instruction at a node in the DAGCircuit."""
+
+    __slots__ = ["op", "qargs", "cargs", "sort_key"]
+
+    def __init__(self, op, qargs: Iterable[Qubit] = (), cargs: Iterable[Clbit] = (), dag=None):
+        """Create an Instruction node"""
+        super().__init__()
+        self.op = op
+        self.qargs = tuple(qargs)
+        self.cargs = tuple(cargs)
+        if dag is not None:
+            cache_key = (self.qargs, self.cargs)
+            key = dag._key_cache.get(cache_key, None)
+            if key is not None:
+                self.sort_key = key
+            else:
+                self.sort_key = ",".join(
+                    f"{dag.find_bit(q).index:04d}" for q in itertools.chain(*cache_key)
+                )
+                dag._key_cache[cache_key] = self.sort_key
+        else:
+            self.sort_key = str(self.qargs)
+
+    @property
+    def name(self):
+        """Returns the Instruction name corresponding to the op for this node"""
+        return self.op.name
+
+    @name.setter
+    def name(self, new_name):
+        """Sets the Instruction name corresponding to the op for this node"""
+        self.op.name = new_name
+
+    def __repr__(self):
+        """Returns a representation of the DAGOpNode"""
+        return f"DAGOpNode(op={self.op}, qargs={self.qargs}, cargs={self.cargs})"
+
+
+class DAGInNode(DAGNode):
+    """Object to represent an incoming wire node in the DAGCircuit."""
+
+    __slots__ = ["wire", "sort_key"]
+
+    def __init__(self, wire):
+        """Create an incoming node"""
+        super().__init__()
+        self.wire = wire
+        # TODO sort_key which is used in dagcircuit.topological_nodes
+        # only works as str([]) for DAGInNodes. Need to figure out why.
+        self.sort_key = str([])
+
+    def __repr__(self):
+        """Returns a representation of the DAGInNode"""
+        return f"DAGInNode(wire={self.wire})"
+
+
+class DAGOutNode(DAGNode):
+    """Object to represent an outgoing wire node in the DAGCircuit."""
+
+    __slots__ = ["wire", "sort_key"]
+
+    def __init__(self, wire):
+        """Create an outgoing node"""
+        super().__init__()
+        self.wire = wire
+        # TODO sort_key which is used in dagcircuit.topological_nodes
+        # only works as str([]) for DAGOutNodes. Need to figure out why.
+        self.sort_key = str([])
+
+    def __repr__(self):
+        """Returns a representation of the DAGOutNode"""
+        return f"DAGOutNode(wire={self.wire})"

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,97 @@
+# 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`)
+===============================================
+
+All Qiskit-related errors 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
+"""
+
+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."""