qiskit 1.3.0__cp39-abi3-macosx_11_0_arm64.whl

qiskit/synthesis/linear_phase/cnot_phase_synth.py

@@ -0,0 +1,206 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Implementation of the GraySynth algorithm for synthesizing CNOT-Phase
+circuits with efficient CNOT cost, and the Patel-Hayes-Markov algorithm
+for optimal synthesis of linear (CNOT-only) reversible circuits.
+"""
+from __future__ import annotations
+
+import copy
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.exceptions import QiskitError
+from qiskit.synthesis.linear import synth_cnot_count_full_pmh
+
+
+def synth_cnot_phase_aam(
+    cnots: list[list[int]], angles: list[str], section_size: int = 2
+) -> QuantumCircuit:
+    r"""This function is an implementation of the `GraySynth` algorithm of
+    Amy, Azimadeh and Mosca.
+
+    GraySynth is a heuristic algorithm from [1] for synthesizing small parity networks.
+    It is inspired by Gray codes. Given a set of binary strings :math:`S`
+    (called ``cnots`` bellow), the algorithm synthesizes a parity network for :math:`S` by
+    repeatedly choosing an index :math:`i` to expand and then effectively recursing on
+    the co-factors :math:`S_0` and :math:`S_1`, consisting of the strings :math:`y \in S`,
+    with :math:`y_i = 0` or :math:`1` respectively. As a subset :math:`S` is recursively expanded,
+    ``cx`` gates are applied so that a designated target bit contains the
+    (partial) parity :math:`\chi_y(x)` where :math:`y_i = 1` if and only if :math:`y'_i = 1` for all
+    :math:`y' \in S`. If :math:`S` contains a single element :math:`\{y'\}`, then :math:`y = y'`,
+    and the target bit contains the value :math:`\chi_{y'}(x)` as desired.
+
+    Notably, rather than uncomputing this sequence of ``cx`` (CNOT) gates when a subset :math:`S`
+    is finished being synthesized, the algorithm maintains the invariant
+    that the remaining parities to be computed are expressed over the current state
+    of bits. This allows the algorithm to avoid the 'backtracking' inherent in
+    uncomputing-based methods.
+
+    The algorithm is described in detail in section 4 of [1].
+
+    Args:
+        cnots: A matrix whose columns are the parities to be synthesized
+            e.g.::
+
+                [[0, 1, 1, 1, 1, 1],
+                 [1, 0, 0, 1, 1, 1],
+                 [1, 0, 0, 1, 0, 0],
+                 [0, 0, 1, 0, 1, 0]]
+
+            corresponds to::
+
+                 x1^x2 + x0 + x0^x3 + x0^x1^x2 + x0^x1^x3 + x0^x1
+
+        angles: A list containing all the phase-shift gates which are
+            to be applied, in the same order as in ``cnots``. A number is
+            interpreted as the angle of :math:`p(angle)`, otherwise the elements
+            have to be ``'t'``, ``'tdg'``, ``'s'``, ``'sdg'`` or ``'z'``.
+
+        section_size: The size of every section in the Patel–Markov–Hayes algorithm.
+            ``section_size`` must be a factor of the number of qubits.
+
+    Returns:
+        The decomposed quantum circuit.
+
+    Raises:
+        QiskitError: when dimensions of ``cnots`` and ``angles`` don't align.
+
+    References:
+        1. Matthew Amy, Parsiad Azimzadeh, and Michele Mosca.
+           *On the controlled-NOT complexity of controlled-NOT–phase circuits.*,
+           Quantum Science and Technology 4.1 (2018): 015002.
+           `arXiv:1712.01859 <https://arxiv.org/abs/1712.01859>`_
+    """
+    num_qubits = len(cnots)
+
+    # Create a quantum circuit on num_qubits
+    qcir = QuantumCircuit(num_qubits)
+
+    if len(cnots[0]) != len(angles):
+        raise QiskitError('Size of "cnots" and "angles" do not match.')
+
+    range_list = list(range(num_qubits))
+    epsilon = num_qubits
+    sta = []
+    cnots_copy = np.transpose(np.array(copy.deepcopy(cnots)))
+    # This matrix keeps track of the state in the algorithm
+    state = np.eye(num_qubits).astype("int")
+
+    # Check if some phase-shift gates can be applied, before adding any C-NOT gates
+    for qubit in range(num_qubits):
+        index = 0
+        for icnots in cnots_copy:
+            if np.array_equal(icnots, state[qubit]):
+                if angles[index] == "t":
+                    qcir.t(qubit)
+                elif angles[index] == "tdg":
+                    qcir.tdg(qubit)
+                elif angles[index] == "s":
+                    qcir.s(qubit)
+                elif angles[index] == "sdg":
+                    qcir.sdg(qubit)
+                elif angles[index] == "z":
+                    qcir.z(qubit)
+                else:
+                    qcir.p(angles[index] % np.pi, qubit)
+                del angles[index]
+                cnots_copy = np.delete(cnots_copy, index, axis=0)
+                if index == len(cnots_copy):
+                    break
+                index -= 1
+            index += 1
+
+    # Implementation of the pseudo-code (Algorithm 1) in the aforementioned paper
+    sta.append([cnots, range_list, epsilon])
+    while sta:
+        [cnots, ilist, qubit] = sta.pop()
+        if cnots == []:
+            continue
+        if 0 <= qubit < num_qubits:
+            condition = True
+            while condition:
+                condition = False
+                for j in range(num_qubits):
+                    if (j != qubit) and (sum(cnots[j]) == len(cnots[j])):
+                        condition = True
+                        qcir.cx(j, qubit)
+                        state[qubit] ^= state[j]
+                        index = 0
+                        for icnots in cnots_copy:
+                            if np.array_equal(icnots, state[qubit]):
+                                if angles[index] == "t":
+                                    qcir.t(qubit)
+                                elif angles[index] == "tdg":
+                                    qcir.tdg(qubit)
+                                elif angles[index] == "s":
+                                    qcir.s(qubit)
+                                elif angles[index] == "sdg":
+                                    qcir.sdg(qubit)
+                                elif angles[index] == "z":
+                                    qcir.z(qubit)
+                                else:
+                                    qcir.p(angles[index] % np.pi, qubit)
+                                del angles[index]
+                                cnots_copy = np.delete(cnots_copy, index, axis=0)
+                                if index == len(cnots_copy):
+                                    break
+                                index -= 1
+                            index += 1
+                        for x in _remove_duplicates(sta + [[cnots, ilist, qubit]]):
+                            [cnotsp, _, _] = x
+                            if cnotsp == []:
+                                continue
+                            for ttt in range(len(cnotsp[j])):
+                                cnotsp[j][ttt] ^= cnotsp[qubit][ttt]
+        if ilist == []:
+            continue
+        # See line 18 in pseudo-code of Algorithm 1 in the aforementioned paper
+        # this choice of j maximizes the size of the largest subset (S_0 or S_1)
+        # and the larger a subset, the closer it gets to the ideal in the
+        # Gray code of one CNOT per string.
+        j = ilist[np.argmax([[max(row.count(0), row.count(1)) for row in cnots][k] for k in ilist])]
+        cnots0 = []
+        cnots1 = []
+        for y in list(map(list, zip(*cnots))):
+            if y[j] == 0:
+                cnots0.append(y)
+            elif y[j] == 1:
+                cnots1.append(y)
+        cnots0 = list(map(list, zip(*cnots0)))
+        cnots1 = list(map(list, zip(*cnots1)))
+        if qubit == epsilon:
+            sta.append([cnots1, list(set(ilist).difference([j])), j])
+        else:
+            sta.append([cnots1, list(set(ilist).difference([j])), qubit])
+        sta.append([cnots0, list(set(ilist).difference([j])), qubit])
+    qcir &= synth_cnot_count_full_pmh(state, section_size).inverse()
+    return qcir
+
+
+def _remove_duplicates(lists):
+    """
+    Remove duplicates in list
+
+    Args:
+        lists (list): a list which may contain duplicate elements.
+
+    Returns:
+        list: a list which contains only unique elements.
+    """
+
+    unique_list = []
+    for element in lists:
+        if element not in unique_list:
+            unique_list.append(element)
+    return unique_list

qiskit/synthesis/linear_phase/cx_cz_depth_lnn.py

@@ -0,0 +1,262 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""
+Given -CZ-CX- transformation (a layer consisting only CNOT gates
+    followed by a layer consisting only CZ gates)
+Return a depth-5n circuit implementation of the -CZ-CX- transformation over LNN.
+
+Args:
+    mat_z: n*n symmetric binary matrix representing a -CZ- circuit
+    mat_x: n*n invertable binary matrix representing a -CX- transformation
+
+Output:
+    QuantumCircuit: :class:`.QuantumCircuit` object containing a depth-5n circuit to implement -CZ-CX-
+
+References:
+    [1] S. A. Kutin, D. P. Moulton, and L. M. Smithline, "Computation at a distance," 2007.
+    [2] D. Maslov and W. Yang, "CNOT circuits need little help to implement arbitrary
+        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
+
+
+def synth_cx_cz_depth_line_my(mat_x: np.ndarray, mat_z: np.ndarray) -> QuantumCircuit:
+    """
+    Joint synthesis of a -CZ-CX- circuit for linear nearest neighbor (LNN) connectivity,
+    with 2-qubit depth at most 5n, based on Maslov and Yang.
+    This method computes the CZ circuit inside the CX circuit via phase gate insertions.
+
+    Args:
+        mat_z : a boolean symmetric matrix representing a CZ circuit.
+            ``mat_z[i][j]=1`` represents a ``cz(i,j)`` gate
+
+        mat_x : a boolean invertible matrix representing a CX circuit.
+
+    Returns:
+        A circuit implementation of a CX circuit following a CZ circuit,
+        denoted as a -CZ-CX- circuit,in two-qubit depth at most ``5n``, for LNN connectivity.
+
+    References:
+        1. Kutin, S., Moulton, D. P., Smithline, L.,
+           *Computation at a distance*, Chicago J. Theor. Comput. Sci., vol. 2007, (2007),
+           `arXiv:quant-ph/0701194 <https://arxiv.org/abs/quant-ph/0701194>`_
+        2. Dmitri Maslov, Willers Yang, *CNOT circuits need little help to implement arbitrary
+           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

qiskit/synthesis/linear_phase/cz_depth_lnn.py

@@ -0,0 +1,58 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 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.
+
+"""
+Synthesis of an n-qubit circuit containing only CZ gates for
+linear nearest neighbor (LNN) connectivity, using CX and phase (S, Sdg or Z) gates.
+The two-qubit depth of the circuit is bounded by 2*n+2.
+This algorithm reverts the order of qubits.
+
+References:
+    [1]: Dmitri Maslov, Martin Roetteler,
+         Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations,
+         `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+"""
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+
+from qiskit._accelerate.synthesis.linear_phase import (
+    synth_cz_depth_line_mr as synth_cz_depth_line_mr_inner,
+)
+
+
+def synth_cz_depth_line_mr(mat: np.ndarray) -> QuantumCircuit:
+    r"""Synthesis of a CZ circuit for linear nearest neighbor (LNN) connectivity,
+    based on Maslov and Roetteler.
+
+    Note that this method *reverts* the order of qubits in the circuit,
+    and returns a circuit containing :class:`.CXGate`\s and phase gates
+    (:class:`.SGate`, :class:`.SdgGate` or :class:`.ZGate`).
+
+    Args:
+        mat: an upper-diagonal matrix representing the CZ circuit.
+            ``mat[i][j]=1 for i<j`` represents a ``cz(i,j)`` gate
+
+    Returns:
+        A circuit implementation of the CZ circuit of depth :math:`2n+2` for LNN
+        connectivity.
+
+    References:
+        1. Dmitri Maslov, Martin Roetteler,
+           *Shorter stabilizer circuits via Bruhat decomposition and quantum circuit transformations*,
+           `arXiv:1705.09176 <https://arxiv.org/abs/1705.09176>`_.
+    """
+
+    # Call Rust implementaton
+    return QuantumCircuit._from_circuit_data(
+        synth_cz_depth_line_mr_inner(mat.astype(bool)), add_regs=True
+    )

qiskit/synthesis/multi_controlled/__init__.py

@@ -0,0 +1,24 @@
+# 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"""
+
+from .mcmt_vchain import synth_mcmt_vchain
+from .mcx_synthesis import (
+    synth_mcx_n_dirty_i15,
+    synth_mcx_n_clean_m15,
+    synth_mcx_1_clean_b95,
+    synth_mcx_gray_code,
+    synth_mcx_noaux_v24,
+    synth_c3x,
+    synth_c4x,
+)

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