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

qiskit/transpiler/passes/synthesis/hls_plugins.py

@@ -214,13 +214,201 @@ not sufficient, the corresponding synthesis method will return `None`.
    MCXSynthesisNDirtyI15
    MCXSynthesis1CleanB95
    MCXSynthesisDefault
+
+
+MCMT Synthesis
+''''''''''''''
+
+.. list-table:: Plugins for :class:`.MCMTGate` (key = ``"mcmt"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Number of clean ancillas
+      - Number of dirty ancillas
+      - Description
+    * - ``"vchain"``
+      - :class:`.MCMTSynthesisVChain`
+      - `k-1`
+      - `0`
+      - uses a linear number of Toffoli gates
+    * - ``"noaux"``
+      - :class:`~.MCMTSynthesisNoAux`
+      - `0`
+      - `0`
+      - uses Qiskit's standard control mechanism
+    * - ``"default"``
+      - :class:`~.MCMTSynthesisDefault`
+      - any
+      - any
+      - chooses the best algorithm based on the ancillas available
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   MCMTSynthesisVChain
+   MCMTSynthesisNoAux
+   MCMTSynthesisDefault
+
+
+Pauli Evolution Synthesis
+'''''''''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.PauliEvolutionGate` (key = ``"PauliEvolution"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Description
+      - Targeted connectivity
+    * - ``"rustiq"``
+      - :class:`~.PauliEvolutionSynthesisRustiq`
+      - use a diagonalizing Clifford per Pauli term
+      - all-to-all
+    * - ``"default"``
+      - :class:`~.PauliEvolutionSynthesisDefault`
+      - use ``rustiq_core`` synthesis library
+      - all-to-all
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   PauliEvolutionSynthesisDefault
+   PauliEvolutionSynthesisRustiq
+
+
+Modular Adder Synthesis
+'''''''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.ModularAdderGate` (key = ``"ModularAdder"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Number of clean ancillas
+      - Description
+    * - ``"ripple_cdkm"``
+      - :class:`.ModularAdderSynthesisC04`
+      - 1
+      - a ripple-carry adder
+    * - ``"ripple_vbe"``
+      - :class:`.ModularAdderSynthesisV95`
+      - :math:`n-1`, for :math:`n`-bit numbers
+      - a ripple-carry adder
+    * - ``"qft"``
+      - :class:`.ModularAdderSynthesisD00`
+      - 0
+      - a QFT-based adder
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   ModularAdderSynthesisC04
+   ModularAdderSynthesisD00
+   ModularAdderSynthesisV95
+
+Half Adder Synthesis
+''''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.HalfAdderGate` (key = ``"HalfAdder"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Number of clean ancillas
+      - Description
+    * - ``"ripple_cdkm"``
+      - :class:`.HalfAdderSynthesisC04`
+      - 1
+      - a ripple-carry adder
+    * - ``"ripple_vbe"``
+      - :class:`.HalfAdderSynthesisV95`
+      - :math:`n-1`, for :math:`n`-bit numbers
+      - a ripple-carry adder
+    * - ``"qft"``
+      - :class:`.HalfAdderSynthesisD00`
+      - 0
+      - a QFT-based adder
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   HalfAdderSynthesisC04
+   HalfAdderSynthesisD00
+   HalfAdderSynthesisV95
+
+Full Adder Synthesis
+''''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.FullAdderGate` (key = ``"FullAdder"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Number of clean ancillas
+      - Description
+    * - ``"ripple_cdkm"``
+      - :class:`.FullAdderSynthesisC04`
+      - 0
+      - a ripple-carry adder
+    * - ``"ripple_vbe"``
+      - :class:`.FullAdderSynthesisV95`
+      - :math:`n-1`, for :math:`n`-bit numbers
+      - a ripple-carry adder
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   FullAdderSynthesisC04
+   FullAdderSynthesisV95
+
+
+Multiplier Synthesis
+''''''''''''''''''''
+
+.. list-table:: Plugins for :class:`.MultiplierGate` (key = ``"Multiplier"``)
+    :header-rows: 1
+
+    * - Plugin name
+      - Plugin class
+      - Number of clean ancillas
+      - Description
+    * - ``"cumulative"``
+      - :class:`.MultiplierSynthesisH18`
+      - depending on the :class:`.AdderGate` used
+      - a cumulative adder based on controlled adders
+    * - ``"qft"``
+      - :class:`.MultiplierSynthesisR17`
+      - 0
+      - a QFT-based multiplier
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   MultiplierSynthesisH18
+   MultiplierSynthesisR17
+
 """
 
+from __future__ import annotations
+
+import warnings
 import numpy as np
 import rustworkx as rx
 
 from qiskit.circuit.quantumcircuit import QuantumCircuit
-from qiskit.circuit.library import LinearFunction, QFTGate, MCXGate, C3XGate, C4XGate
+from qiskit.circuit.library import (
+    LinearFunction,
+    QFTGate,
+    MCXGate,
+    C3XGate,
+    C4XGate,
+    PauliEvolutionGate,
+    ModularAdderGate,
+    HalfAdderGate,
+    FullAdderGate,
+    MultiplierGate,
+)
 from qiskit.transpiler.exceptions import TranspilerError
 from qiskit.transpiler.coupling import CouplingMap
 
@@ -253,6 +441,15 @@ from qiskit.synthesis.multi_controlled import (
     synth_mcx_1_clean_b95,
     synth_mcx_gray_code,
     synth_mcx_noaux_v24,
+    synth_mcmt_vchain,
+)
+from qiskit.synthesis.evolution import ProductFormula, synth_pauli_network_rustiq
+from qiskit.synthesis.arithmetic import (
+    adder_ripple_c04,
+    adder_qft_d00,
+    adder_ripple_v95,
+    multiplier_qft_r17,
+    multiplier_cumulative_h18,
 )
 from qiskit.transpiler.passes.routing.algorithms import ApproximateTokenSwapper
 from .plugin import HighLevelSynthesisPlugin
@@ -505,6 +702,10 @@ class QFTSynthesisFull(HighLevelSynthesisPlugin):
     This plugin name is :``qft.full`` which can be used as the key on
     an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
 
+    Note that the plugin mechanism is not applied if the gate is called ``qft`` but
+    is not an instance of ``QFTGate``. This allows users to create custom gates with
+    name ``qft``.
+
     The plugin supports the following additional options:
 
     * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
@@ -532,10 +733,11 @@ class QFTSynthesisFull(HighLevelSynthesisPlugin):
 
     def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
         """Run synthesis for the given QFTGate."""
+
+        # Even though the gate is called "qft", it's not a QFTGate,
+        # and we should not synthesize it using the plugin.
         if not isinstance(high_level_object, QFTGate):
-            raise TranspilerError(
-                "The synthesis plugin 'qft.full` only applies to objects of type QFTGate."
-            )
+            return None
 
         reverse_qubits = options.get("reverse_qubits", False)
         approximation_degree = options.get("approximation_degree", 0)
@@ -560,6 +762,10 @@ class QFTSynthesisLine(HighLevelSynthesisPlugin):
     This plugin name is :``qft.line`` which can be used as the key on
     an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
 
+    Note that the plugin mechanism is not applied if the gate is called ``qft`` but
+    is not an instance of ``QFTGate``. This allows users to create custom gates with
+    name ``qft``.
+
     The plugin supports the following additional options:
 
     * reverse_qubits (bool): Whether to synthesize the "QFT" operation (if ``False``,
@@ -584,10 +790,11 @@ class QFTSynthesisLine(HighLevelSynthesisPlugin):
 
     def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
         """Run synthesis for the given QFTGate."""
+
+        # Even though the gate is called "qft", it's not a QFTGate,
+        # and we should not synthesize it using the plugin.
         if not isinstance(high_level_object, QFTGate):
-            raise TranspilerError(
-                "The synthesis plugin 'qft.line` only applies to objects of type QFTGate."
-            )
+            return None
 
         reverse_qubits = options.get("reverse_qubits", False)
         approximation_degree = options.get("approximation_degree", 0)
@@ -926,3 +1133,426 @@ class MCXSynthesisDefault(HighLevelSynthesisPlugin):
         return MCXSynthesisNoAuxV24().run(
             high_level_object, coupling_map, target, qubits, **options
         )
+
+
+class MCMTSynthesisDefault(HighLevelSynthesisPlugin):
+    """A default decomposition for MCMT gates."""
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        # first try to use the V-chain synthesis if enough auxiliary qubits are available
+        if (
+            decomposition := MCMTSynthesisVChain().run(
+                high_level_object, coupling_map, target, qubits, **options
+            )
+        ) is not None:
+            return decomposition
+
+        return MCMTSynthesisNoAux().run(high_level_object, coupling_map, target, qubits, **options)
+
+
+class MCMTSynthesisNoAux(HighLevelSynthesisPlugin):
+    """A V-chain based synthesis for ``MCMTGate``."""
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        base_gate = high_level_object.base_gate
+        ctrl_state = options.get("ctrl_state", None)
+
+        if high_level_object.num_target_qubits == 1:
+            # no broadcasting needed (makes for better circuit diagrams)
+            circuit = QuantumCircuit(high_level_object.num_qubits)
+            circuit.append(
+                base_gate.control(high_level_object.num_ctrl_qubits, ctrl_state=ctrl_state),
+                circuit.qubits,
+            )
+
+        else:
+            base = QuantumCircuit(high_level_object.num_target_qubits, name=high_level_object.label)
+            for i in range(high_level_object.num_target_qubits):
+                base.append(base_gate, [i], [])
+
+            circuit = base.control(high_level_object.num_ctrl_qubits, ctrl_state=ctrl_state)
+
+        return circuit.decompose()
+
+
+class MCMTSynthesisVChain(HighLevelSynthesisPlugin):
+    """A V-chain based synthesis for ``MCMTGate``."""
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if options.get("num_clean_ancillas", 0) < high_level_object.num_ctrl_qubits - 1:
+            return None  # insufficient number of auxiliary qubits
+
+        ctrl_state = options.get("ctrl_state", None)
+
+        return synth_mcmt_vchain(
+            high_level_object.base_gate,
+            high_level_object.num_ctrl_qubits,
+            high_level_object.num_target_qubits,
+            ctrl_state,
+        )
+
+
+class ModularAdderSynthesisDefault(HighLevelSynthesisPlugin):
+    """The default modular adder (no carry in, no carry out qubit) synthesis.
+
+    This plugin name is:``ModularAdder.default`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    If at least one clean auxiliary qubit is available, the :class:`ModularAdderSynthesisC04`
+    is used, otherwise :class:`ModularAdderSynthesisD00`.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, ModularAdderGate):
+            return None
+
+        if options.get("num_clean_ancillas", 0) >= 1:
+            return adder_ripple_c04(high_level_object.num_state_qubits, kind="fixed")
+
+        return adder_qft_d00(high_level_object.num_state_qubits, kind="fixed")
+
+
+class ModularAdderSynthesisC04(HighLevelSynthesisPlugin):
+    r"""A ripple-carry adder, modulo :math:`2^n`.
+
+    This plugin name is:``ModularAdder.ripple_c04`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    This plugin requires at least one clean auxiliary qubit.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, ModularAdderGate):
+            return None
+
+        # unless we implement the full adder, this implementation needs an ancilla qubit
+        if options.get("num_clean_ancillas", 0) < 1:
+            return None
+
+        return adder_ripple_c04(high_level_object.num_state_qubits, kind="fixed")
+
+
+class ModularAdderSynthesisV95(HighLevelSynthesisPlugin):
+    r"""A ripple-carry adder, modulo :math:`2^n`.
+
+    This plugin name is:``ModularAdder.ripple_v95`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For an adder on 2 registers with :math:`n` qubits each, this plugin requires at
+    least :math:`n-1` clean auxiliary qubit.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, ModularAdderGate):
+            return None
+
+        num_state_qubits = high_level_object.num_state_qubits
+
+        # for more than 1 state qubit, we need an ancilla
+        if num_state_qubits > 1 > options.get("num_clean_ancillas", 1):
+            return None
+
+        return adder_ripple_v95(num_state_qubits, kind="fixed")
+
+
+class ModularAdderSynthesisD00(HighLevelSynthesisPlugin):
+    r"""A QFT-based adder, modulo :math:`2^n`.
+
+    This plugin name is:``ModularAdder.qft_d00`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, ModularAdderGate):
+            return None
+
+        return adder_qft_d00(high_level_object.num_state_qubits, kind="fixed")
+
+
+class HalfAdderSynthesisDefault(HighLevelSynthesisPlugin):
+    r"""The default half-adder (no carry in, but a carry out qubit) synthesis.
+
+    If we have an auxiliary qubit available, the Cuccaro ripple-carry adder uses
+    :math:`O(n)` CX gates and 1 auxiliary qubit, whereas the Vedral ripple-carry uses more CX
+    and :math:`n-1` auxiliary qubits. The QFT-based adder uses no auxiliary qubits, but
+    :math:`O(n^2)`, hence it is only used if no auxiliary qubits are available.
+
+    This plugin name is:``HalfAdder.default`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    If at least one clean auxiliary qubit is available, the :class:`HalfAdderSynthesisC04`
+    is used, otherwise :class:`HalfAdderSynthesisD00`.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, HalfAdderGate):
+            return None
+
+        if options.get("num_clean_ancillas", 0) >= 1:
+            return adder_ripple_c04(high_level_object.num_state_qubits, kind="half")
+
+        return adder_qft_d00(high_level_object.num_state_qubits, kind="half")
+
+
+class HalfAdderSynthesisC04(HighLevelSynthesisPlugin):
+    """A ripple-carry adder with a carry-out bit.
+
+    This plugin name is:``HalfAdder.ripple_c04`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    This plugin requires at least one clean auxiliary qubit.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, HalfAdderGate):
+            return None
+
+        # unless we implement the full adder, this implementation needs an ancilla qubit
+        if options.get("num_clean_ancillas", 0) < 1:
+            return None
+
+        return adder_ripple_c04(high_level_object.num_state_qubits, kind="half")
+
+
+class HalfAdderSynthesisV95(HighLevelSynthesisPlugin):
+    """A ripple-carry adder with a carry-out bit.
+
+    This plugin name is:``HalfAdder.ripple_v95`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For an adder on 2 registers with :math:`n` qubits each, this plugin requires at
+    least :math:`n-1` clean auxiliary qubit.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, HalfAdderGate):
+            return None
+
+        num_state_qubits = high_level_object.num_state_qubits
+
+        # for more than 1 state qubit, we need an ancilla
+        if num_state_qubits > 1 > options.get("num_clean_ancillas", 1):
+            return None
+
+        return adder_ripple_v95(num_state_qubits, kind="half")
+
+
+class HalfAdderSynthesisD00(HighLevelSynthesisPlugin):
+    """A QFT-based adder with a carry-in and a carry-out bit.
+
+    This plugin name is:``HalfAdder.qft_d00`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, HalfAdderGate):
+            return None
+
+        return adder_qft_d00(high_level_object.num_state_qubits, kind="half")
+
+
+class FullAdderSynthesisC04(HighLevelSynthesisPlugin):
+    """A ripple-carry adder with a carry-in and a carry-out bit.
+
+    This plugin name is:``FullAdder.ripple_c04`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    This plugin requires at least one clean auxiliary qubit.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, FullAdderGate):
+            return None
+
+        return adder_ripple_c04(high_level_object.num_state_qubits, kind="full")
+
+
+class FullAdderSynthesisV95(HighLevelSynthesisPlugin):
+    """A ripple-carry adder with a carry-in and a carry-out bit.
+
+    This plugin name is:``FullAdder.ripple_v95`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    For an adder on 2 registers with :math:`n` qubits each, this plugin requires at
+    least :math:`n-1` clean auxiliary qubit.
+
+    The plugin supports the following plugin-specific options:
+
+    * ``num_clean_ancillas``: The number of clean auxiliary qubits available.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, FullAdderGate):
+            return None
+
+        num_state_qubits = high_level_object.num_state_qubits
+
+        # for more than 1 state qubit, we need an ancilla
+        if num_state_qubits > 1 > options.get("num_clean_ancillas", 1):
+            return None
+
+        return adder_ripple_v95(num_state_qubits, kind="full")
+
+
+class MultiplierSynthesisH18(HighLevelSynthesisPlugin):
+    """A cumulative multiplier based on controlled adders.
+
+    This plugin name is:``Multiplier.cumulative_h18`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, MultiplierGate):
+            return None
+
+        return multiplier_cumulative_h18(
+            high_level_object.num_state_qubits, high_level_object.num_result_qubits
+        )
+
+
+class MultiplierSynthesisR17(HighLevelSynthesisPlugin):
+    """A QFT-based multiplier.
+
+    This plugin name is:``Multiplier.qft_r17`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, MultiplierGate):
+            return None
+
+        return multiplier_qft_r17(
+            high_level_object.num_state_qubits, high_level_object.num_result_qubits
+        )
+
+
+class PauliEvolutionSynthesisDefault(HighLevelSynthesisPlugin):
+    """Synthesize a :class:`.PauliEvolutionGate` using the default synthesis algorithm.
+
+    This plugin name is:``PauliEvolution.default`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The following plugin option can be set:
+
+    * preserve_order: If ``False``, allow re-ordering the Pauli terms in the Hamiltonian to
+        reduce the circuit depth of the decomposition.
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, PauliEvolutionGate):
+            # Don't do anything if a gate is called "evolution" but is not an
+            # actual PauliEvolutionGate
+            return None
+
+        algo = high_level_object.synthesis
+
+        if "preserve_order" in options and isinstance(algo, ProductFormula):
+            algo.preserve_order = options["preserve_order"]
+
+        return algo.synthesize(high_level_object)
+
+
+class PauliEvolutionSynthesisRustiq(HighLevelSynthesisPlugin):
+    """Synthesize a :class:`.PauliEvolutionGate` using Rustiq.
+
+    This plugin name is :``PauliEvolution.rustiq`` which can be used as the key on
+    an :class:`~.HLSConfig` object to use this method with :class:`~.HighLevelSynthesis`.
+
+    The Rustiq synthesis algorithm is described in [1], and is implemented in
+    Rust-based quantum circuit synthesis library available at
+    https://github.com/smartiel/rustiq-core.
+
+    On large circuits the plugin may take a significant runtime.
+
+    The plugin supports the following additional options:
+
+    * optimize_count (bool): if `True` the synthesis algorithm will try to optimize
+        the 2-qubit gate count; and if `False` then the 2-qubit depth.
+    * preserve_order (bool): whether the order of paulis should be preserved, up to
+        commutativity.
+    * upto_clifford (bool): if `True`, the final Clifford operator is not synthesized.
+    * upto_phase (bool): if `True`, the global phase of the returned circuit may
+        differ from the global phase of the given pauli network.
+    * resynth_clifford_method (int): describes the strategy to synthesize the final
+        Clifford operator. Allowed values are `0` (naive approach), `1` (qiskit
+        greedy synthesis), `2` (rustiq isometry synthesis).
+
+    References:
+        1. Timothée Goubault de Brugière and Simon Martiel,
+           *Faster and shorter synthesis of Hamiltonian simulation circuits*,
+           `arXiv:2404.03280 [quant-ph] <https://arxiv.org/abs/2404.03280>`_
+
+    """
+
+    def run(self, high_level_object, coupling_map=None, target=None, qubits=None, **options):
+        if not isinstance(high_level_object, PauliEvolutionGate):
+            # Don't do anything if a gate is called "evolution" but is not an
+            # actual PauliEvolutionGate
+            return None
+
+        algo = high_level_object.synthesis
+
+        if not isinstance(algo, ProductFormula):
+            warnings.warn(
+                "Cannot apply Rustiq if the evolution synthesis does not implement ``expand``. ",
+                stacklevel=2,
+                category=RuntimeWarning,
+            )
+            return None
+
+        if "preserve_order" in options:
+            algo.preserve_order = options["preserve_order"]
+
+        num_qubits = high_level_object.num_qubits
+        pauli_network = algo.expand(high_level_object)
+
+        optimize_count = options.get("optimize_count", True)
+        preserve_order = options.get("preserve_order", True)
+        upto_clifford = options.get("upto_clifford", False)
+        upto_phase = options.get("upto_phase", False)
+        resynth_clifford_method = options.get("resynth_clifford_method", 1)
+
+        return synth_pauli_network_rustiq(
+            num_qubits=num_qubits,
+            pauli_network=pauli_network,
+            optimize_count=optimize_count,
+            preserve_order=preserve_order,
+            upto_clifford=upto_clifford,
+            upto_phase=upto_phase,
+            resynth_clifford_method=resynth_clifford_method,
+        )