qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__cp39-abi3-win32.whl

qiskit/transpiler/passes/synthesis/qubit_tracker.py

@@ -0,0 +1,132 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""A qubit state tracker for synthesizing operations with auxiliary qubits."""
+
+from __future__ import annotations
+from collections.abc import Iterable
+from dataclasses import dataclass
+
+
+@dataclass
+class QubitTracker:
+    """Track qubits (by global index) and their state.
+
+    The states are distinguished into clean (meaning in state :math:`|0\rangle`) or dirty (an
+    unknown state).
+    """
+
+    # This could in future be extended to track different state types, if necessary.
+    # However, using sets of integers here is much faster than e.g. storing a dictionary with
+    # {index: state} entries.
+    qubits: tuple[int]
+    clean: set[int]
+    dirty: set[int]
+
+    def num_clean(self, active_qubits: Iterable[int] | None = None):
+        """Return the number of clean qubits, not considering the active qubits."""
+        # this could be cached if getting the set length becomes a performance bottleneck
+        return len(self.clean.difference(active_qubits or set()))
+
+    def num_dirty(self, active_qubits: Iterable[int] | None = None):
+        """Return the number of dirty qubits, not considering the active qubits."""
+        return len(self.dirty.difference(active_qubits or set()))
+
+    def borrow(self, num_qubits: int, active_qubits: Iterable[int] | None = None) -> list[int]:
+        """Get ``num_qubits`` qubits, excluding ``active_qubits``."""
+        active_qubits = set(active_qubits or [])
+        available_qubits = [qubit for qubit in self.qubits if qubit not in active_qubits]
+
+        if num_qubits > (available := len(available_qubits)):
+            raise RuntimeError(f"Cannot borrow {num_qubits} qubits, only {available} available.")
+
+        # for now, prioritize returning clean qubits
+        available_clean = [qubit for qubit in available_qubits if qubit in self.clean]
+        available_dirty = [qubit for qubit in available_qubits if qubit in self.dirty]
+
+        borrowed = available_clean[:num_qubits]
+        return borrowed + available_dirty[: (num_qubits - len(borrowed))]
+
+    def used(self, qubits: Iterable[int], check: bool = True) -> None:
+        """Set the state of ``qubits`` to used (i.e. False)."""
+        qubits = set(qubits)
+
+        if check:
+            if len(untracked := qubits.difference(self.qubits)) > 0:
+                raise ValueError(f"Setting state of untracked qubits: {untracked}. Tracker: {self}")
+
+        self.clean -= qubits
+        self.dirty |= qubits
+
+    def reset(self, qubits: Iterable[int], check: bool = True) -> None:
+        """Set the state of ``qubits`` to 0 (i.e. True)."""
+        qubits = set(qubits)
+
+        if check:
+            if len(untracked := qubits.difference(self.qubits)) > 0:
+                raise ValueError(f"Setting state of untracked qubits: {untracked}. Tracker: {self}")
+
+        self.clean |= qubits
+        self.dirty -= qubits
+
+    def drop(self, qubits: Iterable[int], check: bool = True) -> None:
+        """Drop qubits from the tracker, meaning that they are no longer available."""
+        qubits = set(qubits)
+
+        if check:
+            if len(untracked := qubits.difference(self.qubits)) > 0:
+                raise ValueError(f"Dropping untracked qubits: {untracked}. Tracker: {self}")
+
+        self.qubits = tuple(qubit for qubit in self.qubits if qubit not in qubits)
+        self.clean -= qubits
+        self.dirty -= qubits
+
+    def copy(
+        self, qubit_map: dict[int, int] | None = None, drop: Iterable[int] | None = None
+    ) -> "QubitTracker":
+        """Copy self.
+
+        Args:
+            qubit_map: If provided, apply the mapping ``{old_qubit: new_qubit}`` to
+                the qubits in the tracker. Only those old qubits in the mapping will be
+                part of the new one.
+            drop: If provided, drop these qubits in the copied tracker. This argument is ignored
+                if ``qubit_map`` is given, since the qubits can then just be dropped in the map.
+        """
+        if qubit_map is None and drop is not None:
+            remaining_qubits = [qubit for qubit in self.qubits if qubit not in drop]
+            qubit_map = dict(zip(remaining_qubits, remaining_qubits))
+
+        if qubit_map is None:
+            clean = self.clean.copy()
+            dirty = self.dirty.copy()
+            qubits = self.qubits  # tuple is immutable, no need to copy
+        else:
+            clean, dirty = set(), set()
+            for old_index, new_index in qubit_map.items():
+                if old_index in self.clean:
+                    clean.add(new_index)
+                elif old_index in self.dirty:
+                    dirty.add(new_index)
+                else:
+                    raise ValueError(f"Unknown old qubit index: {old_index}. Tracker: {self}")
+
+            qubits = tuple(qubit_map.values())
+
+        return QubitTracker(qubits, clean=clean, dirty=dirty)
+
+    def __str__(self) -> str:
+        return (
+            f"QubitTracker({len(self.qubits)}, clean: {self.num_clean()}, dirty: {self.num_dirty()})"
+            + f"\n\tclean: {self.clean}"
+            + f"\n\tdirty: {self.dirty}"
+        )

qiskit/transpiler/passes/synthesis/solovay_kitaev_synthesis.py

@@ -52,7 +52,7 @@ class SolovayKitaev(TransformationPass):
 
     For example, the following circuit
 
-    .. code-block:: text
+    .. parsed-literal::
 
              ┌─────────┐
         q_0: ┤ RX(0.8) ├
@@ -60,7 +60,7 @@ class SolovayKitaev(TransformationPass):
 
     can be decomposed into
 
-    .. code-block:: text
+    .. parsed-literal::
 
         global phase: 7π/8
              ┌───┐┌───┐┌───┐
@@ -95,7 +95,7 @@ class SolovayKitaev(TransformationPass):
 
             print("Error:", np.linalg.norm(Operator(circuit).data - Operator(discretized).data))
 
-        .. code-block:: text
+        .. parsed-literal::
 
             Original circuit:
                ┌─────────┐

qiskit/transpiler/passes/synthesis/unitary_synthesis.py

@@ -73,7 +73,6 @@ from qiskit.transpiler.passes.optimization.optimize_1q_decomposition import (
 from qiskit.transpiler.passes.synthesis import plugin
 from qiskit.transpiler.target import Target
 
-from qiskit._accelerate.unitary_synthesis import run_default_main_loop
 
 GATE_NAME_MAP = {
     "cx": CXGate._standard_gate,
@@ -457,6 +456,37 @@ class UnitarySynthesis(TransformationPass):
             default_kwargs = {}
             method_list = [(plugin_method, plugin_kwargs), (default_method, default_kwargs)]
 
+        for method, kwargs in method_list:
+            if method.supports_basis_gates:
+                kwargs["basis_gates"] = self._basis_gates
+            if method.supports_natural_direction:
+                kwargs["natural_direction"] = self._natural_direction
+            if method.supports_pulse_optimize:
+                kwargs["pulse_optimize"] = self._pulse_optimize
+            if method.supports_gate_lengths:
+                _gate_lengths = _gate_lengths or _build_gate_lengths(
+                    self._backend_props, self._target
+                )
+                kwargs["gate_lengths"] = _gate_lengths
+            if method.supports_gate_errors:
+                _gate_errors = _gate_errors or _build_gate_errors(self._backend_props, self._target)
+                kwargs["gate_errors"] = _gate_errors
+            if method.supports_gate_lengths_by_qubit:
+                _gate_lengths_by_qubit = _gate_lengths_by_qubit or _build_gate_lengths_by_qubit(
+                    self._backend_props, self._target
+                )
+                kwargs["gate_lengths_by_qubit"] = _gate_lengths_by_qubit
+            if method.supports_gate_errors_by_qubit:
+                _gate_errors_by_qubit = _gate_errors_by_qubit or _build_gate_errors_by_qubit(
+                    self._backend_props, self._target
+                )
+                kwargs["gate_errors_by_qubit"] = _gate_errors_by_qubit
+            supported_bases = method.supported_bases
+            if supported_bases is not None:
+                kwargs["matched_basis"] = _choose_bases(self._basis_gates, supported_bases)
+            if method.supports_target:
+                kwargs["target"] = self._target
+
         # Handle approximation degree as a special case for backwards compatibility, it's
         # not part of the plugin interface and only something needed for the default
         # pass.
@@ -471,60 +501,9 @@ class UnitarySynthesis(TransformationPass):
             if plugin_method.supports_coupling_map or default_method.supports_coupling_map
             else {}
         )
-
-        if self.method == "default" and self._target is not None:
-            _coupling_edges = (
-                set(self._coupling_map.get_edges()) if self._coupling_map is not None else set()
-            )
-
-            out = run_default_main_loop(
-                dag,
-                list(qubit_indices.values()),
-                self._min_qubits,
-                self._target,
-                _coupling_edges,
-                self._approximation_degree,
-                self._natural_direction,
-            )
-            return out
-        else:
-            for method, kwargs in method_list:
-                if method.supports_basis_gates:
-                    kwargs["basis_gates"] = self._basis_gates
-                if method.supports_natural_direction:
-                    kwargs["natural_direction"] = self._natural_direction
-                if method.supports_pulse_optimize:
-                    kwargs["pulse_optimize"] = self._pulse_optimize
-                if method.supports_gate_lengths:
-                    _gate_lengths = _gate_lengths or _build_gate_lengths(
-                        self._backend_props, self._target
-                    )
-                    kwargs["gate_lengths"] = _gate_lengths
-                if method.supports_gate_errors:
-                    _gate_errors = _gate_errors or _build_gate_errors(
-                        self._backend_props, self._target
-                    )
-                    kwargs["gate_errors"] = _gate_errors
-                if method.supports_gate_lengths_by_qubit:
-                    _gate_lengths_by_qubit = _gate_lengths_by_qubit or _build_gate_lengths_by_qubit(
-                        self._backend_props, self._target
-                    )
-                    kwargs["gate_lengths_by_qubit"] = _gate_lengths_by_qubit
-                if method.supports_gate_errors_by_qubit:
-                    _gate_errors_by_qubit = _gate_errors_by_qubit or _build_gate_errors_by_qubit(
-                        self._backend_props, self._target
-                    )
-                    kwargs["gate_errors_by_qubit"] = _gate_errors_by_qubit
-                supported_bases = method.supported_bases
-                if supported_bases is not None:
-                    kwargs["matched_basis"] = _choose_bases(self._basis_gates, supported_bases)
-                if method.supports_target:
-                    kwargs["target"] = self._target
-
-            out = self._run_main_loop(
-                dag, qubit_indices, plugin_method, plugin_kwargs, default_method, default_kwargs
-            )
-            return out
+        return self._run_main_loop(
+            dag, qubit_indices, plugin_method, plugin_kwargs, default_method, default_kwargs
+        )
 
     def _run_main_loop(
         self, dag, qubit_indices, plugin_method, plugin_kwargs, default_method, default_kwargs

qiskit/transpiler/passes/utils/barrier_before_final_measurements.py

@@ -13,8 +13,9 @@
 
 """Add a barrier before final measurements."""
 
-from qiskit._accelerate.barrier_before_final_measurement import barrier_before_final_measurements
+from qiskit.circuit.barrier import Barrier
 from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.dagcircuit import DAGCircuit, DAGOpNode
 from .merge_adjacent_barriers import MergeAdjacentBarriers
 
 
@@ -32,7 +33,60 @@ class BarrierBeforeFinalMeasurements(TransformationPass):
 
     def run(self, dag):
         """Run the BarrierBeforeFinalMeasurements pass on `dag`."""
-        barrier_before_final_measurements(dag, self.label)
+        # Collect DAG nodes which are followed only by barriers or other measures.
+        final_op_types = ["measure", "barrier"]
+        final_ops = []
+        for candidate_node in dag.named_nodes(*final_op_types):
+            is_final_op = True
+
+            for _, child_successors in dag.bfs_successors(candidate_node):
+
+                if any(
+                    isinstance(suc, DAGOpNode) and suc.name not in final_op_types
+                    for suc in child_successors
+                ):
+                    is_final_op = False
+                    break
+
+            if is_final_op:
+                final_ops.append(candidate_node)
+
+        if not final_ops:
+            return dag
+
+        # Create a layer with the barrier and add both bits and registers from the original dag.
+        barrier_layer = DAGCircuit()
+        barrier_layer.add_qubits(dag.qubits)
+        for qreg in dag.qregs.values():
+            barrier_layer.add_qreg(qreg)
+        barrier_layer.add_clbits(dag.clbits)
+        for creg in dag.cregs.values():
+            barrier_layer.add_creg(creg)
+
+        # Add a barrier across all qubits so swap mapper doesn't add a swap
+        # from an unmeasured qubit after a measure.
+        final_qubits = dag.qubits
+
+        barrier_layer.apply_operation_back(
+            Barrier(len(final_qubits), label=self.label), final_qubits, (), check=False
+        )
+
+        # Preserve order of final ops collected earlier from the original DAG.
+        ordered_final_nodes = [
+            node for node in dag.topological_op_nodes() if node in set(final_ops)
+        ]
+
+        # Move final ops to the new layer and append the new layer to the DAG.
+        for final_node in ordered_final_nodes:
+            barrier_layer.apply_operation_back(
+                final_node.op, final_node.qargs, final_node.cargs, check=False
+            )
+
+        for final_op in final_ops:
+            dag.remove_op_node(final_op)
+
+        dag.compose(barrier_layer)
+
         if self.label is None:
             # Merge the new barrier into any other barriers
             adjacent_pass = MergeAdjacentBarriers()

qiskit/transpiler/passes/utils/convert_conditions_to_if_ops.py

@@ -22,7 +22,6 @@ from qiskit.circuit import (
 )
 from qiskit.dagcircuit import DAGCircuit
 from qiskit.transpiler.basepasses import TransformationPass
-from qiskit.utils import deprecate_func
 
 
 class ConvertConditionsToIfOps(TransformationPass):
@@ -32,10 +31,6 @@ class ConvertConditionsToIfOps(TransformationPass):
     This is a simple pass aimed at easing the conversion from the old style of using
     :meth:`.InstructionSet.c_if` into the new style of using more complex conditional logic."""
 
-    @deprecate_func(since="1.3.0", removal_timeline="in Qiskit 2.0.0")
-    def __init__(self):
-        super().__init__()
-
     def _run_inner(self, dag):
         """Run the pass on one :class:`.DAGCircuit`, mutating it.  Returns ``True`` if the circuit
         was modified and ``False`` if not."""