classiq 0.66.0__py3-none-any.whl → 0.67.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/bind.py

@@ -1,4 +1,7 @@
-from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
 from classiq.interface.model.bind_operation import BindOperation
 
 from classiq.model_expansions.evaluators.parameter_types import (
@@ -9,21 +12,12 @@ from classiq.model_expansions.evaluators.quantum_type_utils import (
     validate_bind_targets,
 )
 from classiq.model_expansions.quantum_operations.emitter import Emitter
-from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 
 class BindEmitter(Emitter[BindOperation]):
     def emit(self, bind: BindOperation, /) -> None:
-        inputs: list[QuantumSymbol] = [
-            self._interpreter.evaluate(arg).as_type(QuantumSymbol)
-            for arg in bind.in_handles
-        ]
-        outputs: list[QuantumSymbol] = [
-            self._interpreter.evaluate(arg).as_type(QuantumSymbol)
-            for arg in bind.out_handles
-        ]
-        inputs = evaluate_types_in_quantum_symbols(inputs, self._current_scope)
-        outputs = evaluate_types_in_quantum_symbols(outputs, self._current_scope)
+        inputs, outputs = self._get_inputs_outputs(bind)
         validate_bind_targets(bind, self._current_scope)
         unsized_outputs = [
             output for output in outputs if not output.quantum_type.has_size_in_bits
@@ -56,5 +50,63 @@ class BindEmitter(Emitter[BindOperation]):
                 )
 
         self.emit_statement(
-            BindOperation(in_handles=bind.in_handles, out_handles=bind.out_handles)
+            BindOperation(
+                in_handles=bind.in_handles,
+                out_handles=bind.out_handles,
+                back_ref=bind.uuid,
+            )
         )
+
+    def _get_inputs_outputs(
+        self, bind: BindOperation
+    ) -> tuple[list[QuantumSymbol], list[QuantumSymbol]]:
+        evaluated_inputs: list[Evaluated] = [
+            self._interpreter.evaluate(arg) for arg in bind.in_handles
+        ]
+        evaluated_outputs: list[Evaluated] = [
+            self._interpreter.evaluate(arg) for arg in bind.out_handles
+        ]
+        self._validate_handle_states(evaluated_inputs, evaluated_outputs)
+        inputs: list[QuantumSymbol] = [
+            input.as_type(QuantumSymbol) for input in evaluated_inputs
+        ]
+        outputs: list[QuantumSymbol] = [
+            output.as_type(QuantumSymbol) for output in evaluated_outputs
+        ]
+        inputs = evaluate_types_in_quantum_symbols(inputs, self._current_scope)
+        outputs = evaluate_types_in_quantum_symbols(outputs, self._current_scope)
+        return inputs, outputs
+
+    def _validate_handle_states(
+        self, inputs: list[Evaluated], outputs: list[Evaluated]
+    ) -> None:
+        input_var_names: set[str] = set()
+        for inp in inputs:
+            if inp.defining_function is None:
+                raise ClassiqInternalExpansionError
+            var_name = inp.value.handle.name
+            input_var_names.add(var_name)
+            state = self._builder.current_block.captured_vars.get_state(
+                var_name, inp.defining_function
+            )
+            if not state:
+                raise ClassiqExpansionError(
+                    f"Cannot use uninitialized quantum variable "
+                    f"{inp.value.handle.name!r} on the left-hand side of a bind "
+                    f"statement"
+                )
+        for out in outputs:
+            if out.defining_function is None:
+                raise ClassiqInternalExpansionError
+            var_name = out.value.handle.name
+            if var_name in input_var_names:
+                continue
+            state = self._builder.current_block.captured_vars.get_state(
+                var_name, out.defining_function
+            )
+            if state:
+                raise ClassiqExpansionError(
+                    f"Cannot use initialized quantum variable "
+                    f"{out.value.handle.name!r} on the right-hand side of a bind "
+                    f"statement"
+                )

classiq/model_expansions/quantum_operations/call_emitter.py

@@ -1,13 +1,17 @@
 from collections.abc import Sequence
-from itertools import chain
+from itertools import chain, combinations
 from typing import (
     TYPE_CHECKING,
     Generic,
-    Optional,
     cast,
 )
+from uuid import UUID
 
 from classiq.interface.debug_info.debug_info import FunctionDebugInfo
+from classiq.interface.exceptions import ClassiqExpansionError
+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,
@@ -26,6 +30,8 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 
 from classiq.model_expansions.capturing.captured_vars import (
+    INITIALIZED_VAR_MESSAGE,
+    UNINITIALIZED_VAR_MESSAGE,
     validate_args_are_not_propagated,
 )
 from classiq.model_expansions.closure import FunctionClosure
@@ -53,6 +59,25 @@ if TYPE_CHECKING:
     from classiq.model_expansions.interpreters.base_interpreter import BaseInterpreter
 
 
+def _validate_cloning(evaluated_args: list[Evaluated]) -> None:
+    handles = [
+        arg.value.handle
+        for arg in evaluated_args
+        if isinstance(arg.value, QuantumSymbol)
+    ]
+    for handle, other_handle in combinations(handles, 2):
+        if handle.overlaps(other_handle):
+            if handle == other_handle:
+                raise ClassiqExpansionError(
+                    f"Quantum cloning violation: Argument {str(handle)!r} is "
+                    f"duplicated"
+                )
+            raise ClassiqExpansionError(
+                f"Quantum cloning violation: Arguments {str(handle)!r} and "
+                f"{str(other_handle)!r} overlap"
+            )
+
+
 class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSplitter):
     def __init__(self, interpreter: "BaseInterpreter") -> None:
         Emitter.__init__(self, interpreter)
@@ -71,15 +96,15 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             name=self._counted_name_allocator.allocate(name),
             body=body,
             scope=Scope(parent=self._current_scope),
-            is_lambda=True,
+            lambda_external_vars=self._builder.current_block.captured_vars,
         )
-        return self._create_quantum_function_call(wrapping_function, list())
+        return self._create_quantum_function_call(wrapping_function, list(), None)
 
     def _emit_quantum_function_call(
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: Optional[FunctionDebugInfo] = None,
+        propagated_debug_info: FunctionDebugInfo | None,
     ) -> QuantumFunctionCall:
         call = self._create_quantum_function_call(
             function, args, propagated_debug_info=propagated_debug_info
@@ -87,15 +112,27 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         self.emit_statement(call)
         return call
 
+    @staticmethod
+    def _get_back_ref(
+        propagated_debug_info: FunctionDebugInfo | None,
+    ) -> UUID | None:
+        if propagated_debug_info is None:
+            return None
+        if propagated_debug_info.node is None:
+            return None
+        return propagated_debug_info.node.uuid
+
     def _create_quantum_function_call(
         self,
         function: FunctionClosure,
         args: list[ArgValue],
-        propagated_debug_info: Optional[FunctionDebugInfo] = None,
+        propagated_debug_info: FunctionDebugInfo | None,
     ) -> QuantumFunctionCall:
         function = function.clone()
         function = function.set_depth(self._builder.current_function.depth + 1)
+        self._validate_call_args(function.positional_arg_declarations, args)
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
+        _validate_cloning(evaluated_args)
         new_declaration = self._prepare_fully_typed_declaration(
             function, evaluated_args
         )
@@ -114,13 +151,15 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         new_positional_args = self._get_new_positional_args(
             evaluated_args, is_atomic, new_positional_arg_decls
         )
-        captured_args = function.captured_vars.get_captured_args(
+        captured_args = function.captured_vars.filter_vars(function).get_captured_args(
             self._builder.current_function
         )
         validate_args_are_not_propagated(new_positional_args, captured_args)
         new_positional_args.extend(captured_args)
         new_call = QuantumFunctionCall(
-            function=new_declaration.name, positional_args=new_positional_args
+            function=new_declaration.name,
+            positional_args=new_positional_args,
+            back_ref=self._get_back_ref(propagated_debug_info),
         )
         is_allocate_or_free = new_call.func_name == free.func_decl.name
         parameters = {
@@ -144,6 +183,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
             ),
             is_allocate_or_free=is_allocate_or_free,
             port_to_passed_variable_map=port_to_passed_variable_map,
+            node=new_call._as_back_ref(),
         )
         new_call.set_func_decl(new_declaration)
         return new_call
@@ -187,7 +227,10 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
     ) -> NativeFunctionDefinition:
         func_def = self._builder.create_definition(function_context)
 
-        captured_ports = function_context.closure.captured_vars.get_captured_ports()
+        captured_vars = function_context.closure.captured_vars.filter_vars(
+            function_context.closure
+        )
+        captured_ports = captured_vars.get_captured_ports()
         if len(captured_ports) == 0:
             return func_def
         func_def.positional_arg_declarations = list(
@@ -197,7 +240,7 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
         if not function_context.is_lambda:
             return func_def
         func_def.body = self.rewrite(
-            func_def.body, function_context.closure.captured_vars.get_captured_mapping()
+            func_def.body, captured_vars.get_captured_mapping()
         )
 
         return func_def
@@ -265,3 +308,29 @@ class CallEmitter(Generic[QuantumStatementT], Emitter[QuantumStatementT], VarSpl
                 evaluated_args,
             ),
         )
+
+    def _validate_call_args(
+        self, params: Sequence[PositionalArg], args: list[ArgValue]
+    ) -> None:
+        for param, arg in zip(params, args):
+            if not isinstance(param, PortDeclaration) or not isinstance(
+                arg, HandleBinding
+            ):
+                continue
+            var_name = arg.name
+            symbol = self._interpreter.evaluate(var_name)
+            if (
+                not isinstance(symbol.value, QuantumSymbol)
+                or symbol.defining_function is None
+            ):
+                continue
+            var_state = self._builder.current_block.captured_vars.get_state(
+                var_name, symbol.defining_function
+            )
+            if not var_state and param.direction in (
+                PortDeclarationDirection.Inout,
+                PortDeclarationDirection.Input,
+            ):
+                raise ClassiqExpansionError(UNINITIALIZED_VAR_MESSAGE.format(var_name))
+            if var_state and param.direction == PortDeclarationDirection.Output:
+                raise ClassiqExpansionError(INITIALIZED_VAR_MESSAGE.format(var_name))

classiq/model_expansions/quantum_operations/classicalif.py

@@ -1,5 +1,6 @@
 from collections.abc import Sequence
 
+from classiq.interface.debug_info.debug_info import new_function_debug_info_by_node
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_statement import QuantumStatement
@@ -48,6 +49,8 @@ class ClassicalIfEmitter(CallEmitter[ClassicalIf]):
             name=self._counted_name_allocator.allocate("then" if condition else "else"),
             body=body,
             scope=Scope(parent=self._current_scope),
-            is_lambda=True,
+            lambda_external_vars=self._builder.current_block.captured_vars,
+        )
+        self._emit_quantum_function_call(
+            then_else_func, list(), new_function_debug_info_by_node(classical_if)
         )
-        self._emit_quantum_function_call(then_else_func, list())

classiq/model_expansions/quantum_operations/emitter.py

@@ -9,7 +9,10 @@ from typing import (
 
 import sympy
 
-from classiq.interface.debug_info.debug_info import DebugInfoCollection
+from classiq.interface.debug_info.debug_info import (
+    DebugInfoCollection,
+    new_function_debug_info_by_node,
+)
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
@@ -140,6 +143,10 @@ class Emitter(Generic[QuantumStatementT], ABC):
     def emit_statement(self, statement: QuantumStatement) -> None:
         if isinstance(statement, QuantumOperation):
             self._update_captured_vars(statement)
+        if statement.uuid not in self._interpreter._model.debug_info:
+            self._interpreter._model.debug_info[statement.uuid] = (
+                new_function_debug_info_by_node(statement)  # type:ignore[arg-type]
+            )
         self._builder.emit_statement(statement)
 
     def _update_captured_vars(self, op: QuantumOperation) -> None:

classiq/model_expansions/quantum_operations/repeat.py

@@ -1,3 +1,4 @@
+from classiq.interface.debug_info.debug_info import new_function_debug_info_by_node
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.builtins.internal_operators import (
@@ -50,7 +51,11 @@ class RepeatEmitter(CallEmitter[Repeat]):
             ],
             body=repeat.body,
             scope=Scope(parent=self._current_scope),
-            is_lambda=True,
+            lambda_external_vars=self._builder.current_block.captured_vars,
             **extra_args,
         )
-        self._emit_quantum_function_call(iteration_function, [Expression(expr=str(i))])
+        self._emit_quantum_function_call(
+            iteration_function,
+            [Expression(expr=str(i))],
+            new_function_debug_info_by_node(repeat),
+        )

classiq/model_expansions/quantum_operations/shallow_emitter.py

@@ -70,7 +70,7 @@ class ShallowEmitter(Emitter[QuantumOperation]):
             expanded_components[handle_name] = self._interpreter.evaluate(
                 handle
             ).value.handle
-
+        expanded_components["back_ref"] = op.uuid
         op = op.model_copy(update=expanded_components)
         if isinstance(op, QuantumAssignmentOperation):
             self._post_process_assignment(op)

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -1,3 +1,4 @@
+from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -12,8 +13,14 @@ from classiq.model_expansions.scope import Evaluated, QuantumSymbol
 
 class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
     def emit(self, variable_declaration: VariableDeclarationStatement, /) -> None:
-        var_decl = variable_declaration.model_copy()
+        var_decl = variable_declaration.model_copy(
+            update=dict(back_ref=variable_declaration.uuid)
+        )
         var_decl.quantum_type = variable_declaration.quantum_type.model_copy()
+        if variable_declaration.name in self._current_scope:
+            raise ClassiqExpansionError(
+                f"Variable {variable_declaration.name!r} is already defined"
+            )
         self._current_scope[variable_declaration.name] = Evaluated(
             value=QuantumSymbol(
                 handle=HandleBinding(name=var_decl.name),
@@ -25,4 +32,7 @@ class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement])
             ),
             defining_function=self._builder.current_function,
         )
+        self._builder.current_block.captured_vars.init_var(
+            var_decl.name, self._builder.current_function
+        )
         self.emit_statement(var_decl)

classiq/open_library/functions/__init__.py

@@ -1,3 +1,7 @@
+from .amplitude_amplification import (
+    amplitude_amplification,
+    exact_amplitude_amplification,
+)
 from .amplitude_estimation import *
 from .discrete_sine_cosine_transform import *
 from .discrete_sine_cosine_transform import _qct_d_operator, _qct_pi_operator
@@ -23,6 +27,8 @@ OPEN_LIBRARY_FUNCTIONS = [
     _single_pauli,
     linear_pauli_rotations,
     amplitude_estimation,
+    amplitude_amplification,
+    exact_amplitude_amplification,
     phase_oracle,
     reflect_about_zero,
     grover_diffuser,
@@ -78,12 +84,14 @@ OPEN_LIBRARY_FUNCTIONS = [
 __all__ = [
     "_single_pauli",
     "allocate_num",
+    "amplitude_amplification",
     "amplitude_estimation",
     "apply_to_all",
     "c_modular_multiply",
     "cc_modular_add",
     "encode_in_angle",
     "encode_on_bloch",
+    "exact_amplitude_amplification",
     "full_hea",
     "grover_diffuser",
     "grover_operator",

classiq/open_library/functions/amplitude_amplification.py

@@ -0,0 +1,92 @@
+from classiq.open_library.functions.grover import grover_operator
+from classiq.qmod.builtins.functions.standard_gates import RY
+from classiq.qmod.builtins.operations import (
+    allocate,
+    bind,
+    control,
+    repeat,
+    within_apply,
+)
+from classiq.qmod.cparam import CInt, CReal
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QArray, QBit
+from classiq.qmod.quantum_callable import QCallable
+from classiq.qmod.symbolic import acos, asin, ceiling, pi, sin
+
+
+@qfunc
+def amplitude_amplification(
+    reps: CInt,
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    packed_qvars: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies the Amplitude Amplification algorithm (QAE); Prepares a state using the given `space_transform` function, and applies `reps` repetititions
+    of the grover operator, using the given `oracle` functions which marks the "good" states.
+
+    Args:
+        reps: Number of repetitions to apply the grover operator on the initial state. Should be determined by the user, according to the calculated amplification.
+        oracle: The oracle operator that marks the "good" states. This operator should flip the sign of the amplitude of the "good" state.
+        space_transform: The space transform operator (which is known also the state preparation operator). First applied to prepare the state before the amplification, then used inside the Grover operator.
+        packed_vars: The variable that holds the state to be amplified. Assumed to be in the zero state at the beginning of the algorithm.
+    """
+    space_transform(packed_qvars)
+    repeat(reps, lambda index: grover_operator(oracle, space_transform, packed_qvars))
+
+
+@qfunc
+def exact_amplitude_amplification(
+    amplitude: CReal,
+    oracle: QCallable[QArray[QBit]],
+    space_transform: QCallable[QArray[QBit]],
+    packed_qvars: QArray[QBit],
+) -> None:
+    """
+    [Qmod Classiq-library function]
+
+    Applies an exact version of the Amplitude Amplification algorithm (QAE), assuming knowledge of the amplitude of the marked state.
+    The function should be applied on the zero state, and it takes care for preparing the initial state before amplification using the `space_transform`.
+
+    Based on the algorithm in [Quantum state preparation without coherent arithmetic](https://arxiv.org/abs/2210.14892).
+
+    Assuming the `space_transform` creates a state $|\\psi\\rangle = a|\\psi_{good}\\rangle + \\sqrt{1-a}|\\psi_{bad}\\rangle$, given `a` as the `amplitude`
+    argument, the function will load exactly the state $|\\psi_{good}\\rangle$.
+
+    Note: if the `amplitude` argument is not exact, the resulting state will not be exactly $|\\psi_{good}\\rangle$, and there will be additional internal auxilliary of the function that is not released correctly.
+
+    Args:
+        amplitude: The amplitude of the state $|\\psi_{good}\\rangle$ with regards to the initial state prepared by `space_transform`.
+        oracle: The oracle operator that marks the "good" states. This operator should flip the sign of the amplitude of the "good" state.
+        space_transform: The space transform operator (which is known also the state preparation operator). First applied to prepare the state before the amplification, then used inside the Grover operator.
+        packed_vars: The variable that holds the state to be amplified. Assumed to be in the zero state at the beginning of the algorithm.
+    """
+    aux = QBit()
+    k = ceiling((pi / (4 * asin(amplitude))) - 0.5)
+    theta = pi / (4 * k + 2)
+    rot_phase = 2 * acos(sin(theta) / amplitude)
+
+    extended_qvars: QArray = QArray("extended_qvars")
+    within_apply(
+        lambda: [  # type:ignore[arg-type]
+            allocate(aux),
+            bind(
+                [aux, packed_qvars], extended_qvars
+            ),  # type:ignore[func-returns-value]
+        ],
+        lambda: amplitude_amplification(
+            k,
+            lambda qvars_: control(
+                qvars_[0] == 0, lambda: oracle(qvars_[1 : qvars_.size])
+            ),
+            lambda qvars_: [
+                space_transform(  # type:ignore[func-returns-value]
+                    qvars_[1 : qvars_.size]
+                ),
+                RY(rot_phase, qvars_[0]),
+            ],
+            extended_qvars,
+        ),
+    )

classiq/open_library/functions/grover.py

@@ -56,8 +56,8 @@ def reflect_about_zero(packed_vars: QArray[QBit]) -> None:
     besides the |0> state). Implements the operator $S_0$:
 
     $$
-    \begin{equation}
-    S_0|{x}\rangle = (-1)^{(x\ne0)}|{x}\rangle= (2|{0}\rangle\\langle{0}|-I)|{x}\rangle
+    \\begin{equation}
+    S_0|{x}\\rangle = (-1)^{(x\\ne0)}|{x}\\rangle= (2|{0}\\rangle\\langle{0}|-I)|{x}\\rangle
     \\end{equation}
     $$
 
@@ -85,7 +85,7 @@ def grover_diffuser(
     is the `space_transform` parameter. It is defined as:
 
     $$
-    \begin{equation}
+    \\begin{equation}
     D = A S_0 A^{\\dagger}
     \\end{equation}
     $$
@@ -118,11 +118,11 @@ def grover_operator(
     $$
 
     where $S_{\\psi_1}$ is a reflection about marked states, and $S_{\\psi_0}$ is a reflection
-    about a given state defined by $|\\psi_0\rangle = A|0\rangle$.
+    about a given state defined by $|\\psi_0\\rangle = A|0\\rangle$.
 
     Args:
         oracle: A unitary operator which adds a phase of (-1) to marked states.
-        space_transform: The operator which creates $|\\psi_0\rangle$, the initial state, used by the diffuser to reflect about it.
+        space_transform: The operator which creates $|\\psi_0\\rangle$, the initial state, used by the diffuser to reflect about it.
         packed_vars: The state to which to apply the grover operator.
     """
     oracle(packed_vars)

classiq/qmod/builtins/functions/__init__.py

@@ -4,6 +4,7 @@ from .benchmarking import *
 from .chemistry import *
 from .exponentiation import *
 from .finance import *
+from .mid_circuit_measurement import *
 from .operators import *
 from .qsvm import *
 from .standard_gates import *
@@ -66,6 +67,7 @@ CORE_LIB_DECLS = [
         suzuki_trotter,
         qdrift,
         exponentiation_with_depth_constraint,
+        RESET,
     )
 ]
 
@@ -129,6 +131,7 @@ __all__ = [  # noqa: RUF022
     "single_pauli_exponent",
     "suzuki_trotter",
     "unitary",
+    "RESET",
 ]
 BUILTIN_FUNCTION_DECLARATIONS = {
     func_decl.name: func_decl for func_decl in STD_QMOD_OPERATORS + CORE_LIB_DECLS

classiq/qmod/builtins/functions/mid_circuit_measurement.py

@@ -0,0 +1,15 @@
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_variable import QBit
+
+
+@qfunc(external=True)
+def RESET(target: QBit) -> None:
+    """
+    Resets the target qubit to the |0> state.
+
+    Performed by measuring the qubit and applying an X gate if necessary.
+
+    Args:
+        target: the qubit to reset
+    """
+    pass

classiq/qmod/quantum_function.py

@@ -31,6 +31,7 @@ from classiq.qmod.qmod_parameter import CArray, CParam
 from classiq.qmod.qmod_variable import QVar
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 from classiq.qmod.quantum_expandable import QExpandable, QTerminalCallable
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
 from classiq.qmod.utilities import mangle_keyword
 
 
@@ -161,6 +162,9 @@ class QFunc(BaseQFunc):
         )
 
         generative_functions = list(self._qmodule.generative_functions.values())
+        QStructAnnotator().visit(model_stub)
+        for gen_func in generative_functions:
+            QStructAnnotator().visit(gen_func.func_decl)
         resolve_function_calls(
             model_stub,
             dict(model_stub.function_dict)

classiq/qmod/semantics/annotation/call_annotation.py

@@ -1,6 +1,6 @@
 from collections.abc import Iterator, Mapping
 from contextlib import contextmanager
-from typing import Any
+from typing import Any, Optional
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.expressions.expression import Expression
@@ -11,6 +11,7 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
+from classiq.interface.model.model import Model
 from classiq.interface.model.model_visitor import ModelVisitor
 from classiq.interface.model.native_function_definition import NativeFunctionDefinition
 from classiq.interface.model.port_declaration import PortDeclaration
@@ -108,8 +109,13 @@ class _CallLambdaAnnotator(ModelVisitor):
 
 def resolve_function_calls(
     root: Any,
-    quantum_function_dict: Mapping[str, QuantumFunctionDeclaration],
+    quantum_function_dict: Optional[Mapping[str, QuantumFunctionDeclaration]] = None,
 ) -> None:
+    if quantum_function_dict is None:
+        quantum_function_dict = {}
+    quantum_function_dict = dict(quantum_function_dict)
+    if isinstance(root, Model):
+        quantum_function_dict |= root.function_dict
     all_functions: Mapping[str, QuantumFunctionDeclaration] = {
         **BUILTIN_FUNCTION_DECLARATIONS,
         **quantum_function_dict,

classiq/qmod/semantics/annotation/model_annotation.py

@@ -0,0 +1,9 @@
+from classiq.interface.model.model import Model
+
+from classiq.qmod.semantics.annotation.call_annotation import resolve_function_calls
+from classiq.qmod.semantics.annotation.qstruct_annotator import QStructAnnotator
+
+
+def annotate_model(model: Model) -> None:
+    QStructAnnotator().visit(model)
+    resolve_function_calls(model)

classiq/qmod/semantics/error_manager.py

@@ -94,9 +94,3 @@ class ErrorManager:
         self._call_stack.append(func_name)
         yield
         self._call_stack.pop()
-
-
-def append_error(node: ASTNode, message: str) -> None:
-    instance = ErrorManager()
-    with instance.node_context(node):
-        instance.add_error(message)