classiq 0.53.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Dict, Final, List, Optional, Union
+from typing import Final, Optional, Union
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
@@ -15,7 +15,7 @@ from classiq.interface.generator.functions.qmod_python_interface import QmodPySt
 from classiq.applications.qsvm.qsvm import Data, Labels
 from classiq.qmod.builtins.enums import Optimizer
 
-ExecutionParams = Dict[str, Union[float, int, List[int], List[float]]]
+ExecutionParams = dict[str, Union[float, int, list[int], list[float]]]
 
 _CALL_IN_QFUNC_ERROR = (
     'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
@@ -39,28 +39,28 @@ def sample(  # type: ignore[return]
 
 
 def batch_sample(  # type: ignore[return]
-    batch_execution_params: List[ExecutionParams],
+    batch_execution_params: list[ExecutionParams],
 ) -> MultipleExecutionDetails:
     _raise_error("batch_sample")
 
 
 def estimate(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
+    hamiltonian: list[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
     _raise_error("estimate")
 
 
 def batch_estimate(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct],
-    batch_execution_params: List[ExecutionParams],
+    hamiltonian: list[QmodPyStruct],
+    batch_execution_params: list[ExecutionParams],
 ) -> EstimationResults:
     _raise_error("batch_estimate")
 
 
 def vqe(  # type: ignore[return]
-    hamiltonian: List[QmodPyStruct],
+    hamiltonian: list[QmodPyStruct],
     maximize: bool,
-    initial_point: List[float],
+    initial_point: list[float],
     optimizer: Optimizer,
     max_iteration: int,
     tolerance: float,
@@ -118,5 +118,5 @@ __all__ = [
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/builtins/functions/__init__.py

@@ -1,3 +1,6 @@
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+
+from ...quantum_function import GenerativeQFunc
 from .amplitude_estimation import *
 from .arithmetic import *
 from .benchmarking import *
@@ -14,7 +17,7 @@ from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb, _ctrl_x
 from .operators import *
 from .qaoa_penalty import *
-from .qft import *
+from .qft_functions import *
 from .qpe import *
 from .qsvm import *
 from .qsvt import *
@@ -22,6 +25,7 @@ from .standard_gates import *
 from .state_preparation import *
 from .state_preparation import _prepare_uniform_trimmed_state_step
 from .swap_test import *
+from .utility_functions import *
 from .variational import *
 
 CORE_LIB_DECLS = [
@@ -86,62 +90,75 @@ CORE_LIB_DECLS = [
     )
 ]
 
+OPEN_LIBRARY_UNPROCESSED_FUNCTIONS = [
+    qpe_flexible,
+    qpe,
+    _single_pauli,
+    linear_pauli_rotations,
+    amplitude_estimation,
+    phase_oracle,
+    reflect_about_zero,
+    grover_diffuser,
+    grover_operator,
+    grover_search,
+    hadamard_transform,
+    apply_to_all,
+    qft_no_swap,
+    qft_space_add_const,
+    cc_modular_add,
+    c_modular_multiply,
+    multiswap,
+    inplace_c_modular_multiply,
+    modular_exp,
+    qsvt_step,
+    qsvt,
+    projector_controlled_phase,
+    qsvt_inversion,
+    allocate_num,
+    qaoa_mixer_layer,
+    qaoa_cost_layer,
+    qaoa_layer,
+    qaoa_init,
+    qaoa_penalty,
+    full_hea,
+    swap_test,
+    prepare_uniform_trimmed_state,
+    prepare_uniform_interval_state,
+    prepare_ghz_state,
+    prepare_exponential_state,
+    prepare_bell_state,
+    inplace_prepare_int,
+    prepare_int,
+    switch,
+    qct_qst_type1,
+    qct_qst_type2,
+    qct_type2,
+    qst_type2,
+    modular_increment,
+    qft,
+    _ctrl_x,
+    _prepare_uniform_trimmed_state_step,
+    _qct_d_operator,
+    _qct_pi_operator,
+    _check_msb,
+    encode_in_angle,
+    encode_on_bloch,
+]
+
+OPEN_LIBRARY_FUNCTIONS: list[NativeFunctionDefinition] = []
+
+
+def load_open_library_implementations() -> None:
+    OPEN_LIBRARY_FUNCTIONS.extend(
+        [func.get_implementation() for func in OPEN_LIBRARY_UNPROCESSED_FUNCTIONS]
+    )
+
+
+OPEN_LIBRARY_GENERATIVE_FUNCTIONS: list[GenerativeQFunc] = []
+
 OPEN_LIB_DECLS = [
     func.func_decl
-    for func in (
-        qpe_flexible,
-        qpe,
-        _single_pauli,
-        linear_pauli_rotations,
-        amplitude_estimation,
-        phase_oracle,
-        reflect_about_zero,
-        grover_diffuser,
-        grover_operator,
-        grover_search,
-        hadamard_transform,
-        apply_to_all,
-        qft_no_swap,
-        qft_space_add_const,
-        cc_modular_add,
-        c_modular_multiply,
-        multiswap,
-        inplace_c_modular_multiply,
-        modular_exp,
-        qsvt_step,
-        qsvt,
-        projector_controlled_phase,
-        qsvt_inversion,
-        allocate_num,
-        qaoa_mixer_layer,
-        qaoa_cost_layer,
-        qaoa_layer,
-        qaoa_init,
-        qaoa_penalty,
-        full_hea,
-        swap_test,
-        prepare_uniform_trimmed_state,
-        prepare_uniform_interval_state,
-        prepare_ghz_state,
-        prepare_exponential_state,
-        prepare_bell_state,
-        inplace_prepare_int,
-        prepare_int,
-        switch,
-        qct_qst_type1,
-        qct_qst_type2,
-        qct_type2,
-        qst_type2,
-        modular_increment,
-        qft,
-        _ctrl_x,
-        _prepare_uniform_trimmed_state_step,
-        _qct_d_operator,
-        _qct_pi_operator,
-        _check_msb,
-        encode_in_angle,
-        encode_on_bloch,
-    )
+    for func in OPEN_LIBRARY_GENERATIVE_FUNCTIONS + OPEN_LIBRARY_UNPROCESSED_FUNCTIONS
 ]
 
 STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]

classiq/qmod/builtins/functions/amplitude_estimation.py

@@ -1,3 +1,5 @@
+from classiq.qmod.builtins.functions.grover import grover_operator
+from classiq.qmod.builtins.functions.qpe import qpe
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
@@ -24,4 +26,5 @@ def amplitude_estimation(
         phase: Assuming this variable starts from the zero state -this variable output holds the $phase=\\theta$ result in the [0,1] domain, which relates to the estimated probability $a$ through $a=\\sin^2(\\pi \\theta)$.
         packed_vars: The variable that holds the state to be estimated. Assumed to be in the zero state at the beginning of the algorithm.
     """
-    pass
+    space_transform(packed_vars)
+    qpe(lambda: grover_operator(oracle, space_transform, packed_vars), phase)

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,9 +1,13 @@
 from typing import Literal
 
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import PHASE
+from classiq.qmod.builtins.operations import bind, repeat, within_apply
 from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
+from classiq.qmod.symbolic import pi
 
 
 @qfunc(external=True)
@@ -75,4 +79,13 @@ def modular_increment(a: CInt, x: QNum) -> None:
         x: A quantum number that is assumed to be non-negative integer.
 
     """
-    pass
+    array_cast: QArray = QArray("array_cast")
+    within_apply(
+        lambda: (  # type:ignore[arg-type]
+            bind(x, array_cast),  # type:ignore[func-returns-value]
+            qft(array_cast),
+        ),
+        lambda: repeat(
+            x.size, lambda i: PHASE(a * 2 * pi * 2**i / (2**x.size), array_cast[i])
+        ),
+    )

classiq/qmod/builtins/functions/discrete_sine_cosine_transform.py

@@ -1,15 +1,85 @@
+from classiq.qmod.builtins.functions.arithmetic import modular_increment
+from classiq.qmod.builtins.functions.qft_functions import qft
+from classiq.qmod.builtins.functions.standard_gates import PHASE, H, S, X, Z
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.functions.utility_functions import apply_to_all
+from classiq.qmod.builtins.operations import bind, control, invert, repeat, within_apply
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_variable import QArray, QBit, QNum
+from classiq.qmod.symbolic import pi
+
+
+def _b_operator(q: QBit) -> None:
+    S(q)
+    H(q)
 
 
 @qfunc(external=True)
 def _qct_d_operator(x: QNum, q: QBit) -> None:
-    pass
+    _b_operator(q)
+    control(x == 0, lambda: invert(lambda: _b_operator(q)))
 
 
 @qfunc(external=True)
 def _qct_pi_operator(x: QArray[QBit], q: QBit) -> None:
-    pass
+    control(q == 1, lambda: apply_to_all(X, x))
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _t_operator(x: QArray) -> None:
+    _qct_d_operator(x[0 : x.len - 1], x[x.len - 1])
+    _qct_pi_operator(x[0 : x.len - 1], x[x.len - 1])
+
+
+def _vn_operator(x: QArray[QBit], q: QBit) -> None:
+    H(q)
+    control(q == 1, lambda: apply_to_all(X, x))
+
+
+def _d1_operator(x: QArray[QBit], q: QBit) -> None:
+    omega_exp = 2 * pi / (4 * 2**x.len)
+
+    # Li
+    control(q == 0, lambda: repeat(x.len, lambda k: PHASE(omega_exp * (2**k), x[k])))
+    # Ki
+    control(
+        q == 1,
+        lambda: repeat(
+            x.len,
+            lambda k: within_apply(
+                lambda: X(x[k]), lambda: PHASE(-omega_exp * (2**k), x[k])
+            ),
+        ),
+    )
+    PHASE(-omega_exp, q)
+
+
+def _pi2_operator(x: QArray[QBit], q: QBit) -> None:
+    control(q == 1, lambda: modular_increment(1, x))
+
+
+def _j_operator(q: QBit) -> None:
+    within_apply(lambda: Z(q), lambda: (S(q), H(q), S(q)))  # type:ignore[arg-type]
+
+
+def _b_t_operator(q: QBit) -> None:
+    H(q)
+    S(q)
+
+
+def _d0dt_operator(x: QArray, q: QBit) -> None:
+    x_num: QNum = QNum("x_num", x.len, False, 0)
+    bind(x, x_num)
+    _b_t_operator(q)
+    control(x_num == 0, lambda: _j_operator(q))
+    bind(x_num, x)
+
+
+def _un_dag_operator(x: QArray[QBit], q: QBit) -> None:
+    _d1_operator(x, q)
+    invert(lambda: _qct_pi_operator(x, q))
+    _d0dt_operator(x, q)
+    invert(lambda: _pi2_operator(x, q))
 
 
 @qfunc(external=True)
@@ -39,7 +109,7 @@ def qct_qst_type1(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    within_apply(lambda: _t_operator(x), lambda: qft(x))
 
 
 @qfunc(external=True)
@@ -68,7 +138,12 @@ def qct_qst_type2(x: QArray[QBit], q: QBit) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    extended_state: QArray = QArray("extended_state")
+    _vn_operator(x, q)
+    bind([x, q], extended_state)
+    qft(extended_state)
+    bind(extended_state, [x, q])
+    _un_dag_operator(x, q)
 
 
 @qfunc(external=True)
@@ -85,7 +160,8 @@ def qct_type2(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    q = QBit("q")
+    within_apply(lambda: allocate(1, q), lambda: qct_qst_type2(x, q))
 
 
 @qfunc(external=True)
@@ -102,4 +178,8 @@ def qst_type2(x: QArray[QBit]) -> None:
     Links:
         - [Quantum Sine and Cosine Transforms](https://docs.classiq.io/latest/reference-manual/qmod/library-reference/open-library-functions/qct_qst/qct_qst/)
     """
-    pass
+    q = QBit("q")
+    within_apply(
+        lambda: (allocate(1, q), X(q)),  # type:ignore[arg-type]
+        lambda: qct_qst_type2(x, q),
+    )

classiq/qmod/builtins/functions/grover.py

@@ -1,9 +1,18 @@
-from typing_extensions import Annotated
-
+from classiq.qmod.builtins.functions.standard_gates import H, U, X
+from classiq.qmod.builtins.functions.state_preparation import allocate
+from classiq.qmod.builtins.functions.utility_functions import hadamard_transform
+from classiq.qmod.builtins.operations import (
+    bind,
+    control,
+    invert,
+    power,
+    within_apply,
+)
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CInt
-from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.qmod_variable import QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import pi
 
 
 @qfunc(external=True)
@@ -36,7 +45,11 @@ def phase_oracle(
 
         [Hidden shift](https://docs.classiq.io/latest/explore/algorithms/algebraic/hidden_shift/hidden_shift/)
     """
-    pass
+    aux = QBit("aux")
+    within_apply(
+        within=lambda: (allocate(1, aux), X(aux), H(aux)),  # type:ignore[arg-type]
+        apply=lambda: predicate(target, aux),
+    )
 
 
 @qfunc(external=True)
@@ -56,7 +69,14 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     Args:
         packed_vars: The quantum state to reflect.
     """
-    pass
+    msbs: QNum = QNum("msbs", packed_vars.len - 1, False, 0)
+    lsb = QBit("lsb")
+    bind(packed_vars, [msbs, lsb])
+    within_apply(
+        lambda: (X(lsb), H(lsb)),  # type:ignore[arg-type]
+        lambda: control(msbs == 0, lambda: X(lsb)),
+    )
+    bind([msbs, lsb], packed_vars)
 
 
 @qfunc(external=True)
@@ -81,7 +101,10 @@ def grover_diffuser(
         space_transform: The operator which encodes the axis of reflection.
         packed_vars: The state to which to apply the diffuser.
     """
-    pass
+    within_apply(
+        lambda: invert(lambda: space_transform(packed_vars)),
+        lambda: reflect_about_zero(packed_vars),
+    )
 
 
 @qfunc(external=True)
@@ -115,7 +138,9 @@ def grover_operator(
     - [Wikipedia page](https://en.wikipedia.org/wiki/Grover%27s_algorithm).
 
     """
-    pass
+    oracle(packed_vars)
+    grover_diffuser(lambda qba: space_transform(qba), packed_vars)
+    U(0, 0, 0, pi, packed_vars[0])
 
 
 @qfunc(external=True)
@@ -138,41 +163,12 @@ def grover_search(
          [Grover Algorithm](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/grover_operator/grover_operator/)
 
     """
-    pass
-
-
-@qfunc(external=True)
-def hadamard_transform(target: QArray[QBit]) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Applies Hadamard transform to the target qubits.
-
-    Corresponds to the braket notation:
-
-    $$
-     H^{\\otimes n} |x\rangle = \frac{1}{\\sqrt{2^n}} \\sum_{y=0}^{2^n - 1} (-1)^{x \\cdot y} |y\rangle
-    $$
-
-    Args:
-        target:  qubits to apply to Hadamard transform to.
-
-    """
-    pass
-
-
-@qfunc(external=True)
-def apply_to_all(
-    gate_operand: QCallable[Annotated[QBit, "target"]], target: QArray[QBit]
-) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Applies the single-qubit operand `gate_operand` to each qubit in the qubit
-    array `target`.
-
-    Args:
-        gate_operand: The single-qubit gate to apply to each qubit in the array.
-        target: The qubit array to apply the gate to.
-    """
-    pass
+    hadamard_transform(packed_vars)
+    power(
+        reps,
+        lambda: grover_operator(
+            lambda qba: oracle(qba),
+            lambda qba: hadamard_transform(qba),
+            packed_vars,
+        ),
+    )

classiq/qmod/builtins/functions/hea.py

@@ -1,11 +1,11 @@
-from typing import Literal
-
-from typing_extensions import Annotated
+from typing import Annotated, Literal
 
+from classiq.qmod.builtins.operations import if_, repeat
 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.quantum_callable import QCallableList
+from classiq.qmod.symbolic import floor, sum
 
 
 @qfunc(external=True)
@@ -56,4 +56,60 @@ def full_hea(
         operands_2qubit: A list of operations on two qubits
         x: The quantum object to be transformed by the ansatz
     """
-    pass
+    repeat(
+        reps,
+        lambda r: [  # type:ignore[arg-type]
+            repeat(  # type:ignore[func-returns-value]
+                operands_1qubit.len,
+                lambda i1: repeat(
+                    num_qubits,
+                    lambda index: if_(
+                        condition=is_parametrized[i1] == 1,
+                        then=lambda: operands_1qubit[i1](
+                            angle_params[
+                                sum(is_parametrized[0:i1])  # type:ignore[index]
+                                + floor((angle_params.len / reps) * r)
+                                + index
+                            ],
+                            x[index],
+                        ),
+                        else_=lambda: operands_1qubit[i1](0, x[index]),
+                    ),
+                ),
+            ),
+            repeat(  # type:ignore[func-returns-value]
+                operands_2qubit.len,
+                lambda i2: repeat(
+                    connectivity_map.len,
+                    lambda index: if_(
+                        condition=is_parametrized[operands_1qubit.len + i2] == 1,
+                        then=lambda: operands_2qubit[i2](
+                            angle_params[
+                                num_qubits
+                                * sum(
+                                    is_parametrized[
+                                        0 : operands_1qubit.len
+                                    ]  # type:ignore[index]
+                                )
+                                + connectivity_map.len
+                                * sum(
+                                    is_parametrized[
+                                        operands_1qubit.len : operands_1qubit.len + i2
+                                    ]
+                                )
+                                + floor((angle_params.len / reps) * r)
+                                + index
+                            ],
+                            x[connectivity_map[index][0]],
+                            x[connectivity_map[index][1]],
+                        ),
+                        else_=lambda: operands_2qubit[i2](
+                            0,
+                            x[connectivity_map[index][0]],
+                            x[connectivity_map[index][1]],
+                        ),
+                    ),
+                ),
+            ),
+        ],
+    )

classiq/qmod/builtins/functions/linear_pauli_rotation.py

@@ -1,6 +1,9 @@
-from typing_extensions import Annotated
+from typing import Annotated
 
 from classiq.qmod.builtins.enums import Pauli
+from classiq.qmod.builtins.functions.operators import switch
+from classiq.qmod.builtins.functions.standard_gates import IDENTITY, RX, RY, RZ
+from classiq.qmod.builtins.operations import control, repeat
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import QArray, QBit
@@ -15,7 +18,10 @@ def _single_pauli(
     x: QArray[QBit],
     q: QBit,
 ) -> None:
-    pass
+    repeat(
+        x.len, lambda index: control(x[index], lambda: q1_qfunc(2**index * slope, q))
+    )
+    q1_qfunc(offset, q)
 
 
 @qfunc(external=True)
@@ -61,5 +67,21 @@ def linear_pauli_rotations(
     Links:
        [linear_pauli_rotations](https://docs.classiq.io/latest/explore/functions/qmod_library_reference/classiq_open_library/linear_pauli_rotations/linear_pauli_rotations)
     """
-
-    pass
+    repeat(
+        q.len,
+        lambda index: _single_pauli(
+            slope=slopes[index],
+            offset=offsets[index],
+            q1_qfunc=lambda theta, target: switch(
+                bases[index],
+                [
+                    lambda: IDENTITY(target),
+                    lambda: RX(theta, target),
+                    lambda: RY(theta, target),
+                    lambda: RZ(theta, target),
+                ],
+            ),
+            x=x,
+            q=q[index],
+        ),
+    )