qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0rc1__cp38-abi3-win32.whl

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -33,6 +33,7 @@ from qiskit.circuit.library.standard_gates import (
     XGate,
 )
 from qiskit.circuit import Qubit
+from qiskit.circuit.quantumcircuitdata import CircuitInstruction
 from qiskit.dagcircuit.dagcircuit import DAGCircuit
 from qiskit.dagcircuit.dagnode import DAGOpNode
 
@@ -110,16 +111,7 @@ class Optimize1qGatesDecomposition(TransformationPass):
         else:
             return None
 
-    def _resynthesize_run(self, matrix, qubit=None):
-        """
-        Re-synthesizes one 2x2 `matrix`, typically extracted via `dag.collect_1q_runs`.
-
-        Returns the newly synthesized circuit in the indicated basis, or None
-        if no synthesis routine applied.
-
-        When multiple synthesis options are available, it prefers the one with the lowest
-        error when the circuit is applied to `qubit`.
-        """
+    def _get_decomposer(self, qubit=None):
         # include path for when target exists but target.num_qubits is None (BasicSimulator)
         if self._target is not None and self._target.num_qubits is not None:
             if qubit is not None:
@@ -133,6 +125,19 @@ class Optimize1qGatesDecomposition(TransformationPass):
                 decomposers = _possible_decomposers(available_1q_basis)
         else:
             decomposers = self._global_decomposers
+        return decomposers
+
+    def _resynthesize_run(self, matrix, qubit=None):
+        """
+        Re-synthesizes one 2x2 `matrix`, typically extracted via `dag.collect_1q_runs`.
+
+        Returns the newly synthesized circuit in the indicated basis, or None
+        if no synthesis routine applied.
+
+        When multiple synthesis options are available, it prefers the one with the lowest
+        error when the circuit is applied to `qubit`.
+        """
+        decomposers = self._get_decomposer(qubit)
 
         best_synth_circuit = euler_one_qubit_decomposer.unitary_to_gate_sequence(
             matrix,
@@ -149,10 +154,13 @@ class Optimize1qGatesDecomposition(TransformationPass):
         out_dag.global_phase = best_synth_circuit.global_phase
 
         for gate_name, angles in best_synth_circuit:
-            out_dag.apply_operation_back(NAME_MAP[gate_name](*angles), qubits, check=False)
+            op = CircuitInstruction.from_standard(gate_name, qubits, angles)
+            out_dag.apply_operation_back(op.operation, qubits, check=False)
         return out_dag
 
-    def _substitution_checks(self, dag, old_run, new_circ, basis, qubit):
+    def _substitution_checks(
+        self, dag, old_run, new_circ, basis, qubit, old_error=None, new_error=None
+    ):
         """
         Returns `True` when it is recommended to replace `old_run` with `new_circ` over `basis`.
         """
@@ -176,11 +184,14 @@ class Optimize1qGatesDecomposition(TransformationPass):
         # if we're outside of the basis set, we're obligated to logically decompose.
         # if we're outside of the set of gates for which we have physical definitions,
         #    then we _try_ to decompose, using the results if we see improvement.
-        new_error = 0.0
-        old_error = 0.0
         if not uncalibrated_and_not_basis_p:
-            new_error = self._error(new_circ, qubit)
-            old_error = self._error(old_run, qubit)
+            if new_error is None:
+                new_error = self._error(new_circ, qubit)
+            if old_error is None:
+                old_error = self._error(old_run, qubit)
+        else:
+            new_error = 0.0
+            old_error = 0.0
 
         return (
             uncalibrated_and_not_basis_p
@@ -198,32 +209,47 @@ class Optimize1qGatesDecomposition(TransformationPass):
         Returns:
             DAGCircuit: the optimized DAG.
         """
-        runs = dag.collect_1q_runs()
-        for run in runs:
+        runs = []
+        qubits = []
+        bases = []
+        for run in dag.collect_1q_runs():
             qubit = dag.find_bit(run[0].qargs[0]).index
-            operator = run[0].op.to_matrix()
-            for node in run[1:]:
-                operator = node.op.to_matrix().dot(operator)
-            best_circuit_sequence = self._resynthesize_run(operator, qubit)
-
+            runs.append(run)
+            qubits.append(qubit)
+            bases.append(self._get_decomposer(qubit))
+        best_sequences = euler_one_qubit_decomposer.optimize_1q_gates_decomposition(
+            runs, qubits, bases, simplify=True, error_map=self.error_map
+        )
+        for index, best_circuit_sequence in enumerate(best_sequences):
+            run = runs[index]
+            qubit = qubits[index]
             if self._target is None:
                 basis = self._basis_gates
             else:
                 basis = self._target.operation_names_for_qargs((qubit,))
-
-            if best_circuit_sequence is not None and self._substitution_checks(
-                dag, run, best_circuit_sequence, basis, qubit
-            ):
-                for gate_name, angles in best_circuit_sequence:
-                    op = NAME_MAP[gate_name](*angles)
-                    node = DAGOpNode(NAME_MAP[gate_name](*angles), run[0].qargs, dag=dag)
-                    node._node_id = dag._multi_graph.add_node(node)
-                    dag._increment_op(op)
-                    dag._multi_graph.insert_node_on_in_edges(node._node_id, run[0]._node_id)
-                dag.global_phase += best_circuit_sequence.global_phase
-                # Delete the other nodes in the run
-                for current_node in run:
-                    dag.remove_op_node(current_node)
+            if best_circuit_sequence is not None:
+                (old_error, new_error, best_circuit_sequence) = best_circuit_sequence
+                if self._substitution_checks(
+                    dag,
+                    run,
+                    best_circuit_sequence,
+                    basis,
+                    qubit,
+                    old_error=old_error,
+                    new_error=new_error,
+                ):
+                    first_node_id = run[0]._node_id
+                    qubit = run[0].qargs
+                    for gate, angles in best_circuit_sequence:
+                        op = CircuitInstruction.from_standard(gate, qubit, angles)
+                        node = DAGOpNode.from_instruction(op, dag=dag)
+                        node._node_id = dag._multi_graph.add_node(node)
+                        dag._increment_op(gate.name)
+                        dag._multi_graph.insert_node_on_in_edges(node._node_id, first_node_id)
+                    dag.global_phase += best_circuit_sequence.global_phase
+                    # Delete the other nodes in the run
+                    for current_node in run:
+                        dag.remove_op_node(current_node)
 
         return dag
 
@@ -241,10 +267,7 @@ class Optimize1qGatesDecomposition(TransformationPass):
                 circuit, qubit, self.error_map
             )
         else:
-            circuit_list = [(x.op.name, []) for x in circuit]
-            return euler_one_qubit_decomposer.compute_error_list(
-                circuit_list, qubit, self.error_map
-            )
+            return euler_one_qubit_decomposer.compute_error_list(circuit, qubit, self.error_map)
 
 
 def _possible_decomposers(basis_set):

qiskit/transpiler/passes/optimization/optimize_1q_gates.py

@@ -308,7 +308,7 @@ class Optimize1qGates(TransformationPass):
                 if "u3" in self.basis:
                     new_op = U3Gate(*right_parameters)
                 else:
-                    raise TranspilerError("It was not possible to use the basis %s" % self.basis)
+                    raise TranspilerError(f"It was not possible to use the basis {self.basis}")
 
             dag.global_phase += right_global_phase
 

qiskit/transpiler/passes/optimization/split_2q_unitaries.py

@@ -0,0 +1,83 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2024.
+#
+# 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.
+"""Splits each two-qubit gate in the `dag` into two single-qubit gates, if possible without error."""
+from typing import Optional
+
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit.quantumcircuitdata import CircuitInstruction
+from qiskit.dagcircuit.dagcircuit import DAGCircuit, DAGOpNode
+from qiskit.circuit.library.generalized_gates import UnitaryGate
+from qiskit.synthesis.two_qubit.two_qubit_decompose import TwoQubitWeylDecomposition
+
+
+class Split2QUnitaries(TransformationPass):
+    """Attempt to splits two-qubit gates in a :class:`.DAGCircuit` into two single-qubit gates
+
+    This pass will analyze all the two qubit gates in the circuit and analyze the gate's unitary
+    matrix to determine if the gate is actually a product of 2 single qubit gates. In these
+    cases the 2q gate can be simplified into two single qubit gates and this pass will
+    perform this optimization and will replace the two qubit gate with two single qubit
+    :class:`.UnitaryGate`.
+    """
+
+    def __init__(self, fidelity: Optional[float] = 1.0 - 1e-16):
+        """Split2QUnitaries initializer.
+
+        Args:
+            fidelity (float): Allowed tolerance for splitting two-qubit unitaries and gate decompositions
+        """
+        super().__init__()
+        self.requested_fidelity = fidelity
+
+    def run(self, dag: DAGCircuit):
+        """Run the Split2QUnitaries pass on `dag`."""
+        for node in dag.topological_op_nodes():
+            # skip operations without two-qubits and for which we can not determine a potential 1q split
+            if (
+                len(node.cargs) > 0
+                or len(node.qargs) != 2
+                or node.matrix is None
+                or node.is_parameterized()
+            ):
+                continue
+
+            decomp = TwoQubitWeylDecomposition(node.op, fidelity=self.requested_fidelity)
+            if (
+                decomp._inner_decomposition.specialization
+                == TwoQubitWeylDecomposition._specializations.IdEquiv
+            ):
+                new_dag = DAGCircuit()
+                new_dag.add_qubits(node.qargs)
+
+                ur = decomp.K1r
+                ur_node = DAGOpNode.from_instruction(
+                    CircuitInstruction(UnitaryGate(ur), qubits=(node.qargs[0],)), dag=new_dag
+                )
+
+                ul = decomp.K1l
+                ul_node = DAGOpNode.from_instruction(
+                    CircuitInstruction(UnitaryGate(ul), qubits=(node.qargs[1],)), dag=new_dag
+                )
+                new_dag._apply_op_node_back(ur_node)
+                new_dag._apply_op_node_back(ul_node)
+                new_dag.global_phase = decomp.global_phase
+                dag.substitute_node_with_dag(node, new_dag)
+            elif (
+                decomp._inner_decomposition.specialization
+                == TwoQubitWeylDecomposition._specializations.SWAPEquiv
+            ):
+                # TODO maybe also look into swap-gate-like gates? Things to consider:
+                #   * As the qubit mapping may change, we'll always need to build a new dag in this pass
+                #   * There may not be many swap-gate-like gates in an arbitrary input circuit
+                #   * Removing swap gates from a user-routed input circuit here is unexpected
+                pass
+        return dag

qiskit/transpiler/passes/optimization/template_matching/backward_match.py

@@ -622,7 +622,7 @@ class BackwardMatch:
                     )
                     self.matching_list.append_scenario(new_matching_scenario)
 
-                # Third option: if blocking the succesors breaks a match, we consider
+                # Third option: if blocking the successors breaks a match, we consider
                 # also the possibility to block all predecessors (push the gate to the left).
                 if broken_matches and all(global_broken):
 

qiskit/transpiler/passes/optimization/template_matching/forward_match.py

@@ -138,8 +138,8 @@ class ForwardMatch:
         """
         matches = []
 
-        for i in range(0, len(self.match)):
-            matches.append(self.match[i][0])
+        for match in self.match:
+            matches.append(match[0])
 
         pred = matches.copy()
         if len(pred) > 1:

qiskit/transpiler/passes/optimization/template_matching/template_substitution.py

@@ -507,7 +507,7 @@ class TemplateSubstitution:
             to_native_symbolic = lambda x: x
 
         circuit_params, template_params = [], []
-        # Set of all parameter names that are present in the circuits to be optimised.
+        # Set of all parameter names that are present in the circuits to be optimized.
         circuit_params_set = set()
 
         template_dag_dep = copy.deepcopy(self.template_dag_dep)

qiskit/transpiler/passes/routing/commuting_2q_gate_routing/commuting_2q_gate_router.py

@@ -17,8 +17,9 @@ from collections import defaultdict
 from qiskit.circuit import Gate, QuantumCircuit, Qubit
 from qiskit.converters import circuit_to_dag
 from qiskit.dagcircuit import DAGCircuit, DAGOpNode
-from qiskit.transpiler import TransformationPass, Layout, TranspilerError
-
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.passes.routing.commuting_2q_gate_routing.swap_strategy import SwapStrategy
 from qiskit.transpiler.passes.routing.commuting_2q_gate_routing.commuting_2q_block import (
     Commuting2qBlock,

qiskit/transpiler/passes/routing/commuting_2q_gate_routing/swap_strategy.py

@@ -17,7 +17,7 @@ import copy
 import numpy as np
 
 from qiskit.exceptions import QiskitError
-from qiskit.transpiler import CouplingMap
+from qiskit.transpiler.coupling import CouplingMap
 
 
 class SwapStrategy:

qiskit/transpiler/passes/routing/layout_transformation.py

@@ -15,9 +15,10 @@ from __future__ import annotations
 
 import numpy as np
 
-from qiskit.transpiler import Layout, CouplingMap
 from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.coupling import CouplingMap
 from qiskit.transpiler.exceptions import TranspilerError
+from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.passes.routing.algorithms import ApproximateTokenSwapper
 from qiskit.transpiler.target import Target
 

qiskit/transpiler/passes/routing/sabre_swap.py

@@ -18,7 +18,7 @@ import time
 
 import rustworkx
 
-from qiskit.circuit import SwitchCaseOp, ControlFlowOp, Clbit, ClassicalRegister
+from qiskit.circuit import SwitchCaseOp, Clbit, ClassicalRegister
 from qiskit.circuit.library.standard_gates import SwapGate
 from qiskit.circuit.controlflow import condition_resources, node_resources
 from qiskit.converters import dag_to_circuit
@@ -28,15 +28,10 @@ from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.target import Target
 from qiskit.transpiler.passes.layout import disjoint_utils
-from qiskit.dagcircuit import DAGCircuit
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
 from qiskit.utils.parallel import CPU_COUNT
 
-from qiskit._accelerate.sabre import (
-    sabre_routing,
-    Heuristic,
-    NeighborTable,
-    SabreDAG,
-)
+from qiskit._accelerate.sabre import sabre_routing, Heuristic, SetScaling, NeighborTable, SabreDAG
 from qiskit._accelerate.nlayout import NLayout
 
 logger = logging.getLogger(__name__)
@@ -211,14 +206,27 @@ class SabreSwap(TransformationPass):
                 " This circuit cannot be routed to this device."
             )
 
-        if self.heuristic == "basic":
-            heuristic = Heuristic.Basic
+        if isinstance(self.heuristic, Heuristic):
+            heuristic = self.heuristic
+        elif self.heuristic == "basic":
+            heuristic = Heuristic(attempt_limit=10 * num_dag_qubits).with_basic(
+                1.0, SetScaling.Size
+            )
         elif self.heuristic == "lookahead":
-            heuristic = Heuristic.Lookahead
+            heuristic = (
+                Heuristic(attempt_limit=10 * num_dag_qubits)
+                .with_basic(1.0, SetScaling.Size)
+                .with_lookahead(0.5, 20, SetScaling.Size)
+            )
         elif self.heuristic == "decay":
-            heuristic = Heuristic.Decay
+            heuristic = (
+                Heuristic(attempt_limit=10 * num_dag_qubits)
+                .with_basic(1.0, SetScaling.Size)
+                .with_lookahead(0.5, 20, SetScaling.Size)
+                .with_decay(0.001, 5)
+            )
         else:
-            raise TranspilerError("Heuristic %s not recognized." % self.heuristic)
+            raise TranspilerError(f"Heuristic {self.heuristic} not recognized.")
         disjoint_utils.require_layout_isolated_to_component(
             dag, self.coupling_map if self.target is None else self.target
         )
@@ -289,9 +297,9 @@ def _build_sabre_dag(dag, num_physical_qubits, qubit_indices):
         node_blocks = {}
         for node in block_dag.topological_op_nodes():
             cargs_bits = set(node.cargs)
-            if node.op.condition is not None:
-                cargs_bits.update(condition_resources(node.op.condition).clbits)
-            if isinstance(node.op, SwitchCaseOp):
+            if node.condition is not None:
+                cargs_bits.update(condition_resources(node.condition).clbits)
+            if node.is_control_flow() and isinstance(node.op, SwitchCaseOp):
                 target = node.op.target
                 if isinstance(target, Clbit):
                     cargs_bits.add(target)
@@ -300,7 +308,7 @@ def _build_sabre_dag(dag, num_physical_qubits, qubit_indices):
                 else:  # Expr
                     cargs_bits.update(node_resources(target).clbits)
             cargs = {block_dag.find_bit(x).index for x in cargs_bits}
-            if isinstance(node.op, ControlFlowOp):
+            if node.is_control_flow():
                 node_blocks[node._node_id] = [
                     recurse(
                         block,
@@ -313,7 +321,7 @@ def _build_sabre_dag(dag, num_physical_qubits, qubit_indices):
                     node._node_id,
                     [wire_map[x] for x in node.qargs],
                     cargs,
-                    getattr(node.op, "_directive", False),
+                    node.is_directive(),
                 )
             )
         return SabreDAG(num_physical_qubits, block_dag.num_clbits(), dag_list, node_blocks)
@@ -383,14 +391,15 @@ def _apply_sabre_result(
             node = source_dag._multi_graph[node_id]
             if node_id in swap_map:
                 apply_swaps(dest_dag, swap_map[node_id], layout)
-            if not isinstance(node.op, ControlFlowOp):
-                dest_dag.apply_operation_back(
-                    node.op,
-                    [
-                        physical_qubits[layout.virtual_to_physical(root_logical_map[q])]
-                        for q in node.qargs
-                    ],
-                    node.cargs,
+            if not node.is_control_flow():
+                qubits = [
+                    physical_qubits[layout.virtual_to_physical(root_logical_map[q])]
+                    for q in node.qargs
+                ]
+                dest_dag._apply_op_node_back(
+                    DAGOpNode.from_instruction(
+                        node._to_circuit_instruction().replace(qubits=qubits)
+                    ),
                     check=False,
                 )
                 continue

qiskit/transpiler/passes/routing/star_prerouting.py

@@ -14,11 +14,15 @@
 from typing import Iterable, Union, Optional, List, Tuple
 from math import floor, log10
 
-from qiskit.circuit import Barrier
+from qiskit.circuit import SwitchCaseOp, Clbit, ClassicalRegister, Barrier
+from qiskit.circuit.controlflow import condition_resources, node_resources
 from qiskit.dagcircuit import DAGOpNode, DAGDepNode, DAGDependency, DAGCircuit
-from qiskit.transpiler import Layout
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.circuit.library import SwapGate
+from qiskit.transpiler.layout import Layout
+from qiskit.transpiler.passes.routing.sabre_swap import _build_sabre_dag, _apply_sabre_result
+
+from qiskit._accelerate import star_prerouting
+from qiskit._accelerate.nlayout import NLayout
 
 
 class StarBlock:
@@ -260,7 +264,7 @@ class StarPreRouting(TransformationPass):
         # star block by a linear sequence of gates
         new_dag, qubit_mapping = self.star_preroute(dag, star_blocks, processing_order)
 
-        # Fix output permuation -- copied from ElidePermutations
+        # Fix output permutation -- copied from ElidePermutations
         input_qubit_mapping = {qubit: index for index, qubit in enumerate(dag.qubits)}
         self.property_set["original_layout"] = Layout(input_qubit_mapping)
         if self.property_set["original_qubit_indices"] is None:
@@ -305,113 +309,84 @@ class StarPreRouting(TransformationPass):
             new_dag: a dag specifying the pre-routed circuit
             qubit_mapping: the final qubit mapping after pre-routing
         """
-        node_to_block_id = {}
-        for i, block in enumerate(blocks):
-            for node in block.get_nodes():
-                node_to_block_id[node] = i
-
-        new_dag = dag.copy_empty_like()
-        processed_block_ids = set()
-        qubit_mapping = list(range(len(dag.qubits)))
-
-        def _apply_mapping(qargs, qubit_mapping, qubits):
-            return tuple(qubits[qubit_mapping[dag.find_bit(qubit).index]] for qubit in qargs)
-
-        is_first_star = True
-        last_2q_gate = [
-            op
-            for op in reversed(processing_order)
-            if ((len(op.qargs) > 1) and (op.name != "barrier"))
+        # Convert the DAG to a SabreDAG
+        num_qubits = len(dag.qubits)
+        canonical_register = dag.qregs["q"]
+        current_layout = Layout.generate_trivial_layout(canonical_register)
+        qubit_indices = {bit: idx for idx, bit in enumerate(canonical_register)}
+        layout_mapping = {qubit_indices[k]: v for k, v in current_layout.get_virtual_bits().items()}
+        initial_layout = NLayout(layout_mapping, num_qubits, num_qubits)
+        sabre_dag, circuit_to_dag_dict = _build_sabre_dag(dag, num_qubits, qubit_indices)
+
+        # Extract the nodes from the blocks for the Rust representation
+        rust_blocks = [
+            (block.center is not None, _extract_nodes(block.get_nodes(), dag)) for block in blocks
         ]
-        if len(last_2q_gate) > 0:
-            last_2q_gate = last_2q_gate[0]
-        else:
-            last_2q_gate = None
 
+        # Determine the processing order of the nodes in the DAG for the Rust representation
         int_digits = floor(log10(len(processing_order))) + 1
         processing_order_index_map = {
-            node: f"a{str(index).zfill(int(int_digits))}"
-            for index, node in enumerate(processing_order)
+            node: f"a{index:0{int_digits}}" for index, node in enumerate(processing_order)
         }
 
         def tie_breaker_key(node):
             return processing_order_index_map.get(node, node.sort_key)
 
-        for node in dag.topological_op_nodes(key=tie_breaker_key):
-            block_id = node_to_block_id.get(node, None)
-            if block_id is not None:
-                if block_id in processed_block_ids:
-                    continue
-
-                processed_block_ids.add(block_id)
-
-                # process the whole block
-                block = blocks[block_id]
-                sequence = block.nodes
-                center_node = block.center
-
-                if len(sequence) == 2:
-                    for inner_node in sequence:
-                        new_dag.apply_operation_back(
-                            inner_node.op,
-                            _apply_mapping(inner_node.qargs, qubit_mapping, dag.qubits),
-                            inner_node.cargs,
-                            check=False,
-                        )
-                    continue
-                swap_source = None
-                prev = None
-                for inner_node in sequence:
-                    if (len(inner_node.qargs) == 1) or (inner_node.qargs == prev):
-                        new_dag.apply_operation_back(
-                            inner_node.op,
-                            _apply_mapping(inner_node.qargs, qubit_mapping, dag.qubits),
-                            inner_node.cargs,
-                            check=False,
-                        )
-                        continue
-                    if is_first_star and swap_source is None:
-                        swap_source = center_node
-                        new_dag.apply_operation_back(
-                            inner_node.op,
-                            _apply_mapping(inner_node.qargs, qubit_mapping, dag.qubits),
-                            inner_node.cargs,
-                            check=False,
-                        )
-
-                        prev = inner_node.qargs
-                        continue
-                    # place 2q-gate and subsequent swap gate
-                    new_dag.apply_operation_back(
-                        inner_node.op,
-                        _apply_mapping(inner_node.qargs, qubit_mapping, dag.qubits),
-                        inner_node.cargs,
-                        check=False,
-                    )
-
-                    if not inner_node is last_2q_gate and not isinstance(inner_node.op, Barrier):
-                        new_dag.apply_operation_back(
-                            SwapGate(),
-                            _apply_mapping(inner_node.qargs, qubit_mapping, dag.qubits),
-                            inner_node.cargs,
-                            check=False,
-                        )
-                        # Swap mapping
-                        index_0 = dag.find_bit(inner_node.qargs[0]).index
-                        index_1 = dag.find_bit(inner_node.qargs[1]).index
-                        qubit_mapping[index_1], qubit_mapping[index_0] = (
-                            qubit_mapping[index_0],
-                            qubit_mapping[index_1],
-                        )
-
-                    prev = inner_node.qargs
-                is_first_star = False
-            else:
-                # the node is not part of a block
-                new_dag.apply_operation_back(
-                    node.op,
-                    _apply_mapping(node.qargs, qubit_mapping, dag.qubits),
-                    node.cargs,
-                    check=False,
-                )
-        return new_dag, qubit_mapping
+        rust_processing_order = _extract_nodes(dag.topological_op_nodes(key=tie_breaker_key), dag)
+
+        # Run the star prerouting algorithm to obtain the new DAG and qubit mapping
+        *sabre_result, qubit_mapping = star_prerouting.star_preroute(
+            sabre_dag, rust_blocks, rust_processing_order
+        )
+
+        res_dag = _apply_sabre_result(
+            dag.copy_empty_like(),
+            dag,
+            sabre_result,
+            initial_layout,
+            dag.qubits,
+            circuit_to_dag_dict,
+        )
+
+        return res_dag, qubit_mapping
+
+
+def _extract_nodes(nodes, dag):
+    """Extract and format node information for Rust representation used in SabreDAG.
+
+    Each node is represented as a tuple containing:
+    - Node ID (int): The unique identifier of the node in the DAG.
+    - Qubit indices (list of int): Indices of qubits involved in the node's operation.
+    - Classical bit indices (set of int): Indices of classical bits involved in the node's operation.
+    - Directive flag (bool): Indicates whether the operation is a directive (True) or not (False).
+
+    Args:
+        nodes (list[DAGOpNode]): List of DAGOpNode objects to extract information from.
+        dag (DAGCircuit): DAGCircuit object containing the circuit structure.
+
+    Returns:
+        list of tuples: Each tuple contains information about a node in the format described above.
+    """
+    extracted_node_info = []
+    for node in nodes:
+        qubit_indices = [dag.find_bit(qubit).index for qubit in node.qargs]
+        classical_bit_indices = set()
+
+        if node.op.condition is not None:
+            classical_bit_indices.update(condition_resources(node.op.condition).clbits)
+
+        if isinstance(node.op, SwitchCaseOp):
+            switch_case_target = node.op.target
+            if isinstance(switch_case_target, Clbit):
+                classical_bit_indices.add(switch_case_target)
+            elif isinstance(switch_case_target, ClassicalRegister):
+                classical_bit_indices.update(switch_case_target)
+            else:  # Assume target is an expression involving classical bits
+                classical_bit_indices.update(node_resources(switch_case_target).clbits)
+
+        is_directive = getattr(node.op, "_directive", False)
+        extracted_node_info.append(
+            (node._node_id, qubit_indices, classical_bit_indices, is_directive)
+        )
+
+    return extracted_node_info