qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/permutation/permutation_reverse_lnn.py

@@ -0,0 +1,93 @@
+# 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.
+"""
+Synthesis of a reverse permutation for LNN connectivity.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import (
+    synth_permutation_reverse_lnn_kms as synth_permutation_reverse_lnn_kms_inner,
+)
+
+
+def _append_cx_stage1(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i, 2 * i + 1)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 2, 2 * i + 1)
+    return qc
+
+
+def _append_cx_stage2(qc, n):
+    """A single layer of CX gates."""
+    for i in range(n // 2):
+        qc.cx(2 * i + 1, 2 * i)
+    for i in range((n + 1) // 2 - 1):
+        qc.cx(2 * i + 1, 2 * i + 2)
+    return qc
+
+
+def _append_reverse_permutation_lnn_kms(qc: QuantumCircuit, num_qubits: int) -> None:
+    """
+    Append reverse permutation to a QuantumCircuit for linear nearest-neighbor architectures
+    using Kutin, Moulton, Smithline method.
+
+    Synthesis algorithm for reverse permutation from [1], section 5.
+    This algorithm synthesizes the reverse permutation on :math:`n` qubits over
+    a linear nearest-neighbor architecture using CX gates with depth :math:`2 * n + 2`.
+
+    Args:
+        qc: The original quantum circuit.
+        num_qubits: The number of qubits.
+
+    Returns:
+        The quantum circuit with appended reverse permutation.
+
+    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>`_
+    """
+
+    for _ in range((num_qubits + 1) // 2):
+        _append_cx_stage1(qc, num_qubits)
+        _append_cx_stage2(qc, num_qubits)
+    if (num_qubits % 2) == 0:
+        _append_cx_stage1(qc, num_qubits)
+
+
+def synth_permutation_reverse_lnn_kms(num_qubits: int) -> QuantumCircuit:
+    """
+    Synthesize reverse permutation for linear nearest-neighbor architectures using
+    Kutin, Moulton, Smithline method.
+
+    Synthesis algorithm for reverse permutation from [1], section 5.
+    This algorithm synthesizes the reverse permutation on :math:`n` qubits over
+    a linear nearest-neighbor architecture using CX gates with depth :math:`2 * n + 2`.
+
+    Args:
+        num_qubits: The number of qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    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>`_
+    """
+
+    # Call Rust implementation
+    return QuantumCircuit._from_circuit_data(
+        synth_permutation_reverse_lnn_kms_inner(num_qubits), add_regs=True
+    )

qiskit/synthesis/permutation/permutation_utils.py

@@ -0,0 +1,16 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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 permutations."""
+
+# pylint: disable=unused-import
+from qiskit._accelerate.synthesis.permutation import _inverse_pattern, _validate_permutation

qiskit/synthesis/qft/__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""Module containing stabilizer QFT circuit synthesis."""
+
+from .qft_decompose_lnn import synth_qft_line
+from .qft_decompose_full import synth_qft_full

qiskit/synthesis/qft/qft_decompose_full.py

@@ -0,0 +1,97 @@
+# 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.
+"""
+Circuit synthesis for a QFT circuit.
+"""
+
+from __future__ import annotations
+import warnings
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+
+def synth_qft_full(
+    num_qubits: int,
+    do_swaps: bool = True,
+    approximation_degree: int = 0,
+    insert_barriers: bool = False,
+    inverse: bool = False,
+    name: str | None = None,
+) -> QuantumCircuit:
+    """Construct a circuit for the Quantum Fourier Transform using all-to-all connectivity.
+
+    .. note::
+
+        With the default value of ``do_swaps = True``, this synthesis algorithm creates a
+        circuit that faithfully implements the QFT operation. This circuit contains a sequence
+        of swap gates at the end, corresponding to reversing the order of its output qubits.
+        In some applications this reversal permutation can be avoided. Setting ``do_swaps = False``
+        creates a circuit without this reversal permutation, at the expense that this circuit
+        implements the "QFT-with-reversal" instead of QFT. Alternatively, the
+        :class:`~.ElidePermutations` transpiler pass is able to remove these swap gates.
+
+    Args:
+        num_qubits: The number of qubits on which the Quantum Fourier Transform acts.
+        do_swaps: Whether to synthesize the "QFT" or the "QFT-with-reversal" operation.
+        approximation_degree: The degree of approximation (0 for no approximation).
+            It is possible to implement the QFT approximately by ignoring
+            controlled-phase rotations with the angle beneath a threshold. This is discussed
+            in more detail in https://arxiv.org/abs/quant-ph/9601018 or
+            https://arxiv.org/abs/quant-ph/0403071.
+        insert_barriers: If ``True``, barriers are inserted for improved visualization.
+        inverse: If ``True``, the inverse Quantum Fourier Transform is constructed.
+        name: The name of the circuit.
+
+    Returns:
+        A circuit implementing the QFT operation.
+
+    """
+    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
+    circuit = QuantumCircuit(num_qubits, name=name)
+
+    for j in reversed(range(num_qubits)):
+        circuit.h(j)
+        num_entanglements = max(0, j - max(0, approximation_degree - (num_qubits - j - 1)))
+        for k in reversed(range(j - num_entanglements, j)):
+            # Use negative exponents so that the angle safely underflows to zero, rather than
+            # using a temporary variable that overflows to infinity in the worst case.
+            lam = np.pi * (2.0 ** (k - j))
+            circuit.cp(lam, j, k)
+
+        if insert_barriers:
+            circuit.barrier()
+
+    if do_swaps:
+        for i in range(num_qubits // 2):
+            circuit.swap(i, num_qubits - i - 1)
+
+    if inverse:
+        circuit = circuit.inverse()
+
+    return circuit
+
+
+def _warn_if_precision_loss(max_num_entanglements):
+    """Issue a warning if constructing the circuit will lose precision.
+
+    If we need an angle smaller than ``pi * 2**-1022``, we start to lose precision by going into
+    the subnormal numbers.  We won't lose _all_ precision until an exponent of about 1075, but
+    beyond 1022 we're using fractional bits to represent leading zeros.
+    """
+    if max_num_entanglements > -np.finfo(float).minexp:  # > 1022 for doubles.
+        warnings.warn(
+            "precision loss in QFT."
+            f" The rotation needed to represent {max_num_entanglements} entanglements"
+            " is smaller than the smallest normal floating-point number.",
+            category=RuntimeWarning,
+            stacklevel=4,
+        )

qiskit/synthesis/qft/qft_decompose_lnn.py

@@ -0,0 +1,61 @@
+# 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.
+"""
+Circuit synthesis for a QFT circuit.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.synthesis.qft import synth_qft_line as _synth_qft_line
+
+from .qft_decompose_full import _warn_if_precision_loss
+
+
+def synth_qft_line(
+    num_qubits: int, do_swaps: bool = True, approximation_degree: int = 0
+) -> QuantumCircuit:
+    """Construct a circuit for the Quantum Fourier Transform using linear
+    neighbor connectivity.
+
+    The construction is based on Fig 2.b in Fowler et al. [1].
+
+    .. note::
+
+        With the default value of ``do_swaps = True``, this synthesis algorithm creates a
+        circuit that faithfully implements the QFT operation. When ``do_swaps = False``,
+        this synthesis algorithm creates a circuit that corresponds to "QFT-with-reversal":
+        applying the QFT and reversing the order of its output qubits.
+
+    Args:
+        num_qubits: The number of qubits on which the Quantum Fourier Transform acts.
+        approximation_degree: The degree of approximation (0 for no approximation).
+            It is possible to implement the QFT approximately by ignoring
+            controlled-phase rotations with the angle beneath a threshold. This is discussed
+            in more detail in https://arxiv.org/abs/quant-ph/9601018 or
+            https://arxiv.org/abs/quant-ph/0403071.
+        do_swaps: Whether to synthesize the "QFT" or the "QFT-with-reversal" operation.
+
+    Returns:
+        A circuit implementing the QFT operation.
+
+    References:
+        1. A. G. Fowler, S. J. Devitt, and L. C. L. Hollenberg,
+           *Implementation of Shor's algorithm on a linear nearest neighbour qubit array*,
+           Quantum Info. Comput. 4, 4 (July 2004), 237–251.
+           `arXiv:quant-ph/0402196 [quant-ph] <https://arxiv.org/abs/quant-ph/0402196>`_
+    """
+    _warn_if_precision_loss(num_qubits - approximation_degree - 1)
+
+    return QuantumCircuit._from_circuit_data(
+        # From rust
+        _synth_qft_line(num_qubits, do_swaps, approximation_degree),
+        add_regs=True,
+    )

qiskit/synthesis/stabilizer/__init__.py

@@ -0,0 +1,16 @@
+# 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.
+
+"""Module containing stabilizer state preparation circuit synthesis."""
+
+from .stabilizer_decompose import synth_stabilizer_layers, synth_stabilizer_depth_lnn
+from .stabilizer_circuit import synth_circuit_from_stabilizers

qiskit/synthesis/stabilizer/stabilizer_circuit.py

@@ -0,0 +1,149 @@
+# 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.
+"""
+Stabilizer to circuit function
+"""
+from __future__ import annotations
+
+from collections.abc import Collection
+
+import numpy as np
+
+from qiskit.quantum_info import PauliList
+from qiskit.exceptions import QiskitError
+from qiskit.circuit import QuantumCircuit
+from qiskit.quantum_info.operators.symplectic.clifford import Clifford
+
+
+def synth_circuit_from_stabilizers(
+    stabilizers: Collection[str],
+    allow_redundant: bool = False,
+    allow_underconstrained: bool = False,
+    invert: bool = False,
+) -> QuantumCircuit:
+    # pylint: disable=line-too-long
+    """Synthesis of a circuit that generates a state stabilized by the stabilizers
+    using Gaussian elimination with Clifford gates.
+    If the stabilizers are underconstrained, and ``allow_underconstrained`` is ``True``,
+    the circuit will output one of the states stabilized by the stabilizers.
+    Based on stim implementation.
+
+    Args:
+        stabilizers: List of stabilizer strings
+        allow_redundant: Allow redundant stabilizers (i.e., some stabilizers
+            can be products of the others)
+        allow_underconstrained: Allow underconstrained set of stabilizers (i.e.,
+            the stabilizers do not specify a unique state)
+        invert: Return inverse circuit
+
+    Returns:
+        A circuit that generates a state stabilized by ``stabilizers``.
+
+    Raises:
+        QiskitError: if the stabilizers are invalid, do not commute, or contradict each other,
+                     if the list is underconstrained and ``allow_underconstrained`` is ``False``,
+                     or if the list is redundant and ``allow_redundant`` is ``False``.
+
+    References:
+        1. https://github.com/quantumlib/Stim/blob/c0dd0b1c8125b2096cd54b6f72884a459e47fe3e/src/stim/stabilizers/conversions.inl#L469
+        2. https://quantumcomputing.stackexchange.com/questions/12721/how-to-calculate-destabilizer-group-of-toric-and-other-codes
+
+    """
+    stabilizer_list = PauliList(stabilizers)
+    if np.any(stabilizer_list.phase % 2):
+        raise QiskitError("Some stabilizers have an invalid phase")
+    if len(stabilizer_list.commutes_with_all(stabilizer_list)) < len(stabilizer_list):
+        raise QiskitError("Some stabilizers do not commute.")
+
+    num_qubits = stabilizer_list.num_qubits
+    circuit = QuantumCircuit(num_qubits)
+
+    used = 0
+    for i, stabilizer in enumerate(stabilizer_list):
+        curr_stab = stabilizer.evolve(Clifford(circuit), frame="s")
+
+        # Find pivot.
+        pivot = used
+        while pivot < num_qubits:
+            if curr_stab[pivot].x or curr_stab[pivot].z:
+                break
+            pivot += 1
+
+        if pivot == num_qubits:
+            if curr_stab.x.any():
+                raise QiskitError(
+                    f"Stabilizer {i} ({stabilizer}) anti-commutes with some of "
+                    "the previous stabilizers."
+                )
+            if curr_stab.phase == 2:
+                raise QiskitError(
+                    f"Stabilizer {i} ({stabilizer}) contradicts "
+                    "some of the previous stabilizers."
+                )
+            if curr_stab.z.any() and not allow_redundant:
+                raise QiskitError(
+                    f"Stabilizer {i} ({stabilizer}) is a product of the others "
+                    "and allow_redundant is False. Add allow_redundant=True "
+                    "to the function call if you want to allow redundant stabilizers."
+                )
+            continue
+
+        # Change pivot basis to the Z axis.
+        if curr_stab[pivot].x:
+            if curr_stab[pivot].z:
+                circuit.h(pivot)
+                circuit.s(pivot)
+                circuit.h(pivot)
+                circuit.s(pivot)
+                circuit.s(pivot)
+            else:
+                circuit.h(pivot)
+
+        # Cancel other terms in Pauli string.
+        for j in range(num_qubits):
+            if j == pivot or not (curr_stab[j].x or curr_stab[j].z):
+                continue
+            p = curr_stab[j].x + curr_stab[j].z * 2
+            if p == 1:  # X
+                circuit.h(pivot)
+                circuit.cx(pivot, j)
+                circuit.h(pivot)
+            elif p == 2:  # Z
+                circuit.cx(j, pivot)
+            elif p == 3:  # Y
+                circuit.h(pivot)
+                circuit.s(j)
+                circuit.s(j)
+                circuit.s(j)
+                circuit.cx(pivot, j)
+                circuit.h(pivot)
+                circuit.s(j)
+
+        # Move pivot to diagonal.
+        if pivot != used:
+            circuit.swap(pivot, used)
+
+        # fix sign
+        curr_stab = stabilizer.evolve(Clifford(circuit), frame="s")
+        if curr_stab.phase == 2:
+            circuit.x(used)
+        used += 1
+
+    if used < num_qubits and not allow_underconstrained:
+        raise QiskitError(
+            "Stabilizers are underconstrained and allow_underconstrained is False."
+            " Add allow_underconstrained=True  to the function call "
+            "if you want to allow underconstrained stabilizers."
+        )
+    if invert:
+        return circuit
+    return circuit.inverse()

qiskit/synthesis/stabilizer/stabilizer_decompose.py

@@ -0,0 +1,194 @@
+# 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.
+"""
+Circuit synthesis for a stabilizer state preparation circuit.
+"""
+# pylint: disable=invalid-name
+
+from __future__ import annotations
+
+from collections.abc import Callable
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.states import StabilizerState
+from qiskit.synthesis.linear.linear_matrix_utils import (
+    calc_inverse_matrix,
+)
+from qiskit.synthesis.linear_phase import synth_cz_depth_line_mr
+from qiskit.synthesis.clifford.clifford_decompose_layers import (
+    _default_cz_synth_func,
+    _reverse_clifford,
+    _create_graph_state,
+    _decompose_graph_state,
+)
+
+
+def synth_stabilizer_layers(
+    stab: StabilizerState,
+    cz_synth_func: Callable[[np.ndarray], QuantumCircuit] = _default_cz_synth_func,
+    cz_func_reverse_qubits: bool = False,
+    validate: bool = False,
+) -> QuantumCircuit:
+    """Synthesis of a stabilizer state into layers.
+
+    It provides a similar decomposition to the synthesis described in Lemma 8 of reference [1],
+    without the initial Hadamard-free sub-circuit which do not affect the stabilizer state.
+
+    For example, a 5-qubit stabilizer state is decomposed into the following layers:
+
+    .. code-block:: text
+
+             ┌─────┐┌─────┐┌─────┐┌─────┐┌────────┐
+        q_0: ┤0    ├┤0    ├┤0    ├┤0    ├┤0       ├
+             │     ││     ││     ││     ││        │
+        q_1: ┤1    ├┤1    ├┤1    ├┤1    ├┤1       ├
+             │     ││     ││     ││     ││        │
+        q_2: ┤2 H2 ├┤2 S1 ├┤2 CZ ├┤2 H1 ├┤2 Pauli ├
+             │     ││     ││     ││     ││        │
+        q_3: ┤3    ├┤3    ├┤3    ├┤3    ├┤3       ├
+             │     ││     ││     ││     ││        │
+        q_4: ┤4    ├┤4    ├┤4    ├┤4    ├┤4       ├
+             └─────┘└─────┘└─────┘└─────┘└────────┘
+
+    Args:
+        stab: A stabilizer state.
+        cz_synth_func: A function to decompose the CZ sub-circuit.
+            It gets as input a boolean symmetric matrix, and outputs a :class:`.QuantumCircuit`.
+        cz_func_reverse_qubits: ``True`` only if ``cz_synth_func`` is
+            :func:`.synth_cz_depth_line_mr`,
+            since this function returns a circuit that reverts the order of qubits.
+        validate: If ``True``, validates the synthesis process.
+
+    Returns:
+        A circuit implementation of the stabilizer state.
+
+    Raises:
+        QiskitError: if the input is not a :class:`.StabilizerState`.
+
+    References:
+        1. S. Bravyi, D. Maslov, *Hadamard-free circuits expose the
+           structure of the Clifford group*,
+           `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
+    """
+
+    if not isinstance(stab, StabilizerState):
+        raise QiskitError("The input is not a StabilizerState.")
+
+    cliff = stab.clifford
+    num_qubits = cliff.num_qubits
+
+    if cz_func_reverse_qubits:
+        cliff0 = _reverse_clifford(cliff)
+    else:
+        cliff0 = cliff
+
+    H1_circ, cliff1 = _create_graph_state(cliff0, validate=validate)
+
+    H2_circ, CZ1_circ, S1_circ, _ = _decompose_graph_state(
+        cliff1, validate=validate, cz_synth_func=cz_synth_func
+    )
+
+    qubit_list = list(range(num_qubits))
+    layeredCircuit = QuantumCircuit(num_qubits)
+
+    layeredCircuit.append(H2_circ, qubit_list)
+    layeredCircuit.append(S1_circ, qubit_list)
+    layeredCircuit.append(CZ1_circ, qubit_list)
+
+    if cz_func_reverse_qubits:
+        H1_circ = H1_circ.reverse_bits()
+    layeredCircuit.append(H1_circ, qubit_list)
+
+    # Add Pauli layer to fix the Clifford phase signs
+    # pylint: disable=cyclic-import
+    from qiskit.quantum_info.operators.symplectic import Clifford
+
+    clifford_target = Clifford(layeredCircuit)
+    pauli_circ = _calc_pauli_diff_stabilizer(cliff, clifford_target)
+    layeredCircuit.append(pauli_circ, qubit_list)
+
+    return layeredCircuit
+
+
+def _calc_pauli_diff_stabilizer(cliff, cliff_target):
+    """Given two Cliffords whose stabilizers differ by a Pauli, we find this Pauli."""
+
+    # pylint: disable=cyclic-import
+    from qiskit.quantum_info.operators.symplectic import Pauli
+
+    num_qubits = cliff.num_qubits
+    if cliff.num_qubits != cliff_target.num_qubits:
+        raise QiskitError("num_qubits is not the same for the original clifford and the target.")
+
+    # stabilizer generators of the original clifford
+    stab_gen = StabilizerState(cliff).clifford.to_dict()["stabilizer"]
+
+    # stabilizer state of the target clifford
+    ts = StabilizerState(cliff_target)
+
+    phase_destab = [False] * num_qubits
+    phase_stab = [ts.expectation_value(Pauli(stab_gen[i])) == -1 for i in range(num_qubits)]
+
+    phase = []
+    phase.extend(phase_destab)
+    phase.extend(phase_stab)
+    phase = np.array(phase, dtype=int)
+
+    A = cliff.symplectic_matrix.astype(bool, copy=False)
+    Ainv = calc_inverse_matrix(A)
+
+    # By carefully writing how X, Y, Z gates affect each qubit, all we need to compute
+    # is A^{-1} * (phase)
+    C = np.matmul(Ainv, phase) % 2
+
+    # Create the Pauli
+    pauli_circ = QuantumCircuit(num_qubits, name="Pauli")
+    for k in range(num_qubits):
+        destab = C[k]
+        stab = C[k + num_qubits]
+        if stab and destab:
+            pauli_circ.y(k)
+        elif stab:
+            pauli_circ.x(k)
+        elif destab:
+            pauli_circ.z(k)
+
+    return pauli_circ
+
+
+def synth_stabilizer_depth_lnn(stab: StabilizerState) -> QuantumCircuit:
+    """Synthesis of an n-qubit stabilizer state for linear-nearest neighbor connectivity,
+    in 2-qubit depth :math:`2n+2` and two distinct CX layers, using :class:`.CXGate`\\ s and phase gates
+    (:class:`.SGate`, :class:`.SdgGate` or :class:`.ZGate`).
+
+    Args:
+        stab: A stabilizer state.
+
+    Returns:
+        A circuit implementation of the stabilizer state.
+
+    References:
+        1. S. Bravyi, D. Maslov, *Hadamard-free circuits expose the
+           structure of the Clifford group*,
+           `arXiv:2003.09412 [quant-ph] <https://arxiv.org/abs/2003.09412>`_
+        2. Dmitri Maslov, Martin Roetteler,
+           *Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations*,
+           `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+    """
+
+    circ = synth_stabilizer_layers(
+        stab,
+        cz_synth_func=synth_cz_depth_line_mr,
+        cz_func_reverse_qubits=True,
+    )
+    return circ

qiskit/synthesis/two_qubit/__init__.py

@@ -0,0 +1,20 @@
+# 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 two-qubit unitary synthesis methods."""
+
+from .two_qubit_decompose import (
+    TwoQubitBasisDecomposer,
+    two_qubit_cnot_decompose,
+    TwoQubitWeylDecomposition,
+    TwoQubitControlledUDecomposer,
+)