qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/transpiler/passes/synthesis/default_unitary_synth_plugin.py

@@ -0,0 +1,653 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2020.
+#
+# 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.
+
+"""
+=========================================================================================
+Unitary Synthesis Plugin (in :mod:`qiskit.transpiler.passes.synthesis.unitary_synthesis`)
+=========================================================================================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   DefaultUnitarySynthesis
+"""
+
+from __future__ import annotations
+from math import pi, inf, isclose
+from itertools import product
+from functools import partial
+import numpy as np
+
+from qiskit.circuit import Gate, Parameter
+from qiskit.circuit.library.standard_gates import (
+    iSwapGate,
+    CXGate,
+    CZGate,
+    RXXGate,
+    RZXGate,
+    RZZGate,
+    RYYGate,
+    ECRGate,
+    RXGate,
+    SXGate,
+    XGate,
+    RZGate,
+    UGate,
+    PhaseGate,
+    U1Gate,
+    U2Gate,
+    U3Gate,
+    RYGate,
+    RGate,
+    CRXGate,
+    CRYGate,
+    CRZGate,
+    CPhaseGate,
+)
+from qiskit.converters import circuit_to_dag
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit.dagnode import DAGOpNode
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info import Operator
+from qiskit.synthesis.two_qubit.xx_decompose import XXDecomposer, XXEmbodiments
+from qiskit.synthesis.two_qubit.two_qubit_decompose import (
+    TwoQubitBasisDecomposer,
+    TwoQubitWeylDecomposition,
+    TwoQubitControlledUDecomposer,
+)
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.passes.optimization.optimize_1q_decomposition import (
+    Optimize1qGatesDecomposition,
+    _possible_decomposers,
+)
+from qiskit.transpiler.passes.synthesis import plugin
+
+
+GATE_NAME_MAP = {
+    "cx": CXGate._standard_gate,
+    "rx": RXGate._standard_gate,
+    "sx": SXGate._standard_gate,
+    "x": XGate._standard_gate,
+    "rz": RZGate._standard_gate,
+    "u": UGate._standard_gate,
+    "p": PhaseGate._standard_gate,
+    "u1": U1Gate._standard_gate,
+    "u2": U2Gate._standard_gate,
+    "u3": U3Gate._standard_gate,
+    "ry": RYGate._standard_gate,
+    "r": RGate._standard_gate,
+    "rzz": RZZGate._standard_gate,
+    "ryy": RYYGate._standard_gate,
+    "rxx": RXXGate._standard_gate,
+    "rzx": RXXGate._standard_gate,
+    "cp": CPhaseGate._standard_gate,
+    "crx": RXXGate._standard_gate,
+    "cry": RXXGate._standard_gate,
+    "crz": RXXGate._standard_gate,
+}
+
+KAK_GATE_PARAM_NAMES = {
+    "rxx": RXXGate,
+    "rzz": RZZGate,
+    "ryy": RYYGate,
+    "rzx": RZXGate,
+    "cphase": CPhaseGate,
+    "crx": CRXGate,
+    "cry": CRYGate,
+    "crz": CRZGate,
+}
+
+KAK_GATE_NAMES = {
+    "cx": CXGate(),
+    "cz": CZGate(),
+    "iswap": iSwapGate(),
+    "ecr": ECRGate(),
+}
+
+
+def _choose_kak_gate(basis_gates):
+    """Choose the first available 2q gate to use in the KAK decomposition."""
+    kak_gate = None
+    kak_gates = sorted(set(basis_gates or []).intersection(KAK_GATE_NAMES.keys()))
+    kak_gates_params = sorted(set(basis_gates or []).intersection(KAK_GATE_PARAM_NAMES.keys()))
+
+    if kak_gates_params:
+        kak_gate = KAK_GATE_PARAM_NAMES[kak_gates_params[0]]
+
+    elif kak_gates:
+        kak_gate = KAK_GATE_NAMES[kak_gates[0]]
+
+    return kak_gate
+
+
+def _choose_euler_basis(basis_gates):
+    """Choose the first available 1q basis to use in the Euler decomposition."""
+    basis_set = set(basis_gates or [])
+    decomposers = _possible_decomposers(basis_set)
+    if decomposers:
+        return decomposers[0]
+    return "U"
+
+
+def _find_matching_euler_bases(target, qubit):
+    """Find matching available 1q basis to use in the Euler decomposition."""
+    basis_set = target.operation_names_for_qargs((qubit,))
+    return _possible_decomposers(basis_set)
+
+
+def _decomposer_2q_from_basis_gates(basis_gates, pulse_optimize=None, approximation_degree=None):
+    decomposer2q = None
+    kak_gate = _choose_kak_gate(basis_gates)
+    euler_basis = _choose_euler_basis(basis_gates)
+    basis_fidelity = approximation_degree or 1.0
+
+    if kak_gate in KAK_GATE_PARAM_NAMES.values():
+        decomposer2q = TwoQubitControlledUDecomposer(kak_gate, euler_basis)
+    elif kak_gate is not None:
+        decomposer2q = TwoQubitBasisDecomposer(
+            kak_gate,
+            basis_fidelity=basis_fidelity,
+            euler_basis=euler_basis,
+            pulse_optimize=pulse_optimize,
+        )
+    return decomposer2q
+
+
+def _error(circuit, target=None, qubits=None):
+    """
+    Calculate a rough error for a `circuit` that runs on specific
+    `qubits` of `target`.
+
+    Use basis errors from target if available, otherwise use length
+    of circuit as a weak proxy for error.
+    """
+    if target is None:
+        if isinstance(circuit, DAGCircuit):
+            return len(circuit.op_nodes())
+        else:
+            return len(circuit)
+    gate_fidelities = []
+    gate_durations = []
+
+    def score_instruction(inst, inst_qubits):
+        try:
+            keys = target.operation_names_for_qargs(inst_qubits)
+            for key in keys:
+                target_op = target.operation_from_name(key)
+                if isinstance(circuit, DAGCircuit):
+                    op = inst.op
+                else:
+                    op = inst.operation
+                if isinstance(target_op, op.base_class) and (
+                    target_op.is_parameterized()
+                    or all(
+                        isclose(float(p1), float(p2)) for p1, p2 in zip(target_op.params, op.params)
+                    )
+                ):
+                    inst_props = target[key].get(inst_qubits, None)
+                    if inst_props is not None:
+                        error = getattr(inst_props, "error", 0.0) or 0.0
+                        duration = getattr(inst_props, "duration", 0.0) or 0.0
+                        gate_fidelities.append(1 - error)
+                        gate_durations.append(duration)
+                    else:
+                        gate_fidelities.append(1.0)
+                        gate_durations.append(0.0)
+
+                    break
+            else:
+                raise KeyError
+        except KeyError as error:
+            if isinstance(circuit, DAGCircuit):
+                op = inst.op
+            else:
+                op = inst.operation
+            raise TranspilerError(
+                f"Encountered a bad synthesis. " f"Target has no {op} on qubits {qubits}."
+            ) from error
+
+    if isinstance(circuit, DAGCircuit):
+        for inst in circuit.topological_op_nodes():
+            inst_qubits = tuple(qubits[circuit.find_bit(q).index] for q in inst.qargs)
+            score_instruction(inst, inst_qubits)
+    else:
+        for inst in circuit:
+            inst_qubits = tuple(qubits[circuit.find_bit(q).index] for q in inst.qubits)
+            score_instruction(inst, inst_qubits)
+    # TODO:return np.sum(gate_durations)
+    return 1 - np.prod(gate_fidelities)
+
+
+def _preferred_direction(
+    decomposer2q, qubits, natural_direction, coupling_map=None, gate_lengths=None, gate_errors=None
+):
+    """
+    `decomposer2q` decomposes an SU(4) over `qubits`. A user sets `natural_direction`
+    to indicate whether they prefer synthesis in a hardware-native direction.
+    If yes, we return the `preferred_direction` here. If no hardware direction is
+    preferred, we raise an error (unless natural_direction is None).
+    We infer this from `coupling_map`, `gate_lengths`, `gate_errors`.
+
+    Returns [0, 1] if qubits are correct in the hardware-native direction.
+    Returns [1, 0] if qubits must be flipped to match hardware-native direction.
+    """
+    qubits_tuple = tuple(qubits)
+    reverse_tuple = qubits_tuple[::-1]
+
+    preferred_direction = None
+    if natural_direction in {None, True}:
+        # find native gate directions from a (non-bidirectional) coupling map
+        if coupling_map is not None:
+            neighbors0 = coupling_map.neighbors(qubits[0])
+            zero_one = qubits[1] in neighbors0
+            neighbors1 = coupling_map.neighbors(qubits[1])
+            one_zero = qubits[0] in neighbors1
+            if zero_one and not one_zero:
+                preferred_direction = [0, 1]
+            if one_zero and not zero_one:
+                preferred_direction = [1, 0]
+        # otherwise infer natural directions from gate durations or gate errors
+        if preferred_direction is None and (gate_lengths or gate_errors):
+            cost_0_1 = inf
+            cost_1_0 = inf
+            try:
+                cost_0_1 = next(
+                    duration
+                    for gate, duration in gate_lengths.get(qubits_tuple, [])
+                    if gate == decomposer2q.gate
+                )
+            except StopIteration:
+                pass
+            try:
+                cost_1_0 = next(
+                    duration
+                    for gate, duration in gate_lengths.get(reverse_tuple, [])
+                    if gate == decomposer2q.gate
+                )
+            except StopIteration:
+                pass
+            if not (cost_0_1 < inf or cost_1_0 < inf):
+                try:
+                    cost_0_1 = next(
+                        error
+                        for gate, error in gate_errors.get(qubits_tuple, [])
+                        if gate == decomposer2q.gate
+                    )
+                except StopIteration:
+                    pass
+                try:
+                    cost_1_0 = next(
+                        error
+                        for gate, error in gate_errors.get(reverse_tuple, [])
+                        if gate == decomposer2q.gate
+                    )
+                except StopIteration:
+                    pass
+            if cost_0_1 < cost_1_0:
+                preferred_direction = [0, 1]
+            elif cost_1_0 < cost_0_1:
+                preferred_direction = [1, 0]
+    if natural_direction is True and preferred_direction is None:
+        raise TranspilerError(
+            f"No preferred direction of gate on qubits {qubits} "
+            "could be determined from coupling map or "
+            "gate lengths / gate errors."
+        )
+    return preferred_direction
+
+
+class DefaultUnitarySynthesis(plugin.UnitarySynthesisPlugin):
+    """The default unitary synthesis plugin."""
+
+    @property
+    def supports_basis_gates(self):
+        return True
+
+    @property
+    def supports_coupling_map(self):
+        return True
+
+    @property
+    def supports_natural_direction(self):
+        return True
+
+    @property
+    def supports_pulse_optimize(self):
+        return True
+
+    @property
+    def supports_gate_lengths(self):
+        return False
+
+    @property
+    def supports_gate_errors(self):
+        return False
+
+    @property
+    def supports_gate_lengths_by_qubit(self):
+        return True
+
+    @property
+    def supports_gate_errors_by_qubit(self):
+        return True
+
+    @property
+    def max_qubits(self):
+        return None
+
+    @property
+    def min_qubits(self):
+        return None
+
+    @property
+    def supported_bases(self):
+        return None
+
+    @property
+    def supports_target(self):
+        return True
+
+    def __init__(self):
+        super().__init__()
+        self._decomposer_cache = {}
+
+    def _decomposer_2q_from_target(self, target, qubits, approximation_degree):
+        # we just need 2-qubit decomposers, in any direction.
+        # we'll fix the synthesis direction later.
+        qubits_tuple = tuple(sorted(qubits))
+        reverse_tuple = qubits_tuple[::-1]
+        if qubits_tuple in self._decomposer_cache:
+            return self._decomposer_cache[qubits_tuple]
+
+        # available instructions on this qubit pair, and their associated property.
+        available_2q_basis = {}
+        available_2q_props = {}
+
+        # 2q gates sent to 2q decomposers must not have any symbolic parameters.  The
+        # gates must be convertable to a numeric matrix. If a basis gate supports an arbitrary
+        # angle, we have to choose one angle (or more.)
+        def _replace_parameterized_gate(op):
+            if isinstance(op, RXXGate) and isinstance(op.params[0], Parameter):
+                op = RXXGate(pi / 2)
+            elif isinstance(op, RZXGate) and isinstance(op.params[0], Parameter):
+                op = RZXGate(pi / 4)
+            elif isinstance(op, RZZGate) and isinstance(op.params[0], Parameter):
+                op = RZZGate(pi / 2)
+            return op
+
+        try:
+            keys = target.operation_names_for_qargs(qubits_tuple)
+            for key in keys:
+                op = target.operation_from_name(key)
+                if not isinstance(op, Gate):
+                    continue
+                available_2q_basis[key] = _replace_parameterized_gate(op)
+                available_2q_props[key] = target[key][qubits_tuple]
+        except KeyError:
+            pass
+        try:
+            keys = target.operation_names_for_qargs(reverse_tuple)
+            for key in keys:
+                if key not in available_2q_basis:
+                    op = target.operation_from_name(key)
+                    if not isinstance(op, Gate):
+                        continue
+                    available_2q_basis[key] = _replace_parameterized_gate(op)
+                    available_2q_props[key] = target[key][reverse_tuple]
+        except KeyError:
+            pass
+        if not available_2q_basis:
+            raise TranspilerError(
+                f"Target has no gates available on qubits {qubits} to synthesize over."
+            )
+        # available decomposition basis on each of the qubits of the pair
+        # NOTE: assumes both qubits have the same single-qubit gates
+        available_1q_basis = _find_matching_euler_bases(target, qubits_tuple[0])
+
+        # find all decomposers
+        # TODO: reduce number of decomposers here somehow
+        decomposers = []
+
+        def is_supercontrolled(gate):
+            try:
+                operator = Operator(gate)
+            except QiskitError:
+                return False
+            kak = TwoQubitWeylDecomposition(operator.data)
+            return isclose(kak.a, pi / 4) and isclose(kak.c, 0.0)
+
+        def is_controlled(gate):
+            try:
+                operator = Operator(gate)
+            except QiskitError:
+                return False
+            kak = TwoQubitWeylDecomposition(operator.data)
+            return isclose(kak.b, 0.0) and isclose(kak.c, 0.0)
+
+        # possible supercontrolled decomposers (i.e. TwoQubitBasisDecomposer)
+        supercontrolled_basis = {
+            k: v for k, v in available_2q_basis.items() if is_supercontrolled(v)
+        }
+        for basis_1q, basis_2q in product(available_1q_basis, supercontrolled_basis.keys()):
+            props = available_2q_props.get(basis_2q)
+            if props is None:
+                basis_2q_fidelity = 1.0
+            else:
+                error = getattr(props, "error", 0.0)
+                if error is None:
+                    error = 0.0
+                basis_2q_fidelity = 1 - error
+            if approximation_degree is not None:
+                basis_2q_fidelity *= approximation_degree
+            decomposer = TwoQubitBasisDecomposer(
+                supercontrolled_basis[basis_2q],
+                euler_basis=basis_1q,
+                basis_fidelity=basis_2q_fidelity,
+            )
+            decomposers.append(decomposer)
+
+        # If our 2q basis gates are a subset of cx, ecr, or cz then we know TwoQubitBasisDecomposer
+        # is an ideal decomposition and there is no need to bother calculating the XX embodiments
+        # or try the XX decomposer
+        if {"cx", "cz", "ecr"}.issuperset(available_2q_basis):
+            self._decomposer_cache[qubits_tuple] = decomposers
+            return decomposers
+
+        # possible controlled decomposers (i.e. XXDecomposer)
+        controlled_basis = {k: v for k, v in available_2q_basis.items() if is_controlled(v)}
+        basis_2q_fidelity = {}
+        embodiments = {}
+        pi2_basis = None
+        for k, v in controlled_basis.items():
+            strength = 2 * TwoQubitWeylDecomposition(Operator(v).data).a  # pi/2: fully entangling
+            # each strength has its own fidelity
+            props = available_2q_props.get(k)
+            if props is None:
+                basis_2q_fidelity[strength] = 1.0
+            else:
+                error = getattr(props, "error", 0.0)
+                if error is None:
+                    error = 0.0
+                basis_2q_fidelity[strength] = 1 - error
+            # rewrite XX of the same strength in terms of it
+            embodiment = XXEmbodiments[v.base_class]
+            if len(embodiment.parameters) == 1:
+                embodiments[strength] = embodiment.assign_parameters([strength])
+            else:
+                embodiments[strength] = embodiment
+            # basis equivalent to CX are well optimized so use for the pi/2 angle if available
+            if isclose(strength, pi / 2) and k in supercontrolled_basis:
+                pi2_basis = v
+        # if we are using the approximation_degree knob, use it to scale already-given fidelities
+        if approximation_degree is not None:
+            basis_2q_fidelity = {k: v * approximation_degree for k, v in basis_2q_fidelity.items()}
+        if basis_2q_fidelity:
+            for basis_1q in available_1q_basis:
+                if isinstance(pi2_basis, CXGate) and basis_1q == "ZSX":
+                    # If we're going to use the pulse optimal decomposition
+                    # in TwoQubitBasisDecomposer we need to compute the basis
+                    # fidelity to use for the decomposition. Either use the
+                    # cx error rate if approximation degree is None, or
+                    # the approximation degree value if it's a float
+                    if approximation_degree is None:
+                        props = target["cx"].get(qubits_tuple)
+                        if props is not None:
+                            fidelity = 1.0 - getattr(props, "error", 0.0)
+                        else:
+                            fidelity = 1.0
+                    else:
+                        fidelity = approximation_degree
+                    pi2_decomposer = TwoQubitBasisDecomposer(
+                        pi2_basis,
+                        euler_basis=basis_1q,
+                        basis_fidelity=fidelity,
+                        pulse_optimize=True,
+                    )
+                    embodiments.update({pi / 2: XXEmbodiments[pi2_decomposer.gate.base_class]})
+                else:
+                    pi2_decomposer = None
+                decomposer = XXDecomposer(
+                    basis_fidelity=basis_2q_fidelity,
+                    euler_basis=basis_1q,
+                    embodiments=embodiments,
+                    backup_optimizer=pi2_decomposer,
+                )
+                decomposers.append(decomposer)
+
+        self._decomposer_cache[qubits_tuple] = decomposers
+        return decomposers
+
+    def run(self, unitary, **options):
+        # Approximation degree is set directly as an attribute on the
+        # instance by the UnitarySynthesis pass here as it's not part of
+        # plugin interface. However if for some reason it's not set assume
+        # it's 1.
+        approximation_degree = getattr(self, "_approximation_degree", 1.0)
+        basis_gates = options["basis_gates"]
+        coupling_map = options["coupling_map"][0]
+        natural_direction = options["natural_direction"]
+        pulse_optimize = options["pulse_optimize"]
+        gate_lengths = options["gate_lengths_by_qubit"]
+        gate_errors = options["gate_errors_by_qubit"]
+        qubits = options["coupling_map"][1]
+        target = options["target"]
+
+        if unitary.shape == (2, 2):
+            _decomposer1q = Optimize1qGatesDecomposition(basis_gates, target)
+            sequence = _decomposer1q._resynthesize_run(unitary, qubits[0])
+            if sequence is None:
+                return None
+            return _decomposer1q._gate_sequence_to_dag(sequence)
+        elif unitary.shape == (4, 4):
+            # select synthesizers that can lower to the target
+            if target is not None:
+                decomposers2q = self._decomposer_2q_from_target(
+                    target, qubits, approximation_degree
+                )
+            else:
+                decomposer2q = _decomposer_2q_from_basis_gates(
+                    basis_gates, pulse_optimize, approximation_degree
+                )
+                decomposers2q = [decomposer2q] if decomposer2q is not None else []
+            # choose the cheapest output among synthesized circuits
+            synth_circuits = []
+            # If we have a single TwoQubitBasisDecomposer skip dag creation as we don't need to
+            # store and can instead manually create the synthesized gates directly in the output dag
+            if len(decomposers2q) == 1 and isinstance(decomposers2q[0], TwoQubitBasisDecomposer):
+                preferred_direction = _preferred_direction(
+                    decomposers2q[0],
+                    qubits,
+                    natural_direction,
+                    coupling_map,
+                    gate_lengths,
+                    gate_errors,
+                )
+                return self._synth_su4_no_dag(
+                    unitary, decomposers2q[0], preferred_direction, approximation_degree
+                )
+            for decomposer2q in decomposers2q:
+                preferred_direction = _preferred_direction(
+                    decomposer2q, qubits, natural_direction, coupling_map, gate_lengths, gate_errors
+                )
+                synth_circuit = self._synth_su4(
+                    unitary, decomposer2q, preferred_direction, approximation_degree
+                )
+                synth_circuits.append(synth_circuit)
+            synth_circuit = min(
+                synth_circuits,
+                key=partial(_error, target=target, qubits=tuple(qubits)),
+                default=None,
+            )
+        else:
+            from qiskit.synthesis.unitary.qsd import (  # pylint: disable=cyclic-import
+                qs_decomposition,
+            )
+
+            # only decompose if needed. TODO: handle basis better
+            synth_circuit = qs_decomposition(unitary) if (basis_gates or target) else None
+        if synth_circuit is None:
+            return None
+        if isinstance(synth_circuit, DAGCircuit):
+            return synth_circuit
+        return circuit_to_dag(synth_circuit)
+
+    def _synth_su4_no_dag(self, unitary, decomposer2q, preferred_direction, approximation_degree):
+        approximate = not approximation_degree == 1.0
+        synth_circ = decomposer2q._inner_decomposer(unitary, approximate=approximate)
+        if not preferred_direction:
+            return (synth_circ, synth_circ.global_phase, decomposer2q.gate)
+
+        synth_direction = None
+        # if the gates in synthesis are in the opposite direction of the preferred direction
+        # resynthesize a new operator which is the original conjugated by swaps.
+        # this new operator is doubly mirrored from the original and is locally equivalent.
+        for gate, _params, qubits in synth_circ:
+            if gate is None or gate == CXGate._standard_gate:
+                synth_direction = qubits
+        if synth_direction is not None and synth_direction != preferred_direction:
+            # TODO: Avoid using a dag to correct the synthesis direction
+            return self._reversed_synth_su4(unitary, decomposer2q, approximation_degree)
+        return (synth_circ, synth_circ.global_phase, decomposer2q.gate)
+
+    def _synth_su4(self, su4_mat, decomposer2q, preferred_direction, approximation_degree):
+        approximate = not approximation_degree == 1.0
+        synth_circ = decomposer2q(su4_mat, approximate=approximate, use_dag=True)
+        if not preferred_direction:
+            return synth_circ
+        synth_direction = None
+        # if the gates in synthesis are in the opposite direction of the preferred direction
+        # resynthesize a new operator which is the original conjugated by swaps.
+        # this new operator is doubly mirrored from the original and is locally equivalent.
+        for inst in synth_circ.topological_op_nodes():
+            if inst.op.num_qubits == 2:
+                synth_direction = [synth_circ.find_bit(q).index for q in inst.qargs]
+        if synth_direction is not None and synth_direction != preferred_direction:
+            return self._reversed_synth_su4(su4_mat, decomposer2q, approximation_degree)
+        return synth_circ
+
+    def _reversed_synth_su4(self, su4_mat, decomposer2q, approximation_degree):
+        approximate = not approximation_degree == 1.0
+        su4_mat_mm = su4_mat.copy()
+        su4_mat_mm[[1, 2]] = su4_mat_mm[[2, 1]]
+        su4_mat_mm[:, [1, 2]] = su4_mat_mm[:, [2, 1]]
+        synth_circ = decomposer2q(su4_mat_mm, approximate=approximate, use_dag=True)
+        out_dag = DAGCircuit()
+        out_dag.global_phase = synth_circ.global_phase
+        out_dag.add_qubits(list(reversed(synth_circ.qubits)))
+        flip_bits = out_dag.qubits[::-1]
+        for node in synth_circ.topological_op_nodes():
+            qubits = tuple(flip_bits[synth_circ.find_bit(x).index] for x in node.qargs)
+            node = DAGOpNode.from_instruction(
+                node._to_circuit_instruction().replace(qubits=qubits, params=node.params)
+            )
+            out_dag._apply_op_node_back(node)
+        return out_dag