qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/evolution/product_formula.py

@@ -0,0 +1,316 @@
+# 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.
+
+"""A product formula base for decomposing non-commuting operator exponentials."""
+
+from __future__ import annotations
+
+import warnings
+import itertools
+from collections.abc import Callable, Sequence
+from collections import defaultdict
+from itertools import combinations
+import typing
+import numpy as np
+import rustworkx as rx
+from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.circuit.quantumcircuit import QuantumCircuit, ParameterValueType
+from qiskit.quantum_info import SparsePauliOp, SparseObservable
+from qiskit._accelerate.circuit_library import pauli_evolution
+import qiskit.quantum_info
+
+from .evolution_synthesis import EvolutionSynthesis
+
+if typing.TYPE_CHECKING:
+    from qiskit.circuit.library import PauliEvolutionGate
+
+SparsePauliLabel = typing.Tuple[str, list[int], ParameterValueType]
+
+
+class ProductFormula(EvolutionSynthesis):
+    """Product formula base class for the decomposition of non-commuting operator exponentials.
+
+    :obj:`.LieTrotter` and :obj:`.SuzukiTrotter` inherit from this class.
+    """
+
+    def __init__(
+        self,
+        order: int,
+        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:
+            order: The order of the product formula.
+            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. Note that setting
+                this to ``True`` is slower than ``False``. 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__()
+        self.order = order
+        self.reps = reps
+        self.insert_barriers = insert_barriers
+        self.preserve_order = preserve_order
+
+        # user-provided atomic evolution, stored for serialization
+        self._atomic_evolution = atomic_evolution
+
+        if cx_structure not in ["chain", "fountain"]:
+            raise ValueError(f"Unsupported CX structure: {cx_structure}")
+
+        self._cx_structure = cx_structure
+        self._wrap = wrap
+
+        # if atomic evolution is not provided, set a default
+        if atomic_evolution is None:
+            self.atomic_evolution = None
+        else:
+            self.atomic_evolution = wrap_custom_atomic_evolution(
+                atomic_evolution, atomic_evolution_sparse_observable
+            )
+
+    def expand(
+        self, evolution: PauliEvolutionGate
+    ) -> list[tuple[str, tuple[int], ParameterValueType]]:
+        """Apply the product formula to expand the Hamiltonian in the evolution gate.
+
+        Args:
+            evolution: The :class:`.PauliEvolutionGate`, whose Hamiltonian we expand.
+
+        Returns:
+            A list of Pauli rotations in a sparse format, where each element is
+            ``(paulistring, qubits, coefficient)``. For example, the Lie-Trotter expansion
+            of ``H = XI + ZZ`` would return ``[("X", [1], 1), ("ZZ", [0, 1], 1)]``.
+        """
+        raise NotImplementedError(
+            f"The method ``expand`` is not implemented for {self.__class__}. Implement it to "
+            f"automatically enable the call to {self.__class__}.synthesize."
+        )
+
+    def synthesize(self, evolution: PauliEvolutionGate) -> QuantumCircuit:
+        """Synthesize a :class:`.PauliEvolutionGate`.
+
+        Args:
+            evolution: The evolution gate to synthesize.
+
+        Returns:
+            QuantumCircuit: A circuit implementing the evolution.
+        """
+        pauli_rotations = self.expand(evolution)
+        num_qubits = evolution.num_qubits
+
+        if self._wrap or self._atomic_evolution is not None:
+            # this is the slow path, where each Pauli evolution is constructed in Rust
+            # separately and then wrapped into a gate object
+            circuit = self._custom_evolution(num_qubits, pauli_rotations)
+        else:
+            # this is the fast path, where the whole evolution is constructed Rust-side
+            cx_fountain = self._cx_structure == "fountain"
+            data = pauli_evolution(num_qubits, pauli_rotations, self.insert_barriers, cx_fountain)
+            circuit = QuantumCircuit._from_circuit_data(data, add_regs=True)
+
+        return circuit
+
+    @property
+    def settings(self) -> dict[str, typing.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 {
+            "order": self.order,
+            "reps": self.reps,
+            "insert_barriers": self.insert_barriers,
+            "cx_structure": self._cx_structure,
+            "wrap": self._wrap,
+            "preserve_order": self.preserve_order,
+        }
+
+    def _custom_evolution(self, num_qubits, pauli_rotations):
+        """Implement the evolution for the non-standard path.
+
+        This is either because a user-defined atomic evolution is given, or because the evolution
+        of individual Paulis needs to be wrapped in gates.
+        """
+        circuit = QuantumCircuit(num_qubits)
+        cx_fountain = self._cx_structure == "fountain"
+
+        num_paulis = len(pauli_rotations)
+        for i, pauli_rotation in enumerate(pauli_rotations):
+            if self._atomic_evolution is not None:
+                # use the user-provided evolution with a global operator
+                operator = SparseObservable.from_sparse_list([pauli_rotation], num_qubits)
+                self.atomic_evolution(circuit, operator, time=1)  # time is inside the Pauli coeff
+
+            else:  # this means self._wrap is True
+                # we create a local sparse Pauli representation such that the operator
+                # does not span over all qubits of the circuit
+                pauli_string, qubits, coeff = pauli_rotation
+                local_pauli = (pauli_string, list(range(len(qubits))), coeff)
+
+                # build the circuit Rust-side
+                data = pauli_evolution(
+                    len(qubits),
+                    [local_pauli],
+                    False,
+                    cx_fountain,
+                )
+                evo = QuantumCircuit._from_circuit_data(data)
+
+                # and append it to the circuit with the correct label
+                gate = evo.to_gate(label=f"exp(it {pauli_string})")
+                circuit.append(gate, qubits)
+
+            if self.insert_barriers and i < num_paulis - 1:
+                circuit.barrier()
+
+        return circuit
+
+
+def real_or_fail(value, tol=100):
+    """Return real if close, otherwise fail. Unbound parameters are left unchanged.
+
+    Based on NumPy's ``real_if_close``, i.e. ``tol`` is in terms of machine precision for float.
+    """
+    if isinstance(value, ParameterExpression):
+        return value
+
+    abstol = tol * np.finfo(float).eps
+    if abs(np.imag(value)) < abstol:
+        return np.real(value)
+
+    raise ValueError(f"Encountered complex value {value}, but expected real.")
+
+
+def reorder_paulis(
+    paulis: Sequence[SparsePauliLabel],
+    strategy: rx.ColoringStrategy = rx.ColoringStrategy.Saturation,
+) -> list[SparsePauliLabel]:
+    r"""
+    Creates an equivalent operator by reordering terms in order to yield a
+    shallower circuit after evolution synthesis. The original operator remains
+    unchanged.
+
+    This method works in three steps. First, a graph is constructed, where the
+    nodes are the terms of the operator and where two nodes are connected if
+    their terms act on the same qubit (for example, the terms :math:`IXX` and
+    :math:`IYI` would be connected, but not :math:`IXX` and :math:`YII`). Then,
+    the graph is colored.  Two terms with the same color thus do not act on the
+    same qubit, and in particular, their evolution subcircuits can be run in
+    parallel in the greater evolution circuit of ``paulis``.
+
+    This method is deterministic and invariant under permutation of the Pauli
+    term in ``paulis``.
+
+    Args:
+        paulis: The operator whose terms to reorder.
+        strategy: The coloring heuristic to use, see ``ColoringStrategy`` [#].
+            Default is ``ColoringStrategy.Saturation``.
+
+    .. [#] https://www.rustworkx.org/apiref/rustworkx.ColoringStrategy.html#coloringstrategy
+
+    """
+
+    def _term_sort_key(term: SparsePauliLabel) -> typing.Any:
+        # sort by index, then by pauli
+        return (term[1], term[0])
+
+    # Do nothing in trivial cases
+    if len(paulis) <= 1:
+        return paulis
+
+    terms = sorted(paulis, key=_term_sort_key)
+    graph = rx.PyGraph()
+    graph.add_nodes_from(terms)
+    indexed_nodes = list(enumerate(graph.nodes()))
+    for (idx1, (_, ind1, _)), (idx2, (_, ind2, _)) in combinations(indexed_nodes, 2):
+        # Add an edge between two terms if they touch the same qubit
+        if len(set(ind1).intersection(ind2)) > 0:
+            graph.add_edge(idx1, idx2, None)
+
+    # rx.graph_greedy_color is supposed to be deterministic
+    coloring = rx.graph_greedy_color(graph, strategy=strategy)
+    terms_by_color = defaultdict(list)
+
+    for term_idx, color in sorted(coloring.items()):
+        term = graph.nodes()[term_idx]
+        terms_by_color[color].append(term)
+
+    terms = list(itertools.chain(*terms_by_color.values()))
+    return terms
+
+
+def wrap_custom_atomic_evolution(atomic_evolution, support_sparse_observable):
+    r"""Wrap a custom atomic evolution into compatible format for the product formula.
+
+    This includes an inplace action, i.e. the signature is (circuit, operator, time) and
+    ensuring that ``SparseObservable``\ s are supported.
+    """
+    # next, enable backward compatible use of atomic evolutions, that did not support
+    # SparseObservable inputs
+    if support_sparse_observable is False:
+        warnings.warn(
+            "The atomic_evolution should support SparseObservables as operator input. "
+            "Until Qiskit 2.2, an automatic conversion to SparsePauliOp is done, which can "
+            "be turned off by passing the argument atomic_evolution_sparse_observable=True.",
+            category=PendingDeprecationWarning,
+            stacklevel=2,
+        )
+
+        def sparseobs_atomic_evolution(output, operator, time):
+            if isinstance(operator, SparseObservable):
+                operator = SparsePauliOp.from_sparse_observable(operator)
+
+            atomic_evolution(output, operator, time)
+
+    else:
+        sparseobs_atomic_evolution = atomic_evolution
+
+    return sparseobs_atomic_evolution

qiskit/synthesis/evolution/qdrift.py

@@ -0,0 +1,133 @@
+# 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.
+
+"""QDrift Class"""
+
+from __future__ import annotations
+
+import math
+import typing
+from itertools import chain
+from collections.abc import Callable
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.quantum_info.operators import SparsePauliOp
+from qiskit.exceptions import QiskitError
+import qiskit.quantum_info
+
+from .product_formula import ProductFormula, reorder_paulis
+
+if typing.TYPE_CHECKING:
+    from qiskit.circuit.library import PauliEvolutionGate
+
+
+class QDrift(ProductFormula):
+    r"""The QDrift Trotterization method, which selects each term in the
+    Trotterization randomly, with a probability proportional to its weight. Based on the work
+    of Earl Campbell in Ref. [1].
+
+    References:
+        [1]: E. Campbell, "A random compiler for fast Hamiltonian simulation" (2018).
+        `arXiv:quant-ph/1811.08017 <https://arxiv.org/abs/1811.08017>`_
+    """
+
+    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,
+        seed: int | None = None,
+        wrap: bool = False,
+        preserve_order: bool = True,
+        *,
+        atomic_evolution_sparse_observable: bool = False,
+    ) -> None:
+        r"""
+        Args:
+            reps: The number of times to repeat the Trotterization circuit.
+            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.
+            seed: An optional seed for reproducibility of the random sampling process.
+            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,
+            atomic_evolution_sparse_observable=atomic_evolution_sparse_observable,
+        )
+        self.sampled_ops = None
+        self.rng = np.random.default_rng(seed)
+
+    def expand(self, evolution: PauliEvolutionGate) -> list[tuple[str, tuple[int], float]]:
+        operators = evolution.operator
+        time = evolution.time  # used to determine the number of gates
+
+        # QDrift is based on first-order Lie-Trotter, hence we can just concatenate all
+        # Pauli terms and ignore commutations
+        if isinstance(operators, list):
+            paulis = list(chain.from_iterable([op.to_sparse_list() for op in operators]))
+        else:
+            paulis = operators.to_sparse_list()
+
+        try:
+            coeffs = [float(np.real_if_close(coeff)) for _, _, coeff in paulis]
+        except TypeError as exc:
+            raise QiskitError("QDrift requires bound, real coefficients.") from exc
+
+        # We artificially make the weights positive
+        weights = np.abs(coeffs)
+        lambd = np.sum(weights)
+
+        num_gates = math.ceil(2 * (lambd**2) * (time**2) * self.reps)
+
+        # The protocol calls for the removal of the individual coefficients,
+        # and multiplication by a constant evolution time.
+        sampled = self.rng.choice(
+            np.array(paulis, dtype=object), size=(num_gates,), p=weights / lambd
+        )
+
+        rescaled_time = 2 * lambd / num_gates * time
+        sampled_paulis = [
+            (pauli[0], pauli[1], np.real(np.sign(pauli[2])) * rescaled_time) for pauli in sampled
+        ]
+
+        if not self.preserve_order:
+            sampled_paulis = reorder_paulis(sampled_paulis)
+
+        return sampled_paulis

qiskit/synthesis/evolution/suzuki_trotter.py

@@ -0,0 +1,227 @@
+# 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 Suzuki-Trotter product formula."""
+
+from __future__ import annotations
+
+import typing
+from collections.abc import Callable
+from itertools import chain
+import numpy as np
+
+from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.quantum_info import SparsePauliOp
+import qiskit.quantum_info
+
+from .product_formula import ProductFormula, reorder_paulis
+
+if typing.TYPE_CHECKING:
+    from qiskit.circuit.quantumcircuit import ParameterValueType
+    from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
+
+
+class SuzukiTrotter(ProductFormula):
+    r"""The (higher order) Suzuki-Trotter product formula.
+
+    The Suzuki-Trotter formulas improve the error of the Lie-Trotter approximation.
+    For example, the second order decomposition is
+
+    .. math::
+
+        e^{A + B} \approx e^{B/2} e^{A} e^{B/2}.
+
+    Higher order decompositions are based on recursions, see Ref. [1] for more details.
+
+    In this implementation, the operators are provided as sum terms of a Pauli operator.
+    For example, in the second order Suzuki-Trotter decomposition we approximate
+
+    .. math::
+
+        e^{-it(XI + ZZ)} = e^{-it/2 XI}e^{-it ZZ}e^{-it/2 XI} + \mathcal{O}(t^3).
+
+    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,
+        order: int = 2,
+        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:
+            order: The order of the product formula.
+            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.
+
+        Raises:
+            ValueError: If order is not even
+        """
+        if order > 1 and order % 2 == 1:
+            raise ValueError(
+                "Suzuki product formulae are symmetric and therefore only defined "
+                f"for when the order is 1 or even, not {order}."
+            )
+
+        super().__init__(
+            order,
+            reps,
+            insert_barriers,
+            cx_structure,
+            atomic_evolution,
+            wrap,
+            preserve_order=preserve_order,
+            atomic_evolution_sparse_observable=atomic_evolution_sparse_observable,
+        )
+
+    def expand(
+        self, evolution: PauliEvolutionGate
+    ) -> list[tuple[str, list[int], ParameterValueType]]:
+        """Expand the Hamiltonian into a Suzuki-Trotter sequence of sparse gates.
+
+        For example, the Hamiltonian ``H = IX + ZZ`` for an evolution time ``t`` and
+        1 repetition for an order 2 formula would get decomposed into a list of 3-tuples
+        containing ``(pauli, indices, rz_rotation_angle)``, that is:
+
+        .. code-block:: text
+
+            ("X", [0], t), ("ZZ", [0, 1], 2t), ("X", [0], t)
+
+        Note that the rotation angle contains a factor of 2, such that that evolution
+        of a Pauli :math:`P` over time :math:`t`, which is :math:`e^{itP}`, is represented
+        by ``(P, indices, 2 * t)``.
+
+        For ``N`` repetitions, this sequence would be repeated ``N`` times and the coefficients
+        divided by ``N``.
+
+        Args:
+            evolution: The evolution gate to expand.
+
+        Returns:
+            The Pauli network implementing the Trotter expansion.
+        """
+        operators = evolution.operator
+        time = evolution.time
+
+        def to_sparse_list(operator):
+            sparse_list = (
+                operator.to_sparse_list()
+                if isinstance(operator, SparsePauliOp)
+                else operator.to_sparse_list()
+            )
+            paulis = [
+                (pauli, indices, real_or_fail(coeff) * time * 2 / self.reps)
+                for pauli, indices, coeff in sparse_list
+            ]
+            if not self.preserve_order:
+                return reorder_paulis(paulis)
+
+            return paulis
+
+        # construct the evolution circuit
+        if isinstance(operators, list):  # already sorted into commuting bits
+            non_commuting = [to_sparse_list(operator) for operator in operators]
+        else:
+            # Assume no commutativity here. If we were to group commuting Paulis,
+            # here would be the location to do so.
+            non_commuting = [[op] for op in to_sparse_list(operators)]
+
+        # we're already done here since Lie Trotter does not do any operator repetition
+        product_formula = self._recurse(self.order, non_commuting)
+        flattened = self.reps * list(chain.from_iterable(product_formula))
+
+        return flattened
+
+    @staticmethod
+    def _recurse(order, grouped_paulis):
+        if order == 1:
+            return grouped_paulis
+
+        elif order == 2:
+            halves = [
+                [(label, qubits, coeff / 2) for label, qubits, coeff in paulis]
+                for paulis in grouped_paulis[:-1]
+            ]
+            full = [grouped_paulis[-1]]
+            return halves + full + list(reversed(halves))
+
+        else:
+            reduction = 1 / (4 - 4 ** (1 / (order - 1)))
+            outer = 2 * SuzukiTrotter._recurse(
+                order - 2,
+                [
+                    [(label, qubits, coeff * reduction) for label, qubits, coeff in paulis]
+                    for paulis in grouped_paulis
+                ],
+            )
+            inner = SuzukiTrotter._recurse(
+                order - 2,
+                [
+                    [
+                        (label, qubits, coeff * (1 - 4 * reduction))
+                        for label, qubits, coeff in paulis
+                    ]
+                    for paulis in grouped_paulis
+                ],
+            )
+            return outer + inner + outer
+
+
+def real_or_fail(value, tol=100):
+    """Return real if close, otherwise fail. Unbound parameters are left unchanged.
+
+    Based on NumPy's ``real_if_close``, i.e. ``tol`` is in terms of machine precision for float.
+    """
+    if isinstance(value, ParameterExpression):
+        return value
+
+    abstol = tol * np.finfo(float).eps
+    if abs(np.imag(value)) < abstol:
+        return np.real(value)
+
+    raise ValueError(f"Encountered complex value {value}, but expected real.")