classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/execution/execution_session.py

@@ -1,10 +1,15 @@
 import inspect
 import random
+import warnings
 from types import TracebackType
-from typing import Callable, Optional, Union, cast
+from typing import Any, Callable, Optional, Union, cast
 
 from classiq.interface.chemistry.operator import PauliOperator, pauli_integers_to_str
-from classiq.interface.exceptions import ClassiqError, ClassiqValueError
+from classiq.interface.exceptions import (
+    ClassiqDeprecationWarning,
+    ClassiqError,
+    ClassiqValueError,
+)
 from classiq.interface.execution.primitives import (
     EstimateInput,
     MinimizeClassicalCostInput,
@@ -71,6 +76,20 @@ def parse_params(params: ExecutionParams) -> ParsedExecutionParams:
     return result
 
 
+def _hamiltonian_deprecation_warning(hamiltonian: Any) -> None:
+    if isinstance(hamiltonian, list):
+        warnings.warn(
+            (
+                "Parameter type list[PauliTerm] to 'ExecutionSession' methods is "
+                "deprecated and will no longer be supported starting on 21/7/2025 "
+                "at the earliest. Instead, send a 'SparsePauliOp' (see "
+                "https://docs.classiq.io/latest/qmod-reference/language-reference/classical-types/#hamiltonians)."
+            ),
+            ClassiqDeprecationWarning,
+            stacklevel=3,
+        )
+
+
 class ExecutionSession:
     """
     A session for executing a quantum program.
@@ -228,11 +247,18 @@ class ExecutionSession:
         Returns:
             EstimationResult: The result of the estimation.
         """
-        job = self.submit_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        _hamiltonian_deprecation_warning(hamiltonian)
+        job = self.submit_estimate(
+            hamiltonian=hamiltonian, parameters=parameters, _check_deprecation=False
+        )
         return job.get_estimate_result(_http_client=self._async_client)
 
     def submit_estimate(
-        self, hamiltonian: Hamiltonian, parameters: Optional[ExecutionParams] = None
+        self,
+        hamiltonian: Hamiltonian,
+        parameters: Optional[ExecutionParams] = None,
+        *,
+        _check_deprecation: bool = True,
     ) -> ExecutionJob:
         """
         Initiates an execution job with the `estimate` primitive.
@@ -247,6 +273,8 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
+        if _check_deprecation:
+            _hamiltonian_deprecation_warning(hamiltonian)
         execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=self._hamiltonian_to_pauli_operator(hamiltonian),
@@ -270,11 +298,18 @@ class ExecutionSession:
         Returns:
             List[EstimationResult]: The results of all the estimation iterations.
         """
-        job = self.submit_batch_estimate(hamiltonian=hamiltonian, parameters=parameters)
+        _hamiltonian_deprecation_warning(hamiltonian)
+        job = self.submit_batch_estimate(
+            hamiltonian=hamiltonian, parameters=parameters, _check_deprecation=False
+        )
         return job.get_batch_estimate_result(_http_client=self._async_client)
 
     def submit_batch_estimate(
-        self, hamiltonian: Hamiltonian, parameters: list[ExecutionParams]
+        self,
+        hamiltonian: Hamiltonian,
+        parameters: list[ExecutionParams],
+        *,
+        _check_deprecation: bool = True,
     ) -> ExecutionJob:
         """
         Initiates an execution job with the `batch_estimate` primitive.
@@ -289,6 +324,8 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
+        if _check_deprecation:
+            _hamiltonian_deprecation_warning(hamiltonian)
         execution_primitives_input = PrimitivesInput(
             estimate=EstimateInput(
                 hamiltonian=self._hamiltonian_to_pauli_operator(hamiltonian),
@@ -322,11 +359,13 @@ class ExecutionSession:
             A list of tuples, each containing the estimated cost and the corresponding parameters for that iteration.
             `cost` is a float, and `parameters` is a dictionary matching the execution parameter format.
         """
+        _hamiltonian_deprecation_warning(cost_function)
         job = self.submit_minimize(
             cost_function=cost_function,
             initial_params=initial_params,
             max_iteration=max_iteration,
             quantile=quantile,
+            _check_deprecation=False,
         )
         result = job.get_minimization_result(_http_client=self._async_client)
 
@@ -340,6 +379,8 @@ class ExecutionSession:
         initial_params: ExecutionParams,
         max_iteration: int,
         quantile: float = 1.0,
+        *,
+        _check_deprecation: bool = True,
     ) -> ExecutionJob:
         """
         Initiates an execution job with the `minimize` primitive.
@@ -363,6 +404,8 @@ class ExecutionSession:
         Returns:
             The execution job.
         """
+        if _check_deprecation:
+            _hamiltonian_deprecation_warning(cost_function)
         if len(initial_params) != 1:
             raise ClassiqValueError(
                 "The initial parameters must be a dictionary with a single key-value pair."
@@ -461,6 +504,10 @@ class ExecutionSession:
                 raise NotImplementedError(
                     "Filtering is only supported on a single value per model output"
                 )
+            if len(legal_bitstrings) == 0:
+                raise ClassiqValueError(
+                    f"The condition was false for every possible value of {output_name}"
+                )
         else:
             raise NotImplementedError(
                 "Filtering is only supported on QuantumBit and QuantumNumeric"

classiq/interface/_version.py

@@ -3,5 +3,5 @@ from packaging.version import Version
 # This file was generated automatically
 # Please don't track in version control (DONTTRACK)
 
-SEMVER_VERSION = '0.84.0'
+SEMVER_VERSION = '0.86.0'
 VERSION = str(Version(SEMVER_VERSION))

classiq/interface/analyzer/analysis_params.py

@@ -14,7 +14,7 @@ from classiq.interface.generator.model.preferences.preferences import (
 from classiq.interface.hardware import Provider
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
 
-MAX_KB_OF_FILE = 500
+MAX_KB_OF_FILE = 50000
 MAX_FILE_LENGTH = MAX_KB_OF_FILE * 1024
 
 MAX_QUBITS = 100

classiq/interface/analyzer/result.py

@@ -37,7 +37,7 @@ class DataID(pydantic.BaseModel):
 
 
 class QasmCode(pydantic.BaseModel):
-    code: str = Field(..., max_length=MAX_FILE_LENGTH * 100)
+    code: str = Field(..., max_length=MAX_FILE_LENGTH)
 
 
 class AnalysisStatus(StrEnum):

classiq/interface/debug_info/debug_info.py

@@ -9,7 +9,6 @@ from classiq.interface.generator.generated_circuit_data import (
     FunctionDebugInfoInterface,
     StatementType,
 )
-from classiq.interface.model.block import Block
 from classiq.interface.model.handle_binding import ConcreteHandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_call import ArgValue
@@ -82,9 +81,6 @@ def get_back_refs(
 ) -> list[ConcreteQuantumStatement]:
     back_refs: list[ConcreteQuantumStatement] = []
     while (node := debug_info.node) is not None:
-        #  For backwards compatibility, we make sure that the back_ref is not a block
-        #  Remove this check when we start saving blocks in the debug info collection.
-        assert not isinstance(node, Block)
         if len(back_refs) > 0 and node.back_ref == back_refs[0].back_ref:
             break
         back_refs.insert(0, node)

classiq/interface/executor/quantum_code.py

@@ -95,8 +95,8 @@ class QuantumCode(QuantumBaseCode):
     ) -> Optional[ExecutionData]:
         if (
             synthesis_execution_data is not None
-            and values.data.get("syntax") is not QuantumInstructionSet.QASM
-        ):
+            and synthesis_execution_data.function_execution
+        ) and values.data.get("syntax") is not QuantumInstructionSet.QASM:
             raise ClassiqValueError("Only QASM supports the requested configuration")
 
         return synthesis_execution_data

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -63,6 +63,10 @@ def is_constant(expr: Union[str, Expr]) -> bool:
         return False
 
 
+def is_variable(expr: str) -> bool:
+    return IDENITIFIER_REGEX.fullmatch(expr) is not None
+
+
 class ExpressionValidator(ast.NodeVisitor):
     def __init__(
         self,
@@ -95,7 +99,7 @@ class ExpressionValidator(ast.NodeVisitor):
     @staticmethod
     def _get_adjusted_expression(expression: str) -> str:
         # This works around the simplification of the trivial expressions such as a + 0, 1 * a, etc.
-        if IDENITIFIER_REGEX.fullmatch(expression) or is_constant(expression):
+        if is_variable(expression) or is_constant(expression):
             return f"0 + {expression}"
         return expression
 

classiq/interface/generator/arith/binary_ops.py

@@ -20,7 +20,6 @@ from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import argument_utils, number_utils
 from classiq.interface.generator.arith.argument_utils import (
     RegisterOrConst,
-    as_arithmetic_info,
 )
 from classiq.interface.generator.arith.arithmetic_operations import (
     MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
@@ -33,6 +32,13 @@ from classiq.interface.generator.arith.register_user_input import RegisterArithm
 from classiq.interface.generator.arith.unary_ops import Negation
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_add,
+    compute_result_attrs_assign,
+    compute_result_attrs_subtract,
+)
+
 LeftDataT = TypeVar("LeftDataT")
 RightDataT = TypeVar("RightDataT")
 _NumericArgumentInplaceErrorMessage: str = "Cannot inplace the numeric argument {}"
@@ -268,40 +274,35 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "sum"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        left_arg = argument_utils.limit_fraction_places(
+        left_attrs = NumericAttributes.from_type_or_constant(
             self.left_arg, self.machine_precision
         )
-        right_arg = argument_utils.limit_fraction_places(
+        right_attrs = NumericAttributes.from_type_or_constant(
             self.right_arg, self.machine_precision
         )
-        lb = argument_utils.lower_bound(left_arg) + argument_utils.lower_bound(
-            right_arg
-        )
-        ub = argument_utils.upper_bound(left_arg) + argument_utils.upper_bound(
-            right_arg
-        )
-        fraction_places = max(
-            argument_utils.fraction_places(left_arg),
-            argument_utils.fraction_places(right_arg),
-        )
+
+        if self._is_zero(self.left_arg) or self._is_zero(self.right_arg):
+            other_arg_attrs = (
+                right_attrs if self._is_zero(self.left_arg) else left_attrs
+            )
+            result_attrs = compute_result_attrs_assign(
+                other_arg_attrs, self.machine_precision
+            )
+        else:
+            result_attrs = compute_result_attrs_add(
+                left_attrs, right_attrs, self.machine_precision
+            )
+
         return RegisterArithmeticInfo(
-            size=self.output_size or self._get_output_size(ub, lb, fraction_places),
-            fraction_places=fraction_places,
-            is_signed=self._include_sign and lb < 0,
-            bounds=(lb, ub) if self._include_sign else None,
+            size=self.output_size or result_attrs.size,
+            fraction_places=result_attrs.fraction_digits,
+            is_signed=self._include_sign and result_attrs.is_signed,
+            bounds=result_attrs.bounds if self._include_sign else None,
         )
 
-    def _get_output_size(self, ub: float, lb: float, fraction_places: int) -> int:
-        if isinstance(self.left_arg, float) and self.left_arg == 0.0:
-            if isinstance(self.right_arg, RegisterArithmeticInfo):
-                return self.right_arg.size
-            return as_arithmetic_info(self.right_arg).size
-        elif isinstance(self.right_arg, float) and self.right_arg == 0.0:
-            assert isinstance(self.left_arg, RegisterArithmeticInfo)
-            return self.left_arg.size
-
-        integer_part_size = number_utils.bounds_to_integer_part_size(lb, ub)
-        return integer_part_size + fraction_places
+    @staticmethod
+    def _is_zero(arg: RegisterOrConst) -> bool:
+        return isinstance(arg, float) and arg == 0
 
 
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
@@ -337,41 +338,32 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return self._is_arg_trimmed_register(self.right_arg, self.machine_precision)
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        bounds = (
-            argument_utils.lower_bound(self.effective_left_arg)
-            - argument_utils.upper_bound(self.effective_right_arg),
-            argument_utils.upper_bound(self.effective_left_arg)
-            - argument_utils.lower_bound(self.effective_right_arg),
+        left_attrs = NumericAttributes.from_type_or_constant(
+            self.left_arg, self.machine_precision
         )
-        fraction_places = max(
-            argument_utils.fraction_places(self.effective_left_arg),
-            argument_utils.fraction_places(self.effective_right_arg),
+        right_attrs = NumericAttributes.from_type_or_constant(
+            self.right_arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_subtract(
+            left_attrs, right_attrs, self.machine_precision
         )
 
-        size = self.output_size or self._get_output_size(bounds, fraction_places)
-        is_signed = self._include_sign and min(bounds) < 0
+        size = self.output_size or result_attrs.size
+        is_signed = self._include_sign and result_attrs.is_signed
         return RegisterArithmeticInfo(
             size=size,
-            fraction_places=fraction_places,
+            fraction_places=result_attrs.fraction_digits,
             is_signed=is_signed,
             bounds=self._legal_bounds(
-                bounds,
+                result_attrs.bounds,
                 RegisterArithmeticInfo.get_maximal_bounds(
-                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                    size=size,
+                    is_signed=is_signed,
+                    fraction_places=result_attrs.fraction_digits,
                 ),
             ),
         )
 
-    def _get_output_size(
-        self, bounds: tuple[float, float], fraction_places: int
-    ) -> int:
-        if isinstance(self.right_arg, float) and self.effective_right_arg == 0:
-            assert isinstance(self.effective_left_arg, RegisterArithmeticInfo)
-            return self.effective_left_arg.size
-        integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
-        size_needed = integer_part_size + fraction_places
-        return size_needed
-
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if (
             not self.left_arg_is_trimmed_register

classiq/interface/generator/arith/number_utils.py

@@ -79,10 +79,11 @@ def size(float_value: float) -> int:
 
 
 def _is_extra_sign_bit_needed(*, lb: float, ub: float) -> bool:
-    integer_lb = lb * 2 ** fraction_places(lb)
+    fractions = max(fraction_places(lb), fraction_places(ub))
+    integer_lb = lb * 2**fractions
     max_represented_number = (
         2 ** (len(binary_string(integer_lb)) - 1) - 1
-    ) / 2 ** fraction_places(lb)
+    ) / 2**fractions
     return ub > max_represented_number
 
 

classiq/interface/generator/arith/register_user_input.py

@@ -11,6 +11,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
+MAX_REGISTER_SIZE = 10000
+
 
 class RegisterArithmeticInfo(HashablePydanticBaseModel):
     size: pydantic.PositiveInt = pydantic.Field(default=1)
@@ -56,6 +58,19 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
         fraction_places = info.data.get("fraction_places", 0)
         if not isinstance(size, int):
             raise ClassiqValueError("RegisterArithmeticInfo must have an integer size")
+        if not isinstance(fraction_places, int):
+            raise ClassiqValueError(
+                "RegisterArithmeticInfo must have an integer fraction_places"
+            )
+
+        if size > MAX_REGISTER_SIZE:
+            raise ValueError(
+                f"Register size {size} exceeds maximum size {MAX_REGISTER_SIZE}."
+            )
+        if fraction_places > size:
+            raise ValueError(
+                f"Number of fraction places {fraction_places} exceeds register size {size}."
+            )
 
         maximal_bounds = cls.get_maximal_bounds(
             size=size, is_signed=is_signed, fraction_places=fraction_places

classiq/interface/generator/arith/unary_ops.py

@@ -1,11 +1,11 @@
 from collections.abc import Iterable
-from typing import TYPE_CHECKING, Final, Optional
+from typing import Final, Optional
 
 import pydantic
 from pydantic import ConfigDict
 
 from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.arith import argument_utils, number_utils
+from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.arithmetic_operations import (
     MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
@@ -13,6 +13,12 @@ from classiq.interface.generator.arith.arithmetic_operations import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_bitwise_invert,
+    compute_result_attrs_negate,
+)
+
 UNARY_ARG_NAME: Final[str] = "arg"
 
 
@@ -65,13 +71,17 @@ class BitwiseInvert(UnaryOpParams):
     output_name = "inverted"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        eff_arg = argument_utils.limit_fraction_places(self.arg, self.machine_precision)
-        if TYPE_CHECKING:
-            assert isinstance(eff_arg, RegisterArithmeticInfo)
+        arg_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_bitwise_invert(
+            arg_attrs, self.machine_precision
+        )
+
         return RegisterArithmeticInfo(
-            size=self.output_size or eff_arg.size,
-            fraction_places=eff_arg.fraction_places,
-            is_signed=eff_arg.is_signed and self._include_sign,
+            size=self.output_size or result_attrs.size,
+            fraction_places=result_attrs.fraction_digits,
+            is_signed=result_attrs.is_signed and self._include_sign,
         )
 
 
@@ -81,40 +91,34 @@ class Negation(UnaryOpParams):
     )  # True for efficient subtraction
     output_name = "negated"
 
-    @staticmethod
-    def _expected_result_size(arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
-        if arg.size == 1:
-            return 1
-        return arg.fraction_places + number_utils.bounds_to_integer_part_size(
-            *(-bound for bound in arg.bounds)
-        )
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
-        is_signed = max(eff_arg.bounds) > 0 and self._include_sign
-        bounds = (-max(eff_arg.bounds), -min(eff_arg.bounds))
+        arg_attrs = NumericAttributes.from_register_arithmetic_info(
+            self.arg, self.machine_precision
+        )
+        result_attrs = compute_result_attrs_negate(arg_attrs, self.machine_precision)
+        is_signed = result_attrs.is_signed and self._include_sign
+        bounds = result_attrs.bounds
         if self.output_size and not self.bypass_bounds_validation:
-            if eff_arg.fraction_places:
+            if result_attrs.fraction_digits:
                 raise ValueError(MODULO_WITH_FRACTION_PLACES_ERROR_MSG)
             max_bounds = RegisterArithmeticInfo.get_maximal_bounds(
                 size=self.output_size, is_signed=False, fraction_places=0
             )
             bounds = number_utils.bounds_cut(bounds, max_bounds)
         return RegisterArithmeticInfo(
-            size=self.output_size or self._expected_result_size(eff_arg),
-            fraction_places=eff_arg.fraction_places,
+            size=self.output_size or result_attrs.size,
+            fraction_places=result_attrs.fraction_digits,
             is_signed=is_signed,
             bypass_bounds_validation=self.bypass_bounds_validation,
             bounds=bounds,
         )
 
     def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
-        eff_arg = self.arg.limit_fraction_places(self.machine_precision)
-        if (self.output_size or eff_arg.size) == 1:
-            return 0
-        return (
-            self.output_size or self._expected_result_size(self.arg)
-        ) - self.arg.size
+        arg_integers = self.arg.size - self.arg.fraction_places
+        result_integers = (
+            self.result_register.size - self.result_register.fraction_places
+        )
+        return result_integers - arg_integers
 
 
 class Sign(UnaryOpParams):

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -20,9 +20,14 @@ CLASSIQ_EXPR_FUNCTIONS = {
     "get_field",
 }
 
+MEASUREMENT_FUNCTIONS = {
+    "measure",
+}
+
 SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
     *CLASSIQ_BUILTIN_CLASSICAL_FUNCTIONS,
     *CLASSIQ_EXPR_FUNCTIONS,
+    *MEASUREMENT_FUNCTIONS,
 }
 
 SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {

classiq/interface/generator/expressions/expression_types.py

@@ -1,6 +1,6 @@
 from typing import Union
 
-from sympy import Expr
+from sympy import Basic
 from sympy.logic.boolalg import Boolean
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
@@ -31,5 +31,5 @@ Proxies = Union[
     QmodSizedProxy,
     ClassicalProxy,
 ]
-RuntimeExpression = Union[AnyClassicalValue, Expr, Boolean]
+RuntimeExpression = Union[AnyClassicalValue, Basic, Boolean]
 ExpressionValue = Union[RuntimeConstant, Proxies, RuntimeExpression]

classiq/interface/generator/expressions/proxies/classical/qmod_struct_instance.py

@@ -41,3 +41,10 @@ class QmodStructInstance:
             for field_name, field_value in self._fields.items()
         )
         return f"{self.struct_declaration.name}({fields})"
+
+    def __eq__(self, other: Any) -> bool:
+        return (
+            isinstance(other, QmodStructInstance)
+            and self.struct_declaration.name == other.struct_declaration.name
+            and self._fields == other._fields
+        )

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

@@ -6,6 +6,7 @@ CLASSICAL_IF_OPERATOR_NAME = "classical_if"
 POWER_OPERATOR_NAME = "power"
 UNCOMPUTE_OPERATOR_NAME = "uncompute"
 WITHIN_APPLY_NAME = "within_apply"
+BLOCK_OPERATOR_NAME = "block"
 
 All_BUILTINS_OPERATORS = {
     CONTROL_OPERATOR_NAME,
@@ -14,4 +15,5 @@ All_BUILTINS_OPERATORS = {
     POWER_OPERATOR_NAME,
     UNCOMPUTE_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
+    BLOCK_OPERATOR_NAME,
 }

classiq/interface/generator/functions/classical_function_declaration.py

@@ -28,10 +28,6 @@ class ClassicalFunctionDeclaration(FunctionDeclaration):
         default=None,
     )
 
-    BUILTIN_FUNCTION_DECLARATIONS: ClassVar[
-        dict[str, "ClassicalFunctionDeclaration"]
-    ] = {}
-
     FOREIGN_FUNCTION_DECLARATIONS: ClassVar[
         dict[str, "ClassicalFunctionDeclaration"]
     ] = {}

classiq/interface/generator/functions/classical_type.py

@@ -113,7 +113,6 @@ class StructMetaType(ClassicalType):
 class ClassicalArray(ClassicalType):
     kind: Literal["array"]
     element_type: "ConcreteClassicalType"
-    size: Optional[int] = pydantic.Field(exclude=True, default=None)
     length: Optional[Expression] = None
 
     @pydantic.model_validator(mode="before")
@@ -121,37 +120,6 @@ class ClassicalArray(ClassicalType):
     def _set_kind(cls, values: Any) -> dict[str, Any]:
         return values_with_discriminator(values, "kind", "array")
 
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _set_length(cls, values: Any) -> Any:
-        if isinstance(values, dict):
-            size = values.get("size")
-            length = values.get("length")
-        else:
-            size = values.size
-            length = values.length
-        if size is not None:
-            if isinstance(values, dict):
-                values["length"] = Expression(expr=str(size))
-            else:
-                values.length = Expression(expr=str(size))
-        elif length is not None:
-            if isinstance(length, dict):
-                expr = length["expr"]
-            else:
-                expr = length.expr
-            expr_size: Optional[int] = None
-            try:  # noqa: SIM105
-                expr_size = int(expr)
-            except ValueError:
-                pass
-            if expr_size is not None:
-                if isinstance(values, dict):
-                    values["size"] = expr_size
-                else:
-                    values.size = expr_size
-        return values
-
     @property
     def has_length(self) -> bool:
         return self.length is not None and self.length.is_evaluated()

classiq/interface/generator/functions/concrete_types.py

@@ -53,3 +53,23 @@ QuantumBitvector.model_rebuild()
 TypeName.model_rebuild()
 QStructDeclaration.model_rebuild()
 RegisterQuantumType.model_rebuild()
+
+ConcreteType = Annotated[
+    Union[
+        Integer,
+        Real,
+        Bool,
+        StructMetaType,
+        TypeName,
+        ClassicalArray,
+        ClassicalTuple,
+        VQEResult,
+        Histogram,
+        Estimation,
+        IQAERes,
+        QuantumBit,
+        QuantumBitvector,
+        QuantumNumeric,
+    ],
+    Field(discriminator="kind"),
+]