qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__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,7 +19,6 @@ 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
 
@@ -48,7 +47,6 @@ class PulseGates(CalibrationBuilder):
           https://arxiv.org/abs/2104.14722
     """
 
-    @deprecate_pulse_dependency
     def __init__(
         self,
         inst_map: InstructionScheduleMap = None,
@@ -82,7 +80,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.
@@ -97,4 +95,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,7 +24,6 @@ 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):
@@ -46,7 +45,7 @@ class RXCalibrationBuilder(CalibrationBuilder):
        from qiskit.circuit.library import QuantumVolume
        from qiskit.circuit.library.standard_gates import RXGate
 
-       from qiskit.transpiler.passes import RXCalibrationBuilder
+       from calibration.rx_builder import RXCalibrationBuilder
 
        qv = QuantumVolume(4, 4, seed=1004)
 
@@ -76,7 +75,6 @@ class RXCalibrationBuilder(CalibrationBuilder):
           `arXiv:2004.11205 <https://arxiv.org/abs/2004.11205>`
     """
 
-    @deprecate_pulse_dependency
     def __init__(
         self,
         target: Target = None,
@@ -101,15 +99,13 @@ 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"
         )
 
@@ -126,13 +122,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,7 +36,6 @@ 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
@@ -66,7 +65,6 @@ 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,
@@ -91,7 +89,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")
 
@@ -204,20 +202,15 @@ class RZXCalibrationBuilder(CalibrationBuilder):
 
         # The CR instruction is in the forward (native) direction
         if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
-            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)
+            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.
@@ -304,15 +297,11 @@ class RZXCalibrationBuilderNoEcho(RZXCalibrationBuilder):
 
         # RZXCalibrationNoEcho only good for forward CR direction
         if cal_type in [CRCalType.ECR_CX_FORWARD, CRCalType.ECR_FORWARD]:
-            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]))
+            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.")
@@ -358,27 +347,22 @@ def _check_calibration_type(
         QiskitError: Unknown calibration type is detected.
     """
     cal_type = None
-    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}"
-            )
+    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.label:
+        if node.op.label:
             barrier_uuid = f"{node.op.label}_uuid={uuid.uuid4()}"
         else:
             barrier_uuid = f"_none_uuid={uuid.uuid4()}"
@@ -125,30 +125,28 @@ 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[str, DAGOpNode] = {}
+    uuid_map: dict[uuid.UUID, DAGOpNode] = {}
     for node in dag.op_nodes(Barrier):
-        if node.label:
-            if "_uuid=" in node.label:
-                barrier_uuid = node.label
+        if node.op.label:
+            if "_uuid=" in node.op.label:
+                barrier_uuid = node.op.label
             else:
                 continue
             if barrier_uuid in uuid_map:
                 other_node = uuid_map[barrier_uuid]
                 num_qubits = len(other_node.qargs) + len(node.qargs)
-                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_op = Barrier(num_qubits, label=barrier_uuid)
                 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,10 +101,7 @@ class SabreLayout(TransformationPass):
 
     **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>`__
-    [2] Li, Gushu, Yufei Ding, and Yuan Xie. "Tackling the qubit mapping problem
+    [1] 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>`_
     """
@@ -148,9 +145,7 @@ 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. 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.
+                will be raised if both are used.
             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,11 +31,6 @@ 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,6 +38,5 @@ 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,7 +15,6 @@
 
 from functools import partial
 
-from qiskit.exceptions import QiskitError
 from qiskit.transpiler.passes.optimization.collect_and_collapse import (
     CollectAndCollapse,
     collect_using_filter_function,
@@ -38,7 +37,6 @@ class CollectCliffords(CollectAndCollapse):
         min_block_size=2,
         split_layers=False,
         collect_from_back=False,
-        matrix_based=False,
     ):
         """CollectCliffords initializer.
 
@@ -53,13 +51,11 @@ 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=partial(_is_clifford_gate, matrix_based=matrix_based),
+            filter_function=_is_clifford_gate,
             split_blocks=split_blocks,
             min_block_size=min_block_size,
             split_layers=split_layers,
@@ -81,21 +77,9 @@ clifford_gate_names = (
 )
 
 
-def _is_clifford_gate(node, matrix_based=False):
+def _is_clifford_gate(node):
     """Specifies whether a node holds a clifford gate."""
-    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
+    return node.op.name in clifford_gate_names and getattr(node.op, "condition", None) is None
 
 
 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, "condition", None) is None
+    return node.op.name in ("cx", "swap") and getattr(node.op, "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, "condition", None):
+        if getattr(node.op, "condition", None):
             return True
         if node.op.is_parameterized():
             return True

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -12,26 +12,27 @@
 
 """Replace each block of consecutive gates by a single Unitary node."""
 from __future__ import annotations
-from math import pi
 
-from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer
-from qiskit.circuit.library.standard_gates import CXGate, CZGate, iSwapGate, ECRGate, RXXGate
+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.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passmanager import PassManager
-from qiskit._accelerate.consolidate_blocks import consolidate_blocks
+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 .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.
@@ -73,20 +74,13 @@ 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:
-            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
+            self.decomposer = unitary_synthesis._decomposer_2q_from_basis_gates(
+                basis_gates, approximation_degree=approximation_degree
+            )
         else:
             self.decomposer = TwoQubitBasisDecomposer(CXGate())
 
@@ -99,23 +93,89 @@ class ConsolidateBlocks(TransformationPass):
         if self.decomposer is None:
             return dag
 
-        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,
-        )
+        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)
+
         dag = self._handle_control_flow_ops(dag)
 
         # Clear collected blocks and runs as they are no longer valid after consolidation
@@ -135,15 +195,38 @@ 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)
-        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,
-                )
+        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,
+            )
         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