classiq 0.78.0__py3-none-any.whl → 0.79.1__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/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
@@ -40,3 +42,21 @@ def add_information_from_output_arguments(
                 argument_as_quantum_symbol.quantum_type,
                 str(argument_as_quantum_symbol),
             )
+
+
+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/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/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,

classiq/model_expansions/quantum_operations/bounds.py

@@ -0,0 +1,30 @@
+from typing import TYPE_CHECKING
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.model.bounds import SetBoundsStatement
+
+from classiq.model_expansions.quantum_operations.bind import Emitter
+from classiq.model_expansions.scope import QuantumSymbol
+from classiq.qmod.qmod_variable import QuantumNumeric
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+
+
+class SetBoundsEmitter(Emitter[SetBoundsStatement]):
+    def __init__(
+        self, interpreter: "BaseInterpreter", keep_statement: bool = True
+    ) -> None:
+        super().__init__(interpreter)
+        self._keep_statement = keep_statement
+
+    def emit(self, op: SetBoundsStatement, /) -> bool:
+        target = self._interpreter.evaluate(op.target).as_type(QuantumSymbol)
+        if not isinstance(target.quantum_type, QuantumNumeric):
+            raise ClassiqExpansionError(
+                f"Cannot set bounds of a non-numeric variable {op.target.qmod_expr!r}"
+            )
+        target.quantum_type.set_bounds(op.bounds)
+        if self._keep_statement:
+            self.emit_statement(op)
+        return True

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -29,6 +29,7 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -55,6 +56,7 @@ from classiq.model_expansions.capturing.captured_vars import (
 from classiq.model_expansions.closure import Closure, FunctionClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
+    handle_args_numeric_bounds,
 )
 from classiq.model_expansions.evaluators.parameter_types import (
     evaluate_parameter_types_from_args,
@@ -81,6 +83,7 @@ from classiq.model_expansions.transformers.type_qualifier_inference import (
 )
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.model_expansions.utils.text_utils import are, readable_list, s
+from classiq.qmod.pretty_print.expression_to_python import transform_expression
 from classiq.qmod.semantics.validation.signature_validation import (
     validate_function_signature,
 )
@@ -123,6 +126,24 @@ def _is_symbolic(arg: Any) -> bool:
     return False
 
 
+def _validate_gen_args(
+    function: FunctionClosure, evaluated_args: list[Evaluated]
+) -> None:
+    for param, arg in zip_strict(
+        function.positional_arg_declarations, evaluated_args, strict=True
+    ):
+        if (
+            isinstance(param, ClassicalParameterDeclaration)
+            and param.classical_type.is_purely_generative
+            and _is_symbolic(arg.value)
+        ):
+            raise ClassiqExpansionError(
+                f"Parameter {param.name!r} is used in a compile-time expression "
+                f"context but is passed a runtime expression "
+                f"{transform_expression(str(arg.value), {}, {}, one_line=True)!r}"
+            )
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
@@ -187,6 +208,9 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 function.name, new_declaration
             )
         else:
+            # FIXME: enable for BE (CLS-2390)
+            if type(self._interpreter).__name__ == "FrontendGenerativeInterpreter":
+                _validate_gen_args(function, evaluated_args)
             new_declaration = self._expand_function(
                 evaluated_args, new_declaration, function
             )
@@ -198,10 +222,20 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             ]
 
         add_information_from_output_arguments(new_positional_arg_decls, evaluated_args)
-        new_positional_args = [arg.emit() for arg in evaluated_args]
+        handle_args_numeric_bounds(new_positional_arg_decls, evaluated_args)
         captured_args = function.captured_vars.filter_vars(function).get_captured_args(
             self._builder.current_function
         )
+        new_positional_args = [
+            arg.emit(param)
+            for param, arg in zip_strict(
+                new_positional_arg_decls[
+                    : len(new_positional_arg_decls) - len(captured_args)
+                ],
+                evaluated_args,
+                strict=True,
+            )
+        ]
         validate_args_are_not_propagated(
             new_positional_args,
             captured_args,
@@ -240,9 +274,11 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         decl: NamedParamsQuantumFunctionDeclaration,
         function: FunctionClosure,
     ) -> NamedParamsQuantumFunctionDeclaration:
-        self._add_params_to_scope(decl.positional_arg_declarations, args, function)
+        inferred_args = self._add_params_to_scope(
+            decl.positional_arg_declarations, args, function
+        )
         function = function.with_new_declaration(decl)
-        cache_key = get_func_call_cache_key(decl, args)
+        cache_key = get_func_call_cache_key(decl, inferred_args)
         if cache_key in self._expanded_functions:
             function_def = self._expanded_functions[cache_key]
             self._expand_cached_function(function, function_def)
@@ -305,12 +341,13 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         parameters: Sequence[PositionalArg],
         arguments: Sequence[Evaluated],
         closure: FunctionClosure,
-    ) -> None:
+    ) -> list[Evaluated]:
+        inferred_args: list[Evaluated] = []
         for parameter, argument in zip(parameters, arguments):
             param_handle = HandleBinding(name=parameter.name)
             if isinstance(argument.value, QuantumVariable):
                 assert isinstance(parameter, PortDeclaration)
-                closure.scope[parameter.name] = Evaluated(
+                inferred_arg = Evaluated(
                     QuantumSymbol(
                         handle=param_handle,
                         quantum_type=parameter.quantum_type,
@@ -319,12 +356,15 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 )
             elif _is_symbolic(argument.value):
                 assert isinstance(parameter, ClassicalParameterDeclaration)
-                closure.scope[parameter.name] = Evaluated(
+                inferred_arg = Evaluated(
                     value=parameter.classical_type.get_classical_proxy(param_handle),
                     defining_function=closure,
                 )
             else:
-                closure.scope[parameter.name] = argument
+                inferred_arg = argument
+            closure.scope[parameter.name] = inferred_arg
+            inferred_args.append(inferred_arg)
+        return inferred_args
 
     def _prepare_fully_typed_declaration(
         self, function: FunctionClosure, evaluated_args: list[Evaluated]

classiq/model_expansions/quantum_operations/function_calls_cache.py

@@ -18,6 +18,7 @@ from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
+from classiq.interface.model.quantum_type import QuantumNumeric
 
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.scope import (
@@ -73,7 +74,13 @@ def _evaluated_arg_to_str(arg: Any) -> str:
 
 
 def _evaluated_quantum_symbol_to_str(port: QuantumSymbol) -> str:
-    return port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+    res = port.quantum_type.model_dump_json(exclude_none=True, exclude={"name"})
+    if (
+        isinstance(port.quantum_type, QuantumNumeric)
+        and (bounds := port.quantum_type.get_bounds()) is not None
+    ):
+        res += f"_{float(bounds[0])}_{float(bounds[1])}"
+    return res
 
 
 def _evaluated_one_operand_to_str(operand: FunctionClosure) -> str:

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -1,10 +1,9 @@
 from typing import TYPE_CHECKING
 
+import sympy
+
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.classical_scalar_proxy import (
-    ClassicalScalarProxy,
-)
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_lambda_function import OperandIdentifier
@@ -29,7 +28,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
     def emit(self, call: QuantumFunctionCall, /) -> bool:
         if isinstance(call.function, OperandIdentifier):
             index_val = self._interpreter.evaluate(call.function.index).value
-            if isinstance(index_val, ClassicalScalarProxy):
+            if isinstance(index_val, sympy.Basic):
                 return self._emit_symbolic_lambda_list(call, index_val)
         function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
         args = call.positional_args
@@ -40,7 +39,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
         return True
 
     def _emit_symbolic_lambda_list(
-        self, call: QuantumFunctionCall, index: ClassicalScalarProxy
+        self, call: QuantumFunctionCall, index: sympy.Basic
     ) -> bool:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)
@@ -55,7 +54,7 @@ class QuantumFunctionCallEmitter(CallEmitter[QuantumFunctionCall]):
 
     @staticmethod
     def _create_recursive_if(
-        call: QuantumFunctionCall, index: ClassicalScalarProxy, num_funcs: int
+        call: QuantumFunctionCall, index: sympy.Basic, num_funcs: int
     ) -> list[QuantumStatement]:
         if TYPE_CHECKING:
             assert isinstance(call.function, OperandIdentifier)