classiq 0.42.2__py3-none-any.whl → 0.43.1__py3-none-any.whl

classiq/interface/model/quantum_type.py

@@ -12,11 +12,13 @@ from classiq.interface.generator.arith.register_user_input import (
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.qmod_qarray_proxy import QmodQArrayProxy
 from classiq.interface.generator.expressions.qmod_qscalar_proxy import (
+    QmodQBitProxy,
     QmodQNumProxy,
     QmodQScalarProxy,
 )
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import HandleBinding
 
 from classiq.exceptions import ClassiqValueError
 
@@ -45,13 +47,21 @@ class QuantumType(HashableASTNode):
     def set_size_in_bits(self, val: int) -> None:
         self._size_in_bits = val
 
-    def get_proxy(self, name: str) -> QmodSizedProxy:
-        return QmodSizedProxy(size=self.size_in_bits)
+    def get_proxy(self, handle: "HandleBinding") -> QmodSizedProxy:
+        return QmodSizedProxy(handle=handle, size=self.size_in_bits)
+
+    @property
+    def qmod_type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def type_name(self) -> str:
+        return self.get_proxy(HandleBinding(name="DUMMY")).type_name
 
 
 class QuantumScalar(QuantumType):
-    def get_proxy(self, name: str) -> QmodQScalarProxy:
-        return QmodQScalarProxy(name, size=self.size_in_bits)
+    def get_proxy(self, handle: "HandleBinding") -> QmodQScalarProxy:
+        return QmodQScalarProxy(handle, size=self.size_in_bits)
 
 
 class QuantumBit(QuantumScalar):
@@ -65,9 +75,19 @@ class QuantumBit(QuantumScalar):
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "qbit")
 
+    @property
+    def qmod_type_name(self) -> str:
+        return "QBit"
+
+    def get_proxy(self, handle: "HandleBinding") -> QmodQBitProxy:
+        return QmodQBitProxy(handle)
+
 
 class QuantumBitvector(QuantumType):
     kind: Literal["qvec"]
+    element_type: "ConcreteQuantumType" = Field(
+        discriminator="kind", default_factory=QuantumBit
+    )
     length: Optional[Expression]
 
     @pydantic.root_validator(pre=True)
@@ -75,11 +95,41 @@ class QuantumBitvector(QuantumType):
         return values_with_discriminator(values, "kind", "qvec")
 
     def _update_size_in_bits_from_declaration(self) -> None:
-        if self.length is not None and self.length.is_evaluated():
-            self._size_in_bits = self.length.to_int_value()
+        self.element_type._update_size_in_bits_from_declaration()
+        if self.element_type.has_size_in_bits and self.has_length:
+            assert self.length is not None
+            self._size_in_bits = (
+                self.element_type.size_in_bits * self.length.to_int_value()
+            )
 
-    def get_proxy(self, name: str) -> QmodQArrayProxy:
-        return QmodQArrayProxy(name, self.size_in_bits)
+    @property
+    def has_length(self) -> bool:
+        return self.length is not None and self.length.is_evaluated()
+
+    @property
+    def length_value(self) -> int:
+        if not self.has_length:
+            raise ClassiqValueError(
+                "Tried to access unevaluated length of quantum array"
+            )
+        assert self.length is not None
+        return self.length.to_int_value()
+
+    def get_proxy(self, handle: "HandleBinding") -> QmodQArrayProxy:
+        element_size = self.element_type.size_in_bits
+        assert self.size_in_bits % element_size == 0
+        return QmodQArrayProxy(
+            handle,
+            self.element_type.get_proxy,
+            element_size,
+            self.size_in_bits // element_size,
+        )
+
+    @property
+    def qmod_type_name(self) -> str:
+        element_type = [self.element_type.qmod_type_name]
+        length = [self.length.expr] if self.length is not None else []
+        return f"QArray[{', '.join(element_type + length)}]"
 
 
 class QuantumNumeric(QuantumScalar):
@@ -125,19 +175,30 @@ class QuantumNumeric(QuantumScalar):
         if self.size is not None and self.size.is_evaluated():
             self._size_in_bits = self.size.to_int_value()
 
-    def get_proxy(self, name: str) -> QmodQNumProxy:
+    def get_proxy(self, handle: "HandleBinding") -> QmodQNumProxy:
         return QmodQNumProxy(
-            name,
+            handle,
             size=self.size_in_bits,
             fraction_digits=self.fraction_digits_value,
             is_signed=self.sign_value,
         )
 
+    @property
+    def qmod_type_name(self) -> str:
+        if (
+            self.size is not None
+            and self.is_signed is not None
+            and self.fraction_digits is not None
+        ):
+            return f"QNum[{self.size.expr}, {self.is_signed.expr}, {self.fraction_digits.expr}]"
+        return "QNum"
+
 
 ConcreteQuantumType = Annotated[
     Union[QuantumBit, QuantumBitvector, QuantumNumeric],
     Field(discriminator="kind", default_factory=QuantumBitvector),
 ]
+QuantumBitvector.update_forward_refs()
 
 
 def register_info_to_quantum_type(reg_info: RegisterArithmeticInfo) -> QuantumNumeric:

classiq/interface/server/routes.py

@@ -39,8 +39,6 @@ TASKS_GENERATE_SUFFIX = TASKS_SUFFIX + "/generate"
 TASKS_VISUALIZE_SUFFIX = TASKS_SUFFIX + "/visualize"
 TASKS_VISUAL_MODEL_SUFFIX = TASKS_SUFFIX + "/visual_model"
 TASKS_SOLVE_SUFFIX = "/tasks/solve"
-MODEL_GENERATE_PREFIX = "/generate_model"
-CHEMISTRY_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/chemistry"
 
 CHEMISTRY_QMOD_PATH = "/generate_model/chemistry/qmod"
 GROVER_QMOD_PATH = "/generate_model/grover/qmod"
@@ -70,10 +68,6 @@ GENERATE_HAMILTONIAN_FULL_PATH = (
     SYNTHESIS_NON_VERSIONED_PREFIX + GENERATE_HAMILTONIAN_SUFFIX
 )
 
-FINANCE_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/finance"
-
-GROVER_GENERATE_MODEL_PATH = MODEL_GENERATE_PREFIX + "/grover"
-
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX = "/execution_input"
 CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_FULL = (
     CONVERSION_PREFIX + CONVERSION_GENERATED_CIRCUIT_TO_EXECUTION_INPUT_SUFFIX

classiq/qmod/__init__.py

@@ -26,11 +26,11 @@ __all__ = [
     "QCallable",
     "QCallableList",
     "QConstant",
-    "struct",
-    "qfunc",
     "cfunc",
     "create_model",
+    "get_expression_numeric_attributes",
+    "qfunc",
+    "struct",
     "symbolic",
     "write_qmod",
-    "get_expression_numeric_attributes",
 ] + _builtins_all

classiq/qmod/builtins/__init__.py

@@ -1,9 +1,13 @@
+from classiq.interface.finance.function_input import FinanceFunctionInput
+
 from .classical_execution_primitives import *  # noqa: F403
 from .classical_execution_primitives import (
     __all__ as _builtin_classical_execution_primitives,
 )
 from .classical_functions import *  # noqa: F403
 from .classical_functions import __all__ as _builtin_classical_functions
+from .enums import *  # noqa: F403
+from .enums import __all__ as _builtin_enums
 from .functions import *  # noqa: F403
 from .functions import __all__ as _builtin_functions
 from .operations import *  # noqa: F403
@@ -11,8 +15,13 @@ from .operations import __all__ as _builtin_operations
 from .structs import *  # noqa: F403
 from .structs import __all__ as _builtin_structs
 
+FinanceFunctionInput.update_forward_refs(
+    FinanceFunctionType=FinanceFunctionType  # noqa: F405
+)
+
 __all__ = (
-    _builtin_structs
+    _builtin_enums
+    + _builtin_structs
     + _builtin_functions
     + _builtin_operations
     + _builtin_classical_execution_primitives

classiq/qmod/builtins/classical_execution_primitives.py

@@ -1,4 +1,4 @@
-from typing import Dict, List, Optional, Union
+from typing import Dict, Final, List, Optional, Union
 
 from classiq.interface.executor.execution_preferences import QaeWithQpeEstimationMethod
 from classiq.interface.executor.iqae_result import IQAEResult
@@ -9,11 +9,11 @@ from classiq.interface.executor.result import (
     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.applications.qsvm.qsvm import Data, Labels
 from classiq.exceptions import ClassiqError
+from classiq.qmod.builtins.enums import Optimizer
 
 ExecutionParams = Dict[str, Union[float, int, List[int], List[float]]]
 
@@ -21,6 +21,8 @@ _CALL_IN_QFUNC_ERROR = (
     'Cannot call "{}" in a quantum context. "{}" is a classical execution primitive.'
 )
 
+CARRAY_SEPARATOR: Final[str] = "_"
+
 
 def _raise_error(primitive_name: str) -> None:
     raise ClassiqError(_CALL_IN_QFUNC_ERROR.format(primitive_name, primitive_name))

classiq/qmod/builtins/enums.py

@@ -0,0 +1,177 @@
+# This file was generated automatically - do not edit manually
+
+from enum import IntEnum
+
+
+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):
+    I = 0  # noqa: E741
+    X = 1
+    Y = 2
+    Z = 3
+
+
+class QSVMFeatureMapEntanglement(IntEnum):
+    FULL = 0
+    LINEAR = 1
+    CIRCULAR = 2
+    SCA = 3
+    PAIRWISE = 4
+
+
+__all__ = [
+    "Element",
+    "FermionMapping",
+    "FinanceFunctionType",
+    "LadderOperator",
+    "Optimizer",
+    "Pauli",
+    "QSVMFeatureMapEntanglement",
+]

classiq/qmod/builtins/functions.py

@@ -1,7 +1,6 @@
 # This file was generated automatically - do not edit manually
 
-from classiq.interface.generator.expressions.enums.pauli import Pauli
-
+from classiq.qmod.builtins.enums import Pauli
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
 from classiq.qmod.qmod_variable import Input, Output, QArray, QBit, QNum

classiq/qmod/builtins/operations.py

@@ -56,7 +56,7 @@ def bind(
 
 
 def if_(
-    condition: SymbolicExpr,
+    condition: Union[SymbolicExpr, bool],
     then: Union[QCallable, Callable[[], None]],
     else_: Union[QCallable, Callable[[], None], int] = _MISSING_VALUE,
 ) -> None:
@@ -164,9 +164,7 @@ def repeat(count: Union[SymbolicExpr, int], iteration: Callable[[int], None]) ->
         repeat.__name__,
     )
     if not isinstance(iteration_operand, QuantumLambdaFunction):
-        raise ClassiqValueError(
-            "`repeat`'s `iteration` argument must be a lambda function"
-        )
+        raise ClassiqValueError("`repeat`'s `iteration` argument must be a callable.")
     QCallable.CURRENT_EXPANDABLE.append_statement_to_body(
         Repeat(
             iter_var=inspect.getfullargspec(iteration).args[0],

classiq/qmod/builtins/structs.py

@@ -1,19 +1,18 @@
 # This file was generated automatically - do not edit manually
 
-from classiq.interface.generator.expressions.enums.ladder_operator import LadderOperator
-from classiq.interface.generator.expressions.enums.pauli import Pauli
+from dataclasses import dataclass
 
+from classiq.qmod.builtins.enums import LadderOperator, Pauli
 from classiq.qmod.qmod_parameter import CArray, CBool, CInt, CReal
-from classiq.qmod.qmod_struct import struct
 
 
-@struct
+@dataclass
 class PauliTerm:
     pauli: CArray[Pauli]
     coefficient: CReal
 
 
-@struct
+@dataclass
 class MoleculeProblem:
     mapping: CInt
     z2_symmetries: CBool
@@ -22,27 +21,27 @@ class MoleculeProblem:
     remove_orbitals: CArray[CInt]
 
 
-@struct
+@dataclass
 class Molecule:
     atoms: CArray["ChemistryAtom"]
     spin: CInt
     charge: CInt
 
 
-@struct
+@dataclass
 class ChemistryAtom:
     element: CInt
     position: "Position"
 
 
-@struct
+@dataclass
 class Position:
     x: CReal
     y: CReal
     z: CReal
 
 
-@struct
+@dataclass
 class FockHamiltonianProblem:
     mapping: CInt
     z2_symmetries: CBool
@@ -50,19 +49,19 @@ class FockHamiltonianProblem:
     num_particles: CArray[CInt]
 
 
-@struct
+@dataclass
 class LadderTerm:
     coefficient: CReal
     ops: CArray["LadderOp"]
 
 
-@struct
+@dataclass
 class LadderOp:
     op: LadderOperator
     index: CInt
 
 
-@struct
+@dataclass
 class CombinatorialOptimizationSolution:
     probability: CReal
     cost: CReal
@@ -70,7 +69,7 @@ class CombinatorialOptimizationSolution:
     count: CInt
 
 
-@struct
+@dataclass
 class GaussianModel:
     num_qubits: CInt
     normal_max_value: CReal
@@ -80,14 +79,14 @@ class GaussianModel:
     min_loss: CInt
 
 
-@struct
+@dataclass
 class LogNormalModel:
     num_qubits: CInt
     mu: CReal
     sigma: CReal
 
 
-@struct
+@dataclass
 class FinanceFunction:
     f: CInt
     threshold: CReal
@@ -97,13 +96,13 @@ class FinanceFunction:
     tail_probability: CReal
 
 
-@struct
+@dataclass
 class QsvmResult:
     test_score: CReal
     predicted_labels: CArray[CReal]
 
 
-@struct
+@dataclass
 class QSVMFeatureMapPauli:
     feature_dimension: CInt
     reps: CInt

classiq/qmod/declaration_inferrer.py

@@ -1,11 +1,11 @@
 import dataclasses
 import inspect
+from enum import EnumMeta
 from typing import (
     Any,
     Callable,
     Dict,
     List,
-    Mapping,
     Optional,
     Type,
     get_args,
@@ -14,22 +14,20 @@ from typing import (
 
 from typing_extensions import _AnnotatedAlias
 
-from classiq.interface.generator.expressions.enums.ladder_operator import (
-    LadderOperator as LadderOperatorEnum,
-)
-from classiq.interface.generator.expressions.enums.pauli import Pauli as PauliEnum
 from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
     ClassicalList,
     ConcreteClassicalType,
-    CStructBase,
+    Enum,
     Integer,
-    LadderOperator as LadderOperatorType,
-    Pauli as PauliType,
     Real,
     Struct,
 )
+from classiq.interface.generator.types.enum_declaration import (
+    EnumDeclaration,
+    declaration_from_enum,
+)
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -49,10 +47,6 @@ from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 OPERAND_ARG_NAME = "arg{i}"
-ENUM_TYPE_MAPPING: Mapping[type, type] = {
-    PauliEnum: PauliType,
-    LadderOperatorEnum: LadderOperatorType,
-}
 
 
 def python_type_to_qmod(
@@ -64,8 +58,6 @@ def python_type_to_qmod(
         return Real()
     elif py_type == bool or py_type is CBool:
         return Bool()
-    elif py_type in ENUM_TYPE_MAPPING:
-        return ENUM_TYPE_MAPPING[py_type]()
     elif get_origin(py_type) == list:
         return ClassicalList(
             element_type=python_type_to_qmod(get_args(py_type)[0], qmodule=qmodule)
@@ -85,15 +77,26 @@ def python_type_to_qmod(
             "CArray accepts one or two generic parameters in the form "
             "`CArray[<element-type>]` or `CArray[<element-type>, <size>]`"
         )
-    elif inspect.isclass(py_type) and issubclass(py_type, CStructBase):
+    elif inspect.isclass(py_type) and dataclasses.is_dataclass(py_type):
         _add_qmod_struct(py_type, qmodule=qmodule)
         return Struct(name=py_type.__name__)
+    elif inspect.isclass(py_type) and isinstance(py_type, EnumMeta):
+        _add_qmod_enum(py_type, qmodule=qmodule)
+        return Enum(name=py_type.__name__)
     return None
 
 
-def _add_qmod_struct(
-    py_type: Type[CStructBase], *, qmodule: ModelStateContainer
-) -> None:
+def _add_qmod_enum(py_type: EnumMeta, *, qmodule: ModelStateContainer) -> None:
+    if (
+        py_type.__name__ in EnumDeclaration.BUILTIN_ENUM_DECLARATIONS
+        or py_type.__name__ in qmodule.enum_decls
+    ):
+        return
+
+    qmodule.enum_decls[py_type.__name__] = declaration_from_enum(py_type)
+
+
+def _add_qmod_struct(py_type: Type, *, qmodule: ModelStateContainer) -> None:
     if (
         py_type.__name__ in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS
         or py_type.__name__ in qmodule.type_decls
@@ -148,8 +151,8 @@ def _extract_positional_args(
             inspect.isclass(py_type)
             and (
                 issubclass(py_type, CParam)
-                or issubclass(py_type, CStructBase)
-                or py_type in ENUM_TYPE_MAPPING
+                or dataclasses.is_dataclass(py_type)
+                or isinstance(py_type, EnumMeta)
             )
             or get_origin(py_type) == CArray
         ):

classiq/qmod/model_state_container.py

@@ -1,12 +1,14 @@
 from typing import Dict
 
 from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 
 from classiq import StructDeclaration
 
 
 class ModelStateContainer:
+    enum_decls: Dict[str, EnumDeclaration]
     type_decls: Dict[str, StructDeclaration]
     native_defs: Dict[str, NativeFunctionDefinition]
     constants: Dict[str, Constant]