qiskit 1.3.0b1__cp39-abi3-win32.whl → 1.3.0rc2__cp39-abi3-win32.whl

qiskit/transpiler/passes/synthesis/solovay_kitaev_synthesis.py

@@ -52,7 +52,7 @@ class SolovayKitaev(TransformationPass):
 
     For example, the following circuit
 
-    .. parsed-literal::
+    .. code-block:: text
 
              ┌─────────┐
         q_0: ┤ RX(0.8) ├
@@ -60,7 +60,7 @@ class SolovayKitaev(TransformationPass):
 
     can be decomposed into
 
-    .. parsed-literal::
+    .. code-block:: text
 
         global phase: 7π/8
              ┌───┐┌───┐┌───┐
@@ -95,7 +95,7 @@ class SolovayKitaev(TransformationPass):
 
             print("Error:", np.linalg.norm(Operator(circuit).data - Operator(discretized).data))
 
-        .. parsed-literal::
+        .. code-block:: text
 
             Original circuit:
                ┌─────────┐

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

@@ -73,6 +73,7 @@ from qiskit.transpiler.passes.optimization.optimize_1q_decomposition import (
 from qiskit.transpiler.passes.synthesis import plugin
 from qiskit.transpiler.target import Target
 
+from qiskit._accelerate.unitary_synthesis import run_default_main_loop
 
 GATE_NAME_MAP = {
     "cx": CXGate._standard_gate,
@@ -456,37 +457,6 @@ class UnitarySynthesis(TransformationPass):
             default_kwargs = {}
             method_list = [(plugin_method, plugin_kwargs), (default_method, default_kwargs)]
 
-        for method, kwargs in method_list:
-            if method.supports_basis_gates:
-                kwargs["basis_gates"] = self._basis_gates
-            if method.supports_natural_direction:
-                kwargs["natural_direction"] = self._natural_direction
-            if method.supports_pulse_optimize:
-                kwargs["pulse_optimize"] = self._pulse_optimize
-            if method.supports_gate_lengths:
-                _gate_lengths = _gate_lengths or _build_gate_lengths(
-                    self._backend_props, self._target
-                )
-                kwargs["gate_lengths"] = _gate_lengths
-            if method.supports_gate_errors:
-                _gate_errors = _gate_errors or _build_gate_errors(self._backend_props, self._target)
-                kwargs["gate_errors"] = _gate_errors
-            if method.supports_gate_lengths_by_qubit:
-                _gate_lengths_by_qubit = _gate_lengths_by_qubit or _build_gate_lengths_by_qubit(
-                    self._backend_props, self._target
-                )
-                kwargs["gate_lengths_by_qubit"] = _gate_lengths_by_qubit
-            if method.supports_gate_errors_by_qubit:
-                _gate_errors_by_qubit = _gate_errors_by_qubit or _build_gate_errors_by_qubit(
-                    self._backend_props, self._target
-                )
-                kwargs["gate_errors_by_qubit"] = _gate_errors_by_qubit
-            supported_bases = method.supported_bases
-            if supported_bases is not None:
-                kwargs["matched_basis"] = _choose_bases(self._basis_gates, supported_bases)
-            if method.supports_target:
-                kwargs["target"] = self._target
-
         # Handle approximation degree as a special case for backwards compatibility, it's
         # not part of the plugin interface and only something needed for the default
         # pass.
@@ -501,9 +471,60 @@ class UnitarySynthesis(TransformationPass):
             if plugin_method.supports_coupling_map or default_method.supports_coupling_map
             else {}
         )
-        return self._run_main_loop(
-            dag, qubit_indices, plugin_method, plugin_kwargs, default_method, default_kwargs
-        )
+
+        if self.method == "default" and self._target is not None:
+            _coupling_edges = (
+                set(self._coupling_map.get_edges()) if self._coupling_map is not None else set()
+            )
+
+            out = run_default_main_loop(
+                dag,
+                list(qubit_indices.values()),
+                self._min_qubits,
+                self._target,
+                _coupling_edges,
+                self._approximation_degree,
+                self._natural_direction,
+            )
+            return out
+        else:
+            for method, kwargs in method_list:
+                if method.supports_basis_gates:
+                    kwargs["basis_gates"] = self._basis_gates
+                if method.supports_natural_direction:
+                    kwargs["natural_direction"] = self._natural_direction
+                if method.supports_pulse_optimize:
+                    kwargs["pulse_optimize"] = self._pulse_optimize
+                if method.supports_gate_lengths:
+                    _gate_lengths = _gate_lengths or _build_gate_lengths(
+                        self._backend_props, self._target
+                    )
+                    kwargs["gate_lengths"] = _gate_lengths
+                if method.supports_gate_errors:
+                    _gate_errors = _gate_errors or _build_gate_errors(
+                        self._backend_props, self._target
+                    )
+                    kwargs["gate_errors"] = _gate_errors
+                if method.supports_gate_lengths_by_qubit:
+                    _gate_lengths_by_qubit = _gate_lengths_by_qubit or _build_gate_lengths_by_qubit(
+                        self._backend_props, self._target
+                    )
+                    kwargs["gate_lengths_by_qubit"] = _gate_lengths_by_qubit
+                if method.supports_gate_errors_by_qubit:
+                    _gate_errors_by_qubit = _gate_errors_by_qubit or _build_gate_errors_by_qubit(
+                        self._backend_props, self._target
+                    )
+                    kwargs["gate_errors_by_qubit"] = _gate_errors_by_qubit
+                supported_bases = method.supported_bases
+                if supported_bases is not None:
+                    kwargs["matched_basis"] = _choose_bases(self._basis_gates, supported_bases)
+                if method.supports_target:
+                    kwargs["target"] = self._target
+
+            out = self._run_main_loop(
+                dag, qubit_indices, plugin_method, plugin_kwargs, default_method, default_kwargs
+            )
+            return out
 
     def _run_main_loop(
         self, dag, qubit_indices, plugin_method, plugin_kwargs, default_method, default_kwargs

qiskit/transpiler/passes/utils/barrier_before_final_measurements.py

@@ -13,9 +13,8 @@
 
 """Add a barrier before final measurements."""
 
-from qiskit.circuit.barrier import Barrier
+from qiskit._accelerate.barrier_before_final_measurement import barrier_before_final_measurements
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.dagcircuit import DAGCircuit, DAGOpNode
 from .merge_adjacent_barriers import MergeAdjacentBarriers
 
 
@@ -33,60 +32,7 @@ class BarrierBeforeFinalMeasurements(TransformationPass):
 
     def run(self, dag):
         """Run the BarrierBeforeFinalMeasurements pass on `dag`."""
-        # Collect DAG nodes which are followed only by barriers or other measures.
-        final_op_types = ["measure", "barrier"]
-        final_ops = []
-        for candidate_node in dag.named_nodes(*final_op_types):
-            is_final_op = True
-
-            for _, child_successors in dag.bfs_successors(candidate_node):
-
-                if any(
-                    isinstance(suc, DAGOpNode) and suc.name not in final_op_types
-                    for suc in child_successors
-                ):
-                    is_final_op = False
-                    break
-
-            if is_final_op:
-                final_ops.append(candidate_node)
-
-        if not final_ops:
-            return dag
-
-        # Create a layer with the barrier and add both bits and registers from the original dag.
-        barrier_layer = DAGCircuit()
-        barrier_layer.add_qubits(dag.qubits)
-        for qreg in dag.qregs.values():
-            barrier_layer.add_qreg(qreg)
-        barrier_layer.add_clbits(dag.clbits)
-        for creg in dag.cregs.values():
-            barrier_layer.add_creg(creg)
-
-        # Add a barrier across all qubits so swap mapper doesn't add a swap
-        # from an unmeasured qubit after a measure.
-        final_qubits = dag.qubits
-
-        barrier_layer.apply_operation_back(
-            Barrier(len(final_qubits), label=self.label), final_qubits, (), check=False
-        )
-
-        # Preserve order of final ops collected earlier from the original DAG.
-        ordered_final_nodes = [
-            node for node in dag.topological_op_nodes() if node in set(final_ops)
-        ]
-
-        # Move final ops to the new layer and append the new layer to the DAG.
-        for final_node in ordered_final_nodes:
-            barrier_layer.apply_operation_back(
-                final_node.op, final_node.qargs, final_node.cargs, check=False
-            )
-
-        for final_op in final_ops:
-            dag.remove_op_node(final_op)
-
-        dag.compose(barrier_layer)
-
+        barrier_before_final_measurements(dag, self.label)
         if self.label is None:
             # Merge the new barrier into any other barriers
             adjacent_pass = MergeAdjacentBarriers()

qiskit/transpiler/passes/utils/convert_conditions_to_if_ops.py

@@ -22,6 +22,7 @@ from qiskit.circuit import (
 )
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.utils import deprecate_func
 
 
 class ConvertConditionsToIfOps(TransformationPass):
@@ -31,6 +32,10 @@ class ConvertConditionsToIfOps(TransformationPass):
     This is a simple pass aimed at easing the conversion from the old style of using
     :meth:`.InstructionSet.c_if` into the new style of using more complex conditional logic."""
 
+    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0")
+    def __init__(self):
+        super().__init__()
+
     def _run_inner(self, dag):
         """Run the pass on one :class:`.DAGCircuit`, mutating it.  Returns ``True`` if the circuit
         was modified and ``False`` if not."""

qiskit/transpiler/passes/utils/gate_direction.py

@@ -10,40 +10,17 @@
 # copyright notice, and modified files need to carry a notice indicating
 # that they have been altered from the originals.
 
-"""Rearrange the direction of the cx nodes to match the directed coupling map."""
-
-from math import pi
+"""Rearrange the direction of the 2-qubit gate nodes to match the directed coupling map."""
 
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.transpiler.exceptions import TranspilerError
-
-from qiskit.converters import dag_to_circuit, circuit_to_dag
-from qiskit.circuit import QuantumRegister, ControlFlowOp
-from qiskit.dagcircuit import DAGCircuit, DAGOpNode
-from qiskit.circuit.library.standard_gates import (
-    SGate,
-    SdgGate,
-    SXGate,
-    HGate,
-    CXGate,
-    CZGate,
-    ECRGate,
-    RXXGate,
-    RYYGate,
-    RZZGate,
-    RZXGate,
-    SwapGate,
-)
-
-
-def _swap_node_qargs(node):
-    return DAGOpNode(node.op, node.qargs[::-1], node.cargs)
+from qiskit._accelerate.gate_direction import fix_gate_direction_coupling, fix_gate_direction_target
 
 
 class GateDirection(TransformationPass):
     """Modify asymmetric gates to match the hardware coupling direction.
 
-    This pass makes use of the following identities::
+    This pass supports replacements for the `cx`, `cz`, `ecr`, `swap`, `rzx`, `rxx`, `ryy` and
+    `rzz` gates, using the following identities::
 
                              ┌───┐┌───┐┌───┐
         q_0: ──■──      q_0: ┤ H ├┤ X ├┤ H ├
@@ -58,6 +35,9 @@ class GateDirection(TransformationPass):
              │  ECR │  =       ┌┴───┴┐├────┤└┬───┬┘│  Ecr │├───┤
         q_1: ┤1     ├     q_1: ┤ Sdg ├┤ √X ├─┤ S ├─┤0     ├┤ H ├
              └──────┘          └─────┘└────┘ └───┘ └──────┘└───┘
+        Note: This is done in terms of less-efficient S/SX/Sdg gates instead of the more natural
+        `RY(pi /2)` so we have a chance for basis translation to keep things in a discrete basis
+        during resynthesis, if that's what's being asked for.
 
 
              ┌──────┐          ┌───┐┌──────┐┌───┐
@@ -66,18 +46,18 @@ class GateDirection(TransformationPass):
         q_1: ┤1     ├     q_1: ┤ H ├┤0     ├┤ H ├
              └──────┘          └───┘└──────┘└───┘
 
+        cz, swap, rxx, ryy and rzz directions are fixed by reversing their qargs order.
+
     This pass assumes that the positions of the qubits in the :attr:`.DAGCircuit.qubits` attribute
     are the physical qubit indices. For example if ``dag.qubits[0]`` is qubit 0 in the
     :class:`.CouplingMap` or :class:`.Target`.
     """
 
-    _KNOWN_REPLACEMENTS = frozenset(["cx", "cz", "ecr", "swap", "rzx", "rxx", "ryy", "rzz"])
-
     def __init__(self, coupling_map, target=None):
         """GateDirection pass.
 
         Args:
-            coupling_map (CouplingMap): Directed graph represented a coupling map.
+            coupling_map (CouplingMap): Directed graph representing a coupling map.
             target (Target): The backend target to use for this pass. If this is specified
                 it will be used instead of the coupling map
         """
@@ -85,248 +65,6 @@ class GateDirection(TransformationPass):
         self.coupling_map = coupling_map
         self.target = target
 
-        # Create the replacement dag and associated register.
-        self._cx_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        self._cx_dag.add_qreg(qr)
-        self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
-        self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
-        self._cx_dag.apply_operation_back(CXGate(), [qr[1], qr[0]], [])
-        self._cx_dag.apply_operation_back(HGate(), [qr[0]], [])
-        self._cx_dag.apply_operation_back(HGate(), [qr[1]], [])
-
-        # This is done in terms of less-efficient S/SX/Sdg gates instead of the more natural
-        # `RY(pi /2)` so we have a chance for basis translation to keep things in a discrete basis
-        # during resynthesis, if that's what's being asked for.
-        self._ecr_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        self._ecr_dag.global_phase = -pi / 2
-        self._ecr_dag.add_qreg(qr)
-        self._ecr_dag.apply_operation_back(SGate(), [qr[0]], [])
-        self._ecr_dag.apply_operation_back(SXGate(), [qr[0]], [])
-        self._ecr_dag.apply_operation_back(SdgGate(), [qr[0]], [])
-        self._ecr_dag.apply_operation_back(SdgGate(), [qr[1]], [])
-        self._ecr_dag.apply_operation_back(SXGate(), [qr[1]], [])
-        self._ecr_dag.apply_operation_back(SGate(), [qr[1]], [])
-        self._ecr_dag.apply_operation_back(ECRGate(), [qr[1], qr[0]], [])
-        self._ecr_dag.apply_operation_back(HGate(), [qr[0]], [])
-        self._ecr_dag.apply_operation_back(HGate(), [qr[1]], [])
-
-        self._cz_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        self._cz_dag.add_qreg(qr)
-        self._cz_dag.apply_operation_back(CZGate(), [qr[1], qr[0]], [])
-
-        self._swap_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        self._swap_dag.add_qreg(qr)
-        self._swap_dag.apply_operation_back(SwapGate(), [qr[1], qr[0]], [])
-
-        # If adding more replacements (either static or dynamic), also update the class variable
-        # `_KNOWN_REPLACMENTS` to include them in the error messages.
-        self._static_replacements = {
-            "cx": self._cx_dag,
-            "cz": self._cz_dag,
-            "ecr": self._ecr_dag,
-            "swap": self._swap_dag,
-        }
-
-    @staticmethod
-    def _rzx_dag(parameter):
-        _rzx_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        _rzx_dag.add_qreg(qr)
-        _rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
-        _rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
-        _rzx_dag.apply_operation_back(RZXGate(parameter), [qr[1], qr[0]], [])
-        _rzx_dag.apply_operation_back(HGate(), [qr[0]], [])
-        _rzx_dag.apply_operation_back(HGate(), [qr[1]], [])
-        return _rzx_dag
-
-    @staticmethod
-    def _rxx_dag(parameter):
-        _rxx_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        _rxx_dag.add_qreg(qr)
-        _rxx_dag.apply_operation_back(RXXGate(parameter), [qr[1], qr[0]], [])
-        return _rxx_dag
-
-    @staticmethod
-    def _ryy_dag(parameter):
-        _ryy_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        _ryy_dag.add_qreg(qr)
-        _ryy_dag.apply_operation_back(RYYGate(parameter), [qr[1], qr[0]], [])
-        return _ryy_dag
-
-    @staticmethod
-    def _rzz_dag(parameter):
-        _rzz_dag = DAGCircuit()
-        qr = QuantumRegister(2)
-        _rzz_dag.add_qreg(qr)
-        _rzz_dag.apply_operation_back(RZZGate(parameter), [qr[1], qr[0]], [])
-        return _rzz_dag
-
-    def _run_coupling_map(self, dag, wire_map, edges=None):
-        if edges is None:
-            edges = set(self.coupling_map.get_edges())
-        if not edges:
-            return dag
-        # Don't include directives to avoid things like barrier, which are assumed always supported.
-        for node in dag.op_nodes(include_directives=False):
-            if isinstance(node.op, ControlFlowOp):
-                new_op = node.op.replace_blocks(
-                    dag_to_circuit(
-                        self._run_coupling_map(
-                            circuit_to_dag(block),
-                            {
-                                inner: wire_map[outer]
-                                for outer, inner in zip(node.qargs, block.qubits)
-                            },
-                            edges,
-                        )
-                    )
-                    for block in node.op.blocks
-                )
-                dag.substitute_node(node, new_op, propagate_condition=False)
-                continue
-            if len(node.qargs) != 2:
-                continue
-            if dag.has_calibration_for(node):
-                continue
-            qargs = (wire_map[node.qargs[0]], wire_map[node.qargs[1]])
-            if qargs not in edges and (qargs[1], qargs[0]) not in edges:
-                raise TranspilerError(
-                    f"The circuit requires a connection between physical qubits {qargs}"
-                )
-            if qargs not in edges:
-                replacement = self._static_replacements.get(node.name)
-                if replacement is not None:
-                    dag.substitute_node_with_dag(node, replacement)
-                elif node.name == "rzx":
-                    dag.substitute_node_with_dag(node, self._rzx_dag(*node.op.params))
-                elif node.name == "rxx":
-                    dag.substitute_node_with_dag(node, self._rxx_dag(*node.op.params))
-                elif node.name == "ryy":
-                    dag.substitute_node_with_dag(node, self._ryy_dag(*node.op.params))
-                elif node.name == "rzz":
-                    dag.substitute_node_with_dag(node, self._rzz_dag(*node.op.params))
-                else:
-                    raise TranspilerError(
-                        f"'{node.name}' would be supported on '{qargs}' if the direction were"
-                        f" swapped, but no rules are known to do that."
-                        f" {list(self._KNOWN_REPLACEMENTS)} can be automatically flipped."
-                    )
-        return dag
-
-    def _run_target(self, dag, wire_map):
-        # Don't include directives to avoid things like barrier, which are assumed always supported.
-        for node in dag.op_nodes(include_directives=False):
-            if isinstance(node.op, ControlFlowOp):
-                new_op = node.op.replace_blocks(
-                    dag_to_circuit(
-                        self._run_target(
-                            circuit_to_dag(block),
-                            {
-                                inner: wire_map[outer]
-                                for outer, inner in zip(node.qargs, block.qubits)
-                            },
-                        )
-                    )
-                    for block in node.op.blocks
-                )
-                dag.substitute_node(node, new_op, propagate_condition=False)
-                continue
-            if len(node.qargs) != 2:
-                continue
-            if dag.has_calibration_for(node):
-                continue
-            qargs = (wire_map[node.qargs[0]], wire_map[node.qargs[1]])
-            swapped = (qargs[1], qargs[0])
-            if node.name in self._static_replacements:
-                if self.target.instruction_supported(node.name, qargs):
-                    continue
-                if self.target.instruction_supported(node.name, swapped):
-                    dag.substitute_node_with_dag(node, self._static_replacements[node.name])
-                else:
-                    raise TranspilerError(
-                        f"The circuit requires a connection between physical qubits {qargs}"
-                        f" for {node.name}"
-                    )
-            elif node.name == "rzx":
-                if self.target.instruction_supported(
-                    qargs=qargs, operation_class=RZXGate, parameters=node.op.params
-                ):
-                    continue
-                if self.target.instruction_supported(
-                    qargs=swapped, operation_class=RZXGate, parameters=node.op.params
-                ):
-                    dag.substitute_node_with_dag(node, self._rzx_dag(*node.op.params))
-                else:
-                    raise TranspilerError(
-                        f"The circuit requires a connection between physical qubits {qargs}"
-                        f" for {node.name}"
-                    )
-            elif node.name == "rxx":
-                if self.target.instruction_supported(
-                    qargs=qargs, operation_class=RXXGate, parameters=node.op.params
-                ):
-                    continue
-                if self.target.instruction_supported(
-                    qargs=swapped, operation_class=RXXGate, parameters=node.op.params
-                ):
-                    dag.substitute_node_with_dag(node, self._rxx_dag(*node.op.params))
-                else:
-                    raise TranspilerError(
-                        f"The circuit requires a connection between physical qubits {qargs}"
-                        f" for {node.name}"
-                    )
-            elif node.name == "ryy":
-                if self.target.instruction_supported(
-                    qargs=qargs, operation_class=RYYGate, parameters=node.op.params
-                ):
-                    continue
-                if self.target.instruction_supported(
-                    qargs=swapped, operation_class=RYYGate, parameters=node.op.params
-                ):
-                    dag.substitute_node_with_dag(node, self._ryy_dag(*node.op.params))
-                else:
-                    raise TranspilerError(
-                        f"The circuit requires a connection between physical qubits {qargs}"
-                        f" for {node.name}"
-                    )
-            elif node.name == "rzz":
-                if self.target.instruction_supported(
-                    qargs=qargs, operation_class=RZZGate, parameters=node.op.params
-                ):
-                    continue
-                if self.target.instruction_supported(
-                    qargs=swapped, operation_class=RZZGate, parameters=node.op.params
-                ):
-                    dag.substitute_node_with_dag(node, self._rzz_dag(*node.op.params))
-                else:
-                    raise TranspilerError(
-                        f"The circuit requires a connection between physical qubits {qargs}"
-                        f" for {node.name}"
-                    )
-            elif self.target.instruction_supported(node.name, qargs):
-                continue
-            elif self.target.instruction_supported(node.name, swapped) or dag.has_calibration_for(
-                _swap_node_qargs(node)
-            ):
-                raise TranspilerError(
-                    f"'{node.name}' would be supported on '{qargs}' if the direction were"
-                    f" swapped, but no rules are known to do that."
-                    f" {list(self._KNOWN_REPLACEMENTS)} can be automatically flipped."
-                )
-            else:
-                raise TranspilerError(
-                    f"'{node.name}' with parameters '{node.op.params}' is not supported on qubits"
-                    f" '{qargs}' in either direction."
-                )
-
-        return dag
-
     def run(self, dag):
         """Run the GateDirection pass on `dag`.
 
@@ -343,7 +81,6 @@ class GateDirection(TransformationPass):
             TranspilerError: If the circuit cannot be mapped just by flipping the
                 cx nodes.
         """
-        layout_map = {bit: i for i, bit in enumerate(dag.qubits)}
         if self.target is None:
-            return self._run_coupling_map(dag, layout_map)
-        return self._run_target(dag, layout_map)
+            return fix_gate_direction_coupling(dag, set(self.coupling_map.get_edges()))
+        return fix_gate_direction_target(dag, self.target)

qiskit/transpiler/passes/utils/gates_basis.py

@@ -12,9 +12,13 @@
 
 """Check if all gates in the DAGCircuit are in the specified basis gates."""
 
-from qiskit.converters import circuit_to_dag
 from qiskit.transpiler.basepasses import AnalysisPass
 
+from qiskit._accelerate.gates_in_basis import (
+    any_gate_missing_from_basis,
+    any_gate_missing_from_target,
+)
+
 
 class GatesInBasis(AnalysisPass):
     """Check if all gates in a DAG are in a given set of gates"""
@@ -40,35 +44,8 @@ class GatesInBasis(AnalysisPass):
         if self._basis_gates is None and self._target is None:
             self.property_set["all_gates_in_basis"] = True
             return
-        gates_out_of_basis = False
         if self._target is not None:
-
-            def _visit_target(dag, wire_map):
-                for gate in dag.op_nodes():
-                    # Barrier and store are assumed universal and supported by all backends
-                    if gate.name in ("barrier", "store"):
-                        continue
-                    if not self._target.instruction_supported(
-                        gate.name, tuple(wire_map[bit] for bit in gate.qargs)
-                    ):
-                        return True
-                    # Control-flow ops still need to be supported, so don't skip them in the
-                    # previous checks.
-                    if gate.is_control_flow():
-                        for block in gate.op.blocks:
-                            inner_wire_map = {
-                                inner: wire_map[outer]
-                                for outer, inner in zip(gate.qargs, block.qubits)
-                            }
-                            if _visit_target(circuit_to_dag(block), inner_wire_map):
-                                return True
-                return False
-
-            qubit_map = {qubit: index for index, qubit in enumerate(dag.qubits)}
-            gates_out_of_basis = _visit_target(dag, qubit_map)
+            gates_out_of_basis = any_gate_missing_from_target(dag, self._target)
         else:
-            for gate in dag.count_ops(recurse=True):
-                if gate not in self._basis_gates:
-                    gates_out_of_basis = True
-                    break
+            gates_out_of_basis = any_gate_missing_from_basis(dag, self._basis_gates)
         self.property_set["all_gates_in_basis"] = not gates_out_of_basis

qiskit/transpiler/passes/utils/merge_adjacent_barriers.py

@@ -40,7 +40,8 @@ class MergeAdjacentBarriers(TransformationPass):
 
     i.e,
 
-    .. parsed-literal::
+    .. code-block:: text
+
               ░  ░             ░  ░
         q_0: ─░──░─      q_0: ─░──░─
               ░  ░             ░  ░