classiq 0.86.1__py3-none-any.whl → 0.88.0__py3-none-any.whl

classiq/interface/finance/function_input.py

@@ -1,102 +0,0 @@
-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 (
-    PydanticNonZeroProbabilityFloat,
-)
-
-
-class FunctionCondition(pydantic.BaseModel):
-    threshold: float
-    larger: bool = pydantic.Field(
-        default=False,
-        description="When true, function is set when input is larger to threshold and otherwise 0. Default is False.",
-    )
-    model_config = ConfigDict(frozen=True)
-
-
-class FinanceFunctionInput(pydantic.BaseModel):
-    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"
-    )
-    condition: FunctionCondition = pydantic.Field(
-        description="The condition for the function"
-    )
-    polynomial_degree: Optional[int] = pydantic.Field(
-        default=None,
-        description="The polynomial degree of approximation, uses linear approximation by default",
-    )
-    use_chebyshev_polynomial_approximation: bool = pydantic.Field(
-        default=False,
-        description="Flag if to use chebyshev polynomial approximation for target function",
-    )
-
-    tail_probability: Optional[PydanticNonZeroProbabilityFloat] = pydantic.Field(
-        default=None,
-        description="The required probability on the tail of the distribution (1 - percentile)",
-    )
-
-    @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, info: ValidationInfo
-    ) -> bool:
-        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.field_validator("f", mode="before")
-    @classmethod
-    def _validate_finance_function(
-        cls, f: Union[int, str, "FinanceFunctionType"]
-    ) -> FinanceFunctionType:
-        if isinstance(f, FinanceFunctionType):
-            return f
-        if isinstance(f, int):
-            return FinanceFunctionType(f)
-        return get_finance_function_dict()[f]
-
-    @pydantic.field_validator("tail_probability", mode="before")
-    @classmethod
-    def _validate_tail_probability_assignment_for_shortfall(
-        cls,
-        tail_probability: Optional[PydanticNonZeroProbabilityFloat],
-        info: ValidationInfo,
-    ) -> Optional[PydanticNonZeroProbabilityFloat]:
-        if info.data.get("f") == FinanceFunctionType.SHORTFALL and not tail_probability:
-            raise ClassiqValueError(
-                "Tail probability must be set for expected shortfall"
-            )
-        return tail_probability
-
-    model_config = ConfigDict(frozen=True)

classiq/interface/finance/gaussian_model_input.py

@@ -1,50 +0,0 @@
-import math
-from typing import Literal, Optional
-
-import pydantic
-
-from classiq.interface.finance.model_input import FinanceModelInput
-from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityFloat
-
-
-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 "
-        "the random variable Z)."
-    )
-    normal_max_value: float = pydantic.Field(
-        description="Min/max value to truncate the " "latent normal random variable Z"
-    )
-    default_probabilities: list[PydanticProbabilityFloat] = pydantic.Field(
-        description="default probabilities for each asset"
-    )
-
-    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(
-        description="List of ints signifying loss per asset"
-    )
-    min_loss: Optional[int] = pydantic.Field(
-        description="Minimum possible loss for the model "
-    )
-
-    @property
-    def num_model_qubits(self) -> int:
-        return len(self.rhos)
-
-    @property
-    def distribution_range(self) -> tuple[float, float]:
-        return 0, sum(self.loss)
-
-    @property
-    def num_output_qubits(self) -> int:
-        return int(math.log2(sum(self.loss))) + 1
-
-    @property
-    def num_bernoulli_qubits(self) -> int:
-        return self.num_qubits + self.num_model_qubits

classiq/interface/finance/log_normal_model_input.py

@@ -1,40 +0,0 @@
-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."
-    )
-    mu: pydantic.NonNegativeFloat = pydantic.Field(
-        description="Mean of the Normal distribution variable X s.t. ln(X) ~ log-normal."
-    )
-    sigma: pydantic.PositiveFloat = pydantic.Field(
-        description="Std of the Normal distribution variable X s.t. ln(X) ~ log-normal."
-    )
-
-    @property
-    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)
-        low = np.maximum(0, mean - 3 * stddev)
-        high = mean + 3 * stddev
-        return low, high
-
-    @property
-    def num_model_qubits(self) -> int:
-        return self.num_qubits
-
-    @property
-    def num_output_qubits(self) -> int:
-        return self.num_qubits
-
-    model_config = ConfigDict(frozen=True)

classiq/interface/finance/model_input.py

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

classiq/interface/generator/amplitude_estimation.py

@@ -1,34 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.function_params import FunctionParams
-from classiq.interface.generator.grover_operator import GroverOperator
-
-ESTIMATED_AMPLITUDE_OUTPUT_NAME: str = "ESTIMATED_AMPLITUDE_OUTPUT"
-
-
-class AmplitudeEstimation(FunctionParams):
-    """
-    Creates a quantum circuit for amplitude estimation
-    Provide the state preparation and oracle within the GroverOperator parameter
-    Choose estimation accuracy with the estimation_register_size parameter
-    """
-
-    grover_operator: GroverOperator = pydantic.Field(
-        description="The Grover Operator used in the algorithm. "
-        "Composed of the oracle and the state preparation operator."
-    )
-
-    estimation_register_size: pydantic.PositiveInt = pydantic.Field(
-        description="The number of qubits used to estimate the amplitude. "
-        "Bigger register provides a better estimate of the good states' amplitude."
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = dict()
-        self._outputs = {
-            ESTIMATED_AMPLITUDE_OUTPUT_NAME: RegisterArithmeticInfo(
-                size=self.estimation_register_size
-            ),
-            **self.grover_operator.outputs,
-        }

classiq/interface/generator/application_apis/finance_declarations.py

@@ -1,108 +0,0 @@
-from collections.abc import Mapping
-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 Real
-from classiq.interface.generator.functions.port_declaration import (
-    PortDeclarationDirection,
-)
-from classiq.interface.generator.functions.type_modifier import TypeModifier
-from classiq.interface.generator.functions.type_name import Struct
-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 (
-    NamedParamsQuantumFunctionDeclaration,
-)
-from classiq.interface.model.quantum_type import QuantumBit, QuantumBitvector
-
-FUNCTION_PORT_NAME = "func_port"
-OBJECTIVE_PORT_NAME = "obj_port"
-
-
-class FinanceModelType(Enum):
-    LogNormal = "log_normal"
-    Gaussian = "gaussian"
-
-
-FINANCE_FUNCTION_PORT_SIZE_MAPPING: Mapping[FinanceModelType, str] = {
-    FinanceModelType.Gaussian: "get_field(finance_model, 'num_qubits') + get_field(get_field(finance_model, 'rhos'), 'len') + floor(log(sum(get_field(finance_model, 'loss')), 2)) + 1",
-    FinanceModelType.LogNormal: "get_field(finance_model, 'num_qubits')",
-}
-
-
-def _generate_finance_function(
-    finance_model: FinanceModelType,
-) -> NamedParamsQuantumFunctionDeclaration:
-    return NamedParamsQuantumFunctionDeclaration(
-        name=f"{finance_model.value}_finance",
-        positional_arg_declarations=[
-            ClassicalParameterDeclaration(
-                name="finance_model",
-                classical_type=Struct(name=f"{finance_model.name}Model"),
-            ),
-            ClassicalParameterDeclaration(
-                name="finance_function", classical_type=Struct(name="FinanceFunction")
-            ),
-            PortDeclaration(
-                name=FUNCTION_PORT_NAME,
-                quantum_type=QuantumBitvector(
-                    length=Expression(
-                        expr=FINANCE_FUNCTION_PORT_SIZE_MAPPING[finance_model]
-                    )
-                ),
-                direction=PortDeclarationDirection.Inout,
-                type_modifier=TypeModifier.Mutable,
-            ),
-            PortDeclaration(
-                name=OBJECTIVE_PORT_NAME,
-                quantum_type=QuantumBit(),
-                direction=PortDeclarationDirection.Inout,
-                type_modifier=TypeModifier.Mutable,
-            ),
-        ],
-    )
-
-
-LOG_NORMAL_FINANCE_FUNCTION = _generate_finance_function(FinanceModelType.LogNormal)
-
-GAUSSIAN_FINANCE_FUNCTION = _generate_finance_function(FinanceModelType.Gaussian)
-
-LOG_NORMAL_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
-    name="log_normal_finance_post_process",
-    positional_parameters=[
-        ClassicalParameterDeclaration(
-            name="finance_model", classical_type=Struct(name="LogNormalModel")
-        ),
-        ClassicalParameterDeclaration(
-            name="estimation_method", classical_type=Struct(name="FinanceFunction")
-        ),
-        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
-    ],
-    return_type=Real(),
-)
-
-GAUSSIAN_FINANCE_POST_PROCESS = ClassicalFunctionDeclaration(
-    name="gaussian_finance_post_process",
-    positional_parameters=[
-        ClassicalParameterDeclaration(
-            name="finance_model", classical_type=Struct(name="GaussianModel")
-        ),
-        ClassicalParameterDeclaration(
-            name="estimation_method", classical_type=Struct(name="FinanceFunction")
-        ),
-        ClassicalParameterDeclaration(name="probability", classical_type=Real()),
-    ],
-    return_type=Real(),
-)
-
-__all__ = [
-    "GAUSSIAN_FINANCE_FUNCTION",
-    "GAUSSIAN_FINANCE_POST_PROCESS",
-    "LOG_NORMAL_FINANCE_FUNCTION",
-    "LOG_NORMAL_FINANCE_POST_PROCESS",
-]

classiq/interface/generator/expressions/enums/finance_functions.py

@@ -1,12 +0,0 @@
-from classiq.interface.generator.types.builtin_enum_declarations import (
-    FinanceFunctionType,
-)
-
-
-def get_finance_function_dict() -> dict[str, "FinanceFunctionType"]:
-    return {
-        "var": FinanceFunctionType.VAR,
-        "expected shortfall": FinanceFunctionType.SHORTFALL,
-        "x**2": FinanceFunctionType.X_SQUARE,
-        "european call option": FinanceFunctionType.EUROPEAN_CALL_OPTION,
-    }

classiq/interface/generator/finance.py

@@ -1,107 +0,0 @@
-from __future__ import annotations
-
-from typing import Union
-
-import pydantic
-
-from classiq.interface.finance.function_input import FinanceFunctionInput
-from classiq.interface.finance.gaussian_model_input import GaussianModelInput
-from classiq.interface.finance.log_normal_model_input import LogNormalModelInput
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import DEFAULT_ZERO_NAME
-
-FUNCTION_INPUT_NAME = "function_in"
-FUNCTION_OUTPUT_NAME = "function_out"
-OBJECTIVE_INPUT_NAME = "objective_in"
-OBJECTIVE_OUTPUT_NAME = "objective_out"
-DEFAULT_POST_INPUT_NAME = "post_function_input"
-
-
-class Finance(function_params.FunctionParams):
-    model: Union[GaussianModelInput, LogNormalModelInput] = pydantic.Field(
-        description="Load a financial model", discriminator="kind"
-    )
-    finance_function: FinanceFunctionInput = pydantic.Field(
-        description="The finance function to solve the model"
-    )
-
-    def _create_ios(self) -> None:
-        finance_model = FinanceModels(model=self.model)
-        # 1 for the objective qubit
-        function_size = sum(
-            reg.size for reg in finance_model._outputs.values() if reg is not None
-        )
-        self._inputs = {
-            FUNCTION_INPUT_NAME: RegisterUserInput(
-                name=FUNCTION_INPUT_NAME, size=function_size
-            ),
-            OBJECTIVE_INPUT_NAME: RegisterUserInput(name=OBJECTIVE_INPUT_NAME, size=1),
-        }
-        self._outputs = {
-            FUNCTION_OUTPUT_NAME: RegisterUserInput(
-                name=FUNCTION_OUTPUT_NAME, size=function_size
-            ),
-            OBJECTIVE_OUTPUT_NAME: RegisterUserInput(
-                name=OBJECTIVE_OUTPUT_NAME, size=1
-            ),
-        }
-
-
-DEFAULT_INPUT_NAME = "in"
-DEFAULT_OUTPUT_NAME = "out"
-DEFAULT_BERNOULLI_OUTPUT_NAME = "bernoulli_random_variables"
-
-
-class FinanceModels(function_params.FunctionParams):
-    model: Union[GaussianModelInput, LogNormalModelInput] = pydantic.Field(
-        description="Load a financial model"
-    )
-
-    def _create_ios(self) -> None:
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterUserInput(
-                name=DEFAULT_OUTPUT_NAME, size=self.model.num_output_qubits
-            )
-        }
-        if isinstance(self.model, GaussianModelInput):
-            self._inputs = {
-                DEFAULT_INPUT_NAME: RegisterUserInput(
-                    name=DEFAULT_INPUT_NAME, size=self.model.num_bernoulli_qubits
-                )
-            }
-            self._create_zero_input_registers(
-                {DEFAULT_ZERO_NAME: self.model.num_output_qubits}
-            )
-            self._outputs[DEFAULT_BERNOULLI_OUTPUT_NAME] = RegisterUserInput(
-                name=DEFAULT_BERNOULLI_OUTPUT_NAME,
-                size=self.model.num_bernoulli_qubits,
-            )
-        elif isinstance(self.model, LogNormalModelInput):
-            self._inputs = {
-                DEFAULT_INPUT_NAME: RegisterUserInput(
-                    name=DEFAULT_INPUT_NAME, size=self.model.num_model_qubits
-                )
-            }
-
-
-class FinancePayoff(function_params.FunctionParams):
-    finance_function: FinanceFunctionInput = pydantic.Field(
-        description="The finance function to solve the model"
-    )
-    num_qubits: pydantic.PositiveInt
-    distribution_range: tuple[float, float]
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            DEFAULT_INPUT_NAME: RegisterUserInput(
-                name=DEFAULT_INPUT_NAME, size=self.num_qubits
-            )
-        }
-        self._create_zero_input_registers({DEFAULT_ZERO_NAME: 1})
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterUserInput(name=DEFAULT_OUTPUT_NAME, size=1),
-            DEFAULT_POST_INPUT_NAME: RegisterUserInput(
-                name=DEFAULT_INPUT_NAME, size=self.num_qubits
-            ),
-        }

classiq/interface/generator/function_param_list_without_self_reference.py

@@ -1,160 +0,0 @@
-import itertools
-
-from classiq.interface.generator.amplitude_estimation import AmplitudeEstimation
-from classiq.interface.generator.amplitude_loading import AmplitudeLoading
-from classiq.interface.generator.arith.arithmetic import Arithmetic
-from classiq.interface.generator.arith.binary_ops import (
-    Adder,
-    BitwiseAnd,
-    BitwiseOr,
-    BitwiseXor,
-    CyclicShift,
-    Equal,
-    GreaterEqual,
-    GreaterThan,
-    LessEqual,
-    LessThan,
-    LShift,
-    Modulo,
-    Multiplier,
-    NotEqual,
-    Power,
-    RShift,
-    Subtractor,
-)
-from classiq.interface.generator.arith.extremum_operations import Max, Min
-from classiq.interface.generator.arith.logical_ops import LogicalAnd, LogicalOr
-from classiq.interface.generator.arith.unary_ops import BitwiseInvert, Negation, Sign
-from classiq.interface.generator.commuting_pauli_exponentiation import (
-    CommutingPauliExponentiation,
-)
-from classiq.interface.generator.copy import Copy
-from classiq.interface.generator.entangler_params import (
-    GridEntangler,
-    HypercubeEntangler,
-    TwoDimensionalEntangler,
-)
-from classiq.interface.generator.finance import Finance, FinanceModels, FinancePayoff
-from classiq.interface.generator.function_param_library import FunctionParamLibrary
-from classiq.interface.generator.grover_diffuser import GroverDiffuser
-from classiq.interface.generator.grover_operator import GroverOperator
-from classiq.interface.generator.hadamard_transform import HadamardTransform
-from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
-    Exponentiation,
-)
-from classiq.interface.generator.hamiltonian_evolution.qdrift import QDrift
-from classiq.interface.generator.hamiltonian_evolution.suzuki_trotter import (
-    SuzukiTrotter,
-)
-from classiq.interface.generator.hardware_efficient_ansatz import (
-    HardwareEfficientAnsatz,
-)
-from classiq.interface.generator.hartree_fock import HartreeFock
-from classiq.interface.generator.hva import HVA
-from classiq.interface.generator.identity import Identity
-from classiq.interface.generator.linear_pauli_rotations import LinearPauliRotations
-from classiq.interface.generator.mcu import Mcu
-from classiq.interface.generator.mcx import Mcx
-from classiq.interface.generator.oracles.oracle_function_param_list import (
-    oracle_function_param_library,
-)
-from classiq.interface.generator.piecewise_linear_amplitude_loading import (
-    PiecewiseLinearAmplitudeLoading,
-    PiecewiseLinearRotationAmplitudeLoading,
-)
-from classiq.interface.generator.qft import QFT
-from classiq.interface.generator.qsvm import QSVMFeatureMap
-from classiq.interface.generator.randomized_benchmarking import RandomizedBenchmarking
-from classiq.interface.generator.reset import Reset
-from classiq.interface.generator.standard_gates.standard_gates_param_list import (
-    standard_gate_function_param_library,
-)
-from classiq.interface.generator.standard_gates.u_gate import UGate
-from classiq.interface.generator.state_preparation import (
-    BellStatePreparation,
-    ComputationalBasisStatePreparation,
-    ExponentialStatePreparation,
-    GHZStatePreparation,
-    StatePreparation,
-    UniformDistributionStatePreparation,
-    WStatePreparation,
-)
-from classiq.interface.generator.ucc import UCC
-from classiq.interface.generator.unitary_gate import UnitaryGate
-from classiq.interface.generator.user_defined_function_params import CustomFunction
-
-function_param_library_without_self_reference: FunctionParamLibrary = (
-    FunctionParamLibrary(
-        param_list=itertools.chain(
-            {
-                StatePreparation,
-                ComputationalBasisStatePreparation,
-                UniformDistributionStatePreparation,
-                BellStatePreparation,
-                GHZStatePreparation,
-                WStatePreparation,
-                ExponentialStatePreparation,
-                QFT,
-                BitwiseAnd,
-                BitwiseOr,
-                BitwiseXor,
-                BitwiseInvert,
-                Adder,
-                Arithmetic,
-                Sign,
-                Equal,
-                NotEqual,
-                GreaterThan,
-                GreaterEqual,
-                LessThan,
-                LessEqual,
-                Negation,
-                LogicalAnd,
-                LogicalOr,
-                Subtractor,
-                RShift,
-                LShift,
-                CyclicShift,
-                Modulo,
-                TwoDimensionalEntangler,
-                Finance,
-                FinanceModels,
-                FinancePayoff,
-                HypercubeEntangler,
-                AmplitudeEstimation,
-                GridEntangler,
-                GroverDiffuser,
-                GroverOperator,
-                Mcx,
-                Mcu,
-                CustomFunction,
-                HardwareEfficientAnsatz,
-                UnitaryGate,
-                LinearPauliRotations,
-                Multiplier,
-                Power,
-                HartreeFock,
-                UCC,
-                Min,
-                Max,
-                Exponentiation,
-                CommutingPauliExponentiation,
-                SuzukiTrotter,
-                QDrift,
-                Identity,
-                RandomizedBenchmarking,
-                HVA,
-                UGate,
-                AmplitudeLoading,
-                QSVMFeatureMap,
-                PiecewiseLinearAmplitudeLoading,
-                PiecewiseLinearRotationAmplitudeLoading,
-                HadamardTransform,
-                Copy,
-                Reset,
-            },
-            standard_gate_function_param_library.param_list,
-            oracle_function_param_library.param_list,
-        )
-    )
-)