classiq 0.42.2__py3-none-any.whl → 0.43.1__py3-none-any.whl

classiq/interface/generator/arith/arithmetic_expression_validator.py

@@ -1,10 +1,9 @@
 import ast
-import builtins
 import re
 from _ast import AST
-from typing import Any, Optional, Set, Tuple, Type, Union
+from typing import Any, Dict, Optional, Set, Tuple, Type, Union
 
-from typing_extensions import get_args
+from typing_extensions import TypeAlias, get_args
 
 from classiq.interface.generator.arith.ast_node_rewrite import AstNodeRewrite
 from classiq.interface.generator.expressions.sympy_supported_expressions import (
@@ -21,6 +20,7 @@ IDENITIFIER_REGEX = re.compile(r"[a-zA-Z_][a-zA-Z0-9_]*")
 _REPEATED_VARIABLES_ERROR_MESSAGE: str = (
     "Repeated variables in the beginning of an arithmetic expression are not allowed."
 )
+ValidKeyValuePairs: TypeAlias = Dict[str, Set[str]]
 
 SupportedNodesTypes = Union[
     ast.Expression,
@@ -64,14 +64,12 @@ class ExpressionValidator(ast.NodeVisitor):
         supported_nodes: Tuple[Type[AST], ...],
         expression_type: str = DEFAULT_EXPRESSION_TYPE,
         supported_functions: Optional[Set[str]] = None,
-        supported_attr_values: Optional[Set[str]] = None,
         mode: str = "eval",
     ) -> None:
         super().__init__()
         self.supported_nodes = supported_nodes
         self._expression_type = expression_type
         self._supported_functions = supported_functions or DEFAULT_SUPPORTED_FUNC_NAMES
-        self._supported_attr_values = supported_attr_values or set()
         self._mode = mode
         self._ast_obj: Optional[ast.AST] = None
 
@@ -170,26 +168,7 @@ class ExpressionValidator(ast.NodeVisitor):
         self.validate_Constant(node)
         self.generic_visit(node)
 
-    def validate_Attribute(self, node: ast.Attribute) -> None:  # noqa: N802
-        if not (
-            isinstance(node.value, ast.Name)
-            and node.value.id in self._supported_attr_values
-        ):
-            raise ClassiqValueError(
-                f"Attribute is not supported for value {node.value}"
-            )
-
     def visit_Attribute(self, node: ast.Attribute) -> None:
-        self.validate_Attribute(node)
-        self.generic_visit(node)
-
-    def visit_FunctionDef(self, node: ast.FunctionDef) -> Any:
-        if self._mode == "exec":
-            if hasattr(builtins, node.name):
-                raise ClassiqValueError(
-                    f"Defining a function named {node.name} is forbidden"
-                )
-            self._supported_functions.add(node.name)
         self.generic_visit(node)
 
     @classmethod
@@ -203,7 +182,6 @@ def validate_expression(
     supported_nodes: Tuple[Type[AST], ...] = DEFAULT_SUPPORTED_NODE_TYPES,
     expression_type: str = DEFAULT_EXPRESSION_TYPE,
     supported_functions: Optional[Set[str]] = None,
-    supported_attr_values: Optional[Set[str]] = None,
     mode: str = "eval",
 ) -> ast.AST:
     supported_functions = supported_functions or set(SYMPY_SUPPORTED_EXPRESSIONS).union(
@@ -213,7 +191,6 @@ def validate_expression(
         supported_nodes,
         expression_type,
         supported_functions,
-        supported_attr_values,
         mode,
     )
     validator.validate(expression)

classiq/interface/generator/arith/binary_ops.py

@@ -264,10 +264,10 @@ class Adder(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
 
     def _get_result_register(self) -> RegisterArithmeticInfo:
         left_arg = argument_utils.limit_fraction_places(
-            self.left_arg, machine_precision=self.machine_precision
+            self.left_arg, self.machine_precision
         )
         right_arg = argument_utils.limit_fraction_places(
-            self.right_arg, machine_precision=self.machine_precision
+            self.right_arg, self.machine_precision
         )
         lb = argument_utils.lower_bound(left_arg) + argument_utils.lower_bound(
             right_arg
@@ -305,9 +305,7 @@ class Subtractor(InplacableBinaryOpParams[RegisterOrConst, RegisterOrConst]):
     def _get_effective_arg(
         arg: RegisterOrConst, machine_precision: int
     ) -> RegisterOrConst:
-        return argument_utils.limit_fraction_places(
-            arg, machine_precision=machine_precision
-        )
+        return argument_utils.limit_fraction_places(arg, machine_precision)
 
     @property
     def effective_left_arg(self) -> RegisterOrConst:
@@ -453,13 +451,9 @@ class Multiplier(BinaryOpWithFloatInputs):
 
     def expected_fraction_places(self) -> int:
         return argument_utils.fraction_places(
-            argument_utils.limit_fraction_places(
-                self.left_arg, machine_precision=self.machine_precision
-            )
+            argument_utils.limit_fraction_places(self.left_arg, self.machine_precision)
         ) + argument_utils.fraction_places(
-            argument_utils.limit_fraction_places(
-                self.right_arg, machine_precision=self.machine_precision
-            )
+            argument_utils.limit_fraction_places(self.right_arg, self.machine_precision)
         )
 
     @staticmethod
@@ -483,10 +477,10 @@ class Multiplier(BinaryOpWithFloatInputs):
     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, machine_precision=self.machine_precision
+            self.left_arg, self.machine_precision
         )
         right_arg = argument_utils.limit_fraction_places(
-            self.right_arg, machine_precision=self.machine_precision
+            self.right_arg, self.machine_precision
         )
         bounds = self._get_bounds((left_arg, right_arg), self.machine_precision)
 
@@ -572,7 +566,7 @@ class Power(BinaryOpParams[RegisterArithmeticInfo, pydantic.PositiveInt]):
         return (
             argument_utils.fraction_places(
                 argument_utils.limit_fraction_places(
-                    self.left_arg, machine_precision=self.machine_precision
+                    self.left_arg, self.machine_precision
                 )
             )
             * self.right_arg

classiq/interface/generator/arith/extremum_operations.py

@@ -57,7 +57,21 @@ class Extremum(ArithmeticOperationParams):
     def _bound_calculator(cls, arg1: float, arg2: float) -> float:
         pass
 
+    @classmethod
+    @abc.abstractmethod
+    def _preferred_arg(
+        cls, arg1: RegisterOrConst, arg2: RegisterOrConst
+    ) -> RegisterOrConst:
+        pass
+
     def _get_result_register(self) -> RegisterArithmeticInfo:
+        if argument_utils.arg_bounds_overlap((self.left_arg, self.right_arg)):
+            return self._get_general_case_result_register()
+        return argument_utils.as_arithmetic_info(
+            self._preferred_arg(self.left_arg, self.right_arg)
+        )
+
+    def _get_general_case_result_register(self) -> RegisterArithmeticInfo:
         integer_part_size = max(
             argument_utils.integer_part_size(self.left_arg),
             argument_utils.integer_part_size(self.right_arg),
@@ -92,6 +106,14 @@ 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:
+        if min(argument_utils.bounds(arg1)) < min(argument_utils.bounds(arg2)):
+            return arg1
+        return arg2
+
 
 class Max(Extremum):
     output_name = "max_value"
@@ -99,3 +121,11 @@ 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:
+        if max(argument_utils.bounds(arg1)) > max(argument_utils.bounds(arg2)):
+            return arg1
+        return arg2

classiq/interface/generator/arith/number_utils.py

@@ -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)
 

classiq/interface/generator/arith/unary_ops.py

@@ -64,9 +64,7 @@ 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(

classiq/interface/generator/compiler_keywords.py

@@ -1,4 +1,4 @@
 EXPANDED_KEYWORD = "expanded__"
 CAPTURE_SUFFIX = "_captured__"
 LAMBDA_KEYWORD = "lambda__"
-GENERAL_INPLACE_ARITHMETIC_AUXILIARY_VARIABLE = "result__temp__"
+INPLACE_ARITH_AUX_VAR_PREFIX = "result__temp__"

classiq/interface/generator/expressions/atomic_expression_functions.py

@@ -1,8 +1,10 @@
 from classiq.interface.generator.functions.classical_type import CLASSICAL_ATTRIBUTES
 
-SUPPORTED_BUILTIN_FUNCTIONS = ["len", "sum", "print"]
+SUPPORTED_PYTHON_BUILTIN_FUNCTIONS = {"len", "sum", "print"}
 
-SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
+SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS = {
+    "do_div",
+    "do_slice",
     "do_subscript",
     "hypercube_entangler_graph",
     "grid_entangler_graph",
@@ -15,11 +17,19 @@ SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
     "molecule_problem_to_hamiltonian",
     "fock_hamiltonian_problem_to_hamiltonian",
     "molecule_ground_state_solution_post_process",
+}
+
+SUPPORTED_CLASSIQ_SYMPY_WRAPPERS = {
     "BitwiseAnd",
     "BitwiseXor",
     "BitwiseNot",
     "BitwiseOr",
-    *SUPPORTED_BUILTIN_FUNCTIONS,
+}
+
+SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS = {
+    *SUPPORTED_CLASSIQ_BUILTIN_FUNCTIONS,
+    *SUPPORTED_CLASSIQ_SYMPY_WRAPPERS,
+    *SUPPORTED_PYTHON_BUILTIN_FUNCTIONS,
 }
 
 SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD = (

classiq/interface/generator/expressions/enums/__init__.py

@@ -1,20 +0,0 @@
-from enum import EnumMeta
-
-from .chemistry import Element, FermionMapping
-from .finance_functions import FinanceFunctionType
-from .ladder_operator import LadderOperator
-from .optimizers import Optimizer
-from .pauli import Pauli
-from .qsvm_feature_map_entanglement import QSVMFeatureMapEntanglement
-
-BUILTIN_ENUMS = dict(filter(lambda pair: isinstance(pair[1], EnumMeta), vars().items()))
-
-__all__ = [
-    "Element",
-    "FermionMapping",
-    "FinanceFunctionType",
-    "LadderOperator",
-    "Optimizer",
-    "Pauli",
-    "QSVMFeatureMapEntanglement",
-]

classiq/interface/generator/expressions/enums/finance_functions.py

@@ -1,22 +1,15 @@
-from typing import Dict
+from typing import TYPE_CHECKING, Dict
 
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
+if TYPE_CHECKING:
+    from classiq.qmod.builtins.enums import FinanceFunctionType
 
 
-class FinanceFunctionType(ClassicalEnum):
-    VAR = 0
-    SHORTFALL = 1
-    X_SQUARE = 2
-    EUROPEAN_CALL_OPTION = 3
+def get_finance_function_dict() -> Dict[str, "FinanceFunctionType"]:
+    from classiq.qmod.builtins.enums import FinanceFunctionType
 
-    @staticmethod
-    def from_string(func_str: str) -> "FinanceFunctionType":
-        return FINANCE_FUNCTION_STRING[func_str]
-
-
-FINANCE_FUNCTION_STRING: Dict[str, FinanceFunctionType] = {
-    "var": FinanceFunctionType.VAR,
-    "expected shortfall": FinanceFunctionType.SHORTFALL,
-    "x**2": FinanceFunctionType.X_SQUARE,
-    "european call option": FinanceFunctionType.EUROPEAN_CALL_OPTION,
-}
+    return {
+        "var": FinanceFunctionType.VAR,
+        "expected shortfall": FinanceFunctionType.SHORTFALL,
+        "x**2": FinanceFunctionType.X_SQUARE,
+        "european call option": FinanceFunctionType.EUROPEAN_CALL_OPTION,
+    }

classiq/interface/generator/expressions/non_symbolic_expr.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from typing import Any, NoReturn
+
+from classiq.exceptions import ClassiqArithmeticError
+
+
+class NonSymbolicExpr:
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
+    @staticmethod
+    def _raise_error(type_name: str, op: str) -> NoReturn:
+        raise ClassiqArithmeticError(
+            f"Unsupported operand type for {op!r}: {type_name}"
+        )
+
+    def __add__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __sub__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __mul__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "*")
+
+    def __truediv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "/")
+
+    def __floordiv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "//")
+
+    def __mod__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "%")
+
+    def __pow__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "**")
+
+    def __lshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<<")
+
+    def __rshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">>")
+
+    def __and__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "&")
+
+    def __xor__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "^")
+
+    def __or__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "|")
+
+    def __radd__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __rsub__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __rmul__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "*")
+
+    def __rtruediv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "/")
+
+    def __rfloordiv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "//")
+
+    def __rmod__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "%")
+
+    def __rpow__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "**")
+
+    def __rlshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<<")
+
+    def __rrshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">>")
+
+    def __rand__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "&")
+
+    def __rxor__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "^")
+
+    def __ror__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "|")
+
+    def __lt__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<")
+
+    def __le__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<=")
+
+    def __eq__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "==")
+
+    def __ne__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "!=")
+
+    def __gt__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">")
+
+    def __ge__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">=")
+
+    def __neg__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __pos__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __abs__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "abs")
+
+    def __invert__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "~")

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -1,6 +1,7 @@
-from typing import Any, Mapping, Optional, Tuple, Union
+from typing import Any, Callable, Mapping, Optional, Tuple, Union
 
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.model.handle_binding import (
     HandleBinding,
@@ -15,22 +16,22 @@ SLICE_OUT_OF_BOUNDS_MSG = "Slice end index out of bounds"
 QARRAY_ELEMENT_NOT_SUBSCRIPTABLE = "Subscripting an element in QArray is illegal"
 
 
-class QmodQArrayProxy(QmodSizedProxy):
+class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
     def __init__(
         self,
-        name: str,
-        size: int,
-        slice_: Optional[Tuple[int, int]] = None,
-        index_: Optional[int] = None,
+        handle: HandleBinding,
+        element_proxy: Callable[[HandleBinding], QmodSizedProxy],
+        element_size: int,
+        length: int,
     ) -> None:
-        super().__init__(size)
-        self._name = name
-        self._slice = slice_
-        self._index = index_
+        super().__init__(handle, element_size * length)
+        self._length = length
+        self._element_proxy = element_proxy
+        self._element_size = element_size
 
-    def __getitem__(self, key: Union[slice, int]) -> "QmodQArrayProxy":
+    def __getitem__(self, key: Union[slice, int]) -> "QmodSizedProxy":
         if self._index is not None:
-            raise ClassiqValueError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
+            raise TypeError(QARRAY_ELEMENT_NOT_SUBSCRIPTABLE)
 
         new_index: Optional[int] = None
 
@@ -47,8 +48,14 @@ class QmodQArrayProxy(QmodSizedProxy):
         ] > self._size:
             raise ClassiqValueError(SLICE_OUT_OF_BOUNDS_MSG)
 
+        new_handle = self._get_new_handle(new_index, new_slice)
+        if new_index is not None:
+            return self._element_proxy(new_handle)
         return QmodQArrayProxy(
-            self._name, self._size, slice_=new_slice, index_=new_index
+            new_handle,
+            self._element_proxy,
+            self._element_size,
+            self._length,
         )
 
     def _get_new_slice(self, start: int, end: int) -> Tuple[int, int]:
@@ -61,29 +68,34 @@ class QmodQArrayProxy(QmodSizedProxy):
         return "Quantum array"
 
     @property
-    def index(self) -> Optional[int]:
-        return self._index
+    def _index(self) -> Optional[int]:
+        if not isinstance(self._handle, SubscriptHandleBinding):
+            return None
+        return self._handle.index.to_int_value()
 
     @property
-    def slice(self) -> Optional[Tuple[int, int]]:
-        return self._slice
-
-    @property
-    def handle(self) -> HandleBinding:
-        if self._index is not None:
+    def _slice(self) -> Optional[Tuple[int, int]]:
+        if not isinstance(self._handle, SlicedHandleBinding):
+            return None
+        return self._handle.start.to_int_value(), self._handle.end.to_int_value()
+
+    def _get_new_handle(
+        self, new_index: Optional[int], new_slice: Tuple[int, int]
+    ) -> HandleBinding:
+        if new_index is not None:
             return SubscriptHandleBinding(
-                name=self._name,
-                index=Expression(expr=str(self._index)),
-            )
-
-        if self._slice is not None:
-            return SlicedHandleBinding(
-                name=self._name,
-                start=Expression(expr=str(self._slice[0])),
-                end=Expression(expr=str(self._slice[1])),
+                name=self.handle.name,
+                index=Expression(expr=str(new_index)),
             )
+        return SlicedHandleBinding(
+            name=self.handle.name,
+            start=Expression(expr=str(new_slice[0])),
+            end=Expression(expr=str(new_slice[1])),
+        )
 
-        return HandleBinding(name=self._name)
+    @property
+    def len(self) -> int:
+        return self._length
 
     @property
     def fields(self) -> Mapping[str, Any]:
@@ -91,12 +103,15 @@ class QmodQArrayProxy(QmodSizedProxy):
             "len": self.len,
         }
 
-    def __len__(self) -> int:
-        if (slice_ := self.slice) is not None:
-            return slice_[1] - slice_[0]
-        elif self.index is not None:
-            return 1
-        return self._size
+    @property
+    def size(self) -> int:
+        if (slice_ := self._slice) is not None:
+            length = slice_[1] - slice_[0]
+        elif self._index is not None:
+            length = 1
+        else:
+            length = self._length
+        return length * self._element_size
 
     def __str__(self) -> str:
         return str(self.handle)

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -5,21 +5,21 @@ from sympy import Symbol
 from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
 from classiq.interface.model.handle_binding import HandleBinding
 
+from classiq.exceptions import ClassiqValueError
 
-class QmodQScalarProxy(Symbol, QmodSizedProxy):
-    def __new__(cls, name: str, **assumptions: bool) -> "QmodQScalarProxy":
-        return super().__new__(cls, name, **assumptions)
 
-    def __init__(self, name: str, size: int) -> None:
-        super().__init__(size)
-        self.name = name
+class QmodQScalarProxy(Symbol, QmodSizedProxy):
+    def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
+        return super().__new__(cls, str(handle), **assumptions)
 
-    @property
-    def handle(self) -> HandleBinding:
-        return HandleBinding(name=self.name)
+    def __init__(self, handle: HandleBinding, size: int) -> None:
+        super().__init__(handle, size)
 
 
 class QmodQBitProxy(QmodQScalarProxy):
+    def __init__(self, handle: HandleBinding) -> None:
+        super().__init__(handle, 1)
+
     @property
     def type_name(self) -> str:
         return "Quantum bit"
@@ -27,9 +27,14 @@ class QmodQBitProxy(QmodQScalarProxy):
 
 class QmodQNumProxy(QmodQScalarProxy):
     def __init__(
-        self, name: str, size: int, fraction_digits: int, is_signed: bool
+        self, handle: HandleBinding, size: int, fraction_digits: int, is_signed: bool
     ) -> None:
-        super().__init__(name, size)
+        super().__init__(handle, size)
+        if fraction_digits + is_signed > size:
+            raise ClassiqValueError(
+                f"{'Signed' if is_signed else 'Unsigned'} quantum numeric of size "
+                f"{size} cannot have {fraction_digits} fraction digits"
+            )
         self._fraction_digits = fraction_digits
         self._is_signed = is_signed
 

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,16 +1,16 @@
 from typing import TYPE_CHECKING, Any, Mapping
 
-from classiq.exceptions import ClassiqNotImplementedError
-
 if TYPE_CHECKING:
     from classiq.interface.model.handle_binding import HandleBinding
 
 
 class QmodSizedProxy:
-    def __init__(self, size: int) -> None:
+    def __init__(self, handle: "HandleBinding", size: int) -> None:
+        self._handle = handle
         self._size = size
 
-    def __len__(self) -> int:
+    @property
+    def size(self) -> int:
         return self._size
 
     def __str__(self) -> str:
@@ -22,7 +22,7 @@ class QmodSizedProxy:
 
     @property
     def handle(self) -> "HandleBinding":
-        raise ClassiqNotImplementedError("cannot compute handle")
+        return self._handle
 
     @property
     def len(self) -> int: