classiq 0.93.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/open_library/functions/lcu.py

@@ -9,6 +9,7 @@ from classiq.open_library.functions.utility_functions import switch
 from classiq.qmod.builtins.functions import IDENTITY, X, Y, Z, inplace_prepare_state
 from classiq.qmod.builtins.operations import (
     control,
+    if_,
     repeat,
     within_apply,
 )
@@ -16,7 +17,7 @@ from classiq.qmod.builtins.structs import IndexedPauli, SparsePauliOp
 from classiq.qmod.cparam import CArray
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
-from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.quantum_callable import QCallable, QCallableList
 
 
 @qfunc
@@ -36,27 +37,23 @@ def apply_pauli_term(pauli_string: CArray[IndexedPauli], x: QArray[QBit]) -> Non
 
 
 @qfunc
-def lcu(
+def prepare_select(
     coefficients: list[float],
-    unitaries: QCallableList,
+    select: QCallable[QNum],
     block: QNum[Literal["max(ceiling(log(coefficients.len, 2)), 1)"]],
 ) -> None:
     """
     [Qmod Classiq-library function]
 
-    Implements a general linear combination of unitaries (LCU) procedure. The algorithm prepares a superposition
-    over the `unitaries` according to `magnitudes`, and then conditionally applies each unitary controlled by the `block`.
-
-    The operation is of the form:
-
-    $$\\sum_j \\alpha_j U_j$$
-
-    where $U_j$ is a unitary operation applied to `data`.
+    Applies the 'Prepare-Select' scheme used for Linear Combination of Unitaries (LCU).
+    Compared to the `lcu` function, here the Select operator should be provided directly, allowing to take advantage of some structure for
+    the unitaries of the LCU.
+    The select operator is defined by: $\\mathrm{SELECT} = \\sum_{j=0}^{m-1} |j\rangle\\!\\langle j|_{block} \\otimes U_j$.
 
     Args:
         coefficients: L1-normalized array of  $\\{ \\alpha_j \\}$ of the LCU coefficients.
-        unitaries: A list of quantum callable functions to be applied conditionally.
-        block: Quantum variable that holds the superposition index used for conditional application of each unitary.
+        select: A quantum callable to be applied between the state preparation and its inverse. Its input is the `block` variable, labeling the index of the unitaries in the LCU.
+        block: A Quantum variable that holds the index used as input for the 'select' operator.
     """
     coefficients = coefficients + [0] * (
         2**block.size - len(coefficients)  # type:ignore[operator]
@@ -68,16 +65,48 @@ def lcu(
     within_apply(
         lambda: inplace_prepare_state(magnitudes, 0, block),
         lambda: [
-            repeat(
-                count=unitaries.len,
-                iteration=lambda i: control(block == i, lambda: unitaries[i]()),
+            select(block),
+            if_(
+                not np.allclose(np.array(phases) % (2 * np.pi), 0),
+                lambda: apply_phase_table(phases, block),
             ),
-            # TODO: replace to sparse constant phase
-            apply_phase_table(phases, block),
         ],
     )
 
 
+@qfunc
+def lcu(
+    coefficients: list[float],
+    unitaries: QCallableList,
+    block: QNum[Literal["max(ceiling(log(coefficients.len, 2)), 1)"]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Implements a general linear combination of unitaries (LCU) procedure. The algorithm prepares a superposition
+    over the `unitaries` according to the given `coefficients`, and then conditionally applies each unitary controlled by the `block`.
+
+    The operation is of the form:
+
+    $$\\sum_j \\alpha_j U_j$$
+
+    where $U_j$ is a unitary operation applied to `data`.
+
+    Args:
+        coefficients: L1-normalized array of  $\\{ \\alpha_j \\}$ of the LCU coefficients.
+        unitaries: A list of quantum callable functions to be applied conditionally.
+        block: Quantum variable that holds the superposition index used for conditional application of each unitary.
+    """
+    prepare_select(
+        coefficients,
+        lambda _block: repeat(
+            count=unitaries.len,
+            iteration=lambda i: control(_block == i, lambda: unitaries[i]()),
+        ),
+        block,
+    )
+
+
 @qfunc
 def lcu_pauli(
     operator: SparsePauliOp,

classiq/open_library/functions/modular_exponentiation.py

@@ -8,11 +8,12 @@ from classiq.qmod.builtins.operations import (
     control,
     invert,
     repeat,
+    skip_control,
     within_apply,
 )
 from classiq.qmod.cparam import CInt
-from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import Const, Permutable, QArray, QBit
+from classiq.qmod.qfunc import qfunc, qperm
+from classiq.qmod.qmod_variable import Const, QArray, QBit
 from classiq.qmod.symbolic import min, mod_inverse
 
 
@@ -51,9 +52,9 @@ def qft_space_add_const(value: CInt, phi_b: QArray[QBit]) -> None:
     )
 
 
-@qfunc(unchecked=["phi_b"])
+@qperm(disable_perm_check=True)
 def cc_modular_add(
-    n: CInt, a: CInt, phi_b: Permutable[QArray[QBit]], c1: Const[QBit], c2: Const[QBit]
+    n: CInt, a: CInt, phi_b: QArray[QBit], c1: Const[QBit], c2: Const[QBit]
 ) -> None:
     """
     [Qmod Classiq-library function]
@@ -91,11 +92,11 @@ def cc_modular_add(
     free(aux)
 
 
-@qfunc(unchecked=["b"])
+@qperm(disable_perm_check=True)
 def c_modular_multiply(
     n: CInt,
     a: CInt,
-    b: Permutable[QArray[QBit]],
+    b: QArray[QBit],
     x: Const[QArray[QBit]],
     ctrl: Const[QBit],
 ) -> None:
@@ -123,8 +124,8 @@ def c_modular_multiply(
     )
 
 
-@qfunc
-def multiswap(x: Permutable[QArray[QBit]], y: Permutable[QArray[QBit]]) -> None:
+@qperm
+def multiswap(x: QArray[QBit], y: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -164,6 +165,90 @@ def inplace_c_modular_multiply(n: CInt, a: CInt, x: QArray[QBit], ctrl: QBit) ->
     free(b)
 
 
+@qperm(disable_perm_check=True)
+def modular_add_qft_space(n: CInt, a: CInt, phi_b: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Adds a constant `a` to a quantum number `phi_b` modulo the constant `n`.
+    The quantum number `phi_b` is assumed to be in the QFT space.
+
+    Args:
+        n: The modulo number.
+        a: The constant to add to the quantum number.
+        phi_b: The quantum number to which the constant is added.
+
+    """
+    aux = QBit()
+
+    allocate(aux)
+    qft_space_add_const(a, phi_b),
+    skip_control(
+        lambda: (
+            invert(lambda: qft_space_add_const(n, phi_b)),
+            _check_msb(1, phi_b, aux),
+            control(aux, lambda: qft_space_add_const(n, phi_b)),
+        )
+    )
+    invert(lambda: qft_space_add_const(a, phi_b))
+    skip_control(lambda: _check_msb(0, phi_b, aux))
+    qft_space_add_const(a, phi_b)
+    free(aux)
+
+
+@qperm(disable_perm_check=True)
+def modular_multiply(
+    n: CInt,
+    a: CInt,
+    b: QArray[QBit],
+    x: Const[QArray[QBit]],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Performs out-of-place multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`,
+    and adds the result to a quantum array `b` (Applies $b += xa \\mod n$).
+
+    Args:
+        n: The modulo number. Should be non-negative.
+        a: The classical factor. Should be non-negative.
+        b: The quantum number added to the multiplication result. Stores the result of the multiplication.
+        x: The quantum factor.
+    """
+    within_apply(
+        lambda: qft(b),
+        lambda: repeat(
+            count=x.len,
+            iteration=lambda index: control(
+                x[index], lambda: modular_add_qft_space(n, (a * (2**index)) % n, b)
+            ),
+        ),
+    )
+
+
+@qfunc
+def inplace_modular_multiply(n: CInt, a: CInt, x: QArray[QBit]) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Performs multiplication of a quantum number `x` by a classical number `a` modulo classical number `n`
+    (Applies $x=xa \\mod n$).
+
+    Args:
+        n: The modulo number. Should be non-negative.
+        a: The classical factor. Should be non-negative.
+        x: The quantum factor.
+
+    Comment: It is assumed that `a` has an inverse modulo `n`
+    """
+    b: QArray[QBit] = QArray(length=x.len + 1)
+    allocate(b)
+    modular_multiply(n, a, b, x)
+    multiswap(x, b)
+    invert(lambda: modular_multiply(n, mod_inverse(a, n), b, x))
+    free(b)
+
+
 @qfunc
 def modular_exp(n: CInt, a: CInt, x: QArray[QBit], power: QArray[QBit]) -> None:
     """

classiq/open_library/functions/qsvt.py

@@ -1,8 +1,10 @@
-from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RZ, H, U, X, Z
+from typing import Literal
+
+from classiq.qmod.builtins.functions.standard_gates import RZ, H, U, X, Z
 from classiq.qmod.builtins.operations import control, if_, invert, repeat, within_apply
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CInt, CReal
-from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.qmod_variable import QBit
 from classiq.qmod.quantum_callable import QCallable
 from classiq.qmod.symbolic import floor, min as qmin
 
@@ -11,10 +13,9 @@ from classiq.qmod.symbolic import floor, min as qmin
 def qsvt_step(
     phase1: CReal,
     phase2: CReal,
-    proj_cnot_1: QCallable[QArray[QBit], QBit],
-    proj_cnot_2: QCallable[QArray[QBit], QBit],
-    u: QCallable[QArray[QBit]],
-    qvar: QArray[QBit],
+    proj_cnot_1: QCallable[QBit],
+    proj_cnot_2: QCallable[QBit],
+    u: QCallable,
     aux: QBit,
 ) -> None:
     """
@@ -29,25 +30,23 @@ def qsvt_step(
     Args:
         phase1: 1st rotation phase.
         phase2: 2nd rotation phase.
-        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        u: A block encoded unitary matrix.
-        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        u: A block encoding unitary matrix.
         aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
     """
-    u(qvar)
-    projector_controlled_phase(phase1, proj_cnot_2, qvar, aux)
-    invert(lambda: u(qvar))
-    projector_controlled_phase(phase2, proj_cnot_1, qvar, aux)
+    u()
+    projector_controlled_phase(phase1, proj_cnot_2, aux)
+    invert(lambda: u())
+    projector_controlled_phase(phase2, proj_cnot_1, aux)
 
 
 @qfunc
 def qsvt(
     phase_seq: CArray[CReal],
-    proj_cnot_1: QCallable[QArray[QBit], QBit],
-    proj_cnot_2: QCallable[QArray[QBit], QBit],
-    u: QCallable[QArray[QBit]],
-    qvar: QArray[QBit],
+    proj_cnot_1: QCallable[QBit],
+    proj_cnot_2: QCallable[QBit],
+    u: QCallable,
     aux: QBit,
 ) -> None:
     """
@@ -72,15 +71,14 @@ def qsvt(
 
     Args:
         phase_seq: A sequence of phase angles of length d+1.
-        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        u: A block encoded unitary matrix.
-        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        u: A block encoding unitary matrix.
         aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
     """
     H(aux)
 
-    projector_controlled_phase(phase_seq[0], proj_cnot_1, qvar, aux)
+    projector_controlled_phase(phase_seq[0], proj_cnot_1, aux)
     repeat(
         count=floor((phase_seq.len - 1) / 2),
         iteration=lambda index: qsvt_step(
@@ -89,20 +87,18 @@ def qsvt(
             proj_cnot_1,
             proj_cnot_2,
             u,
-            qvar,
             aux,
         ),
     )
 
     if_(
         condition=phase_seq.len % 2 == 1,
-        then=lambda: IDENTITY(qvar),
+        then=lambda: None,
         else_=lambda: (
-            u(qvar),
+            u(),
             projector_controlled_phase(
                 phase_seq[phase_seq.len - 1],
                 proj_cnot_2,
-                qvar,
                 aux,
             ),
         ),
@@ -114,8 +110,7 @@ def qsvt(
 @qfunc
 def projector_controlled_phase(
     phase: CReal,
-    proj_cnot: QCallable[QArray[QBit], QBit],
-    qvar: QArray[QBit],
+    proj_cnot: QCallable[QBit],
     aux: QBit,
 ) -> None:
     """
@@ -130,18 +125,16 @@ def projector_controlled_phase(
     Args:
         phase: A rotation phase.
         proj_cnot: Projector-controlled-not unitary that sets an auxilliary qubit to |1> when the state is in the projection.
-        qvar: The quantum variable to which the rotation applies, which resides in the entire block encoding space.
-        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotation. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+        aux: A zero auxilliary qubit, used for the projector-controlled-phase rotation.
     """
-    within_apply(lambda: proj_cnot(qvar, aux), lambda: RZ(phase, aux))
+    within_apply(lambda: proj_cnot(aux), lambda: RZ(phase, aux))
 
 
 @qfunc
 def qsvt_inversion(
     phase_seq: CArray[CReal],
-    block_encoding_cnot: QCallable[QArray[QBit], QBit],
-    u: QCallable[QArray[QBit]],
-    qvar: QArray[QBit],
+    block_encoding_cnot: QCallable[QBit],
+    u: QCallable,
     aux: QBit,
 ) -> None:
     """
@@ -152,17 +145,15 @@ def qsvt_inversion(
 
     Args:
         phase_seq: A sequence of phase angles of length d+1, corresponding to an odd polynomial approximation of the scaled inverse function.
-        block_encoding_cnot: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        u: A block encoded unitary matrix.
-        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        block_encoding_cnot: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable that should be set to |1> when the state is in the block.
+        u: A block encoding unitary matrix.
         aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
     """
     qsvt(
         phase_seq,
         block_encoding_cnot,
         block_encoding_cnot,
-        lambda x: invert(lambda: u(x)),
-        qvar,
+        lambda: invert(lambda: u()),
         aux,
     )
 
@@ -171,8 +162,7 @@ def qsvt_inversion(
 def projector_controlled_double_phase(
     phase_even: CReal,
     phase_odd: CReal,
-    proj_cnot: QCallable[QArray[QBit], QBit],
-    qvar: QArray[QBit],
+    proj_cnot: QCallable[QBit],
     aux: QBit,
     lcu: QBit,
 ) -> None:
@@ -187,15 +177,15 @@ def projector_controlled_double_phase(
     $$
 
     Args:
-        phase_even: Rotation phase, corresponds to 'lcu'=1.
-        phase_odd: Rotation phase, corresponds to 'lcu'=0.
+        phase_even: Rotation phase, corresponds to 'lcu'=0.
+        phase_odd: Rotation phase, corresponds to 'lcu'=1.
         proj_cnot: Projector-controlled-not unitary that sets an auxilliary qubit to |1> when the state is in the projection.
-        qvar: The quantum variable to which the rotation applies, which resides in the entire block encoding space.
         aux: A zero auxilliary qubit, used for the projector-controlled-phase rotation. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
+        lcu: The quantum variable used for controlling the phase assignment.
     """
     within_apply(
-        lambda: proj_cnot(qvar, aux),
-        lambda: control(lcu, lambda: RZ(phase_even, aux), lambda: RZ(phase_odd, aux)),
+        lambda: proj_cnot(aux),
+        lambda: control(lcu, lambda: RZ(phase_odd, aux), lambda: RZ(phase_even, aux)),
     )
 
 
@@ -203,10 +193,9 @@ def projector_controlled_double_phase(
 def qsvt_lcu_step(
     phases_even: CArray[CReal],
     phases_odd: CArray[CReal],
-    proj_cnot_1: QCallable[QArray[QBit], QBit],
-    proj_cnot_2: QCallable[QArray[QBit], QBit],
-    u: QCallable[QArray[QBit]],
-    qvar: QArray[QBit],
+    proj_cnot_1: QCallable[QBit],
+    proj_cnot_2: QCallable[QBit],
+    u: QCallable,
     aux: QBit,
     lcu: QBit,
 ) -> None:
@@ -222,20 +211,19 @@ def qsvt_lcu_step(
     Args:
         phases_even: 2 rotation phases for the even polynomial
         phases_odd: 2 rotation phases for the odd polynomial
-        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        u: A block encoded unitary matrix.
-        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        u: A block encoding unitary matrix.
         aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
         lcu: A qubit used for the combination of 2 polynomials within a single qsvt application
     """
-    u(qvar)
+    u()
     projector_controlled_double_phase(
-        phases_even[0], phases_odd[0], proj_cnot_2, qvar, aux, lcu
+        phases_even[0], phases_odd[0], proj_cnot_2, aux, lcu
     )
-    invert(lambda: u(qvar))
+    invert(lambda: u())
     projector_controlled_double_phase(
-        phases_even[1], phases_odd[1], proj_cnot_1, qvar, aux, lcu
+        phases_even[1], phases_odd[1], proj_cnot_1, aux, lcu
     )
 
 
@@ -243,10 +231,9 @@ def qsvt_lcu_step(
 def qsvt_lcu(
     phase_seq_even: CArray[CReal],
     phase_seq_odd: CArray[CReal],
-    proj_cnot_1: QCallable[QArray[QBit], QBit],
-    proj_cnot_2: QCallable[QArray[QBit], QBit],
-    u: QCallable[QArray[QBit]],
-    qvar: QArray[QBit],
+    proj_cnot_1: QCallable[QBit],
+    proj_cnot_2: QCallable[QBit],
+    u: QCallable,
     aux: QBit,
     lcu: QBit,
 ) -> None:
@@ -262,23 +249,22 @@ def qsvt_lcu(
 
     The function is intended to be called within a context of LCU, where it is called as the SELECT operator, and wrapped
     with initialization of the `lcu` qubit to get the desired combination coefficients.
-    The even polynomial corresponds to the case where the $lcu=|0\\rangle$, while the odd to #lcu=|1\\rangle$.
+    The even polynomial corresponds to the case where the $lcu=|0\\rangle$, while the odd to $lcu=|1\\rangle$.
 
     Note: the two polynomials should have the same degree up to a difference of 1.
 
     Args:
         phase_seq_odd: A sequence of phase angles of length d+(d%2) for the odd polynomial.
         phase_seq_even: A sequence of phase angles of length d+(d+1)%2 for the even polynomial.
-        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a quantum variable of the same size as qvar, and a qubit that is set to |1> when the state is in the block.
-        u: A block encoded unitary matrix.
-        qvar: The quantum variable to which U is applied, which resides in the entire block encoding space.
+        proj_cnot_1: Projector-controlled-not unitary that locates the encoded matrix columns within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        proj_cnot_2: Projector-controlled-not unitary that locates the encoded matrix rows within U. Accepts a qubit that should be set to |1> when the state is in the block.
+        u: A block encoding unitary matrix.
         aux: A zero auxilliary qubit, used for the projector-controlled-phase rotations. Given as an inout so that qsvt can be used as a building-block in a larger algorithm.
         lcu: A qubit used for the combination of 2 polynomials within a single qsvt application
     """
     H(aux)
     projector_controlled_double_phase(
-        phase_seq_even[0], phase_seq_odd[0], proj_cnot_1, qvar, aux, lcu
+        phase_seq_even[0], phase_seq_odd[0], proj_cnot_1, aux, lcu
     )
     repeat(
         count=floor((qmin(phase_seq_odd.len - 1, phase_seq_even.len - 1)) / 2),
@@ -288,7 +274,6 @@ def qsvt_lcu(
             proj_cnot_1,
             proj_cnot_2,
             u,
-            qvar,
             aux,
             lcu,
         ),
@@ -296,11 +281,11 @@ def qsvt_lcu(
     if_(
         condition=phase_seq_odd.len > phase_seq_even.len,
         then=lambda: control(
-            lcu == 0,
+            lcu,
             lambda: [
-                u(qvar),
+                u(),
                 projector_controlled_phase(
-                    phase_seq_odd[phase_seq_odd.len - 1], proj_cnot_2, qvar, aux
+                    phase_seq_odd[phase_seq_odd.len - 1], proj_cnot_2, aux
                 ),
             ],
         ),
@@ -308,21 +293,20 @@ def qsvt_lcu(
     if_(
         condition=phase_seq_odd.len < phase_seq_even.len,
         then=lambda: (
-            u(qvar),
+            u(),
             projector_controlled_double_phase(
                 phase_seq_even[phase_seq_even.len - 2],
                 phase_seq_odd[phase_seq_odd.len - 1],
                 proj_cnot_2,
-                qvar,
                 aux,
                 lcu,
             ),
             control(
-                lcu,
+                lcu == 0,
                 lambda: [
-                    invert(lambda: u(qvar)),
+                    invert(lambda: u()),
                     projector_controlled_phase(
-                        phase_seq_even[phase_seq_even.len - 1], proj_cnot_1, qvar, aux
+                        phase_seq_even[phase_seq_even.len - 1], proj_cnot_1, aux
                     ),
                 ],
             ),
@@ -342,7 +326,10 @@ def _gqsp_r_gate(theta: CReal, phi: CReal, _lambda: CReal, q: QBit) -> None:
 
 @qfunc
 def gqsp(
-    u: QCallable, aux: QBit, phases: CArray[CArray[CReal], 3], negative_power: CInt  # type: ignore[valid-type]
+    u: QCallable,
+    aux: QBit,
+    phases: CArray[CArray[CReal], Literal[3]],
+    negative_power: CInt,
 ) -> None:
     """
      Implements Generalized Quantum Signal Processing (GQSP), which realizes a