qiskit 1.4.0__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/preset_passmanagers/builtin_plugins.py

@@ -13,14 +13,12 @@
 """Built-in transpiler stage plugins for preset pass managers."""
 
 import os
-import warnings
 
 from qiskit.transpiler.passes.optimization.split_2q_unitaries import Split2QUnitaries
 from qiskit.transpiler.passmanager import PassManager
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.passes import BasicSwap
 from qiskit.transpiler.passes import LookaheadSwap
-from qiskit.transpiler.passes import StochasticSwap
 from qiskit.transpiler.passes import SabreSwap
 from qiskit.transpiler.passes import Error
 from qiskit.transpiler.passes import SetLayout
@@ -43,6 +41,7 @@ from qiskit.transpiler.passes.optimization import (
     ConsolidateBlocks,
     InverseCancellation,
     RemoveIdentityEquivalent,
+    ContractIdleWiresInControlFlow,
 )
 from qiskit.transpiler.passes import Depth, Size, FixedPoint, MinimumPoint
 from qiskit.transpiler.passes.utils.gates_basis import GatesInBasis
@@ -67,7 +66,7 @@ from qiskit.circuit.library.standard_gates import (
     SXGate,
     SXdgGate,
 )
-from qiskit.utils.parallel import CPU_COUNT
+from qiskit.utils import default_num_processes
 from qiskit import user_config
 
 CONFIG = user_config.get_config()
@@ -126,22 +125,25 @@ class DefaultInitPassManager(PassManagerStagePlugin):
                     pass_manager_config.qubits_initially_zero,
                 )
             init.append(
-                InverseCancellation(
-                    [
-                        CXGate(),
-                        ECRGate(),
-                        CZGate(),
-                        CYGate(),
-                        XGate(),
-                        YGate(),
-                        ZGate(),
-                        HGate(),
-                        SwapGate(),
-                        (TGate(), TdgGate()),
-                        (SGate(), SdgGate()),
-                        (SXGate(), SXdgGate()),
-                    ]
-                )
+                [
+                    InverseCancellation(
+                        [
+                            CXGate(),
+                            ECRGate(),
+                            CZGate(),
+                            CYGate(),
+                            XGate(),
+                            YGate(),
+                            ZGate(),
+                            HGate(),
+                            SwapGate(),
+                            (TGate(), TdgGate()),
+                            (SGate(), SdgGate()),
+                            (SXGate(), SXdgGate()),
+                        ]
+                    ),
+                    ContractIdleWiresInControlFlow(),
+                ]
             )
 
         elif optimization_level in {2, 3}:
@@ -156,31 +158,32 @@ class DefaultInitPassManager(PassManagerStagePlugin):
             )
             if pass_manager_config.routing_method != "none":
                 init.append(ElidePermutations())
-            init.append(RemoveDiagonalGatesBeforeMeasure())
-            # Target not set on RemoveIdentityEquivalent because we haven't applied a Layout
-            # yet so doing anything relative to an error rate in the target is not valid.
-            init.append(
-                RemoveIdentityEquivalent(
-                    approximation_degree=pass_manager_config.approximation_degree
-                )
-            )
             init.append(
-                InverseCancellation(
-                    [
-                        CXGate(),
-                        ECRGate(),
-                        CZGate(),
-                        CYGate(),
-                        XGate(),
-                        YGate(),
-                        ZGate(),
-                        HGate(),
-                        SwapGate(),
-                        (TGate(), TdgGate()),
-                        (SGate(), SdgGate()),
-                        (SXGate(), SXdgGate()),
-                    ]
-                )
+                [
+                    RemoveDiagonalGatesBeforeMeasure(),
+                    # Target not set on RemoveIdentityEquivalent because we haven't applied a Layout
+                    # yet so doing anything relative to an error rate in the target is not valid.
+                    RemoveIdentityEquivalent(
+                        approximation_degree=pass_manager_config.approximation_degree
+                    ),
+                    InverseCancellation(
+                        [
+                            CXGate(),
+                            ECRGate(),
+                            CZGate(),
+                            CYGate(),
+                            XGate(),
+                            YGate(),
+                            ZGate(),
+                            HGate(),
+                            SwapGate(),
+                            (TGate(), TdgGate()),
+                            (SGate(), SdgGate()),
+                            (SXGate(), SXdgGate()),
+                        ]
+                    ),
+                    ContractIdleWiresInControlFlow(),
+                ]
             )
             init.append(CommutativeCancellation())
             init.append(ConsolidateBlocks())
@@ -188,42 +191,52 @@ class DefaultInitPassManager(PassManagerStagePlugin):
             # error rates in the target. However, in the init stage we don't yet know the target
             # qubits being used to figure out the fidelity so just use the default fidelity parameter
             # in this case.
+            split_2q_unitaries_swap = False
+            if pass_manager_config.routing_method != "none":
+                split_2q_unitaries_swap = True
             if pass_manager_config.approximation_degree is not None:
-                init.append(Split2QUnitaries(pass_manager_config.approximation_degree))
+                init.append(
+                    Split2QUnitaries(
+                        pass_manager_config.approximation_degree, split_swap=split_2q_unitaries_swap
+                    )
+                )
             else:
-                init.append(Split2QUnitaries())
+                init.append(Split2QUnitaries(split_swap=split_2q_unitaries_swap))
         else:
             raise TranspilerError(f"Invalid optimization level {optimization_level}")
         return init
 
 
+class DefaultTranslationPassManager(PassManagerStagePlugin):
+    """Plugin class for the default-method translation stage."""
+
+    def pass_manager(self, pass_manager_config, optimization_level=None) -> PassManager:
+        # For now, this is just a wrapper around the `BasisTranslator`.  It might expand in the
+        # future if we want to change the default method to do more context-aware switching, or to
+        # start transitioning the default method without breaking the semantics of the default
+        # string referring to the `BasisTranslator`.
+        return BasisTranslatorPassManager().pass_manager(pass_manager_config, optimization_level)
+
+
 class BasisTranslatorPassManager(PassManagerStagePlugin):
     """Plugin class for translation stage with :class:`~.BasisTranslator`"""
 
     def pass_manager(self, pass_manager_config, optimization_level=None) -> PassManager:
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*argument ``backend_properties`` is deprecated as of Qiskit 1.4",
-                module="qiskit",
-            )
-            return common.generate_translation_passmanager(
-                pass_manager_config.target,
-                basis_gates=pass_manager_config.basis_gates,
-                method="translator",
-                approximation_degree=pass_manager_config.approximation_degree,
-                coupling_map=pass_manager_config.coupling_map,
-                backend_props=pass_manager_config.backend_properties,
-                unitary_synthesis_method=pass_manager_config.unitary_synthesis_method,
-                unitary_synthesis_plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
-                hls_config=pass_manager_config.hls_config,
-                qubits_initially_zero=pass_manager_config.qubits_initially_zero,
-            )
+        return common.generate_translation_passmanager(
+            pass_manager_config.target,
+            basis_gates=pass_manager_config.basis_gates,
+            method="translator",
+            approximation_degree=pass_manager_config.approximation_degree,
+            coupling_map=pass_manager_config.coupling_map,
+            unitary_synthesis_method=pass_manager_config.unitary_synthesis_method,
+            unitary_synthesis_plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
+            hls_config=pass_manager_config.hls_config,
+            qubits_initially_zero=pass_manager_config.qubits_initially_zero,
+        )
 
 
 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(
@@ -232,7 +245,6 @@ class UnitarySynthesisPassManager(PassManagerStagePlugin):
             method="synthesis",
             approximation_degree=pass_manager_config.approximation_degree,
             coupling_map=pass_manager_config.coupling_map,
-            backend_props=pass_manager_config.backend_properties,
             unitary_synthesis_method=pass_manager_config.unitary_synthesis_method,
             unitary_synthesis_plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
             hls_config=pass_manager_config.hls_config,
@@ -240,6 +252,17 @@ class UnitarySynthesisPassManager(PassManagerStagePlugin):
         )
 
 
+class DefaultRoutingPassManager(PassManagerStagePlugin):
+    """Plugin class for the "default" routing stage implementation."""
+
+    def pass_manager(self, pass_manager_config, optimization_level=None) -> PassManager:
+        # The Sabre-based PM is the default implementation currently, but semantically the "default"
+        # plugin has more scope to change its logic than one called "sabre".  In practice, we don't
+        # run the actually `SabreSwap` logic from this pass most of the time, because we do that
+        # during default layout; we're looking for the VF2PostLayout stuff mostly.
+        return SabreSwapPassManager().pass_manager(pass_manager_config, optimization_level)
+
+
 class BasicSwapPassManager(PassManagerStagePlugin):
     """Plugin class for routing stage with :class:`~.BasicSwap`"""
 
@@ -247,7 +270,6 @@ class BasicSwapPassManager(PassManagerStagePlugin):
         """Build routing stage PassManager."""
         target = pass_manager_config.target
         coupling_map = pass_manager_config.coupling_map
-        backend_properties = pass_manager_config.backend_properties
         if target is None:
             routing_pass = BasicSwap(coupling_map)
         else:
@@ -273,7 +295,6 @@ class BasicSwapPassManager(PassManagerStagePlugin):
                 coupling_map,
                 vf2_call_limit=vf2_call_limit,
                 vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
                 seed_transpiler=-1,
                 check_trivial=True,
                 use_barrier_before_measurement=True,
@@ -285,7 +306,6 @@ class BasicSwapPassManager(PassManagerStagePlugin):
                 coupling_map=coupling_map,
                 vf2_call_limit=vf2_call_limit,
                 vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
                 seed_transpiler=-1,
                 use_barrier_before_measurement=True,
             )
@@ -296,63 +316,6 @@ class BasicSwapPassManager(PassManagerStagePlugin):
                 coupling_map=coupling_map,
                 vf2_call_limit=vf2_call_limit,
                 vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
-                seed_transpiler=-1,
-                use_barrier_before_measurement=True,
-            )
-        raise TranspilerError(f"Invalid optimization level specified: {optimization_level}")
-
-
-class StochasticSwapPassManager(PassManagerStagePlugin):
-    """Plugin class for routing stage with :class:`~.StochasticSwap`"""
-
-    def pass_manager(self, pass_manager_config, optimization_level=None) -> PassManager:
-        """Build routing stage PassManager."""
-        seed_transpiler = pass_manager_config.seed_transpiler
-        target = pass_manager_config.target
-        coupling_map = pass_manager_config.coupling_map
-        coupling_map_routing = target
-        if coupling_map_routing is None:
-            coupling_map_routing = coupling_map
-        backend_properties = pass_manager_config.backend_properties
-        vf2_call_limit, vf2_max_trials = common.get_vf2_limits(
-            optimization_level,
-            pass_manager_config.layout_method,
-            pass_manager_config.initial_layout,
-        )
-        if optimization_level == 3:
-            routing_pass = StochasticSwap(coupling_map_routing, trials=200, seed=seed_transpiler)
-        else:
-            routing_pass = StochasticSwap(coupling_map_routing, trials=20, seed=seed_transpiler)
-
-        if optimization_level == 0:
-            return common.generate_routing_passmanager(
-                routing_pass,
-                target,
-                coupling_map=coupling_map,
-                seed_transpiler=-1,
-                use_barrier_before_measurement=True,
-            )
-        if optimization_level == 1:
-            return common.generate_routing_passmanager(
-                routing_pass,
-                target,
-                coupling_map,
-                vf2_call_limit=vf2_call_limit,
-                vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
-                seed_transpiler=-1,
-                check_trivial=True,
-                use_barrier_before_measurement=True,
-            )
-        if optimization_level in {2, 3}:
-            return common.generate_routing_passmanager(
-                routing_pass,
-                target,
-                coupling_map=coupling_map,
-                vf2_call_limit=vf2_call_limit,
-                vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
                 seed_transpiler=-1,
                 use_barrier_before_measurement=True,
             )
@@ -369,7 +332,6 @@ class LookaheadSwapPassManager(PassManagerStagePlugin):
         coupling_map_routing = target
         if coupling_map_routing is None:
             coupling_map_routing = coupling_map
-        backend_properties = pass_manager_config.backend_properties
         vf2_call_limit, vf2_max_trials = common.get_vf2_limits(
             optimization_level,
             pass_manager_config.layout_method,
@@ -392,7 +354,6 @@ class LookaheadSwapPassManager(PassManagerStagePlugin):
                 coupling_map,
                 vf2_call_limit=vf2_call_limit,
                 vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
                 seed_transpiler=-1,
                 check_trivial=True,
                 use_barrier_before_measurement=True,
@@ -405,7 +366,6 @@ class LookaheadSwapPassManager(PassManagerStagePlugin):
                 coupling_map=coupling_map,
                 vf2_call_limit=vf2_call_limit,
                 vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
                 seed_transpiler=-1,
                 use_barrier_before_measurement=True,
             )
@@ -417,7 +377,6 @@ class LookaheadSwapPassManager(PassManagerStagePlugin):
                 coupling_map=coupling_map,
                 vf2_call_limit=vf2_call_limit,
                 vf2_max_trials=vf2_max_trials,
-                backend_properties=backend_properties,
                 seed_transpiler=-1,
                 use_barrier_before_measurement=True,
             )
@@ -435,7 +394,6 @@ class SabreSwapPassManager(PassManagerStagePlugin):
         coupling_map_routing = target
         if coupling_map_routing is None:
             coupling_map_routing = coupling_map
-        backend_properties = pass_manager_config.backend_properties
         vf2_call_limit, vf2_max_trials = common.get_vf2_limits(
             optimization_level,
             pass_manager_config.layout_method,
@@ -464,24 +422,16 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 seed=seed_transpiler,
                 trials=trial_count,
             )
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*argument ``backend_properties`` is deprecated as of Qiskit 1.4",
-                    module="qiskit",
-                )
-                return common.generate_routing_passmanager(
-                    routing_pass,
-                    target,
-                    coupling_map,
-                    vf2_call_limit=vf2_call_limit,
-                    vf2_max_trials=vf2_max_trials,
-                    backend_properties=backend_properties,
-                    seed_transpiler=-1,
-                    check_trivial=True,
-                    use_barrier_before_measurement=True,
-                )
+            return common.generate_routing_passmanager(
+                routing_pass,
+                target,
+                coupling_map,
+                vf2_call_limit=vf2_call_limit,
+                vf2_max_trials=vf2_max_trials,
+                seed_transpiler=-1,
+                check_trivial=True,
+                use_barrier_before_measurement=True,
+            )
         if optimization_level == 2:
             trial_count = _get_trial_count(20)
 
@@ -491,23 +441,15 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 seed=seed_transpiler,
                 trials=trial_count,
             )
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*argument ``backend_properties`` is deprecated as of Qiskit 1.4",
-                    module="qiskit",
-                )
-                return common.generate_routing_passmanager(
-                    routing_pass,
-                    target,
-                    coupling_map=coupling_map,
-                    vf2_call_limit=vf2_call_limit,
-                    vf2_max_trials=vf2_max_trials,
-                    backend_properties=backend_properties,
-                    seed_transpiler=-1,
-                    use_barrier_before_measurement=True,
-                )
+            return common.generate_routing_passmanager(
+                routing_pass,
+                target,
+                coupling_map=coupling_map,
+                vf2_call_limit=vf2_call_limit,
+                vf2_max_trials=vf2_max_trials,
+                seed_transpiler=-1,
+                use_barrier_before_measurement=True,
+            )
         if optimization_level == 3:
             trial_count = _get_trial_count(20)
             routing_pass = SabreSwap(
@@ -516,23 +458,15 @@ class SabreSwapPassManager(PassManagerStagePlugin):
                 seed=seed_transpiler,
                 trials=trial_count,
             )
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*argument ``backend_properties`` is deprecated as of Qiskit 1.4",
-                    module="qiskit",
-                )
-                return common.generate_routing_passmanager(
-                    routing_pass,
-                    target,
-                    coupling_map=coupling_map,
-                    vf2_call_limit=vf2_call_limit,
-                    vf2_max_trials=vf2_max_trials,
-                    backend_properties=backend_properties,
-                    seed_transpiler=-1,
-                    use_barrier_before_measurement=True,
-                )
+            return common.generate_routing_passmanager(
+                routing_pass,
+                target,
+                coupling_map=coupling_map,
+                vf2_call_limit=vf2_call_limit,
+                vf2_max_trials=vf2_max_trials,
+                seed_transpiler=-1,
+                use_barrier_before_measurement=True,
+            )
         raise TranspilerError(f"Invalid optimization level specified: {optimization_level}")
 
 
@@ -563,7 +497,7 @@ class OptimizationPassManager(PassManagerStagePlugin):
     def pass_manager(self, pass_manager_config, optimization_level=None) -> PassManager:
         """Build pass manager for optimization stage."""
         # Obtain the translation method required for this pass to work
-        translation_method = pass_manager_config.translation_method or "translator"
+        translation_method = pass_manager_config.translation_method or "default"
         optimization = PassManager()
         if optimization_level != 0:
             plugin_manager = PassManagerStagePluginManager()
@@ -587,8 +521,12 @@ class OptimizationPassManager(PassManagerStagePlugin):
                 pass_manager_config,
                 optimization_level=optimization_level,
             )
+
+            # Basic steps for optimization level 1:
+            # 1. Optimize1qGatesDecomposition
+            # 2. InverseCancellation
             if optimization_level == 1:
-                # Steps for optimization level 1
+
                 _opt = [
                     Optimize1qGatesDecomposition(
                         basis=pass_manager_config.basis_gates, target=pass_manager_config.target
@@ -609,8 +547,13 @@ class OptimizationPassManager(PassManagerStagePlugin):
                             (SXGate(), SXdgGate()),
                         ]
                     ),
+                    ContractIdleWiresInControlFlow(),
                 ]
 
+            # Basic steps for optimization level 2:
+            # 1. RemoveIdentityEquivalent
+            # 2. Optimize1qGatesDecomposition
+            # 3. CommutativeCancellation
             elif optimization_level == 2:
                 _opt = [
                     RemoveIdentityEquivalent(
@@ -621,40 +564,40 @@ class OptimizationPassManager(PassManagerStagePlugin):
                         basis=pass_manager_config.basis_gates, target=pass_manager_config.target
                     ),
                     CommutativeCancellation(target=pass_manager_config.target),
+                    ContractIdleWiresInControlFlow(),
                 ]
+
+            # Basic steps for optimization level 3:
+            # 1. ConsolidateBlocks
+            # 2. UnitarySynthesis
+            # 3. RemoveIdentityEquivalent
+            # 4. Optimize1qGatesDecomposition
+            # 5. CommutativeCancellation
             elif optimization_level == 3:
-                # Steps for optimization level 3
-                with warnings.catch_warnings():
-                    warnings.filterwarnings(
-                        "ignore",
-                        category=DeprecationWarning,
-                        message=".*argument ``backend_props`` is deprecated as of Qiskit 1.4",
-                        module="qiskit",
-                    )
-                    _opt = [
-                        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,
-                        ),
-                        RemoveIdentityEquivalent(
-                            approximation_degree=pass_manager_config.approximation_degree,
-                            target=pass_manager_config.target,
-                        ),
-                        Optimize1qGatesDecomposition(
-                            basis=pass_manager_config.basis_gates, target=pass_manager_config.target
-                        ),
-                        CommutativeCancellation(target=pass_manager_config.target),
-                    ]
+                _opt = [
+                    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,
+                        method=pass_manager_config.unitary_synthesis_method,
+                        plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
+                        target=pass_manager_config.target,
+                    ),
+                    RemoveIdentityEquivalent(
+                        approximation_degree=pass_manager_config.approximation_degree,
+                        target=pass_manager_config.target,
+                    ),
+                    Optimize1qGatesDecomposition(
+                        basis=pass_manager_config.basis_gates, target=pass_manager_config.target
+                    ),
+                    CommutativeCancellation(target=pass_manager_config.target),
+                    ContractIdleWiresInControlFlow(),
+                ]
 
                 def _opt_control(property_set):
                     return not property_set["optimization_loop_minimum_point"]
@@ -664,11 +607,11 @@ class OptimizationPassManager(PassManagerStagePlugin):
 
             unroll = translation.to_flow_controller()
 
-            # Build nested Flow controllers
+            # Build nested flow controllers
             def _unroll_condition(property_set):
                 return not property_set["all_gates_in_basis"]
 
-            # Check if any gate is not in the basis, and if so, run unroll passes
+            # Check if any gate is not in the basis, and if so, run unroll/translation passes
             _unroll_if_out_of_basis = [
                 GatesInBasis(pass_manager_config.basis_gates, target=pass_manager_config.target),
                 ConditionalController(unroll, condition=_unroll_condition),
@@ -677,31 +620,23 @@ class OptimizationPassManager(PassManagerStagePlugin):
             if optimization_level == 3:
                 optimization.append(_minimum_point_check)
             elif optimization_level == 2:
-                with warnings.catch_warnings():
-                    warnings.filterwarnings(
-                        "ignore",
-                        category=DeprecationWarning,
-                        message=".*argument ``backend_props`` is deprecated as of Qiskit 1.4",
-                        module="qiskit",
-                    )
-                    optimization.append(
-                        [
-                            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,
-                            ),
-                        ]
-                    )
+                optimization.append(
+                    [
+                        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,
+                            method=pass_manager_config.unitary_synthesis_method,
+                            plugin_config=pass_manager_config.unitary_synthesis_plugin_config,
+                            target=pass_manager_config.target,
+                        ),
+                    ]
+                )
                 optimization.append(_depth_check + _size_check)
             else:
                 optimization.append(_depth_check + _size_check)
@@ -725,16 +660,11 @@ class AlapSchedulingPassManager(PassManagerStagePlugin):
         instruction_durations = pass_manager_config.instruction_durations
         scheduling_method = pass_manager_config.scheduling_method
         timing_constraints = pass_manager_config.timing_constraints
-        inst_map = pass_manager_config.inst_map
         target = pass_manager_config.target
 
-        with warnings.catch_warnings():
-            warnings.simplefilter(action="ignore", category=DeprecationWarning)
-            # Passing `inst_map` to `generate_scheduling` is deprecated in Qiskit 1.3
-            # so filtering these warning when building pass managers
-            return common.generate_scheduling(
-                instruction_durations, scheduling_method, timing_constraints, inst_map, target
-            )
+        return common.generate_scheduling(
+            instruction_durations, scheduling_method, timing_constraints, target
+        )
 
 
 class AsapSchedulingPassManager(PassManagerStagePlugin):
@@ -746,16 +676,11 @@ class AsapSchedulingPassManager(PassManagerStagePlugin):
         instruction_durations = pass_manager_config.instruction_durations
         scheduling_method = pass_manager_config.scheduling_method
         timing_constraints = pass_manager_config.timing_constraints
-        inst_map = pass_manager_config.inst_map
         target = pass_manager_config.target
 
-        with warnings.catch_warnings():
-            warnings.simplefilter(action="ignore", category=DeprecationWarning)
-            # Passing `inst_map` to `generate_scheduling` is deprecated in Qiskit 1.3
-            # so filtering these warning when building pass managers
-            return common.generate_scheduling(
-                instruction_durations, scheduling_method, timing_constraints, inst_map, target
-            )
+        return common.generate_scheduling(
+            instruction_durations, scheduling_method, timing_constraints, target
+        )
 
 
 class DefaultSchedulingPassManager(PassManagerStagePlugin):
@@ -767,16 +692,11 @@ class DefaultSchedulingPassManager(PassManagerStagePlugin):
         instruction_durations = pass_manager_config.instruction_durations
         scheduling_method = None
         timing_constraints = pass_manager_config.timing_constraints or TimingConstraints()
-        inst_map = pass_manager_config.inst_map
         target = pass_manager_config.target
 
-        with warnings.catch_warnings():
-            warnings.simplefilter(action="ignore", category=DeprecationWarning)
-            # Passing `inst_map` to `generate_scheduling` is deprecated in Qiskit 1.3
-            # so filtering these warning when building pass managers
-            return common.generate_scheduling(
-                instruction_durations, scheduling_method, timing_constraints, inst_map, target
-            )
+        return common.generate_scheduling(
+            instruction_durations, scheduling_method, timing_constraints, target
+        )
 
 
 class DefaultLayoutPassManager(PassManagerStagePlugin):
@@ -830,21 +750,13 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                     condition=_choose_layout_condition,
                 )
             )
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*argument ``properties`` is deprecated as of Qiskit 1.4",
-                    module="qiskit",
-                )
-                choose_layout_1 = VF2Layout(
-                    coupling_map=pass_manager_config.coupling_map,
-                    seed=-1,
-                    call_limit=int(5e4),  # Set call limit to ~100ms with rustworkx 0.10.2
-                    properties=pass_manager_config.backend_properties,
-                    target=pass_manager_config.target,
-                    max_trials=2500,  # Limits layout scoring to < 600ms on ~400 qubit devices
-                )
+            choose_layout_1 = VF2Layout(
+                coupling_map=pass_manager_config.coupling_map,
+                seed=-1,
+                call_limit=int(5e4),  # Set call limit to ~100ms with rustworkx 0.10.2
+                target=pass_manager_config.target,
+                max_trials=2500,  # Limits layout scoring to < 600ms on ~400 qubit devices
+            )
             layout.append(ConditionalController(choose_layout_1, condition=_layout_not_perfect))
 
             trial_count = _get_trial_count(5)
@@ -855,8 +767,7 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                 seed=pass_manager_config.seed_transpiler,
                 swap_trials=trial_count,
                 layout_trials=trial_count,
-                skip_routing=pass_manager_config.routing_method is not None
-                and pass_manager_config.routing_method != "sabre",
+                skip_routing=pass_manager_config.routing_method not in (None, "default", "sabre"),
             )
             layout.append(
                 ConditionalController(
@@ -870,21 +781,13 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                 )
             )
         elif optimization_level == 2:
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*argument ``properties`` is deprecated as of Qiskit 1.4",
-                    module="qiskit",
-                )
-                choose_layout_0 = VF2Layout(
-                    coupling_map=pass_manager_config.coupling_map,
-                    seed=-1,
-                    call_limit=int(5e6),  # Set call limit to ~10s with rustworkx 0.10.2
-                    properties=pass_manager_config.backend_properties,
-                    target=pass_manager_config.target,
-                    max_trials=2500,  # Limits layout scoring to < 600ms on ~400 qubit devices
-                )
+            choose_layout_0 = VF2Layout(
+                coupling_map=pass_manager_config.coupling_map,
+                seed=-1,
+                call_limit=int(5e6),  # Set call limit to ~10s with rustworkx 0.10.2
+                target=pass_manager_config.target,
+                max_trials=2500,  # Limits layout scoring to < 600ms on ~400 qubit devices
+            )
             layout.append(
                 ConditionalController(choose_layout_0, condition=_choose_layout_condition)
             )
@@ -897,8 +800,7 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                 seed=pass_manager_config.seed_transpiler,
                 swap_trials=trial_count,
                 layout_trials=trial_count,
-                skip_routing=pass_manager_config.routing_method is not None
-                and pass_manager_config.routing_method != "sabre",
+                skip_routing=pass_manager_config.routing_method not in (None, "default", "sabre"),
             )
             layout.append(
                 ConditionalController(
@@ -912,21 +814,13 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                 )
             )
         elif optimization_level == 3:
-            with warnings.catch_warnings():
-                warnings.filterwarnings(
-                    "ignore",
-                    category=DeprecationWarning,
-                    message=".*argument ``properties`` is deprecated as of Qiskit 1.4",
-                    module="qiskit",
-                )
-                choose_layout_0 = VF2Layout(
-                    coupling_map=pass_manager_config.coupling_map,
-                    seed=-1,
-                    call_limit=int(3e7),  # Set call limit to ~60s with rustworkx 0.10.2
-                    properties=pass_manager_config.backend_properties,
-                    target=pass_manager_config.target,
-                    max_trials=250000,  # Limits layout scoring to < 60s on ~400 qubit devices
-                )
+            choose_layout_0 = VF2Layout(
+                coupling_map=pass_manager_config.coupling_map,
+                seed=-1,
+                call_limit=int(3e7),  # Set call limit to ~60s with rustworkx 0.10.2
+                target=pass_manager_config.target,
+                max_trials=250000,  # Limits layout scoring to < 60s on ~400 qubit devices
+            )
             layout.append(
                 ConditionalController(choose_layout_0, condition=_choose_layout_condition)
             )
@@ -939,8 +833,7 @@ class DefaultLayoutPassManager(PassManagerStagePlugin):
                 seed=pass_manager_config.seed_transpiler,
                 swap_trials=trial_count,
                 layout_trials=trial_count,
-                skip_routing=pass_manager_config.routing_method is not None
-                and pass_manager_config.routing_method != "sabre",
+                skip_routing=pass_manager_config.routing_method not in (None, "default", "sabre"),
             )
             layout.append(
                 ConditionalController(
@@ -1000,23 +893,15 @@ class DenseLayoutPassManager(PassManagerStagePlugin):
 
         layout = PassManager()
         layout.append(_given_layout)
-        with warnings.catch_warnings():
-            warnings.filterwarnings(
-                "ignore",
-                category=DeprecationWarning,
-                message=".*argument ``backend_prop`` is deprecated as of Qiskit 1.4",
-                module="qiskit",
-            )
-            layout.append(
-                ConditionalController(
-                    DenseLayout(
-                        coupling_map=pass_manager_config.coupling_map,
-                        backend_prop=pass_manager_config.backend_properties,
-                        target=pass_manager_config.target,
-                    ),
-                    condition=_choose_layout_condition,
-                )
+        layout.append(
+            ConditionalController(
+                DenseLayout(
+                    coupling_map=pass_manager_config.coupling_map,
+                    target=pass_manager_config.target,
+                ),
+                condition=_choose_layout_condition,
             )
+        )
         layout += common.generate_embed_passmanager(coupling_map)
         return layout
 
@@ -1049,8 +934,7 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
                 seed=pass_manager_config.seed_transpiler,
                 swap_trials=trial_count,
                 layout_trials=trial_count,
-                skip_routing=pass_manager_config.routing_method is not None
-                and pass_manager_config.routing_method != "sabre",
+                skip_routing=pass_manager_config.routing_method not in (None, "default", "sabre"),
             )
         elif optimization_level == 1:
             trial_count = _get_trial_count(5)
@@ -1061,8 +945,7 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
                 seed=pass_manager_config.seed_transpiler,
                 swap_trials=trial_count,
                 layout_trials=trial_count,
-                skip_routing=pass_manager_config.routing_method is not None
-                and pass_manager_config.routing_method != "sabre",
+                skip_routing=pass_manager_config.routing_method not in (None, "default", "sabre"),
             )
         elif optimization_level == 2:
             trial_count = _get_trial_count(20)
@@ -1073,8 +956,7 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
                 seed=pass_manager_config.seed_transpiler,
                 swap_trials=trial_count,
                 layout_trials=trial_count,
-                skip_routing=pass_manager_config.routing_method is not None
-                and pass_manager_config.routing_method != "sabre",
+                skip_routing=pass_manager_config.routing_method not in (None, "default", "sabre"),
             )
         elif optimization_level == 3:
             trial_count = _get_trial_count(20)
@@ -1085,8 +967,7 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
                 seed=pass_manager_config.seed_transpiler,
                 swap_trials=trial_count,
                 layout_trials=trial_count,
-                skip_routing=pass_manager_config.routing_method is not None
-                and pass_manager_config.routing_method != "sabre",
+                skip_routing=pass_manager_config.routing_method not in (None, "default", "sabre"),
             )
         else:
             raise TranspilerError(f"Invalid optimization level: {optimization_level}")
@@ -1108,5 +989,5 @@ class SabreLayoutPassManager(PassManagerStagePlugin):
 
 def _get_trial_count(default_trials=5):
     if CONFIG.get("sabre_all_threads", None) or os.getenv("QISKIT_SABRE_ALL_THREADS"):
-        return max(CPU_COUNT, default_trials)
+        return max(default_num_processes(), default_trials)
     return default_trials