qiskit 1.1.1__cp38-abi3-macosx_11_0_arm64.whl → 1.2.0__cp38-abi3-macosx_11_0_arm64.whl

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)

qiskit/synthesis/evolution/qdrift.py

@@ -12,11 +12,15 @@
 
 """QDrift Class"""
 
+from __future__ import annotations
+
+import inspect
 import math
-from typing import Union, Optional, Callable
+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 .product_formula import ProductFormula
 from .lie_trotter import LieTrotter
@@ -32,15 +36,33 @@ class QDrift(ProductFormula):
         `arXiv:quant-ph/1811.08017 <https://arxiv.org/abs/1811.08017>`_
     """
 
+    @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,
-        seed: Optional[int] = None,
+        atomic_evolution: (
+            Callable[[Pauli | SparsePauliOp, float], QuantumCircuit]
+            | Callable[[QuantumCircuit, Pauli | SparsePauliOp, float], None]
+            | None
+        ) = None,
+        seed: int | None = None,
+        wrap: bool = False,
     ) -> None:
         r"""
         Args:
@@ -48,13 +70,21 @@ class QDrift(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.
+                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.
             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``.
         """
-        super().__init__(1, reps, insert_barriers, cx_structure, atomic_evolution)
+        super().__init__(1, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
         self.sampled_ops = None
         self.rng = np.random.default_rng(seed)
 

qiskit/synthesis/evolution/suzuki_trotter.py

@@ -12,12 +12,16 @@
 
 """The Suzuki-Trotter product formula."""
 
-from typing import Callable, Optional, Union
+from __future__ import annotations
+
+import inspect
+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 .product_formula import ProductFormula
@@ -51,15 +55,33 @@ class SuzukiTrotter(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,
         order: int = 2,
         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:
@@ -68,10 +90,17 @@ class SuzukiTrotter(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.
+                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``.
         Raises:
             ValueError: If order is not even
         """
@@ -81,7 +110,7 @@ class SuzukiTrotter(ProductFormula):
                 "Suzuki product formulae are symmetric and therefore only defined "
                 "for even orders."
             )
-        super().__init__(order, reps, insert_barriers, cx_structure, atomic_evolution)
+        super().__init__(order, reps, insert_barriers, cx_structure, atomic_evolution, wrap)
 
     def synthesize(self, evolution):
         # get operators and time to evolve
@@ -97,32 +126,13 @@ class SuzukiTrotter(ProductFormula):
 
         # construct the evolution circuit
         single_rep = QuantumCircuit(operators[0].num_qubits)
-        first_barrier = False
-
-        for op, coeff in ops_to_evolve:
-            # add barriers
-            if first_barrier:
-                if self.insert_barriers:
-                    single_rep.barrier()
-            else:
-                first_barrier = True
-
-            single_rep.compose(self.atomic_evolution(op, coeff), wrap=True, inplace=True)
-
-        evolution_circuit = QuantumCircuit(operators[0].num_qubits)
-        first_barrier = False
-
-        for _ in range(self.reps):
-            # add barriers
-            if first_barrier:
-                if self.insert_barriers:
-                    single_rep.barrier()
-            else:
-                first_barrier = True
 
-            evolution_circuit.compose(single_rep, inplace=True)
+        for i, (op, coeff) in enumerate(ops_to_evolve):
+            self.atomic_evolution(single_rep, op, coeff)
+            if self.insert_barriers and i != len(ops_to_evolve) - 1:
+                single_rep.barrier()
 
-        return evolution_circuit
+        return single_rep.repeat(self.reps, insert_barriers=self.insert_barriers).decompose()
 
     @staticmethod
     def _recurse(order, time, pauli_list):

qiskit/synthesis/linear/__init__.py

@@ -18,6 +18,7 @@ from .linear_matrix_utils import (
     random_invertible_binary_matrix,
     calc_inverse_matrix,
     check_invertible_binary_matrix,
+    binary_matmul,
 )
 
 # This is re-import is kept for compatibility with Terra 0.23. Eligible for deprecation in 0.25+.

qiskit/synthesis/linear/cnot_synth.py

@@ -17,33 +17,37 @@ for optimal synthesis of linear (CNOT-only) reversible circuits.
 """
 
 from __future__ import annotations
-import copy
+
 import numpy as np
 from qiskit.circuit import QuantumCircuit
-from qiskit.exceptions import QiskitError
+
+from qiskit._accelerate.synthesis.linear import synth_cnot_count_full_pmh as fast_pmh
 
 
 def synth_cnot_count_full_pmh(
-    state: list[list[bool]] | np.ndarray[bool], section_size: int = 2
+    state: list[list[bool]] | np.ndarray[bool], section_size: int | None = None
 ) -> QuantumCircuit:
-    """
+    r"""
     Synthesize linear reversible circuits for all-to-all architecture
     using Patel, Markov and Hayes method.
 
     This function is an implementation of the Patel, Markov and Hayes algorithm from [1]
     for optimal synthesis of linear reversible circuits for all-to-all architecture,
-    as specified by an :math:`n \\times n` matrix.
+    as specified by an :math:`n \times n` matrix.
 
     Args:
-        state: :math:`n \\times n` boolean invertible matrix, describing
-            the state of the input circuit
+        state: :math:`n \times n` boolean invertible matrix, describing
+            the state of the input circuit.
         section_size: The size of each section in the Patel–Markov–Hayes algorithm [1].
+            If ``None`` it is chosen to be :math:`\max(2, \alpha\log_2(n))` with
+            :math:`\alpha = 0.56`, which approximately minimizes the upper bound on the number
+            of row operations given in [1] Eq. (3).
 
     Returns:
-        QuantumCircuit: a CX-only circuit implementing the linear transformation.
+        A CX-only circuit implementing the linear transformation.
 
     Raises:
-        QiskitError: when variable ``state`` isn't of type ``numpy.ndarray``
+        ValueError: When ``section_size`` is larger than the number of columns.
 
     References:
         1. Patel, Ketan N., Igor L. Markov, and John P. Hayes,
@@ -51,93 +55,15 @@ def synth_cnot_count_full_pmh(
            Quantum Information & Computation 8.3 (2008): 282-294.
            `arXiv:quant-ph/0302002 [quant-ph] <https://arxiv.org/abs/quant-ph/0302002>`_
     """
-    if not isinstance(state, (list, np.ndarray)):
-        raise QiskitError(
-            "state should be of type list or numpy.ndarray, "
-            "but was of the type {}".format(type(state))
+    normalized = np.asarray(state).astype(bool)
+    if section_size is not None and normalized.shape[1] < section_size:
+        raise ValueError(
+            f"The section_size ({section_size}) cannot be larger than the number of columns "
+            f"({normalized.shape[1]})."
         )
-    state = np.array(state)
-    # Synthesize lower triangular part
-    [state, circuit_l] = _lwr_cnot_synth(state, section_size)
-    state = np.transpose(state)
-    # Synthesize upper triangular part
-    [state, circuit_u] = _lwr_cnot_synth(state, section_size)
-    circuit_l.reverse()
-    for i in circuit_u:
-        i.reverse()
-    # Convert the list into a circuit of C-NOT gates
-    circ = QuantumCircuit(state.shape[0])
-    for i in circuit_u + circuit_l:
-        circ.cx(i[0], i[1])
-    return circ
-
-
-def _lwr_cnot_synth(state, section_size):
-    """
-    This function is a helper function of the algorithm for optimal synthesis
-    of linear reversible circuits (the Patel–Markov–Hayes algorithm). It works
-    like gaussian elimination, except that it works a lot faster, and requires
-    fewer steps (and therefore fewer CNOTs). It takes the matrix "state" and
-    splits it into sections of size section_size. Then it eliminates all non-zero
-    sub-rows within each section, which are the same as a non-zero sub-row
-    above. Once this has been done, it continues with normal gaussian elimination.
-    The benefit is that with small section sizes (m), most of the sub-rows will
-    be cleared in the first step, resulting in a factor m fewer row row operations
-    during Gaussian elimination.
 
-    The algorithm is described in detail in the following paper
-    "Optimal synthesis of linear reversible circuits."
-    Patel, Ketan N., Igor L. Markov, and John P. Hayes.
-    Quantum Information & Computation 8.3 (2008): 282-294.
-
-    Note:
-    This implementation tweaks the Patel, Markov, and Hayes algorithm by adding
-    a "back reduce" which adds rows below the pivot row with a high degree of
-    overlap back to it. The intuition is to avoid a high-weight pivot row
-    increasing the weight of lower rows.
-
-    Args:
-        state (ndarray): n x n matrix, describing a linear quantum circuit
-        section_size (int): the section size the matrix columns are divided into
-
-    Returns:
-        numpy.matrix: n by n matrix, describing the state of the output circuit
-        list: a k by 2 list of C-NOT operations that need to be applied
-    """
-    circuit = []
-    num_qubits = state.shape[0]
-    cutoff = 1
+    # call Rust implementation with normalized input
+    circuit_data = fast_pmh(normalized, section_size)
 
-    # Iterate over column sections
-    for sec in range(1, int(np.floor(num_qubits / section_size) + 1)):
-        # Remove duplicate sub-rows in section sec
-        patt = {}
-        for row in range((sec - 1) * section_size, num_qubits):
-            sub_row_patt = copy.deepcopy(state[row, (sec - 1) * section_size : sec * section_size])
-            if np.sum(sub_row_patt) == 0:
-                continue
-            if str(sub_row_patt) not in patt:
-                patt[str(sub_row_patt)] = row
-            else:
-                state[row, :] ^= state[patt[str(sub_row_patt)], :]
-                circuit.append([patt[str(sub_row_patt)], row])
-        # Use gaussian elimination for remaining entries in column section
-        for col in range((sec - 1) * section_size, sec * section_size):
-            # Check if 1 on diagonal
-            diag_one = 1
-            if state[col, col] == 0:
-                diag_one = 0
-            # Remove ones in rows below column col
-            for row in range(col + 1, num_qubits):
-                if state[row, col] == 1:
-                    if diag_one == 0:
-                        state[col, :] ^= state[row, :]
-                        circuit.append([row, col])
-                        diag_one = 1
-                    state[row, :] ^= state[col, :]
-                    circuit.append([col, row])
-                # Back reduce the pivot row using the current row
-                if sum(state[col, :] & state[row, :]) > cutoff:
-                    state[col, :] ^= state[row, :]
-                    circuit.append([row, col])
-    return [state, circuit]
+    # construct circuit from the data
+    return QuantumCircuit._from_circuit_data(circuit_data)