qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/discrete_basis/solovay_kitaev.py

@@ -0,0 +1,280 @@
+# 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.
+
+"""Synthesize a single qubit gate to a discrete basis set."""
+
+from __future__ import annotations
+
+import typing
+import warnings
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.library import get_standard_gate_name_mapping, IGate
+from qiskit.utils.deprecation import deprecate_func
+from qiskit._accelerate.synthesis.discrete_basis import (
+    SolovayKitaevSynthesis as RustSolovayKitaevSynthesis,
+    GateSequence,
+)
+
+if typing.TYPE_CHECKING:
+    from qiskit.dagcircuit import DAGCircuit
+
+
+class SolovayKitaevDecomposition:
+    """The Solovay Kitaev discrete decomposition algorithm.
+
+    This class is called recursively by the transpiler pass, which is why it is separated.
+    See :class:`~qiskit.transpiler.passes.SolovayKitaev` for more information.
+    """
+
+    def __init__(
+        self,
+        basic_approximations: str | dict[str, np.ndarray] | list[GateSequence] | None = None,
+        *,
+        basis_gates: list[str | Gate] | None = None,
+        depth: int = 12,
+        check_input: bool = False,
+    ) -> None:
+        """
+        Args:
+            basic_approximations: A specification of the basic SO(3) approximations in terms
+                of discrete gates. At each iteration this algorithm, the remaining error is
+                approximated with the closest sequence of gates in this set.
+                If a ``str``, this specifies a filename from which to load the
+                approximation. If a ``dict``, then this contains
+                ``{gates: effective_SO3_matrix}`` pairs,
+                e.g. ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}``.
+                If a list, this contains the same information as the dict, but already converted to
+                :class:`.GateSequence` objects, which contain the SO(3) matrix and gates.
+
+                Either this parameter, or ``basis_gates`` and ``depth`` can be specified.
+            basis_gates: A list of discrete (i.e., non-parameterized) standard gates.
+                Defaults to ``["h", "t", "tdg"]``.
+            depth: The number of basis gate combinations to consider in the basis set. This
+                determines how fast (and if) the algorithm converges and should be chosen
+                sufficiently high.
+            check_input: If ``True``, perform intermediate steps checking whether the matrices
+                are of expected form.
+        """
+        if basic_approximations is None:
+            if basis_gates is not None:
+                basis_gates = normalize_gates(basis_gates)
+            self._sk = RustSolovayKitaevSynthesis(basis_gates, depth, None, check_input)
+
+        elif basis_gates is not None:
+            raise ValueError(
+                "Either basic_approximations or basis_gates + depth can be specified, not both."
+            )
+
+        else:
+            # Fast Rust path to load the file
+            if isinstance(basic_approximations, str) and basic_approximations[~3:] != ".npy":
+                self._sk = RustSolovayKitaevSynthesis.from_basic_approximations(
+                    basic_approximations, True
+                )
+            else:
+                sequences = self.load_basic_approximations(basic_approximations)
+                self._sk = RustSolovayKitaevSynthesis.from_sequences(sequences, True)
+
+        self._depth = depth
+        self._check_input = check_input
+        self._basis_gates = basis_gates
+
+    @property
+    def depth(self) -> int:
+        """The maximum gate depth of the basic approximations."""
+        return self._depth
+
+    @property
+    def check_input(self) -> bool:
+        """Whether to perform runtime checks on the internal data."""
+        return self._check_input
+
+    @property
+    def basis_gates(self) -> list[str] | None:
+        """The basis gate set of the basic approximations.
+
+        If ``None``, defaults to ``["h", "t", "tdg"]``.
+        """
+        return self._basis_gates
+
+    @staticmethod
+    def load_basic_approximations(data: list | str | dict) -> list[GateSequence]:
+        """Load basic approximations.
+
+        Args:
+            data: If a string, specifies the path to the file from where to load the data.
+                If a dictionary, directly specifies the decompositions as ``{gates: matrix}``
+                or ``{gates: (matrix, global_phase)}``. There, ``gates`` are the names of the gates
+                producing the SO(3) matrix ``matrix``, e.g.
+                ``{"h t": np.array([[0, 0.7071, -0.7071], [0, -0.7071, -0.7071], [-1, 0, 0]]}``
+                and the ``global_phase`` can be given to account for a global phase difference
+                between the U(2) matrix of the quantum gates and the stored SO(3) matrix.
+                If not given, the ``global_phase`` will be assumed to be 0.
+
+        Returns:
+            A list of basic approximations as type ``GateSequence``.
+
+        Raises:
+            ValueError: If the number of gate combinations and associated matrices does not match.
+        """
+        # new data format stored by the Rust internal class
+        if isinstance(data, str) and data[-4:] != ".npy":
+            sk = SolovayKitaevDecomposition(data)
+            return sk._sk.get_gate_sequences()
+
+        warnings.warn(
+            "It is suggested to pass basic_approximations in the binary format produced "
+            "by SolovayKitaevDecomposition.save_basic_approximations, which is more "
+            "performant than other formats. Other formats are pending deprecation "
+            "and will be deprecated in a future release.",
+            category=PendingDeprecationWarning,
+        )
+
+        # is already a list of GateSequences
+        if isinstance(data, list):
+            return data
+
+        # file is ``.npy``, load the dictionary it contains
+        if isinstance(data, str):
+            data = np.load(data, allow_pickle=True).item()
+
+        # parse the dictionary
+        sequences = []
+        for gatestring, matrix_and_phase in data.items():
+            if isinstance(matrix_and_phase, tuple):
+                matrix, global_phase = matrix_and_phase
+            else:
+                matrix, global_phase = matrix_and_phase, 0
+
+            # gates = [_1q_gates[element] for element in gatestring.split()]
+            gates = normalize_gates(gatestring.split())
+            sequence = GateSequence.from_gates_and_matrix(gates, matrix, global_phase)
+            sequences.append(sequence)
+
+        return sequences
+
+    def save_basic_approximations(self, filename: str):
+        """Save the basic approximations into a file.
+
+        This can then be loaded again via the class initializer (preferred) or
+        via :meth:`load_basic_approximations`::
+
+            filename = "approximations.bin"
+            sk.save_basic_approximations(filename)
+
+            new_sk = SolovayKitaevDecomposition(filename)
+
+        Args:
+            filename: The filename to store the approximations in.
+
+        Raises:
+            ValueError: If the filename has a `.npy` extension. The format is not `.npy`,
+                and storing as such can cause errors when loading the file again.
+        """
+        # Safety guard: previously, we serialized via npy, but this format is incompatible
+        # with the current serialization, using Rust's serde + bincode. While we can still load
+        # .npy files in legacy format, the new format should not be stored as .npy.
+        if filename[~3:] == ".npy":
+            raise ValueError(
+                "The basic approximations are not stored in npy format. "
+                "Choose a different file extension (e.g. .bin)."
+            )
+        self._sk.save_basic_approximations(filename)
+
+    def run(
+        self,
+        gate_matrix: np.ndarray | Gate,
+        recursion_degree: int,
+        return_dag: bool = False,
+        check_input: bool = True,
+    ) -> QuantumCircuit | DAGCircuit:
+        r"""Run the algorithm.
+
+        Args:
+            gate_matrix: The single-qubit gate to approximate. Can either be a :class:`.Gate`, where
+                :meth:`.Gate.to_matrix` returns the matrix, or a :math:`2\times 2` unitary matrix
+                representing the gate.
+            recursion_degree: The recursion degree, called :math:`n` in the paper.
+            return_dag: If ``True`` return a :class:`.DAGCircuit`, else a :class:`.QuantumCircuit`.
+            check_input: If ``True`` check that the input matrix is valid for the decomposition.
+                Overrides the class attribute with the same name, but only for this function call.
+
+        Returns:
+            A one-qubit circuit approximating the ``gate_matrix`` in the specified discrete basis.
+        """
+        # handle overriding the check_input setting
+        self_check_input = self.check_input
+        if check_input != self_check_input:
+            self._sk.do_checks = check_input
+
+        if isinstance(gate_matrix, Gate):
+            data = self._sk.synthesize(gate_matrix, recursion_degree)
+        else:
+            data = self._sk.synthesize_matrix(gate_matrix, recursion_degree)
+
+        if check_input != self_check_input:
+            self._sk.do_checks = self_check_input
+
+        circuit = QuantumCircuit._from_circuit_data(data, add_regs=True)
+
+        if return_dag:
+            from qiskit.converters import circuit_to_dag  # pylint: disable=cyclic-import
+
+            return circuit_to_dag(circuit)
+
+        return circuit
+
+    def query_basic_approximation(self, gate: np.ndarray | Gate) -> QuantumCircuit:
+        """Query a basic approximation of a matrix."""
+        if isinstance(gate, Gate):
+            data = self._sk.query_basic_approximation(gate)
+        else:
+            data = self._sk.query_basic_approximation_matrix(gate)
+
+        circuit = QuantumCircuit._from_circuit_data(data, add_regs=True)
+        return circuit
+
+    @deprecate_func(
+        since="2.1",
+        additional_msg="Use query_basic_approximation instead, which takes a Gate or matrix "
+        "as input and returns a QuantumCircuit object.",
+        pending=True,
+    )
+    def find_basic_approximation(self, sequence: GateSequence) -> GateSequence:
+        """Find ``GateSequence`` in ``self._basic_approximations`` that approximates ``sequence``.
+
+        Args:
+            sequence: ``GateSequence`` to find the approximation to.
+
+        Returns:
+            ``GateSequence`` in that approximates ``sequence``.
+        """
+        return self._sk.find_basic_approximation(sequence)
+
+
+def normalize_gates(gates: list[Gate | str]) -> list[Gate]:
+    """Normalize a list[Gate | str] into list[Gate]."""
+    name_to_gate = get_standard_gate_name_mapping()
+    # special case: we used to support "i" as IGate, but the official name is "id", so
+    # we add it manually here
+    name_to_gate["i"] = IGate()
+
+    def normalize(gate: Gate | str) -> Gate:
+        if isinstance(gate, Gate):
+            return gate
+        if gate in name_to_gate:
+            return name_to_gate[gate]
+        raise ValueError(f"Unsupported gate: {gate}")
+
+    return list(map(normalize, gates))

qiskit/synthesis/evolution/__init__.py

@@ -0,0 +1,21 @@
+# 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.
+
+"""Synthesis for operator evolution gates."""
+
+from .evolution_synthesis import EvolutionSynthesis
+from .matrix_synthesis import MatrixExponential
+from .product_formula import ProductFormula
+from .lie_trotter import LieTrotter
+from .suzuki_trotter import SuzukiTrotter
+from .qdrift import QDrift
+from .pauli_network import synth_pauli_network_rustiq

qiskit/synthesis/evolution/evolution_synthesis.py

@@ -0,0 +1,48 @@
+# 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.
+
+"""Evolution synthesis."""
+
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+
+class EvolutionSynthesis(ABC):
+    """Interface for evolution synthesis algorithms."""
+
+    @abstractmethod
+    def synthesize(self, evolution):
+        """Synthesize an ``qiskit.circuit.library.PauliEvolutionGate``.
+
+        Args:
+            evolution (PauliEvolutionGate): The evolution gate to synthesize.
+
+        Returns:
+            QuantumCircuit: A circuit implementing the evolution.
+        """
+        raise NotImplementedError
+
+    @property
+    def settings(self) -> dict[str, Any]:
+        """Return the settings in a dictionary, which can be used to reconstruct the object.
+
+        Returns:
+            A dictionary containing the settings of this product formula.
+
+        Raises:
+            NotImplementedError: The interface does not implement this method.
+        """
+        raise NotImplementedError(
+            "The settings property is not implemented for the base interface."
+        )

qiskit/synthesis/evolution/lie_trotter.py

@@ -0,0 +1,123 @@
+# 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.
+
+"""The Lie-Trotter product formula."""
+
+from __future__ import annotations
+
+from collections.abc import Callable
+from typing import Any
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.quantum_info.operators import SparsePauliOp
+import qiskit.quantum_info
+
+from .suzuki_trotter import SuzukiTrotter
+
+
+class LieTrotter(SuzukiTrotter):
+    r"""The Lie-Trotter product formula.
+
+    The Lie-Trotter formula approximates the exponential of two non-commuting operators
+    with products of their exponentials up to a second order error:
+
+    .. math::
+
+        e^{A + B} \approx e^{A}e^{B}.
+
+    In this implementation, the operators are provided as sum terms of a Pauli operator.
+    For example, we approximate
+
+    .. math::
+
+        e^{-it(XI + ZZ)} = e^{-it XI}e^{-it ZZ} + \mathcal{O}(t^2).
+
+    References:
+
+        [1]: D. Berry, G. Ahokas, R. Cleve and B. Sanders,
+        "Efficient quantum algorithms for simulating sparse Hamiltonians" (2006).
+        `arXiv:quant-ph/0508139 <https://arxiv.org/abs/quant-ph/0508139>`_
+        [2]: N. Hatano and M. Suzuki,
+        "Finding Exponential Product Formulas of Higher Orders" (2005).
+        `arXiv:math-ph/0506007 <https://arxiv.org/pdf/math-ph/0506007.pdf>`_
+    """
+
+    def __init__(
+        self,
+        reps: int = 1,
+        insert_barriers: bool = False,
+        cx_structure: str = "chain",
+        atomic_evolution: (
+            Callable[[QuantumCircuit, qiskit.quantum_info.Pauli | SparsePauliOp, float], None]
+            | None
+        ) = None,
+        wrap: bool = False,
+        preserve_order: bool = True,
+        *,
+        atomic_evolution_sparse_observable: bool = False,
+    ) -> None:
+        r"""
+        Args:
+            reps: The number of time steps.
+            insert_barriers: Whether to insert barriers between the atomic evolutions.
+            cx_structure: How to arrange the CX gates for the Pauli evolutions, can be
+                ``"chain"``, where next neighbor connections are used, or ``"fountain"``,
+                where all qubits are connected to one. This only takes effect when
+                ``atomic_evolution is None``.
+            atomic_evolution: A function to apply the evolution of a single
+                :class:`~.quantum_info.Pauli`, or :class:`.SparsePauliOp` of only commuting terms,
+                to a circuit. The function takes in three arguments: the circuit to append the
+                evolution to, the Pauli operator to evolve, and the evolution time. By default, a
+                single Pauli evolution is decomposed into a chain of ``CX`` gates and a single
+                ``RZ`` gate.
+            wrap: Whether to wrap the atomic evolutions into custom gate objects. This only takes
+                effect when ``atomic_evolution is None``.
+            preserve_order: If ``False``, allows reordering the terms of the operator to
+                potentially yield a shallower evolution circuit. Not relevant
+                when synthesizing operator with a single term.
+            atomic_evolution_sparse_observable: If a custom ``atomic_evolution`` is passed,
+                which does not yet support :class:`.SparseObservable`\ s as input, set this
+                argument to ``False`` to automatically apply a conversion to :class:`.SparsePauliOp`.
+                This argument is supported until Qiskit 2.2, at which point all atomic evolutions
+                are required to support :class:`.SparseObservable`\ s as input.
+        """
+        super().__init__(
+            1,
+            reps,
+            insert_barriers,
+            cx_structure,
+            atomic_evolution,
+            wrap,
+            preserve_order=preserve_order,
+            atomic_evolution_sparse_observable=atomic_evolution_sparse_observable,
+        )
+
+    @property
+    def settings(self) -> dict[str, Any]:
+        """Return the settings in a dictionary, which can be used to reconstruct the object.
+
+        Returns:
+            A dictionary containing the settings of this product formula.
+
+        Raises:
+            NotImplementedError: If a custom atomic evolution is set, which cannot be serialized.
+        """
+        if self._atomic_evolution is not None:
+            raise NotImplementedError(
+                "Cannot serialize a product formula with a custom atomic evolution."
+            )
+
+        return {
+            "reps": self.reps,
+            "insert_barriers": self.insert_barriers,
+            "cx_structure": self._cx_structure,
+            "wrap": self._wrap,
+        }

qiskit/synthesis/evolution/matrix_synthesis.py

@@ -0,0 +1,47 @@
+# 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.
+
+"""Exact synthesis of operator evolution via (exponentially expensive) matrix exponentiation."""
+
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+from .evolution_synthesis import EvolutionSynthesis
+
+
+class MatrixExponential(EvolutionSynthesis):
+    r"""Exact operator evolution via matrix exponentiation and unitary synthesis.
+
+    This class synthesis the exponential of operators by calculating their exponentially-sized
+    matrix representation and using exact matrix exponentiation followed by unitary synthesis
+    to obtain a circuit. This process is not scalable and serves as comparison or benchmark
+    for small systems.
+    """
+
+    def synthesize(self, evolution):
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.library.hamiltonian_gate import HamiltonianGate
+
+        # get operators and time to evolve
+        operators = evolution.operator
+        time = evolution.time
+
+        if not isinstance(operators, list):
+            matrix = operators.to_matrix()
+        else:
+            matrix = sum(op.to_matrix() for op in operators)
+
+        # construct the evolution circuit
+        evolution_circuit = QuantumCircuit(operators[0].num_qubits)
+        gate = HamiltonianGate(matrix, time)
+        evolution_circuit.append(gate, evolution_circuit.qubits)
+
+        return evolution_circuit

qiskit/synthesis/evolution/pauli_network.py

@@ -0,0 +1,80 @@
+# 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.
+
+"""Circuit synthesis for pauli evolution gates."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumCircuit
+
+from qiskit._accelerate.synthesis.evolution import (
+    pauli_network_synthesis as pauli_network_synthesis_inner,
+)
+
+
+def synth_pauli_network_rustiq(
+    num_qubits: int,
+    pauli_network: list,
+    optimize_count: bool = True,
+    preserve_order: bool = True,
+    upto_clifford: bool = False,
+    upto_phase: bool = False,
+    resynth_clifford_method: int = 0,
+) -> QuantumCircuit:
+    """
+    Calls Rustiq's pauli network synthesis algorithm.
+
+    The algorithm is described in [1]. The source code (in Rust) is available at
+    https://github.com/smartiel/rustiq-core.
+
+    Args:
+        num_qubits: the number of qubits over which the pauli network is defined.
+        pauli_network: a list of pauli rotations, represented in sparse format: a list of
+            triples such as `[("XX", [0, 3], theta), ("ZZ", [0, 1], 0.1)]`.
+        optimize_count: if `True` the synthesis algorithm will try to optimize the 2-qubit
+            gate count; and if `False` then the 2-qubit depth.
+        preserve_order: whether the order of paulis should be preserved, up to
+            commutativity. If the order is not preserved, the returned circuit will
+            generally not be equivalent to the given pauli network.
+        upto_clifford: if `True`, the final Clifford operator is not synthesized
+            and the returned circuit will generally not be equivalent to the given
+            pauli network. In addition, the argument `upto_phase` would be ignored.
+        upto_phase: if `True`, the global phase of the returned circuit may differ
+             from the global phase of the given pauli network. The argument is ignored
+             when `upto_clifford` is `True`.
+        resynth_clifford_method: describes the strategy to synthesize the final Clifford
+            operator. If `0` a naive approach is used, which doubles the number of gates
+            but preserves the global phase of the circuit. If `1`, the Clifford is
+            resynthesized using Qiskit's greedy Clifford synthesis algorithm. If `2`, it
+            is resynthesized by Rustiq itself. If `upto_phase` is `False`, the naive
+            approach is used, as neither synthesis method preserves the global phase.
+
+    Returns:
+        A circuit implementation of the pauli network.
+
+    References:
+        1. Timothée Goubault de Brugière and Simon Martiel,
+           *Faster and shorter synthesis of Hamiltonian simulation circuits*,
+           `arXiv:2404.03280 [quant-ph] <https://arxiv.org/abs/2404.03280>`_
+
+    """
+    out = pauli_network_synthesis_inner(
+        num_qubits=num_qubits,
+        pauli_network=pauli_network,
+        optimize_count=optimize_count,
+        preserve_order=preserve_order,
+        upto_clifford=upto_clifford,
+        upto_phase=upto_phase,
+        resynth_clifford_method=resynth_clifford_method,
+    )
+    circuit = QuantumCircuit._from_circuit_data(out, add_regs=True)
+    return circuit