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

classiq/interface/generator/arith/binary_ops.py

@@ -1,23 +1,29 @@
 import math
+from collections.abc import Iterable
 from typing import (
     Any,
     ClassVar,
-    Dict,
     Generic,
-    Iterable,
     Literal,
     Optional,
-    Tuple,
     TypeVar,
     Union,
 )
 
 import pydantic
-from pydantic.generics import GenericModel
+from pydantic import BaseModel
+from pydantic_core.core_schema import ValidationInfo
+from typing_extensions import Self
 
+from classiq.interface.enum_utils import StrEnum
+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.argument_utils import (
+    RegisterOrConst,
+    as_arithmetic_info,
+)
 from classiq.interface.generator.arith.arithmetic_operations import (
+    MODULO_WITH_FRACTION_PLACES_ERROR_MSG,
     ArithmeticOperationParams,
 )
 from classiq.interface.generator.arith.ast_node_rewrite import (
@@ -27,8 +33,6 @@ 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._internals.enum_utils import StrEnum
-
 LeftDataT = TypeVar("LeftDataT")
 RightDataT = TypeVar("RightDataT")
 _NumericArgumentInplaceErrorMessage: str = "Cannot inplace the numeric argument {}"
@@ -49,35 +53,49 @@ class ArgToInplace(StrEnum):
 
 
 class BinaryOpParams(
-    ArithmeticOperationParams, GenericModel, Generic[LeftDataT, RightDataT]
+    ArithmeticOperationParams, BaseModel, Generic[LeftDataT, RightDataT]
 ):
     left_arg: LeftDataT
     right_arg: RightDataT
     left_arg_name: ClassVar[str] = DEFAULT_LEFT_ARG_NAME
     right_arg_name: ClassVar[str] = DEFAULT_RIGHT_ARG_NAME
 
-    @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 ValueError("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 to affect the other.
-            values["right_arg"] = left_arg.copy(deep=True)
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _clone_repeated_arg(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+
+            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 to affect the other.
+                values["right_arg"] = left_arg.model_copy(deep=True)
         return values
 
+    def garbage_output_size(self) -> pydantic.NonNegativeInt:
+        return 0
+
     def _create_ios(self) -> None:
         self._inputs = dict()
         if isinstance(self.left_arg, RegisterArithmeticInfo):
             self._inputs[self.left_arg_name] = self.left_arg
         if isinstance(self.right_arg, RegisterArithmeticInfo):
             self._inputs[self.right_arg_name] = self.right_arg
-        zero_input_name = get_zero_input_name(self.output_name)
-        self._zero_inputs = {zero_input_name: self.result_register}
         self._outputs = {**self._inputs, self.output_name: self.result_register}
 
+        garbage_size = self.garbage_output_size()
+        if garbage_size > 0:
+            self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
+                size=garbage_size
+            )
+
+        zero_input_name = get_zero_input_name(self.output_name)
+        zero_input_size = self.result_register.size + garbage_size
+        self._zero_inputs = {
+            zero_input_name: RegisterArithmeticInfo(size=zero_input_size)
+        }
+
     def is_inplaced(self) -> bool:
         return False
 
@@ -90,24 +108,25 @@ class InplacableBinaryOpParams(
 ):
     inplace_arg: Optional[ArgToInplace] = None
 
-    @pydantic.root_validator(pre=True)
-    def _validate_inplace_arg(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
-        right_arg = values.get("right_arg")
-        inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
-        if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
-            raise ValueError(_NumericArgumentInplaceErrorMessage.format(right_arg))
-        elif inplace_arg == ArgToInplace.LEFT and isinstance(left_arg, Numeric):
-            raise ValueError(_NumericArgumentInplaceErrorMessage.format(left_arg))
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_inplace_arg(cls, values: Any) -> dict[str, Any]:
+        if isinstance(values, dict):
+            left_arg = values.get("left_arg")
+            right_arg = values.get("right_arg")
+            inplace_arg: Optional[ArgToInplace] = values.get("inplace_arg")
+            if inplace_arg == ArgToInplace.RIGHT and isinstance(right_arg, Numeric):
+                raise ClassiqValueError(
+                    _NumericArgumentInplaceErrorMessage.format(right_arg)
+                )
+            elif inplace_arg == ArgToInplace.LEFT and isinstance(left_arg, Numeric):
+                raise ClassiqValueError(
+                    _NumericArgumentInplaceErrorMessage.format(left_arg)
+                )
         return values
 
     def _create_ios(self) -> None:
         BinaryOpParams._create_ios(self)
-        garbage_size = self.garbage_output_size()
-        if garbage_size > 0:
-            self._outputs[self.garbage_output_name] = RegisterArithmeticInfo(
-                size=garbage_size
-            )
         if self.inplace_arg is None:
             return
         inplace_arg_name = (
@@ -117,7 +136,7 @@ class InplacableBinaryOpParams(
         )
         self._outputs.pop(inplace_arg_name)
 
-        self._set_inplace_zero_inputs(inplace_arg_name, garbage_size)
+        self._set_inplace_zero_inputs(inplace_arg_name, self.garbage_output_size())
 
     def _set_inplace_zero_inputs(
         self, inplace_arg_name: str, garbage_size: int
@@ -140,9 +159,13 @@ class InplacableBinaryOpParams(
         if self.inplace_arg is None:
             return 0
         arg = self.left_arg if self.inplace_arg == ArgToInplace.LEFT else self.right_arg
-        return max(0, arg.integer_part_size - self.result_register.integer_part_size)  # type: ignore[attr-defined]
+        return max(
+            0, arg.integer_part_size - self.result_register.integer_part_size  # type: ignore[attr-defined]
+        ) + max(
+            0, arg.fraction_places - self.result_register.fraction_places  # type: ignore[attr-defined]
+        )
 
-    def _carried_arguments(self) -> Tuple[Optional[LeftDataT], Optional[RightDataT]]:
+    def _carried_arguments(self) -> tuple[Optional[LeftDataT], Optional[RightDataT]]:
         if self.inplace_arg == ArgToInplace.RIGHT and isinstance(
             self.left_arg, RegisterArithmeticInfo
         ):
@@ -173,28 +196,28 @@ class InplacableBinaryOpParams(
             yield ArgToInplace.LEFT
 
     def get_params_inplace_options(self) -> Iterable["InplacableBinaryOpParams"]:
-        params_kwargs = self.copy().__dict__
+        params_kwargs = self.model_copy().__dict__
         for inplace_arg in self._get_binary_op_inplace_options():
             params_kwargs["inplace_arg"] = inplace_arg
             yield self.__class__(**params_kwargs)
 
 
 class BinaryOpWithIntInputs(BinaryOpParams[RegisterOrInt, RegisterOrInt]):
-    @pydantic.root_validator()
-    def validate_int_registers(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        left_arg = values.get("left_arg")
+    @pydantic.model_validator(mode="after")
+    def validate_int_registers(self) -> Self:
+        left_arg = self.left_arg
         is_left_arg_float_register = (
             isinstance(left_arg, RegisterArithmeticInfo)
             and left_arg.fraction_places > 0
         )
-        right_arg = values.get("right_arg")
+        right_arg = self.right_arg
         is_right_arg_float_register = (
             isinstance(right_arg, RegisterArithmeticInfo)
             and right_arg.fraction_places > 0
         )
         if is_left_arg_float_register or is_right_arg_float_register:
-            raise ValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
-        return values
+            raise ClassiqValueError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
+        return self
 
     @staticmethod
     def _is_signed(arg: Union[int, RegisterArithmeticInfo]) -> bool:
@@ -245,74 +268,160 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "sum"
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        lb = argument_utils.lower_bound(self.left_arg) + argument_utils.lower_bound(
-            self.right_arg
+        left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, self.machine_precision
         )
-        ub = argument_utils.upper_bound(self.left_arg) + argument_utils.upper_bound(
-            self.right_arg
+        right_arg = argument_utils.limit_fraction_places(
+            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
         )
-        integer_part_size = number_utils.bounds_to_integer_part_size(lb, ub)
         fraction_places = max(
-            self._compute_fraction_places(self.left_arg),
-            self._compute_fraction_places(self.right_arg),
+            argument_utils.fraction_places(left_arg),
+            argument_utils.fraction_places(right_arg),
         )
-        size_needed = integer_part_size + fraction_places
         return RegisterArithmeticInfo(
-            size=self.output_size or size_needed,
+            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,
         )
 
+    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
+
 
 class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     output_name = "difference"
 
+    @staticmethod
+    def _get_effective_arg(
+        arg: RegisterOrConst, machine_precision: int
+    ) -> RegisterOrConst:
+        return argument_utils.limit_fraction_places(arg, machine_precision)
+
+    @property
+    def effective_left_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.left_arg, self.machine_precision)
+
+    @property
+    def effective_right_arg(self) -> RegisterOrConst:
+        return self._get_effective_arg(self.right_arg, self.machine_precision)
+
+    @staticmethod
+    def _is_arg_trimmed_register(arg: RegisterOrConst, machine_precision: int) -> bool:
+        return (
+            isinstance(arg, RegisterArithmeticInfo)
+            and arg.fraction_places > machine_precision
+        )
+
+    @property
+    def left_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.left_arg, self.machine_precision)
+
+    @property
+    def right_arg_is_trimmed_register(self) -> bool:
+        return self._is_arg_trimmed_register(self.right_arg, self.machine_precision)
+
     def _get_result_register(self) -> RegisterArithmeticInfo:
         bounds = (
-            argument_utils.lower_bound(self.left_arg)
-            - argument_utils.upper_bound(self.right_arg),
-            argument_utils.upper_bound(self.left_arg)
-            - argument_utils.lower_bound(self.right_arg),
+            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),
         )
-        integer_part_size = number_utils.bounds_to_integer_part_size(*bounds)
         fraction_places = max(
-            self._compute_fraction_places(self.left_arg),
-            self._compute_fraction_places(self.right_arg),
+            argument_utils.fraction_places(self.effective_left_arg),
+            argument_utils.fraction_places(self.effective_right_arg),
         )
-        size_needed = integer_part_size + fraction_places
+
+        size = self.output_size or self._get_output_size(bounds, fraction_places)
+        is_signed = self._include_sign and min(bounds) < 0
         return RegisterArithmeticInfo(
-            size=self.output_size or size_needed,
+            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
+                ),
+            ),
         )
 
+    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 isinstance(self.right_arg, RegisterArithmeticInfo):
+        if (
+            not self.left_arg_is_trimmed_register
+            and not self.right_arg_is_trimmed_register
+        ):
+            return self._untrimmed_garbage_output_size()
+        if not self.is_inplaced():
+            return 0
+        inplace_arg_name = (
+            self.left_arg_name
+            if self.inplace_arg == ArgToInplace.LEFT
+            else self.right_arg_name
+        )
+        return max(
+            0,
+            self._inputs[inplace_arg_name].fraction_places
+            - self.result_register.fraction_places,
+        )
+
+    def _untrimmed_garbage_output_size(self) -> pydantic.NonNegativeInt:
+        if not isinstance(self.effective_right_arg, RegisterArithmeticInfo):
             adder_params = Adder(
-                left_arg=self.left_arg,
-                right_arg=-self.right_arg,
+                left_arg=self.effective_left_arg,
+                right_arg=-self.effective_right_arg,
                 output_size=self.output_size,
                 inplace_arg=self.inplace_arg,
             )
             return adder_params.garbage_output_size()
 
         negation_params = Negation(
-            arg=self.right_arg,
+            arg=self.effective_right_arg,
             output_size=self.negation_output_size,
             inplace=self.should_inplace_negation,
+            bypass_bounds_validation=True,
         )
         negation_result = negation_params.result_register
-        if self.output_size is None and max(self.right_arg.bounds) > 0:
-            negation_result = negation_result.copy(
-                update=dict(
-                    is_signed=True,
-                    bounds=(-max(self.right_arg.bounds), -min(self.right_arg.bounds)),
-                )
+        if self.output_size is None and max(self.effective_right_arg.bounds) > 0:
+            bounds = (
+                -max(self.effective_right_arg.bounds),
+                -min(self.effective_right_arg.bounds),
+            )
+            negation_result = RegisterArithmeticInfo(
+                size=negation_result.size,
+                fraction_places=negation_result.fraction_places,
+                is_signed=True,
+                bounds=bounds,
+                bypass_bounds_validation=True,
             )
         adder_params = Adder(
-            left_arg=self.left_arg,
+            left_arg=self.effective_left_arg,
             right_arg=negation_result,
             output_size=self.output_size,
             inplace_arg=self.arg_to_inplace_adder,
@@ -327,10 +436,10 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
         return self.inplace_arg == ArgToInplace.LEFT
 
     def _expected_negation_output_size(self) -> int:
-        return self._compute_fraction_places(self.right_arg) + min(
+        return argument_utils.fraction_places(self.effective_right_arg) + min(
             self.result_register.integer_part_size,
             number_utils.bounds_to_integer_part_size(
-                *(-bound for bound in argument_utils.bounds(self.right_arg))
+                *(-bound for bound in argument_utils.bounds(self.effective_right_arg))
             ),
         )
 
@@ -356,29 +465,85 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
 class Multiplier(BinaryOpWithFloatInputs):
     output_name = "product"
 
-    def _get_result_register(self) -> RegisterArithmeticInfo:
-        fraction_places = self._compute_fraction_places(
-            self.left_arg
-        ) + self._compute_fraction_places(self.right_arg)
+    def expected_fraction_places(self) -> int:
+        return argument_utils.fraction_places(
+            argument_utils.limit_fraction_places(self.left_arg, self.machine_precision)
+        ) + argument_utils.fraction_places(
+            argument_utils.limit_fraction_places(self.right_arg, self.machine_precision)
+        )
+
+    @staticmethod
+    def _get_bounds(
+        args: tuple[RegisterOrConst, RegisterOrConst], machine_precision: int
+    ) -> tuple[float, float]:
         extremal_values = [
             left * right
-            for left in argument_utils.bounds(self.left_arg)
-            for right in argument_utils.bounds(self.right_arg)
+            for left in argument_utils.bounds(args[0])
+            for right in argument_utils.bounds(args[1])
         ]
-        bounds = (min(extremal_values), max(extremal_values))
+        return (
+            number_utils.limit_fraction_places(min(extremal_values), machine_precision),
+            number_utils.limit_fraction_places(max(extremal_values), machine_precision),
+        )
+
+    def _get_result_register(self) -> RegisterArithmeticInfo:
+        fraction_places = min(self.machine_precision, self.expected_fraction_places())
+        left_arg = argument_utils.limit_fraction_places(
+            self.left_arg, self.machine_precision
+        )
+        right_arg = argument_utils.limit_fraction_places(
+            self.right_arg, self.machine_precision
+        )
+        bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
+        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 self._get_output_size(
+            bounds, fraction_places, left_arg, right_arg
+        )
+        is_signed = self._include_sign and min(bounds) < 0
+        return RegisterArithmeticInfo(
+            size=size,
+            fraction_places=fraction_places,
+            is_signed=is_signed,
+            bounds=self._legal_bounds(
+                bounds,
+                RegisterArithmeticInfo.get_maximal_bounds(
+                    size=size, is_signed=is_signed, fraction_places=fraction_places
+                ),
+            ),
+        )
+
+    @staticmethod
+    def _get_output_size(
+        bounds: tuple[float, float],
+        fraction_places: int,
+        left_arg: Union[RegisterArithmeticInfo, float],
+        right_arg: Union[RegisterArithmeticInfo, float],
+    ) -> int:
+        if isinstance(left_arg, float) and left_arg == 1.0:
+            assert isinstance(right_arg, RegisterArithmeticInfo)
+            return right_arg.size
+        elif isinstance(right_arg, float) and right_arg == 1.0:
+            assert isinstance(left_arg, RegisterArithmeticInfo)
+            return left_arg.size
         largest_bound = max(bounds, key=abs)
         integer_places = int(largest_bound).bit_length() + int(largest_bound < 0)
         extra_sign_bit = int(
-            argument_utils.is_signed(self.left_arg)
-            and argument_utils.is_signed(self.right_arg)
+            argument_utils.is_signed(left_arg)
+            and argument_utils.is_signed(right_arg)
             and largest_bound > 0
         )
-        return RegisterArithmeticInfo(
-            size=self.output_size
-            or max(1, integer_places + fraction_places + extra_sign_bit),
-            fraction_places=fraction_places,
-            is_signed=self._include_sign and min(bounds) < 0,
-            bounds=self._legal_bounds(bounds),
+        return max(1, integer_places + fraction_places + extra_sign_bit)
+
+    def garbage_output_size(self) -> pydantic.NonNegativeInt:
+        return max(
+            0, self.expected_fraction_places() - self.result_register.fraction_places
         )
 
 
@@ -416,29 +581,57 @@ class LessEqual(Comparator):
 class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
     output_name = "powered"
 
-    @pydantic.validator("right_arg", pre=True)
+    @pydantic.field_validator("right_arg", mode="before")
+    @classmethod
     def _validate_legal_power(cls, right_arg: Any) -> pydantic.PositiveInt:
         if not float(right_arg).is_integer():
-            raise ValueError("Power must be an integer")
+            raise ClassiqValueError("Power must be an integer")
         if right_arg <= 0:
-            raise ValueError("Power must be greater than one")
+            raise ClassiqValueError("Power must be greater than one")
         return int(right_arg)
 
-    def _get_result_bounds(self) -> Tuple[float, float]:
-        if (self.right_arg % 2) or min(self.left_arg.bounds) >= 0:
+    def expected_fraction_places(self) -> int:
+        return (
+            argument_utils.fraction_places(
+                argument_utils.limit_fraction_places(
+                    self.left_arg, self.machine_precision
+                )
+            )
+            * self.right_arg
+        )
+
+    def _get_result_bounds(self) -> tuple[float, float]:
+        bounds = [
+            number_utils.limit_fraction_places(
+                bound, machine_precision=self.machine_precision
+            )
+            for bound in self.left_arg.bounds
+        ]
+        if (self.right_arg % 2) or min(bounds) >= 0:
             return (
-                self.left_arg.bounds[0] ** self.right_arg,
-                self.left_arg.bounds[1] ** self.right_arg,
+                number_utils.limit_fraction_places(
+                    bounds[0] ** self.right_arg,
+                    machine_precision=self.machine_precision,
+                ),
+                number_utils.limit_fraction_places(
+                    bounds[1] ** self.right_arg,
+                    machine_precision=self.machine_precision,
+                ),
             )
-        return 0.0, max(abs(bound) for bound in self.left_arg.bounds) ** self.right_arg
+        return 0.0, number_utils.limit_fraction_places(
+            max(abs(bound) for bound in bounds) ** self.right_arg,
+            machine_precision=self.machine_precision,
+        )
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
         if self.output_size:
             return RegisterArithmeticInfo(size=self.output_size)
 
-        fraction_places: int = self.left_arg.fraction_places * self.right_arg
+        fraction_places = min(self.machine_precision, self.expected_fraction_places())
         bounds = self._get_result_bounds()
         size = number_utils.bounds_to_integer_part_size(*bounds) + fraction_places
+        if bounds[0] == bounds[1]:
+            size = 1
         return RegisterArithmeticInfo(
             size=size,
             is_signed=self.left_arg.is_signed and (self.right_arg % 2 == 1),
@@ -446,6 +639,50 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
             bounds=bounds,
         )
 
+    def _get_inner_action_garbage_size(
+        self,
+        action_type: Union[type["Power"], type[Multiplier]],
+        *,
+        arg: RegisterArithmeticInfo,
+        action_right_arg: RegisterOrConst,
+        compute_power: int,
+    ) -> pydantic.NonNegativeInt:
+        inner_compute_power_params = Power(
+            left_arg=arg,
+            right_arg=compute_power,
+            output_size=self.output_size,
+            machine_precision=self.machine_precision,
+        )
+        return action_type(
+            left_arg=inner_compute_power_params.result_register,
+            right_arg=action_right_arg,
+            output_size=self.output_size,
+            machine_precision=self.machine_precision,
+        ).garbage_output_size()
+
+    def garbage_output_size(self) -> pydantic.NonNegativeInt:
+        arg = self.left_arg
+        power = self.right_arg
+        if power == 1:
+            return 0
+        if (
+            power == 2
+            or (arg.size == 1 and arg.fraction_places == 0)
+            or self.output_size == 1
+        ):
+            return max(
+                0,
+                self.expected_fraction_places() - self.result_register.fraction_places,
+            )
+
+        if power % 2 == 0:
+            return self._get_inner_action_garbage_size(
+                Power, arg=arg, action_right_arg=power // 2, compute_power=2
+            )
+        return self._get_inner_action_garbage_size(
+            Multiplier, arg=arg, action_right_arg=arg, compute_power=power - 1
+        )
+
 
 class EffectiveUnaryOpParams(
     InplacableBinaryOpParams[RegisterArithmeticInfo, RightDataT], Generic[RightDataT]
@@ -457,19 +694,19 @@ class LShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     output_name = "left_shifted"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
-        shift = values.get("right_arg")
+            return self
+        arg = self.left_arg
+        shift = self.right_arg
         if not isinstance(arg, RegisterArithmeticInfo):
-            raise ValueError("left arg must be a RegisterArithmeticInfo")
+            raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
-            raise ValueError("Shift must be an integer")
+            raise ClassiqValueError("Shift must be an integer")
         assert arg.fraction_places - shift <= 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None or self.output_size is None:
@@ -498,21 +735,21 @@ class RShift(EffectiveUnaryOpParams[pydantic.NonNegativeInt]):
     def _shifted_fraction_places(*, arg: RegisterArithmeticInfo, shift: int) -> int:
         return arg.fraction_places * int(arg.is_signed or shift < arg.size)
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
-        shift = values.get("right_arg")
+            return self
+        arg = self.left_arg
+        shift = self.right_arg
         if not isinstance(arg, RegisterArithmeticInfo):
-            raise ValueError("left arg must be a RegisterArithmeticInfo")
+            raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         if not isinstance(shift, int):
-            raise ValueError("Shift must be an integer")
+            raise ClassiqValueError("Shift must be an integer")
         assert (
-            cls._shifted_fraction_places(arg=arg, shift=shift) == 0
+            self._shifted_fraction_places(arg=arg, shift=shift) == 0
         ), _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None:
@@ -542,16 +779,16 @@ class CyclicShift(EffectiveUnaryOpParams[int]):
     output_name = "cyclic_shifted"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.root_validator()
-    def _validate_legal_modulo(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        output_size = values.get("output_size")
+    @pydantic.model_validator(mode="after")
+    def _validate_legal_modulo(self) -> Self:
+        output_size = self.output_size
         if output_size is None:
-            return values
-        arg = values.get("left_arg")
+            return self
+        arg = self.left_arg
         if not isinstance(arg, RegisterArithmeticInfo):
-            raise ValueError("left arg must be a RegisterArithmeticInfo")
+            raise ClassiqValueError("left arg must be a RegisterArithmeticInfo")
         assert arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
-        return values
+        return self
 
     def garbage_output_size(self) -> pydantic.NonNegativeInt:
         if self.inplace_arg is None:
@@ -570,31 +807,30 @@ class Modulo(EffectiveUnaryOpParams[int]):
     output_name = "modulus"
     inplace_arg: Optional[ArgToInplace] = ArgToInplace.LEFT
 
-    @pydantic.validator("left_arg")
+    @pydantic.field_validator("left_arg", mode="before")
+    @classmethod
     def _validate_left_arg_is_integer(
         cls, left_arg: RegisterArithmeticInfo
     ) -> RegisterArithmeticInfo:
         assert left_arg.fraction_places == 0, _FLOATING_POINT_MODULO_ERROR_MESSAGE
         return left_arg
 
-    @pydantic.validator("right_arg")
+    @pydantic.field_validator("right_arg", mode="before")
+    @classmethod
     def _validate_right_arg_is_a_power_of_two(
-        cls, right_arg: int, values: Dict[str, Any]
+        cls, right_arg: int, info: ValidationInfo
     ) -> int:
         repr_qubits_float = math.log2(right_arg)
         repr_qubits = round(repr_qubits_float)
         assert abs(repr_qubits - repr_qubits_float) < 10**-8, NOT_POWER_OF_TWO_ERROR_MSG
-        output_size = values.get("output_size")
+        output_size = info.data.get("output_size")
         if output_size is not None:
             repr_qubits = min(repr_qubits, output_size)
-        values["output_size"] = None
+        info.data["output_size"] = None
         return 2 ** (repr_qubits)
 
-    @property
-    def result_size(self) -> int:
-        return round(math.log2(self.right_arg))
-
     def _get_result_register(self) -> RegisterArithmeticInfo:
-        return RegisterArithmeticInfo(
-            size=self.result_size, is_signed=False, fraction_places=0
-        )
+        size = round(math.log2(self.right_arg))
+        if size <= 0:
+            raise ClassiqValueError("Cannot use a quantum expression with zero size")
+        return RegisterArithmeticInfo(size=size, is_signed=False, fraction_places=0)