classiq 0.45.1__py3-none-any.whl → 0.46.1__py3-none-any.whl

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -0,0 +1,174 @@
+import ast
+from typing import Tuple
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.compiler_keywords import INPLACE_ARITH_AUX_VAR_PREFIX
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.inplace_binary_operation import (
+    BinaryOperation,
+    InplaceBinaryOperation,
+)
+from classiq.interface.model.quantum_expressions.arithmetic_operation import (
+    ArithmeticOperation,
+)
+from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
+)
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
+)
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.evaluators.quantum_type_utils import copy_type_information
+from classiq.model_expansions.quantum_operations.expression_operation import (
+    ExpressionOperationEmitter,
+)
+from classiq.model_expansions.scope import QuantumSymbol
+from classiq.model_expansions.visitors.boolean_expression_transformers import (
+    BooleanExpressionFuncLibAdapter,
+    BooleanExpressionOptimizer,
+)
+from classiq.qmod import builtins
+from classiq.qmod.builtins.functions import X
+
+
+class QuantumAssignmentOperationEmitter(
+    ExpressionOperationEmitter[QuantumAssignmentOperation]
+):
+    def emit(self, op: QuantumAssignmentOperation, /) -> None:
+        new_expression = self._evaluate_op_expression(op)
+        arrays_with_subscript = self._get_symbols_to_split(new_expression)
+        if len(arrays_with_subscript) > 0:
+            self._emit_with_split(op, new_expression, arrays_with_subscript)
+            return
+
+        self._emit_op(new_expression, op)
+
+    def _emit_op(self, expression: Expression, op: QuantumAssignmentOperation) -> None:
+        op = self._evaluate_types_in_expression(op, expression)
+        with self._propagated_var_stack.capture_variables(op):
+            pass  # This propagates the expression variables
+        if isinstance(op, ArithmeticOperation):
+            self._emit_arithmetic_op(op, expression)
+            return
+        self._emit_general_assignment_operation(op)
+
+    def _emit_arithmetic_op(
+        self, op: ArithmeticOperation, expression: Expression
+    ) -> None:
+        op, expression, is_bool_opt = self._optimize_boolean_expression(op, expression)
+        if op.inplace_result:
+            self._emit_inplace_arithmetic_op(op, expression, is_bool_opt)
+        else:
+            self._emit_general_assignment_operation(op)
+
+    def _emit_inplace_arithmetic_op(
+        self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
+    ) -> None:
+        if op.result_type.size_in_bits > 1 or not _is_res_boolean(op):
+            _validate_naive_inplace_handles(op)
+            self._build_naive_inplace(op, expression)
+            return
+
+        op, expression, to_invert = self._adapt_boolean_inplace(
+            op, expression, is_bool_opt
+        )
+        self._emit_general_assignment_operation(op)
+        if not to_invert:
+            return
+
+        call = QuantumFunctionCall(
+            function=builtins.functions.X.__name__,  # type:ignore[attr-defined]
+            positional_args=[op.result_var],
+            source_ref=op.source_ref,
+        )
+        call.set_func_decl(X.func_decl)
+        self._interpreter.emit_statement(call)
+
+    def _emit_general_assignment_operation(
+        self, op: QuantumAssignmentOperation
+    ) -> None:
+        result = self._interpreter.evaluate(op.result_var).as_type(QuantumSymbol)
+        copy_type_information(op.result_type, result.quantum_type, str(result.handle))
+        self._builder.emit_statement(op)
+
+    def _optimize_boolean_expression(
+        self, op: ArithmeticOperation, expression: Expression
+    ) -> Tuple[ArithmeticOperation, Expression, bool]:
+        if not _all_vars_boolean(op):
+            return op, expression, False
+        optimizer = BooleanExpressionOptimizer()
+        optimized_expression = Expression(
+            expr=ast.unparse(optimizer.visit(ast.parse(expression.expr)))
+        )
+        optimized_expression = self._evaluate_expression(optimized_expression)
+        optimized_op = op.copy(update=dict(expression=optimized_expression))
+        return optimized_op, optimized_expression, optimizer.is_convertible
+
+    def _adapt_boolean_inplace(
+        self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
+    ) -> Tuple[ArithmeticOperation, Expression, bool]:
+        adapter = BooleanExpressionFuncLibAdapter(is_bool_opt)
+        adapted_expression = self._evaluate_expression(
+            Expression(expr=ast.unparse(adapter.visit(ast.parse(expression.expr))))
+        )
+        adapted_op = op.copy(update=dict(expression=adapted_expression))
+        return adapted_op, adapted_expression, adapter.to_invert
+
+    def _build_naive_inplace(
+        self, qe: ArithmeticOperation, new_expression: Expression
+    ) -> None:
+        aux_var = self._counted_name_allocator.allocate(INPLACE_ARITH_AUX_VAR_PREFIX)
+        self._interpreter.emit_statement(
+            VariableDeclarationStatement(name=aux_var, quantum_type=QuantumNumeric())
+        )
+        arith_expression = ArithmeticOperation(
+            result_var=HandleBinding(name=aux_var),
+            expression=new_expression,
+            inplace_result=False,
+        )
+        inplace_store = InplaceBinaryOperation(
+            operation=BinaryOperation.Xor,
+            target=qe.result_var,
+            value=HandleBinding(name=aux_var),
+        )
+        self._interpreter.emit_statement(
+            WithinApply(compute=[arith_expression], action=[inplace_store])
+        )
+
+
+def _validate_naive_inplace_handles(qe: ArithmeticOperation) -> None:
+    if qe.result_var in qe.var_handles:
+        raise ClassiqExpansionError(
+            f"Quantum variable {qe.result_var.name} cannot appear on both sides of "
+            f"the ^= assignment"
+        )
+
+
+def _all_vars_boolean(op: ArithmeticOperation) -> bool:
+    if not all(
+        var_type.has_size_in_bits and var_type.size_in_bits == 1
+        for var_type in op.var_types.values()
+    ):
+        return False
+    if any(
+        isinstance(var_type, QuantumNumeric)
+        and (var_type.sign_value or var_type.fraction_digits_value > 0)
+        for var_type in op.var_types.values()
+    ):
+        return False
+    return _is_res_boolean(op)
+
+
+def _is_res_boolean(op: ArithmeticOperation) -> bool:
+    if not (op.result_type.has_size_in_bits and op.result_type.size_in_bits == 1):
+        return False
+    return not (
+        isinstance(op.result_type, QuantumNumeric)
+        and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
+    )

classiq/model_expansions/quantum_operations/quantum_function_call.py

@@ -0,0 +1,15 @@
+from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.qmod.semantics.error_manager import ErrorManager
+
+
+class QuantumFunctionCallEmitter(Emitter[QuantumFunctionCall]):
+    def emit(self, call: QuantumFunctionCall, /) -> None:
+        function = self._interpreter.evaluate(call.function).as_type(FunctionClosure)
+        args = call.positional_args
+        with ErrorManager().call(
+            function.name
+        ), self._propagated_var_stack.capture_variables(call):
+            self._emit_quantum_function_call(function, args)

classiq/model_expansions/quantum_operations/repeat.py

@@ -0,0 +1,33 @@
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    REPEAT_OPERATOR_NAME,
+)
+from classiq.interface.generator.functions.classical_type import Integer
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.repeat import Repeat
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Scope
+
+
+class RepeatEmitter(Emitter[Repeat]):
+    def emit(self, repeat: Repeat, /) -> None:
+        count = self._interpreter.evaluate(repeat.count).as_type(int)
+        for i in range(count):
+            with self._propagated_var_stack.capture_variables(repeat):
+                iteration_function = FunctionClosure.create(
+                    name=REPEAT_OPERATOR_NAME,
+                    positional_arg_declarations=[
+                        ClassicalParameterDeclaration(
+                            name=repeat.iter_var, classical_type=Integer()
+                        )
+                    ],
+                    body=repeat.body,
+                    scope=Scope(parent=self._current_scope),
+                )
+                self._emit_quantum_function_call(
+                    iteration_function, [Expression(expr=str(i))]
+                )

classiq/model_expansions/quantum_operations/variable_decleration.py

@@ -0,0 +1,28 @@
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.variable_declaration_statement import (
+    VariableDeclarationStatement,
+)
+
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_type_in_quantum_symbol,
+)
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol
+
+
+class VariableDeclarationStatementEmitter(Emitter[VariableDeclarationStatement]):
+    def emit(self, variable_declaration: VariableDeclarationStatement, /) -> None:
+        var_decl = variable_declaration.copy()
+        var_decl.quantum_type = variable_declaration.quantum_type.copy()
+        self._current_scope[variable_declaration.name] = Evaluated(
+            value=QuantumSymbol(
+                handle=HandleBinding(name=var_decl.name),
+                quantum_type=evaluate_type_in_quantum_symbol(
+                    var_decl.quantum_type,
+                    self._current_scope,
+                    var_decl.name,
+                ),
+            ),
+            defining_function=self._builder.current_function,
+        )
+        self._builder.emit_statement(var_decl)

classiq/model_expansions/quantum_operations/within_apply.py

@@ -0,0 +1,46 @@
+from classiq.interface.generator.functions.builtins.internal_operators import (
+    COMPUTE_OPERATOR_NAME,
+    WITHIN_APPLY_NAME,
+)
+from classiq.interface.model.within_apply_operation import WithinApply
+
+from classiq.model_expansions.closure import Closure
+from classiq.model_expansions.quantum_operations.emitter import Emitter
+from classiq.model_expansions.scope import Scope
+
+
+class WithinApplyEmitter(Emitter[WithinApply]):
+    def emit(self, within_apply: WithinApply, /) -> None:
+        if self._should_wrap(within_apply.compute):
+            self._emit_wrapped(within_apply)
+            return
+
+        self._emit_as_operation(within_apply)
+
+    def _emit_as_operation(self, within_apply: WithinApply) -> None:
+        within_apply_operation = Closure(
+            name=WITHIN_APPLY_NAME,
+            blocks=dict(within=within_apply.compute, apply=within_apply.action),
+            scope=Scope(parent=self._current_scope),
+        )
+        with self._propagated_var_stack.capture_variables(within_apply):
+            context = self._expand_operation(within_apply_operation)
+        self._builder.emit_statement(
+            WithinApply(
+                compute=context.statements("within"),
+                action=context.statements("apply"),
+                source_ref=within_apply.source_ref,
+            )
+        )
+
+    def _emit_wrapped(self, within_apply: WithinApply) -> None:
+        with self._propagated_var_stack.capture_variables(within_apply):
+            wrapped_compute = self._create_expanded_wrapping_function(
+                COMPUTE_OPERATOR_NAME, within_apply.compute
+            )
+        wrapped_within_apply = WithinApply(
+            compute=[wrapped_compute],
+            action=within_apply.action,
+            source_ref=within_apply.source_ref,
+        )
+        self._builder.emit_statement(wrapped_within_apply)

classiq/model_expansions/scope.py

@@ -0,0 +1,226 @@
+import itertools
+from collections import UserDict
+from dataclasses import dataclass
+from functools import singledispatch
+from typing import TYPE_CHECKING, Any, Dict, Iterator, Optional, Type, TypeVar, Union
+
+from typing_extensions import Self
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.qmod_qarray_proxy import (
+    ILLEGAL_SLICE_BOUNDS_MSG,
+)
+from classiq.interface.generator.expressions.qmod_struct_instance import (
+    QmodStructInstance,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+from classiq.interface.model.quantum_function_call import ArgValue
+from classiq.interface.model.quantum_type import (
+    QuantumBitvector,
+    QuantumType,
+)
+
+if TYPE_CHECKING:
+    from classiq.model_expansions.closure import Closure
+
+T = TypeVar("T")
+
+
+@dataclass(frozen=True)
+class QuantumSymbol:
+    handle: HandleBinding
+    quantum_type: QuantumType
+
+    @property
+    def is_subscript(self) -> bool:
+        return isinstance(self.handle, (SubscriptHandleBinding, SlicedHandleBinding))
+
+    def emit(self) -> HandleBinding:
+        return self.handle
+
+    def __getitem__(self, item: Union[slice, int]) -> "QuantumSymbol":
+        if isinstance(item, int):
+            return self._subscript(item)
+
+        return self._slice(item.start, item.stop)
+
+    def _slice(self, start: int, end: int) -> "QuantumSymbol":
+        if not isinstance(self.quantum_type, QuantumBitvector):
+            raise ClassiqExpansionError(
+                f"{self.quantum_type.type_name} is not subscriptable."
+            )
+        if start >= end:
+            raise ClassiqExpansionError(ILLEGAL_SLICE_BOUNDS_MSG.format(start, end))
+        if (
+            self.quantum_type.has_length
+            and end - start > self.quantum_type.length_value
+        ):
+            raise ClassiqExpansionError(
+                f"Slice [{start}:{end}] is out of bounds for {self.handle}."
+            )
+        return QuantumSymbol(
+            handle=SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(start)),
+                end=Expression(expr=str(end)),
+            ),
+            quantum_type=QuantumBitvector(
+                element_type=self.quantum_type.element_type,
+                length=Expression(expr=str(end - start)),
+            ),
+        )
+
+    def _subscript(self, index: int) -> "QuantumSymbol":
+        if not isinstance(self.quantum_type, QuantumBitvector):
+            raise ClassiqExpansionError(
+                f"{self.quantum_type.type_name} is not subscriptable."
+            )
+        if (
+            index < 0
+            or self.quantum_type.has_length
+            and index > self.quantum_type.length_value
+        ):
+            raise ClassiqExpansionError(
+                f"Subscript [{index}] is out of bounds for {self.handle}."
+            )
+        return QuantumSymbol(
+            handle=SubscriptHandleBinding(
+                base_handle=self.handle,
+                index=Expression(expr=str(index)),
+            ),
+            quantum_type=self.quantum_type.element_type,
+        )
+
+    @property
+    def fields(self) -> Dict[str, "QuantumSymbol"]:
+        quantum_type = self.quantum_type
+        if not isinstance(quantum_type, TypeName):
+            raise ClassiqExpansionError(
+                f"{self.quantum_type.type_name} is not a struct"
+            )
+        return {
+            field_name: QuantumSymbol(
+                handle=FieldHandleBinding(base_handle=self.handle, field=field_name),
+                quantum_type=field_type,
+            )
+            for field_name, field_type in quantum_type.fields.items()
+        }
+
+
+@singledispatch
+def _evaluated_to_str(value: Any) -> str:
+    return str(value)
+
+
+@_evaluated_to_str.register
+def _evaluated_to_str_list(value: list) -> str:
+    return f"[{', '.join(_evaluated_to_str(x) for x in value)}]"
+
+
+@_evaluated_to_str.register
+def _evaluated_to_str_struct_literal(value: QmodStructInstance) -> str:
+    return f"struct_literal({value.struct_declaration.name}, {', '.join(f'{k}={_evaluated_to_str(v)}' for k, v in value.fields.items())})"
+
+
+@dataclass(frozen=True)
+class Evaluated:  # FIXME: Merge with EvaluatedExpression if possible
+    value: Any
+    defining_function: Optional["Closure"] = None
+
+    def as_type(self, t: Type[T]) -> T:
+        if t is int:
+            return self._as_int()  # type: ignore[return-value]
+
+        if not isinstance(self.value, t):
+            raise ClassiqExpansionError(
+                f"Invalid access to expression {self.value!r} as {t}"
+            )
+
+        return self.value
+
+    def _as_int(self) -> int:
+        if not isinstance(self.value, (int, float)):
+            raise ClassiqExpansionError(
+                f"Invalid access to expression {self.value!r} as {int}"
+            )
+
+        return int(self.value)
+
+    def emit(self) -> ArgValue:
+        if isinstance(self.value, QuantumSymbol):
+            return self.value.emit()
+
+        ret = Expression(expr=_evaluated_to_str(self.value))
+        ret._evaluated_expr = EvaluatedExpression(value=self.value)
+        return ret
+
+
+if TYPE_CHECKING:
+    EvaluatedUserDict = UserDict[str, Evaluated]
+else:
+    EvaluatedUserDict = UserDict
+
+
+class Scope(EvaluatedUserDict):
+    def __init__(
+        self,
+        data: Optional[Dict[str, Evaluated]] = None,
+        /,
+        *,
+        parent: Optional[Self] = None,
+    ) -> None:
+        super().__init__(data or {})
+        self._parent: Optional[Self] = parent
+
+    @property
+    def parent(self) -> Optional[Self]:
+        return self._parent
+
+    def __getitem__(self, name: str) -> Evaluated:
+        if name in self.data:
+            return self.data[name]
+        if self._parent is not None:
+            return self._parent[name]
+        raise ClassiqExpansionError(f"Variable {name!r} is undefined")
+
+    def __contains__(self, item: Any) -> bool:
+        return item in self.data or (self._parent is not None and item in self._parent)
+
+    def __iter__(self) -> Iterator[str]:
+        if self._parent is None:
+            return iter(self.data)
+        return iter(itertools.chain(self.data, self._parent))
+
+    def iter_without_top_level(self) -> Iterator[str]:
+        if self.parent is None:
+            return iter(tuple())
+        return iter(itertools.chain(self.data, self.parent.iter_without_top_level()))
+
+    def __or__(self, other: Any) -> "Scope":  # type: ignore[override]
+        if not (isinstance(other, Scope) and isinstance(self, Scope)):
+            raise ClassiqInternalExpansionError
+
+        if self.parent is None:
+            parent = other.parent
+        elif other.parent is None:
+            parent = self.parent
+        else:
+            parent = self.parent | other.parent
+
+        return Scope(
+            (self.data or {}) | (other.data or {}),
+            parent=parent,
+        )

classiq/model_expansions/scope_initialization.py

@@ -0,0 +1,136 @@
+from typing import List, Sequence
+
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.expression_constants import (
+    CPARAM_EXECUTION_SUFFIX,
+)
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model
+from classiq.interface.model.native_function_definition import NativeFunctionDefinition
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import PositionalArg
+
+from classiq.model_expansions.closure import FunctionClosure, GenerativeFunctionClosure
+from classiq.model_expansions.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
+from classiq.model_expansions.evaluators.parameter_types import (
+    evaluate_type_in_quantum_symbol,
+)
+from classiq.model_expansions.expression_renamer import ExpressionRenamer
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+from classiq.qmod.builtins.functions import (
+    CORE_LIB_DECLS,
+    OPEN_LIB_DECLS,
+    STD_QMOD_OPERATORS,
+)
+from classiq.qmod.quantum_function import GenerativeQFunc
+
+
+def get_main_renamer(
+    functions: Sequence[NativeFunctionDefinition],
+) -> ExpressionRenamer:
+    for func in functions:
+        if func.name == MAIN_FUNCTION_NAME:
+            return ExpressionRenamer.from_positional_arg_declarations(
+                func.positional_arg_declarations, CPARAM_EXECUTION_SUFFIX
+            )
+    return ExpressionRenamer(var_mapping={})
+
+
+def _add_constants_to_scope(constants: List[Constant], scope: Scope) -> None:
+    for constant in constants:
+        scope[constant.name] = Evaluated(
+            value=evaluate_classical_expression(constant.value, scope).value
+        )
+
+
+def _add_functions_to_scope(
+    functions: List[NativeFunctionDefinition], scope: Scope
+) -> None:
+    for function in functions:
+        scope[function.name] = Evaluated(
+            value=FunctionClosure.create(
+                name=function.name,
+                positional_arg_declarations=function.positional_arg_declarations,
+                body=function.body,
+                scope=Scope(parent=scope),
+            )
+        )
+
+
+def _add_generative_functions_to_scope(
+    functions: List[GenerativeQFunc], scope: Scope
+) -> None:
+    for function in functions:
+        scope[function.func_decl.name] = Evaluated(
+            value=GenerativeFunctionClosure.create(
+                name=function.func_decl.name,
+                positional_arg_declarations=function.func_decl.positional_arg_declarations,
+                scope=Scope(parent=scope),
+                generative_function=function,
+            )
+        )
+
+
+def _init_builtins_scope(scope: Scope) -> None:
+    for builtin_function in CORE_LIB_DECLS:
+        scope[builtin_function.name] = Evaluated(
+            value=FunctionClosure.create(
+                name=builtin_function.name,
+                positional_arg_declarations=builtin_function.positional_arg_declarations,
+                scope=Scope(parent=scope),
+                is_atomic=True,
+            )
+        )
+    for builtin_function in STD_QMOD_OPERATORS:
+        scope[builtin_function.name] = Evaluated(
+            value=FunctionClosure.create(
+                name=builtin_function.name,
+                positional_arg_declarations=builtin_function.positional_arg_declarations,
+                scope=Scope(parent=scope),
+            )
+        )
+    for func_decl in OPEN_LIB_DECLS:
+        if func_decl.name not in scope:
+            scope[func_decl.name] = Evaluated(
+                value=FunctionClosure.create(
+                    name=func_decl.name,
+                    positional_arg_declarations=func_decl.positional_arg_declarations,
+                    scope=Scope(parent=scope),
+                    is_atomic=True,
+                )
+            )
+
+
+def add_entry_point_params_to_scope(
+    parameters: Sequence[PositionalArg], main_closure: FunctionClosure
+) -> None:
+    for parameter in parameters:
+        if isinstance(parameter, PortDeclaration):
+            main_closure.scope[parameter.name] = Evaluated(
+                value=QuantumSymbol(
+                    handle=HandleBinding(name=parameter.name),
+                    quantum_type=evaluate_type_in_quantum_symbol(
+                        parameter.quantum_type, main_closure.scope, parameter.name
+                    ),
+                ),
+                defining_function=main_closure,
+            )
+        elif isinstance(parameter, ClassicalParameterDeclaration):
+            main_closure.scope[parameter.name] = Evaluated(
+                value=parameter.classical_type.as_symbolic(parameter.name),
+                defining_function=main_closure,
+            )
+
+
+def init_top_level_scope(
+    model: Model, generative_functions: List[GenerativeQFunc], scope: Scope
+) -> None:
+    _add_functions_to_scope(model.functions, scope)
+    _add_generative_functions_to_scope(generative_functions, scope)
+    _add_constants_to_scope(model.constants, scope)
+    _init_builtins_scope(scope)