classiq 0.53.0__py3-none-any.whl → 0.55.0__py3-none-any.whl

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)
 
 
@@ -73,8 +70,13 @@ 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._expanded_functions_compilation_metadata = (
+            self._interpreter._expanded_functions_compilation_metadata
+        )
+        self._functions_compilation_metadata = (
+            self._interpreter._model.functions_compilation_metadata
+        )
+        self._generative_contexts: dict[str, OperationContext] = {}
 
     @abstractmethod
     def emit(self, statement: QuantumStatementT, /) -> None:
@@ -103,7 +105,7 @@ class Emitter(Generic[QuantumStatementT]):
         return self._interpreter._current_scope
 
     @property
-    def _expanded_functions(self) -> List[NativeFunctionDefinition]:
+    def _expanded_functions(self) -> dict[str, NativeFunctionDefinition]:
         return self._interpreter._expanded_functions
 
     @property
@@ -125,14 +127,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(
@@ -140,23 +142,34 @@ class Emitter(Generic[QuantumStatementT]):
         )
         new_positional_arg_decls = new_declaration.positional_arg_declarations
         is_atomic = function.is_atomic
-        if not is_atomic:  # perform monomorphization
+        new_function_name = function.name
+        if not is_atomic:  # perform monomorphization per interpreted parameters set
             self._add_params_to_scope(
                 new_positional_arg_decls, evaluated_args, function
             )
             context = self._expand_operation(
                 function.with_new_declaration(new_declaration)
             )
-            self._expanded_functions.append(
-                self._builder.create_definition(cast(FunctionContext, context))
+            function_context = cast(FunctionContext, context)
+            closure_id = function_context.closure.closure_id
+            function_def = self._expanded_functions.get(closure_id)
+            if function_def is None:
+                function_def = self._builder.create_definition(function_context)
+                self._expanded_functions[closure_id] = function_def
+            new_function_name = function_def.name
+            compilation_metadata = self._functions_compilation_metadata.get(
+                function.name
             )
+            if compilation_metadata is not None:
+                self._expanded_functions_compilation_metadata[new_function_name] = (
+                    compilation_metadata
+                )
+
         new_positional_args = self._get_new_positional_args(
             evaluated_args, is_atomic, new_positional_arg_decls
         )
         new_call = QuantumFunctionCall(
-            function=(
-                new_declaration.name if is_atomic else self._expanded_functions[-1].name
-            ),
+            function=new_function_name,
             positional_args=new_positional_args,
         )
         is_allocate_or_free = (
@@ -206,10 +219,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 +243,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 +273,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, Union
 
 from classiq.interface.exceptions import (
     ClassiqExpansionError,
@@ -13,6 +13,7 @@ from classiq.interface.generator.expressions.evaluated_expression import (
 from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.type_name import TypeName
 from classiq.interface.model.bind_operation import BindOperation
+from classiq.interface.model.control import Control
 from classiq.interface.model.handle_binding import (
     FieldHandleBinding,
     HandleBinding,
@@ -20,12 +21,14 @@ from classiq.interface.model.handle_binding import (
     SubscriptHandleBinding,
 )
 from classiq.interface.model.quantum_expressions.quantum_expression import (
+    QuantumAssignmentOperation,
     QuantumExpressionOperation,
 )
 from classiq.interface.model.quantum_type import (
     QuantumBit,
     QuantumBitvector,
     QuantumNumeric,
+    QuantumType,
 )
 from classiq.interface.model.variable_declaration_statement import (
     VariableDeclarationStatement,
@@ -48,7 +51,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 +65,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 +81,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 +99,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 +124,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 +144,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 +178,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(
@@ -207,3 +216,25 @@ class ExpressionOperationEmitter(Emitter[ExpressionOperationT]):
             self._machine_precision,
         )
         return op_with_evaluated_types
+
+    @staticmethod
+    def _all_vars_boolean(op: QuantumExpressionOperation) -> bool:
+        if not all(
+            var_type.has_size_in_bits and var_type.size_in_bits == 1
+            for var_type in op.var_types.values()
+        ):
+            return False
+        return not any(
+            isinstance(var_type, QuantumNumeric)
+            and (var_type.sign_value or var_type.fraction_digits_value > 0)
+            for var_type in op.var_types.values()
+        )
+
+    @staticmethod
+    def _is_res_boolean(op: Union[QuantumAssignmentOperation, Control]) -> bool:
+        if not (op.result_type.has_size_in_bits and op.result_type.size_in_bits == 1):
+            return False
+        return not (
+            isinstance(op.result_type, QuantumNumeric)
+            and (op.result_type.sign_value or op.result_type.fraction_digits_value > 0)
+        )

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)
@@ -192,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],
@@ -207,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, [], []
 
@@ -246,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:
@@ -291,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(
@@ -318,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,
@@ -333,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(
@@ -348,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(