classiq 0.84.0__py3-none-any.whl → 0.86.0__py3-none-any.whl

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -0,0 +1,132 @@
+import ast
+from typing import TYPE_CHECKING
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.model.quantum_type import QuantumNumeric
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    IntegerValueType,
+    NumberValueType,
+    QmodType,
+    is_classical_integer,
+    is_classical_type,
+    is_numeric_type,
+)
+
+
+def _binary_op_allowed(left: QmodType, right: QmodType) -> bool:
+    return is_numeric_type(left) and is_numeric_type(right)
+
+
+def _validate_binary_op(op: ast.AST, left_type: QmodType, right_type: QmodType) -> None:
+    if not _binary_op_allowed(left_type, right_type):
+        raise ClassiqExpansionError(
+            f"Both sides of the binary operator {type(op).__name__!r} must be "
+            f"scalar values"
+        )
+    if isinstance(op, (ast.LShift, ast.RShift)) and (
+        isinstance(left_type, Real) or isinstance(right_type, Real)
+    ):
+        raise ClassiqExpansionError(
+            f"Bitshift operation {type(op).__name__!r} on real values is not "
+            f"supported"
+        )
+    if isinstance(op, (ast.BitOr, ast.BitXor, ast.BitAnd)) and (
+        isinstance(left_type, Real) or isinstance(right_type, Real)
+    ):
+        raise ClassiqExpansionError(
+            f"Bitwise operation {type(op).__name__!r} on real values is not supported"
+        )
+
+    if isinstance(op, ast.MatMult):
+        raise ClassiqExpansionError(
+            f"Binary operation {type(op).__name__!r} is not supported"
+        )
+
+    if not is_classical_type(right_type) and (
+        isinstance(
+            op, (ast.Div, ast.FloorDiv, ast.Mod, ast.Pow, ast.LShift, ast.RShift)
+        )
+    ):
+        raise ClassiqExpansionError(
+            f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+        )
+
+
+def _eval_binary_op_constant(
+    op: ast.AST, left_value: NumberValueType, right_value: NumberValueType
+) -> NumberValueType:
+    if isinstance(op, ast.Add):
+        return left_value + right_value
+    if isinstance(op, ast.Sub):
+        return left_value - right_value
+    if isinstance(op, ast.Mult):
+        return left_value * right_value
+    if isinstance(op, ast.Div):
+        if right_value == 0:
+            raise ClassiqExpansionError("Division by zero")
+        return left_value / right_value
+    if isinstance(op, ast.FloorDiv):
+        if right_value == 0:
+            raise ClassiqExpansionError("Integer division by zero")
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Integer division with a complex number")
+        return left_value // right_value
+    if isinstance(op, ast.Mod):
+        if right_value == 0:
+            raise ClassiqExpansionError("Integer modulu by zero")
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Integer modulu with a complex number")
+        return left_value % right_value
+    if isinstance(op, ast.Pow):
+        return left_value**right_value
+
+    if TYPE_CHECKING:
+        assert isinstance(left_value, IntegerValueType)
+        assert isinstance(right_value, IntegerValueType)
+
+    if isinstance(op, ast.LShift):
+        return left_value << right_value
+    if isinstance(op, ast.RShift):
+        return left_value >> right_value
+    if isinstance(op, ast.BitAnd):
+        return left_value & right_value
+    if isinstance(op, ast.BitOr):
+        return left_value | right_value
+    if isinstance(op, ast.BitXor):
+        return left_value ^ right_value
+
+    raise ClassiqInternalExpansionError
+
+
+def eval_binary_op(expr_val: QmodAnnotatedExpression, node: ast.BinOp) -> None:
+    left = node.left
+    right = node.right
+    op = node.op
+
+    left_type = expr_val.get_type(left)
+    right_type = expr_val.get_type(right)
+    _validate_binary_op(op, left_type, right_type)
+
+    node_type: QmodType
+    if not is_classical_type(left_type) or not is_classical_type(left_type):
+        node_type = QuantumNumeric()
+    elif (
+        not isinstance(op, ast.Div)
+        and is_classical_integer(left_type)
+        and is_classical_integer(right_type)
+    ):
+        node_type = Integer()
+    else:
+        node_type = Real()
+    expr_val.set_type(node, node_type)
+
+    if expr_val.has_value(left) and expr_val.has_value(right):
+        left_value = expr_val.get_value(left)
+        right_value = expr_val.get_value(right)
+        expr_val.set_value(node, _eval_binary_op_constant(op, left_value, right_value))

classiq/evaluators/qmod_node_evaluators/bool_op_evaluation.py

@@ -0,0 +1,70 @@
+import ast
+from functools import reduce
+from operator import and_, or_
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Bool
+from classiq.interface.model.quantum_type import QuantumBit, QuantumNumeric
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    is_classical_type,
+    qnum_is_qbit,
+)
+
+
+def bool_op_allowed(left: QmodType, right: QmodType) -> bool:
+    return is_bool_type(left) and is_bool_type(right)
+
+
+def is_bool_type(qmod_type: QmodType) -> bool:
+    if isinstance(qmod_type, QuantumNumeric):
+        return qnum_is_qbit(qmod_type)
+    elif not isinstance(qmod_type, (QuantumBit, Bool)):
+        return False
+    return True
+
+
+def eval_bool_op(expr_val: QmodAnnotatedExpression, node: ast.BoolOp) -> None:
+    if len(node.values) < 2:
+        raise ClassiqInternalExpansionError
+
+    left = node.values[0]
+    rights = node.values[0:]
+    op = node.op
+
+    left_type = expr_val.get_type(left)
+    right_types = [expr_val.get_type(right) for right in rights]
+    if not all(bool_op_allowed(left_type, right_type) for right_type in right_types):
+        raise ClassiqExpansionError(
+            f"Both sides of the Boolean operator {type(op).__name__!r} must be "
+            f"Boolean values"
+        )
+    qmod_type: QmodType
+    if not is_classical_type(left_type) or not all(
+        is_classical_type(right_type) for right_type in right_types
+    ):
+        qmod_type = QuantumBit()
+    else:
+        qmod_type = Bool()
+    expr_val.set_type(node, qmod_type)
+
+    if not expr_val.has_value(left) or not all(
+        expr_val.has_value(right) for right in rights
+    ):
+        return
+
+    left_value = expr_val.get_value(left)
+    right_values = [expr_val.get_value(right) for right in rights]
+    if isinstance(op, ast.And):
+        operator = and_
+    elif isinstance(op, ast.Or):
+        operator = or_
+    else:
+        raise ClassiqInternalExpansionError
+    constant_value = reduce(operator, [left_value, *right_values])
+    expr_val.set_value(node, constant_value)

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -0,0 +1,311 @@
+import ast
+from typing import Any, Callable, Optional, Union, cast
+
+import sympy
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    ClassicalType,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.helpers.backward_compatibility import zip_strict
+from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    SYMPY_SYMBOLS,
+    QmodType,
+    array_len,
+    element_types,
+    get_qmod_type_name,
+)
+
+MIN_MAX_FUNCTION_NAMES = {"min", "Min", "max", "Max"}
+
+
+def _check_classical_array_arg_type(
+    param_type: Union[ClassicalArray, ClassicalTuple], arg_type: ClassicalType
+) -> bool:
+    if not isinstance(arg_type, (ClassicalArray, ClassicalTuple)):
+        return False
+    param_len = array_len(param_type)
+    arg_len = array_len(arg_type)
+    if param_len is not None and arg_len is not None and param_len != arg_len:
+        return False
+    if isinstance(param_type, ClassicalArray):
+        if isinstance(arg_type, ClassicalArray):
+            return check_classical_arg_type(
+                param_type.element_type, arg_type.element_type
+            )
+        return all(
+            check_classical_arg_type(param_type.element_type, arg_element_type)
+            for arg_element_type in arg_type.element_types
+        )
+    if isinstance(arg_type, ClassicalArray):
+        return all(
+            check_classical_arg_type(param_element_type, arg_type.element_type)
+            for param_element_type in param_type.element_types
+        )
+    return all(
+        check_classical_arg_type(param_element_type, arg_element_type)
+        for param_element_type, arg_element_type in zip_strict(
+            param_type.element_types, arg_type.element_types, strict=True
+        )
+    )
+
+
+def check_classical_arg_type(
+    param_type: ClassicalType, arg_type: ClassicalType
+) -> bool:
+    if isinstance(param_type, (Integer, Real)):
+        return isinstance(arg_type, (Integer, Real))
+    if isinstance(param_type, Bool):
+        return isinstance(arg_type, Bool)
+    if isinstance(param_type, (ClassicalArray, ClassicalTuple)):
+        return _check_classical_array_arg_type(param_type, arg_type)
+    if not isinstance(param_type, TypeName):
+        raise ClassiqInternalExpansionError
+    if not isinstance(arg_type, TypeName):
+        return False
+    if param_type.is_enum or param_type.has_classical_struct_decl:
+        return arg_type.name == param_type.name
+    raise ClassiqInternalExpansionError
+
+
+def _check_classical_arg(
+    func_name: str, param_name: str, param_type: ClassicalType, arg_type: QmodType
+) -> None:
+    if not isinstance(arg_type, ClassicalType) or not check_classical_arg_type(
+        param_type, arg_type
+    ):
+        raise ClassiqExpansionError(
+            f"Parameter {param_name!r} of function {func_name!r} expects a "
+            f"{get_qmod_type_name(param_type)} argument, but got a "
+            f"{get_qmod_type_name(arg_type)}"
+        )
+
+
+def check_classical_func_call(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    decl: ClassicalFunctionDeclaration,
+) -> None:
+    expected_num_args = len(decl.param_decls)
+    actual_num_args = len(node.args) + len(node.keywords)
+    if expected_num_args != actual_num_args:
+        raise ClassiqExpansionError(
+            f"Function {decl.name!r} takes {expected_num_args} arguments but "
+            f"{actual_num_args} were given"
+        )
+    params = list(decl.param_decls)
+    assigned_params: set[str] = set()
+    for arg in node.args:
+        param = params.pop(0)
+        assigned_params.add(param.name)
+        _check_classical_arg(
+            decl.name, param.name, param.classical_type, expr_val.get_type(arg)
+        )
+    remaining_params = nameables_to_dict(params)
+    for kwarg in node.keywords:
+        if kwarg.arg is None:
+            raise ClassiqExpansionError("Star argument syntax is not supported")
+        if kwarg.arg not in remaining_params:
+            if kwarg.arg in assigned_params:
+                raise ClassiqExpansionError(
+                    f"Function {decl.name!r} got multiple values for parameter "
+                    f"{kwarg.arg!r}"
+                )
+            raise ClassiqExpansionError(
+                f"Function {decl.name!r} has no parameter named {kwarg.arg}"
+            )
+        assigned_params.add(kwarg.arg)
+        param = remaining_params.pop(kwarg.arg)
+        _check_classical_arg(
+            decl.name, param.name, param.classical_type, expr_val.get_type(kwarg.value)
+        )
+
+
+def eval_symbolic_function(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    decl: ClassicalFunctionDeclaration,
+) -> None:
+    check_classical_func_call(expr_val, node, decl)
+    if decl.return_type is None:
+        raise ClassiqInternalExpansionError
+    expr_val.set_type(node, decl.return_type)
+
+
+def eval_function(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.Call,
+    decl: ClassicalFunctionDeclaration,
+    func: Callable,
+) -> None:
+    eval_symbolic_function(expr_val, node, decl)
+
+    args = node.args
+    kwargs = {kwarg.arg: kwarg.value for kwarg in node.keywords}
+    if None in kwargs:
+        raise ClassiqInternalExpansionError
+    if not all(expr_val.has_value(arg) for arg in args) or not all(
+        expr_val.has_value(kwarg) for kwarg in kwargs.values()
+    ):
+        return
+    arg_values = [expr_val.get_value(arg) for arg in args]
+    kwarg_values = {
+        cast(str, kwarg_name): expr_val.get_value(kwarg_value)
+        for kwarg_name, kwarg_value in kwargs.items()
+    }
+    expr_val.set_value(node, func(*arg_values, **kwarg_values))
+
+
+def try_eval_sympy_function(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
+) -> bool:
+    sympy_func = SYMPY_SYMBOLS.get(func_name)
+    if not isinstance(sympy_func, sympy.FunctionClass):
+        return False
+    _validate_no_kwargs(node)
+    args: Optional[list[Any]] = None
+    sympy_ret_val: Any = None
+    if all(expr_val.has_value(arg) for arg in node.args):
+        args = [expr_val.get_value(arg) for arg in node.args]
+        sympy_ret_val = sympy_func(*args)
+        if not isinstance(sympy_ret_val, sympy.Expr):
+            raise ClassiqInternalExpansionError
+    ret_type: QmodType
+    ret_val: Any = None
+    if hasattr(sympy_func, "is_Boolean") and sympy_func.is_Boolean:
+        ret_type = Bool()
+        if args is not None:
+            ret_val = bool(sympy_ret_val)
+    elif hasattr(sympy_func, "is_Integer") and sympy_func.is_Integer:
+        ret_type = Integer()
+        if args is not None:
+            ret_val = int(sympy_ret_val)
+    else:
+        ret_type = Real()
+        if sympy_ret_val is not None:
+            if sympy_ret_val.is_imaginary:
+                ret_val = complex(sympy_ret_val)
+            elif sympy_ret_val.is_real:
+                ret_val = float(sympy_ret_val)
+            else:
+                raise ClassiqInternalExpansionError
+    expr_val.set_type(node, ret_type)
+    if ret_val is not None:
+        expr_val.set_value(node, ret_val)
+    return True
+
+
+def try_eval_builtin_function(
+    expr_val: QmodAnnotatedExpression, node: ast.Call, func_name: str
+) -> bool:
+    args_are_int = all(isinstance(expr_val.get_type(arg), Integer) for arg in node.args)
+    args_are_real = all(
+        isinstance(expr_val.get_type(arg), (Integer, Real)) for arg in node.args
+    )
+    arg_is_int_list = (
+        len(node.args) == 1
+        and isinstance(
+            arg_type := expr_val.get_type(node.args[0]),
+            (ClassicalArray, ClassicalTuple),
+        )
+        and all(
+            isinstance(element_type, Integer)
+            for element_type in element_types(arg_type)
+        )
+    )
+    arg_is_real_list = (
+        len(node.args) == 1
+        and isinstance(
+            arg_type := expr_val.get_type(node.args[0]),
+            (ClassicalArray, ClassicalTuple),
+        )
+        and all(
+            isinstance(element_type, (Integer, Real))
+            for element_type in element_types(arg_type)
+        )
+    )
+    args_have_values = all(expr_val.has_value(arg) for arg in node.args)
+
+    if func_name in MIN_MAX_FUNCTION_NAMES:
+        if not try_eval_sympy_function(expr_val, node, func_name.capitalize()):
+            return False
+        if args_are_int:
+            expr_val.set_type(node, Integer())
+            if expr_val.has_value(node):
+                expr_val.set_value(node, int(expr_val.get_value(node)))
+        return True
+
+    if func_name == "mod_inverse":
+        _validate_no_kwargs(node)
+        ret_type: QmodType
+        if args_are_int:
+            ret_type = Integer()
+        elif args_are_real:
+            ret_type = Real()
+        else:
+            raise ClassiqExpansionError(
+                "Function 'mod_inverse' expects numeric arguments"
+            )
+        expr_val.set_type(node, ret_type)
+        if args_have_values:
+            sympy_val = sympy.mod_inverse(
+                *[expr_val.get_value(arg) for arg in node.args]
+            )
+            ret_val: Any
+            if args_are_int:
+                ret_val = int(sympy_val)
+            elif isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
+                ret_val = complex(sympy_val)
+            else:
+                ret_val = float(sympy_val)
+            expr_val.set_value(node, ret_val)
+        return True
+
+    if func_name == "sum":
+        _validate_no_kwargs(node)
+        if arg_is_int_list:
+            ret_type = Integer()
+        elif arg_is_real_list:
+            ret_type = Real()
+        else:
+            raise ClassiqExpansionError("Function 'sum' expects numeric arguments")
+        expr_val.set_type(node, ret_type)
+        if args_have_values:
+            expr_val.set_value(node, sum(expr_val.get_value(node.args[0])))
+        return True
+
+    if func_name == "sqrt":
+        _validate_no_kwargs(node)
+        expr_val.set_type(node, Real())
+        if args_have_values:
+            expr_val.set_value(
+                node, sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
+            )
+        return True
+
+    return False
+
+
+def _validate_no_kwargs(node: ast.Call) -> None:
+    if not isinstance(node.func, ast.Name):
+        raise ClassiqInternalExpansionError
+    if len(node.keywords) > 0:
+        raise ClassiqExpansionError(
+            f"Keyword argument syntax is not supported for built-in function "
+            f"{node.func.id!r}"
+        )

classiq/evaluators/qmod_node_evaluators/compare_evaluation.py

@@ -0,0 +1,107 @@
+import ast
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+    ClassiqInternalExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalArray,
+    ClassicalTuple,
+    Integer,
+    Real,
+)
+from classiq.interface.generator.functions.type_name import TypeName
+from classiq.interface.model.quantum_type import (
+    QuantumBit,
+    QuantumNumeric,
+    QuantumScalar,
+)
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.list_evaluation import list_allowed
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    element_types,
+    get_qmod_type_name,
+    is_classical_integer,
+    is_classical_type,
+    qnum_is_qbit,
+)
+
+
+def comparison_allowed(
+    left: QmodType, right: QmodType, inequality: bool = False
+) -> bool:
+    if isinstance(left, Bool):
+        return isinstance(right, (Bool, QuantumBit)) or (
+            isinstance(right, QuantumNumeric) and qnum_is_qbit(right)
+        )
+    if isinstance(left, Real) or is_classical_integer(left):
+        return isinstance(right, (Real, QuantumScalar)) or is_classical_integer(right)
+    if isinstance(left, (ClassicalArray, ClassicalTuple)):
+        if inequality:
+            return False
+        if not isinstance(right, (ClassicalArray, ClassicalTuple)):
+            return False
+        return list_allowed(element_types(left) + element_types(right))
+    if isinstance(left, TypeName):
+        return (
+            left.has_classical_struct_decl
+            and not inequality
+            and isinstance(right, TypeName)
+            and left.name == right.name
+        ) or (
+            left.is_enum
+            and (
+                isinstance(right, (Integer, Real, QuantumScalar))
+                or (isinstance(right, TypeName) and right.is_enum)
+            )
+        )
+    if isinstance(left, QuantumScalar):
+        return isinstance(right, (Bool, Real, QuantumScalar)) or is_classical_integer(
+            right
+        )
+    raise ClassiqInternalExpansionError
+
+
+def eval_compare(expr_val: QmodAnnotatedExpression, node: ast.Compare) -> None:
+    left = node.left
+    if len(node.ops) != 1 or len(node.comparators) != 1:
+        raise ClassiqExpansionError("Multi-compare expressions are not supported")
+    right = node.comparators[0]
+    op = node.ops[0]
+
+    left_type = expr_val.get_type(left)
+    right_type = expr_val.get_type(right)
+    if not comparison_allowed(left_type, right_type, not isinstance(op, ast.Eq)):
+        raise ClassiqExpansionError(
+            f"Cannot compare {get_qmod_type_name(left_type)} {ast.unparse(left)!r} "
+            f"and {get_qmod_type_name(right_type)} {ast.unparse(right)!r}"
+        )
+    qmod_type: QmodType
+    if not is_classical_type(left_type) or not is_classical_type(right_type):
+        qmod_type = QuantumBit()
+    else:
+        qmod_type = Bool()
+    expr_val.set_type(node, qmod_type)
+
+    if not expr_val.has_value(left) or not expr_val.has_value(right):
+        return
+
+    left_value = expr_val.get_value(left)
+    right_value = expr_val.get_value(right)
+    if isinstance(op, ast.Eq):
+        expr_val.set_value(node, left_value == right_value)
+    elif isinstance(op, ast.NotEq):
+        expr_val.set_value(node, left_value != right_value)
+    elif isinstance(op, ast.Lt):
+        expr_val.set_value(node, left_value < right_value)
+    elif isinstance(op, ast.Gt):
+        expr_val.set_value(node, left_value > right_value)
+    elif isinstance(op, ast.LtE):
+        expr_val.set_value(node, left_value <= right_value)
+    elif isinstance(op, ast.GtE):
+        expr_val.set_value(node, left_value >= right_value)
+    else:
+        raise ClassiqExpansionError(f"Unsupported comparison {type(op).__name__!r}")

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -0,0 +1,67 @@
+import ast
+from enum import IntEnum
+from typing import Any
+
+import sympy
+
+from classiq.interface.exceptions import (
+    ClassiqExpansionError,
+)
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+from classiq.interface.generator.functions.type_name import Enum
+
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import SYMPY_SYMBOLS, QmodType
+
+
+def eval_enum_member(
+    expr_val: QmodAnnotatedExpression, node: ast.Attribute, enum: type[IntEnum]
+) -> None:
+    enum_name = enum.__name__
+    enum_members = {  # type: ignore[var-annotated]
+        member.name: member for member in list(enum)
+    }
+    attr = node.attr
+    if attr not in enum_members:
+        raise ClassiqExpansionError(f"Enum {enum_name} has no member named {attr!r}")
+
+    expr_val.set_type(node, Enum(name=enum_name))
+    expr_val.set_value(node, enum_members[attr])
+
+
+def eval_constant(expr_val: QmodAnnotatedExpression, node: ast.Constant) -> None:
+    value = node.value
+    expr_val.set_value(node, value)
+    constant_type: QmodType
+    if isinstance(value, bool):
+        constant_type = Bool()
+    elif isinstance(value, int):
+        constant_type = Integer()
+    elif isinstance(value, (float, complex)):
+        constant_type = Real()
+    else:
+        raise ClassiqExpansionError(f"Unsupported constant {str(value)!r}")
+    expr_val.set_type(node, constant_type)
+
+
+def try_eval_sympy_constant(expr_val: QmodAnnotatedExpression, node: ast.Name) -> bool:
+    sympy_val = SYMPY_SYMBOLS.get(node.id)
+    if not isinstance(sympy_val, sympy.Expr) or not sympy_val.is_constant():
+        return False
+    constant_type: QmodType
+    constant_value: Any
+    if sympy_val.is_Integer:
+        constant_type = Integer()
+        constant_value = int(sympy_val)
+    elif sympy_val.is_Boolean:
+        constant_type = Bool()
+        constant_value = bool(sympy_val)
+    elif sympy_val.is_imaginary:
+        constant_type = Real()
+        constant_value = complex(sympy_val)
+    else:
+        constant_type = Real()
+        constant_value = float(sympy_val)
+    expr_val.set_type(node, constant_type)
+    expr_val.set_value(node, constant_value)
+    return True