qiskit 1.0.2__cp38-abi3-macosx_11_0_arm64.whl → 1.1.0rc1__cp38-abi3-macosx_11_0_arm64.whl

qiskit/circuit/library/generalized_gates/isometry.py

@@ -21,7 +21,7 @@ Generic isometries from m to n qubits.
 
 from __future__ import annotations
 
-import itertools
+import math
 import numpy as np
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.circuit.instruction import Instruction
@@ -29,6 +29,7 @@ from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.exceptions import QiskitError
 from qiskit.quantum_info.operators.predicates import is_isometry
+from qiskit._accelerate import isometry as isometry_rs
 
 from .diagonal import Diagonal
 from .uc import UCGate
@@ -93,8 +94,8 @@ class Isometry(Instruction):
         self._epsilon = epsilon
 
         # Check if the isometry has the right dimension and if the columns are orthonormal
-        n = np.log2(isometry.shape[0])
-        m = np.log2(isometry.shape[1])
+        n = math.log2(isometry.shape[0])
+        m = math.log2(isometry.shape[1])
         if not n.is_integer() or n < 0:
             raise QiskitError(
                 "The number of rows of the isometry is not a non negative power of 2."
@@ -150,18 +151,22 @@ class Isometry(Instruction):
         # to keep a copyof the input isometry)
         remaining_isometry = self.iso_data.astype(complex)  # note: "astype" does copy the isometry
         diag = []
-        m = int(np.log2((self.iso_data).shape[1]))
+        m = int(math.log2(self.iso_data.shape[1]))
         # Decompose the column with index column_index and attache the gate to the circuit object.
         # Return the isometry that is left to decompose, where the columns up to index column_index
         # correspond to the firstfew columns of the identity matrix up to diag, and hence we only
         # have to save a list containing them.
         for column_index in range(2**m):
-            self._decompose_column(circuit, q, diag, remaining_isometry, column_index)
+            remaining_isometry, diag = self._decompose_column(
+                circuit, q, diag, remaining_isometry, column_index
+            )
             # extract phase of the state that was sent to the basis state ket(column_index)
             diag.append(remaining_isometry[column_index, 0])
             # remove first column (which is now stored in diag)
             remaining_isometry = remaining_isometry[:, 1:]
-        if len(diag) > 1 and not _diag_is_identity_up_to_global_phase(diag, self._epsilon):
+        if len(diag) > 1 and not isometry_rs.diag_is_identity_up_to_global_phase(
+            diag, self._epsilon
+        ):
             diagonal = Diagonal(np.conj(diag))
             circuit.append(diagonal, q_input)
         return circuit
@@ -170,9 +175,12 @@ class Isometry(Instruction):
         """
         Decomposes the column with index column_index.
         """
-        n = int(np.log2(self.iso_data.shape[0]))
+        n = int(math.log2(self.iso_data.shape[0]))
         for s in range(n):
-            self._disentangle(circuit, q, diag, remaining_isometry, column_index, s)
+            remaining_isometry, diag = self._disentangle(
+                circuit, q, diag, remaining_isometry, column_index, s
+            )
+        return remaining_isometry, diag
 
     def _disentangle(self, circuit, q, diag, remaining_isometry, column_index, s):
         """
@@ -185,16 +193,22 @@ class Isometry(Instruction):
         # (note that we remove columns of the isometry during the procedure for efficiency)
         k_prime = 0
         v = remaining_isometry
-        n = int(np.log2(self.iso_data.shape[0]))
+        n = int(math.log2(self.iso_data.shape[0]))
 
         # MCG to set one entry to zero (preparation for disentangling with UCGate):
-        index1 = 2 * _a(k, s + 1) * 2**s + _b(k, s + 1)
-        index2 = (2 * _a(k, s + 1) + 1) * 2**s + _b(k, s + 1)
+        index1 = 2 * isometry_rs.a(k, s + 1) * 2**s + isometry_rs.b(k, s + 1)
+        index2 = (2 * isometry_rs.a(k, s + 1) + 1) * 2**s + isometry_rs.b(k, s + 1)
         target_label = n - s - 1
         # Check if a MCG is required
-        if _k_s(k, s) == 0 and _b(k, s + 1) != 0 and np.abs(v[index2, k_prime]) > self._epsilon:
+        if (
+            isometry_rs.k_s(k, s) == 0
+            and isometry_rs.b(k, s + 1) != 0
+            and np.abs(v[index2, k_prime]) > self._epsilon
+        ):
             # Find the MCG, decompose it and apply it to the remaining isometry
-            gate = _reverse_qubit_state([v[index1, k_prime], v[index2, k_prime]], 0, self._epsilon)
+            gate = isometry_rs.reverse_qubit_state(
+                [v[index1, k_prime], v[index2, k_prime]], 0, self._epsilon
+            )
             control_labels = [
                 i
                 for i, x in enumerate(_get_binary_rep_as_list(k, n))
@@ -204,57 +218,49 @@ class Isometry(Instruction):
                 circuit, q, gate, control_labels, target_label
             )
             # apply the MCG to the remaining isometry
-            _apply_multi_controlled_gate(v, control_labels, target_label, gate)
+            v = isometry_rs.apply_multi_controlled_gate(v, control_labels, target_label, gate)
             # correct for the implementation "up to diagonal"
-            diag_mcg_inverse = np.conj(diagonal_mcg).tolist()
-            _apply_diagonal_gate(v, control_labels + [target_label], diag_mcg_inverse)
+            diag_mcg_inverse = np.conj(diagonal_mcg).astype(complex, copy=False)
+            v = isometry_rs.apply_diagonal_gate(
+                v, control_labels + [target_label], diag_mcg_inverse
+            )
             # update the diag according to the applied diagonal gate
-            _apply_diagonal_gate_to_diag(diag, control_labels + [target_label], diag_mcg_inverse, n)
+            diag = isometry_rs.apply_diagonal_gate_to_diag(
+                diag, control_labels + [target_label], diag_mcg_inverse, n
+            )
 
         # UCGate to disentangle a qubit:
         # Find the UCGate, decompose it and apply it to the remaining isometry
         single_qubit_gates = self._find_squs_for_disentangling(v, k, s)
-        if not _ucg_is_identity_up_to_global_phase(single_qubit_gates, self._epsilon):
+        if not isometry_rs.ucg_is_identity_up_to_global_phase(single_qubit_gates, self._epsilon):
             control_labels = list(range(target_label))
             diagonal_ucg = self._append_ucg_up_to_diagonal(
                 circuit, q, single_qubit_gates, control_labels, target_label
             )
             # merge the diagonal into the UCGate for efficient application of both together
-            diagonal_ucg_inverse = np.conj(diagonal_ucg).tolist()
-            single_qubit_gates = _merge_UCGate_and_diag(single_qubit_gates, diagonal_ucg_inverse)
+            diagonal_ucg_inverse = np.conj(diagonal_ucg).astype(complex, copy=False)
+            single_qubit_gates = isometry_rs.merge_ucgate_and_diag(
+                single_qubit_gates, diagonal_ucg_inverse
+            )
             # apply the UCGate (with the merged diagonal gate) to the remaining isometry
-            _apply_ucg(v, len(control_labels), single_qubit_gates)
+            v = isometry_rs.apply_ucg(v, len(control_labels), single_qubit_gates)
             # update the diag according to the applied diagonal gate
-            _apply_diagonal_gate_to_diag(
+            diag = isometry_rs.apply_diagonal_gate_to_diag(
                 diag, control_labels + [target_label], diagonal_ucg_inverse, n
             )
             # # correct for the implementation "up to diagonal"
             # diag_inv = np.conj(diag).tolist()
             # _apply_diagonal_gate(v, control_labels + [target_label], diag_inv)
+        return v, diag
 
     # This method finds the single-qubit gates for a UCGate to disentangle a qubit:
     # we consider the n-qubit state v[:,0] starting with k zeros (in the computational basis).
     # The qubit with label n-s-1 is disentangled into the basis state k_s(k,s).
     def _find_squs_for_disentangling(self, v, k, s):
-        k_prime = 0
-        n = int(np.log2(self.iso_data.shape[0]))
-        if _b(k, s + 1) == 0:
-            i_start = _a(k, s + 1)
-        else:
-            i_start = _a(k, s + 1) + 1
-        id_list = [np.eye(2, 2) for _ in range(i_start)]
-        squs = [
-            _reverse_qubit_state(
-                [
-                    v[2 * i * 2**s + _b(k, s), k_prime],
-                    v[(2 * i + 1) * 2**s + _b(k, s), k_prime],
-                ],
-                _k_s(k, s),
-                self._epsilon,
-            )
-            for i in range(i_start, 2 ** (n - s - 1))
-        ]
-        return id_list + squs
+        res = isometry_rs.find_squs_for_disentangling(
+            v, k, s, self._epsilon, n=int(math.log2(self.iso_data.shape[0]))
+        )
+        return res
 
     # Append a UCGate up to diagonal to the circuit circ.
     def _append_ucg_up_to_diagonal(self, circ, q, single_qubit_gates, control_labels, target_label):
@@ -264,7 +270,7 @@ class Isometry(Instruction):
             q_ancillas_zero,
             q_ancillas_dirty,
         ) = self._define_qubit_role(q)
-        n = int(np.log2(self.iso_data.shape[0]))
+        n = int(math.log2(self.iso_data.shape[0]))
         qubits = q_input + q_ancillas_for_output
         # Note that we have to reverse the control labels, since controls are provided by
         # increasing qubit number toa UCGate by convention
@@ -286,7 +292,7 @@ class Isometry(Instruction):
             q_ancillas_zero,
             q_ancillas_dirty,
         ) = self._define_qubit_role(q)
-        n = int(np.log2(self.iso_data.shape[0]))
+        n = int(math.log2(self.iso_data.shape[0]))
         qubits = q_input + q_ancillas_for_output
         control_qubits = _reverse_qubit_oder(_get_qubits_by_label(control_labels, qubits, n))
         target_qubit = _get_qubits_by_label([target_label], qubits, n)[0]
@@ -307,8 +313,8 @@ class Isometry(Instruction):
 
     def _define_qubit_role(self, q):
 
-        n = int(np.log2(self.iso_data.shape[0]))
-        m = int(np.log2(self.iso_data.shape[1]))
+        n = int(math.log2(self.iso_data.shape[0]))
+        m = int(math.log2(self.iso_data.shape[1]))
 
         # Define the role of the qubits
         q_input = q[:m]
@@ -337,146 +343,6 @@ class Isometry(Instruction):
         return self._inverse
 
 
-# Find special unitary matrix that maps [c0,c1] to [r,0] or [0,r] if basis_state=0 or
-# basis_state=1 respectively
-def _reverse_qubit_state(state, basis_state, epsilon):
-    state = np.array(state)
-    r = np.linalg.norm(state)
-    if r < epsilon:
-        return np.eye(2, 2)
-    if basis_state == 0:
-        m = np.array([[np.conj(state[0]), np.conj(state[1])], [-state[1], state[0]]]) / r
-    else:
-        m = np.array([[-state[1], state[0]], [np.conj(state[0]), np.conj(state[1])]]) / r
-    return m
-
-
-# Methods for applying gates to matrices (should be moved to Qiskit AER)
-
-# Input: matrix m with 2^n rows (and arbitrary many columns). Think of the columns as states
-#  on n qubits. The method applies a uniformly controlled gate (UCGate) to all the columns, where
-#  the UCGate is specified by the inputs k and single_qubit_gates:
-
-#  k =  number of controls. We assume that the controls are on the k most significant qubits
-#       (and the target is on the (k+1)th significant qubit)
-#  single_qubit_gates =     [u_0,...,u_{2^k-1}], where the u_i's are 2*2 unitaries
-#                           (provided as numpy arrays)
-
-# The order of the single-qubit unitaries is such that the first unitary u_0 is applied to the
-# (k+1)th significant qubit if the control qubits are in the state ket(0...00), the gate u_1 is
-# applied if the control qubits are in the state ket(0...01), and so on.
-
-# The input matrix m and the single-qubit gates have to be of dtype=complex.
-
-
-def _apply_ucg(m, k, single_qubit_gates):
-    # ToDo: Improve efficiency by parallelizing the gate application. A generalized version of
-    # ToDo: this method should be implemented by the state vector simulator in Qiskit AER.
-    num_qubits = int(np.log2(m.shape[0]))
-    num_col = m.shape[1]
-    spacing = 2 ** (num_qubits - k - 1)
-    for j in range(2 ** (num_qubits - 1)):
-        i = (j // spacing) * spacing + j
-        gate_index = i // (2 ** (num_qubits - k))
-        for col in range(num_col):
-            m[np.array([i, i + spacing]), np.array([col, col])] = np.ndarray.flatten(
-                single_qubit_gates[gate_index].dot(np.array([[m[i, col]], [m[i + spacing, col]]]))
-            ).tolist()
-    return m
-
-
-# Apply a diagonal gate with diagonal entries liste in diag and acting on qubits with labels
-#  action_qubit_labels to a matrix m.
-# The input matrix m has to be of dtype=complex
-# The qubit labels are such that label 0 corresponds to the most significant qubit, label 1 to
-#  the second most significant qubit, and so on ...
-
-
-def _apply_diagonal_gate(m, action_qubit_labels, diag):
-    # ToDo: Improve efficiency by parallelizing the gate application. A generalized version of
-    # ToDo: this method should be implemented by the state vector simulator in Qiskit AER.
-    num_qubits = int(np.log2(m.shape[0]))
-    num_cols = m.shape[1]
-    basis_states = list(itertools.product([0, 1], repeat=num_qubits))
-    for state in basis_states:
-        state_on_action_qubits = [state[i] for i in action_qubit_labels]
-        diag_index = _bin_to_int(state_on_action_qubits)
-        i = _bin_to_int(state)
-        for j in range(num_cols):
-            m[i, j] = diag[diag_index] * m[i, j]
-    return m
-
-
-# Special case of the method _apply_diagonal_gate, where the input m is a diagonal matrix on the
-# log2(len(m_diagonal)) least significant qubits (this method is more efficient in this case
-# than _apply_diagonal_gate). The input m_diagonal is provided as a list of diagonal entries.
-# The diagonal diag is applied on the qubits with labels listed in action_qubit_labels. The input
-# num_qubits gives the total number of considered qubits (this input is required to interpret the
-# action_qubit_labels in relation to the least significant qubits).
-
-
-def _apply_diagonal_gate_to_diag(m_diagonal, action_qubit_labels, diag, num_qubits):
-    if not m_diagonal:
-        return m_diagonal
-    basis_states = list(itertools.product([0, 1], repeat=num_qubits))
-    for state in basis_states[: len(m_diagonal)]:
-        state_on_action_qubits = [state[i] for i in action_qubit_labels]
-        diag_index = _bin_to_int(state_on_action_qubits)
-        i = _bin_to_int(state)
-        m_diagonal[i] *= diag[diag_index]
-    return m_diagonal
-
-
-# Apply a MC single-qubit gate (given by the 2*2 unitary input: gate) with controlling on
-# the qubits with label control_labels and acting on the qubit with label target_label
-# to a matrix m. The input matrix m and the gate have to be of dtype=complex. The qubit labels are
-# such that label 0 corresponds to the most significant qubit, label 1 to the second most
-# significant qubit, and so on ...
-
-
-def _apply_multi_controlled_gate(m, control_labels, target_label, gate):
-    # ToDo: This method should be integrated into the state vector simulator in Qiskit AER.
-    num_qubits = int(np.log2(m.shape[0]))
-    num_cols = m.shape[1]
-    control_labels.sort()
-    free_qubits = num_qubits - len(control_labels) - 1
-    basis_states_free = list(itertools.product([0, 1], repeat=free_qubits))
-    for state_free in basis_states_free:
-        (e1, e2) = _construct_basis_states(state_free, control_labels, target_label)
-        for i in range(num_cols):
-            m[np.array([e1, e2]), np.array([i, i])] = np.ndarray.flatten(
-                gate.dot(np.array([[m[e1, i]], [m[e2, i]]]))
-            ).tolist()
-    return m
-
-
-# Helper method for _apply_multi_controlled_gate. This constructs the basis states the MG gate
-# is acting on for a specific state state_free of the qubits we neither control nor act on.
-
-
-def _construct_basis_states(state_free, control_labels, target_label):
-    e1 = []
-    e2 = []
-    j = 0
-    for i in range(len(state_free) + len(control_labels) + 1):
-        if i in control_labels:
-            e1.append(1)
-            e2.append(1)
-        elif i == target_label:
-            e1.append(0)
-            e2.append(1)
-        else:
-            e1.append(state_free[j])
-            e2.append(state_free[j])
-            j += 1
-    out1 = _bin_to_int(e1)
-    out2 = _bin_to_int(e2)
-    return out1, out2
-
-
-# Some helper methods:
-
-
 # Get the qubits in the list qubits corresponding to the labels listed in labels. The total number
 # of qubits is given by num_qubits (and determines the convention for the qubit labeling)
 
@@ -495,14 +361,6 @@ def _reverse_qubit_oder(qubits):
 # Convert list of binary digits to integer
 
 
-def _bin_to_int(binary_digits_as_list):
-    return int("".join(str(x) for x in binary_digits_as_list), 2)
-
-
-def _ct(m):
-    return np.transpose(np.conjugate(m))
-
-
 def _get_binary_rep_as_list(n, num_digits):
     binary_string = np.binary_repr(n).zfill(num_digits)
     binary = []
@@ -510,64 +368,3 @@ def _get_binary_rep_as_list(n, num_digits):
         for c in line:
             binary.append(int(c))
     return binary[-num_digits:]
-
-
-# absorb a diagonal gate into a UCGate
-
-
-def _merge_UCGate_and_diag(single_qubit_gates, diag):
-    for i, gate in enumerate(single_qubit_gates):
-        single_qubit_gates[i] = np.array([[diag[2 * i], 0.0], [0.0, diag[2 * i + 1]]]).dot(gate)
-    return single_qubit_gates
-
-
-# Helper variables/functions for the column-by-column decomposition
-
-
-# a(k,s) and b(k,s) are positive integers such that k = a(k,s)2^s + b(k,s)
-# (with the maximal choice of a(k,s))
-
-
-def _a(k, s):
-    return k // 2**s
-
-
-def _b(k, s):
-    return k - (_a(k, s) * 2**s)
-
-
-# given a binary representation of k with binary digits [k_{n-1},..,k_1,k_0],
-# the method k_s(k, s) returns k_s
-
-
-def _k_s(k, s):
-    if k == 0:
-        return 0
-    else:
-        num_digits = s + 1
-        return _get_binary_rep_as_list(k, num_digits)[0]
-
-
-# Check if a gate of a special form is equal to the identity gate up to global phase
-
-
-def _ucg_is_identity_up_to_global_phase(single_qubit_gates, epsilon):
-    if not np.abs(single_qubit_gates[0][0, 0]) < epsilon:
-        global_phase = 1.0 / (single_qubit_gates[0][0, 0])
-    else:
-        return False
-    for gate in single_qubit_gates:
-        if not np.allclose(global_phase * gate, np.eye(2, 2)):
-            return False
-    return True
-
-
-def _diag_is_identity_up_to_global_phase(diag, epsilon):
-    if not np.abs(diag[0]) < epsilon:
-        global_phase = 1.0 / (diag[0])
-    else:
-        return False
-    for d in diag:
-        if not np.abs(global_phase * d - 1) < epsilon:
-            return False
-    return True

qiskit/circuit/library/generalized_gates/pauli.py

@@ -63,13 +63,13 @@ class PauliGate(Gate):
         r"""Return inverted pauli gate (itself)."""
         return PauliGate(self.params[0])  # self-inverse
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, copy=None):
         """Return a Numpy.array for the pauli gate.
         i.e. tensor product of the paulis"""
         # pylint: disable=cyclic-import
         from qiskit.quantum_info.operators import Pauli
 
-        return Pauli(self.params[0]).__array__(dtype=dtype)
+        return Pauli(self.params[0]).__array__(dtype=dtype, copy=copy)
 
     def validate_parameter(self, parameter):
         if isinstance(parameter, str):

qiskit/circuit/library/generalized_gates/permutation.py

@@ -147,8 +147,11 @@ class PermutationGate(Gate):
 
         super().__init__(name="permutation", num_qubits=num_qubits, params=[pattern])
 
-    def __array__(self, dtype=None):
+    def __array__(self, dtype=None, copy=None):
         """Return a numpy.array for the Permutation gate."""
+        if copy is False:
+            raise ValueError("unable to avoid copy while creating an array as requested")
+
         nq = len(self.pattern)
         mat = np.zeros((2**nq, 2**nq), dtype=dtype)
 

qiskit/circuit/library/generalized_gates/rv.py

@@ -12,13 +12,14 @@
 
 """Rotation around an arbitrary axis on the Bloch sphere."""
 
+import math
 import numpy
 from qiskit.circuit.gate import Gate
 from qiskit.circuit.exceptions import CircuitError
 
 
 class RVGate(Gate):
-    r"""Rotation around arbitrary rotation axis :math:`v` where :math:`|v|` is
+    r"""Rotation around arbitrary rotation axis :math:`\vec{v}` where :math:`\|\vec{v}\|_2` is
     angle of rotation in radians.
 
     Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
@@ -36,14 +37,17 @@ class RVGate(Gate):
 
     .. math::
 
-        \newcommand{\rotationangle}{|\vec{v}|}
-        \newcommand{\sinc}{\text{sinc}}
-            R(\vec{v}) = e^{-i \vec{v}\cdot\vec{\sigma}} =
+        \newcommand{\rotationangle}{\frac{\|\vec{v}\|_2}{2}}
+            R(\vec{v}) = e^{-i \vec{v}\cdot\vec{\sigma} / 2} =
                 \begin{pmatrix}
-                    \cos\left(\rotationangle\right) -i v_z \sinc\left(\rotationangle\right)
-                    & -(i v_x + v_y) \sinc\left(\rotationangle\right) \\
-                    -(i v_x - v_y) \sinc\left(\rotationangle\right)
-                    & \cos\left(\rotationangle\right) + i v_z \sinc\left(\rotationangle\right)
+                    \cos\left(\rotationangle\right)
+                    -i \frac{v_z}{\|\vec{v}\|_2} \sin\left(\rotationangle\right)
+                    & -(i \frac{v_x}{\|\vec{v}\|_2}
+                    + \frac{v_y}{\|\vec{v}\|_2}) \sin\left(\rotationangle\right) \\
+                    -(i \frac{v_x}{\|\vec{v}\|_2}
+                    - \frac{v_y}{\|\vec{v}\|_2}) \sin\left(\rotationangle\right)
+                    & \cos\left(\rotationangle\right)
+                    + i \frac{v_z}{\|\vec{v}\|_2} \sin\left(\rotationangle\right)
                 \end{pmatrix}
     """
 
@@ -79,12 +83,12 @@ class RVGate(Gate):
     def to_matrix(self):
         """Return a numpy.array for the R(v) gate."""
         v = numpy.asarray(self.params, dtype=float)
-        angle = numpy.sqrt(v.dot(v))
+        angle = math.sqrt(v.dot(v))
         if angle == 0:
             return numpy.array([[1, 0], [0, 1]])
         nx, ny, nz = v / angle
-        sin = numpy.sin(angle / 2)
-        cos = numpy.cos(angle / 2)
+        sin = math.sin(angle / 2)
+        cos = math.cos(angle / 2)
         return numpy.array(
             [
                 [cos - 1j * nz * sin, (-ny - 1j * nx) * sin],

qiskit/circuit/library/generalized_gates/uc.py

@@ -21,7 +21,6 @@
 
 from __future__ import annotations
 
-import cmath
 import math
 
 import numpy as np
@@ -33,14 +32,11 @@ from qiskit.circuit.quantumregister import QuantumRegister
 from qiskit.circuit.quantumcircuit import QuantumCircuit
 from qiskit.circuit.exceptions import CircuitError
 from qiskit.exceptions import QiskitError
-
-# pylint: disable=cyclic-import
-from qiskit.synthesis.one_qubit.one_qubit_decompose import OneQubitEulerDecomposer
+from qiskit._accelerate import uc_gate
 
 from .diagonal import Diagonal
 
 _EPS = 1e-10  # global variable used to chop very small numbers to zero
-_DECOMPOSER1Q = OneQubitEulerDecomposer("U3")
 
 
 class UCGate(Gate):
@@ -203,99 +199,7 @@ class UCGate(Gate):
         https://arxiv.org/pdf/quant-ph/0410066.pdf.
         """
         single_qubit_gates = [gate.astype(complex) for gate in self.params]
-        diag = np.ones(2**self.num_qubits, dtype=complex)
-        num_contr = self.num_qubits - 1
-        for dec_step in range(num_contr):
-            num_ucgs = 2**dec_step
-            # The decomposition works recursively and the following loop goes over the different
-            # UCGates that arise in the decomposition
-            for ucg_index in range(num_ucgs):
-                len_ucg = 2 ** (num_contr - dec_step)
-                for i in range(int(len_ucg / 2)):
-                    shift = ucg_index * len_ucg
-                    a = single_qubit_gates[shift + i]
-                    b = single_qubit_gates[shift + len_ucg // 2 + i]
-                    # Apply the decomposition for UCGates given in equation (3) in
-                    # https://arxiv.org/pdf/quant-ph/0410066.pdf
-                    # to demultiplex one control of all the num_ucgs uniformly-controlled gates
-                    #  with log2(len_ucg) uniform controls
-                    v, u, r = self._demultiplex_single_uc(a, b)
-                    #  replace the single-qubit gates with v,u (the already existing ones
-                    #  are not needed any more)
-                    single_qubit_gates[shift + i] = v
-                    single_qubit_gates[shift + len_ucg // 2 + i] = u
-                    # Now we decompose the gates D as described in Figure 4  in
-                    # https://arxiv.org/pdf/quant-ph/0410066.pdf and merge some of the gates
-                    # into the UCGates and the diagonal at the end of the circuit
-
-                    # Remark: The Rz(pi/2) rotation acting on the target qubit and the Hadamard
-                    # gates arising in the decomposition of D are ignored for the moment (they will
-                    # be added together with the C-NOT gates at the end of the decomposition
-                    # (in the method dec_ucg()))
-                    if ucg_index < num_ucgs - 1:
-                        # Absorb the Rz(pi/2) rotation on the control into the UC-Rz gate and
-                        # merge the UC-Rz rotation with the following UCGate,
-                        # which hasn't been decomposed yet.
-                        k = shift + len_ucg + i
-                        single_qubit_gates[k] = single_qubit_gates[k].dot(
-                            UCGate._ct(r)
-                        ) * UCGate._rz(np.pi / 2).item((0, 0))
-                        k = k + len_ucg // 2
-                        single_qubit_gates[k] = single_qubit_gates[k].dot(r) * UCGate._rz(
-                            np.pi / 2
-                        ).item((1, 1))
-                    else:
-                        # Absorb the Rz(pi/2) rotation on the control into the UC-Rz gate and merge
-                        # the trailing UC-Rz rotation into a diagonal gate at the end of the circuit
-                        for ucg_index_2 in range(num_ucgs):
-                            shift_2 = ucg_index_2 * len_ucg
-                            k = 2 * (i + shift_2)
-                            diag[k] = (
-                                diag[k]
-                                * UCGate._ct(r).item((0, 0))
-                                * UCGate._rz(np.pi / 2).item((0, 0))
-                            )
-                            diag[k + 1] = (
-                                diag[k + 1]
-                                * UCGate._ct(r).item((1, 1))
-                                * UCGate._rz(np.pi / 2).item((0, 0))
-                            )
-                            k = len_ucg + k
-                            diag[k] *= r.item((0, 0)) * UCGate._rz(np.pi / 2).item((1, 1))
-                            diag[k + 1] *= r.item((1, 1)) * UCGate._rz(np.pi / 2).item((1, 1))
-        return single_qubit_gates, diag
-
-    def _demultiplex_single_uc(self, a, b):
-        """
-        This method implements the decomposition given in equation (3) in
-        https://arxiv.org/pdf/quant-ph/0410066.pdf.
-        The decomposition is used recursively to decompose uniformly controlled gates.
-        a,b = single qubit unitaries
-        v,u,r = outcome of the decomposition given in the reference mentioned above
-        (see there for the details).
-        """
-        # The notation is chosen as in https://arxiv.org/pdf/quant-ph/0410066.pdf.
-        x = a.dot(UCGate._ct(b))
-        det_x = np.linalg.det(x)
-        x11 = x.item((0, 0)) / cmath.sqrt(det_x)
-        phi = cmath.phase(det_x)
-        r1 = cmath.exp(1j / 2 * (np.pi / 2 - phi / 2 - cmath.phase(x11)))
-        r2 = cmath.exp(1j / 2 * (np.pi / 2 - phi / 2 + cmath.phase(x11) + np.pi))
-        r = np.array([[r1, 0], [0, r2]], dtype=complex)
-        d, u = np.linalg.eig(r.dot(x).dot(r))
-        # If d is not equal to diag(i,-i), then we put it into this "standard" form
-        # (see eq. (13) in https://arxiv.org/pdf/quant-ph/0410066.pdf) by interchanging
-        # the eigenvalues and eigenvectors.
-        if abs(d[0] + 1j) < _EPS:
-            d = np.flip(d, 0)
-            u = np.flip(u, 1)
-        d = np.diag(np.sqrt(d))
-        v = d.dot(UCGate._ct(u)).dot(UCGate._ct(r)).dot(b)
-        return v, u, r
-
-    @staticmethod
-    def _ct(m):
-        return np.transpose(np.conjugate(m))
+        return uc_gate.dec_ucg_help(single_qubit_gates, self.num_qubits)
 
     @staticmethod
     def _rz(alpha):