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

classiq/interface/generator/application_apis/chemistry_declarations.py

@@ -1,69 +0,0 @@
-from enum import Enum
-
-from classiq.interface.generator.functions.classical_function_declaration import (
-    ClassicalFunctionDeclaration,
-)
-from classiq.interface.generator.functions.classical_type import (
-    ClassicalArray,
-    VQEResult,
-)
-from classiq.interface.generator.functions.type_name import Struct
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
-
-MOLECULE_PROBLEM_PARAM = ClassicalParameterDeclaration(
-    name="molecule_problem", classical_type=Struct(name="MoleculeProblem")
-)
-
-FOCK_HAMILTONIAN_PROBLEM_PARAM = ClassicalParameterDeclaration(
-    name="fock_hamiltonian_problem",
-    classical_type=Struct(name="FockHamiltonianProblem"),
-)
-FOCK_HAMILTONIAN_SIZE = (
-    "fock_hamiltonian_problem_to_hamiltonian(fock_hamiltonian_problem)[0].pauli.len"
-)
-
-
-class ChemistryProblemType(Enum):
-    MoleculeProblem = "molecule_problem"
-    FockHamiltonianProblem = "fock_hamiltonian_problem"
-
-
-MOLECULE_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
-    name="molecule_problem_to_hamiltonian",
-    positional_parameters=[
-        ClassicalParameterDeclaration(
-            name="problem", classical_type=Struct(name="MoleculeProblem")
-        ),
-    ],
-    return_type=ClassicalArray(element_type=Struct(name="PauliTerm")),
-)
-
-FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN = ClassicalFunctionDeclaration(
-    name="fock_hamiltonian_problem_to_hamiltonian",
-    positional_parameters=[
-        ClassicalParameterDeclaration(
-            name="problem", classical_type=Struct(name="FockHamiltonianProblem")
-        ),
-    ],
-    return_type=ClassicalArray(element_type=Struct(name="PauliTerm")),
-)
-
-
-MOLECULE_GROUND_STATE_SOLUTION_POST_PROCESS = ClassicalFunctionDeclaration(
-    name="molecule_ground_state_solution_post_process",
-    positional_parameters=[
-        ClassicalParameterDeclaration(
-            name="problem", classical_type=Struct(name="MoleculeProblem")
-        ),
-        ClassicalParameterDeclaration(name="vqe_result", classical_type=VQEResult()),
-    ],
-    return_type=Struct(name="MoleculeResult"),
-)
-
-__all__ = [
-    "FOCK_HAMILTONIAN_PROBLEM_TO_HAMILTONIAN",
-    "MOLECULE_GROUND_STATE_SOLUTION_POST_PROCESS",
-    "MOLECULE_PROBLEM_TO_HAMILTONIAN",
-]

classiq/interface/generator/application_apis/entangler_declarations.py

@@ -1,29 +0,0 @@
-from classiq.interface.generator.functions.classical_function_declaration import (
-    ClassicalFunctionDeclaration,
-)
-from classiq.interface.generator.functions.classical_type import (
-    Bool,
-    ClassicalArray,
-    Integer,
-)
-from classiq.interface.model.classical_parameter_declaration import (
-    ClassicalParameterDeclaration,
-)
-
-GRID_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
-    name="grid_entangler_graph",
-    positional_parameters=[
-        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
-        ClassicalParameterDeclaration(name="schmidt_rank", classical_type=Integer()),
-        ClassicalParameterDeclaration(name="grid_randomization", classical_type=Bool()),
-    ],
-    return_type=ClassicalArray(element_type=ClassicalArray(element_type=Integer())),
-)
-
-HYPERCUBE_ENTANGLER_GRAPH = ClassicalFunctionDeclaration(
-    name="hypercube_entangler_graph",
-    positional_parameters=[
-        ClassicalParameterDeclaration(name="num_qubits", classical_type=Integer()),
-    ],
-    return_type=ClassicalArray(element_type=ClassicalArray(element_type=Integer())),
-)

classiq/interface/generator/chemistry_function_params.py

@@ -1,50 +0,0 @@
-import pydantic
-
-from classiq.interface.chemistry.ground_state_problem import (
-    CHEMISTRY_PROBLEMS_TYPE,
-    GroundStateProblem,
-)
-from classiq.interface.exceptions import 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,
-)
-
-
-class ChemistryFunctionParams(FunctionParams):
-    gs_problem: CHEMISTRY_PROBLEMS_TYPE
-
-    @pydantic.field_validator("gs_problem")
-    @classmethod
-    def validate_gs_problem_contains_num_qubits(
-        cls, gs_problem: CHEMISTRY_PROBLEMS_TYPE
-    ) -> CHEMISTRY_PROBLEMS_TYPE:
-        if not gs_problem.num_qubits:
-            raise ClassiqValueError(
-                "Ground state problem doesn't contain num_qubits. "
-                "Use update_problem method."
-            )
-
-        return gs_problem
-
-    @property
-    def num_qubits(self) -> int:
-        assert isinstance(
-            self.gs_problem, GroundStateProblem
-        ), "self.gs_problem is not from GroundStateProblem class"
-        assert isinstance(self.gs_problem.num_qubits, int)
-        return self.gs_problem.num_qubits
-
-    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/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/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/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)