qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/passes/layout/vf2_post_layout.py

@@ -23,10 +23,8 @@ from rustworkx import PyDiGraph, vf2_mapping, PyGraph
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.transpiler.exceptions import TranspilerError
-from qiskit.providers.exceptions import BackendPropertyError
 from qiskit.transpiler.passes.layout import vf2_utils
 
-from qiskit.utils import deprecate_arg
 
 logger = logging.getLogger(__name__)
 
@@ -79,8 +77,7 @@ class VF2PostLayout(AnalysisPass):
         * ``">2q gates in basis"``: If VF2PostLayout can't work with the basis of the circuit.
 
     By default, this pass will construct a heuristic scoring map based on
-    the error rates in the provided ``target`` (or ``properties`` if ``target``
-    is not provided). However, analysis passes can be run prior to this pass
+    the error rates in the provided ``target``. However, analysis passes can be run prior to this pass
     and set ``vf2_avg_error_map`` in the property set with a :class:`~.ErrorMap`
     instance. If a value is ``NaN`` that is treated as an ideal edge
     For example if an error map is created as::
@@ -100,32 +97,9 @@ class VF2PostLayout(AnalysisPass):
     is run.
     """
 
-    @deprecate_arg(
-        name="properties",
-        since="1.4",
-        package_name="Qiskit",
-        removal_timeline="in Qiskit 2.0",
-        additional_msg="The BackendProperties data structure has been deprecated and will be "
-        "removed in Qiskit 2.0. The `target` input argument should be used instead. "
-        "You can use Target.from_configuration() to build the target from the properties "
-        "object, but in 2.0 you will need to generate a target directly.",
-    )
-    @deprecate_arg(
-        name="coupling_map",
-        since="1.4",
-        package_name="Qiskit",
-        removal_timeline="in Qiskit 2.0",
-        additional_msg="This argument was only used with `properties`, which relied on "
-        "the deprecated BackendProperties data structure. The `target` input argument "
-        "should be used instead. "
-        "You can use Target.from_configuration() to build the target from coupling "
-        "map + properties, but in 2.0 you will need to generate a target directly.",
-    )
     def __init__(
         self,
         target=None,
-        coupling_map=None,
-        properties=None,
         seed=None,
         call_limit=None,
         time_limit=None,
@@ -136,12 +110,6 @@ class VF2PostLayout(AnalysisPass):
 
         Args:
             target (Target): A target representing the backend device to run ``VF2PostLayout`` on.
-                If specified it will supersede a set value for ``properties`` and
-                ``coupling_map``.
-            coupling_map (CouplingMap): Directed graph representing a coupling map.
-            properties (BackendProperties): The backend properties for the backend. If
-                :meth:`~qiskit.providers.models.BackendProperties.readout_error` is available
-                it is used to score the layout.
             seed (int): Sets the seed of the PRNG. -1 Means no node shuffling.
             call_limit (int): The number of state visits to attempt in each execution of
                 VF2.
@@ -160,12 +128,10 @@ class VF2PostLayout(AnalysisPass):
                 a layout. A value of ``0`` (the default) means 'unlimited'.
 
         Raises:
-            TypeError: At runtime, if neither ``coupling_map`` or ``target`` are provided.
+            TypeError: At runtime, if ``target`` isn't provided.
         """
         super().__init__()
         self.target = target
-        self.coupling_map = coupling_map
-        self.properties = properties
         self.call_limit = call_limit
         self.time_limit = time_limit
         self.max_trials = max_trials
@@ -175,16 +141,12 @@ class VF2PostLayout(AnalysisPass):
 
     def run(self, dag):
         """run the layout method"""
-        if self.target is None and (self.coupling_map is None or self.properties is None):
-            raise TranspilerError(
-                "A target must be specified or a coupling map and properties must be provided"
-            )
+        if self.target is None:
+            raise TranspilerError("A target must be specified or a coupling map must be provided")
         if not self.strict_direction:
             self.avg_error_map = self.property_set["vf2_avg_error_map"]
             if self.avg_error_map is None:
-                self.avg_error_map = vf2_utils.build_average_error_map(
-                    self.target, self.properties, self.coupling_map
-                )
+                self.avg_error_map = vf2_utils.build_average_error_map(self.target, None)
 
         result = vf2_utils.build_interaction_graph(dag, self.strict_direction)
         if result is None:
@@ -194,67 +156,62 @@ class VF2PostLayout(AnalysisPass):
         scoring_bit_list = vf2_utils.build_bit_list(im_graph, im_graph_node_map)
         scoring_edge_list = vf2_utils.build_edge_list(im_graph)
 
-        if self.target is not None:
-            # If qargs is None then target is global and ideal so no
-            # scoring is needed
-            if self.target.qargs is None:
-                return
-            if self.strict_direction:
-                cm_graph = PyDiGraph(multigraph=False)
-            else:
-                cm_graph = PyGraph(multigraph=False)
-            # If None is present in qargs there are globally defined ideal operations
-            # we should add these to all entries based on the number of qubits, so we
-            # treat that as a valid operation even if there is no scoring for the
-            # strict direction case
-            global_ops = None
-            if None in self.target.qargs:
-                global_ops = {1: [], 2: []}
-                for op in self.target.operation_names_for_qargs(None):
-                    operation = self.target.operation_for_name(op)
-                    # If operation is a class this is a variable width ideal instruction
-                    # so we treat it as available on both 1 and 2 qubits
-                    if inspect.isclass(operation):
-                        global_ops[1].append(op)
-                        global_ops[2].append(op)
-                    else:
-                        num_qubits = operation.num_qubits
-                        if num_qubits in global_ops:
-                            global_ops[num_qubits].append(op)
-            op_names = []
-            for i in range(self.target.num_qubits):
-                try:
-                    entry = set(self.target.operation_names_for_qargs((i,)))
-                except KeyError:
-                    entry = set()
-                if global_ops is not None:
-                    entry.update(global_ops[1])
-                op_names.append(entry)
-            cm_graph.add_nodes_from(op_names)
-            for qargs in self.target.qargs:
-                len_args = len(qargs)
-                # If qargs == 1 we already populated it and if qargs > 2 there are no instructions
-                # using those in the circuit because we'd have already returned by this point
-                if len_args == 2:
-                    ops = set(self.target.operation_names_for_qargs(qargs))
-                    if global_ops is not None:
-                        ops.update(global_ops[2])
-                    cm_graph.add_edge(qargs[0], qargs[1], ops)
-            cm_nodes = list(cm_graph.node_indexes())
-            # Filter qubits without any supported operations. If they
-            # don't support any operations, they're not valid for layout selection.
-            # This is only needed in the undirected case because in strict direction
-            # mode the node matcher will not match since none of the circuit ops
-            # will match the cmap ops.
-            if not self.strict_direction:
-                has_operations = set(itertools.chain.from_iterable(self.target.qargs))
-                to_remove = set(cm_graph.node_indices()).difference(has_operations)
-                if to_remove:
-                    cm_graph.remove_nodes_from(list(to_remove))
+        # If qargs is None then target is global and ideal so no
+        # scoring is needed
+        if self.target.qargs is None:
+            return
+        if self.strict_direction:
+            cm_graph = PyDiGraph(multigraph=False)
         else:
-            cm_graph, cm_nodes = vf2_utils.shuffle_coupling_graph(
-                self.coupling_map, self.seed, self.strict_direction
-            )
+            cm_graph = PyGraph(multigraph=False)
+        # If None is present in qargs there are globally defined ideal operations
+        # we should add these to all entries based on the number of qubits, so we
+        # treat that as a valid operation even if there is no scoring for the
+        # strict direction case
+        global_ops = None
+        if None in self.target.qargs:
+            global_ops = {1: [], 2: []}
+            for op in self.target.operation_names_for_qargs(None):
+                operation = self.target.operation_for_name(op)
+                # If operation is a class this is a variable width ideal instruction
+                # so we treat it as available on both 1 and 2 qubits
+                if inspect.isclass(operation):
+                    global_ops[1].append(op)
+                    global_ops[2].append(op)
+                else:
+                    num_qubits = operation.num_qubits
+                    if num_qubits in global_ops:
+                        global_ops[num_qubits].append(op)
+        op_names = []
+        for i in range(self.target.num_qubits):
+            try:
+                entry = set(self.target.operation_names_for_qargs((i,)))
+            except KeyError:
+                entry = set()
+            if global_ops is not None:
+                entry.update(global_ops[1])
+            op_names.append(entry)
+        cm_graph.add_nodes_from(op_names)
+        for qargs in self.target.qargs:
+            len_args = len(qargs)
+            # If qargs == 1 we already populated it and if qargs > 2 there are no instructions
+            # using those in the circuit because we'd have already returned by this point
+            if len_args == 2:
+                ops = set(self.target.operation_names_for_qargs(qargs))
+                if global_ops is not None:
+                    ops.update(global_ops[2])
+                cm_graph.add_edge(qargs[0], qargs[1], ops)
+        cm_nodes = list(cm_graph.node_indexes())
+        # Filter qubits without any supported operations. If they
+        # don't support any operations, they're not valid for layout selection.
+        # This is only needed in the undirected case because in strict direction
+        # mode the node matcher will not match since none of the circuit ops
+        # will match the cmap ops.
+        if not self.strict_direction:
+            has_operations = set(itertools.chain.from_iterable(self.target.qargs))
+            to_remove = set(cm_graph.node_indices()).difference(has_operations)
+            if to_remove:
+                cm_graph.remove_nodes_from(list(to_remove))
 
         logger.debug("Running VF2 to find post transpile mappings")
         if self.target and self.strict_direction:
@@ -416,26 +373,4 @@ class VF2PostLayout(AnalysisPass):
                         props = self.target[gate][qargs]
                         if props is not None and props.error is not None:
                             fidelity *= (1 - props.error) ** count
-        else:
-            for bit, node_index in bit_map.items():
-                gate_counts = im_graph[node_index]
-                for gate, count in gate_counts.items():
-                    if gate == "measure":
-                        try:
-                            fidelity *= (1 - self.properties.readout_error(bits[bit])) ** count
-                        except BackendPropertyError:
-                            pass
-                    else:
-                        try:
-                            fidelity *= (1 - self.properties.gate_error(gate, bits[bit])) ** count
-                        except BackendPropertyError:
-                            pass
-            for edge in im_graph.edge_index_map().values():
-                qargs = (bits[reverse_bit_map[edge[0]]], bits[reverse_bit_map[edge[1]]])
-                gate_counts = edge[2]
-                for gate, count in gate_counts.items():
-                    try:
-                        fidelity *= (1 - self.properties.gate_error(gate, qargs)) ** count
-                    except BackendPropertyError:
-                        pass
         return 1 - fidelity

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -13,7 +13,6 @@
 """This module contains common utils for vf2 layout passes."""
 
 from collections import defaultdict
-import statistics
 import random
 
 import numpy as np
@@ -142,7 +141,7 @@ def score_layout(
     )
 
 
-def build_average_error_map(target, properties, coupling_map):
+def build_average_error_map(target, coupling_map):
     """Build an average error map used for scoring layouts pre-basis translation."""
     num_qubits = 0
     if target is not None and target.qargs is not None:
@@ -173,35 +172,12 @@ def build_average_error_map(target, properties, coupling_map):
                     qargs = (qargs[0], qargs[0])
                 avg_map.add_error(qargs, qarg_error / count)
                 built = True
-    elif properties is not None:
-        errors = defaultdict(list)
-        for qubit in range(len(properties.qubits)):
-            errors[(qubit,)].append(properties.readout_error(qubit))
-        for gate in properties.gates:
-            qubits = tuple(gate.qubits)
-            for param in gate.parameters:
-                if param.name == "gate_error":
-                    errors[qubits].append(param.value)
-        for k, v in errors.items():
-            if len(k) == 1:
-                qargs = (k[0], k[0])
-            else:
-                qargs = k
-            # If the properties payload contains an index outside the number of qubits
-            # the properties are invalid for the given input. This normally happens either
-            # with a malconstructed properties payload or if the faulty qubits feature of
-            # BackendV1/BackendPropeties is being used. In such cases we map noise characteristics
-            # so we should just treat the mapping as an ideal case.
-            if qargs[0] >= num_qubits or qargs[1] >= num_qubits:
-                continue
-            avg_map.add_error(qargs, statistics.mean(v))
-            built = True
     # if there are no error rates in the target we should fallback to using the degree heuristic
     # used for a coupling map. To do this we can build the coupling map from the target before
     # running the fallback heuristic
     if not built and target is not None and coupling_map is None:
         coupling_map = target.build_coupling_map()
-    if not built and coupling_map is not None:
+    if not built and coupling_map is not None and num_qubits is not None:
         for qubit in range(num_qubits):
             avg_map.add_error(
                 (qubit, qubit),

qiskit/transpiler/passes/optimization/__init__.py

@@ -20,7 +20,6 @@ from .consolidate_blocks import ConsolidateBlocks
 from .commutation_analysis import CommutationAnalysis
 from .commutative_cancellation import CommutativeCancellation
 from .commutative_inverse_cancellation import CommutativeInverseCancellation
-from .cx_cancellation import CXCancellation
 from .optimize_1q_commutation import Optimize1qGatesSimpleCommutation
 from .optimize_swap_before_measure import OptimizeSwapBeforeMeasure
 from .remove_reset_in_zero_state import RemoveResetInZeroState
@@ -30,14 +29,14 @@ from .hoare_opt import HoareOptimizer
 from .template_optimization import TemplateOptimization
 from .inverse_cancellation import InverseCancellation
 from .collect_1q_runs import Collect1qRuns
-from .echo_rzx_weyl_decomposition import EchoRZXWeylDecomposition
 from .collect_linear_functions import CollectLinearFunctions
 from .reset_after_measure_simplification import ResetAfterMeasureSimplification
 from .optimize_cliffords import OptimizeCliffords
 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
+from .contract_idle_wires_in_control_flow import ContractIdleWiresInControlFlow
+from .light_cone import LightCone

qiskit/transpiler/passes/optimization/collect_and_collapse.py

@@ -95,6 +95,7 @@ def collect_using_filter_function(
     min_block_size,
     split_layers=False,
     collect_from_back=False,
+    max_block_width=None,
 ):
     """Corresponds to an important block collection strategy that greedily collects
     maximal blocks of nodes matching a given ``filter_function``.
@@ -105,6 +106,7 @@ def collect_using_filter_function(
         min_block_size=min_block_size,
         split_layers=split_layers,
         collect_from_back=collect_from_back,
+        max_block_width=max_block_width,
     )
 
 

qiskit/transpiler/passes/optimization/collect_cliffords.py

@@ -39,6 +39,7 @@ class CollectCliffords(CollectAndCollapse):
         split_layers=False,
         collect_from_back=False,
         matrix_based=False,
+        max_block_width=None,
     ):
         """CollectCliffords initializer.
 
@@ -55,6 +56,9 @@ class CollectCliffords(CollectAndCollapse):
                 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).
+            max_block_width (int | None): specifies the maximum width of the block
+                (that is, the number of qubits over which the block is defined)
+                for the block to be collected.
         """
 
         collect_function = partial(
@@ -64,6 +68,7 @@ class CollectCliffords(CollectAndCollapse):
             min_block_size=min_block_size,
             split_layers=split_layers,
             collect_from_back=collect_from_back,
+            max_block_width=max_block_width,
         )
         collapse_function = partial(collapse_to_operation, collapse_function=_collapse_to_clifford)
 

qiskit/transpiler/passes/optimization/collect_linear_functions.py

@@ -34,6 +34,7 @@ class CollectLinearFunctions(CollectAndCollapse):
         min_block_size=2,
         split_layers=False,
         collect_from_back=False,
+        max_block_width=None,
     ):
         """CollectLinearFunctions initializer.
 
@@ -48,6 +49,9 @@ class CollectLinearFunctions(CollectAndCollapse):
                 over disjoint qubit subsets.
             collect_from_back (bool): specifies if blocks should be collected started
                 from the end of the circuit.
+            max_block_width (int | None): specifies the maximum width of the block
+                (that is, the number of qubits over which the block is defined)
+                for the block to be collected.
         """
 
         collect_function = partial(
@@ -57,6 +61,7 @@ class CollectLinearFunctions(CollectAndCollapse):
             min_block_size=min_block_size,
             split_layers=split_layers,
             collect_from_back=collect_from_back,
+            max_block_width=max_block_width,
         )
         collapse_function = partial(
             collapse_to_operation, collapse_function=_collapse_to_linear_function

qiskit/transpiler/passes/optimization/collect_multiqubit_blocks.py

@@ -33,13 +33,18 @@ class CollectMultiQBlocks(AnalysisPass):
     Some gates may not be present in any block (e.g. if the number
     of operands is greater than ``max_block_size``)
 
+    By default, blocks are collected in the direction from the inputs towards the
+    outputs of the DAG. The option ``collect_from_back`` allows to change this
+    direction, that is to collect blocks from the outputs towards the inputs.
+    Note that the blocks are still reported in a valid topological order.
+
     A Disjoint Set Union data structure (DSU) is used to maintain blocks as
     gates are processed. This data structure points each qubit to a set at all
     times and the sets correspond to current blocks. These change over time
     and the data structure allows these changes to be done quickly.
     """
 
-    def __init__(self, max_block_size=2):
+    def __init__(self, max_block_size=2, collect_from_back=False):
         super().__init__()
         self.parent = {}  # parent array for the union
 
@@ -49,6 +54,7 @@ class CollectMultiQBlocks(AnalysisPass):
         self.gate_groups = {}  # current gate lists for the groups
 
         self.max_block_size = max_block_size  # maximum block size
+        self.collect_from_back = collect_from_back  # backward collection
 
     def find_set(self, index):
         """DSU function for finding root of set of items
@@ -127,6 +133,10 @@ class CollectMultiQBlocks(AnalysisPass):
 
         op_nodes = dag.topological_op_nodes(key=collect_key)
 
+        # When collecting from the back, the order of nodes is reversed
+        if self.collect_from_back:
+            op_nodes = reversed(list(op_nodes))
+
         for nd in op_nodes:
             can_process = True
             makes_too_big = False
@@ -222,6 +232,11 @@ class CollectMultiQBlocks(AnalysisPass):
             if item == index and len(self.gate_groups[index]) != 0:
                 block_list.append(self.gate_groups[index][:])
 
+        # When collecting from the back, both the order of the blocks
+        # and the order of nodes in each block should be reversed.
+        if self.collect_from_back:
+            block_list = [block[::-1] for block in block_list[::-1]]
+
         self.property_set["block_list"] = block_list
 
         return dag

qiskit/transpiler/passes/optimization/commutation_analysis.py

@@ -18,10 +18,10 @@ from qiskit._accelerate.commutation_analysis import analyze_commutations
 
 
 class CommutationAnalysis(AnalysisPass):
-    """Analysis pass to find commutation relations between DAG nodes.
+    r"""Analysis pass to find commutation relations between DAG nodes.
 
-    ``property_set['commutation_set']`` is a dictionary that describes
-    the commutation relations on a given wire, all the gates on a wire
+    This sets ``property_set['commutation_set']`` to a dictionary that describes
+    the commutation relations on a given wire: all the gates on a wire
     are grouped into a set of gates that commute.
     """
 

qiskit/transpiler/passes/optimization/consolidate_blocks.py

@@ -12,10 +12,22 @@
 
 """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
+from qiskit.synthesis.two_qubit import TwoQubitBasisDecomposer, TwoQubitControlledUDecomposer
+from qiskit.circuit.library.standard_gates import (
+    CXGate,
+    CZGate,
+    iSwapGate,
+    ECRGate,
+    RXXGate,
+    RYYGate,
+    RZZGate,
+    RZXGate,
+    CRXGate,
+    CRYGate,
+    CRZGate,
+    CPhaseGate,
+)
 
 from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passmanager import PassManager
@@ -29,7 +41,17 @@ KAK_GATE_NAMES = {
     "cz": CZGate(),
     "iswap": iSwapGate(),
     "ecr": ECRGate(),
-    "rxx": RXXGate(pi / 2),
+}
+
+KAK_GATE_PARAM_NAMES = {
+    "rxx": RXXGate,
+    "rzz": RZZGate,
+    "ryy": RYYGate,
+    "rzx": RZXGate,
+    "cphase": CPhaseGate,
+    "crx": CRXGate,
+    "cry": CRYGate,
+    "crz": CRZGate,
 }
 
 
@@ -69,7 +91,9 @@ class ConsolidateBlocks(TransformationPass):
         """
         super().__init__()
         self.basis_gates = None
-        self.target = target
+        # Bypass target if it doesn't contain any basis gates (i.e. it's a _FakeTarget), as this
+        # not part of the official target model.
+        self.target = target if target is not None and len(target.operation_names) > 0 else None
         if basis_gates is not None:
             self.basis_gates = set(basis_gates)
         self.force_consolidate = force_consolidate
@@ -77,13 +101,14 @@ class ConsolidateBlocks(TransformationPass):
             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
+            kak_param_gates = KAK_GATE_PARAM_NAMES.keys() & (basis_gates or [])
+            if kak_param_gates:
+                self.decomposer = TwoQubitControlledUDecomposer(
+                    KAK_GATE_PARAM_NAMES[list(kak_param_gates)[0]]
                 )
-            elif "rzx" in basis_gates:
+            elif kak_gates:
                 self.decomposer = TwoQubitBasisDecomposer(
-                    CXGate(), basis_fidelity=approximation_degree or 1.0
+                    KAK_GATE_NAMES[list(kak_gates)[0]], basis_fidelity=approximation_degree or 1.0
                 )
             else:
                 self.decomposer = None
@@ -109,7 +134,7 @@ class ConsolidateBlocks(TransformationPass):
         consolidate_blocks(
             dag,
             self.decomposer._inner_decomposer,
-            self.decomposer.gate.name,
+            self.decomposer.gate_name,
             self.force_consolidate,
             target=self.target,
             basis_gates=self.basis_gates,
@@ -138,12 +163,9 @@ class ConsolidateBlocks(TransformationPass):
             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.control_flow_op_nodes():
+            dag.substitute_node(
+                node,
+                node.op.replace_blocks(pass_manager.run(block) for block in node.op.blocks),
+            )
         return dag

qiskit/transpiler/passes/optimization/contract_idle_wires_in_control_flow.py

@@ -0,0 +1,104 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Contract control-flow operations that contain idle wires."""
+
+from qiskit.circuit import Qubit, Clbit, QuantumCircuit
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.transpiler.basepasses import TransformationPass
+
+
+class ContractIdleWiresInControlFlow(TransformationPass):
+    """Remove idle qubits from control-flow operations of a :class:`.DAGCircuit`."""
+
+    def run(self, dag):
+        # `control_flow_op_nodes` is eager and doesn't borrow; we're mutating the DAG in the loop.
+        for node in dag.control_flow_op_nodes() or []:
+            inst = node._to_circuit_instruction()
+            new_inst = _contract_control_flow(inst)
+            if new_inst is inst:
+                # No top-level contraction; nothing to do.
+                continue
+            replacement = DAGCircuit()
+            # Dictionaries to retain insertion order for reproducibility, and because we can
+            # then re-use them as mapping dictionaries.
+            qubits, clbits, vars_ = {}, {}, {}
+            for _, _, wire in dag.edges(node):
+                if isinstance(wire, Qubit):
+                    qubits[wire] = wire
+                elif isinstance(wire, Clbit):
+                    clbits[wire] = wire
+                else:
+                    vars_[wire] = wire
+            replacement.add_qubits(list(qubits))
+            replacement.add_clbits(list(clbits))
+            for var in vars_:
+                replacement.add_captured_var(var)
+            replacement._apply_op_node_back(DAGOpNode.from_instruction(new_inst))
+            # The replacement DAG is defined over all the same qubits, but with the correct
+            # qubits now explicitly marked as idle, so everything gets linked up correctly.
+            dag.substitute_node_with_dag(node, replacement, wires=qubits | clbits | vars_)
+        return dag
+
+
+def _contract_control_flow(inst):
+    """Contract a `CircuitInstruction` containing a control-flow operation.
+
+    Returns the input object by the same reference if there's no contraction to be done at the call
+    site, though nested control-flow ops may have been contracted in place."""
+    op = inst.operation
+    idle = set(inst.qubits)
+    for block in op.blocks:
+        qubit_map = dict(zip(block.qubits, inst.qubits))
+        for i, inner in enumerate(block.data):
+            if inner.is_control_flow():
+                # In `QuantumCircuit` it's easy to replace an instruction with a narrower one, so it
+                # doesn't matter much if this is replacing it with itself.
+                block.data[i] = inner = _contract_control_flow(inner)
+            for qubit in inner.qubits:
+                idle.discard(qubit_map[qubit])
+    # If a box, we still want the prior side-effect of contracting any internal control-flow
+    # operations (optimisations are still valid _within_ a box), but we don't want to contract the
+    # box itself.  If there's no idle qubits, we're also done here.
+    if not idle or inst.name == "box":
+        return inst
+
+    def contract(block):
+        out = QuantumCircuit(
+            name=block.name,
+            global_phase=block.global_phase,
+            metadata=block.metadata,
+            captures=block.iter_captures(),
+        )
+        out.add_bits(
+            [
+                block_qubit
+                for (block_qubit, inst_qubit) in zip(block.qubits, inst.qubits)
+                if inst_qubit not in idle
+            ]
+        )
+        out.add_bits(block.clbits)
+        for creg in block.cregs:
+            out.add_register(creg)
+        # Control-flow ops can only have captures and locals, and we already added the captures.
+        for var in block.iter_declared_vars():
+            out.add_uninitialized_var(var)
+        for stretch in block.iter_declared_stretches():
+            out.add_stretch(stretch)
+        for inner in block:
+            out._append(inner)
+        return out
+
+    return inst.replace(
+        operation=op.replace_blocks(contract(block) for block in op.blocks),
+        qubits=[qubit for qubit in inst.qubits if qubit not in idle],
+    )