qiskit 1.3.0__cp39-abi3-win32.whl

qiskit/synthesis/multi_controlled/mcx_synthesis.py

@@ -0,0 +1,356 @@
+# 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 with and without ancillary qubits."""
+
+from math import ceil
+import numpy as np
+
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.library.standard_gates import (
+    HGate,
+    MCU1Gate,
+    CU1Gate,
+    RC3XGate,
+    C3SXGate,
+)
+
+
+def synth_mcx_n_dirty_i15(
+    num_ctrl_qubits: int,
+    relative_phase: bool = False,
+    action_only: bool = False,
+) -> QuantumCircuit:
+    r"""
+    Synthesize a multi-controlled X gate with :math:`k` controls using :math:`k - 2`
+    dirty ancillary qubits producing a circuit with :math:`2 * k - 1` qubits and at most
+    :math:`8 * k - 6` CX gates, by Iten et. al. [1].
+
+    Args:
+        num_ctrl_qubits: The number of control qubits.
+
+        relative_phase: when set to ``True``, the method applies the optimized multi-controlled X gate
+            up to a relative phase, in a way that, by lemma 8 of [1], the relative
+            phases of the ``action part`` cancel out with the phases of the ``reset part``.
+
+        action_only: when set to ``True``, the method applies only the ``action part`` of lemma 8 of [1].
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Iten et. al., *Quantum Circuits for Isometries*, Phys. Rev. A 93, 032318 (2016),
+           `arXiv:1501.06911 <http://arxiv.org/abs/1501.06911>`_
+    """
+
+    num_qubits = 2 * num_ctrl_qubits - 1
+    q = QuantumRegister(num_qubits, name="q")
+    qc = QuantumCircuit(q, name="mcx_vchain")
+    q_controls = q[:num_ctrl_qubits]
+    q_target = q[num_ctrl_qubits]
+    q_ancillas = q[num_ctrl_qubits + 1 :]
+
+    if num_ctrl_qubits == 1:
+        qc.cx(q_controls, q_target)
+        return qc
+    elif num_ctrl_qubits == 2:
+        qc.ccx(q_controls[0], q_controls[1], q_target)
+        return qc
+    elif not relative_phase and num_ctrl_qubits == 3:
+        circuit = synth_c3x()
+        qc.compose(circuit, [*q_controls, q_target], inplace=True, copy=False)
+        return qc
+
+    num_ancillas = num_ctrl_qubits - 2
+    targets = [q_target] + q_ancillas[:num_ancillas][::-1]
+
+    for j in range(2):
+        for i in range(num_ctrl_qubits):  # action part
+            if i < num_ctrl_qubits - 2:
+                if targets[i] != q_target or relative_phase:
+                    # gate cancelling
+
+                    # cancel rightmost gates of action part
+                    # with leftmost gates of reset part
+                    if relative_phase and targets[i] == q_target and j == 1:
+                        qc.cx(q_ancillas[num_ancillas - i - 1], targets[i])
+                        qc.t(targets[i])
+                        qc.cx(q_controls[num_ctrl_qubits - i - 1], targets[i])
+                        qc.tdg(targets[i])
+                        qc.h(targets[i])
+                    else:
+                        qc.h(targets[i])
+                        qc.t(targets[i])
+                        qc.cx(q_controls[num_ctrl_qubits - i - 1], targets[i])
+                        qc.tdg(targets[i])
+                        qc.cx(q_ancillas[num_ancillas - i - 1], targets[i])
+                else:
+                    controls = [
+                        q_controls[num_ctrl_qubits - i - 1],
+                        q_ancillas[num_ancillas - i - 1],
+                    ]
+
+                    qc.ccx(controls[0], controls[1], targets[i])
+            else:
+                # implements an optimized toffoli operation
+                # up to a diagonal gate, akin to lemma 6 of arXiv:1501.06911
+                qc.h(targets[i])
+                qc.t(targets[i])
+                qc.cx(q_controls[num_ctrl_qubits - i - 2], targets[i])
+                qc.tdg(targets[i])
+                qc.cx(q_controls[num_ctrl_qubits - i - 1], targets[i])
+                qc.t(targets[i])
+                qc.cx(q_controls[num_ctrl_qubits - i - 2], targets[i])
+                qc.tdg(targets[i])
+                qc.h(targets[i])
+
+                break
+
+        for i in range(num_ancillas - 1):  # reset part
+            qc.cx(q_ancillas[i], q_ancillas[i + 1])
+            qc.t(q_ancillas[i + 1])
+            qc.cx(q_controls[2 + i], q_ancillas[i + 1])
+            qc.tdg(q_ancillas[i + 1])
+            qc.h(q_ancillas[i + 1])
+
+        if action_only:
+            qc.ccx(q_controls[-1], q_ancillas[-1], q_target)
+
+            break
+
+    return qc
+
+
+def synth_mcx_n_clean_m15(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
+    Synthesize a multi-controlled X gate with :math:`k` controls using :math:`k - 2`
+    clean ancillary qubits with producing a circuit with :math:`2 * k - 1` qubits
+    and at most :math:`6 * k - 6` CX gates, by Maslov [1].
+
+    Args:
+        num_ctrl_qubits: The number of control qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Maslov., Phys. Rev. A 93, 022311 (2016),
+           `arXiv:1508.03273 <https://arxiv.org/pdf/1508.03273>`_
+    """
+
+    num_qubits = 2 * num_ctrl_qubits - 1
+    q = QuantumRegister(num_qubits, name="q")
+    qc = QuantumCircuit(q, name="mcx_vchain")
+    q_controls = q[:num_ctrl_qubits]
+    q_target = q[num_ctrl_qubits]
+    q_ancillas = q[num_ctrl_qubits + 1 :]
+
+    qc.rccx(q_controls[0], q_controls[1], q_ancillas[0])
+    i = 0
+    for j in range(2, num_ctrl_qubits - 1):
+        qc.rccx(q_controls[j], q_ancillas[i], q_ancillas[i + 1])
+
+        i += 1
+
+    qc.ccx(q_controls[-1], q_ancillas[i], q_target)
+
+    for j in reversed(range(2, num_ctrl_qubits - 1)):
+        qc.rccx(q_controls[j], q_ancillas[i - 1], q_ancillas[i])
+
+        i -= 1
+
+    qc.rccx(q_controls[0], q_controls[1], q_ancillas[i])
+
+    return qc
+
+
+def synth_mcx_1_clean_b95(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
+    Synthesize a multi-controlled X gate with :math:`k` controls using a single
+    clean ancillary qubit producing a circuit with :math:`k + 2` qubits and at most
+    :math:`16 * k - 8` CX gates, by Barenco et al. [1].
+
+    Args:
+        num_ctrl_qubits: The number of control qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Barenco et. al., Phys.Rev. A52 3457 (1995),
+           `arXiv:quant-ph/9503016 <https://arxiv.org/abs/quant-ph/9503016>`_
+    """
+
+    if num_ctrl_qubits == 3:
+        return synth_c3x()
+
+    elif num_ctrl_qubits == 4:
+        return synth_c4x()
+
+    num_qubits = num_ctrl_qubits + 2
+    q = QuantumRegister(num_qubits, name="q")
+    qc = QuantumCircuit(q, name="mcx_recursive")
+
+    num_ctrl_qubits = len(q) - 1
+    q_ancilla = q[-1]
+    q_target = q[-2]
+    middle = ceil(num_ctrl_qubits / 2)
+    first_half = [*q[:middle]]
+    second_half = [*q[middle : num_ctrl_qubits - 1], q_ancilla]
+
+    qc_first_half = synth_mcx_n_dirty_i15(num_ctrl_qubits=len(first_half))
+    qc_second_half = synth_mcx_n_dirty_i15(num_ctrl_qubits=len(second_half))
+
+    qc.append(
+        qc_first_half,
+        qargs=[*first_half, q_ancilla, *q[middle : middle + len(first_half) - 2]],
+        cargs=[],
+    )
+    qc.append(
+        qc_second_half,
+        qargs=[*second_half, q_target, *q[: len(second_half) - 2]],
+        cargs=[],
+    )
+    qc.append(
+        qc_first_half,
+        qargs=[*first_half, q_ancilla, *q[middle : middle + len(first_half) - 2]],
+        cargs=[],
+    )
+    qc.append(
+        qc_second_half,
+        qargs=[*second_half, q_target, *q[: len(second_half) - 2]],
+        cargs=[],
+    )
+
+    return qc
+
+
+def synth_mcx_gray_code(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
+    Synthesize a multi-controlled X gate with :math:`k` controls using the Gray code.
+
+    Produces a quantum circuit with :math:`k + 1` qubits. This method
+    produces exponentially many CX gates and should be used only for small
+    values of :math:`k`.
+
+    Args:
+        num_ctrl_qubits: The number of control qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+    """
+    num_qubits = num_ctrl_qubits + 1
+    q = QuantumRegister(num_qubits, name="q")
+    qc = QuantumCircuit(q, name="mcx_gray")
+    qc._append(HGate(), [q[-1]], [])
+    qc._append(MCU1Gate(np.pi, num_ctrl_qubits=num_ctrl_qubits), q[:], [])
+    qc._append(HGate(), [q[-1]], [])
+    return qc
+
+
+def synth_mcx_noaux_v24(num_ctrl_qubits: int) -> QuantumCircuit:
+    r"""
+    Synthesize a multi-controlled X gate with :math:`k` controls based on
+    the implementation for MCPhaseGate.
+
+    In turn, the MCPhase gate uses the decomposition for multi-controlled
+    special unitaries described in [1].
+
+    Produces a quantum circuit with :math:`k + 1` qubits.
+    The number of CX-gates is quadratic in :math:`k`.
+
+    Args:
+        num_ctrl_qubits: The number of control qubits.
+
+    Returns:
+        The synthesized quantum circuit.
+
+    References:
+        1. Vale et. al., *Circuit Decomposition of Multicontrolled Special Unitary
+           Single-Qubit Gates*, IEEE TCAD 43(3) (2024),
+           `arXiv:2302.06377 <https://arxiv.org/abs/2302.06377>`_
+    """
+    if num_ctrl_qubits == 3:
+        return synth_c3x()
+
+    if num_ctrl_qubits == 4:
+        return synth_c4x()
+
+    num_qubits = num_ctrl_qubits + 1
+    q = QuantumRegister(num_qubits, name="q")
+    qc = QuantumCircuit(q)
+    q_controls = list(range(num_ctrl_qubits))
+    q_target = num_ctrl_qubits
+    qc.h(q_target)
+    qc.mcp(np.pi, q_controls, q_target)
+    qc.h(q_target)
+    return qc
+
+
+def synth_c3x() -> QuantumCircuit:
+    """Efficient synthesis of 3-controlled X-gate."""
+
+    q = QuantumRegister(4, name="q")
+    qc = QuantumCircuit(q, name="mcx")
+    qc.h(3)
+    qc.p(np.pi / 8, [0, 1, 2, 3])
+    qc.cx(0, 1)
+    qc.p(-np.pi / 8, 1)
+    qc.cx(0, 1)
+    qc.cx(1, 2)
+    qc.p(-np.pi / 8, 2)
+    qc.cx(0, 2)
+    qc.p(np.pi / 8, 2)
+    qc.cx(1, 2)
+    qc.p(-np.pi / 8, 2)
+    qc.cx(0, 2)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(1, 3)
+    qc.p(np.pi / 8, 3)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(0, 3)
+    qc.p(np.pi / 8, 3)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(1, 3)
+    qc.p(np.pi / 8, 3)
+    qc.cx(2, 3)
+    qc.p(-np.pi / 8, 3)
+    qc.cx(0, 3)
+    qc.h(3)
+    return qc
+
+
+def synth_c4x() -> QuantumCircuit:
+    """Efficient synthesis of 4-controlled X-gate."""
+
+    q = QuantumRegister(5, name="q")
+    qc = QuantumCircuit(q, name="mcx")
+
+    rules = [
+        (HGate(), [q[4]], []),
+        (CU1Gate(np.pi / 2), [q[3], q[4]], []),
+        (HGate(), [q[4]], []),
+        (RC3XGate(), [q[0], q[1], q[2], q[3]], []),
+        (HGate(), [q[4]], []),
+        (CU1Gate(-np.pi / 2), [q[3], q[4]], []),
+        (HGate(), [q[4]], []),
+        (RC3XGate().inverse(), [q[0], q[1], q[2], q[3]], []),
+        (C3SXGate(), [q[0], q[1], q[2], q[4]], []),
+    ]
+    for instr, qargs, cargs in rules:
+        qc._append(instr, qargs, cargs)
+
+    return qc

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.quantumregister 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