classiq 0.37.1__py3-none-any.whl → 0.65.3__py3-none-any.whl

classiq/interface/backend/ionq/ionq_quantum_program.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, List, Optional
+from typing import TYPE_CHECKING, Annotated, Optional
 
-import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, ConfigDict, Field
 
 # This file is based on autogenerated code from: https://static.ionq.co/schemas/circuit-v0.json using
 # https://pydantic-docs.helpmanual.io/datamodel_code_generator/
@@ -12,35 +11,28 @@ from pydantic import BaseModel
 if TYPE_CHECKING:
     PydanticGateName = str
 else:
-    PydanticGateName = pydantic.constr(
-        regex=r"^\w+$",
-        min_length=1,
-    )
+    PydanticGateName = Annotated[
+        str,
+        Field(
+            pattern=r"^\w+$",
+            min_length=1,
+        ),
+    ]
 
 
 class Gate(BaseModel):
     gate: PydanticGateName
     target: Optional[int] = None
     control: Optional[int] = None
-    targets: Optional[List[int]] = None
-    controls: Optional[List[int]] = None
-
-    # Ionq changes format sometimes.
-    #   One example is that `IonqQauntumCircuit` got a field name "gateset" with the value "qis"
-    #   Another is that `Gate` got a field named "rotation"
-    class Config:
-        extra = pydantic.Extra.allow
+    targets: Optional[list[int]] = None
+    controls: Optional[list[int]] = None
+    model_config = ConfigDict(extra="allow")
 
 
 class IonqQuantumCircuit(BaseModel):
     qubits: int
-    circuit: List[Gate]
-
-    # Ionq changes format sometimes.
-    #   One example is that `IonqQauntumCircuit` got a field name "gateset" with the value "qis"
-    #   Another is that `Gate` got a field named "rotation"
-    class Config:
-        extra = pydantic.Extra.allow
+    circuit: list[Gate]
+    model_config = ConfigDict(extra="allow")
 
     @classmethod
     def from_string(cls, code: str) -> IonqQuantumCircuit:
@@ -48,4 +40,4 @@ class IonqQuantumCircuit(BaseModel):
         commentless_code = "\n".join(
             line for line in code_lines if not line.startswith("//")
         )
-        return cls.parse_raw(commentless_code)
+        return cls.model_validate_json(commentless_code)

classiq/interface/backend/pydantic_backend.py

@@ -1,20 +1,18 @@
-from datetime import timedelta
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Annotated
 
-import pydantic
+from pydantic import Field, StrictStr, constr
 
 AZURE_QUANTUM_RESOURCE_ID_REGEX = r"^/subscriptions/([a-fA-F0-9-]*)/resourceGroups/([^\s/]*)/providers/Microsoft\.Quantum/Workspaces/([^\s/]*)$"
 
 _IONQ_API_KEY_LENGTH: int = 32
 _ALICE_BOB_API_KEY_LENGTH: int = 72
 INVALID_API_KEY: str = _IONQ_API_KEY_LENGTH * "a"
-INVALID_API_KEY_ALICE_BOB: str = _ALICE_BOB_API_KEY_LENGTH * "a"
 INVALID_EMAIL_OQC: str = "aa@aa.aa"
-INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"
-MAX_EXECUTION_TIMEOUT_SECONDS = timedelta(hours=4).total_seconds()
+INVALID_PASSWORD_OQC: str = "Aa1!Aa1!"  # noqa: S105
+
+EXECUTION_PARAMETER_PATTERN = "[_a-z][_a-z0-9]*"
 
 if TYPE_CHECKING:
-    PydanticExecutionTimeout = int
     PydanticAwsRoleArn = str
     PydanticS3BucketKey = str
     PydanticS3BucketName = str
@@ -26,24 +24,31 @@ if TYPE_CHECKING:
 else:
     # TODO Simplify regular expressions in this file
 
-    PydanticAwsRoleArn = pydantic.constr(
-        strip_whitespace=True,
-    )
-
-    PydanticS3BucketKey = pydantic.constr(strip_whitespace=True, min_length=1)
+    PydanticAwsRoleArn = Annotated[
+        StrictStr,
+        constr(
+            strip_whitespace=True,
+        ),
+    ]
 
-    PydanticAzureResourceIDType = pydantic.constr(regex=AZURE_QUANTUM_RESOURCE_ID_REGEX)
+    PydanticS3BucketKey = Annotated[
+        StrictStr, constr(strip_whitespace=True, min_length=1)
+    ]
 
-    PydanticIonQApiKeyType = pydantic.constr(
-        regex=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}"
-    )
+    PydanticAzureResourceIDType = Annotated[
+        str, Field(pattern=AZURE_QUANTUM_RESOURCE_ID_REGEX)
+    ]
 
-    PydanticAliceBobApiKeyType = pydantic.constr(
-        regex=f"[A-Za-z0-9]{{{_ALICE_BOB_API_KEY_LENGTH}}}"
-    )
+    PydanticIonQApiKeyType = Annotated[
+        str, Field(pattern=f"[A-Za-z0-9]{{{_IONQ_API_KEY_LENGTH}}}")
+    ]
 
-    PydanticExecutionTimeout = pydantic.conint(gt=0, le=MAX_EXECUTION_TIMEOUT_SECONDS)
+    PydanticAliceBobApiKeyType = Annotated[
+        StrictStr, constr(min_length=1, strip_whitespace=True)
+    ]
 
-    PydanticArgumentNameType = pydantic.constr(regex="[_a-zA-Z][_a-zA-Z0-9]*")
+    PydanticArgumentNameType = Annotated[str, Field(pattern="[_a-zA-Z][_a-zA-Z0-9]*")]
 
-    PydanticExecutionParameter = pydantic.constr(regex="[_a-z][_a-z0-9]*")
+    PydanticExecutionParameter = Annotated[
+        str, Field(pattern=EXECUTION_PARAMETER_PATTERN)
+    ]

classiq/interface/backend/quantum_backend_providers.py

@@ -1,6 +1,6 @@
 from typing import Literal, Union
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class AnalyzerProviderVendor(StrEnum):
@@ -18,6 +18,9 @@ class ProviderVendor(StrEnum):
     GOOGLE = "Google"
     ALICE_AND_BOB = "Alice & Bob"
     OQC = "OQC"
+    INTEL = "Intel"
+    AQT = "AQT"
+    IQCC = "IQCC"
 
 
 class ProviderTypeVendor:
@@ -29,23 +32,41 @@ class ProviderTypeVendor:
     GOOGLE = Literal[ProviderVendor.GOOGLE]
     ALICE_BOB = Literal[ProviderVendor.ALICE_AND_BOB]
     OQC = Literal[ProviderVendor.OQC]
+    INTEL = Literal[ProviderVendor.INTEL]
+    AQT = Literal[ProviderVendor.AQT]
+    IQCC = Literal[ProviderVendor.IQCC]
 
 
-class ClassiqAerBackendNames(StrEnum):
-    AER_SIMULATOR = "aer_simulator"
-    AER_SIMULATOR_STATEVECTOR = "aer_simulator_statevector"
-    AER_SIMULATOR_DENSITY_MATRIX = "aer_simulator_density_matrix"
-    AER_SIMULATOR_MATRIX_PRODUCT_STATE = "aer_simulator_matrix_product_state"
+class ClassiqSimulatorBackendNames(StrEnum):
+    """
+
+    The simulator backends available in the Classiq provider.
+
+    """
+
+    SIMULATOR = "simulator"
+    SIMULATOR_STATEVECTOR = "simulator_statevector"
+    SIMULATOR_DENSITY_MATRIX = "simulator_density_matrix"
+    SIMULATOR_MATRIX_PRODUCT_STATE = "simulator_matrix_product_state"
 
 
 class IonqBackendNames(StrEnum):
+    """
+    IonQ backend names which Classiq Supports running on.
+    """
+
     SIMULATOR = "simulator"
     HARMONY = "qpu.harmony"
-    ARIA = "qpu.aria-1"
-    S11 = "qpu.s11"
+    ARIA_1 = "qpu.aria-1"
+    ARIA_2 = "qpu.aria-2"
+    FORTE_1 = "qpu.forte-1"
 
 
 class AzureQuantumBackendNames(StrEnum):
+    """
+    AzureQuantum backend names which Classiq Supports running on.
+    """
+
     IONQ_ARIA_1 = "ionq.qpu.aria-1"
     IONQ_ARIA_2 = "ionq.qpu.aria-2"
     IONQ_QPU = "ionq.qpu"
@@ -53,9 +74,9 @@ class AzureQuantumBackendNames(StrEnum):
     IONQ_SIMULATOR = "ionq.simulator"
     MICROSOFT_ESTIMATOR = "microsoft.estimator"
     MICROSOFT_FULLSTATE_SIMULATOR = "microsoft.simulator.fullstate"
-    RIGETTI_ASPEN3 = "rigetti.qpu.aspen-m-3"
     RIGETTI_SIMULATOR = "rigetti.sim.qvm"
     RIGETTI_ANKAA2 = "rigetti.qpu.ankaa-2"
+    RIGETTI_ANKAA9 = "rigetti.qpu.ankaa-9q-1"
     QCI_MACHINE1 = "qci.machine1"
     QCI_NOISY_SIMULATOR = "qci.simulator.noisy"
     QCI_SIMULATOR = "qci.simulator"
@@ -71,6 +92,10 @@ class AzureQuantumBackendNames(StrEnum):
 
 
 class AmazonBraketBackendNames(StrEnum):
+    """
+    Amazon Braket backend names which Classiq Supports running on.
+    """
+
     AMAZON_BRAKET_SV1 = "SV1"
     AMAZON_BRAKET_TN1 = "TN1"
     AMAZON_BRAKET_DM1 = "dm1"
@@ -87,6 +112,10 @@ class AmazonBraketBackendNames(StrEnum):
 #   # Using _normalize_backend_name from `ibm_hardware_graphs.py`
 #   the_devices = [_normalize_backend_name(str(backend)) for backend in backends_list]
 class IBMQHardwareNames(StrEnum):
+    """
+    IBM backend names which Classiq Supports running on.
+    """
+
     ALMADEN = "Almaden"
     ARMONK = "Armonk"
     ATHENS = "Athens"
@@ -137,24 +166,46 @@ class IBMQHardwareNames(StrEnum):
 
 
 class ClassiqNvidiaBackendNames(StrEnum):
-    SIMULATOR = "nvidia_state_vector_simulator"
+    """
+    Classiq's Nvidia simulator backend names.
+    """
+
+    SIMULATOR = "nvidia_simulator"
+    SIMULATOR_STATEVECTOR = "nvidia_simulator_statevector"
+
+
+class IntelBackendNames(StrEnum):
+    SIMULATOR = "intel_qsdk_simulator"
 
 
-AllClassiqBackendNames = Union[ClassiqAerBackendNames, ClassiqNvidiaBackendNames]
+AllClassiqBackendNames = Union[ClassiqSimulatorBackendNames, ClassiqNvidiaBackendNames]
 
 
 class GoogleNvidiaBackendNames(StrEnum):
+    """
+    Google backend names which Classiq Supports running on.
+    """
+
     CUQUANTUM = "cuquantum"
+    CUQUANTUM_STATEVECTOR = "cuquantum_statevector"
 
 
 class AliceBobBackendNames(StrEnum):
-    PERFECT_QUBITS = "EMU:20Q:PERFECT_QUBITS"
-    LOGICAL_TARGET = "EMU:40Q:LOGICAL_TARGET"
-    LOGICAL_EARLY = "EMU:15Q:LOGICAL_EARLY"
-    TRANSMONS = "EMU:7Q:TRANSMONS"
+    """
+    Alice & Bob backend names which Classiq Supports running on.
+    """
+
+    PERFECT_QUBITS = "PERFECT_QUBITS"
+    LOGICAL_TARGET = "LOGICAL_TARGET"
+    LOGICAL_EARLY = "LOGICAL_EARLY"
+    TRANSMONS = "TRANSMONS"
 
 
 class OQCBackendNames(StrEnum):
+    """
+    OQC backend names which Classiq Supports running on.
+    """
+
     LUCY = "Lucy"
 
 
@@ -165,7 +216,8 @@ EXACT_SIMULATORS = {
     AmazonBraketBackendNames.AMAZON_BRAKET_SV1,
     AmazonBraketBackendNames.AMAZON_BRAKET_TN1,
     AmazonBraketBackendNames.AMAZON_BRAKET_DM1,
-    *ClassiqAerBackendNames,
+    *ClassiqSimulatorBackendNames,
+    *IntelBackendNames,
     *ClassiqNvidiaBackendNames,
 }
 
@@ -176,6 +228,7 @@ AllBackendsNameByVendor = Union[
     AzureQuantumBackendNames,
     AmazonBraketBackendNames,
     IonqBackendNames,
+    IntelBackendNames,
     ClassiqNvidiaBackendNames,
     AliceBobBackendNames,
     OQCBackendNames,
@@ -187,6 +240,7 @@ AllBackendsNameEnums = [
     AmazonBraketBackendNames,
     IonqBackendNames,
     AliceBobBackendNames,
+    IntelBackendNames,
     ClassiqNvidiaBackendNames,
     OQCBackendNames,
 ]

classiq/interface/chemistry/fermionic_operator.py

@@ -1,17 +1,19 @@
 from __future__ import annotations
 
 import itertools
-from typing import Set, Tuple, Union
+from typing import Union
 
 import numpy as np
 import pydantic
+from pydantic import ConfigDict
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-LadderOperator = Tuple[str, int]
-FermionicOperatorTuple = Tuple["FermionicOperator", float]
+LadderOperator = tuple[str, int]
+FermionicOperatorTuple = tuple["FermionicOperator", float]
 
 _SUBSCRIPT_UNICODE_CHARS = {
     "0": "\u2080",
@@ -37,7 +39,10 @@ class FermionicOperator(HashablePydanticBaseModel):
     """
 
     op_list: list = pydantic.Field(
-        description="A list of tuples each containing an index and a character; for example [('+', 0), ('-', 1)].",
+        description=(
+            "A list of tuples each containing an index and a character; for "
+            "example [('+', 0), ('-', 1)]."
+        ),
     )
 
     @staticmethod
@@ -46,32 +51,40 @@ class FermionicOperator(HashablePydanticBaseModel):
             try:  # type: ignore[unreachable] # it is reachable...
                 op = tuple(op)
             except Exception as exc:
-                raise ValueError("Ladder operator should be a tuple.") from exc
+                raise ClassiqValueError("Ladder operator should be a tuple.") from exc
         if len(op) != 2:
-            raise ValueError(
-                "Ladder operator tuple should be of length two; for example (1, '+')."
+            raise ClassiqValueError(
+                "Ladder operator tuple should be of length two; for example ('+', 1)."
             )
 
-        if op[0] not in ("+", "-"):
-            raise ValueError(
-                "The first term in a ladder operator tuple indicates if its a raising ('+')"
-                f" or lowering ('-') operator. Allowed input is: '+' or '-', received {op[0]}"
+        op_symbol = op[0]
+        if op_symbol == "LadderOperator.PLUS":
+            op_symbol = "+"
+        elif op_symbol == "LadderOperator.MINUS":
+            op_symbol = "-"
+        if op_symbol not in ("+", "-"):
+            raise ClassiqValueError(
+                f"The first term in a ladder operator tuple indicates if its a raising "
+                f"(LadderOperator.PLUS / '+') or lowering (LadderOperator.MINUS / '-') "
+                f"operator. Received {op_symbol}"
             )
-        if not isinstance(op[1], int):
-            raise ValueError(
+        op_index = op[1]
+        if not isinstance(op_index, int):
+            raise ClassiqValueError(
                 "The second term in a ladder operator tuple indicates its index and should be of type int"
             )
 
-        return op  # type: ignore[return-value] # mypy thinks that it is `Tuple[Any, ...]`, though the asserts here tell otherwise..
+        return (op_symbol, op_index)
 
-    @pydantic.validator("op_list")
+    @pydantic.field_validator("op_list")
+    @classmethod
     def _validate_op_list(cls, op_list: list) -> list:
         return list(map(cls._validate_single_op, op_list))
 
     def __mul__(self, coeff: Union[float, int]) -> SummedFermionicOperator:
         if isinstance(coeff, (float, int)):
             return SummedFermionicOperator(op_list=[(self, float(coeff))])
-        raise ValueError(
+        raise ClassiqValueError(
             "The coefficient multiplying Fermionic Operator should be of type float"
         )
 
@@ -84,12 +97,11 @@ class FermionicOperator(HashablePydanticBaseModel):
             return SummedFermionicOperator(op_list=[(self, 1.0)] + other.op_list)
         elif isinstance(other, FermionicOperator):
             return SummedFermionicOperator(op_list=[(self, 1.0)] + [(other, 1.0)])
-        raise ValueError(
+        raise ClassiqValueError(
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @staticmethod
     def _to_ladder_op(char: str) -> str:
@@ -106,7 +118,7 @@ class FermionicOperator(HashablePydanticBaseModel):
         )
 
     @property
-    def all_indices(self) -> Set[int]:
+    def all_indices(self) -> set[int]:
         return {op[1] for op in self.op_list}
 
 
@@ -124,9 +136,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
     op_list: list = pydantic.Field(
         description="A list of tuples each containing a FermionicOperator and a coefficient.",
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @staticmethod
     def _validate_single_op(op: tuple) -> FermionicOperatorTuple:
@@ -135,27 +145,28 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
             try:  # type: ignore[unreachable] # it is reachable...
                 op = tuple(op)
             except Exception as exc:
-                raise ValueError("Operator should be a tuple.") from exc
+                raise ClassiqValueError("Operator should be a tuple.") from exc
         if len(op) != 2:
-            raise ValueError("Operator tuple should be of length two.")
+            raise ClassiqValueError("Operator tuple should be of length two.")
 
         # is it FermionicOperator - if not, convert to FermionicOperator
-        if type(op[0]) is not FermionicOperator:
+        if not isinstance(op[0], FermionicOperator):
             try:
                 op = (FermionicOperator(**op[0]), op[1])
             except Exception as exc:
-                raise ValueError(
+                raise ClassiqValueError(
                     "The first term in the operator tuple should be an instance of the FermionicOperator class"
                 ) from exc
 
-        if type(op[1]) is not float:
-            raise ValueError(
+        if not isinstance(op[1], float):
+            raise ClassiqValueError(
                 "The second term in the operator tuple indicates its coefficient and should be of type float"
             )
 
         return op  # type: ignore[return-value] # mypy thinks that it is `Tuple[Any, ...]`, though the asserts here tell otherwise..
 
-    @pydantic.validator("op_list")
+    @pydantic.field_validator("op_list")
+    @classmethod
     def _validate_op_list(cls, op_list: list) -> list:
         return list(map(cls._validate_single_op, op_list))
 
@@ -166,7 +177,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
             return SummedFermionicOperator(op_list=self.op_list + other.op_list)
         elif isinstance(other, FermionicOperator):
             return SummedFermionicOperator(op_list=self.op_list + [(other, 1.0)])
-        raise ValueError(
+        raise ClassiqValueError(
             "FermionicOperator can be summed together only with type FermionicOperator or SummedFermionicOperator"
         )
 
@@ -184,7 +195,7 @@ class SummedFermionicOperator(HashablePydanticBaseModel):
         return True
 
     @property
-    def _all_indices(self) -> Set[int]:
+    def _all_indices(self) -> set[int]:
         return set(
             itertools.chain.from_iterable(op.all_indices for op, _ in self.op_list)
         )

classiq/interface/chemistry/ground_state_problem.py

@@ -1,15 +1,17 @@
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Annotated, Literal, Optional, Union, cast
 
 import pydantic
+from pydantic import ConfigDict, Field
+from pydantic_core.core_schema import ValidationInfo
 
 from classiq.interface.chemistry.fermionic_operator import SummedFermionicOperator
 from classiq.interface.chemistry.molecule import Molecule
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
 )
 
-from classiq._internals.enum_utils import StrEnum
-
 """
 The correct type hint is:
 NumSpinUpParticles = pydantic.NonNegativeInt
@@ -26,7 +28,7 @@ And use a list, and manually check its length
 """
 NumSpinUpParticles = pydantic.NonNegativeInt
 NumSpinDownParticles = pydantic.NonNegativeInt
-NumParticles = Tuple[NumSpinUpParticles, NumSpinDownParticles]
+NumParticles = tuple[NumSpinUpParticles, NumSpinDownParticles]
 
 
 class FermionMapping(StrEnum):
@@ -37,6 +39,8 @@ class FermionMapping(StrEnum):
 
 
 class GroundStateProblem(HashablePydanticBaseModel):
+    kind: str
+
     mapping: FermionMapping = pydantic.Field(
         default=FermionMapping.JORDAN_WIGNER,
         description="Fermionic mapping type",
@@ -48,53 +52,67 @@ class GroundStateProblem(HashablePydanticBaseModel):
     )
     num_qubits: Optional[int] = pydantic.Field(default=None)
 
-    @pydantic.validator("z2_symmetries")
-    def _validate_z2_symmetries(
-        cls, z2_symmetries: bool, values: Dict[str, Any]
-    ) -> bool:
-        if z2_symmetries and values.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV:
-            raise ValueError(
+    @pydantic.field_validator("z2_symmetries")
+    @classmethod
+    def _validate_z2_symmetries(cls, z2_symmetries: bool, info: ValidationInfo) -> bool:
+        if (
+            z2_symmetries
+            and info.data.get("mapping") == FermionMapping.FAST_BRAVYI_KITAEV
+        ):
+            raise ClassiqValueError(
                 "z2 symmetries reduction can not be used for fast_bravyi_kitaev mapping"
             )
         return z2_symmetries
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class MoleculeProblem(GroundStateProblem):
+    kind: Literal["molecule"] = pydantic.Field(default="molecule")
+
     molecule: Molecule
     basis: str = pydantic.Field(default="sto3g", description="Molecular basis set")
     freeze_core: bool = pydantic.Field(default=False)
-    remove_orbitals: List[int] = pydantic.Field(
+    remove_orbitals: list[int] = pydantic.Field(
         default_factory=list, description="list of orbitals to remove"
     )
 
 
 class HamiltonianProblem(GroundStateProblem):
+    kind: Literal["hamiltonian"] = pydantic.Field(default="hamiltonian")
+
     hamiltonian: SummedFermionicOperator = pydantic.Field(
         description="Hamiltonian as a fermionic operator"
     )
-    num_particles: List[pydantic.PositiveInt] = pydantic.Field(
+    num_particles: list[pydantic.PositiveInt] = pydantic.Field(
         description="Tuple containing the numbers of alpha particles and beta particles"
     )
 
-    @pydantic.validator("num_particles")
-    def _validate_num_particles(cls, num_particles: List[int]) -> List[int]:
-        assert isinstance(num_particles, list)
+    @pydantic.field_validator("num_particles", mode="before")
+    @classmethod
+    def _validate_num_particles(
+        cls,
+        num_particles: Union[
+            list[Union[int, float]], tuple[Union[int, float], Union[int, float]]
+        ],
+    ) -> list[int]:
+        assert isinstance(num_particles, (list, tuple))
         assert len(num_particles) == 2
 
-        # This probably will never happen, since pydantic automatically converts
-        #   floats to ints
-        assert isinstance(num_particles[0], int)
-        assert num_particles[0] >= 1
+        num_particles = [int(x) for x in num_particles]
 
-        assert isinstance(num_particles[1], int)
+        assert num_particles[0] >= 1
         assert num_particles[1] >= 1
 
-        return num_particles
+        return cast(list[int], num_particles)
 
 
 CHEMISTRY_PROBLEMS = (MoleculeProblem, HamiltonianProblem)
-CHEMISTRY_PROBLEMS_TYPE = Union[MoleculeProblem, HamiltonianProblem]
+CHEMISTRY_PROBLEMS_TYPE = Annotated[
+    Union[MoleculeProblem, HamiltonianProblem],
+    Field(
+        discriminator="kind",
+        description="Ground state problem object describing the system.",
+    ),
+]
 CHEMISTRY_ANSATZ_NAMES = ["hw_efficient", "ucc", "hva"]