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

qiskit/transpiler/passes/basis/unroll_3q_or_more.py

@@ -54,7 +54,7 @@ class Unroll3qOrMore(TransformationPass):
             QiskitError: if a 3q+ gate is not decomposable
         """
         for node in dag.multi_qubit_ops():
-            if dag.has_calibration_for(node):
+            if dag._has_calibration_for(node):
                 continue
 
             if isinstance(node.op, ControlFlowOp):

qiskit/transpiler/passes/basis/unroll_custom_definitions.py

@@ -74,7 +74,7 @@ class UnrollCustomDefinitions(TransformationPass):
             if getattr(node.op, "_directive", False):
                 continue
 
-            if dag.has_calibration_for(node) or len(node.qargs) < self._min_qubits:
+            if dag._has_calibration_for(node) or len(node.qargs) < self._min_qubits:
                 continue
 
             controlled_gate_open_ctrl = isinstance(node.op, ControlledGate) and node.op._open_ctrl

qiskit/transpiler/passes/calibration/pulse_gate.py

@@ -19,6 +19,7 @@ from qiskit.pulse import Schedule, ScheduleBlock
 from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
 from qiskit.transpiler.target import Target
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 from .base_builder import CalibrationBuilder
 
@@ -47,6 +48,7 @@ class PulseGates(CalibrationBuilder):
           https://arxiv.org/abs/2104.14722
     """
 
+    @deprecate_pulse_dependency
     def __init__(
         self,
         inst_map: InstructionScheduleMap = None,
@@ -80,7 +82,7 @@ class PulseGates(CalibrationBuilder):
         Returns:
             Return ``True`` is calibration can be provided.
         """
-        return self.target.has_calibration(node_op.name, tuple(qubits))
+        return self.target._has_calibration(node_op.name, tuple(qubits))
 
     def get_calibration(self, node_op: CircuitInst, qubits: List) -> Union[Schedule, ScheduleBlock]:
         """Gets the calibrated schedule for the given instruction and qubits.
@@ -95,4 +97,4 @@ class PulseGates(CalibrationBuilder):
         Raises:
             TranspilerError: When node is parameterized and calibration is raw schedule object.
         """
-        return self.target.get_calibration(node_op.name, tuple(qubits), *node_op.params)
+        return self.target._get_calibration(node_op.name, tuple(qubits), *node_op.params)

qiskit/transpiler/passes/calibration/rx_builder.py

@@ -24,6 +24,7 @@ from qiskit.pulse.channels import Channel
 from qiskit.pulse.library.symbolic_pulses import Drag
 from qiskit.transpiler.passes.calibration.base_builder import CalibrationBuilder
 from qiskit.transpiler.target import Target
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
 class RXCalibrationBuilder(CalibrationBuilder):
@@ -45,7 +46,7 @@ class RXCalibrationBuilder(CalibrationBuilder):
        from qiskit.circuit.library import QuantumVolume
        from qiskit.circuit.library.standard_gates import RXGate
 
-       from calibration.rx_builder import RXCalibrationBuilder
+       from qiskit.transpiler.passes import RXCalibrationBuilder
 
        qv = QuantumVolume(4, 4, seed=1004)
 
@@ -75,6 +76,7 @@ class RXCalibrationBuilder(CalibrationBuilder):
           `arXiv:2004.11205 <https://arxiv.org/abs/2004.11205>`
     """
 
+    @deprecate_pulse_dependency
     def __init__(
         self,
         target: Target = None,
@@ -99,13 +101,15 @@ class RXCalibrationBuilder(CalibrationBuilder):
         """
         return (
             isinstance(node_op, RXGate)
-            and self.target.has_calibration("sx", tuple(qubits))
-            and (len(self.target.get_calibration("sx", tuple(qubits)).instructions) == 1)
+            and self.target._has_calibration("sx", tuple(qubits))
+            and (len(self.target._get_calibration("sx", tuple(qubits)).instructions) == 1)
             and isinstance(
-                self.target.get_calibration("sx", tuple(qubits)).instructions[0][1].pulse,
+                self.target._get_calibration("sx", tuple(qubits)).instructions[0][1].pulse,
                 ScalableSymbolicPulse,
             )
-            and self.target.get_calibration("sx", tuple(qubits)).instructions[0][1].pulse.pulse_type
+            and self.target._get_calibration("sx", tuple(qubits))
+            .instructions[0][1]
+            .pulse.pulse_type
             == "Drag"
         )
 
@@ -122,13 +126,13 @@ class RXCalibrationBuilder(CalibrationBuilder):
             raise QiskitError("Target rotation angle is not assigned.") from ex
 
         params = (
-            self.target.get_calibration("sx", tuple(qubits))
+            self.target._get_calibration("sx", tuple(qubits))
             .instructions[0][1]
             .pulse.parameters.copy()
         )
         new_rx_sched = _create_rx_sched(
             rx_angle=angle,
-            channel=self.target.get_calibration("sx", tuple(qubits)).channels[0],
+            channel=self.target._get_calibration("sx", tuple(qubits)).channels[0],
             duration=params["duration"],
             amp=params["amp"],
             sigma=params["sigma"],

qiskit/transpiler/passes/calibration/rzx_builder.py

@@ -36,6 +36,7 @@ from qiskit.pulse import builder
 from qiskit.pulse.filters import filter_instructions
 from qiskit.pulse.instruction_schedule_map import InstructionScheduleMap
 from qiskit.transpiler.target import Target
+from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 from .base_builder import CalibrationBuilder
 from .exceptions import CalibrationNotAvailable
@@ -65,6 +66,7 @@ class RZXCalibrationBuilder(CalibrationBuilder):
     angle. Additional details can be found in https://arxiv.org/abs/2012.11660.
     """
 
+    @deprecate_pulse_dependency
     def __init__(
         self,
         instruction_schedule_map: InstructionScheduleMap = None,
@@ -89,7 +91,7 @@ class RZXCalibrationBuilder(CalibrationBuilder):
         self._inst_map = instruction_schedule_map
         self._verbose = verbose
         if target:
-            self._inst_map = target.instruction_schedule_map()
+            self._inst_map = target._instruction_schedule_map()
         if self._inst_map is None:
             raise QiskitError("Calibrations can only be added to Pulse-enabled backends")
 
@@ -202,15 +204,20 @@ class RZXCalibrationBuilder(CalibrationBuilder):
 
         # The CR instruction is in the forward (native) direction
         if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
-            xgate = self._inst_map.get("x", qubits[0])
-            with builder.build(
-                default_alignment="sequential", name=f"rzx({theta:.3f})"
-            ) as rzx_theta_native:
-                for cr_tone, comp_tone in zip(cr_tones, comp_tones):
-                    with builder.align_left():
-                        self.rescale_cr_inst(cr_tone, theta)
-                        self.rescale_cr_inst(comp_tone, theta)
-                    builder.call(xgate)
+            with warnings.catch_warnings():
+                warnings.simplefilter(action="ignore", category=DeprecationWarning)
+                # `InstructionScheduleMap.get` and the pulse builder emit deprecation warnings
+                # as they use classes and methods which are deprecated in Qiskit 1.3 as part of the
+                # Qiskit Pulse deprecation
+                xgate = self._inst_map.get("x", qubits[0])
+                with builder.build(
+                    default_alignment="sequential", name=f"rzx({theta:.3f})"
+                ) as rzx_theta_native:
+                    for cr_tone, comp_tone in zip(cr_tones, comp_tones):
+                        with builder.align_left():
+                            self.rescale_cr_inst(cr_tone, theta)
+                            self.rescale_cr_inst(comp_tone, theta)
+                        builder.call(xgate)
             return rzx_theta_native
 
         # The direction is not native. Add Hadamard gates to flip the direction.
@@ -297,11 +304,15 @@ class RZXCalibrationBuilderNoEcho(RZXCalibrationBuilder):
 
         # RZXCalibrationNoEcho only good for forward CR direction
         if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
-            with builder.build(default_alignment="left", name=f"rzx({theta:.3f})") as rzx_theta:
-                stretched_dur = self.rescale_cr_inst(cr_tones[0], 2 * theta)
-                self.rescale_cr_inst(comp_tones[0], 2 * theta)
-                # Placeholder to make pulse gate work
-                builder.delay(stretched_dur, DriveChannel(qubits[0]))
+            with warnings.catch_warnings():
+                warnings.simplefilter(action="ignore", category=DeprecationWarning)
+                # Pulse builder emits deprecation warnings as part of the
+                # Qiskit Pulse deprecation
+                with builder.build(default_alignment="left", name=f"rzx({theta:.3f})") as rzx_theta:
+                    stretched_dur = self.rescale_cr_inst(cr_tones[0], 2 * theta)
+                    self.rescale_cr_inst(comp_tones[0], 2 * theta)
+                    # Placeholder to make pulse gate work
+                    builder.delay(stretched_dur, DriveChannel(qubits[0]))
             return rzx_theta
 
         raise QiskitError("RZXCalibrationBuilderNoEcho only supports hardware-native RZX gates.")
@@ -347,22 +358,27 @@ def _check_calibration_type(
         QiskitError: Unknown calibration type is detected.
     """
     cal_type = None
-    if inst_sched_map.has("cx", qubits):
-        cr_sched = inst_sched_map.get("cx", qubits=qubits)
-    elif inst_sched_map.has("ecr", qubits):
-        cr_sched = inst_sched_map.get("ecr", qubits=qubits)
-        cal_type = CRCalType.ECR_FORWARD
-    elif inst_sched_map.has("ecr", tuple(reversed(qubits))):
-        cr_sched = inst_sched_map.get("ecr", tuple(reversed(qubits)))
-        cal_type = CRCalType.ECR_REVERSE
-    else:
-        raise QiskitError(
-            f"Native direction cannot be determined: operation on qubits {qubits} "
-            f"for the following instruction schedule map:\n{inst_sched_map}"
-        )
+    with warnings.catch_warnings():
+        warnings.simplefilter(action="ignore", category=DeprecationWarning)
+        # `InstructionScheduleMap.get` and `filter_instructions` emit deprecation warnings
+        # as they use classes and methods which are deprecated in Qiskit 1.3 as part of the
+        # Qiskit Pulse deprecation
+        if inst_sched_map.has("cx", qubits):
+            cr_sched = inst_sched_map.get("cx", qubits=qubits)
+        elif inst_sched_map.has("ecr", qubits):
+            cr_sched = inst_sched_map.get("ecr", qubits=qubits)
+            cal_type = CRCalType.ECR_FORWARD
+        elif inst_sched_map.has("ecr", tuple(reversed(qubits))):
+            cr_sched = inst_sched_map.get("ecr", tuple(reversed(qubits)))
+            cal_type = CRCalType.ECR_REVERSE
+        else:
+            raise QiskitError(
+                f"Native direction cannot be determined: operation on qubits {qubits} "
+                f"for the following instruction schedule map:\n{inst_sched_map}"
+            )
 
-    cr_tones = [t[1] for t in filter_instructions(cr_sched, [_filter_cr_tone]).instructions]
-    comp_tones = [t[1] for t in filter_instructions(cr_sched, [_filter_comp_tone]).instructions]
+        cr_tones = [t[1] for t in filter_instructions(cr_sched, [_filter_cr_tone]).instructions]
+        comp_tones = [t[1] for t in filter_instructions(cr_sched, [_filter_comp_tone]).instructions]
 
     if cal_type is None:
         if len(comp_tones) == 0:

qiskit/transpiler/passes/layout/disjoint_utils.py

@@ -107,7 +107,7 @@ def split_barriers(dag: DAGCircuit):
         num_qubits = len(node.qargs)
         if num_qubits == 1:
             continue
-        if node.op.label:
+        if node.label:
             barrier_uuid = f"{node.op.label}_uuid={uuid.uuid4()}"
         else:
             barrier_uuid = f"_none_uuid={uuid.uuid4()}"
@@ -125,28 +125,30 @@ def split_barriers(dag: DAGCircuit):
 def combine_barriers(dag: DAGCircuit, retain_uuid: bool = True):
     """Mutate input dag to combine barriers with UUID labels into a single barrier."""
     qubit_indices = {bit: index for index, bit in enumerate(dag.qubits)}
-    uuid_map: dict[uuid.UUID, DAGOpNode] = {}
+    uuid_map: dict[str, DAGOpNode] = {}
     for node in dag.op_nodes(Barrier):
-        if node.op.label:
-            if "_uuid=" in node.op.label:
-                barrier_uuid = node.op.label
+        if node.label:
+            if "_uuid=" in node.label:
+                barrier_uuid = node.label
             else:
                 continue
             if barrier_uuid in uuid_map:
                 other_node = uuid_map[barrier_uuid]
                 num_qubits = len(other_node.qargs) + len(node.qargs)
-                new_op = Barrier(num_qubits, label=barrier_uuid)
+                if not retain_uuid:
+                    if isinstance(node.label, str) and node.label.startswith("_none_uuid="):
+                        label = None
+                    elif isinstance(node.label, str) and "_uuid=" in node.label:
+                        label = "_uuid=".join(node.label.split("_uuid=")[:-1])
+                    else:
+                        label = barrier_uuid
+                else:
+                    label = barrier_uuid
+                new_op = Barrier(num_qubits, label=label)
                 new_node = dag.replace_block_with_op([node, other_node], new_op, qubit_indices)
                 uuid_map[barrier_uuid] = new_node
             else:
                 uuid_map[barrier_uuid] = node
-    if not retain_uuid:
-        for node in dag.op_nodes(Barrier):
-            if isinstance(node.op.label, str) and node.op.label.startswith("_none_uuid="):
-                node.op.label = None
-            elif isinstance(node.op.label, str) and "_uuid=" in node.op.label:
-                original_label = "_uuid=".join(node.op.label.split("_uuid=")[:-1])
-                node.op.label = original_label
 
 
 def require_layout_isolated_to_component(

qiskit/transpiler/passes/layout/sabre_layout.py

@@ -101,7 +101,10 @@ class SabreLayout(TransformationPass):
 
     **References:**
 
-    [1] Li, Gushu, Yufei Ding, and Yuan Xie. "Tackling the qubit mapping problem
+    [1] Henry Zou and Matthew Treinish and Kevin Hartman and Alexander Ivrii and Jake Lishman.
+    "LightSABRE: A Lightweight and Enhanced SABRE Algorithm"
+    `arXiv:2409.08368 <https://doi.org/10.48550/arXiv.2409.08368>`__
+    [2] Li, Gushu, Yufei Ding, and Yuan Xie. "Tackling the qubit mapping problem
     for NISQ-era quantum devices." ASPLOS 2019.
     `arXiv:1809.02573 <https://arxiv.org/pdf/1809.02573.pdf>`_
     """
@@ -145,7 +148,9 @@ class SabreLayout(TransformationPass):
                 (and ``routing_pass`` is not set) then the number of local
                 physical CPUs will be used as the default value. This option is
                 mutually exclusive with the ``routing_pass`` argument and an error
-                will be raised if both are used.
+                will be raised if both are used. An additional 3 or 4 trials
+                depending on the ``coupling_map`` value are run with common layouts
+                on top of the random trial count specified by this value.
             skip_routing (bool): If this is set ``True`` and ``routing_pass`` is not used
                 then routing will not be applied to the output circuit.  Only the layout
                 will be set in the property set. This is a tradeoff to run custom

qiskit/transpiler/passes/layout/sabre_pre_layout.py

@@ -31,6 +31,11 @@ class SabrePreLayout(AnalysisPass):
     ``sabre_starting_layouts`` (``list[Layout]``)
         An optional list of :class:`~.Layout` objects to use for additional Sabre layout trials.
 
+    **References:**
+
+    [1] Henry Zou and Matthew Treinish and Kevin Hartman and Alexander Ivrii and Jake Lishman.
+    "LightSABRE: A Lightweight and Enhanced SABRE Algorithm"
+    `arXiv:2409.08368 <https://doi.org/10.48550/arXiv.2409.08368>`__
     """
 
     def __init__(

qiskit/transpiler/passes/optimization/__init__.py

@@ -38,5 +38,6 @@ from .collect_cliffords import CollectCliffords
 from .elide_permutations import ElidePermutations
 from .normalize_rx_angle import NormalizeRXAngle
 from .optimize_annotated import OptimizeAnnotated
+from .remove_identity_equiv import RemoveIdentityEquivalent
 from .split_2q_unitaries import Split2QUnitaries
 from .collect_and_collapse import CollectAndCollapse

qiskit/transpiler/passes/optimization/collect_cliffords.py

@@ -15,6 +15,7 @@
 
 from functools import partial
 
+from qiskit.exceptions import QiskitError
 from qiskit.transpiler.passes.optimization.collect_and_collapse import (
     CollectAndCollapse,
     collect_using_filter_function,
@@ -37,6 +38,7 @@ class CollectCliffords(CollectAndCollapse):
         min_block_size=2,
         split_layers=False,
         collect_from_back=False,
+        matrix_based=False,
     ):
         """CollectCliffords initializer.
 
@@ -51,11 +53,13 @@ class CollectCliffords(CollectAndCollapse):
                 over disjoint qubit subsets.
             collect_from_back (bool): specifies if blocks should be collected started
                 from the end of the circuit.
+            matrix_based (bool): specifies whether to collect unitary gates
+               which are Clifford gates only for certain parameters (based on their unitary matrix).
         """
 
         collect_function = partial(
             collect_using_filter_function,
-            filter_function=_is_clifford_gate,
+            filter_function=partial(_is_clifford_gate, matrix_based=matrix_based),
             split_blocks=split_blocks,
             min_block_size=min_block_size,
             split_layers=split_layers,
@@ -77,9 +81,21 @@ clifford_gate_names = (
 )
 
 
-def _is_clifford_gate(node):
+def _is_clifford_gate(node, matrix_based=False):
     """Specifies whether a node holds a clifford gate."""
-    return node.op.name in clifford_gate_names and getattr(node.op, "condition", None) is None
+    if getattr(node.op, "_condition", None) is not None:
+        return False
+    if node.op.name in clifford_gate_names:
+        return True
+
+    if not matrix_based:
+        return False
+
+    try:
+        Clifford(node.op)
+        return True
+    except QiskitError:
+        return False
 
 
 def _collapse_to_clifford(circuit):

qiskit/transpiler/passes/optimization/collect_linear_functions.py

@@ -71,7 +71,7 @@ class CollectLinearFunctions(CollectAndCollapse):
 
 def _is_linear_gate(node):
     """Specifies whether a node holds a linear gate."""
-    return node.op.name in ("cx", "swap") and getattr(node.op, "condition", None) is None
+    return node.op.name in ("cx", "swap") and getattr(node, "condition", None) is None
 
 
 def _collapse_to_linear_function(circuit):

qiskit/transpiler/passes/optimization/collect_multiqubit_blocks.py

@@ -120,7 +120,7 @@ class CollectMultiQBlocks(AnalysisPass):
             if not isinstance(x, DAGOpNode):
                 return "d"
             if isinstance(x.op, Gate):
-                if x.op.is_parameterized() or getattr(x.op, "condition", None) is not None:
+                if x.op.is_parameterized() or getattr(x.op, "_condition", None) is not None:
                     return "c"
                 return "b" + chr(ord("a") + len(x.qargs))
             return "d"
@@ -133,7 +133,7 @@ class CollectMultiQBlocks(AnalysisPass):
 
             # check if the node is a gate and if it is parameterized
             if (
-                getattr(nd.op, "condition", None) is not None
+                getattr(nd.op, "_condition", None) is not None
                 or nd.op.is_parameterized()
                 or not isinstance(nd.op, Gate)
             ):

qiskit/transpiler/passes/optimization/commutative_inverse_cancellation.py

@@ -49,7 +49,7 @@ class CommutativeInverseCancellation(TransformationPass):
         # checking can be extended to cover additional cases.
         if getattr(node.op, "_directive", False) or node.name in {"measure", "reset", "delay"}:
             return True
-        if getattr(node.op, "condition", None):
+        if getattr(node, "condition", None):
             return True
         if node.op.is_parameterized():
             return True

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -12,27 +12,26 @@
 
 """Replace each block of consecutive gates by a single Unitary node."""
 from __future__ import annotations
+from math import pi
 
-import numpy as np
-
-from qiskit.circuit.classicalregister import ClassicalRegister
-from qiskit.circuit.quantumregister import QuantumRegister
-from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.dagcircuit.dagnode import DAGOpNode
-from qiskit.quantum_info import Operator
 from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer
-from qiskit.circuit.library.generalized_gates.unitary import UnitaryGate
-from qiskit.circuit.library.standard_gates import CXGate
+from qiskit.circuit.library.standard_gates import CXGate, CZGate, iSwapGate, ECRGate, RXXGate
+
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passmanager import PassManager
-from qiskit.transpiler.passes.synthesis import unitary_synthesis
-from qiskit.circuit.controlflow import CONTROL_FLOW_OP_NAMES
-from qiskit._accelerate.convert_2q_block_matrix import blocks_to_matrix
-from qiskit.exceptions import QiskitError
+from qiskit._accelerate.consolidate_blocks import consolidate_blocks
 
 from .collect_1q_runs import Collect1qRuns
 from .collect_2q_blocks import Collect2qBlocks
 
+KAK_GATE_NAMES = {
+    "cx": CXGate(),
+    "cz": CZGate(),
+    "iswap": iSwapGate(),
+    "ecr": ECRGate(),
+    "rxx": RXXGate(pi / 2),
+}
+
 
 class ConsolidateBlocks(TransformationPass):
     """Replace each block of consecutive gates by a single Unitary node.
@@ -74,13 +73,20 @@ class ConsolidateBlocks(TransformationPass):
         if basis_gates is not None:
             self.basis_gates = set(basis_gates)
         self.force_consolidate = force_consolidate
-
         if kak_basis_gate is not None:
             self.decomposer = TwoQubitBasisDecomposer(kak_basis_gate)
         elif basis_gates is not None:
-            self.decomposer = unitary_synthesis._decomposer_2q_from_basis_gates(
-                basis_gates, approximation_degree=approximation_degree
-            )
+            kak_gates = KAK_GATE_NAMES.keys() & (basis_gates or [])
+            if kak_gates:
+                self.decomposer = TwoQubitBasisDecomposer(
+                    KAK_GATE_NAMES[kak_gates.pop()], basis_fidelity=approximation_degree or 1.0
+                )
+            elif "rzx" in basis_gates:
+                self.decomposer = TwoQubitBasisDecomposer(
+                    CXGate(), basis_fidelity=approximation_degree or 1.0
+                )
+            else:
+                self.decomposer = None
         else:
             self.decomposer = TwoQubitBasisDecomposer(CXGate())
 
@@ -93,89 +99,23 @@ class ConsolidateBlocks(TransformationPass):
         if self.decomposer is None:
             return dag
 
-        blocks = self.property_set["block_list"] or []
-        basis_gate_name = self.decomposer.gate.name
-        all_block_gates = set()
-        for block in blocks:
-            if len(block) == 1 and self._check_not_in_basis(dag, block[0].name, block[0].qargs):
-                all_block_gates.add(block[0])
-                dag.substitute_node(block[0], UnitaryGate(block[0].op.to_matrix()))
-            else:
-                basis_count = 0
-                outside_basis = False
-                block_qargs = set()
-                block_cargs = set()
-                for nd in block:
-                    block_qargs |= set(nd.qargs)
-                    if isinstance(nd, DAGOpNode) and getattr(nd, "condition", None):
-                        block_cargs |= set(getattr(nd, "condition", None)[0])
-                    all_block_gates.add(nd)
-                block_index_map = self._block_qargs_to_indices(dag, block_qargs)
-                for nd in block:
-                    if nd.name == basis_gate_name:
-                        basis_count += 1
-                    if self._check_not_in_basis(dag, nd.name, nd.qargs):
-                        outside_basis = True
-                if len(block_qargs) > 2:
-                    q = QuantumRegister(len(block_qargs))
-                    qc = QuantumCircuit(q)
-                    if block_cargs:
-                        c = ClassicalRegister(len(block_cargs))
-                        qc.add_register(c)
-                    for nd in block:
-                        qc.append(nd.op, [q[block_index_map[i]] for i in nd.qargs])
-                    unitary = UnitaryGate(Operator(qc), check_input=False)
-                else:
-                    try:
-                        matrix = blocks_to_matrix(block, block_index_map)
-                    except QiskitError:
-                        # If building a matrix for the block fails we should not consolidate it
-                        # because there is nothing we can do with it.
-                        continue
-                    unitary = UnitaryGate(matrix, check_input=False)
-
-                max_2q_depth = 20  # If depth > 20, there will be 1q gates to consolidate.
-                if (  # pylint: disable=too-many-boolean-expressions
-                    self.force_consolidate
-                    or unitary.num_qubits > 2
-                    or self.decomposer.num_basis_gates(matrix) < basis_count
-                    or len(block) > max_2q_depth
-                    or ((self.basis_gates is not None) and outside_basis)
-                    or ((self.target is not None) and outside_basis)
-                ):
-                    identity = np.eye(2**unitary.num_qubits)
-                    if np.allclose(identity, unitary.to_matrix()):
-                        for node in block:
-                            dag.remove_op_node(node)
-                    else:
-                        dag.replace_block_with_op(
-                            block, unitary, block_index_map, cycle_check=False
-                        )
-        # If 1q runs are collected before consolidate those too
-        runs = self.property_set["run_list"] or []
-        identity_1q = np.eye(2)
-        for run in runs:
-            if any(gate in all_block_gates for gate in run):
-                continue
-            if len(run) == 1 and not self._check_not_in_basis(dag, run[0].name, run[0].qargs):
-                dag.substitute_node(run[0], UnitaryGate(run[0].op.to_matrix(), check_input=False))
-            else:
-                qubit = run[0].qargs[0]
-                operator = run[0].op.to_matrix()
-                already_in_block = False
-                for gate in run[1:]:
-                    if gate in all_block_gates:
-                        already_in_block = True
-                    operator = gate.op.to_matrix().dot(operator)
-                if already_in_block:
-                    continue
-                unitary = UnitaryGate(operator, check_input=False)
-                if np.allclose(identity_1q, unitary.to_matrix()):
-                    for node in run:
-                        dag.remove_op_node(node)
-                else:
-                    dag.replace_block_with_op(run, unitary, {qubit: 0}, cycle_check=False)
-
+        blocks = self.property_set["block_list"]
+        if blocks is not None:
+            blocks = [[node._node_id for node in block] for block in blocks]
+        runs = self.property_set["run_list"]
+        if runs is not None:
+            runs = [[node._node_id for node in run] for run in runs]
+
+        consolidate_blocks(
+            dag,
+            self.decomposer._inner_decomposer,
+            self.decomposer.gate.name,
+            self.force_consolidate,
+            target=self.target,
+            basis_gates=self.basis_gates,
+            blocks=blocks,
+            runs=runs,
+        )
         dag = self._handle_control_flow_ops(dag)
 
         # Clear collected blocks and runs as they are no longer valid after consolidation
@@ -195,38 +135,15 @@ class ConsolidateBlocks(TransformationPass):
         pass_manager = PassManager()
         if "run_list" in self.property_set:
             pass_manager.append(Collect1qRuns())
-        if "block_list" in self.property_set:
             pass_manager.append(Collect2qBlocks())
 
         pass_manager.append(self)
-        for node in dag.op_nodes():
-            if node.name not in CONTROL_FLOW_OP_NAMES:
-                continue
-            dag.substitute_node(
-                node,
-                node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks),
-                propagate_condition=False,
-            )
+        control_flow_nodes = dag.control_flow_op_nodes()
+        if control_flow_nodes is not None:
+            for node in control_flow_nodes:
+                dag.substitute_node(
+                    node,
+                    node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks),
+                    propagate_condition=False,
+                )
         return dag
-
-    def _check_not_in_basis(self, dag, gate_name, qargs):
-        if self.target is not None:
-            return not self.target.instruction_supported(
-                gate_name, tuple(dag.find_bit(qubit).index for qubit in qargs)
-            )
-        else:
-            return self.basis_gates and gate_name not in self.basis_gates
-
-    def _block_qargs_to_indices(self, dag, block_qargs):
-        """Map each qubit in block_qargs to its wire position among the block's wires.
-        Args:
-            block_qargs (list): list of qubits that a block acts on
-            global_index_map (dict): mapping from each qubit in the
-                circuit to its wire position within that circuit
-        Returns:
-            dict: mapping from qarg to position in block
-        """
-        block_indices = [dag.find_bit(q).index for q in block_qargs]
-        ordered_block_indices = {bit: index for index, bit in enumerate(sorted(block_indices))}
-        block_positions = {q: ordered_block_indices[dag.find_bit(q).index] for q in block_qargs}
-        return block_positions