classiq 0.75.0__py3-none-any.whl → 0.76.0__py3-none-any.whl

classiq/interface/model/quantum_lambda_function.py

@@ -5,6 +5,7 @@ import pydantic
 from classiq.interface.ast_node import ASTNode
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.quantum_function_declaration import (
     AnonQuantumOperandDeclaration,
 )
@@ -56,7 +57,7 @@ class QuantumLambdaFunction(ASTNode):
     def named_func_decl(self) -> AnonQuantumOperandDeclaration:
         named_params = [
             param.rename(rename)
-            for param, rename in zip(
+            for param, rename in zip_strict(
                 self.func_decl.positional_arg_declarations,
                 self.pos_rename_params,
                 strict=False,  # strict=False enables lambda keyword args

classiq/interface/server/routes.py

@@ -6,6 +6,8 @@ CONVERSION_PREFIX = "/conversion"
 PROVIDERS_PREFIX = "/providers"
 
 IQCC_PREFIX = PROVIDERS_PREFIX + "/iqcc"
+USER_BUDGETS_PREFIX = "/user_budgets"
+
 
 ANALYZER_CIRCUIT_PAGE = "circuit"
 DEFAULT_IDE_FE_APP = "https://platform.classiq.io/"
@@ -50,6 +52,7 @@ TASK_TEST_SUFFIX = TASKS_SUFFIX + "/test"
 TASK_PREDICT_SUFFIX = TASKS_SUFFIX + "/predict"
 TASK_RB_SUFFIX = TASKS_SUFFIX + RB
 TASKS_GENERATE_FULL_PATH = TASKS_GENERATE_SUFFIX
+TASKS_VISUAL_MODEL_FULL_PATH = ANALYZER_PREFIX + TASKS_VISUAL_MODEL_SUFFIX
 
 EXECUTION_JOBS_SUFFIX = "/jobs"
 EXECUTION_JOBS_FULL_PATH = EXECUTION_PREFIX + EXECUTION_JOBS_SUFFIX
@@ -80,3 +83,6 @@ IQCC_LIST_AUTH_METHODS_SUFFIX = "/auth_methods"
 IQCC_LIST_AUTH_METHODS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_METHODS_SUFFIX
 IQCC_LIST_AUTH_TARGETS_SUFFIX = "/auth_targets"
 IQCC_LIST_AUTH_TARGETS_FULL_PATH = IQCC_PREFIX + IQCC_LIST_AUTH_TARGETS_SUFFIX
+
+USER_BUDGETS_SUFFIX = "/all"
+USER_BUDGETS_FULL_PATH = USER_BUDGETS_PREFIX + USER_BUDGETS_SUFFIX

classiq/model_expansions/atomic_expression_functions_defs.py

@@ -2,6 +2,7 @@ from collections.abc import Mapping
 from enum import Enum
 from typing import Any, Callable, Union, get_args
 
+import sympy
 from sympy import Eq, Expr, Piecewise, Symbol
 
 from classiq.interface.exceptions import (
@@ -56,6 +57,8 @@ from classiq.model_expansions.sympy_conversion.arithmetics import (
     BitwiseOr,
     BitwiseXor,
     LogicalXor,
+    LShift,
+    RShift,
 )
 from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
     MISSING_SLICE_VALUE_PLACEHOLDER,
@@ -63,11 +66,12 @@ from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
 from classiq.model_expansions.sympy_conversion.sympy_to_python import (
     sympy_to_python,
 )
-from classiq.model_expansions.utils.sympy_utils import (
-    is_constant_subscript,
-    unwrap_sympy_numeric,
+from classiq.model_expansions.utils.sympy_utils import is_constant_subscript
+from classiq.qmod.builtins.classical_functions import (
+    __all__ as qmod_classical_functions,
 )
 from classiq.qmod.model_state_container import QMODULE
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 
 def qmod_val_to_python(val: ExpressionValue, qmod_type: ClassicalType) -> Any:
@@ -169,19 +173,14 @@ def get_field(
     ],
     field: str,
 ) -> ExpressionValue:
-    if isinstance(proxy, AnyClassicalValue):
-        return AnyClassicalValue(f"({proxy}).{field}")
-    if isinstance(proxy, type) and issubclass(proxy, Enum):
-        return getattr(proxy, field)
-    if (
+    if isinstance(proxy, AnyClassicalValue) or (
         isinstance(proxy, Symbol)
         and not isinstance(proxy, QmodSizedProxy)
         and not isinstance(proxy, ClassicalProxy)
     ):
-        raise ClassiqExpansionError(
-            f"Cannot evaluate '{proxy}.{field}': Variable {str(proxy)!r} is not "
-            f"initialized"
-        )
+        return AnyClassicalValue(f"get_field({qmod_val_to_expr_str(proxy)}, '{field}')")
+    if isinstance(proxy, type) and issubclass(proxy, Enum):
+        return getattr(proxy, field)
     if isinstance(proxy, list):
         if field != "len":
             raise ClassiqExpansionError(
@@ -217,9 +216,10 @@ def get_type(struct_type: Symbol) -> TypeProxy:
 
 
 def do_div(lhs: Any, rhs: Any) -> Any:
-    lhs = unwrap_sympy_numeric(lhs)
-    rhs = unwrap_sympy_numeric(rhs)
-    return lhs / rhs
+    res = lhs / rhs
+    if isinstance(res, sympy.Expr):
+        res = res.evalf()
+    return res
 
 
 _EXPRESSION_TYPES = get_args(ExpressionValue)
@@ -253,7 +253,7 @@ def do_subscript(value: Any, index: Any) -> Any:
             and not is_constant_subscript(index)
             and _is_qmod_value(index)
         ):
-            return AnyClassicalValue(str(value))[index]
+            return AnyClassicalValue(qmod_val_to_expr_str(value))[index]
         return value[index]
     if index.is_signed or index.fraction_digits > 0:
         raise ClassiqExpansionError(
@@ -270,7 +270,9 @@ def do_subscript(value: Any, index: Any) -> Any:
             f"{index.size} qubits but the list size is {length} != 2**{index.size}"
         )
     if isinstance(value, ClassicalArrayProxy):
-        return AnyClassicalValue(f"{value}[{index}]")
+        return AnyClassicalValue(
+            f"do_subscript({qmod_val_to_expr_str(value)}, {qmod_val_to_expr_str(index)})"
+        )
     else:
         return Piecewise(
             *[(item, Eq(index, idx)) for idx, item in enumerate(value[:-1])],
@@ -286,9 +288,29 @@ def do_slice(value: Any, lower: Any, upper: Any) -> Any:
     return do_subscript(value, slice(lower, upper))
 
 
+def do_sum(val: Any) -> Any:
+    if isinstance(val, AnyClassicalValue):
+        return AnyClassicalValue(f"sum({val})")
+    return sum(val)
+
+
+do_sum.__name__ = "sum"
+
+
+def mod_inverse(a: Any, b: Any) -> Any:
+    if (
+        isinstance(a, AnyClassicalValue)
+        or (isinstance(a, sympy.Basic) and len(a.free_symbols) > 0)
+        or isinstance(b, AnyClassicalValue)
+        or (isinstance(b, sympy.Basic) and len(b.free_symbols) > 0)
+    ):
+        return AnyClassicalValue(f"mod_inverse({a}, {b})")
+    return sympy.mod_inverse(a, b)
+
+
 CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     print,
-    sum,
+    do_sum,
     struct_literal,
     get_field,
     get_type,
@@ -300,8 +322,29 @@ CORE_LIB_FUNCTIONS_LIST: list[Callable] = [
     BitwiseNot,
     BitwiseOr,
     LogicalXor,
+    RShift,
+    LShift,
+    mod_inverse,
+]
+
+
+def _symbolic_function(func: str) -> Callable:
+    def wrapper(*args: Any) -> AnyClassicalValue:
+        return AnyClassicalValue(
+            f"{func}({', '.join(map(qmod_val_to_expr_str, args))})"
+        )
+
+    wrapper.__name__ = func
+    return wrapper
+
+
+QMOD_CLASSICAL_FUNCTIONS = [
+    _symbolic_function(func) for func in qmod_classical_functions
 ]
 
 ATOMIC_EXPRESSION_FUNCTIONS = {
-    **{core_func.__name__: core_func for core_func in CORE_LIB_FUNCTIONS_LIST},
+    **{
+        core_func.__name__: core_func
+        for core_func in CORE_LIB_FUNCTIONS_LIST + QMOD_CLASSICAL_FUNCTIONS
+    },
 }

classiq/model_expansions/capturing/captured_vars.py

@@ -15,6 +15,7 @@ from classiq.interface.generator.functions.classical_type import ClassicalType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -132,6 +133,7 @@ class _CapturedHandle(_Captured):
             name=self.mangled_name,
             quantum_type=self.quantum_type,
             direction=self.direction.dump(),
+            type_qualifier=TypeQualifier.Inferred,  # TODO https://classiq.atlassian.net/browse/CLS-1830
         )
 
     def is_same_var(self, other: "_CapturedHandle") -> bool:

classiq/model_expansions/closure.py

@@ -17,6 +17,7 @@ from classiq.interface.generator.expressions.proxies.classical.classical_struct_
 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,
     PositionalArg,
@@ -43,6 +44,10 @@ class Closure:
     positional_arg_declarations: Sequence[PositionalArg] = tuple()
     captured_vars: CapturedVars = field(default_factory=CapturedVars)
 
+    @property
+    def parameters_dict(self) -> dict[str, PositionalArg]:
+        return nameables_to_dict(self.positional_arg_declarations)
+
 
 @dataclass(frozen=True)
 class GenerativeClosure(Closure):

classiq/model_expansions/evaluators/classical_type_inference.py

@@ -1,6 +1,9 @@
 from typing import 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,
 )
@@ -17,6 +20,7 @@ from classiq.interface.generator.functions.classical_type import (
 )
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.helpers.backward_compatibility import zip_strict
 
 
 def infer_classical_type(val: Any, classical_type: ClassicalType) -> ClassicalType:
@@ -33,7 +37,7 @@ def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> Classica
     decl = val.struct_declaration
     new_fields = {
         field_name: infer_classical_type(field_val, field_type)
-        for (field_name, field_val), field_type in zip(
+        for (field_name, field_val), field_type in zip_strict(
             val.fields.items(),
             decl.variables.values(),
             strict=True,
@@ -49,13 +53,20 @@ def _infer_classical_struct_type(val: Any, classical_type: TypeName) -> Classica
 def _infer_classical_array_type(
     val: Any, classical_type: Union[ClassicalArray, ClassicalList]
 ) -> ClassicalType:
-    if isinstance(val, list):
-        val_length = len(val)
-    elif isinstance(val, ClassicalArrayProxy):
+    if isinstance(val, ClassicalArrayProxy):
         val_length = val.length
+    elif isinstance(val, list):
+        val_length = len(val)
+    elif isinstance(val, AnyClassicalValue):
+        return classical_type
     else:
         raise ClassiqExpansionError(f"Array expected, got {str(val)!r}")
-    if isinstance(classical_type, ClassicalArray) and val_length != classical_type.size:
+    if (
+        isinstance(classical_type, ClassicalArray)
+        and isinstance(val_length, int)
+        and isinstance(classical_type.size, int)
+        and val_length != classical_type.size
+    ):
         raise ClassiqExpansionError(
             f"Type mismatch: Argument has {val_length} items but "
             f"{classical_type.size} expected"
@@ -63,7 +74,7 @@ def _infer_classical_array_type(
     return ClassicalArray(
         element_type=(
             infer_classical_type(val[0], classical_type.element_type)
-            if val_length > 0
+            if not isinstance(val_length, int) or val_length > 0
             else classical_type.element_type
         ),
         size=val_length,

classiq/model_expansions/evaluators/parameter_types.py

@@ -1,10 +1,15 @@
-from typing import TypeVar, Union
+from typing import Optional, TypeVar, Union
+
+import sympy
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
 from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
+    AnyClassicalValue,
+)
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
@@ -178,7 +183,8 @@ def _evaluate_qarray_in_quantum_symbol(
             "length",
             param_name,
         )
-        set_length(type_to_update, new_length)
+        if new_length is not None:
+            set_length(type_to_update, new_length)
     return type_to_update
 
 
@@ -194,7 +200,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "sign",
             param_name,
         )
-        type_to_update.is_signed = Expression(expr=str(new_is_sign))
+        if new_is_sign is not None:
+            type_to_update.is_signed = Expression(expr=str(new_is_sign))
     if type_to_update.fraction_digits is not None:
         new_fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
@@ -204,7 +211,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "fraction digits",
             param_name,
         )
-        type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
+        if new_fraction_digits is not None:
+            type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     if type_to_update.size is not None:
         new_size = _eval_expr(
             type_to_update.size,
@@ -214,7 +222,8 @@ def _evaluate_qnum_in_quantum_symbol(
             "size",
             param_name,
         )
-        set_size(type_to_update, new_size, param_name)
+        if new_size is not None:
+            set_size(type_to_update, new_size, param_name)
     return type_to_update
 
 
@@ -228,17 +237,21 @@ def _eval_expr(
     type_name: str,
     attr_name: str,
     param_name: str,
-) -> _EXPR_TYPE:
+) -> Optional[_EXPR_TYPE]:
     val = evaluate_classical_expression(expression, scope).value
     if expected_type is int and isinstance(val, float):
         val = int(val)
-    if not isinstance(val, expected_type):
-        raise ClassiqExpansionError(
-            f"When inferring the type of parameter {param_name!r}: "
-            f"{type_name} {attr_name} must be {expected_type.__name__}, got "
-            f"{str(val)!r}"
-        )
-    return val
+    if isinstance(val, expected_type):
+        return val
+    if isinstance(val, AnyClassicalValue) or (
+        isinstance(val, sympy.Basic) and len(val.free_symbols) > 0
+    ):
+        return None
+    raise ClassiqExpansionError(
+        f"When inferring the type of parameter {param_name!r}: "
+        f"{type_name} {attr_name} must be {expected_type.__name__}, got "
+        f"{str(val)!r}"
+    )
 
 
 def _evaluate_qstruct_in_quantum_symbol(

classiq/model_expansions/expression_evaluator.py

@@ -73,7 +73,7 @@ def evaluate(
     try:
         sympify_result = sympify(sympy_expr, locals=model_locals)
     except (TypeError, IndexError) as e:
-        raise ClassiqExpansionError(str(e)) from None
+        raise ClassiqExpansionError(str(e)) from e
     except AttributeError as e:
         if isinstance(e.obj, EnumMeta):
             raise ClassiqExpansionError(

classiq/model_expansions/generative_functions.py

@@ -16,7 +16,7 @@ from classiq.interface.generator.expressions.proxies.classical.utils import (
     get_proxy_type,
 )
 from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.helpers.datastructures import get_sdk_compatible_python_object
+from classiq.interface.helpers.datastructures import LenList
 from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -31,16 +31,18 @@ from classiq.model_expansions.closure import (
     FunctionClosure,
     GenerativeClosure,
 )
-from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+from classiq.model_expansions.scope import Evaluated
 from classiq.qmod.generative import generative_mode_context, set_frontend_interpreter
 from classiq.qmod.model_state_container import QMODULE
 from classiq.qmod.qmod_parameter import CParamStruct, create_param
-from classiq.qmod.qmod_variable import _create_qvar_for_qtype
+from classiq.qmod.qmod_variable import QScalar, _create_qvar_for_qtype
 from classiq.qmod.quantum_expandable import (
     QTerminalCallable,
 )
 from classiq.qmod.quantum_function import QFunc
 from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.symbolic_expr import SymbolicExpr, SymbolicSubscriptAndField
+from classiq.qmod.utilities import qmod_val_to_expr_str
 
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.generative_interpreter import (
@@ -65,36 +67,61 @@ def _unwrap_traceback_frame(e: Exception) -> Exception:
     return e.with_traceback(back_tb)
 
 
-def translate_ast_arg_to_python_qmod(param: PositionalArg, evaluated: Evaluated) -> Any:
-    if isinstance(param, PortDeclaration):
-        quantum_symbol = evaluated.as_type(QuantumSymbol)
-        return _create_qvar_for_qtype(
-            quantum_symbol.quantum_type, quantum_symbol.handle
+class SymbolicList(LenList):
+    def __getitem__(self, index: Any) -> Any:
+        if isinstance(index, (QScalar, SymbolicExpr)) or (
+            isinstance(index, slice)
+            and any(
+                isinstance(slice_part, (QScalar, SymbolicExpr))
+                for slice_part in (index.start, index.stop, index.step)
+            )
+        ):
+            return SymbolicSubscriptAndField(
+                qmod_val_to_expr_str(self), is_quantum=False
+            )[index]
+        try:
+            return super().__getitem__(index)
+        except (IndexError, TypeError) as e:
+            raise _unwrap_traceback_frame(e) from None
+
+
+def translate_classical_ast_arg_to_python_qmod(value: Any) -> Any:
+    if isinstance(value, QmodStructInstance):
+        return QmodStructInstance(
+            value.struct_declaration,
+            {
+                field_name: translate_classical_ast_arg_to_python_qmod(field_value)
+                for field_name, field_value in value.fields.items()
+            },
         )
+    if isinstance(value, list):
+        return SymbolicList(
+            [translate_classical_ast_arg_to_python_qmod(item) for item in value]
+        )
+    if isinstance(value, ClassicalProxy):
+        return create_param(str(value.handle), get_proxy_type(value), QMODULE)
+
+    return value
+
+
+def translate_ast_arg_to_python_qmod(param: PositionalArg, value: Any) -> Any:
+    if isinstance(param, PortDeclaration):
+        return _create_qvar_for_qtype(value.quantum_type, value.handle)
     if isinstance(param, QuantumOperandDeclaration):
         if not param.is_list or not param.is_generative:
             return QTerminalCallable(param)
         inner_decl = param.model_copy(update={"is_list": False})
-        func_list: list[FunctionClosure] = evaluated.as_type(list)
-        return [
-            QTerminalCallable(inner_decl, index_=idx) for idx in range(len(func_list))
-        ]
-    classical_value = evaluated.value
-    if isinstance(classical_value, QmodStructInstance):
-        if param.classical_type.is_purely_declarative:
-            return CParamStruct(
-                expr=param.name,
-                struct_type=Struct(name=classical_value.struct_declaration.name),
-                qmodule=QMODULE,
-            )
-        else:
-            return get_sdk_compatible_python_object(dict(classical_value.fields))
-    if isinstance(classical_value, ClassicalProxy):
-        return create_param(
-            str(classical_value.handle), get_proxy_type(classical_value), QMODULE
+        return [QTerminalCallable(inner_decl, index_=idx) for idx in range(len(value))]
+    if (
+        isinstance(value, QmodStructInstance)
+        and param.classical_type.is_purely_declarative
+    ):
+        classical_type = Struct(name=value.struct_declaration.name)
+        classical_type.set_classical_struct_decl(value.struct_declaration)
+        return CParamStruct(
+            expr=param.name, struct_type=classical_type, qmodule=QMODULE
         )
-
-    return get_sdk_compatible_python_object(classical_value)
+    return translate_classical_ast_arg_to_python_qmod(value)
 
 
 class _InterpreterExpandable(QFunc):
@@ -140,14 +167,14 @@ class _InterpreterExpandable(QFunc):
                     name=name,
                     positional_arg_declarations=value.positional_arg_declarations,
                 )
-            elif (
-                isinstance(value, list)
-                and len(value) > 0
-                and isinstance(value[0], FunctionClosure)
-            ):
+                continue
+            op_param = self._interpreter._builder.current_function.parameters_dict.get(
+                name
+            )
+            if isinstance(op_param, QuantumOperandDeclaration):
                 scope_func_decls[name] = QuantumFunctionDeclaration(
                     name=name,
-                    positional_arg_declarations=value[0].positional_arg_declarations,
+                    positional_arg_declarations=op_param.positional_arg_declarations,
                 )
         return (
             nameables_to_dict(self._interpreter._get_function_declarations())
@@ -161,7 +188,7 @@ def emit_generative_statements(
     args: list[Evaluated],
 ) -> None:
     python_qmod_args = [
-        translate_ast_arg_to_python_qmod(param, arg)
+        translate_ast_arg_to_python_qmod(param, arg.value)
         for param, arg in zip(operation.positional_arg_declarations, args)
     ]
     with _InterpreterExpandable(interpreter):

classiq/model_expansions/interpreters/base_interpreter.py

@@ -6,7 +6,6 @@ from contextlib import nullcontext
 from functools import singledispatchmethod
 from typing import Any, cast
 
-import sympy
 from pydantic import ValidationError
 
 from classiq.interface.debug_info.debug_info import (
@@ -17,6 +16,9 @@ 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.types.compilation_metadata import CompilationMetadata
 from classiq.interface.model.handle_binding import (
@@ -57,11 +59,13 @@ from classiq.model_expansions.scope_initialization import (
 )
 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
 from classiq.qmod.model_state_container import QMODULE
 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
 
 
 class BaseInterpreter:
@@ -126,7 +130,11 @@ class BaseInterpreter:
             classical_execution_code=self._model.classical_execution_code,
             execution_preferences=self._model.execution_preferences,
             functions=list(self._expanded_functions.values()),
-            constants=self._model.constants,
+            constants=[
+                const
+                for name, const in QMODULE.constants.items()
+                if name not in builtin_constants
+            ],
             enums=[
                 enum_decl
                 for name, enum_decl in QMODULE.enum_decls.items()
@@ -157,14 +165,17 @@ class BaseInterpreter:
     @evaluate.register
     def evaluate_classical_expression(self, expression: Expression) -> Evaluated:
         expr = evaluate_classical_expression(expression, self._builder.current_scope)
-        if not isinstance(expr.value, sympy.Basic):
-            return expr
         vrc = VarRefCollector(ignore_duplicated_handles=True, unevaluated=True)
-        vrc.visit(ast.parse(str(expr.value)))
+        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], QuantumSymbol
+                self._builder.current_scope[handle.name].value, QuantumSymbol
             ):
+                if (
+                    isinstance(handle, FieldHandleBinding)
+                    and handle.field in CLASSICAL_ATTRIBUTES
+                ):
+                    handle = handle.base_handle
                 self.evaluate(handle)
         return expr
 

classiq/model_expansions/interpreters/frontend_generative_interpreter.py

@@ -5,6 +5,7 @@ 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 (
@@ -16,6 +17,7 @@ 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,
@@ -40,6 +42,9 @@ class FrontendGenerativeInterpreter(GenerativeInterpreter):
     def emit_allocate(self, allocate: Allocate) -> None:
         AllocateEmitter(self, allow_symbolic_size=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)
 

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -61,7 +61,11 @@ from classiq.model_expansions.quantum_operations.allocate import AllocateEmitter
 from classiq.model_expansions.quantum_operations.assignment_result_processor import (
     AssignmentResultProcessor,
 )
-from classiq.model_expansions.quantum_operations.block_evaluator import BlockEvaluator
+from classiq.model_expansions.quantum_operations.block_evaluator import (
+    BlockEvaluator,
+    IfElimination,
+    RepeatElimination,
+)
 from classiq.model_expansions.quantum_operations.composite_emitter import (
     CompositeEmitter,
 )
@@ -152,10 +156,16 @@ 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)
 
     @emit.register
+    def _emit_bind(self, bind: BindOperation) -> None:
+        self.emit_bind(bind)
+
     def emit_bind(self, bind: BindOperation) -> None:
         BindEmitter(self).emit(bind)
 
@@ -210,6 +220,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 ExpressionEvaluator(self, "condition"),
+                IfElimination(self),
                 BlockEvaluator(
                     self,
                     CLASSICAL_IF_OPERATOR_NAME,
@@ -243,6 +254,7 @@ class GenerativeInterpreter(BaseInterpreter):
             self,
             [
                 ExpressionEvaluator(self, "count"),
+                RepeatElimination(self),
                 RepeatBlockEvaluator(self, REPEAT_OPERATOR_NAME, "body"),
             ],
         ).emit(repeat)