classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/interface/generator/application_apis/entangler_declarations.py

@@ -6,19 +6,24 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 GRID_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="grid_entangler_graph",
-    param_decls={
-        "num_qubits": Integer(),
-        "schmidt_rank": Integer(),
-        "grid_randomization": Bool(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="schmidt_rank", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="grid_randomization", classical_type=Bool()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )
 
 HYPERCUBE_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="hypercube_entangler_graph",
-    param_decls={"num_qubits": Integer()},
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )

classiq/interface/generator/application_apis/finance_declarations.py

@@ -1,25 +1,23 @@
+from collections.abc import Mapping
 from enum import Enum
-from typing import Mapping
 
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
-from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalList,
-    Integer,
-    Real,
-    Struct,
-)
+from classiq.interface.generator.functions.classical_type import Real
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
+from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
 
 FUNCTION_PORT_NAME = "func_port"
 OBJECTIVE_PORT_NAME = "obj_port"
@@ -31,32 +29,39 @@ class FinanceModelType(Enum):
 
 
 FINANCE_FUNCTION_PORT_SIZE_MAPPING: Mapping[FinanceModelType, str] = {
-    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + len(get_field(finance_model, 'rhos')) + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
+    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + get_field(get_field(finance_model, 'rhos'), 'len') + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
     FinanceModelType.LogNormal: "get_field(finance_model, 'num_qubits')",
 }
 
 
 def _generate_finance_function(
     finance_model: FinanceModelType,
-) -> QuantumFunctionDeclaration:
-    return QuantumFunctionDeclaration(
+) -> NamedParamsQuantumFunctionDeclaration:
+    return NamedParamsQuantumFunctionDeclaration(
         name=f"{finance_model.value}_finance",
-        param_decls={
-            "finance_model": Struct(name=f"{finance_model.name}Model"),
-            "finance_function": Struct(name="FinanceFunction"),
-        },
-        port_declarations={
-            FUNCTION_PORT_NAME: PortDeclaration(
+        positional_arg_declarations=[
+            ClassicalParameterDeclaration(
+                name="finance_model",
+                classical_type=Struct(name=f"{finance_model.name}Model"),
+            ),
+            ClassicalParameterDeclaration(
+                name="finance_function", classical_type=Struct(name="FinanceFunction")
+            ),
+            PortDeclaration(
                 name=FUNCTION_PORT_NAME,
+                quantum_type=QuantumBitvector(
+                    length=Expression(
+                        expr=FINANCE_FUNCTION_PORT_SIZE_MAPPING[finance_model]
+                    )
+                ),
                 direction=PortDeclarationDirection.Inout,
-                size=Expression(expr=FINANCE_FUNCTION_PORT_SIZE_MAPPING[finance_model]),
             ),
-            OBJECTIVE_PORT_NAME: PortDeclaration(
+            PortDeclaration(
                 name=OBJECTIVE_PORT_NAME,
+                quantum_type=QuantumBit(),
                 direction=PortDeclarationDirection.Inout,
-                size=Expression(expr="1"),
             ),
-        },
+        ],
     )
 
 
@@ -64,63 +69,37 @@ LOG_NORMAL_FINANCE_FUNCTION = _generate_finance_function(FinanceModelType.LogNor
 
 GAUSSIAN_FINANCE_FUNCTION = _generate_finance_function(FinanceModelType.Gaussian)
 
-GAUSSIAN_MODEL = StructDeclaration(
-    name="GaussianModel",
-    variables={
-        "num_qubits": Integer(),
-        "normal_max_value": Real(),
-        "default_probabilities": ClassicalList(element_type=Real()),
-        "rhos": ClassicalList(element_type=Real()),
-        "loss": ClassicalList(element_type=Integer()),
-        "min_loss": Integer(),
-    },
-)
-
-
-LOG_NORMAL_MODEL = StructDeclaration(
-    name="LogNormalModel",
-    variables={"num_qubits": Integer(), "mu": Real(), "sigma": Real()},
-)
-
-
-FINANCE_FUNCTION = StructDeclaration(
-    name="FinanceFunction",
-    variables={
-        "f": Integer(),
-        "threshold": Real(),
-        "larger": Bool(),
-        "polynomial_degree": Integer(),
-        "use_chebyshev_polynomial_approximation": Bool(),
-        "tail_probability": Real(),
-    },
-)
-
 LOG_NORMAL_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="log_normal_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="LogNormalModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="LogNormalModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 
 GAUSSIAN_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
     name="gaussian_finance_post_process",
-    param_decls={
-        "finance_model": Struct(name="GaussianModel"),
-        "estimation_method": Struct(name="FinanceFunction"),
-        "probability": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="finance_model", classical_type=Struct(name="GaussianModel")
+        ),
+        ClassicalParameterDeclaration(
+            name="estimation_method", classical_type=Struct(name="FinanceFunction")
+        ),
+        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
+    ],
     return_type=Real(),
 )
 
 __all__ = [
-    "LOG_NORMAL_FINANCE_FUNCTION",
     "GAUSSIAN_FINANCE_FUNCTION",
-    "GAUSSIAN_MODEL",
-    "LOG_NORMAL_MODEL",
-    "FINANCE_FUNCTION",
-    "LOG_NORMAL_FINANCE_POST_PROCESS",
     "GAUSSIAN_FINANCE_POST_PROCESS",
+    "LOG_NORMAL_FINANCE_FUNCTION",
+    "LOG_NORMAL_FINANCE_POST_PROCESS",
 ]

classiq/interface/generator/application_apis/qsvm_declarations.py

@@ -1,76 +1,6 @@
 import enum
 
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalList,
-    Integer,
-    Pauli,
-    Real,
-    Struct,
-)
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-
 
 class FeatureMapType(enum.Enum):
     BlochSphere = "bloch_sphere"
     Pauli = "pauli"
-
-
-QSVM_PAULI_FEATURE_MAP_SIZE = "get_field(feature_map, 'feature_dimension')"
-QSVM_PAULI_FEATURE_MAP = QuantumFunctionDeclaration(
-    name="pauli_feature_map",
-    param_decls={"feature_map": Struct(name="QSVMFeatureMapPauli")},
-    port_declarations={
-        "qbv": PortDeclaration(
-            name="qbv",
-            direction=PortDeclarationDirection.Inout,
-            size=Expression(expr=QSVM_PAULI_FEATURE_MAP_SIZE),
-        )
-    },
-)
-
-QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE = "ceiling(feature_dimension/2)"
-QSVM_BLOCH_SPHERE_FEATURE_MAP = QuantumFunctionDeclaration(
-    name="bloch_sphere_feature_map",
-    param_decls={"feature_dimension": Integer()},
-    port_declarations={
-        "qbv": PortDeclaration(
-            name="qbv",
-            direction=PortDeclarationDirection.Inout,
-            size=Expression(expr=QSVM_BLOCH_SPHERE_FEATURE_MAP_SIZE),
-        )
-    },
-)
-
-QSVM_FEATURE_MAP_PAULI = StructDeclaration(
-    name="QSVMFeatureMapPauli",
-    variables={
-        "feature_dimension": Integer(),
-        "reps": Integer(),
-        "entanglement": Integer(),
-        "alpha": Real(),
-        "paulis": ClassicalList(element_type=ClassicalList(element_type=Pauli())),
-    },
-)
-
-QSVM_RESULT = StructDeclaration(
-    name="QsvmResult",
-    variables={
-        "test_score": Real(),
-        "predicted_labels": ClassicalList(element_type=Real()),
-    },
-)
-
-__all__ = [
-    "QSVM_RESULT",
-    "QSVM_PAULI_FEATURE_MAP",
-    "QSVM_BLOCH_SPHERE_FEATURE_MAP",
-    "QSVM_FEATURE_MAP_PAULI",
-]

classiq/interface/generator/arith/argument_utils.py

@@ -1,6 +1,9 @@
-from typing import Tuple, Union
+from typing import Union
 
 from classiq.interface.generator.arith import number_utils
+from classiq.interface.generator.arith.number_utils import (
+    get_int_representation_and_fraction_places,
+)
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
 
 RegisterOrConst = Union[RegisterArithmeticInfo, float]
@@ -42,17 +45,55 @@ def lower_bound(argument: RegisterOrConst) -> float:
     return argument
 
 
-def bounds(argument: RegisterOrConst) -> Tuple[float, float]:
+def bounds(argument: RegisterOrConst) -> tuple[float, float]:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.bounds
     return argument, argument
 
 
 def limit_fraction_places(
-    argument: RegisterOrConst, *, machine_precision: int
+    argument: RegisterOrConst, machine_precision: int
 ) -> RegisterOrConst:
     if isinstance(argument, RegisterArithmeticInfo):
         return argument.limit_fraction_places(machine_precision)
-    return number_utils.limit_fraction_places(
-        argument, machine_precision=machine_precision
+    return number_utils.limit_fraction_places(argument, machine_precision)
+
+
+def arg_bounds_overlap(args: tuple[RegisterOrConst, RegisterOrConst]) -> bool:
+    return (max(bounds(args[0])) - min(bounds(args[1]))) * (
+        min(bounds(args[0])) - max(bounds(args[1]))
+    ) < 0
+
+
+def as_arithmetic_info(
+    arg: RegisterOrConst, with_bounds: bool = True
+) -> RegisterArithmeticInfo:
+    if isinstance(arg, RegisterArithmeticInfo):
+        return arg
+    return RegisterArithmeticInfo(
+        size=number_utils.size(arg),
+        is_signed=arg < 0,
+        fraction_places=number_utils.fraction_places(arg),
+        bounds=(arg, arg) if with_bounds else None,
     )
+
+
+def unsigned_integer_interpretation(
+    value: float, register: RegisterArithmeticInfo
+) -> int:
+    int_val, fraction_digits = get_int_representation_and_fraction_places(value)
+
+    # align fraction digits
+    fraction_digits_diff = register.fraction_places - fraction_digits
+    if fraction_digits_diff < 0:
+        int_val >>= -fraction_digits_diff
+    else:
+        int_val <<= fraction_digits_diff
+
+    # extend sign bit
+    if int(value) < 0:
+        bin_val = number_utils.binary_string(int_val)
+        bin_val += "1" * (register.size - len(bin_val))
+        int_val = number_utils.binary_to_int(bin_val[::-1])
+
+    return int_val

classiq/interface/generator/arith/arithmetic.py

@@ -1,12 +1,17 @@
-from typing import Any, Dict, Optional, Set
+from typing import Any, Final, Optional
 
 import networkx as nx
 import pydantic
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import arithmetic_expression_parser
 from classiq.interface.generator.arith.arithmetic_expression_abc import (
     ArithmeticExpressionABC,
 )
+from classiq.interface.generator.arith.arithmetic_expression_validator import (
+    is_constant,
+)
 from classiq.interface.generator.arith.arithmetic_param_getters import (
     id2op,
     operation_allows_target,
@@ -15,31 +20,37 @@ from classiq.interface.generator.arith.arithmetic_result_builder import (
     ArithmeticResultBuilder,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
+from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.model.quantum_type import (
+    QuantumNumeric,
     QuantumType,
     quantum_var_to_register,
     register_info_to_quantum_type,
 )
 
-from classiq.exceptions import ClassiqValueError
+ARITHMETIC_EXPRESSION_TARGET_NAME: Final[str] = "arithmetic_target"
+ARITHMETIC_EXPRESSION_RESULT_NAME: Final[str] = "expression_result"
+ARITHMETIC_EXPRESSION_GARBAGE_NAME: Final[str] = "expression_garbage"
+
 
-ARITHMETIC_EXPRESSION_TARGET_NAME: str = "arithmetic_target"
-ARITHMETIC_EXPRESSION_RESULT_NAME: str = "expression_result"
+def is_zero(expr: str) -> bool:
+    return is_constant(expr) and float(expr) == 0
 
 
 class Arithmetic(ArithmeticExpressionABC):
     target: Optional[RegisterArithmeticInfo] = None
-    inputs_to_save: Set[str] = pydantic.Field(default_factory=set)
+    inputs_to_save: set[str] = pydantic.Field(default_factory=set)
 
-    @pydantic.validator("inputs_to_save", always=True)
+    @pydantic.field_validator("inputs_to_save")
+    @classmethod
     def _validate_inputs_to_save(
-        cls, inputs_to_save: Set[str], values: Dict[str, Any]
-    ) -> Set[str]:
-        assert all(reg in values.get("definitions", {}) for reg in inputs_to_save)
+        cls, inputs_to_save: set[str], info: ValidationInfo
+    ) -> set[str]:
+        assert all(reg in info.data.get("definitions", {}) for reg in inputs_to_save)
         return inputs_to_save
 
     @staticmethod
-    def _validate_expression_graph(graph: nx.DiGraph, values: Dict[str, Any]) -> None:
+    def _validate_expression_graph(graph: nx.DiGraph, values: dict[str, Any]) -> None:
         target = values.get("target")
         if target is None:
             return
@@ -64,19 +75,21 @@ class Arithmetic(ArithmeticExpressionABC):
             if name in self._inputs
         }
         # TODO: avoid calling the result builder again, as it is called in validation
-        result_info = ArithmeticResultBuilder(
+        result_builder = ArithmeticResultBuilder(
             graph=arithmetic_expression_parser.parse_expression(self.expression),
             definitions=self.definitions,
             machine_precision=self.machine_precision,
-        ).result
-        self._outputs[ARITHMETIC_EXPRESSION_RESULT_NAME] = result_info
+        )
+        self._outputs[ARITHMETIC_EXPRESSION_RESULT_NAME] = result_builder.result
+        if result_builder.garbage:
+            self._outputs[ARITHMETIC_EXPRESSION_GARBAGE_NAME] = result_builder.garbage
         if self.target:
             self._inputs[ARITHMETIC_EXPRESSION_TARGET_NAME] = self.target
 
 
 def get_arithmetic_params(
     expr_str: str,
-    var_types: Dict[str, QuantumType],
+    var_types: dict[str, QuantumType],
     machine_precision: int,
     enable_target: bool = False,
 ) -> Arithmetic:
@@ -94,8 +107,14 @@ def get_arithmetic_params(
 
 
 def compute_arithmetic_result_type(
-    expr_str: str, var_types: Dict[str, QuantumType], machine_precision: int
-) -> QuantumType:
+    expr_str: str, var_types: dict[str, QuantumType], machine_precision: int
+) -> QuantumNumeric:
+    if is_zero(expr_str):
+        return QuantumNumeric(
+            size=Expression(expr="1"),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        )
     arith_param = get_arithmetic_params(expr_str, var_types, machine_precision)
     return register_info_to_quantum_type(
         arith_param.outputs[ARITHMETIC_EXPRESSION_RESULT_NAME]

classiq/interface/generator/arith/arithmetic_arg_type_validator.py

@@ -1,21 +1,20 @@
-from typing import Callable, Dict, List
+from typing import Callable
 
 from typing_extensions import TypeAlias
 
+from classiq.interface.exceptions import ClassiqArithmeticError
 from classiq.interface.generator.arith import argument_utils
 from classiq.interface.generator.arith.binary_ops import BOOLEAN_OP_WITH_FRACTIONS_ERROR
 
-from classiq.exceptions import ClassiqArithmeticError
+ArgTypeValidator: TypeAlias = Callable[[list[argument_utils.RegisterOrConst]], None]
 
-ArgTypeValidator: TypeAlias = Callable[[List[argument_utils.RegisterOrConst]], None]
 
-
-def _validate_bitwise_op_args(args: List[argument_utils.RegisterOrConst]) -> None:
+def _validate_bitwise_op_args(args: list[argument_utils.RegisterOrConst]) -> None:
     if any(argument_utils.fraction_places(arg) > 0 for arg in args):
         raise ClassiqArithmeticError(BOOLEAN_OP_WITH_FRACTIONS_ERROR)
 
 
-arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
+arg_type_validator_map: dict[str, ArgTypeValidator] = dict(
     BitXor=_validate_bitwise_op_args,
     BitAnd=_validate_bitwise_op_args,
     BitOr=_validate_bitwise_op_args,
@@ -24,7 +23,7 @@ arg_type_validator_map: Dict[str, ArgTypeValidator] = dict(
 
 def validate_operation_arg_types(
     operation: str,
-    arguments: List[argument_utils.RegisterOrConst],
+    arguments: list[argument_utils.RegisterOrConst],
     machine_precision: int,
 ) -> None:
     if operation not in arg_type_validator_map:

classiq/interface/generator/arith/arithmetic_expression_abc.py

@@ -1,12 +1,14 @@
 import abc
 import ast
 import re
-from typing import Any, Dict, Optional, Set, Tuple, Union
+from typing import Any, Optional, Union
 
 import networkx as nx
 import pydantic
+from pydantic import TypeAdapter
 from typing_extensions import TypeAlias
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.arith.arithmetic_expression_parser import (
     parse_expression,
@@ -30,8 +32,6 @@ from classiq.interface.generator.expressions.expression_constants import (
 from classiq.interface.generator.function_params import FunctionParams
 from classiq.interface.helpers.custom_pydantic_types import PydanticExpressionStr
 
-from classiq.exceptions import ClassiqValueError
-
 ValidDefinitions: TypeAlias = Union[
     pydantic.StrictInt, pydantic.StrictFloat, RegisterArithmeticInfo
 ]
@@ -41,20 +41,16 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
     uncomputation_method: UncomputationMethods = UncomputationMethods.optimized
     machine_precision: pydantic.NonNegativeInt = DEFAULT_MACHINE_PRECISION
     expression: PydanticExpressionStr
-    definitions: Dict[str, ValidDefinitions]
+    definitions: dict[str, ValidDefinitions]
     qubit_count: Optional[pydantic.NonNegativeInt] = None
 
-    def _get_literal_set(self) -> Set[str]:
+    def _get_literal_set(self) -> set[str]:
         return _extract_literals(self.expression)
 
-    @pydantic.validator("definitions")
+    @classmethod
     def _validate_expression_literals_and_definitions(
-        cls, definitions: Dict[str, ValidDefinitions], values: Dict[str, Any]
-    ) -> Dict[str, ValidDefinitions]:
-        expression = values.get("expression")
-        if expression is None:
-            return definitions
-
+        cls, definitions: dict[str, ValidDefinitions], expression: PydanticExpressionStr
+    ) -> dict[str, ValidDefinitions]:
         literals = _extract_literals(expression)
 
         forbidden = literals.intersection(FORBIDDEN_LITERALS)
@@ -71,12 +67,33 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
             raise ClassiqValueError(f"The following names are undefined: {undefined}")
         return definitions
 
-    @pydantic.root_validator
-    def _validate_expression(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        expression: Optional[str] = values.get("expression")
-        definitions: Optional[Dict[str, ValidDefinitions]] = values.get("definitions")
-        machine_precision: Optional[int] = values.get("machine_precision")
-        if expression is None or definitions is None or machine_precision is None:
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _validate_expression(cls, values: Any) -> dict[str, Any]:
+        if not isinstance(values, dict):
+            return values
+        expression_adapter: TypeAdapter = TypeAdapter(Optional[PydanticExpressionStr])
+        expression = expression_adapter.validate_python(values.get("expression"))
+        definitions_adapter: TypeAdapter = TypeAdapter(
+            Optional[dict[str, ValidDefinitions]]
+        )
+        definition_dict = values.get("definitions")
+        if (
+            isinstance(definition_dict, list)
+            and len(definition_dict) > 0
+            and isinstance(definition_dict[0], tuple)
+        ):
+            definition_dict = dict(definition_dict)
+        definitions = definitions_adapter.validate_python(definition_dict)
+        machine_precision: Optional[int] = values.get(
+            "machine_precision", DEFAULT_MACHINE_PRECISION
+        )
+        if (
+            expression is None
+            or expression == ""
+            or definitions is None
+            or machine_precision is None
+        ):
             return values
 
         try:
@@ -88,15 +105,39 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         cls._validate_ast_obj(ast_obj)
 
         graph = parse_expression(expression)
-        cls._validate_expression_graph(graph, values)
+        try:
+            cls._validate_expression_graph(graph, values)
+        except ClassiqValueError as e:
+            # This flow was created specifically for inplace Boolean XOR operations like q1 ^ q2.
+            # We can't plug equality in previous stages due to SymPy restrictions.
+            # Note that we don't validate that the expression itself is Boolean (passing non-Boolean expressions
+            # as inplace is currently not supported, so it's a bug).
+            if not e.raw_message == "Expression does not support target assignment":
+                raise
+            ast_parsed_expression = ast.parse(expression)
+            ast_expr = ast_parsed_expression.body[0]
+            if (
+                not isinstance(ast_expr, ast.Expr)
+                or not isinstance(ast_expr.value, ast.BinOp)
+                or not isinstance(ast_expr.value.op, ast.BitXor)
+            ):
+                raise
+            expression = f"({expression}) == 1"
+            graph = parse_expression(expression)
+            cls._validate_expression_graph(graph, values)
+
+        validated_defs = cls._validate_expression_literals_and_definitions(
+            definitions, expression
+        )
+
         validate_arithmetic_result_type(
             graph=graph,
-            definitions=definitions,
+            definitions=validated_defs,
             machine_precision=machine_precision,
         )
 
         new_expr, new_defs = cls._replace_const_definitions_in_expression(
-            expression, definitions, machine_precision
+            expression, validated_defs, machine_precision
         )
         values["expression"] = new_expr
         values["definitions"] = new_defs
@@ -107,16 +148,16 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         pass
 
     @staticmethod
-    def _validate_expression_graph(graph: nx.DiGraph, values: Dict[str, Any]) -> None:
+    def _validate_expression_graph(graph: nx.DiGraph, values: dict[str, Any]) -> None:
         pass
 
     @classmethod
     def _replace_const_definitions_in_expression(
         cls,
         expression: str,
-        definitions: Dict[str, ValidDefinitions],
+        definitions: dict[str, ValidDefinitions],
         machine_precision: int,
-    ) -> Tuple[str, Dict[str, RegisterArithmeticInfo]]:
+    ) -> tuple[str, dict[str, RegisterArithmeticInfo]]:
         new_definitions = dict()
         for var_name, value in definitions.items():
             if isinstance(value, RegisterArithmeticInfo):
@@ -141,5 +182,5 @@ class ArithmeticExpressionABC(abc.ABC, FunctionParams):
         return re.sub(r"\b" + var + r"\b", str(value), expression)
 
 
-def _extract_literals(expression: str) -> Set[str]:
+def _extract_literals(expression: str) -> set[str]:
     return set(re.findall(SUPPORTED_VAR_NAMES_REG, expression)) - SUPPORTED_FUNC_NAMES