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

qiskit/synthesis/__init__.py

@@ -125,7 +125,6 @@ Two-Qubit Synthesis
 Multi Controlled Synthesis
 ==========================
 
-.. autofunction:: synth_mcmt_vchain
 .. autofunction:: synth_mcx_n_dirty_i15
 .. autofunction:: synth_mcx_n_clean_m15
 .. autofunction:: synth_mcx_1_clean_b95
@@ -134,22 +133,6 @@ Multi Controlled Synthesis
 .. autofunction:: synth_c3x
 .. autofunction:: synth_c4x
 
-Binary Arithmetic Synthesis
-===========================
-
-Adders
-------
-
-.. autofunction:: adder_qft_d00
-.. autofunction:: adder_ripple_c04
-.. autofunction:: adder_ripple_v95
-
-Multipliers
------------
-
-.. autofunction:: multiplier_cumulative_h18 
-.. autofunction:: multiplier_qft_r17
-
 """
 
 from .evolution import (
@@ -202,7 +185,6 @@ from .two_qubit.two_qubit_decompose import (
     TwoQubitWeylDecomposition,
 )
 from .multi_controlled import (
-    synth_mcmt_vchain,
     synth_mcx_n_dirty_i15,
     synth_mcx_n_clean_m15,
     synth_mcx_1_clean_b95,
@@ -211,10 +193,3 @@ from .multi_controlled import (
     synth_c3x,
     synth_c4x,
 )
-from .arithmetic import (
-    adder_qft_d00,
-    adder_ripple_c04,
-    adder_ripple_v95,
-    multiplier_cumulative_h18,
-    multiplier_qft_r17,
-)

qiskit/synthesis/clifford/clifford_decompose_bm.py

@@ -41,6 +41,7 @@ def synth_clifford_bm(clifford: Clifford) -> QuantumCircuit:
            `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
     """
     circuit = QuantumCircuit._from_circuit_data(
-        synth_clifford_bm_inner(clifford.tableau.astype(bool)), add_regs=True, name=str(clifford)
+        synth_clifford_bm_inner(clifford.tableau.astype(bool)), add_regs=True
     )
+    circuit.name = str(clifford)
     return circuit

qiskit/synthesis/clifford/clifford_decompose_greedy.py

@@ -51,8 +51,7 @@ def synth_clifford_greedy(clifford: Clifford) -> QuantumCircuit:
            `arXiv:2105.02291 [quant-ph] <https://arxiv.org/abs/2105.02291>`_
     """
     circuit = QuantumCircuit._from_circuit_data(
-        synth_clifford_greedy_inner(clifford.tableau.astype(bool)),
-        add_regs=True,
-        name=str(clifford),
+        synth_clifford_greedy_inner(clifford.tableau.astype(bool)), add_regs=True
     )
+    circuit.name = str(clifford)
     return circuit

qiskit/synthesis/clifford/clifford_decompose_layers.py

@@ -77,8 +77,7 @@ def synth_clifford_layers(
 
     For example, a 5-qubit Clifford circuit is decomposed into the following layers:
 
-    .. code-block:: text
-
+    .. parsed-literal::
              ┌─────┐┌─────┐┌────────┐┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
         q_0: ┤0    ├┤0    ├┤0       ├┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
              │     ││     ││        ││     ││     ││     ││     ││        │

qiskit/synthesis/evolution/__init__.py

@@ -18,4 +18,3 @@ 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/lie_trotter.py

@@ -14,15 +14,18 @@
 
 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 .suzuki_trotter import SuzukiTrotter
+from .product_formula import ProductFormula
 
 
-class LieTrotter(SuzukiTrotter):
+class LieTrotter(ProductFormula):
     r"""The Lie-Trotter product formula.
 
     The Lie-Trotter formula approximates the exponential of two non-commuting operators
@@ -37,7 +40,7 @@ class LieTrotter(SuzukiTrotter):
 
     .. math::
 
-        e^{-it(XI + ZZ)} = e^{-it XI}e^{-it ZZ} + \mathcal{O}(t^2).
+        e^{-it(XX + ZZ)} = e^{-it XX}e^{-it ZZ} + \mathcal{O}(t^2).
 
     References:
 
@@ -49,6 +52,21 @@ class LieTrotter(SuzukiTrotter):
         `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,
@@ -60,7 +78,6 @@ class LieTrotter(SuzukiTrotter):
             | None
         ) = None,
         wrap: bool = False,
-        preserve_order: bool = True,
     ) -> None:
         """
         Args:
@@ -80,19 +97,28 @@ class LieTrotter(SuzukiTrotter):
                 built.
             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.
         """
-        super().__init__(
-            1,
-            reps,
-            insert_barriers,
-            cx_structure,
-            atomic_evolution,
-            wrap,
-            preserve_order=preserve_order,
-        )
+        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]:

qiskit/synthesis/evolution/product_formula.py

@@ -15,26 +15,17 @@
 from __future__ import annotations
 
 import inspect
-import itertools
-from collections.abc import Callable, Sequence
-from collections import defaultdict
-from itertools import combinations
-import typing
+from collections.abc import Callable
+from typing import Any
+from functools import partial
 import numpy as np
-import rustworkx as rx
 from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.circuit.quantumcircuit import QuantumCircuit, ParameterValueType
+from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info import SparsePauliOp, Pauli
 from qiskit.utils.deprecation import deprecate_arg
-from qiskit._accelerate.circuit_library import pauli_evolution
 
 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.
@@ -69,7 +60,6 @@ class ProductFormula(EvolutionSynthesis):
             | None
         ) = None,
         wrap: bool = False,
-        preserve_order: bool = True,
     ) -> None:
         """
         Args:
@@ -88,31 +78,24 @@ class ProductFormula(EvolutionSynthesis):
                 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. 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.
+            wrap: Whether to wrap the atomic evolutions into custom gate objects. This only takes
+                effect when ``atomic_evolution is None``.
         """
         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
+            self.atomic_evolution = partial(
+                _default_atomic_evolution, cx_structure=cx_structure, wrap=wrap
+            )
 
         elif len(inspect.signature(atomic_evolution).parameters) == 2:
 
@@ -125,50 +108,8 @@ class ProductFormula(EvolutionSynthesis):
         else:
             self.atomic_evolution = atomic_evolution
 
-    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]:
+    def settings(self) -> dict[str, Any]:
         """Return the settings in a dictionary, which can be used to reconstruct the object.
 
         Returns:
@@ -188,124 +129,256 @@ class ProductFormula(EvolutionSynthesis):
             "insert_barriers": self.insert_barriers,
             "cx_structure": self._cx_structure,
             "wrap": self._wrap,
-            "preserve_order": self.preserve_order,
         }
 
-    def _normalize_coefficients(
-        self, paulis: list[str | list[int], float | complex | ParameterExpression]
-    ) -> list[str | list[int] | ParameterValueType]:
-        """Ensure the coefficients are real (or parameter expressions)."""
-        return [[(op, qubits, real_or_fail(coeff)) for op, qubits, coeff in ops] for ops in paulis]
 
-    def _custom_evolution(self, num_qubits, pauli_rotations):
-        """Implement the evolution for the non-standard path.
+def evolve_pauli(
+    output: QuantumCircuit,
+    pauli: Pauli,
+    time: float | ParameterExpression = 1.0,
+    cx_structure: str = "chain",
+    wrap: bool = False,
+    label: str | None = None,
+) -> None:
+    r"""Construct a circuit implementing the time evolution of a single Pauli string.
 
-        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"
+    For a Pauli string :math:`P = \{I, X, Y, Z\}^{\otimes n}` on :math:`n` qubits and an
+    evolution time :math:`t`, the returned circuit implements the unitary operation
+
+    .. math::
+
+        U(t) = e^{-itP}.
+
+    Since only a single Pauli string is evolved the circuit decomposition is exact.
+
+    Args:
+        output: The circuit object to which to append the evolved Pauli.
+        pauli: The Pauli to evolve.
+        time: The evolution time.
+        cx_structure: Determine the structure of CX gates, can be either ``"chain"`` for
+            next-neighbor connections or ``"fountain"`` to connect directly to the top qubit.
+        wrap: Whether to wrap the single Pauli evolutions into custom gate objects.
+        label: A label for the gate.
+    """
+    num_non_identity = len([label for label in pauli.to_label() if label != "I"])
+
+    # first check, if the Pauli is only the identity, in which case the evolution only
+    # adds a global phase
+    if num_non_identity == 0:
+        output.global_phase -= time
+    # if we evolve on a single qubit, if yes use the corresponding qubit rotation
+    elif num_non_identity == 1:
+        _single_qubit_evolution(output, pauli, time, wrap)
+    # same for two qubits, use Qiskit's native rotations
+    elif num_non_identity == 2:
+        _two_qubit_evolution(output, pauli, time, cx_structure, wrap)
+    # otherwise do basis transformation and CX chains
+    else:
+        _multi_qubit_evolution(output, pauli, time, cx_structure, wrap)
+
+
+def _single_qubit_evolution(output, pauli, time, wrap):
+    dest = QuantumCircuit(1) if wrap else output
+    # Note that all phases are removed from the pauli label and are only in the coefficients.
+    # That's because the operators we evolved have all been translated to a SparsePauliOp.
+    qubits = []
+    label = ""
+    for i, pauli_i in enumerate(reversed(pauli.to_label())):
+        idx = 0 if wrap else i
+        if pauli_i == "X":
+            dest.rx(2 * time, idx)
+            qubits.append(i)
+            label += "X"
+        elif pauli_i == "Y":
+            dest.ry(2 * time, idx)
+            qubits.append(i)
+            label += "Y"
+        elif pauli_i == "Z":
+            dest.rz(2 * time, idx)
+            qubits.append(i)
+            label += "Z"
+
+    if wrap:
+        gate = dest.to_gate(label=f"exp(it {label})")
+        qubits = [output.qubits[q] for q in qubits]
+        output.append(gate, qargs=qubits, copy=False)
+
+
+def _two_qubit_evolution(output, pauli, time, cx_structure, wrap):
+    # Get the Paulis and the qubits they act on.
+    # Note that all phases are removed from the pauli label and are only in the coefficients.
+    # That's because the operators we evolved have all been translated to a SparsePauliOp.
+    labels_as_array = np.array(list(reversed(pauli.to_label())))
+    qubits = np.where(labels_as_array != "I")[0]
+    indices = [0, 1] if wrap else qubits
+    labels = np.array([labels_as_array[idx] for idx in qubits])
+
+    dest = QuantumCircuit(2) if wrap else output
+
+    # go through all cases we have implemented in Qiskit
+    if all(labels == "X"):  # RXX
+        dest.rxx(2 * time, indices[0], indices[1])
+    elif all(labels == "Y"):  # RYY
+        dest.ryy(2 * time, indices[0], indices[1])
+    elif all(labels == "Z"):  # RZZ
+        dest.rzz(2 * time, indices[0], indices[1])
+    elif labels[0] == "Z" and labels[1] == "X":  # RZX
+        dest.rzx(2 * time, indices[0], indices[1])
+    elif labels[0] == "X" and labels[1] == "Z":  # RXZ
+        dest.rzx(2 * time, indices[1], indices[0])
+    else:  # all the others are not native in Qiskit, so use default the decomposition
+        _multi_qubit_evolution(output, pauli, time, cx_structure, wrap)
+        return
+
+    if wrap:
+        gate = dest.to_gate(label=f"exp(it {''.join(labels)})")
+        qubits = [output.qubits[q] for q in qubits]
+        output.append(gate, qargs=qubits, copy=False)
+
+
+def _multi_qubit_evolution(output, pauli, time, cx_structure, wrap):
+    # get diagonalizing clifford
+    cliff = diagonalizing_clifford(pauli)
+
+    # get CX chain to reduce the evolution to the top qubit
+    if cx_structure == "chain":
+        chain = cnot_chain(pauli)
+    else:
+        chain = cnot_fountain(pauli)
+
+    # determine qubit to do the rotation on
+    target = None
+    # Note that all phases are removed from the pauli label and are only in the coefficients.
+    # That's because the operators we evolved have all been translated to a SparsePauliOp.
+    for i, pauli_i in enumerate(reversed(pauli.to_label())):
+        if pauli_i != "I":
+            target = i
+            break
+
+    # build the evolution as: diagonalization, reduction, 1q evolution, followed by inverses
+    dest = QuantumCircuit(pauli.num_qubits) if wrap else output
+    dest.compose(cliff, inplace=True)
+    dest.compose(chain, inplace=True)
+    dest.rz(2 * time, target)
+    dest.compose(chain.inverse(), inplace=True)
+    dest.compose(cliff.inverse(), inplace=True)
+
+    if wrap:
+        gate = dest.to_gate(label=f"exp(it {pauli.to_label()})")
+        output.append(gate, qargs=output.qubits, copy=False)
+
+
+def diagonalizing_clifford(pauli: Pauli) -> QuantumCircuit:
+    """Get the clifford circuit to diagonalize the Pauli operator.
 
-        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 = SparsePauliOp.from_sparse_list([pauli_rotation], num_qubits)
-                self.atomic_evolution(circuit, operator, time=1)  # time is inside the Pauli coeff
+    Args:
+        pauli: The Pauli to diagonalize.
 
-            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)
+    Returns:
+        A circuit to diagonalize.
+    """
+    cliff = QuantumCircuit(pauli.num_qubits)
+    for i, pauli_i in enumerate(reversed(pauli.to_label())):
+        if pauli_i == "Y":
+            cliff.sdg(i)
+        if pauli_i in ["X", "Y"]:
+            cliff.h(i)
 
-                # build the circuit Rust-side
-                data = pauli_evolution(
-                    len(qubits),
-                    [local_pauli],
-                    False,
-                    cx_fountain,
-                )
-                evo = QuantumCircuit._from_circuit_data(data)
+    return cliff
 
-                # 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()
+def cnot_chain(pauli: Pauli) -> QuantumCircuit:
+    """CX chain.
 
-        return circuit
+    For example, for the Pauli with the label 'XYZIX'.
 
+    .. parsed-literal::
 
-def real_or_fail(value, tol=100):
-    """Return real if close, otherwise fail. Unbound parameters are left unchanged.
+                       ┌───┐
+        q_0: ──────────┤ X ├
+                       └─┬─┘
+        q_1: ────────────┼──
+                  ┌───┐  │
+        q_2: ─────┤ X ├──■──
+             ┌───┐└─┬─┘
+        q_3: ┤ X ├──■───────
+             └─┬─┘
+        q_4: ──■────────────
+
+    Args:
+        pauli: The Pauli for which to construct the CX chain.
 
-    Based on NumPy's ``real_if_close``, i.e. ``tol`` is in terms of machine precision for float.
+    Returns:
+        A circuit implementing the CX chain.
     """
-    if isinstance(value, ParameterExpression):
-        return value
 
-    abstol = tol * np.finfo(float).eps
-    if abs(np.imag(value)) < abstol:
-        return np.real(value)
+    chain = QuantumCircuit(pauli.num_qubits)
+    control, target = None, None
 
-    raise ValueError(f"Encountered complex value {value}, but expected real.")
+    # iterate over the Pauli's and add CNOTs
+    for i, pauli_i in enumerate(pauli.to_label()):
+        i = pauli.num_qubits - i - 1
+        if pauli_i != "I":
+            if control is None:
+                control = i
+            else:
+                target = i
 
+        if control is not None and target is not None:
+            chain.cx(control, target)
+            control = i
+            target = None
 
-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.
+    return chain
 
-    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``.
+def cnot_fountain(pauli: Pauli) -> QuantumCircuit:
+    """CX chain in the fountain shape.
 
-    Args:
-        paulis: The operator whose terms to reorder.
-        strategy: The coloring heuristic to use, see ``ColoringStrategy`` [#].
-            Default is ``ColoringStrategy.Saturation``.
+    For example, for the Pauli with the label 'XYZIX'.
+
+    .. parsed-literal::
 
-    .. [#] https://www.rustworkx.org/apiref/rustworkx.ColoringStrategy.html#coloringstrategy
+             ┌───┐┌───┐┌───┐
+        q_0: ┤ X ├┤ X ├┤ X ├
+             └─┬─┘└─┬─┘└─┬─┘
+        q_1: ──┼────┼────┼──
+               │    │    │
+        q_2: ──■────┼────┼──
+                    │    │
+        q_3: ───────■────┼──
+                         │
+        q_4: ────────────■──
+
+    Args:
+        pauli: The Pauli for which to construct the CX chain.
 
+    Returns:
+        A circuit implementing the CX chain.
     """
 
-    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
+    chain = QuantumCircuit(pauli.num_qubits)
+    control, target = None, None
+    for i, pauli_i in enumerate(reversed(pauli.to_label())):
+        if pauli_i != "I":
+            if target is None:
+                target = i
+            else:
+                control = i
+
+        if control is not None and target is not None:
+            chain.cx(control, target)
+            control = None
+
+    return chain
+
+
+def _default_atomic_evolution(output, operator, time, cx_structure, wrap):
+    if isinstance(operator, Pauli):
+        # single Pauli operator: just exponentiate it
+        evolve_pauli(output, operator, time, cx_structure, wrap)
+    else:
+        # sum of Pauli operators: exponentiate each term (this assumes they commute)
+        pauli_list = [(Pauli(op), np.real(coeff)) for op, coeff in operator.to_list()]
+        for pauli, coeff in pauli_list:
+            evolve_pauli(output, pauli, coeff * time, cx_structure, wrap)