qiskit 2.0.3__cp39-abi3-macosx_11_0_arm64.whl → 2.1.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/transpiler/passes/layout/vf2_layout.py

@@ -23,6 +23,7 @@ from qiskit.transpiler.layout import Layout
 from qiskit.transpiler.basepasses import AnalysisPass
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.passes.layout import vf2_utils
+from qiskit._accelerate.vf2_layout import vf2_layout_pass, MultiQEncountered
 
 
 logger = logging.getLogger(__name__)
@@ -110,13 +111,7 @@ class VF2Layout(AnalysisPass):
         """
         super().__init__()
         self.target = target
-        if (
-            target is not None
-            and (target_coupling_map := self.target.build_coupling_map()) is not None
-        ):
-            self.coupling_map = target_coupling_map
-        else:
-            self.coupling_map = coupling_map
+        self.coupling_map = coupling_map
         self.strict_direction = strict_direction
         self.seed = seed
         self.call_limit = call_limit
@@ -126,11 +121,52 @@ class VF2Layout(AnalysisPass):
 
     def run(self, dag):
         """run the layout method"""
-        if self.coupling_map is None:
+        if self.target is None and self.coupling_map is None:
             raise TranspilerError("coupling_map or target must be specified.")
+        if self.coupling_map is None:
+            target, coupling_map = self.target, self.target.build_coupling_map()
+        elif self.target is None:
+            coupling_map = self.coupling_map
+            target = vf2_utils.build_dummy_target(coupling_map)
+        else:
+            # We have both, but may need to override the target if it has no connectivity.
+            coupling_map = self.target.build_coupling_map()
+            if coupling_map is None:
+                target = vf2_utils.build_dummy_target(self.coupling_map)
+                coupling_map = self.coupling_map
+            else:
+                target = self.target
         self.avg_error_map = self.property_set["vf2_avg_error_map"]
+        # Run rust fast path if we have no randomization
+        if self.seed == -1:
+            try:
+                layout = vf2_layout_pass(
+                    dag,
+                    target,
+                    self.strict_direction,
+                    self.call_limit,
+                    self.time_limit,
+                    self.max_trials,
+                    self.avg_error_map,
+                )
+            except MultiQEncountered:
+                self.property_set["VF2Layout_stop_reason"] = VF2LayoutStopReason.MORE_THAN_2Q
+                return
+            if layout is None:
+                self.property_set["VF2Layout_stop_reason"] = VF2LayoutStopReason.NO_SOLUTION_FOUND
+                return
+
+            self.property_set["VF2Layout_stop_reason"] = VF2LayoutStopReason.SOLUTION_FOUND
+            mapping = {dag.qubits[virt]: phys for virt, phys in layout.items()}
+            chosen_layout = Layout(mapping)
+            self.property_set["layout"] = chosen_layout
+            for reg in dag.qregs.values():
+                self.property_set["layout"].add_register(reg)
+            return
+        # We can't use the rust fast path because we have a seed set, or no target so continue with
+        # the python path
         if self.avg_error_map is None:
-            self.avg_error_map = vf2_utils.build_average_error_map(self.target, self.coupling_map)
+            self.avg_error_map = vf2_utils.build_average_error_map(target, coupling_map)
 
         result = vf2_utils.build_interaction_graph(dag, self.strict_direction)
         if result is None:
@@ -140,12 +176,12 @@ class VF2Layout(AnalysisPass):
         scoring_edge_list = vf2_utils.build_edge_list(im_graph)
         scoring_bit_list = vf2_utils.build_bit_list(im_graph, im_graph_node_map)
         cm_graph, cm_nodes = vf2_utils.shuffle_coupling_graph(
-            self.coupling_map, self.seed, self.strict_direction
+            coupling_map, self.seed, self.strict_direction
         )
         # Filter qubits without any supported operations. If they don't support any operations
         # They're not valid for layout selection
-        if self.target is not None and self.target.qargs is not None:
-            has_operations = set(itertools.chain.from_iterable(self.target.qargs))
+        if target is not None and target.qargs is not None:
+            has_operations = set(itertools.chain.from_iterable(target.qargs))
             to_remove = set(range(len(cm_nodes))).difference(has_operations)
             if to_remove:
                 cm_graph.remove_nodes_from([cm_nodes[i] for i in to_remove])
@@ -156,7 +192,7 @@ class VF2Layout(AnalysisPass):
         # mapping in the search space if no other limits are set
         if self.max_trials is None and self.call_limit is None and self.time_limit is None:
             im_graph_edge_count = len(im_graph.edge_list())
-            cm_graph_edge_count = len(self.coupling_map.graph.edge_list())
+            cm_graph_edge_count = len(coupling_map.graph.edge_list())
             self.max_trials = max(im_graph_edge_count, cm_graph_edge_count) + 15
 
         logger.debug("Running VF2 to find mappings")

qiskit/transpiler/passes/layout/vf2_utils.py

@@ -20,6 +20,7 @@ from rustworkx import PyDiGraph, PyGraph, connected_components
 
 from qiskit.circuit import ForLoopOp
 from qiskit.converters import circuit_to_dag
+from qiskit.transpiler.target import Target
 from qiskit._accelerate import vf2_layout
 from qiskit._accelerate.nlayout import NLayout
 from qiskit._accelerate.error_map import ErrorMap
@@ -141,6 +142,15 @@ def score_layout(
     )
 
 
+def build_dummy_target(coupling_map) -> Target:
+    """Build a dummy target with no error rates that represents the coupling in ``coupling_map``."""
+    # The choice of basis gates is completely arbitrary, and we have no source of error rates.
+    # We just want _something_ to represent the coupling constraints.
+    return Target.from_configuration(
+        basis_gates=["u", "cx"], num_qubits=coupling_map.size(), coupling_map=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

qiskit/transpiler/passes/optimization/__init__.py

@@ -39,4 +39,4 @@ 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
+from .optimize_clifford_t import OptimizeCliffordT

qiskit/transpiler/passes/optimization/optimize_1q_decomposition.py

@@ -19,6 +19,7 @@ from qiskit.transpiler.basepasses import TransformationPass
 from qiskit.transpiler.passes.utils import control_flow
 from qiskit.synthesis.one_qubit import one_qubit_decompose
 from qiskit._accelerate import euler_one_qubit_decomposer
+from qiskit._accelerate import optimize_1q_gates_decomposition
 from qiskit.circuit.library.standard_gates import (
     UGate,
     PhaseGate,
@@ -207,7 +208,7 @@ class Optimize1qGatesDecomposition(TransformationPass):
         Returns:
             DAGCircuit: the optimized DAG.
         """
-        euler_one_qubit_decomposer.optimize_1q_gates_decomposition(
+        optimize_1q_gates_decomposition.optimize_1q_gates_decomposition(
             dag,
             target=self._target,
             global_decomposers=self._global_decomposers,

qiskit/transpiler/passes/optimization/optimize_clifford_t.py

@@ -0,0 +1,68 @@
+# 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.
+
+"""Combine consecutive T/Tdg gates in a Clifford+T circuit."""
+
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.circuit.library import SGate, SdgGate
+
+
+class OptimizeCliffordT(TransformationPass):
+    """An optimization pass for Clifford+T circuits.
+
+    Currently all the pass does is merging pairs of consecutive T-gates into
+    S-gates, and pair of consecutive Tdg-gates into Sdg-gates.
+    """
+
+    def run(self, dag: DAGCircuit):
+        """
+        Run the OptimizeCliffordT pass on `dag`.
+
+        Args:
+            dag: The directed acyclic graph to run on.
+
+        Returns:
+            DAGCircuit: Transformed DAG.
+        """
+
+        new_dag = dag.copy_empty_like()
+
+        nodes = list(dag.topological_op_nodes())
+        num_nodes = len(nodes)
+        idx = 0
+
+        while idx < num_nodes - 1:
+            cur_node = nodes[idx]
+            next_node = nodes[idx + 1]
+            if cur_node.name == "t" and next_node.name == "t" and cur_node.qargs == next_node.qargs:
+                # Combine two consecutive T-gates into an S-gate
+                new_dag.apply_operation_back(SGate(), cur_node.qargs, cur_node.cargs)
+                idx += 2
+            elif (
+                nodes[idx].name == "tdg"
+                and nodes[idx + 1].name == "tdg"
+                and nodes[idx].qargs == nodes[idx + 1].qargs
+            ):
+                # Combine two consecutive Tdg-gates into an Sdg-gate
+                new_dag.apply_operation_back(SdgGate(), cur_node.qargs, cur_node.cargs)
+                idx += 2
+            else:
+                new_dag.apply_operation_back(cur_node.op, cur_node.qargs, cur_node.cargs)
+                idx += 1
+
+        # Handle the last element (if any)
+        if idx == num_nodes - 1:
+            cur_node = nodes[idx]
+            new_dag.apply_operation_back(cur_node.op, cur_node.qargs, cur_node.cargs)
+
+        return new_dag

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

@@ -497,14 +497,8 @@ class TemplateSubstitution:
         """
         import sympy as sym
 
-        if _optionals.HAS_SYMENGINE:
-            import symengine
-
-            # Converts Sympy expressions to Symengine ones.
-            to_native_symbolic = symengine.sympify
-        else:
-            # Our native form is sympy, so we don't need to do anything.
-            to_native_symbolic = lambda x: x
+        # Our native form is sympy, so we don't need to do anything.
+        to_native_symbolic = lambda x: x
 
         circuit_params, template_params = [], []
         # Set of all parameter names that are present in the circuits to be optimized.
@@ -596,7 +590,7 @@ class TemplateSubstitution:
             return None
         # If there's multiple solutions, arbitrarily pick the first one.
         sol = {
-            param.name: ParameterExpression(circ_dict, to_native_symbolic(expr))
+            param.name: ParameterExpression(circ_dict, str(to_native_symbolic(expr)))
             for param, expr in sym_sol[0].items()
         }
         fake_bind = {key: sol[key.name] for key in temp_symbols}

qiskit/transpiler/passes/routing/sabre_swap.py

@@ -210,6 +210,8 @@ class SabreSwap(TransformationPass):
                 " This circuit cannot be routed to this device."
             )
 
+        # In our defaults, the basic heuristic shouldn't scale by size; if it does, it's liable to
+        # get the algorithm stuck.  See https://github.com/Qiskit/qiskit/pull/14458 for more.
         if isinstance(self.heuristic, Heuristic):
             heuristic = self.heuristic
         elif self.heuristic == "basic":
@@ -219,13 +221,13 @@ class SabreSwap(TransformationPass):
         elif self.heuristic == "lookahead":
             heuristic = (
                 Heuristic(attempt_limit=10 * num_dag_qubits)
-                .with_basic(1.0, SetScaling.Size)
+                .with_basic(1.0, SetScaling.Constant)
                 .with_lookahead(0.5, 20, SetScaling.Size)
             )
         elif self.heuristic == "decay":
             heuristic = (
                 Heuristic(attempt_limit=10 * num_dag_qubits)
-                .with_basic(1.0, SetScaling.Size)
+                .with_basic(1.0, SetScaling.Constant)
                 .with_lookahead(0.5, 20, SetScaling.Size)
                 .with_decay(0.001, 5)
             )

qiskit/transpiler/passes/routing/star_prerouting.py

@@ -15,22 +15,18 @@ import itertools
 from typing import Iterable, Union, Optional, List, Tuple
 from math import floor, log10
 
-from qiskit.circuit import SwitchCaseOp, Clbit, ClassicalRegister, Barrier
-from qiskit.circuit.controlflow import condition_resources, node_resources
+from qiskit.circuit import Barrier
+from qiskit.circuit.library import SwapGate
 from qiskit.dagcircuit import (
     DAGOpNode,
+    DAGOutNode,
+    DAGInNode,
     DAGDepNode,
     DAGDependency,
     DAGCircuit,
-    DAGOutNode,
-    DAGInNode,
 )
 from qiskit.transpiler.basepasses import TransformationPass
 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:
@@ -232,7 +228,7 @@ class StarPreRouting(TransformationPass):
             return (
                 len(node.qargs) <= 2
                 and len(node.cargs) == 0
-                and getattr(node, "condition", None) is None
+                and getattr(node.op, "condition", None) is None
                 and not isinstance(node.op, Barrier)
             )
 
@@ -318,24 +314,33 @@ class StarPreRouting(TransformationPass):
             new_dag: a dag specifying the pre-routed circuit
             qubit_mapping: the final qubit mapping after pre-routing
         """
-        # 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
+        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"))
         ]
+        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{index:0{int_digits}}" for index, node in enumerate(processing_order)
+            node: f"a{str(index).zfill(int(int_digits))}"
+            for index, node in enumerate(processing_order)
         }
 
         def tie_breaker_key(node):
@@ -348,61 +353,81 @@ class StarPreRouting(TransformationPass):
                 f"{dag.find_bit(q).index:04d}" for q in itertools.chain(node.qargs, node.cargs)
             )
 
-        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 getattr(node, "condition", None) 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
+        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

qiskit/transpiler/passes/scheduling/__init__.py

@@ -14,7 +14,7 @@
 
 from .scheduling import ALAPScheduleAnalysis, ASAPScheduleAnalysis, SetIOLatency
 from .time_unit_conversion import TimeUnitConversion
-from .padding import PadDelay, PadDynamicalDecoupling
+from .padding import PadDelay, PadDynamicalDecoupling, ContextAwareDynamicalDecoupling
 from .alignments import InstructionDurationCheck, ConstrainedReschedule
 
 # For backward compatibility

qiskit/transpiler/passes/scheduling/alignments/check_durations.py

@@ -59,7 +59,7 @@ class InstructionDurationCheck(AnalysisPass):
         self.property_set["reschedule_required"] = False
 
         # Rescheduling is not necessary
-        if (self.acquire_align == 1 and self.pulse_align == 1) or dag._num_stretches != 0:
+        if (self.acquire_align == 1 and self.pulse_align == 1) or dag.num_stretches != 0:
             return
 
         # Check delay durations

qiskit/transpiler/passes/scheduling/padding/__init__.py

@@ -12,5 +12,6 @@
 
 """Scheduling pass to fill idle times with gate sequence."""
 
+from .context_aware_dynamical_decoupling import ContextAwareDynamicalDecoupling
 from .dynamical_decoupling import PadDynamicalDecoupling
 from .pad_delay import PadDelay