qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/multi_controlled/multi_control_rotation_gates.py

@@ -0,0 +1,205 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2018, 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.
+"""
+Multiple-Controlled U3 gate utilities. Not using ancillary qubits.
+"""
+
+import math
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit, Gate
+from qiskit.circuit.library.standard_gates.u3 import _generate_gray_code
+from qiskit.exceptions import QiskitError
+
+
+def _apply_cu(circuit, theta, phi, lam, control, target, use_basis_gates=True):
+    if use_basis_gates:
+        #          ┌──────────────┐
+        # control: ┤ P(λ/2 + φ/2) ├──■──────────────────────────────────■────────────────
+        #          ├──────────────┤┌─┴─┐┌────────────────────────────┐┌─┴─┐┌────────────┐
+        #  target: ┤ P(λ/2 - φ/2) ├┤ X ├┤ U(-0.5*0,0,-0.5*λ - 0.5*φ) ├┤ X ├┤ U(0/2,φ,0) ├
+        #          └──────────────┘└───┘└────────────────────────────┘└───┘└────────────┘
+        circuit.p((lam + phi) / 2, [control])
+        circuit.p((lam - phi) / 2, [target])
+        circuit.cx(control, target)
+        circuit.u(-theta / 2, 0, -(phi + lam) / 2, [target])
+        circuit.cx(control, target)
+        circuit.u(theta / 2, phi, 0, [target])
+    else:
+        circuit.cu(theta, phi, lam, 0, control, target)
+
+
+def _apply_mcu_graycode(circuit, theta, phi, lam, ctls, tgt, use_basis_gates):
+    """Apply multi-controlled u gate from ctls to tgt using graycode
+    pattern with single-step angles theta, phi, lam."""
+
+    n = len(ctls)
+
+    gray_code = _generate_gray_code(n)
+    last_pattern = None
+
+    for pattern in gray_code:
+        if "1" not in pattern:
+            continue
+        if last_pattern is None:
+            last_pattern = pattern
+        # find left most set bit
+        lm_pos = list(pattern).index("1")
+
+        # find changed bit
+        comp = [i != j for i, j in zip(pattern, last_pattern)]
+        if True in comp:
+            pos = comp.index(True)
+        else:
+            pos = None
+        if pos is not None:
+            if pos != lm_pos:
+                circuit.cx(ctls[pos], ctls[lm_pos])
+            else:
+                indices = [i for i, x in enumerate(pattern) if x == "1"]
+                for idx in indices[1:]:
+                    circuit.cx(ctls[idx], ctls[lm_pos])
+        # check parity and undo rotation
+        if pattern.count("1") % 2 == 0:
+            # inverse CU: u(theta, phi, lamb)^dagger = u(-theta, -lam, -phi)
+            _apply_cu(
+                circuit, -theta, -lam, -phi, ctls[lm_pos], tgt, use_basis_gates=use_basis_gates
+            )
+        else:
+            _apply_cu(circuit, theta, phi, lam, ctls[lm_pos], tgt, use_basis_gates=use_basis_gates)
+        last_pattern = pattern
+
+
+def _mcsu2_real_diagonal(
+    gate: Gate,
+    num_controls: int,
+    use_basis_gates: bool = False,
+) -> QuantumCircuit:
+    """
+    Return a multi-controlled SU(2) gate [1]_ with a real main diagonal or secondary diagonal.
+
+    Args:
+        gate: SU(2) Gate whose unitary matrix has one real diagonal.
+        num_controls: The number of control qubits.
+        use_basis_gates: If ``True``, use ``[p, u, cx]`` gates to implement the decomposition.
+
+    Returns:
+        A :class:`.QuantumCircuit` implementing the multi-controlled SU(2) gate.
+
+    Raises:
+        QiskitError: If the input matrix is invalid.
+
+    References:
+
+        .. [1]: R. Vale et al. Decomposition of Multi-controlled Special Unitary Single-Qubit Gates
+            `arXiv:2302.06377 (2023) <https://arxiv.org/abs/2302.06377>`__
+
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.library.standard_gates import RXGate, RYGate, RZGate
+    from qiskit.circuit.library.generalized_gates import UnitaryGate
+    from qiskit.quantum_info.operators.predicates import is_unitary_matrix
+    from qiskit.compiler import transpile
+    from qiskit.synthesis.multi_controlled import synth_mcx_n_dirty_i15
+
+    if isinstance(gate, RYGate):
+        theta = gate.params[0]
+        s_gate = RYGate(-theta / 4)
+        is_secondary_diag_real = True
+    elif isinstance(gate, RZGate):
+        theta = gate.params[0]
+        s_gate = RZGate(-theta / 4)
+        is_secondary_diag_real = True
+    elif isinstance(gate, RXGate):
+        theta = gate.params[0]
+        s_gate = RZGate(-theta / 4)
+        is_secondary_diag_real = False
+
+    else:
+        unitary = gate.to_matrix()
+        if unitary.shape != (2, 2):
+            raise QiskitError(f"The unitary must be a 2x2 matrix, but has shape {unitary.shape}.")
+
+        if not is_unitary_matrix(unitary):
+            raise QiskitError(f"The unitary in must be an unitary matrix, but is {unitary}.")
+
+        if not np.isclose(1.0, np.linalg.det(unitary)):
+            raise QiskitError(
+                "Invalid Value _mcsu2_real_diagonal requires det(unitary) equal to one."
+            )
+
+        is_main_diag_real = np.isclose(unitary[0, 0].imag, 0.0) and np.isclose(
+            unitary[1, 1].imag, 0.0
+        )
+        is_secondary_diag_real = np.isclose(unitary[0, 1].imag, 0.0) and np.isclose(
+            unitary[1, 0].imag, 0.0
+        )
+
+        if not is_main_diag_real and not is_secondary_diag_real:
+            raise QiskitError("The unitary must have one real diagonal.")
+
+        if is_secondary_diag_real:
+            x = unitary[0, 1]
+            z = unitary[1, 1]
+        else:
+            x = -unitary[0, 1].real
+            z = unitary[1, 1] - unitary[0, 1].imag * 1.0j
+
+        if np.isclose(z, -1):
+            s_op = [[1.0, 0.0], [0.0, 1.0j]]
+        else:
+            alpha_r = math.sqrt((math.sqrt((z.real + 1.0) / 2.0) + 1.0) / 2.0)
+            alpha_i = z.imag / (
+                2.0 * math.sqrt((z.real + 1.0) * (math.sqrt((z.real + 1.0) / 2.0) + 1.0))
+            )
+            alpha = alpha_r + 1.0j * alpha_i
+            beta = x / (2.0 * math.sqrt((z.real + 1.0) * (math.sqrt((z.real + 1.0) / 2.0) + 1.0)))
+
+            # S gate definition
+            s_op = np.array([[alpha, -np.conj(beta)], [beta, np.conj(alpha)]])
+        s_gate = UnitaryGate(s_op)
+
+    k_1 = math.ceil(num_controls / 2.0)
+    k_2 = math.floor(num_controls / 2.0)
+
+    controls = list(range(num_controls))  # control indices, defined for code legibility
+    target = num_controls  # target index, defined for code legibility
+
+    mcx1 = synth_mcx_n_dirty_i15(num_ctrl_qubits=k_1)
+    mcx1_num_ancillas = mcx1.num_qubits - k_1 - 1
+    mcx1_qubits = controls[:k_1] + [target] + controls[k_1 : k_1 + mcx1_num_ancillas]
+
+    mcx2 = synth_mcx_n_dirty_i15(num_ctrl_qubits=k_2)
+    mcx2_num_ancillas = mcx2.num_qubits - k_2 - 1
+    mcx2_qubits = controls[k_1:] + [target] + controls[k_1 - mcx2_num_ancillas : k_1]
+
+    circuit = QuantumCircuit(num_controls + 1, name="MCSU2")
+
+    if not is_secondary_diag_real:
+        circuit.h(target)
+
+    circuit.compose(mcx1, mcx1_qubits, inplace=True)
+    circuit.append(s_gate, [target])
+    circuit.compose(mcx2, mcx2_qubits, inplace=True)
+    circuit.append(s_gate.inverse(), [target])
+    circuit.compose(mcx1, mcx1_qubits, inplace=True)
+    circuit.append(s_gate, [target])
+    circuit.compose(mcx2, mcx2_qubits, inplace=True)
+    circuit.append(s_gate.inverse(), [target])
+
+    if not is_secondary_diag_real:
+        circuit.h(target)
+
+    if use_basis_gates:
+        circuit = transpile(circuit, basis_gates=["p", "u", "cx"], qubits_initially_zero=False)
+
+    return circuit

qiskit/synthesis/one_qubit/__init__.py

@@ -0,0 +1,15 @@
+# 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 one qubit unitary synthesis methods."""
+
+from .one_qubit_decompose import OneQubitEulerDecomposer

qiskit/synthesis/one_qubit/one_qubit_decompose.py

@@ -0,0 +1,288 @@
+# 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.
+
+"""
+Decompose a single-qubit unitary via Euler angles.
+"""
+from __future__ import annotations
+from typing import TYPE_CHECKING
+import numpy as np
+
+from qiskit._accelerate import euler_one_qubit_decomposer
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit import Qubit
+from qiskit.circuit.library.standard_gates import (
+    UGate,
+    PhaseGate,
+    U3Gate,
+    U2Gate,
+    U1Gate,
+    RXGate,
+    RYGate,
+    RZGate,
+    RGate,
+    SXGate,
+    XGate,
+)
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info.operators.predicates import is_unitary_matrix
+from qiskit.circuit.gate import Gate
+from qiskit.quantum_info.operators.operator import Operator
+
+if TYPE_CHECKING:
+    from qiskit.dagcircuit import DAGCircuit
+
+DEFAULT_ATOL = 1e-12
+
+ONE_QUBIT_EULER_BASIS_GATES = {
+    "U3": ["u3"],
+    "U321": ["u3", "u2", "u1"],
+    "U": ["u"],
+    "PSX": ["p", "sx"],
+    "U1X": ["u1", "rx"],
+    "RR": ["r"],
+    "ZYZ": ["rz", "ry"],
+    "ZXZ": ["rz", "rx"],
+    "XZX": ["rz", "rx"],
+    "XYX": ["rx", "ry"],
+    "ZSXX": ["rz", "sx", "x"],
+    "ZSX": ["rz", "sx"],
+}
+
+NAME_MAP = {
+    "u": UGate,
+    "u1": U1Gate,
+    "u2": U2Gate,
+    "u3": U3Gate,
+    "p": PhaseGate,
+    "rx": RXGate,
+    "ry": RYGate,
+    "rz": RZGate,
+    "r": RGate,
+    "sx": SXGate,
+    "x": XGate,
+}
+
+
+class OneQubitEulerDecomposer:
+    r"""A class for decomposing 1-qubit unitaries into Euler angle rotations.
+
+    The resulting decomposition is parameterized by 3 Euler rotation angle
+    parameters :math:`(\theta, \phi, \lambda)`, and a phase parameter
+    :math:`\gamma`. The value of the parameters for an input unitary depends
+    on the decomposition basis. Allowed bases and the resulting circuits are
+    shown in the following table. Note that for the non-Euler bases (:math:`U3`,
+    :math:`U1X`, :math:`RR`), the :math:`ZYZ` Euler parameters are used.
+
+    .. list-table:: Supported circuit bases
+        :widths: auto
+        :header-rows: 1
+
+        * - Basis
+          - Euler Angle Basis
+          - Decomposition Circuit
+        * - 'ZYZ'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} R_Z(\phi).R_Y(\theta).R_Z(\lambda)`
+        * - 'ZXZ'
+          - :math:`Z(\phi) X(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} R_Z(\phi).R_X(\theta).R_Z(\lambda)`
+        * - 'XYX'
+          - :math:`X(\phi) Y(\theta) X(\lambda)`
+          - :math:`e^{i\gamma} R_X(\phi).R_Y(\theta).R_X(\lambda)`
+        * - 'XZX'
+          - :math:`X(\phi) Z(\theta) X(\lambda)`
+          - :math:`e^{i\gamma} R_X(\phi).R_Z(\theta).R_X(\lambda)`
+        * - 'U3'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} U_3(\theta,\phi,\lambda)`
+        * - 'U321'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} U_3(\theta,\phi,\lambda)`
+        * - 'U'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} U_3(\theta,\phi,\lambda)`
+        * - 'PSX'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} U_1(\phi+\pi).R_X\left(\frac{\pi}{2}\right).`
+            :math:`U_1(\theta+\pi).R_X\left(\frac{\pi}{2}\right).U_1(\lambda)`
+        * - 'ZSX'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} R_Z(\phi+\pi).\sqrt{X}.`
+            :math:`R_Z(\theta+\pi).\sqrt{X}.R_Z(\lambda)`
+        * - 'ZSXX'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} R_Z(\phi+\pi).\sqrt{X}.R_Z(\theta+\pi).\sqrt{X}.R_Z(\lambda)`
+            or
+            :math:`e^{i\gamma} R_Z(\phi+\pi).X.R_Z(\lambda)`
+        * - 'U1X'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} U_1(\phi+\pi).R_X\left(\frac{\pi}{2}\right).`
+            :math:`U_1(\theta+\pi).R_X\left(\frac{\pi}{2}\right).U_1(\lambda)`
+        * - 'RR'
+          - :math:`Z(\phi) Y(\theta) Z(\lambda)`
+          - :math:`e^{i\gamma} R\left(-\pi,\frac{\phi-\lambda+\pi}{2}\right).`
+            :math:`R\left(\theta+\pi,\frac{\pi}{2}-\lambda\right)`
+
+    .. automethod:: __call__
+    """
+
+    def __init__(self, basis: str = "U3", use_dag: bool = False):
+        """Initialize decomposer
+
+        Supported bases are: ``'U'``, ``'PSX'``, ``'ZSXX'``, ``'ZSX'``, ``'U321'``, ``'U3'``,
+        ``'U1X'``, ``'RR'``, ``'ZYZ'``, ``'ZXZ'``, ``'XYX'``, ``'XZX'``.
+
+        Args:
+            basis: the decomposition basis [Default: ``'U3'``]
+            use_dag: If true the output from calls to the decomposer
+                will be a :class:`~qiskit.dagcircuit.DAGCircuit` object instead of
+                :class:`~qiskit.circuit.QuantumCircuit`.
+
+        Raises:
+            QiskitError: If input basis is not recognized.
+        """
+        self.basis = basis  # sets: self._basis, self._params, self._circuit
+        self.use_dag = use_dag
+
+    def build_circuit(self, gates, global_phase) -> QuantumCircuit | DAGCircuit:
+        """Return the circuit or dag object from a list of gates."""
+        qr = [Qubit()]
+        lookup_gate = False
+        if len(gates) > 0 and isinstance(gates[0], tuple):
+            lookup_gate = True
+
+        from qiskit.dagcircuit import dagcircuit
+
+        dag = dagcircuit.DAGCircuit()
+        dag.global_phase = global_phase
+        dag.add_qubits(qr)
+        for gate_entry in gates:
+            if lookup_gate:
+                gate = NAME_MAP[gate_entry[0].name](*gate_entry[1])
+            else:
+                gate = gate_entry.name
+
+            dag.apply_operation_back(gate, (qr[0],), check=False)
+        return dag
+
+    def __call__(
+        self,
+        unitary: Operator | Gate | np.ndarray,
+        simplify: bool = True,
+        atol: float = DEFAULT_ATOL,
+    ) -> QuantumCircuit | DAGCircuit:
+        """Decompose single qubit gate into a circuit.
+
+        Args:
+            unitary: 1-qubit unitary matrix
+            simplify: reduce gate count in decomposition [Default: True].
+            atol: absolute tolerance for checking angles when simplifying
+                         returned circuit [Default: 1e-12].
+
+        Returns:
+            QuantumCircuit: the decomposed single-qubit gate circuit
+
+        Raises:
+            QiskitError: if input is invalid or synthesis fails.
+        """
+        if hasattr(unitary, "to_operator"):
+            # If input is a BaseOperator subclass this attempts to convert
+            # the object to an Operator so that we can extract the underlying
+            # numpy matrix from `Operator.data`.
+            unitary = unitary.to_operator().data
+        elif hasattr(unitary, "to_matrix"):
+            # If input is Gate subclass or some other class object that has
+            # a to_matrix method this will call that method.
+            unitary = unitary.to_matrix()
+        # Convert to numpy array in case not already an array
+        unitary = np.asarray(unitary, dtype=complex)
+
+        # Check input is a 2-qubit unitary
+        if unitary.shape != (2, 2):
+            raise QiskitError("OneQubitEulerDecomposer: expected 2x2 input matrix")
+        if not is_unitary_matrix(unitary):
+            raise QiskitError("OneQubitEulerDecomposer: input matrix is not unitary.")
+        return self._decompose(unitary, simplify=simplify, atol=atol)
+
+    def _decompose(self, unitary, simplify=True, atol=DEFAULT_ATOL):
+        if self.use_dag:
+            circuit_sequence = euler_one_qubit_decomposer.unitary_to_gate_sequence(
+                unitary, [self.basis], 0, None, simplify, atol
+            )
+            circuit = self.build_circuit(circuit_sequence, circuit_sequence.global_phase)
+            return circuit
+        return QuantumCircuit._from_circuit_data(
+            euler_one_qubit_decomposer.unitary_to_circuit(
+                unitary, [self.basis], 0, None, simplify, atol
+            ),
+            add_regs=True,
+        )
+
+    @property
+    def basis(self):
+        """The decomposition basis."""
+        return self._basis
+
+    @basis.setter
+    def basis(self, basis):
+        """Set the decomposition basis."""
+        basis_methods = {
+            "U321": self._params_u3,
+            "U3": self._params_u3,
+            "U": self._params_u3,
+            "PSX": self._params_u1x,
+            "ZSX": self._params_u1x,
+            "ZSXX": self._params_u1x,
+            "U1X": self._params_u1x,
+            "RR": self._params_zyz,
+            "ZYZ": self._params_zyz,
+            "ZXZ": self._params_zxz,
+            "XYX": self._params_xyx,
+            "XZX": self._params_xzx,
+        }
+        if basis not in basis_methods:
+            raise QiskitError(f"OneQubitEulerDecomposer: unsupported basis {basis}")
+        self._basis = basis
+        self._params = basis_methods[basis]
+
+    def angles(self, unitary: np.ndarray) -> tuple:
+        """Return the Euler angles for input array.
+
+        Args:
+            unitary: :math:`2\\times2` unitary matrix.
+
+        Returns:
+            tuple: ``(theta, phi, lambda)``.
+        """
+        unitary = np.asarray(unitary, dtype=complex)
+        theta, phi, lam, _ = self._params(unitary)
+        return theta, phi, lam
+
+    def angles_and_phase(self, unitary: np.ndarray) -> tuple:
+        """Return the Euler angles and phase for input array.
+
+        Args:
+            unitary: :math:`2\\times2`
+
+        Returns:
+            tuple: ``(theta, phi, lambda, phase)``.
+        """
+        unitary = np.asarray(unitary, dtype=complex)
+        return self._params(unitary)
+
+    _params_zyz = staticmethod(euler_one_qubit_decomposer.params_zyz)
+    _params_zxz = staticmethod(euler_one_qubit_decomposer.params_zxz)
+    _params_xyx = staticmethod(euler_one_qubit_decomposer.params_xyx)
+    _params_xzx = staticmethod(euler_one_qubit_decomposer.params_xzx)
+    _params_u3 = staticmethod(euler_one_qubit_decomposer.params_u3)
+    _params_u1x = staticmethod(euler_one_qubit_decomposer.params_u1x)

qiskit/synthesis/permutation/__init__.py

@@ -0,0 +1,18 @@
+# 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.
+
+"""Module containing synthesis algorithms for Permutation gates."""
+
+
+from .permutation_lnn import synth_permutation_depth_lnn_kms
+from .permutation_full import synth_permutation_basic, synth_permutation_acg
+from .permutation_reverse_lnn import synth_permutation_reverse_lnn_kms

qiskit/synthesis/permutation/permutation_full.py

@@ -0,0 +1,78 @@
+# 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.
+
+"""Synthesis algorithm for Permutation gates for full-connectivity."""
+
+from __future__ import annotations
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import (
+    _synth_permutation_basic,
+    _synth_permutation_acg,
+)
+
+
+def synth_permutation_basic(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
+    """Synthesize a permutation circuit for a fully-connected
+    architecture using sorting.
+
+    More precisely, if the input permutation is a cycle of length ``m``,
+    then this creates a quantum circuit with ``m-1`` SWAPs (and of depth ``m-1``);
+    if the input  permutation consists of several disjoint cycles, then each cycle
+    is essentially treated independently.
+
+    Args:
+        pattern: Permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        The synthesized quantum circuit.
+    """
+    return QuantumCircuit._from_circuit_data(_synth_permutation_basic(pattern), add_regs=True)
+
+
+def synth_permutation_acg(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
+    """Synthesize a permutation circuit for a fully-connected
+    architecture using the Alon, Chung, Graham method.
+
+    This produces a quantum circuit of depth 2 (measured in the number of SWAPs).
+
+    This implementation is based on the Proposition 4.1 in reference [1] with
+    the detailed proof given in Theorem 2 in reference [2]
+
+    Args:
+        pattern: Permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. N. Alon, F. R. K. Chung, and R. L. Graham.
+           *Routing Permutations on Graphs Via Matchings.*,
+           Proceedings of the Twenty-Fifth Annual ACM Symposium on Theory of Computing(1993).
+           Pages 583–591.
+           `(Extended abstract) 10.1145/167088.167239 <https://doi.org/10.1145/167088.167239>`_
+        2. N. Alon, F. R. K. Chung, and R. L. Graham.
+           *Routing Permutations on Graphs Via Matchings.*,
+           `(Full paper) <https://www.cs.tau.ac.il/~nogaa/PDFS/r.pdf>`_
+    """
+    return QuantumCircuit._from_circuit_data(_synth_permutation_acg(pattern), add_regs=True)

qiskit/synthesis/permutation/permutation_lnn.py

@@ -0,0 +1,54 @@
+# 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.
+
+"""Depth-efficient synthesis algorithm for Permutation gates."""
+
+from __future__ import annotations
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit._accelerate.synthesis.permutation import _synth_permutation_depth_lnn_kms
+
+
+def synth_permutation_depth_lnn_kms(pattern: list[int] | np.ndarray[int]) -> QuantumCircuit:
+    """Synthesize a permutation circuit for a linear nearest-neighbor
+    architecture using the Kutin, Moulton, Smithline method.
+
+    This is the permutation synthesis algorithm from [1], section 6.
+    It synthesizes any permutation of n qubits over linear nearest-neighbor
+    architecture using SWAP gates with depth at most :math:`n` and size at most
+    :math:`n(n-1)/2` (where both depth and size are measured with respect to SWAPs).
+
+    Args:
+        pattern: Permutation pattern, describing
+            which qubits occupy the positions 0, 1, 2, etc. after applying the
+            permutation. That is, ``pattern[k] = m`` when the permutation maps
+            qubit ``m`` to position ``k``. As an example, the pattern ``[2, 4, 3, 0, 1]``
+            means that qubit ``2`` goes to position ``0``, qubit ``4`` goes to
+            position ``1``, etc.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Samuel A. Kutin, David Petrie Moulton and Lawren M. Smithline.
+           *Computation at a distance.*,
+           `arXiv:quant-ph/0701194v1 <https://arxiv.org/abs/quant-ph/0701194>`_
+    """
+
+    # In Qiskit, the permutation pattern [2, 4, 3, 0, 1] means that
+    # the permutation that maps qubit 2 to position 0, 4 to 1, 3 to 2, 0 to 3, and 1 to 4.
+    # In the permutation synthesis code below the notation is opposite:
+    # [2, 4, 3, 0, 1] means that 0 maps to 2, 1 to 3, 2 to 3, 3 to 0, and 4 to 1.
+    # This is why we invert the pattern.
+    return QuantumCircuit._from_circuit_data(
+        _synth_permutation_depth_lnn_kms(pattern), add_regs=True
+    )