Use retworkx

.pylintrc

@@ -298,7 +298,7 @@ ignore-mixin-members=yes
 # (useful for modules/projects where namespaces are manipulated during runtime
 # and thus existing member attributes cannot be deduced by static analysis. It
 # supports qualified module names, as well as Unix pattern matching.
-ignored-modules=matplotlib.cm,numpy.random
+ignored-modules=matplotlib.cm,numpy.random,retworkx
 
 # List of class names for which member attributes should not be checked (useful
 # for classes with dynamically set attributes). This supports the use of

qiskit/transpiler/passes/utils/merge_adjacent_barriers.py

@@ -113,7 +113,7 @@ def _collect_potential_merges(dag, barriers):
         for next_barrier in barriers[1:]:
 
             # Ensure barriers are adjacent before checking if they are mergeable.
-            if dag._multi_graph.has_edge(end_of_barrier, next_barrier):
+            if dag._multi_graph.has_edge(end_of_barrier._node_id, next_barrier._node_id):
 
                 # Remove all barriers that have already been included in this new barrier from the
                 # set of ancestors/descendants as they will be removed from the new DAG when it is

requirements.txt

@@ -3,6 +3,7 @@ marshmallow>=3,<4
 marshmallow_polyfield>=5.7,<6
 networkx>=2.2;python_version>'3.5'
 networkx>=2.2,<2.4;python_version=='3.5'
+retworkx>=0.3.0
 numpy>=1.13
 ply>=3.10
 psutil>=5

setup.py

@@ -31,6 +31,7 @@
     "networkx>=2.2;python_version>'3.5'",
     # Networkx 2.4 is the final version with python 3.5 support.
     "networkx>=2.2,<2.4;python_version=='3.5'",
+    "retworkx>=0.3.0",
     "numpy>=1.13",
     "ply>=3.10",
     "psutil>=5",

test/python/test_dagcircuit.py

@@ -18,7 +18,7 @@
 
 from ddt import ddt, data
 
-import networkx as nx
+import retworkx as nx
 
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.circuit import QuantumRegister
@@ -72,8 +72,8 @@ def raise_if_dagcircuit_invalid(dag):
 
     # Every edge should be labled with a known wire.
     edges_outside_wires = [edge_data['wire']
-                           for source, dest, edge_data
-                           in multi_graph.edges(data=True)
+                           for edge_data
+                           in multi_graph.edges()
                            if edge_data['wire'] not in dag.wires]
     if edges_outside_wires:
         raise DAGCircuitError('multi_graph contains one or more edges ({}) '
@@ -94,23 +94,22 @@ def raise_if_dagcircuit_invalid(dag):
     for wire in dag.wires:
         cur_node = dag.input_map[wire]
         out_node = dag.output_map[wire]
-
         while cur_node != out_node:
-            out_edges = multi_graph.out_edges(cur_node, data=True)
+            out_edges = multi_graph.out_edges(cur_node._node_id)
             edges_to_follow = [(src, dest, data) for (src, dest, data) in out_edges
                                if data['wire'] == wire]
 
             assert len(edges_to_follow) == 1
-            cur_node = edges_to_follow[0][1]
+            cur_node = dag._id_to_node[edges_to_follow[0][1]]
 
     # Wires can only terminate at input/output nodes.
     for op_node in dag.op_nodes():
-        assert multi_graph.in_degree(op_node) == multi_graph.out_degree(op_node)
+        assert multi_graph.in_degree(op_node._node_id) == multi_graph.out_degree(op_node._node_id)
 
     # Node input/output edges should match node qarg/carg/condition.
     for node in dag.op_nodes():
-        in_edges = multi_graph.in_edges(node, data=True)
-        out_edges = multi_graph.out_edges(node, data=True)
+        in_edges = multi_graph.in_edges(node._node_id)
+        out_edges = multi_graph.out_edges(node._node_id)
 
         in_wires = {data['wire'] for src, dest, data in in_edges}
         out_wires = {data['wire'] for src, dest, data in out_edges}
@@ -219,24 +218,24 @@ def test_apply_operation_back_conditional(self):
         self.assertEqual(h_node.condition, h_gate.condition)
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(h_node, data=True)),
+            sorted(self.dag._multi_graph.in_edges(h_node._node_id)),
             sorted([
-                (self.dag.input_map[self.qubit2], h_node,
+                (self.dag.input_map[self.qubit2]._node_id, h_node._node_id,
                  {'wire': self.qubit2, 'name': 'qr[2]'}),
-                (self.dag.input_map[self.clbit0], h_node,
+                (self.dag.input_map[self.clbit0]._node_id, h_node._node_id,
                  {'wire': self.clbit0, 'name': 'cr[0]'}),
-                (self.dag.input_map[self.clbit1], h_node,
+                (self.dag.input_map[self.clbit1]._node_id, h_node._node_id,
                  {'wire': self.clbit1, 'name': 'cr[1]'}),
             ]))
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(h_node, data=True)),
+            sorted(self.dag._multi_graph.out_edges(h_node._node_id)),
             sorted([
-                (h_node, self.dag.output_map[self.qubit2],
+                (h_node._node_id, self.dag.output_map[self.qubit2]._node_id,
                  {'wire': self.qubit2, 'name': 'qr[2]'}),
-                (h_node, self.dag.output_map[self.clbit0],
+                (h_node._node_id, self.dag.output_map[self.clbit0]._node_id,
                  {'wire': self.clbit0, 'name': 'cr[0]'}),
-                (h_node, self.dag.output_map[self.clbit1],
+                (h_node._node_id, self.dag.output_map[self.clbit1]._node_id,
                  {'wire': self.clbit1, 'name': 'cr[1]'}),
             ]))
 
@@ -261,24 +260,24 @@ def test_apply_operation_back_conditional_measure(self):
         self.assertEqual(meas_node.condition, meas_gate.condition)
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(meas_node, data=True)),
+            sorted(self.dag._multi_graph.in_edges(meas_node._node_id)),
             sorted([
-                (self.dag.input_map[self.qubit0], meas_node,
+                (self.dag.input_map[self.qubit0]._node_id, meas_node._node_id,
                  {'wire': self.qubit0, 'name': 'qr[0]'}),
-                (self.dag.input_map[self.clbit0], meas_node,
+                (self.dag.input_map[self.clbit0]._node_id, meas_node._node_id,
                  {'wire': self.clbit0, 'name': 'cr[0]'}),
-                (self.dag.input_map[new_creg[0]], meas_node,
+                (self.dag.input_map[new_creg[0]]._node_id, meas_node._node_id,
                  {'wire': Clbit(new_creg, 0), 'name': 'cr2[0]'}),
             ]))
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(meas_node, data=True)),
+            sorted(self.dag._multi_graph.out_edges(meas_node._node_id)),
             sorted([
-                (meas_node, self.dag.output_map[self.qubit0],
+                (meas_node._node_id, self.dag.output_map[self.qubit0]._node_id,
                  {'wire': self.qubit0, 'name': 'qr[0]'}),
-                (meas_node, self.dag.output_map[self.clbit0],
+                (meas_node._node_id, self.dag.output_map[self.clbit0]._node_id,
                  {'wire': self.clbit0, 'name': 'cr[0]'}),
-                (meas_node, self.dag.output_map[new_creg[0]],
+                (meas_node._node_id, self.dag.output_map[new_creg[0]]._node_id,
                  {'wire': Clbit(new_creg, 0), 'name': 'cr2[0]'}),
             ]))
 
@@ -300,24 +299,24 @@ def test_apply_operation_back_conditional_measure_to_self(self):
         self.assertEqual(meas_node.condition, meas_gate.condition)
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.in_edges(meas_node, data=True)),
+            sorted(self.dag._multi_graph.in_edges(meas_node._node_id)),
             sorted([
-                (self.dag.input_map[self.qubit1], meas_node,
+                (self.dag.input_map[self.qubit1]._node_id, meas_node._node_id,
                  {'wire': self.qubit1, 'name': 'qr[1]'}),
-                (self.dag.input_map[self.clbit0], meas_node,
+                (self.dag.input_map[self.clbit0]._node_id, meas_node._node_id,
                  {'wire': self.clbit0, 'name': 'cr[0]'}),
-                (self.dag.input_map[self.clbit1], meas_node,
+                (self.dag.input_map[self.clbit1]._node_id, meas_node._node_id,
                  {'wire': self.clbit1, 'name': 'cr[1]'}),
             ]))
 
         self.assertEqual(
-            sorted(self.dag._multi_graph.out_edges(meas_node, data=True)),
+            sorted(self.dag._multi_graph.out_edges(meas_node._node_id)),
             sorted([
-                (meas_node, self.dag.output_map[self.qubit1],
+                (meas_node._node_id, self.dag.output_map[self.qubit1]._node_id,
                  {'wire': self.qubit1, 'name': 'qr[1]'}),
-                (meas_node, self.dag.output_map[self.clbit0],
+                (meas_node._node_id, self.dag.output_map[self.clbit0]._node_id,
                  {'wire': self.clbit0, 'name': 'cr[0]'}),
-                (meas_node, self.dag.output_map[self.clbit1],
+                (meas_node._node_id, self.dag.output_map[self.clbit1]._node_id,
                  {'wire': self.clbit1, 'name': 'cr[1]'}),
             ]))
 
@@ -476,7 +475,8 @@ def test_topological_nodes(self):
                     ('cr[0]', []),
                     ('cr[1]', []),
                     ('cr[1]', [])]
-        self.assertEqual(expected, [(i.name, i.qargs) for i in named_nodes])
+        result = [(i.name, i.qargs) for i in named_nodes]
+        self.assertEqual(expected, result)
 
     def test_topological_op_nodes(self):
         """The topological_op_nodes() method"""
@@ -501,12 +501,12 @@ def test_dag_nodes_on_wire(self):
         self.dag.apply_operation_back(HGate(), [self.qubit0], [])
 
         qbit = self.dag.qubits()[0]
-        self.assertEqual([1, 11, 12, 2], [i._node_id for i in self.dag.nodes_on_wire(qbit)])
-        self.assertEqual([11, 12],
+        self.assertEqual([0, 10, 11, 1], [i._node_id for i in self.dag.nodes_on_wire(qbit)])
+        self.assertEqual([10, 11],
                          [i._node_id for i in self.dag.nodes_on_wire(qbit, only_ops=True)])
 
         cbit = self.dag.clbits()[0]
-        self.assertEqual([7, 8], [i._node_id for i in self.dag.nodes_on_wire(cbit)])
+        self.assertEqual([6, 7], [i._node_id for i in self.dag.nodes_on_wire(cbit)])
         self.assertEqual([], [i._node_id for i in self.dag.nodes_on_wire(cbit, only_ops=True)])
 
         with self.assertRaises(DAGCircuitError):
@@ -565,7 +565,7 @@ def test_remove_non_op_node(self):
         """Try to remove a non-op node with remove_op_node method."""
         self.dag.apply_operation_back(HGate(), [self.qubit0])
 
-        in_node = next(self.dag.topological_nodes())
+        in_node = next(iter(self.dag.topological_nodes()))
         self.assertRaises(DAGCircuitError, self.dag.remove_op_node, in_node)
 
     def test_dag_collect_runs(self):
@@ -671,7 +671,7 @@ def test_layers_maintains_order(self):
         qr = QuantumRegister(1, 'q0')
 
         # the order the nodes should be in
-        truth = [('in', 'q0[0]', 1), ('op', 'x', 3), ('op', 'id', 4), ('out', 'q0[0]', 2)]
+        truth = [('in', 'q0[0]', 0), ('op', 'x', 2), ('op', 'id', 3), ('out', 'q0[0]', 1)]
 
         # this only occurred sometimes so has to be run more than once
         # (10 times seemed to always be enough for this bug to show at least once)

test/python/transpiler/test_commutation_analysis.py

@@ -86,18 +86,18 @@ def test_all_gates(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1],
+        expected = {'qr[0]': [[0],
+                              [4],
                               [5],
                               [6],
-                              [7],
-                              [8, 9, 10, 11],
+                              [7, 8, 9, 10],
+                              [11],
                               [12],
                               [13],
                               [14],
                               [15],
-                              [16],
-                              [2]],
-                    'qr[1]': [[3], [14], [15], [16], [4]]}
+                              [1]],
+                    'qr[1]': [[2], [13], [14], [15], [3]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
     def test_non_commutative_circuit(self):
@@ -116,7 +116,7 @@ def test_non_commutative_circuit(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1], [7], [2]], 'qr[1]': [[3], [8], [4]], 'qr[2]': [[5], [9], [6]]}
+        expected = {'qr[0]': [[0], [6], [1]], 'qr[1]': [[2], [7], [3]], 'qr[2]': [[4], [8], [5]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
     def test_non_commutative_circuit_2(self):
@@ -137,9 +137,9 @@ def test_non_commutative_circuit_2(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1], [7], [2]],
-                    'qr[1]': [[3], [7], [9], [4]],
-                    'qr[2]': [[5], [8], [9], [6]]}
+        expected = {'qr[0]': [[0], [6], [1]],
+                    'qr[1]': [[2], [6], [8], [3]],
+                    'qr[2]': [[4], [7], [8], [5]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
     def test_commutative_circuit(self):
@@ -161,9 +161,9 @@ def test_commutative_circuit(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1], [7], [2]],
-                    'qr[1]': [[3], [7, 9], [4]],
-                    'qr[2]': [[5], [8], [9], [6]]}
+        expected = {'qr[0]': [[0], [6], [1]],
+                    'qr[1]': [[2], [6, 8], [3]],
+                    'qr[2]': [[4], [7], [8], [5]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
     def test_commutative_circuit_2(self):
@@ -187,9 +187,9 @@ def test_commutative_circuit_2(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1], [7, 8], [2]],
-                    'qr[1]': [[3], [7, 10], [4]],
-                    'qr[2]': [[5], [9], [10], [6]]}
+        expected = {'qr[0]': [[0], [6, 7], [1]],
+                    'qr[1]': [[2], [6, 9], [3]],
+                    'qr[2]': [[4], [8], [9], [5]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
     def test_commutative_circuit_3(self):
@@ -215,9 +215,9 @@ def test_commutative_circuit_3(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1], [7, 9, 11, 13], [2]],
-                    'qr[1]': [[3], [7, 10, 11], [14], [4]],
-                    'qr[2]': [[5], [8], [10], [12, 14], [6]]}
+        expected = {'qr[0]': [[0], [6, 8, 10, 12], [1]],
+                    'qr[1]': [[2], [6, 9, 10], [13], [3]],
+                    'qr[2]': [[4], [7], [9], [11, 13], [5]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
     def test_jordan_wigner_type_circuit(self):
@@ -253,12 +253,12 @@ def test_jordan_wigner_type_circuit(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1], [13, 23], [2]],
-                    'qr[1]': [[3], [13], [14, 22], [23], [4]],
-                    'qr[2]': [[5], [14], [15, 21], [22], [6]],
-                    'qr[3]': [[7], [15], [16, 20], [21], [8]],
-                    'qr[4]': [[9], [16], [17, 19], [20], [10]],
-                    'qr[5]': [[11], [17], [18], [19], [12]]}
+        expected = {'qr[0]': [[0], [12, 22], [1]],
+                    'qr[1]': [[2], [12], [13, 21], [22], [3]],
+                    'qr[2]': [[4], [13], [14, 20], [21], [5]],
+                    'qr[3]': [[6], [14], [15, 19], [20], [7]],
+                    'qr[4]': [[8], [15], [16, 18], [19], [9]],
+                    'qr[5]': [[10], [16], [17], [18], [11]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
     def test_all_commute_circuit(self):
@@ -279,11 +279,11 @@ def test_all_commute_circuit(self):
 
         self.pass_.run(dag)
 
-        expected = {'qr[0]': [[1], [11, 15, 17], [2]],
-                    'qr[1]': [[3], [11, 12, 17, 18], [4]],
-                    'qr[2]': [[5], [12, 14, 18, 20], [6]],
-                    'qr[3]': [[7], [13, 14, 19, 20], [8]],
-                    'qr[4]': [[9], [13, 16, 19], [10]]}
+        expected = {'qr[0]': [[0], [10, 14, 16], [1]],
+                    'qr[1]': [[2], [10, 11, 16, 17], [3]],
+                    'qr[2]': [[4], [11, 13, 17, 19], [5]],
+                    'qr[3]': [[6], [12, 13, 18, 19], [7]],
+                    'qr[4]': [[8], [12, 15, 18], [9]]}
         self.assertCommutationSet(self.pset["commutation_set"], expected)
 
 

test/python/transpiler/test_pass_scheduler.py

@@ -296,7 +296,7 @@ def test_fenced_dag(self):
         self.passmanager.append(PassI_Bad_AP())
         self.assertSchedulerRaises(circ, self.passmanager,
                                    ['run analysis pass PassI_Bad_AP',
-                                    'cx_runs: {(5, 6, 7, 8)}'],
+                                    'cx_runs: {(4, 5, 6, 7)}'],
                                    TranspilerError)
 
     def test_analysis_pass_is_idempotent(self):

tox.ini

@@ -11,6 +11,7 @@ setenv =
   LANGUAGE=en_US
   LC_ALL=en_US.utf-8
   ARGS="-V"
+  RUST_BACKTRACE=full
 deps = -r{toxinidir}/requirements.txt
        -r{toxinidir}/requirements-dev.txt
 commands =