classiq 0.37.0__py3-none-any.whl → 0.38.0__py3-none-any.whl

classiq/interface/generator/state_propagator.py

@@ -1,4 +1,4 @@
-from typing import List
+from typing import Any, Dict, List
 
 import numpy as np
 import pydantic
@@ -11,6 +11,8 @@ from classiq.interface.generator.function_params import (
     DEFAULT_OUTPUT_NAME,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class StatePropagator(function_params.FunctionParams):
     """
@@ -33,16 +35,25 @@ class StatePropagator(function_params.FunctionParams):
     )
 
     @pydantic.validator("start_state_vector", always=True)
-    def validate_start_state(cls, start_state_vector, values):
+    def validate_start_state(
+        cls, start_state_vector: List[Complex], values: Dict[str, Any]
+    ) -> List[Complex]:
         end_state_vector = values.get("end_state_vector")
+        if end_state_vector is None:
+            raise ClassiqValueError(
+                "Cannot validate start_start_vector without end_state_vector"
+            )
+
         num_qubits = cls._num_qubits(end_state_vector)
         if len(start_state_vector) == 0:
-            default_start_state_vector = [0.0 for _ in range(2**num_qubits)]
-            default_start_state_vector[0] = 1.0
+            default_start_state_vector = [Complex(0.0) for _ in range(2**num_qubits)]
+            default_start_state_vector[0] = Complex(1.0)
             start_state_vector = default_start_state_vector
 
         if len(start_state_vector) != len(end_state_vector):
-            raise ValueError("Start and end state vectors are of non-equal length")
+            raise ClassiqValueError(
+                "Start and end state vectors are of non-equal length"
+            )
 
         return start_state_vector
 

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

@@ -1,2 +1 @@
 from .pauli_struct_declarations import *  # noqa: F403
-from .qaoa_declarations import *  # noqa: F403

classiq/interface/generator/types/struct_declaration.py

@@ -15,11 +15,16 @@ class StructDeclaration(HashablePydanticBaseModel):
 
     variables: Dict[str, ConcreteClassicalType] = pydantic.Field(
         default_factory=dict,
-        description="Dictionary of variable names and their classical type",
+        description="Dictionary of variable names and their classical types",
     )
 
     BUILTIN_STRUCT_DECLARATIONS: ClassVar[Dict[str, "StructDeclaration"]] = {}
 
     def validate_fields(self, fields: Mapping[str, Any]) -> None:
-        if set(self.variables.keys()) != {field for field in fields.keys()}:
-            raise ClassiqValueError(f"Invalid fields for {self.name} instance")
+        expected_field_names = list(self.variables.keys())
+        received_field_names = list(fields.keys())
+        if set(expected_field_names) != set(received_field_names):
+            raise ClassiqValueError(
+                f"Invalid fields for {self.name} instance. Expected fields "
+                f"{expected_field_names}, got {received_field_names}"
+            )

classiq/interface/generator/ucc.py

@@ -10,6 +10,8 @@ from classiq.interface.generator.excitations import (
     EXCITATIONS_TYPE_EXACT,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 _EXCITATIONS_DICT = {"s": 1, "d": 2, "t": 3, "q": 4}
 
 DEFAULT_EXCITATIONS = [1, 2]
@@ -44,7 +46,7 @@ class UCC(ChemistryFunctionParams):
     def _validate_excitations(cls, excitations: EXCITATIONS_TYPE) -> EXCITATIONS_TYPE:
         if isinstance(excitations, int):
             if excitations not in _EXCITATIONS_DICT.values():
-                raise ValueError(
+                raise ClassiqValueError(
                     f"possible values of excitations are {list(_EXCITATIONS_DICT.values())}"
                 )
             excitations = [excitations]
@@ -53,19 +55,19 @@ class UCC(ChemistryFunctionParams):
             excitations = list(excitations)  # type: ignore[assignment]
             if all(isinstance(idx, int) for idx in excitations):
                 if any(idx not in _EXCITATIONS_DICT.values() for idx in excitations):
-                    raise ValueError(
+                    raise ClassiqValueError(
                         f"possible values of excitations are {list(_EXCITATIONS_DICT.values())}"
                     )
 
             elif all(isinstance(idx, str) for idx in excitations):
                 if any(idx not in _EXCITATIONS_DICT.keys() for idx in excitations):
-                    raise ValueError(
+                    raise ClassiqValueError(
                         f"possible values of excitations are {list(_EXCITATIONS_DICT.keys())}"
                     )
                 excitations = sorted(_EXCITATIONS_DICT[idx] for idx in excitations)  # type: ignore[index]
 
             else:
-                raise ValueError(
+                raise ClassiqValueError(
                     "excitations must be of the same type (all str or all int)"
                 )
         return excitations

classiq/interface/generator/unitary_gate.py

@@ -6,6 +6,8 @@ import pydantic
 from classiq.interface.generator import complex_type, function_params
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
+from classiq.exceptions import ClassiqValueError
+
 DataNumber = Union[complex_type.Complex, float, int]
 DataArray = List[List[DataNumber]]
 
@@ -28,11 +30,13 @@ class UnitaryGate(function_params.FunctionParams):
     def validate_data(cls, data: DataArray) -> DataArray:
         data_np = np.array(data, dtype=object)
         if data_np.ndim != 2:
-            raise ValueError("Data must me two dimensional")
+            raise ClassiqValueError("Data must me two dimensional")
         if data_np.shape[0] != data_np.shape[1]:
-            raise ValueError("Matrix must be square")
+            raise ClassiqValueError("Matrix must be square")
         if not np.mod(np.log2(data_np.shape[0]), 1) == 0:
-            raise ValueError("Matrix dimensions must be an integer exponent of 2")
+            raise ClassiqValueError(
+                "Matrix dimensions must be an integer exponent of 2"
+            )
         return data
 
     @property

classiq/interface/generator/validations/flow_graph.py

@@ -11,6 +11,8 @@ from classiq.interface.generator.quantum_function_call import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
+from classiq.exceptions import ClassiqValueError
+
 IO_MULTI_USE_ERROR_MSG = "Input and output names can only be used once"
 UNCONNECTED_WIRES_ERROR_MSG = "Wires connected only on one end"
 UNCONNECTED_FLOW_IO_ERROR_MSG = "Flow IOs not connected to inner calls"
@@ -40,7 +42,7 @@ def _parse_call_inputs(
         wire = wires[wire_name]
 
         if wire.end:
-            raise ValueError(
+            raise ClassiqValueError(
                 IO_MULTI_USE_ERROR_MSG
                 + f". The name {wire_name} is used multiple times."
             )
@@ -62,7 +64,7 @@ def _parse_call_outputs(
         wire = wires[wire_name]
 
         if wire.start:
-            raise ValueError(
+            raise ClassiqValueError(
                 IO_MULTI_USE_ERROR_MSG
                 + f". The name {wire_name} is used multiple times."
             )
@@ -148,7 +150,7 @@ def validate_legal_wiring(
     if unconnected_wires:
         error_messages.append(f"{UNCONNECTED_WIRES_ERROR_MSG}: {unconnected_wires}")
 
-    raise ValueError(_join_errors(error_messages))
+    raise ClassiqValueError(_join_errors(error_messages))
 
 
 def _join_errors(error_messages: List[str]) -> str:
@@ -180,7 +182,7 @@ def validate_acyclic_logic_flow(
 
     if not nx.algorithms.is_directed_acyclic_graph(graph):
         cycles = list(nx.algorithms.simple_cycles(graph))
-        raise ValueError(CYCLE_ERROR_MSG + ". Cycles are: " + str(cycles))
+        raise ClassiqValueError(CYCLE_ERROR_MSG + ". Cycles are: " + str(cycles))
 
     return graph
 

classiq/interface/generator/validations/validator_functions.py

@@ -4,6 +4,8 @@ import numpy as np
 
 from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityFloat
 
+from classiq.exceptions import ClassiqValueError
+
 NOT_SUM_TO_ONE_ERROR = "Probabilities do not sum to 1"
 
 SUM_TO_ONE_SENSITIVITY = 8
@@ -26,9 +28,9 @@ def is_probabilities_sum_to_one(pro: Iterable[PydanticProbabilityFloat]) -> bool
 
 def validate_amplitudes(amp: Amplitude) -> Amplitude:
     if not is_amplitudes_sum_to_one(amp):
-        raise ValueError("Amplitudes do not sum to 1")
+        raise ClassiqValueError("Amplitudes do not sum to 1")
     if not _is_power_of_two(amp):
-        raise ValueError("Amplitudes length must be power of 2")
+        raise ClassiqValueError("Amplitudes length must be power of 2")
     return amp
 
 
@@ -36,7 +38,7 @@ def validate_probabilities(
     cls: type, pmf: Sequence[PydanticProbabilityFloat]
 ) -> Sequence[PydanticProbabilityFloat]:
     if not is_probabilities_sum_to_one(pmf):
-        raise ValueError(NOT_SUM_TO_ONE_ERROR)
+        raise ClassiqValueError(NOT_SUM_TO_ONE_ERROR)
     if not _is_power_of_two(pmf):
-        raise ValueError("Probabilities length must be power of 2")
+        raise ClassiqValueError("Probabilities length must be power of 2")
     return pmf

classiq/interface/hardware.py

@@ -17,8 +17,8 @@ class Provider(StrEnum):
     OQC = "OQC"
 
     @property
-    def id(self):
-        return self.value.replace(" ", "-").lower()
+    def id(self) -> "ProviderIDEnum":
+        return self.value.replace(" ", "-").lower()  # type: ignore[return-value]
 
 
 ProviderIDEnum = StrEnum("ProviderIDEnum", {p.id: p.id for p in Provider})  # type: ignore[misc]

classiq/interface/helpers/custom_encoders.py

@@ -0,0 +1,3 @@
+from typing import Any, Callable, Dict
+
+CUSTOM_ENCODERS: Dict[type, Callable[[Any], Any]] = {complex: str}

classiq/interface/helpers/pydantic_model_helpers.py

@@ -1,11 +1,5 @@
 from typing import Any, Dict, Protocol, Sequence, TypeVar
 
-import pydantic
-
-
-def get_discriminator_field(default: str, **kwargs: Any) -> Any:
-    return pydantic.Field(default_factory=lambda: default, **kwargs)
-
 
 def values_with_discriminator(
     values: Dict[str, Any], discriminator: str, discriminator_value: Any

classiq/interface/helpers/validation_helpers.py

@@ -12,7 +12,7 @@ def is_list_unique(lst: List[Hashable]) -> bool:
 def validate_nameables_mapping(
     nameables_dict: Mapping[str, Nameable], declaration_type: str
 ) -> None:
-    if not all([name == nameable.name for (name, nameable) in nameables_dict.items()]):
+    if not all(name == nameable.name for (name, nameable) in nameables_dict.items()):
         raise ClassiqValueError(
             f"{declaration_type} declaration names should match the keys of their names."
         )

classiq/interface/helpers/versioned_model.py

@@ -1,7 +1,10 @@
 import pydantic
 
 from classiq.interface._version import VERSION
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 
 
-class VersionedModel(pydantic.BaseModel, extra=pydantic.Extra.forbid):
+class VersionedModel(
+    pydantic.BaseModel, extra=pydantic.Extra.forbid, json_encoders=CUSTOM_ENCODERS
+):
     version: str = pydantic.Field(default=VERSION)

classiq/interface/ide/show.py

@@ -4,7 +4,7 @@ import pydantic
 
 from classiq.interface.analyzer.result import QasmCode
 
-from classiq import GeneratedCircuit
+from classiq import QuantumProgram
 from classiq._internals.api_wrapper import ApiWrapper
 from classiq._internals.async_utils import syncify_function
 from classiq.exceptions import ClassiqValueError
@@ -28,7 +28,7 @@ CANT_PARSE_QUANTUM_PROGRAM_MSG = (
 
 def show(quantum_program: SerializedQuantumProgram) -> None:
     try:
-        circuit = GeneratedCircuit.parse_raw(quantum_program)
+        circuit = QuantumProgram.parse_raw(quantum_program)
     except pydantic.error_wrappers.ValidationError as exc:
         raise ClassiqValueError(CANT_PARSE_QUANTUM_PROGRAM_MSG) from exc
     circuit.show()  # type: ignore[attr-defined]

classiq/interface/jobs.py

@@ -1,9 +1,11 @@
-from typing import Any, Dict, Generic, TypeVar, Union
+from typing import Any, Dict, Generic, Literal, TypeVar, Union
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
 from pydantic.generics import GenericModel
 
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
+
 from classiq._internals.enum_utils import StrEnum
 
 JSONObject = Dict[str, Any]
@@ -29,6 +31,73 @@ class JobStatus(StrEnum):
         return self in (self.COMPLETED, self.FAILED, self.CANCELLED)
 
 
-class JobDescription(GenericModel, Generic[T]):
+"""
+A job can be in either of 3 states: ongoing, completed successfully or completed
+unsuccessfully. Each job status belongs to one of the 3 states
+The class JobDescriptionBase represents a job description, regardless of its state
+JobDescriptionSuccess represents a job that was completed successfully. It contains the
+job result in the description field. The type of the result depends on the route, and
+so it's defined as a generic class
+JobDescriptionFailure represents a job that was completed unsuccessfully. It contains
+the failure details (i.e., error message) in the description field
+JobDescriptionNonFinal represents a job that has not terminated yet. It does not contain
+any additional information
+JobDescriptionUnion is used to define a discriminator field between the 3 states. Since
+JobDescriptionSuccess is generic, so is the union. This means it cannot be defined
+as an annotated type alias (that is, we cannot define
+JobDescriptionUnion = Annotated[Union[...], Field(discriminator="kind")])
+"""
+
+SuccessStatus = Literal[JobStatus.COMPLETED]
+FailureStatus = Union[
+    Literal[JobStatus.FAILED],
+    Literal[JobStatus.CANCELLED],
+]
+NonFinalStatus = Union[
+    Literal[JobStatus.QUEUED],
+    Literal[JobStatus.RUNNING],
+    Literal[JobStatus.READY],
+    Literal[JobStatus.CANCELLING],
+    Literal[JobStatus.UNKNOWN],
+]
+
+
+class FailureDetails(BaseModel):
+    details: str
+
+
+class JobDescriptionBase(GenericModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
+    kind: str
     status: JobStatus
+    description: Union[T, FailureDetails, Dict]
+
+
+class JobDescriptionSuccess(JobDescriptionBase[T], Generic[T]):
+    kind: Literal["success"] = pydantic.Field(default="success")
+    status: SuccessStatus = Field(default=JobStatus.COMPLETED)
     description: T
+
+
+class JobDescriptionFailure(JobDescriptionBase[Any]):
+    kind: Literal["failure"] = pydantic.Field(default="failure")
+    status: FailureStatus
+    description: FailureDetails
+
+
+class JobDescriptionNonFinal(JobDescriptionBase[Any]):
+    kind: Literal["non_final"] = pydantic.Field(default="non_final")
+    status: NonFinalStatus
+    description: Dict = Field(default_factory=dict)
+
+    @pydantic.validator("description")
+    def validate_empty_description(cls, description: Dict) -> Dict:
+        if description:
+            raise ValueError("Non-final job description must be empty")
+
+        return description
+
+
+class JobDescriptionUnion(GenericModel, Generic[T], json_encoders=CUSTOM_ENCODERS):
+    __root__: Union[
+        JobDescriptionSuccess[T], JobDescriptionFailure, JobDescriptionNonFinal
+    ] = Field(discriminator="kind")

classiq/interface/model/bind_operation.py

@@ -1,4 +1,4 @@
-from typing import Mapping
+from typing import List, Mapping
 
 import pydantic
 
@@ -12,19 +12,26 @@ BIND_OUTPUT_NAME = "bind_output"
 
 
 class BindOperation(QuantumOperation):
-    in_handle: HandleBinding
-    out_handle: HandleBinding
+    in_handles: List[HandleBinding]
+    out_handles: List[HandleBinding]
 
     @property
     def wiring_inputs(self) -> Mapping[str, HandleBinding]:
-        return {BIND_INPUT_NAME: self.in_handle}
+        return {
+            f"{BIND_INPUT_NAME}_{i}": handle for i, handle in enumerate(self.in_handles)
+        }
 
     @property
     def wiring_outputs(self) -> Mapping[str, HandleBinding]:
-        return {BIND_OUTPUT_NAME: self.out_handle}
-
-    @pydantic.validator("in_handle", "out_handle")
-    def validate_handle(cls, handle: HandleBinding) -> HandleBinding:
-        if not handle.is_bindable():
-            raise ClassiqValueError(f"Cannot bind '{handle}'")  # noqa: B907
-        return handle
+        return {
+            f"{BIND_OUTPUT_NAME}_{i}": handle
+            for i, handle in enumerate(self.out_handles)
+        }
+
+    @pydantic.validator("in_handles", "out_handles")
+    def validate_handle(cls, handles: List[HandleBinding]) -> List[HandleBinding]:
+        for handle in handles:
+            if not handle.is_bindable():
+                raise ClassiqValueError(f"Cannot bind '{handle}'")
+
+        return handles

classiq/interface/model/call_synthesis_data.py

@@ -0,0 +1,68 @@
+import dataclasses
+from typing import Any, List, Mapping
+
+from sympy import sympify
+
+from classiq.interface.generator.control_state import ControlState
+from classiq.interface.generator.synthesis_execution_parameter import PydanticPowerType
+
+from classiq.exceptions import ClassiqValueError
+
+ILLEGAL_NESTED_POWER_ERROR = "Nested power calls with a parametric power and an integer power are unsupported: {a}, {b}"
+
+
+def _merge_power(a: PydanticPowerType, b: PydanticPowerType) -> PydanticPowerType:
+    symbolic_res = sympify(a) * sympify(b)
+    if symbolic_res.is_Integer:
+        return int(symbolic_res)
+    elif symbolic_res.is_symbol:
+        return str(symbolic_res)
+    else:
+        raise ClassiqValueError(ILLEGAL_NESTED_POWER_ERROR.format(a=a, b=b))
+
+
+@dataclasses.dataclass
+class CallSynthesisData(Mapping):
+    power: PydanticPowerType = 1
+    is_inverse: bool = False
+    control_states: List[ControlState] = dataclasses.field(default_factory=list)
+    should_control: bool = True
+
+    def merge(self, other: "CallSynthesisData") -> "CallSynthesisData":
+        return CallSynthesisData(
+            power=_merge_power(self.power, other.power),
+            is_inverse=self.is_inverse != other.is_inverse,
+            control_states=self.control_states + other.control_states,
+            should_control=self.should_control and other.should_control,
+        )
+
+    def set_control(self, ctrl_name: str, ctrl_size: int) -> None:
+        self.control_states = [
+            ControlState(
+                name=ctrl_name,
+                num_ctrl_qubits=ctrl_size,
+            )
+        ]
+
+    def update_control_state(self, ctrl_size: int, ctrl_state: str) -> None:
+        prev_ctrl_state = self.control_states.pop()
+        self.control_states.append(
+            ControlState(
+                name=prev_ctrl_state.name,
+                num_ctrl_qubits=ctrl_size,
+                ctrl_state=ctrl_state,
+            )
+        )
+
+    @property
+    def has_control(self) -> bool:
+        return bool(self.control_states)
+
+    def __getitem__(self, key: str) -> Any:
+        return dataclasses.asdict(self)[key]
+
+    def __iter__(self):
+        return iter(dataclasses.asdict(self))
+
+    def __len__(self):
+        return len(dataclasses.asdict(self))

classiq/interface/model/inplace_binary_operation.py

@@ -11,8 +11,8 @@ from classiq.exceptions import ClassiqValueError
 
 
 class BinaryOperation(StrEnum):
-    Addition = "addition"
-    Xor = "xor"
+    Addition = "inplace_add"
+    Xor = "inplace_xor"
 
     @property
     def internal_function(self) -> str:

classiq/interface/model/model.py

@@ -1,4 +1,5 @@
-from typing import Any, Dict, List, Literal, NewType, Optional, Set, Union
+from collections import Counter
+from typing import Any, Dict, List, Literal, NewType, Optional, Set
 
 import pydantic
 
@@ -10,23 +11,17 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
 from classiq.interface.generator.quantum_function_call import SUFFIX_RANDOMIZER
-from classiq.interface.generator.types.combinatorial_problem import (
-    CombinatorialOptimizationStructDeclaration,
-)
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.helpers.pydantic_model_helpers import (
-    get_discriminator_field,
-    nameables_to_dict,
-)
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_call import ConcreteQuantumStatement
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
 from classiq.interface.model.resolvers.function_call_resolver import (
     resolve_function_calls,
 )
+from classiq.interface.model.statement_block import StatementBlock
 
 from classiq.exceptions import ClassiqValueError
 
@@ -39,10 +34,6 @@ DEFAULT_PORT_SIZE = 1
 
 SerializedModel = NewType("SerializedModel", str)
 
-ConcreteStructDeclaration = Union[
-    CombinatorialOptimizationStructDeclaration, StructDeclaration
-]
-
 TYPE_NAME_CONFLICT_BUILTIN = (
     "Type '{name}' conflicts with a builtin type with the same name"
 )
@@ -65,7 +56,7 @@ class Model(VersionedModel):
     All the relevant data for generating quantum circuit in one place.
     """
 
-    kind: Literal["user"] = get_discriminator_field(USER_MODEL_MARKER)
+    kind: Literal["user"] = pydantic.Field(default=USER_MODEL_MARKER)
 
     # Must be validated before logic_flow
     functions: List[NativeFunctionDefinition] = pydantic.Field(
@@ -73,7 +64,7 @@ class Model(VersionedModel):
         description="The user-defined custom type library.",
     )
 
-    types: List[ConcreteStructDeclaration] = pydantic.Field(
+    types: List[StructDeclaration] = pydantic.Field(
         default_factory=list,
         description="The user-defined custom function library.",
     )
@@ -98,7 +89,7 @@ class Model(VersionedModel):
         return self.function_dict[MAIN_FUNCTION_NAME]  # type:ignore[return-value]
 
     @property
-    def body(self) -> List[ConcreteQuantumStatement]:
+    def body(self) -> StatementBlock:
         return self.main_func.body
 
     @pydantic.validator("preferences", always=True)
@@ -142,15 +133,15 @@ class Model(VersionedModel):
         return values
 
     @pydantic.validator("types")
-    def types_validator(
-        cls, types: List[ConcreteStructDeclaration]
-    ) -> List[ConcreteStructDeclaration]:
+    def types_validator(cls, types: List[StructDeclaration]) -> List[StructDeclaration]:
         user_defined_types: Set[str] = set()
         for ctype in types:
             if ctype.name in StructDeclaration.BUILTIN_STRUCT_DECLARATIONS:
-                raise ValueError(TYPE_NAME_CONFLICT_BUILTIN.format(name=ctype.name))
+                raise ClassiqValueError(
+                    TYPE_NAME_CONFLICT_BUILTIN.format(name=ctype.name)
+                )
             if ctype.name in user_defined_types:
-                raise ValueError(TYPE_NAME_CONFLICT_USER.format(name=ctype.name))
+                raise ClassiqValueError(TYPE_NAME_CONFLICT_USER.format(name=ctype.name))
             user_defined_types.add(ctype.name)
 
         return types
@@ -174,3 +165,18 @@ class Model(VersionedModel):
             raise ClassiqValueError("Function 'main' cannot declare quantum inputs")
 
         return functions
+
+    @pydantic.validator("constants")
+    def _validate_constants(cls, constants: List[Constant]) -> List[Constant]:
+        constant_definition_counts = Counter(
+            [constant.name for constant in constants]
+        ).items()
+        multiply_defined_constants = {
+            constant for constant, count in constant_definition_counts if count > 1
+        }
+        if len(multiply_defined_constants) > 0:
+            raise ClassiqValueError(
+                f"The following constants were defined more than once: "
+                f"{multiply_defined_constants}"
+            )
+        return constants

classiq/interface/model/native_function_definition.py

@@ -1,11 +1,9 @@
-from typing import List
-
 import pydantic
 
-from classiq.interface.model.quantum_function_call import ConcreteQuantumStatement
 from classiq.interface.model.quantum_function_declaration import (
     QuantumFunctionDeclaration,
 )
+from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.validations.handles_validator import HandleValidator
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -22,7 +20,7 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
     objects from other classes.
     """
 
-    body: List[ConcreteQuantumStatement] = pydantic.Field(
+    body: StatementBlock = pydantic.Field(
         default_factory=list, description="List of function calls to perform."
     )
 
@@ -33,6 +31,6 @@ class NativeFunctionDefinition(QuantumFunctionDeclaration):
             if isinstance(statement, VariableDeclarationStatement):
                 handle_validator.handle_variable_declaration(statement)
             else:
-                handle_validator.handle_call(statement)
+                handle_validator.handle_operation(statement)
 
         handle_validator.report_errored_handles(ClassiqValueError)

classiq/interface/model/quantum_expressions/amplitude_loading_operation.py

@@ -36,9 +36,14 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
     ) -> Mapping[
         str, Union[SlicedHandleBinding, SubscriptHandleBinding, HandleBinding]
     ]:
-        if len(self.var_handles) == 0:
-            return dict()
-        return {AMPLITUDE_IO_NAME: self.var_handles[0]}
+        inouts = {self.result_name(): self.result_var}
+        if len(self.var_handles) == 1:
+            inouts[AMPLITUDE_IO_NAME] = self.var_handles[0]
+        return inouts
+
+    @property
+    def wiring_outputs(self) -> Mapping[str, HandleBinding]:
+        return {}
 
     def initialize_var_types(
         self,
@@ -50,7 +55,7 @@ class AmplitudeLoadingOperation(QuantumAssignmentOperation):
         var_type = var_types[self.var_handles[0].name]
         if not (
             isinstance(var_type, QuantumNumeric)
-            and var_type.fraction_digits == var_type.size_in_bits
+            and var_type.fraction_digits_value == var_type.size_in_bits
         ):
             raise ClassiqValueError(VAR_DOMAIN_ILLEGAL)
         super().initialize_var_types(var_types, machine_precision)