classiq 0.93.0__py3-none-any.whl → 0.94.0__py3-none-any.whl

classiq/applications/chemistry/problems.py

@@ -1,5 +1,5 @@
 from collections.abc import Sequence
-from typing import Optional, cast
+from typing import cast
 
 from openfermion import MolecularData
 from openfermion.ops import FermionOperator
@@ -31,7 +31,7 @@ class FermionHamiltonianProblem:
         self,
         fermion_hamiltonian: FermionOperator,
         n_particles: tuple[int, int],
-        n_orbitals: Optional[int] = None,
+        n_orbitals: int | None = None,
     ) -> None:
         """
         Initializes a `FermionHamiltonianProblem` from the fermion hamiltonian, number
@@ -115,7 +115,7 @@ class FermionHamiltonianProblem:
         cls,
         molecule: MolecularData,
         first_active_index: int = 0,
-        remove_orbitlas: Optional[Sequence[int]] = None,
+        remove_orbitlas: Sequence[int] | None = None,
         op_compression_tol: float = 1e-13,
     ) -> "FermionHamiltonianProblem":
         """

classiq/applications/chemistry/ucc.py

@@ -1,7 +1,6 @@
 from collections.abc import Sequence
 from itertools import chain, combinations, product
 from math import factorial
-from typing import Union
 
 from openfermion.ops.operators.fermion_operator import FermionOperator
 from openfermion.ops.operators.qubit_operator import QubitOperator
@@ -17,7 +16,7 @@ from classiq.qmod.builtins.structs import (
 def get_ucc_hamiltonians(
     problem: FermionHamiltonianProblem,
     mapper: FermionToQubitMapper,
-    excitations: Union[int, Sequence[int]],
+    excitations: int | Sequence[int],
 ) -> list[SparsePauliOp]:
     """
     Computes the UCC hamiltonians of the given problem in the desired excitations,

classiq/applications/chemistry/z2_symmetries.py

@@ -1,6 +1,6 @@
 from collections.abc import Sequence
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Optional
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 from openfermion.ops.operators.fermion_operator import FermionOperator
@@ -38,7 +38,7 @@ class Z2SymTaperMapper(FermionToQubitMapper):
         generators: Sequence[QubitOperator],
         x_ops: Sequence[QubitOperator],
         method: MappingMethod = MappingMethod.JORDAN_WIGNER,
-        sector: Optional[Sequence[int]] = None,
+        sector: Sequence[int] | None = None,
         tol: float = 1e-14,
     ) -> None:
         """
@@ -192,7 +192,7 @@ class Z2SymTaperMapper(FermionToQubitMapper):
         generators = _get_z2_symmetries_generators(qubit_op, n_qubits)
         x_ops = _get_x_ops_for_generators(generators, n_qubits)
 
-        sector: Optional[list[int]] = None
+        sector: list[int] | None = None
         if sector_from_hartree_fock:
             from classiq.applications.chemistry.hartree_fock import get_hf_state
 
@@ -252,7 +252,7 @@ def _get_x_ops_for_generators(
         # we look for a column in the Z-part of the matrix which is populated only with
         # 0s except for a 1 in the current generator: a X operation in this column's
         # qubit will anti-commute with the current generator and commute with all others
-        found_col: Optional[int] = None
+        found_col: int | None = None
         for col in range(n_qubits):
             if (
                 generators[row, n_qubits + col] == 1

classiq/applications/combinatorial_helpers/allowed_constraints.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from sympy import Add, Expr, LessThan, Symbol
 
 from classiq.interface.combinatorial_optimization.encoding_types import EncodingType
@@ -8,7 +6,7 @@ _INEQUALITY_UPPER_LIMIT = 1
 
 
 def is_constraint_sum_less_than_one(
-    expression: Expr, encoding_type: Optional[EncodingType] = None
+    expression: Expr, encoding_type: EncodingType | None = None
 ) -> bool:
     # tests the case: x_1 + ... + x_n <= 1
     return (

classiq/applications/combinatorial_helpers/arithmetic/arithmetic_expression.py

@@ -2,7 +2,6 @@ from typing import Any
 
 import sympy
 from pyomo.core.expr.sympy_tools import PyomoSympyBimap
-from scipy.optimize import differential_evolution
 from sympy import Expr
 
 from classiq.applications.combinatorial_helpers import encoding_utils
@@ -17,6 +16,8 @@ def sympy_lambdify(*args: Any, **kwargs: Any) -> Any:
 def multivariate_extremum(
     expr: Expr, symbols_map: PyomoSympyBimap, is_min: bool
 ) -> float:
+    from scipy.optimize import differential_evolution
+
     if expr.is_number:
         return float(expr)
 

classiq/applications/combinatorial_helpers/combinatorial_problem_utils.py

@@ -1,6 +1,6 @@
 import itertools
+from collections.abc import Callable
 from functools import partial
-from typing import Callable, Union
 
 import numpy as np
 import pyomo.environ as pyo
@@ -96,7 +96,7 @@ def _decode_vector_str(
     )  # reverse qubit order
 
 
-def _evaluate_operator(operator: SparsePauliOp, state: Union[list[int], str]) -> float:
+def _evaluate_operator(operator: SparsePauliOp, state: list[int] | str) -> float:
     if isinstance(state, list):
         state = "".join([str(x) for x in state])
 

classiq/applications/combinatorial_helpers/encoding_mapping.py

@@ -1,6 +1,5 @@
 import itertools
 from dataclasses import dataclass, field
-from typing import Optional, Union
 
 import pyomo.environ as pyo
 from pyomo.core.base.var import VarData
@@ -47,7 +46,7 @@ class EncodingMapping:
         self,
         original_var: VarData,
         encoding_expr: pyo.Expression,
-        encodings_vars: Union[list[VarData], None] = None,
+        encodings_vars: list[VarData] | None = None,
     ) -> None:
         if encodings_vars is None:
             encodings_vars = list(identify_variables(encoding_expr))
@@ -73,7 +72,7 @@ class EncodingMapping:
     def get_encoding_vars(self, original_var: VarData) -> list[VarData]:
         return self.get_var_expr_mapping(original_var).encodings_vars
 
-    def get_original_var(self, encoding_var: VarData) -> Optional[VarData]:
+    def get_original_var(self, encoding_var: VarData) -> VarData | None:
         for original_var in self.original_vars:
             if pyomo_utils.contains(encoding_var, self.get_encoding_vars(original_var)):
                 return original_var

classiq/applications/combinatorial_helpers/encoding_utils.py

@@ -1,6 +1,6 @@
 import math
 from itertools import filterfalse
-from typing import Any, Union, cast
+from typing import Any, cast
 
 import numpy as np
 import pyomo.environ as pyo
@@ -97,7 +97,7 @@ def encode_constraints(
 
 def deal_with_trivial_boolean_constraint(
     constraint: _ComponentBase,
-    constraint_expression: Union[bool, Expr],
+    constraint_expression: bool | Expr,
     model: pyo.ConcreteModel,
 ) -> None:
     # using '==' on purpose since comparing against sympy's True

classiq/applications/combinatorial_helpers/optimization_model.py

@@ -1,7 +1,6 @@
 import copy
 from functools import cached_property
 from itertools import filterfalse
-from typing import Optional, Union
 
 import pyomo.environ as pyo
 import sympy
@@ -49,8 +48,8 @@ class OptimizationModel:
         self,
         model: ConcreteModel,
         qsolver: QSolver,
-        penalty_energy: Optional[float],
-        encoding_type: Optional[EncodingType] = None,
+        penalty_energy: float | None,
+        encoding_type: EncodingType | None = None,
     ) -> None:
         assert model.nobjectives() == 1, "model must have a single objective"
         model_copy = copy.deepcopy(model)
@@ -130,7 +129,7 @@ class OptimizationModel:
 
     def _get_penalty_term(
         self, constraints: list[_GeneralConstraintData]
-    ) -> Union[int, Expression]:
+    ) -> int | Expression:
         normalized_penalty_term = penalty.get_penalty_expression(constraints)
         return self.penalty_energy * normalized_penalty_term * self.sign
 

classiq/applications/combinatorial_helpers/pauli_helpers/pauli_sparsing.py

@@ -1,4 +1,4 @@
-from typing import Any, Union
+from typing import Any
 
 import numpy as np
 
@@ -23,7 +23,7 @@ class SparsePauliOp:
         new_coeffs = np.concatenate([self.coeffs, other.coeffs])
         return SparsePauliOp(new_paulis, new_coeffs)
 
-    def __mul__(self, other: Union[int, float, complex]) -> "SparsePauliOp":
+    def __mul__(self, other: int | float | complex) -> "SparsePauliOp":
         """Scalar multiplication of a SparsePauliOp."""
         if not isinstance(other, (int, float, complex)):
             raise ValueError("Can only multiply by scalar values.")

classiq/applications/combinatorial_helpers/pyomo_utils.py

@@ -8,7 +8,7 @@ from enum import Enum
 from functools import reduce
 from operator import mul
 from types import CodeType
-from typing import Any, Optional, TypeVar, Union
+from typing import Any, TypeVar
 
 import pydantic
 import pyomo.core.expr.numeric_expr as pyo_expr
@@ -132,7 +132,7 @@ def _delete_element_by_value(dict_: dict, value: Any) -> None:
             del dict_[k]
 
 
-def get_name(component: Union[IndexedComponent, ComponentData]) -> str:
+def get_name(component: IndexedComponent | ComponentData) -> str:
     if isinstance(component, IndexedComponent):
         return component._name  # constraint.name returns "'{name}'"
     else:
@@ -141,8 +141,8 @@ def get_name(component: Union[IndexedComponent, ComponentData]) -> str:
 
 class FixedSympy2PyomoVisitor(Sympy2PyomoVisitor):
     def beforeChild(  # noqa: N802
-        self, node: Optional[sympy.Expr], child: sympy.Expr, child_idx: Optional[int]
-    ) -> tuple[bool, Union[int, float, None]]:
+        self, node: sympy.Expr | None, child: sympy.Expr, child_idx: int | None
+    ) -> tuple[bool, int | float | None]:
         if not child._args:
             item = self.object_map.getPyomoSymbol(child, None)
             if item is None:
@@ -300,7 +300,7 @@ def _get_array_sizes(vars: list[VarData]) -> dict[str, tuple[int, ...]]:
 
 def _get_indices_dimensions(
     indices: set[tuple[int, ...]], *, strict: bool
-) -> Optional[tuple[int, ...]]:
+) -> tuple[int, ...] | None:
     indices_list = list(indices)
     if len(indices) == 0:
         return None
@@ -365,7 +365,7 @@ def _get_qmod_field_type(var_name: str, var_data: VarData) -> type[QVar]:
 
 
 def evaluate_objective(
-    var_mapping: dict[Any, Union[str, tuple[str, tuple[int, ...]]]],
+    var_mapping: dict[Any, str | tuple[str, tuple[int, ...]]],
     sympy_expr: sympy.Expr,
     code_expr: CodeType,
     struct_obj: Any,
@@ -411,7 +411,7 @@ def is_index_var(var: VarData) -> bool:
     )
 
 
-def index_as_tuple(index: Union[int, tuple[int, ...]]) -> tuple[int, ...]:
+def index_as_tuple(index: int | tuple[int, ...]) -> tuple[int, ...]:
     if isinstance(index, int):
         return (index,)
     return index
@@ -435,7 +435,7 @@ def add_var_domain_constraints(model: ConcreteModel) -> Iterator[None]:
     model.del_component("var_domain_constraints")
 
 
-def _get_var_domain_constraint(var: VarData) -> Optional[ExpressionBase]:
+def _get_var_domain_constraint(var: VarData) -> ExpressionBase | None:
     bounds = var.bounds
     if (
         type(bounds) is not tuple

classiq/applications/combinatorial_helpers/sympy_utils.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pyomo.core as pyo
 from pyomo.core.base.var import VarData
 from pyomo.core.expr.sympy_tools import Pyomo2SympyVisitor, PyomoSympyBimap
@@ -14,7 +12,7 @@ def sympyify_vars(variables: list[VarData]) -> PyomoSympyBimap:
 
 
 def sympyify_expression(
-    expression: pyo.Expression, symbols_map: Optional[PyomoSympyBimap] = None
+    expression: pyo.Expression, symbols_map: PyomoSympyBimap | None = None
 ) -> Expr:
     if symbols_map is None:
         symbols_map = PyomoSympyBimap()

classiq/applications/combinatorial_helpers/transformations/encoding.py

@@ -1,6 +1,6 @@
 import copy
+from collections.abc import Callable
 from itertools import chain, product
-from typing import Callable, Union
 
 import pyomo.environ as pyo
 from pyomo.core.base.var import VarData
@@ -25,7 +25,7 @@ def _make_invalid_encoding_type_error(
     )
 
 
-def encoding_length(var: VarData, encoding_type: Union[EncodingType, None]) -> int:
+def encoding_length(var: VarData, encoding_type: EncodingType | None) -> int:
     if encoding_type is None:
         return 1
 
@@ -172,7 +172,7 @@ class ModelEncoder:
     def encode_expr(
         self,
         expr: pyo.Expression,
-        substitution_dict: Union[dict[int, pyo.Expression], None] = None,
+        substitution_dict: dict[int, pyo.Expression] | None = None,
     ) -> pyo.Expression:
         if substitution_dict is None:
             substitution_dict = self.vars_encoding_mapping.substitution_dict

classiq/applications/combinatorial_helpers/transformations/fixed_variables.py

@@ -1,5 +1,4 @@
 import copy
-from typing import Union
 
 from pyomo.core import ConcreteModel, Var
 from pyomo.core.base.constraint import _GeneralConstraintData
@@ -125,7 +124,7 @@ def add_fixed_variables_to_solution(
     return solution_with_fixed
 
 
-def _get_value_if_exists(var: VarData) -> Union[int, VarData]:
+def _get_value_if_exists(var: VarData) -> int | VarData:
     return var.value if var.value is not None else var
 
 

classiq/applications/combinatorial_optimization/combinatorial_optimization_config.py

@@ -1,6 +1,5 @@
 import dataclasses
 from dataclasses import dataclass
-from typing import Optional
 
 from classiq.interface.executor.optimizer_preferences import CostType, OptimizerType
 
@@ -14,10 +13,10 @@ class QAOAConfig:
 @dataclass
 class OptimizerConfig:
     opt_type: OptimizerType = OptimizerType.COBYLA
-    max_iteration: Optional[int] = None
+    max_iteration: int | None = None
     tolerance: float = 0.0
     step_size: float = 0.0
     skip_compute_variance: bool = False
     cost_type: CostType = CostType.CVAR
     alpha_cvar: float = 1.0
-    initial_point: Optional[list[float]] = dataclasses.field(default=None)
+    initial_point: list[float] | None = dataclasses.field(default=None)

classiq/applications/combinatorial_optimization/combinatorial_optimization_model_constructor.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 from pyomo import environ as pyo
 from pyomo.core import Objective, maximize
 
@@ -47,8 +45,8 @@ with set_global_declarative_switch():
 
 def construct_combi_opt_py_model(
     pyo_model: pyo.ConcreteModel,
-    qaoa_config: Optional[QAOAConfig] = None,
-    optimizer_config: Optional[OptimizerConfig] = None,
+    qaoa_config: QAOAConfig | None = None,
+    optimizer_config: OptimizerConfig | None = None,
 ) -> Model:
     if qaoa_config is None:
         qaoa_config = QAOAConfig()
@@ -137,8 +135,8 @@ save({{"vqe_result": vqe_result, "hamiltonian": hamiltonian}})
 
 def construct_combinatorial_optimization_model(
     pyo_model: pyo.ConcreteModel,
-    qaoa_config: Optional[QAOAConfig] = None,
-    optimizer_config: Optional[OptimizerConfig] = None,
+    qaoa_config: QAOAConfig | None = None,
+    optimizer_config: OptimizerConfig | None = None,
 ) -> SerializedModel:
     converted_pyo_model = convert_pyomo_to_global_presentation(pyo_model)
     model = construct_combi_opt_py_model(

classiq/applications/combinatorial_optimization/combinatorial_problem.py

@@ -1,11 +1,10 @@
 import math
 import re
-from typing import Callable, Optional, cast
+from collections.abc import Callable
+from typing import TYPE_CHECKING, cast
 
 import numpy as np
-import pandas as pd
 import pyomo.core as pyo
-import scipy
 
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
 from classiq.interface.executor.result import ExecutionDetails
@@ -29,6 +28,9 @@ from classiq.qmod.qmod_parameter import CArray
 from classiq.qmod.qmod_variable import Output, QVar
 from classiq.synthesis import synthesize
 
+if TYPE_CHECKING:
+    import pandas as pd
+
 
 class CombinatorialProblem:
     def __init__(
@@ -62,8 +64,8 @@ class CombinatorialProblem:
 
     def get_model(
         self,
-        constraints: Optional[Constraints] = None,
-        preferences: Optional[Preferences] = None,
+        constraints: Constraints | None = None,
+        preferences: Preferences | None = None,
     ) -> SerializedModel:
         @qfunc
         def main(
@@ -93,10 +95,10 @@ class CombinatorialProblem:
 
     def optimize(
         self,
-        execution_preferences: Optional[ExecutionPreferences] = None,
+        execution_preferences: ExecutionPreferences | None = None,
         maxiter: int = 20,
         quantile: float = 1.0,
-        initial_params: Optional[list[float]] = None,
+        initial_params: list[float] | None = None,
     ) -> list[float]:
         if self.qprog_ is None:
             self.get_qprog()
@@ -131,10 +133,12 @@ class CombinatorialProblem:
         self._es = _es
         return _optimized_params
 
-    def sample_uniform(self) -> pd.DataFrame:
+    def sample_uniform(self) -> "pd.DataFrame":
         return self.sample([0] * self.num_layers_ * 2)
 
-    def sample(self, params: list) -> pd.DataFrame:
+    def sample(self, params: list) -> "pd.DataFrame":
+        import pandas as pd
+
         assert self._es is not None
         res = self._es.sample({"params": params})
         parsed_result = [
@@ -161,7 +165,7 @@ def execute_qaoa(
     cost_func: Callable,
     num_layers: int,
     maxiter: int,
-    execution_preferences: Optional[ExecutionPreferences] = None,
+    execution_preferences: ExecutionPreferences | None = None,
 ) -> tuple[SerializedModel, QuantumProgram, ExecutionDetails]:
     """
     Implements a simple QAOA algorithm, including the creation and synthesis of the QAOA
@@ -178,6 +182,7 @@ def execute_qaoa(
         a tuple containing the model of the QAOA ansatz, the corresponding synthesized quantum program,
         and the result of the execution with the optimized parameters
     """
+    import scipy
 
     @qfunc
     def main(

classiq/applications/hamiltonian/pauli_decomposition.py

@@ -1,5 +1,3 @@
-from typing import Union
-
 import numpy as np
 from sympy import fwht
 
@@ -56,7 +54,7 @@ def _coefficents_for_set(mat: np.ndarray, set_index: int) -> list:
 
 def _get_signed_coefficient(
     c: complex, k: int, i: int, is_hermitian: bool
-) -> Union[complex, float]:
+) -> complex | float:
     # correct from iY to Y
     coef = complex((1j) ** ((i & k).bit_count()) * c)
     if is_hermitian:
@@ -131,7 +129,7 @@ def _sparse_pauli_to_list(operator: SparsePauliOp) -> list[PauliTerm]:
 
 # return matrix from hamiltonian
 def hamiltonian_to_matrix(
-    hamiltonian: Union[list[PauliTerm], SparsePauliOp],
+    hamiltonian: list[PauliTerm] | SparsePauliOp,
 ) -> np.ndarray:
     if isinstance(hamiltonian, SparsePauliOp):
         hamiltonian = _sparse_pauli_to_list(hamiltonian)
@@ -143,3 +141,7 @@ def hamiltonian_to_matrix(
         matrix += p.coefficient * pauli_string_to_mat(p.pauli)
 
     return matrix
+
+
+def pauli_operator_to_matrix(pauli_op: SparsePauliOp) -> np.ndarray:
+    return hamiltonian_to_matrix(_sparse_pauli_to_list(pauli_op))

classiq/applications/iqae/iqae.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, cast
+from typing import Literal, cast
 
 from classiq.interface.applications.iqae.generic_iqae import GenericIQAE
 from classiq.interface.applications.iqae.iqae_result import (
@@ -46,15 +46,15 @@ class IQAE:
         self,
         state_prep_op: QCallable[QArray[QBit, Literal["problem_vars_size"]], QBit],
         problem_vars_size: int,
-        constraints: Optional[Constraints] = None,
-        preferences: Optional[Preferences] = None,
+        constraints: Constraints | None = None,
+        preferences: Preferences | None = None,
     ) -> None:
         self._state_prep_op = state_prep_op
         self._problem_vars_size: int = problem_vars_size
-        self._constraints: Optional[Constraints] = constraints
-        self._preferences: Optional[Preferences] = preferences
-        self._model: Optional[SerializedModel] = None
-        self._qprog: Optional[QuantumProgram] = None
+        self._constraints: Constraints | None = constraints
+        self._preferences: Preferences | None = preferences
+        self._model: SerializedModel | None = None
+        self._qprog: QuantumProgram | None = None
 
         """
         Args:
@@ -133,7 +133,7 @@ class IQAE:
         self,
         epsilon: float,
         alpha: float,
-        execution_preferences: Optional[ExecutionPreferences] = None,
+        execution_preferences: ExecutionPreferences | None = None,
     ) -> IQAEResult:
         """
         Executes IQAE's quantum program with the provided epsilon, alpha, and execution

classiq/applications/qnn/datasets/dataset_base_classes.py

@@ -1,6 +1,6 @@
 from abc import ABC, abstractmethod
 from collections.abc import Sequence
-from typing import Literal, Optional, TypeVar, Union
+from typing import Literal, TypeVar
 
 from torch import Tensor, tensor
 from torch.utils.data import Dataset
@@ -16,8 +16,8 @@ class MyDataset(Dataset, ABC):
     def __init__(
         self,
         n: int = 2,
-        transform: Optional[Transform] = None,
-        target_transform: Optional[Transform] = None,
+        transform: Transform | None = None,
+        target_transform: Transform | None = None,
     ) -> None:
         self._n = n
         self.transform = transform
@@ -55,9 +55,9 @@ class MySubsetDataset(MyDataset, ABC):
     def __init__(
         self,
         n: int = 2,
-        subset: Union[list[int], Literal["all"]] = "all",
-        transform: Optional[Transform] = None,
-        target_transform: Optional[Transform] = None,
+        subset: list[int] | Literal["all"] = "all",
+        transform: Transform | None = None,
+        target_transform: Transform | None = None,
     ) -> None:
         super().__init__(n, transform, target_transform)
 

classiq/applications/qnn/datasets/dataset_parity.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Union
+from typing import Literal
 
 from classiq.applications.qnn.datasets.dataset_base_classes import MySubsetDataset
 from classiq.applications.qnn.types import DataAndLabel, Transform
@@ -8,10 +8,10 @@ class DatasetSubsetParity(MySubsetDataset):
     def __init__(
         self,
         n: int = 2,
-        subset: Union[list[int], Literal["all"]] = "all",
+        subset: list[int] | Literal["all"] = "all",
         add_readout_qubit: bool = True,
-        transform: Optional[Transform] = None,
-        target_transform: Optional[Transform] = None,
+        transform: Transform | None = None,
+        target_transform: Transform | None = None,
     ) -> None:
         super().__init__(n, subset, transform, target_transform)
 
@@ -35,7 +35,7 @@ class DatasetParity(DatasetSubsetParity):
         self,
         n: int = 2,
         add_readout_qubit: bool = True,
-        transform: Optional[Transform] = None,
-        target_transform: Optional[Transform] = None,
+        transform: Transform | None = None,
+        target_transform: Transform | None = None,
     ) -> None:
         super().__init__(n, "all", add_readout_qubit, transform, target_transform)

classiq/applications/qnn/qlayer.py

@@ -2,7 +2,8 @@ import functools
 import inspect
 import os
 import typing
-from typing import Any, Callable, Optional, Union, overload
+from collections.abc import Callable
+from typing import Any, overload
 
 import more_itertools
 import torch
@@ -41,14 +42,14 @@ from classiq.execution.qnn import _MAX_ARGUMENTS_SIZE, _execute_qnn_sample
 
 class QLayerFunction(torch.autograd.Function):
     @staticmethod
-    def forward(  # type: ignore[override]
+    def forward(
         ctx: Any,
         inputs: Tensor,
         weights: Tensor,
         quantum_program: QuantumProgram,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
-        epsilon: Optional[float] = EPSILON,
+        epsilon: float | None = EPSILON,
     ) -> Tensor:
         """
         This function receives:
@@ -105,7 +106,7 @@ class QLayerFunction(torch.autograd.Function):
     @staticmethod
     def backward(  # type: ignore[override]
         ctx: Any, grad_output: Tensor
-    ) -> tuple[Optional[Tensor], Optional[Tensor], None, None, None, None]:
+    ) -> tuple[Tensor | None, Tensor | None, None, None, None, None]:
         """
         grad_output: Tensor
             is of shape (ctx.batch_size, ctx.num_out_features)
@@ -159,7 +160,7 @@ class QLayer(nn.Module):
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
         # Optional parameters:
-        head_start: Union[float, Tensor, None] = None,
+        head_start: float | Tensor | None = None,
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
         epsilon: float = EPSILON,
@@ -172,7 +173,7 @@ class QLayer(nn.Module):
         post_process: PostProcessFunction,
         /,
         # Optional parameters:
-        head_start: Union[float, Tensor, None] = None,
+        head_start: float | Tensor | None = None,
         # Experimental parameters:
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
         epsilon: float = EPSILON,
@@ -207,7 +208,7 @@ class QLayer(nn.Module):
         circuit: Circuit,
         execute: ExecuteFunction,
         post_process: PostProcessFunction,
-        head_start: Union[float, Tensor, None] = None,
+        head_start: float | Tensor | None = None,
         calc_num_out_features: CalcNumOutFeatures = calc_num_out_features_single_output,
         epsilon: float = EPSILON,
     ) -> None: