qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/linear/cnot_synth.py

@@ -0,0 +1,69 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+"""
+Implementation of the GraySynth algorithm for synthesizing CNOT-Phase
+circuits with efficient CNOT cost, and the Patel-Hayes-Markov algorithm
+for optimal synthesis of linear (CNOT-only) reversible circuits.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+
+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 | 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.
+
+    Args:
+        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:
+        A CX-only circuit implementing the linear transformation.
+
+    Raises:
+        ValueError: When ``section_size`` is larger than the number of columns.
+
+    References:
+        1. Patel, Ketan N., Igor L. Markov, and John P. Hayes,
+           *Optimal synthesis of linear reversible circuits*,
+           Quantum Information & Computation 8.3 (2008): 282-294.
+           `arXiv:quant-ph/0302002 [quant-ph] <https://arxiv.org/abs/quant-ph/0302002>`_
+    """
+    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]})."
+        )
+
+    # call Rust implementation with normalized input
+    circuit_data = fast_pmh(normalized, section_size)
+
+    # construct circuit from the data
+    return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)

qiskit/synthesis/linear/linear_circuits_utils.py

@@ -0,0 +1,128 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2022.
+#
+# 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.
+
+"""Utility functions for handling linear reversible circuits."""
+
+import copy
+from typing import Callable
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.circuit.exceptions import CircuitError
+from . import calc_inverse_matrix, check_invertible_binary_matrix
+
+
+def transpose_cx_circ(qc: QuantumCircuit):
+    """Takes a circuit having only CX gates, and calculates its transpose.
+    This is done by recursively replacing CX(i, j) with CX(j, i) in all instructions.
+
+    Args:
+        qc: a :class:`.QuantumCircuit` containing only CX gates.
+
+    Returns:
+        QuantumCircuit: the transposed circuit.
+
+    Raises:
+        CircuitError: if qc has a non-CX gate.
+    """
+    transposed_circ = QuantumCircuit(qc.qubits, qc.clbits, name=qc.name + "_transpose")
+    for instruction in reversed(qc.data):
+        if instruction.operation.name != "cx":
+            raise CircuitError("The circuit contains non-CX gates.")
+        transposed_circ._append(instruction.replace(qubits=reversed(instruction.qubits)))
+    return transposed_circ
+
+
+def optimize_cx_4_options(function: Callable, mat: np.ndarray, optimize_count: bool = True):
+    """Get the best implementation of a circuit implementing a binary invertible matrix M,
+    by considering all four options: M,M^(-1),M^T,M^(-1)^T.
+    Optimizing either the CX count or the depth.
+
+    Args:
+        function: the synthesis function.
+        mat: a binary invertible matrix.
+        optimize_count: True if the number of CX gates in optimize, False if the depth is optimized.
+
+    Returns:
+        QuantumCircuit: an optimized :class:`.QuantumCircuit`, has the best depth or CX count of
+            the four options.
+
+    Raises:
+        QiskitError: if mat is not an invertible matrix.
+    """
+    if not check_invertible_binary_matrix(mat):
+        raise QiskitError("The matrix is not invertible.")
+
+    qc = function(mat)
+    best_qc = qc
+    best_depth = qc.depth()
+    best_count = qc.count_ops()["cx"]
+
+    for i in range(1, 4):
+        mat_cpy = copy.deepcopy(mat)
+        # i=1 inverse, i=2 transpose, i=3 transpose and inverse
+        if i == 1:
+            mat_cpy = calc_inverse_matrix(mat_cpy)
+            qc = function(mat_cpy)
+            qc = qc.inverse()
+        elif i == 2:
+            mat_cpy = np.transpose(mat_cpy)
+            qc = function(mat_cpy)
+            qc = transpose_cx_circ(qc)
+        elif i == 3:
+            mat_cpy = calc_inverse_matrix(np.transpose(mat_cpy))
+            qc = function(mat_cpy)
+            qc = transpose_cx_circ(qc)
+            qc = qc.inverse()
+
+        new_depth = qc.depth()
+        new_count = qc.count_ops()["cx"]
+        # Prioritize count, and if it has the same count, then also consider depth
+        better_count = (optimize_count and best_count > new_count) or (
+            not optimize_count and best_depth == new_depth and best_count > new_count
+        )
+        # Prioritize depth, and if it has the same depth, then also consider count
+        better_depth = (not optimize_count and best_depth > new_depth) or (
+            optimize_count and best_count == new_count and best_depth > new_depth
+        )
+
+        if better_count or better_depth:
+            best_count = new_count
+            best_depth = new_depth
+            best_qc = qc
+
+    return best_qc
+
+
+def check_lnn_connectivity(qc: QuantumCircuit) -> bool:
+    """Check that the synthesized circuit qc fits linear nearest neighbor connectivity.
+
+    Args:
+        qc: a :class:`.QuantumCircuit` containing only CX and single qubit gates.
+
+    Returns:
+        bool: True if the circuit has linear nearest neighbor connectivity.
+
+    Raises:
+        CircuitError: if qc has a non-CX two-qubit gate.
+    """
+    for instruction in qc.data:
+        if instruction.operation.num_qubits > 1:
+            if instruction.operation.name == "cx":
+                q0 = qc.find_bit(instruction.qubits[0]).index
+                q1 = qc.find_bit(instruction.qubits[1]).index
+                dist = abs(q0 - q1)
+                if dist != 1:
+                    return False
+            else:
+                raise CircuitError("The circuit has two-qubits gates different than CX.")
+    return True

qiskit/synthesis/linear/linear_depth_lnn.py

@@ -0,0 +1,61 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2022, 2024.
+#
+# 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.
+
+"""
+Optimize the synthesis of an n-qubit circuit contains only CX gates for
+linear nearest neighbor (LNN) connectivity.
+The depth of the circuit is bounded by 5*n, while the gate count is approximately 2.5*n^2
+
+References:
+    [1]: Kutin, S., Moulton, D. P., Smithline, L. (2007).
+         Computation at a Distance.
+         `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_.
+"""
+
+from __future__ import annotations
+import numpy as np
+from qiskit.exceptions import QiskitError
+from qiskit.circuit import QuantumCircuit
+from qiskit.synthesis.linear.linear_matrix_utils import check_invertible_binary_matrix
+from qiskit._accelerate.synthesis.linear import py_synth_cnot_depth_line_kms as fast_kms
+
+
+def synth_cnot_depth_line_kms(mat: np.ndarray[bool]) -> QuantumCircuit:
+    """
+    Synthesize linear reversible circuit for linear nearest-neighbor architectures using
+    Kutin, Moulton, Smithline method.
+
+    Synthesis algorithm for linear reversible circuits from [1], section 7.
+    This algorithm synthesizes any linear reversible circuit of :math:`n` qubits over
+    a linear nearest-neighbor architecture using CX gates with depth at most :math:`5n`.
+
+    Args:
+        mat: A boolean invertible matrix.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    Raises:
+        QiskitError: if ``mat`` is not invertible.
+
+    References:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+    """
+    if not check_invertible_binary_matrix(mat):
+        raise QiskitError("The input matrix is not invertible.")
+
+    circuit_data = fast_kms(mat)
+
+    # construct circuit from the data
+    return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)

qiskit/synthesis/linear/linear_matrix_utils.py

@@ -0,0 +1,27 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2022.
+#
+# 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.
+
+"""Utility functions for handling binary matrices."""
+
+# pylint: disable=unused-import
+from qiskit._accelerate.synthesis.linear import (
+    gauss_elimination,
+    gauss_elimination_with_perm,
+    compute_rank_after_gauss_elim,
+    compute_rank,
+    calc_inverse_matrix,
+    binary_matmul,
+    random_invertible_binary_matrix,
+    check_invertible_binary_matrix,
+    row_op,
+    col_op,
+)

qiskit/synthesis/linear_phase/__init__.py

@@ -0,0 +1,17 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017 - 2023.
+#
+# 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.
+
+"""Module containing cnot-phase circuits"""
+
+from .cz_depth_lnn import synth_cz_depth_line_mr
+from .cx_cz_depth_lnn import synth_cx_cz_depth_line_my
+from .cnot_phase_synth import synth_cnot_phase_aam

qiskit/synthesis/linear_phase/cnot_phase_synth.py

@@ -0,0 +1,206 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# 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.
+
+"""
+Implementation of the GraySynth algorithm for synthesizing CNOT-Phase
+circuits with efficient CNOT cost, and the Patel-Hayes-Markov algorithm
+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.synthesis.linear import synth_cnot_count_full_pmh
+
+
+def synth_cnot_phase_aam(
+    cnots: list[list[int]], angles: list[str], section_size: int = 2
+) -> QuantumCircuit:
+    r"""This function is an implementation of the `GraySynth` algorithm of
+    Amy, Azimadeh and Mosca.
+
+    GraySynth is a heuristic algorithm from [1] for synthesizing small parity networks.
+    It is inspired by Gray codes. Given a set of binary strings :math:`S`
+    (called ``cnots`` bellow), the algorithm synthesizes a parity network for :math:`S` by
+    repeatedly choosing an index :math:`i` to expand and then effectively recursing on
+    the co-factors :math:`S_0` and :math:`S_1`, consisting of the strings :math:`y \in S`,
+    with :math:`y_i = 0` or :math:`1` respectively. As a subset :math:`S` is recursively expanded,
+    ``cx`` gates are applied so that a designated target bit contains the
+    (partial) parity :math:`\chi_y(x)` where :math:`y_i = 1` if and only if :math:`y'_i = 1` for all
+    :math:`y' \in S`. If :math:`S` contains a single element :math:`\{y'\}`, then :math:`y = y'`,
+    and the target bit contains the value :math:`\chi_{y'}(x)` as desired.
+
+    Notably, rather than uncomputing this sequence of ``cx`` (CNOT) gates when a subset :math:`S`
+    is finished being synthesized, the algorithm maintains the invariant
+    that the remaining parities to be computed are expressed over the current state
+    of bits. This allows the algorithm to avoid the 'backtracking' inherent in
+    uncomputing-based methods.
+
+    The algorithm is described in detail in section 4 of [1].
+
+    Args:
+        cnots: A matrix whose columns are the parities to be synthesized
+            e.g.::
+
+                [[0, 1, 1, 1, 1, 1],
+                 [1, 0, 0, 1, 1, 1],
+                 [1, 0, 0, 1, 0, 0],
+                 [0, 0, 1, 0, 1, 0]]
+
+            corresponds to::
+
+                 x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1
+
+        angles: A list containing all the phase-shift gates which are
+            to be applied, in the same order as in ``cnots``. A number is
+            interpreted as the angle of :math:`p(angle)`, otherwise the elements
+            have to be ``'t'``, ``'tdg'``, ``'s'``, ``'sdg'`` or ``'z'``.
+
+        section_size: The size of every section in the Patel–Markov–Hayes algorithm.
+            ``section_size`` must be a factor of the number of qubits.
+
+    Returns:
+        The decomposed quantum circuit.
+
+    Raises:
+        QiskitError: when dimensions of ``cnots`` and ``angles`` don't align.
+
+    References:
+        1. Matthew Amy, Parsiad Azimzadeh, and Michele Mosca.
+           *On the controlled-NOT complexity of controlled-NOT–phase circuits.*,
+           Quantum Science and Technology 4.1 (2018): 015002.
+           `arXiv:1712.01859 <https://arxiv.org/abs/1712.01859>`_
+    """
+    num_qubits = len(cnots)
+
+    # Create a quantum circuit on num_qubits
+    qcir = QuantumCircuit(num_qubits)
+
+    if len(cnots[0]) != len(angles):
+        raise QiskitError('Size of "cnots" and "angles" do not match.')
+
+    range_list = list(range(num_qubits))
+    epsilon = num_qubits
+    sta = []
+    cnots_copy = np.transpose(np.array(copy.deepcopy(cnots)))
+    # This matrix keeps track of the state in the algorithm
+    state = np.eye(num_qubits).astype("int")
+
+    # Check if some phase-shift gates can be applied, before adding any C-NOT gates
+    for qubit in range(num_qubits):
+        index = 0
+        for icnots in cnots_copy:
+            if np.array_equal(icnots, state[qubit]):
+                if angles[index] == "t":
+                    qcir.t(qubit)
+                elif angles[index] == "tdg":
+                    qcir.tdg(qubit)
+                elif angles[index] == "s":
+                    qcir.s(qubit)
+                elif angles[index] == "sdg":
+                    qcir.sdg(qubit)
+                elif angles[index] == "z":
+                    qcir.z(qubit)
+                else:
+                    qcir.p(angles[index] % np.pi, qubit)
+                del angles[index]
+                cnots_copy = np.delete(cnots_copy, index, axis=0)
+                if index == len(cnots_copy):
+                    break
+                index -= 1
+            index += 1
+
+    # Implementation of the pseudo-code (Algorithm 1) in the aforementioned paper
+    sta.append([cnots, range_list, epsilon])
+    while sta:
+        [cnots, ilist, qubit] = sta.pop()
+        if cnots == []:
+            continue
+        if 0 <= qubit < num_qubits:
+            condition = True
+            while condition:
+                condition = False
+                for j in range(num_qubits):
+                    if (j != qubit) and (sum(cnots[j]) == len(cnots[j])):
+                        condition = True
+                        qcir.cx(j, qubit)
+                        state[qubit] ^= state[j]
+                        index = 0
+                        for icnots in cnots_copy:
+                            if np.array_equal(icnots, state[qubit]):
+                                if angles[index] == "t":
+                                    qcir.t(qubit)
+                                elif angles[index] == "tdg":
+                                    qcir.tdg(qubit)
+                                elif angles[index] == "s":
+                                    qcir.s(qubit)
+                                elif angles[index] == "sdg":
+                                    qcir.sdg(qubit)
+                                elif angles[index] == "z":
+                                    qcir.z(qubit)
+                                else:
+                                    qcir.p(angles[index] % np.pi, qubit)
+                                del angles[index]
+                                cnots_copy = np.delete(cnots_copy, index, axis=0)
+                                if index == len(cnots_copy):
+                                    break
+                                index -= 1
+                            index += 1
+                        for x in _remove_duplicates(sta + [[cnots, ilist, qubit]]):
+                            [cnotsp, _, _] = x
+                            if cnotsp == []:
+                                continue
+                            for ttt in range(len(cnotsp[j])):
+                                cnotsp[j][ttt] ^= cnotsp[qubit][ttt]
+        if ilist == []:
+            continue
+        # See line 18 in pseudo-code of Algorithm 1 in the aforementioned paper
+        # this choice of j maximizes the size of the largest subset (S_0 or S_1)
+        # and the larger a subset, the closer it gets to the ideal in the
+        # Gray code of one CNOT per string.
+        j = ilist[np.argmax([[max(row.count(0), row.count(1)) for row in cnots][k] for k in ilist])]
+        cnots0 = []
+        cnots1 = []
+        for y in list(map(list, zip(*cnots))):
+            if y[j] == 0:
+                cnots0.append(y)
+            elif y[j] == 1:
+                cnots1.append(y)
+        cnots0 = list(map(list, zip(*cnots0)))
+        cnots1 = list(map(list, zip(*cnots1)))
+        if qubit == epsilon:
+            sta.append([cnots1, list(set(ilist).difference([j])), j])
+        else:
+            sta.append([cnots1, list(set(ilist).difference([j])), qubit])
+        sta.append([cnots0, list(set(ilist).difference([j])), qubit])
+    qcir &= synth_cnot_count_full_pmh(state, section_size).inverse()
+    return qcir
+
+
+def _remove_duplicates(lists):
+    """
+    Remove duplicates in list
+
+    Args:
+        lists (list): a list which may contain duplicate elements.
+
+    Returns:
+        list: a list which contains only unique elements.
+    """
+
+    unique_list = []
+    for element in lists:
+        if element not in unique_list:
+            unique_list.append(element)
+    return unique_list

qiskit/synthesis/linear_phase/cx_cz_depth_lnn.py

@@ -0,0 +1,61 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023-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.
+
+"""
+Given -CZ-CX- transformation (a layer consisting only CNOT gates
+    followed by a layer consisting only CZ gates)
+Return a depth-5n circuit implementation of the -CZ-CX- transformation over LNN.
+
+Args:
+    mat_z: n*n symmetric binary matrix representing a -CZ- circuit
+    mat_x: n*n invertable binary matrix representing a -CX- transformation
+
+Output:
+    QuantumCircuit: :class:`.QuantumCircuit` object containing a depth-5n circuit to implement -CZ-CX-
+
+References:
+    [1] S. A. Kutin, D. P. Moulton, and L. M. Smithline, "Computation at a distance," 2007.
+    [2] D. Maslov and W. Yang, "CNOT circuits need little help to implement arbitrary
+        Hadamard-free Clifford transformations they generate," 2022.
+"""
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.synthesis.linear_phase import py_synth_cx_cz_depth_line_my
+
+
+def synth_cx_cz_depth_line_my(mat_x: np.ndarray, mat_z: np.ndarray) -> QuantumCircuit:
+    """
+    Joint synthesis of a -CZ-CX- circuit for linear nearest neighbor (LNN) connectivity,
+    with 2-qubit depth at most 5n, based on Maslov and Yang.
+    This method computes the CZ circuit inside the CX circuit via phase gate insertions.
+
+    Args:
+        mat_z : a boolean symmetric matrix representing a CZ circuit.
+            ``mat_z[i][j]=1`` represents a ``cz(i,j)`` gate
+
+        mat_x : a boolean invertible matrix representing a CX circuit.
+
+    Returns:
+        A circuit implementation of a CX circuit following a CZ circuit,
+        denoted as a -CZ-CX- circuit,in two-qubit depth at most ``5n``, for LNN connectivity.
+
+    References:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+        2. Dmitri Maslov, Willers Yang, *CNOT circuits need little help to implement arbitrary
+           Hadamard-free Clifford transformations they generate*,
+           `arXiv:2210.16195 <https://arxiv.org/abs/2210.16195>`_.
+    """
+    circuit_data = py_synth_cx_cz_depth_line_my(mat_x.astype(bool), mat_z.astype(bool))
+    return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)

qiskit/synthesis/linear_phase/cz_depth_lnn.py

@@ -0,0 +1,58 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023
+#
+# 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.
+
+"""
+Synthesis of an n-qubit circuit containing only CZ gates for
+linear nearest neighbor (LNN) connectivity, using CX and phase (S, Sdg or Z) gates.
+The two-qubit depth of the circuit is bounded by 2*n+2.
+This algorithm reverts the order of qubits.
+
+References:
+    [1]: Dmitri Maslov, Martin Roetteler,
+         Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations,
+         `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+"""
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+
+from qiskit._accelerate.synthesis.linear_phase import (
+    synth_cz_depth_line_mr as synth_cz_depth_line_mr_inner,
+)
+
+
+def synth_cz_depth_line_mr(mat: np.ndarray) -> QuantumCircuit:
+    r"""Synthesis of a CZ circuit for linear nearest neighbor (LNN) connectivity,
+    based on Maslov and Roetteler.
+
+    Note that this method *reverts* the order of qubits in the circuit,
+    and returns a circuit containing :class:`.CXGate`\s and phase gates
+    (:class:`.SGate`, :class:`.SdgGate` or :class:`.ZGate`).
+
+    Args:
+        mat: an upper-diagonal matrix representing the CZ circuit.
+            ``mat[i][j]=1 for i<j`` represents a ``cz(i,j)`` gate
+
+    Returns:
+        A circuit implementation of the CZ circuit of depth :math:`2n+2` for LNN
+        connectivity.
+
+    References:
+        1. Dmitri Maslov, Martin Roetteler,
+           *Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations*,
+           `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+    """
+
+    # Call Rust implementaton
+    return QuantumCircuit._from_circuit_data(
+        synth_cz_depth_line_mr_inner(mat.astype(bool)), add_regs=True
+    )

qiskit/synthesis/multi_controlled/__init__.py

@@ -0,0 +1,25 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2024.
+#
+# 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.
+
+"""Module containing multi-controlled circuits synthesis"""
+
+from .mcmt_vchain import synth_mcmt_vchain
+from .mcx_synthesis import (
+    synth_mcx_n_dirty_i15,
+    synth_mcx_n_clean_m15,
+    synth_mcx_1_clean_b95,
+    synth_mcx_gray_code,
+    synth_mcx_noaux_v24,
+    synth_c3x,
+    synth_c4x,
+)
+from .multi_control_rotation_gates import _apply_cu, _apply_mcu_graycode, _mcsu2_real_diagonal