Implementing pluggable HighLevelSynthesis

qiskit/compiler/transpiler.py

@@ -80,6 +80,7 @@ def transpile(
     unitary_synthesis_method: str = "default",
     unitary_synthesis_plugin_config: dict = None,
     target: Target = None,
+    hls_config=None,
 ) -> Union[QuantumCircuit, List[QuantumCircuit]]:
     """Transpile one or more circuits, according to some desired transpilation targets.
 
@@ -246,6 +247,7 @@ def callback_func(**kwargs):
             the ``backend`` argument, but if you have manually constructed a
             :class:`~qiskit.transpiler.Target` object you can specify it manually here.
             This will override the target from ``backend``.
+        hls_config: high-level-synthesis config
     Returns:
         The transpiled circuit(s).
 
@@ -310,6 +312,7 @@ def callback_func(**kwargs):
         unitary_synthesis_method,
         unitary_synthesis_plugin_config,
         target,
+        hls_config,
     )
     # Get transpile_args to configure the circuit transpilation job(s)
     if coupling_map in unique_transpile_args:
@@ -560,6 +563,7 @@ def _parse_transpile_args(
     unitary_synthesis_method,
     unitary_synthesis_plugin_config,
     target,
+    hls_config,
 ) -> Tuple[List[Dict], Dict]:
     """Resolve the various types of args allowed to the transpile() function through
     duck typing, overriding args, etc. Refer to the transpile() docstring for details on
@@ -646,6 +650,7 @@ def _parse_transpile_args(
         "unitary_synthesis_method": unitary_synthesis_method,
         "unitary_synthesis_plugin_config": unitary_synthesis_plugin_config,
         "target": target,
+        "hls_config": hls_config,
     }.items():
         if isinstance(value, list):
             unique_dict[key] = value

qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2021.
+# (C) Copyright IBM 2022.
 #
 # 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
@@ -11,35 +11,119 @@
 # that they have been altered from the originals.
 
 
-"""Synthesize high-level objects."""
+"""Synthesize higher-level objects."""
+
+import stevedore
 
 from qiskit.converters import circuit_to_dag
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
-from qiskit.quantum_info.synthesis.clifford_decompose import decompose_clifford
+from qiskit.transpiler.exceptions import TranspilerError
+
+
+# ToDo: possibly choose a better name for this data structure.
+class HLSConfig:
+    """
+    To each higher-level-object (e.g., "clifford", "linear_function", etc.) we associate a
+    pair consisting of the name of a synthesis algorithm and additional arguments it requires.
+    There are two special values for the name:
+        "default" is the default synthesis algorithm (chosen by Qiskit developers)
+        "none" is to skip synthesizing this object
+    All other names should be declared in entry points in setup.
+    """
+
+    def __init__(self, default_or_none: True):
+        """
+        Creates a high-level-synthesis config.
+        Args:
+            default_or_none: specifies the default method for every higher-level object,
+                either "default" (use the "default" synthesize method if available),
+                or "none" (skip synthesizing)
+        """
+        self.default_or_none = default_or_none
+        self.methods = dict()
 
+    def set_method(self, hls_name: str, method_name: str, method_args=None):
+        """Sets the synthesis method for a given higher-level-object."""
+        if method_args is None:
+            method_args = dict()
+        self.methods[hls_name] = (method_name, method_args)
 
+    def print(self):
+        """This is temporary for debugging."""
+        print("HLS CONFIG:")
+        print(f"default_or_none = {self.default_or_none}")
+        for hls_name in self.methods:
+            print(f"  name = {hls_name}, method = {self.methods[hls_name]}")
+
+
+# ToDo [1]: Make sure that plugin_method is an instance of a certain API
+#           (for instance, every plugin for Unitary Synthesis derives from UnitarySynthesisPlugin).
+#           It probably makes sense to create a more general HigherLevelSynthesisPlugin
+#           (which is exactly what UnitarySynthesisPlugin is right now), and to rename/inherit
+#           UnitarySynthesisPlugin from that.
+# ToDo [2]: Do we have a way to specify optimization criteria (e.g., 2q gate count vs. depth)?
+# ToDo [3]: Do we also need a PluginManager, similar to UnitarySynthesisPluginManager?
 class HighLevelSynthesis(TransformationPass):
-    """Synthesize high-level objects by choosing the appropriate synthesis method based on
-    the object's name.
+    """Synthesize higher-level objects by choosing the appropriate synthesis method
+    based on the node's name and the HLS-config (if provided).
     """
 
-    # TODO: Currently, this class only contains the minimal functionality required to transpile
-    #       Cliffords. In the near future, this class will be expanded to cover other higher-level
-    #       objects (as these become available). Additionally, the plan is to make HighLevelSynthesis
-    #       "pluggable", so that the users would be able to "plug in" their own synthesis methods
-    #       for higher-level objects (which would be called during transpilation).
+    def __init__(self, hls_config=None):
+        super().__init__()
+
+        if hls_config is not None:
+            self.hls_config = hls_config
+        else:
+            # When the config file is not provided, we will use the "default" method
+            # to synthesize Operations (when available).
+            self.hls_config = HLSConfig(True)
 
     def run(self, dag: DAGCircuit) -> DAGCircuit:
         """Run the HighLevelSynthesis pass on `dag`.
         Args:
             dag: input dag.
         Returns:
-            Output dag with high level objects synthesized.
+            Output dag with certain Operations synthesized (as specified by
+            the hls_config).
         """
 
-        for node in dag.named_nodes("clifford"):
-            decomposition = circuit_to_dag(decompose_clifford(node.op))
-            dag.substitute_node_with_dag(node, decomposition)
+        for node in dag.op_nodes():
+            # Get available plugins corresponding to the name of the current operation (node)
+            # ToDo [4]: check how (un)efficient it is to call stevedore for every gate in the circuit
+            available_plugins = stevedore.ExtensionManager(
+                "qiskit.synthesis." + node.name, invoke_on_load=True, propagate_map_exceptions=True
+            )
+
+            if node.name in self.hls_config.methods.keys():
+                # the operation's name appears in the user-provided config
+                # note that the plugin might be "default" or "none"
+                plugin_name, plugin_args = self.hls_config.methods[node.name]
+            elif self.hls_config.default_or_none and "default" in available_plugins.names():
+                # the operation's name does not appear in the user-specified config,
+                # but we should use the "default" method when possible
+                plugin_name, plugin_args = "default", {}
+            else:
+                # the operation's name does not appear in the user-specified config,
+                # and either the "default" method is not available or we should skip these
+                plugin_name, plugin_args = "none", {}
+
+            if plugin_name == "none":
+                # don't synthesize this operation
+                continue
+
+            if plugin_name not in available_plugins:
+                raise TranspilerError(
+                    "Specified method: %s not found in available plugins for %s"
+                    % (plugin_name, node.name)
+                )
+
+            # print(f"  Using method {plugin_name} for {node.name}")
+            plugin_method = available_plugins[plugin_name].obj
+
+            # ToDo: [5] similarly to UnitarySynthesis, we should pass additional parameters
+            #       e.g. coupling_map to the synthesis algorithm.
+            decomposition = plugin_method.run(node.op, **plugin_args)
+            dag.substitute_node_with_dag(node, circuit_to_dag(decomposition))
 
         return dag

qiskit/transpiler/passes/synthesis/high_level_synthesis_plugins.py

@@ -0,0 +1,35 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022.
+#
+# 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.
+
+"""
+Default plugins for synthesizing high-level-objects in Qiskit.
+"""
+from qiskit.quantum_info import decompose_clifford
+from qiskit.transpiler.synthesis import cnot_synth
+
+
+class DefaultSynthesisClifford:
+    def run(self, clifford, **options):
+        """Run synthesis for the given Clifford."""
+
+        print(f"    -> Running DefaultSynthesisClifford")
+        decomposition = decompose_clifford(clifford)
+        return decomposition
+
+
+class DefaultSynthesisLinearFunction:
+    def run(self, linear_function, **options):
+        """Run synthesis for the given LinearFunction."""
+
+        print(f"    -> Running DefaultSynthesisLinearFunction")
+        decomposition = cnot_synth(linear_function.linear)
+        return decomposition

qiskit/transpiler/passmanager_config.py

@@ -39,6 +39,7 @@ def __init__(
         unitary_synthesis_method="default",
         unitary_synthesis_plugin_config=None,
         target=None,
+        hls_config=None,
     ):
         """Initialize a PassManagerConfig object
 
@@ -70,6 +71,7 @@ def __init__(
                 :class:`~qiskit.transpiler.passes.UnitarySynthesis` pass. Will
                 search installed plugins for a valid method.
             target (Target): The backend target
+            hls_config (str): hls config
         """
         self.initial_layout = initial_layout
         self.basis_gates = basis_gates
@@ -87,6 +89,7 @@ def __init__(
         self.unitary_synthesis_method = unitary_synthesis_method
         self.unitary_synthesis_plugin_config = unitary_synthesis_plugin_config
         self.target = target
+        self.hls_config = hls_config
 
     @classmethod
     def from_backend(cls, backend, **pass_manager_options):
@@ -166,4 +169,5 @@ def __str__(self):
             f"\tunitary_synthesis_method: {self.unitary_synthesis_method}\n"
             f"\tunitary_synthesis_plugin_config: {self.unitary_synthesis_plugin_config}\n"
             f"\ttarget: {str(self.target).replace(newline, newline_tab)}\n"
+            f"\thls_config: {self.hls_config}\n"
         )

qiskit/transpiler/preset_passmanagers/__init__.py

@@ -55,6 +55,7 @@ def generate_preset_pass_manager(
     seed_transpiler=None,
     unitary_synthesis_method="default",
     unitary_synthesis_plugin_config=None,
+    hls_config=None,
 ):
     """Generate a preset :class:`~.PassManager`
 
@@ -134,6 +135,7 @@ def generate_preset_pass_manager(
             the ``unitary_synthesis`` argument. As this is custom for each
             unitary synthesis plugin refer to the plugin documentation for how
             to use this option.
+        hls_config: hls_config
 
     Returns:
         StagedPassManager: The preset pass manager for the given options
@@ -172,6 +174,7 @@ def generate_preset_pass_manager(
         unitary_synthesis_method=unitary_synthesis_method,
         unitary_synthesis_plugin_config=unitary_synthesis_plugin_config,
         initial_layout=initial_layout,
+        hls_config=hls_config,
     )
 
     if backend is not None:

qiskit/transpiler/preset_passmanagers/common.py

@@ -55,6 +55,7 @@ def generate_unroll_3q(
     approximation_degree=None,
     unitary_synthesis_method="default",
     unitary_synthesis_plugin_config=None,
+    hls_config=None,
 ):
     """Generate an unroll >3q :class:`~qiskit.transpiler.PassManager`
 
@@ -68,6 +69,7 @@ def generate_unroll_3q(
         unitary_synthesis_plugin_config (dict): The optional dictionary plugin
             configuration, this is plugin specific refer to the specified plugin's
             documenation for how to use.
+        hls_config: hls config
 
     Returns:
         PassManager: The unroll 3q or more pass manager
@@ -83,7 +85,7 @@ def generate_unroll_3q(
             target=target,
         )
     )
-    unroll_3q.append(HighLevelSynthesis())
+    unroll_3q.append(HighLevelSynthesis(hls_config=hls_config))
     unroll_3q.append(Unroll3qOrMore(target=target, basis_gates=basis_gates))
     return unroll_3q
 
@@ -234,6 +236,7 @@ def generate_translation_passmanager(
     backend_props=None,
     unitary_synthesis_method="default",
     unitary_synthesis_plugin_config=None,
+    hls_config=None,
 ):
     """Generate a basis translation :class:`~qiskit.transpiler.PassManager`
 
@@ -255,6 +258,7 @@ def generate_translation_passmanager(
         backend_props (BackendProperties): Properties of a backend to
             synthesize for (e.g. gate fidelities).
         unitary_synthesis_method (str): The unitary synthesis method to use
+        hls_config: hls config
 
     Returns:
         PassManager: The basis translation pass manager
@@ -277,7 +281,7 @@ def generate_translation_passmanager(
                 method=unitary_synthesis_method,
                 target=target,
             ),
-            HighLevelSynthesis(),
+            HighLevelSynthesis(hls_config=hls_config),
             UnrollCustomDefinitions(sel, basis_gates),
             BasisTranslator(sel, basis_gates, target),
         ]
@@ -295,7 +299,7 @@ def generate_translation_passmanager(
                 min_qubits=3,
                 target=target,
             ),
-            HighLevelSynthesis(),
+            HighLevelSynthesis(hls_config=hls_config),
             Unroll3qOrMore(target=target, basis_gates=basis_gates),
             Collect2qBlocks(),
             Collect1qRuns(),
@@ -309,7 +313,7 @@ def generate_translation_passmanager(
                 method=unitary_synthesis_method,
                 target=target,
             ),
-            HighLevelSynthesis(),
+            HighLevelSynthesis(hls_config=hls_config),
         ]
     else:
         raise TranspilerError("Invalid translation method %s." % method)

qiskit/transpiler/preset_passmanagers/level1.py

@@ -81,6 +81,7 @@ def level_1_pass_manager(pass_manager_config: PassManagerConfig) -> StagedPassMa
     unitary_synthesis_plugin_config = pass_manager_config.unitary_synthesis_plugin_config
     timing_constraints = pass_manager_config.timing_constraints or TimingConstraints()
     target = pass_manager_config.target
+    hls_config = pass_manager_config.hls_config
 
     # Use trivial layout if no layout given
     _given_layout = SetLayout(initial_layout)
@@ -201,6 +202,7 @@ def _opt_control(property_set):
             approximation_degree,
             unitary_synthesis_method,
             unitary_synthesis_plugin_config,
+            hls_config,
         )
         layout = PassManager()
         layout.append(_given_layout)
@@ -233,6 +235,7 @@ def _opt_control(property_set):
         backend_properties,
         unitary_synthesis_method,
         unitary_synthesis_plugin_config,
+        hls_config,
     )
     pre_routing = None
     if toqm_pass:

setup.py

@@ -100,6 +100,14 @@
         "qiskit.unitary_synthesis": [
             "default = qiskit.transpiler.passes.synthesis.unitary_synthesis:DefaultUnitarySynthesis",
             "aqc = qiskit.transpiler.synthesis.aqc.aqc_plugin:AQCSynthesisPlugin",
-        ]
+        ],
+        "qiskit.synthesis.clifford": [
+            "default = qiskit.transpiler.passes.synthesis.high_level_synthesis_plugins:DefaultSynthesisClifford",
+        ],
+        "qiskit.synthesis.linear_function": [
+            "default = qiskit.transpiler.passes.synthesis.high_level_synthesis_plugins:DefaultSynthesisLinearFunction",
+            "depth_opt = test_stuff:LinearFunctionSynthesisPluginForDepth",
+            "count_opt = test_stuff:LinearFunctionSynthesisPluginForCount",
+        ],
     },
 )