adding optional conversion data when converting to DAGDependency_V2

Author: alexanderivrii

qiskit/converters/circuit_conversion_data.py

@@ -17,8 +17,8 @@ class CircuitConversionData:
     """Conversion data when switching between different circuit formats."""
 
     def __init__(self):
-        self._fwd_map = dict()
-        self._bwd_map = dict()
+        self._fwd_map = {}
+        self._bwd_map = {}
 
     def store_mapping(self, from_node, to_node):
         """Stores that ``from_node`` is mapped to ``to_node``."""

qiskit/converters/dag_to_dagdependency.py

@@ -11,8 +11,8 @@
 # that they have been altered from the originals.
 
 """Helper function for converting a dag circuit to a dag dependency"""
-from .circuit_conversion_data import CircuitConversionData
 from qiskit.dagcircuit.dagdependency import DAGDependency
+from .circuit_conversion_data import CircuitConversionData
 
 
 def dag_to_dagdependency_with_data(
@@ -78,7 +78,7 @@ def dag_to_dagdependency(dag, create_preds_and_succs=True):
     Return:
         DAGDependency: the DAG representing the input circuit as a dag dependency.
     """
-    dagdependency, conversion_data = dag_to_dagdependency_with_data(
+    dagdependency, _ = dag_to_dagdependency_with_data(
         dag, create_preds_and_succs=create_preds_and_succs
     )
     return dagdependency

qiskit/converters/dag_to_dagdependency_v2.py

@@ -12,17 +12,26 @@
 
 """Helper function for converting a dag circuit to a dag dependency"""
 from qiskit.dagcircuit.dagdependency_v2 import _DAGDependencyV2
+from .circuit_conversion_data import CircuitConversionData
 
 
-def _dag_to_dagdependency_v2(dag):
+def _dag_to_dagdependency_v2_with_data(dag, *, create_conversion_data=False):
     """Build a ``_DAGDependencyV2`` object from a ``DAGCircuit``.
 
     Args:
         dag (DAGCircuit): the input dag.
+        create_conversion_data (bool): whether to construct mappings
+            between nodes in the input and the output circuits.
 
     Return:
         _DAGDependencyV2: the DAG representing the input circuit as a dag dependency.
+        CircuitConversionData: data storing mappings between nodes
+            in the input and the output circuits when ``create_conversion_data``
+            is ``True``, and ``None`` otherwise.
+
     """
+    conversion_data = CircuitConversionData() if create_conversion_data else None
+
     dagdependency = _DAGDependencyV2()
     dagdependency.name = dag.name
     dagdependency.metadata = dag.metadata
@@ -38,7 +47,24 @@ def _dag_to_dagdependency_v2(dag):
     for register in dag.cregs.values():
         dagdependency.add_creg(register)
 
-    for node in dag.topological_op_nodes():
-        dagdependency.apply_operation_back(node.op.copy(), node.qargs, node.cargs)
+    for in_node in dag.topological_op_nodes():
+        out_node = dagdependency.apply_operation_back(
+            in_node.op.copy(), in_node.qargs, in_node.cargs
+        )
+        if create_conversion_data:
+            conversion_data.store_mapping(in_node, out_node)
+
+    return dagdependency, conversion_data
+
+
+def _dag_to_dagdependency_v2(dag):
+    """Build a ``_DAGDependencyV2`` object from a ``DAGCircuit``.
+
+    Args:
+        dag (DAGCircuit): the input dag.
 
+    Return:
+        _DAGDependencyV2: the DAG representing the input circuit as a dag dependency.
+    """
+    dagdependency, _ = _dag_to_dagdependency_v2_with_data(dag)
     return dagdependency

qiskit/dagcircuit/dagdependency_v2.py

@@ -339,6 +339,9 @@ def apply_operation_back(self, operation, qargs=(), cargs=()):
             operation (qiskit.circuit.Operation): operation as a quantum gate
             qargs (list[~qiskit.circuit.Qubit]): list of qubits on which the operation acts
             cargs (list[Clbit]): list of classical wires to attach to
+
+        Returns:
+            DAGOpNode: the newly appended node
         """
         new_node = DAGOpNode(
             op=operation,
@@ -349,6 +352,7 @@ def apply_operation_back(self, operation, qargs=(), cargs=()):
         new_node._node_id = self._multi_graph.add_node(new_node)
         self._update_edges()
         self._increment_op(new_node.op)
+        return new_node
 
     def _update_edges(self):
         """

test/python/converters/test_dag_to_dagdependency.py

@@ -84,10 +84,8 @@ def test_metadata(self):
         dag_out = dagdependency_to_dag(dag_dependency)
         self.assertEqual(dag_out.metadata, meta_dict)
 
-    def test_conversion_data(self):
-        """Test that conversion data is created and is correct when
-        ``create_conversion_data`` is ``True``.
-        """
+    def test_conversion_data_not_created_by_default(self):
+        """Test that conversion data is not created by default."""
         qr = QuantumRegister(3)
         cr = ClassicalRegister(3)
         circuit_in = QuantumCircuit(qr, cr)
@@ -101,20 +99,13 @@ def test_conversion_data(self):
         circuit_in.measure(qr[2], cr[2])
         dag_in = circuit_to_dag(circuit_in)
 
-        dag_dependency, conversion_data = dag_to_dagdependency_with_data(
-            dag_in, create_conversion_data=True
-        )
-        self.assertIsNotNone(conversion_data)
-
-        # Check that mapping an op_node first forward and then backward gives back the same node.
-        for in_node in dag_in.op_nodes():
-            out_node = conversion_data.forward_map(in_node)
-            self.assertIsNotNone(out_node)
-            in_out_node = conversion_data.backward_map(out_node)
-            self.assertEqual(in_node, in_out_node)
+        _, conversion_data = dag_to_dagdependency_with_data(dag_in)
+        self.assertIsNone(conversion_data)
 
-    def test_conversion_data_not_created_by_default(self):
-        """Test that conversion data is not created by default."""
+    def test_conversion_data(self):
+        """Test that conversion data is created and is correct when
+        ``create_conversion_data`` is ``True``.
+        """
         qr = QuantumRegister(3)
         cr = ClassicalRegister(3)
         circuit_in = QuantumCircuit(qr, cr)
@@ -128,8 +119,15 @@ def test_conversion_data_not_created_by_default(self):
         circuit_in.measure(qr[2], cr[2])
         dag_in = circuit_to_dag(circuit_in)
 
-        dag_dependency, conversion_data = dag_to_dagdependency_with_data(dag_in)
-        self.assertIsNone(conversion_data)
+        _, conversion_data = dag_to_dagdependency_with_data(dag_in, create_conversion_data=True)
+        self.assertIsNotNone(conversion_data)
+
+        # Check that mapping an op_node first forward and then backward gives back the same node.
+        for in_node in dag_in.op_nodes():
+            out_node = conversion_data.forward_map(in_node)
+            self.assertIsNotNone(out_node)
+            in_out_node = conversion_data.backward_map(out_node)
+            self.assertEqual(in_node, in_out_node)
 
 
 if __name__ == "__main__":

test/python/converters/test_dag_to_dagdependency_v2.py

@@ -16,7 +16,10 @@
 import unittest
 
 from qiskit.converters.circuit_to_dag import circuit_to_dag
-from qiskit.converters.dag_to_dagdependency_v2 import _dag_to_dagdependency_v2
+from qiskit.converters.dag_to_dagdependency_v2 import (
+    _dag_to_dagdependency_v2,
+    _dag_to_dagdependency_v2_with_data,
+)
 from qiskit.converters.dagdependency_to_dag import dagdependency_to_dag
 from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
 from test import QiskitTestCase  # pylint: disable=wrong-import-order
@@ -60,6 +63,51 @@ def test_metadata(self):
         dag_out = dagdependency_to_dag(dag_dependency)
         self.assertEqual(dag_out.metadata, meta_dict)
 
+    def test_conversion_data_not_created_by_default(self):
+        """Test that conversion data is not created by default."""
+        qr = QuantumRegister(3)
+        cr = ClassicalRegister(3)
+        circuit_in = QuantumCircuit(qr, cr)
+        circuit_in.h(qr[0])
+        circuit_in.h(qr[1])
+        circuit_in.measure(qr[0], cr[0])
+        circuit_in.measure(qr[1], cr[1])
+        circuit_in.x(qr[0]).c_if(cr, 0x3)
+        circuit_in.measure(qr[0], cr[0])
+        circuit_in.measure(qr[1], cr[1])
+        circuit_in.measure(qr[2], cr[2])
+        dag_in = circuit_to_dag(circuit_in)
+
+        _, conversion_data = _dag_to_dagdependency_v2_with_data(dag_in)
+        self.assertIsNone(conversion_data)
+
+    def test_conversion_data(self):
+        """Test that conversion data is created and is correct when
+        ``create_conversion_data`` is ``True``.
+        """
+        qr = QuantumRegister(3)
+        cr = ClassicalRegister(3)
+        circuit_in = QuantumCircuit(qr, cr)
+        circuit_in.h(qr[0])
+        circuit_in.h(qr[1])
+        circuit_in.measure(qr[0], cr[0])
+        circuit_in.measure(qr[1], cr[1])
+        circuit_in.x(qr[0]).c_if(cr, 0x3)
+        circuit_in.measure(qr[0], cr[0])
+        circuit_in.measure(qr[1], cr[1])
+        circuit_in.measure(qr[2], cr[2])
+        dag_in = circuit_to_dag(circuit_in)
+
+        _, conversion_data = _dag_to_dagdependency_v2_with_data(dag_in, create_conversion_data=True)
+        self.assertIsNotNone(conversion_data)
+
+        # Check that mapping an op_node first forward and then backward gives back the same node.
+        for in_node in dag_in.op_nodes():
+            out_node = conversion_data.forward_map(in_node)
+            self.assertIsNotNone(out_node)
+            in_out_node = conversion_data.backward_map(out_node)
+            self.assertEqual(in_node, in_out_node)
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2)