classiq 0.38.0__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/model_expansions/evaluators/parameter_types.py

@@ -0,0 +1,226 @@
+from typing import Union
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.port_declaration import (
+    PortDeclarationDirection,
+)
+from classiq.interface.generator.functions.type_name import (
+    TypeName,
+)
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    PositionalArg,
+    QuantumOperandDeclaration,
+)
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumType,
+)
+
+from classiq.model_expansions.closure import FunctionClosure
+from classiq.model_expansions.evaluators.arg_type_match import check_type_match
+from classiq.model_expansions.evaluators.classical_expression import (
+    evaluate_classical_expression,
+)
+from classiq.model_expansions.evaluators.quantum_type_utils import (
+    copy_type_information,
+    set_element_type,
+    set_fraction_digits,
+    set_is_signed,
+    set_length,
+    set_size,
+)
+from classiq.model_expansions.scope import Evaluated, QuantumSymbol, Scope
+
+
+def evaluate_parameter_types_from_args(
+    closure: FunctionClosure, signature_scope: Scope, arguments: list[Evaluated]
+) -> list[PositionalArg]:
+    parameters = closure.positional_arg_declarations
+    function_name = closure.name
+    check_type_match(parameters, arguments, function_name)
+
+    for parameter, argument in zip(parameters, arguments):
+        _update_scope(parameter, argument, closure)
+
+    parameter_names = {parameter.name for parameter in parameters}
+    for parameter in parameters:
+        if isinstance(parameter, QuantumOperandDeclaration):
+            parameter_value = closure.scope[parameter.name].value
+            _update_operand_signature_environment(
+                parameter_value, parameter_names, closure
+            )
+
+    return [
+        _evaluate_type_from_arg(
+            parameter, argument, Scope(parent=closure.scope | signature_scope)
+        )
+        for parameter, argument in zip(parameters, arguments)
+    ]
+
+
+def _update_scope(
+    parameter: PositionalArg, argument: Evaluated, closure: FunctionClosure
+) -> None:
+    if not isinstance(parameter, PortDeclaration):
+        closure.scope[parameter.name] = argument
+        return
+    if parameter.direction is PortDeclarationDirection.Output:
+        return
+    quantum_symbol = argument.as_type(QuantumSymbol)
+    if not quantum_symbol.quantum_type.has_size_in_bits:
+        raise ClassiqExpansionError(
+            f"Argument {str(quantum_symbol.emit())!r} to function {closure.name!r} "
+            f"is not initialized"
+        )
+    casted_argument = _cast(
+        parameter.quantum_type,
+        quantum_symbol,
+        parameter.name,
+    )
+    closure.scope[parameter.name] = Evaluated(
+        value=casted_argument, defining_function=closure
+    )
+
+
+NestedFunctionClosureT = Union[FunctionClosure, list["NestedFunctionClosureT"]]
+
+
+def _update_operand_signature_environment(
+    operand_val: NestedFunctionClosureT,
+    parameter_names: set[str],
+    closure: FunctionClosure,
+) -> None:
+    # We update the environment (parent) of the operand by adding closure.scope.data,
+    # which includes the parameters that appear in the function's signature only.
+    if isinstance(operand_val, list):
+        for operand in operand_val:
+            _update_operand_signature_environment(operand, parameter_names, closure)
+        return
+    if not isinstance(operand_val, FunctionClosure):
+        raise ClassiqInternalExpansionError
+    operand_val.signature_scope.update(
+        {
+            identifier: value
+            for identifier, value in closure.scope.data.items()
+            if identifier in parameter_names
+        }
+    )
+
+
+def _cast(
+    quantum_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+) -> QuantumSymbol:
+    updated_quantum_type = quantum_type.model_copy()
+    _inject_quantum_arg_info_to_type(updated_quantum_type, quantum_symbol, param_name)
+    return QuantumSymbol(
+        handle=quantum_symbol.handle, quantum_type=updated_quantum_type
+    )
+
+
+def _evaluate_type_from_arg(
+    parameter: PositionalArg, argument: Evaluated, inner_scope: Scope
+) -> PositionalArg:
+    if not isinstance(parameter, PortDeclaration):
+        return parameter
+
+    updated_quantum_type: QuantumType = evaluate_type_in_quantum_symbol(
+        parameter.quantum_type.model_copy(), inner_scope, parameter.name
+    )
+    if parameter.direction != PortDeclarationDirection.Output:
+        updated_quantum_type = _inject_quantum_arg_info_to_type(
+            updated_quantum_type, argument.as_type(QuantumSymbol), parameter.name
+        )
+    return parameter.model_copy(update={"quantum_type": updated_quantum_type})
+
+
+def evaluate_type_in_quantum_symbol(
+    type_to_update: QuantumType, scope: Scope, param_name: str
+) -> ConcreteQuantumType:
+    if isinstance(type_to_update, QuantumBitvector):
+        return _evaluate_qarray_in_quantum_symbol(type_to_update, scope, param_name)
+    elif isinstance(type_to_update, QuantumNumeric):
+        return _evaluate_qnum_in_quantum_symbol(type_to_update, scope, param_name)
+    elif isinstance(type_to_update, TypeName):
+        return _evaluate_qstruct_in_quantum_symbol(type_to_update, scope, param_name)
+    else:
+        assert isinstance(type_to_update, QuantumBit)
+        return type_to_update
+
+
+def _evaluate_qarray_in_quantum_symbol(
+    type_to_update: QuantumBitvector, scope: Scope, param_name: str
+) -> QuantumBitvector:
+    new_element_type = evaluate_type_in_quantum_symbol(
+        type_to_update.element_type, scope, param_name
+    )
+    set_element_type(type_to_update, new_element_type)
+    if type_to_update.length is not None:
+        new_length = evaluate_classical_expression(
+            type_to_update.length, scope
+        ).as_type(int)
+        set_length(type_to_update, new_length)
+    return type_to_update
+
+
+def _evaluate_qnum_in_quantum_symbol(
+    type_to_update: QuantumNumeric, scope: Scope, param_name: str
+) -> QuantumNumeric:
+    if type_to_update.is_signed is not None:
+        new_is_sign = evaluate_classical_expression(
+            type_to_update.is_signed, scope
+        ).as_type(bool)
+        set_is_signed(type_to_update, new_is_sign, param_name)
+    if type_to_update.fraction_digits is not None:
+        new_fraction_digits = evaluate_classical_expression(
+            type_to_update.fraction_digits, scope
+        ).as_type(int)
+        set_fraction_digits(type_to_update, new_fraction_digits, param_name)
+    if type_to_update.size is not None:
+        new_size = evaluate_classical_expression(type_to_update.size, scope).as_type(
+            int
+        )
+        set_size(type_to_update, new_size, param_name)
+    return type_to_update
+
+
+def _evaluate_qstruct_in_quantum_symbol(
+    type_to_update: TypeName, scope: Scope, param_name: str
+) -> TypeName:
+    new_fields = {
+        field_name: evaluate_type_in_quantum_symbol(field_type, scope, param_name)
+        for field_name, field_type in type_to_update.fields.items()
+    }
+    type_to_update.set_fields(new_fields)
+    return type_to_update
+
+
+def evaluate_types_in_quantum_symbols(
+    symbols: list[QuantumSymbol], scope: Scope
+) -> list[QuantumSymbol]:
+    return [
+        QuantumSymbol(
+            handle=symbol.handle,
+            quantum_type=evaluate_type_in_quantum_symbol(
+                symbol.quantum_type, scope, str(symbol.handle)
+            ),
+        )
+        for symbol in symbols
+    ]
+
+
+def _inject_quantum_arg_info_to_type(
+    parameter_type: QuantumType, quantum_symbol: QuantumSymbol, param_name: str
+) -> QuantumType:
+    copy_type_information(
+        quantum_symbol.quantum_type,
+        parameter_type,
+        param_name,
+    )
+    return parameter_type

classiq/model_expansions/evaluators/quantum_type_utils.py

@@ -0,0 +1,239 @@
+from collections.abc import Sequence
+from typing import Optional
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
+from classiq.interface.generator.functions.type_name import (
+    TypeName,
+)
+from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.inplace_binary_operation import BinaryOperation
+from classiq.interface.model.port_declaration import PortDeclaration
+from classiq.interface.model.quantum_function_declaration import PositionalArg
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumBitvector,
+    QuantumNumeric,
+    QuantumScalar,
+    QuantumType,
+)
+
+from classiq.model_expansions.scope import QuantumSymbol, Scope
+
+
+def copy_type_information(
+    from_type: QuantumType,
+    to_type: QuantumType,
+    to_param_name: str,
+) -> None:
+    if isinstance(to_type, QuantumBit):
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    elif isinstance(to_type, QuantumNumeric):
+        set_is_signed(to_type, getattr(from_type, "sign_value", None), to_param_name)
+        set_fraction_digits(
+            to_type,
+            getattr(from_type, "fraction_digits_value", None),
+            to_param_name,
+        )
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    elif isinstance(to_type, QuantumBitvector):
+        if isinstance(from_type, QuantumBitvector) and type(  # noqa: E721
+            from_type.element_type
+        ) == type(to_type.element_type):
+            copy_type_information(
+                from_type.element_type, to_type.element_type, to_param_name
+            )
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    elif isinstance(to_type, TypeName):
+        if isinstance(from_type, TypeName) and from_type.name == to_type.name:
+            for field in from_type.fields:
+                copy_type_information(
+                    from_type.fields[field], to_type.fields[field], to_param_name
+                )
+        set_size(to_type, from_type.size_in_bits, to_param_name)
+    else:
+        raise ClassiqInternalExpansionError
+
+
+def set_size(quantum_type: QuantumType, size: int, param_name: str) -> None:
+    if size <= 0:
+        raise ClassiqExpansionError(
+            f"Size for {param_name!r} was deduced to be non-positive: {size!r}"
+        )
+
+    if quantum_type.has_size_in_bits and quantum_type.size_in_bits != size:
+        raise ClassiqExpansionError(
+            f"Size mismatch for port {param_name!r} between declared size {quantum_type.size_in_bits} and assigned size {size}"
+        )
+
+    if isinstance(quantum_type, QuantumNumeric):
+        quantum_type.size = Expression(expr=str(size))
+        if not quantum_type.has_sign or not quantum_type.has_fraction_digits:
+            set_is_signed(quantum_type, False, param_name)
+            set_fraction_digits(quantum_type, 0, param_name)
+    elif isinstance(quantum_type, QuantumBitvector):
+        if quantum_type.has_length:
+            if size % quantum_type.length_value != 0:
+                raise ClassiqExpansionError(
+                    f"Size mismatch for port {param_name!r}. Cannot fit {size} "
+                    f"qubits into an array of {quantum_type.length_value} elements."
+                )
+            set_size(
+                quantum_type.element_type,
+                size // quantum_type.length_value,
+                param_name,
+            )
+        set_length_by_size(quantum_type, size, param_name)
+    elif isinstance(quantum_type, TypeName):
+        fields_without_size = [
+            field_type
+            for field_type in quantum_type.fields.values()
+            if not field_type.has_size_in_bits
+        ]
+        if len(fields_without_size) > 1:
+            raise ClassiqInternalExpansionError(
+                f"QuantumStruct should have at most one field without "
+                f"predetermined size. Found {fields_without_size}."
+            )
+        if len(fields_without_size) == 1:
+            predetermined_size_part = sum(
+                field_type.size_in_bits if field_type.has_size_in_bits else 0
+                for field_type in quantum_type.fields.values()
+            )
+            set_size(fields_without_size[0], size - predetermined_size_part, param_name)
+
+
+def set_fraction_digits(
+    quantum_numeric: QuantumNumeric, fraction_digits: Optional[int], param_name: str
+) -> None:
+    if fraction_digits is not None and fraction_digits < 0:
+        raise ClassiqExpansionError(
+            f"Number of fraction digits for {param_name!r} was deduced to be negative: "
+            f"{fraction_digits!r}"
+        )
+
+    if (
+        fraction_digits is not None
+        and quantum_numeric.fraction_digits is not None
+        and quantum_numeric.fraction_digits.is_evaluated()
+        and quantum_numeric.fraction_digits_value != fraction_digits
+    ):
+        raise ClassiqExpansionError(
+            f"Fraction digits mismatch for port {param_name!r} between declared "
+            f"fraction digits {quantum_numeric.fraction_digits_value!r} and assigned fraction "
+            f"digits {fraction_digits!r}"
+        )
+
+    if not (
+        quantum_numeric.fraction_digits is not None
+        and quantum_numeric.fraction_digits.is_evaluated()
+    ):
+        quantum_numeric.fraction_digits = Expression(expr=str(fraction_digits or 0))
+
+
+def set_is_signed(
+    quantum_numeric: QuantumNumeric, is_signed: Optional[bool], param_name: str
+) -> None:
+    if (
+        is_signed is not None
+        and quantum_numeric.is_signed is not None
+        and quantum_numeric.is_signed.is_evaluated()
+        and quantum_numeric.sign_value != is_signed
+    ):
+        raise ClassiqExpansionError(
+            f"Sign mismatch for port {param_name!r} between declared sign {quantum_numeric.sign_value!r} and assigned sign {is_signed!r}"
+        )
+
+    if not (
+        quantum_numeric.is_signed is not None
+        and quantum_numeric.is_signed.is_evaluated()
+    ):
+        quantum_numeric.is_signed = Expression(expr=str(is_signed or False))
+
+
+def set_element_type(
+    quantum_array: QuantumBitvector, element_type: ConcreteQuantumType
+) -> None:
+    quantum_array.element_type = element_type
+
+
+def set_length(quantum_array: QuantumBitvector, length: int) -> None:
+    quantum_array.length = Expression(expr=str(length))
+
+
+def set_length_by_size(
+    quantum_array: QuantumBitvector, size: int, param_name: str
+) -> None:
+    if size <= 0:
+        raise ClassiqExpansionError(
+            f"Size for {param_name!r} was deduced to be non-positive: {size!r}"
+        )
+
+    if quantum_array.has_size_in_bits and quantum_array.size_in_bits != size:
+        raise ClassiqExpansionError(
+            f"Size mismatch for port {param_name!r} between declared size "
+            f"{quantum_array.size_in_bits} ({quantum_array.length_value} elements of "
+            f"size {quantum_array.element_type.size_in_bits}) and assigned size {size}."
+        )
+
+    if not quantum_array.element_type.has_size_in_bits:
+        raise ClassiqExpansionError(
+            f"Could not infer element size for array {param_name!r}."
+        )
+    element_size = quantum_array.element_type.size_in_bits
+
+    if size % element_size != 0:
+        raise ClassiqExpansionError(
+            f"Size mismatch for port {param_name!r}. Cannot fit elements of type "
+            f"{quantum_array.element_type.qmod_type_name} (size {element_size}) into "
+            f"{size} qubits."
+        )
+
+    quantum_array.length = Expression(expr=str(size // element_size))
+
+
+def validate_bind_targets(bind: BindOperation, scope: Scope) -> None:
+    illegal_qnum_bind_targets = []
+    for out_handle in bind.out_handles:
+        out_var = scope[out_handle.name].as_type(QuantumSymbol)
+        out_var_type = out_var.quantum_type
+        if not isinstance(out_var_type, QuantumNumeric):
+            continue
+        if not out_var_type.has_size_in_bits:
+            illegal_qnum_bind_targets.append(str(out_var.handle))
+        elif not out_var_type.has_sign:
+            assert not out_var_type.has_fraction_digits
+            illegal_qnum_bind_targets.append(str(out_var.handle))
+    if len(illegal_qnum_bind_targets) > 0:
+        raise ClassiqExpansionError(
+            f"QNum bind targets {illegal_qnum_bind_targets!r} must be declared or initialized with size, sign, and fraction digits"
+        )
+
+
+def get_inplace_op_scalar_as_numeric(
+    var: QuantumSymbol, operation: BinaryOperation, var_kind: str
+) -> QuantumNumeric:
+    if not isinstance(var.quantum_type, QuantumScalar):
+        raise ClassiqExpansionError(
+            f"Cannot perform inplace {operation.name.lower()} with non-scalar {var_kind} {var.handle}"
+        )
+    if isinstance(var.quantum_type, QuantumNumeric):
+        return var.quantum_type
+    if isinstance(var.quantum_type, QuantumBit):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
+    raise ClassiqInternalExpansionError(f"Unexpected scalar type {var.quantum_type}")
+
+
+def is_signature_monomorphic(params: Sequence[PositionalArg]) -> bool:
+    return all(
+        isinstance(param, PortDeclaration) and param.quantum_type.is_evaluated
+        for param in params
+    )

classiq/model_expansions/evaluators/type_type_match.py

@@ -0,0 +1,90 @@
+from collections.abc import Sequence
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.model.classical_parameter_declaration import (
+    AnonClassicalParameterDeclaration,
+)
+from classiq.interface.model.port_declaration import AnonPortDeclaration
+from classiq.interface.model.quantum_function_declaration import (
+    AnonPositionalArg,
+    AnonQuantumOperandDeclaration,
+)
+
+
+def check_signature_match(
+    decl_params: Sequence[AnonPositionalArg],
+    op_params: Sequence[AnonPositionalArg],
+    location_str: str,
+) -> None:
+    if len(decl_params) != len(op_params):
+        raise ClassiqExpansionError(
+            f"{location_str} should have {len(decl_params)} parameters, "
+            f"not {len(op_params)}"
+        )
+    for idx, (decl_param, op_param) in enumerate(zip(decl_params, op_params)):
+        message_prefix = f"Argument {idx} in {location_str} has incompatible type; "
+        _check_type_match(op_param, decl_param, location_str, message_prefix)
+
+
+def _check_type_match(
+    op_param: AnonPositionalArg,
+    decl_param: AnonPositionalArg,
+    location_str: str,
+    message_prefix: str,
+) -> None:
+    if isinstance(decl_param, AnonPortDeclaration):
+        error_message = message_prefix + "expected quantum parameter"
+        _check_qvar_type_match(op_param, error_message)
+    elif isinstance(decl_param, AnonQuantumOperandDeclaration):
+        if decl_param.is_list:
+            error_message = message_prefix + "expected operand list parameter"
+        else:
+            error_message = message_prefix + "expected operand parameter"
+        _check_operand_type_match(op_param, decl_param, location_str, error_message)
+    elif isinstance(decl_param, AnonClassicalParameterDeclaration):
+        error_message = (
+            message_prefix + f"expected classical {decl_param.classical_type} parameter"
+        )
+        _check_classical_type_match(op_param, decl_param, error_message)
+    else:
+        raise ClassiqInternalExpansionError(
+            f"unexpected parameter declaration type: {type(decl_param).__name__}"
+        )
+
+
+def _check_qvar_type_match(op_param: AnonPositionalArg, error_message: str) -> None:
+    if not isinstance(op_param, AnonPortDeclaration):
+        raise ClassiqExpansionError(error_message)
+
+
+def _check_operand_type_match(
+    op_param: AnonPositionalArg,
+    decl_param: AnonQuantumOperandDeclaration,
+    location_str: str,
+    error_message: str,
+) -> None:
+    if (
+        not isinstance(op_param, AnonQuantumOperandDeclaration)
+        or decl_param.is_list ^ op_param.is_list
+    ):
+        raise ClassiqExpansionError(error_message)
+    check_signature_match(
+        decl_param.positional_arg_declarations,
+        op_param.positional_arg_declarations,
+        f"operand {decl_param.name} in {location_str}",
+    )
+
+
+def _check_classical_type_match(
+    op_param: AnonPositionalArg,
+    decl_param: AnonClassicalParameterDeclaration,
+    error_message: str,
+) -> None:
+    if (
+        not isinstance(op_param, AnonClassicalParameterDeclaration)
+        or decl_param.classical_type != op_param.classical_type
+    ):
+        raise ClassiqExpansionError(error_message)

classiq/model_expansions/expression_evaluator.py

@@ -0,0 +1,135 @@
+import ast
+import re
+from collections.abc import Mapping
+from enum import EnumMeta
+from typing import Any, Optional
+
+from sympy import sympify
+
+from classiq.interface.exceptions import ClassiqExpansionError
+from classiq.interface.generator.constant import Constant
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_constants import (
+    CPARAM_EXECUTION_SUFFIX_PATTERN,
+)
+from classiq.interface.generator.expressions.expression_types import ExpressionValue
+from classiq.interface.generator.expressions.sympy_supported_expressions import (
+    SYMPY_SUPPORTED_EXPRESSIONS,
+)
+
+from classiq.model_expansions.atomic_expression_functions_defs import (
+    ATOMIC_EXPRESSION_FUNCTIONS,
+    qmod_val_to_python,
+)
+from classiq.model_expansions.sympy_conversion.expression_to_sympy import (
+    translate_to_sympy,
+)
+from classiq.model_expansions.sympy_conversion.sympy_to_python import sympy_to_python
+from classiq.qmod import symbolic
+from classiq.qmod.builtins.enums import BUILTIN_ENUM_DECLARATIONS
+from classiq.qmod.model_state_container import QMODULE
+
+
+def evaluate_constants(constants: list[Constant]) -> dict[str, EvaluatedExpression]:
+    result: dict[str, EvaluatedExpression] = {}
+    for constant in constants:
+        result[constant.name] = evaluate(constant.value, result)
+    return result
+
+
+def evaluate_constants_as_python(constants: list[Constant]) -> dict[str, Any]:
+    evaluated = evaluate_constants(constants)
+    return {
+        constant.name: qmod_val_to_python(
+            evaluated[constant.name].value, constant.const_type
+        )
+        for constant in constants
+    }
+
+
+def evaluate(
+    expr: Expression,
+    locals_dict: Mapping[str, EvaluatedExpression],
+    uninitialized_locals: Optional[set[str]] = None,
+) -> EvaluatedExpression:
+    model_locals: dict[str, ExpressionValue] = {}
+    model_locals.update(ATOMIC_EXPRESSION_FUNCTIONS)
+    model_locals.update(
+        {
+            enum_decl.name: enum_decl.create_enum()
+            for enum_decl in (QMODULE.enum_decls | BUILTIN_ENUM_DECLARATIONS).values()
+        }
+    )
+    # locals override builtin-functions
+    model_locals.update({name: expr.value for name, expr in locals_dict.items()})
+    uninitialized_locals = uninitialized_locals or set()
+
+    _validate_undefined_vars(expr.expr, model_locals, uninitialized_locals)
+
+    sympy_expr = translate_to_sympy(expr.expr)
+    try:
+        sympify_result = sympify(sympy_expr, locals=model_locals)
+    except (TypeError, IndexError) as e:
+        raise ClassiqExpansionError(str(e)) from None
+    except AttributeError as e:
+        if isinstance(e.obj, EnumMeta):
+            raise ClassiqExpansionError(
+                f"Enum {e.obj.__name__} has no member {e.name!r}. Available members: "
+                f"{', '.join(e.obj.__members__)}"
+            ) from e
+        raise
+
+    return EvaluatedExpression(
+        value=sympy_to_python(sympify_result, locals=model_locals)
+    )
+
+
+def _validate_undefined_vars(
+    expr: str,
+    model_locals: dict[str, ExpressionValue],
+    uninitialized_locals: Optional[set[str]],
+) -> None:
+    uninitialized_locals = uninitialized_locals or set()
+    id_visitor = _VarsCollector()
+    id_visitor.visit(ast.parse(expr))
+    identifiers = id_visitor.vars
+    undefined_vars = (
+        identifiers
+        - model_locals.keys()
+        - set(SYMPY_SUPPORTED_EXPRESSIONS)
+        - set(symbolic.__all__)
+        - uninitialized_locals
+    )
+
+    # Ignore expanded execution parameters
+    undefined_vars = {
+        var
+        for var in undefined_vars
+        if not re.search(CPARAM_EXECUTION_SUFFIX_PATTERN, var)
+    }
+
+    if len(undefined_vars) == 1:
+        undefined_var = undefined_vars.__iter__().__next__()
+        raise ClassiqExpansionError(f"Variable {undefined_var!r} is undefined")
+    elif len(undefined_vars) > 1:
+        raise ClassiqExpansionError(f"Variables {list(undefined_vars)} are undefined")
+
+
+class _VarsCollector(ast.NodeTransformer):
+    def __init__(self) -> None:
+        self.vars: set[str] = set()
+
+    def visit_Name(self, node: ast.Name) -> None:
+        self.vars.add(node.id)
+
+    def visit_Call(self, node: ast.Call) -> None:
+        func = node.func
+        self.visit(func)
+        if not isinstance(func, ast.Name) or func.id != "struct_literal":
+            for arg in node.args:
+                self.visit(arg)
+        for kw in node.keywords:
+            self.visit(kw)