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

classiq/interface/generator/expressions/enums/__init__.py

@@ -1,10 +0,0 @@
-from enum import EnumMeta
-
-from .chemistry import Element, FermionMapping
-from .finance_functions import FinanceFunctionType
-from .ladder_operator import LadderOperator
-from .optimizers import Optimizer
-from .pauli import Pauli
-from .qsvm_feature_map_entanglement import QSVMFeatureMapEntanglement
-
-BUILTIN_ENUMS = dict(filter(lambda pair: isinstance(pair[1], EnumMeta), vars().items()))

classiq/interface/generator/expressions/enums/finance_functions.py

@@ -1,22 +1,12 @@
-from typing import Dict
-
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class FinanceFunctionType(ClassicalEnum):
-    VAR = 0
-    SHORTFALL = 1
-    X_SQUARE = 2
-    EUROPEAN_CALL_OPTION = 3
-
-    @staticmethod
-    def from_string(func_str: str) -> "FinanceFunctionType":
-        return FINANCE_FUNCTION_STRING[func_str]
-
-
-FINANCE_FUNCTION_STRING: Dict[str, FinanceFunctionType] = {
-    "var": FinanceFunctionType.VAR,
-    "expected shortfall": FinanceFunctionType.SHORTFALL,
-    "x**2": FinanceFunctionType.X_SQUARE,
-    "european call option": FinanceFunctionType.EUROPEAN_CALL_OPTION,
-}
+from classiq.interface.generator.types.builtin_enum_declarations import (
+    FinanceFunctionType,
+)
+
+
+def get_finance_function_dict() -> dict[str, "FinanceFunctionType"]:
+    return {
+        "var": FinanceFunctionType.VAR,
+        "expected shortfall": FinanceFunctionType.SHORTFALL,
+        "x**2": FinanceFunctionType.X_SQUARE,
+        "european call option": FinanceFunctionType.EUROPEAN_CALL_OPTION,
+    }

classiq/interface/generator/expressions/evaluated_expression.py

@@ -1,8 +1,13 @@
+import re
+from collections.abc import Mapping
 from dataclasses import dataclass
-from typing import Any, Mapping, Type
+from typing import Any, Optional
 
+from sympy import Expr
 from typing_extensions import get_args
 
+from classiq.interface.backend.pydantic_backend import EXECUTION_PARAMETER_PATTERN
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.expression_types import (
     ExpressionValue,
     QmodStructInstance,
@@ -10,22 +15,25 @@ from classiq.interface.generator.expressions.expression_types import (
 )
 from classiq.interface.generator.expressions.handle_identifier import HandleIdentifier
 
-from classiq.exceptions import ClassiqValueError
-
 
 @dataclass(frozen=True)
 class EvaluatedExpression:
     value: ExpressionValue
 
-    def is_constant(self) -> bool:
+    def is_constant(self, constant_type: Optional[type] = None) -> bool:
         if self.value is None:
             return False
 
-        return isinstance(self.value, get_args(RuntimeConstant))
+        return isinstance(
+            self.value,
+            get_args(RuntimeConstant) if constant_type is None else constant_type,
+        )
 
-    def as_constant_type(self, constant_type: Type) -> Any:
+    def as_constant_type(self, constant_type: type) -> Any:
         if not self.is_constant():
-            raise ClassiqValueError(f"Invalid access to expression as {constant_type}")
+            raise ClassiqValueError(
+                f"Invalid access to expression {self.value!r} as {constant_type}"
+            )
 
         return constant_type(self.value)
 
@@ -62,3 +70,9 @@ class EvaluatedExpression:
             raise ClassiqValueError("Invalid access to unevaluated expression")
 
         return str(self.value)
+
+    def is_identifier(self) -> bool:
+        return (
+            isinstance(self.value, Expr)
+            and re.fullmatch(EXECUTION_PARAMETER_PATTERN, str(self.value)) is not None
+        )

classiq/interface/generator/expressions/expression.py

@@ -1,14 +1,17 @@
 import ast
-from typing import Any, Mapping, Optional, Type
+from collections.abc import Mapping
+from typing import Any, Optional
 
 import pydantic
-from pydantic import PrivateAttr
+from pydantic import ConfigDict, PrivateAttr
 
+from classiq.interface.ast_node import HashableASTNode
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
 )
 from classiq.interface.generator.expressions.atomic_expression_functions import (
-    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS,
+    SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD,
 )
 from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
@@ -17,14 +20,9 @@ from classiq.interface.generator.expressions.sympy_supported_expressions import
     SYMPY_SUPPORTED_EXPRESSIONS,
 )
 from classiq.interface.generator.function_params import validate_expression_str
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-from classiq.exceptions import ClassiqError
 
 
-class Expression(HashablePydanticBaseModel):
+class Expression(HashableASTNode):
     expr: str
     _evaluated_expr: Optional[EvaluatedExpression] = PrivateAttr(default=None)
 
@@ -33,20 +31,27 @@ class Expression(HashablePydanticBaseModel):
 
         self._try_to_immediate_evaluate()
 
-    @pydantic.validator("expr")
+    @pydantic.field_validator("expr")
+    @classmethod
     def validate_expression(cls, expr: str) -> str:
         supported_functions = (
-            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS
+            SUPPORTED_ATOMIC_EXPRESSION_FUNCTIONS_QMOD
             | set(SYMPY_SUPPORTED_EXPRESSIONS)
             | set(DEFAULT_SUPPORTED_FUNC_NAMES)
         )
         validate_expression_str(expr, supported_functions=supported_functions)
         return expr
 
+    @pydantic.field_validator("expr")
+    @classmethod
+    def format_expression(cls, expr: str) -> str:
+        expr = ast.unparse(ast.parse(expr))
+        return expr
+
     def is_evaluated(self) -> bool:
         return self._evaluated_expr is not None
 
-    def as_constant(self, constant_type: Type) -> Any:
+    def as_constant(self, constant_type: type) -> Any:
         return self.value.as_constant_type(constant_type)
 
     def to_int_value(self) -> int:
@@ -65,11 +70,19 @@ class Expression(HashablePydanticBaseModel):
         return self.as_constant(list)
 
     def _try_to_immediate_evaluate(self) -> None:
+        # FIXME remove special treatment (CAD-22999)
+        if self.expr == "SIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=True)
+            return
+        if self.expr == "UNSIGNED":
+            self._evaluated_expr = EvaluatedExpression(value=False)
+            return
+
         try:
             result = ast.literal_eval(self.expr)
             if isinstance(result, (int, float, bool)):
                 self._evaluated_expr = EvaluatedExpression(value=result)
-        except Exception:  # nosec B110
+        except Exception:  # noqa: S110
             pass
 
     @property
@@ -85,8 +98,7 @@ class Expression(HashablePydanticBaseModel):
     def is_constant(self) -> bool:
         return self.value.is_constant()
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     def __str__(self) -> str:
         return self.expr

classiq/interface/generator/expressions/expression_constants.py

@@ -1,5 +1,5 @@
 import keyword
-from typing import Set
+from typing import Final
 
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     DEFAULT_SUPPORTED_FUNC_NAMES,
@@ -11,9 +11,15 @@ from classiq.interface.generator.function_params import NAME_REGEX
 
 SUPPORTED_VAR_NAMES_REG = NAME_REGEX
 
-SUPPORTED_FUNC_NAMES: Set[str] = (
+SUPPORTED_FUNC_NAMES: set[str] = (
     {"or", "and"}
     .union(DEFAULT_SUPPORTED_FUNC_NAMES)
     .union(set(SYMPY_SUPPORTED_EXPRESSIONS))
 )
-FORBIDDEN_LITERALS: Set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+BOOLEAN_LITERALS = {"True", "False"}
+FORBIDDEN_LITERALS: set[str] = set(keyword.kwlist) - SUPPORTED_FUNC_NAMES
+CPARAM_EXECUTION_SUFFIX: Final[str] = "_param"
+RESERVED_EXPRESSIONS: frozenset[str] = frozenset({"i"})
+CPARAM_EXECUTION_SUFFIX_PATTERN = (
+    rf"({CPARAM_EXECUTION_SUFFIX}|^({'|'.join(RESERVED_EXPRESSIONS)}))(_\d+)*$"
+)

classiq/interface/generator/expressions/non_symbolic_expr.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from typing import Any, NoReturn
+
+from classiq.interface.exceptions import ClassiqArithmeticError
+
+
+class NonSymbolicExpr:
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
+    @staticmethod
+    def _raise_error(type_name: str, op: str) -> NoReturn:
+        raise ClassiqArithmeticError(
+            f"Unsupported operand type for {op!r}: {type_name}"
+        )
+
+    def __add__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __sub__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __mul__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "*")
+
+    def __truediv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "/")
+
+    def __floordiv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "//")
+
+    def __mod__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "%")
+
+    def __pow__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "**")
+
+    def __lshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<<")
+
+    def __rshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">>")
+
+    def __and__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "&")
+
+    def __xor__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "^")
+
+    def __or__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "|")
+
+    def __radd__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __rsub__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __rmul__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "*")
+
+    def __rtruediv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "/")
+
+    def __rfloordiv__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "//")
+
+    def __rmod__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "%")
+
+    def __rpow__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "**")
+
+    def __rlshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<<")
+
+    def __rrshift__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">>")
+
+    def __rand__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "&")
+
+    def __rxor__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "^")
+
+    def __ror__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "|")
+
+    def __lt__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<")
+
+    def __le__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "<=")
+
+    def __eq__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "==")
+
+    def __ne__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "!=")
+
+    def __gt__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">")
+
+    def __ge__(self, other: Any) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, ">=")
+
+    def __neg__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "-")
+
+    def __pos__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "+")
+
+    def __abs__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "abs")
+
+    def __invert__(self) -> NoReturn:
+        NonSymbolicExpr._raise_error(self.type_name, "~")

classiq/interface/generator/expressions/qmod_qarray_proxy.py

@@ -0,0 +1,99 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, Union
+
+from sympy import Integer
+
+from classiq.interface.exceptions import (
+    ClassiqInternalExpansionError,
+    ClassiqValueError,
+)
+from classiq.interface.generator.expressions.expression import Expression
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    HandleBinding,
+    SlicedHandleBinding,
+    SubscriptHandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
+
+ILLEGAL_SLICING_STEP_MSG = "Slicing with a step of a quantum variable is not supported"
+ILLEGAL_SLICE_MSG = "Quantum array slice must be of the form [<int-value>:<int-value>]."
+
+
+class QmodQArrayProxy(NonSymbolicExpr, QmodSizedProxy):
+    def __init__(
+        self,
+        handle: HandleBinding,
+        element_type: "QuantumType",
+        element_size: int,
+        length: int,
+    ) -> None:
+        super().__init__(handle, element_size * length)
+        self._length = length
+        self._element_type = element_type
+        self._element_size = element_size
+
+    def __getitem__(self, key: Union[slice, int, Integer]) -> "QmodSizedProxy":
+        return (
+            self._get_slice(key) if isinstance(key, slice) else self._get_subscript(key)
+        )
+
+    def _get_subscript(self, index: Union[int, Integer]) -> "QmodSizedProxy":
+        if isinstance(index, Integer):
+            index = int(index)
+        if index < 0 or index >= self._length:
+            raise ClassiqInternalExpansionError
+
+        return self._element_type.get_proxy(
+            SubscriptHandleBinding(
+                base_handle=self.handle,
+                index=Expression(expr=str(index)),
+            )
+        )
+
+    def _get_slice(self, slice_: slice) -> "QmodSizedProxy":
+        if slice_.step is not None:
+            raise ClassiqValueError(ILLEGAL_SLICING_STEP_MSG)
+        if isinstance(slice_.start, Integer):
+            slice_ = slice(int(slice_.start), slice_.stop)
+        if isinstance(slice_.stop, Integer):
+            slice_ = slice(slice_.start, int(slice_.stop))
+        if not isinstance(slice_.start, int) or not isinstance(slice_.stop, int):
+            raise ClassiqValueError(ILLEGAL_SLICE_MSG)
+        if (
+            slice_.start >= slice_.stop
+            or slice_.start < 0
+            or slice_.stop > self._length
+        ):
+            raise ClassiqInternalExpansionError
+
+        return QmodQArrayProxy(
+            SlicedHandleBinding(
+                base_handle=self.handle,
+                start=Expression(expr=str(slice_.start)),
+                end=Expression(expr=str(slice_.stop)),
+            ),
+            self._element_type,
+            self._element_size,
+            slice_.stop - slice_.start,
+        )
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum array"
+
+    @property
+    def len(self) -> int:
+        return self._length
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {**super().fields, "len": self.len}
+
+    @property
+    def size(self) -> int:
+        return self.len * self._element_size

classiq/interface/generator/expressions/qmod_qscalar_proxy.py

@@ -0,0 +1,59 @@
+from collections.abc import Mapping
+from typing import Any
+
+from sympy import Symbol
+
+from classiq.interface.exceptions import ClassiqValueError
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import HandleBinding
+
+
+class QmodQScalarProxy(Symbol, QmodSizedProxy):
+    def __new__(cls, handle: HandleBinding, **assumptions: bool) -> "QmodQScalarProxy":
+        return super().__new__(cls, str(handle), **assumptions)
+
+    def __init__(self, handle: HandleBinding, size: int) -> None:
+        super().__init__(handle, size)
+
+
+class QmodQBitProxy(QmodQScalarProxy):
+    def __init__(self, handle: HandleBinding) -> None:
+        super().__init__(handle, 1)
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum bit"
+
+
+class QmodQNumProxy(QmodQScalarProxy):
+    def __init__(
+        self, handle: HandleBinding, size: int, fraction_digits: int, is_signed: bool
+    ) -> None:
+        super().__init__(handle, size)
+        if fraction_digits > size:
+            raise ClassiqValueError(
+                f"Quantum numeric of size {size} cannot have {fraction_digits} "
+                f"fraction digits"
+            )
+        self._fraction_digits = fraction_digits
+        self._is_signed = is_signed
+
+    @property
+    def type_name(self) -> str:
+        return "Quantum numeric"
+
+    @property
+    def fraction_digits(self) -> int:
+        return self._fraction_digits
+
+    @property
+    def is_signed(self) -> bool:
+        return self._is_signed
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {
+            **super().fields,
+            "is_signed": self.is_signed,
+            "fraction_digits": self.fraction_digits,
+        }

classiq/interface/generator/expressions/qmod_qstruct_proxy.py

@@ -0,0 +1,36 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING
+
+from classiq.interface.generator.expressions.non_symbolic_expr import NonSymbolicExpr
+from classiq.interface.generator.expressions.qmod_sized_proxy import QmodSizedProxy
+from classiq.interface.model.handle_binding import (
+    FieldHandleBinding,
+    HandleBinding,
+)
+
+if TYPE_CHECKING:
+    from classiq.interface.model.quantum_type import QuantumType
+
+
+class QmodQStructProxy(NonSymbolicExpr, QmodSizedProxy):
+    def __init__(
+        self,
+        handle: HandleBinding,
+        struct_name: str,
+        fields: Mapping[str, "QuantumType"],
+    ) -> None:
+        self._fields = {
+            name: type_.get_proxy(FieldHandleBinding(base_handle=handle, field=name))
+            for name, type_ in fields.items()
+        }
+        size = sum(proxy.size for proxy in self._fields.values())
+        super().__init__(handle, size)
+        self._struct_name = struct_name
+
+    @property
+    def type_name(self) -> str:
+        return self._struct_name
+
+    @property
+    def fields(self) -> Mapping[str, QmodSizedProxy]:
+        return {**super().fields, **self._fields}

classiq/interface/generator/expressions/qmod_sized_proxy.py

@@ -1,6 +1,34 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from classiq.interface.model.handle_binding import HandleBinding
+
+
 class QmodSizedProxy:
-    def __init__(self, size: int) -> None:
+    def __init__(self, handle: "HandleBinding", size: int) -> None:
+        self._handle = handle
         self._size = size
 
-    def __len__(self) -> int:
+    @property
+    def size(self) -> int:
         return self._size
+
+    def __str__(self) -> str:
+        return str(self.handle)
+
+    @property
+    def type_name(self) -> str:
+        raise NotImplementedError
+
+    @property
+    def handle(self) -> "HandleBinding":
+        return self._handle
+
+    @property
+    def len(self) -> int:
+        return self._size
+
+    @property
+    def fields(self) -> Mapping[str, Any]:
+        return {"size": self._size}

classiq/interface/generator/expressions/qmod_struct_instance.py

@@ -1,5 +1,6 @@
 import types
-from typing import TYPE_CHECKING, Any, Mapping
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     from classiq.interface.generator.expressions.expression_types import ExpressionValue
@@ -16,9 +17,20 @@ class QmodStructInstance:
         self.struct_declaration = struct_declaration
         self._fields = fields
 
+    @property
+    def type_name(self) -> str:
+        return f"Struct {self.struct_declaration.name}"
+
     @property
     def fields(self) -> Mapping[str, Any]:
         return types.MappingProxyType(self._fields)
 
+    def __str__(self) -> str:
+        return repr(self)
+
     def __repr__(self) -> str:
-        return repr(self._fields)
+        fields = ", ".join(
+            f"{field_name}={field_value}"
+            for field_name, field_value in self._fields.items()
+        )
+        return f"{self.struct_declaration.name}({fields})"

classiq/interface/generator/expressions/sympy_supported_expressions.py

@@ -1,7 +1,5 @@
-from typing import List
-
-BASIC_ARITHMETIC_OPERATORS: List[str] = ["+", "-", "*", "/", "%"]
-MATHEMATICAL_FUNCTIONS: List[str] = [
+BASIC_ARITHMETIC_OPERATORS: list[str] = ["+", "-", "*", "/", "%"]
+MATHEMATICAL_FUNCTIONS: list[str] = [
     "sin",
     "cos",
     "tan",
@@ -34,8 +32,9 @@ MATHEMATICAL_FUNCTIONS: List[str] = [
     "ceiling",
     "Max",
     "Min",
+    "mod_inverse",
 ]
-SPECIAL_FUNCTIONS: List[str] = [
+SPECIAL_FUNCTIONS: list[str] = [
     "erf",
     "erfc",
     "gamma",
@@ -56,10 +55,20 @@ SPECIAL_FUNCTIONS: List[str] = [
     "euler",
     "catalan",
 ]
-PIECEWISE_FUNCTIONS: List[str] = ["Piecewise", "Heaviside"]
-CONSTANTS: List[str] = ["pi", "E", "I", "GoldenRatio", "EulerGamma", "Catalan"]
-DATA_TYPES: List[str] = ["Matrix"]
-LOGIC_OPERATORS: List[str] = [
+PIECEWISE_FUNCTIONS: list[str] = ["Piecewise", "Heaviside"]
+NUMERIC_CONSTANTS: list[str] = [
+    "pi",
+    "E",
+    "I",
+    "GoldenRatio",
+    "EulerGamma",
+    "Catalan",
+]
+BOOLEAN_CONSTANTS: list[str] = ["true", "false"]
+CONSTANTS: list[str] = NUMERIC_CONSTANTS + BOOLEAN_CONSTANTS
+
+DATA_TYPES: list[str] = ["Matrix"]
+LOGIC_OPERATORS: list[str] = [
     "And",
     "Or",
     "Not",
@@ -69,9 +78,9 @@ LOGIC_OPERATORS: List[str] = [
     "Nand",
     "Nor",
 ]
-RELATIONAL_OPERATORS: List[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq"]
+RELATIONAL_OPERATORS: list[str] = ["<", "<=", ">", ">=", "!=", "<>", "Eq", "Ne"]
 
-SYMPY_SUPPORTED_EXPRESSIONS: List[str] = (
+SYMPY_SUPPORTED_EXPRESSIONS: list[str] = (
     BASIC_ARITHMETIC_OPERATORS
     + MATHEMATICAL_FUNCTIONS
     + SPECIAL_FUNCTIONS