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

classiq/_internals/config.py

@@ -24,7 +24,7 @@ class Configuration(BaseModel):
 
     host: pydantic.AnyHttpUrl = pydantic.Field(..., description="Classiq backend URI.")
     ide: pydantic.AnyHttpUrl = pydantic.Field(
-        default=DEFAULT_IDE_FE_APP, description="Classiq IDE URI."
+        default=pydantic.AnyHttpUrl(DEFAULT_IDE_FE_APP), description="Classiq IDE URI."
     )
     should_check_host: bool = pydantic.Field(
         default=True, description="Should check backend URI and version."

classiq/applications/__init__.py

@@ -1,9 +1,8 @@
-from classiq.applications import chemistry, combinatorial_optimization, finance, qsvm
+from classiq.applications import chemistry, combinatorial_optimization, qsvm
 
 __all__ = [
     "chemistry",
     "combinatorial_optimization",
-    "finance",
     "qsvm",
 ]
 

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -43,7 +43,7 @@ def compute_qaoa_initial_point(
 
     beta_params: np.ndarray = np.linspace(1, 0, repetitions) * time_step
     gamma_params: np.ndarray = np.linspace(0, 1, repetitions) * time_step
-    return list(itertools.chain(*zip(gamma_params, beta_params)))
+    return [float(x) for x in itertools.chain(*zip(gamma_params, beta_params))]
 
 
 def pyo_model_to_hamiltonian(

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -137,7 +137,7 @@ def hamiltonian_to_matrix(
         hamiltonian = _sparse_pauli_to_list(hamiltonian)
     matrix = np.zeros(
         [2 ** len(hamiltonian[0].pauli), 2 ** len(hamiltonian[0].pauli)],
-        dtype=np.complex_,
+        dtype=np.complex128,
     )
     for p in hamiltonian:
         matrix += p.coefficient * pauli_string_to_mat(p.pauli)

classiq/evaluators/qmod_annotated_expression.py

@@ -1,5 +1,5 @@
 import ast
-from collections.abc import Sequence
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
 from enum import Enum
 from typing import Any, Union, cast
@@ -30,7 +30,7 @@ class QuantumSubscriptAnnotation:
 
 @dataclass(frozen=True)
 class QuantumTypeAttributeAnnotation:
-    value: QmodExprNodeId
+    value: HandleBinding
     attr: str
 
 
@@ -45,7 +45,7 @@ def qmod_val_to_str(val: Any) -> str:
             f"{field_name}={qmod_val_to_str(field_val)}"
             for field_name, field_val in val.fields.items()
         )
-        return f"{val.struct_declaration.name}({fields})"
+        return f"struct_literal({val.struct_declaration.name}, {fields})"
     if isinstance(val, list):
         return f"[{', '.join(qmod_val_to_str(item) for item in val)}]"
     if isinstance(val, Enum):
@@ -82,9 +82,13 @@ class QmodAnnotatedExpression:
             QmodExprNodeId, QuantumTypeAttributeAnnotation
         ] = {}
         self._concatenations: dict[QmodExprNodeId, ConcatenationAnnotation] = {}
+        self._locked = False
+
+    def print_by_node(self, node: ast.AST) -> str:
+        return ast.unparse(_ExprInliner(self).visit(node))
 
     def __str__(self) -> str:
-        return ast.unparse(_ExprInliner(self).visit(self.root))
+        return self.print_by_node(self.root)
 
     def has_node(self, node_id: QmodExprNodeId) -> bool:
         return node_id in self._node_mapping
@@ -93,6 +97,8 @@ class QmodAnnotatedExpression:
         return self._node_mapping[node_id]
 
     def set_value(self, node: Union[ast.AST, QmodExprNodeId], value: Any) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         self._values[node] = value
@@ -110,6 +116,8 @@ class QmodAnnotatedExpression:
     def set_type(
         self, node: Union[ast.AST, QmodExprNodeId], qmod_type: QmodType
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node_id = id(node)
             self._node_mapping[node_id] = node
@@ -138,6 +146,8 @@ class QmodAnnotatedExpression:
         return cast(ClassicalType, qmod_type)
 
     def set_var(self, node: Union[ast.AST, QmodExprNodeId], var: HandleBinding) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         var = var.collapse()
         if isinstance(node, ast.AST):
             node = id(node)
@@ -165,6 +175,8 @@ class QmodAnnotatedExpression:
         return node in self._quantum_vars
 
     def remove_var(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if node in self._classical_vars:
@@ -178,6 +190,8 @@ class QmodAnnotatedExpression:
         value: Union[ast.AST, QmodExprNodeId],
         index: Union[ast.AST, QmodExprNodeId],
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         if isinstance(value, ast.AST):
@@ -195,19 +209,19 @@ class QmodAnnotatedExpression:
 
     def get_quantum_subscripts(
         self,
-    ) -> dict[QmodExprNodeId, QuantumSubscriptAnnotation]:
+    ) -> Mapping[QmodExprNodeId, QuantumSubscriptAnnotation]:
         return self._quantum_subscripts
 
     def set_quantum_type_attr(
         self,
         node: Union[ast.AST, QmodExprNodeId],
-        value: Union[ast.AST, QmodExprNodeId],
+        value: HandleBinding,
         attr: str,
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
-        if isinstance(value, ast.AST):
-            value = id(value)
         self._quantum_type_attrs[node] = QuantumTypeAttributeAnnotation(
             value=value, attr=attr
         )
@@ -219,7 +233,7 @@ class QmodAnnotatedExpression:
 
     def get_quantum_type_attributes(
         self,
-    ) -> dict[QmodExprNodeId, QuantumTypeAttributeAnnotation]:
+    ) -> Mapping[QmodExprNodeId, QuantumTypeAttributeAnnotation]:
         return self._quantum_type_attrs
 
     def set_concatenation(
@@ -227,6 +241,8 @@ class QmodAnnotatedExpression:
         node: Union[ast.AST, QmodExprNodeId],
         elements: Sequence[Union[ast.AST, QmodExprNodeId]],
     ) -> None:
+        if self._locked:
+            raise ClassiqInternalExpansionError("QAE is locked")
         if isinstance(node, ast.AST):
             node = id(node)
         inlined_elements: list[QmodExprNodeId] = []
@@ -244,13 +260,13 @@ class QmodAnnotatedExpression:
             node = id(node)
         return node in self._concatenations
 
-    def get_concatenations(self) -> dict[QmodExprNodeId, ConcatenationAnnotation]:
+    def get_concatenations(self) -> Mapping[QmodExprNodeId, ConcatenationAnnotation]:
         return self._concatenations
 
-    def get_classical_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+    def get_classical_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._classical_vars
 
-    def get_quantum_vars(self) -> dict[QmodExprNodeId, HandleBinding]:
+    def get_quantum_vars(self) -> Mapping[QmodExprNodeId, HandleBinding]:
         return self._quantum_vars
 
     def clear_node_data(self, node: Union[ast.AST, QmodExprNodeId]) -> None:
@@ -265,9 +281,7 @@ class QmodAnnotatedExpression:
         if qs is not None:
             self.clear_node_data(qs.value)
             self.clear_node_data(qs.index)
-        qta = self._quantum_type_attrs.pop(node, None)
-        if qta is not None:
-            self.clear_node_data(qta.value)
+        self._quantum_type_attrs.pop(node, None)
         cnct = self._concatenations.pop(node, None)
         if cnct is not None:
             for element in cnct.elements:
@@ -282,3 +296,11 @@ class QmodAnnotatedExpression:
         self._quantum_subscripts |= other._quantum_subscripts
         self._quantum_type_attrs |= other._quantum_type_attrs
         self._concatenations |= other._concatenations
+
+    def clone(self) -> "QmodAnnotatedExpression":
+        expr_val = QmodAnnotatedExpression(self.root)
+        expr_val._add_data_from(self)
+        return expr_val
+
+    def lock(self) -> None:
+        self._locked = True

classiq/evaluators/qmod_expression_visitors/qmod_expression_bwc.py

@@ -73,11 +73,6 @@ class QmodExpressionBwc(ast.NodeTransformer):
                 return node
             return ast.Compare(left=args[0], ops=[ast.GtE()], comparators=[args[1]])
 
-        if func == "struct_literal":
-            if num_args != 1:
-                return node
-            return ast.Call(func=node.args[0], args=[], keywords=node.keywords)
-
         if func == "do_subscript":
             if num_args != 2 or num_kwargs != 0:
                 return node

classiq/evaluators/qmod_expression_visitors/qmod_expression_evaluator.py

@@ -85,7 +85,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             Sequence[ClassicalFunctionDeclaration]
         ] = None,
         classical_function_callables: Optional[Mapping[str, Callable]] = None,
-        scope: Optional[dict[str, Any]] = None,
+        scope: Optional[Mapping[str, Any]] = None,
     ) -> None:
         self._expr_val = expr_val
         self._treat_qnum_as_float = treat_qnum_as_float
@@ -103,8 +103,8 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
 
     def visit(self, node: ast.AST) -> None:
         if not isinstance(node, _SUPPORTED_NODES):
-            raise ClassiqInternalExpansionError(
-                f"Syntax error: {type(node).__name__!r} is not supported"
+            raise ClassiqExpansionError(
+                f"Syntax error: {type(node).__name__!r} is not a valid Qmod expression"
             )
         super().visit(node)
 
@@ -138,11 +138,23 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             self._eval_piecewise(node)
             return
 
-        for arg in node.args:
-            self.visit(arg)
         for kwarg in node.keywords:
             self.visit(kwarg)
 
+        if (
+            func_name == "struct_literal"
+            and len(node.args) == 1
+            and isinstance(node.args[0], ast.Name)
+            and (struct_name := node.args[0].id) in self._classical_struct_decls
+        ):
+            eval_struct_instantiation(
+                self._expr_val, node, self._classical_struct_decls[struct_name]
+            )
+            return
+
+        for arg in node.args:
+            self.visit(arg)
+
         if func_name == "measure":
             eval_measurement(self._expr_val, node)
             return
@@ -157,13 +169,6 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             )
             return
 
-        # FIXME: Remove (CLS-3241)
-        if func_name in self._classical_struct_decls:
-            eval_struct_instantiation(
-                self._expr_val, node, self._classical_struct_decls[func_name]
-            )
-            return
-
         # FIXME: Remove (CLS-3241)
         if func_name in self._classical_function_callables:
             if func_name not in self._classical_function_declarations:
@@ -176,6 +181,7 @@ class QmodExpressionEvaluator(ast.NodeVisitor):
             )
             return
 
+        # FIXME: Remove (CLS-3241)
         if func_name in self._classical_function_declarations:
             eval_symbolic_function(
                 self._expr_val, node, self._classical_function_declarations[func_name]
@@ -258,7 +264,7 @@ def evaluate_qmod_expression(
         Sequence[ClassicalFunctionDeclaration]
     ] = None,
     classical_function_callables: Optional[Mapping[str, Callable]] = None,
-    scope: Optional[dict[str, Any]] = None,
+    scope: Optional[Mapping[str, Any]] = None,
 ) -> QmodAnnotatedExpression:
     expr_ast = ast.parse(expr, mode="eval").body
     expr_value = QmodAnnotatedExpression(expr_ast)
@@ -272,4 +278,5 @@ def evaluate_qmod_expression(
         classical_function_callables=classical_function_callables,
         scope=scope,
     ).visit(expr_value.root)
+    expr_value.lock()
     return expr_value

classiq/evaluators/qmod_expression_visitors/qmod_expression_renamer.py

@@ -9,10 +9,12 @@ from classiq.evaluators.qmod_annotated_expression import (
 def replace_expression_vars(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[HandleBinding, HandleBinding],
-) -> None:
+) -> QmodAnnotatedExpression:
+    expr_val = expr_val.clone()
     if len(renaming) == 0:
-        return
-    all_vars = expr_val.get_classical_vars() | expr_val.get_quantum_vars()
+        expr_val.lock()
+        return expr_val
+    all_vars = dict(expr_val.get_classical_vars()) | dict(expr_val.get_quantum_vars())
     for node_id, var in all_vars.items():
         renamed_var = var
         for source, target in renaming.items():
@@ -24,18 +26,21 @@ def replace_expression_vars(
         expr_val.clear_node_data(node_id)
         expr_val.set_type(node_id, node_type)
         expr_val.set_var(node_id, renamed_var)
-    return
+    expr_val.lock()
+    return expr_val
 
 
 def replace_expression_type_attrs(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[tuple[HandleBinding, str], HandleBinding],
-) -> None:
+) -> QmodAnnotatedExpression:
+    expr_val = expr_val.clone()
     if len(renaming) == 0:
-        return
+        expr_val.lock()
+        return expr_val
     type_attrs = dict(expr_val.get_quantum_type_attributes())
     for node_id, ta in type_attrs.items():
-        var = expr_val.get_var(ta.value)
+        var = ta.value
         renamed_var = var
         renamed_attr = ta.attr
         for (source, attr), target in renaming.items():
@@ -47,13 +52,15 @@ def replace_expression_type_attrs(
         expr_val.clear_node_data(node_id)
         expr_val.set_type(node_id, node_type)
         expr_val.set_var(node_id, renamed_var)
-    return
+    expr_val.lock()
+    return expr_val
 
 
 def replace_expression_nodes(
     expr_val: QmodAnnotatedExpression,
     renaming: dict[QmodExprNodeId, str],
 ) -> str:
+    expr_val = expr_val.clone()
     for node_id, renamed_var in renaming.items():
         expr_val.set_var(node_id, HandleBinding(name=f"{renamed_var}"))
     return str(expr_val)

classiq/evaluators/qmod_expression_visitors/qmod_expression_simplifier.py

@@ -1,10 +1,12 @@
 import ast
-from typing import Any, cast
+from typing import Any, Callable, TypeVar, cast
 
 import sympy
 
 from classiq.interface.exceptions import ClassiqInternalExpansionError
-from classiq.interface.model.handle_binding import HandleBinding
+from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
+    QmodStructInstance,
+)
 
 from classiq.evaluators.qmod_annotated_expression import (
     QmodAnnotatedExpression,
@@ -37,13 +39,15 @@ _SYMPY_WRAPPERS = {
     do_div.__name__: do_div,
 }
 
+_PY_NODE = TypeVar("_PY_NODE", bound=ast.AST)
+
 
 class _VarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(self, expr_val: QmodAnnotatedExpression) -> None:
         self._expr_val = expr_val
         self._mask_id = 0
         self.masks: dict[str, QmodExprNodeId] = {}
-        self._assigned_masks: dict[HandleBinding, str] = {}
+        self._assigned_masks: dict[Any, str] = {}
 
     def _create_mask(self) -> str:
         mask = f"x{self._mask_id}"
@@ -52,27 +56,44 @@ class _VarMaskTransformer(OutOfPlaceNodeTransformer):
 
     def visit(self, node: ast.AST) -> ast.AST:
         if self._expr_val.has_value(node):
-            return ast.parse(str(self._expr_val.get_value(node)))
+            val = self._expr_val.get_value(node)
+            if not isinstance(val, (list, QmodStructInstance)):
+                return ast.Constant(value=val)
+            mask = self._create_mask()
+            self.masks[mask] = id(node)
+            return ast.Name(id=mask)
         if self._expr_val.has_var(node):
             var = self._expr_val.get_var(node)
-            if var in self._assigned_masks:
-                mask = self._assigned_masks[var]
-            else:
-                mask = self._create_mask()
-                self._assigned_masks[var] = mask
-                self.masks[mask] = id(node)
-            return ast.Name(id=mask)
-        if self._expr_val.has_quantum_subscript(node):
+            var_str = str(var.collapse())
+            if var_str in self._assigned_masks:
+                return ast.Name(id=self._assigned_masks[var_str])
             mask = self._create_mask()
+            self._assigned_masks[var_str] = mask
             self.masks[mask] = id(node)
             return ast.Name(id=mask)
         return super().visit(node)
 
-    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
-        mask = self._create_mask()
+    def _reduce_node(
+        self, node: _PY_NODE, inner_node: ast.AST, key: Callable[[_PY_NODE], str]
+    ) -> ast.AST:
+        new_value = self.visit(inner_node)
+        if isinstance(new_value, ast.Name):
+            mask_key = (new_value.id, key(node))
+            if mask_key in self._assigned_masks:
+                return ast.Name(self._assigned_masks[mask_key])
+            mask = self._create_mask()
+            self._assigned_masks[mask_key] = mask
+        else:
+            mask = self._create_mask()
         self.masks[mask] = id(node)
         return ast.Name(id=mask)
 
+    def visit_Attribute(self, node: ast.Attribute) -> ast.AST:
+        return self._reduce_node(node, node.value, lambda n: n.attr)
+
+    def visit_Subscript(self, node: ast.Subscript) -> ast.AST:
+        return self._reduce_node(node, node.value, lambda n: ast.unparse(node.slice))
+
 
 class _InverseVarMaskTransformer(OutOfPlaceNodeTransformer):
     def __init__(
@@ -230,12 +251,14 @@ class _InverseSympyCompatibilityTransformer(OutOfPlaceNodeTransformer):
         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 == "Abs":
+            node.func.id = "abs"
         if func == "Max":
             node.func.id = "max"
         elif func == "Min":
             node.func.id = "min"
+        if func == "Mod":
+            return ast.BinOp(left=node.args[0], op=ast.Mod(), right=node.args[1])
 
         return node
 

classiq/evaluators/qmod_node_evaluators/attribute_evaluation.py

@@ -5,6 +5,7 @@ from classiq.interface.exceptions import (
     ClassiqExpansionError,
     ClassiqInternalExpansionError,
 )
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.expressions.proxies.classical.qmod_struct_instance import (
     QmodStructInstance,
 )
@@ -15,7 +16,12 @@ from classiq.interface.generator.functions.classical_type import (
     Integer,
 )
 from classiq.interface.generator.functions.type_name import TypeName
-from classiq.interface.model.handle_binding import FieldHandleBinding
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
 from classiq.interface.model.quantum_type import (
     QuantumBitvector,
     QuantumNumeric,
@@ -26,6 +32,46 @@ from classiq.evaluators.qmod_annotated_expression import QmodAnnotatedExpression
 from classiq.evaluators.qmod_node_evaluators.utils import QmodType
 
 
+def _get_symbolic_quantum_var(
+    expr_val: QmodAnnotatedExpression, node: ast.AST
+) -> HandleBinding:
+    if expr_val.has_quantum_var(node):
+        var = expr_val.get_var(node)
+        expr_val.remove_var(node)
+        return var
+    if isinstance(node, ast.Attribute):
+        return FieldHandleBinding(
+            base_handle=_get_symbolic_quantum_var(expr_val, node.value),
+            field=node.attr,
+        )
+    if isinstance(node, ast.Subscript):
+        base_var = _get_symbolic_quantum_var(expr_val, node.value)
+        slice_ = node.slice
+        if isinstance(slice_, ast.Slice):
+            if slice_.lower is None or slice_.upper is None or slice_.step is not None:
+                raise ClassiqInternalExpansionError("Illegal slice")
+            return SlicedHandleBinding(
+                base_handle=base_var,
+                start=Expression(expr=expr_val.print_by_node(slice_.lower)),
+                end=Expression(expr=expr_val.print_by_node(slice_.upper)),
+            )
+        else:
+            return SubscriptHandleBinding(
+                base_handle=base_var,
+                index=Expression(expr=expr_val.print_by_node(slice_)),
+            )
+    raise ClassiqInternalExpansionError("Symbolic variable construction failed")
+
+
+def _remove_quantum_var(expr_val: QmodAnnotatedExpression, node: ast.AST) -> None:
+    if expr_val.has_quantum_var(node):
+        expr_val.remove_var(node)
+    elif isinstance(node, (ast.Attribute, ast.Subscript)):
+        _remove_quantum_var(expr_val, node.value)
+    else:
+        raise ClassiqInternalExpansionError("Failed to remove quantum var")
+
+
 def _eval_type_attribute(
     expr_val: QmodAnnotatedExpression, node: ast.Attribute
 ) -> None:
@@ -37,15 +83,22 @@ def _eval_type_attribute(
         expr_val.set_type(node, Integer())
         if subject_type.has_size_in_bits:
             expr_val.set_value(node, subject_type.size_in_bits)
+            _remove_quantum_var(expr_val, subject)
         else:
-            expr_val.set_quantum_type_attr(node, subject, attr)
+            expr_val.set_quantum_type_attr(
+                node, _get_symbolic_quantum_var(expr_val, subject), attr
+            )
         return
     if isinstance(subject_type, (ClassicalArray, QuantumBitvector)) and attr == "len":
         expr_val.set_type(node, Integer())
-        if subject_type.has_length:
+        if subject_type.has_constant_length:
             expr_val.set_value(node, subject_type.length_value)
+            if isinstance(subject_type, QuantumBitvector):
+                _remove_quantum_var(expr_val, subject)
         elif isinstance(subject_type, QuantumType):
-            expr_val.set_quantum_type_attr(node, subject, attr)
+            expr_val.set_quantum_type_attr(
+                node, _get_symbolic_quantum_var(expr_val, subject), attr
+            )
         return
     if isinstance(subject_type, ClassicalTuple) and attr == "len":
         expr_val.set_type(node, Integer())
@@ -56,19 +109,27 @@ def _eval_type_attribute(
             expr_val.set_type(node, Bool())
             if subject_type.has_sign:
                 expr_val.set_value(node, subject_type.sign_value)
+                _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:
                 expr_val.set_value(node, False)
+                _remove_quantum_var(expr_val, subject)
             else:
-                expr_val.set_quantum_type_attr(node, subject, attr)
+                expr_val.set_quantum_type_attr(
+                    node, _get_symbolic_quantum_var(expr_val, subject), attr
+                )
             return
         if attr == "fraction_digits":
             expr_val.set_type(node, Integer())
             if subject_type.has_fraction_digits:
                 expr_val.set_value(node, subject_type.fraction_digits_value)
+                _remove_quantum_var(expr_val, subject)
             elif subject_type.has_size_in_bits:
                 expr_val.set_value(node, 0)
+                _remove_quantum_var(expr_val, subject)
             else:
-                expr_val.set_quantum_type_attr(node, subject, attr)
+                expr_val.set_quantum_type_attr(
+                    node, _get_symbolic_quantum_var(expr_val, subject), attr
+                )
             return
     raise ClassiqExpansionError(
         f"{subject_type.raw_qmod_type_name} has no attribute {attr!r}"

classiq/evaluators/qmod_node_evaluators/classical_function_evaluation.py

@@ -30,6 +30,9 @@ from classiq.evaluators.qmod_node_evaluators.utils import (
     element_types,
     is_classical_integer,
 )
+from classiq.evaluators.qmod_type_inference.classical_type_inference import (
+    infer_classical_type,
+)
 
 # These sympy functions are not declared as int funcs for some reason...
 INTEGER_FUNCTION_OVERRIDE = {"floor", "ceiling"}
@@ -169,7 +172,9 @@ def eval_function(
         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))
+    ret_val = func(*arg_values, **kwarg_values)
+    expr_val.set_type(node, infer_classical_type(ret_val))
+    expr_val.set_value(node, ret_val)
 
 
 def try_eval_sympy_function(
@@ -261,10 +266,10 @@ def try_eval_builtin_function(
                 *[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:
+            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)
@@ -287,9 +292,14 @@ def try_eval_builtin_function(
         _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])
-            )
+            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)
         return True
 
     if func_name == "abs":
@@ -301,7 +311,7 @@ def try_eval_builtin_function(
         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])
+                node, abs(*[expr_val.get_value(arg) for arg in node.args])
             )
         return True
 

classiq/evaluators/qmod_node_evaluators/compare_evaluation.py

@@ -100,12 +100,20 @@ def eval_compare(expr_val: QmodAnnotatedExpression, node: ast.Compare) -> None:
     elif isinstance(op, ast.NotEq):
         expr_val.set_value(node, left_value != right_value)
     elif isinstance(op, ast.Lt):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value < right_value)
     elif isinstance(op, ast.Gt):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value > right_value)
     elif isinstance(op, ast.LtE):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value <= right_value)
     elif isinstance(op, ast.GtE):
+        if isinstance(left_value, complex) or isinstance(right_value, complex):
+            raise ClassiqExpansionError("Inequality with a complex number")
         expr_val.set_value(node, left_value >= right_value)
     else:
         raise ClassiqExpansionError(f"Unsupported comparison {type(op).__name__!r}")