classiq 0.63.1__py3-none-any.whl → 0.65.1__py3-none-any.whl

classiq/model_expansions/interpreters/generative_interpreter.py

@@ -0,0 +1,249 @@
+from functools import singledispatchmethod
+from typing import Any
+
+import numpy as np
+from numpy.random import permutation
+
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    CONTROL_OPERATOR_NAME,
+    INVERT_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+)
+from classiq.interface.model.allocate import Allocate
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.classical_if import ClassicalIf
+from classiq.interface.model.control import Control
+from classiq.interface.model.inplace_binary_operation import InplaceBinaryOperation
+from classiq.interface.model.invert import Invert
+from classiq.interface.model.model import Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.phase_operation import PhaseOperation
+from classiq.interface.model.power import Power
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_function_declaration import (
+    NamedParamsQuantumFunctionDeclaration,
+)
+from classiq.interface.model.quantum_lambda_function import (
+    OperandIdentifier,
+    QuantumLambdaFunction,
+)
+from classiq.interface.model.quantum_statement import QuantumStatement
+from classiq.interface.model.repeat import Repeat
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.closure import (
+    Closure,
+    FunctionClosure,
+    GenerativeClosure,
+    GenerativeFunctionClosure,
+)
+from classiq.model_expansions.generative_functions import emit_generative_statements
+from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
+from classiq.model_expansions.quantum_operations import (
+    BindEmitter,
+    ClassicalIfEmitter,
+    QuantumFunctionCallEmitter,
+    RepeatEmitter,
+    VariableDeclarationStatementEmitter,
+)
+from classiq.model_expansions.quantum_operations.shallow_emitter import ShallowEmitter
+from classiq.model_expansions.scope import Evaluated, Scope
+from classiq.model_expansions.scope_initialization import (
+    add_functions_to_scope,
+    add_generative_functions_to_scope,
+)
+from classiq.qmod.builtins.functions import permute
+from classiq.qmod.model_state_container import QMODULE, ModelStateContainer
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+
+class GenerativeInterpreter(BaseInterpreter):
+    def __init__(
+        self,
+        model: Model,
+        generative_functions: list[GenerativeQFunc],
+    ) -> None:
+        super().__init__(model)
+        add_generative_functions_to_scope(generative_functions, self._top_level_scope)
+
+    def evaluate_lambda(self, function: QuantumLambdaFunction) -> Evaluated:
+        renamed_params = [
+            param.rename(function.pos_rename_params[idx])
+            for idx, param in enumerate(function.func_decl.positional_arg_declarations)
+        ]
+        func_decl = NamedParamsQuantumFunctionDeclaration(
+            name=self._counted_name_allocator.allocate(
+                function.func_decl.name or "<lambda>"
+            ),
+            positional_arg_declarations=renamed_params,
+        )
+
+        closure_class: type[FunctionClosure]
+        extra_args: dict[str, Any]
+        if function.is_generative():
+            closure_class = GenerativeFunctionClosure
+            extra_args = {
+                "generative_blocks": {
+                    "body": GenerativeQFunc(function.py_callable, func_decl),
+                }
+            }
+        else:
+            closure_class = FunctionClosure
+            extra_args = {}
+
+        return Evaluated(
+            value=closure_class.create(
+                name=func_decl.name,
+                positional_arg_declarations=func_decl.positional_arg_declarations,
+                body=function.body,
+                scope=Scope(parent=self._builder.current_scope),
+                is_lambda=True,
+                **extra_args,
+            ),
+            defining_function=self._builder.current_function,
+        )
+
+    @singledispatchmethod
+    def emit(self, statement: QuantumStatement) -> None:  # type:ignore[override]
+        raise NotImplementedError(f"Cannot emit {statement!r}")
+
+    @emit.register
+    def _emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        self.emit_quantum_function_call(call)
+
+    def emit_quantum_function_call(self, call: QuantumFunctionCall) -> None:
+        QuantumFunctionCallEmitter(self).emit(call)
+
+    @emit.register
+    def emit_allocate(self, allocate: Allocate) -> None:
+        ShallowEmitter(self, "allocate", components=["size", "target"]).emit(allocate)
+
+    @emit.register
+    def emit_bind(self, bind: BindOperation) -> None:
+        BindEmitter(self).emit(bind)
+
+    @emit.register
+    def emit_quantum_assignment_operation(self, op: QuantumAssignmentOperation) -> None:
+        ShallowEmitter(
+            self, "assignment_operation", components=["expression", "result_var"]
+        ).emit(op)
+
+    @emit.register
+    def emit_inplace_binary_operation(self, op: InplaceBinaryOperation) -> None:
+        ShallowEmitter(
+            self, "inplace_binary_operation", components=["target", "value"]
+        ).emit(op)
+
+    @emit.register
+    def emit_variable_declaration(
+        self, variable_declaration: VariableDeclarationStatement
+    ) -> None:
+        VariableDeclarationStatementEmitter(self).emit(variable_declaration)
+
+    @emit.register
+    def emit_classical_if(self, classical_if: ClassicalIf) -> None:
+        ClassicalIfEmitter(self).emit(classical_if)
+
+    @emit.register
+    def emit_within_apply(self, within_apply: WithinApply) -> None:
+        ShallowEmitter(
+            self,
+            WITHIN_APPLY_NAME,
+            components=["within", "apply", "compute", "action"],
+        ).emit(within_apply)
+
+    @emit.register
+    def emit_invert(self, invert: Invert) -> None:
+        ShallowEmitter(self, INVERT_OPERATOR_NAME, components=["body"]).emit(invert)
+
+    @emit.register
+    def emit_repeat(self, repeat: Repeat) -> None:
+        RepeatEmitter(self).emit(repeat)
+
+    @emit.register
+    def emit_control(self, control: Control) -> None:
+        ShallowEmitter(
+            self,
+            CONTROL_OPERATOR_NAME,
+            components=["expression", "body", "else_block"],
+        ).emit(control)
+
+    @emit.register
+    def emit_power(self, power: Power) -> None:
+        ShallowEmitter(self, CONTROL_OPERATOR_NAME, components=["power", "body"]).emit(
+            power
+        )
+
+    @emit.register
+    def emit_phase(self, phase: PhaseOperation) -> None:
+        ShallowEmitter(self, "phase", components=["expression", "theta"]).emit(phase)
+
+    def _expand_body(self, operation: Closure) -> None:
+        if isinstance(operation, FunctionClosure) and operation.name == "permute":
+            # special expansion since permute is generative
+            self._expand_permute()
+        elif isinstance(operation, GenerativeClosure):
+            args = [
+                self.evaluate(param.name)
+                for param in operation.positional_arg_declarations
+            ]
+            emit_generative_statements(self, operation, args)
+        else:
+            super()._expand_body(operation)
+
+    def _expand_permute(self) -> None:
+        functions = self.evaluate("functions").as_type(list)
+        functions_permutation = permutation(np.array(range(len(functions))))
+        calls: list[QuantumFunctionCall] = []
+        for function_index in functions_permutation:
+            permute_call = QuantumFunctionCall(
+                function=OperandIdentifier(
+                    name="functions", index=Expression(expr=f"{function_index}")
+                )
+            )
+            permute_call.set_func_decl(permute.func_decl)
+            calls.append(permute_call)
+        self._expand_block(calls, "body")
+
+    def update_generative_functions(
+        self, generative_functions: dict[str, GenerativeQFunc]
+    ) -> None:
+        add_generative_functions_to_scope(
+            list(generative_functions.values()), self._top_level_scope
+        )
+        for name, gen_func in generative_functions.items():
+            if gen_func.compilation_metadata is not None:
+                self._functions_compilation_metadata[name] = (
+                    gen_func.compilation_metadata
+                )
+
+    def update_declarative_functions(
+        self,
+        functions: dict[str, NativeFunctionDefinition],
+        qmodule: ModelStateContainer,
+    ) -> None:
+        add_functions_to_scope(list(functions.values()), self._top_level_scope)
+        for dec_func_name in functions:
+            if dec_func_name in qmodule.functions_compilation_metadata:
+                self._functions_compilation_metadata[dec_func_name] = (
+                    qmodule.functions_compilation_metadata[dec_func_name]
+                )
+
+    def add_purely_declarative_function(self, function: FunctionClosure) -> None:
+        functions_to_add = [function.name] + QMODULE.function_dependencies[
+            function.name
+        ]
+        for func in functions_to_add:
+            if func not in self._expanded_functions and func in QMODULE.native_defs:
+                self._expanded_functions[func] = QMODULE.native_defs[func]
+                if func in QMODULE.functions_compilation_metadata:
+                    self._expanded_functions_compilation_metadata[func] = (
+                        QMODULE.functions_compilation_metadata[func]
+                    )

classiq/model_expansions/model_tables.py

@@ -1,98 +1,7 @@
-from abc import ABC, abstractmethod
-from enum import IntEnum
-from typing import ClassVar, Generic, Optional, TypeVar
+from typing import Optional
 
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 from classiq.interface.generator.functions.classical_type import QmodPyObject
-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
-
-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
-
-DeclarationType = TypeVar(
-    "DeclarationType", EnumDeclaration, StructDeclaration, QStructDeclaration
-)
-
-
-class TypeTable(Generic[DeclarationType], ABC):
-    def __init__(self, user_types: list[DeclarationType]) -> None:
-        self._all_types: dict[str, DeclarationType] = self.builtins.copy()
-        for t in user_types:
-            assert t.name not in self._all_types  # FIXME: issue user error (CAD-7856)
-            self._all_types[t.name] = t
-
-    @property
-    @abstractmethod
-    def builtins(self) -> dict[str, DeclarationType]:
-        pass
-
-    def __getitem__(self, key: str) -> DeclarationType:
-        return self._all_types[key]
-
-    def __setitem__(self, key: str, value: DeclarationType) -> None:
-        self._all_types[key] = value
-
-    def __contains__(self, key: str) -> bool:
-        return key in self._all_types
-
-    def all_types(self) -> dict[str, DeclarationType]:
-        return self._all_types
-
-
-class EnumTable(TypeTable[EnumDeclaration]):
-    def __init__(self, user_types: list[EnumDeclaration]) -> None:
-        super().__init__(user_types)
-
-    @property
-    def builtins(self) -> dict[str, EnumDeclaration]:
-        return BUILTIN_ENUM_DECLARATIONS
-
-    @property
-    def enums(self) -> dict[str, IntEnum]:
-        return {
-            enum_decl.name: enum_decl.create_enum()
-            for enum_decl in self.all_types().values()
-        }
-
-
-class StructTable(TypeTable[StructDeclaration]):
-    @property
-    def builtins(self) -> dict[str, StructDeclaration]:
-        return BUILTIN_STRUCT_DECLARATIONS
-
-
-class QStructTable(TypeTable[QStructDeclaration]):
-    @property
-    def builtins(self) -> dict[str, QStructDeclaration]:
-        return {}
-
-
-class SymbolTable:
-    enum_table: ClassVar[EnumTable] = EnumTable([])
-    type_table: ClassVar[StructTable] = StructTable([])
-    qstruct_table: ClassVar[QStructTable] = QStructTable([])
-
-    @classmethod
-    def init_user_enums(cls, user_enums: list[EnumDeclaration]) -> None:
-        cls.enum_table = EnumTable(user_enums)
-        QMODULE.enum_decls = {enum_decl.name: enum_decl for enum_decl in user_enums}
-
-    @classmethod
-    def init_user_types(cls, user_types: list[StructDeclaration]) -> None:
-        cls.type_table = StructTable(user_types)
-        QMODULE.type_decls = {
-            struct_decl.name: struct_decl for struct_decl in user_types
-        }
-
-    @classmethod
-    def init_user_qstructs(cls, user_qstructs: list[QStructDeclaration]) -> None:
-        cls.qstruct_table = QStructTable(user_qstructs)
-        QMODULE.qstruct_decls = {
-            qstruct_decl.name: qstruct_decl for qstruct_decl in user_qstructs
-        }
 
 
 class HandleTable:

classiq/model_expansions/quantum_operations/__init__.py

@@ -1,14 +1,5 @@
 from classiq.model_expansions.quantum_operations.bind import BindEmitter
 from classiq.model_expansions.quantum_operations.classicalif import ClassicalIfEmitter
-from classiq.model_expansions.quantum_operations.control import ControlEmitter
-from classiq.model_expansions.quantum_operations.inplace_binary_operation import (
-    InplaceBinaryOperationEmitter,
-)
-from classiq.model_expansions.quantum_operations.invert import InvertEmitter
-from classiq.model_expansions.quantum_operations.power import PowerEmitter
-from classiq.model_expansions.quantum_operations.quantum_assignment_operation import (
-    QuantumAssignmentOperationEmitter,
-)
 from classiq.model_expansions.quantum_operations.quantum_function_call import (
     QuantumFunctionCallEmitter,
 )
@@ -16,4 +7,3 @@ from classiq.model_expansions.quantum_operations.repeat import RepeatEmitter
 from classiq.model_expansions.quantum_operations.variable_decleration import (
     VariableDeclarationStatementEmitter,
 )
-from classiq.model_expansions.quantum_operations.within_apply import WithinApplyEmitter

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -8,9 +8,6 @@ from typing import (
 )
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
 from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
@@ -23,10 +20,6 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
     PositionalArg,
 )
-from classiq.interface.model.quantum_lambda_function import (
-    OperandIdentifier,
-    QuantumLambdaFunction,
-)
 from classiq.interface.model.quantum_statement import QuantumStatement
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -35,7 +28,7 @@ from classiq.interface.model.variable_declaration_statement import (
 from classiq.model_expansions.capturing.captured_vars import (
     validate_args_are_not_propagated,
 )
-from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
+from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.evaluators.argument_types import (
     add_information_from_output_arguments,
 )
@@ -52,14 +45,13 @@ from classiq.model_expansions.quantum_operations.emitter import (
 from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
 from classiq.model_expansions.transformers.var_splitter import VarSplitter
 from classiq.qmod.builtins.functions import allocate, free
-from classiq.qmod.model_state_container import QMODULE
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
-    def __init__(self, interpreter: "Interpreter") -> None:
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
         VarSplitter.__init__(self, interpreter._builder.current_scope)
 
@@ -105,45 +97,16 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             function, evaluated_args
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
-        is_atomic = function.is_atomic
-        if (
-            self._interpreter._is_shallow
-            and self._is_function_purely_declarative(function)
-            and self._are_args_purely_declarative(args)
-        ):
+        if not self.should_expand_function(function, evaluated_args):
             is_atomic = True
-            self._interpreter.add_purely_declarative_function(function)
-        new_function_name = function.name
-        if not is_atomic:  # perform monomorphization per interpreted parameters set
-            self._add_params_to_scope(
-                new_positional_arg_decls, evaluated_args, function
+            new_declaration = self._expanded_functions_by_name.get(
+                function.name, new_declaration
             )
-            context = self._expand_operation(
-                function.with_new_declaration(new_declaration)
+        else:
+            is_atomic = False
+            new_declaration = self._expand_function(
+                evaluated_args, new_declaration, function
             )
-            function_context = cast(FunctionContext, context)
-            closure_id = function_context.closure.closure_id
-            function_def = self._expanded_functions.get(closure_id)
-            if function_def is None:
-                function_def = self._create_function_definition(function_context)
-                self._expanded_functions[closure_id] = function_def
-                self._top_level_scope[function_def.name] = Evaluated(
-                    value=function_context.closure.with_new_declaration(function_def)
-                )
-                compilation_metadata = self._functions_compilation_metadata.get(
-                    function.name
-                )
-                if compilation_metadata is not None:
-                    self._expanded_functions_compilation_metadata[function_def.name] = (
-                        compilation_metadata
-                    )
-            else:
-                self._expanded_functions_compilation_metadata[
-                    function_def.name
-                ].occurrences_number += 1
-
-            new_declaration = function_def
-            new_function_name = function_def.name
 
         new_positional_args = self._get_new_positional_args(
             evaluated_args, is_atomic, new_positional_arg_decls
@@ -154,8 +117,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         validate_args_are_not_propagated(new_positional_args, captured_args)
         new_positional_args.extend(captured_args)
         new_call = QuantumFunctionCall(
-            function=new_function_name,
-            positional_args=new_positional_args,
+            function=new_declaration.name, positional_args=new_positional_args
         )
         is_allocate_or_free = (
             new_call.func_name == allocate.func_decl.name
@@ -186,6 +148,40 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         new_call.set_func_decl(new_declaration)
         return new_call
 
+    def should_expand_function(
+        self, function: FunctionClosure, args: list[Evaluated]
+    ) -> bool:
+        return not function.is_atomic
+
+    def _expand_function(
+        self,
+        args: list[Evaluated],
+        decl: NamedParamsQuantumFunctionDeclaration,
+        function: FunctionClosure,
+    ) -> NamedParamsQuantumFunctionDeclaration:
+        self._add_params_to_scope(decl.positional_arg_declarations, args, function)
+        context = self._expand_operation(function.with_new_declaration(decl))
+        function_context = cast(FunctionContext, context)
+        closure_id = function_context.closure.closure_id
+        if closure_id in self._expanded_functions:
+            function_def = self._expanded_functions[closure_id]
+            self._expanded_functions_compilation_metadata[
+                function_def.name
+            ].occurrences_number += 1
+            return function_def
+
+        function_def = self._create_function_definition(function_context)
+        self._expanded_functions[closure_id] = function_def
+        self._top_level_scope[function_def.name] = Evaluated(
+            value=function_context.closure.with_new_declaration(function_def)
+        )
+        compilation_metadata = self._functions_compilation_metadata.get(function.name)
+        if compilation_metadata is not None:
+            self._expanded_functions_compilation_metadata[function_def.name] = (
+                compilation_metadata
+            )
+        return function_def
+
     def _create_function_definition(
         self, function_context: FunctionContext
     ) -> NativeFunctionDefinition:
@@ -268,47 +264,3 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 evaluated_args,
             ),
         )
-
-    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
-        if function.name not in QMODULE.native_defs:
-            return False
-
-        if isinstance(function, GenerativeClosure):
-            return False
-
-        if any(
-            not param.quantum_type.is_instantiated
-            for param in function.positional_arg_declarations
-            if isinstance(param, PortDeclaration)
-            and param.direction == PortDeclarationDirection.Output
-        ):
-            return False
-
-        dependencies = QMODULE.function_dependencies[function.name]
-        return self._are_identifiers_purely_declarative(dependencies)
-
-    def _are_args_purely_declarative(self, args: list[ArgValue]) -> bool:
-        if any(
-            isinstance(arg, (OperandIdentifier, QuantumLambdaFunction))
-            or (
-                isinstance(arg, list)
-                and any(
-                    isinstance(item, (OperandIdentifier, QuantumLambdaFunction))
-                    for item in arg
-                )
-            )
-            for arg in args
-        ):
-            return False
-
-        dependencies = [arg for arg in args if isinstance(arg, str)]
-        dependencies += [
-            cast(str, item) for arg in args if isinstance(arg, list) for item in arg
-        ]
-        return self._are_identifiers_purely_declarative(dependencies)
-
-    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
-        return not any(
-            isinstance(self._current_scope[dep].value, GenerativeClosure)
-            for dep in dependencies
-        )

classiq/model_expansions/quantum_operations/declarative_call_emitter.py

@@ -0,0 +1,87 @@
+from itertools import chain
+from typing import TYPE_CHECKING, Generic
+
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeClosure
+from classiq.model_expansions.quantum_operations.call_emitter import CallEmitter
+from classiq.model_expansions.quantum_operations.emitter import QuantumStatementT
+from classiq.model_expansions.scope import Evaluated
+from classiq.qmod.model_state_container import QMODULE
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.interpreters.generative_interpreter import (
+        GenerativeInterpreter,
+    )
+
+
+class DeclarativeCallEmitter(
+    Generic[QuantumStatementT], CallEmitter[QuantumStatementT]
+):
+    _interpreter: "GenerativeInterpreter"
+
+    def __init__(self, interpreter: "GenerativeInterpreter") -> None:
+        super().__init__(interpreter)
+
+    def should_expand_function(
+        self, function: FunctionClosure, args: list[Evaluated]
+    ) -> bool:
+        if not super().should_expand_function(function, args):
+            return False
+
+        if self._is_function_purely_declarative(
+            function
+        ) and self._are_args_purely_declarative(args):
+            self._interpreter.add_purely_declarative_function(function)
+            return False
+
+        return True
+
+    def _is_function_purely_declarative(self, function: FunctionClosure) -> bool:
+        if function.name not in QMODULE.native_defs:
+            return False
+
+        if isinstance(function, GenerativeClosure):
+            return False
+
+        if any(
+            not param.quantum_type.is_instantiated
+            for param in function.positional_arg_declarations
+            if isinstance(param, PortDeclaration)
+            and param.direction == PortDeclarationDirection.Output
+        ):
+            return False
+
+        dependencies = QMODULE.function_dependencies[function.name]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_args_purely_declarative(self, args: list[Evaluated]) -> bool:
+        values = [arg.value for arg in args]
+        function_inputs: list[FunctionClosure] = list(
+            chain.from_iterable(
+                (
+                    [arg]
+                    if isinstance(arg, FunctionClosure)
+                    else (
+                        arg
+                        if isinstance(arg, list)
+                        and any(isinstance(item, FunctionClosure) for item in arg)
+                        else []
+                    )
+                )
+                for arg in values
+            )
+        )
+        if any(func.is_lambda for func in function_inputs):
+            return False
+        dependencies = [func.name for func in function_inputs if not func.is_lambda]
+        return self._are_identifiers_purely_declarative(dependencies)
+
+    def _are_identifiers_purely_declarative(self, dependencies: list[str]) -> bool:
+        return not any(
+            isinstance(self._current_scope[dep].value, GenerativeClosure)
+            for dep in dependencies
+        )

classiq/model_expansions/quantum_operations/emitter.py

@@ -19,6 +19,7 @@ from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.quantum_function_declaration import (
@@ -40,13 +41,13 @@ from classiq.model_expansions.visitors.variable_references import VarRefCollecto
 from classiq.qmod.quantum_function import GenerativeQFunc
 
 if TYPE_CHECKING:
-    from classiq.model_expansions.interpreter import Interpreter
+    from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
 
 
 class Emitter(Generic[QuantumStatementT]):
-    def __init__(self, interpreter: "Interpreter") -> None:
+    def __init__(self, interpreter: "BaseInterpreter") -> None:
         self._interpreter = interpreter
 
         self._machine_precision = self._interpreter._model.preferences.machine_precision
@@ -80,6 +81,10 @@ class Emitter(Generic[QuantumStatementT]):
     def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
 
+    @property
+    def _expanded_functions_by_name(self) -> dict[str, NativeFunctionDefinition]:
+        return nameables_to_dict(list(self._interpreter._expanded_functions.values()))
+
     @property
     def _counted_name_allocator(self) -> CountedNameAllocator:
         return self._interpreter._counted_name_allocator