classiq 0.52.0__py3-none-any.whl → 0.54.0__py3-none-any.whl

classiq/model_expansions/quantum_operations/bind.py

@@ -1,5 +1,3 @@
-from typing import List
-
 from classiq.interface.exceptions import ClassiqExpansionError
 from classiq.interface.model.bind_operation import BindOperation
 
@@ -18,11 +16,11 @@ class BindEmitter(Emitter[BindOperation]):
     def emit(self, bind: BindOperation, /) -> None:
         with self._propagated_var_stack.capture_variables(bind):
             pass
-        inputs: List[QuantumSymbol] = [
+        inputs: list[QuantumSymbol] = [
             self._interpreter.evaluate(arg).as_type(QuantumSymbol)
             for arg in bind.in_handles
         ]
-        outputs: List[QuantumSymbol] = [
+        outputs: list[QuantumSymbol] = [
             self._interpreter.evaluate(arg).as_type(QuantumSymbol)
             for arg in bind.out_handles
         ]

classiq/model_expansions/quantum_operations/classicalif.py

@@ -1,4 +1,4 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from classiq.interface.model.classical_if import ClassicalIf
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall

classiq/model_expansions/quantum_operations/control.py

@@ -1,5 +1,3 @@
-from typing import List, Tuple
-
 from sympy import Equality
 from sympy.logic.boolalg import Boolean
 from typing_extensions import TypeGuard
@@ -160,7 +158,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
     def _emit_with_x_gates(
         self, control: Control, ctrl: QmodSizedProxy, ctrl_state: str
     ) -> None:
-        compute_op: List[ConcreteQuantumStatement] = []
+        compute_op: list[ConcreteQuantumStatement] = []
 
         x_gate_value = self._get_x_gate_value(ctrl_state)
         if x_gate_value != 0:
@@ -194,7 +192,7 @@ class ControlEmitter(ExpressionOperationEmitter[Control]):
 
     def _get_array_cast_ops(
         self, ctrl: QmodQNumProxy
-    ) -> Tuple[VariableDeclarationStatement, BindOperation]:
+    ) -> tuple[VariableDeclarationStatement, BindOperation]:
         array_cast = self._counted_name_allocator.allocate(
             f"{ctrl.handle}{ARRAY_CAST_SUFFIX}"
         )

classiq/model_expansions/quantum_operations/emitter.py

@@ -1,11 +1,9 @@
 from abc import abstractmethod
+from collections.abc import Sequence
 from typing import (
     TYPE_CHECKING,
-    Dict,
     Generic,
-    List,
     Optional,
-    Sequence,
     TypeVar,
     Union,
     cast,
@@ -18,7 +16,7 @@ from classiq.interface.generator.expressions.evaluated_expression import (
     EvaluatedExpression,
 )
 from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.ide.visual_model import OperationLevel
+from classiq.interface.generator.generated_circuit_data import OperationLevel
 from classiq.interface.model.classical_parameter_declaration import (
     ClassicalParameterDeclaration,
 )
@@ -63,7 +61,6 @@ from classiq.qmod.quantum_function import GenerativeQFunc
 if TYPE_CHECKING:
     from classiq.model_expansions.interpreter import Interpreter
 
-
 QuantumStatementT = TypeVar("QuantumStatementT", bound=QuantumStatement)
 
 
@@ -74,7 +71,7 @@ class Emitter(Generic[QuantumStatementT]):
         self._scope_guard = self._interpreter._scope_guard
         self._machine_precision = self._interpreter._model.preferences.machine_precision
 
-        self._generative_contexts: Dict[str, OperationContext] = {}
+        self._generative_contexts: dict[str, OperationContext] = {}
 
     @abstractmethod
     def emit(self, statement: QuantumStatementT, /) -> None:
@@ -103,7 +100,7 @@ class Emitter(Generic[QuantumStatementT]):
         return self._interpreter._current_scope
 
     @property
-    def _expanded_functions(self) -> List[NativeFunctionDefinition]:
+    def _expanded_functions(self) -> list[NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
 
     @property
@@ -125,14 +122,14 @@ class Emitter(Generic[QuantumStatementT]):
         return self._create_quantum_function_call(wrapping_function, list())
 
     def _emit_quantum_function_call(
-        self, function: FunctionClosure, args: List[ArgValue]
+        self, function: FunctionClosure, args: list[ArgValue]
     ) -> QuantumFunctionCall:
         call = self._create_quantum_function_call(function, args)
         self._builder.emit_statement(call)
         return call
 
     def _create_quantum_function_call(
-        self, function: FunctionClosure, args: List[ArgValue]
+        self, function: FunctionClosure, args: list[ArgValue]
     ) -> QuantumFunctionCall:
         evaluated_args = [self._interpreter.evaluate(arg) for arg in args]
         new_declaration = self._prepare_fully_typed_declaration(
@@ -206,10 +203,10 @@ class Emitter(Generic[QuantumStatementT]):
 
     def _get_new_positional_args(
         self,
-        evaluated_args: List[Evaluated],
+        evaluated_args: list[Evaluated],
         is_atomic: bool,
         new_positional_arg_decls: Sequence[PositionalArg],
-    ) -> List[ArgValue]:
+    ) -> list[ArgValue]:
         evaluated_args = add_information_from_output_arguments(
             new_positional_arg_decls, evaluated_args
         )
@@ -230,7 +227,7 @@ class Emitter(Generic[QuantumStatementT]):
         return positional_args
 
     def _prepare_fully_typed_declaration(
-        self, function: FunctionClosure, evaluated_args: List[Evaluated]
+        self, function: FunctionClosure, evaluated_args: list[Evaluated]
     ) -> NamedParamsQuantumFunctionDeclaration:
         """
         Given, for example,
@@ -260,7 +257,7 @@ class Emitter(Generic[QuantumStatementT]):
         self,
         op: QuantumOperation,
         context_name: str,
-        block_names: Union[None, str, List[str]] = None,
+        block_names: Union[None, str, list[str]] = None,
         func_decl: Optional[NamedParamsQuantumFunctionDeclaration] = None,
     ) -> OperationContext:
         if isinstance(block_names, str):

classiq/model_expansions/quantum_operations/expression_operation.py

@@ -1,7 +1,7 @@
 import ast
 from abc import abstractmethod
 from itertools import chain
-from typing import TYPE_CHECKING, Dict, List, Tuple, TypeVar
+from typing import TYPE_CHECKING, TypeVar
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -26,6 +26,7 @@ from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
     QuantumNumeric,
+    QuantumType,
 )
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -48,7 +49,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         self,
         op: ExpressionOperationT,
         expression: Expression,
-        symbols_to_split: List[QuantumSymbol],
+        symbols_to_split: list[QuantumSymbol],
     ) -> None:
         symbols_parts, bind_ops = self._get_bind_ops(symbols_to_split)
 
@@ -62,14 +63,13 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
                         )
                     )
 
-        new_expression = self._update_op_expression(
-            {
-                symbol.handle: symbol_part_var_name
-                for symbol, symbol_part_var_name in chain.from_iterable(symbols_parts)
-            },
-            expression,
-        )
+        symbol_mapping = {
+            symbol.handle: (symbol_part_var_name, symbol.quantum_type)
+            for symbol, symbol_part_var_name in chain.from_iterable(symbols_parts)
+        }
+        new_expression = self._update_op_expression(symbol_mapping, expression)
         new_op = op.model_copy(update=dict(expression=new_expression))
+        new_op = self._get_updated_op_split_symbols(new_op, symbol_mapping)
 
         self._interpreter.emit_statement(
             WithinApply(
@@ -79,9 +79,16 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             )
         )
 
+    @staticmethod
+    def _get_updated_op_split_symbols(
+        op: ExpressionOperationT,
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+    ) -> ExpressionOperationT:
+        return op
+
     def _update_op_expression(
         self,
-        symbol_parts: Dict[HandleBinding, str],
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
         expression: Expression,
     ) -> Expression:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
@@ -90,9 +97,9 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
         new_expr_str = expression.expr
         for handle in vrc.var_handles:
             collapsed_handle = handle.collapse()
-            if collapsed_handle in symbol_parts:
+            if collapsed_handle in symbol_mapping:
                 new_expr_str = new_expr_str.replace(
-                    str(handle), symbol_parts[collapsed_handle]
+                    str(handle), symbol_mapping[collapsed_handle][0]
                 )
         self._check_all_handles_were_replaced(new_expr_str)
 
@@ -115,8 +122,8 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
     def _get_bind_ops(
         self,
-        symbols_to_split: List[QuantumSymbol],
-    ) -> Tuple[List[List[Tuple[QuantumSymbol, str]]], List[BindOperation]]:
+        symbols_to_split: list[QuantumSymbol],
+    ) -> tuple[list[list[tuple[QuantumSymbol, str]]], list[BindOperation]]:
         bind_ops = []
         symbols_parts = []
         for symbol in symbols_to_split:
@@ -135,7 +142,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
 
     def _get_symbol_parts(
         self, symbol: QuantumSymbol
-    ) -> List[Tuple[QuantumSymbol, str]]:
+    ) -> list[tuple[QuantumSymbol, str]]:
         quantum_type = symbol.quantum_type
 
         if isinstance(quantum_type, (QuantumBit, QuantumNumeric)):
@@ -169,7 +176,7 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             )
         )
 
-    def _get_symbols_to_split(self, expression: Expression) -> List[QuantumSymbol]:
+    def _get_symbols_to_split(self, expression: Expression) -> list[QuantumSymbol]:
         vrc = VarRefCollector(ignore_duplicated_handles=True)
         vrc.visit(ast.parse(expression.expr))
         symbol_names_to_split = dict.fromkeys(

classiq/model_expansions/quantum_operations/inplace_binary_operation.py

@@ -1,10 +1,12 @@
-from typing import TYPE_CHECKING, List, Tuple, Union
+from typing import TYPE_CHECKING, Optional, Union
 
+from classiq.interface.exceptions import ClassiqInternalExpansionError
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import HandleBinding
 from classiq.interface.model.inplace_binary_operation import (
     BinaryOperation,
@@ -16,11 +18,7 @@ from classiq.interface.model.quantum_function_declaration import (
     NamedParamsQuantumFunctionDeclaration,
 )
 from classiq.interface.model.quantum_statement import QuantumStatement
-from classiq.interface.model.quantum_type import (
-    QuantumBit,
-    QuantumBitvector,
-    QuantumNumeric,
-)
+from classiq.interface.model.quantum_type import QuantumBitvector, QuantumNumeric
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
 )
@@ -38,6 +36,7 @@ from classiq.model_expansions.scope import QuantumSymbol, Scope
 from classiq.qmod.builtins.functions import (
     CX,
     allocate,
+    apply_to_all,
     integer_xor,
     modular_add,
     modular_add_constant,
@@ -94,6 +93,18 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
             handle=HandleBinding(name="target"),
             quantum_type=target_var.quantum_type,
         )
+        internal_func_decl = _binary_function_declaration(op.operation, constant=False)
+        if op.operation == BinaryOperation.Xor:
+            body = _build_inplace_xor_operation(
+                value_var=value_var,
+                target_var=target_var,
+            )
+        else:
+            body = _build_inplace_binary_operation(
+                value_var=value_var,
+                target_var=target_var,
+                internal_function_declaration=internal_func_decl,
+            )
         inplace_binary_op_function = FunctionClosure.create(
             name=op.operation.value,
             positional_arg_declarations=[
@@ -108,13 +119,7 @@ class InplaceBinaryOperationEmitter(Emitter[InplaceBinaryOperation]):
                     direction=PortDeclarationDirection.Inout,
                 ),
             ],
-            body=_build_inplace_binary_operation(
-                value_var=value_var,
-                target_var=target_var,
-                internal_function_declaration=_binary_function_declaration(
-                    op.operation, constant=False
-                ),
-            ),
+            body=body,
             scope=Scope(parent=self._current_scope),
         )
         with self._propagated_var_stack.capture_variables(op):
@@ -139,7 +144,7 @@ def _build_inplace_binary_operation(
     value_var: QuantumSymbol,
     target_var: QuantumSymbol,
     internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
-) -> List[QuantumStatement]:
+) -> list[QuantumStatement]:
     if TYPE_CHECKING:
         assert isinstance(value_var.quantum_type, QuantumNumeric)
         assert isinstance(target_var.quantum_type, QuantumNumeric)
@@ -148,9 +153,6 @@ def _build_inplace_binary_operation(
         value_var.quantum_type.fraction_digits_value
         - target_var.quantum_type.fraction_digits_value
     )
-    size_diff = (
-        value_var.quantum_type.size_in_bits - target_var.quantum_type.size_in_bits
-    )
 
     target_overlap_var, target_var_decls, target_bind_ops = (
         _trim_superfluous_fraction_digits("target", target_var, -frac_digits_diff)
@@ -158,6 +160,10 @@ def _build_inplace_binary_operation(
     value_overlap_var, value_trim_var_decls, value_bind_ops = (
         _trim_superfluous_fraction_digits("value", value_var, frac_digits_diff)
     )
+    size_diff = (
+        value_overlap_var.quantum_type.size_in_bits
+        - target_overlap_var.quantum_type.size_in_bits
+    )
     (
         value_padded_var,
         value_pad_var_decls,
@@ -191,6 +197,54 @@ def _build_inplace_binary_operation(
     ]
 
 
+def _build_inplace_xor_operation(
+    value_var: QuantumSymbol, target_var: QuantumSymbol
+) -> list[QuantumStatement]:
+    if TYPE_CHECKING:
+        assert isinstance(value_var.quantum_type, QuantumNumeric)
+        assert isinstance(target_var.quantum_type, QuantumNumeric)
+
+    frac_digits_diff = (
+        value_var.quantum_type.fraction_digits_value
+        - target_var.quantum_type.fraction_digits_value
+    )
+
+    target_overlap_var, target_var_decls, target_bind_ops = (
+        _trim_superfluous_fraction_digits("target", target_var, -frac_digits_diff)
+    )
+    value_overlap_var, value_trim_var_decls, value_bind_ops = (
+        _trim_superfluous_fraction_digits("value", value_var, frac_digits_diff)
+    )
+    target_left_var, value_left_var, sign_var_decls, sign_bind_ops, sign_xor = (
+        _split_and_xor_sign(target_overlap_var, value_overlap_var)
+    )
+
+    action: list[QuantumStatement] = []
+    if target_left_var is not None and value_left_var is not None:
+        action.append(
+            _internal_inplace_binary_operation_function_call(
+                integer_xor.func_decl,
+                value_left_var.handle,
+                target_left_var.handle,
+            )
+        )
+    action.extend(sign_xor)
+
+    return [
+        *target_var_decls,
+        *value_trim_var_decls,
+        *sign_var_decls,
+        WithinApply(
+            compute=[
+                *target_bind_ops,
+                *value_bind_ops,
+                *sign_bind_ops,
+            ],
+            action=action,
+        ),
+    ]
+
+
 def _internal_inplace_binary_operation_function_call(
     internal_function_declaration: NamedParamsQuantumFunctionDeclaration,
     value: Union[HandleBinding, Expression],
@@ -206,7 +260,7 @@ def _internal_inplace_binary_operation_function_call(
 
 def _trim_superfluous_fraction_digits(
     kind: str, var: QuantumSymbol, frac_digits_diff: int
-) -> Tuple[QuantumSymbol, List[VariableDeclarationStatement], List[BindOperation]]:
+) -> tuple[QuantumSymbol, list[VariableDeclarationStatement], list[BindOperation]]:
     if frac_digits_diff <= 0:
         return var, [], []
 
@@ -245,12 +299,12 @@ def _trim_superfluous_fraction_digits(
     return overlap_var, split_var_declarations, [bind_op]
 
 
-def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
+def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> tuple[
     QuantumSymbol,
-    List[VariableDeclarationStatement],
-    List[QuantumStatement],
-    List[QuantumFunctionCall],
-    List[BindOperation],
+    list[VariableDeclarationStatement],
+    list[QuantumStatement],
+    list[QuantumFunctionCall],
+    list[BindOperation],
 ]:
     quantum_type = var.quantum_type
     if TYPE_CHECKING:
@@ -290,7 +344,7 @@ def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
             [padding_rebind],
         )
 
-    significand_var, sign_var, sign_split_bind = _split_sign(kind, var)
+    significand_var, sign_var, sign_split_bind = _split_var(kind, var, 1)
     padding_init_ops = _init_padding(sign_var, padding_var, size_diff)
 
     padding_rebind = BindOperation(
@@ -317,7 +371,7 @@ def _pad_with_sign_bit(kind: str, var: QuantumSymbol, size_diff: int) -> Tuple[
 
 def _init_padding(
     sign_var: QuantumSymbol, padding_var: QuantumSymbol, size_diff: int
-) -> List[QuantumFunctionCall]:
+) -> list[QuantumFunctionCall]:
     padding_init_ops = [
         QuantumFunctionCall(
             function=CX.func_decl.name,
@@ -332,7 +386,7 @@ def _init_padding(
 
 def _allocate_padding(
     kind: str, size_diff: int
-) -> Tuple[QuantumSymbol, QuantumFunctionCall]:
+) -> tuple[QuantumSymbol, QuantumFunctionCall]:
     padding_var = QuantumSymbol(
         handle=HandleBinding(name=f"{kind}_sign_padding"),
         quantum_type=QuantumBitvector(
@@ -347,23 +401,95 @@ def _allocate_padding(
     return padding_var, padding_allocation
 
 
-def _split_sign(
-    kind: str, var: QuantumSymbol
-) -> Tuple[QuantumSymbol, QuantumSymbol, BindOperation]:
-    significand_var = QuantumSymbol(
-        handle=HandleBinding(name=f"{kind}_significand"),
+def _split_var(
+    kind: str, var: QuantumSymbol, right_size: int
+) -> tuple[QuantumSymbol, QuantumSymbol, BindOperation]:
+    left_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_left"),
         quantum_type=QuantumNumeric(
-            size=Expression(expr=str(var.quantum_type.size_in_bits - 1)),
+            size=Expression(expr=str(var.quantum_type.size_in_bits - right_size)),
             is_signed=Expression(expr="False"),
             fraction_digits=Expression(expr="0"),
         ),
     )
-    sign_var = QuantumSymbol(
-        handle=HandleBinding(name=f"{kind}_sign_bit"),
-        quantum_type=QuantumBit(),
+    right_var = QuantumSymbol(
+        handle=HandleBinding(name=f"{kind}_right"),
+        quantum_type=QuantumNumeric(
+            size=Expression(expr=str(right_size)),
+            is_signed=Expression(expr="False"),
+            fraction_digits=Expression(expr="0"),
+        ),
     )
-    sign_split_bind = BindOperation(
+    split_bind = BindOperation(
         in_handles=[var.handle],
-        out_handles=[significand_var.handle, sign_var.handle],
+        out_handles=[left_var.handle, right_var.handle],
+    )
+    return left_var, right_var, split_bind
+
+
+def _split_and_xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> tuple[
+    Optional[QuantumSymbol],
+    Optional[QuantumSymbol],
+    list[VariableDeclarationStatement],
+    list[BindOperation],
+    list[Control],
+]:
+    if TYPE_CHECKING:
+        assert isinstance(value_var.quantum_type, QuantumNumeric)
+        assert isinstance(target_var.quantum_type, QuantumNumeric)
+    size_diff = (
+        value_var.quantum_type.size_in_bits - target_var.quantum_type.size_in_bits
+    )
+    if not value_var.quantum_type.sign_value or size_diff >= 0:
+        return target_var, value_var, [], [], []
+
+    if value_var.quantum_type.size_in_bits == 1:
+        return None, None, [], [], [_xor_sign(target_var, value_var)]
+
+    value_rest_var, value_sign_var, value_split_bind = _split_var("value", value_var, 1)
+    target_left_var, target_right_var, target_split_bind = _split_var(
+        "target", target_var, -size_diff + 1
+    )
+    var_decls = [
+        VariableDeclarationStatement(
+            name=var.handle.name,
+            quantum_type=var.quantum_type,
+        )
+        for var in (value_rest_var, value_sign_var, target_left_var, target_right_var)
+    ]
+    bind_ops = [value_split_bind, target_split_bind]
+    sign_xor = _xor_sign(target_right_var, value_sign_var)
+    return target_left_var, value_rest_var, var_decls, bind_ops, [sign_xor]
+
+
+def _xor_sign(target_var: QuantumSymbol, value_var: QuantumSymbol) -> Control:
+    quantum_type = value_var.quantum_type
+    if TYPE_CHECKING:
+        assert isinstance(quantum_type, QuantumNumeric)
+    if quantum_type.size_in_bits != 1 or quantum_type.fraction_digits_value not in (
+        0,
+        1,
+    ):
+        raise ClassiqInternalExpansionError
+
+    inner_xor = QuantumFunctionCall(
+        function=apply_to_all.func_decl.name,
+        positional_args=["X", target_var.handle],
+    )
+    inner_xor.set_func_decl(apply_to_all.func_decl)
+
+    if quantum_type.sign_value:
+        if quantum_type.fraction_digits_value == 1:
+            ctrl_value = -0.5
+        else:
+            ctrl_value = -1
+    else:
+        if quantum_type.fraction_digits_value == 1:
+            ctrl_value = 0.5
+        else:
+            ctrl_value = 1
+
+    return Control(
+        expression=Expression(expr=f"{value_var.handle} == {ctrl_value}"),
+        body=[inner_xor],
     )
-    return significand_var, sign_var, sign_split_bind

classiq/model_expansions/quantum_operations/phase.py

@@ -1,4 +1,4 @@
-from typing import TYPE_CHECKING, Dict, List, Tuple
+from typing import TYPE_CHECKING
 
 import sympy
 from sympy import sympify
@@ -108,8 +108,8 @@ class PhaseEmitter(ExpressionOperationEmitter[PhaseOperation]):
 
 
 def _get_single_bit_vars_expression(
-    expr: sympy.Expr, vars_info: Dict[str, QuantumScalar]
-) -> Tuple[sympy.Expr, List[sympy.Symbol]]:
+    expr: sympy.Expr, vars_info: dict[str, QuantumScalar]
+) -> tuple[sympy.Expr, list[sympy.Symbol]]:
     bit_vars = []
     for var_name, var_info in vars_info.items():
         size = var_info.size_in_bits
@@ -139,9 +139,9 @@ def _get_single_bit_vars_expression(
 
 
 def _convert_ising_sympy_to_pauli_terms(
-    ising_expr: sympy.Expr, ordered_sympy_vars: List[sympy.Symbol]
+    ising_expr: sympy.Expr, ordered_sympy_vars: list[sympy.Symbol]
 ) -> str:
-    pauli_terms: List[str] = []
+    pauli_terms: list[str] = []
     coefficients = ising_expr.as_coefficients_dict(*ordered_sympy_vars)
     for expr_term in ising_expr.args:
         expr_vars = _get_vars(expr_term)
@@ -171,7 +171,7 @@ def _convert_ising_sympy_to_pauli_terms(
 
 def _convert_cost_expression_to_hamiltonian(
     expr: str,
-    vars: Dict[str, QuantumScalar],
+    vars: dict[str, QuantumScalar],
 ) -> Expression:
     sympy_expr = sympify(expr)
     single_bit_vars_expression, single_bit_vars = _get_single_bit_vars_expression(

classiq/model_expansions/quantum_operations/quantum_assignment_operation.py

@@ -1,6 +1,5 @@
 import ast
 import re
-from typing import Tuple
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -23,6 +22,7 @@ from classiq.interface.model.quantum_expressions.quantum_expression import (
 from classiq.interface.model.quantum_function_call import QuantumFunctionCall
 from classiq.interface.model.quantum_type import (
     QuantumNumeric,
+    QuantumType,
 )
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -41,6 +41,10 @@ from classiq.model_expansions.visitors.boolean_expression_transformers import (
 from classiq.qmod import builtins
 from classiq.qmod.builtins.functions import X, allocate
 
+HANDLE_ERROR_MESSAGE = (
+    "Quantum variable '{handle_str}' cannot appear on both sides of the assignment"
+)
+
 
 def _is_constant(expr: str) -> bool:
     try:
@@ -129,7 +133,7 @@ class QuantumAssignmentOperationEmitter(
 
     def _optimize_boolean_expression(
         self, op: ArithmeticOperation, expression: Expression
-    ) -> Tuple[ArithmeticOperation, Expression, bool]:
+    ) -> tuple[ArithmeticOperation, Expression, bool]:
         if (
             self._interpreter._is_frontend
             or op.operation_kind
@@ -150,7 +154,7 @@ class QuantumAssignmentOperationEmitter(
 
     def _adapt_boolean_inplace(
         self, op: ArithmeticOperation, expression: Expression, is_bool_opt: bool
-    ) -> Tuple[ArithmeticOperation, Expression, bool]:
+    ) -> tuple[ArithmeticOperation, Expression, bool]:
         adapter = BooleanExpressionFuncLibAdapter(is_bool_opt)
         adapted_expression = self._evaluate_expression(
             Expression(expr=ast.unparse(adapter.visit(ast.parse(expression.expr))))
@@ -223,12 +227,28 @@ class QuantumAssignmentOperationEmitter(
         self._interpreter.emit_statement(allocate_call)
         return True
 
+    @staticmethod
+    def _get_updated_op_split_symbols(
+        op: QuantumAssignmentOperation,
+        symbol_mapping: dict[HandleBinding, tuple[str, QuantumType]],
+    ) -> QuantumAssignmentOperation:
+        if op.result_var not in symbol_mapping:
+            return op
+        handle_str, quantum_type = symbol_mapping[op.result_var]
+        if handle_str in op.expression.expr:
+            raise ClassiqExpansionError(
+                HANDLE_ERROR_MESSAGE.format(handle_str=str(op.result_var))
+            )
+        new_result_handle = HandleBinding(name=handle_str)
+        return op.model_copy(
+            update=dict(result_var=new_result_handle, _result_type=quantum_type)
+        )
+
 
 def _validate_naive_inplace_handles(qe: ArithmeticOperation) -> None:
     if qe.result_var in qe.var_handles:
         raise ClassiqExpansionError(
-            f"Quantum variable {qe.result_var.name} cannot appear on both sides of "
-            f"the ^= assignment"
+            HANDLE_ERROR_MESSAGE.format(handle_str=str(qe.result_var))
         )