classiq 0.38.0__py3-none-any.whl → 0.65.4__py3-none-any.whl

classiq/interface/finance/function_input.py

@@ -1,17 +1,20 @@
-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 (
-    FINANCE_FUNCTION_STRING,
+    get_finance_function_dict,
+)
+from classiq.interface.generator.types.builtin_enum_declarations import (
     FinanceFunctionType,
 )
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticNonZeroProbabilityFloat,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 
 class FunctionCondition(pydantic.BaseModel):
     threshold: float
@@ -19,13 +22,11 @@ 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: FinanceFunctionType = pydantic.Field(
+    f: "FinanceFunctionType" = pydantic.Field(
         description="An enumeration of the wanted financial function: VaR, expected "
         "shortfall, European call options or x^2"
     )
@@ -49,44 +50,53 @@ class FinanceFunctionInput(pydantic.BaseModel):
         description="The required probability on the tail of the distribution (1 - percentile)",
     )
 
-    @pydantic.validator("f", pre=True)
-    def _convert_f_if_str(cls, f: Any) -> FinanceFunctionType:
-        # Keep this for backwards-compatible string support
-        if f in FINANCE_FUNCTION_STRING:
-            return FINANCE_FUNCTION_STRING[f]
-        return f
+    @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.validator("use_chebyshev_polynomial_approximation")
+    @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 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:
+        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, Literal, Optional, Tuple
+from typing import Literal, Optional
 
 import pydantic
 
@@ -18,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(
@@ -38,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,7 +1,8 @@
-from typing import Literal, Tuple
+from typing import Literal
 
 import numpy as np
 import pydantic
+from pydantic import ConfigDict
 
 from classiq.interface.finance.model_input import FinanceModelInput
 
@@ -20,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)
@@ -36,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,
@@ -13,10 +14,9 @@ class FinanceModelInput(HashablePydanticBaseModel):
     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,9 +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
-from classiq.exceptions import ClassiqValueError
-
 AMPLITUDE_IO_NAME = "AMPLITUDE"
 TARGET_OUTPUT_NAME = "TARGET"
 
@@ -36,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."
     )
@@ -44,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.
@@ -59,13 +67,13 @@ 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 ClassiqValueError(
                 f"The following names: {not_allowed} are not allowed"
@@ -73,7 +81,7 @@ class AmplitudeLoading(FunctionParams):
 
         if len(variables) != 1:
             raise ClassiqValueError(f"{variables} must contain exactly single variable")
-        return values
+        return self
 
     def _create_ios(self) -> None:
         self._inputs = {
@@ -89,5 +97,7 @@ class AmplitudeLoading(FunctionParams):
 
     @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/arithmetic_declarations.py

@@ -2,13 +2,16 @@ 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",
-    param_decls={
-        "bit_index": Integer(),
-        "value": Integer(),
-        "reg_len": Integer(),
-    },
+    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",
 ]

classiq/interface/generator/application_apis/combinatorial_optimization_declarations.py

@@ -3,40 +3,37 @@ from classiq.interface.generator.functions.classical_function_declaration import
 )
 from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
-    Integer,
     Real,
-    Struct,
     StructMetaType,
     VQEResult,
 )
-from classiq.interface.generator.types.struct_declaration import StructDeclaration
-
-COMBINATORIAL_OPTIMIZATION_SOLUTION = StructDeclaration(
-    name="CombinatorialOptimizationSolution",
-    variables={
-        "probability": Real(),
-        "cost": Real(),
-        "solution": ClassicalList(element_type=Integer()),
-        "count": Integer(),
-    },
+from classiq.interface.generator.functions.type_name import Struct
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
 )
 
 OPTIMIZATION_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
     name="optimization_problem_to_hamiltonian",
-    param_decls={
-        "problem_type": StructMetaType(),
-        "penalty_energy": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem_type", classical_type=StructMetaType()
+        ),
+        ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
+    ],
     return_type=ClassicalList(element_type=Struct(name="PauliTerm")),
 )
 
 GET_OPTIMIZATION_SOLUTION = ClassicalFunctionDeclaration(
     name="get_optimization_solution",
-    param_decls={
-        "problem_type": StructMetaType(),
-        "vqe_result_handle": VQEResult(),
-        "penalty_energy": Real(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(
+            name="problem_type", classical_type=StructMetaType()
+        ),
+        ClassicalParameterDeclaration(
+            name="vqe_result_handle", classical_type=VQEResult()
+        ),
+        ClassicalParameterDeclaration(name="penalty_energy", classical_type=Real()),
+    ],
     return_type=ClassicalList(
         element_type=Struct(name="CombinatorialOptimizationSolution")
     ),