qiskit 2.0.3__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/synthesis/multi_controlled/mcmt_vchain.py

@@ -0,0 +1,52 @@
+# 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 for multiple-control, multiple-target Gate."""
+
+from __future__ import annotations
+
+from qiskit.circuit import QuantumCircuit, Gate
+from qiskit._accelerate.synthesis.multi_controlled import mcmt_v_chain
+
+
+def synth_mcmt_vchain(
+    gate: Gate, num_ctrl_qubits: int, num_target_qubits: int, ctrl_state: int | None = None
+) -> QuantumCircuit:
+    """Synthesize MCMT using a V-chain.
+
+    This uses a chain of CCX gates, using ``num_ctrl_qubits - 1`` auxiliary qubits.
+
+    For example, a 3-control and 2-target H gate will be synthesized as::
+
+        q_0: ──■────────────────────────■──
+               │                        │
+        q_1: ──■────────────────────────■──
+               │                        │
+        q_2: ──┼────■──────────────■────┼──
+               │    │  ┌───┐       │    │
+        q_3: ──┼────┼──┤ H ├───────┼────┼──
+               │    │  └─┬─┘┌───┐  │    │
+        q_4: ──┼────┼────┼──┤ H ├──┼────┼──
+             ┌─┴─┐  │    │  └─┬─┘  │  ┌─┴─┐
+        q_5: ┤ X ├──■────┼────┼────■──┤ X ├
+             └───┘┌─┴─┐  │    │  ┌─┴─┐└───┘
+        q_6: ─────┤ X ├──■────■──┤ X ├─────
+                  └───┘          └───┘
+
+    """
+    if gate.num_qubits != 1:
+        raise ValueError("Only single qubit gates are supported as input.")
+
+    circ = QuantumCircuit._from_circuit_data(
+        mcmt_v_chain(gate.control(), num_ctrl_qubits, num_target_qubits, ctrl_state)
+    )
+    return circ

qiskit/synthesis/multi_controlled/mcx_synthesis.py

@@ -0,0 +1,359 @@
+# 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 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>`_
+    """
+
+    if num_ctrl_qubits == 1:
+        num_qubits = 2
+    else:
+        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/multi_controlled/multi_control_rotation_gates.py

@@ -0,0 +1,206 @@
+# 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)
+
+    circuit = QuantumCircuit(num_controls + 1, name="MCSU2")
+    controls = list(range(num_controls))  # control indices, defined for code legibility
+    target = num_controls  # target index, defined for code legibility
+
+    if not is_secondary_diag_real:
+        circuit.h(target)
+
+    mcx_1 = synth_mcx_n_dirty_i15(num_ctrl_qubits=k_1)
+    circuit.compose(mcx_1, controls[:k_1] + [target] + controls[k_1 : 2 * k_1 - 2], inplace=True)
+    circuit.append(s_gate, [target])
+
+    # TODO: improve CX count by using action_only=True (based on #9687)
+    mcx_2 = synth_mcx_n_dirty_i15(num_ctrl_qubits=k_2).to_gate()
+    circuit.compose(
+        mcx_2.inverse(), controls[k_1:] + [target] + controls[k_1 - k_2 + 2 : k_1], inplace=True
+    )
+    circuit.append(s_gate.inverse(), [target])
+
+    mcx_3 = synth_mcx_n_dirty_i15(num_ctrl_qubits=k_1).to_gate()
+    circuit.compose(mcx_3, controls[:k_1] + [target] + controls[k_1 : 2 * k_1 - 2], inplace=True)
+    circuit.append(s_gate, [target])
+
+    mcx_4 = synth_mcx_n_dirty_i15(num_ctrl_qubits=k_2).to_gate()
+    circuit.compose(mcx_4, controls[k_1:] + [target] + controls[k_1 - k_2 + 2 : k_1], 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