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

classiq/interface/executor/execution_preferences.py

@@ -1,5 +1,5 @@
 from datetime import timedelta
-from typing import Any, Dict, List, Optional, TypeVar, Union
+from typing import Any, Dict, Optional, TypeVar
 
 import pydantic
 
@@ -23,6 +23,7 @@ from classiq.interface.generator.model.preferences.randomness import create_rand
 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 "
@@ -40,41 +41,12 @@ class QaeWithQpeEstimationMethod(int, ReprEnum):
     BEST_FIT = 1
 
 
-class AmplitudeAmplification(pydantic.BaseModel):
-    iterations: List[int] = pydantic.Field(
-        default_factory=list,
-        description="Number or list of numbers of iteration to use",
-    )
-    growth_rate: float = pydantic.Field(
-        default=1.25,
-        description="Number of iteration used is set to round(growth_rate**iterations)",
-    )
-    sample_from_iterations: bool = pydantic.Field(
-        default=False,
-        description="If True, number of iterations used is picked randomly from "
-        "[1, iteration] range",
-    )
-    num_of_highest_probability_states_to_check: pydantic.PositiveInt = pydantic.Field(
-        default=1, description="Then number of highest probability states to check"
-    )
-
-    @pydantic.validator("iterations")
-    def _validate_iterations(cls, iterations: Union[List[int], int]) -> List[int]:
-        if isinstance(iterations, int):
-            return [iterations]
-        return iterations
-
-
 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.",
     )
-    amplitude_amplification: AmplitudeAmplification = pydantic.Field(
-        default_factory=AmplitudeAmplification,
-        description="Settings related to amplitude amplification execution, used during the grover execution.",
-    )
     optimizer_preferences: Optional[OptimizerPreferences] = pydantic.Field(
         default_factory=None,
         description="Settings related to VQE execution.",
@@ -130,9 +102,9 @@ class ExecutionPreferences(pydantic.BaseModel):
             timeout != backend_preferences.job_timeout
             and backend_preferences.job_timeout != AWS_DEFAULT_JOB_TIMEOUT_SECONDS
         ):
-            raise ValueError(DIFFERENT_TIMEOUT_MSG)
+            raise ClassiqValueError(DIFFERENT_TIMEOUT_MSG)
         if timeout > MAX_EXECUTION_TIMEOUT_SECONDS:
-            raise ValueError(TIMEOUT_LARGE_FOR_AWS_MSG)
+            raise ClassiqValueError(TIMEOUT_LARGE_FOR_AWS_MSG)
 
         backend_preferences.job_timeout = timeout
         return backend_preferences
@@ -169,7 +141,7 @@ def _choose_original_or_optimizer_attribute(
         return optimizer_attribute
 
     elif original_attribute != optimizer_attribute:
-        raise ValueError(
+        raise ClassiqValueError(
             f"Different {attribure_name} were given for ExecutionPreferences and OptimizerPreferences."
         )
 
@@ -179,7 +151,6 @@ def _choose_original_or_optimizer_attribute(
 
 __all__ = [
     "ExecutionPreferences",
-    "AmplitudeAmplification",
     "ErrorMitigationMethod",
     "NoiseProperties",
     "OptimizerPreferences",

classiq/interface/executor/execution_request.py

@@ -1,80 +1,47 @@
 from datetime import datetime
-from typing import Any, Dict, List, Literal, Optional, Union
+from typing import List, Literal, Optional, Union
 
 import pydantic
-from pydantic import BaseModel
+from pydantic import BaseModel, Field
+from typing_extensions import Annotated
 
-from classiq.interface.backend.backend_preferences import IonqBackendPreferences
 from classiq.interface.executor.estimation import OperatorsEstimation
 from classiq.interface.executor.execution_preferences import ExecutionPreferences
-from classiq.interface.executor.quantum_program import (
-    QuantumInstructionSet,
-    QuantumProgram,
-)
-from classiq.interface.generator.generated_circuit import GeneratedCircuit
+from classiq.interface.executor.quantum_code import QuantumCode
+from classiq.interface.generator.quantum_program import QuantumProgram
+from classiq.interface.helpers.custom_encoders import CUSTOM_ENCODERS
 from classiq.interface.helpers.versioned_model import VersionedModel
 from classiq.interface.jobs import JobStatus
 
 
-class GeneratedCircuitExecution(GeneratedCircuit):
-    execution_type: Literal["generated_circuit"] = "generated_circuit"
+class QuantumProgramExecution(QuantumProgram):
+    execution_type: Literal["quantum_program2"] = "quantum_program2"
 
 
-class QuantumProgramExecution(QuantumProgram):
-    execution_type: Literal["quantum_program"] = "quantum_program"
+class QuantumCodeExecution(QuantumCode):
+    execution_type: Literal["quantum_code"] = "quantum_code"
 
 
 class EstimateOperatorsExecution(OperatorsEstimation):
     execution_type: Literal["estimate_operators"] = "estimate_operators"
 
 
-ExecutionPayloads = Union[
-    GeneratedCircuitExecution, QuantumProgramExecution, EstimateOperatorsExecution
+ExecutionPayloads = Annotated[
+    Union[QuantumProgramExecution, QuantumCodeExecution, EstimateOperatorsExecution],
+    Field(discriminator="execution_type"),
 ]
 
 
-class ExecutionRequest(BaseModel):
+class ExecutionRequest(BaseModel, json_encoders=CUSTOM_ENCODERS):
     execution_payload: ExecutionPayloads
     preferences: ExecutionPreferences = pydantic.Field(
         default_factory=ExecutionPreferences,
         description="preferences for the execution",
     )
 
-    @pydantic.validator("preferences")
-    def validate_ionq_backend(
-        cls, preferences: ExecutionPreferences, values: Dict[str, Any]
-    ) -> ExecutionPreferences:
-        """
-        This function implement the following check:
-        BE \\ payload | IonQ program | Qasm program | Other
-        --------------|--------------|--------------|------
-        IonQ backend  |       V      |      V       |   X
-        Other backend |       X      |      V       |   V
-        Since:
-        - We can't execute non-programs on the IonQ backends
-        - We can't execute IonQ programs on non-IonQ backends
-        """
-        quantum_program = values.get("execution_payload")
-        is_ionq_backend = isinstance(
-            preferences.backend_preferences, IonqBackendPreferences
-        )
-        if isinstance(quantum_program, QuantumProgram):
-            if (
-                quantum_program.syntax == QuantumInstructionSet.IONQ
-                and not is_ionq_backend
-            ):
-                raise ValueError("Can only execute IonQ code on IonQ backend.")
-        else:
-            # If we handle anything other than a program.
-            if is_ionq_backend:
-                raise ValueError(
-                    "IonQ backend supports only execution of QuantumPrograms"
-                )
-        return preferences
-
 
 class QuantumProgramExecutionRequest(ExecutionRequest):
-    execution_payload: QuantumProgramExecution
+    execution_payload: QuantumCodeExecution
 
 
 class ExecutionJobDetails(VersionedModel):

classiq/interface/executor/optimizer_preferences.py

@@ -1,4 +1,4 @@
-from typing import List, Optional
+from typing import Any, Dict, List, Optional
 
 import pydantic
 from pydantic import BaseModel
@@ -6,6 +6,7 @@ from pydantic import BaseModel
 from classiq.interface.helpers.custom_pydantic_types import PydanticAlphaParamCVAR
 
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 
 class CostType(StrEnum):
@@ -33,10 +34,10 @@ class OptimizerPreferences(BaseModel):
     max_iteration: pydantic.PositiveInt = pydantic.Field(
         default=100, description="Maximal number of optimizer iterations"
     )
-    tolerance: pydantic.PositiveFloat = pydantic.Field(
+    tolerance: Optional[pydantic.PositiveFloat] = pydantic.Field(
         default=None, description="Final accuracy in the optimization"
     )
-    step_size: pydantic.PositiveFloat = pydantic.Field(
+    step_size: Optional[pydantic.PositiveFloat] = pydantic.Field(
         default=None,
         description="step size for numerically " "calculating the gradient",
     )
@@ -54,30 +55,36 @@ class OptimizerPreferences(BaseModel):
     )
 
     @pydantic.validator("tolerance", pre=True, always=True)
-    def check_tolerance(cls, tolerance, values):
+    def check_tolerance(
+        cls, tolerance: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+    ) -> Optional[pydantic.PositiveFloat]:
         optimizer_type = values.get("type")
         if tolerance is not None and optimizer_type == OptimizerType.SPSA:
-            raise ValueError("No tolerance param for SPSA optimizer")
+            raise ClassiqValueError("No tolerance param for SPSA optimizer")
 
         if tolerance is None and optimizer_type != OptimizerType.SPSA:
-            tolerance = 0.001
+            tolerance = pydantic.PositiveFloat(0.001)
 
         return tolerance
 
     @pydantic.validator("step_size", pre=True, always=True)
-    def check_step_size(cls, step_size, values):
+    def check_step_size(
+        cls, step_size: Optional[pydantic.PositiveFloat], values: Dict[str, Any]
+    ) -> Optional[pydantic.PositiveFloat]:
         optimizer_type = values.get("name")
         if step_size is not None and optimizer_type not in (
             OptimizerType.L_BFGS_B,
             OptimizerType.ADAM,
         ):
-            raise ValueError("Use step_size only for L_BFGS_B or ADAM optimizers.")
+            raise ClassiqValueError(
+                "Use step_size only for L_BFGS_B or ADAM optimizers."
+            )
 
         if step_size is None and optimizer_type in (
             OptimizerType.L_BFGS_B,
             OptimizerType.ADAM,
         ):
-            step_size = 0.05
+            step_size = pydantic.PositiveFloat(0.05)
 
         return step_size
 
@@ -91,7 +98,7 @@ class CombinatorialOptimizer(OptimizerPreferences):
         default=CostType.CVAR,
         description="Summarizing method of the measured bit strings",
     )
-    alpha_cvar: PydanticAlphaParamCVAR = pydantic.Field(
+    alpha_cvar: Optional[PydanticAlphaParamCVAR] = pydantic.Field(
         default=None, description="Parameter for the CVAR summarizing method"
     )
     is_maximization: bool = pydantic.Field(
@@ -104,12 +111,14 @@ class CombinatorialOptimizer(OptimizerPreferences):
     )
 
     @pydantic.validator("alpha_cvar", pre=True, always=True)
-    def check_alpha_cvar(cls, alpha_cvar, values):
+    def check_alpha_cvar(
+        cls, alpha_cvar: Optional[PydanticAlphaParamCVAR], values: Dict[str, Any]
+    ) -> Optional[PydanticAlphaParamCVAR]:
         cost_type = values.get("cost_type")
         if alpha_cvar is not None and cost_type != CostType.CVAR:
-            raise ValueError("Use CVAR params only for CostType.CVAR.")
+            raise ClassiqValueError("Use CVAR params only for CostType.CVAR.")
 
         if alpha_cvar is None and cost_type == CostType.CVAR:
-            alpha_cvar = 0.2
+            alpha_cvar = PydanticAlphaParamCVAR(0.2)
 
         return alpha_cvar

classiq/interface/executor/{quantum_program.py → quantum_code.py}

@@ -6,7 +6,7 @@ from typing import Any, Dict, Optional, Tuple, Union
 import pydantic
 from pydantic import BaseModel
 
-from classiq.interface.backend.ionq import ionq_quantum_program
+from classiq.interface.backend.ionq.ionq_quantum_program import IonqQuantumCircuit
 from classiq.interface.backend.pydantic_backend import PydanticArgumentNameType
 from classiq.interface.executor.quantum_instruction_set import QuantumInstructionSet
 from classiq.interface.executor.register_initialization import RegisterInitialization
@@ -14,15 +14,17 @@ from classiq.interface.generator.synthesis_metadata.synthesis_execution_data imp
     ExecutionData,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 Arguments = Dict[PydanticArgumentNameType, Any]
 MultipleArguments = Tuple[Arguments, ...]
-CodeType = Union[str, ionq_quantum_program.IonqQuantumCircuit]
+CodeType = str
 RegistersInitialization = Dict[str, RegisterInitialization]
 Qubits = Tuple[int, ...]
 OutputQubitsMap = Dict[str, Qubits]
 
 
-class QuantumBaseProgram(BaseModel):
+class QuantumBaseCode(BaseModel):
     syntax: QuantumInstructionSet = pydantic.Field(
         default=QuantumInstructionSet.QASM, description="The syntax of the program."
     )
@@ -31,17 +33,21 @@ class QuantumBaseProgram(BaseModel):
     )
 
     @pydantic.validator("code")
-    def load_quantum_program(cls, code: CodeType, values: Dict[str, Any]) -> CodeType:
-        if not isinstance(code, str):
-            return code
-
+    def load_quantum_program(
+        cls, code: Union[CodeType, IonqQuantumCircuit], values: Dict[str, Any]
+    ) -> CodeType:
         syntax = values.get("syntax")
-        if syntax == QuantumInstructionSet.IONQ:
-            return ionq_quantum_program.IonqQuantumCircuit.from_string(code)
+        if isinstance(code, IonqQuantumCircuit):
+            if syntax != QuantumInstructionSet.IONQ:
+                raise ClassiqValueError(
+                    f"Invalid code type {type(code)} for syntax: {syntax}"
+                )
+            return code.json()
+
         return code
 
 
-class QuantumProgram(QuantumBaseProgram):
+class QuantumCode(QuantumBaseCode):
     arguments: MultipleArguments = pydantic.Field(
         default=(),
         description="The parameters dictionary for a parametrized quantum program.",
@@ -68,10 +74,10 @@ class QuantumProgram(QuantumBaseProgram):
             QuantumInstructionSet.QSHARP,
             QuantumInstructionSet.QASM,
         ):
-            raise ValueError("Only QASM or Q# programs support arguments")
+            raise ClassiqValueError("Only QASM or Q# programs support arguments")
 
         if values.get("syntax") == QuantumInstructionSet.QSHARP and len(arguments) > 1:
-            raise ValueError(
+            raise ClassiqValueError(
                 f"Q# programs supports only one group of arguments. {len(arguments)} given"
             )
 
@@ -87,7 +93,7 @@ class QuantumProgram(QuantumBaseProgram):
             synthesis_execution_data is not None
             and values.get("syntax") is not QuantumInstructionSet.QASM
         ):
-            raise ValueError("Only QASM supports the requested configuration")
+            raise ClassiqValueError("Only QASM supports the requested configuration")
 
         return synthesis_execution_data
 
@@ -96,9 +102,9 @@ class QuantumProgram(QuantumBaseProgram):
         file_path: Union[str, Path],
         syntax: Optional[Union[str, QuantumInstructionSet]] = None,
         arguments: MultipleArguments = (),
-    ) -> QuantumProgram:
+    ) -> QuantumCode:
         path = Path(file_path)
         code = path.read_text()
         if syntax is None:
             syntax = QuantumInstructionSet.from_suffix(path.suffix.lstrip("."))
-        return QuantumProgram(syntax=syntax, code=code, arguments=arguments)
+        return QuantumCode(syntax=syntax, code=code, arguments=arguments)

classiq/interface/executor/quantum_instruction_set.py

@@ -1,4 +1,5 @@
 from classiq._internals.enum_utils import StrEnum
+from classiq.exceptions import ClassiqValueError
 
 
 class QuantumInstructionSet(StrEnum):
@@ -14,4 +15,4 @@ class QuantumInstructionSet(StrEnum):
             return QuantumInstructionSet.QSHARP
         if suffix == "ionq":
             return QuantumInstructionSet.IONQ
-        raise ValueError("Illegal suffix")
+        raise ClassiqValueError("Illegal suffix")

classiq/interface/executor/register_initialization.py

@@ -30,9 +30,7 @@ class RegisterInitialization(pydantic.BaseModel):
         initial_condition: int = values.get("initial_condition", 0)
         name: str = values.get("name", "")
 
-        initial_condition_length = number_utils.size(
-            initial_condition, machine_precision=number_utils.MAX_FRACTION_PLACES
-        )
+        initial_condition_length = number_utils.size(initial_condition)
         register_length = len(qubits)
         if initial_condition_length > register_length:
             raise ClassiqStateInitializationError(

classiq/interface/executor/result.py

@@ -17,7 +17,7 @@ import pydantic
 from pydantic import BaseModel
 from typing_extensions import TypeAlias
 
-from classiq.interface.executor.quantum_program import OutputQubitsMap, Qubits
+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
 from classiq.interface.generator.functions.classical_type import QmodPyObject
@@ -44,6 +44,9 @@ class SampledState(BaseModel):
     state: ParsedState
     shots: MeasuredShots
 
+    def __repr__(self) -> str:
+        return f"{self.state}: {self.shots}"
+
 
 ParsedCounts: TypeAlias = List[SampledState]
 
@@ -97,6 +100,28 @@ def get_sampled_state(
     return None
 
 
+def reduce_parsed_states(
+    parsed_states: ParsedStates, outputs: Tuple[Name, ...]
+) -> ParsedStates:
+    return {
+        state: {
+            output: value for output, value in parsed_state.items() if output in outputs
+        }
+        for state, parsed_state in parsed_states.items()
+    }
+
+
+def get_parsed_counts(counts: Counts, parsed_states: ParsedStates) -> ParsedCounts:
+    parsed_counts: ParsedCounts = []
+    for bitstring, count in counts.items():
+        parsed_state = parsed_states[bitstring]
+        if sampled_state := get_sampled_state(parsed_counts, parsed_state):
+            sampled_state.shots += count
+        else:
+            parsed_counts.append(SampledState(state=parsed_state, shots=count))
+    return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
+
+
 class ExecutionDetails(BaseModel, QmodPyObject):
     vendor_format_result: Dict[str, Any] = pydantic.Field(
         ..., description="Result in proprietary vendor format"
@@ -155,14 +180,7 @@ class ExecutionDetails(BaseModel, QmodPyObject):
 
     @property
     def parsed_counts(self) -> ParsedCounts:
-        parsed_counts: ParsedCounts = []
-        for bitstring, count in self.counts.items():
-            parsed_state = self.parsed_states[bitstring]
-            if sampled_state := get_sampled_state(parsed_counts, parsed_state):
-                sampled_state.shots += count
-            else:
-                parsed_counts.append(SampledState(state=parsed_state, shots=count))
-        return sorted(parsed_counts, key=lambda k: k.shots, reverse=True)
+        return get_parsed_counts(self.counts, self.parsed_states)
 
     @property
     def parsed_state_vector(self) -> Optional[ParsedStateVector]:
@@ -223,6 +241,17 @@ class ExecutionDetails(BaseModel, QmodPyObject):
             reduced_counts[reduced_strs] += state_count
         return dict(reduced_counts)
 
+    def parsed_counts_of_outputs(
+        self, output_names: Union[Name, Tuple[Name, ...]]
+    ) -> ParsedCounts:
+        if isinstance(output_names, Name):
+            output_names = (output_names,)
+        if any(name not in self.output_qubits_map for name in output_names):
+            raise ClassiqError(_UNAVAILABLE_OUTPUT_ERROR_MSG)
+
+        reduced_parsed_states = reduce_parsed_states(self.parsed_states, output_names)
+        return get_parsed_counts(self.counts, reduced_parsed_states)
+
     def register_output_from_qubits(self, qubits: Tuple[int, ...]) -> Dict[float, int]:
         register_output: Dict[float, int] = {}
         value_from_str_bin = functools.partial(
@@ -273,7 +302,9 @@ class EstimationResults(VersionedModel):
     def __len__(self) -> int:
         return len(self.results)
 
-    def __iter__(self) -> Iterator[EstimationResult]:  # type: ignore
+    def __iter__(self) -> Iterator[EstimationResult]:  # type: ignore[override]
+        # TODO This is a bug waiting to happen. We change the meaning of
+        # __iter__ in a derived class.
         return iter(self.results)
 
     def __getitem__(self, index: int) -> EstimationResult:

classiq/interface/executor/vqe_result.py

@@ -18,7 +18,7 @@ Solution = Tuple[int, ...]
 class SolverResult(BaseModel):
     energy: float
     # TODO: add time units (like seconds)
-    time: Optional[float]
+    time: Optional[float] = None
     solution: Optional[Solution]
 
 
@@ -63,7 +63,7 @@ class VQESolverResult(SolverResult, QmodPyObject):
         self.convergence_graph.show()
 
     @property
-    def convergence_graph(self):
+    def convergence_graph(self) -> Image.Image:
         return Image.open(io.BytesIO(base64.b64decode(self.convergence_graph_str)))
 
     @property

classiq/interface/finance/function_input.py

@@ -3,12 +3,15 @@ from typing import Any, Dict, Optional, Union
 import pydantic
 
 from classiq.interface.generator.expressions.enums.finance_functions import (
+    FINANCE_FUNCTION_STRING,
     FinanceFunctionType,
 )
 from classiq.interface.helpers.custom_pydantic_types import (
     PydanticNonZeroProbabilityFloat,
 )
 
+from classiq.exceptions import ClassiqValueError
+
 
 class FunctionCondition(pydantic.BaseModel):
     threshold: float
@@ -22,8 +25,9 @@ class FunctionCondition(pydantic.BaseModel):
 
 
 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,13 +49,20 @@ 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.validator("use_chebyshev_polynomial_approximation")
     def _validate_polynomial_flag(
         cls, use_chebyshev_flag: bool, values: Dict[str, Any]
     ) -> bool:
         if use_chebyshev_flag ^ (values.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"
         )
 
@@ -72,7 +83,9 @@ class FinanceFunctionInput(pydantic.BaseModel):
         values: Dict[str, Any],
     ) -> Optional[PydanticNonZeroProbabilityFloat]:
         if values.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
-            raise ValueError("Tail probability must be set for expected shortfall")
+            raise ClassiqValueError(
+                "Tail probability must be set for expected shortfall"
+            )
         return tail_probability
 
     class Config:

classiq/interface/finance/gaussian_model_input.py

@@ -1,5 +1,5 @@
 import math
-from typing import List, Optional, Tuple
+from typing import List, Literal, Optional, Tuple
 
 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 "

classiq/interface/finance/log_normal_model_input.py

@@ -1,4 +1,4 @@
-from typing import Tuple
+from typing import Literal, Tuple
 
 import numpy as np
 import pydantic
@@ -7,6 +7,8 @@ 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."
     )

classiq/interface/finance/model_input.py

@@ -7,6 +7,8 @@ from classiq.interface.helpers.hashable_pydantic_base_model import (
 
 
 class FinanceModelInput(HashablePydanticBaseModel):
+    kind: str
+
     @property
     def num_output_qubits(self) -> int:
         return 0

classiq/interface/generator/amplitude_loading.py

@@ -20,6 +20,7 @@ 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"
@@ -66,14 +67,17 @@ class AmplitudeLoading(FunctionParams):
         not_allowed = literals.intersection(FORBIDDEN_LITERALS)
         variables = literals.difference(SUPPORTED_FUNC_NAMES)
         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")
+            raise ClassiqValueError(f"{variables} must contain exactly single variable")
         return values
 
     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,7 +86,6 @@ 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:

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,14 @@
+from classiq.interface.generator.functions.classical_function_declaration import (
+    ClassicalFunctionDeclaration,
+)
+from classiq.interface.generator.functions.classical_type import Integer, Real
+
+qft_const_adder_phase = ClassicalFunctionDeclaration(
+    name="qft_const_adder_phase",
+    param_decls={
+        "bit_index": Integer(),
+        "value": Integer(),
+        "reg_len": Integer(),
+    },
+    return_type=Real(),
+)