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

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