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

classiq/evaluators/qmod_node_evaluators/struct_instantiation_evaluation.py

@@ -0,0 +1,66 @@
+import ast
+from typing import cast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.text_utils import readable_list, s
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.compare_evaluation import (
+    comparison_allowed,
+)
+from classiq.evaluators.qmod_node_evaluators.utils import get_qmod_type_name
+
+
+def eval_struct_instantiation(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, decl: StructDeclaration
+) -> None:
+    if len(node.args) > 0 or any(kwarg.arg is None for kwarg in node.keywords):
+        raise ClassiqExpansionError(
+            "Classical structs must be instantiated using keyword arguments"
+        )
+
+    field_assignments = {cast(str, kwarg.arg): kwarg.value for kwarg in node.keywords}
+    assigned_fields = list(field_assignments)
+    expected_fields = list(decl.variables)
+    if set(assigned_fields) != set(expected_fields):
+        raise ClassiqExpansionError(
+            f"Struct {decl.name} has field{s(expected_fields)} "
+            f"{readable_list(expected_fields, quote=True)} but was instantiated "
+            f"using the field{s(assigned_fields)} "
+            f"{readable_list(assigned_fields, quote=True)}"
+        )
+
+    for field_name, field_value in field_assignments.items():
+        assignment_type = expr_val.get_type(field_value)
+        expected_type = decl.variables[field_name]
+        if not comparison_allowed(assignment_type, expected_type):
+            raise ClassiqExpansionError(
+                f"Cannot assign value of type {get_qmod_type_name(assignment_type)} "
+                f"to field {field_name!r} of type {get_qmod_type_name(expected_type)}"
+            )
+
+    classical_type = Struct(name=decl.name)
+    classical_type.set_classical_struct_decl(decl)
+    expr_val.set_type(node, classical_type)
+
+    if any(
+        not expr_val.has_value(field_value)
+        for field_value in field_assignments.values()
+    ):
+        return
+
+    struct_val = QmodStructInstance(
+        decl,
+        {
+            field_name: expr_val.get_value(field_value)
+            for field_name, field_value in field_assignments.items()
+        },
+    )
+    expr_val.set_value(node, struct_val)

classiq/evaluators/qmod_node_evaluators/subscript_evaluation.py

@@ -0,0 +1,225 @@
+import ast
+from typing import Optional, cast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.arith.arithmetic import (
+    aggregate_numeric_types,
+    compute_arithmetic_result_type,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalTuple,
+    Integer,
+    Real,
+)
+from classiq.interface.model.handle_binding import (
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+    register_info_to_quantum_type,
+)
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    element_types,
+    get_qmod_type_name,
+    qnum_is_qint,
+)
+
+
+def _eval_slice(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
+    subject = node.value
+    slice_ = cast(ast.Slice, node.slice)
+    start = cast(ast.AST, slice_.lower)
+    stop = cast(ast.AST, slice_.upper)
+    if slice_.step is not None:
+        raise ClassiqExpansionError("Slice step is not supported")
+
+    start_type = expr_val.get_type(start)
+    stop_type = expr_val.get_type(stop)
+    for index_type in (start_type, stop_type):
+        if not isinstance(index_type, Integer):
+            raise ClassiqExpansionError(
+                f"Slice indices must be integers, not {get_qmod_type_name(index_type)!r}"
+            )
+
+    start_val: Optional[int] = None
+    if expr_val.has_value(start):
+        start_val = cast(int, expr_val.get_value(start))
+        if start_val < 0:
+            raise ClassiqExpansionError("Slice indices must be positive integers")
+    stop_val: Optional[int] = None
+    if expr_val.has_value(stop):
+        stop_val = cast(int, expr_val.get_value(stop))
+        if start_val is not None and stop_val < start_val:
+            raise ClassiqExpansionError(
+                "Slice upper bound must be greater or equal to the lower bound"
+            )
+
+    subject_type = expr_val.get_type(subject)
+    slice_type: QmodType
+    if isinstance(subject_type, ClassicalArray):
+        if subject_type.has_length and (
+            (start_val is not None and start_val >= subject_type.length_value)
+            or (stop_val is not None and stop_val > subject_type.length_value)
+        ):
+            raise ClassiqExpansionError("Array index out of range")
+        length_expr: Optional[Expression] = None
+        if start_val is not None and stop_val is not None:
+            length_expr = Expression(expr=str(stop_val - start_val))
+        slice_type = ClassicalArray(
+            element_type=subject_type.element_type, length=length_expr
+        )
+    elif isinstance(subject_type, ClassicalTuple):
+        if start_val is not None and stop_val is not None:
+            if start_val >= len(subject_type.element_types) or stop_val > len(
+                subject_type.element_types
+            ):
+                raise ClassiqExpansionError("Array index out of range")
+            slice_type = ClassicalTuple(
+                element_types=subject_type.element_types[start_val:stop_val]
+            )
+        else:
+            slice_type = subject_type.get_raw_type()
+    elif isinstance(subject_type, QuantumBitvector):
+        if start_val is not None and stop_val is not None:
+            if subject_type.has_length and (
+                start_val >= subject_type.length_value
+                or stop_val > subject_type.length_value
+            ):
+                raise ClassiqExpansionError("Array index out of range")
+            slice_length = Expression(expr=str(stop_val - start_val))
+        else:
+            slice_length = None
+        slice_type = QuantumBitvector(
+            element_type=subject_type.element_type, length=slice_length
+        )
+    else:
+        raise ClassiqExpansionError(
+            f"{get_qmod_type_name(subject_type)} is not subscriptable"
+        )
+    expr_val.set_type(node, slice_type)
+
+    if start_val is None or stop_val is None:
+        return
+    if expr_val.has_value(subject):
+        subject_val = expr_val.get_value(subject)
+        expr_val.set_value(node, subject_val[start_val:stop_val])
+    elif expr_val.has_var(subject):
+        subject_var = expr_val.get_var(subject)
+        expr_val.set_var(
+            node,
+            SlicedHandleBinding(
+                base_handle=subject_var,
+                start=Expression(expr=str(start_val)),
+                end=Expression(expr=str(stop_val)),
+            ),
+        )
+        expr_val.remove_var(subject)
+
+
+def _eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
+    subject = node.value
+    subscript = node.slice
+
+    index_type = expr_val.get_type(subscript)
+    if not isinstance(index_type, Integer):
+        raise ClassiqExpansionError(
+            f"Array indices must be integers or slices, not {get_qmod_type_name(index_type)}"
+        )
+
+    sub_val: Optional[int] = None
+    if expr_val.has_value(subscript):
+        sub_val = cast(int, expr_val.get_value(subscript))
+        if sub_val < 0:
+            raise ClassiqExpansionError("Array indices must be positive integers")
+
+    subject_type = expr_val.get_type(subject)
+    sub_type: QmodType
+    if isinstance(subject_type, (ClassicalArray, QuantumBitvector)):
+        if (
+            sub_val is not None
+            and subject_type.has_length
+            and sub_val >= subject_type.length_value
+        ):
+            raise ClassiqExpansionError("Array index out of range")
+        sub_type = subject_type.element_type
+    elif isinstance(subject_type, ClassicalTuple):
+        if sub_val is not None:
+            if sub_val >= len(subject_type.element_types):
+                raise ClassiqExpansionError("Array index out of range")
+            sub_type = subject_type.element_types[sub_val]
+        else:
+            raw_subject_type = subject_type.get_raw_type()
+            if not isinstance(raw_subject_type, ClassicalArray):
+                raise ClassiqInternalExpansionError
+            sub_type = raw_subject_type.element_type
+    else:
+        raise ClassiqExpansionError(
+            f"{get_qmod_type_name(subject_type)} is not subscriptable"
+        )
+    expr_val.set_type(node, sub_type)
+
+    if sub_val is None:
+        return
+    if expr_val.has_value(subject):
+        subject_val = expr_val.get_value(subject)
+        expr_val.set_value(node, subject_val[sub_val])
+    elif expr_val.has_var(subject):
+        subject_var = expr_val.get_var(subject)
+        expr_val.set_var(
+            node,
+            SubscriptHandleBinding(
+                base_handle=subject_var, index=Expression(expr=str(sub_val))
+            ),
+        )
+        expr_val.remove_var(subject)
+
+
+def eval_subscript(expr_val: QmodAnnotatedExpression, node: ast.Subscript) -> None:
+    if isinstance(node.slice, ast.Slice):
+        _eval_slice(expr_val, node)
+    else:
+        _eval_subscript(expr_val, node)
+
+
+def eval_quantum_subscript(
+    expr_val: QmodAnnotatedExpression, node: ast.Subscript, machine_precision: int
+) -> None:
+    subject = node.value
+    subscript = node.slice
+
+    index_type = cast(QuantumType, expr_val.get_type(subscript))
+    if not qnum_is_qint(index_type):
+        raise ClassiqExpansionError("Quantum indices must be unsigned quantum numerics")
+    subject_type = expr_val.get_type(subject)
+    if not isinstance(subject_type, (ClassicalArray, ClassicalTuple)) or not all(
+        isinstance(element_type, (Integer, Real))
+        for element_type in element_types(subject_type)
+    ):
+        raise ClassiqExpansionError(
+            "Only classical numeric arrays may have quantum subscripts"
+        )
+
+    expr_val.set_quantum_subscript(node, subject, subscript)
+    if not expr_val.has_value(subject):
+        expr_val.set_type(node, QuantumNumeric())
+        return
+
+    items = expr_val.get_value(subject)
+    numeric_types = [
+        compute_arithmetic_result_type(str(num), {}, machine_precision) for num in items
+    ]
+    unified_numeric_type = register_info_to_quantum_type(
+        aggregate_numeric_types(numeric_types)
+    )
+    expr_val.set_type(node, unified_numeric_type)

classiq/evaluators/qmod_node_evaluators/unary_op_evaluation.py

@@ -0,0 +1,58 @@
+import ast
+from typing import Any
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.generator.functions.type_name import TypeName
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.bool_op_evaluation import is_bool_type
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_numeric_type
+
+
+def unary_op_allowed(op: ast.AST, operand_type: QmodType) -> bool:
+    if isinstance(op, ast.Not):
+        return is_bool_type(operand_type)
+    return is_numeric_type(operand_type)
+
+
+def eval_unary_op(expr_val: QmodAnnotatedExpression, node: ast.UnaryOp) -> None:
+    operand = node.operand
+    op = node.op
+
+    operand_type = expr_val.get_type(operand)
+    if not unary_op_allowed(op, operand_type):
+        expected_val_type = "Boolean" if isinstance(op, ast.Not) else "scalar"
+        raise ClassiqExpansionError(
+            f"The operand of the unary operator {type(op).__name__!r} must be "
+            f"a {expected_val_type} value"
+        )
+    if isinstance(op, ast.Invert) and isinstance(operand_type, Real):
+        raise ClassiqExpansionError(
+            f"Operation {type(op).__name__!r} on a real value is not supported"
+        )
+    op_type: QmodType
+    if isinstance(operand_type, TypeName):
+        op_type = Integer()
+    else:
+        op_type = operand_type
+    expr_val.set_type(node, op_type)
+
+    if not expr_val.has_value(operand):
+        return
+    operand_value = expr_val.get_value(operand)
+    constant_value: Any
+    if isinstance(op, ast.Not):
+        constant_value = not operand_value
+    elif isinstance(op, ast.Invert):
+        constant_value = ~operand_value
+    elif isinstance(op, ast.UAdd):
+        constant_value = +operand_value
+    elif isinstance(op, ast.USub):
+        constant_value = -operand_value
+    else:
+        raise ClassiqInternalExpansionError
+    expr_val.set_value(node, constant_value)

classiq/evaluators/qmod_node_evaluators/utils.py

@@ -0,0 +1,80 @@
+from typing import Any, Optional, Union, cast
+
+import sympy
+
+from classiq.interface.generator.functions.classical_type import (
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumNumeric,
+    QuantumScalar,
+    QuantumType,
+)
+
+QmodType = Union[ClassicalType, QuantumType]
+IntegerValueType = int
+RealValueType = Union[float, complex]
+NumberValueType = Union[IntegerValueType, RealValueType]
+SYMPY_SYMBOLS = {sym: getattr(sympy, sym) for sym in sympy.__all__}
+
+
+def get_qmod_type_name(type_: Any) -> str:
+    return getattr(type_, "type_name", type(type_).__name__)
+
+
+def is_classical_type(qmod_type: QmodType) -> bool:
+    if isinstance(qmod_type, TypeName):
+        return qmod_type.has_classical_struct_decl or qmod_type.is_enum
+    return isinstance(qmod_type, ClassicalType)
+
+
+def qnum_is_qbit(qmod_type: QuantumNumeric) -> bool:
+    return (
+        (not qmod_type.has_size_in_bits or qmod_type.size_in_bits == 1)
+        and (not qmod_type.has_sign or not qmod_type.sign_value)
+        and (not qmod_type.has_fraction_digits or qmod_type.fraction_digits_value == 0)
+    )
+
+
+def qnum_is_qint(qmod_type: QuantumType) -> bool:
+    return isinstance(qmod_type, QuantumBit) or (
+        isinstance(qmod_type, QuantumNumeric)
+        and (not qmod_type.has_sign or not qmod_type.sign_value)
+        and (not qmod_type.has_fraction_digits or qmod_type.fraction_digits_value == 0)
+    )
+
+
+def element_types(
+    classical_type: Union[ClassicalArray, ClassicalTuple],
+) -> list[ClassicalType]:
+    if isinstance(classical_type, ClassicalArray):
+        return [classical_type.element_type]
+    return cast(list[ClassicalType], classical_type.element_types)
+
+
+def array_len(
+    classical_type: Union[ClassicalArray, ClassicalTuple],
+) -> Optional[int]:
+    if isinstance(classical_type, ClassicalTuple):
+        return len(classical_type.element_types)
+    if classical_type.has_length:
+        return classical_type.length_value
+    return None
+
+
+def is_numeric_type(qmod_type: QmodType) -> bool:
+    return isinstance(qmod_type, (Integer, Real, QuantumScalar)) or (
+        isinstance(qmod_type, TypeName) and qmod_type.is_enum
+    )
+
+
+def is_classical_integer(qmod_type: QmodType) -> bool:
+    return isinstance(qmod_type, Integer) or (
+        isinstance(qmod_type, TypeName) and qmod_type.is_enum
+    )

classiq/execution/execution_session.py

@@ -504,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.85.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/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