Replace DAGNode class with OpNode, InNode, and OutNode classes

qiskit/dagcircuit/__init__.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017.
+# (C) Copyright IBM 2017, 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
@@ -24,7 +24,9 @@
    :toctree: ../stubs/
 
    DAGCircuit
-   DAGNode
+   OpNode
+   InNode
+   OutNode
    DAGDepNode
    DAGDependency
 
@@ -37,7 +39,7 @@
    DAGCircuitError
 """
 from .dagcircuit import DAGCircuit
-from .dagnode import DAGNode
+from .dagnode import OpNode, InNode, OutNode
 from .dagdepnode import DAGDepNode
 from .exceptions import DAGCircuitError
 from .dagdependency import DAGDependency

qiskit/dagcircuit/dagnode.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2017, 2019.
+# (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
@@ -12,16 +12,146 @@
 
 # pylint: disable=redefined-builtin
 
-"""Object to represent the information at a node in the DAGCircuit."""
+"""Objects to represent the information at a node in the DAGCircuit."""
 
 import warnings
 
 from qiskit.exceptions import QiskitError
 
 
+class DAGNodeP:
+    """Parent class for OpNode, InNode, and OutNode used by DAGCircuit."""
+
+    __slots__ = ["_qargs", "cargs", "sort_key", "_node_id"]
+
+    def __init__(self, qargs=None, cargs=None, nid=-1):
+        """Create a node"""
+        self._qargs = qargs if qargs is not None else []
+        self.cargs = cargs if cargs is not None else []
+        self.sort_key = str(self._qargs)
+        self._node_id = nid
+
+    @property
+    def qargs(self):
+        """Returns list of Qubit, else an empty list."""
+        return self._qargs
+
+    @qargs.setter
+    def qargs(self, new_qargs):
+        """Sets qargs to be the new list of qargs and updates sort_key."""
+        self._qargs = new_qargs
+        self.sort_key = str(new_qargs)
+
+    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=None, bit_indices2=None):
+        """
+        Check if DAG nodes are considered equivalent, e.g., as a node_match for nx.is_isomorphic.
+
+        Args:
+            node1 (OpNode, InNode, or OutNode): A node to compare.
+            node2 (OpNode, InNode, or OutNode): 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 bit_indices1 is None or bit_indices2 is None:
+            warnings.warn(
+                "DAGNodeP.semantic_eq now expects two bit-to-circuit index "
+                "mappings as arguments. To ease the transition, these will be "
+                "pre-populated based on the values found in Bit.index and "
+                "Bit.register. However, this behavior is deprecated and a future "
+                "release will require the mappings to be provided as arguments.",
+                DeprecationWarning,
+            )
+
+            bit_indices1 = {arg: arg for arg in node1.qargs + node1.cargs}
+            bit_indices2 = {arg: arg for arg in node2.qargs + node2.cargs}
+
+        if isinstance(node1, OpNode) and isinstance(node2, OpNode):
+            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 "barrier" == node1.op.name == node2.op.name:
+                return set(node1_qargs) == set(node2_qargs)
+
+            if node1.op.name == node2.op.name:
+                if node1_qargs == node2_qargs:
+                    if node1_cargs == node2_cargs:
+                        if node1.op.condition == node2.op.condition:
+                            return True
+        elif (isinstance(node1, InNode) and isinstance(node2, InNode)) or (
+            isinstance(node1, OutNode) and isinstance(node2, OutNode)
+        ):
+            if bit_indices1.get(node1.wire, None) == bit_indices2.get(node2.wire, None):
+                return True
+        else:
+            return False
+
+
+class OpNode(DAGNodeP):
+    """Object to represent an Instruction at a node in the DAGCircuit."""
+
+    __slots__ = ["op"]
+
+    def __init__(self, op, qargs=None, cargs=None):
+        """Create an Instruction node"""
+        self.op = op
+        super().__init__(qargs, cargs)
+
+    @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
+
+
+class InNode(DAGNodeP):
+    """Object to represent an incoming wire node in the DAGCircuit."""
+
+    __slots__ = ["wire"]
+
+    def __init__(self, wire):
+        """Create an incoming node"""
+        self.wire = wire
+        super().__init__()
+
+
+class OutNode(DAGNodeP):
+    """Object to represent an outgoing wire node in the DAGCircuit."""
+
+    __slots__ = ["wire"]
+
+    def __init__(self, wire):
+        """Create an outgoing node"""
+        self.wire = wire
+        super().__init__()
+
+
 class DAGNode:
     """Object to represent the information at a node in the DAGCircuit.
-
     It is used as the return value from `*_nodes()` functions and can
     be supplied to functions that take a node.
     """
@@ -66,6 +196,7 @@ def name(self):
 
     @name.setter
     def name(self, name):
+        """Sets the Instruction name corresponding to the op for this node"""
         if self.type and self.type == "op":
             self._op.name = name
 
@@ -138,15 +269,13 @@ def __str__(self):
     def semantic_eq(node1, node2, bit_indices1=None, bit_indices2=None):
         """
         Check if DAG nodes are considered equivalent, e.g., as a node_match for nx.is_isomorphic.
-
         Args:
             node1 (DAGNode): A node to compare.
             node2 (DAGNode): 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
         """

qiskit/transpiler/passes/analysis/dag_longest_path.py

@@ -16,7 +16,7 @@
 
 
 class DAGLongestPath(AnalysisPass):
-    """Return the longest path in a DAGcircuit as a list of DAGNodes."""
+    """Return the longest path in a DAGcircuit as a list of OpNodes, InNodes, and OutNodes."""
 
     def run(self, dag):
         """Run the DAGLongestPath pass on `dag`."""

qiskit/transpiler/passes/layout/apply_layout.py

@@ -13,7 +13,7 @@
 """Transform a circuit with virtual qubits into a circuit with physical qubits."""
 
 from qiskit.circuit import QuantumRegister
-from qiskit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit import DAGCircuit, OpNode
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.exceptions import TranspilerError
 
@@ -59,7 +59,7 @@ def run(self, dag):
         for creg in dag.cregs.values():
             new_dag.add_creg(creg)
         for node in dag.topological_op_nodes():
-            if node.type == "op":
+            if isinstance(node, OpNode):
                 qargs = [q[layout[qarg]] for qarg in node.qargs]
                 new_dag.apply_operation_back(node.op, qargs, node.cargs)
         new_dag._global_phase = dag._global_phase

qiskit/transpiler/passes/optimization/collect_2q_blocks.py

@@ -15,6 +15,7 @@
 from collections import defaultdict
 
 from qiskit.circuit import Gate
+from qiskit.dagcircuit import OpNode
 from qiskit.transpiler.basepasses import AnalysisPass
 
 
@@ -57,12 +58,12 @@ def run(self, dag):
             group = []
             # Explore predecessors and successors of 2q gates
             if (  # pylint: disable=too-many-boolean-expressions
-                nd.type == "op"
-                and isinstance(nd._op, Gate)
+                isinstance(nd, OpNode)
+                and isinstance(nd.op, Gate)
                 and len(nd._qargs) == 2
                 and not nodes_seen[nd]
-                and nd._op.condition is None
-                and not nd._op.is_parameterized()
+                and nd.op.condition is None
+                and not nd.op.is_parameterized()
             ):
                 these_qubits = set(nd._qargs)
                 # Explore predecessors of the 2q node
@@ -74,11 +75,11 @@ def run(self, dag):
                     if len(pred) == 1 and not nodes_seen[pred[0]]:
                         pnd = pred[0]
                         if (
-                            pnd.type == "op"
-                            and isinstance(pnd._op, Gate)
+                            isinstance(pnd, OpNode)
+                            and isinstance(pnd.op, Gate)
                             and len(pnd._qargs) <= 2
-                            and pnd._op.condition is None
-                            and not pnd._op.is_parameterized()
+                            and pnd.op.condition is None
+                            and not pnd.op.is_parameterized()
                         ):
                             if (len(pnd._qargs) == 2 and set(pnd._qargs) == these_qubits) or len(
                                 pnd._qargs
@@ -112,18 +113,18 @@ def run(self, dag):
                         # Examine each predecessor
                         for pnd in sorted_pred:
                             if (
-                                pnd.type != "op"
-                                or not isinstance(pnd._op, Gate)
+                                not isinstance(pnd, OpNode)
+                                or not isinstance(pnd.op, Gate)
                                 or len(pnd._qargs) > 2
-                                or pnd._op.condition is not None
-                                or pnd._op.is_parameterized()
+                                or pnd.op.condition is not None
+                                or pnd.op.is_parameterized()
                             ):
                                 # remove any qubits that are interrupted by a gate
                                 # e.g. a measure in the middle of the circuit
                                 these_qubits = list(set(these_qubits) - set(pnd._qargs))
                                 continue
                             # If a predecessor is a single qubit gate, add it
-                            if len(pnd._qargs) == 1 and not pnd._op.is_parameterized():
+                            if len(pnd._qargs) == 1 and not pnd.op.is_parameterized():
                                 if not nodes_seen[pnd]:
                                     group.append(pnd)
                                     nodes_seen[pnd] = True
@@ -133,8 +134,8 @@ def run(self, dag):
                                 pred_qubits = set(pnd._qargs)
                                 if (
                                     pred_qubits == these_qubits
-                                    and pnd._op.condition is None
-                                    and not pnd._op.is_parameterized()
+                                    and pnd.op.condition is None
+                                    and not pnd.op.is_parameterized()
                                 ):
                                     # add if on same qubits
                                     if not nodes_seen[pnd]:
@@ -164,11 +165,11 @@ def run(self, dag):
                     if len(succ) == 1 and not nodes_seen[succ[0]]:
                         snd = succ[0]
                         if (
-                            snd.type == "op"
-                            and isinstance(snd._op, Gate)
+                            isinstance(snd, OpNode)
+                            and isinstance(snd.op, Gate)
                             and len(snd._qargs) <= 2
-                            and snd._op.condition is None
-                            and not snd._op.is_parameterized()
+                            and snd.op.condition is None
+                            and not snd.op.is_parameterized()
                         ):
                             if (len(snd._qargs) == 2 and set(snd._qargs) == these_qubits) or len(
                                 snd._qargs
@@ -202,11 +203,11 @@ def run(self, dag):
                         # Examine each successor
                         for snd in sorted_succ:
                             if (
-                                snd.type != "op"
-                                or not isinstance(snd._op, Gate)
+                                not isinstance(snd, OpNode)
+                                or not isinstance(snd.op, Gate)
                                 or len(snd._qargs) > 2
-                                or snd._op.condition is not None
-                                or snd._op.is_parameterized()
+                                or snd.op.condition is not None
+                                or snd.op.is_parameterized()
                             ):
                                 # remove qubits from consideration if interrupted
                                 # by a gate e.g. a measure in the middle of the circuit
@@ -216,7 +217,7 @@ def run(self, dag):
                             # If a successor is a single qubit gate, add it
                             # NB as we have eliminated all gates with names not in
                             # good_names, this check guarantees they are single qubit
-                            if len(snd._qargs) == 1 and not snd._op.is_parameterized():
+                            if len(snd._qargs) == 1 and not snd.op.is_parameterized():
                                 if not nodes_seen[snd]:
                                     group.append(snd)
                                     nodes_seen[snd] = True
@@ -226,8 +227,8 @@ def run(self, dag):
                                 succ_qubits = set(snd._qargs)
                                 if (
                                     succ_qubits == these_qubits
-                                    and snd._op.condition is None
-                                    and not snd._op.is_parameterized()
+                                    and snd.op.condition is None
+                                    and not snd.op.is_parameterized()
                                 ):
                                     # add if on same qubits
                                     if not nodes_seen[snd]:

qiskit/transpiler/passes/optimization/commutation_analysis.py

@@ -17,6 +17,7 @@
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.quantum_info.operators import Operator
+from qiskit.dagcircuit import OpNode
 
 _CUTOFF_PRECISION = 1e-10
 
@@ -88,7 +89,7 @@ def run(self, dag):
 
 def _commute(node1, node2, cache):
 
-    if node1.type != "op" or node2.type != "op":
+    if not isinstance(node1, OpNode) or not isinstance(node2, OpNode):
         return False
 
     for nd in [node1, node2]:

qiskit/transpiler/passes/optimization/commutative_cancellation.py

@@ -19,7 +19,7 @@
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passes.optimization.commutation_analysis import CommutationAnalysis
-from qiskit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit import DAGCircuit, InNode, OutNode
 from qiskit.circuit.library.standard_gates.u1 import U1Gate
 from qiskit.circuit.library.standard_gates.rx import RXGate
 from qiskit.circuit.library.standard_gates.p import PhaseGate
@@ -97,7 +97,7 @@ def run(self, dag):
             wire_commutation_set = self.property_set["commutation_set"][wire]
 
             for com_set_idx, com_set in enumerate(wire_commutation_set):
-                if com_set[0].type in ["in", "out"]:
+                if isinstance(com_set[0], (InNode, OutNode)):
                     continue
                 for node in com_set:
                     num_qargs = len(node.qargs)