qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/synthesis/discrete_basis/solovay_kitaev.py

@@ -0,0 +1,217 @@
+# 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 numpy as np
+
+from .gate_sequence import GateSequence
+from .commutator_decompose import commutator_decompose
+from .generate_basis_approximations import generate_basic_approximations, _1q_gates, _1q_inverses
+
+
+class SolovayKitaevDecomposition:
+    """The Solovay Kitaev discrete decomposition algorithm.
+
+    This class is called recursively by the transpiler pass, which is why it is separeted.
+    See :class:`qiskit.transpiler.passes.SolovayKitaev` for more information.
+    """
+
+    def __init__(
+        self, basic_approximations: str | dict[str, np.ndarray] | list[GateSequence] | None = None
+    ) -> None:
+        """
+        Args:
+            basic_approximations: A specification of the basic SU(2) 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 ``.npy`` 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.
+        """
+        if basic_approximations is None:
+            # generate a default basic approximation
+            basic_approximations = generate_basic_approximations(
+                basis_gates=["h", "t", "tdg"], depth=10
+            )
+
+        self.basic_approximations = self.load_basic_approximations(basic_approximations)
+
+    @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.
+        """
+        # is already a list of GateSequences
+        if isinstance(data, list):
+            return data
+
+        # if a file, load the dictionary
+        if isinstance(data, str):
+            data = np.load(data, allow_pickle=True).item()
+
+        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
+
+            sequence = GateSequence()
+            sequence.gates = [_1q_gates[element] for element in gatestring.split()]
+            sequence.labels = [gate.name for gate in sequence.gates]
+            sequence.product = np.asarray(matrix)
+            sequence.global_phase = global_phase
+            sequences.append(sequence)
+
+        return sequences
+
+    def run(
+        self,
+        gate_matrix: np.ndarray,
+        recursion_degree: int,
+        return_dag: bool = False,
+        check_input: bool = True,
+    ) -> "QuantumCircuit" | "DAGCircuit":
+        r"""Run the algorithm.
+
+        Args:
+            gate_matrix: The 2x2 matrix representing the gate. This matrix has to be SU(2)
+                up to global phase.
+            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.
+
+        Returns:
+            A one-qubit circuit approximating the ``gate_matrix`` in the specified discrete basis.
+        """
+        # make input matrix SU(2) and get the according global phase
+        z = 1 / np.sqrt(np.linalg.det(gate_matrix))
+        gate_matrix_su2 = GateSequence.from_matrix(z * gate_matrix)
+        global_phase = np.arctan2(np.imag(z), np.real(z))
+
+        # get the decomposition as GateSequence type
+        decomposition = self._recurse(gate_matrix_su2, recursion_degree, check_input=check_input)
+
+        # simplify
+        _remove_identities(decomposition)
+        _remove_inverse_follows_gate(decomposition)
+
+        # convert to a circuit and attach the right phases
+        if return_dag:
+            out = decomposition.to_dag()
+        else:
+            out = decomposition.to_circuit()
+
+        out.global_phase = decomposition.global_phase - global_phase
+
+        return out
+
+    def _recurse(self, sequence: GateSequence, n: int, check_input: bool = True) -> GateSequence:
+        """Performs ``n`` iterations of the Solovay-Kitaev algorithm on ``sequence``.
+
+        Args:
+            sequence: ``GateSequence`` to which the Solovay-Kitaev algorithm is applied.
+            n: The number of iterations that the algorithm needs to run.
+            check_input: If ``True`` check that the input matrix represented by ``GateSequence``
+                is valid for the decomposition.
+
+        Returns:
+            GateSequence that approximates ``sequence``.
+
+        Raises:
+            ValueError: If the matrix in ``GateSequence`` does not represent an SO(3)-matrix.
+        """
+        if sequence.product.shape != (3, 3):
+            raise ValueError("Shape of U must be (3, 3) but is", sequence.shape)
+
+        if n == 0:
+            return self.find_basic_approximation(sequence)
+
+        u_n1 = self._recurse(sequence, n - 1, check_input=check_input)
+
+        v_n, w_n = commutator_decompose(
+            sequence.dot(u_n1.adjoint()).product, check_input=check_input
+        )
+
+        v_n1 = self._recurse(v_n, n - 1, check_input=check_input)
+        w_n1 = self._recurse(w_n, n - 1, check_input=check_input)
+        return v_n1.dot(w_n1).dot(v_n1.adjoint()).dot(w_n1.adjoint()).dot(u_n1)
+
+    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 ``self._basic_approximations`` that approximates ``sequence``.
+        """
+        # TODO explore using a k-d tree here
+
+        def key(x):
+            return np.linalg.norm(np.subtract(x.product, sequence.product))
+
+        best = min(self.basic_approximations, key=key)
+        return best
+
+
+def _remove_inverse_follows_gate(sequence):
+    index = 0
+    while index < len(sequence.gates) - 1:
+        curr_gate = sequence.gates[index]
+        next_gate = sequence.gates[index + 1]
+        if curr_gate.name in _1q_inverses:
+            remove = _1q_inverses[curr_gate.name] == next_gate.name
+        else:
+            remove = curr_gate.inverse() == next_gate
+
+        if remove:
+            # remove gates at index and index + 1
+            sequence.remove_cancelling_pair([index, index + 1])
+            # take a step back to see if we have uncovered a new pair, e.g.
+            # [h, s, sdg, h] at index = 1 removes s, sdg but if we continue at index 1
+            # we miss the uncovered [h, h] pair at indices 0 and 1
+            if index > 0:
+                index -= 1
+        else:
+            # next index
+            index += 1
+
+
+def _remove_identities(sequence):
+    index = 0
+    while index < len(sequence.gates):
+        if sequence.gates[index].name == "id":
+            sequence.gates.pop(index)
+        else:
+            index += 1

qiskit/synthesis/evolution/__init__.py

@@ -0,0 +1,20 @@
+# 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

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,143 @@
+# 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
+
+import inspect
+from collections.abc import Callable
+from typing import Any
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.quantum_info.operators import SparsePauliOp, Pauli
+from qiskit.utils.deprecation import deprecate_arg
+
+from .product_formula import ProductFormula
+
+
+class LieTrotter(ProductFormula):
+    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(XX + ZZ)} = e^{-it XX}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>`_
+    """
+
+    @deprecate_arg(
+        name="atomic_evolution",
+        since="1.2",
+        predicate=lambda callable: callable is not None
+        and len(inspect.signature(callable).parameters) == 2,
+        deprecation_description=(
+            "The 'Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]' signature of the "
+            "'atomic_evolution' argument"
+        ),
+        additional_msg=(
+            "Instead you should update your 'atomic_evolution' function to be of the following "
+            "type: 'Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]'."
+        ),
+        pending=True,
+    )
+    def __init__(
+        self,
+        reps: int = 1,
+        insert_barriers: bool = False,
+        cx_structure: str = "chain",
+        atomic_evolution: (
+            Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]
+            | Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]
+            | None
+        ) = None,
+        wrap: bool = False,
+    ) -> None:
+        """
+        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:`.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.
+                Alternatively, the function can also take Pauli operator and evolution time as
+                inputs and returns the circuit that will be appended to the overall circuit being
+                built.
+            wrap: Whether to wrap the atomic evolutions into custom gate objects. This only takes
+                effect when ``atomic_evolution is None``.
+        """
+        super().__init__(1, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
+
+    def synthesize(self, evolution):
+        # get operators and time to evolve
+        operators = evolution.operator
+        time = evolution.time
+
+        # construct the evolution circuit
+        single_rep = QuantumCircuit(operators[0].num_qubits)
+
+        if not isinstance(operators, list):
+            pauli_list = [(Pauli(op), np.real(coeff)) for op, coeff in operators.to_list()]
+        else:
+            pauli_list = [(op, 1) for op in operators]
+
+        for i, (op, coeff) in enumerate(pauli_list):
+            self.atomic_evolution(single_rep, op, coeff * time / self.reps)
+            if self.insert_barriers and i != len(pauli_list) - 1:
+                single_rep.barrier()
+
+        return single_rep.repeat(self.reps, insert_barriers=self.insert_barriers).decompose()
+
+    @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