classiq 0.92.0__py3-none-any.whl → 0.99.0__py3-none-any.whl

classiq/interface/generator/entangler_params.py

@@ -1,72 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import FunctionParams
-from classiq.interface.helpers.custom_pydantic_types import PydanticProbabilityFloat
-
-IN_NAME: str = "IN"
-OUT_NAME: str = "OUT"
-
-
-class Entangler(FunctionParams):
-    """
-    A Father class for all entangler classes
-    """
-
-    qubit_count: pydantic.PositiveInt = pydantic.Field(
-        description="The number of qubits for the entangler."
-    )
-    schmidt_rank: pydantic.NonNegativeInt = pydantic.Field(
-        default=0, description="The required schmidt rank (log of schmidt number)."
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {IN_NAME: RegisterUserInput(name=IN_NAME, size=self.qubit_count)}
-        self._outputs = {
-            OUT_NAME: RegisterUserInput(name=OUT_NAME, size=self.qubit_count)
-        }
-
-
-class TwoDimensionalEntangler(Entangler):
-    """
-    Creates a two dimensional cluster state with the specified number of qubits and schmidt rank
-    (log of schmidt number). When the desired schmidt rank is too high, a rectangular grid with schmidt rank
-    floor(sqrt(qubit_count))-1 is generated.
-    """
-
-    pass
-
-
-class HypercubeEntangler(Entangler):
-    """
-    Creates a cluster/graph state in the form of a hypercube with the specified number of qubits. The hypercube is
-    constructed by building cubes of growing dimension therefore if the number of qubits is not a a power of 2 (n=2^k)
-    the last cube will not be completed. for example if n = 11 = 2^3 + 3 a three dimensional cube is constructed
-    connected to additional 3 qubits in the natural order
-    (that is, these qubits will be: 1000, 1001, 1010)
-    """
-
-    pass
-
-
-class GridEntangler(Entangler):
-    """
-    creates a graph state in the form of multi-dimensional grid according to the specified number of qubits and Schmidt
-    rank. If possible the grid will include the exact Schmidt rank if not a smaller grid with a lower schmidt rank is
-    constructed - as close as possible to the specified parameters. if the specified Schmidt rank is too high a 'long'
-    grid with the maximal possible Schmidt rank width is constructed (that still obeys the condition that the largest
-    dimension minus 1 is larger then the sum of the (d_i - 1) -- d_i including all other dimensions)
-    """
-
-    grid_randomization: bool = pydantic.Field(
-        default=True,
-        description="Boolean determining whether the grid structure is randomly selected out of all grids which provide"
-        "the same Schmidt rank width. If False the grid with maximal number of dimensions is selected.",
-    )
-
-    filling_factor: PydanticProbabilityFloat = pydantic.Field(
-        default=1,
-        description="float determining the fraction of cz gates that are included in a circuit for a given grid "
-        "structure. For example, for filling_factor=0.5 half of the cz gates required for the full grid structure are "
-        "included in the output circuit. The cz gates included in the circuit are chosen randomaly.",
-    )

classiq/interface/generator/entanglers.py

@@ -1,14 +0,0 @@
-import pydantic
-from pydantic import BaseModel
-
-from classiq.interface.helpers.custom_pydantic_types import PydanticLargerThanOneInteger
-
-
-class SquareClusterEntanglerParameters(BaseModel):
-    num_of_qubits: PydanticLargerThanOneInteger
-    schmidt_rank: pydantic.NonNegativeInt
-
-
-class Open2DClusterEntanglerParameters(BaseModel):
-    qubit_count: PydanticLargerThanOneInteger
-    schmidt_rank: pydantic.NonNegativeInt

classiq/interface/generator/hamiltonian_evolution/qdrift.py

@@ -1,27 +0,0 @@
-import pydantic
-
-from classiq.interface.chemistry import operator
-from classiq.interface.chemistry.operator import PauliOperator
-from classiq.interface.generator.function_params import FunctionParamsNumericParameter
-from classiq.interface.generator.hamiltonian_evolution.hamiltonian_evolution import (
-    HamiltonianEvolution,
-)
-
-
-class QDrift(HamiltonianEvolution):
-    """
-    qDrift trotterization of a Hermitian operator; see https://arxiv.org/abs/1811.08017
-    """
-
-    evolution_coefficient: FunctionParamsNumericParameter = pydantic.Field(
-        default=1.0,
-        description="A global coefficient multiplying the operator.",
-    )
-    num_qdrift: pydantic.PositiveInt = pydantic.Field(
-        description="The number of elements in the qDrift product.",
-    )
-
-    @pydantic.field_validator("pauli_operator")
-    @classmethod
-    def _validate_is_hermitian(cls, pauli_operator: PauliOperator) -> PauliOperator:
-        return operator.validate_operator_is_hermitian(pauli_operator)

classiq/interface/generator/hartree_fock.py

@@ -1,26 +0,0 @@
-from typing import Any, Union
-
-import pydantic
-
-from classiq.interface.chemistry.ground_state_problem import (
-    CHEMISTRY_PROBLEMS,
-    HamiltonianProblem,
-    MoleculeProblem,
-)
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.chemistry_function_params import (
-    ChemistryFunctionParams,
-)
-
-
-class HartreeFock(ChemistryFunctionParams):
-    @pydantic.field_validator("gs_problem")
-    @classmethod
-    def validate_gs_problem(
-        cls, gs_problem: Any
-    ) -> Union[MoleculeProblem, HamiltonianProblem]:
-        if not isinstance(gs_problem, CHEMISTRY_PROBLEMS):
-            raise ClassiqValueError(
-                f"ground state problem must be of type {CHEMISTRY_PROBLEMS}"
-            )
-        return gs_problem

classiq/interface/generator/hva.py

@@ -1,22 +0,0 @@
-import pydantic
-
-from classiq.interface.generator.chemistry_function_params import (
-    ChemistryFunctionParams,
-)
-
-
-class HVA(ChemistryFunctionParams):
-    """
-    Hamiltonian Variational Ansatz
-    """
-
-    reps: pydantic.PositiveInt = pydantic.Field(
-        default=1, description="Number of layers in the Ansatz"
-    )
-    use_naive_evolution: bool = pydantic.Field(
-        default=False, description="Whether to evolve the operator naively"
-    )
-    parameter_prefix: str = pydantic.Field(
-        default="hva_param_",
-        description="Prefix for the generated parameters",
-    )

classiq/interface/generator/linear_pauli_rotations.py

@@ -1,92 +0,0 @@
-from typing import TYPE_CHECKING, Annotated, Any
-
-import pydantic
-from pydantic import StringConstraints
-from typing_extensions import Self
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator import function_params
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-
-STATE = "state"
-TARGET = "target"
-
-LENGTH_ERROR_MESSAGE = "Field required"
-
-if TYPE_CHECKING:
-    PydanticPauliBasisStr = str
-else:
-    PydanticPauliBasisStr = Annotated[
-        str,
-        StringConstraints(
-            to_lower=True,
-            pattern=r"[xyz]",
-        ),
-    ]
-
-
-class LinearPauliRotations(function_params.FunctionParams):
-    """
-    Perform independent linear rotations on target qubits, each controlled by an identical
-    n-qubit state register |x>.
-
-    Each target qubit, indexed with k and denoted by q_k, undergoes the following transformation:
-    |x>|q_k> -> |x> * [cos(theta(x,k)/2) + i*sin(theta(x,k)/2)*sigma]|q_k>
-    with sigma being 'X', 'Y' or 'Z' Pauli matrix, and the angle is a linear function of the state,
-    theta(x,k)/2 = (slope(k)*x + offset(k))/2.
-
-    For example, a 'Y' rotation on one target qubit will result in a circuit implementing the following logic:
-    |x>|0> -> cos((slope*x + offset)/2)|x>|0> + sin((slope*x + offset)/2)|x>|1>
-
-            q_0: ─────────────────────────■───────── ... ──────────────────────
-                                          │
-                                          .
-                                          │
-        q_(n-1): ─────────────────────────┼───────── ... ───────────■──────────
-                  ┌────────────┐  ┌───────┴───────┐       ┌─────────┴─────────┐
-         target: ─┤ RY(offset) ├──┤ RY(2^0 slope) ├  ...  ┤ RY(2^(n-1) slope) ├
-                  └────────────┘  └───────────────┘       └───────────────────┘
-    """
-
-    num_state_qubits: pydantic.PositiveInt = pydantic.Field(
-        description="The number of input qubits"
-    )
-    bases: list[PydanticPauliBasisStr] = pydantic.Field(
-        description="The types of Pauli rotations ('X', 'Y', 'Z')."
-    )
-    slopes: list[float] = pydantic.Field(
-        description="The slopes of the controlled rotations."
-    )
-    offsets: list[float] = pydantic.Field(
-        description="The offsets of the controlled rotations."
-    )
-
-    @pydantic.field_validator("bases", "slopes", "offsets", mode="before")
-    @classmethod
-    def as_list(cls, v: Any) -> list[Any]:
-        if not isinstance(v, list):
-            v = [v]
-        res = []
-        for x in v:
-            element = x
-            if isinstance(x, str):
-                res.append(element.lower())
-            else:
-                res.append(element)
-        return res
-
-    @pydantic.model_validator(mode="after")
-    def validate_lists(self) -> Self:
-        offsets = self.offsets or list()
-        bases = self.bases or list()
-        slopes = self.slopes or list()
-        if len(slopes) == len(offsets) and len(offsets) == len(bases):
-            return self
-        raise ClassiqValueError(LENGTH_ERROR_MESSAGE)
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            STATE: RegisterArithmeticInfo(size=self.num_state_qubits),
-            TARGET: RegisterArithmeticInfo(size=len(self.bases)),
-        }
-        self._outputs = {**self.inputs}

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