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

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -1,22 +1,18 @@
 import ast
-from typing import Any, Optional, cast
+from typing import Any, cast
 
 import sympy
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.generator.arith.arithmetic import compute_arithmetic_result_type
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.handle_binding import HandleBinding
-from classiq.interface.model.quantum_type import (
-    QuantumBit,
-    QuantumNumeric,
-    QuantumType,
-)
 
 from classiq.evaluators.qmod_annotated_expression import (
     QmodAnnotatedExpression,
     QmodExprNodeId,
 )
+from classiq.evaluators.qmod_expression_visitors.out_of_place_node_transformer import (
+    OutOfPlaceNodeTransformer,
+)
 from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     BitwiseAnd,
     BitwiseNot,
@@ -25,7 +21,7 @@ from classiq.evaluators.qmod_expression_visitors.sympy_wrappers import (
     LShift,
     RShift,
 )
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType
+from classiq.model_expansions.atomic_expression_functions_defs import do_div
 
 _SYMPY_WRAPPERS = {
     wrapper.__name__: wrapper
@@ -37,10 +33,12 @@ _SYMPY_WRAPPERS = {
         LShift,
         RShift,
     ]
+} | {
+    do_div.__name__: do_div,
 }
 
 
-class _VarMaskTransformer(ast.NodeTransformer):
+class _VarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(self, expr_val: QmodAnnotatedExpression) -> None:
         self._expr_val = expr_val
         self._mask_id = 0
@@ -68,7 +66,7 @@ class _VarMaskTransformer(ast.NodeTransformer):
             mask = self._create_mask()
             self.masks[mask] = id(node)
             return ast.Name(id=mask)
-        return self.generic_visit(node)
+        return super().visit(node)
 
     def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
         mask = self._create_mask()
@@ -76,7 +74,7 @@ class _VarMaskTransformer(ast.NodeTransformer):
         return ast.Name(id=mask)
 
 
-class _InverseVarMaskTransformer(ast.NodeTransformer):
+class _InverseVarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(
         self, expr_val: QmodAnnotatedExpression, masks: dict[str, QmodExprNodeId]
     ) -> None:
@@ -93,7 +91,7 @@ class _InverseVarMaskTransformer(ast.NodeTransformer):
         return node
 
 
-class _SympyCompatibilityTransformer(ast.NodeTransformer):
+class _SympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
     def visit_BoolOp(self, node: ast.BoolOp) -> ast.Call:
         if len(node.values) != 2:
             raise ClassiqInternalExpansionError
@@ -151,6 +149,12 @@ class _SympyCompatibilityTransformer(ast.NodeTransformer):
             sympy_func = BitwiseXor.__name__
         elif isinstance(node.op, ast.BitAnd):
             sympy_func = BitwiseAnd.__name__
+        elif isinstance(node.op, ast.Div):
+            return ast.Call(
+                func=ast.Name(id=do_div.__name__),
+                args=[node.left, node.right],
+                keywords=[],
+            )
         else:
             return node
         return ast.Call(
@@ -158,7 +162,7 @@ class _SympyCompatibilityTransformer(ast.NodeTransformer):
         )
 
 
-class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
+class _InverseSympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
     def visit_Call(self, node: ast.Call) -> Any:
         node = cast(ast.Call, self.generic_visit(node))
         if not isinstance(node.func, ast.Name):
@@ -183,12 +187,12 @@ class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
             and (len(node.args) != 2 or len(node.keywords) > 0)
         ) or (
             func in {BitwiseNot.__name__}
-            and (len(node.args) != 2 or len(node.keywords) > 0)
+            and (len(node.args) != 1 or len(node.keywords) > 0)
         ):
             raise ClassiqInternalExpansionError
 
         if func == BitwiseNot.__name__:
-            return ast.UnaryOp(op=ast.Invert, operand=node.args[0])
+            return ast.UnaryOp(op=ast.Invert(), operand=node.args[0])
 
         if func == "Eq":
             return ast.Compare(
@@ -226,6 +230,13 @@ class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
         if func == BitwiseAnd.__name__:
             return ast.BinOp(left=node.args[0], op=ast.BitAnd(), right=node.args[1])
 
+        if func == "Mod":
+            return ast.BinOp(left=node.args[0], op=ast.Mod(), right=node.args[1])
+        if func == "Max":
+            node.func.id = "max"
+        elif func == "Min":
+            node.func.id = "min"
+
         return node
 
     def visit_UnaryOp(self, node: ast.UnaryOp) -> Any:
@@ -247,46 +258,12 @@ class _InverseSympyCompatibilityTransformer(ast.NodeTransformer):
         return node
 
 
-def _get_numeric_type(
-    expr_val: QmodAnnotatedExpression,
-    expr_type: QmodType,
-    simplified_expr: str,
-    masks: dict[str, QmodExprNodeId],
-    machine_precision: int,
-) -> Optional[QuantumNumeric]:
-    if isinstance(expr_type, QuantumBit):
-        return QuantumNumeric(
-            size=Expression(expr="1"),
-            is_signed=Expression(expr="False"),
-            fraction_digits=Expression(expr="0"),
-        )
-    if not isinstance(expr_type, QuantumNumeric):
-        return None
-    if expr_type.is_evaluated:
-        return expr_type
-    var_types = {
-        var_name: expr_val.get_type(node_id) for var_name, node_id in masks.items()
-    }
-    if not all(
-        isinstance(var_type, QuantumBit)
-        or (isinstance(var_type, QuantumNumeric) and var_type.is_instantiated)
-        for var_type in var_types.values()
-    ):
-        return None
-    return compute_arithmetic_result_type(
-        simplified_expr, cast(dict[str, QuantumType], var_types), machine_precision
-    )
-
-
-def simplify_qmod_expression(
-    expr_val: QmodAnnotatedExpression, machine_precision: int
-) -> tuple[str, Optional[QuantumNumeric]]:
+def simplify_qmod_expression(expr_val: QmodAnnotatedExpression) -> str:
     if expr_val.has_value(expr_val.root):
         raise ClassiqInternalExpansionError(
             "This expression is a constant value. No need for simplification"
         )
     var_mask_transformer = _VarMaskTransformer(expr_val)
-    masks = var_mask_transformer.masks
     mask_expr = var_mask_transformer.visit(expr_val.root)
     sympy_expr = _SympyCompatibilityTransformer().visit(mask_expr)
     simplified_expr = str(
@@ -295,14 +272,7 @@ def simplify_qmod_expression(
     restored_expr = _InverseSympyCompatibilityTransformer().visit(
         ast.parse(simplified_expr, mode="eval")
     )
-    expr_type = _get_numeric_type(
-        expr_val,
-        expr_val.get_type(expr_val.root),
-        ast.unparse(restored_expr),
-        masks,
-        machine_precision,
-    )
     restored_expr = _InverseVarMaskTransformer(
         expr_val, var_mask_transformer.masks
     ).visit(restored_expr)
-    return ast.unparse(restored_expr), expr_type
+    return ast.unparse(restored_expr)

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -23,7 +23,7 @@ from classiq.interface.model.quantum_type import (
 )
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType, get_qmod_type_name
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType
 
 
 def _eval_type_attribute(
@@ -71,7 +71,7 @@ def _eval_type_attribute(
                 expr_val.set_quantum_type_attr(node, subject, attr)
             return
     raise ClassiqExpansionError(
-        f"{get_qmod_type_name(subject_type)} has no attribute {attr!r}"
+        f"{subject_type.raw_qmod_type_name} has no attribute {attr!r}"
     )
 
 
@@ -94,7 +94,7 @@ def eval_attribute(expr_val: QmodAnnotatedExpression, node: ast.Attribute) -> No
         raise ClassiqInternalExpansionError
     if attr not in subject_fields:
         raise ClassiqExpansionError(
-            f"{get_qmod_type_name(subject_type)} has no field {attr!r}"
+            f"{subject_type.raw_qmod_type_name} has no field {attr!r}"
         )
     expr_val.set_type(node, subject_fields[attr])
 
@@ -103,9 +103,16 @@ def eval_attribute(expr_val: QmodAnnotatedExpression, node: ast.Attribute) -> No
         if (
             not isinstance(subject_value, QmodStructInstance)
             or attr not in subject_value.fields
-        ):
+        ) and (not isinstance(subject_value, dict) or attr not in subject_value):
             raise ClassiqInternalExpansionError
-        expr_val.set_value(node, subject_value.fields[attr])
+        if isinstance(subject_value, QmodStructInstance):
+            attr_value = subject_value.fields[attr]
+        else:
+            # dicts are supported because our foreign funcs return dicts instead of
+            # QmodStructInstances
+            # FIXME: Remove (CLS-3241)
+            attr_value = subject_value[attr]
+        expr_val.set_value(node, attr_value)
     elif expr_val.has_var(subject):
         subject_var = expr_val.get_var(subject)
         expr_val.set_var(node, FieldHandleBinding(base_handle=subject_var, field=attr))

classiq/evaluators/qmod_node_evaluators/binary_op_evaluation.py

@@ -5,10 +5,14 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
 from classiq.interface.model.quantum_type import QuantumNumeric
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.numeric_attrs_utils import (
+    get_classical_value_for_arithmetic,
+    get_numeric_attrs,
+)
 from classiq.evaluators.qmod_node_evaluators.utils import (
     IntegerValueType,
     NumberValueType,
@@ -17,14 +21,38 @@ from classiq.evaluators.qmod_node_evaluators.utils import (
     is_classical_type,
     is_numeric_type,
 )
+from classiq.model_expansions.arithmetic import NumericAttributes
+from classiq.model_expansions.arithmetic_compute_result_attrs import (
+    compute_result_attrs_add,
+    compute_result_attrs_bitwise_and,
+    compute_result_attrs_bitwise_or,
+    compute_result_attrs_bitwise_xor,
+    compute_result_attrs_lshift,
+    compute_result_attrs_modulo,
+    compute_result_attrs_multiply,
+    compute_result_attrs_power,
+    compute_result_attrs_rshift,
+    compute_result_attrs_subtract,
+)
 
 
-def _binary_op_allowed(left: QmodType, right: QmodType) -> bool:
-    return is_numeric_type(left) and is_numeric_type(right)
+def _binary_op_allowed(left: QmodType, right: QmodType, op: ast.AST) -> bool:
+    left_numeric = is_numeric_type(left)
+    right_numeric = is_numeric_type(right)
+    if isinstance(op, (ast.BitOr, ast.BitAnd, ast.BitXor)):
+        return (left_numeric or isinstance(left, Bool)) and (
+            right_numeric or isinstance(right, Bool)
+        )
+    return left_numeric and right_numeric
 
 
-def _validate_binary_op(op: ast.AST, left_type: QmodType, right_type: QmodType) -> None:
-    if not _binary_op_allowed(left_type, right_type):
+def _validate_binary_op(
+    op: ast.AST,
+    left_type: QmodType,
+    right_type: QmodType,
+    treat_qnum_as_float: bool,
+) -> None:
+    if not _binary_op_allowed(left_type, right_type, op):
         raise ClassiqExpansionError(
             f"Both sides of the binary operator {type(op).__name__!r} must be "
             f"scalar values"
@@ -48,15 +76,132 @@ def _validate_binary_op(op: ast.AST, left_type: QmodType, right_type: QmodType)
             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)
+    if not treat_qnum_as_float:
+        if isinstance(op, ast.FloorDiv) and (
+            not is_classical_type(left_type) or not is_classical_type(right_type)
+        ):
+            raise ClassiqExpansionError(
+                f"{type(op).__name__!r} with quantum variables is not supported"
+            )
+
+        if not is_classical_type(right_type) and isinstance(
+            op, (ast.Div, 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 _infer_binary_op_type(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.BinOp,
+    left_type: QmodType,
+    right_type: QmodType,
+    machine_precision: int,
+    treat_qnum_as_float: bool,
+) -> QmodType:
+    op = node.op
+
+    if is_classical_type(left_type) and is_classical_type(right_type):
+        if isinstance(left_type, Bool) and isinstance(right_type, Bool):
+            return Bool()
+        if (
+            not isinstance(op, ast.Div)
+            and (is_classical_integer(left_type) or isinstance(left_type, Bool))
+            and (is_classical_integer(right_type) or isinstance(right_type, Bool))
+        ):
+            return Integer()
+        return Real()
+
+    left_attrs = get_numeric_attrs(
+        expr_val, node.left, left_type, machine_precision, treat_qnum_as_float
+    )
+    right_attrs = get_numeric_attrs(
+        expr_val, node.right, right_type, machine_precision, treat_qnum_as_float
+    )
+
+    if left_attrs is None or right_attrs is None:
+        return QuantumNumeric()
+
+    right_value = get_classical_value_for_arithmetic(
+        expr_val, node.right, right_type, treat_qnum_as_float
+    )
+
+    if isinstance(op, ast.Add):
+        result_attrs = compute_result_attrs_add(
+            left_attrs, right_attrs, machine_precision
         )
-    ):
-        raise ClassiqExpansionError(
-            f"Right-hand side of binary operation {type(op).__name__!r} must be classical numeric value"
+
+    elif isinstance(op, ast.Sub):
+        result_attrs = compute_result_attrs_subtract(
+            left_attrs, right_attrs, machine_precision
         )
 
+    elif isinstance(op, ast.Mult):
+        result_attrs = compute_result_attrs_multiply(
+            left_attrs, right_attrs, machine_precision
+        )
+
+    elif isinstance(op, ast.Div):
+        if right_value is None:
+            return QuantumNumeric()
+        if right_value == 0:
+            raise ClassiqExpansionError("Division by zero")
+        right_attrs = NumericAttributes.from_constant(
+            1 / right_value, machine_precision
+        )
+        result_attrs = compute_result_attrs_multiply(
+            left_attrs, right_attrs, machine_precision
+        )
+    elif isinstance(op, ast.FloorDiv):
+        return QuantumNumeric()
+
+    elif isinstance(op, ast.Mod):
+        if right_value is None or treat_qnum_as_float:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_modulo(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.Pow):
+        if right_value is None or treat_qnum_as_float:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_power(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.LShift):
+        if right_value is None:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_lshift(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.RShift):
+        if right_value is None:
+            return QuantumNumeric()
+        result_attrs = compute_result_attrs_rshift(
+            left_attrs, right_value, machine_precision
+        )
+
+    elif isinstance(op, ast.BitAnd):
+        result_attrs = compute_result_attrs_bitwise_and(
+            left_attrs, right_attrs, machine_precision
+        )
+    elif isinstance(op, ast.BitOr):
+        result_attrs = compute_result_attrs_bitwise_or(
+            left_attrs, right_attrs, machine_precision
+        )
+
+    elif isinstance(op, ast.BitXor):
+        result_attrs = compute_result_attrs_bitwise_xor(
+            left_attrs, right_attrs, machine_precision
+        )
+    else:
+        raise ClassiqInternalExpansionError
+
+    return result_attrs.to_quantum_numeric()
+
 
 def _eval_binary_op_constant(
     op: ast.AST, left_value: NumberValueType, right_value: NumberValueType
@@ -79,9 +224,9 @@ def _eval_binary_op_constant(
         return left_value // right_value
     if isinstance(op, ast.Mod):
         if right_value == 0:
-            raise ClassiqExpansionError("Integer modulu by zero")
+            raise ClassiqExpansionError("Integer modulo by zero")
         if isinstance(left_value, complex) or isinstance(right_value, complex):
-            raise ClassiqExpansionError("Integer modulu with a complex number")
+            raise ClassiqExpansionError("Integer modulo with a complex number")
         return left_value % right_value
     if isinstance(op, ast.Pow):
         return left_value**right_value
@@ -104,27 +249,29 @@ def _eval_binary_op_constant(
     raise ClassiqInternalExpansionError
 
 
-def eval_binary_op(expr_val: QmodAnnotatedExpression, node: ast.BinOp) -> None:
+def eval_binary_op(
+    expr_val: QmodAnnotatedExpression,
+    node: ast.BinOp,
+    treat_qnum_as_float: bool,
+    machine_precision: int,
+) -> 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)
+    _validate_binary_op(op, left_type, right_type, treat_qnum_as_float)
+
+    inferred_type = _infer_binary_op_type(
+        expr_val,
+        node,
+        left_type,
+        right_type,
+        machine_precision,
+        treat_qnum_as_float,
+    )
+    expr_val.set_type(node, inferred_type)
 
     if expr_val.has_value(left) and expr_val.has_value(right):
         left_value = expr_val.get_value(left)

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -28,10 +28,11 @@ from classiq.evaluators.qmod_node_evaluators.utils import (
     QmodType,
     array_len,
     element_types,
-    get_qmod_type_name,
+    is_classical_integer,
 )
 
-MIN_MAX_FUNCTION_NAMES = {"min", "Min", "max", "Max"}
+# These sympy functions are not declared as int funcs for some reason...
+INTEGER_FUNCTION_OVERRIDE = {"floor", "ceiling"}
 
 
 def _check_classical_array_arg_type(
@@ -91,8 +92,8 @@ def _check_classical_arg(
     ):
         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)}"
+            f"{param_type.qmod_type_name} argument, but got a "
+            f"{arg_type.qmod_type_name}"
         )
 
 
@@ -191,7 +192,9 @@ def try_eval_sympy_function(
         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:
+    elif (
+        hasattr(sympy_func, "is_Integer") and sympy_func.is_Integer
+    ) or func_name in INTEGER_FUNCTION_OVERRIDE:
         ret_type = Integer()
         if args is not None:
             ret_val = int(sympy_ret_val)
@@ -241,15 +244,6 @@ def try_eval_builtin_function(
     )
     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
@@ -298,6 +292,19 @@ def try_eval_builtin_function(
             )
         return True
 
+    if func_name == "abs":
+        _validate_no_kwargs(node)
+        if len(node.args) > 0 and is_classical_integer(expr_val.get_type(node.args[0])):
+            ret_type = Integer()
+        else:
+            ret_type = Real()
+        expr_val.set_type(node, ret_type)
+        if args_have_values:
+            expr_val.set_value(
+                node, sympy.Abs(*[expr_val.get_value(arg) for arg in node.args])
+            )
+        return True
+
     return False
 
 

classiq/evaluators/qmod_node_evaluators/compare_evaluation.py

@@ -14,6 +14,7 @@ from classiq.interface.generator.functions.classical_type import (
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.model.quantum_type import (
     QuantumBit,
+    QuantumBitvector,
     QuantumNumeric,
     QuantumScalar,
 )
@@ -23,7 +24,6 @@ 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,
@@ -34,11 +34,13 @@ def comparison_allowed(
     left: QmodType, right: QmodType, inequality: bool = False
 ) -> bool:
     if isinstance(left, Bool):
-        return isinstance(right, (Bool, QuantumBit)) or (
+        return isinstance(right, (Bool, Integer, 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)
+        return isinstance(right, (Real, Bool, QuantumScalar)) or is_classical_integer(
+            right
+        )
     if isinstance(left, (ClassicalArray, ClassicalTuple)):
         if inequality:
             return False
@@ -62,6 +64,8 @@ def comparison_allowed(
         return isinstance(right, (Bool, Real, QuantumScalar)) or is_classical_integer(
             right
         )
+    if isinstance(left, QuantumBitvector):
+        return False
     raise ClassiqInternalExpansionError
 
 
@@ -76,8 +80,8 @@ def eval_compare(expr_val: QmodAnnotatedExpression, node: ast.Compare) -> None:
     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}"
+            f"Cannot compare {left_type.qmod_type_name} {ast.unparse(left)!r} "
+            f"and {right_type.qmod_type_name} {ast.unparse(right)!r}"
         )
     qmod_type: QmodType
     if not is_classical_type(left_type) or not is_classical_type(right_type):

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -7,12 +7,22 @@ import sympy
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
 )
-from classiq.interface.generator.functions.classical_type import Bool, Integer, Real
+from classiq.interface.generator.functions.classical_type import (
+    Bool,
+    ClassicalType,
+    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
 
+QMOD_LITERALS: dict[str, tuple[ClassicalType, Any]] = {
+    "false": (Bool(), False),
+    "true": (Bool(), True),
+}
+
 
 def eval_enum_member(
     expr_val: QmodAnnotatedExpression, node: ast.Attribute, enum: type[IntEnum]
@@ -44,6 +54,15 @@ def eval_constant(expr_val: QmodAnnotatedExpression, node: ast.Constant) -> None
     expr_val.set_type(node, constant_type)
 
 
+def try_eval_qmod_literal(expr_val: QmodAnnotatedExpression, node: ast.Name) -> bool:
+    if node.id not in QMOD_LITERALS:
+        return False
+    lit_type, lit_val = QMOD_LITERALS[node.id]
+    expr_val.set_type(node, lit_type)
+    expr_val.set_value(node, lit_val)
+    return True
+
+
 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():