qiskit 1.4.2__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/synthesis/linear/linear_depth_lnn.py

@@ -25,217 +25,8 @@ from __future__ import annotations
 import numpy as np
 from qiskit.exceptions import QiskitError
 from qiskit.circuit import QuantumCircuit
-from qiskit.synthesis.linear.linear_matrix_utils import (
-    calc_inverse_matrix,
-    check_invertible_binary_matrix,
-    col_op,
-    row_op,
-)
-
-
-def _row_op_update_instructions(cx_instructions, mat, a, b):
-    # Add a cx gate to the instructions and update the matrix mat
-    cx_instructions.append((a, b))
-    row_op(mat, a, b)
-
-
-def _get_lower_triangular(n, mat, mat_inv):
-    # Get the instructions for a lower triangular basis change of a matrix mat.
-    # See the proof of Proposition 7.3 in [1].
-    mat = mat.copy()
-    mat_t = mat.copy()
-    mat_inv_t = mat_inv.copy()
-
-    cx_instructions_rows = []
-
-    # Use the instructions in U, which contains only gates of the form cx(a,b) a>b
-    # to transform the matrix to a permuted lower-triangular matrix.
-    # The original Matrix is unchanged.
-    for i in reversed(range(0, n)):
-        found_first = False
-        # Find the last "1" in row i, use COL operations to the left in order to
-        # zero out all other "1"s in that row.
-        for j in reversed(range(0, n)):
-            if mat[i, j]:
-                if not found_first:
-                    found_first = True
-                    first_j = j
-                else:
-                    # cx_instructions_cols (L instructions) are not needed
-                    col_op(mat, j, first_j)
-        # Use row operations directed upwards to zero out all "1"s above the remaining "1" in row i
-        for k in reversed(range(0, i)):
-            if mat[k, first_j]:
-                _row_op_update_instructions(cx_instructions_rows, mat, i, k)
-
-    # Apply only U instructions to get the permuted L
-    for inst in cx_instructions_rows:
-        row_op(mat_t, inst[0], inst[1])
-        col_op(mat_inv_t, inst[0], inst[1])
-    return mat_t, mat_inv_t
-
-
-def _get_label_arr(n, mat_t):
-    # For each row in mat_t, save the column index of the last "1"
-    label_arr = []
-    for i in range(n):
-        j = 0
-        while not mat_t[i, n - 1 - j]:
-            j += 1
-        label_arr.append(j)
-    return label_arr
-
-
-def _in_linear_combination(label_arr_t, mat_inv_t, row, k):
-    # Check if "row" is a linear combination of all rows in mat_inv_t not including the row labeled by k
-    indx_k = label_arr_t[k]
-    w_needed = np.zeros(len(row), dtype=bool)
-    # Find the linear combination of mat_t rows which produces "row"
-    for row_l, _ in enumerate(row):
-        if row[row_l]:
-            # mat_inv_t can be thought of as a set of instructions. Row l in mat_inv_t
-            # indicates which rows from mat_t are necessary to produce the elementary vector e_l
-            w_needed = w_needed ^ mat_inv_t[row_l]
-    # If the linear combination requires the row labeled by k
-    if w_needed[indx_k]:
-        return False
-    return True
-
-
-def _get_label_arr_t(n, label_arr):
-    # Returns label_arr_t = label_arr^(-1)
-    label_arr_t = [None] * n
-    for i in range(n):
-        label_arr_t[label_arr[i]] = i
-    return label_arr_t
-
-
-def _matrix_to_north_west(n, mat, mat_inv):
-    # Transform an arbitrary boolean invertible matrix to a north-west triangular matrix
-    # by Proposition 7.3 in [1]
-
-    # The rows of mat_t hold all w_j vectors (see [1]). mat_inv_t is the inverted matrix of mat_t
-    mat_t, mat_inv_t = _get_lower_triangular(n, mat, mat_inv)
-
-    # Get all pi(i) labels
-    label_arr = _get_label_arr(n, mat_t)
-
-    # Save the original labels, exchange index <-> value
-    label_arr_t = _get_label_arr_t(n, label_arr)
-
-    first_qubit = 0
-    empty_layers = 0
-    done = False
-    cx_instructions_rows = []
-
-    while not done:
-        # At each iteration the values of i switch between even and odd
-        at_least_one_needed = False
-
-        for i in range(first_qubit, n - 1, 2):
-            # "If j < k, we do nothing" (see [1])
-            # "If j > k, we swap the two labels, and we also perform a box" (see [1])
-            if label_arr[i] > label_arr[i + 1]:
-                at_least_one_needed = True
-                # "Let W be the span of all w_l for l!=k" (see [1])
-                # " We can perform a box on <i> and <i + 1> that writes a vector in W to wire <i + 1>."
-                # (see [1])
-                if _in_linear_combination(label_arr_t, mat_inv_t, mat[i + 1], label_arr[i + 1]):
-                    pass
-
-                elif _in_linear_combination(
-                    label_arr_t, mat_inv_t, mat[i + 1] ^ mat[i], label_arr[i + 1]
-                ):
-                    _row_op_update_instructions(cx_instructions_rows, mat, i, i + 1)
-
-                elif _in_linear_combination(label_arr_t, mat_inv_t, mat[i], label_arr[i + 1]):
-                    _row_op_update_instructions(cx_instructions_rows, mat, i + 1, i)
-                    _row_op_update_instructions(cx_instructions_rows, mat, i, i + 1)
-
-                label_arr[i], label_arr[i + 1] = label_arr[i + 1], label_arr[i]
-
-        if not at_least_one_needed:
-            empty_layers += 1
-            if empty_layers > 1:  # if nothing happened twice in a row, then finished.
-                done = True
-        else:
-            empty_layers = 0
-
-        first_qubit = int(not first_qubit)
-
-    return cx_instructions_rows
-
-
-def _north_west_to_identity(n, mat):
-    # Transform a north-west triangular matrix to identity in depth 3*n by Proposition 7.4 of [1]
-
-    # At start the labels are in reversed order
-    label_arr = list(reversed(range(n)))
-    first_qubit = 0
-    empty_layers = 0
-    done = False
-    cx_instructions_rows = []
-
-    while not done:
-        at_least_one_needed = False
-
-        for i in range(first_qubit, n - 1, 2):
-            # Exchange the labels if needed
-            if label_arr[i] > label_arr[i + 1]:
-                at_least_one_needed = True
-
-                # If row i has "1" in column i+1, swap and remove the "1" (in depth 2)
-                # otherwise, only do a swap (in depth 3)
-                if not mat[i, label_arr[i + 1]]:
-                    # Adding this turns the operation to a SWAP
-                    _row_op_update_instructions(cx_instructions_rows, mat, i + 1, i)
-
-                _row_op_update_instructions(cx_instructions_rows, mat, i, i + 1)
-                _row_op_update_instructions(cx_instructions_rows, mat, i + 1, i)
-
-                label_arr[i], label_arr[i + 1] = label_arr[i + 1], label_arr[i]
-
-        if not at_least_one_needed:
-            empty_layers += 1
-            if empty_layers > 1:  # if nothing happened twice in a row, then finished.
-                done = True
-        else:
-            empty_layers = 0
-
-        first_qubit = int(not first_qubit)
-
-    return cx_instructions_rows
-
-
-def _optimize_cx_circ_depth_5n_line(mat):
-    # Optimize CX circuit in depth bounded by 5n for LNN connectivity.
-    # The algorithm [1] has two steps:
-    # a) transform the original matrix to a north-west matrix (m2nw),
-    # b) transform the north-west matrix to identity (nw2id).
-    #
-    # A square n-by-n matrix A is called north-west if A[i][j]=0 for all i+j>=n
-    # For example, the following matrix is north-west:
-    # [[0, 1, 0, 1]
-    #  [1, 1, 1, 0]
-    #  [0, 1, 0, 0]
-    #  [1, 0, 0, 0]]
-
-    # According to [1] the synthesis is done on the inverse matrix
-    # so the matrix mat is inverted at this step
-    mat_inv = mat.astype(bool, copy=True)
-    mat_cpy = calc_inverse_matrix(mat_inv)
-
-    n = len(mat_cpy)
-
-    # Transform an arbitrary invertible matrix to a north-west triangular matrix
-    # by Proposition 7.3 of [1]
-    cx_instructions_rows_m2nw = _matrix_to_north_west(n, mat_cpy, mat_inv)
-
-    # Transform a north-west triangular matrix to identity in depth 3*n
-    # by Proposition 7.4 of [1]
-    cx_instructions_rows_nw2id = _north_west_to_identity(n, mat_cpy)
-
-    return cx_instructions_rows_m2nw, cx_instructions_rows_nw2id
+from qiskit.synthesis.linear.linear_matrix_utils import check_invertible_binary_matrix
+from qiskit._accelerate.synthesis.linear import py_synth_cnot_depth_line_kms as fast_kms
 
 
 def synth_cnot_depth_line_kms(mat: np.ndarray[bool]) -> QuantumCircuit:
@@ -264,13 +55,7 @@ def synth_cnot_depth_line_kms(mat: np.ndarray[bool]) -> QuantumCircuit:
     if not check_invertible_binary_matrix(mat):
         raise QiskitError("The input matrix is not invertible.")
 
-    # Returns the quantum circuit constructed from the instructions
-    # that we got in _optimize_cx_circ_depth_5n_line
-    num_qubits = len(mat)
-    cx_inst = _optimize_cx_circ_depth_5n_line(mat)
-    qc = QuantumCircuit(num_qubits)
-    for pair in cx_inst[0]:
-        qc.cx(pair[0], pair[1])
-    for pair in cx_inst[1]:
-        qc.cx(pair[0], pair[1])
-    return qc
+    circuit_data = fast_kms(mat)
+
+    # construct circuit from the data
+    return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)

qiskit/synthesis/linear_phase/cx_cz_depth_lnn.py

@@ -1,6 +1,6 @@
 # This code is part of Qiskit.
 #
-# (C) Copyright IBM 2023
+# (C) Copyright IBM 2023-2025
 #
 # This code is licensed under the Apache License, Version 2.0. You may
 # obtain a copy of this license in the LICENSE.txt file in the root directory
@@ -28,191 +28,9 @@ References:
         Hadamard-free Clifford transformations they generate," 2022.
 """
 
-from copy import deepcopy
 import numpy as np
-
 from qiskit.circuit import QuantumCircuit
-from qiskit.synthesis.linear.linear_matrix_utils import calc_inverse_matrix
-from qiskit.synthesis.linear.linear_depth_lnn import _optimize_cx_circ_depth_5n_line
-
-
-def _initialize_phase_schedule(mat_z):
-    """
-    Given a CZ layer (represented as an n*n CZ matrix Mz)
-    Return a schedule of phase gates implementing Mz in a SWAP-only netwrok
-    (c.f. Alg 1, [2])
-    """
-    n = len(mat_z)
-    phase_schedule = np.zeros((n, n), dtype=int)
-    for i, j in zip(*np.where(mat_z)):
-        if i >= j:
-            continue
-
-        phase_schedule[i, j] = 3
-        phase_schedule[i, i] += 1
-        phase_schedule[j, j] += 1
-
-    return phase_schedule
-
-
-def _shuffle(labels, odd):
-    """
-    Args:
-        labels : a list of indices
-        odd : a boolean indicating whether this layer is odd or even,
-    Shuffle the indices in labels by swapping adjacent elements
-    (c.f. Fig.2, [2])
-    """
-    swapped = [v for p in zip(labels[1::2], labels[::2]) for v in p]
-    return swapped + labels[-1:] if odd else swapped
-
-
-def _make_seq(n):
-    """
-    Given the width of the circuit n,
-    Return the labels of the boxes in order from left to right, top to bottom
-    (c.f. Fig.2, [2])
-    """
-    seq = []
-    wire_labels = list(range(n - 1, -1, -1))
-
-    for i in range(n):
-        wire_labels_new = (
-            _shuffle(wire_labels, n % 2)
-            if i % 2 == 0
-            else wire_labels[0:1] + _shuffle(wire_labels[1:], (n + 1) % 2)
-        )
-        seq += [
-            (min(i), max(i)) for i in zip(wire_labels[::2], wire_labels_new[::2]) if i[0] != i[1]
-        ]
-        wire_labels = wire_labels_new
-
-    return seq
-
-
-def _swap_plus(instructions, seq):
-    """
-    Given CX instructions (c.f. Thm 7.1, [1]) and the labels of all boxes,
-    Return a list of labels of the boxes that is SWAP+ in descending order
-        * Assumes the instruction gives gates in the order from top to bottom,
-          from left to right
-        * SWAP+ is defined in section 3.A. of [2]. Note the northwest
-          diagonalization procedure of [1] consists exactly n layers of boxes,
-          each being either a SWAP or a SWAP+. That is, each northwest
-          diagonalization circuit can be uniquely represented by which of its
-          n(n-1)/2 boxes are SWAP+ and which are SWAP.
-    """
-    instr = deepcopy(instructions)
-    swap_plus = set()
-    for i, j in reversed(seq):
-        cnot_1 = instr.pop()
-        instr.pop()
-
-        if instr == [] or instr[-1] != cnot_1:
-            # Only two CNOTs on same set of controls -> this box is SWAP+
-            swap_plus.add((i, j))
-        else:
-            instr.pop()
-    return swap_plus
-
-
-def _update_phase_schedule(n, phase_schedule, swap_plus):
-    """
-    Given phase_schedule initialized to induce a CZ circuit in SWAP-only network and list of SWAP+ boxes
-    Update phase_schedule for each SWAP+ according to Algorithm 2, [2]
-    """
-    layer_order = list(range(n))[-3::-2] + list(range(n))[-2::-2][::-1]
-    order_comp = np.argsort(layer_order[::-1])
-
-    # Go through each box by descending layer order
-
-    for i in layer_order:
-        for j in range(i + 1, n):
-            if (i, j) not in swap_plus:
-                continue
-            # we need to correct for the effected linear functions:
-
-            # We first correct type 1 and type 2 by switching
-            # the phase applied to c_j and c_i+c_j
-            phase_schedule[j, j], phase_schedule[i, j] = phase_schedule[i, j], phase_schedule[j, j]
-
-            # Then, we go through all the boxes that permutes j BEFORE box(i,j) and update:
-
-            for k in range(n):  # all boxes that permutes j
-                if k in (i, j):
-                    continue
-                if (
-                    order_comp[min(k, j)] < order_comp[i]
-                    and phase_schedule[min(k, j), max(k, j)] % 4 != 0
-                ):
-                    phase = phase_schedule[min(k, j), max(k, j)]
-                    phase_schedule[min(k, j), max(k, j)] = 0
-
-                    # Step 1, apply phase to c_i, c_j, c_k
-                    for l_s in (i, j, k):
-                        phase_schedule[l_s, l_s] = (phase_schedule[l_s, l_s] + phase * 3) % 4
-
-                    # Step 2, apply phase to c_i+ c_j, c_i+c_k, c_j+c_k:
-                    for l1, l2 in [(i, j), (i, k), (j, k)]:
-                        ls = min(l1, l2)
-                        lb = max(l1, l2)
-                        phase_schedule[ls, lb] = (phase_schedule[ls, lb] + phase * 3) % 4
-    return phase_schedule
-
-
-def _apply_phase_to_nw_circuit(n, phase_schedule, seq, swap_plus):
-    """
-    Given
-        Width of the circuit (int n)
-        A CZ circuit, represented by the n*n phase schedule phase_schedule
-        A CX circuit, represented by box-labels (seq) and whether the box is SWAP+ (swap_plus)
-            *   This circuit corresponds to the CX tranformation that tranforms a matrix to
-                a NW matrix (c.f. Prop.7.4, [1])
-            *   SWAP+ is defined in section 3.A. of [2].
-            *   As previously noted, the northwest diagonalization procedure of [1] consists
-                of exactly n layers of boxes, each being either a SWAP or a SWAP+. That is,
-                each northwest diagonalization circuit can be uniquely represented by which
-                of its n(n-1)/2 boxes are SWAP+ and which are SWAP.
-    Return a QuantumCircuit that computes the phase schedule S inside CX
-    """
-    cir = QuantumCircuit(n)
-
-    wires = list(zip(range(n), range(1, n)))
-    wires = wires[::2] + wires[1::2]
-
-    for i, (j, k) in zip(range(len(seq) - 1, -1, -1), reversed(seq)):
-        w1, w2 = wires[i % (n - 1)]
-
-        p = phase_schedule[j, k]
-
-        if (j, k) not in swap_plus:
-            cir.cx(w1, w2)
-
-        cir.cx(w2, w1)
-
-        if p % 4 == 0:
-            pass
-        elif p % 4 == 1:
-            cir.sdg(w2)
-        elif p % 4 == 2:
-            cir.z(w2)
-        else:
-            cir.s(w2)
-
-        cir.cx(w1, w2)
-
-    for i in range(n):
-        p = phase_schedule[n - 1 - i, n - 1 - i]
-        if p % 4 == 0:
-            continue
-        if p % 4 == 1:
-            cir.sdg(i)
-        elif p % 4 == 2:
-            cir.z(i)
-        else:
-            cir.s(i)
-
-    return cir
+from qiskit._accelerate.synthesis.linear_phase import py_synth_cx_cz_depth_line_my
 
 
 def synth_cx_cz_depth_line_my(mat_x: np.ndarray, mat_z: np.ndarray) -> QuantumCircuit:
@@ -239,24 +57,5 @@ def synth_cx_cz_depth_line_my(mat_x: np.ndarray, mat_z: np.ndarray) -> QuantumCi
            Hadamard-free Clifford transformations they generate*,
            `arXiv:2210.16195 <https://arxiv.org/abs/2210.16195>`_.
     """
-
-    # First, find circuits implementing mat_x by Proposition 7.3 and Proposition 7.4 of [1]
-
-    n = len(mat_x)
-    mat_x = calc_inverse_matrix(mat_x)
-
-    cx_instructions_rows_m2nw, cx_instructions_rows_nw2id = _optimize_cx_circ_depth_5n_line(mat_x)
-
-    # Meanwhile, also build the -CZ- circuit via Phase gate insertions as per Algorithm 2 [2]
-    phase_schedule = _initialize_phase_schedule(mat_z)
-    seq = _make_seq(n)
-    swap_plus = _swap_plus(cx_instructions_rows_nw2id, seq)
-
-    _update_phase_schedule(n, phase_schedule, swap_plus)
-
-    qc = _apply_phase_to_nw_circuit(n, phase_schedule, seq, swap_plus)
-
-    for i, j in reversed(cx_instructions_rows_m2nw):
-        qc.cx(i, j)
-
-    return qc
+    circuit_data = py_synth_cx_cz_depth_line_my(mat_x.astype(bool), mat_z.astype(bool))
+    return QuantumCircuit._from_circuit_data(circuit_data, add_regs=True)

qiskit/synthesis/multi_controlled/__init__.py

@@ -22,3 +22,4 @@ from .mcx_synthesis import (
     synth_c3x,
     synth_c4x,
 )
+from .multi_control_rotation_gates import _apply_cu, _apply_mcu_graycode, _mcsu2_real_diagonal

qiskit/synthesis/multi_controlled/mcx_synthesis.py

@@ -15,7 +15,7 @@
 from math import ceil
 import numpy as np
 
-from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.library.standard_gates import (
     HGate,
@@ -53,7 +53,10 @@ def synth_mcx_n_dirty_i15(
            `arXiv:1501.06911 <http://arxiv.org/abs/1501.06911>`_
     """
 
-    num_qubits = 2 * num_ctrl_qubits - 1
+    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]

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