classiq 0.89.0__py3-none-any.whl → 0.90.0__py3-none-any.whl

classiq/evaluators/parameter_types.py

@@ -1,4 +1,4 @@
-from typing import Optional, TypeVar, Union
+from typing import TYPE_CHECKING, Any, NoReturn, TypeVar, Union
 
 import sympy
 
@@ -6,14 +6,17 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.expressions.proxies.classical.any_classical_value import (
-    AnyClassicalValue,
+from classiq.interface.generator.expressions.evaluated_expression import (
+    EvaluatedExpression,
 )
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.expression_types import RuntimeConstant
 from classiq.interface.generator.functions.classical_type import (
+    Bool,
     ClassicalArray,
     ClassicalTuple,
     ClassicalType,
+    Integer,
 )
 from classiq.interface.generator.functions.concrete_types import ConcreteQuantumType
 from classiq.interface.generator.functions.port_declaration import (
@@ -22,12 +25,14 @@ from classiq.interface.generator.functions.port_declaration import (
 from classiq.interface.generator.functions.type_name import (
     TypeName,
 )
+from classiq.interface.helpers.backward_compatibility import zip_strict
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
+    AnonQuantumOperandDeclaration,
     PositionalArg,
     QuantumOperandDeclaration,
 )
@@ -38,71 +43,62 @@ from classiq.interface.model.quantum_type import (
     QuantumType,
 )
 
-from classiq.evaluators.arg_type_match import check_type_match
 from classiq.evaluators.classical_expression import (
     evaluate_classical_expression,
 )
-from classiq.evaluators.classical_type_inference import (
+from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
+from classiq.evaluators.qmod_node_evaluators.utils import QmodType, get_sympy_val
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
     infer_classical_type,
+    inject_classical_type_attributes,
 )
 from classiq.evaluators.qmod_type_inference.quantum_type_inference import (
     inject_quantum_type_attributes,
+    validate_quantum_type_attributes,
 )
+from classiq.evaluators.type_type_match import check_signature_match
 from classiq.model_expansions.closure import FunctionClosure
 from classiq.model_expansions.scope import (
+    ClassicalSymbol,
     Evaluated,
     QuantumSymbol,
     QuantumVariable,
     Scope,
 )
+from classiq.model_expansions.visitors.symbolic_param_inference import (
+    set_generative_recursively,
+)
 
 
 def evaluate_parameter_types_from_args(
-    closure: FunctionClosure, signature_scope: Scope, arguments: list[Evaluated]
+    closure: FunctionClosure, arguments: list[Evaluated]
 ) -> list[PositionalArg]:
     parameters = closure.positional_arg_declarations
-    function_name = closure.name
-    check_type_match(parameters, arguments, function_name)
+    if len(parameters) != len(arguments):
+        raise ClassiqExpansionError(
+            f"Function {closure.name!r} takes {len(parameters)} arguments but "
+            f"{len(arguments)} were given"
+        )
+
+    for parameter, argument in zip_strict(parameters, arguments, strict=True):
+        if isinstance(parameter, ClassicalParameterDeclaration):
+            arg_val = argument.value
+            if not isinstance(arg_val, QmodAnnotatedExpression):
+                closure.scope[parameter.name] = argument
 
-    for parameter, argument in zip(parameters, arguments):
-        _update_scope(parameter, argument, closure)
+    evaluated_params = [
+        _evaluate_type_from_arg(parameter, argument, closure)
+        for parameter, argument in zip_strict(parameters, arguments, strict=True)
+    ]
 
     parameter_names = {parameter.name for parameter in parameters}
-    for parameter in parameters:
+    for parameter, argument in zip_strict(parameters, arguments, strict=True):
         if isinstance(parameter, QuantumOperandDeclaration):
-            parameter_value = closure.scope[parameter.name].value
             _update_operand_signature_environment(
-                parameter_value, parameter_names, closure
+                argument.value, parameter_names, closure
             )
 
-    return [
-        _evaluate_type_from_arg(
-            parameter,
-            argument,
-            Scope(parent=closure.scope | signature_scope),
-            closure.name,
-        )
-        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_var = argument.as_type(QuantumVariable)
-    casted_argument = _cast(
-        parameter.quantum_type,
-        quantum_var,
-        parameter.name,
-    )
-    closure.scope[parameter.name] = Evaluated(
-        value=casted_argument, defining_function=closure
-    )
+    return evaluated_params
 
 
 NestedFunctionClosureT = Union[FunctionClosure, list["NestedFunctionClosureT"]]
@@ -130,60 +126,162 @@ def _update_operand_signature_environment(
     )
 
 
-def _cast(
-    parameter_type: QuantumType, argument: QuantumVariable, param_name: str
-) -> QuantumSymbol:
-    updated_type = inject_quantum_type_attributes(argument.quantum_type, parameter_type)
-    if updated_type is None:
-        raise ClassiqExpansionError(
-            f"Argument {str(argument)!r} of type "
-            f"{argument.quantum_type.qmod_type_name} is incompatible with parameter "
-            f"{param_name!r} of type {parameter_type.qmod_type_name}"
-        )
-    return QuantumSymbol(
-        handle=HandleBinding(name=param_name), quantum_type=updated_type
-    )
-
-
 def _evaluate_type_from_arg(
     parameter: PositionalArg,
     argument: Evaluated,
-    inner_scope: Scope,
-    function_name: str,
+    closure: FunctionClosure,
 ) -> PositionalArg:
     # FIXME: Remove suzuki_trotter overloading (CLS-2912)
-    if function_name == "suzuki_trotter" and parameter.name == "pauli_operator":
+    if closure.name == "suzuki_trotter" and parameter.name == "pauli_operator":
         return parameter
     if isinstance(parameter, ClassicalParameterDeclaration):
-        updated_classical_type = evaluate_type_in_classical_symbol(
-            parameter.classical_type.model_copy(), inner_scope, parameter.name
-        )
-        return ClassicalParameterDeclaration(
-            name=parameter.name,
-            classical_type=infer_classical_type(argument.value, updated_classical_type),
+        return _evaluate_classical_type_from_arg(parameter, argument, closure)
+    if isinstance(parameter, PortDeclaration):
+        return _evaluate_quantum_type_from_arg(parameter, argument, closure)
+    if TYPE_CHECKING:
+        assert isinstance(parameter, QuantumOperandDeclaration)
+    if parameter.is_list:
+        return _evaluate_op_list_type_from_arg(parameter, argument, closure)
+    else:
+        return _evaluate_op_type_from_arg(parameter, argument, closure)
+
+
+def _evaluate_classical_type_from_arg(
+    parameter: ClassicalParameterDeclaration,
+    argument: Evaluated,
+    closure: FunctionClosure,
+) -> ClassicalParameterDeclaration:
+    unified_scope = closure.scope | closure.signature_scope
+    updated_classical_type = evaluate_type_in_classical_symbol(
+        parameter.classical_type.model_copy(), unified_scope, parameter.name
+    )
+    arg_val = argument.value
+    if isinstance(arg_val, QmodAnnotatedExpression):
+        arg_type = arg_val.get_classical_type(arg_val.root)
+    else:
+        arg_type = infer_classical_type(arg_val)
+    injected_classical_type = inject_classical_type_attributes(
+        arg_type.without_symbolic_attributes(), updated_classical_type
+    )
+    if injected_classical_type is None:
+        _raise_argument_type_error(
+            arg_val, arg_type, parameter.name, updated_classical_type
         )
+    if parameter.classical_type.is_purely_generative:
+        set_generative_recursively(injected_classical_type)
+    closure.scope[parameter.name] = Evaluated(
+        value=(
+            ClassicalSymbol(
+                handle=HandleBinding(name=parameter.name),
+                classical_type=injected_classical_type,
+            )
+            if isinstance(arg_val, QmodAnnotatedExpression)
+            else arg_val
+        ),
+        defining_function=closure,
+    )
+    return ClassicalParameterDeclaration(
+        name=parameter.name, classical_type=injected_classical_type
+    )
 
-    if not isinstance(parameter, PortDeclaration):
-        return parameter
 
+def _evaluate_quantum_type_from_arg(
+    parameter: PortDeclaration,
+    argument: Evaluated,
+    closure: FunctionClosure,
+) -> PortDeclaration:
+    unified_scope = closure.scope | closure.signature_scope
     updated_quantum_type: QuantumType = evaluate_type_in_quantum_symbol(
-        parameter.quantum_type.model_copy(), inner_scope, parameter.name
+        parameter.quantum_type.model_copy(), unified_scope, parameter.name
     )
     if parameter.direction != PortDeclarationDirection.Output:
         arg_type = argument.as_type(QuantumVariable).quantum_type
         updated_output_quantum_type = inject_quantum_type_attributes(
-            arg_type, updated_quantum_type
+            arg_type.without_symbolic_attributes(), updated_quantum_type
         )
         if updated_output_quantum_type is None:
-            raise ClassiqExpansionError(
-                f"Argument {str(argument.value)!r} of type "
-                f"{arg_type.qmod_type_name} is incompatible with parameter "
-                f"{parameter.name!r} of type {updated_quantum_type.qmod_type_name}"
+            _raise_argument_type_error(
+                argument.value, arg_type, parameter.name, updated_quantum_type
             )
         updated_quantum_type = updated_output_quantum_type
+    validate_quantum_type_attributes(updated_quantum_type)
+    closure.scope[parameter.name] = Evaluated(
+        value=QuantumSymbol(
+            handle=HandleBinding(name=parameter.name), quantum_type=updated_quantum_type
+        ),
+        defining_function=closure,
+    )
     return parameter.model_copy(update={"quantum_type": updated_quantum_type})
 
 
+def _evaluate_op_list_type_from_arg(
+    parameter: QuantumOperandDeclaration, argument: Evaluated, closure: FunctionClosure
+) -> QuantumOperandDeclaration:
+    arg_val = argument.value
+    if not isinstance(arg_val, list) or any(
+        not isinstance(op, FunctionClosure) for op in arg_val
+    ):
+        if isinstance(arg_val, FunctionClosure):
+            _raise_argument_type_error(
+                "<lambda>",
+                arg_val.as_operand_declaration(is_list=False),
+                parameter.name,
+                parameter,
+            )
+        raise ClassiqInternalExpansionError("Non-lambda argument to lambda parameter")
+    for idx, operand in enumerate(arg_val):
+        check_signature_match(
+            parameter.positional_arg_declarations,
+            operand.positional_arg_declarations,
+            f"operand #{idx + 1} in parameter {parameter.name!r} "
+            f"in function {closure.name!r}",
+        )
+    return parameter
+
+
+def _evaluate_op_type_from_arg(
+    parameter: QuantumOperandDeclaration, argument: Evaluated, closure: FunctionClosure
+) -> QuantumOperandDeclaration:
+    arg_val = argument.value
+    if not isinstance(arg_val, FunctionClosure):
+        if isinstance(arg_val, list):
+            if len(arg_val) == 0:
+                _raise_argument_type_error(
+                    arg_val,
+                    AnonQuantumOperandDeclaration(is_list=True),
+                    parameter.name,
+                    parameter,
+                )
+            first_lambda = arg_val[0]
+            if isinstance(first_lambda, FunctionClosure):
+                _raise_argument_type_error(
+                    arg_val,
+                    first_lambda.as_operand_declaration(is_list=True),
+                    parameter.name,
+                    parameter,
+                )
+        raise ClassiqInternalExpansionError("Non-lambda argument to lambda parameter")
+    check_signature_match(
+        parameter.positional_arg_declarations,
+        arg_val.positional_arg_declarations,
+        f"operand {parameter.name!r} in function {closure.name!r}",
+    )
+    return parameter
+
+
+def _raise_argument_type_error(
+    arg_val: Any,
+    arg_type: Union[QmodType, AnonQuantumOperandDeclaration],
+    param_name: str,
+    param_type: Union[QmodType, AnonQuantumOperandDeclaration],
+) -> NoReturn:
+    raise ClassiqExpansionError(
+        f"Argument {str(arg_val)!r} of type "
+        f"{arg_type.qmod_type_name} is incompatible with parameter "
+        f"{param_name!r} of type {param_type.qmod_type_name}"
+    )
+
+
 def evaluate_type_in_quantum_symbol(
     type_to_update: QuantumType, scope: Scope, param_name: str
 ) -> ConcreteQuantumType:
@@ -206,16 +304,15 @@ def _evaluate_qarray_in_quantum_symbol(
     )
     type_to_update.element_type = new_element_type
     if type_to_update.length is not None:
-        new_length = _eval_expr(
+        type_to_update.length = _eval_expr(
             type_to_update.length,
             scope,
             int,
+            Integer,
             type_to_update.type_name,
             "length",
             param_name,
         )
-        if new_length is not None:
-            type_to_update.length = Expression(expr=str(new_length))
     return type_to_update
 
 
@@ -224,73 +321,74 @@ def _evaluate_qnum_in_quantum_symbol(
 ) -> QuantumNumeric:
     if type_to_update.size is None:
         return type_to_update
-    new_size = _eval_expr(
+    type_to_update.size = _eval_expr(
         type_to_update.size,
         scope,
         int,
+        Integer,
         type_to_update.type_name,
         "size",
         param_name,
     )
-    if new_size is not None:
-        type_to_update.size = Expression(expr=str(new_size))
 
     if type_to_update.is_signed is not None:
-        new_is_sign = _eval_expr(
+        type_to_update.is_signed = _eval_expr(
             type_to_update.is_signed,
             scope,
             bool,
+            Bool,
             type_to_update.type_name,
             "sign",
             param_name,
         )
-        if new_is_sign is not None:
-            type_to_update.is_signed = Expression(expr=str(new_is_sign))
     else:
         type_to_update.is_signed = Expression(expr="False")
 
     if type_to_update.fraction_digits is not None:
-        new_fraction_digits = _eval_expr(
+        type_to_update.fraction_digits = _eval_expr(
             type_to_update.fraction_digits,
             scope,
             int,
+            Integer,
             type_to_update.type_name,
             "fraction digits",
             param_name,
         )
-        if new_fraction_digits is not None:
-            type_to_update.fraction_digits = Expression(expr=str(new_fraction_digits))
     else:
         type_to_update.fraction_digits = Expression(expr="0")
 
     return type_to_update
 
 
-_EXPR_TYPE = TypeVar("_EXPR_TYPE")
+_EXPR_TYPE = TypeVar("_EXPR_TYPE", bound=RuntimeConstant)
 
 
 def _eval_expr(
     expression: Expression,
     scope: Scope,
     expected_type: type[_EXPR_TYPE],
+    expected_qmod_type: type,
     type_name: str,
     attr_name: str,
     param_name: str,
-) -> Optional[_EXPR_TYPE]:
-    val = evaluate_classical_expression(expression, scope).value
-    if expected_type is int and isinstance(val, float):
+) -> Expression:
+    val = evaluate_classical_expression(Expression(expr=expression.expr), scope).value
+    if isinstance(val, sympy.Basic):
+        val = get_sympy_val(val)
+    if expected_type is int and isinstance(val, float) and int(val) == val:
         val = int(val)
-    if isinstance(val, expected_type):
-        return val
-    if isinstance(val, AnyClassicalValue) or (
-        isinstance(val, sympy.Basic) and len(val.free_symbols) > 0
+    if not isinstance(val, expected_type) and (
+        not isinstance(val, QmodAnnotatedExpression)
+        or not isinstance(val.get_type(val.root), expected_qmod_type)
     ):
-        return None
-    raise ClassiqExpansionError(
-        f"When inferring the type of parameter {param_name!r}: "
-        f"{type_name} {attr_name} must be {expected_type.__name__}, got "
-        f"{str(val)!r}"
-    )
+        raise ClassiqExpansionError(
+            f"When inferring the type of parameter {param_name!r}: "
+            f"{type_name} {attr_name} must be {expected_qmod_type.__name__}, got "
+            f"{str(val)!r}"
+        )
+    expr = Expression(expr=str(val))
+    expr._evaluated_expr = EvaluatedExpression(value=val)
+    return expr
 
 
 def _evaluate_qstruct_in_quantum_symbol(
@@ -325,11 +423,9 @@ def evaluate_type_in_classical_symbol(
     if isinstance(type_to_update, ClassicalArray):
         length = type_to_update.length
         if length is not None:
-            new_length = _eval_expr(
-                length, scope, int, "classical array", "length", param_name
+            length = _eval_expr(
+                length, scope, int, Integer, "classical array", "length", param_name
             )
-            if new_length is not None:
-                length = Expression(expr=str(new_length))
         updated_type = ClassicalArray(
             element_type=evaluate_type_in_classical_symbol(
                 type_to_update.element_type, scope, param_name

classiq/evaluators/qmod_annotated_expression.py

@@ -4,6 +4,8 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Union, cast
 
+import sympy
+
 from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
@@ -50,7 +52,7 @@ def qmod_val_to_str(val: Any) -> str:
         return f"[{', '.join(qmod_val_to_str(item) for item in val)}]"
     if isinstance(val, Enum):
         return Enum.__str__(val)
-    if isinstance(val, (int, float, bool, complex)):
+    if isinstance(val, (int, float, bool, complex, sympy.Basic)):
         return str(val)
     raise ClassiqInternalExpansionError(
         f"Unrecognized value {str(val)!r} of type {type(val)}"

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -1,5 +1,5 @@
 import ast
-from typing import Any, Callable, Optional, Union, cast
+from typing import Callable, Union, cast
 
 import sympy
 
@@ -184,37 +184,25 @@ def try_eval_sympy_function(
     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
     ) or func_name in INTEGER_FUNCTION_OVERRIDE:
         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)
+
+    if any(not expr_val.has_value(arg) for arg in node.args):
+        return True
+
+    args = [expr_val.get_value(arg) for arg in node.args]
+    sympy_ret_val = sympy_func(*args)
+    if not isinstance(sympy_ret_val, sympy.Basic):
+        raise ClassiqInternalExpansionError
+    expr_val.set_value(node, sympy_ret_val)
     return True
 
 
@@ -265,14 +253,7 @@ def try_eval_builtin_function(
             sympy_val = sympy.mod_inverse(
                 *[expr_val.get_value(arg) for arg in node.args]
             )
-            ret_val: Any
-            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
-                ret_val = complex(sympy_val)
-            elif args_are_int:
-                ret_val = int(sympy_val)
-            else:
-                ret_val = float(sympy_val)
-            expr_val.set_value(node, ret_val)
+            expr_val.set_value(node, sympy_val)
         return True
 
     if func_name == "sum":
@@ -293,13 +274,7 @@ def try_eval_builtin_function(
         expr_val.set_type(node, Real())
         if args_have_values:
             sympy_val = sympy.sqrt(*[expr_val.get_value(arg) for arg in node.args])
-            if isinstance(sympy_val, sympy.Expr) and sympy_val.is_imaginary:
-                ret_val = complex(sympy_val)
-            elif float(sympy_val) == int(sympy_val):
-                ret_val = int(sympy_val)
-            else:
-                ret_val = float(sympy_val)
-            expr_val.set_value(node, ret_val)
+            expr_val.set_value(node, sympy_val)
         return True
 
     if func_name == "abs":

classiq/evaluators/qmod_node_evaluators/constant_evaluation.py

@@ -16,7 +16,11 @@ from classiq.interface.generator.functions.classical_type import (
 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
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    SYMPY_SYMBOLS,
+    QmodType,
+    get_sympy_type,
+)
 
 QMOD_LITERALS: dict[str, tuple[ClassicalType, Any]] = {
     "false": (Bool(), False),
@@ -68,22 +72,9 @@ def try_eval_qmod_literal(expr_val: QmodAnnotatedExpression, node: ast.Name) ->
 
 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():
+    if not isinstance(sympy_val, sympy.Basic) or len(sympy_val.free_symbols) > 0:
         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)
+    constant_type = get_sympy_type(sympy_val)
     expr_val.set_type(node, constant_type)
-    expr_val.set_value(node, constant_value)
+    expr_val.set_value(node, sympy_val)
     return True

classiq/evaluators/qmod_node_evaluators/measurement_evaluation.py

@@ -21,5 +21,5 @@ def eval_measurement(expr_val: QmodAnnotatedExpression, node: ast.Call) -> None:
     if is_classical_type(arg_type):
         raise ClassiqExpansionError("'measure' expects a quantum input")
     if not isinstance(arg_type, QuantumBit):
-        raise ClassiqExpansionError("Currently, 'measure' only supports quantum bits")
+        raise ClassiqExpansionError("'measure' only supports QBits")
     expr_val.set_type(node, Bool())

classiq/evaluators/qmod_node_evaluators/min_max_evaluation.py

@@ -1,5 +1,7 @@
 import ast
 
+import sympy
+
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
@@ -84,7 +86,11 @@ def eval_min_max_op(
 
     if all(expr_val.has_value(arg) for arg in node.args):
         values = [expr_val.get_value(arg) for arg in node.args]
-        if not all(isinstance(value, (int, float)) for value in values):
+        if not all(
+            isinstance(value, (int, float))
+            or (isinstance(value, sympy.Expr) and value.is_real)
+            for value in values
+        ):
             raise ClassiqExpansionError(f"Invalid argument for function {func_name!r}")
 
         if func_name == "min":

classiq/evaluators/qmod_node_evaluators/name_evaluation.py

@@ -22,7 +22,6 @@ from classiq.evaluators.qmod_type_inference.classical_type_inference import (
 
 
 def eval_name(expr_val: QmodAnnotatedExpression, node: ast.Name, value: Any) -> None:
-    # FIXME: Remove sympy compatibility (CLS-3214)
     if isinstance(
         value, (bool, int, float, complex, list, QmodStructInstance, sympy.Basic)
     ):

classiq/evaluators/qmod_node_evaluators/numeric_attrs_utils.py

@@ -1,12 +1,18 @@
 import ast
 from typing import TYPE_CHECKING, Optional
 
+import sympy
+
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.generator.functions.classical_type import Bool
 from classiq.interface.model.quantum_type import QuantumScalar
 
 from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
-from classiq.evaluators.qmod_node_evaluators.utils import QmodType, is_classical_type
+from classiq.evaluators.qmod_node_evaluators.utils import (
+    QmodType,
+    get_sympy_val,
+    is_classical_type,
+)
 from classiq.model_expansions.arithmetic import NumericAttributes
 
 
@@ -46,6 +52,8 @@ def get_classical_value_for_arithmetic(
         return None
 
     value = expr_val.get_value(node)
+    if isinstance(value, sympy.Basic):
+        value = get_sympy_val(value)
     if not isinstance(value, (int, float)):
         if treat_qnum_as_float and isinstance(value, complex):
             return None