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

classiq/interface/generator/arith/extremum_operations.py

@@ -1,11 +1,14 @@
 import abc
-from typing import Any, Dict, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 import pydantic
 
-from classiq.interface.generator.arith import argument_utils
+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
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.binary_ops import (
@@ -15,8 +18,6 @@ from classiq.interface.generator.arith.binary_ops import (
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
-from classiq.exceptions import ClassiqValueError
-
 Numeric = (float, int)
 
 
@@ -24,16 +25,18 @@ class Extremum(ArithmeticOperationParams):
     left_arg: RegisterOrConst
     right_arg: RegisterOrConst
 
-    @pydantic.root_validator(pre=True)
-    def _validate_one_is_register(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
-        right_arg = values.get("right_arg")
-        if isinstance(left_arg, Numeric) and isinstance(right_arg, Numeric):
-            raise ClassiqValueError("One argument must be a register")
-        if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
-            # In case both arguments refer to the same object, copy it.
-            # This prevents changes performed on one argument from affecting the other.
-            values["right_arg"] = left_arg.copy(deep=True)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_one_is_register(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+            if isinstance(left_arg, Numeric) and isinstance(right_arg, Numeric):
+                raise ClassiqValueError("One argument must be a register")
+            if left_arg is right_arg and isinstance(left_arg, pydantic.BaseModel):
+                # In case both arguments refer to the same object, copy it.
+                # This prevents changes performed on one argument from affecting the other.
+                values["right_arg"] = left_arg.model_copy(deep=True)
         return values
 
     def _create_ios(self) -> None:
@@ -57,31 +60,77 @@ class Extremum(ArithmeticOperationParams):
     def _bound_calculator(cls, arg1: float, arg2: float) -> float:
         pass
 
+    @staticmethod
+    def _less_qubits_arg(
+        arg1: RegisterOrConst, arg2: RegisterOrConst
+    ) -> RegisterOrConst:
+        if not isinstance(arg1, RegisterArithmeticInfo):
+            return arg1
+        if not isinstance(arg2, RegisterArithmeticInfo):
+            return arg2
+        return arg1 if arg1.size <= arg2.size else arg2
+
+    @classmethod
+    @abc.abstractmethod
+    def preferred_arg(
+        cls, arg1: RegisterOrConst, arg2: RegisterOrConst
+    ) -> RegisterOrConst:
+        pass
+
     def _get_result_register(self) -> RegisterArithmeticInfo:
+        eff_left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, self.machine_precision
+        )
+        eff_right_arg = argument_utils.limit_fraction_places(
+            self.right_arg, self.machine_precision
+        )
+        if argument_utils.arg_bounds_overlap((eff_left_arg, eff_right_arg)):
+            return self._get_general_case_result_register(eff_left_arg, eff_right_arg)
+        return argument_utils.as_arithmetic_info(
+            self.preferred_arg(eff_left_arg, eff_right_arg)
+        )
+
+    def _get_general_case_result_register(
+        self, eff_left_arg: RegisterOrConst, eff_right_arg: RegisterOrConst
+    ) -> RegisterArithmeticInfo:
         integer_part_size = max(
-            argument_utils.integer_part_size(self.left_arg),
-            argument_utils.integer_part_size(self.right_arg),
+            argument_utils.integer_part_size(eff_left_arg),
+            argument_utils.integer_part_size(eff_right_arg),
         )
         fraction_places = max(
-            argument_utils.fraction_places(self.left_arg),
-            argument_utils.fraction_places(self.right_arg),
+            argument_utils.fraction_places(eff_left_arg),
+            argument_utils.fraction_places(eff_right_arg),
         )
         required_size = integer_part_size + fraction_places
         bounds = (
             self._bound_calculator(
-                argument_utils.lower_bound(self.left_arg),
-                argument_utils.lower_bound(self.right_arg),
+                argument_utils.lower_bound(eff_left_arg),
+                argument_utils.lower_bound(eff_right_arg),
             ),
             self._bound_calculator(
-                argument_utils.upper_bound(self.left_arg),
-                argument_utils.upper_bound(self.right_arg),
+                argument_utils.upper_bound(eff_left_arg),
+                argument_utils.upper_bound(eff_right_arg),
             ),
         )
+        if self.output_size:
+            if fraction_places:
+                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)
+        size = self.output_size or required_size
+        is_signed = self._include_sign and min(bounds) < 0
         return RegisterArithmeticInfo(
-            size=self.output_size or required_size,
+            size=size,
             fraction_places=fraction_places,
-            is_signed=self._include_sign and min(bounds) < 0,
-            bounds=self._legal_bounds(bounds),
+            is_signed=is_signed,
+            bounds=self._legal_bounds(
+                bounds,
+                RegisterArithmeticInfo.get_maximal_bounds(
+                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                ),
+            ),
         )
 
 
@@ -92,6 +141,17 @@ class Min(Extremum):
     def _bound_calculator(cls, arg1: float, arg2: float) -> float:
         return min(arg1, arg2)
 
+    @classmethod
+    def preferred_arg(
+        cls, arg1: RegisterOrConst, arg2: RegisterOrConst
+    ) -> RegisterOrConst:
+        min1, min2 = min(argument_utils.bounds(arg1)), min(argument_utils.bounds(arg2))
+        if min1 < min2:
+            return arg1
+        if min2 < min1:
+            return arg2
+        return cls._less_qubits_arg(arg1, arg2)
+
 
 class Max(Extremum):
     output_name = "max_value"
@@ -99,3 +159,14 @@ class Max(Extremum):
     @classmethod
     def _bound_calculator(cls, arg1: float, arg2: float) -> float:
         return max(arg1, arg2)
+
+    @classmethod
+    def preferred_arg(
+        cls, arg1: RegisterOrConst, arg2: RegisterOrConst
+    ) -> RegisterOrConst:
+        max1, max2 = max(argument_utils.bounds(arg1)), max(argument_utils.bounds(arg2))
+        if max1 > max2:
+            return arg1
+        if max2 > max1:
+            return arg2
+        return cls._less_qubits_arg(arg1, arg2)

classiq/interface/generator/arith/logical_ops.py

@@ -1,7 +1,10 @@
-from typing import Iterable, List, Optional
+from collections.abc import Iterable
+from typing import Optional
 
 import pydantic
+from pydantic import ConfigDict
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.argument_utils import RegisterOrConst
 from classiq.interface.generator.arith.arithmetic_operations import (
     ArithmeticOperationParams,
@@ -9,31 +12,31 @@ 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.exceptions import ClassiqValueError
-
 
 def get_arg_name(idx: int) -> str:
     return f"arg_{idx}"
 
 
 class LogicalOps(ArithmeticOperationParams):
-    args: List[RegisterOrConst]
+    args: list[RegisterOrConst]
     target: Optional[RegisterArithmeticInfo]
-    _should_invert_node_list: List[str] = pydantic.PrivateAttr(default_factory=list)
+    _should_invert_node_list: list[str] = pydantic.PrivateAttr(default_factory=list)
 
-    def update_should_invert_node_list(self, invert_args: List[str]) -> None:
+    def update_should_invert_node_list(self, invert_args: list[str]) -> None:
         self._should_invert_node_list.extend(invert_args)
 
-    @pydantic.validator("output_size")
+    @pydantic.field_validator("output_size")
+    @classmethod
     def _validate_output_size(cls, output_size: Optional[int]) -> int:
         if output_size is not None and output_size != 1:
             raise ClassiqValueError("logical operation output size must be 1")
         return 1
 
-    @pydantic.validator("args")
+    @pydantic.field_validator("args")
+    @classmethod
     def _validate_inputs_sizes(
-        cls, arguments: List[RegisterOrConst]
-    ) -> List[RegisterOrConst]:
+        cls, arguments: list[RegisterOrConst]
+    ) -> list[RegisterOrConst]:
         for arg_idx, arg in enumerate(arguments):
             if isinstance(arg, RegisterArithmeticInfo) and not arg.is_boolean_register:
                 raise ClassiqValueError(
@@ -65,8 +68,7 @@ class LogicalOps(ArithmeticOperationParams):
     def get_params_inplace_options(self) -> Iterable["LogicalOps"]:
         return ()
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 class LogicalAnd(LogicalOps):

classiq/interface/generator/arith/number_utils.py

@@ -1,4 +1,4 @@
-from typing import Final, Tuple, Union
+from typing import Final, Union
 
 MAXIMAL_MACHINE_PRECISION: Final[int] = 20
 
@@ -12,7 +12,7 @@ def signed_int_to_unsigned(number: int) -> int:
     return number + 2 ** (number.bit_length() + 1 * not_power2)
 
 
-def _binary_to_int(bin_rep: str, is_signed: bool) -> int:
+def binary_to_int(bin_rep: str, is_signed: bool = False) -> int:
     negative_offset: int = -(2 ** len(bin_rep)) * (bin_rep[0] == "1") * is_signed
     return int(bin_rep, 2) + negative_offset
 
@@ -20,14 +20,14 @@ def _binary_to_int(bin_rep: str, is_signed: bool) -> int:
 def binary_to_float(
     bin_rep: str, fraction_part_size: int = 0, is_signed: bool = False
 ) -> float:
-    return _binary_to_int(bin_rep, is_signed) / 2**fraction_part_size
+    return binary_to_int(bin_rep, is_signed) / 2**fraction_part_size
 
 
 def binary_to_float_or_int(
     bin_rep: str, fraction_part_size: int = 0, is_signed: bool = False
 ) -> Union[float, int]:
     if fraction_part_size == 0:
-        return _binary_to_int(bin_rep, is_signed)
+        return binary_to_int(bin_rep, is_signed)
     return binary_to_float(bin_rep, fraction_part_size, is_signed)
 
 
@@ -40,7 +40,7 @@ def _get_fraction_places(*, binary_value: str) -> int:
     return fraction_places
 
 
-def get_int_representation_and_fraction_places(float_value: float) -> Tuple[int, int]:
+def get_int_representation_and_fraction_places(float_value: float) -> tuple[int, int]:
     int_val = signed_int_to_unsigned(int(float_value * 2**MAXIMAL_MACHINE_PRECISION))
     if int_val == 0:
         return 0, 0
@@ -100,7 +100,7 @@ def bounds_to_integer_part_size(lb: float, ub: float) -> int:
     )
 
 
-def limit_fraction_places(number: float, *, machine_precision: int) -> float:
+def limit_fraction_places(number: float, machine_precision: int) -> float:
     orig_bin_rep = binary_string(number)[::-1]
     orig_fractions = fraction_places(number)
 
@@ -110,3 +110,9 @@ def limit_fraction_places(number: float, *, machine_precision: int) -> float:
         fraction_part_size=orig_fractions - removed_fractions,
         is_signed=number < 0,
     )
+
+
+def bounds_cut(
+    bounds1: tuple[float, float], bounds2: tuple[float, float]
+) -> tuple[float, float]:
+    return max(min(bounds1), min(bounds2)), min(max(bounds1), max(bounds2))

classiq/interface/generator/arith/register_user_input.py

@@ -1,55 +1,77 @@
-from typing import Any, Dict, Optional
+from typing import Any, Optional
 
 import pydantic
+from pydantic import ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.helpers.custom_pydantic_types import PydanticFloatTuple
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class RegisterArithmeticInfo(HashablePydanticBaseModel):
-    size: pydantic.PositiveInt
+    size: pydantic.PositiveInt = pydantic.Field(default=1)
     is_signed: bool = pydantic.Field(default=False)
     fraction_places: pydantic.NonNegativeInt = pydantic.Field(default=0)
-    bounds: PydanticFloatTuple = pydantic.Field(default=None)
+    bypass_bounds_validation: bool = pydantic.Field(default=False)
+    bounds: PydanticFloatTuple = pydantic.Field(
+        default=None,
+        validate_default=True,
+    )
 
-    @pydantic.root_validator(pre=True)
-    def _remove_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        if "name" in values:
-            values.pop("name")
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _remove_name(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
+        if isinstance(values, dict):
+            values = values.copy()
+        elif hasattr(values, "__dict__"):
+            values = values.__dict__.copy()
+        elif values is None and info.data:
+            values = info.data.copy()
+        else:
+            raise ValueError("Unsupported type for removing 'name'.")
+
+        values.pop("name", None)
         return values
 
-    @pydantic.validator("bounds", always=True)
-    def _validate_bounds(
-        cls, bounds: Optional[PydanticFloatTuple], values: Dict[str, Any]
-    ) -> PydanticFloatTuple:
-        if bounds is not None:
-            if min(bounds) < 0:
-                assert values.get("is_signed")
-            fraction_places = values.get("fraction_places")
-            if not isinstance(fraction_places, int):
-                raise ClassiqValueError(
-                    "RegisterUserInput must have an integer fraction_places"
-                )
-            return number_utils.limit_fraction_places(
-                min(bounds), machine_precision=fraction_places
-            ), number_utils.limit_fraction_places(
-                max(bounds), machine_precision=fraction_places
-            )
-
-        size = values.get("size")
-        if not isinstance(size, int):
-            raise ClassiqValueError("RegisterUserInput must have an integer size")
-        is_signed: bool = values.get("is_signed", False)
+    @staticmethod
+    def get_maximal_bounds(
+        *, size: int, is_signed: bool, fraction_places: int
+    ) -> tuple[float, float]:
         lb = 0 if not is_signed else -(2 ** (size - 1))
         ub = 2**size - 1 if not is_signed else 2 ** (size - 1) - 1
-        fraction_factor = float(2 ** -values.get("fraction_places", 0))
+        fraction_factor = float(2**-fraction_places)
         return (lb * fraction_factor, ub * fraction_factor)
 
+    @pydantic.field_validator("bounds", mode="before")
+    @classmethod
+    def _validate_bounds(
+        cls, bounds: Optional[PydanticFloatTuple], info: ValidationInfo
+    ) -> PydanticFloatTuple:
+        size = info.data.get("size")
+        is_signed = info.data.get("is_signed", False)
+        fraction_places = info.data.get("fraction_places", 0)
+        if not isinstance(size, int):
+            raise ClassiqValueError("RegisterArithmeticInfo must have an integer size")
+
+        maximal_bounds = cls.get_maximal_bounds(
+            size=size, is_signed=is_signed, fraction_places=fraction_places
+        )
+        if bounds is None:
+            return maximal_bounds
+
+        trimmed_bounds = (
+            number_utils.limit_fraction_places(min(bounds), fraction_places),
+            number_utils.limit_fraction_places(max(bounds), fraction_places),
+        )
+        if not info.data.get("bypass_bounds_validation", False):
+            assert min(trimmed_bounds) >= min(maximal_bounds), "Illegal bound min"
+            assert max(trimmed_bounds) <= max(maximal_bounds), "Illegal bound max"
+        return trimmed_bounds
+
     def limit_fraction_places(self, machine_precision: int) -> "RegisterArithmeticInfo":
         truncated_bits: int = max(self.fraction_places - machine_precision, 0)
         return RegisterArithmeticInfo(
@@ -57,6 +79,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
             is_signed=self.is_signed,
             fraction_places=self.fraction_places - truncated_bits,
             bounds=self.bounds,
+            bypass_bounds_validation=self.bypass_bounds_validation,
         )
 
     @property
@@ -71,8 +94,7 @@ class RegisterArithmeticInfo(HashablePydanticBaseModel):
     def integer_part_size(self) -> pydantic.NonNegativeInt:
         return self.size - self.fraction_places
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class RegisterUserInput(RegisterArithmeticInfo):
@@ -82,12 +104,13 @@ class RegisterUserInput(RegisterArithmeticInfo):
         super().__init__(**data)
         self._fields_to_skip_in_hash = frozenset({"name"})
 
-    @pydantic.root_validator(pre=True)
-    def _remove_name(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _remove_name(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
         return values
 
     def revalued(self, **kwargs: Any) -> "RegisterUserInput":
-        return self.copy(update=kwargs)
+        return self.model_copy(update=kwargs)
 
     @classmethod
     def from_arithmetic_info(

classiq/interface/generator/arith/unary_ops.py

@@ -1,17 +1,19 @@
-from typing import TYPE_CHECKING, Iterable, Optional
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, 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.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 from classiq.interface.generator.function_params import get_zero_input_name
 
-from classiq.exceptions import ClassiqValueError
-
-UNARY_ARG_NAME: str = "arg"
+UNARY_ARG_NAME: Final[str] = "arg"
 
 
 class UnaryOpParams(ArithmeticOperationParams):
@@ -19,17 +21,16 @@ class UnaryOpParams(ArithmeticOperationParams):
     inplace: bool = False
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
-        return int(self.is_inplaced()) * max(
-            self.arg.size - self.result_register.size, 0
+        return int(self.is_inplaced()) * (
+            max(self.arg.integer_part_size - self.result_register.integer_part_size, 0)
+            + max(self.arg.fraction_places - self.result_register.fraction_places, 0)
         )
 
     def should_add_zero_inputs(self) -> bool:
-        return not self.is_inplaced() or self.should_add_zero_input_for_extension()
+        return not self.is_inplaced() or self.zero_input_for_extension() > 0
 
-    def should_add_zero_input_for_extension(
-        self, output_size: Optional[int] = None
-    ) -> bool:
-        return (output_size or self.result_register.size) > self.arg.size
+    def zero_input_for_extension(self) -> pydantic.NonNegativeInt:
+        return max(0, self.result_register.size - self.arg.size)
 
     def _create_ios(self) -> None:
         self._inputs = {UNARY_ARG_NAME: self.arg}
@@ -41,8 +42,8 @@ class UnaryOpParams(ArithmeticOperationParams):
             zero_input_register = self.result_register
             self._zero_inputs = {zero_input_name: zero_input_register}
             return
-        if self.should_add_zero_input_for_extension():
-            output_extension_size = self.result_register.size - self.arg.size
+        if self.zero_input_for_extension() > 0:
+            output_extension_size = self.zero_input_for_extension()
             self._create_zero_input_registers({zero_input_name: output_extension_size})
         if self.garbage_output_size() > 0:
             self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
@@ -53,21 +54,18 @@ class UnaryOpParams(ArithmeticOperationParams):
         return self.inplace
 
     def get_params_inplace_options(self) -> Iterable["UnaryOpParams"]:
-        params_kwargs = self.copy().__dict__
+        params_kwargs = self.model_copy().model_dump()
         params_kwargs["inplace"] = True
         yield self.__class__(**params_kwargs)
 
-    class Config:
-        arbitrary_types_allowed = True
+    model_config = ConfigDict(arbitrary_types_allowed=True)
 
 
 class BitwiseInvert(UnaryOpParams):
     output_name = "inverted"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        eff_arg = argument_utils.limit_fraction_places(
-            self.arg, machine_precision=self.machine_precision
-        )
+        eff_arg = argument_utils.limit_fraction_places(self.arg, self.machine_precision)
         if TYPE_CHECKING:
             assert isinstance(eff_arg, RegisterArithmeticInfo)
         return RegisterArithmeticInfo(
@@ -78,30 +76,52 @@ class BitwiseInvert(UnaryOpParams):
 
 
 class Negation(UnaryOpParams):
+    bypass_bounds_validation: bool = pydantic.Field(
+        default=False
+    )  # True for efficient subtraction
     output_name = "negated"
 
-    def _expected_result_size(self) -> pydantic.PositiveInt:
-        if self.arg.size == 1:
+    @staticmethod
+    def _expected_result_size(arg: RegisterArithmeticInfo) -> pydantic.PositiveInt:
+        if arg.size == 1:
             return 1
-        return self.arg.fraction_places + number_utils.bounds_to_integer_part_size(
-            *(-bound for bound in self.arg.bounds)
+        return arg.fraction_places + number_utils.bounds_to_integer_part_size(
+            *(-bound for bound in arg.bounds)
         )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        is_signed = max(self.arg.bounds) > 0 and self._include_sign
-        bounds = (-max(self.arg.bounds), -min(self.arg.bounds))
+        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))
+        if self.output_size and not self.bypass_bounds_validation:
+            if eff_arg.fraction_places:
+                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(),
-            fraction_places=self.arg.fraction_places,
+            size=self.output_size or self._expected_result_size(eff_arg),
+            fraction_places=eff_arg.fraction_places,
             is_signed=is_signed,
-            bounds=bounds if (is_signed or min(bounds) >= 0) else None,
+            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
+
 
 class Sign(UnaryOpParams):
     output_name = "sign"
 
-    @pydantic.validator("output_size")
+    @pydantic.field_validator("output_size")
+    @classmethod
     def _validate_output_size(
         cls, output_size: Optional[pydantic.PositiveInt]
     ) -> pydantic.PositiveInt:

classiq/interface/generator/arith/uncomputation_methods.py

@@ -1,4 +1,4 @@
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class UncomputationMethods(StrEnum):

classiq/interface/generator/builtin_api_builder.py

@@ -1,19 +1,12 @@
-from typing import Any, Iterable
+from collections.abc import Iterable
+from typing import Any
 
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
 
 
 def populate_builtin_declarations(decls: Iterable[Any]) -> None:
     for decl in decls:
-        if isinstance(decl, QuantumFunctionDeclaration):
-            QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS[decl.name] = decl
         if isinstance(decl, ClassicalFunctionDeclaration):
             ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS[decl.name] = decl
-        if isinstance(decl, StructDeclaration):
-            StructDeclaration.BUILTIN_STRUCT_DECLARATIONS[decl.name] = decl

classiq/interface/generator/chemistry_function_params.py

@@ -4,6 +4,7 @@ from classiq.interface.chemistry.ground_state_problem import (
     CHEMISTRY_PROBLEMS_TYPE,
     GroundStateProblem,
 )
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.function_params import (
     DEFAULT_INPUT_NAME,
@@ -11,13 +12,12 @@ from classiq.interface.generator.function_params import (
     FunctionParams,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class ChemistryFunctionParams(FunctionParams):
     gs_problem: CHEMISTRY_PROBLEMS_TYPE
 
-    @pydantic.validator("gs_problem")
+    @pydantic.field_validator("gs_problem")
+    @classmethod
     def validate_gs_problem_contains_num_qubits(
         cls, gs_problem: CHEMISTRY_PROBLEMS_TYPE
     ) -> CHEMISTRY_PROBLEMS_TYPE:

classiq/interface/generator/circuit_code/circuit_code.py

@@ -1,7 +1,8 @@
-from typing import Dict, Optional
+from typing import Optional
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqMissingOutputFormatError
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.generator.circuit_code.types_and_constants import (
     INSTRUCTION_SET_TO_FORMAT,
@@ -12,17 +13,16 @@ from classiq.interface.generator.circuit_code.types_and_constants import (
 )
 from classiq.interface.generator.model.preferences.preferences import QuantumFormat
 
-from classiq.exceptions import ClassiqMissingOutputFormatError
-
 
 class CircuitCodeInterface(pydantic.BaseModel):
-    outputs: Dict[QuantumFormat, Code]
+    outputs: dict[QuantumFormat, Code]
     qasm_version: QasmVersion
 
-    @pydantic.validator("outputs")
+    @pydantic.field_validator("outputs")
+    @classmethod
     def reformat_long_string_output_formats(
-        cls, outputs: Dict[QuantumFormat, str]
-    ) -> Dict[QuantumFormat, LongStr]:
+        cls, outputs: dict[QuantumFormat, str]
+    ) -> dict[QuantumFormat, LongStr]:
         return {key: LongStr(value) for key, value in outputs.items()}
 
     @property