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

classiq/builtin_functions/suzuki_trotter.py

@@ -1,3 +0,0 @@
-from classiq.interface.generator.hamiltonian_evolution.suzuki_trotter import (  # noqa: F401
-    SuzukiParameters,
-)

classiq/interface/executor/aws_execution_cost.py

@@ -1,73 +0,0 @@
-from datetime import date
-from typing import Any, Dict, List, Optional
-
-import pydantic
-from pydantic import validator
-
-from classiq._internals.enum_utils import StrEnum
-from classiq.exceptions import ClassiqValueError
-
-
-class Granularity(StrEnum):
-    monthly = "MONTHLY"
-    daily = "DAILY"
-    hourly = "HOURLY"
-
-
-class CostScope(StrEnum):
-    user = "user"
-    organization = "organization"
-
-
-class ExecutionCostForTimePeriod(pydantic.BaseModel):
-    start: date = pydantic.Field(
-        description="The beginning of the time period for tasks usage and cost ("
-        "inclusive).",
-    )
-    end: date = pydantic.Field(
-        description="The end of the time period for tasks usage and cost (exclusive).",
-    )
-    granularity: Granularity = pydantic.Field(
-        description="Either MONTHLY or DAILY, or HOURLY.", default=Granularity.daily
-    )
-    cost_scope: CostScope = pydantic.Field(
-        description="Either user or organization", default=CostScope.user
-    )
-
-    class Config:
-        json_encoders = {date: lambda v: v.strftime("%Y-%m-%d")}
-
-    @validator("end")
-    def date_order(cls, v: date, values: Dict[str, Any], **kwargs: Any) -> date:
-        if "start" in values and v <= values["start"]:
-            raise ClassiqValueError('"end" date should be after "start" date')
-        return v
-
-
-"""The following models describe the aws response model and based on this schema:
-https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/ce.html#CostExplorer.Client.get_cost_and_usage"""
-
-
-class TimePeriod(pydantic.BaseModel):
-    Start: str
-    End: str
-
-
-class BlendedCost(pydantic.BaseModel):
-    Amount: str
-    Unit: str
-
-
-class Total(pydantic.BaseModel):
-    BlendedCost: BlendedCost
-
-
-class ExecutedTaskForPeriodItem(pydantic.BaseModel):
-    TimePeriod: TimePeriod
-    Total: Total
-    Groups: Optional[List]
-    Estimated: Optional[bool]
-
-
-class ExecutionCostForTimePeriodResponse(pydantic.BaseModel):
-    executed_task_for_period: List[ExecutedTaskForPeriodItem]

classiq/interface/executor/error_mitigation.py

@@ -1,6 +0,0 @@
-from classiq._internals.enum_utils import StrEnum
-
-
-class ErrorMitigationMethod(StrEnum):
-    COMPLETE_CALIBRATION = "Complete Calibration"
-    TENSORED_CALIBRATION = "Tensored Calibration"

classiq/interface/generator/credit_risk_example/linear_gci.py

@@ -1,122 +0,0 @@
-from statistics import NormalDist
-from typing import Any, Dict, List, Tuple
-
-import numpy as np
-import pydantic
-
-from classiq.interface.generator import function_params, linear_pauli_rotations
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.helpers.custom_pydantic_types import (
-    PydanticNonOneProbabilityFloat,
-    PydanticProbabilityFloat,
-)
-
-from classiq.exceptions import ClassiqValueError
-
-RHOS_PZEROS_LENGTH_ERROR_MSG = "rhos and p_zeros must have the same length"
-
-
-class LinearGCI(function_params.FunctionParams):
-    """
-    A circuit composed of a series of Y rotations to perform a linear approximation to the Gaussian Conditional
-    Independence model.
-    The model consists of a Bernoulli probability, which itself is a function of a latent random variable x:
-    p(x) = F( (F_inv(p_zero) + x*sqrt(rho))/sqrt(1-rho) )
-    with F being the Gaussian CDF, p_zero is p(x=0) when rho=0, and rho reflects the sensitivity.
-
-    The circuit takes a state register |x> and zero-input target qubits.
-    Each target qubit undergoes the following transformation:
-    |x>|0> -> cos((slope*x + offset)/2)|x>|0> + sin((slope*x + offset)/2)|x>|1>
-    Where the slope and the offset are determined by the linear approximation of the inverse sine of p(x).
-    """
-
-    num_state_qubits: pydantic.PositiveInt = pydantic.Field(
-        description="The number of input qubits"
-    )
-    truncation_value: float = pydantic.Field(
-        description="The truncation value of the latent normal distribution"
-    )
-    p_zeros: List[PydanticProbabilityFloat] = pydantic.Field(
-        description="The probability when the latent normal variable equals zero"
-    )
-    rhos: List[PydanticNonOneProbabilityFloat] = pydantic.Field(
-        description="The sensitivity of the probability to changes in the latent normal variable values"
-    )
-
-    @pydantic.validator("rhos")
-    def validate_rhos(
-        cls, rhos: List[PydanticNonOneProbabilityFloat], values: Dict[str, Any]
-    ) -> List[PydanticNonOneProbabilityFloat]:
-        p_zeros = values.get("p_zeros")
-        if p_zeros is None:
-            raise ClassiqValueError("Cannot validate rhos, p_zeros is missing")
-
-        if len(p_zeros) != len(rhos):
-            raise ClassiqValueError(RHOS_PZEROS_LENGTH_ERROR_MSG)
-        return rhos
-
-    @property
-    def linear_pauli_rotations(self) -> linear_pauli_rotations.LinearPauliRotations:
-        offsets, slopes = get_gci_values(
-            qubit_count_state=self.num_state_qubits,
-            truncation_value=self.truncation_value,
-            rhos=self.rhos,
-            p_zeros=self.p_zeros,
-        )
-        return linear_pauli_rotations.LinearPauliRotations(
-            num_state_qubits=self.num_state_qubits,
-            bases=["Y"] * len(self.rhos),
-            offsets=offsets,
-            slopes=slopes,
-        )
-
-    def _create_ios(self) -> None:
-        state_name = linear_pauli_rotations.STATE
-        target_name = linear_pauli_rotations.TARGET
-        self._inputs = {
-            state_name: RegisterUserInput(name=state_name, size=self.num_state_qubits),
-            target_name: RegisterUserInput(name=target_name, size=len(self.rhos)),
-        }
-        self._outputs = {**self.inputs}
-
-
-def get_gci_values(
-    *,
-    qubit_count_state: int,
-    truncation_value: float,
-    rhos: List[float],
-    p_zeros: List[float],
-) -> Tuple[List[float], List[float]]:
-    qubit_count_target = len(rhos)
-
-    # Qiskit's code below
-
-    # get normal (inverse) CDF and pdf
-    def cdf(x: float) -> float:
-        return NormalDist().cdf(x)
-
-    def inv_cdf(p: float) -> float:
-        return NormalDist().inv_cdf(p)
-
-    def pdf(x: float) -> float:
-        return NormalDist().pdf(x)
-
-    # create linear rotations for conditional defaults
-    slopes = []
-    offsets = []
-    for k in range(qubit_count_target):
-        psi = inv_cdf(p_zeros[k]) / np.sqrt(1 - rhos[k])
-
-        # compute slope / offset
-        slope = -np.sqrt(rhos[k]) / np.sqrt(1 - rhos[k])
-        slope *= pdf(psi) / np.sqrt(1 - cdf(psi)) / np.sqrt(cdf(psi))
-        offset = 2 * np.arcsin(np.sqrt(cdf(psi)))
-
-        # adjust for integer to normal range mapping
-        offset += slope * (-truncation_value)
-        slope *= 2 * truncation_value / (2**qubit_count_state - 1)
-
-        offsets.append(offset)
-        slopes.append(slope)
-
-    return offsets, slopes

classiq/interface/generator/credit_risk_example/weighted_adder.py

@@ -1,69 +0,0 @@
-from typing import Any, Dict, List, Optional
-
-import numpy as np
-import pydantic
-
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import get_zero_input_name
-
-from classiq.exceptions import ClassiqValueError
-
-LENGTH_ERROR_MESSAGE = "Input length error: Length of weights vector has to be identical to the number of input qubits"
-STATE = "state"
-SUM = "sum"
-
-
-class PydanticStrictNonNegativeInteger(pydantic.ConstrainedInt):
-    strict = True
-    ge = 0
-
-
-class WeightedAdder(function_params.FunctionParams):
-    """
-    Creates a circuit implementing a scalar product between an n-qubit state |q1,q2,...,qn> and an n-length non-negative
-    integer vector (w1,w2,...wn), such that the result of the output register is |q1*w1+q2*w2+...qn*wn>.
-    If no weights are provided, they are default to 1 for every qubit.
-    """
-
-    num_state_qubits: pydantic.PositiveInt = pydantic.Field(
-        description="The number of input qubits"
-    )
-    weights: List[PydanticStrictNonNegativeInteger] = pydantic.Field(
-        default=None,
-        description="List of non-negative integers corresponding to the weight of each qubit",
-    )
-
-    @pydantic.validator("weights", always=True, pre=True)
-    def validate_weights(
-        cls,
-        weights: Optional[List[PydanticStrictNonNegativeInteger]],
-        values: Dict[str, Any],
-    ) -> List[PydanticStrictNonNegativeInteger]:
-        num_state_qubits = values.get("num_state_qubits")
-        if num_state_qubits is None:
-            raise ClassiqValueError(
-                "Missing num_state_qubits and weights, either must be provided"
-            )
-        if weights is None:
-            return [PydanticStrictNonNegativeInteger(1)] * num_state_qubits
-        if len(weights) != num_state_qubits:
-            raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
-        return weights
-
-    def num_sum_qubits(self) -> int:
-        sum_weights = np.sum(self.weights)
-        if sum_weights > 0:
-            return 1 + int(np.floor(np.log2(sum_weights)))
-        return 1
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            STATE: RegisterUserInput(name=STATE, size=self.num_state_qubits)
-        }
-        zero_input_name = get_zero_input_name(SUM)
-        self._create_zero_input_registers({zero_input_name: self.num_sum_qubits()})
-        self._outputs = {
-            **self._inputs,
-            SUM: RegisterUserInput(name=SUM, size=self.num_sum_qubits()),
-        }

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

@@ -1,28 +0,0 @@
-import enum
-from typing import Dict
-
-from sympy import Basic, Integer
-
-from classiq.interface.chemistry.elements import ELEMENTS
-from classiq.interface.chemistry.ground_state_problem import (
-    FermionMapping as LibraryFermionMapping,
-)
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-Element = ClassicalEnum("Element", ELEMENTS)  # type: ignore[call-overload]
-
-
-class MolecularBasis(enum.Enum):
-    sto3g = 0
-
-    def to_sympy(self) -> Basic:
-        return Integer(self.value)
-
-    @staticmethod
-    def sympy_locals() -> Dict[str, Basic]:
-        return {f"Basis_{basis.name}": basis.to_sympy() for basis in MolecularBasis}
-
-
-FermionMapping = ClassicalEnum(  # type: ignore[call-overload]
-    "FermionMapping", [mapping.name for mapping in LibraryFermionMapping]
-)

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

@@ -1,5 +0,0 @@
-import enum
-
-
-class ClassicalEnum(int, enum.Enum):
-    pass

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

@@ -1,16 +0,0 @@
-from typing_extensions import assert_never
-
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class LadderOperator(ClassicalEnum):
-    PLUS = 0
-    MINUS = 1
-
-    def __str__(self) -> str:
-        if self is LadderOperator.PLUS:
-            return "+"
-        elif self is LadderOperator.MINUS:
-            return "-"
-        else:
-            assert_never(self)

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

@@ -1,9 +0,0 @@
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class Optimizer(ClassicalEnum):
-    COBYLA = 1
-    SPSA = 2
-    L_BFGS_B = 3
-    NELDER_MEAD = 4
-    ADAM = 5

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

@@ -1,8 +0,0 @@
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class Pauli(ClassicalEnum):
-    I = 0  # noqa: E741
-    X = 1
-    Y = 2
-    Z = 3

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

@@ -1,9 +0,0 @@
-from classiq.interface.generator.expressions.enums.classical_enum import ClassicalEnum
-
-
-class QSVMFeatureMapEntanglement(ClassicalEnum):
-    FULL = 0
-    LINEAR = 1
-    CIRCULAR = 2
-    SCA = 3
-    PAIRWISE = 4

classiq/interface/generator/functions/core_lib_declarations/quantum_functions/__init__.py

@@ -1,18 +0,0 @@
-from classiq.interface.helpers.pydantic_model_helpers import nameables_to_dict
-from classiq.interface.model.quantum_function_declaration import (
-    QuantumFunctionDeclaration,
-)
-
-from .atomic_quantum_functions import *  # noqa: F403
-from .exponentiation_functions import *  # noqa: F403
-from .std_lib_functions import *  # noqa: F403
-
-QuantumFunctionDeclaration.BUILTIN_FUNCTION_DECLARATIONS.update(
-    nameables_to_dict(
-        [
-            func
-            for func in vars().values()
-            if isinstance(func, QuantumFunctionDeclaration)
-        ]
-    )
-)