classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,40 +1,66 @@
-from typing import Dict, List, Optional
+from typing import Final, Optional, Union
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
 from classiq.interface.executor.iqae_result import IQAEResult
-from classiq.interface.executor.result import EstimationResult, ExecutionDetails
+from classiq.interface.executor.result import (
+    EstimationResult,
+    EstimationResults,
+    ExecutionDetails,
+    MultipleExecutionDetails,
+)
 from classiq.interface.executor.vqe_result import VQESolverResult
-from classiq.interface.generator.expressions.enums import Optimizer
 from classiq.interface.generator.functions.qmod_python_interface import QmodPyStruct
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
 
 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]]]
+
+_CALL_IN_QFUNC_ERROR = (
+    'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
+)
+
+CARRAY_SEPARATOR: Final[str] = "_"
+
 
-ExecutionParams = Dict[str, float]
+def _raise_error(primitive_name: str) -> None:
+    raise ClassiqError(_CALL_IN_QFUNC_ERROR.format(primitive_name, primitive_name))
 
 
 def save(values_to_save: dict) -> None:
-    pass
+    _raise_error("save")
 
 
-def sample(  # type: ignore
+def sample(  # type: ignore[return]
     execution_params: Optional[ExecutionParams] = None,
 ) -> ExecutionDetails:
-    pass
+    _raise_error("sample")
 
 
-def estimate(  # type: ignore
-    hamiltonian: List[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
+def batch_sample(  # type: ignore[return]
+    batch_execution_params: list[ExecutionParams],
+) -> MultipleExecutionDetails:
+    _raise_error("batch_sample")
+
+
+def estimate(  # type: ignore[return]
+    hamiltonian: list[QmodPyStruct], execution_params: Optional[ExecutionParams] = None
 ) -> EstimationResult:
-    pass
+    _raise_error("estimate")
+
 
+def batch_estimate(  # type: ignore[return]
+    hamiltonian: list[QmodPyStruct],
+    batch_execution_params: list[ExecutionParams],
+) -> EstimationResults:
+    _raise_error("batch_estimate")
 
-def vqe(  # type: ignore
-    hamiltonian: List[QmodPyStruct],
+
+def vqe(  # type: ignore[return]
+    hamiltonian: list[QmodPyStruct],
     maximize: bool,
-    initial_point: List[int],
+    initial_point: list[float],
     optimizer: Optimizer,
     max_iteration: int,
     tolerance: float,
@@ -42,68 +68,55 @@ def vqe(  # type: ignore
     skip_compute_variance: bool,
     alpha_cvar: float,
 ) -> VQESolverResult:
-    pass
+    _raise_error("vqe")
 
 
-def qae_with_qpe_result_post_processing(  # type: ignore
+def qae_with_qpe_result_post_processing(  # type: ignore[return]
     estimation_register_size: int,
     estimation_method: QaeWithQpeEstimationMethod,
     result: ExecutionDetails,
 ) -> float:
-    pass
+    _raise_error("qae_with_qpe_result_post_processing")
 
 
-def qsvm_full_run(  # type: ignore
+def qsvm_full_run(  # type: ignore[return]
     train_data: Data,
     train_labels: Labels,
     test_data: Data,
     test_labels: Labels,
     predict_data: Data,
 ) -> QmodPyStruct:
-    pass
+    _raise_error("qsvm_full_run")
 
 
-def iqae(  # type: ignore
+def iqae(  # type: ignore[return]
     epsilon: float,
     alpha: float,
     execution_params: Optional[ExecutionParams] = None,
 ) -> IQAEResult:
-    pass
+    _raise_error("iqae")
 
 
-def molecule_ground_state_solution_post_process(  # type: ignore
+def molecule_ground_state_solution_post_process(  # type: ignore[return]
     problem: QmodPyStruct, vqe_result: VQESolverResult
 ) -> QmodPyStruct:
-    pass
-
-
-def optimization_problem_to_hamiltonian(  # type: ignore
-    problem_struct: CombinatorialOptimizationStructDeclaration, penalty_energy: float
-) -> List[QmodPyStruct]:
-    pass
-
-
-def get_optimization_solution(  # type: ignore
-    problem_struct: CombinatorialOptimizationStructDeclaration,
-    vqe_result: VQESolverResult,
-    penalty_energy: float,
-) -> List[QmodPyStruct]:
-    pass
+    _raise_error("molecule_ground_state_solution_post_process")
 
 
 __all__ = [
-    "save",
-    "sample",
+    "ExecutionParams",
+    "batch_estimate",
+    "batch_sample",
     "estimate",
-    "vqe",
-    "qae_with_qpe_result_post_processing",
-    "qsvm_full_run",
     "iqae",
     "molecule_ground_state_solution_post_process",
-    "optimization_problem_to_hamiltonian",
-    "get_optimization_solution",
+    "qae_with_qpe_result_post_processing",
+    "qsvm_full_run",
+    "sample",
+    "save",
+    "vqe",
 ]
 
 
-def __dir__() -> List[str]:
+def __dir__() -> list[str]:
     return __all__

classiq/qmod/builtins/classical_functions.py

@@ -1,68 +1,74 @@
 # This file was generated automatically - do not edit manually
 
-from typing import List
 
-from classiq.qmod.qmod_parameter import QParam
+from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.symbolic import symbolic_function
 
 from .structs import *
 
 
-def compute_qaoa_initial_point(
-    hamiltonian: QParam[List[PauliTerm]],
-    repetitions: QParam[int],
-) -> QParam[List[float]]:
-    return symbolic_function(hamiltonian, repetitions)
+def qft_const_adder_phase(
+    bit_index: CInt,
+    value: CInt,
+    reg_len: CInt,
+) -> CReal:
+    return symbolic_function(bit_index, value, reg_len, return_type=CReal)
 
 
-def molecule_problem_to_hamiltonian(
-    problem: QParam[MoleculeProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem)
+def fock_hamiltonian_problem_to_hamiltonian(
+    problem: FockHamiltonianProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
-def fock_hamiltonian_problem_to_hamiltonian(
-    problem: QParam[FockHamiltonianProblem],
-) -> QParam[List[PauliTerm]]:
-    return symbolic_function(problem)
+def molecule_problem_to_hamiltonian(
+    problem: MoleculeProblem,
+) -> CArray[PauliTerm]:
+    return symbolic_function(problem, return_type=CArray[PauliTerm])
 
 
 def grid_entangler_graph(
-    num_qubits: QParam[int],
-    schmidt_rank: QParam[int],
-    grid_randomization: QParam[bool],
-) -> QParam[List[List[int]]]:
-    return symbolic_function(num_qubits, schmidt_rank, grid_randomization)
+    num_qubits: CInt,
+    schmidt_rank: CInt,
+    grid_randomization: CBool,
+) -> CArray[CArray[CInt]]:
+    return symbolic_function(
+        num_qubits, schmidt_rank, grid_randomization, return_type=CArray[CArray[CInt]]
+    )
 
 
 def hypercube_entangler_graph(
-    num_qubits: QParam[int],
-) -> QParam[List[List[int]]]:
-    return symbolic_function(num_qubits)
+    num_qubits: CInt,
+) -> CArray[CArray[CInt]]:
+    return symbolic_function(num_qubits, return_type=CArray[CArray[CInt]])
 
 
-def log_normal_finance_post_process(
-    finance_model: QParam[LogNormalModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
-    return symbolic_function(finance_model, estimation_method, probability)
+def gaussian_finance_post_process(
+    finance_model: GaussianModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
+    return symbolic_function(
+        finance_model, estimation_method, probability, return_type=CReal
+    )
 
 
-def gaussian_finance_post_process(
-    finance_model: QParam[GaussianModel],
-    estimation_method: QParam[FinanceFunction],
-    probability: QParam[float],
-) -> QParam[float]:
-    return symbolic_function(finance_model, estimation_method, probability)
+def log_normal_finance_post_process(
+    finance_model: LogNormalModel,
+    estimation_method: FinanceFunction,
+    probability: CReal,
+) -> CReal:
+    return symbolic_function(
+        finance_model, estimation_method, probability, return_type=CReal
+    )
 
 
 __all__ = [
-    "compute_qaoa_initial_point",
-    "molecule_problem_to_hamiltonian",
+    "qft_const_adder_phase",
     "fock_hamiltonian_problem_to_hamiltonian",
+    "molecule_problem_to_hamiltonian",
     "grid_entangler_graph",
     "hypercube_entangler_graph",
-    "log_normal_finance_post_process",
     "gaussian_finance_post_process",
+    "log_normal_finance_post_process",
 ]

classiq/qmod/builtins/constants.py

@@ -0,0 +1,10 @@
+from classiq.qmod.cparam import CBool
+from classiq.qmod.qmod_constant import QConstant
+
+SIGNED = QConstant("SIGNED", CBool, True)
+UNSIGNED = QConstant("UNSIGNED", CBool, False)
+
+__all__ = [
+    "SIGNED",
+    "UNSIGNED",
+]

classiq/qmod/builtins/enums.py

@@ -0,0 +1,208 @@
+from enum import IntEnum
+
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+
+
+class Element(IntEnum):
+    H = 0
+    He = 1
+    Li = 2
+    Be = 3
+    B = 4
+    C = 5
+    N = 6
+    O = 7  # noqa: E741
+    F = 8
+    Ne = 9
+    Na = 10
+    Mg = 11
+    Al = 12
+    Si = 13
+    P = 14
+    S = 15
+    Cl = 16
+    Ar = 17
+    K = 18
+    Ca = 19
+    Sc = 20
+    Ti = 21
+    V = 22
+    Cr = 23
+    Mn = 24
+    Fe = 25
+    Co = 26
+    Ni = 27
+    Cu = 28
+    Zn = 29
+    Ga = 30
+    Ge = 31
+    As = 32
+    Se = 33
+    Br = 34
+    Kr = 35
+    Rb = 36
+    Sr = 37
+    Y = 38
+    Zr = 39
+    Nb = 40
+    Mo = 41
+    Tc = 42
+    Ru = 43
+    Rh = 44
+    Pd = 45
+    Ag = 46
+    Cd = 47
+    In = 48
+    Sn = 49
+    Sb = 50
+    Te = 51
+    I = 52  # noqa: E741
+    Xe = 53
+    Cs = 54
+    Ba = 55
+    La = 56
+    Ce = 57
+    Pr = 58
+    Nd = 59
+    Pm = 60
+    Sm = 61
+    Eu = 62
+    Gd = 63
+    Tb = 64
+    Dy = 65
+    Ho = 66
+    Er = 67
+    Tm = 68
+    Yb = 69
+    Lu = 70
+    Hf = 71
+    Ta = 72
+    W = 73
+    Re = 74
+    Os = 75
+    Ir = 76
+    Pt = 77
+    Au = 78
+    Hg = 79
+    Tl = 80
+    Pb = 81
+    Bi = 82
+    Po = 83
+    At = 84
+    Rn = 85
+    Fr = 86
+    Ra = 87
+    Ac = 88
+    Th = 89
+    Pa = 90
+    U = 91
+    Np = 92
+    Pu = 93
+    Am = 94
+    Cm = 95
+    Bk = 96
+    Cf = 97
+    Es = 98
+    Fm = 99
+    Md = 100
+    No = 101
+    Lr = 102
+    Rf = 103
+    Db = 104
+    Sg = 105
+    Bh = 106
+    Hs = 107
+    Mt = 108
+    Ds = 109
+    Rg = 110
+    Cn = 111
+    Nh = 112
+    Fl = 113
+    Mc = 114
+    Lv = 115
+    Ts = 116
+    Og = 117
+
+
+class FermionMapping(IntEnum):
+    JORDAN_WIGNER = 0
+    PARITY = 1
+    BRAVYI_KITAEV = 2
+    FAST_BRAVYI_KITAEV = 3
+
+
+class FinanceFunctionType(IntEnum):
+    VAR = 0
+    SHORTFALL = 1
+    X_SQUARE = 2
+    EUROPEAN_CALL_OPTION = 3
+
+
+class LadderOperator(IntEnum):
+    PLUS = 0
+    MINUS = 1
+
+
+class Optimizer(IntEnum):
+    COBYLA = 1
+    SPSA = 2
+    L_BFGS_B = 3
+    NELDER_MEAD = 4
+    ADAM = 5
+
+
+class Pauli(IntEnum):
+    """
+    Enumeration for the Pauli matrices used in quantum computing.
+
+    The Pauli matrices are fundamental operations in quantum computing, and this
+    enum assigns integer values to represent each matrix.
+    """
+
+    I = 0  # noqa: E741
+    """I (int): Identity matrix, represented by the integer 0. \n
+    $I = \\begin{bmatrix} 1 & 0 \\\\ 0 & 1 \\end{bmatrix}$"""
+
+    X = 1
+    """X (int): Pauli-X matrix, represented by the integer 1. \n
+    $X = \\begin{bmatrix} 0 & 1 \\\\ 1 & 0 \\end{bmatrix}$"""
+
+    Y = 2
+    """Y (int): Pauli-Y matrix, represented by the integer 2. \n
+    $Y = \\begin{bmatrix} 0 & -i \\\\ i & 0 \\end{bmatrix}$"""
+
+    Z = 3
+    """Z (int): Pauli-Z matrix, represented by the integer 3. \n
+    $Z = \\begin{bmatrix} 1 & 0 \\\\ 0 & -1 \\end{bmatrix}$"""
+
+
+class QSVMFeatureMapEntanglement(IntEnum):
+    FULL = 0
+    LINEAR = 1
+    CIRCULAR = 2
+    SCA = 3
+    PAIRWISE = 4
+
+
+BUILTIN_ENUM_DECLARATIONS = {
+    enum_def.__name__: EnumDeclaration(
+        name=enum_def.__name__,
+        members={enum_val.name: enum_val.value for enum_val in enum_def},
+    )
+    for enum_def in vars().values()
+    if (
+        isinstance(enum_def, type)
+        and issubclass(enum_def, IntEnum)
+        and enum_def is not IntEnum
+    )
+}
+
+__all__ = [
+    "Element",
+    "FermionMapping",
+    "FinanceFunctionType",
+    "LadderOperator",
+    "Optimizer",
+    "Pauli",
+    "QSVMFeatureMapEntanglement",
+]

classiq/qmod/builtins/functions/__init__.py

@@ -0,0 +1,137 @@
+from .allocation import *
+from .arithmetic import *
+from .benchmarking import *
+from .chemistry import *
+from .exponentiation import *
+from .finance import *
+from .operators import *
+from .qsvm import *
+from .standard_gates import *
+
+CORE_LIB_DECLS = [
+    func.func_decl
+    for func in (
+        molecule_ucc,
+        molecule_hva,
+        molecule_hartree_fock,
+        fock_hamiltonian_ucc,
+        fock_hamiltonian_hva,
+        fock_hamiltonian_hartree_fock,
+        log_normal_finance,
+        gaussian_finance,
+        pauli_feature_map,
+        bloch_sphere_feature_map,
+        H,
+        X,
+        Y,
+        Z,
+        I,
+        S,
+        T,
+        SDG,
+        TDG,
+        PHASE,
+        RX,
+        RY,
+        RZ,
+        R,
+        RXX,
+        RYY,
+        RZZ,
+        CH,
+        CX,
+        CY,
+        CZ,
+        CRX,
+        CRY,
+        CRZ,
+        CPHASE,
+        SWAP,
+        IDENTITY,
+        prepare_state,
+        prepare_amplitudes,
+        unitary,
+        add,
+        modular_add,
+        integer_xor,
+        modular_add_constant,
+        real_xor_constant,
+        U,
+        CCX,
+        allocate,
+        free,
+        randomized_benchmarking,
+        inplace_prepare_state,
+        inplace_prepare_amplitudes,
+        single_pauli_exponent,
+        suzuki_trotter,
+        qdrift,
+        exponentiation_with_depth_constraint,
+    )
+]
+
+STD_QMOD_OPERATORS = [func.func_decl for func in (apply, permute)]
+
+__all__ = [  # noqa: RUF022
+    "CCX",
+    "CH",
+    "CPHASE",
+    "CRX",
+    "CRY",
+    "CRZ",
+    "CX",
+    "CY",
+    "CZ",
+    "H",
+    "I",
+    "IDENTITY",
+    "PHASE",
+    "R",
+    "RX",
+    "RXX",
+    "RY",
+    "RYY",
+    "RZ",
+    "RZZ",
+    "SDG",
+    "S",
+    "SWAP",
+    "T",
+    "TDG",
+    "U",
+    "X",
+    "Y",
+    "Z",
+    "add",
+    "allocate",
+    "apply",
+    "bloch_sphere_feature_map",
+    "exponentiation_with_depth_constraint",
+    "fock_hamiltonian_hartree_fock",
+    "fock_hamiltonian_hva",
+    "fock_hamiltonian_ucc",
+    "free",
+    "gaussian_finance",
+    "inplace_prepare_amplitudes",
+    "inplace_prepare_state",
+    "integer_xor",
+    "log_normal_finance",
+    "modular_add",
+    "modular_add_constant",
+    "molecule_hartree_fock",
+    "molecule_hva",
+    "molecule_ucc",
+    "pauli_feature_map",
+    "permute",
+    "prepare_amplitudes",
+    "prepare_state",
+    "qdrift",
+    "randomized_benchmarking",
+    "real_xor_constant",
+    "single_pauli_exponent",
+    "suzuki_trotter",
+    "unitary",
+]
+BUILTIN_FUNCTION_DECLARATIONS = {
+    func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS
+}