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

classiq/interface/generator/model/preferences/preferences.py

@@ -1,11 +1,11 @@
 from collections.abc import Sequence
 from enum import IntEnum
-from typing import TYPE_CHECKING, Annotated, Any, Optional, Union
+from typing import TYPE_CHECKING, Annotated, Any, Optional, TypeAlias
 
 import pydantic
 from pydantic import Field
 from pydantic_core.core_schema import ValidationInfo
-from typing_extensions import Self, TypeAlias
+from typing_extensions import Self
 
 from classiq.interface.backend.backend_preferences import (
     BackendPreferences,
@@ -135,21 +135,15 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
             - If `backend_service_provider` is not valid.
     """
 
-    _backend_preferences: Optional[BackendPreferences] = pydantic.PrivateAttr(
-        default=None
-    )
+    _backend_preferences: BackendPreferences | None = pydantic.PrivateAttr(default=None)
     machine_precision: PydanticMachinePrecision = DEFAULT_MACHINE_PRECISION
 
-    backend_service_provider: Optional[Union[Provider, ProviderVendor, str]] = (
-        pydantic.Field(
-            default=None,
-            description="Provider company or cloud for the requested backend.",
-        )
+    backend_service_provider: Provider | ProviderVendor | str | None = pydantic.Field(
+        default=None,
+        description="Provider company or cloud for the requested backend.",
     )
-    backend_name: Optional[Union[PydanticBackendName, AllBackendsNameByVendor]] = (
-        pydantic.Field(
-            default=None, description="Name of the requested backend or target."
-        )
+    backend_name: PydanticBackendName | AllBackendsNameByVendor | None = pydantic.Field(
+        default=None, description="Name of the requested backend or target."
     )
     custom_hardware_settings: CustomHardwareSettings = pydantic.Field(
         default_factory=CustomHardwareSettings,
@@ -182,7 +176,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         "declarations).",
     )
 
-    qasm3: Optional[bool] = pydantic.Field(
+    qasm3: bool | None = pydantic.Field(
         None,
         description="Output OpenQASM 3.0 instead of OpenQASM 2.0. Relevant only for "
         "the `qasm` and `transpiled_circuit.qasm` attributes of `GeneratedCircuit`.",
@@ -194,7 +188,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         "transpiled circuit and its depth",
     )
 
-    solovay_kitaev_max_iterations: Optional[pydantic.PositiveInt] = pydantic.Field(
+    solovay_kitaev_max_iterations: pydantic.PositiveInt | None = pydantic.Field(
         None,
         description="Maximum iterations for the Solovay-Kitaev algorithm (if applied).",
     )
@@ -203,7 +197,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         default=300, description="Generation timeout in seconds"
     )
 
-    optimization_timeout_seconds: Optional[pydantic.PositiveInt] = pydantic.Field(
+    optimization_timeout_seconds: pydantic.PositiveInt | None = pydantic.Field(
         default=None,
         description="Optimization timeout in seconds, or None for no "
         "optimization timeout (will still timeout when the generation timeout is over)",
@@ -217,9 +211,9 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
     @classmethod
     def optimization_timeout_less_than_generation_timeout(
         cls,
-        optimization_timeout_seconds: Optional[pydantic.PositiveInt],
+        optimization_timeout_seconds: pydantic.PositiveInt | None,
         info: ValidationInfo,
-    ) -> Optional[pydantic.PositiveInt]:
+    ) -> pydantic.PositiveInt | None:
         generation_timeout_seconds = info.data.get("timeout_seconds")
         if generation_timeout_seconds is None or optimization_timeout_seconds is None:
             return optimization_timeout_seconds
@@ -256,7 +250,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
 
     @pydantic.field_validator("backend_name")
     @classmethod
-    def validate_backend_name(cls, backend_name: Optional[str]) -> Optional[str]:
+    def validate_backend_name(cls, backend_name: str | None) -> str | None:
         if backend_name is None:
             return backend_name
         return backend_name.rstrip()
@@ -270,7 +264,7 @@ class Preferences(pydantic.BaseModel, extra="forbid"):
         return self
 
     @property
-    def backend_preferences(self) -> Optional[BackendPreferences]:
+    def backend_preferences(self) -> BackendPreferences | None:
         """
         Returns the backend preferences. If the backend preferences are not provided, the function sets the backend preferences according to backend name and provider.
 

classiq/interface/generator/model/quantum_register.py

@@ -1,11 +1,8 @@
 import itertools
-import sys
 from collections.abc import Iterator
 from types import GenericAlias as TypesGenericAlias
 from typing import (  # type: ignore[attr-defined]
     Any,
-    Optional,
-    Union,
     _GenericAlias,
 )
 
@@ -31,7 +28,7 @@ class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
         return super().__call__(*args, **kwargs, **arith_info)
 
     def __eq__(self, other: Any) -> bool:
-        if sys.version_info >= (3, 9) and isinstance(other, TypesGenericAlias):
+        if isinstance(other, TypesGenericAlias):
             return (
                 self.__origin__ == other.__origin__ and self.__args__ == other.__args__
             )
@@ -39,23 +36,23 @@ class QRegGenericAlias(_GenericAlias, _root=True):  # type: ignore[call-arg]
             return super().__eq__(other)
 
     @property
-    def role(self) -> Optional[RegisterRole]:
+    def role(self) -> RegisterRole | None:
         return getattr(self.__origin__, "role", None)
 
     @property
-    def size(self) -> Optional[int]:
+    def size(self) -> int | None:
         if self.integer_places is not None:
             return self.integer_places + (self.fraction_places or 0)
         return None
 
     @property
-    def integer_places(self) -> Optional[int]:
+    def integer_places(self) -> int | None:
         if len(self.__args__) in (1, 2) and isinstance(self.__args__[0], int):
             return self.__args__[0]
         return None
 
     @property
-    def fraction_places(self) -> Optional[int]:
+    def fraction_places(self) -> int | None:
         if len(self.__args__) == 2 and isinstance(self.__args__[1], int):
             return self.__args__[1]
         return None
@@ -96,11 +93,11 @@ class QReg:
         qreg._qubits = qubits
         return qreg
 
-    def __getitem__(self, key: Union[int, slice]) -> "QReg":
+    def __getitem__(self, key: int | slice) -> "QReg":
         state = self._qubits[key]
         return QReg._from_qubits(state if isinstance(state, list) else [state])
 
-    def __setitem__(self, key: Union[int, slice], value: "QReg") -> None:
+    def __setitem__(self, key: int | slice, value: "QReg") -> None:
         if isinstance(key, int) and len(value) != 1:
             raise ClassiqQRegError(
                 f"Size mismatch: value size {len(value)}, expected size 1"

classiq/interface/generator/noise_properties.py

@@ -1,5 +1,3 @@
-from typing import Optional
-
 import pydantic
 from pydantic import BaseModel
 
@@ -7,9 +5,7 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class NoiseProperties(BaseModel):
-    measurement_bit_flip_probability: Optional[PydanticProbabilityFloat] = (
-        pydantic.Field(
-            default=None,
-            description="Probability of measuring the wrong value for each qubit.",
-        )
+    measurement_bit_flip_probability: PydanticProbabilityFloat | None = pydantic.Field(
+        default=None,
+        description="Probability of measuring the wrong value for each qubit.",
     )

classiq/interface/generator/parameters.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Any, Union
 from classiq.interface.generator.complex_type import Complex
 
 if TYPE_CHECKING:
-    from typing_extensions import TypeAlias
+    from typing import TypeAlias
 else:
     TypeAlias = Any
 

classiq/interface/generator/partitioned_register.py

@@ -1,7 +1,6 @@
 import itertools
 from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import Optional
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.slice_parsing_utils import parse_io_slicing
@@ -72,7 +71,7 @@ class RegisterPartition:
     partitioned_register: PartitionedRegister
 
     # index == None means this is the partition containing the leftover qubits.
-    _index: Optional[int]
+    _index: int | None
 
     def __post_init__(self) -> None:
         num_partitions = len(self.partitioned_register.partitions)

classiq/interface/generator/preferences/qasm_to_qmod_params.py

@@ -5,8 +5,19 @@ from classiq.interface.enum_utils import StrEnum
 
 
 class QmodFormat(StrEnum):
+    """
+    Qmod code format.
+    """
+
     NATIVE = "native"
+    """
+    Native Qmod (`.qmod`).
+    """
+
     PYTHON = "python"
+    """
+    Python Qmod (`.py`).
+    """
 
 
 class QasmToQmodParams(BaseModel):

classiq/interface/generator/qsvm.py

@@ -1,4 +1,4 @@
-from typing import Literal, Optional, Union
+from typing import Literal, Union
 
 import numpy as np
 import pydantic
@@ -28,7 +28,7 @@ class QSVMFeatureMapEntanglement(StrEnum):
 
 
 class QSVMFeatureMapDimensional(HashablePydanticBaseModel):
-    feature_dimension: Optional[int] = None
+    feature_dimension: int | None = None
     model_config = ConfigDict(frozen=True)
 
 

classiq/interface/generator/quantum_function_call.py

@@ -10,7 +10,6 @@ from collections.abc import Iterable, Mapping, Sequence
 from re import Match
 from typing import (
     Any,
-    Optional,
     Union,
 )
 from uuid import UUID, uuid4
@@ -151,13 +150,11 @@ class SynthesisQuantumFunctionCall(BaseModel):
         description="The name of the function instance. "
         "If not set, determined automatically.",
     )
-    caller_parameters: Optional[list[str]] = pydantic.Field(default=None)
-    parameter_assignments: Optional[dict[str, ClassicalArg]] = pydantic.Field(
-        default=None
-    )
-    source_id: Optional[UUID] = pydantic.Field(default=None)
-    arithmetic_id: Optional[str] = pydantic.Field(default=None)
-    inverse_op_id: Optional[UUID] = pydantic.Field(default=None)
+    caller_parameters: list[str] | None = pydantic.Field(default=None)
+    parameter_assignments: dict[str, ClassicalArg] | None = pydantic.Field(default=None)
+    source_id: UUID | None = pydantic.Field(default=None)
+    arithmetic_id: str | None = pydantic.Field(default=None)
+    inverse_op_id: UUID | None = pydantic.Field(default=None)
 
     uuid: UUID = pydantic.Field(default_factory=uuid4)
 
@@ -222,7 +219,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
 
     @pydantic.field_validator("name", mode="before")
     @classmethod
-    def _create_name(cls, name: Optional[str], info: ValidationInfo) -> str:
+    def _create_name(cls, name: str | None, info: ValidationInfo) -> str:
         """
         generates a name to a user defined-functions as follows:
         <function_name>_<SUFFIX_MARKER>_<random_suffix>
@@ -400,7 +397,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
     @pydantic.field_validator("inputs", mode="before")
     @classmethod
     def _validate_inputs(cls, inputs: IOType, info: ValidationInfo) -> WireDict:
-        params: Optional[FunctionParams] = info.data.get("function_params")
+        params: FunctionParams | None = info.data.get("function_params")
         is_inverse: bool = info.data.get("is_inverse", False)
         strict_zero_ios: bool = info.data.get("strict_zero_ios", True)
         control_states: list[ControlState] = info.data.get("control_states", list())
@@ -556,7 +553,7 @@ class SynthesisQuantumFunctionCall(BaseModel):
         control_states: list[ControlState],
         strict_zero_ios: bool,
     ) -> tuple[list[str], list[str], list[str]]:
-        expression_matches: Iterable[Optional[Match]] = map(
+        expression_matches: Iterable[Match | None] = map(
             functools.partial(re.fullmatch, IO_REGEX), expressions
         )
 

classiq/interface/generator/quantum_program.py

@@ -2,10 +2,9 @@ import uuid
 import warnings
 from datetime import datetime, timezone
 from pathlib import Path
-from typing import Optional, Union
+from typing import TypeAlias
 
 import pydantic
-from typing_extensions import TypeAlias
 
 from classiq.interface.compression_utils import decompress
 from classiq.interface.exceptions import (
@@ -60,19 +59,17 @@ def _get_formatted_utc_current_time() -> str:
 
 class QuantumProgram(VersionedModel, CircuitCodeInterface):
     hardware_data: SynthesisHardwareData
-    initial_values: Optional[InitialConditions] = pydantic.Field(default=None)
+    initial_values: InitialConditions | None = pydantic.Field(default=None)
     data: GeneratedCircuitData
     model: ExecutionModel
-    transpiled_circuit: Optional[TranspiledCircuitData] = pydantic.Field(default=None)
+    transpiled_circuit: TranspiledCircuitData | None = pydantic.Field(default=None)
     creation_time: str = pydantic.Field(default_factory=_get_formatted_utc_current_time)
-    synthesis_duration: Optional[SynthesisStepDurations] = pydantic.Field(default=None)
-    debug_info: Optional[list[FunctionDebugInfoInterface]] = pydantic.Field(
-        default=None
-    )
-    compressed_debug_info: Optional[bytes] = pydantic.Field(default=None)
+    synthesis_duration: SynthesisStepDurations | None = pydantic.Field(default=None)
+    debug_info: list[FunctionDebugInfoInterface] | None = pydantic.Field(default=None)
+    compressed_debug_info: bytes | None = pydantic.Field(default=None)
     program_id: str = pydantic.Field(default_factory=get_uuid_as_str)
-    execution_primitives_input: Optional[PrimitivesInput] = pydantic.Field(default=None)
-    synthesis_warnings: Optional[list[str]] = pydantic.Field(default=None)
+    execution_primitives_input: PrimitivesInput | None = pydantic.Field(default=None)
+    synthesis_warnings: list[str] | None = pydantic.Field(default=None)
     should_warn: bool = pydantic.Field(default=False)
     # Unique identifier for the circuit (since the program_id might change when running show). Used for the circuit store.
     circuit_id: str = pydantic.Field(default_factory=get_uuid_as_str)
@@ -95,8 +92,8 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
 
     def to_program(
         self,
-        initial_values: Optional[InitialConditions] = None,
-        instruction_set: Optional[QuantumInstructionSet] = None,
+        initial_values: InitialConditions | None = None,
+        instruction_set: QuantumInstructionSet | None = None,
     ) -> quantum_code.QuantumCode:
         initial_values = initial_values or self.initial_values
         if instruction_set is not None:
@@ -141,7 +138,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             for name, init_value in initial_values.items()
         }
 
-    def save_results(self, filename: Optional[Union[str, Path]] = None) -> None:
+    def save_results(self, filename: str | Path | None = None) -> None:
         """
         Saves quantum program results as json into a file.
             Parameters:
@@ -171,7 +168,7 @@ class QuantumProgram(VersionedModel, CircuitCodeInterface):
             else self
         )
 
-    def get_debug_info(self) -> Optional[list[FunctionDebugInfoInterface]]:
+    def get_debug_info(self) -> list[FunctionDebugInfoInterface] | None:
         # Support legacy uncompressed debug info
         if self.debug_info is not None:
             return self.debug_info

classiq/interface/generator/range_types.py

@@ -1,5 +1,5 @@
 import math
-from typing import Generic, Optional, TypeVar
+from typing import Generic, TypeVar
 
 import pydantic
 from pydantic import BaseModel, ConfigDict
@@ -17,8 +17,8 @@ DEF_RTOL: float = 1e-05
 
 
 class Range(BaseModel, Generic[RangeType]):
-    lower_bound: Optional[RangeType] = None
-    upper_bound: Optional[RangeType] = None
+    lower_bound: RangeType | None = None
+    upper_bound: RangeType | None = None
     model_config = ConfigDict(frozen=True)
 
     @pydantic.model_validator(mode="after")

classiq/interface/generator/slice_parsing_utils.py

@@ -1,6 +1,5 @@
 import re
 from re import Match
-from typing import Optional
 
 from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.function_params import NAME_REGEX
@@ -17,8 +16,8 @@ def parse_io_slicing(io_str: str) -> tuple[str, slice]:
     return name, get_slice(slicing)
 
 
-def separate_name_and_slice(io_str: str) -> tuple[str, Optional[str]]:
-    match: Optional[Match] = re.fullmatch(IO_REGEX, io_str)
+def separate_name_and_slice(io_str: str) -> tuple[str, str | None]:
+    match: Match | None = re.fullmatch(IO_REGEX, io_str)
     if match is None:
         raise AssertionError("Input/output name validation error")
     name, slicing = (match.groupdict().get(x) for x in [NAME, SLICING])
@@ -27,7 +26,7 @@ def separate_name_and_slice(io_str: str) -> tuple[str, Optional[str]]:
     return name, slicing
 
 
-def get_slice(slicing: Optional[str]) -> slice:
+def get_slice(slicing: str | None) -> slice:
     if slicing is None:
         return slice(None)
 
@@ -61,5 +60,5 @@ def get_slice(slicing: Optional[str]) -> slice:
         raise AssertionError("Input/output slicing validation error")
 
 
-def _int_or_none(v: str) -> Optional[int]:
+def _int_or_none(v: str) -> int | None:
     return int(v) if v else None

classiq/interface/generator/standard_gates/standard_gates.py

@@ -1,4 +1,4 @@
-from typing import Any, Literal, Optional
+from typing import Any, Literal
 
 import pydantic
 
@@ -38,9 +38,7 @@ class _StandardGate(FunctionParams, metaclass=MyMetaAngledClassModel):  # type:
     def num_target_qubits(self) -> int:
         return self._num_target_qubits
 
-    def __init_subclass__(
-        cls, angles: Optional[list[str]] = None, **kwargs: Any
-    ) -> None:
+    def __init_subclass__(cls, angles: list[str] | None = None, **kwargs: Any) -> None:
         super().__init_subclass__(**kwargs)
 
 

classiq/interface/generator/state_preparation/state_preparation.py

@@ -1,5 +1,3 @@
-from typing import Optional, Union
-
 import numpy as np
 import pydantic
 from pydantic_core.core_schema import ValidationInfo
@@ -26,12 +24,12 @@ from classiq.interface.generator.validations.validator_functions import (
 
 
 class StatePreparation(StatePreparationABC):
-    amplitudes: Optional[Amplitudes] = pydantic.Field(
+    amplitudes: Amplitudes | None = pydantic.Field(
         description="vector of probabilities",
         default=None,
         validate_default=True,
     )
-    probabilities: Optional[Probabilities] = pydantic.Field(
+    probabilities: Probabilities | None = pydantic.Field(
         description="vector of amplitudes",
         default=None,
         validate_default=True,
@@ -46,8 +44,8 @@ class StatePreparation(StatePreparationABC):
     @pydantic.field_validator("amplitudes", mode="before")
     @classmethod
     def _initialize_amplitudes(
-        cls, amplitudes: Optional[FlexibleAmplitudes]
-    ) -> Optional[Amplitudes]:
+        cls, amplitudes: FlexibleAmplitudes | None
+    ) -> Amplitudes | None:
         if amplitudes is None:
             return None
         amplitudes = np.array(amplitudes).squeeze()
@@ -61,8 +59,8 @@ class StatePreparation(StatePreparationABC):
     @pydantic.field_validator("probabilities", mode="before")
     @classmethod
     def _initialize_probabilities(
-        cls, probabilities: Optional[FlexibleProbabilities]
-    ) -> Optional[Union[PMF, GaussianMixture, dict]]:
+        cls, probabilities: FlexibleProbabilities | None
+    ) -> PMF | GaussianMixture | dict | None:
         if probabilities is None:
             return None
         if isinstance(probabilities, Probabilities.__args__):  # type: ignore[attr-defined]

classiq/interface/generator/synthesis_execution_parameter.py

@@ -1,6 +1,4 @@
-from typing import Union
-
-from typing_extensions import TypeAlias
+from typing import TypeAlias, Union
 
 from classiq.interface.backend.pydantic_backend import PydanticExecutionParameter
 

classiq/interface/generator/synthesis_metadata/synthesis_execution_data.py

@@ -1,5 +1,4 @@
 from itertools import chain
-from typing import Optional
 
 import pydantic
 import sympy
@@ -10,10 +9,10 @@ from classiq.interface.generator.parameters import ParameterType
 
 
 class FunctionExecutionData(pydantic.BaseModel):
-    power_parameter: Optional[ParameterType] = pydantic.Field(default=None)
+    power_parameter: ParameterType | None = pydantic.Field(default=None)
 
     @property
-    def power_vars(self) -> Optional[list[str]]:
+    def power_vars(self) -> list[str] | None:
         if self.power_parameter is None:
             return None
         return list(map(str, sympy.sympify(self.power_parameter).free_symbols))

classiq/interface/generator/transpiler_basis_gates.py

@@ -1,6 +1,4 @@
-from typing import TYPE_CHECKING, Optional
-
-from typing_extensions import TypeAlias
+from typing import TYPE_CHECKING, TypeAlias
 
 from classiq.interface.enum_utils import StrEnum
 
@@ -80,7 +78,7 @@ ALL_GATES_DICT = {gate.upper(): gate.lower() for gate in sorted(ALL_GATES)}
 
 class LowerValsEnum(StrEnum):
     @classmethod
-    def _missing_(cls, value: Optional[str]) -> Optional[str]:  # type: ignore[override]
+    def _missing_(cls, value: str | None) -> str | None:  # type: ignore[override]
         if not isinstance(value, str):
             return None
         lower = value.lower()

classiq/interface/generator/types/builtin_enum_declarations.py

@@ -4,139 +4,6 @@
 from enum import IntEnum
 
 
-class Element(IntEnum):
-    H = 0
-    He = 1
-    Li = 2
-    Be = 3
-    B = 4
-    C = 5
-    N = 6
-    O = 7  # noqa: E741
-    F = 8
-    Ne = 9
-    Na = 10
-    Mg = 11
-    Al = 12
-    Si = 13
-    P = 14
-    S = 15
-    Cl = 16
-    Ar = 17
-    K = 18
-    Ca = 19
-    Sc = 20
-    Ti = 21
-    V = 22
-    Cr = 23
-    Mn = 24
-    Fe = 25
-    Co = 26
-    Ni = 27
-    Cu = 28
-    Zn = 29
-    Ga = 30
-    Ge = 31
-    As = 32
-    Se = 33
-    Br = 34
-    Kr = 35
-    Rb = 36
-    Sr = 37
-    Y = 38
-    Zr = 39
-    Nb = 40
-    Mo = 41
-    Tc = 42
-    Ru = 43
-    Rh = 44
-    Pd = 45
-    Ag = 46
-    Cd = 47
-    In = 48
-    Sn = 49
-    Sb = 50
-    Te = 51
-    I = 52  # noqa: E741
-    Xe = 53
-    Cs = 54
-    Ba = 55
-    La = 56
-    Ce = 57
-    Pr = 58
-    Nd = 59
-    Pm = 60
-    Sm = 61
-    Eu = 62
-    Gd = 63
-    Tb = 64
-    Dy = 65
-    Ho = 66
-    Er = 67
-    Tm = 68
-    Yb = 69
-    Lu = 70
-    Hf = 71
-    Ta = 72
-    W = 73
-    Re = 74
-    Os = 75
-    Ir = 76
-    Pt = 77
-    Au = 78
-    Hg = 79
-    Tl = 80
-    Pb = 81
-    Bi = 82
-    Po = 83
-    At = 84
-    Rn = 85
-    Fr = 86
-    Ra = 87
-    Ac = 88
-    Th = 89
-    Pa = 90
-    U = 91
-    Np = 92
-    Pu = 93
-    Am = 94
-    Cm = 95
-    Bk = 96
-    Cf = 97
-    Es = 98
-    Fm = 99
-    Md = 100
-    No = 101
-    Lr = 102
-    Rf = 103
-    Db = 104
-    Sg = 105
-    Bh = 106
-    Hs = 107
-    Mt = 108
-    Ds = 109
-    Rg = 110
-    Cn = 111
-    Nh = 112
-    Fl = 113
-    Mc = 114
-    Lv = 115
-    Ts = 116
-    Og = 117
-
-
-class FermionMapping(IntEnum):
-    JORDAN_WIGNER = 0
-    PARITY = 1
-    BRAVYI_KITAEV = 2
-    FAST_BRAVYI_KITAEV = 3
-
-
-class LadderOperator(IntEnum):
-    PLUS = 0
-    MINUS = 1
-
-
 class Optimizer(IntEnum):
     COBYLA = 1
     SPSA = 2
@@ -162,9 +29,6 @@ class QSVMFeatureMapEntanglement(IntEnum):
 
 
 __all__ = [
-    "Element",
-    "FermionMapping",
-    "LadderOperator",
     "Optimizer",
     "Pauli",
     "QSVMFeatureMapEntanglement",