cirq-core 1.1.0.dev20221219200817__py3-none-any.whl → 1.2.0__py3-none-any.whl

cirq/testing/sample_gates.py

@@ -0,0 +1,79 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import dataclasses
+
+import cirq
+import numpy as np
+from cirq import ops, qis, protocols
+
+
+def _matrix_for_phasing_state(num_qubits, phase_state, phase):
+    matrix = qis.eye_tensor((2,) * num_qubits, dtype=np.complex128)
+    matrix = matrix.reshape((2**num_qubits, 2**num_qubits))
+    matrix[phase_state, phase_state] = phase
+    print(num_qubits, phase_state, phase)
+    print(matrix)
+    return matrix
+
+
+@dataclasses.dataclass(frozen=True)
+class PhaseUsingCleanAncilla(ops.Gate):
+    r"""Phases the state $|phase_state>$ by $\exp(1j * \pi * \theta)$ using one clean ancilla."""
+
+    theta: float
+    phase_state: int = 1
+    target_bitsize: int = 1
+    ancilla_bitsize: int = 1
+
+    def _num_qubits_(self):
+        return self.target_bitsize
+
+    def _decompose_with_context_(self, qubits, *, context: protocols.DecompositionContext):
+        anc = context.qubit_manager.qalloc(self.ancilla_bitsize)
+        cv = [int(x) for x in f'{self.phase_state:0{self.target_bitsize}b}']
+        cnot_ladder = [cirq.CNOT(anc[i - 1], anc[i]) for i in range(1, self.ancilla_bitsize)]
+
+        yield ops.X(anc[0]).controlled_by(*qubits, control_values=cv)
+        yield [cnot_ladder, ops.Z(anc[-1]) ** self.theta, reversed(cnot_ladder)]
+        yield ops.X(anc[0]).controlled_by(*qubits, control_values=cv)
+
+    def narrow_unitary(self) -> np.ndarray:
+        """Narrowed unitary corresponding to the unitary effect applied on target qubits."""
+        phase = np.exp(1j * np.pi * self.theta)
+        return _matrix_for_phasing_state(self.target_bitsize, self.phase_state, phase)
+
+
+@dataclasses.dataclass(frozen=True)
+class PhaseUsingDirtyAncilla(ops.Gate):
+    r"""Phases the state $|phase_state>$ by -1 using one dirty ancilla."""
+
+    phase_state: int = 1
+    target_bitsize: int = 1
+    ancilla_bitsize: int = 1
+
+    def _num_qubits_(self):
+        return self.target_bitsize
+
+    def _decompose_with_context_(self, qubits, *, context: protocols.DecompositionContext):
+        anc = context.qubit_manager.qalloc(self.ancilla_bitsize)
+        cv = [int(x) for x in f'{self.phase_state:0{self.target_bitsize}b}']
+        cnot_ladder = [cirq.CNOT(anc[i - 1], anc[i]) for i in range(1, self.ancilla_bitsize)]
+        yield ops.X(anc[0]).controlled_by(*qubits, control_values=cv)
+        yield [cnot_ladder, ops.Z(anc[-1]), reversed(cnot_ladder)]
+        yield ops.X(anc[0]).controlled_by(*qubits, control_values=cv)
+        yield [cnot_ladder, ops.Z(anc[-1]), reversed(cnot_ladder)]
+
+    def narrow_unitary(self) -> np.ndarray:
+        """Narrowed unitary corresponding to the unitary effect applied on target qubits."""
+        return _matrix_for_phasing_state(self.target_bitsize, self.phase_state, -1)

cirq/testing/sample_gates_test.py

@@ -0,0 +1,59 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import pytest
+
+import numpy as np
+from cirq.testing import sample_gates
+import cirq
+
+
+@pytest.mark.parametrize('theta', np.linspace(0, 2 * np.pi, 20))
+def test_phase_using_clean_ancilla(theta: float):
+    g = sample_gates.PhaseUsingCleanAncilla(theta)
+    q = cirq.LineQubit(0)
+    qubit_order = cirq.QubitOrder.explicit([q], fallback=cirq.QubitOrder.DEFAULT)
+    decomposed_unitary = cirq.Circuit(cirq.decompose_once(g.on(q))).unitary(qubit_order=qubit_order)
+    phase = np.exp(1j * np.pi * theta)
+    np.testing.assert_allclose(g.narrow_unitary(), np.array([[1, 0], [0, phase]]))
+    np.testing.assert_allclose(
+        decomposed_unitary,
+        # fmt: off
+        np.array(
+            [
+                [1 , 0    , 0    , 0],
+                [0 , phase, 0    , 0],
+                [0 , 0    , phase, 0],
+                [0 , 0    , 0    , 1],
+            ]
+        ),
+        # fmt: on
+    )
+
+
+@pytest.mark.parametrize(
+    'target_bitsize, phase_state', [(1, 0), (1, 1), (2, 0), (2, 1), (2, 2), (2, 3)]
+)
+@pytest.mark.parametrize('ancilla_bitsize', [1, 4])
+def test_phase_using_dirty_ancilla(target_bitsize, phase_state, ancilla_bitsize):
+    g = sample_gates.PhaseUsingDirtyAncilla(phase_state, target_bitsize, ancilla_bitsize)
+    q = cirq.LineQubit.range(target_bitsize)
+    qubit_order = cirq.QubitOrder.explicit(q, fallback=cirq.QubitOrder.DEFAULT)
+    decomposed_circuit = cirq.Circuit(cirq.decompose_once(g.on(*q)))
+    decomposed_unitary = decomposed_circuit.unitary(qubit_order=qubit_order)
+    phase_matrix = np.eye(2**target_bitsize)
+    phase_matrix[phase_state, phase_state] = -1
+    np.testing.assert_allclose(g.narrow_unitary(), phase_matrix)
+    np.testing.assert_allclose(
+        decomposed_unitary, np.kron(phase_matrix, np.eye(2**ancilla_bitsize)), atol=1e-5
+    )

cirq/transformers/__init__.py

@@ -25,6 +25,7 @@ from cirq.transformers.analytical_decompositions import (
     parameterized_2q_op_to_sqrt_iswap_operations,
     prepare_two_qubit_state_using_cz,
     prepare_two_qubit_state_using_sqrt_iswap,
+    quantum_shannon_decomposition,
     single_qubit_matrix_to_gates,
     single_qubit_matrix_to_pauli_rotations,
     single_qubit_matrix_to_phased_x_z,
@@ -36,6 +37,7 @@ from cirq.transformers.analytical_decompositions import (
     two_qubit_matrix_to_diagonal_and_cz_operations,
     two_qubit_matrix_to_ion_operations,
     two_qubit_matrix_to_sqrt_iswap_operations,
+    unitary_to_pauli_string,
 )
 
 from cirq.transformers.heuristic_decompositions import (

cirq/transformers/analytical_decompositions/__init__.py

@@ -28,6 +28,10 @@ from cirq.transformers.analytical_decompositions.cphase_to_fsim import (
     decompose_cphase_into_two_fsim,
 )
 
+from cirq.transformers.analytical_decompositions.quantum_shannon_decomposition import (
+    quantum_shannon_decomposition,
+)
+
 from cirq.transformers.analytical_decompositions.single_qubit_decompositions import (
     is_negligible_turn,
     single_qubit_matrix_to_gates,
@@ -67,3 +71,7 @@ from cirq.transformers.analytical_decompositions.two_qubit_state_preparation imp
 from cirq.transformers.analytical_decompositions.single_to_two_qubit_isometry import (
     two_qubit_matrix_to_cz_isometry,
 )
+
+from cirq.transformers.analytical_decompositions.pauli_string_decomposition import (
+    unitary_to_pauli_string,
+)

cirq/transformers/analytical_decompositions/pauli_string_decomposition.py

@@ -0,0 +1,130 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Optional, Tuple, cast
+
+import numpy as np
+import numpy.typing as npt
+
+from cirq.ops import DensePauliString
+from cirq import protocols
+
+
+def _argmax(V: npt.NDArray) -> Tuple[int, float]:
+    """Returns a tuple (index of max number, max number)."""
+    V = (V * V.conj()).real
+    idx_max = np.argmax(V)
+    V[idx_max] = 0
+    return cast(int, idx_max), np.max(V)
+
+
+def _validate_decomposition(decomposition: DensePauliString, U: npt.NDArray, eps: float) -> bool:
+    """Returns whether the max absolute value of the elementwise difference is less than eps."""
+    got = protocols.unitary(decomposition)
+    return np.abs(got - U).max() < eps
+
+
+def _fast_walsh_hadamard_transform(V: npt.NDArray) -> None:
+    """Fast Walsh–Hadamard Transform of an array."""
+    m = len(V)
+    n = m.bit_length() - 1
+    for h in [2**i for i in range(n)]:
+        for i in range(0, m, h * 2):
+            for j in range(i, i + h):
+                x = V[j]
+                y = V[j + h]
+                V[j] = x + y
+                V[j + h] = x - y
+
+
+def _conjugate_with_hadamard(U: npt.NDArray) -> npt.NDArray:
+    """Applies HcUH in O(n4^n) instead of O(8^n)."""
+
+    U = np.copy(U.T)
+    for i in range(U.shape[1]):
+        _fast_walsh_hadamard_transform(U[:, i])
+    U = U.T
+    for i in range(U.shape[1]):
+        _fast_walsh_hadamard_transform(U[:, i])
+    return U
+
+
+def unitary_to_pauli_string(U: npt.NDArray, eps: float = 1e-15) -> Optional[DensePauliString]:
+    """Attempts to find a pauli string (with possible phase) equivalent to U up to eps.
+
+        Based on this answer https://shorturl.at/aA079.
+        Let x_mask be the index of the maximum number of the first column of U
+        and z_mask be the index of the maximum number of the first column of H†UH
+        each of these indicies is n-bits long where U is 2^n x 2^n.
+
+        These two indices/masks encode in binary the indices of the qubits that
+        have I, X, Y, Z acting on them as follows:
+        x_mask[i] == 1 and z_mask[i] == 0: X acts on the ith qubit
+        x_mask[i] == 0 and z_mask[i] == 1: Z acts on the ith qubit
+        x_mask[i] == 1 and z_mask[i] == 1: Y acts on the ith qubit
+        x_mask[i] == 0 and z_mask[i] == 0: I acts on the ith qubit
+
+    Args:
+        U: A square array whose dimension is a power of 2.
+        eps: numbers smaller than `eps` are considered zero.
+
+    Returns:
+        A DensePauliString of None.
+
+    Raises:
+        ValueError: if U is not square with a power of 2 dimension.
+    """
+
+    if len(U.shape) != 2 or U.shape[0] != U.shape[1]:
+        raise ValueError(f'Input has a non-square shape {U}')
+    n = U.shape[0].bit_length() - 1
+    if U.shape[0] != 2**n:
+        raise ValueError(f'Input dimension {U.shape[0]} isn\'t a power of 2')
+
+    x_msk, second_largest = _argmax(U[:, 0])
+    if second_largest > eps:
+        return None
+    U_z = _conjugate_with_hadamard(U)
+    z_msk, second_largest = _argmax(U_z[:, 0])
+    if second_largest > eps:
+        return None
+
+    def select(i):
+        """Returns the gate that acts on the ith qubit."""
+        has_x = (x_msk >> i) & 1
+        has_z = (z_msk >> i) & 1
+        # The mapping is:
+        #   - has_x and not has_z => X
+        #   - not has_x and has_z => Z
+        #   - has_x and has_z => Y
+        #   - not has_x and not has_z => I
+        gate_table = ['IX', 'ZY']
+        return gate_table[has_z][has_x]
+
+    decomposition = DensePauliString(''.join(select(i) for i in reversed(range(n))))
+
+    guess = protocols.unitary(decomposition)
+    if np.abs(guess[x_msk, 0]) < eps:
+        return None
+    phase = U[x_msk, 0] / guess[x_msk, 0]
+    phase /= np.abs(phase)  # Make sure |phase| = 1 to avoid rounding issues.
+
+    decomposition = DensePauliString(
+        ''.join(select(i) for i in reversed(range(n))), coefficient=phase
+    )
+
+    if not _validate_decomposition(decomposition, U, eps):
+        return None
+
+    return decomposition

cirq/transformers/analytical_decompositions/pauli_string_decomposition_test.py

@@ -0,0 +1,58 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import cast
+import itertools
+import cmath
+import pytest
+
+import numpy as np
+
+from cirq.ops import DensePauliString, T
+from cirq import protocols
+from cirq.transformers.analytical_decompositions import unitary_to_pauli_string
+
+
+@pytest.mark.parametrize('phase', [cmath.exp(i * 2 * cmath.pi / 5 * 1j) for i in range(5)])
+@pytest.mark.parametrize(
+    'pauli_string', [''.join(p) for p in itertools.product(['', 'I', 'X', 'Y', 'Z'], repeat=4)]
+)
+def test_unitary_to_pauli_string(pauli_string: str, phase: complex):
+    want = DensePauliString(pauli_string, coefficient=phase)
+    got = unitary_to_pauli_string(protocols.unitary(want))
+    assert got is not None
+    assert np.all(want.pauli_mask == got.pauli_mask)
+    assert np.isclose(cast(np.complex128, want.coefficient), cast(np.complex128, got.coefficient))
+
+
+def test_unitary_to_pauli_string_non_pauli_input():
+    got = unitary_to_pauli_string(protocols.unitary(T))
+    assert got is None
+
+    got = unitary_to_pauli_string(np.array([[1, 0], [1, 0]]))
+    assert got is None
+
+    got = unitary_to_pauli_string(np.array([[1, 1], [0, 2]]))
+    assert got is None
+
+    got = unitary_to_pauli_string(np.array([[0, 0.5], [1, -1]]), eps=1.1)
+    assert got is None
+
+
+def test_invalid_input():
+    with pytest.raises(ValueError, match='Input has a non-square shape.*'):
+        _ = unitary_to_pauli_string(np.zeros((2, 3)))
+
+    with pytest.raises(ValueError, match='Input dimension [0-9]* isn\'t a power of 2'):
+        _ = unitary_to_pauli_string(np.zeros((3, 3)))

cirq/transformers/analytical_decompositions/quantum_shannon_decomposition.py

@@ -0,0 +1,230 @@
+# Copyright 2023 The Cirq Developers
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+"""Utility methods for decomposing arbitrary n-qubit (2^n x 2^n) unitary.
+
+Based on:
+Synthesis of Quantum Logic Circuits. Tech. rep. 2006,
+https://arxiv.org/abs/quant-ph/0406176
+"""
+from typing import List, Callable, TYPE_CHECKING
+
+from scipy.linalg import cossin
+
+import numpy as np
+
+from cirq import ops
+from cirq.linalg import decompositions, predicates
+
+if TYPE_CHECKING:
+    import cirq
+    from cirq.ops import op_tree
+
+
+def quantum_shannon_decomposition(qubits: 'List[cirq.Qid]', u: np.ndarray) -> 'op_tree.OpTree':
+    """Decomposes n-qubit unitary into CX/YPow/ZPow/CNOT gates, preserving global phase.
+
+    The algorithm is described in Shende et al.:
+    Synthesis of Quantum Logic Circuits. Tech. rep. 2006,
+    https://arxiv.org/abs/quant-ph/0406176
+
+    Args:
+        qubits: List of qubits in order of significance
+        u: Numpy array for unitary matrix representing gate to be decomposed
+
+    Calls:
+        (Base Case)
+        1. _single_qubit_decomposition
+            OR
+        (Recursive Case)
+        1. _msb_demuxer
+        2. _multiplexed_cossin
+        3. _msb_demuxer
+
+    Yields:
+        A single 2-qubit or 1-qubit operations from OP TREE
+        composed from the set
+           { CNOT, rz, ry, ZPowGate }
+
+    Raises:
+        ValueError: If the u matrix is non-unitary
+        ValueError: If the u matrix is not of shape (2^n,2^n)
+    """
+    if not predicates.is_unitary(u):  # Check that u is unitary
+        raise ValueError(
+            "Expected input matrix u to be unitary, \
+                but it fails cirq.is_unitary check"
+        )
+
+    n = u.shape[0]
+    if n & (n - 1):
+        raise ValueError(
+            f"Expected input matrix u to be a (2^n x 2^n) shaped numpy array, \
+                but instead got shape {u.shape}"
+        )
+
+    if n == 2:
+        # Yield a single-qubit decomp if u is 2x2
+        yield from _single_qubit_decomposition(qubits[0], u)
+        return
+
+    # Perform a cosine-sine (linalg) decomposition on u
+    #   X   =   [ u1 , 0  ] [ cos(theta) , -sin(theta) ] [ v1 , 0  ]
+    #           [ 0  , u2 ] [ sin(theta) ,  cos(theta) ] [ 0  , v2 ]
+    (u1, u2), theta, (v1, v2) = cossin(u, n / 2, n / 2, separate=True)
+
+    # Yield ops from decomposition of multiplexed v1/v2 part
+    yield from _msb_demuxer(qubits, v1, v2)
+
+    # Observe that middle part looks like Σ_i( Ry(theta_i)⊗|i><i| )
+    # Then most significant qubit is Ry multiplexed over all other qubits
+    # Yield ops from multiplexed Ry part
+    yield from _multiplexed_cossin(qubits, theta, ops.ry)
+
+    # Yield ops from decomposition of multiplexed u1/u2 part
+    yield from _msb_demuxer(qubits, u1, u2)
+
+
+def _single_qubit_decomposition(qubit: 'cirq.Qid', u: np.ndarray) -> 'op_tree.OpTree':
+    """Decomposes single-qubit gate, and returns list of operations, keeping phase invariant.
+
+    Args:
+        qubit: Qubit on which to apply operations
+        u: (2 x 2) Numpy array for unitary representing 1-qubit gate to be decomposed
+
+    Yields:
+        A single operation from OP TREE of 3 operations (rz,ry,ZPowGate)
+    """
+    # Perform native ZYZ decomposition
+    phi_0, phi_1, phi_2 = decompositions.deconstruct_single_qubit_matrix_into_angles(u)
+
+    # Determine global phase picked up
+    phase = np.angle(u[0, 0] / (np.exp(-1j * (phi_0) / 2) * np.cos(phi_1 / 2)))
+
+    # Append first two operations operations
+    yield ops.rz(phi_0).on(qubit)
+    yield ops.ry(phi_1).on(qubit)
+
+    # Append third operation with global phase added
+    yield ops.ZPowGate(exponent=phi_2 / np.pi, global_shift=phase / phi_2).on(qubit)
+
+
+def _msb_demuxer(
+    demux_qubits: 'List[cirq.Qid]', u1: np.ndarray, u2: np.ndarray
+) -> 'op_tree.OpTree':
+    """Demultiplexes a unitary matrix that is multiplexed in its most-significant-qubit.
+
+    Decomposition structure:
+      [ u1 , 0  ]  =  [ V , 0 ][ D , 0  ][ W , 0 ]
+      [ 0  , u2 ]     [ 0 , V ][ 0 , D* ][ 0 , W ]
+
+      Gives: ( u1 )( u2* ) = ( V )( D^2 )( V* )
+         and:  W = ( D )( V* )( u2 )
+
+    Args:
+        demux_qubits: Subset of total qubits involved in this unitary gate
+        u1: Upper-left quadrant of total unitary to be decomposed (see diagram)
+        u2: Lower-right quadrant of total unitary to be decomposed (see diagram)
+
+    Calls:
+        1. quantum_shannon_decomposition
+        2. _multiplexed_cossin
+        3. quantum_shannon_decomposition
+
+    Yields: Single operation from OP TREE of 2-qubit and 1-qubit operations
+    """
+    # Perform a diagonalization to find values
+    u = u1 @ u2.T.conjugate()
+    dsquared, V = np.linalg.eig(u)
+    d = np.sqrt(dsquared)
+    D = np.diag(d)
+    W = D @ V.T.conjugate() @ u2
+
+    # Last term is given by ( I ⊗ W ), demultiplexed
+    # Remove most-significant (demuxed) control-qubit
+    # Yield operations for QSD on W
+    yield from quantum_shannon_decomposition(demux_qubits[1:], W)
+
+    # Use complex phase of d_i to give theta_i (so d_i* gives -theta_i)
+    # Observe that middle part looks like Σ_i( Rz(theta_i)⊗|i><i| )
+    # Yield ops from multiplexed Rz part
+    yield from _multiplexed_cossin(demux_qubits, -np.angle(d), ops.rz)
+
+    # Yield operations for QSD on V
+    yield from quantum_shannon_decomposition(demux_qubits[1:], V)
+
+
+def _nth_gray(n: int) -> int:
+    # Return the nth Gray Code number
+    return n ^ (n >> 1)
+
+
+def _multiplexed_cossin(
+    cossin_qubits: 'List[cirq.Qid]', angles: List[float], rot_func: Callable = ops.ry
+) -> 'op_tree.OpTree':
+    """Performs a multiplexed rotation over all qubits in this unitary matrix,
+
+    Uses ry and rz multiplexing for quantum shannon decomposition
+
+    Args:
+        cossin_qubits: Subset of total qubits involved in this unitary gate
+        angles: List of angles to be multiplexed over for the given type of rotation
+        rot_func: Rotation function used for this multiplexing implementation
+                    (cirq.ry or cirq.rz)
+
+    Calls:
+        No major calls
+
+    Yields: Single operation from OP TREE from set 1- and 2-qubit gates: {ry,rz,CNOT}
+    """
+    # Most significant qubit is main qubit with rotation function applied
+    main_qubit = cossin_qubits[0]
+
+    # All other qubits are control qubits
+    control_qubits = cossin_qubits[1:]
+
+    for j in range(len(angles)):
+        # The rotation includes a factor of (-1) for each bit in the Gray Code
+        #   if the position of that bit is also 1
+        # The number of factors of -1 is counted using the 1s in the
+        #   binary representation of the (gray(j) & i)
+        # Here, i gives the index for the angle, and
+        #   j is the iteration of the decomposition
+        rotation = sum(
+            -angle if bin(_nth_gray(j) & i).count('1') % 2 else angle
+            for i, angle in enumerate(angles)
+        )
+
+        # Divide by a factor of 2 for each additional select qubit
+        # This is due to the halving in the decomposition applied recursively
+        rotation = rotation * 2 / len(angles)
+
+        # The XOR of the this gray code with the next will give the 1 for the bit
+        #   corresponding to the CNOT select, else 0
+        select_string = _nth_gray(j) ^ _nth_gray(j + 1)
+
+        # Find the index number where the bit is 1
+        select_qubit = next(i for i in range(len(angles)) if (select_string >> i & 1))
+
+        # Negate the value, since we must index starting at most significant qubit
+        # Also the final value will overflow, and it should be the MSB,
+        #   so introduce max function
+        select_qubit = max(-select_qubit - 1, -len(control_qubits))
+
+        # Add a rotation on the main qubit
+        yield rot_func(rotation).on(main_qubit)
+
+        # Add a CNOT from the select qubit to the main qubit
+        yield ops.CNOT(control_qubits[select_qubit], main_qubit)