classiq 0.69.0__py3-none-any.whl → 0.71.0__py3-none-any.whl

classiq/model_expansions/transformers/model_renamer.py

@@ -1,4 +1,5 @@
 import ast
+import re
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from typing import TypeVar, cast
@@ -16,6 +17,12 @@ from classiq.model_expansions.visitors.variable_references import VarRefCollecto
 AST_NODE = TypeVar("AST_NODE", bound=NodeType)
 
 
+def _replace_full_word(pattern: str, substitution: str, target: str) -> str:
+    return re.sub(
+        rf"(^|\b|\W)({re.escape(pattern)})($|\b|\W)", rf"\1{substitution}\3", target
+    )
+
+
 @dataclass(frozen=True)
 class HandleRenaming:
     source_handle: HandleBinding
@@ -74,7 +81,7 @@ class ModelRenamer:
         symbol_mapping: SymbolRenaming,
         expression: Expression,
     ) -> Expression:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
+        vrc = VarRefCollector(ignore_duplicated_handles=True, ignore_sympy_symbols=True)
         vrc.visit(ast.parse(expression.expr))
 
         handle_names = {
@@ -87,10 +94,12 @@ class ModelRenamer:
             new_handle = handle.collapse()
             for handle_to_replace, replacement in handle_names.items():
                 new_handle = new_handle.replace_prefix(handle_to_replace, replacement)
-            new_expr_str = new_expr_str.replace(str(handle), str(new_handle))
+            new_expr_str = _replace_full_word(
+                str(handle), str(new_handle), new_expr_str
+            )
             if handle.qmod_expr != str(handle):
-                new_expr_str = new_expr_str.replace(
-                    handle.qmod_expr, new_handle.qmod_expr
+                new_expr_str = _replace_full_word(
+                    str(handle.qmod_expr), str(new_handle.qmod_expr), new_expr_str
                 )
 
         new_expr = Expression(expr=new_expr_str)

classiq/model_expansions/visitors/variable_references.py

@@ -24,10 +24,14 @@ from classiq.interface.model.handle_binding import (
 
 class VarRefCollector(ast.NodeVisitor):
     def __init__(
-        self, ignore_duplicated_handles: bool = False, unevaluated: bool = False
+        self,
+        ignore_duplicated_handles: bool = False,
+        unevaluated: bool = False,
+        ignore_sympy_symbols: bool = False,
     ) -> None:
         self._var_handles: dict[HandleBinding, bool] = {}
         self._ignore_duplicated_handles = ignore_duplicated_handles
+        self._ignore_sympy_symbols = ignore_sympy_symbols
         self._unevaluated = unevaluated
         self._is_nested = False
 
@@ -117,9 +121,9 @@ class VarRefCollector(ast.NodeVisitor):
         return handle
 
     def visit_Name(self, node: ast.Name) -> Optional[HandleBinding]:
-        if node.id in set(SYMPY_SUPPORTED_EXPRESSIONS) | set(
-            DEFAULT_SUPPORTED_FUNC_NAMES
-        ):
+        if not self._ignore_sympy_symbols and node.id in set(
+            SYMPY_SUPPORTED_EXPRESSIONS
+        ) | set(DEFAULT_SUPPORTED_FUNC_NAMES):
             return None
         handle = HandleBinding(name=node.id)
         if not self._is_nested:

classiq/open_library/functions/__init__.py

@@ -9,6 +9,7 @@ from .grover import *
 from .hea import *
 from .linear_pauli_rotation import *
 from .linear_pauli_rotation import _single_pauli
+from .lookup_table import span_lookup_table
 from .modular_exponentiation import *
 from .modular_exponentiation import _check_msb
 from .qaoa_penalty import *
@@ -131,6 +132,7 @@ __all__ = [
     "qsvt_lcu_step",
     "qsvt_step",
     "reflect_about_zero",
+    "span_lookup_table",
     "suzuki_trotter",
     "swap_test",
     "switch",

classiq/open_library/functions/lookup_table.py

@@ -0,0 +1,58 @@
+from itertools import product
+
+from classiq.interface.exceptions import ClassiqValueError
+
+from classiq.qmod.builtins.operations import assign, bind, within_apply
+from classiq.qmod.qmod_variable import QNum
+from classiq.qmod.symbolic import subscript
+from classiq.qmod.utilities import RealFunction, get_temp_var_name, qnum_values
+
+
+def _get_qnum_values(num: QNum) -> list[float]:
+    size = num.size
+    is_signed = num.is_signed
+    fraction_digits = num.fraction_digits
+    if (
+        not isinstance(size, int)
+        or not isinstance(is_signed, bool)
+        or not isinstance(fraction_digits, int)
+    ):
+        raise ClassiqValueError(
+            "Must call 'span_lookup_table' inside a generative qfunc"
+        )
+
+    return qnum_values(size, is_signed, fraction_digits)
+
+
+def span_lookup_table(func: RealFunction, *targets: QNum) -> QNum:
+    """
+    Applies a classical function to quantum numbers.
+
+    Works by reducing the function into a lookup table over all the possible values
+    of the quantum numbers.
+
+    Args:
+        func: A Python function
+        *targets: One or more initialized quantum numbers
+
+    Returns:
+        The quantum result of applying func to targets
+
+    Notes:
+        Must be called inside a generative function (`@qfunc(generative=True)`)
+    """
+    if len(targets) == 0:
+        raise ClassiqValueError("No targets specified")
+
+    target_vals = [_get_qnum_values(target) for target in targets]
+    lookup_table = [func(*vals[::-1]) for vals in product(*target_vals[::-1])]
+
+    index_size = sum(target.size for target in targets)
+    index: QNum = QNum(get_temp_var_name(), size=index_size)
+    result: QNum = QNum(get_temp_var_name("result"))
+
+    within_apply(
+        lambda: bind(list(targets), index),
+        lambda: assign(subscript(lookup_table, index), result),
+    )
+    return result

classiq/qmod/__init__.py

@@ -6,7 +6,7 @@ from .expression_query import get_expression_numeric_attributes
 from .qfunc import qfunc
 from .qmod_constant import QConstant
 from .qmod_parameter import Array, CArray, CBool, CInt, CReal
-from .qmod_variable import Input, Output, QArray, QBit, QNum, QStruct
+from .qmod_variable import Const, Input, Output, QArray, QBit, QFree, QNum, QStruct
 from .quantum_callable import QCallable, QCallableList
 from .write_qmod import write_qmod
 
@@ -18,6 +18,8 @@ __all__ = [
     "CReal",
     "Input",
     "Output",
+    "Const",
+    "QFree",
     "QArray",
     "QBit",
     "QNum",

classiq/qmod/declaration_inferrer.py

@@ -19,6 +19,7 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
 from classiq.interface.generator.types.enum_declaration import declaration_from_enum
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
 from classiq.interface.model.classical_parameter_declaration import (
@@ -36,8 +37,9 @@ 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 ModelStateContainer
 from classiq.qmod.python_classical_type import PythonClassicalType
-from classiq.qmod.qmod_variable import QVar
+from classiq.qmod.qmod_variable import QVar, get_port_from_type_hint
 from classiq.qmod.quantum_callable import QCallableList
+from classiq.qmod.semantics.validation.type_hints import validate_annotation
 from classiq.qmod.utilities import unmangle_keyword, version_portable_get_args
 
 if sys.version_info[0:2] >= (3, 9):
@@ -84,15 +86,12 @@ def python_type_to_qmod(
 
 
 def _extract_port_decl(name: Optional[str], py_type: Any) -> AnonPortDeclaration:
-    # FIXME: CAD-13409
-    qtype: type[QVar] = QVar.from_type_hint(py_type)  # type:ignore[assignment]
-    direction = qtype.port_direction(py_type)
-    if isinstance(py_type, _AnnotatedAlias):
-        py_type = py_type.__args__[0]
+    quantum_type, direction, qualifier = get_port_from_type_hint(py_type)
     param = AnonPortDeclaration(
         name=None,
         direction=direction,
-        quantum_type=qtype.to_qmod_quantum_type(py_type),
+        quantum_type=quantum_type,
+        type_qualifier=qualifier,
     )
     if name is not None:
         param = param.rename(name)
@@ -123,25 +122,47 @@ def _extract_operand_decl(
 
 
 def _extract_operand_param(py_type: Any) -> tuple[Optional[str], Any]:
-    if sys.version_info[0:2] < (3, 9) or get_origin(py_type) is not Annotated:
+    if get_origin(py_type) is not Annotated:
         return None, py_type
+
     args = get_args(py_type)
-    if len(args) == 2:
-        if isinstance(args[1], PortDeclarationDirection):
-            return None, py_type
-        elif isinstance(args[1], str):
-            return args[1], args[0]
-        elif get_origin(args[1]) is Literal:
-            return version_portable_get_args(args[1])[0], args[0]
-    elif len(args) == 3 and isinstance(args[1], PortDeclarationDirection):
-        if isinstance(args[2], str):
-            return args[2], Annotated[args[0], args[1]]
-        elif get_origin(args[2]) is Literal:
-            return version_portable_get_args(args[2])[0], Annotated[args[0], args[1]]
-    raise ClassiqValueError(
-        f"Operand parameter declaration must be of the form <param-type> or "
-        f"Annotated[<param-type>, <param-name>]. Got {py_type}"
-    )
+    _validate_annotations(args, py_type)
+    param_name = _get_param_name(args)
+
+    if param_name is None:
+        if len(args) > 1:
+            return None, _unpacked_annotated(args[0], args[1:])
+        return None, args[0]
+
+    if len(args) > 2:
+        return param_name, _unpacked_annotated(args[0], args[1:-1])
+    return param_name, args[0]
+
+
+def _unpacked_annotated(arg_0: Any, args: Any) -> _AnnotatedAlias:
+    return Annotated.__class_getitem__((arg_0, *args))  # type:ignore[attr-defined]
+
+
+def _get_param_name(py_type_args: Any) -> Optional[str]:
+    if isinstance(py_type_args[-1], str) and not isinstance(
+        py_type_args[-1], (PortDeclarationDirection, TypeQualifier)
+    ):
+        return py_type_args[-1]
+    elif py_type_args[-1] is Literal:
+        return str(version_portable_get_args(py_type_args[-1])[0])  # type: ignore[arg-type]
+    else:
+        return None
+
+
+def _validate_annotations(py_type_args: Any, py_type: Any) -> None:
+    for arg in py_type_args[1:-1]:
+        if (
+            isinstance(arg, str) and not isinstance(arg, PortDeclarationDirection)
+        ) or arg is Literal:
+            raise ClassiqValueError(
+                f"Operand parameter declaration must be of the form <param-type> or "
+                f"Annotated[<param-type>, <param-name>]. Got {py_type}"
+            )
 
 
 @overload
@@ -163,6 +184,7 @@ def _extract_positional_args(
 ) -> Sequence[AnonPositionalArg]:
     result: list[AnonPositionalArg] = []
     for name, py_type in args:
+        validate_annotation(py_type)
         if name == "return":
             continue
         name = unmangle_keyword(name)
@@ -175,7 +197,7 @@ def _extract_positional_args(
             if name is not None:
                 param = param.rename(name)
             result.append(param)
-        elif QVar.from_type_hint(py_type) is not None:
+        elif is_qvar(py_type):
             result.append(_extract_port_decl(name, py_type))
         else:
             result.append(_extract_operand_decl(name, py_type, qmodule=qmodule))
@@ -191,3 +213,11 @@ def infer_func_decl(
             list(py_func.__annotations__.items()), qmodule=qmodule
         ),
     )
+
+
+def is_qvar(type_hint: Any) -> Any:
+    non_annotated_type = (
+        type_hint.__origin__ if isinstance(type_hint, _AnnotatedAlias) else type_hint
+    )
+    type_ = get_origin(non_annotated_type) or non_annotated_type
+    return issubclass(type_, QVar)

classiq/qmod/native/pretty_printer.py

@@ -18,6 +18,8 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -95,6 +97,7 @@ class DSLPrettyPrinter(ModelVisitor):
         self._level = 0
         self._decimal_precision = decimal_precision
         self._emit_open_lib_functions = emit_open_lib_functions
+        self._compilation_metadata: dict[str, CompilationMetadata] = {}
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -105,6 +108,8 @@ class DSLPrettyPrinter(ModelVisitor):
     def visit_Model(self, model: Model) -> str:
         # FIXME - CAD-20149: Remove this line once the froggies are removed, and the visit of lambdas can be done without accessing the func_decl property (with rename_params values only).
         resolve_function_calls(model, model.function_dict)
+        self._compilation_metadata = model.functions_compilation_metadata
+
         enum_decls = [self.visit(enum_decl) for enum_decl in model.enums]
         struct_decls = [self.visit(struct_decl) for struct_decl in model.types]
         qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]
@@ -135,10 +140,20 @@ class DSLPrettyPrinter(ModelVisitor):
         )
         return f"({positional_args})"
 
+    def _get_decl_string(self, func_decl: QuantumFunctionDeclaration) -> str:
+        no_qualifiers_decl = "qfunc"
+        if func_decl.name not in self._compilation_metadata:
+            return no_qualifiers_decl
+        atomic_qualifiers = self._compilation_metadata[func_decl.name].atomic_qualifiers
+        if len(atomic_qualifiers) == 0:
+            return no_qualifiers_decl
+        return f"atomic_qualifiers ({', '.join(atomic_qualifiers)})\n" f"qfunc"
+
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
     ) -> str:
-        return f"qfunc {func_decl.name}{self._visit_arg_decls(func_decl)}"
+        qfunc_decl = self._get_decl_string(func_decl)
+        return f"{qfunc_decl} {func_decl.name}{self._visit_arg_decls(func_decl)}"
 
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         return f"enum {enum_decl.name} {{\n{self._visit_members(enum_decl.members)}}}\n"
@@ -175,13 +190,20 @@ class DSLPrettyPrinter(ModelVisitor):
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
+        qualifier_str = (
+            f"{port_decl.type_qualifier} "
+            if port_decl.type_qualifier is not TypeQualifier.Quantum
+            else ""
+        )
         dir_str = (
             f"{port_decl.direction} "
-            if port_decl.direction != PortDeclarationDirection.Inout
+            if port_decl.direction is not PortDeclarationDirection.Inout
             else ""
         )
         param_name = f"{port_decl.name}: " if port_decl.name is not None else ""
-        return f"{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
+        return (
+            f"{qualifier_str}{dir_str}{param_name}{self.visit(port_decl.quantum_type)}"
+        )
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
         return "qbit"

classiq/qmod/pretty_print/pretty_printer.py

@@ -21,6 +21,8 @@ from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.generator.functions.type_qualifier import TypeQualifier
+from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
 from classiq.interface.generator.types.qstruct_declaration import QStructDeclaration
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
@@ -131,6 +133,7 @@ class PythonPrettyPrinter(ModelVisitor):
         self._import_annotated = False
         self._symbolic_imports: dict[str, int] = dict()
         self._functions: Optional[Mapping[str, QuantumFunctionDeclaration]] = None
+        self._compilation_metadata: dict[str, CompilationMetadata] = dict()
 
     def visit(self, node: NodeType) -> str:
         res = super().visit(node)
@@ -140,6 +143,7 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def visit_Model(self, model: Model) -> str:
         self._functions = {**model.function_dict, **BUILTIN_FUNCTION_DECLARATIONS}
+        self._compilation_metadata = model.functions_compilation_metadata
         enum_decls = [self.visit(decl) for decl in model.enums]
         struct_decls = [self.visit(decl) for decl in model.types]
         qstruct_decls = [self.visit(qstruct_decl) for qstruct_decl in model.qstructs]
@@ -196,12 +200,23 @@ class PythonPrettyPrinter(ModelVisitor):
             self.visit(arg_decl) for arg_decl in func_def.positional_arg_declarations
         )
 
+    def _get_qfunc_decorator(self, func_decl: QuantumFunctionDeclaration) -> str:
+        no_qualifiers_decorator = "@qfunc"
+        if func_decl.name not in self._compilation_metadata:
+            return no_qualifiers_decorator
+        atomic_qualifiers = self._compilation_metadata[func_decl.name].atomic_qualifiers
+        if len(atomic_qualifiers) == 0:
+            return no_qualifiers_decorator
+
+        qualifiers = (f'"{qualifier}"' for qualifier in atomic_qualifiers)
+        qualifier_list = f"[{', '.join(qualifiers)}]"
+        return no_qualifiers_decorator + f" (atomic_qualifiers={qualifier_list})"
+
     def visit_QuantumFunctionDeclaration(
         self, func_decl: QuantumFunctionDeclaration
     ) -> str:
-        return (
-            f"@qfunc\ndef {func_decl.name}({self._visit_arg_decls(func_decl)}) -> None:"
-        )
+        qfunc_decorator = self._get_qfunc_decorator(func_decl)
+        return f"{qfunc_decorator}\ndef {func_decl.name}({self._visit_arg_decls(func_decl)}) -> None:"
 
     def visit_EnumDeclaration(self, enum_decl: EnumDeclaration) -> str:
         self._import_enum = True
@@ -241,16 +256,18 @@ class PythonPrettyPrinter(ModelVisitor):
         return f"{var_decl.name}: {self.visit(var_decl.quantum_type)}"
 
     def visit_AnonPortDeclaration(self, port_decl: AnonPortDeclaration) -> str:
-        var = f"{port_decl.name}: {self.visit(port_decl.quantum_type)}"
-        var_name, var_type = var.split(": ")
-        for direction in PortDeclarationDirection:
-            if port_decl.direction == PortDeclarationDirection.Inout:
-                return var
-            if port_decl.direction == direction:
-                direction_identifier = direction.name
-                self._imports[direction_identifier] = 1
-                return f"{var_name}: {direction_identifier}[{var_type}]"
-        raise RuntimeError("Should not reach here")
+        var_type = self._extract_port_type(port_decl)
+        return f"{port_decl.name}: {var_type}"
+
+    def _extract_port_type(self, port_decl: AnonPortDeclaration) -> str:
+        var_type = self.visit(port_decl.quantum_type)
+        if port_decl.direction is not PortDeclarationDirection.Inout:
+            self._imports[port_decl.direction.name] = 1
+            var_type = f"{port_decl.direction.name}[{var_type}]"
+        if port_decl.type_qualifier is not TypeQualifier.Quantum:
+            self._imports[port_decl.type_qualifier.name] = 1
+            var_type = f"{port_decl.type_qualifier.name}[{var_type}]"
+        return var_type
 
     def visit_QuantumBit(self, qtype: QuantumBit) -> str:
         self._imports["QBit"] = 1
@@ -349,7 +366,7 @@ class PythonPrettyPrinter(ModelVisitor):
 
     def _visit_operand_arg_decl(self, arg_decl: AnonPositionalArg) -> str:
         if isinstance(arg_decl, AnonPortDeclaration):
-            type_str = self.visit(arg_decl.quantum_type)
+            type_str = self._extract_port_type(arg_decl)
         elif isinstance(arg_decl, AnonClassicalParameterDeclaration):
             type_str = self.visit(arg_decl.classical_type)
         else:

classiq/qmod/python_classical_type.py

@@ -2,6 +2,9 @@ import dataclasses
 import inspect
 from enum import EnumMeta
 from typing import (
+    Any,
+    ForwardRef,
+    Literal,
     Optional,
     get_args,
     get_origin,
@@ -19,7 +22,6 @@ from classiq.interface.generator.functions.concrete_types import ConcreteClassic
 from classiq.interface.generator.functions.type_name import Enum, Struct
 
 from classiq.qmod.cparam import CArray, CBool, CInt, CReal
-from classiq.qmod.qmod_variable import get_type_hint_expr
 from classiq.qmod.utilities import version_portable_get_args
 
 CARRAY_ERROR_MESSAGE = (
@@ -71,3 +73,12 @@ class PythonClassicalType:
 
     def register_enum(self, py_type: EnumMeta) -> None:
         pass
+
+
+def get_type_hint_expr(type_hint: Any) -> str:
+    if isinstance(type_hint, ForwardRef):  # expression in string literal
+        return str(type_hint.__forward_arg__)
+    if get_origin(type_hint) == Literal:  # explicit numeric literal
+        return str(get_args(type_hint)[0])
+    else:
+        return str(type_hint)  # implicit numeric literal

classiq/qmod/qfunc.py

@@ -35,6 +35,7 @@ def qfunc(
     *,
     external: Literal[True],
     synthesize_separately: Literal[False] = False,
+    atomic_qualifiers: Optional[list[str]] = None,
 ) -> Callable[[Callable], ExternalQFunc]: ...
 
 
@@ -43,11 +44,22 @@ def qfunc(
     *,
     generative: Literal[True],
     synthesize_separately: bool = False,
+    atomic_qualifiers: Optional[list[str]] = None,
 ) -> Callable[[Callable], GenerativeQFunc]: ...
 
 
 @overload
-def qfunc(*, synthesize_separately: bool) -> Callable[[Callable], QFunc]: ...
+def qfunc(
+    *, synthesize_separately: bool, atomic_qualifiers: Optional[list[str]] = None
+) -> Callable[[Callable], QFunc]: ...
+
+
+@overload
+def qfunc(
+    *,
+    synthesize_separately: bool = False,
+    atomic_qualifiers: Optional[list[str]] = None,
+) -> Callable[[Callable], QFunc]: ...
 
 
 def qfunc(
@@ -56,24 +68,37 @@ def qfunc(
     external: bool = False,
     generative: bool = False,
     synthesize_separately: bool = False,
+    atomic_qualifiers: Optional[list[str]] = None,
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
     def wrapper(func: Callable) -> QCallable:
         qfunc: BaseQFunc
+
+        if external:
+            _validate_directives(synthesize_separately, atomic_qualifiers)
+            return ExternalQFunc(func)
+
         if generative or _GENERATIVE_SWITCH:
             qfunc = GenerativeQFunc(func)
-        elif external:
-            if synthesize_separately:
-                raise ClassiqInternalError(
-                    "External functions can't be marked as synthesized separately"
-                )
-            return ExternalQFunc(func)
         else:
             qfunc = QFunc(func)
         if synthesize_separately:
             qfunc.update_compilation_metadata(should_synthesize_separately=True)
+        if atomic_qualifiers is not None and len(atomic_qualifiers) > 0:
+            qfunc.update_compilation_metadata(atomic_qualifiers=atomic_qualifiers)
         return qfunc
 
     if func is not None:
         return wrapper(func)
-
     return wrapper
+
+
+def _validate_directives(
+    synthesize_separately: bool, atomic_qualifiers: Optional[list[str]] = None
+) -> None:
+    error_msg = ""
+    if synthesize_separately:
+        error_msg += "External functions can't be marked as synthesized separately. \n"
+    if atomic_qualifiers is not None and len(atomic_qualifiers) > 0:
+        error_msg += "External functions can't have atomic qualifiers."
+    if error_msg:
+        raise ClassiqInternalError(error_msg)

classiq/qmod/qmod_parameter.py

@@ -22,6 +22,11 @@ from classiq.qmod.cparam import (  # noqa: F401
     CParamScalar,
     CReal,
 )
+from classiq.qmod.generative import (
+    generative_mode_context,
+    interpret_expression,
+    is_generative_mode,
+)
 from classiq.qmod.model_state_container import ModelStateContainer
 from classiq.qmod.symbolic_expr import Symbolic, SymbolicExpr
 
@@ -66,6 +71,9 @@ class CParamList(CParam):
 
     @property
     def len(self) -> CParamScalar:
+        if is_generative_mode():
+            with generative_mode_context(False):
+                return interpret_expression(str(self.len))
         return CParamScalar(f"get_field({self}, 'len')")