classiq 0.62.0__py3-none-any.whl → 0.63.0__py3-none-any.whl

classiq/qmod/builtins/functions/allocation.py

@@ -0,0 +1,150 @@
+from typing import Literal
+
+from classiq.qmod.qfunc import qfunc
+from classiq.qmod.qmod_parameter import CArray, CInt, CReal
+from classiq.qmod.qmod_variable import Input, Output, QArray, QBit
+
+
+@qfunc(external=True)
+def allocate(
+    num_qubits: CInt, out: Output[QArray[QBit, Literal["num_qubits"]]]
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Allocates the specified number of qubits to a given quantum variable and initializes
+    them in the zero state:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\left|0\\right\\rangle^{\\otimes \\text{num_qubits}}
+    $$
+
+    Args:
+        num_qubits: The number of qubits to allocate. Must be a positive integer.
+        out: The quantum variable that will receive the allocated qubits. Must be uninitialized before allocation.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits allocated must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def free(in_: Input[QArray[QBit]]) -> None:
+    """
+    [Qmod core-library function]
+
+    Releases the qubits allocated to a quantum variable, allowing them to be reused.
+
+    Args:
+        in_: The quantum variable that will be freed. Must be initialized before.
+
+    Note:
+        This operation does not uncompute the qubits. It is the responsibility of the user to ensure that the qubits are at the zero state before freeing them.
+    """
+    pass
+
+
+@qfunc(external=True)
+def prepare_state(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Initializes a quantum variable in a state corresponding to a given probability distribution:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(probabilities)}-1} \\sqrt{\\text{probabilities}[i]} \\left|i\\right\\rangle
+    $$
+
+    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
+
+    Args:
+        probabilities: The probability distribution to initialize the quantum variable. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        out: The quantum variable that will receive the initialized state. Must be uninitialized.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def prepare_amplitudes(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    out: Output[QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Initializes a quantum variable in a state corresponding to the given amplitudes:
+
+    $$
+        \\left|\\text{out}\\right\\rangle = \\sum_{i=0}^{\\text{len(amplitudes)}-1} \\text{amplitudes}[i] \\left|i\\right\\rangle
+    $$
+
+    with $i = 0, 1, 2, ..., \\text{len(amplitudes)}-1$ corresponding to computational basis states.
+
+    Args:
+        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        out: The quantum variable that will receive the initialized state. Must be uninitialized.
+
+    Notes:
+        1. If the output variable has been declared with a specific number of qubits, the number of qubits formed by the distribution must match the declared number.
+        2. The synthesis engine automatically handles the allocation, either by drawing new qubits from the available pool or by reusing existing ones.
+    """
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_state(
+    probabilities: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(probabilities, 'len'), 2)"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Transforms a given quantum variable in the state |0> to the state per the specified probability distribution
+    (similar to `prepare_state` but preformed on an initialized variable).
+
+    Args:
+        probabilities: The probability distribution corresponding to the quantum variable state. Must be a valid probability distribution, i.e., a list of non-negative real numbers that sum to 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        target: The quantum variable to act upon.
+
+    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
+
+    """
+    pass
+
+
+@qfunc(external=True)
+def inplace_prepare_amplitudes(
+    amplitudes: CArray[CReal],
+    bound: CReal,
+    target: QArray[QBit, Literal["log(get_field(amplitudes, 'len'), 2)"]],
+) -> None:
+    """
+    [Qmod core-library function]
+
+    Transforms a given quantum variable in the state |0> to the state per the specified amplitudes
+    (similar to `prepare_amplitudes` but preformed on an initialized variable).
+
+    Args:
+        amplitudes: The amplitudes to initialize the quantum variable. Must be a valid real quantum state vector, i.e., the sum of squares should be 1. Must have a valid length (a power of 2).
+        bound: An error bound, expressed as the $L^{2}$ norm between the expected and actual distributions. A larger bound can reduce the circuit size at the expense of accuracy. Must be a positive real number.
+        target: The quantum variable to act upon.
+
+    This is useful as part of quantum building blocks like the Grover diffuser operator, $\\left|\\psi\\right\\rangle\\left\\langle\\psi\\right| \\left( 2\\left|0\\right\\rangle\\left\\langle0\\right| - \\mathcal{I} \\right)$, where the output state of the oracle is reflected about this state.
+
+    """
+    pass

classiq/qmod/builtins/functions/arithmetic.py

@@ -1,13 +1,8 @@
 from typing import Literal
 
-from classiq.qmod.builtins.functions.qft_functions import qft
-from classiq.qmod.builtins.functions.standard_gates import PHASE
-from classiq.qmod.builtins.operations import bind, repeat, within_apply
-from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.qmod_parameter import CArray, CReal
 from classiq.qmod.qmod_variable import Output, QArray, QBit, QNum
-from classiq.qmod.symbolic import pi
 
 
 @qfunc(external=True)
@@ -58,32 +53,3 @@ def integer_xor(left: QArray[QBit], right: QArray[QBit]) -> None:
 @qfunc(external=True)
 def real_xor_constant(left: CReal, right: QNum) -> None:
     pass
-
-
-@qfunc
-def modular_increment(a: CInt, x: QNum) -> None:
-    """
-    [Qmod Classiq-library function]
-
-    Adds $a$ to $x$ modulo the range of $x$, assumed that $x$ is a non-negative integer and $a$ is an integer.
-    Mathematically it is described as:
-
-    $$
-        x = (x+a)\\ \\mod \\ 2^{x.size}-1
-    $$
-
-    Args:
-        a: A classical integer to be added to x.
-        x: A quantum number that is assumed to be non-negative integer.
-
-    """
-    array_cast: QArray = QArray("array_cast")
-    within_apply(
-        lambda: (  # type:ignore[arg-type]
-            bind(x, array_cast),  # type:ignore[func-returns-value]
-            qft(array_cast),
-        ),
-        lambda: repeat(
-            x.size, lambda i: PHASE(a * 2 * pi * 2**i / (2**x.size), array_cast[i])
-        ),
-    )

classiq/qmod/builtins/functions/operators.py

@@ -1,4 +1,3 @@
-from classiq.qmod.cparam import CInt
 from classiq.qmod.qfunc import qfunc
 from classiq.qmod.quantum_callable import QCallable, QCallableList
 
@@ -15,8 +14,3 @@ def apply(
     operand: QCallable,
 ) -> None:
     pass
-
-
-@qfunc
-def switch(selector: CInt, cases: QCallableList) -> None:
-    cases[selector]()

classiq/qmod/create_model_function.py

@@ -1,30 +1,15 @@
-from typing import TYPE_CHECKING, Optional, Union, cast
+from typing import Optional, Union
 
 from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.generator.model.constraints import Constraints
 from classiq.interface.generator.model.preferences.preferences import Preferences
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.model import MAIN_FUNCTION_NAME, Model, SerializedModel
-from classiq.interface.model.native_function_definition import NativeFunctionDefinition
-from classiq.interface.model.quantum_function_call import QuantumFunctionCall
+from classiq.interface.model.model import MAIN_FUNCTION_NAME, SerializedModel
 
-from classiq.model_expansions.interpreter import Interpreter
-from classiq.qmod.builtins.functions import BUILTIN_FUNCTION_DECLARATIONS
 from classiq.qmod.classical_function import CFunc
-from classiq.qmod.generative import (
-    is_generative_expansion_enabled,
-    set_frontend_interpreter,
-)
-from classiq.qmod.model_state_container import QMODULE
-from classiq.qmod.qfunc import DEC_QFUNCS, GEN_QFUNCS
-from classiq.qmod.quantum_expandable import _prepare_args
 from classiq.qmod.quantum_function import GenerativeQFunc, QFunc
-from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
 from classiq.qmod.write_qmod import write_qmod
 
-GEN_MAIN_NAME = "_gen_main"
-
 
 def create_model(
     entry_point: Union[QFunc, GenerativeQFunc],
@@ -57,154 +42,15 @@ def create_model(
             f"The entry point function must be named 'main', got '{entry_point.func_decl.name}'"
         )
 
-    user_gen_functions = {
-        gen_func._py_callable.__name__ for gen_func in GEN_QFUNCS
-    } - set(BUILTIN_FUNCTION_DECLARATIONS.keys())
-
-    if len(user_gen_functions) > 0 and is_generative_expansion_enabled():
-        model = _expand_generative_model(
-            (
-                entry_point
-                if isinstance(entry_point, QFunc)
-                else QFunc(entry_point._py_callable)
-            ),
-            constraints,
-            execution_preferences,
-            preferences,
-        )
-    else:
-        if TYPE_CHECKING:
-            assert isinstance(entry_point, QFunc)
-        model = entry_point.create_model(
-            constraints,
-            execution_preferences,
-            preferences,
-            classical_execution_function,
-        )
-    result = model.get_model()
-
-    if out_file is not None:
-        write_qmod(result, out_file)
-
-    return result
-
-
-def _expand_generative_model(
-    gen_main: QFunc,
-    constraints: Optional[Constraints] = None,
-    execution_preferences: Optional[ExecutionPreferences] = None,
-    preferences: Optional[Preferences] = None,
-) -> Model:
-    @QFunc
-    def _dummy() -> None:
-        pass
-
-    model = _dummy.create_model(
+    model = entry_point.create_model(
         constraints,
         execution_preferences,
         preferences,
+        classical_execution_function,
     )
-    gen_expand_model = _get_generative_functions(gen_main, preferences)
-    model.functions = gen_expand_model.functions
-    model.functions_compilation_metadata = (
-        gen_expand_model.functions_compilation_metadata
-    )
-    model.types = list(QMODULE.type_decls.values())
-    model.enums = list(QMODULE.enum_decls.values())
-    model.qstructs = list(QMODULE.qstruct_decls.values())
-    return model
-
-
-def _get_generative_functions(
-    gen_main: QFunc,
-    preferences: Optional[Preferences],
-) -> Model:
-    # The Interpreter accepts a model and a list of generative functions.
-    # Since the main function is generative, it can only be expanded using the
-    # Interpreter.
-    # To solve this deadlock, we create a wrapper model
-    # `qfunc main(...) { _gen_main(...); }` and rename `main` to `_gen_main` before
-    # passing them to the Interpreter.
-    gen_model = _get_wrapper_main(gen_main, preferences)
-    gen_functions = _get_all_model_functions_as_generative_functions()
-    return _interpret_generative_model(gen_model, gen_functions)
-
-
-def _get_wrapper_main(
-    gen_main: QFunc,
-    preferences: Optional[Preferences],
-) -> Model:
-    extra_args = {}
-    if preferences is not None:
-        extra_args["preferences"] = preferences
-    functions_compilation_metadata = {
-        qfunc._py_callable.__name__: qfunc.compilation_metadata
-        for qfunc in DEC_QFUNCS + GEN_QFUNCS
-        if qfunc.compilation_metadata is not None
-    }
-    return Model(
-        functions=[
-            NativeFunctionDefinition(
-                name=MAIN_FUNCTION_NAME,
-                positional_arg_declarations=gen_main.func_decl.positional_arg_declarations,
-                body=[
-                    QuantumFunctionCall(
-                        function=GEN_MAIN_NAME,
-                        positional_args=_prepare_args(
-                            gen_main.func_decl,
-                            gen_main._get_positional_args(),
-                            {},
-                        ),
-                    ),
-                ],
-            ),
-        ],
-        functions_compilation_metadata=functions_compilation_metadata,
-        **extra_args,
-    )
-
-
-def _get_all_model_functions_as_generative_functions() -> list[GenerativeQFunc]:
-
-    gen_functions = list(GEN_QFUNCS) + [
-        GenerativeQFunc(
-            dec_func._py_callable, dec_func.func_decl, dec_func.compilation_metadata
-        )
-        for dec_func in DEC_QFUNCS
-    ]
-    return [
-        (
-            gen_func
-            if gen_func.func_decl.name != MAIN_FUNCTION_NAME
-            else GenerativeQFunc(
-                gen_func._py_callable,
-                gen_func.func_decl.model_copy(update={"name": GEN_MAIN_NAME}),
-                gen_func.compilation_metadata,
-            )
-        )
-        for gen_func in gen_functions
-        if gen_func.func_decl.name not in BUILTIN_FUNCTION_DECLARATIONS
-    ]
-
+    result = model.get_model()
 
-def _interpret_generative_model(
-    gen_model: Model, gen_functions: list[GenerativeQFunc]
-) -> Model:
-    resolve_function_calls(
-        gen_model,
-        {gen_func.func_decl.name: gen_func.func_decl for gen_func in gen_functions},
-    )
-    interpreter = Interpreter(gen_model, gen_functions, is_frontend=True)
-    set_frontend_interpreter(interpreter)
-    expand_model = interpreter.expand()
-    functions_dict = nameables_to_dict(expand_model.functions)
+    if out_file is not None:
+        write_qmod(result, out_file)
 
-    # Inline _gen_main call in main
-    expanded_gen_main_name = cast(
-        QuantumFunctionCall, functions_dict[MAIN_FUNCTION_NAME].body[0]
-    ).func_name
-    functions_dict[MAIN_FUNCTION_NAME] = functions_dict[
-        expanded_gen_main_name
-    ].model_copy(update={"name": MAIN_FUNCTION_NAME})
-    functions_dict.pop(expanded_gen_main_name)
-    return expand_model.model_copy(update={"functions": list(functions_dict.values())})
+    return result

classiq/qmod/generative.py

@@ -8,7 +8,6 @@ from classiq.interface.generator.expressions.expression import Expression
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
 
-_GENERATIVE_ENABLED_SWITCH: bool = True
 _GENERATIVE_MODE: bool = False
 _FRONTEND_INTERPRETER: Optional["Interpreter"] = None
 
@@ -28,21 +27,6 @@ def generative_mode_context(generative: bool) -> Iterator[None]:
         _GENERATIVE_MODE = previous
 
 
-@contextmanager
-def enable_generative_expansion(enabled: bool) -> Iterator[None]:
-    global _GENERATIVE_ENABLED_SWITCH
-    previous = _GENERATIVE_ENABLED_SWITCH
-    _GENERATIVE_ENABLED_SWITCH = enabled
-    try:
-        yield
-    finally:
-        _GENERATIVE_ENABLED_SWITCH = previous
-
-
-def is_generative_expansion_enabled() -> bool:
-    return _GENERATIVE_ENABLED_SWITCH
-
-
 def set_frontend_interpreter(interpreter: "Interpreter") -> None:
     global _FRONTEND_INTERPRETER
     _FRONTEND_INTERPRETER = interpreter

classiq/qmod/model_state_container.py

@@ -1,3 +1,5 @@
+from typing import TYPE_CHECKING
+
 from classiq.interface.generator.constant import Constant
 from classiq.interface.generator.types.compilation_metadata import CompilationMetadata
 from classiq.interface.generator.types.enum_declaration import EnumDeclaration
@@ -7,6 +9,9 @@ from classiq.interface.model.native_function_definition import (
     NativeFunctionDefinition,
 )
 
+if TYPE_CHECKING:
+    from classiq.qmod.quantum_function import GenerativeQFunc
+
 
 class ModelStateContainer:
     enum_decls: dict[str, EnumDeclaration]
@@ -15,6 +20,8 @@ class ModelStateContainer:
     native_defs: dict[str, NativeFunctionDefinition]
     constants: dict[str, Constant]
     functions_compilation_metadata: dict[str, CompilationMetadata]
+    generative_functions: dict[str, "GenerativeQFunc"]
+    function_dependencies: dict[str, list[str]]
 
 
 QMODULE = ModelStateContainer()

classiq/qmod/native/pretty_printer.py

@@ -78,7 +78,7 @@ from classiq.interface.model.variable_declaration_statement import (
 )
 from classiq.interface.model.within_apply_operation import WithinApply
 
-from classiq.qmod.builtins.functions import OPEN_LIBRARY_FUNCTIONS
+from classiq.open_library.functions import OPEN_LIBRARY_FUNCTIONS
 from classiq.qmod.native.expression_to_qmod import transform_expression
 from classiq.qmod.semantics.static_semantics_visitor import resolve_function_calls
 from classiq.qmod.utilities import DEFAULT_DECIMAL_PRECISION
@@ -114,16 +114,15 @@ class DSLPrettyPrinter(Visitor):
             else []
         )
 
-        return "\n".join(
-            [
-                *constants,
-                *enum_decls,
-                *struct_decls,
-                *qstruct_decls,
-                *func_defs,
-                *classical_code,
-            ]
-        )
+        items = [
+            *constants,
+            *enum_decls,
+            *struct_decls,
+            *qstruct_decls,
+            *func_defs,
+            *classical_code,
+        ]
+        return "\n".join([item for item in items if item != ""])
 
     def visit_Constant(self, constant: Constant) -> str:
         return f"{self._indent}{self.visit(constant.name)}: {self.visit(constant.const_type)} = {self.visit(constant.value)};\n"

classiq/qmod/pretty_print/pretty_printer.py

@@ -412,7 +412,7 @@ class PythonPrettyPrinter(Visitor):
     def visit_PhaseOperation(self, op: PhaseOperation) -> str:
         self._imports["phase"] = 1
         theta = f", {self.visit(op.theta)}" if op.theta is not None else ""
-        return f"{self._indent}phase({self.visit(op.expression)},{theta})\n"
+        return f"{self._indent}phase({self.visit(op.expression)}{theta})\n"
 
     def visit_ClassicalIf(self, op: ClassicalIf) -> str:
         self._imports["if_"] = 1

classiq/qmod/qfunc.py

@@ -1,3 +1,5 @@
+from collections.abc import Iterator
+from contextlib import contextmanager
 from typing import Callable, Literal, Optional, Union, overload
 
 from classiq.interface.exceptions import ClassiqInternalError
@@ -10,17 +12,16 @@ from classiq.qmod.quantum_function import (
     QFunc,
 )
 
-GEN_QFUNCS: list[GenerativeQFunc] = []
-DEC_QFUNCS: list[QFunc] = []
+_GENERATIVE_SWITCH = False
 
 
-def set_discovered_functions(
-    dec_funcs: list[QFunc], gen_funcs: list[GenerativeQFunc]
-) -> None:
-    DEC_QFUNCS.clear()
-    DEC_QFUNCS.extend(dec_funcs)
-    GEN_QFUNCS.clear()
-    GEN_QFUNCS.extend(gen_funcs)
+@contextmanager
+def set_global_generative_switch() -> Iterator[None]:
+    global _GENERATIVE_SWITCH
+    previous = _GENERATIVE_SWITCH
+    _GENERATIVE_SWITCH = True
+    yield
+    _GENERATIVE_SWITCH = previous
 
 
 @overload
@@ -56,9 +57,8 @@ def qfunc(
 ) -> Union[Callable[[Callable], QCallable], QCallable]:
     def wrapper(func: Callable) -> QCallable:
         qfunc: BaseQFunc
-        if generative:
+        if generative or _GENERATIVE_SWITCH:
             qfunc = GenerativeQFunc(func)
-            GEN_QFUNCS.append(qfunc)
         elif external:
             if synthesize_separately:
                 raise ClassiqInternalError(
@@ -67,7 +67,6 @@ def qfunc(
             return ExternalQFunc(func)
         else:
             qfunc = QFunc(func)
-            DEC_QFUNCS.append(qfunc)
         if synthesize_separately:
             qfunc.update_compilation_metadata(should_synthesize_separately=True)
         return qfunc

classiq/qmod/qmod_variable.py

@@ -285,7 +285,7 @@ class QNum(Generic[_P], QScalar):
     def __init__(
         self,
         name: Union[str, HandleBinding],
-        size: Union[int, CInt, Expression, None] = None,
+        size: Union[int, CInt, Expression, SymbolicExpr, None] = None,
         is_signed: Union[bool, Expression, SymbolicExpr, None] = None,
         fraction_digits: Union[int, CInt, Expression, None] = None,
         _expr_str: Optional[str] = None,
@@ -485,8 +485,6 @@ class QArray(ArrayBase[_P], QVar):
             if is_generative_mode():
                 with generative_mode_context(False):
                     return interpret_expression(str(self.len))
-            if self._length is not None:
-                return CParamScalar(f"{self._length}")
             return CParamScalar(f"get_field({self}, 'len')")
 
     @classmethod

classiq/qmod/quantum_expandable.py

@@ -101,6 +101,10 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             QExpandable.STACK[-1] if QExpandable.STACK else None
         )
 
+    def __call__(self, *args: Any, **kwargs: Any) -> None:
+        super().__call__(*args, **kwargs)
+        self.add_function_dependencies()
+
     def expand(self) -> None:
         if self not in QExpandable.STACK:
             with self, generative_mode_context(False):
@@ -161,6 +165,17 @@ class QExpandable(QCallable, QExpandableInterface, ABC):
             func_decl, None, source_ref_, *args, **kwargs
         )
 
+    def add_function_dependencies(self) -> None:
+        called_name = self.func_decl.name
+        if called_name is None:
+            return
+        for expandable in QExpandable.STACK:
+            caller_name = expandable.func_decl.name
+            if caller_name is not None:
+                caller_deps = self._qmodule.function_dependencies[caller_name]
+                if called_name not in caller_deps:
+                    caller_deps.append(called_name)
+
 
 class QLambdaFunction(QExpandable):
     def __init__(
@@ -298,6 +313,12 @@ def prepare_arg(
 def prepare_arg(
     arg_decl: AnonPositionalArg, val: Any, func_name: Optional[str], param_name: str
 ) -> ArgValue:
+    from classiq.qmod.quantum_function import BaseQFunc, GenerativeQFunc
+
+    if isinstance(val, BaseQFunc):
+        val.add_function_dependencies()
+    if isinstance(val, GenerativeQFunc):
+        QMODULE.generative_functions[val.func_decl.name] = val
     if isinstance(val, QConstant):
         val.add_to_model()
         return Expression(expr=str(val.name))