classiq 0.93.0__py3-none-any.whl → 0.100.0__py3-none-any.whl

classiq/interface/generator/qft.py

@@ -1,37 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.function_params import (
-    DEFAULT_INPUT_NAME,
-    DEFAULT_OUTPUT_NAME,
-    FunctionParams,
-)
-
-
-class QFT(FunctionParams):
-    """
-    Creates a quantum Fourier transform on a specified number of qubits.
-    """
-
-    num_qubits: pydantic.PositiveInt = pydantic.Field(
-        description="The number of qubits on which the QFT acts."
-    )
-    approximation_degree: pydantic.NonNegativeInt = pydantic.Field(
-        default=0,
-        description="The degree of approximation (0 for no approximation). The smallest "
-        "'approximation_degree' rotation angles are dropped from the QFT.",
-    )
-    do_swaps: bool = pydantic.Field(
-        default=True, description="Whether to include the final swaps in the QFT."
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            DEFAULT_INPUT_NAME: RegisterArithmeticInfo(size=self.num_qubits)
-        }
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterArithmeticInfo(size=self.num_qubits)
-        }
-
-    def get_power_order(self) -> int:
-        return 4

classiq/interface/generator/qsvm.py

@@ -1,96 +0,0 @@
-from typing import Literal, Optional, Union
-
-import numpy as np
-import pydantic
-from pydantic import ConfigDict
-
-from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqQSVMError, ClassiqValueError
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import (
-    DEFAULT_INPUT_NAME,
-    DEFAULT_OUTPUT_NAME,
-    FunctionParams,
-)
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-VALID_PAULI_LETTERS = ("I", "X", "Y", "Z")
-
-
-class QSVMFeatureMapEntanglement(StrEnum):
-    FULL = "full"
-    LINEAR = "linear"
-    CIRCULAR = "circular"
-    SCA = "sca"
-    PAIRWISE = "pairwise"
-
-
-class QSVMFeatureMapDimensional(HashablePydanticBaseModel):
-    feature_dimension: Optional[int] = None
-    model_config = ConfigDict(frozen=True)
-
-
-class QSVMFeatureMapPauli(QSVMFeatureMapDimensional):
-    map_type: Literal["pauli_feature_map"] = pydantic.Field(default="pauli_feature_map")
-    reps: int = 2
-    entanglement: QSVMFeatureMapEntanglement = QSVMFeatureMapEntanglement.LINEAR
-    alpha: float = 2.0
-    paulis: list[str] = ["Z", "ZZ"]
-    parameter_prefix: str = "x"
-    name: str = "PauliFeatureMap"
-
-    @pydantic.field_validator("paulis", mode="before")
-    @classmethod
-    def set_paulis(cls, paulis: list[str]) -> list[str]:
-        # iterate every letter in every string in the list of paulis
-        for s in paulis:
-            if not all(map(VALID_PAULI_LETTERS.__contains__, s.upper())):
-                raise ClassiqValueError(
-                    f"Invalid pauli string given: {s!r}. Expecting a combination of {VALID_PAULI_LETTERS}"
-                )
-        return list(map(str.upper, paulis))
-
-
-class QSVMFeatureMapBlochSphere(QSVMFeatureMapDimensional):
-    map_type: Literal["bloch_sphere_feature_map"] = pydantic.Field(
-        default="bloch_sphere_feature_map"
-    )
-
-
-FeatureMapType = Union[QSVMFeatureMapBlochSphere, QSVMFeatureMapPauli]
-
-
-class QSVMFeatureMap(FunctionParams):
-    """
-    Feature map circuit used for QSVM
-    """
-
-    feature_map: FeatureMapType = pydantic.Field(
-        description="The feature map for the qsvm",
-        discriminator="map_type",
-    )
-
-    @property
-    def num_qubits(self) -> int:
-        if not self.feature_map.feature_dimension:
-            raise ClassiqQSVMError(
-                "Feature dimension should be provided to create a circuit."
-            )
-        if isinstance(self.feature_map, QSVMFeatureMapPauli):
-            return self.feature_map.feature_dimension
-        else:
-            return int(np.ceil(self.feature_map.feature_dimension / 2))
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            DEFAULT_INPUT_NAME: RegisterUserInput(
-                name=DEFAULT_INPUT_NAME, size=self.num_qubits
-            )
-        }
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterUserInput(
-                name=DEFAULT_OUTPUT_NAME, size=self.num_qubits
-            )
-        }

classiq/interface/generator/state_preparation/__init__.py

@@ -1,14 +0,0 @@
-from .bell_state_preparation import BellStatePreparation
-from .computational_basis_state_preparation import ComputationalBasisStatePreparation
-from .distributions import PMF, GaussianMixture, GaussianMoments
-from .exponential_state_preparation import ExponentialStatePreparation
-from .ghz_state_preparation import GHZStatePreparation
-from .metrics import Metrics
-from .state_preparation import StatePreparation
-from .state_preparation_abc import (
-    DEFAULT_INPUT_NAME,
-    DEFAULT_OUTPUT_NAME,
-    StatePreparationABC,
-)
-from .uniform_distibution_state_preparation import UniformDistributionStatePreparation
-from .w_state_preparation import WStatePreparation

classiq/interface/generator/state_preparation/bell_state_preparation.py

@@ -1,27 +0,0 @@
-from typing import Literal
-
-import pydantic
-
-from classiq.interface.generator.state_preparation.state_preparation_abc import (
-    StatePreparationABC,
-)
-
-BellStateName = Literal["psi+", "psi-", "phi+", "phi-"]
-_ALIGNED_STATES: frozenset[BellStateName] = frozenset({"phi+", "phi-"})
-_SIGNED_STATES: frozenset[BellStateName] = frozenset({"psi-", "phi-"})
-
-
-class BellStatePreparation(StatePreparationABC):
-    name: BellStateName = pydantic.Field(default="phi+")
-
-    @property
-    def aligned(self) -> bool:
-        return self.name in _ALIGNED_STATES
-
-    @property
-    def signed(self) -> bool:
-        return self.name in _SIGNED_STATES
-
-    @property
-    def num_state_qubits(self) -> int:
-        return 2

classiq/interface/generator/state_preparation/computational_basis_state_preparation.py

@@ -1,28 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.control_state import ControlState
-from classiq.interface.generator.state_preparation.state_preparation_abc import (
-    StatePreparationABC,
-)
-from classiq.interface.helpers.custom_pydantic_types import PydanticNonEmptyString
-
-
-class ComputationalBasisStatePreparation(StatePreparationABC):
-    computational_state: PydanticNonEmptyString = pydantic.Field(
-        description="binary computational state to create"
-    )
-
-    @pydantic.field_validator("computational_state")
-    @classmethod
-    def _validate_computational_state(
-        cls, computational_state: PydanticNonEmptyString
-    ) -> PydanticNonEmptyString:
-        ControlState.validate_control_string(computational_state)
-        return computational_state
-
-    @property
-    def num_state_qubits(self) -> int:
-        return len(self.computational_state)
-
-    def get_power_order(self) -> int:
-        return 2

classiq/interface/generator/state_preparation/distributions.py

@@ -1,53 +0,0 @@
-from collections.abc import Collection, Sequence
-from typing import Union
-
-import pydantic
-from numpy.typing import ArrayLike
-from pydantic import ConfigDict
-
-from classiq.interface.generator.validations.validator_functions import (
-    validate_probabilities,
-)
-from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityFloat
-
-
-class PMF(pydantic.BaseModel):
-    pmf: tuple[PydanticProbabilityFloat, ...]
-
-    @pydantic.field_validator("pmf")
-    @classmethod
-    def _validate_pmf(
-        cls, pmf: tuple[PydanticProbabilityFloat, ...]
-    ) -> Sequence[PydanticProbabilityFloat]:
-        return validate_probabilities(cls, pmf)
-
-    model_config = ConfigDict(frozen=True)
-
-
-class GaussianMoments(pydantic.BaseModel):
-    mu: float
-    sigma: pydantic.PositiveFloat
-    model_config = ConfigDict(frozen=True)
-
-
-class GaussianMixture(pydantic.BaseModel):
-    gaussian_moment_list: tuple[GaussianMoments, ...]
-    num_qubits: pydantic.PositiveInt = pydantic.Field(
-        description="Number of qubits for the provided state."
-    )
-    model_config = ConfigDict(frozen=True)
-
-
-Probabilities = Union[PMF, GaussianMixture]
-FlexibleProbabilities = Union[Probabilities, ArrayLike, dict, Collection[float]]
-Amplitudes = tuple[float, ...]
-FlexibleAmplitudes = Union[ArrayLike, Collection[float]]
-Distribution = Union[Amplitudes, Probabilities]
-
-
-def num_of_qubits(distribution: Distribution) -> int:
-    if isinstance(distribution, GaussianMixture):
-        return distribution.num_qubits
-    if isinstance(distribution, PMF):
-        return len(distribution.pmf).bit_length() - 1
-    return len(distribution).bit_length() - 1

classiq/interface/generator/state_preparation/exponential_state_preparation.py

@@ -1,14 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.state_preparation.state_preparation_abc import (
-    StatePreparationABC,
-)
-
-
-class ExponentialStatePreparation(StatePreparationABC):
-    num_qubits: pydantic.PositiveInt = pydantic.Field()
-    rate: float = pydantic.Field()
-
-    @property
-    def num_state_qubits(self) -> int:
-        return self.num_qubits

classiq/interface/generator/state_preparation/ghz_state_preparation.py

@@ -1,14 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.state_preparation.state_preparation_abc import (
-    StatePreparationABC,
-)
-from classiq.interface.helpers.custom_pydantic_types import PydanticLargerThanOneInteger
-
-
-class GHZStatePreparation(StatePreparationABC):
-    num_qubits: PydanticLargerThanOneInteger = pydantic.Field(default=3)
-
-    @property
-    def num_state_qubits(self) -> int:
-        return self.num_qubits

classiq/interface/generator/state_preparation/metrics.py

@@ -1,41 +0,0 @@
-from classiq.interface.enum_utils import StrEnum
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.preferences.optimization import (
-    StatePrepOptimizationMethod,
-)
-
-_AMPLITUDE_SUPPORTING_METRICS: frozenset = frozenset(
-    {"L2", "L1", "MAX_PROBABILITY", "TOTAL_VARIATION"}
-)
-
-_ZERO_DIVERGENT_METRICS: frozenset = frozenset({"KL", "BHATTACHARYYA"})
-
-
-class Metrics(StrEnum):
-    KL = "KL"
-    L2 = "L2"
-    L1 = "L1"
-    MAX_PROBABILITY = "MAX_PROBABILITY"
-    LOSS_OF_FIDELITY = "LOSS_OF_FIDELITY"
-    TOTAL_VARIATION = "TOTAL_VARIATION"
-    HELLINGER = "HELLINGER"
-    BHATTACHARYYA = "BHATTACHARYYA"
-
-    @classmethod
-    def from_sp_optimization_method(
-        cls, sp_opt_method: StatePrepOptimizationMethod
-    ) -> "Metrics":
-        try:
-            return Metrics(sp_opt_method.value)
-        except ValueError:
-            raise ClassiqValueError(
-                f"Failed to convert {sp_opt_method} to an error metric"
-            ) from None
-
-    @property
-    def supports_amplitudes(self) -> bool:
-        return self.value in _AMPLITUDE_SUPPORTING_METRICS
-
-    @property
-    def possibly_diverges(self) -> bool:
-        return self.value in _ZERO_DIVERGENT_METRICS

classiq/interface/generator/state_preparation/state_preparation.py

@@ -1,113 +0,0 @@
-from typing import Optional, Union
-
-import numpy as np
-import pydantic
-from pydantic_core.core_schema import ValidationInfo
-from typing_extensions import Self
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.range_types import NonNegativeFloatRange
-from classiq.interface.generator.state_preparation.distributions import (
-    PMF,
-    Amplitudes,
-    FlexibleAmplitudes,
-    FlexibleProbabilities,
-    GaussianMixture,
-    Probabilities,
-    num_of_qubits,
-)
-from classiq.interface.generator.state_preparation.metrics import Metrics
-from classiq.interface.generator.state_preparation.state_preparation_abc import (
-    StatePreparationABC,
-)
-from classiq.interface.generator.validations.validator_functions import (
-    validate_amplitudes,
-)
-
-
-class StatePreparation(StatePreparationABC):
-    amplitudes: Optional[Amplitudes] = pydantic.Field(
-        description="vector of probabilities",
-        default=None,
-        validate_default=True,
-    )
-    probabilities: Optional[Probabilities] = pydantic.Field(
-        description="vector of amplitudes",
-        default=None,
-        validate_default=True,
-    )
-    error_metric: dict[Metrics, NonNegativeFloatRange] = pydantic.Field(
-        default_factory=lambda: {
-            Metrics.L2: NonNegativeFloatRange(lower_bound=0, upper_bound=1e-4)
-        }
-    )
-    # The order of validations is important: amplitudes, probabilities, error_metric
-
-    @pydantic.field_validator("amplitudes", mode="before")
-    @classmethod
-    def _initialize_amplitudes(
-        cls, amplitudes: Optional[FlexibleAmplitudes]
-    ) -> Optional[Amplitudes]:
-        if amplitudes is None:
-            return None
-        amplitudes = np.array(amplitudes).squeeze()
-        if amplitudes.ndim == 1:
-            return validate_amplitudes(tuple(amplitudes))
-
-        raise ClassiqValueError(
-            "Invalid amplitudes were given, please ensure the amplitude is a vector of float in the form of either tuple or list or numpy array"
-        )
-
-    @pydantic.field_validator("probabilities", mode="before")
-    @classmethod
-    def _initialize_probabilities(
-        cls, probabilities: Optional[FlexibleProbabilities]
-    ) -> Optional[Union[PMF, GaussianMixture, dict]]:
-        if probabilities is None:
-            return None
-        if isinstance(probabilities, Probabilities.__args__):  # type: ignore[attr-defined]
-            return probabilities
-        if isinstance(probabilities, dict):  # a pydantic object
-            return probabilities
-        probabilities = np.array(probabilities).squeeze()
-        if probabilities.ndim == 1:
-            return PMF(pmf=probabilities.tolist())
-
-        raise ClassiqValueError(
-            "Invalid probabilities were given, please ensure the probabilities is a vector of float in the form of either tuple or list or numpy array"
-        )
-
-    @pydantic.field_validator("error_metric", mode="before")
-    @classmethod
-    def _validate_error_metric(
-        cls, error_metric: dict[Metrics, NonNegativeFloatRange], info: ValidationInfo
-    ) -> dict[Metrics, NonNegativeFloatRange]:
-        if not info.data.get("amplitudes"):
-            return error_metric
-        unsupported_metrics = {
-            Metrics(metric).value
-            for metric in error_metric
-            if not Metrics(metric).supports_amplitudes
-        }
-        if unsupported_metrics:
-            raise ClassiqValueError(
-                f"{unsupported_metrics} are not supported for amplitude preparation"
-            )
-        return error_metric
-
-    @pydantic.model_validator(mode="after")
-    def _validate_either_probabilities_or_amplitudes(self) -> Self:
-        amplitudes = self.amplitudes
-        probabilities = self.probabilities
-        if amplitudes is not None and probabilities is not None:
-            raise ClassiqValueError(
-                "StatePreparation can't get both probabilities and amplitudes"
-            )
-        return self
-
-    @property
-    def num_state_qubits(self) -> int:
-        distribution = self.probabilities or self.amplitudes
-        if distribution is None:
-            raise ClassiqValueError("Must have either probabilities or amplitudes")
-        return num_of_qubits(distribution)

classiq/interface/generator/state_preparation/state_preparation_abc.py

@@ -1,24 +0,0 @@
-import abc
-
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import (
-    DEFAULT_INPUT_NAME,
-    DEFAULT_OUTPUT_NAME,
-    FunctionParams,
-)
-
-
-class StatePreparationABC(FunctionParams, abc.ABC):
-    @property
-    @abc.abstractmethod
-    def num_state_qubits(self) -> int:
-        pass
-
-    def _create_ios(self) -> None:
-        self._inputs = dict()
-        self._outputs = {
-            DEFAULT_OUTPUT_NAME: RegisterUserInput(
-                name=DEFAULT_OUTPUT_NAME, size=self.num_state_qubits
-            )
-        }
-        self._create_zero_input_registers({DEFAULT_INPUT_NAME: self.num_state_qubits})

classiq/interface/generator/state_preparation/uniform_distibution_state_preparation.py

@@ -1,13 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.state_preparation.state_preparation_abc import (
-    StatePreparationABC,
-)
-
-
-class UniformDistributionStatePreparation(StatePreparationABC):
-    num_qubits: pydantic.PositiveInt = pydantic.Field(default=2)
-
-    @property
-    def num_state_qubits(self) -> int:
-        return self.num_qubits

classiq/interface/generator/state_preparation/w_state_preparation.py

@@ -1,13 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.state_preparation.state_preparation_abc import (
-    StatePreparationABC,
-)
-
-
-class WStatePreparation(StatePreparationABC):
-    num_qubits: pydantic.PositiveInt = pydantic.Field(default=3)
-
-    @property
-    def num_state_qubits(self) -> int:
-        return self.num_qubits

classiq/interface/generator/ucc.py

@@ -1,74 +0,0 @@
-from collections.abc import Iterable
-from typing import Optional
-
-import pydantic
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.chemistry_function_params import (
-    ChemistryFunctionParams,
-)
-from classiq.interface.generator.excitations import (
-    EXCITATIONS_TYPE,
-    EXCITATIONS_TYPE_EXACT,
-)
-
-_EXCITATIONS_DICT = {"s": 1, "d": 2, "t": 3, "q": 4}
-
-DEFAULT_EXCITATIONS = [1, 2]
-
-
-def default_excitation_factory() -> EXCITATIONS_TYPE_EXACT:
-    return DEFAULT_EXCITATIONS
-
-
-class UCC(ChemistryFunctionParams):
-    """
-    Ucc ansatz
-    """
-
-    use_naive_evolution: bool = pydantic.Field(
-        default=False, description="Whether to evolve the operator naively"
-    )
-    excitations: EXCITATIONS_TYPE = pydantic.Field(
-        default_factory=default_excitation_factory,
-        description="type of excitation operators in the UCC ansatz",
-    )
-    max_depth: Optional[pydantic.PositiveInt] = pydantic.Field(
-        default=None,
-        description="Maximum depth of the generated quantum circuit ansatz",
-    )
-    parameter_prefix: str = pydantic.Field(
-        default="ucc_param_",
-        description="Prefix for the generated parameters",
-    )
-
-    @pydantic.field_validator("excitations")
-    @classmethod
-    def _validate_excitations(cls, excitations: EXCITATIONS_TYPE) -> EXCITATIONS_TYPE:
-        if isinstance(excitations, int):
-            if excitations not in _EXCITATIONS_DICT.values():
-                raise ClassiqValueError(
-                    f"possible values of excitations are {list(_EXCITATIONS_DICT.values())}"
-                )
-            excitations = [excitations]
-
-        elif isinstance(excitations, Iterable):
-            excitations = list(excitations)  # type: ignore[assignment]
-            if all(isinstance(idx, int) for idx in excitations):
-                if any(idx not in _EXCITATIONS_DICT.values() for idx in excitations):
-                    raise ClassiqValueError(
-                        f"possible values of excitations are {list(_EXCITATIONS_DICT.values())}"
-                    )
-
-            elif all(isinstance(idx, str) for idx in excitations):
-                if any(idx not in _EXCITATIONS_DICT.keys() for idx in excitations):
-                    raise ClassiqValueError(
-                        f"possible values of excitations are {list(_EXCITATIONS_DICT.keys())}"
-                    )
-                excitations = sorted(_EXCITATIONS_DICT[idx] for idx in excitations)  # type: ignore[index]
-
-            else:
-                raise ClassiqValueError(
-                    "excitations must be of the same type (all str or all int)"
-                )
-        return excitations

classiq/interface/helpers/backward_compatibility.py

@@ -1,9 +0,0 @@
-import sys
-from typing import Any
-
-if sys.version_info[0:2] >= (3, 10):
-    zip_strict = zip
-else:
-
-    def zip_strict(*iterables: Any, strict: bool = False) -> zip:
-        return zip(*iterables)