classiq 0.77.0__py3-none-any.whl → 0.79.0__py3-none-any.whl

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -18,6 +18,7 @@ from classiq.interface.generator.expressions.proxies.classical.any_classical_val
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
     ClassicalArrayProxy,
+    ClassicalSequenceProxy,
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
     ClassicalProxy,
@@ -39,6 +40,7 @@ from classiq.interface.generator.functions.classical_type import (
     Bool,
     ClassicalArray,
     ClassicalList,
+    ClassicalTuple,
     ClassicalType,
     OpaqueHandle,
     QmodPyObject,
@@ -46,6 +48,7 @@ from classiq.interface.generator.functions.classical_type import (
     StructMetaType,
 )
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.helpers.backward_compatibility import zip_strict
 
 from classiq.model_expansions.model_tables import (
     HandleIdentifier,
@@ -92,6 +95,15 @@ def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
         if isinstance(val, list):
             return [qmod_val_to_python(elem, qmod_type.element_type) for elem in val]
 
+    elif isinstance(qmod_type, ClassicalTuple):
+        if isinstance(val, list):
+            return [
+                qmod_val_to_python(elem, elem_type)
+                for elem_type, elem in zip_strict(
+                    qmod_type.element_types, val, strict=True
+                )
+            ]
+
     elif isinstance(qmod_type, OpaqueHandle):
         if isinstance(val, HandleIdentifier):
             return HandleTable.get_handle_object(val)
@@ -133,7 +145,7 @@ def python_val_to_qmod(val: Any, qmod_type: ClassicalType) -> ExpressionValue:
             field_name: python_val_to_qmod(val[field_name], field_type)
             for field_name, field_type in struct_decl.variables.items()
         }
-        return QmodStructInstance(struct_decl, qmod_dict)
+        return QmodStructInstance(struct_decl.model_copy(), qmod_dict)
 
     if isinstance(qmod_type, ClassicalList):
         if not isinstance(val, list):
@@ -162,7 +174,7 @@ def python_call_wrapper(func: Callable, *args: ExpressionValue) -> Any:
 
 def struct_literal(struct_type_symbol: Symbol, **kwargs: Any) -> QmodStructInstance:
     return QmodStructInstance(
-        QMODULE.type_decls[struct_type_symbol.name],
+        QMODULE.type_decls[struct_type_symbol.name].model_copy(),
         {field: sympy_to_python(field_value) for field, field_value in kwargs.items()},
     )
 
@@ -236,7 +248,7 @@ def _is_qmod_value(val: Any) -> bool:
 
 
 def do_subscript(value: Any, index: Any) -> Any:
-    if not isinstance(value, (list, ClassicalArrayProxy)) or not isinstance(
+    if not isinstance(value, (list, ClassicalSequenceProxy)) or not isinstance(
         index, QmodQNumProxy
     ):
         if isinstance(index, (QmodSizedProxy, QmodStructInstance)):
@@ -260,7 +272,7 @@ def do_subscript(value: Any, index: Any) -> Any:
             "Quantum numeric subscript must be an unsigned integer (is_signed=False, "
             "fraction_digits=0)"
         )
-    if isinstance(value, ClassicalArrayProxy):
+    if isinstance(value, ClassicalSequenceProxy):
         length = value.length
     else:
         length = len(value)
@@ -269,7 +281,7 @@ def do_subscript(value: Any, index: Any) -> Any:
             f"Quantum numeric subscript size mismatch: The quantum numeric has "
             f"{index.size} qubits but the list size is {length} != 2**{index.size}"
         )
-    if isinstance(value, ClassicalArrayProxy):
+    if isinstance(value, ClassicalSequenceProxy):
         return AnyClassicalValue(
             f"do_subscript({qmod_val_to_expr_str(value)}, {qmod_val_to_expr_str(index)})"
         )
@@ -289,7 +301,9 @@ def do_slice(value: Any, lower: Any, upper: Any) -> Any:
 
 
 def do_sum(val: Any) -> Any:
-    if isinstance(val, AnyClassicalValue):
+    if (isinstance(val, sympy.Basic) and len(val.free_symbols) > 0) or (
+        isinstance(val, ClassicalArrayProxy) and not isinstance(val.length, int)
+    ):
         return AnyClassicalValue(f"sum({val})")
     return sum(val)
 

classiq/model_expansions/closure.py

@@ -1,22 +1,11 @@
 import dataclasses
-import json
-from collections.abc import Collection, Sequence
+from collections.abc import Sequence
 from dataclasses import dataclass, field
-from functools import singledispatch
 from typing import Any, Optional
 
 from typing_extensions import Self
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.expressions.proxies.classical.classical_proxy import (
-    ClassicalProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
-    ClassicalStructProxy,
-)
-from classiq.interface.generator.expressions.proxies.classical.utils import (
-    get_proxy_type,
-)
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
@@ -27,10 +16,7 @@ from classiq.interface.model.quantum_statement import QuantumStatement
 
 from classiq.model_expansions.capturing.captured_vars import CapturedVars
 from classiq.model_expansions.scope import (
-    Evaluated,
-    QuantumSymbol,
     Scope,
-    evaluated_to_str as evaluated_classical_param_to_str,
 )
 from classiq.qmod.builtins.functions import permute
 from classiq.qmod.quantum_function import GenerativeQFunc
@@ -67,13 +53,6 @@ class FunctionClosure(Closure):
             raise ClassiqInternalExpansionError
         return self._depth
 
-    # creates a unique id for the function closure based on the arguments values.
-    # The closure is changing across the interpreter flow so it's closure_id may change
-    @property
-    def closure_id(self) -> str:
-        signature = _generate_closure_id(self.scope.data.values())
-        return f"{self.name}__{signature}"
-
     @property
     def body(self) -> Sequence[QuantumStatement]:
         if self.name == permute.func_decl.name:
@@ -134,39 +113,3 @@ class FunctionClosure(Closure):
 @dataclass(frozen=True)
 class GenerativeFunctionClosure(GenerativeClosure, FunctionClosure):
     pass
-
-
-def _generate_closure_id(evaluated_args: Collection[Evaluated]) -> str:
-    args_signature = [
-        _evaluated_arg_to_str(eval_arg.value) for eval_arg in evaluated_args
-    ]
-    return json.dumps(args_signature)
-
-
-@singledispatch
-def _evaluated_arg_to_str(arg: Any) -> str:
-    if isinstance(arg, str):
-        return arg
-    if isinstance(arg, QuantumSymbol):
-        return _evaluated_quantum_symbol_to_str(arg)
-    if isinstance(arg, FunctionClosure):
-        return _evaluated_one_operand_to_str(arg)
-    if isinstance(arg, list) and arg and isinstance(arg[0], FunctionClosure):
-        return _evaluated_operands_list_to_str(arg)
-    if isinstance(arg, ClassicalProxy):
-        if isinstance(arg, ClassicalStructProxy):
-            return repr(arg.struct_declaration)
-        return repr(get_proxy_type(arg))
-    return evaluated_classical_param_to_str(arg)
-
-
-def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
-    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
-
-
-def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:
-    return operand.closure_id
-
-
-def _evaluated_operands_list_to_str(arg: list[FunctionClosure]) -> str:
-    return json.dumps([_evaluated_one_operand_to_str(ope) for ope in arg])

classiq/model_expansions/evaluators/argument_types.py

@@ -3,8 +3,10 @@ from collections.abc import Sequence
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.port_declaration import AnonPortDeclaration
 from classiq.interface.model.quantum_function_declaration import AnonPositionalArg
+from classiq.interface.model.quantum_type import QuantumNumeric
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.scope import Evaluated, QuantumVariable
@@ -13,7 +15,7 @@ from classiq.model_expansions.scope import Evaluated, QuantumVariable
 def add_information_from_output_arguments(
     parameters: Sequence[AnonPositionalArg],
     args: list[Evaluated],
-) -> list[Evaluated]:
+) -> None:
     """
     This function propagates the quantum type information from the output arguments
     to the arguments that were passed to it.
@@ -40,4 +42,21 @@ def add_information_from_output_arguments(
                 argument_as_quantum_symbol.quantum_type,
                 str(argument_as_quantum_symbol),
             )
-    return args
+
+
+def handle_args_numeric_bounds(
+    parameters: Sequence[AnonPositionalArg],
+    args: list[Evaluated],
+) -> None:
+    for parameter, argument in zip(parameters, args):
+        if not isinstance(parameter, AnonPortDeclaration):
+            continue
+
+        argument_as_quantum_symbol = argument.as_type(QuantumVariable)
+
+        if (
+            parameter.direction != PortDeclarationDirection.Output
+            and parameter.type_qualifier != TypeQualifier.Const
+            and isinstance(argument_as_quantum_symbol.quantum_type, QuantumNumeric)
+        ):
+            argument_as_quantum_symbol.quantum_type.reset_bounds()

classiq/model_expansions/evaluators/classical_type_inference.py

@@ -1,11 +1,12 @@
-from typing import Any, Union
+from typing import TYPE_CHECKING, Any, Union
 
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
     AnyClassicalValue,
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_array_proxy import (
-    ClassicalArrayProxy,
+    ClassicalSequenceProxy,
+    _is_int,
 )
 from classiq.interface.generator.expressions.proxies.classical.classical_struct_proxy import (
     ClassicalStructProxy,
@@ -16,6 +17,7 @@ from classiq.interface.generator.expressions.proxies.classical.qmod_struct_insta
 from classiq.interface.generator.functions.classical_type import (
     ClassicalArray,
     ClassicalList,
+    ClassicalTuple,
     ClassicalType,
 )
 from classiq.interface.generator.functions.type_name import TypeName
@@ -26,7 +28,7 @@ from classiq.interface.helpers.backward_compatibility import zip_strict
 def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalType:
     if isinstance(classical_type, TypeName):
         return _infer_classical_struct_type(val, classical_type)
-    if isinstance(classical_type, (ClassicalArray, ClassicalList)):
+    if isinstance(classical_type, (ClassicalArray, ClassicalList, ClassicalTuple)):
         return _infer_classical_array_type(val, classical_type)
     return classical_type
 
@@ -34,7 +36,11 @@ def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalTy
 def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> ClassicalType:
     if not isinstance(val, (QmodStructInstance, ClassicalStructProxy)):
         return classical_type
-    decl = val.struct_declaration
+    if classical_type.is_enum:
+        raise ClassiqExpansionError(
+            f"{classical_type.type_name!r} expected, got {str(val)!r}"
+        )
+    decl = classical_type.classical_struct_decl
     new_fields = {
         field_name: infer_classical_type(field_val, field_type)
         for (field_name, field_val), field_type in zip_strict(
@@ -51,9 +57,9 @@ def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> Classica
 
 
 def _infer_classical_array_type(
-    val: Any, classical_type: Union[ClassicalArray, ClassicalList]
+    val: Any, classical_type: Union[ClassicalArray, ClassicalList, ClassicalTuple]
 ) -> ClassicalType:
-    if isinstance(val, ClassicalArrayProxy):
+    if isinstance(val, ClassicalSequenceProxy):
         val_length = val.length
     elif isinstance(val, list):
         val_length = len(val)
@@ -62,7 +68,7 @@ def _infer_classical_array_type(
     else:
         raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
     if (
-        isinstance(classical_type, ClassicalArray)
+        isinstance(classical_type, (ClassicalArray, ClassicalTuple))
         and isinstance(val_length, int)
         and isinstance(classical_type.size, int)
         and val_length != classical_type.size
@@ -71,11 +77,34 @@ def _infer_classical_array_type(
             f"Type mismatch: Argument has {val_length} items but "
             f"{classical_type.size} expected"
         )
-    return ClassicalArray(
-        element_type=(
-            infer_classical_type(val[0], classical_type.element_type)
-            if not isinstance(val_length, int) or val_length > 0
-            else classical_type.element_type
+    new_classical_type = _infer_inner_array_types(classical_type, val, val_length)
+    if classical_type.is_generative:
+        new_classical_type.set_generative()
+    return new_classical_type
+
+
+def _infer_inner_array_types(
+    classical_type: ClassicalType, val: Any, val_length: Any
+) -> ClassicalType:
+    if isinstance(classical_type, (ClassicalArray, ClassicalList)):
+        if _is_int(val_length) and val_length != 0:
+            return ClassicalTuple(
+                element_types=(
+                    infer_classical_type(val[i], classical_type.element_type)
+                    for i in range(int(val_length))
+                ),
+            )
+        element_type: ClassicalType
+        if val_length == 0:
+            element_type = classical_type.element_type
+        else:
+            element_type = infer_classical_type(val[0], classical_type.element_type)
+        return ClassicalArray(element_type=element_type, size=val_length)
+    if TYPE_CHECKING:
+        assert isinstance(classical_type, ClassicalTuple)
+    return ClassicalTuple(
+        element_types=(
+            infer_classical_type(val[idx], element_type)
+            for idx, element_type in enumerate(classical_type.element_types)
         ),
-        size=val_length,
     )

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -38,6 +38,7 @@ def copy_type_information(
                 expr=str(from_type.fraction_digits_value)
             )
         set_size(to_type, from_type.size_in_bits, to_param_name)
+        set_bounds(from_type, to_type)
     elif isinstance(to_type, QuantumBitvector):
         if isinstance(from_type, QuantumBitvector) and type(  # noqa: E721
             from_type.element_type
@@ -146,16 +147,20 @@ def set_length_by_size(
     quantum_array.length = Expression(expr=str(size // element_size))
 
 
-def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
+def validate_bind_targets(
+    bind: BindOperation, scope: Scope, allow_symbolic_size: bool
+) -> None:
     illegal_qnum_bind_targets = []
     for out_handle in bind.out_handles:
         out_var = scope[out_handle.name].as_type(QuantumSymbol)
         out_var_type = out_var.quantum_type
         if not isinstance(out_var_type, QuantumNumeric):
             continue
-        if not out_var_type.has_size_in_bits:
+        if (allow_symbolic_size and not out_var_type.is_instantiated) or (
+            not allow_symbolic_size and not out_var_type.has_size_in_bits
+        ):
             illegal_qnum_bind_targets.append(str(out_var.handle))
-        elif not out_var_type.has_sign:
+        elif not allow_symbolic_size and not out_var_type.has_sign:
             assert not out_var_type.has_fraction_digits
             illegal_qnum_bind_targets.append(str(out_var.handle))
     if len(illegal_qnum_bind_targets) > 0:
@@ -187,3 +192,26 @@ def is_signature_monomorphic(params: Sequence[PositionalArg]) -> bool:
         isinstance(param, PortDeclaration) and param.quantum_type.is_evaluated
         for param in params
     )
+
+
+def set_bounds(from_type: QuantumType, to_type: QuantumNumeric) -> None:
+    if not isinstance(from_type, QuantumNumeric):
+        to_type.reset_bounds()
+        return
+
+    if from_type.is_evaluated and to_type.is_evaluated:
+        same_attributes = to_type.sign_value == from_type.sign_value and (
+            to_type.fraction_digits_value == from_type.fraction_digits_value
+        )
+    else:
+        same_attributes = (
+            (from_type.is_signed is not None and from_type.fraction_digits is not None)
+            and (to_type.is_signed is not None and to_type.fraction_digits is not None)
+            and (to_type.is_signed.expr == from_type.is_signed.expr)
+            and (to_type.fraction_digits.expr == from_type.fraction_digits.expr)
+        )
+
+    if same_attributes:
+        to_type.set_bounds(from_type.get_bounds())
+    else:
+        to_type.reset_bounds()

classiq/model_expansions/function_builder.py

@@ -11,15 +11,12 @@ from classiq.interface.generator.compiler_keywords import (
 from classiq.interface.generator.functions.builtins.internal_operators import (
     WITHIN_APPLY_NAME,
 )
-from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.model import MAIN_FUNCTION_NAME
 from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
-from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     PositionalArg,
-    QuantumOperandDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
@@ -215,7 +212,6 @@ class OperationBuilder:
         self, function_context: FunctionContext, params: Sequence[PositionalArg]
     ) -> NativeFunctionDefinition:
         name = self._get_expanded_function_name(function_context)
-        self._override_type_qualifier(function_context, params)
 
         return NativeFunctionDefinition(
             name=name,
@@ -248,44 +244,3 @@ class OperationBuilder:
             raise ClassiqInternalExpansionError("Could not allocate function name")
 
         return name
-
-    def _override_type_qualifier(
-        self, function_context: FunctionContext, params: Sequence[PositionalArg]
-    ) -> None:
-        """
-        The type qualifier can be changed according to the operand passed to the
-        function. For example,
-        apply_to_all(X, q) --> q will be QFree after expansion
-        apply_to_all(H, q) --> q will be Quantum after expansion
-        This also holds for the intermediate lambda created during the expansion.
-
-        We don't override the type qualifier if it's explicitly specified (QFree or
-        Const), neither in the function declaration nor in the operand declaration.
-        """
-
-        if function_context.is_lambda:
-            self._update_type_qualifiers(params)
-            return
-
-        orig_name = function_context.name
-        if orig_name == MAIN_FUNCTION_NAME or orig_name not in self.current_scope:
-            return
-
-        orig_func = self.current_scope[orig_name].value
-        if not any(
-            isinstance(param_decl, QuantumOperandDeclaration)
-            for param_decl in orig_func.positional_arg_declarations
-        ):
-            return
-
-        self._update_type_qualifiers(params)
-
-    @staticmethod
-    def _update_type_qualifiers(params: Sequence[PositionalArg]) -> None:
-        # only override the qualifier if it's unspecified (not QFree or Const)
-        for param in params:
-            if (
-                isinstance(param, PortDeclaration)
-                and param.type_qualifier is TypeQualifier.Quantum
-            ):
-                param.type_qualifier = TypeQualifier.Inferred

classiq/model_expansions/generative_functions.py

@@ -114,7 +114,7 @@ def translate_ast_arg_to_python_qmod(param: PositionalArg, value: Any) -> Any:
         return [QTerminalCallable(inner_decl, index_=idx) for idx in range(len(value))]
     if (
         isinstance(value, QmodStructInstance)
-        and param.classical_type.is_purely_declarative
+        and not param.classical_type.is_purely_generative
     ):
         classical_type = Struct(name=value.struct_declaration.name)
         classical_type.set_classical_struct_decl(value.struct_declaration)

classiq/model_expansions/interpreters/base_interpreter.py

@@ -104,10 +104,8 @@ class BaseInterpreter:
             main_closure.positional_arg_declarations, main_closure
         )
         context = self._expand_operation(main_closure)
-        self._expanded_functions[main_closure.closure_id] = (
-            self._builder.create_definition(
-                cast(FunctionContext, context), main_closure.positional_arg_declarations
-            )
+        self._expanded_functions[main_closure.name] = self._builder.create_definition(
+            cast(FunctionContext, context), main_closure.positional_arg_declarations
         )
 
     def _get_main_closure(self, main_func: FunctionClosure) -> FunctionClosure:
@@ -275,19 +273,19 @@ class BaseInterpreter:
 
     def _expand_operation(self, operation: Closure) -> OperationContext:
         with self._builder.operation_context(operation) as context:
-            if isinstance(operation, FunctionClosure) and (
-                (func_def := self._expanded_functions.get(operation.closure_id))
-                is not None
-            ):
-                cached_closure = self._top_level_scope[func_def.name].value
-                operation.captured_vars.set(
-                    cached_closure.captured_vars, cached_closure, operation
-                )
-            else:
-                self._expand_body(operation)
+            self._expand_body(operation)
 
         return context
 
+    def _expand_cached_function(
+        self, operation: FunctionClosure, func_def: NativeFunctionDefinition
+    ) -> None:
+        with self._builder.operation_context(operation):
+            cached_closure = self._top_level_scope[func_def.name].value
+            operation.captured_vars.set(
+                cached_closure.captured_vars, cached_closure, operation
+            )
+
     def _expand_body(self, operation: Closure) -> None:
         for block, block_body in operation.blocks.items():
             self._expand_block(block_body, block)

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -1,17 +1,12 @@
 import inspect
 import os
-from typing import Optional
 
 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.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
-from classiq.interface.model.quantum_function_declaration import (
-    NamedParamsQuantumFunctionDeclaration,
-)
 from classiq.interface.source_reference import SourceReference
 
 from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
@@ -24,22 +19,10 @@ from classiq.model_expansions.quantum_operations.quantum_function_call import (
     DeclarativeQuantumFunctionCallEmitter,
 )
 from classiq.model_expansions.scope import Scope
-from classiq.model_expansions.visitors.symbolic_param_inference import (
-    SymbolicParamInference,
-)
 from classiq.qmod.model_state_container import QMODULE
 
 
 class FrontendGenerativeInterpreter(GenerativeInterpreter):
-    def infer_symbolic_parameters(
-        self,
-        functions: list[NativeFunctionDefinition],
-        additional_signatures: Optional[
-            list[NamedParamsQuantumFunctionDeclaration]
-        ] = None,
-    ) -> None:
-        SymbolicParamInference(functions, additional_signatures).infer()
-
     def emit_allocate(self, allocate: Allocate) -> None:
         AllocateEmitter(self, allow_symbolic_size=True).emit(allocate)
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -15,6 +15,7 @@ from classiq.interface.generator.functions.builtins.internal_operators import (
 )
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.bounds import SetBoundsStatement
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.control import Control
 from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
@@ -66,6 +67,7 @@ from classiq.model_expansions.quantum_operations.block_evaluator import (
     IfElimination,
     RepeatElimination,
 )
+from classiq.model_expansions.quantum_operations.bounds import SetBoundsEmitter
 from classiq.model_expansions.quantum_operations.composite_emitter import (
     CompositeEmitter,
 )
@@ -297,6 +299,13 @@ class GenerativeInterpreter(BaseInterpreter):
             ],
         ).emit(phase)
 
+    @emit.register
+    def emit_set_bounds(self, op: SetBoundsStatement) -> None:
+        CompositeEmitter[SetBoundsStatement](
+            self,
+            [HandleEvaluator(self, "target"), SetBoundsEmitter(self)],
+        ).emit(op)
+
     def _expand_body(self, operation: Closure) -> None:
         if isinstance(operation, FunctionClosure) and operation.name == "permute":
             # special expansion since permute is generative

classiq/model_expansions/quantum_operations/__init__.py

@@ -1,4 +1,7 @@
 from classiq.model_expansions.quantum_operations.bind import BindEmitter
+from classiq.model_expansions.quantum_operations.bounds import (
+    SetBoundsEmitter,
+)
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     QuantumFunctionCallEmitter,
 )

classiq/model_expansions/quantum_operations/allocate.py

@@ -10,7 +10,7 @@ from classiq.interface.generator.expressions.proxies.classical.any_classical_val
 )
 from classiq.interface.model.allocate import Allocate
 from classiq.interface.model.handle_binding import NestedHandleBinding
-from classiq.interface.model.quantum_type import QuantumBitvector
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
 
 from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
 from classiq.model_expansions.quantum_operations.emitter import Emitter
@@ -38,6 +38,8 @@ class AllocateEmitter(Emitter[Allocate]):
             )
 
         size_expr = self._get_var_size(target, allocate.size)
+        if isinstance(target.quantum_type, QuantumNumeric):
+            target.quantum_type.set_bounds((0, 0))
         allocate = allocate.model_copy(
             update=dict(
                 size=Expression(expr=size_expr),

classiq/model_expansions/quantum_operations/assignment_result_processor.py

@@ -37,15 +37,17 @@ from classiq.qmod.builtins.functions.standard_gates import CX
 
 class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
     def emit(self, op: QuantumAssignmentOperation, /) -> bool:
+        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        result_type = result_symbol.quantum_type
+
         if not (
             isinstance(op, ArithmeticOperation)
             and op.operation_kind == ArithmeticOperationKind.Assignment
         ):
+            if isinstance(result_type, QuantumNumeric):
+                result_type.reset_bounds()
             return False
 
-        result_symbol = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
-        result_type = result_symbol.quantum_type
-
         validate_assignment_bool_expression(
             result_symbol, op.expression.expr, op.operation_kind
         )
@@ -69,6 +71,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             result_type, inferred_result_type, str(op.result_var)
         )
         self._assign_to_inferred_var_and_bind(op, result_type, inferred_result_type)
+        result_type.set_bounds(inferred_result_type.get_bounds())
         return True
 
     def _infer_result_type(self, op: ArithmeticOperation) -> Optional[QuantumNumeric]:
@@ -105,6 +108,7 @@ class AssignmentResultProcessor(Emitter[QuantumAssignmentOperation]):
             result_type.fraction_digits = Expression(
                 expr=str(inferred_result_type.fraction_digits_value)
             )
+        result_type.set_bounds(inferred_result_type.get_bounds())
 
     @staticmethod
     def _same_numeric_attributes(

classiq/model_expansions/quantum_operations/bind.py

@@ -1,3 +1,4 @@
+from itertools import chain
 from typing import TYPE_CHECKING
 
 from classiq.interface.exceptions import (
@@ -5,6 +6,7 @@ from classiq.interface.exceptions import (
     ClassiqInternalExpansionError,
 )
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.quantum_type import QuantumNumeric
 
 from classiq.model_expansions.evaluators.parameter_types import (
     evaluate_types_in_quantum_symbols,
@@ -29,8 +31,13 @@ class BindEmitter(Emitter[BindOperation]):
 
     def emit(self, bind: BindOperation, /) -> bool:
         inputs, outputs = self._get_inputs_outputs(bind)
-        validate_bind_targets(bind, self._current_scope)
+        validate_bind_targets(bind, self._current_scope, self._allow_symbolic_size)
         self._process_var_sizes(bind, inputs, outputs)
+
+        for symbol in chain(inputs, outputs):
+            if isinstance(symbol.quantum_type, QuantumNumeric):
+                symbol.quantum_type.reset_bounds()
+
         self.emit_statement(
             BindOperation(
                 in_handles=bind.in_handles,