ResourceEstimation AnalysisPass

CHANGELOG.rst

@@ -50,6 +50,8 @@ Added
 - ``execute_circuits()`` and ``assemble_circuits()`` allow setting a qobj_header of type
   QobjHeader to add extra information to the qobj (and thus result).
 - Register indexing supports negative indices (#1875)
+- Added new resource estimation passes: ``Depth``, ``Width``, ``Size``, ``CountOps``, and
+  ``NumTensorFactors``, all grouped in the ``ResourceEstimation`` analysis pass.
 - Added ``nodes_on_wire()`` to DAGCircuit which returns an iterator over all the
   operations on the given wire
 - Added new properties to an Instruction:
@@ -61,7 +63,6 @@ Added
 - Added an ``Instruction.mirror()`` method that mirrors a composite instruction
   (reverses its sub-instructions) (#1816).
 
-
 Changed
 -------
 

qiskit/dagcircuit/dagcircuit.py

@@ -631,7 +631,8 @@ def depth(self):
         if not nx.is_directed_acyclic_graph(self.multi_graph):
             raise DAGCircuitError("not a DAG")
 
-        return nx.dag_longest_path_length(self.multi_graph) - 1
+        depth = nx.dag_longest_path_length(self.multi_graph) - 1
+        return depth if depth != -1 else 0
 
     def width(self):
         """Return the total number of qubits used by the circuit."""

qiskit/transpiler/passes/__init__.py

@@ -10,6 +10,12 @@
 from .unroller import Unroller
 from .cx_cancellation import CXCancellation
 from .fixed_point import FixedPoint
+from .resource_estimation import ResourceEstimation
+from .depth import Depth
+from .size import Size
+from .width import Width
+from .count_ops import CountOps
+from .num_tensor_factors import NumTensorFactors
 from .dag_fixed_point import DAGFixedPoint
 from .optimize_1q_gates import Optimize1qGates
 from .decompose import Decompose

qiskit/transpiler/passes/count_ops.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+""" An analysis pass for counting operations in a DAG circuit.
+"""
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class CountOps(AnalysisPass):
+    """ An analysis pass for counting operations in a DAG circuit.
+    """
+
+    def run(self, dag):
+        self.property_set['count_ops'] = dag.count_ops()

qiskit/transpiler/passes/depth.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+""" An analysis pass for calculating the depth of a DAG circuit.
+"""
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class Depth(AnalysisPass):
+    """ An analysis pass for calculating the depth of a DAG circuit.
+    """
+
+    def run(self, dag):
+        self.property_set['depth'] = dag.depth()

qiskit/transpiler/passes/num_tensor_factors.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+""" An analysis pass for calculating the number of tensor factors of a DAG circuit.
+"""
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class NumTensorFactors(AnalysisPass):
+    """ An analysis pass for calculating the number of tensor factors of a DAG circuit.
+    """
+
+    def run(self, dag):
+        self.property_set['num_tensor_factors'] = dag.num_tensor_factors()

qiskit/transpiler/passes/resource_estimation.py

@@ -0,0 +1,28 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+""" An analysis pass for automatically running Depth(), Width(), Size(), CountOps(), and
+Tensor_Factor()
+"""
+from qiskit.transpiler.basepasses import AnalysisPass
+from qiskit.transpiler.passes.depth import Depth
+from qiskit.transpiler.passes.width import Width
+from qiskit.transpiler.passes.size import Size
+from qiskit.transpiler.passes.count_ops import CountOps
+from qiskit.transpiler.passes.num_tensor_factors import NumTensorFactors
+
+
+class ResourceEstimation(AnalysisPass):
+    """ Requires Depth(), Width(), Size(), CountOps(), and NumTensorFactors().
+    """
+
+    def __init__(self):
+        super().__init__()
+        self.requires += [Depth(), Width(), Size(), CountOps(), NumTensorFactors()]
+
+    def run(self, _):
+        pass

qiskit/transpiler/passes/size.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+""" An analysis pass for calculating the size of a DAG circuit.
+"""
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class Size(AnalysisPass):
+    """ An analysis pass for calculating the size of a DAG circuit.
+    """
+
+    def run(self, dag):
+        self.property_set['size'] = dag.size()

qiskit/transpiler/passes/width.py

@@ -0,0 +1,18 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+""" An analysis pass for calculating the width of a DAG circuit.
+"""
+from qiskit.transpiler.basepasses import AnalysisPass
+
+
+class Width(AnalysisPass):
+    """ An analysis pass for calculating the width of a DAG circuit.
+    """
+
+    def run(self, dag):
+        self.property_set['width'] = dag.width()

test/python/transpiler/test_count_ops_pass.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+"""Depth pass testing"""
+
+import unittest
+
+from qiskit import QuantumCircuit, QuantumRegister
+from qiskit.converters import circuit_to_dag
+from qiskit.transpiler.passes import CountOps
+from qiskit.test import QiskitTestCase
+
+
+class TestCountOpsPass(QiskitTestCase):
+    """ Tests for CountOps analysis methods. """
+
+    def test_empty_dag(self):
+        """ Empty DAG has empty counts."""
+        circuit = QuantumCircuit()
+        dag = circuit_to_dag(circuit)
+
+        pass_ = CountOps()
+        _ = pass_.run(dag)
+
+        self.assertDictEqual(pass_.property_set['count_ops'], {})
+
+    def test_just_qubits(self):
+        """ A dag with 8 operations (6 CXs and 2 Hs)"""
+        qr = QuantumRegister(2)
+        circuit = QuantumCircuit(qr)
+        circuit.h(qr[0])
+        circuit.h(qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[1], qr[0])
+        circuit.cx(qr[1], qr[0])
+        dag = circuit_to_dag(circuit)
+
+        pass_ = CountOps()
+        _ = pass_.run(dag)
+
+        self.assertDictEqual(pass_.property_set['count_ops'], {'cx': 6, 'h': 2})
+
+
+if __name__ == '__main__':
+    unittest.main()

test/python/transpiler/test_depth_pass.py

@@ -0,0 +1,65 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+"""Depth pass testing"""
+
+import unittest
+
+from qiskit import QuantumCircuit, QuantumRegister
+from qiskit.converters import circuit_to_dag
+from qiskit.transpiler.passes import Depth
+from qiskit.test import QiskitTestCase
+
+
+class TestDepthPass(QiskitTestCase):
+    """ Tests for Depth analysis methods. """
+
+    def test_empty_dag(self):
+        """ Empty DAG has 0 depth """
+        circuit = QuantumCircuit()
+        dag = circuit_to_dag(circuit)
+
+        pass_ = Depth()
+        _ = pass_.run(dag)
+
+        self.assertEqual(pass_.property_set['depth'], 0)
+
+    def test_just_qubits(self):
+        """ A dag with 8 operations and no classic bits"""
+        qr = QuantumRegister(2)
+        circuit = QuantumCircuit(qr)
+        circuit.h(qr[0])
+        circuit.h(qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[1], qr[0])
+        circuit.cx(qr[1], qr[0])
+        dag = circuit_to_dag(circuit)
+
+        pass_ = Depth()
+        _ = pass_.run(dag)
+
+        self.assertEqual(pass_.property_set['depth'], 7)
+
+    def test_depth_one(self):
+        """ A dag with operations in parallel and depth 1"""
+        qr = QuantumRegister(2)
+        circuit = QuantumCircuit(qr)
+        circuit.h(qr[0])
+        circuit.h(qr[1])
+        dag = circuit_to_dag(circuit)
+
+        pass_ = Depth()
+        _ = pass_.run(dag)
+
+        self.assertEqual(pass_.property_set['depth'], 1)
+
+
+if __name__ == '__main__':
+    unittest.main()

test/python/transpiler/test_resource_estimation_pass.py

@@ -0,0 +1,58 @@
+# -*- coding: utf-8 -*-
+
+# Copyright 2019, IBM.
+#
+# This source code is licensed under the Apache License, Version 2.0 found in
+# the LICENSE.txt file in the root directory of this source tree.
+
+"""ResourceEstimation pass testing"""
+
+import unittest
+
+from qiskit import QuantumRegister, QuantumCircuit
+from qiskit.transpiler import PassManager, transpile
+from qiskit.transpiler.passes import ResourceEstimation
+from qiskit.test import QiskitTestCase
+from qiskit.test.mock import FakeRueschlikon
+
+
+class TestResourceEstimationPass(QiskitTestCase):
+    """ Tests for PropertySet methods. """
+
+    def test_empty_dag(self):
+        """ Empty DAG."""
+        circuit = QuantumCircuit()
+        passmanager = PassManager()
+        passmanager.append(ResourceEstimation())
+        _ = transpile(circuit, FakeRueschlikon(), pass_manager=passmanager)
+
+        self.assertEqual(passmanager.property_set['size'], 0)
+        self.assertEqual(passmanager.property_set['depth'], 0)
+        self.assertEqual(passmanager.property_set['width'], 0)
+        self.assertDictEqual(passmanager.property_set['count_ops'], {})
+
+    def test_just_qubits(self):
+        """ A dag with 8 operations and no classic bits"""
+        qr = QuantumRegister(2)
+        circuit = QuantumCircuit(qr)
+        circuit.h(qr[0])
+        circuit.h(qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[0], qr[1])
+        circuit.cx(qr[1], qr[0])
+        circuit.cx(qr[1], qr[0])
+
+        passmanager = PassManager()
+        passmanager.append(ResourceEstimation())
+        _ = transpile(circuit, FakeRueschlikon(), pass_manager=passmanager)
+
+        self.assertEqual(passmanager.property_set['size'], 8)
+        self.assertEqual(passmanager.property_set['depth'], 7)
+        self.assertEqual(passmanager.property_set['width'], 2)
+        self.assertDictEqual(passmanager.property_set['count_ops'], {'cx': 6, 'h': 2})
+
+
+if __name__ == '__main__':
+    unittest.main()