classiq 0.60.1__py3-none-any.whl → 0.62.0__py3-none-any.whl

classiq/qmod/builtins/functions/qaoa_penalty.py

@@ -8,7 +8,7 @@ from classiq.qmod.qmod_parameter import CArray, CInt, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -24,7 +24,7 @@ def qaoa_mixer_layer(b: CReal, target: QArray[QBit]) -> None:
     repeat(target.len, lambda index: RX(b, target[index]))
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_cost_layer(
     g: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
 ) -> None:
@@ -45,7 +45,7 @@ def qaoa_cost_layer(
     suzuki_trotter(hamiltonian, g, 1, 1, target)
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_layer(
     g: CReal, b: CReal, hamiltonian: CArray[PauliTerm], target: QArray[QBit]
 ) -> None:
@@ -69,7 +69,7 @@ def qaoa_layer(
     qaoa_mixer_layer(b, target)
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_init(target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -86,7 +86,7 @@ def qaoa_init(target: QArray[QBit]) -> None:
     repeat(target.len, lambda index: H(target[index]))
 
 
-@qfunc(external=True)
+@qfunc
 def qaoa_penalty(
     num_qubits: CInt,
     params_list: CArray[CReal],

classiq/qmod/builtins/functions/qft_functions.py

@@ -5,7 +5,7 @@ from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.symbolic import pi
 
 
-@qfunc(external=True)
+@qfunc
 def qft_no_swap(qbv: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -32,7 +32,7 @@ def qft_no_swap(qbv: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def qft(target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/qpe.py

@@ -1,15 +1,15 @@
 from classiq.qmod.builtins.functions.qft_functions import qft
 from classiq.qmod.builtins.functions.standard_gates import H
 from classiq.qmod.builtins.functions.utility_functions import apply_to_all
-from classiq.qmod.builtins.operations import bind, control, invert, power, repeat
+from classiq.qmod.builtins.operations import control, invert, power, repeat
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_variable import QArray, QNum
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
 
 
-@qfunc(external=True)
-def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
+@qfunc
+def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
 
@@ -20,22 +20,19 @@ def qpe_flexible(unitary_with_power: QCallable[CInt], phase: QNum) -> None:
         unitary_with_power: A callable that returns the unitary operator $U^k$ given an integer $k$. This callable is used to control the application of powers of the unitary operator.
         phase: The quantum variable that represents the estimated phase (eigenvalue), assuming initialized to zero.
     """
-    phase_array: QArray = QArray("phase_array")
-    bind(phase, phase_array)
-    apply_to_all(H, phase_array)
+    apply_to_all(H, phase)
 
     repeat(
-        count=phase_array.len,
+        count=phase.len,
         iteration=lambda index: control(
-            ctrl=phase_array[index], stmt_block=lambda: unitary_with_power(2**index)
+            ctrl=phase[index], stmt_block=lambda: unitary_with_power(2**index)
         ),
     )
 
-    invert(lambda: qft(phase_array))
-    bind(phase_array, phase)
+    invert(lambda: qft(phase))
 
 
-@qfunc(external=True)
+@qfunc
 def qpe(unitary: QCallable, phase: QNum) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/qsvt.py

@@ -1,13 +1,13 @@
 from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RZ, H
-from classiq.qmod.builtins.operations import if_, invert, repeat
+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, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
 from classiq.qmod.quantum_callable import QCallable
-from classiq.qmod.symbolic import floor
+from classiq.qmod.symbolic import floor, min as qmin
 
 
-@qfunc(external=True)
+@qfunc
 def qsvt_step(
     phase1: CReal,
     phase2: CReal,
@@ -23,7 +23,7 @@ def qsvt_step(
     Applies a single QSVT step, composed of 2 projector-controlled-phase rotations, and applications of the block encoding unitary `u` and its inverse:
 
     $$
-    \\Pi_{\\phi_2}U^{\\dagger}\tilde{\\Pi}_{\\phi_{1}}U
+    \\Pi_{\\phi_2}U^{\\dagger}\\tilde{\\Pi}_{\\phi_{1}}U
     $$
 
     Args:
@@ -41,7 +41,7 @@ def qsvt_step(
     projector_controlled_phase(phase2, proj_cnot_1, qvar, aux)
 
 
-@qfunc(external=True)
+@qfunc
 def qsvt(
     phase_seq: CArray[CReal],
     proj_cnot_1: QCallable[QArray[QBit], QBit],
@@ -53,17 +53,17 @@ def qsvt(
     """
     [Qmod Classiq-library function]
 
-    Implements the Quantum Singular Value Transformation (QSVT) - an algorithmic framework, used to apply polynomial transformations of degree `d` on the singular values of a block encoded matrix, given as the unitary `u`.    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
-    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
+    Implements the Quantum Singular Value Transformation (QSVT) - an algorithmic framework, used to apply polynomial transformations of degree `d` on the singular values of a block encoded matrix, given as the unitary `u`.    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
+    Given a unitary $U$, a list of phase angles  $\\phi_1, \\phi_2, ..., \\phi_{d+1}$ and 2 projector-controlled-not operands $C_{\\Pi}NOT,C_{\\tilde{\\Pi}}NOT$, the QSVT sequence is as follows:
 
     $$
-    \tilde{\\Pi}_{\\phi_{d+1}}U \\prod_{k=1}^{(d-1)/2} (\\Pi_{\\phi_{d-2k}} U^{\\dagger}\tilde{\\Pi}_{\\phi_{d - (2k+1)}}U)\\Pi_{\\phi_{1}}
+    \\tilde{\\Pi}_{\\phi_{d+1}}U \\prod_{k=1}^{(d-1)/2} (\\Pi_{\\phi_{d-2k}} U^{\\dagger}\\tilde{\\Pi}_{\\phi_{d - (2k+1)}}U)\\Pi_{\\phi_{1}}
     $$
 
     for odd $d$, and:
 
     $$
-    \\prod_{k=1}^{d/2} (\\Pi_{\\phi_{d-(2k-1)}} U^{\\dagger}\tilde{\\Pi}_{\\phi_{d-2k}}U)\\Pi_{\\phi_{1}}
+    \\prod_{k=1}^{d/2} (\\Pi_{\\phi_{d-(2k-1)}} U^{\\dagger}\\tilde{\\Pi}_{\\phi_{d-2k}}U)\\Pi_{\\phi_{1}}
     $$
 
     for even $d$.
@@ -111,7 +111,7 @@ def qsvt(
     H(aux)
 
 
-@qfunc(external=True)
+@qfunc
 def projector_controlled_phase(
     phase: CReal,
     proj_cnot: QCallable[QArray[QBit], QBit],
@@ -128,17 +128,15 @@ def projector_controlled_phase(
     $$
 
     Args:
-        phase_seq: A rotation phase.
+        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.
     """
-    proj_cnot(qvar, aux)
-    RZ(phase, aux)
-    proj_cnot(qvar, aux)
+    within_apply(lambda: proj_cnot(qvar, aux), lambda: RZ(phase, aux))
 
 
-@qfunc(external=True)
+@qfunc
 def qsvt_inversion(
     phase_seq: CArray[CReal],
     block_encoding_cnot: QCallable[QArray[QBit], QBit],
@@ -167,3 +165,167 @@ def qsvt_inversion(
         qvar,
         aux,
     )
+
+
+@qfunc
+def projector_controlled_double_phase(
+    phase_even: CReal,
+    phase_odd: CReal,
+    proj_cnot: QCallable[QArray[QBit], QBit],
+    qvar: QArray[QBit],
+    aux: QBit,
+    lcu: QBit,
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Assigns 2 phases to the entire subspace determined by the given projector, each one is controlled differentely on a given `lcu` qvar.
+    Used in the context of the `qsvt_lcu` function. Corresponds to the operation:
+
+    $$
+    \\Pi_{\\phi_{odd}, \\phi_{even}} = (C_{\\Pi}NOT) (C_{lcu=1}e^{-i\\frac{\\phi_{even}}{2}Z}) (C_{lcu=0}e^{-i\\frac{\\phi_{odd}}{2}Z}) (C_{\\Pi}NOT)
+    $$
+
+    Args:
+        phase_even: Rotation phase, corresponds to 'lcu'=1.
+        phase_odd: Rotation phase, corresponds to 'lcu'=0.
+        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.
+    """
+    within_apply(
+        lambda: proj_cnot(qvar, aux),
+        lambda: control(lcu, lambda: RZ(phase_even, aux), lambda: RZ(phase_odd, aux)),
+    )
+
+
+@qfunc
+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],
+    aux: QBit,
+    lcu: QBit,
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies a single QSVT-lcu step, composed of 2 double phase projector-controlled-phase rotations, and applications of the block encoding unitary `u` and its inverse:
+
+    $$
+    (C_{lcu=1}\\Pi^{even}_{\\phi_2})(C_{lcu=0}\\Pi^{odd}_{\\phi_2})U^{\\dagger}(C_{lcu=1}\\tilde{\\Pi}^{even}_{\\phi_1})(C_{lcu=0}\\tilde{\\Pi}^{odd}_{\\phi_1})U
+    $$
+
+    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.
+        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)
+    projector_controlled_double_phase(
+        phases_even[0], phases_odd[0], proj_cnot_2, qvar, aux, lcu
+    )
+    invert(lambda: u(qvar))
+    projector_controlled_double_phase(
+        phases_even[1], phases_odd[1], proj_cnot_1, qvar, aux, lcu
+    )
+
+
+@qfunc
+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],
+    aux: QBit,
+    lcu: QBit,
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Implements the Quantum Singular Value Transformation (QSVT) for a linear combination of odd and even polynomials, so that
+    it is possible to encode a polynomial of indefinite parity, such as approximation to exp(i*A) or exp(A). Should work
+    for Hermitian block encodings.
+
+    The function is equivalent to applying the `qsvt` function for odd and even polynomials with a LCU function, but
+    is more efficient as the two polynomials share the same applications of the given unitary.
+
+    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$.
+
+    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+1 for the odd polynomial.
+        phase_seq_even: A sequence of phase angles of length d+1 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.
+        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
+    )
+    repeat(
+        count=floor((qmin(phase_seq_odd.len, phase_seq_even.len)) / 2),
+        iteration=lambda index: qsvt_lcu_step(
+            phase_seq_even[2 * index + 1 : 2 * index + 3],
+            phase_seq_odd[2 * index + 1 : 2 * index + 3],
+            proj_cnot_1,
+            proj_cnot_2,
+            u,
+            qvar,
+            aux,
+            lcu,
+        ),
+    )
+    if_(
+        condition=phase_seq_odd.len > phase_seq_even.len,
+        then=lambda: control(
+            lcu == 0,
+            lambda: [  # type:ignore[arg-type]
+                u(qvar),  # type:ignore[func-returns-value]
+                projector_controlled_phase(
+                    phase_seq_odd[phase_seq_odd.len - 1], proj_cnot_2, qvar, aux
+                ),
+            ],
+        ),
+    )
+    if_(
+        condition=phase_seq_odd.len < phase_seq_even.len,
+        then=lambda: (  # type:ignore[arg-type]
+            u(qvar),  # type:ignore[func-returns-value]
+            projector_controlled_double_phase(
+                phase_seq_even[phase_seq_even.len - 1],
+                phase_seq_odd[phase_seq_odd.len - 1],
+                proj_cnot_2,
+                qvar,
+                aux,
+                lcu,
+            ),
+            control(
+                lcu,
+                lambda: [  # type:ignore[arg-type]
+                    invert(lambda: u(qvar)),  # type:ignore[func-returns-value]
+                    projector_controlled_phase(
+                        phase_seq_even[phase_seq_even.len - 1], proj_cnot_1, qvar, aux
+                    ),
+                ],
+            ),
+        ),
+    )
+    H(aux)

classiq/qmod/builtins/functions/state_preparation.py

@@ -46,7 +46,7 @@ def allocate(
     pass
 
 
-@qfunc(external=True)
+@qfunc
 def allocate_num(
     num_qubits: CInt,
     is_signed: CBool,
@@ -200,7 +200,7 @@ def prepare_uniform_trimmed_state_apply_rotation(
     )
 
 
-@qfunc(external=True)
+@qfunc
 def _prepare_uniform_trimmed_state_step(
     size_lsb: CInt, ctrl_val: CInt, lsbs_val: CInt, ctrl_var: QNum, rotation_var: QBit
 ) -> None:
@@ -215,7 +215,7 @@ def _prepare_uniform_trimmed_state_step(
     )
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -261,7 +261,7 @@ def prepare_uniform_trimmed_state(m: CInt, q: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -287,7 +287,7 @@ def prepare_uniform_interval_state(start: CInt, end: CInt, q: QArray[QBit]) -> N
     modular_increment(start, q)
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
     """
     [Qmod Classiq-library function]
@@ -319,7 +319,7 @@ def prepare_ghz_state(size: CInt, q: Output[QArray[QBit]]) -> None:
     repeat(floor(log(size - 1, 2)) + 1, inner_lop)  # type:ignore[arg-type]
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
     """
 
@@ -338,7 +338,7 @@ def prepare_exponential_state(rate: CInt, q: QArray[QBit]) -> None:
     repeat(q.len, lambda i: RY(2.0 * atan(exp((-rate * 2.0**i) / 2.0)), q[i]))
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) -> None:
     """
     [Qmod Classiq-library function]
@@ -387,7 +387,7 @@ def prepare_bell_state(state_num: CInt, q: Output[QArray[QBit, Literal[2]]]) ->
     CX(q[0], q[1])
 
 
-@qfunc(external=True)
+@qfunc
 def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]
@@ -412,7 +412,7 @@ def inplace_prepare_int(value: CInt, target: QArray[QBit]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def prepare_int(
     value: CInt,
     out: Output[QNum[Literal["floor(log(value, 2)) + 1"]]],

classiq/qmod/builtins/functions/swap_test.py

@@ -5,7 +5,7 @@ from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import Output, QArray, QBit
 
 
-@qfunc(external=True)
+@qfunc
 def swap_test(state1: QArray[QBit], state2: QArray[QBit], test: Output[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/utility_functions.py

@@ -6,7 +6,7 @@ from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QCallable
 
 
-@qfunc(external=True)
+@qfunc
 def apply_to_all(
     gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
 ) -> None:
@@ -23,7 +23,7 @@ def apply_to_all(
     repeat(target.len, lambda index: gate_operand(target[index]))
 
 
-@qfunc(external=True)
+@qfunc
 def hadamard_transform(target: QArray[QBit]) -> None:
     """
     [Qmod Classiq-library function]

classiq/qmod/builtins/functions/variational.py

@@ -8,7 +8,7 @@ from classiq.qmod.qmod_variable import Output, QArray, QBit
 from classiq.qmod.symbolic import ceiling, floor, pi
 
 
-@qfunc(external=True)
+@qfunc
 def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
     """
     [Qmod Classiq-library function]
@@ -28,7 +28,7 @@ def encode_in_angle(data: CArray[CReal], qba: Output[QArray[QBit]]) -> None:
     )
 
 
-@qfunc(external=True)
+@qfunc
 def encode_on_bloch(data: CArray[CReal], qba: Output[QArray]) -> None:
     """
     [Qmod Classiq-library function]