Update transpiler pipeline to (only) use target internally

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -201,7 +201,7 @@ def build_average_error_map(target, properties, coupling_map):
     # running the fallback heuristic
     if not built and target is not None and coupling_map is None:
         coupling_map = target.build_coupling_map()
-    if not built and coupling_map is not None:
+    if not built and coupling_map is not None and num_qubits is not None:
         for qubit in range(num_qubits):
             avg_map.add_error(
                 (qubit, qubit),

qiskit/transpiler/passes/synthesis/high_level_synthesis.py

@@ -302,7 +302,9 @@ def __init__(
         self._basis_gates = basis_gates
         self._min_qubits = min_qubits
 
-        self._top_level_only = self._basis_gates is None and self._target is None
+        self._top_level_only = (self._basis_gates is None or len(self._basis_gates) == 0) and (
+            self._target is None or len(self._target.operation_names) == 0
+        )
 
         # include path for when target exists but target.num_qubits is None (BasicSimulator)
         if not self._top_level_only and (self._target is None or self._target.num_qubits is None):

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -210,7 +210,7 @@ def pass_manager(self, pass_manager_config, optimization_level=None) -> PassMana
 
 
 class UnitarySynthesisPassManager(PassManagerStagePlugin):
-    """Plugin class for translation stage with :class:`~.BasisTranslator`"""
+    """Plugin class for translation stage with :class:`~.UnitarySynthesis`"""
 
     def pass_manager(self, pass_manager_config, optimization_level=None) -> PassManager:
         return common.generate_translation_passmanager(
@@ -558,10 +558,18 @@ def _opt_control(property_set):
             )
             if optimization_level == 1:
                 # Steps for optimization level 1
-                _opt = [
-                    Optimize1qGatesDecomposition(
-                        basis=pass_manager_config.basis_gates, target=pass_manager_config.target
-                    ),
+                if (
+                    pass_manager_config.basis_gates is not None
+                    and len(pass_manager_config.basis_gates) > 0
+                ):
+                    _opt = [
+                        Optimize1qGatesDecomposition(
+                            basis=pass_manager_config.basis_gates, target=pass_manager_config.target
+                        )
+                    ]
+                else:
+                    _opt = []
+                _opt += [
                     InverseCancellation(
                         [
                             CXGate(),
@@ -581,10 +589,18 @@ def _opt_control(property_set):
                 ]
 
             elif optimization_level == 2:
-                _opt = [
-                    Optimize1qGatesDecomposition(
-                        basis=pass_manager_config.basis_gates, target=pass_manager_config.target
-                    ),
+                if (
+                    pass_manager_config.basis_gates is not None
+                    and len(pass_manager_config.basis_gates) > 0
+                ):
+                    _opt = [
+                        Optimize1qGatesDecomposition(
+                            basis=pass_manager_config.basis_gates, target=pass_manager_config.target
+                        )
+                    ]
+                else:
+                    _opt = []
+                _opt += [
                     CommutativeCancellation(target=pass_manager_config.target),
                 ]
             elif optimization_level == 3:
@@ -596,21 +612,29 @@ def _opt_control(property_set):
                         target=pass_manager_config.target,
                         approximation_degree=pass_manager_config.approximation_degree,
                     ),
-                    UnitarySynthesis(
-                        pass_manager_config.basis_gates,
-                        approximation_degree=pass_manager_config.approximation_degree,
-                        coupling_map=pass_manager_config.coupling_map,
-                        backend_props=pass_manager_config.backend_properties,
-                        method=pass_manager_config.unitary_synthesis_method,
-                        plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
-                        target=pass_manager_config.target,
-                    ),
-                    Optimize1qGatesDecomposition(
-                        basis=pass_manager_config.basis_gates, target=pass_manager_config.target
-                    ),
-                    CommutativeCancellation(target=pass_manager_config.target),
                 ]
 
+                if (
+                    pass_manager_config.basis_gates is not None
+                    and len(pass_manager_config.basis_gates) > 0
+                ):
+                    _opt += [
+                        UnitarySynthesis(
+                            pass_manager_config.basis_gates,
+                            approximation_degree=pass_manager_config.approximation_degree,
+                            coupling_map=pass_manager_config.coupling_map,
+                            backend_props=pass_manager_config.backend_properties,
+                            method=pass_manager_config.unitary_synthesis_method,
+                            plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
+                            target=pass_manager_config.target,
+                        ),
+                        Optimize1qGatesDecomposition(
+                            basis=pass_manager_config.basis_gates, target=pass_manager_config.target
+                        ),
+                    ]
+
+                _opt += [CommutativeCancellation(target=pass_manager_config.target)]
+
                 def _opt_control(property_set):
                     return not property_set["optimization_loop_minimum_point"]
 
@@ -632,25 +656,40 @@ def _unroll_condition(property_set):
             if optimization_level == 3:
                 optimization.append(_minimum_point_check)
             elif optimization_level == 2:
-                optimization.append(
-                    [
-                        Collect2qBlocks(),
-                        ConsolidateBlocks(
-                            basis_gates=pass_manager_config.basis_gates,
-                            target=pass_manager_config.target,
-                            approximation_degree=pass_manager_config.approximation_degree,
-                        ),
-                        UnitarySynthesis(
-                            pass_manager_config.basis_gates,
-                            approximation_degree=pass_manager_config.approximation_degree,
-                            coupling_map=pass_manager_config.coupling_map,
-                            backend_props=pass_manager_config.backend_properties,
-                            method=pass_manager_config.unitary_synthesis_method,
-                            plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
-                            target=pass_manager_config.target,
-                        ),
-                    ]
-                )
+                if (
+                    pass_manager_config.basis_gates is not None
+                    and len(pass_manager_config.basis_gates) > 0
+                ):
+                    optimization.append(
+                        [
+                            Collect2qBlocks(),
+                            ConsolidateBlocks(
+                                basis_gates=pass_manager_config.basis_gates,
+                                target=pass_manager_config.target,
+                                approximation_degree=pass_manager_config.approximation_degree,
+                            ),
+                            UnitarySynthesis(
+                                pass_manager_config.basis_gates,
+                                approximation_degree=pass_manager_config.approximation_degree,
+                                coupling_map=pass_manager_config.coupling_map,
+                                backend_props=pass_manager_config.backend_properties,
+                                method=pass_manager_config.unitary_synthesis_method,
+                                plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
+                                target=pass_manager_config.target,
+                            ),
+                        ]
+                    )
+                else:
+                    optimization.append(
+                        [
+                            Collect2qBlocks(),
+                            ConsolidateBlocks(
+                                basis_gates=pass_manager_config.basis_gates,
+                                target=pass_manager_config.target,
+                                approximation_degree=pass_manager_config.approximation_degree,
+                            ),
+                        ]
+                    )
                 optimization.append(_depth_check + _size_check)
             else:
                 optimization.append(_depth_check + _size_check)

qiskit/transpiler/preset_passmanagers/common.py

@@ -85,9 +85,9 @@ class _InvalidControlFlowForBackend:
     # Explicitly stateful closure to allow pickling.
 
     def __init__(self, basis_gates=(), target=None):
-        if target is not None:
+        if target is not None and len(target.operation_names) > 0:
             self.unsupported = [op for op in CONTROL_FLOW_OP_NAMES if op not in target]
-        elif basis_gates is not None:
+        elif basis_gates is not None and len(basis_gates) > 0:
             basis_gates = set(basis_gates)
             self.unsupported = [op for op in CONTROL_FLOW_OP_NAMES if op not in basis_gates]
         else:
@@ -237,7 +237,12 @@ def generate_unroll_3q(
     )
     # If there are no target instructions revert to using unroll3qormore so
     # routing works.
-    if basis_gates is None and target is None:
+    if (
+        basis_gates is None
+        and target is None
+        or target is not None
+        and len(target.operation_names) == 0
+    ):
         unroll_3q.append(Unroll3qOrMore(target, basis_gates))
     else:
         unroll_3q.append(BasisTranslator(sel, basis_gates, target=target, min_qubits=3))
@@ -454,77 +459,124 @@ def generate_translation_passmanager(
     Raises:
         TranspilerError: If the ``method`` kwarg is not a valid value
     """
+    if basis_gates is None and target is None:
+        return PassManager([])
+
     if method == "translator":
-        unroll = [
-            # Use unitary synthesis for basis aware decomposition of
-            # UnitaryGates before custom unrolling
-            UnitarySynthesis(
-                basis_gates,
-                approximation_degree=approximation_degree,
-                coupling_map=coupling_map,
-                backend_props=backend_props,
-                plugin_config=unitary_synthesis_plugin_config,
-                method=unitary_synthesis_method,
-                target=target,
-            ),
-            HighLevelSynthesis(
-                hls_config=hls_config,
-                coupling_map=coupling_map,
-                target=target,
-                use_qubit_indices=True,
-                equivalence_library=sel,
-                basis_gates=basis_gates,
-                qubits_initially_zero=qubits_initially_zero,
-            ),
-            BasisTranslator(sel, basis_gates, target),
-        ]
+        if target is not None and len(target.operation_names) == 0:
+            unroll = [
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    equivalence_library=sel,
+                    basis_gates=basis_gates,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+            ]
+        else:
+            unroll = [
+                # Use unitary synthesis for basis aware decomposition of
+                # UnitaryGates before custom unrolling
+                UnitarySynthesis(
+                    basis_gates,
+                    approximation_degree=approximation_degree,
+                    coupling_map=coupling_map,
+                    backend_props=backend_props,
+                    plugin_config=unitary_synthesis_plugin_config,
+                    method=unitary_synthesis_method,
+                    target=target,
+                ),
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    equivalence_library=sel,
+                    basis_gates=basis_gates,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+                BasisTranslator(sel, basis_gates, target),
+            ]
     elif method == "synthesis":
-        unroll = [
-            # # Use unitary synthesis for basis aware decomposition of
-            # UnitaryGates > 2q before collection
-            UnitarySynthesis(
-                basis_gates,
-                approximation_degree=approximation_degree,
-                coupling_map=coupling_map,
-                backend_props=backend_props,
-                plugin_config=unitary_synthesis_plugin_config,
-                method=unitary_synthesis_method,
-                min_qubits=3,
-                target=target,
-            ),
-            HighLevelSynthesis(
-                hls_config=hls_config,
-                coupling_map=coupling_map,
-                target=target,
-                use_qubit_indices=True,
-                basis_gates=basis_gates,
-                min_qubits=3,
-                qubits_initially_zero=qubits_initially_zero,
-            ),
-            Unroll3qOrMore(target=target, basis_gates=basis_gates),
-            Collect2qBlocks(),
-            Collect1qRuns(),
-            ConsolidateBlocks(
-                basis_gates=basis_gates, target=target, approximation_degree=approximation_degree
-            ),
-            UnitarySynthesis(
-                basis_gates=basis_gates,
-                approximation_degree=approximation_degree,
-                coupling_map=coupling_map,
-                backend_props=backend_props,
-                plugin_config=unitary_synthesis_plugin_config,
-                method=unitary_synthesis_method,
-                target=target,
-            ),
-            HighLevelSynthesis(
-                hls_config=hls_config,
-                coupling_map=coupling_map,
-                target=target,
-                use_qubit_indices=True,
-                basis_gates=basis_gates,
-                qubits_initially_zero=qubits_initially_zero,
-            ),
-        ]
+        if target is not None and len(target.operation_names) == 0:
+            unroll = [
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    basis_gates=basis_gates,
+                    min_qubits=3,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+                Unroll3qOrMore(target=target, basis_gates=basis_gates),
+                Collect2qBlocks(),
+                Collect1qRuns(),
+                ConsolidateBlocks(
+                    basis_gates=basis_gates,
+                    target=target,
+                    approximation_degree=approximation_degree,
+                ),
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    basis_gates=basis_gates,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+            ]
+        else:
+            unroll = [
+                # # Use unitary synthesis for basis aware decomposition of
+                # UnitaryGates > 2q before collection
+                UnitarySynthesis(
+                    basis_gates,
+                    approximation_degree=approximation_degree,
+                    coupling_map=coupling_map,
+                    backend_props=backend_props,
+                    plugin_config=unitary_synthesis_plugin_config,
+                    method=unitary_synthesis_method,
+                    min_qubits=3,
+                    target=target,
+                ),
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    basis_gates=basis_gates,
+                    min_qubits=3,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+                Unroll3qOrMore(target=target, basis_gates=basis_gates),
+                Collect2qBlocks(),
+                Collect1qRuns(),
+                ConsolidateBlocks(
+                    basis_gates=basis_gates,
+                    target=target,
+                    approximation_degree=approximation_degree,
+                ),
+                UnitarySynthesis(
+                    basis_gates=basis_gates,
+                    approximation_degree=approximation_degree,
+                    coupling_map=coupling_map,
+                    backend_props=backend_props,
+                    plugin_config=unitary_synthesis_plugin_config,
+                    method=unitary_synthesis_method,
+                    target=target,
+                ),
+                HighLevelSynthesis(
+                    hls_config=hls_config,
+                    coupling_map=coupling_map,
+                    target=target,
+                    use_qubit_indices=True,
+                    basis_gates=basis_gates,
+                    qubits_initially_zero=qubits_initially_zero,
+                ),
+            ]
     else:
         raise TranspilerError(f"Invalid translation method {method}.")
     return PassManager(unroll)