classiq 0.89.0__py3-none-any.whl → 0.91.0__py3-none-any.whl

classiq/model_expansions/interpreters/base_interpreter.py

@@ -4,7 +4,7 @@ from collections import defaultdict
 from collections.abc import Sequence
 from contextlib import nullcontext
 from functools import singledispatchmethod
-from typing import Any, cast
+from typing import Any, Callable, cast
 
 from pydantic import ValidationError
 
@@ -16,10 +16,8 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.expressions.atomic_expression_functions import (
-    CLASSICAL_ATTRIBUTES,
-)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
@@ -42,8 +40,20 @@ from classiq.interface.model.quantum_lambda_function import (
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 
-from classiq.evaluators.classical_expression import (
-    evaluate_classical_expression,
+from classiq.evaluators.classical_expression import process_scope_val
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_bwc import (
+    QmodExpressionBwc,
+)
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_evaluator import (
+    evaluate_qmod_expression,
+)
+from classiq.evaluators.qmod_expression_visitors.qmod_expression_simplifier import (
+    simplify_qmod_expression,
+)
+from classiq.evaluators.qmod_node_evaluators.utils import is_classical_integer
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
 )
 from classiq.model_expansions.closure import (
     Closure,
@@ -67,7 +77,6 @@ from classiq.model_expansions.scope_initialization import (
     init_top_level_scope,
 )
 from classiq.model_expansions.utils.counted_name_allocator import CountedNameAllocator
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
 from classiq.qmod.builtins.constants import __all__ as builtin_constants
 from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
 from classiq.qmod.builtins.structs import BUILTIN_STRUCT_DECLARATIONS
@@ -75,7 +84,17 @@ from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.semantics.error_manager import ErrorManager
 from classiq.qmod.semantics.validation.model_validation import validate_model
-from classiq.qmod.utilities import qmod_val_to_expr_str
+
+
+def _validate_index(val: ExpressionValue, subject: str) -> None:
+    if isinstance(val, QmodAnnotatedExpression):
+        val_type = val.get_type(val.root)
+    else:
+        val_type = infer_classical_type(val)
+    if not is_classical_integer(val_type):
+        raise ClassiqExpansionError(
+            f"{subject} indices must be integers, not {val_type.raw_qmod_type_name}"
+        )
 
 
 class BaseInterpreter:
@@ -130,6 +149,12 @@ class BaseInterpreter:
         try:
             with self._error_manager.call("main"):
                 self._expand_main_func()
+        except RecursionError:
+            self._error_manager.add_error(
+                "RecursionError: maximum recursion depth exceeded. Tip: If your "
+                "program contains recursive functions, check for base cases using a "
+                "Python if-statement (instead of Qmod's `if_`)"
+            )
         except Exception as e:
             if isinstance(e, ClassiqInternalExpansionError) or debug_mode.get():
                 raise e
@@ -175,22 +200,56 @@ class BaseInterpreter:
     def evaluate(self, expression: Any) -> Evaluated:
         raise NotImplementedError(f"Cannot evaluate {expression!r}")
 
+    def get_foreign_functions(self) -> dict[str, Callable]:
+        return {}
+
     @evaluate.register
-    def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
-        expr = evaluate_classical_expression(expression, self._builder.current_scope)
-        vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(qmod_val_to_expr_str(expr.value)))
-        for handle in vrc.var_handles:
-            if handle.name in self._builder.current_scope and isinstance(
-                self._builder.current_scope[handle.name].value, QuantumSymbol
-            ):
+    def evaluate_classical_expression(
+        self,
+        expression: Expression,
+        *,
+        simplify: bool = False,
+        treat_qnum_as_float: bool = False,
+    ) -> Evaluated:
+        if expression.is_evaluated():
+            return Evaluated(value=expression.value.value)
+        expr_ast = ast.parse(expression.expr, mode="eval").body
+        expr_ast = QmodExpressionBwc().visit(expr_ast)
+        expr_val = self._eval_expr(ast.unparse(expr_ast), treat_qnum_as_float)
+        if simplify and not expr_val.has_value(expr_val.root):
+            simplified_expr = simplify_qmod_expression(expr_val)
+            expr_val = self._eval_expr(simplified_expr, treat_qnum_as_float)
+        if expr_val.has_value(expr_val.root):
+            value = expr_val.get_value(expr_val.root)
+        else:
+            value = expr_val
+
+        return Evaluated(value=value)
+
+    def _eval_expr(
+        self, expr: str, treat_qnum_as_float: bool
+    ) -> QmodAnnotatedExpression:
+        return evaluate_qmod_expression(
+            expr,
+            treat_qnum_as_float=treat_qnum_as_float,
+            machine_precision=self._model.preferences.machine_precision,
+            classical_struct_declarations=list(QMODULE.type_decls.values()),
+            enum_declarations=list(QMODULE.enum_decls.values()),
+            classical_function_declarations=list(
+                ClassicalFunctionDeclaration.FOREIGN_FUNCTION_DECLARATIONS.values()
+            ),
+            classical_function_callables=self.get_foreign_functions(),
+            scope={
+                name: processed_val
+                for name in list(self._builder.current_scope)
                 if (
-                    isinstance(handle, FieldHandleBinding)
-                    and handle.field in CLASSICAL_ATTRIBUTES
-                ):
-                    handle = handle.base_handle
-                self.evaluate(handle)
-        return expr
+                    processed_val := process_scope_val(
+                        self._builder.current_scope[name].value
+                    )
+                )
+                is not None
+            },
+        )
 
     @evaluate.register
     def evaluate_identifier(self, identifier: str) -> Evaluated:
@@ -216,6 +275,8 @@ class BaseInterpreter:
         )
         start = self.evaluate(sliced_handle_binding.start).value
         end = self.evaluate(sliced_handle_binding.end).value
+        _validate_index(start, "Slice")
+        _validate_index(end, "Slice")
         return Evaluated(value=quantum_variable[start:end])
 
     @evaluate.register
@@ -232,6 +293,7 @@ class BaseInterpreter:
     def evaluate_subscript_operand(self, subscript: OperandIdentifier) -> Evaluated:
         base_value = self.evaluate(subscript.name)
         index_value = self.evaluate(subscript.index).as_type(int)
+        _validate_index(index_value, "Array")
         return Evaluated(value=base_value.value[index_value])
 
     @evaluate.register

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -4,8 +4,6 @@ import os
 from pydantic import ValidationError
 
 from classiq.interface.exceptions import ClassiqError
-from classiq.interface.model.allocate import Allocate
-from classiq.interface.model.bind_operation import BindOperation
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.source_reference import SourceReference
 
@@ -13,8 +11,6 @@ from classiq.model_expansions.closure import FunctionClosure, GenerativeFunction
 from classiq.model_expansions.interpreters.generative_interpreter import (
     GenerativeInterpreter,
 )
-from classiq.model_expansions.quantum_operations import BindEmitter
-from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
@@ -23,12 +19,6 @@ from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
-    def emit_allocate(self, allocate: Allocate) -> None:
-        AllocateEmitter(self, allow_symbolic_attrs=True).emit(allocate)
-
-    def emit_bind(self, bind: BindOperation) -> None:
-        BindEmitter(self, allow_symbolic_size=True).emit(bind)
-
     def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
         DeclarativeQuantumFunctionCallEmitter(self).emit(call)
 
@@ -45,7 +35,7 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
         return super()._get_main_closure(main_func)
 
     def process_exception(self, e: Exception) -> None:
-        if not isinstance(e, (ClassiqError, ValidationError)):
+        if not isinstance(e, (ClassiqError, ValidationError, RecursionError)):
             frame = inspect.trace()[-1]
             module = inspect.getmodule(frame[0])
             if module is None or not module.__name__.startswith("classiq."):

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -11,6 +11,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
     CLASSICAL_IF_OPERATOR_NAME,
     CONTROL_OPERATOR_NAME,
     INVERT_OPERATOR_NAME,
+    POWER_OPERATOR_NAME,
     REPEAT_OPERATOR_NAME,
     WITHIN_APPLY_NAME,
 )
@@ -108,6 +109,7 @@ class GenerativeInterpreter(BaseInterpreter):
         self.infer_symbolic_parameters(
             model.functions, [gen_func.func_decl for gen_func in generative_functions]
         )
+        self._symbolic_parameters_switch = self.allow_symbolic_parameters()
 
     def infer_symbolic_parameters(
         self,
@@ -118,6 +120,9 @@ class GenerativeInterpreter(BaseInterpreter):
     ) -> None:
         pass
 
+    def allow_symbolic_parameters(self) -> bool:
+        return True
+
     def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
         func_decl = NamedParamsQuantumFunctionDeclaration(
             name=self._counted_name_allocator.allocate(
@@ -164,18 +169,28 @@ class GenerativeInterpreter(BaseInterpreter):
         QuantumFunctionCallEmitter(self).emit(call)
 
     @emit.register
-    def _emit_allocate(self, allocate: Allocate) -> None:
-        return self.emit_allocate(allocate)
-
     def emit_allocate(self, allocate: Allocate) -> None:
-        AllocateEmitter(self).emit(allocate)
+        CompositeEmitter[Allocate](
+            self,
+            [
+                ExpressionEvaluator(
+                    self,
+                    "size",
+                    readable_expression_name="allocation size",
+                    allow_link_time_vars=self._symbolic_parameters_switch,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
+                AllocateEmitter(
+                    self, allow_symbolic_attrs=self._symbolic_parameters_switch
+                ),
+            ],
+        ).emit(allocate)
 
     @emit.register
-    def _emit_bind(self, bind: BindOperation) -> None:
-        self.emit_bind(bind)
-
     def emit_bind(self, bind: BindOperation) -> None:
-        BindEmitter(self).emit(bind)
+        BindEmitter(self, allow_symbolic_size=self._symbolic_parameters_switch).emit(
+            bind
+        )
 
     @emit.register
     def emit_amplitude_loading_operation(self, op: AmplitudeLoadingOperation) -> None:
@@ -183,7 +198,14 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(
+                    self,
+                    "expression",
+                    readable_expression_name="amplitude-encoding expression",
+                    simplify=True,
+                    treat_qnum_as_float=True,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
                 AssignmentResultProcessor(self),
             ],
         ).emit(op)
@@ -197,7 +219,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 HandleEvaluator(self, "result_var"),
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(self, "expression", simplify=True),
                 ClassicalVarEmitter(self),
                 AssignmentResultProcessor(self),
             ],
@@ -210,7 +232,7 @@ class GenerativeInterpreter(BaseInterpreter):
             [
                 HandleEvaluator(self, "target"),
                 HandleEvaluator(self, "value"),
-                ExpressionEvaluator(self, "value"),
+                ExpressionEvaluator(self, "value", simplify=True),
             ],
         ).emit(op)
 
@@ -221,14 +243,16 @@ class GenerativeInterpreter(BaseInterpreter):
         VariableDeclarationStatementEmitter(self).emit(variable_declaration)
 
     @emit.register
-    def _emit_classical_if(self, classical_if: ClassicalIf) -> None:
-        self.emit_classical_if(classical_if)
-
     def emit_classical_if(self, classical_if: ClassicalIf) -> None:
         CompositeEmitter[ClassicalIf](
             self,
             [
-                ExpressionEvaluator(self, "condition"),
+                ExpressionEvaluator(
+                    self,
+                    "condition",
+                    readable_expression_name="classical-if condition",
+                    allow_link_time_vars=self._symbolic_parameters_switch,
+                ),
                 IfElimination(self),
                 BlockEvaluator(
                     self,
@@ -276,7 +300,14 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[Control](
             self,
             [
-                ExpressionEvaluator(self, "expression"),
+                ExpressionEvaluator(
+                    self,
+                    "expression",
+                    simplify=True,
+                    readable_expression_name="control expression",
+                    allow_link_time_vars=self._symbolic_parameters_switch,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
                 BlockEvaluator(
                     self,
                     CONTROL_OPERATOR_NAME,
@@ -291,8 +322,13 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[Power](
             self,
             [
-                ExpressionEvaluator(self, "power"),
-                BlockEvaluator(self, CONTROL_OPERATOR_NAME, "body"),
+                ExpressionEvaluator(
+                    self,
+                    "power",
+                    readable_expression_name="power exponent",
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
+                BlockEvaluator(self, POWER_OPERATOR_NAME, "body"),
             ],
         ).emit(power)
 
@@ -301,8 +337,19 @@ class GenerativeInterpreter(BaseInterpreter):
         CompositeEmitter[PhaseOperation](
             self,
             [
-                ExpressionEvaluator(self, "expression"),
-                ExpressionEvaluator(self, "theta"),
+                ExpressionEvaluator(
+                    self,
+                    "expression",
+                    readable_expression_name="phase expression",
+                    simplify=True,
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
+                ExpressionEvaluator(
+                    self,
+                    "theta",
+                    readable_expression_name="phase theta expression",
+                    allow_runtime_vars=self._symbolic_parameters_switch,
+                ),
             ],
         ).emit(phase)
 

classiq/model_expansions/quantum_operations/allocate.py

@@ -1,10 +1,16 @@
-from typing import TYPE_CHECKING, Union
+from typing import TYPE_CHECKING, Any, Union
 
 import sympy
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
 from classiq.interface.exceptions import ClassiqExpansionError, ClassiqValueError
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+from classiq.interface.helpers.text_utils import s
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
 from classiq.interface.model.quantum_type import (
@@ -12,6 +18,8 @@ from classiq.interface.model.quantum_type import (
     QuantumNumeric,
 )
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import get_sympy_type
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
@@ -22,6 +30,13 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
+def _assign_attr(
+    op_update_dict: dict[str, Expression], attr: str, size_value: ExpressionValue
+) -> None:
+    op_update_dict[attr] = Expression(expr=str(size_value))
+    op_update_dict[attr]._evaluated_expr = EvaluatedExpression(value=size_value)
+
+
 class AllocateEmitter(Emitter[Allocate]):
     def __init__(
         self, interpreter: "BaseInterpreter", allow_symbolic_attrs: bool = False
@@ -86,7 +101,7 @@ class AllocateEmitter(Emitter[Allocate]):
             raise ClassiqValueError(
                 f"Could not infer the size of variable {str(target.handle)!r}"
             )
-        op_update_dict["size"] = Expression(expr=expr)
+        op_update_dict["size"] = self._evaluate_expression(Expression(expr=expr))
 
     def _handle_with_size(
         self,
@@ -95,10 +110,10 @@ class AllocateEmitter(Emitter[Allocate]):
         op_update_dict: dict[str, Expression],
     ) -> None:
         size_value = self._interpret_size(size, str(target.handle))
-        op_update_dict["size"] = Expression(expr=str(size_value))
+        _assign_attr(op_update_dict, "size", size_value)
 
         if not isinstance(
-            size_value, sympy.Basic
+            size_value, QmodAnnotatedExpression
         ) and not inject_quantum_type_attributes_inplace(
             QuantumBitvector(length=op_update_dict["size"]), target.quantum_type
         ):
@@ -122,16 +137,19 @@ class AllocateEmitter(Emitter[Allocate]):
             )
 
         size_value = self._interpret_size(size, var_name)
-        op_update_dict["size"] = Expression(expr=str(size_value))
+        _assign_attr(op_update_dict, "size", size_value)
         is_signed_value = self._interpret_is_signed(is_signed)
-        op_update_dict["is_signed"] = Expression(expr=str(is_signed_value))
+        _assign_attr(op_update_dict, "is_signed", is_signed_value)
         fraction_digits_value = self._interpret_fraction_digits(fraction_digits)
-        op_update_dict["fraction_digits"] = Expression(expr=str(fraction_digits_value))
+        _assign_attr(op_update_dict, "fraction_digits", fraction_digits_value)
+        self._validate_numeric_atrributes(
+            var_name, size_value, is_signed_value, fraction_digits_value
+        )
 
         if not (
-            isinstance(size_value, sympy.Basic)
-            or isinstance(is_signed_value, sympy.Basic)
-            or isinstance(fraction_digits_value, sympy.Basic)
+            isinstance(size_value, QmodAnnotatedExpression)
+            or isinstance(is_signed_value, QmodAnnotatedExpression)
+            or isinstance(fraction_digits_value, QmodAnnotatedExpression)
         ) and not inject_quantum_type_attributes_inplace(
             QuantumNumeric(
                 size=op_update_dict["size"],
@@ -145,24 +163,73 @@ class AllocateEmitter(Emitter[Allocate]):
                 f"{var_name!r} of type {target.quantum_type.qmod_type_name}"
             )
 
+    def _validate_numeric_atrributes(
+        self,
+        var_name: str,
+        size_value: Any,
+        is_signed_value: Any,
+        fraction_digits_value: Any,
+    ) -> None:
+        if (
+            isinstance(size_value, int)
+            and isinstance(is_signed_value, bool)
+            and isinstance(fraction_digits_value, int)
+        ):
+            if size_value < 0:
+                raise ClassiqValueError(
+                    f"Cannot allocate {size_value} qubit{s(size_value)} for variable "
+                    f"{var_name!r}"
+                )
+            if fraction_digits_value < 0:
+                raise ClassiqValueError(
+                    f"Variable {var_name!r} cannot have a negative number of fraction "
+                    f"digits (got {fraction_digits_value})"
+                )
+            if size_value < fraction_digits_value:
+                raise ClassiqValueError(
+                    f"Cannot allocate {size_value} qubit{s(size_value)} for variable "
+                    f"{var_name!r} with {fraction_digits_value} fraction digits"
+                )
+
     def _interpret_size(
         self, size: Expression, var_name: str
-    ) -> Union[int, float, sympy.Basic]:
+    ) -> Union[int, float, sympy.Basic, QmodAnnotatedExpression]:
         size_value = self._interpreter.evaluate(size).value
-        if not self._allow_symbolic_attrs and not isinstance(size_value, (int, float)):
-            if size.expr == f"{var_name}.size":
-                raise ClassiqValueError(
-                    f"Could not infer the size of variable {var_name!r}"
-                )
+        if not (
+            (
+                isinstance(size_value, QmodAnnotatedExpression)
+                and isinstance(size_value.get_type(size_value.root), (Integer, Real))
+            )
+            or isinstance(size_value, (int, float))
+            or (
+                isinstance(size_value, sympy.Basic)
+                and isinstance(get_sympy_type(size_value), (Integer, Real))
+            )
+        ):
             raise ClassiqValueError(
                 f"The number of allocated qubits must be an integer. Got "
                 f"{str(size_value)!r}"
             )
+        if (
+            isinstance(size_value, QmodAnnotatedExpression)
+            and not self._allow_symbolic_attrs
+        ):
+            raise ClassiqValueError(
+                f"Could not infer the size of variable {var_name!r}"
+            )
         return size_value
 
-    def _interpret_is_signed(self, is_signed: Expression) -> Union[bool, sympy.Basic]:
+    def _interpret_is_signed(
+        self, is_signed: Expression
+    ) -> Union[bool, sympy.Basic, QmodAnnotatedExpression]:
         is_signed_value = self._interpreter.evaluate(is_signed).value
-        if not self._allow_symbolic_attrs and not isinstance(is_signed_value, bool):
+        if not self._allow_symbolic_attrs and not (
+            isinstance(is_signed_value, bool)
+            or (
+                isinstance(is_signed_value, sympy.Basic)
+                and isinstance(get_sympy_type(is_signed_value), Bool)
+            )
+        ):
             raise ClassiqValueError(
                 f"The sign of a variable must be boolean. Got "
                 f"{str(is_signed_value)!r}"
@@ -171,10 +238,14 @@ class AllocateEmitter(Emitter[Allocate]):
 
     def _interpret_fraction_digits(
         self, fraction_digits: Expression
-    ) -> Union[int, float, sympy.Basic]:
+    ) -> Union[int, float, sympy.Expr, QmodAnnotatedExpression]:
         fraction_digits_value = self._interpreter.evaluate(fraction_digits).value
-        if not self._allow_symbolic_attrs and not isinstance(
-            fraction_digits_value, (int, float)
+        if not self._allow_symbolic_attrs and not (
+            isinstance(fraction_digits_value, (int, float))
+            or (
+                isinstance(fraction_digits_value, sympy.Expr)
+                and fraction_digits_value.is_integer
+            )
         ):
             raise ClassiqValueError(
                 f"The fraction digits of a variable must be an integer. Got "

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -1,7 +1,6 @@
 from typing import TYPE_CHECKING, Optional
 
 from classiq.interface.exceptions import ClassiqExpansionError
-from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
@@ -20,23 +19,31 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
     QuantumAssignmentOperation,
 )
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+)
 from classiq.interface.model.statement_block import StatementBlock
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes_inplace,
 )
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_assign,
+)
 from classiq.model_expansions.quantum_operations.arithmetic.explicit_boolean_expressions import (
     convert_assignment_bool_expression,
     validate_assignment_bool_expression,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
 from classiq.model_expansions.scope import ClassicalSymbol
-from classiq.model_expansions.transformers.ast_renamer import rename_variables
 from classiq.qmod.builtins.functions.standard_gates import CX
 
 if TYPE_CHECKING:
@@ -100,33 +107,27 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     def _infer_expression_type(
         self, op: ArithmeticOperation
-    ) -> Optional[QuantumNumeric]:
+    ) -> Optional[QuantumScalar]:
         expr = self._evaluate_expression(op.expression)
-        if len(self._get_classical_vars_in_expression(expr)):
-            return None
-
-        symbols = self._get_symbols_in_expression(expr)
-        if any(not symbol.quantum_type.is_instantiated for symbol in symbols):
+        expr_val = expr.value.value
+        if isinstance(expr_val, QmodAnnotatedExpression):
+            root_type = expr_val.get_type(expr_val.root)
+            if isinstance(root_type, QuantumScalar) and root_type.is_instantiated:
+                root_type = compute_result_attrs_assign(
+                    NumericAttributes.from_type_or_constant(root_type),
+                    self._machine_precision,
+                ).to_quantum_numeric()
+                return root_type
             return None
-
-        expr_str = rename_variables(
-            expr.expr,
-            {str(symbol.handle): symbol.handle.identifier for symbol in symbols}
-            | {symbol.handle.qmod_expr: symbol.handle.identifier for symbol in symbols},
-        )
-        for symbol in symbols:
-            expr_str = expr_str.replace(
-                symbol.handle.qmod_expr, symbol.handle.identifier
-            )
-        return compute_arithmetic_result_type(
-            expr_str,
-            {symbol.handle.identifier: symbol.quantum_type for symbol in symbols},
-            self._machine_precision,
-        )
+        if isinstance(expr_val, (int, float)):
+            return NumericAttributes.from_constant(
+                expr_val, self._machine_precision
+            ).to_quantum_numeric()
+        return None
 
     @staticmethod
     def _same_numeric_attributes(
-        result_type: QuantumNumeric, expression_type: QuantumNumeric
+        result_type: QuantumNumeric, expression_type: QuantumScalar
     ) -> bool:
         return (
             result_type.size_in_bits == expression_type.size_in_bits
@@ -137,7 +138,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
 
     @classmethod
     def _validate_declared_attributes(
-        cls, result_type: QuantumNumeric, expression_type: QuantumNumeric, var: str
+        cls, result_type: QuantumNumeric, expression_type: QuantumScalar, var: str
     ) -> None:
         result_size, result_sign, result_fractions = (
             result_type.size_in_bits,
@@ -183,7 +184,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
         self,
         op: ArithmeticOperation,
         result_type: QuantumNumeric,
-        expression_type: QuantumNumeric,
+        expression_type: QuantumScalar,
     ) -> None:
         stmts: StatementBlock = []
         handles: list[HandleBinding] = []