classiq 0.39.0__py3-none-any.whl → 0.41.0__py3-none-any.whl

classiq/qmod/builtins/functions.py

@@ -1,9 +1,9 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List, Literal
+from classiq.interface.generator.expressions.enums.pauli import Pauli
 
 from classiq.qmod.qfunc import qfunc
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 
@@ -26,91 +26,61 @@ def apply(
 
 @qfunc(external=True)
 def molecule_ucc(
-    molecule_problem: QParam[MoleculeProblem],
-    excitations: QParam[List[int]],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
+    molecule_problem: MoleculeProblem,
+    excitations: CArray[CInt],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def molecule_hva(
-    molecule_problem: QParam[MoleculeProblem],
-    reps: QParam[int],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
+    molecule_problem: MoleculeProblem,
+    reps: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def molecule_hartree_fock(
-    molecule_problem: QParam[MoleculeProblem],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
-        ],
-    ],
+    molecule_problem: MoleculeProblem,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def fock_hamiltonian_ucc(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    excitations: QParam[List[int]],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    excitations: CArray[CInt],
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def fock_hamiltonian_hva(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    reps: QParam[int],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    reps: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def fock_hamiltonian_hartree_fock(
-    fock_hamiltonian_problem: QParam[FockHamiltonianProblem],
-    qbv: QArray[
-        QBit,
-        Literal[
-            "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
-        ],
-    ],
+    fock_hamiltonian_problem: FockHamiltonianProblem,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def log_normal_finance(
-    finance_model: QParam[LogNormalModel],
-    finance_function: QParam[FinanceFunction],
-    func_port: QArray[QBit, Literal["get_field(finance_model, 'num_qubits')"]],
+    finance_model: LogNormalModel,
+    finance_function: FinanceFunction,
+    func_port: QArray[QBit],
     obj_port: QBit,
 ) -> None:
     pass
@@ -118,14 +88,9 @@ def log_normal_finance(
 
 @qfunc(external=True)
 def gaussian_finance(
-    finance_model: QParam[GaussianModel],
-    finance_function: QParam[FinanceFunction],
-    func_port: QArray[
-        QBit,
-        Literal[
-            "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1"
-        ],
-    ],
+    finance_model: GaussianModel,
+    finance_function: FinanceFunction,
+    func_port: QArray[QBit],
     obj_port: QBit,
 ) -> None:
     pass
@@ -133,16 +98,16 @@ def gaussian_finance(
 
 @qfunc(external=True)
 def pauli_feature_map(
-    feature_map: QParam[QSVMFeatureMapPauli],
-    qbv: QArray[QBit, Literal["get_field(feature_map, 'feature_dimension')"]],
+    feature_map: QSVMFeatureMapPauli,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def bloch_sphere_feature_map(
-    feature_dimension: QParam[int],
-    qbv: QArray[QBit, Literal["ceiling(feature_dimension/2)"]],
+    feature_dimension: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -212,7 +177,7 @@ def TDG(
 
 @qfunc(external=True)
 def PHASE(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -220,7 +185,7 @@ def PHASE(
 
 @qfunc(external=True)
 def RX(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -228,7 +193,7 @@ def RX(
 
 @qfunc(external=True)
 def RY(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -236,7 +201,7 @@ def RY(
 
 @qfunc(external=True)
 def RZ(
-    theta: QParam[float],
+    theta: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -244,8 +209,8 @@ def RZ(
 
 @qfunc(external=True)
 def R(
-    theta: QParam[float],
-    phi: QParam[float],
+    theta: CReal,
+    phi: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -253,24 +218,24 @@ def R(
 
 @qfunc(external=True)
 def RXX(
-    theta: QParam[float],
-    target: QArray[QBit, Literal[2]],
+    theta: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def RYY(
-    theta: QParam[float],
-    target: QArray[QBit, Literal[2]],
+    theta: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def RZZ(
-    theta: QParam[float],
-    target: QArray[QBit, Literal[2]],
+    theta: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
@@ -309,7 +274,7 @@ def CZ(
 
 @qfunc(external=True)
 def CRX(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -318,7 +283,7 @@ def CRX(
 
 @qfunc(external=True)
 def CRY(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -327,7 +292,7 @@ def CRY(
 
 @qfunc(external=True)
 def CRZ(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -336,7 +301,7 @@ def CRZ(
 
 @qfunc(external=True)
 def CPHASE(
-    theta: QParam[float],
+    theta: CReal,
     control: QBit,
     target: QBit,
 ) -> None:
@@ -360,26 +325,26 @@ def IDENTITY(
 
 @qfunc(external=True)
 def prepare_state(
-    probabilities: QParam[List[float]],
-    bound: QParam[float],
-    out: Output[QArray[QBit, Literal["log(len(probabilities), 2)"]]],
+    probabilities: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def prepare_amplitudes(
-    amplitudes: QParam[List[float]],
-    bound: QParam[float],
-    out: Output[QArray[QBit, Literal["log(len(amplitudes), 2)"]]],
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit]],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def unitary(
-    elements: QParam[List[List[float]]],
-    target: QArray[QBit, Literal["log(len(elements[0]), 2)"]],
+    elements: CArray[CArray[CReal]],
+    target: QArray[QBit],
 ) -> None:
     pass
 
@@ -388,7 +353,7 @@ def unitary(
 def add(
     left: QArray[QBit],
     right: QArray[QBit],
-    result: Output[QArray[QBit, Literal["Max(len(left), len(right)) + 1"]]],
+    result: Output[QArray[QBit]],
 ) -> None:
     pass
 
@@ -411,10 +376,10 @@ def integer_xor(
 
 @qfunc(external=True)
 def U(
-    theta: QParam[float],
-    phi: QParam[float],
-    lam: QParam[float],
-    gam: QParam[float],
+    theta: CReal,
+    phi: CReal,
+    lam: CReal,
+    gam: CReal,
     target: QBit,
 ) -> None:
     pass
@@ -422,7 +387,7 @@ def U(
 
 @qfunc(external=True)
 def CCX(
-    control: QArray[QBit, Literal[2]],
+    control: QArray[QBit],
     target: QBit,
 ) -> None:
     pass
@@ -430,8 +395,8 @@ def CCX(
 
 @qfunc(external=True)
 def allocate(
-    num_qubits: QParam[int],
-    out: Output[QArray[QBit, Literal["num_qubits"]]],
+    num_qubits: CInt,
+    out: Output[QArray[QBit]],
 ) -> None:
     pass
 
@@ -445,7 +410,7 @@ def free(
 
 @qfunc(external=True)
 def randomized_benchmarking(
-    num_of_cliffords: QParam[int],
+    num_of_cliffords: CInt,
     target: QArray[QBit],
 ) -> None:
     pass
@@ -453,58 +418,58 @@ def randomized_benchmarking(
 
 @qfunc(external=True)
 def inplace_prepare_state(
-    probabilities: QParam[List[float]],
-    bound: QParam[float],
-    target: QArray[QBit, Literal["log(len(probabilities), 2)"]],
+    probabilities: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def inplace_prepare_amplitudes(
-    amplitudes: QParam[List[float]],
-    bound: QParam[float],
-    target: QArray[QBit, Literal["log(len(amplitudes), 2)"]],
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def single_pauli_exponent(
-    pauli_string: QParam[List[int]],
-    coefficient: QParam[float],
-    qbv: QArray[QBit, Literal["len(pauli_string)"]],
+    pauli_string: CArray[Pauli],
+    coefficient: CReal,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def suzuki_trotter(
-    pauli_operator: QParam[List[PauliTerm]],
-    evolution_coefficient: QParam[float],
-    order: QParam[int],
-    repetitions: QParam[int],
-    qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    order: CInt,
+    repetitions: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def qdrift(
-    pauli_operator: QParam[List[PauliTerm]],
-    evolution_coefficient: QParam[float],
-    num_qdrift: QParam[int],
-    qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    num_qdrift: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def exponentiation_with_depth_constraint(
-    pauli_operator: QParam[List[PauliTerm]],
-    evolution_coefficient: QParam[float],
-    max_depth: QParam[int],
-    qbv: QArray[QBit, Literal["len(get_field(pauli_operator[0], 'pauli'))"]],
+    pauli_operator: CArray[PauliTerm],
+    evolution_coefficient: CReal,
+    max_depth: CInt,
+    qbv: QArray[QBit],
 ) -> None:
     pass
 
@@ -525,7 +490,7 @@ def qft(
 
 @qfunc(external=True)
 def qpe_flexible(
-    unitary_with_power: QCallable[QParam[int]],
+    unitary_with_power: QCallable[CInt],
     phase: QNum,
 ) -> None:
     pass
@@ -541,9 +506,9 @@ def qpe(
 
 @qfunc(external=True)
 def single_pauli(
-    slope: QParam[float],
-    offset: QParam[float],
-    q1_qfunc: QCallable[QParam[float], QBit],
+    slope: CReal,
+    offset: CReal,
+    q1_qfunc: QCallable[CReal, QBit],
     x: QArray[QBit],
     q: QBit,
 ) -> None:
@@ -552,9 +517,9 @@ def single_pauli(
 
 @qfunc(external=True)
 def linear_pauli_rotations(
-    bases: QParam[List[int]],
-    slopes: QParam[List[float]],
-    offsets: QParam[List[float]],
+    bases: CArray[Pauli],
+    slopes: CArray[CReal],
+    offsets: CArray[CReal],
     x: QArray[QBit],
     q: QArray[QBit],
 ) -> None:
@@ -605,7 +570,7 @@ def grover_operator(
 
 @qfunc(external=True)
 def grover_search(
-    reps: QParam[int],
+    reps: CInt,
     oracle: QCallable[QArray[QBit]],
     packed_vars: QArray[QBit],
 ) -> None:
@@ -627,11 +592,143 @@ def apply_to_all(
     pass
 
 
+@qfunc(external=True)
+def qft_no_swap(
+    qbv: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def _check_msb(
+    ref: CInt,
+    x: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def _ctrl_x(
+    ref: CInt,
+    ctrl: QNum,
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qft_space_add_const(
+    value: CInt,
+    phi_b: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def cc_modular_add(
+    n: CInt,
+    a: CInt,
+    phi_b: QArray[QBit],
+    c1: QArray[QBit],
+    c2: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def c_modular_multiply(
+    n: CInt,
+    a: CInt,
+    b: QArray[QBit],
+    x: QArray[QBit],
+    ctrl: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def multiswap(
+    x: QArray[QBit],
+    y: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def inplace_c_modular_multiply(
+    n: CInt,
+    a: CInt,
+    x: QArray[QBit],
+    ctrl: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def modular_exp(
+    n: CInt,
+    a: CInt,
+    x: QArray[QBit],
+    power: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qsvt_step(
+    phase_seq: CArray[CReal],
+    index: CInt,
+    proj_cnot_1: QCallable[QArray[QBit], QArray[QBit]],
+    proj_cnot_2: QCallable[QArray[QBit], QArray[QBit]],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qsvt(
+    phase_seq: CArray[CReal],
+    proj_cnot_1: QCallable[QArray[QBit], QArray[QBit]],
+    proj_cnot_2: QCallable[QArray[QBit], QArray[QBit]],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def projector_controlled_phase(
+    phase: CReal,
+    proj_cnot: QCallable[QArray[QBit], QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
+@qfunc(external=True)
+def qsvt_inversion(
+    phase_seq: CArray[CReal],
+    block_encoding_cnot: QCallable[QArray[QBit], QArray[QBit]],
+    u: QCallable[QArray[QBit]],
+    qvar: QArray[QBit],
+    aux: QArray[QBit],
+) -> None:
+    pass
+
+
 @qfunc(external=True)
 def allocate_num(
-    num_qubits: QParam[int],
-    is_signed: QParam[bool],
-    fraction_digits: QParam[int],
+    num_qubits: CInt,
+    is_signed: CBool,
+    fraction_digits: CInt,
     out: Output[QNum],
 ) -> None:
     pass
@@ -639,7 +736,7 @@ def allocate_num(
 
 @qfunc(external=True)
 def qaoa_mixer_layer(
-    b: QParam[float],
+    b: CReal,
     target: QArray[QBit],
 ) -> None:
     pass
@@ -647,8 +744,8 @@ def qaoa_mixer_layer(
 
 @qfunc(external=True)
 def qaoa_cost_layer(
-    g: QParam[float],
-    hamiltonian: QParam[List[PauliTerm]],
+    g: CReal,
+    hamiltonian: CArray[PauliTerm],
     target: QArray[QBit],
 ) -> None:
     pass
@@ -656,9 +753,9 @@ def qaoa_cost_layer(
 
 @qfunc(external=True)
 def qaoa_layer(
-    g: QParam[float],
-    b: QParam[float],
-    hamiltonian: QParam[List[PauliTerm]],
+    g: CReal,
+    b: CReal,
+    hamiltonian: CArray[PauliTerm],
     target: QArray[QBit],
 ) -> None:
     pass
@@ -673,24 +770,24 @@ def qaoa_init(
 
 @qfunc(external=True)
 def qaoa_penalty(
-    num_qubits: QParam[int],
-    params_list: QParam[List[float]],
-    hamiltonian: QParam[List[PauliTerm]],
-    target: QArray[QBit, Literal["num_qubits"]],
+    num_qubits: CInt,
+    params_list: CArray[CReal],
+    hamiltonian: CArray[PauliTerm],
+    target: QArray[QBit],
 ) -> None:
     pass
 
 
 @qfunc(external=True)
 def full_hea(
-    num_qubits: QParam[int],
-    is_parametrized: QParam[List[int]],
-    angle_params: QParam[List[float]],
-    connectivity_map: QParam[List[List[int]]],
-    reps: QParam[int],
-    operands_1qubit: QCallableList[QParam[float], QBit],
-    operands_2qubit: QCallableList[QParam[float], QBit, QBit],
-    x: QArray[QBit, Literal["num_qubits"]],
+    num_qubits: CInt,
+    is_parametrized: CArray[CInt],
+    angle_params: CArray[CReal],
+    connectivity_map: CArray[CArray[CInt]],
+    reps: CInt,
+    operands_1qubit: QCallableList[CReal, QBit],
+    operands_2qubit: QCallableList[CReal, QBit, QBit],
+    x: QArray[QBit],
 ) -> None:
     pass
 
@@ -706,7 +803,7 @@ def swap_test(
 
 @qfunc(external=True)
 def prepare_ghz_state(
-    size: QParam[int],
+    size: CInt,
     q: Output[QArray[QBit]],
 ) -> None:
     pass
@@ -714,7 +811,7 @@ def prepare_ghz_state(
 
 @qfunc(external=True)
 def prepare_exponential_state(
-    rate: QParam[int],
+    rate: CInt,
     q: QArray[QBit],
 ) -> None:
     pass
@@ -722,7 +819,7 @@ def prepare_exponential_state(
 
 @qfunc(external=True)
 def prepare_bell_state(
-    state_num: QParam[int],
+    state_num: CInt,
     q: Output[QArray[QBit]],
 ) -> None:
     pass
@@ -730,7 +827,7 @@ def prepare_bell_state(
 
 @qfunc(external=True)
 def inplace_prepare_int(
-    value: QParam[int],
+    value: CInt,
     target: QArray[QBit],
 ) -> None:
     pass
@@ -738,7 +835,7 @@ def inplace_prepare_int(
 
 @qfunc(external=True)
 def prepare_int(
-    value: QParam[int],
+    value: CInt,
     out: Output[QNum],
 ) -> None:
     pass
@@ -746,7 +843,7 @@ def prepare_int(
 
 @qfunc(external=True)
 def switch(
-    selector: QParam[int],
+    selector: CInt,
     cases: QCallableList,
 ) -> None:
     pass
@@ -823,6 +920,19 @@ __all__ = [
     "grover_search",
     "hadamard_transform",
     "apply_to_all",
+    "qft_no_swap",
+    "_check_msb",
+    "_ctrl_x",
+    "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",