qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.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

@@ -0,0 +1,297 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021.
+#
+# 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.
+
+"""
+=======================================================================================================
+Solovay-Kitaev Synthesis Plugin (in :mod:`qiskit.transpiler.passes.synthesis.solovay_kitaev_synthesis`)
+=======================================================================================================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   SolovayKitaevSynthesis
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.converters import circuit_to_dag
+from qiskit.circuit.gate import Gate
+from qiskit.dagcircuit import DAGCircuit
+from qiskit.synthesis.discrete_basis.solovay_kitaev import SolovayKitaevDecomposition
+from qiskit.synthesis.discrete_basis.generate_basis_approximations import (
+    generate_basic_approximations,
+)
+from qiskit.transpiler.basepasses import TransformationPass
+from qiskit.transpiler.exceptions import TranspilerError
+
+from .plugin import UnitarySynthesisPlugin
+
+
+class SolovayKitaev(TransformationPass):
+    r"""Approximately decompose 1q gates to a discrete basis using the Solovay-Kitaev algorithm.
+
+    The Solovay-Kitaev theorem [1] states that any single qubit gate can be approximated to
+    arbitrary precision by a set of fixed single-qubit gates, if the set generates a dense
+    subset in :math:`SU(2)`. This is an important result, since it means that any single-qubit
+    gate can be expressed in terms of a discrete, universal gate set that we know how to implement
+    fault-tolerantly. Therefore, the Solovay-Kitaev algorithm allows us to take any
+    non-fault tolerant circuit and rephrase it in a fault-tolerant manner.
+
+    This implementation of the Solovay-Kitaev algorithm is based on [2].
+
+    For example, the following circuit
+
+    .. parsed-literal::
+
+             ┌─────────┐
+        q_0: ┤ RX(0.8) ├
+             └─────────┘
+
+    can be decomposed into
+
+    .. parsed-literal::
+
+        global phase: 7π/8
+             ┌───┐┌───┐┌───┐
+        q_0: ┤ H ├┤ T ├┤ H ├
+             └───┘└───┘└───┘
+
+    with an L2-error of approximately 0.01.
+
+    Examples:
+
+        Per default, the basis gate set is ``["t", "tdg", "h"]``:
+
+        .. code-block::
+
+            import numpy as np
+            from qiskit.circuit import QuantumCircuit
+            from qiskit.transpiler.passes.synthesis import SolovayKitaev
+            from qiskit.quantum_info import Operator
+
+            circuit = QuantumCircuit(1)
+            circuit.rx(0.8, 0)
+
+            print("Original circuit:")
+            print(circuit.draw())
+
+            skd = SolovayKitaev(recursion_degree=2)
+
+            discretized = skd(circuit)
+
+            print("Discretized circuit:")
+            print(discretized.draw())
+
+            print("Error:", np.linalg.norm(Operator(circuit).data - Operator(discretized).data))
+
+        .. parsed-literal::
+
+            Original circuit:
+               ┌─────────┐
+            q: ┤ Rx(0.8) ├
+               └─────────┘
+            Discretized circuit:
+            global phase: 7π/8
+               ┌───┐┌───┐┌───┐
+            q: ┤ H ├┤ T ├┤ H ├
+               └───┘└───┘└───┘
+            Error: 2.828408279166474
+
+        For individual basis gate sets, the ``generate_basic_approximations`` function can be used:
+
+        .. code-block::
+
+            from qiskit.synthesis import generate_basic_approximations
+            from qiskit.transpiler.passes import SolovayKitaev
+
+            basis = ["s", "sdg", "t", "tdg", "z", "h"]
+            approx = generate_basic_approximations(basis, depth=3)
+
+            skd = SolovayKitaev(recursion_degree=2, basic_approximations=approx)
+
+    References:
+
+        [1]: Kitaev, A Yu (1997). Quantum computations: algorithms and error correction.
+             Russian Mathematical Surveys. 52 (6): 1191–1249.
+             `Online <https://iopscience.iop.org/article/10.1070/RM1997v052n06ABEH002155>`_.
+
+        [2]: Dawson, Christopher M.; Nielsen, Michael A. (2005) The Solovay-Kitaev Algorithm.
+             `arXiv:quant-ph/0505030 <https://arxiv.org/abs/quant-ph/0505030>`_.
+
+    """
+
+    def __init__(
+        self,
+        recursion_degree: int = 3,
+        basic_approximations: str | dict[str, np.ndarray] | None = None,
+    ) -> None:
+        """
+        Args:
+            recursion_degree: The recursion depth for the Solovay-Kitaev algorithm.
+                A larger recursion depth increases the accuracy and length of the
+                decomposition.
+            basic_approximations: The basic approximations for the finding the best discrete
+                decomposition at the root of the recursion. If a string, it specifies the ``.npy``
+                file to load the approximations from. If a dictionary, it contains
+                ``{label: SO(3)-matrix}`` pairs. If None, a default based on the H, T and Tdg gates
+                up to combinations of depth 10 is generated.
+        """
+        super().__init__()
+        self.recursion_degree = recursion_degree
+        self._sk = SolovayKitaevDecomposition(basic_approximations)
+
+    def run(self, dag: DAGCircuit) -> DAGCircuit:
+        """Run the ``SolovayKitaev`` pass on `dag`.
+
+        Args:
+            dag: The input dag.
+
+        Returns:
+            Output dag with 1q gates synthesized in the discrete target basis.
+
+        Raises:
+            TranspilerError: if a gates does not have to_matrix
+        """
+        for node in dag.op_nodes():
+            if not node.op.num_qubits == 1:
+                continue  # ignore all non-single qubit gates
+
+            # we do not check the input matrix as we know it comes from a Qiskit gate, as this
+            # we know it will generate a valid SU(2) matrix
+            check_input = not isinstance(node.op, Gate)
+
+            if not hasattr(node.op, "to_matrix"):
+                raise TranspilerError(
+                    f"SolovayKitaev does not support gate without to_matrix method: {node.op.name}"
+                )
+
+            matrix = node.op.to_matrix()
+
+            # call solovay kitaev
+            approximation = self._sk.run(
+                matrix, self.recursion_degree, return_dag=True, check_input=check_input
+            )
+
+            # convert to a dag and replace the gate by the approximation
+            dag.substitute_node_with_dag(node, approximation)
+
+        return dag
+
+
+class SolovayKitaevSynthesis(UnitarySynthesisPlugin):
+    """A Solovay-Kitaev Qiskit unitary synthesis plugin.
+
+    This plugin is invoked by :func:`~.compiler.transpile` when the ``unitary_synthesis_method``
+    parameter is set to ``"sk"``.
+
+    This plugin supports customization and additional parameters can be passed to the plugin
+    by passing a dictionary as the ``unitary_synthesis_plugin_config`` parameter of
+    the :func:`~qiskit.compiler.transpile` function.
+
+    Supported parameters in the dictionary:
+
+    basis_approximations (str | dict):
+        The basic approximations for the finding the best discrete decomposition at the root of the
+        recursion. If a string, it specifies the ``.npy`` file to load the approximations from.
+        If a dictionary, it contains ``{label: SO(3)-matrix}`` pairs. If None, a default based on
+        the specified ``basis_gates`` and ``depth`` is generated.
+
+    basis_gates (list):
+        A list of strings specifying the discrete basis gates to decompose to. If None,
+        defaults to ``["h", "t", "tdg"]``.
+
+    depth (int):
+        The gate-depth of the basic approximations. All possible, unique combinations of the
+        basis gates up to length ``depth`` are considered. If None, defaults to 10.
+
+    recursion_degree (int):
+        The number of times the decomposition is recursively improved. If None, defaults to 3.
+    """
+
+    # we cache an instance of the Solovay-Kitaev class to generate the
+    # computationally expensive basis approximation of single qubit gates only once
+    _sk = None
+
+    @property
+    def max_qubits(self):
+        """Maximum number of supported qubits is ``1``."""
+        return 1
+
+    @property
+    def min_qubits(self):
+        """Minimum number of supported qubits is ``1``."""
+        return 1
+
+    @property
+    def supports_natural_direction(self):
+        """The plugin does not support natural direction, it does not assume
+        bidirectional two qubit gates."""
+        return True
+
+    @property
+    def supports_pulse_optimize(self):
+        """The plugin does not support optimization of pulses."""
+        return False
+
+    @property
+    def supports_gate_lengths(self):
+        """The plugin does not support gate lengths."""
+        return False
+
+    @property
+    def supports_gate_errors(self):
+        """The plugin does not support gate errors."""
+        return False
+
+    @property
+    def supported_bases(self):
+        """The plugin does not support bases for synthesis."""
+        return None
+
+    @property
+    def supports_basis_gates(self):
+        """The plugin does not support basis gates. By default it synthesis to the
+        ``["h", "t", "tdg"]`` gate basis."""
+        return True
+
+    @property
+    def supports_coupling_map(self):
+        """The plugin does not support coupling maps."""
+        return False
+
+    def run(self, unitary, **options):
+
+        # Runtime imports to avoid the overhead of these imports for
+        # plugin discovery and only use them if the plugin is run/used
+        config = options.get("config") or {}
+
+        recursion_degree = config.get("recursion_degree", 3)
+
+        # if we didn't yet construct the Solovay-Kitaev instance, which contains
+        # the basic approximations, do it now
+        if SolovayKitaevSynthesis._sk is None:
+            basic_approximations = config.get("basic_approximations", None)
+            basis_gates = options.get("basis_gates", ["h", "t", "tdg"])
+
+            # if the basic approximations are not generated and not given,
+            # try to generate them if the basis set is specified
+            if basic_approximations is None:
+                depth = config.get("depth", 10)
+                basic_approximations = generate_basic_approximations(basis_gates, depth)
+
+            SolovayKitaevSynthesis._sk = SolovayKitaevDecomposition(basic_approximations)
+
+        approximate_circuit = SolovayKitaevSynthesis._sk.run(unitary, recursion_degree)
+        dag_circuit = circuit_to_dag(approximate_circuit)
+        return dag_circuit