classiq 0.43.3__py3-none-any.whl → 0.45.0__py3-none-any.whl

classiq/interface/executor/execution_preferences.py

@@ -1,18 +1,15 @@
-from datetime import timedelta
-from typing import Any, Dict, Optional
+from typing import Optional
 
 import pydantic
 
 from classiq.interface.backend.backend_preferences import (
-    AWS_DEFAULT_JOB_TIMEOUT_SECONDS,
-    AwsBackendPreferences,
     BackendPreferencesTypes,
     backend_preferences_field,
 )
-from classiq.interface.backend.pydantic_backend import MAX_EXECUTION_TIMEOUT_SECONDS
 from classiq.interface.backend.quantum_backend_providers import (
     ClassiqSimulatorBackendNames,
 )
+from classiq.interface.enum_utils import ReprEnum
 from classiq.interface.executor.optimizer_preferences import OptimizerType
 from classiq.interface.generator.model.preferences.preferences import (
     TranspilationOption,
@@ -20,19 +17,6 @@ from classiq.interface.generator.model.preferences.preferences import (
 from classiq.interface.generator.model.preferences.randomness import create_random_seed
 from classiq.interface.generator.noise_properties import NoiseProperties
 
-from classiq._internals.enum_utils import ReprEnum
-from classiq.exceptions import ClassiqValueError
-
-DIFFERENT_TIMEOUT_MSG = (
-    "Timeout is defined differently in the execution preferences and the "
-    "AWS Backend Preferences."
-)
-
-TIMEOUT_LARGE_FOR_AWS_MSG = (
-    "Timeout is larger than the current allowed limit of "
-    f"{timedelta(MAX_EXECUTION_TIMEOUT_SECONDS)}"
-)
-
 
 class QaeWithQpeEstimationMethod(int, ReprEnum):
     MAXIMUM_LIKELIHOOD = 0
@@ -40,11 +24,6 @@ class QaeWithQpeEstimationMethod(int, ReprEnum):
 
 
 class ExecutionPreferences(pydantic.BaseModel):
-    timeout_sec: Optional[pydantic.PositiveInt] = pydantic.Field(
-        default=None,
-        description="If set, limits the execution runtime. Value is in seconds. "
-        "Not supported on all platforms.",
-    )
     noise_properties: Optional[NoiseProperties] = pydantic.Field(
         default=None, description="Properties of the noise in the circuit"
     )
@@ -66,30 +45,6 @@ class ExecutionPreferences(pydantic.BaseModel):
         description="The job name",
     )
 
-    def __init__(self, **kwargs: Any) -> None:
-        super().__init__(**kwargs)
-
-    @pydantic.validator("backend_preferences", always=True)
-    def validate_timeout_for_aws(
-        cls, backend_preferences: BackendPreferencesTypes, values: Dict[str, Any]
-    ) -> BackendPreferencesTypes:
-        timeout = values.get("timeout_sec", None)
-        if (
-            not isinstance(backend_preferences, AwsBackendPreferences)
-            or timeout is None
-        ):
-            return backend_preferences
-        if (
-            timeout != backend_preferences.job_timeout
-            and backend_preferences.job_timeout != AWS_DEFAULT_JOB_TIMEOUT_SECONDS
-        ):
-            raise ClassiqValueError(DIFFERENT_TIMEOUT_MSG)
-        if timeout > MAX_EXECUTION_TIMEOUT_SECONDS:
-            raise ClassiqValueError(TIMEOUT_LARGE_FOR_AWS_MSG)
-
-        backend_preferences.job_timeout = timeout
-        return backend_preferences
-
 
 __all__ = [
     "ExecutionPreferences",

classiq/interface/executor/execution_result.py

@@ -3,6 +3,7 @@ from typing import Any, List, Literal, Union
 from pydantic import BaseModel, Field
 from typing_extensions import Annotated, TypeAlias
 
+from classiq.interface.enum_utils import StrEnum
 from classiq.interface.executor.iqae_result import IQAEResult
 from classiq.interface.executor.result import (
     EstimationResult,
@@ -13,8 +14,6 @@ from classiq.interface.executor.result import (
 from classiq.interface.executor.vqe_result import VQESolverResult
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq._internals.enum_utils import StrEnum
-
 
 class SavedResultValueType(StrEnum):
     Integer = "int"

classiq/interface/executor/optimizer_preferences.py

@@ -3,11 +3,10 @@ from typing import Any, Dict, List, Optional
 import pydantic
 from pydantic import BaseModel
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.helpers.custom_pydantic_types import PydanticAlphaParamCVAR
 
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
 
 class CostType(StrEnum):
     MIN = "MIN"

classiq/interface/executor/quantum_code.py

@@ -8,14 +8,13 @@ from pydantic import BaseModel
 
 from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircuit
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
 from classiq.interface.generator.synthesis_metadata.synthesis_execution_data import (
     ExecutionData,
 )
 
-from classiq.exceptions import ClassiqValueError
-
 Arguments = Dict[PydanticArgumentNameType, Any]
 MultipleArguments = Tuple[Arguments, ...]
 CodeType = str

classiq/interface/executor/quantum_instruction_set.py

@@ -1,5 +1,5 @@
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 
 
 class QuantumInstructionSet(StrEnum):

classiq/interface/executor/register_initialization.py

@@ -2,10 +2,9 @@ from typing import Any, Dict, List
 
 import pydantic
 
+from classiq.interface.exceptions import ClassiqStateInitializationError
 from classiq.interface.generator.arith import number_utils
 
-from classiq.exceptions import ClassiqStateInitializationError
-
 _NON_INTEGER_INITIALIZATION_ERROR_MSG: str = (
     "Only natural numbers are supported as initial conditions"
 )

classiq/interface/executor/result.py

@@ -2,6 +2,7 @@ import functools
 import operator
 from collections import defaultdict
 from typing import (
+    TYPE_CHECKING,
     Any,
     DefaultDict,
     Dict,
@@ -17,6 +18,7 @@ import pydantic
 from pydantic import BaseModel
 from typing_extensions import TypeAlias
 
+from classiq.interface.exceptions import ClassiqError
 from classiq.interface.executor.quantum_code import OutputQubitsMap, Qubits
 from classiq.interface.generator.arith import number_utils
 from classiq.interface.generator.complex_type import Complex
@@ -24,15 +26,13 @@ from classiq.interface.generator.functions.classical_type import QmodPyObject
 from classiq.interface.helpers.custom_pydantic_types import PydanticNonNegIntTuple
 from classiq.interface.helpers.versioned_model import VersionedModel
 
-from classiq.exceptions import ClassiqError
-
 _ILLEGAL_QUBIT_ERROR_MSG: str = "Illegal qubit index requested"
 _REPEATED_QUBIT_ERROR_MSG: str = "Requested a qubit more than once"
 _UNAVAILABLE_OUTPUT_ERROR_MSG: str = "Requested output doesn't exist in the circuit"
 
 State: TypeAlias = str
 Name: TypeAlias = str
-RegisterValue: TypeAlias = Union[float, int]
+RegisterValue: TypeAlias = Union[float, int, list, dict]
 MeasuredShots: TypeAlias = pydantic.NonNegativeInt
 ParsedState: TypeAlias = Mapping[Name, RegisterValue]
 ParsedStates: TypeAlias = Mapping[State, ParsedState]
@@ -60,6 +60,7 @@ class SimulatedState(BaseModel):
         return self.state[item]
 
 
+SimulatedState.update_forward_refs(RegisterValue=RegisterValue)
 ParsedStateVector: TypeAlias = List[SimulatedState]
 
 
@@ -122,6 +123,23 @@ def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCoun
     return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
 
 
+def prepare_parsed_state_vector(
+    state_vector: StateVector, parsed_state_vector_states: ParsedStates
+) -> Optional[ParsedStateVector]:
+    if not state_vector:
+        return None
+
+    parsed_state_vector = [
+        SimulatedState(
+            state=parsed_state_vector_states[bitstring],
+            bitstring=bitstring,
+            amplitude=complex(amplitude_str),
+        )
+        for bitstring, amplitude_str in state_vector.items()
+    ]
+    return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
+
+
 class ExecutionDetails(BaseModel, QmodPyObject):
     vendor_format_result: Dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
@@ -133,6 +151,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
         True,
         description="Is the qubit order of counts field such that the LSB is right?",
     )
+    probabilities: Dict[State, pydantic.NonNegativeFloat] = pydantic.Field(
+        default_factory=dict, description="Probabilities of each state"
+    )
     parsed_states: ParsedStates = pydantic.Field(
         default_factory=dict,
         description="A mapping between the raw states of counts (bitstrings) to their parsed states (registers' values)",
@@ -184,17 +205,9 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @property
     def parsed_state_vector(self) -> Optional[ParsedStateVector]:
-        if not self.state_vector:
-            return None
-        parsed_state_vector = [
-            SimulatedState(
-                state=self.parsed_state_vector_states[bitstring],
-                bitstring=bitstring,
-                amplitude=complex(amplitude_str),
-            )
-            for bitstring, amplitude_str in self.state_vector.items()
-        ]
-        return sorted(parsed_state_vector, key=lambda k: abs(k.amplitude), reverse=True)
+        return prepare_parsed_state_vector(
+            self.state_vector, self.parsed_state_vector_states
+        )
 
     def flip_execution_counts_bitstring(self) -> None:
         """Backends should return result count bitstring in right to left form"""
@@ -261,6 +274,8 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             lsb_right=False
         ).items():
             value = value_from_str_bin(binary_string=results_binary_key)
+            if TYPE_CHECKING:
+                assert isinstance(value, float)
             register_output[value] = register_output.get(value, 0) + counts
 
         return register_output

classiq/interface/finance/function_input.py

@@ -1,19 +1,18 @@
-from typing import TYPE_CHECKING, Any, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union
 
 import pydantic
 
+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 (
     PydanticNonZeroProbabilityFloat,
 )
 
-from classiq.exceptions import ClassiqValueError
-
-if TYPE_CHECKING:
-    from classiq.qmod.builtins.enums import FinanceFunctionType
-
 
 class FunctionCondition(pydantic.BaseModel):
     threshold: float
@@ -71,9 +70,7 @@ class FinanceFunctionInput(pydantic.BaseModel):
     @pydantic.validator("f")
     def _validate_finance_function(
         cls, f: Union[int, str, "FinanceFunctionType"]
-    ) -> "FinanceFunctionType":
-        from classiq.qmod.builtins.enums import FinanceFunctionType
-
+    ) -> FinanceFunctionType:
         if isinstance(f, FinanceFunctionType):
             return f
         if isinstance(f, int):
@@ -86,8 +83,6 @@ class FinanceFunctionInput(pydantic.BaseModel):
         tail_probability: Optional[PydanticNonZeroProbabilityFloat],
         values: Dict[str, Any],
     ) -> Optional[PydanticNonZeroProbabilityFloat]:
-        from classiq.qmod.builtins.enums import FinanceFunctionType
-
         if values.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
             raise ClassiqValueError(
                 "Tail probability must be set for expected shortfall"

classiq/interface/generator/amplitude_loading.py

@@ -4,6 +4,8 @@ from typing import Any, Dict, get_args
 import pydantic
 import sympy
 
+from classiq.interface.enum_utils import StrEnum
+from classiq.interface.exceptions import ClassiqValueError
 from classiq.interface.generator.arith.arithmetic_expression_validator import (
     validate_expression,
 )
@@ -20,9 +22,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"
 

classiq/interface/generator/ansatz_library.py

@@ -2,7 +2,7 @@ from typing import Dict, List, Optional, Union
 
 from pydantic import BaseModel
 
-from classiq._internals.enum_utils import StrEnum
+from classiq.interface.enum_utils import StrEnum
 
 
 class RotationBlocksType(StrEnum):

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

@@ -10,43 +10,44 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
     Real,
-    Struct,
-    TypeName,
     VQEResult,
 )
 from classiq.interface.generator.functions.port_declaration import (
     PortDeclarationDirection,
 )
+from classiq.interface.generator.functions.type_name import Struct, TypeName
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 from classiq.interface.model.port_declaration import PortDeclaration
 from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
+    NamedParamsQuantumFunctionDeclaration,
 )
 
-MOLECULE_PROBLEM_PARAM = {"molecule_problem": Struct(name="MoleculeProblem")}
+MOLECULE_PROBLEM_PARAM = ClassicalParameterDeclaration(
+    name="molecule_problem", classical_type=Struct(name="MoleculeProblem")
+)
 MOLECULE_PROBLEM_SIZE = "get_field(get_field(molecule_problem_to_hamiltonian(molecule_problem)[0], 'pauli'), 'len')"
-MOLECULE_PROBLEM_PORT = {
-    "qbv": PortDeclaration(
-        name="qbv",
-        direction=PortDeclarationDirection.Inout,
-        size=Expression(
-            expr=MOLECULE_PROBLEM_SIZE,
-        ),
-    )
-}
+MOLECULE_PROBLEM_PORT = PortDeclaration(
+    name="qbv",
+    direction=PortDeclarationDirection.Inout,
+    size=Expression(
+        expr=MOLECULE_PROBLEM_SIZE,
+    ),
+)
 
-FOCK_HAMILTONIAN_PROBLEM_PARAM = {
-    "fock_hamiltonian_problem": Struct(name="FockHamiltonianProblem")
-}
+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')"
 
-FOCK_HAMILTONIAN_PROBLEM_PORT = {
-    "qbv": PortDeclaration(
-        name="qbv",
-        direction=PortDeclarationDirection.Inout,
-        size=Expression(expr=FOCK_HAMILTONIAN_SIZE),
-    )
-}
+FOCK_HAMILTONIAN_PROBLEM_PORT = PortDeclaration(
+    name="qbv",
+    direction=PortDeclarationDirection.Inout,
+    size=Expression(expr=FOCK_HAMILTONIAN_SIZE),
+)
 
 
 class ChemistryProblemType(Enum):
@@ -54,59 +55,63 @@ class ChemistryProblemType(Enum):
     FockHamiltonianProblem = "fock_hamiltonian_problem"
 
 
-MOLECULE_UCC_ANSATZ = QuantumFunctionDeclaration(
+MOLECULE_UCC_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="molecule_ucc",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-        "excitations": ClassicalList(element_type=Integer()),
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
+    positional_arg_declarations=[
+        MOLECULE_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(
+            name="excitations", classical_type=ClassicalList(element_type=Integer())
+        ),
+        MOLECULE_PROBLEM_PORT,
+    ],
 )
 
 
-MOLECULE_HVA_ANSATZ = QuantumFunctionDeclaration(
+MOLECULE_HVA_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="molecule_hva",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-        "reps": Integer(),
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
+    positional_arg_declarations=[
+        MOLECULE_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(name="reps", classical_type=Integer()),
+        MOLECULE_PROBLEM_PORT,
+    ],
 )
 
 
-MOLECULE_HARTREE_FOCK = QuantumFunctionDeclaration(
+MOLECULE_HARTREE_FOCK = NamedParamsQuantumFunctionDeclaration(
     name="molecule_hartree_fock",
-    param_decls={
-        **MOLECULE_PROBLEM_PARAM,
-    },
-    port_declarations=MOLECULE_PROBLEM_PORT,
+    positional_arg_declarations=[
+        MOLECULE_PROBLEM_PARAM,
+        MOLECULE_PROBLEM_PORT,
+    ],
 )
 
 
-FOCK_HAMILTONIAN_UCC_ANSATZ = QuantumFunctionDeclaration(
+FOCK_HAMILTONIAN_UCC_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="fock_hamiltonian_ucc",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-        "excitations": ClassicalList(element_type=Integer()),
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
+    positional_arg_declarations=[
+        FOCK_HAMILTONIAN_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(
+            name="excitations", classical_type=ClassicalList(element_type=Integer())
+        ),
+        FOCK_HAMILTONIAN_PROBLEM_PORT,
+    ],
 )
 
-FOCK_HAMILTONIAN_HVA_ANSATZ = QuantumFunctionDeclaration(
+FOCK_HAMILTONIAN_HVA_ANSATZ = NamedParamsQuantumFunctionDeclaration(
     name="fock_hamiltonian_hva",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-        "reps": Integer(),
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
+    positional_arg_declarations=[
+        FOCK_HAMILTONIAN_PROBLEM_PARAM,
+        ClassicalParameterDeclaration(name="reps", classical_type=Integer()),
+        FOCK_HAMILTONIAN_PROBLEM_PORT,
+    ],
 )
 
-FOCK_HAMILTONIAN_HARTREE_FOCK = QuantumFunctionDeclaration(
+FOCK_HAMILTONIAN_HARTREE_FOCK = NamedParamsQuantumFunctionDeclaration(
     name="fock_hamiltonian_hartree_fock",
-    param_decls={
-        **FOCK_HAMILTONIAN_PROBLEM_PARAM,
-    },
-    port_declarations=FOCK_HAMILTONIAN_PROBLEM_PORT,
+    positional_arg_declarations=[
+        FOCK_HAMILTONIAN_PROBLEM_PARAM,
+        FOCK_HAMILTONIAN_PROBLEM_PORT,
+    ],
 )
 
 
@@ -187,20 +192,33 @@ MOLECULE_RESULT = StructDeclaration(
 
 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"),
 )
 

classiq/interface/generator/application_apis/combinatorial_optimization_declarations.py

@@ -5,11 +5,14 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
     Real,
-    Struct,
     StructMetaType,
     VQEResult,
 )
+from classiq.interface.generator.functions.type_name import Struct
 from classiq.interface.generator.types.struct_declaration import StructDeclaration
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 COMBINATORIAL_OPTIMIZATION_SOLUTION = StructDeclaration(
     name="CombinatorialOptimizationSolution",
@@ -23,20 +26,26 @@ COMBINATORIAL_OPTIMIZATION_SOLUTION = StructDeclaration(
 
 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")
     ),

classiq/interface/generator/application_apis/entangler_declarations.py

@@ -6,19 +6,24 @@ from classiq.interface.generator.functions.classical_type import (
     ClassicalList,
     Integer,
 )
+from classiq.interface.model.classical_parameter_declaration import (
+    ClassicalParameterDeclaration,
+)
 
 GRID_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="grid_entangler_graph",
-    param_decls={
-        "num_qubits": Integer(),
-        "schmidt_rank": Integer(),
-        "grid_randomization": Bool(),
-    },
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="schmidt_rank", classical_type=Integer()),
+        ClassicalParameterDeclaration(name="grid_randomization", classical_type=Bool()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )
 
 HYPERCUBE_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
     name="hypercube_entangler_graph",
-    param_decls={"num_qubits": Integer()},
+    positional_parameters=[
+        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
+    ],
     return_type=ClassicalList(element_type=ClassicalList(element_type=Integer())),
 )