qiskit 1.4.1__cp39-abi3-win_amd64.whl → 2.0.0__cp39-abi3-win_amd64.whl

qiskit/synthesis/boolean/boolean_expression_synth.py

@@ -0,0 +1,124 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+"""Circuit synthesizers and related classes for boolean expressions"""
+
+import itertools
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.library import ZGate, XGate
+
+
+class EsopGenerator:
+    """Generates an ESOP (Exlusive-sum-of-products) representation
+    for a boolean function given by its truth table"""
+
+    def __init__(self, truth_table):
+        self.truth_table = truth_table
+        self.cofactor_table = {}
+        self.esop = self.generate_esop(assignment=())
+
+    def clause_diff(self, clause1, clause2):
+        """The indices of variables where the clauses differ"""
+        return [i for i in range(len(clause1)) if clause1[i] != clause2[i]]
+
+    def combine_and_optimize(self, clauses_1, clauses_2):
+        """Combining clauses of distance 1 until no more combinations can be performed"""
+        something_changed = True
+        combined_clauses = clauses_1 + clauses_2
+        while something_changed:
+            something_changed = False
+            for clause_1, clause_2 in itertools.combinations(combined_clauses, 2):
+                diff = self.clause_diff(clause_1, clause_2)
+                if len(diff) == 1:
+                    new_clause = clause_1[: diff[0]] + "-" + clause_1[diff[0] + 1 :]
+                    if new_clause not in combined_clauses:
+                        combined_clauses.remove(clause_1)
+                        combined_clauses.remove(clause_2)
+                        combined_clauses.append(new_clause)
+                        something_changed = True
+                        break
+        return combined_clauses
+
+    def generate_esop(self, assignment):
+        """Recursively generates an ESOP for a partially determined boolean expression
+        'assignment' is a partial assignment to the expression's variables
+        """
+        # this base case is non-optimized;
+        # we may be able to terminate even before having a full assignment
+        if len(assignment) == self.truth_table.num_bits:
+            if self.truth_table[assignment]:
+                return ["-" * self.truth_table.num_bits]  # True; a don't care clause
+            else:
+                return []  # False
+        i = len(assignment)  # current variable
+        negative_esop = self.generate_esop(assignment + (False,))
+        positive_esop = self.generate_esop(assignment + (True,))
+        # Shannon's expansion
+        negative_esop_bool_expanded = [
+            clause[:i] + "0" + clause[i + 1 :] for clause in negative_esop
+        ]
+        positive_esop_bool_expanded = [
+            clause[:i] + "1" + clause[i + 1 :] for clause in positive_esop
+        ]
+        self.cofactor_table[assignment] = self.combine_and_optimize(
+            negative_esop_bool_expanded, positive_esop_bool_expanded
+        )
+        return self.cofactor_table[assignment]
+
+
+def synth_phase_oracle_from_esop(esop, num_qubits):
+    """
+    Generates a phase oracle for the boolean function f given in ESOP (Exlusive sum of products) form
+    esop is of the form ('01-1', '11-0', ...) etc
+    where 1 is the variable, 0 is negated variable and - is don't care
+    """
+    qc = QuantumCircuit(num_qubits)
+    clause_data = [
+        (zip(*[qubit_data for qubit_data in enumerate(clause) if qubit_data[1] != "-"]))
+        for clause in esop
+    ]
+    for qubit_indices, control_data in clause_data:
+        control_state = "".join(control_data)
+        if len(control_state) == 1:  # single qubit; either Z or XZX
+            if control_state == "0":
+                qc.x(qubit_indices[0])
+            qc.z(qubit_indices[0])
+            if control_state == "0":
+                qc.x(qubit_indices[0])
+        else:  # use custom controlled-Z gate
+            # we use the last qubit as the target, flipping it if the control is 0 for that qubit
+            gate = ZGate().control(len(qubit_indices) - 1, ctrl_state=control_state[:-1][::-1])
+            if control_state[-1] == "0":
+                qc.x(qubit_indices[-1])
+            qc.append(gate, qubit_indices)
+            if control_state[-1] == "0":
+                qc.x(qubit_indices[-1])
+    return qc
+
+
+def synth_bit_oracle_from_esop(esop, num_qubits):
+    """
+    Generates a bit-flip oracle for the boolean function f given in ESOP (Exlusive sum of products) form
+    esop is of the form ('01-1', '11-0', ...) etc
+    where 1 is the variable, 0 is negated variable and - is don't care
+    """
+    output_index = num_qubits - 1
+    qc = QuantumCircuit(num_qubits)
+    clause_data = [
+        (zip(*[qubit_data for qubit_data in enumerate(clause) if qubit_data[1] != "-"]))
+        for clause in esop
+    ]
+    for qubit_indices, control_data in clause_data:
+        control_state = "".join(control_data)
+        # use custom controlled-X gate
+        gate = XGate().control(len(qubit_indices), ctrl_state=control_state[::-1])
+        qc.append(gate, qubit_indices + (output_index,))
+    return qc

qiskit/synthesis/boolean/boolean_expression_visitor.py

@@ -0,0 +1,96 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2025.
+#
+# 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.
+
+"""Node visitor as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor
+This module is used internally by ``qiskit.synthesis.boolean.BooleanExpression``.
+"""
+
+import ast
+import _ast
+
+
+class BooleanExpressionEvalVisitor(ast.NodeVisitor):
+    """Node visitor to compute the value of the expression, given the boolean values of the args
+    as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor"""
+
+    # pylint: disable=invalid-name
+    bitops = {
+        _ast.BitAnd: lambda values: values[0] and values[1],
+        _ast.And: lambda values: values[0] and values[1],
+        _ast.BitOr: lambda values: values[0] or values[1],
+        _ast.Or: lambda values: values[0] or values[1],
+        _ast.BitXor: lambda values: values[0] ^ values[1],
+        _ast.Not: lambda values: not values[0],
+        _ast.Invert: lambda values: not values[0],
+    }
+
+    def __init__(self):
+        self.arg_values = {}
+        super().__init__()
+
+    def bit_binop(self, op, values):
+        """Performs the operation, if it is recognized"""
+        op_type = type(op)
+        if op_type not in self.bitops:
+            raise ValueError(f"Unknown op: {op_type}")
+        return self.bitops[op_type](values)
+
+    def visit_BinOp(self, node):
+        """Handles ``&``, ``^``, and ``|``."""
+        return self.bit_binop(node.op, [self.visit(node.left), self.visit(node.right)])
+
+    def visit_UnaryOp(self, node):
+        """Handles ``~``."""
+        return self.bit_binop(node.op, [self.visit(node.operand)])
+
+    def visit_Name(self, node):
+        """Reduce variable names."""
+        if node.id not in self.arg_values:
+            raise ValueError(f"Undefined value for {node.id}")
+        return self.arg_values[node.id]
+
+    def visit_Module(self, node):
+        """Returns the value of the single expression comprising the boolean expression"""
+        if len(node.body) != 1 or not isinstance(node.body[0], ast.Expr):
+            raise ValueError("Incorrectly formatted boolean expression")
+        return self.visit(node.body[0])
+
+    def visit_Expr(self, node):
+        """Returns the value of the expression"""
+        return self.visit(node.value)
+
+    def generic_visit(self, node):
+        """Catch all for the unhandled nodes."""
+        raise ValueError(f"Unknown node: {type(node)}")
+
+
+class BooleanExpressionArgsCollectorVisitor(ast.NodeVisitor):
+    """Node visitor to collect the name of the args of the expression
+    as defined in https://docs.python.org/3/library/ast.html#ast.NodeVisitor"""
+
+    # pylint: disable=invalid-name
+    def __init__(self):
+        self.args = set()
+        self.args_pos = {}
+        super().__init__()
+
+    def visit_Name(self, node):
+        """Collect arg name."""
+        self.args.add(node.id)
+        if node.id not in self.args_pos or (
+            self.args_pos[node.id] > (node.lineno, node.col_offset)
+        ):
+            self.args_pos[node.id] = (node.lineno, node.col_offset)
+
+    def get_sorted_args(self):
+        """Returns a list of the args, sorted by their appearance locations"""
+        return sorted(self.args, key=lambda arg: self.args_pos[arg])

qiskit/synthesis/discrete_basis/generate_basis_approximations.py

@@ -37,6 +37,8 @@ _1q_inverses = {
     "tdg": "t",
     "s": "sdg",
     "sdg": "s",
+    "sx": "sxdg",
+    "sxdg": "sx",
 }
 
 _1q_gates = {

qiskit/synthesis/evolution/lie_trotter.py

@@ -55,14 +55,14 @@ class LieTrotter(SuzukiTrotter):
         insert_barriers: bool = False,
         cx_structure: str = "chain",
         atomic_evolution: (
-            Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]
-            | Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]
-            | None
+            Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None] | None
         ) = None,
         wrap: bool = False,
         preserve_order: bool = True,
+        *,
+        atomic_evolution_sparse_observable: bool = False,
     ) -> None:
-        """
+        r"""
         Args:
             reps: The number of time steps.
             insert_barriers: Whether to insert barriers between the atomic evolutions.
@@ -75,14 +75,16 @@ class LieTrotter(SuzukiTrotter):
                 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``.
             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,
@@ -92,6 +94,7 @@ class LieTrotter(SuzukiTrotter):
             atomic_evolution,
             wrap,
             preserve_order=preserve_order,
+            atomic_evolution_sparse_observable=atomic_evolution_sparse_observable,
         )
 
     @property

qiskit/synthesis/evolution/product_formula.py

@@ -14,7 +14,7 @@
 
 from __future__ import annotations
 
-import inspect
+import warnings
 import itertools
 from collections.abc import Callable, Sequence
 from collections import defaultdict
@@ -24,8 +24,7 @@ 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, Pauli
-from qiskit.utils.deprecation import deprecate_arg
+from qiskit.quantum_info import SparsePauliOp, Pauli, SparseObservable
 from qiskit._accelerate.circuit_library import pauli_evolution
 
 from .evolution_synthesis import EvolutionSynthesis
@@ -42,20 +41,6 @@ class ProductFormula(EvolutionSynthesis):
     :obj:`.LieTrotter` and :obj:`.SuzukiTrotter` inherit from this class.
     """
 
-    @deprecate_arg(
-        name="atomic_evolution",
-        since="1.4",
-        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]'."
-        ),
-    )
     def __init__(
         self,
         order: int,
@@ -63,14 +48,14 @@ class ProductFormula(EvolutionSynthesis):
         insert_barriers: bool = False,
         cx_structure: str = "chain",
         atomic_evolution: (
-            Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]
-            | Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]
-            | None
+            Callable[[QuantumCircuit, 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.
@@ -84,15 +69,17 @@ class ProductFormula(EvolutionSynthesis):
                 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. 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
@@ -112,17 +99,10 @@ class ProductFormula(EvolutionSynthesis):
         # if atomic evolution is not provided, set a default
         if atomic_evolution is None:
             self.atomic_evolution = None
-
-        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
-
         else:
-            self.atomic_evolution = atomic_evolution
+            self.atomic_evolution = wrap_custom_atomic_evolution(
+                atomic_evolution, atomic_evolution_sparse_observable
+            )
 
     def expand(
         self, evolution: PauliEvolutionGate
@@ -203,7 +183,7 @@ class ProductFormula(EvolutionSynthesis):
         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)
+                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
@@ -302,3 +282,32 @@ def reorder_paulis(
 
     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

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import inspect
 import math
 import typing
 from itertools import chain
@@ -22,7 +21,6 @@ from collections.abc import Callable
 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 qiskit.exceptions import QiskitError
 
 from .product_formula import ProductFormula, reorder_paulis
@@ -32,7 +30,7 @@ if typing.TYPE_CHECKING:
 
 
 class QDrift(ProductFormula):
-    r"""The QDrift Trotterization method, which selects each each term in the
+    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].
 
@@ -41,33 +39,19 @@ class QDrift(ProductFormula):
         `arXiv:quant-ph/1811.08017 <https://arxiv.org/abs/1811.08017>`_
     """
 
-    @deprecate_arg(
-        name="atomic_evolution",
-        since="1.4",
-        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]'."
-        ),
-    )
     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
+            Callable[[QuantumCircuit, 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:
@@ -82,18 +66,27 @@ class QDrift(ProductFormula):
                 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.
             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
+            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)

qiskit/synthesis/evolution/suzuki_trotter.py

@@ -14,7 +14,6 @@
 
 from __future__ import annotations
 
-import inspect
 import typing
 from collections.abc import Callable
 from itertools import chain
@@ -22,8 +21,7 @@ import numpy as np
 
 from qiskit.circuit.parameterexpression import ParameterExpression
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.quantum_info.operators import SparsePauliOp, Pauli
-from qiskit.utils.deprecation import deprecate_arg
+from qiskit.quantum_info import SparsePauliOp, Pauli
 
 from .product_formula import ProductFormula, reorder_paulis
 
@@ -60,20 +58,6 @@ class SuzukiTrotter(ProductFormula):
         `arXiv:math-ph/0506007 <https://arxiv.org/pdf/math-ph/0506007.pdf>`_
     """
 
-    @deprecate_arg(
-        name="atomic_evolution",
-        since="1.4",
-        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]'."
-        ),
-    )
     def __init__(
         self,
         order: int = 2,
@@ -81,14 +65,14 @@ class SuzukiTrotter(ProductFormula):
         insert_barriers: bool = False,
         cx_structure: str = "chain",
         atomic_evolution: (
-            Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]
-            | Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]
-            | None
+            Callable[[QuantumCircuit, 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.
@@ -101,23 +85,26 @@ class SuzukiTrotter(ProductFormula):
                 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``.
             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,
@@ -126,6 +113,7 @@ class SuzukiTrotter(ProductFormula):
             atomic_evolution,
             wrap,
             preserve_order=preserve_order,
+            atomic_evolution_sparse_observable=atomic_evolution_sparse_observable,
         )
 
     def expand(
@@ -154,13 +142,18 @@ class SuzukiTrotter(ProductFormula):
         Returns:
             The Pauli network implementing the Trotter expansion.
         """
-        operators = evolution.operator  # type: SparsePauliOp | list[SparsePauliOp]
+        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 operator.to_sparse_list()
+                for pauli, indices, coeff in sparse_list
             ]
             if not self.preserve_order:
                 return reorder_paulis(paulis)