classiq 0.43.2__py3-none-any.whl → 0.44.0__py3-none-any.whl

classiq/interface/generator/functions/builtins/quantum_operators.py

@@ -1,35 +1,22 @@
-from typing import Any
-
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
     QuantumOperandDeclaration,
 )
 
-
-def get_single_empty_operand_operator(
-    operator_name: str, **kwargs: Any
-) -> QuantumFunctionDeclaration:
-    operand_field_name = "operand"
-    return QuantumFunctionDeclaration(
-        name=operator_name,
-        operand_declarations={
-            operand_field_name: QuantumOperandDeclaration(name=operand_field_name)
-        },
-        **kwargs,
-    )
-
-
-PERMUTE_OPERATOR = QuantumFunctionDeclaration(
+PERMUTE_OPERATOR = NamedParamsQuantumFunctionDeclaration(
     name="permute",
-    operand_declarations={
-        "functions": QuantumOperandDeclaration(
+    positional_arg_declarations=[
+        QuantumOperandDeclaration(
             name="functions",
             is_list=True,
         )
-    },
+    ],
 )
 
-APPLY_OPERATOR = get_single_empty_operand_operator(operator_name="apply")
+APPLY_OPERATOR = NamedParamsQuantumFunctionDeclaration(
+    name="apply",
+    positional_arg_declarations=[QuantumOperandDeclaration(name="operand")],
+)
 
 STD_QMOD_OPERATORS = [
     PERMUTE_OPERATOR,

classiq/interface/generator/functions/classical_function_declaration.py

@@ -1,11 +1,14 @@
-from typing import ClassVar, Dict, Mapping, Optional
+from typing import ClassVar, Dict, Optional, Sequence
 
 import pydantic
 
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 from classiq.interface.generator.functions.function_declaration import (
     FunctionDeclaration,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 
 class ClassicalFunctionDeclaration(FunctionDeclaration):
@@ -13,6 +16,12 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
     Facilitates the creation of a common classical function interface object.
     """
 
+    name: str
+
+    positional_parameters: Sequence[ClassicalParameterDeclaration] = pydantic.Field(
+        default_factory=list,
+    )
+
     return_type: Optional[ConcreteClassicalType] = pydantic.Field(
         description="The type of the classical value that is returned by the function (for classical functions)",
         default=None,
@@ -26,10 +35,9 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
         Dict[str, "ClassicalFunctionDeclaration"]
     ] = {}
 
-    def update_logic_flow(
-        self, function_dict: Mapping[str, "ClassicalFunctionDeclaration"]
-    ) -> None:
-        pass
+    @property
+    def param_decls(self) -> Sequence[ClassicalParameterDeclaration]:
+        return self.positional_parameters
 
 
 ClassicalFunctionDeclaration.update_forward_refs()

classiq/interface/generator/functions/classical_type.py

@@ -1,14 +1,18 @@
-from typing import Any, Dict, List, Literal, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Literal, Union
 
 import pydantic
-from pydantic import Extra, Field
+from pydantic import Extra
 from sympy import IndexedBase, Symbol
-from typing_extensions import Annotated
 
 from classiq.interface.ast_node import HashableASTNode
 from classiq.interface.generator.expressions.expression_types import RuntimeExpression
 from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
 
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import (
+        ConcreteClassicalType,
+    )
+
 CLASSICAL_ATTRIBUTES = {"len", "size", "is_signed", "fraction_digits"}
 
 NamedSymbol = Union[IndexedBase, Symbol]
@@ -97,20 +101,6 @@ class ClassicalList(ClassicalType):
         return CArray[self.element_type.qmod_type]  # type:ignore[name-defined]
 
 
-class Pauli(ClassicalType):
-    kind: Literal["pauli"]
-
-    @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:
-        from classiq.qmod.builtins.enums import Pauli
-
-        return Pauli
-
-
 class StructMetaType(ClassicalType):
     kind: Literal["type_proxy"]
 
@@ -119,27 +109,6 @@ class StructMetaType(ClassicalType):
         return values_with_discriminator(values, "kind", "type_proxy")
 
 
-class TypeName(ClassicalType):
-    kind: Literal["struct_instance"]
-    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]:
-        return values_with_discriminator(values, "kind", "struct_instance")
-
-    @property
-    def qmod_type(self) -> type:
-        return type(self.name, (TypeName,), dict())
-
-
-class Enum(TypeName):
-    pass
-
-
-class Struct(TypeName):
-    pass
-
-
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
@@ -197,44 +166,6 @@ class IQAERes(OpaqueHandle):
         return values_with_discriminator(values, "kind", "iqae_result")
 
 
-class LadderOperator(ClassicalType):
-    kind: Literal["ladder_operator"]
-
-    @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:
-        from classiq.qmod.builtins.enums import LadderOperator
-
-        return LadderOperator
-
-
-ConcreteClassicalType = Annotated[
-    Union[
-        Integer,
-        Real,
-        Bool,
-        ClassicalList,
-        Pauli,
-        StructMetaType,
-        TypeName,
-        ClassicalArray,
-        VQEResult,
-        Histogram,
-        Estimation,
-        LadderOperator,
-        IQAERes,
-    ],
-    Field(discriminator="kind"),
-]
-ClassicalList.update_forward_refs()
-ClassicalArray.update_forward_refs()
-
-PythonClassicalTypes = (int, float, bool, list, Enum)
-
-
 def as_symbolic(symbols: Dict[str, ClassicalType]) -> Dict[str, RuntimeExpression]:
     return {
         param_name: param_type.as_symbolic(param_name)

classiq/interface/generator/functions/concrete_types.py

@@ -0,0 +1,55 @@
+from typing import Union
+
+from pydantic import Field
+from typing_extensions import Annotated
+
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalList,
+    Estimation,
+    Histogram,
+    Integer,
+    IQAERes,
+    Real,
+    StructMetaType,
+    VQEResult,
+)
+from classiq.interface.generator.functions.type_name import Enum, TypeName
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    RegisterQuantumType,
+)
+
+ConcreteClassicalType = Annotated[
+    Union[
+        Integer,
+        Real,
+        Bool,
+        ClassicalList,
+        StructMetaType,
+        TypeName,
+        ClassicalArray,
+        VQEResult,
+        Histogram,
+        Estimation,
+        IQAERes,
+    ],
+    Field(discriminator="kind"),
+]
+ClassicalList.update_forward_refs(ConcreteClassicalType=ConcreteClassicalType)
+ClassicalArray.update_forward_refs(ConcreteClassicalType=ConcreteClassicalType)
+
+PythonClassicalTypes = (int, float, bool, list, Enum)
+
+ConcreteQuantumType = Annotated[
+    Union[QuantumBit, QuantumBitvector, QuantumNumeric, TypeName],
+    Field(discriminator="kind", default_factory=QuantumBitvector),
+]
+QuantumBitvector.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)
+TypeName.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)
+QStructDeclaration.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)
+RegisterQuantumType.update_forward_refs(ConcreteQuantumType=ConcreteQuantumType)

classiq/interface/generator/functions/function_declaration.py

@@ -1,23 +1,23 @@
 import abc
-from typing import Dict
+from typing import Sequence
 
 import pydantic
 
-from classiq.interface.ast_node import ASTNode
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
+from classiq.interface.model.parameter import Parameter
 
 
-class FunctionDeclaration(ASTNode, abc.ABC):
+class FunctionDeclaration(Parameter, abc.ABC):
     """
     Facilitates the creation of a common function interface object.
     """
 
-    name: str = pydantic.Field(description="The name of the function")
-
-    param_decls: Dict[str, ConcreteClassicalType] = pydantic.Field(
-        description="The expected interface of the functions parameters",
-        default_factory=dict,
-    )
+    @property
+    @abc.abstractmethod
+    def param_decls(self) -> Sequence[AnonClassicalParameterDeclaration]:
+        pass
 
     class Config:
         extra = pydantic.Extra.forbid

classiq/interface/generator/functions/type_name.py

@@ -0,0 +1,104 @@
+from typing import TYPE_CHECKING, Any, Dict, Literal, Mapping, Optional
+
+import pydantic
+
+from classiq.interface.generator.expressions.qmod_qstruct_proxy import QmodQStructProxy
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalType,
+)
+from classiq.interface.helpers.pydantic_model_helpers import values_with_discriminator
+from classiq.interface.model.handle_binding import FieldHandleBinding, HandleBinding
+from classiq.interface.model.quantum_type import (
+    QuantumType,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+
+    from classiq.qmod.qmod_variable import QStruct
+
+
+class TypeName(ClassicalType, QuantumType):  # type:ignore[misc]
+    kind: Literal["struct_instance"]
+    name: str = pydantic.Field(description="The type name of the instance")
+    _assigned_fields: Optional[Mapping[str, "ConcreteQuantumType"]] = (
+        pydantic.PrivateAttr(default=None)
+    )
+
+    @pydantic.root_validator(pre=True)
+    def _set_kind(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        return values_with_discriminator(values, "kind", "struct_instance")
+
+    @property
+    def qmod_type(self) -> type:
+        return type(self.name, (TypeName,), dict())
+
+    def _update_size_in_bits_from_declaration(self) -> None:
+        fields_types = list(self.fields.values())
+        for field_type in fields_types:
+            field_type._update_size_in_bits_from_declaration()
+        if all(field_type.has_size_in_bits for field_type in fields_types):
+            self._size_in_bits = sum(
+                field_type.size_in_bits for field_type in fields_types
+            )
+
+    def get_proxy(self, handle: "HandleBinding") -> "QmodQStructProxy":
+        from classiq.interface.generator.expressions.qmod_qstruct_proxy import (
+            QmodQStructProxy,
+        )
+
+        return QmodQStructProxy(
+            handle=handle, struct_name=self.name, fields=self.fields
+        )
+
+    @property
+    def qmod_type_name(self) -> str:
+        return self.name
+
+    @property
+    def type_name(self) -> str:
+        return self.name
+
+    def to_qvar(self, origin: HandleBinding) -> "QStruct":
+        from classiq.qmod.qmod_variable import QStruct
+
+        return QStruct(
+            origin,
+            self.name,
+            {
+                field_name: field_type.to_qvar(
+                    FieldHandleBinding(base_handle=origin, field=field_name)
+                )
+                for field_name, field_type in self.fields.items()
+            },
+        )
+
+    @property
+    def fields(self) -> Mapping[str, "ConcreteQuantumType"]:
+        from classiq.qmod.model_state_container import QMODULE
+
+        if self._assigned_fields is None:
+            qstruct_fields = QMODULE.qstruct_decls[self.name].fields
+            self._assigned_fields = {
+                field_name: field_type.copy()
+                for field_name, field_type in qstruct_fields.items()
+            }
+
+        return self._assigned_fields
+
+    def _set_fields(self, fields: Mapping[str, "ConcreteQuantumType"]) -> None:
+        from classiq.qmod.model_state_container import QMODULE
+
+        QMODULE.qstruct_decls[self.name].fields = fields
+
+
+class Enum(TypeName):
+    pass
+
+
+class Struct(TypeName):
+    @property
+    def qmod_type(self) -> type:
+        type_ = super().qmod_type
+        type_.__dataclass_fields__ = []  # type:ignore[attr-defined]
+        return type_

classiq/interface/generator/generated_circuit_data.py

@@ -21,7 +21,7 @@ VISUALIZATION_HIDE_LIST = [
     "control",
     "mcx",
     "iteration",
-    "operand",
+    "stmt_block",
 ]
 
 
@@ -94,9 +94,9 @@ class GeneratedCircuitData(pydantic.BaseModel):
         return cls(width=0)
 
 
-class FunctionDebugInfo(pydantic.BaseModel):
+class FunctionDebugInfoInterface(pydantic.BaseModel):
     generated_function: Optional[GeneratedFunction]
-    children: List["FunctionDebugInfo"]
+    children: List["FunctionDebugInfoInterface"]
     relative_qubits: Tuple[int, ...]
     absolute_qubits: Optional[Tuple[int, ...]]
     is_basis_gate: Optional[bool]

classiq/interface/generator/model/model.py

@@ -7,9 +7,11 @@ from classiq.interface.executor.execution_preferences import ExecutionPreference
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.function_params import ArithmeticIODict
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
+from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.validation_helpers import is_list_unique
 from classiq.interface.helpers.versioned_model import VersionedModel
+from classiq.interface.model.quantum_type import RegisterQuantumTypeDict
 
 from classiq.exceptions import ClassiqValueError
 
@@ -33,6 +35,11 @@ class ClassiqBaseModel(VersionedModel, ABC):
         description="user-defined structs",
     )
 
+    qstructs: List[QStructDeclaration] = pydantic.Field(
+        default_factory=list,
+        description="user-defined quantum structs",
+    )
+
     constants: List[Constant] = pydantic.Field(
         default_factory=list,
     )
@@ -58,3 +65,7 @@ class ExecutionModel(ClassiqBaseModel):
         description="Mapping between a measured register name and its arithmetic type",
         default_factory=dict,
     )
+    circuit_output_types: RegisterQuantumTypeDict = pydantic.Field(
+        description="Mapping between a measured register name and its qmod type",
+        default=dict(),
+    )

classiq/interface/generator/model/preferences/preferences.py

@@ -127,6 +127,11 @@ class Preferences(pydantic.BaseModel, extra=pydantic.Extra.forbid):
         "transpiled circuit and its depth",
     )
 
+    solovay_kitaev_max_iterations: Optional[pydantic.PositiveInt] = pydantic.Field(
+        None,
+        description="Maximum iterations for the Solovay-Kitaev algorithm (if applied).",
+    )
+
     timeout_seconds: pydantic.PositiveInt = pydantic.Field(
         default=300, description="Generation timeout in seconds"
     )

classiq/interface/generator/quantum_function_call.py

@@ -18,6 +18,7 @@ from typing import (
     Tuple,
     Union,
 )
+from uuid import UUID, uuid4
 
 import pydantic
 from pydantic import BaseModel, Extra
@@ -150,6 +151,8 @@ class SynthesisQuantumFunctionCall(BaseModel):
         "If not set, determined automatically.",
     )
 
+    uuid: UUID = pydantic.Field(default_factory=uuid4)
+
     def __eq__(self, other: Any) -> bool:
         return (
             isinstance(other, SynthesisQuantumFunctionCall) and self.name == other.name

classiq/interface/generator/quantum_program.py

@@ -17,7 +17,7 @@ from classiq.interface.generator.circuit_code.types_and_constants import (
     CodeAndSyntax,
 )
 from classiq.interface.generator.generated_circuit_data import (
-    FunctionDebugInfo,
+    FunctionDebugInfoInterface,
     GeneratedCircuitData,
 )
 from classiq.interface.generator.hardware.hardware_data import SynthesisHardwareData
@@ -59,7 +59,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
     transpiled_circuit: Optional[TranspiledCircuitData]
     creation_time: str = pydantic.Field(default_factory=datetime.utcnow().isoformat)
     synthesis_duration: Optional[SynthesisStepDurations]
-    debug_info: Optional[List[FunctionDebugInfo]]
+    debug_info: Optional[List[FunctionDebugInfoInterface]]
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
 
     def _hardware_agnostic_program_code(self) -> CodeAndSyntax:

classiq/interface/generator/register_role.py

@@ -10,6 +10,7 @@ class RegisterRole(StrEnum):
     ZERO_INPUT = "zero_input"
     ZERO_OUTPUT = "zero_output"
     GARBAGE_OUTPUT = "garbage_output"
+    EXPLICIT_ZERO_INPUT = "explicit_zero_input"
 
     @staticmethod
     def output_roles(include_garbage: bool = False) -> Set["RegisterRole"]:
@@ -24,4 +25,9 @@ class RegisterRole(StrEnum):
 
     @staticmethod
     def input_roles() -> Set["RegisterRole"]:
-        return {RegisterRole.INPUT, RegisterRole.ZERO_INPUT, RegisterRole.AUXILIARY}
+        return {
+            RegisterRole.INPUT,
+            RegisterRole.ZERO_INPUT,
+            RegisterRole.AUXILIARY,
+            RegisterRole.EXPLICIT_ZERO_INPUT,
+        }

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,11 +1,9 @@
-from typing import Dict, Final, Optional, Set
+from typing import Dict, 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_struct_declarations/pauli_struct_declarations.py

@@ -2,10 +2,9 @@ import functools
 
 from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
-    Enum,
     Real,
-    Struct,
 )
+from classiq.interface.generator.functions.type_name import Enum, Struct
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 

classiq/interface/generator/types/qstruct_declaration.py

@@ -0,0 +1,17 @@
+from typing import TYPE_CHECKING, Mapping
+
+import pydantic
+
+from classiq.interface.ast_node import HashableASTNode
+
+if TYPE_CHECKING:
+    from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+
+
+class QStructDeclaration(HashableASTNode):
+    name: str
+
+    fields: Mapping[str, "ConcreteQuantumType"] = pydantic.Field(
+        default_factory=dict,
+        description="Dictionary of field names and their quantum types",
+    )

classiq/interface/generator/types/struct_declaration.py

@@ -3,7 +3,7 @@ from typing import Any, ClassVar, Dict, Mapping
 import pydantic
 
 from classiq.interface.ast_node import HashableASTNode
-from classiq.interface.generator.functions.classical_type import ConcreteClassicalType
+from classiq.interface.generator.functions.concrete_types import ConcreteClassicalType
 
 from classiq.exceptions import ClassiqValueError
 

classiq/interface/helpers/validation_helpers.py

@@ -1,4 +1,4 @@
-from typing import Hashable, List, Mapping, Optional
+from typing import Hashable, List, Mapping
 
 from classiq.interface.helpers.pydantic_model_helpers import Nameable
 
@@ -16,19 +16,3 @@ def validate_nameables_mapping(
         raise ClassiqValueError(
             f"{declaration_type} declaration names should match the keys of their names."
         )
-
-
-def validate_nameables_no_overlap(
-    left_nameables_dict: Optional[Mapping[str, Nameable]],
-    right_nameables_dict: Optional[Mapping[str, Nameable]],
-    left_declaration_type: str,
-    right_declaration_type: str,
-) -> Optional[str]:
-    if left_nameables_dict is None or right_nameables_dict is None:
-        return None
-
-    matched_names = left_nameables_dict.keys() & right_nameables_dict.keys()
-    if matched_names:
-        return f"{left_declaration_type} declaration names overlap with {right_declaration_type} declaration names: {matched_names}"
-
-    return None

classiq/interface/ide/visual_model.py

@@ -9,8 +9,9 @@ from classiq._internals.enum_utils import StrEnum
 
 
 class OperationLevel(StrEnum):
-    USER_DEFINED = "USER_DEFINED"
-    ENGINE_GENERATED = "ENGINE_GENERATED"
+    QMOD_FUNCTION_CALL = "QMOD_CALL"
+    QMOD_STATEMENT = "QMOD_STATEMENT"
+    ENGINE_FUNCTION_CALL = "ENGINE_CALL"
     BASIS_GATE = "BASIS_GATE"
     UNKNOWN = "UNKNOWN"
 
@@ -41,6 +42,12 @@ class OperationLink(pydantic.BaseModel):
     qubits: Tuple[int, ...]
     type: str
 
+    class Config:
+        allow_mutation = False
+
+    def __hash__(self) -> int:
+        return hash((type(self), self.label, self.qubits, self.type))
+
 
 class OperationLinks(pydantic.BaseModel):
     inputs: List[OperationLink]

classiq/interface/interface_version.py

@@ -0,0 +1 @@
+INTERFACE_VERSION = "2"