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

classiq/interface/generator/functions/classical_type.py

@@ -1,4 +1,3 @@
-from abc import abstractmethod
 from typing import Any, Dict, List, Literal, Union
 
 import pydantic
@@ -7,11 +6,6 @@ from sympy import IndexedBase, Symbol
 from typing_extensions import Annotated
 
 from classiq.interface.ast_node import HashableASTNode
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-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.expressions.expression_types import RuntimeExpression
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
@@ -24,13 +18,6 @@ class ClassicalType(HashableASTNode):
     def as_symbolic(self, name: str) -> Union[NamedSymbol, List[NamedSymbol]]:
         return Symbol(name)
 
-    @property
-    @abstractmethod
-    def default_value(self) -> Any:
-        raise NotImplementedError(
-            f"{self.__class__.__name__} type has no default value"
-        )
-
     @property
     def qmod_type(self) -> type:
         raise NotImplementedError(
@@ -44,20 +31,12 @@ class ClassicalType(HashableASTNode):
         return str(type(self).__name__)
 
 
-class EnumType(ClassicalType):
-    pass
-
-
 class Integer(ClassicalType):
     kind: Literal["int"]
 
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, integer=True)
 
-    @property
-    def default_value(self) -> int:
-        return 0
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "int")
@@ -75,10 +54,6 @@ class Real(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return Symbol(name, real=True)
 
-    @property
-    def default_value(self) -> float:
-        return 0.0
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "real")
@@ -93,10 +68,6 @@ class Real(ClassicalType):
 class Bool(ClassicalType):
     kind: Literal["bool"]
 
-    @property
-    def default_value(self) -> bool:
-        return False
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "bool")
@@ -115,10 +86,6 @@ class ClassicalList(ClassicalType):
     def as_symbolic(self, name: str) -> Symbol:
         return IndexedBase(name)
 
-    @property
-    def default_value(self) -> List:
-        return []
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "list")
@@ -130,45 +97,31 @@ class ClassicalList(ClassicalType):
         return CArray[self.element_type.qmod_type]  # type:ignore[name-defined]
 
 
-class Pauli(EnumType):
+class Pauli(ClassicalType):
     kind: Literal["pauli"]
 
-    @property
-    def default_value(self) -> PauliEnum:
-        return PauliEnum.I
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "pauli")
 
     @property
     def qmod_type(self) -> type:
-        return PauliEnum
+        from classiq.qmod.builtins.enums import Pauli
+
+        return Pauli
 
 
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
 
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "type_proxy")
 
 
-class CStructBase:  # marker for Qmod structs in the Python SDK
-    pass
-
-
-class Struct(ClassicalType):
+class TypeName(ClassicalType):
     kind: Literal["struct_instance"]
-    name: str = pydantic.Field(description="The struct type of the instance")
-
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
+    name: str = pydantic.Field(description="The type name of the instance")
 
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
@@ -176,7 +129,15 @@ class Struct(ClassicalType):
 
     @property
     def qmod_type(self) -> type:
-        return type(self.name, (CStructBase,), dict())
+        return type(self.name, (TypeName,), dict())
+
+
+class Enum(TypeName):
+    pass
+
+
+class Struct(TypeName):
+    pass
 
 
 class ClassicalArray(ClassicalType):
@@ -187,10 +148,6 @@ class ClassicalArray(ClassicalType):
     def as_symbolic(self, name: str) -> list:
         return [self.element_type.as_symbolic(f"{name}_{i}") for i in range(self.size)]
 
-    @property
-    def default_value(self) -> Any:
-        return super().default_value
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
@@ -205,9 +162,7 @@ class ClassicalArray(ClassicalType):
 
 
 class OpaqueHandle(ClassicalType):
-    @property
-    def default_value(self) -> int:
-        return 0
+    pass
 
 
 class VQEResult(OpaqueHandle):
@@ -242,20 +197,18 @@ class IQAERes(OpaqueHandle):
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-class LadderOperator(EnumType):
+class LadderOperator(ClassicalType):
     kind: Literal["ladder_operator"]
 
-    @property
-    def default_value(self) -> LadderOperatorEnum:
-        return LadderOperatorEnum.PLUS
-
     @pydantic.root_validator(pre=True)
     def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
         return values_with_discriminator(values, "kind", "ladder_operator")
 
     @property
     def qmod_type(self) -> type:
-        return LadderOperatorEnum
+        from classiq.qmod.builtins.enums import LadderOperator
+
+        return LadderOperator
 
 
 ConcreteClassicalType = Annotated[
@@ -266,7 +219,7 @@ ConcreteClassicalType = Annotated[
         ClassicalList,
         Pauli,
         StructMetaType,
-        Struct,
+        TypeName,
         ClassicalArray,
         VQEResult,
         Histogram,
@@ -279,7 +232,7 @@ ConcreteClassicalType = Annotated[
 ClassicalList.update_forward_refs()
 ClassicalArray.update_forward_refs()
 
-PythonClassicalTypes = (int, float, bool, list, CStructBase, ClassicalEnum)
+PythonClassicalTypes = (int, float, bool, list, Enum)
 
 
 def as_symbolic(symbols: Dict[str, ClassicalType]) -> Dict[str, RuntimeExpression]:

classiq/interface/generator/functions/port_declaration.py

@@ -1,8 +1,5 @@
 from typing import Any
 
-import pydantic
-from pydantic import BaseModel
-
 from classiq.interface.generator.function_params import PortDirection
 
 from classiq._internals.enum_utils import StrEnum
@@ -39,11 +36,3 @@ class PortDeclarationDirection(StrEnum):
         cls, port_direction: PortDirection
     ) -> "PortDeclarationDirection":
         return cls(port_direction.value)
-
-
-class SynthesisPortDeclaration(BaseModel):
-    name: str
-    size: int
-    direction: PortDeclarationDirection
-    is_signed: bool = pydantic.Field(default=False)
-    fraction_places: int = pydantic.Field(default=0)

classiq/interface/generator/model/__init__.py

@@ -5,7 +5,6 @@ from classiq.interface.generator.model.constraints import (
     OptimizationParameter,
     TranspilerBasisGates,
 )
-from classiq.interface.generator.model.model import SynthesisModel
 from classiq.interface.generator.model.preferences import (
     CustomHardwareSettings,
     Preferences,

classiq/interface/generator/model/model.py

@@ -1,68 +1,36 @@
 from abc import ABC
-from typing import Any, Dict, List, Literal, Mapping, NewType, Optional, Union
+from typing import List
 
 import pydantic
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.constant import Constant
-from classiq.interface.generator.function_params import ArithmeticIODict, IOName
-from classiq.interface.generator.functions import (
-    SynthesisNativeFunctionDefinition,
-    SynthesisPortDeclaration,
-    SynthesisQuantumFunctionDeclaration,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.model.constraints import Constraints
-from classiq.interface.generator.model.preferences.preferences import Preferences
-from classiq.interface.generator.model.quantum_register import QReg, QRegGenericAlias
-from classiq.interface.generator.quantum_function_call import (
-    SUFFIX_RANDOMIZER,
-    SynthesisQuantumFunctionCall,
-    WireDict,
-    WireName,
-)
+from classiq.interface.generator.function_params import ArithmeticIODict
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq import ForeignFunctionDefinition as SynthesisForeignFunctionDefinition
 from classiq.exceptions import ClassiqValueError
 
-MAIN_FUNCTION_NAME = "main"
-CLASSICAL_ENTRY_FUNCTION_NAME = "cmain"
-
-DEFAULT_PORT_SIZE = 1
-
-
-SerializedModel = NewType("SerializedModel", str)
-
-# We need to define ConcreteFunctionData so pydantic will know
-# what class to use when deserializing from object (pydantic attempts to
-# parse as each of the classes in the Union, in order).
-ConcreteFunctionDefinition = Union[
-    SynthesisForeignFunctionDefinition, SynthesisNativeFunctionDefinition
-]
-
 TYPE_LIBRARY_DUPLICATED_TYPE_NAMES = (
     "Cannot have multiple struct types with the same name"
 )
 
 
-def _create_default_functions() -> List[ConcreteFunctionDefinition]:
-    return [SynthesisNativeFunctionDefinition(name=MAIN_FUNCTION_NAME)]
-
-
 class ClassiqBaseModel(VersionedModel, ABC):
     """
     All the relevant data for evaluating execution in one place.
     """
 
+    enums: List[EnumDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined enums",
+    )
+
     types: List[StructDeclaration] = pydantic.Field(
         default_factory=list,
-        description="The user-defined custom function library.",
+        description="user-defined structs",
     )
 
     constants: List[Constant] = pydantic.Field(
@@ -90,147 +58,3 @@ class ExecutionModel(ClassiqBaseModel):
         description="Mapping between a measured register name and its arithmetic type",
         default_factory=dict,
     )
-
-
-class SynthesisModel(ClassiqBaseModel):
-    """
-    All the relevant data for generating quantum circuit in one place.
-    """
-
-    kind: Literal["synthesis"] = pydantic.Field(default="synthesis")
-
-    # Must be validated before logic_flow
-    functions: List[ConcreteFunctionDefinition] = pydantic.Field(
-        default_factory=_create_default_functions,
-        description="The quantum functions of the model.",
-    )
-
-    constraints: Constraints = pydantic.Field(default_factory=Constraints)
-    preferences: Preferences = pydantic.Field(default_factory=Preferences)
-
-    def __init__(
-        self,
-        *,
-        body: Optional[List[SynthesisQuantumFunctionCall]] = None,
-        inputs: Optional[WireDict] = None,
-        outputs: Optional[WireDict] = None,
-        **kwargs: Any,
-    ) -> None:
-        super().__init__(**kwargs)
-        if body:
-            self.main_func.body.extend(body)
-        if inputs:
-            self.set_inputs(
-                {
-                    name: QRegGenericAlias(
-                        QReg(DEFAULT_PORT_SIZE), (DEFAULT_PORT_SIZE, 0)
-                    )
-                    for name in inputs.keys()
-                },
-                inputs,
-            )
-        if outputs:
-            self.set_outputs(
-                {name: QReg(DEFAULT_PORT_SIZE) for name in outputs.keys()}, outputs
-            )
-
-    @property
-    def main_func(self) -> SynthesisNativeFunctionDefinition:
-        return self.function_dict[MAIN_FUNCTION_NAME]  # type:ignore[return-value]
-
-    @property
-    def body(self) -> List[SynthesisQuantumFunctionCall]:
-        return self.main_func.body
-
-    @property
-    def inputs(self) -> WireDict:
-        return self.main_func.input_ports_wiring
-
-    def set_inputs(
-        self,
-        inputs: Mapping[IOName, QRegGenericAlias],
-        input_wiring: Mapping[IOName, WireName],
-    ) -> None:
-        self._update_main_declarations(inputs, PortDeclarationDirection.Input)
-        self.main_func.input_ports_wiring.update(input_wiring)
-
-    @property
-    def outputs(self) -> WireDict:
-        return self.main_func.output_ports_wiring
-
-    def set_outputs(
-        self, outputs: Mapping[IOName, QReg], output_wiring: Mapping[IOName, WireName]
-    ) -> None:
-        self._update_main_declarations(outputs, PortDeclarationDirection.Output)
-        self.main_func.output_ports_wiring.update(output_wiring)
-
-    @pydantic.validator("preferences", always=True)
-    def _seed_suffix_randomizer(cls, preferences: Preferences) -> Preferences:
-        SUFFIX_RANDOMIZER.seed(preferences.random_seed)
-        return preferences
-
-    def _get_qualified_direction(
-        self, port_name: str, direction: PortDeclarationDirection
-    ) -> PortDeclarationDirection:
-        if port_name in self.main_func.port_declarations:
-            return PortDeclarationDirection.Inout
-        return direction
-
-    def _update_main_declarations(
-        self,
-        value: Union[Mapping[IOName, QReg], Mapping[IOName, QRegGenericAlias]],
-        direction: PortDeclarationDirection,
-    ) -> None:
-        for port_name, register in value.items():
-            if isinstance(register, QReg):
-                size = len(register)
-                is_signed = getattr(register, "is_signed", False) or False
-                fraction_places = getattr(register, "fraction_places", 0) or 0
-            else:
-                size = register.size if register.size is not None else DEFAULT_PORT_SIZE
-                is_signed = False
-                fraction_places = (
-                    register.fraction_places
-                    if register.fraction_places is not None
-                    else 0
-                )
-
-            self.main_func.port_declarations[port_name] = SynthesisPortDeclaration(
-                name=port_name,
-                size=size,
-                direction=self._get_qualified_direction(port_name, direction),
-                is_signed=is_signed,
-                fraction_places=fraction_places,
-            )
-
-    @property
-    def function_dict(self) -> Dict[str, SynthesisQuantumFunctionDeclaration]:
-        return nameables_to_dict(self.functions)
-
-    @pydantic.validator("functions", each_item=True)
-    def validate_static_correctness(
-        cls, func_def: ConcreteFunctionDefinition
-    ) -> ConcreteFunctionDefinition:
-        if isinstance(func_def, SynthesisNativeFunctionDefinition):
-            func_def.validate_body()
-        return func_def
-
-    @pydantic.validator("functions")
-    def validate_main_function_exists(
-        cls, func_defs: List[ConcreteFunctionDefinition]
-    ) -> List[ConcreteFunctionDefinition]:
-        if MAIN_FUNCTION_NAME not in {func.name for func in func_defs}:
-            raise ClassiqValueError("The model must contain a `main` function")
-        return func_defs
-
-    def get_model(self) -> SerializedModel:
-        return SerializedModel(self.json(exclude_defaults=True, indent=2))
-
-    def classical_model(self) -> ExecutionModel:
-        return ExecutionModel(
-            types=self.types,
-            constants=self.constants,
-            classical_execution_code=self.classical_execution_code,
-            execution_preferences=self.execution_preferences,
-            circuit_outputs=self.main_func.outputs,
-        )

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,9 +1,11 @@
-from typing import Dict, Optional, Set
+from typing import Dict, Final, Optional, Set
 
 import pydantic
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
 
+CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
+
 
 class FunctionExecutionData(pydantic.BaseModel):
     power_parameter: Optional[PydanticExecutionParameter] = pydantic.Field(default=None)

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -0,0 +1,69 @@
+from classiq.interface.chemistry.elements import ELEMENTS
+from classiq.interface.chemistry.ground_state_problem import FermionMapping
+from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+
+ELEMENT = EnumDeclaration(
+    name="Element", members={element: idx for idx, element in enumerate(ELEMENTS)}
+)
+
+FERMION_MAPPING = EnumDeclaration(
+    name="FermionMapping",
+    members={
+        mapping.name: idx  # type:ignore[attr-defined]
+        for idx, mapping in enumerate(FermionMapping)
+    },
+)
+
+FINANCE_FUNCTION_TYPE = EnumDeclaration(
+    name="FinanceFunctionType",
+    members={
+        "VAR": 0,
+        "SHORTFALL": 1,
+        "X_SQUARE": 2,
+        "EUROPEAN_CALL_OPTION": 3,
+    },
+)
+
+LADDER_OPERATOR = EnumDeclaration(
+    name="LadderOperator",
+    members={
+        "PLUS": 0,
+        "MINUS": 1,
+    },
+)
+
+OPTIMIZER = EnumDeclaration(
+    name="Optimizer",
+    members={
+        "COBYLA": 1,
+        "SPSA": 2,
+        "L_BFGS_B": 3,
+        "NELDER_MEAD": 4,
+        "ADAM": 5,
+    },
+)
+
+PAULI = EnumDeclaration(
+    name="Pauli",
+    members={
+        "I": 0,
+        "X": 1,
+        "Y": 2,
+        "Z": 3,
+    },
+)
+
+QSVM_FEATURE_MAP_ENTANGLEMENT = EnumDeclaration(
+    name="QSVMFeatureMapEntanglement",
+    members={
+        "FULL": 0,
+        "LINEAR": 1,
+        "CIRCULAR": 2,
+        "SCA": 3,
+        "PAIRWISE": 4,
+    },
+)
+
+for enum_decl in list(vars().values()):
+    if isinstance(enum_decl, EnumDeclaration):
+        EnumDeclaration.BUILTIN_ENUM_DECLARATIONS[enum_decl.name] = enum_decl

classiq/interface/generator/types/builtin_struct_declarations/pauli_struct_declarations.py

@@ -2,7 +2,7 @@ import functools
 
 from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
-    Pauli,
+    Enum,
     Real,
     Struct,
 )
@@ -12,7 +12,7 @@ from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 PAULI_TERM = StructDeclaration(
     name="PauliTerm",
     variables={
-        "pauli": ClassicalList(element_type=Pauli()),
+        "pauli": ClassicalList(element_type=Enum(name="Pauli")),
         "coefficient": Real(),
     },
 )

classiq/interface/generator/types/enum_declaration.py

@@ -0,0 +1,57 @@
+from collections import Counter
+from enum import Enum, EnumMeta, IntEnum
+from typing import ClassVar, Dict
+
+import pydantic
+
+from classiq.interface.ast_node import HashableASTNode
+
+from classiq.exceptions import ClassiqValueError
+
+
+class EnumDeclaration(HashableASTNode):
+    name: str
+
+    members: Dict[str, int] = pydantic.Field(
+        default_factory=dict,
+        description="Dictionary of member names and their values",
+    )
+
+    BUILTIN_ENUM_DECLARATIONS: ClassVar[Dict[str, "EnumDeclaration"]] = {}
+
+    @pydantic.validator("members")
+    def _validate_members(cls, members: Dict[str, int]) -> Dict[str, int]:
+        underscore_members = [
+            member for member in members.keys() if member.startswith("_")
+        ]
+        if len(underscore_members) > 0:
+            raise ClassiqValueError(
+                f"Enum member names must not start with an underscore. The offending "
+                f"members: {underscore_members}"
+            )
+
+        counter = Counter(members.values())
+        repeating_members = [
+            member for member, value in members.items() if counter[value] > 1
+        ]
+        if len(repeating_members) > 0:
+            raise ClassiqValueError(
+                f"Cannot assign the same value to more than one enum member. The "
+                f"offending members: {repeating_members}"
+            )
+
+        return members
+
+    def create_enum(self) -> IntEnum:
+        return IntEnum(self.name, self.members)
+
+
+def declaration_from_enum(enum_type: EnumMeta) -> EnumDeclaration:
+    members: list[Enum] = list(enum_type)
+    return EnumDeclaration(
+        name=enum_type.__name__,
+        members={
+            member.name: member.value
+            for member in sorted(members, key=lambda member: member.value)
+        },
+    )