qiskit 1.1.2__cp38-abi3-win32.whl → 1.2.0rc1__cp38-abi3-win32.whl

qiskit/synthesis/clifford/clifford_decompose_layers.py

@@ -33,9 +33,10 @@ from qiskit.synthesis.linear import (
 from qiskit.synthesis.linear_phase import synth_cz_depth_line_mr, synth_cx_cz_depth_line_my
 from qiskit.synthesis.linear.linear_matrix_utils import (
     calc_inverse_matrix,
-    _compute_rank,
-    _gauss_elimination,
-    _gauss_elimination_with_perm,
+    compute_rank,
+    gauss_elimination,
+    gauss_elimination_with_perm,
+    binary_matmul,
 )
 
 
@@ -137,32 +138,32 @@ def synth_clifford_layers(
         cz_func_reverse_qubits=cz_func_reverse_qubits,
     )
 
-    layeredCircuit.append(S2_circ, qubit_list)
+    layeredCircuit.append(S2_circ, qubit_list, copy=False)
 
     if cx_cz_synth_func is None:
-        layeredCircuit.append(CZ2_circ, qubit_list)
+        layeredCircuit.append(CZ2_circ, qubit_list, copy=False)
 
         CXinv = CX_circ.copy().inverse()
-        layeredCircuit.append(CXinv, qubit_list)
+        layeredCircuit.append(CXinv, qubit_list, copy=False)
 
     else:
         # note that CZ2_circ is None and built into the CX_circ when
         # cx_cz_synth_func is not None
-        layeredCircuit.append(CX_circ, qubit_list)
+        layeredCircuit.append(CX_circ, qubit_list, copy=False)
 
-    layeredCircuit.append(H2_circ, qubit_list)
-    layeredCircuit.append(S1_circ, qubit_list)
-    layeredCircuit.append(CZ1_circ, qubit_list)
+    layeredCircuit.append(H2_circ, qubit_list, copy=False)
+    layeredCircuit.append(S1_circ, qubit_list, copy=False)
+    layeredCircuit.append(CZ1_circ, qubit_list, copy=False)
 
     if cz_func_reverse_qubits:
         H1_circ = H1_circ.reverse_bits()
-    layeredCircuit.append(H1_circ, qubit_list)
+    layeredCircuit.append(H1_circ, qubit_list, copy=False)
 
     # Add Pauli layer to fix the Clifford phase signs
 
     clifford_target = Clifford(layeredCircuit)
     pauli_circ = _calc_pauli_diff(cliff, clifford_target)
-    layeredCircuit.append(pauli_circ, qubit_list)
+    layeredCircuit.append(pauli_circ, qubit_list, copy=False)
 
     return layeredCircuit
 
@@ -203,24 +204,25 @@ def _create_graph_state(cliff, validate=False):
     """
 
     num_qubits = cliff.num_qubits
-    rank = _compute_rank(cliff.stab_x)
+    rank = compute_rank(np.asarray(cliff.stab_x, dtype=bool))
     H1_circ = QuantumCircuit(num_qubits, name="H1")
     cliffh = cliff.copy()
 
     if rank < num_qubits:
         stab = cliff.stab[:, :-1]
-        stab = _gauss_elimination(stab, num_qubits)
+        stab = stab.astype(bool, copy=True)
+        gauss_elimination(stab, num_qubits)
 
         Cmat = stab[rank:num_qubits, num_qubits:]
         Cmat = np.transpose(Cmat)
-        Cmat, perm = _gauss_elimination_with_perm(Cmat)
+        perm = gauss_elimination_with_perm(Cmat)
         perm = perm[0 : num_qubits - rank]
 
         # validate that the output matrix has the same rank
         if validate:
-            if _compute_rank(Cmat) != num_qubits - rank:
+            if compute_rank(Cmat) != num_qubits - rank:
                 raise QiskitError("The matrix Cmat after Gauss elimination has wrong rank.")
-            if _compute_rank(stab[:, 0:num_qubits]) != rank:
+            if compute_rank(stab[:, 0:num_qubits]) != rank:
                 raise QiskitError("The matrix after Gauss elimination has wrong rank.")
             # validate that we have a num_qubits - rank zero rows
             for i in range(rank, num_qubits):
@@ -236,8 +238,8 @@ def _create_graph_state(cliff, validate=False):
 
         # validate that a layer of Hadamard gates and then appending cliff, provides a graph state.
         if validate:
-            stabh = cliffh.stab_x
-            if _compute_rank(stabh) != num_qubits:
+            stabh = (cliffh.stab_x).astype(bool, copy=False)
+            if compute_rank(stabh) != num_qubits:
                 raise QiskitError("The state is not a graph state.")
 
     return H1_circ, cliffh
@@ -267,7 +269,7 @@ def _decompose_graph_state(cliff, validate, cz_synth_func):
     """
 
     num_qubits = cliff.num_qubits
-    rank = _compute_rank(cliff.stab_x)
+    rank = compute_rank(np.asarray(cliff.stab_x, dtype=bool))
     cliff_cpy = cliff.copy()
     if rank < num_qubits:
         raise QiskitError("The stabilizer state is not a graph state.")
@@ -278,7 +280,7 @@ def _decompose_graph_state(cliff, validate, cz_synth_func):
     stabx = cliff.stab_x
     stabz = cliff.stab_z
     stabx_inv = calc_inverse_matrix(stabx, validate)
-    stabz_update = np.matmul(stabx_inv, stabz) % 2
+    stabz_update = binary_matmul(stabx_inv, stabz)
 
     # Assert that stabz_update is a symmetric matrix.
     if validate:
@@ -340,7 +342,7 @@ def _decompose_hadamard_free(
     if not (stabx == np.zeros((num_qubits, num_qubits))).all():
         raise QiskitError("The given Clifford is not Hadamard-free.")
 
-    destabz_update = np.matmul(calc_inverse_matrix(destabx), destabz) % 2
+    destabz_update = binary_matmul(calc_inverse_matrix(destabx), destabz)
     # Assert that destabz_update is a symmetric matrix.
     if validate:
         if (destabz_update != destabz_update.T).any():
@@ -412,7 +414,7 @@ def _calc_pauli_diff(cliff, cliff_target):
 
 
 def synth_clifford_depth_lnn(cliff):
-    """Synthesis of a :class:`.Clifford` into layers for linear-nearest neighbour connectivity.
+    """Synthesis of a :class:`.Clifford` into layers for linear-nearest neighbor connectivity.
 
     The depth of the synthesized n-qubit circuit is bounded by :math:`7n+2`, which is not optimal.
     It should be replaced by a better algorithm that provides depth bounded by :math:`7n-4` [3].

qiskit/synthesis/cnotdihedral/cnotdihedral_decompose_full.py

@@ -40,7 +40,7 @@ def synth_cnotdihedral_full(elem: CNOTDihedral) -> QuantumCircuit:
            with optimal number of two qubit gates*, `Quantum 4(369), 2020
            <https://quantum-journal.org/papers/q-2020-12-07-369/>`_
         2. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta,
-           *Scalable randomised benchmarking of non-Clifford gates*,
+           *Scalable randomized benchmarking of non-Clifford gates*,
            npj Quantum Inf 2, 16012 (2016).
     """
 

qiskit/synthesis/cnotdihedral/cnotdihedral_decompose_general.py

@@ -38,7 +38,7 @@ def synth_cnotdihedral_general(elem: CNOTDihedral) -> QuantumCircuit:
 
     References:
         1. Andrew W. Cross, Easwar Magesan, Lev S. Bishop, John A. Smolin and Jay M. Gambetta,
-           *Scalable randomised benchmarking of non-Clifford gates*,
+           *Scalable randomized benchmarking of non-Clifford gates*,
            npj Quantum Inf 2, 16012 (2016).
     """
 

qiskit/synthesis/discrete_basis/generate_basis_approximations.py

@@ -137,7 +137,7 @@ def generate_basic_approximations(
     basis = []
     for gate in basis_gates:
         if isinstance(gate, str):
-            if gate not in _1q_gates.keys():
+            if gate not in _1q_gates:
                 raise ValueError(f"Invalid gate identifier: {gate}")
             basis.append(gate)
         else:  # gate is a qiskit.circuit.Gate

qiskit/synthesis/discrete_basis/solovay_kitaev.py

@@ -119,7 +119,7 @@ class SolovayKitaevDecomposition:
         gate_matrix_su2 = GateSequence.from_matrix(z * gate_matrix)
         global_phase = np.arctan2(np.imag(z), np.real(z))
 
-        # get the decompositon as GateSequence type
+        # get the decomposition as GateSequence type
         decomposition = self._recurse(gate_matrix_su2, recursion_degree, check_input=check_input)
 
         # simplify
@@ -190,7 +190,7 @@ def _remove_inverse_follows_gate(sequence):
     while index < len(sequence.gates) - 1:
         curr_gate = sequence.gates[index]
         next_gate = sequence.gates[index + 1]
-        if curr_gate.name in _1q_inverses.keys():
+        if curr_gate.name in _1q_inverses:
             remove = _1q_inverses[curr_gate.name] == next_gate.name
         else:
             remove = curr_gate.inverse() == next_gate

qiskit/synthesis/evolution/evolution_synthesis.py

@@ -12,8 +12,10 @@
 
 """Evolution synthesis."""
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
-from typing import Any, Dict
+from typing import Any
 
 
 class EvolutionSynthesis(ABC):
@@ -32,7 +34,7 @@ class EvolutionSynthesis(ABC):
         raise NotImplementedError
 
     @property
-    def settings(self) -> Dict[str, Any]:
+    def settings(self) -> dict[str, Any]:
         """Return the settings in a dictionary, which can be used to reconstruct the object.
 
         Returns:

qiskit/synthesis/evolution/lie_trotter.py

@@ -12,10 +12,15 @@
 
 """The Lie-Trotter product formula."""
 
-from typing import Callable, Optional, Union, Dict, Any
+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
 
@@ -47,14 +52,32 @@ class LieTrotter(ProductFormula):
         `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: Optional[
-            Callable[[Union[Pauli, SparsePauliOp], float], QuantumCircuit]
-        ] = None,
+        atomic_evolution: (
+            Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]
+            | Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]
+            | None
+        ) = None,
+        wrap: bool = False,
     ) -> None:
         """
         Args:
@@ -62,12 +85,20 @@ class LieTrotter(ProductFormula):
             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.
-            atomic_evolution: A function to construct the circuit for the evolution of single
-                Pauli string. Per default, a single Pauli evolution is decomposed in a CX chain
-                and a single qubit Z rotation.
+                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)
+        super().__init__(1, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
 
     def synthesize(self, evolution):
         # get operators and time to evolve
@@ -75,27 +106,22 @@ class LieTrotter(ProductFormula):
         time = evolution.time
 
         # construct the evolution circuit
-        evolution_circuit = QuantumCircuit(operators[0].num_qubits)
+        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]
 
-        # if we only evolve a single Pauli we don't need to additionally wrap it
-        wrap = not (len(pauli_list) == 1 and self.reps == 1)
-
         for i, (op, coeff) in enumerate(pauli_list):
-            evolution_circuit.compose(
-                self.atomic_evolution(op, coeff * time / self.reps), wrap=wrap, inplace=True
-            )
+            self.atomic_evolution(single_rep, op, coeff * time / self.reps)
             if self.insert_barriers and i != len(pauli_list) - 1:
-                evolution_circuit.barrier()
+                single_rep.barrier()
 
-        return evolution_circuit.repeat(self.reps).decompose()
+        return single_rep.repeat(self.reps, insert_barriers=self.insert_barriers).decompose()
 
     @property
-    def settings(self) -> Dict[str, Any]:
+    def settings(self) -> dict[str, Any]:
         """Return the settings in a dictionary, which can be used to reconstruct the object.
 
         Returns:
@@ -113,4 +139,5 @@ class LieTrotter(ProductFormula):
             "reps": self.reps,
             "insert_barriers": self.insert_barriers,
             "cx_structure": self._cx_structure,
+            "wrap": self._wrap,
         }

qiskit/synthesis/evolution/product_formula.py

@@ -12,12 +12,17 @@
 
 """A product formula base for decomposing non-commuting operator exponentials."""
 
-from typing import Callable, Optional, Union, Any, Dict
+from __future__ import annotations
+
+import inspect
+from collections.abc import Callable
+from typing import Any
 from functools import partial
 import numpy as np
 from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.quantum_info import SparsePauliOp, Pauli
+from qiskit.utils.deprecation import deprecate_arg
 
 from .evolution_synthesis import EvolutionSynthesis
 
@@ -28,15 +33,33 @@ class ProductFormula(EvolutionSynthesis):
     :obj:`.LieTrotter` and :obj:`.SuzukiTrotter` inherit from this class.
     """
 
+    @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,
         order: int,
         reps: int = 1,
         insert_barriers: bool = False,
         cx_structure: str = "chain",
-        atomic_evolution: Optional[
-            Callable[[Union[Pauli, SparsePauliOp], float], QuantumCircuit]
-        ] = None,
+        atomic_evolution: (
+            Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]
+            | Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]
+            | None
+        ) = None,
+        wrap: bool = False,
     ) -> None:
         """
         Args:
@@ -45,10 +68,18 @@ class ProductFormula(EvolutionSynthesis):
             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.
-            atomic_evolution: A function to construct the circuit for the evolution of single
-                Pauli string. Per default, a single Pauli evolution is decomposed in a CX chain
-                and a single qubit Z rotation.
+                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__()
         self.order = order
@@ -58,15 +89,27 @@ class ProductFormula(EvolutionSynthesis):
         # user-provided atomic evolution, stored for serialization
         self._atomic_evolution = atomic_evolution
         self._cx_structure = cx_structure
+        self._wrap = wrap
 
         # if atomic evolution is not provided, set a default
         if atomic_evolution is None:
-            atomic_evolution = partial(_default_atomic_evolution, cx_structure=cx_structure)
+            self.atomic_evolution = partial(
+                _default_atomic_evolution, cx_structure=cx_structure, wrap=wrap
+            )
+
+        elif len(inspect.signature(atomic_evolution).parameters) == 2:
+
+            def wrap_atomic_evolution(output, operator, time):
+                definition = atomic_evolution(operator, time)
+                output.compose(definition, wrap=wrap, inplace=True)
+
+            self.atomic_evolution = wrap_atomic_evolution
 
-        self.atomic_evolution = atomic_evolution
+        else:
+            self.atomic_evolution = atomic_evolution
 
     @property
-    def settings(self) -> Dict[str, Any]:
+    def settings(self) -> dict[str, Any]:
         """Return the settings in a dictionary, which can be used to reconstruct the object.
 
         Returns:
@@ -85,15 +128,18 @@ class ProductFormula(EvolutionSynthesis):
             "reps": self.reps,
             "insert_barriers": self.insert_barriers,
             "cx_structure": self._cx_structure,
+            "wrap": self._wrap,
         }
 
 
 def evolve_pauli(
+    output: QuantumCircuit,
     pauli: Pauli,
-    time: Union[float, ParameterExpression] = 1.0,
+    time: float | ParameterExpression = 1.0,
     cx_structure: str = "chain",
-    label: Optional[str] = None,
-) -> QuantumCircuit:
+    wrap: bool = False,
+    label: str | None = None,
+) -> None:
     r"""Construct a circuit implementing the time evolution of a single Pauli string.
 
     For a Pauli string :math:`P = \{I, X, Y, Z\}^{\otimes n}` on :math:`n` qubits and an
@@ -106,79 +152,91 @@ def evolve_pauli(
     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.
-
-    Returns:
-        A quantum circuit implementing the time evolution of the Pauli.
     """
     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:
-        definition = QuantumCircuit(pauli.num_qubits, global_phase=-time)
+        output.global_phase -= time
     # if we evolve on a single qubit, if yes use the corresponding qubit rotation
     elif num_non_identity == 1:
-        definition = _single_qubit_evolution(pauli, time)
+        _single_qubit_evolution(output, pauli, time, wrap)
     # same for two qubits, use Qiskit's native rotations
     elif num_non_identity == 2:
-        definition = _two_qubit_evolution(pauli, time, cx_structure)
+        _two_qubit_evolution(output, pauli, time, cx_structure, wrap)
     # otherwise do basis transformation and CX chains
     else:
-        definition = _multi_qubit_evolution(pauli, time, cx_structure)
-
-    definition.name = f"exp(it {pauli.to_label()})"
+        _multi_qubit_evolution(output, pauli, time, cx_structure, wrap)
 
-    return definition
 
-
-def _single_qubit_evolution(pauli, time):
-    definition = QuantumCircuit(pauli.num_qubits)
+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":
-            definition.rx(2 * time, i)
+            dest.rx(2 * time, idx)
+            qubits.append(i)
+            label += "X"
         elif pauli_i == "Y":
-            definition.ry(2 * time, i)
+            dest.ry(2 * time, idx)
+            qubits.append(i)
+            label += "Y"
         elif pauli_i == "Z":
-            definition.rz(2 * time, i)
+            dest.rz(2 * time, idx)
+            qubits.append(i)
+            label += "Z"
 
-    return definition
+    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(pauli, time, cx_structure):
+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])
 
-    definition = QuantumCircuit(pauli.num_qubits)
+    dest = QuantumCircuit(2) if wrap else output
 
     # go through all cases we have implemented in Qiskit
     if all(labels == "X"):  # RXX
-        definition.rxx(2 * time, qubits[0], qubits[1])
+        dest.rxx(2 * time, indices[0], indices[1])
     elif all(labels == "Y"):  # RYY
-        definition.ryy(2 * time, qubits[0], qubits[1])
+        dest.ryy(2 * time, indices[0], indices[1])
     elif all(labels == "Z"):  # RZZ
-        definition.rzz(2 * time, qubits[0], qubits[1])
+        dest.rzz(2 * time, indices[0], indices[1])
     elif labels[0] == "Z" and labels[1] == "X":  # RZX
-        definition.rzx(2 * time, qubits[0], qubits[1])
+        dest.rzx(2 * time, indices[0], indices[1])
     elif labels[0] == "X" and labels[1] == "Z":  # RXZ
-        definition.rzx(2 * time, qubits[1], qubits[0])
+        dest.rzx(2 * time, indices[1], indices[0])
     else:  # all the others are not native in Qiskit, so use default the decomposition
-        definition = _multi_qubit_evolution(pauli, time, cx_structure)
+        _multi_qubit_evolution(output, pauli, time, cx_structure, wrap)
+        return
 
-    return definition
+    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(pauli, time, cx_structure):
+def _multi_qubit_evolution(output, pauli, time, cx_structure, wrap):
     # get diagonalizing clifford
     cliff = diagonalizing_clifford(pauli)
 
@@ -198,14 +256,16 @@ def _multi_qubit_evolution(pauli, time, cx_structure):
             break
 
     # build the evolution as: diagonalization, reduction, 1q evolution, followed by inverses
-    definition = QuantumCircuit(pauli.num_qubits)
-    definition.compose(cliff, inplace=True)
-    definition.compose(chain, inplace=True)
-    definition.rz(2 * time, target)
-    definition.compose(chain.inverse(), inplace=True)
-    definition.compose(cliff.inverse(), inplace=True)
+    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)
 
-    return definition
+    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:
@@ -313,16 +373,12 @@ def cnot_fountain(pauli: Pauli) -> QuantumCircuit:
     return chain
 
 
-def _default_atomic_evolution(operator, time, cx_structure):
+def _default_atomic_evolution(output, operator, time, cx_structure, wrap):
     if isinstance(operator, Pauli):
         # single Pauli operator: just exponentiate it
-        evolution_circuit = evolve_pauli(operator, time, cx_structure)
+        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()]
-        name = f"exp(it {[pauli.to_label() for pauli, _ in pauli_list]})"
-        evolution_circuit = QuantumCircuit(operator.num_qubits, name=name)
         for pauli, coeff in pauli_list:
-            evolution_circuit.compose(evolve_pauli(pauli, coeff * time, cx_structure), inplace=True)
-
-    return evolution_circuit
+            evolve_pauli(output, pauli, coeff * time, cx_structure, wrap)