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

classiq/interface/finance/function_input.py

@@ -1,8 +1,14 @@
-from typing import Any, Dict, Optional, Union
+from typing import Any, Optional, Union
 
 import pydantic
+from pydantic import ConfigDict
+from pydantic_core.core_schema import ValidationInfo
 
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.expressions.enums.finance_functions import (
+    get_finance_function_dict,
+)
+from classiq.interface.generator.types.builtin_enum_declarations import (
     FinanceFunctionType,
 )
 from classiq.interface.helpers.custom_pydantic_types import (
@@ -16,14 +22,13 @@ class FunctionCondition(pydantic.BaseModel):
         default=False,
         description="When true, function is set when input is larger to threshold and otherwise 0. Default is False.",
     )
-
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
 
 class FinanceFunctionInput(pydantic.BaseModel):
-    f: Union[int, str, FinanceFunctionType] = pydantic.Field(
-        description="A callable function to solve the model"
+    f: "FinanceFunctionType" = pydantic.Field(
+        description="An enumeration of the wanted financial function: VaR, expected "
+        "shortfall, European call options or x^2"
     )
     variable: str = pydantic.Field(
         default="x", description="Variable/s of the function"
@@ -45,35 +50,53 @@ class FinanceFunctionInput(pydantic.BaseModel):
         description="The required probability on the tail of the distribution (1 - percentile)",
     )
 
-    @pydantic.validator("use_chebyshev_polynomial_approximation")
+    @pydantic.model_validator(mode="before")
+    @classmethod
+    def _convert_f_if_str(cls, values: Any, info: ValidationInfo) -> dict[str, Any]:
+        if isinstance(values, dict):
+            f = values.get("f")
+        elif isinstance(values, FinanceFunctionInput):
+            f = values.f
+            values = values.model_dump()
+        else:
+            f = info.data.get("f")
+        if isinstance(f, str) and f in get_finance_function_dict():
+            values["f"] = get_finance_function_dict()[f]
+        return values
+
+    @pydantic.field_validator("use_chebyshev_polynomial_approximation", mode="before")
+    @classmethod
     def _validate_polynomial_flag(
-        cls, use_chebyshev_flag: bool, values: Dict[str, Any]
+        cls, use_chebyshev_flag: bool, info: ValidationInfo
     ) -> bool:
-        if use_chebyshev_flag ^ (values.get("polynomial_degree") is None):
+        if use_chebyshev_flag ^ (info.data.get("polynomial_degree") is None):
             return use_chebyshev_flag
-        raise ValueError(
+        raise ClassiqValueError(
             "Degree must be positive and use_chebyshev_polynomial_approximation set to True"
         )
 
-    @pydantic.validator("f")
+    @pydantic.field_validator("f", mode="before")
+    @classmethod
     def _validate_finance_function(
-        cls, f: Union[int, str, FinanceFunctionType]
+        cls, f: Union[int, str, "FinanceFunctionType"]
     ) -> FinanceFunctionType:
         if isinstance(f, FinanceFunctionType):
             return f
         if isinstance(f, int):
             return FinanceFunctionType(f)
-        return FinanceFunctionType.from_string(f)
+        return get_finance_function_dict()[f]
 
-    @pydantic.validator("tail_probability", always=True)
+    @pydantic.field_validator("tail_probability", mode="before")
+    @classmethod
     def _validate_tail_probability_assignment_for_shortfall(
         cls,
         tail_probability: Optional[PydanticNonZeroProbabilityFloat],
-        values: Dict[str, Any],
+        info: ValidationInfo,
     ) -> Optional[PydanticNonZeroProbabilityFloat]:
-        if values.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
-            raise ValueError("Tail probability must be set for expected shortfall")
+        if info.data.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
+            raise ClassiqValueError(
+                "Tail probability must be set for expected shortfall"
+            )
         return tail_probability
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/finance/gaussian_model_input.py

@@ -1,5 +1,5 @@
 import math
-from typing import List, Optional, Tuple
+from typing import Literal, Optional
 
 import pydantic
 
@@ -8,6 +8,8 @@ from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityF
 
 
 class GaussianModelInput(FinanceModelInput):
+    kind: Literal["gaussian"] = pydantic.Field(default="gaussian")
+
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         description="The number of qubits represent"
         "the latent normal random variable Z (Resolution of "
@@ -16,15 +18,15 @@ class GaussianModelInput(FinanceModelInput):
     normal_max_value: float = pydantic.Field(
         description="Min/max value to truncate the " "latent normal random variable Z"
     )
-    default_probabilities: List[PydanticProbabilityFloat] = pydantic.Field(
+    default_probabilities: list[PydanticProbabilityFloat] = pydantic.Field(
         description="default probabilities for each asset"
     )
 
-    rhos: List[pydantic.PositiveFloat] = pydantic.Field(
+    rhos: list[pydantic.PositiveFloat] = pydantic.Field(
         description="Sensitivities of default probability of assets "
         "with respect to Z (1/sigma(Z))"
     )
-    loss: List[int] = pydantic.Field(
+    loss: list[int] = pydantic.Field(
         description="List of ints signifying loss per asset"
     )
     min_loss: Optional[int] = pydantic.Field(
@@ -36,7 +38,7 @@ class GaussianModelInput(FinanceModelInput):
         return len(self.rhos)
 
     @property
-    def distribution_range(self) -> Tuple[float, float]:
+    def distribution_range(self) -> tuple[float, float]:
         return 0, sum(self.loss)
 
     @property

classiq/interface/finance/log_normal_model_input.py

@@ -1,12 +1,15 @@
-from typing import Tuple
+from typing import Literal
 
 import numpy as np
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.finance.model_input import FinanceModelInput
 
 
 class LogNormalModelInput(FinanceModelInput):
+    kind: Literal["log_normal"] = pydantic.Field(default="log_normal")
+
     num_qubits: pydantic.PositiveInt = pydantic.Field(
         description="Number of qubits to represent the probability."
     )
@@ -18,7 +21,7 @@ class LogNormalModelInput(FinanceModelInput):
     )
 
     @property
-    def distribution_range(self) -> Tuple[float, float]:
+    def distribution_range(self) -> tuple[float, float]:
         mean = np.exp(self.mu + self.sigma**2 / 2)
         variance = (np.exp(self.sigma**2) - 1) * np.exp(2 * self.mu + self.sigma**2)
         stddev = np.sqrt(variance)
@@ -34,5 +37,4 @@ class LogNormalModelInput(FinanceModelInput):
     def num_output_qubits(self) -> int:
         return self.num_qubits
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)

classiq/interface/finance/model_input.py

@@ -1,5 +1,6 @@
 import abc
-from typing import Tuple
+
+from pydantic import ConfigDict
 
 from classiq.interface.helpers.hashable_pydantic_base_model import (
     HashablePydanticBaseModel,
@@ -7,14 +8,15 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 
 
 class FinanceModelInput(HashablePydanticBaseModel):
+    kind: str
+
     @property
     def num_output_qubits(self) -> int:
         return 0
 
-    class Config:
-        frozen = True
+    model_config = ConfigDict(frozen=True)
 
     @property
     @abc.abstractmethod
-    def distribution_range(self) -> Tuple[float, float]:
+    def distribution_range(self) -> tuple[float, float]:
         pass

classiq/interface/generator/adjacency.py

@@ -1,9 +1,7 @@
-from typing import List
-
 import numpy as np
 
 
-def get_rand_adjacency_matrix(num_vertices: int) -> List[List[bool]]:
+def get_rand_adjacency_matrix(num_vertices: int) -> list[list[bool]]:
     adjacency_matrix = np.random.choice([0, 1], size=(num_vertices, num_vertices))
     for i in range(num_vertices):
         for j in range(num_vertices):

classiq/interface/generator/amplitude_loading.py

@@ -1,14 +1,18 @@
 import re
-from typing import Any, Dict, get_args
+from typing import get_args
 
 import pydantic
 import sympy
+from typing_extensions import Self
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     validate_expression,
 )
 from classiq.interface.generator.arith.register_user_input import RegisterUserInput
 from classiq.interface.generator.expressions.expression_constants import (
+    BOOLEAN_LITERALS,
     FORBIDDEN_LITERALS,
     SUPPORTED_FUNC_NAMES,
     SUPPORTED_VAR_NAMES_REG,
@@ -19,8 +23,6 @@ from classiq.interface.generator.function_params import (
 )
 from classiq.interface.helpers.custom_pydantic_types import PydanticExpressionStr
 
-from classiq._internals.enum_utils import StrEnum
-
 AMPLITUDE_IO_NAME = "AMPLITUDE"
 TARGET_OUTPUT_NAME = "TARGET"
 
@@ -35,6 +37,12 @@ class AmplitudeLoading(FunctionParams):
     size: pydantic.PositiveInt = pydantic.Field(
         description="The number of qubits of the amplitude input."
     )
+    fraction_digits: pydantic.NonNegativeInt = pydantic.Field(
+        description="The number of fraction digits of the amplitude input."
+    )
+    is_signed: bool = pydantic.Field(
+        description="Whether the amplitude input has a sign qubit."
+    )
     expression: PydanticExpressionStr = pydantic.Field(
         description="The mathematical expression of the amplitude loading function."
     )
@@ -43,7 +51,8 @@ class AmplitudeLoading(FunctionParams):
         description="Implementation options.",
     )
 
-    @pydantic.validator("expression", pre=True)
+    @pydantic.field_validator("expression", mode="before")
+    @classmethod
     def validate_coefficient(cls, expression: str) -> str:
         if isinstance(expression, str):
             # We validate the given value is legal and does not contain code that will be executed in our BE.
@@ -58,22 +67,25 @@ class AmplitudeLoading(FunctionParams):
             return str(expression)
         return expression
 
-    @pydantic.root_validator()
-    def check_all_variable_are_defined(cls, values: Dict[str, Any]) -> Dict[str, Any]:
-        expression = values.get("expression", "")
+    @pydantic.model_validator(mode="after")
+    def check_all_variable_are_defined(self) -> Self:
+        expression = self.expression or ""
         literals = set(re.findall(SUPPORTED_VAR_NAMES_REG, expression))
 
-        not_allowed = literals.intersection(FORBIDDEN_LITERALS)
-        variables = literals.difference(SUPPORTED_FUNC_NAMES)
+        not_allowed = literals.intersection(FORBIDDEN_LITERALS) - BOOLEAN_LITERALS
+        variables = literals.difference(SUPPORTED_FUNC_NAMES) - BOOLEAN_LITERALS
         if not_allowed:
-            raise ValueError(f"The following names: {not_allowed} are not allowed")
+            raise ClassiqValueError(
+                f"The following names: {not_allowed} are not allowed"
+            )
 
         if len(variables) != 1:
-            raise ValueError(f"{variables} must contain exactly single variable")
-        return values
+            raise ClassiqValueError(f"{variables} must contain exactly single variable")
+        return self
 
     def _create_ios(self) -> None:
         self._inputs = {
+            TARGET_OUTPUT_NAME: RegisterUserInput(name=TARGET_OUTPUT_NAME, size=1),
             AMPLITUDE_IO_NAME: RegisterUserInput(
                 name=AMPLITUDE_IO_NAME, size=self.size
             ),
@@ -82,9 +94,10 @@ class AmplitudeLoading(FunctionParams):
             TARGET_OUTPUT_NAME: RegisterUserInput(name=TARGET_OUTPUT_NAME, size=1),
             **self._inputs,
         }
-        self._create_zero_input_registers({TARGET_OUTPUT_NAME: 1})
 
     @property
     def variable(self) -> str:
-        literals = set(re.findall(SUPPORTED_VAR_NAMES_REG, self.expression))
+        literals = (
+            set(re.findall(SUPPORTED_VAR_NAMES_REG, self.expression)) - BOOLEAN_LITERALS
+        )
         return list(literals.difference(SUPPORTED_FUNC_NAMES))[0]

classiq/interface/generator/ansatz_library.py

@@ -1,8 +1,8 @@
-from typing import Dict, List, Optional, Union
+from typing import Optional, Union
 
 from pydantic import BaseModel
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class RotationBlocksType(StrEnum):
@@ -42,7 +42,7 @@ class EntanglingLayersArgs(CustomAnsatzArgs):
 
 class RandomArgs(CustomAnsatzArgs):
     gate_count: int = 100
-    gate_probabilities: Dict[str, float] = {"cx": 0.5, "u": 0.5}
+    gate_probabilities: dict[str, float] = {"cx": 0.5, "u": 0.5}
     random_seed: Optional[int] = None
 
 
@@ -52,11 +52,11 @@ class RandomTwoQubitGatesArgs(CustomAnsatzArgs):
 
 
 class TwoLocalArgs(CustomAnsatzArgs):
-    rotation_blocks: Optional[Union[RotationBlocksType, List[RotationBlocksType]]] = (
+    rotation_blocks: Optional[Union[RotationBlocksType, list[RotationBlocksType]]] = (
         RotationBlocksType.ry
     )
     entanglement_blocks: Optional[
-        Union[EntanglementBlocksType, List[EntanglementBlocksType]]
+        Union[EntanglementBlocksType, list[EntanglementBlocksType]]
     ] = EntanglementBlocksType.cx
     entanglement: EntanglementStructureType = EntanglementStructureType.full
     reps: int = 3

classiq/interface/generator/application_apis/__init__.py

@@ -2,6 +2,7 @@ from classiq.interface.generator.builtin_api_builder import (
     populate_builtin_declarations,
 )
 
+from .arithmetic_declarations import *  # noqa: F403
 from .chemistry_declarations import *  # noqa: F403
 from .combinatorial_optimization_declarations import *  # noqa: F403
 from .entangler_declarations import *  # noqa: F403

classiq/interface/generator/application_apis/arithmetic_declarations.py

@@ -0,0 +1,17 @@
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
+
+qft_const_adder_phase = ClassicalFunctionDeclaration(
+    name="qft_const_adder_phase",
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="bit_index", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="value", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="reg_len", classical_type=Integer()),
+    ],
+    return_type=Real(),
+)

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -1,54 +1,26 @@
-import functools
 from enum import Enum
 
-from classiq.interface.generator.expressions.expression import Expression
 from classiq.interface.generator.functions.classical_function_declaration import (
     ClassicalFunctionDeclaration,
 )
 from classiq.interface.generator.functions.classical_type import (
-    Bool,
     ClassicalList,
-    Integer,
-    LadderOperator,
-    Real,
-    Struct,
     VQEResult,
 )
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-from classiq.interface.model.port_declaration import PortDeclaration
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
 )
 
-MOLECULE_PROBLEM_PARAM = {"molecule_problem": Struct(name="MoleculeProblem")}
-MOLECULE_PROBLEM_SIZE = (
-    "len(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'))"
+MOLECULE_PROBLEM_PARAM = ClassicalParameterDeclaration(
+    name="molecule_problem", classical_type=Struct(name="MoleculeProblem")
 )
-MOLECULE_PROBLEM_PORT = {
-    "qbv": PortDeclaration(
-        name="qbv",
-        direction=PortDeclarationDirection.Inout,
-        size=Expression(
-            expr=MOLECULE_PROBLEM_SIZE,
-        ),
-    )
-}
-
-FOCK_HAMILTONIAN_PROBLEM_PARAM = {
-    "fock_hamiltonian_problem": Struct(name="FockHamiltonianProblem")
-}
-FOCK_HAMILTONIAN_SIZE = "len(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'))"
 
-FOCK_HAMILTONIAN_PROBLEM_PORT = {
-    "qbv": PortDeclaration(
-        name="qbv",
-        direction=PortDeclarationDirection.Inout,
-        size=Expression(expr=FOCK_HAMILTONIAN_SIZE),
-    )
-}
+FOCK_HAMILTONIAN_PROBLEM_PARAM = ClassicalParameterDeclaration(
+    name="fock_hamiltonian_problem",
+    classical_type=Struct(name="FockHamiltonianProblem"),
+)
+FOCK_HAMILTONIAN_SIZE = "get_field(get_field(fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0], 'pauli'), 'len')"
 
 
 class ChemistryProblemType(Enum):
@@ -56,172 +28,40 @@ class ChemistryProblemType(Enum):
     FockHamiltonianProblem = "fock_hamiltonian_problem"
 
 
-MOLECULE_UCC_ANSATZ = QuantumFunctionDeclaration(
-    name="molecule_ucc",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-        "excitations": ClassicalList(element_type=Integer()),
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
-)
-
-
-MOLECULE_HVA_ANSATZ = QuantumFunctionDeclaration(
-    name="molecule_hva",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-        "reps": Integer(),
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
-)
-
-
-MOLECULE_HARTREE_FOCK = QuantumFunctionDeclaration(
-    name="molecule_hartree_fock",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
-)
-
-
-FOCK_HAMILTONIAN_UCC_ANSATZ = QuantumFunctionDeclaration(
-    name="fock_hamiltonian_ucc",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-        "excitations": ClassicalList(element_type=Integer()),
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
-)
-
-FOCK_HAMILTONIAN_HVA_ANSATZ = QuantumFunctionDeclaration(
-    name="fock_hamiltonian_hva",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-        "reps": Integer(),
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
-)
-
-FOCK_HAMILTONIAN_HARTREE_FOCK = QuantumFunctionDeclaration(
-    name="fock_hamiltonian_hartree_fock",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
-)
-
-
-MOLECULE_PROBLEM = StructDeclaration(
-    name="MoleculeProblem",
-    variables={
-        "mapping": Integer(),
-        "z2_symmetries": Bool(),
-        # A negative number of qubits is considered None
-        # basis: str = pydantic.Field(default="sto3g", description="Molecular basis set")
-        "molecule": Struct(name="Molecule"),
-        "freeze_core": Bool(),
-        "remove_orbitals": ClassicalList(element_type=Integer()),
-    },
-)
-
-MOLECULE = StructDeclaration(
-    name="Molecule",
-    variables={
-        "atoms": ClassicalList(element_type=Struct(name="ChemistryAtom")),
-        "spin": Integer(),
-        "charge": Integer(),
-    },
-)
-
-CHEMISTRY_ATOM = StructDeclaration(
-    name="ChemistryAtom",
-    variables={
-        "element": Integer(),
-        "position": Struct(name="Position"),
-    },
-)
-
-POSITION = StructDeclaration(
-    name="Position", variables={"x": Real(), "y": Real(), "z": Real()}
-)
-
-FockHamiltonian = functools.partial(
-    ClassicalList, element_type=Struct(name="LadderTerm")
-)
-
-FOCK_HAMILTONIAN_PROBLEM = StructDeclaration(
-    name="FockHamiltonianProblem",
-    variables={
-        "mapping": Integer(),
-        "z2_symmetries": Bool(),
-        "terms": FockHamiltonian(),
-        "num_particles": ClassicalList(element_type=Integer()),
-    },
-)
-
-LADDER_TERM = StructDeclaration(
-    name="LadderTerm",
-    variables={
-        "coefficient": Real(),
-        "ops": ClassicalList(element_type=Struct(name="LadderOp")),
-    },
-)
-
-LADDER_OP = StructDeclaration(
-    name="LadderOp",
-    variables={
-        "op": LadderOperator(),
-        "index": Integer(),
-    },
-)
-
-MOLECULE_RESULT = StructDeclaration(
-    name="MoleculeResult",
-    variables={
-        "energy": Real(),
-        "nuclear_repulsion_energy": Real(),
-        "total_energy": Real(),
-        "hartree_fock_energy": Real(),
-        "vqe_result": VQEResult(),
-    },
-)
-
 MOLECULE_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
     name="molecule_problem_to_hamiltonian",
-    param_decls={"problem": Struct(name="MoleculeProblem")},
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem", classical_type=Struct(name="MoleculeProblem")
+        ),
+    ],
     return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
 )
 
 FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
     name="fock_hamiltonian_problem_to_hamiltonian",
-    param_decls={"problem": Struct(name="FockHamiltonianProblem")},
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem", classical_type=Struct(name="FockHamiltonianProblem")
+        ),
+    ],
     return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
 )
 
 
 MOLECULE_GROUND_STATE_SOLUTION_POST_PROCESS = ClassicalFunctionDeclaration(
     name="molecule_ground_state_solution_post_process",
-    param_decls={"problem": Struct(name="MoleculeProblem"), "vqe_result": VQEResult()},
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem", classical_type=Struct(name="MoleculeProblem")
+        ),
+        ClassicalParameterDeclaration(name="vqe_result", classical_type=VQEResult()),
+    ],
     return_type=Struct(name="MoleculeResult"),
 )
 
 __all__ = [
-    "MOLECULE_UCC_ANSATZ",
-    "MOLECULE_HVA_ANSATZ",
-    "MOLECULE_HARTREE_FOCK",
-    "FOCK_HAMILTONIAN_UCC_ANSATZ",
-    "FOCK_HAMILTONIAN_HVA_ANSATZ",
-    "FOCK_HAMILTONIAN_HARTREE_FOCK",
-    "MOLECULE_PROBLEM",
-    "MOLECULE",
-    "CHEMISTRY_ATOM",
-    "POSITION",
-    "FOCK_HAMILTONIAN_PROBLEM",
-    "LADDER_TERM",
-    "LADDER_OP",
-    "MOLECULE_PROBLEM_TO_HAMILTONIAN",
     "FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN",
     "MOLECULE_GROUND_STATE_SOLUTION_POST_PROCESS",
-    "MOLECULE_RESULT",
+    "MOLECULE_PROBLEM_TO_HAMILTONIAN",
 ]