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

classiq/interface/generator/qpe.py

@@ -1,169 +0,0 @@
-from typing import Any, Optional
-
-import pydantic
-from pydantic import ConfigDict
-from pydantic_core.core_schema import ValidationInfo
-from typing_extensions import Self
-
-from classiq.interface.exceptions import ClassiqMismatchIOsError, ClassiqValueError
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.function_param_list_without_self_reference import (
-    function_param_library_without_self_reference,
-)
-from classiq.interface.generator.function_params import (
-    DEFAULT_ZERO_NAME,
-    FunctionParams,
-    IOName,
-    parse_function_params_values,
-)
-from classiq.interface.generator.hamiltonian_evolution.exponentiation import (
-    Exponentiation,
-)
-from classiq.interface.generator.user_defined_function_params import CustomFunction
-
-PHASE_ESTIMATION_DEFAULT_OUTPUT_NAME = "PHASE_ESTIMATION"
-CUSTOM_FUNCTIONS_IO_MISMATCH_ERROR = (
-    "Custom function provided to the QPE has different input and output names."
-)
-
-
-class ExponentiationScaling(pydantic.BaseModel):
-    """
-    Details of exponentiation scaling for phase estimation.
-    """
-
-    max_depth: pydantic.PositiveInt = pydantic.Field(
-        description="The max_depth of the smallest exponentiation",
-    )
-    max_depth_scaling_factor: pydantic.NonNegativeFloat = pydantic.Field(
-        default=2.0,
-        description="The scaling factor of the exponentiation max_depth; defaults to 2.",
-    )
-    model_config = ConfigDict(frozen=True)
-
-
-class ExponentiationSpecification(pydantic.BaseModel):
-    """
-    Specifications of individual Exponentiation details for each qubit; only valid if Exponentiation is given as unitary_params for PhaseEstimation.
-    This sets the optimization to ExponentiationOptimization.MINIMIZE_ERROR and overrides the max_depth constraints.
-    """
-
-    scaling: Optional[ExponentiationScaling] = pydantic.Field(
-        default=None,
-        description="The scaling of the exponentiation functions.",
-    )
-    max_depths: Optional[tuple[pydantic.NonNegativeInt, ...]] = pydantic.Field(
-        default=None,
-        description="The max_depth of each exponentiation function; overrides scaling.",
-    )
-    model_config = ConfigDict(frozen=True)
-
-    @pydantic.model_validator(mode="after")
-    def _validate_exponentiation_specification(self) -> Self:
-        if self.scaling is None and self.max_depths is None:
-            raise ClassiqValueError("At least one specification must be provided.")
-        return self
-
-
-class PhaseEstimation(FunctionParams):
-    """
-    Quantum phase estimation of a given unitary function.
-    """
-
-    size: pydantic.PositiveInt = pydantic.Field(
-        description="The number of qubits storing the estimated phase."
-    )
-    unitary: str = pydantic.Field(
-        description="The unitary function for phase estimation.",
-    )
-    unitary_params: FunctionParams = pydantic.Field(
-        description="The unitary function parameters.",
-        default_factory=CustomFunction,
-    )
-    exponentiation_specification: Optional[ExponentiationSpecification] = (
-        pydantic.Field(
-            default=None,
-            description="The specifications for phase estimation of exponentiation functions.",
-        )
-    )
-
-    _output_name: IOName = pydantic.PrivateAttr(
-        default=PHASE_ESTIMATION_DEFAULT_OUTPUT_NAME
-    )
-
-    @property
-    def output_name(self) -> str:
-        return self._output_name
-
-    def _create_ios(self) -> None:
-        self._inputs = {**self.unitary_params.inputs}
-        self._outputs = {**self.unitary_params.outputs}
-        self._outputs[self._output_name] = RegisterArithmeticInfo(size=self.size)
-        self._create_zero_input_registers({DEFAULT_ZERO_NAME: self.size})
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _validate_composite_name(cls, values: Any) -> dict[str, Any]:
-        if not isinstance(values, dict):
-            return values
-        unitary_params = values.get("unitary_params")
-        unitary = values.get("unitary")
-
-        if isinstance(unitary_params, CustomFunction) and not unitary:
-            raise ClassiqValueError(
-                "`PhaseEstimation` of a user define function (`CustomFunction`) must receive the function name from the `unitary` field"
-            )
-        return values
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _parse_function_params(
-        cls, values: Any, info: ValidationInfo
-    ) -> dict[str, Any]:
-        vals = info.data.copy() if info.data else {}
-        if isinstance(values, dict):
-            vals = values
-        elif isinstance(values, PhaseEstimation):
-            vals = values.model_dump()
-
-        parse_function_params_values(
-            values=vals,
-            params_key="unitary_params",
-            discriminator_key="unitary",
-            param_classes=function_param_library_without_self_reference.param_list,
-            default_parser_class=CustomFunction,
-        )
-        return vals
-
-    @pydantic.field_validator("unitary_params")
-    @classmethod
-    def _validate_unitary_params(cls, unitary_params: FunctionParams) -> FunctionParams:
-        if not unitary_params.is_powerable():
-            if isinstance(unitary_params, CustomFunction):
-                raise ClassiqMismatchIOsError(CUSTOM_FUNCTIONS_IO_MISMATCH_ERROR)
-            raise ClassiqValueError(
-                f"Phase estimation of {unitary_params.discriminator()} is currently not supported."
-            )
-        return unitary_params
-
-    @pydantic.field_validator("exponentiation_specification")
-    @classmethod
-    def _validate_exponentiation_specification(
-        cls,
-        exponentiation_specification: Optional[ExponentiationSpecification],
-        validation_info: ValidationInfo,
-    ) -> Optional[ExponentiationSpecification]:
-        if exponentiation_specification is None:
-            return exponentiation_specification
-        unitary_params = validation_info.data.get("unitary_params")
-        if not isinstance(unitary_params, Exponentiation):
-            raise ClassiqValueError(
-                "exponentiation_specification is only valid for Exponentiation unitary_params."
-            )
-        if exponentiation_specification.max_depths is not None and len(
-            exponentiation_specification.max_depths
-        ) != validation_info.data.get("size"):
-            raise ClassiqValueError(
-                "Length of max_depths must match the provided size."
-            )
-        return exponentiation_specification

classiq/interface/grover/grover_modelling_params.py

@@ -1,13 +0,0 @@
-import pydantic
-from pydantic import BaseModel
-
-from classiq.interface.generator.oracles import ArithmeticOracle
-
-
-class GroverParams(BaseModel):
-    oracle: ArithmeticOracle = pydantic.Field(
-        description="An arithmatic oracle for the grover search."
-    )
-    num_reps: int = pydantic.Field(
-        default=1, description="The number of repetitions of the " "grover block."
-    )

classiq/model_expansions/transformers/var_splitter.py

@@ -1,224 +0,0 @@
-import ast
-from dataclasses import dataclass
-from itertools import chain
-from typing import TYPE_CHECKING, Callable, Optional
-
-from classiq.interface.exceptions import (
-    ClassiqExpansionError,
-    ClassiqInternalExpansionError,
-)
-from classiq.interface.generator.expressions.expression import Expression
-from classiq.interface.model.bind_operation import BindOperation
-from classiq.interface.model.handle_binding import (
-    HandleBinding,
-    NestedHandleBinding,
-    SlicedHandleBinding,
-    SubscriptHandleBinding,
-)
-from classiq.interface.model.quantum_type import (
-    QuantumBitvector,
-    QuantumScalar,
-    QuantumType,
-)
-from classiq.interface.model.variable_declaration_statement import (
-    VariableDeclarationStatement,
-)
-
-from classiq.model_expansions.scope import QuantumSymbol, Scope
-from classiq.model_expansions.transformers.model_renamer import (
-    HandleRenaming,
-    ModelRenamer,
-)
-from classiq.model_expansions.visitors.variable_references import VarRefCollector
-
-
-@dataclass(frozen=True)
-class SymbolPart(HandleRenaming):
-    target_var_type: QuantumType
-
-
-SymbolParts = dict[HandleBinding, list[SymbolPart]]
-PartNamer = Callable[[str], str]
-
-
-class VarSplitter(ModelRenamer):
-    def __init__(self, scope: Scope):
-        self._scope = scope
-
-    def split_symbols(self, expression: Expression, namer: PartNamer) -> SymbolParts:
-        vrc = VarRefCollector(ignore_duplicated_handles=True)
-        vrc.visit(ast.parse(expression.expr))
-        symbol_names_to_split = dict.fromkeys(
-            handle.name
-            for handle in vrc.var_handles
-            if isinstance(self._scope[handle.name].value, QuantumSymbol)
-            and isinstance(handle, NestedHandleBinding)
-        )
-
-        symbol_handles = {
-            symbol: list(
-                dict.fromkeys(
-                    handle.collapse()
-                    for handle in vrc.var_handles
-                    if handle.name == symbol.handle.name
-                )
-            )
-            for symbol_name in symbol_names_to_split
-            if isinstance(
-                symbol := self._scope[symbol_name].value,
-                QuantumSymbol,
-            )
-        }
-
-        return {
-            symbol.handle: [
-                SymbolPart(
-                    source_handle=part.handle,
-                    target_var_name=namer(part.handle.identifier),
-                    target_var_type=part.quantum_type,
-                )
-                for part in self._get_symbol_parts(symbol, handles)
-            ]
-            for symbol, handles in symbol_handles.items()
-        }
-
-    def _get_symbol_parts(
-        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
-    ) -> list[QuantumSymbol]:
-        for i in range(len(target_parts)):
-            for j in range(i + 1, len(target_parts)):
-                if target_parts[i].overlaps(target_parts[j]):
-                    raise ClassiqInternalExpansionError(
-                        f"Handles {str(target_parts[i])!r} and "
-                        f"{str(target_parts[j])!r} overlapping in expression"
-                    )
-        return self._get_symbol_parts_unsafe(symbol, target_parts)
-
-    def _get_symbol_parts_unsafe(
-        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
-    ) -> list[QuantumSymbol]:
-        if all(
-            symbol.handle == target_part or symbol.handle not in target_part.prefixes()
-            for target_part in target_parts
-        ) or isinstance(symbol.quantum_type, QuantumScalar):
-            return [symbol]
-
-        if isinstance(symbol.quantum_type, QuantumBitvector):
-            return self._get_array_parts(symbol, target_parts)
-
-        return self._get_struct_parts(symbol, target_parts)
-
-    def _get_array_parts(
-        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
-    ) -> list[QuantumSymbol]:
-        if TYPE_CHECKING:
-            assert isinstance(symbol.quantum_type, QuantumBitvector)
-
-        if not symbol.quantum_type.has_length:
-            raise ClassiqExpansionError(
-                f"Could not determine the length of quantum array " f"{symbol.handle}."
-            )
-        target_slices = self._get_target_slices(symbol, target_parts)
-
-        symbol_parts: list[QuantumSymbol] = []
-        idx = 0
-        while idx < symbol.quantum_type.length_value:
-            if idx in target_slices:
-                stop = target_slices[idx]
-                if stop <= idx:
-                    raise ClassiqInternalExpansionError(
-                        f"Illegal sliced handle {str(symbol[idx: stop].handle)!r}"
-                    )
-                symbol_parts.append(symbol[idx:stop])
-                idx = stop
-            else:
-                symbol_parts.extend(
-                    self._get_symbol_parts_unsafe(symbol[idx], target_parts)
-                )
-                idx += 1
-
-        return symbol_parts
-
-    def _get_target_slices(
-        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
-    ) -> dict[int, int]:
-        if TYPE_CHECKING:
-            assert isinstance(symbol.quantum_type, QuantumBitvector)
-        target_items = {
-            idx
-            for idx in range(symbol.quantum_type.length_value)
-            for target_part in target_parts
-            if target_part
-            in SubscriptHandleBinding(
-                base_handle=symbol.handle, index=Expression(expr=str(idx))
-            )
-        }
-        target_slices = {
-            target_part.start.to_int_value(): target_part.end.to_int_value()
-            for target_part in target_parts
-            if isinstance(target_part, SlicedHandleBinding)
-            and symbol.handle == target_part.base_handle
-        }
-        self._add_unused_indices_as_slices(symbol, target_items, target_slices)
-        return target_slices
-
-    @staticmethod
-    def _add_unused_indices_as_slices(
-        symbol: QuantumSymbol, target_items: set[int], target_slices: dict[int, int]
-    ) -> None:
-        if TYPE_CHECKING:
-            assert isinstance(symbol.quantum_type, QuantumBitvector)
-        last_unused_idx: Optional[int] = None
-        array_length = symbol.quantum_type.length_value
-        idx = 0
-
-        while idx < array_length:
-            if (
-                idx in target_items or idx in target_slices
-            ) and last_unused_idx is not None:
-                target_slices[last_unused_idx] = idx
-                last_unused_idx = None
-
-            if idx in target_slices:
-                if target_slices[idx] <= idx:
-                    raise ClassiqInternalExpansionError
-                idx = target_slices[idx]
-                continue
-
-            if idx not in target_items and last_unused_idx is None:
-                last_unused_idx = idx
-
-            idx += 1
-
-        if last_unused_idx is not None:
-            target_slices[last_unused_idx] = array_length
-
-    def _get_struct_parts(
-        self, symbol: QuantumSymbol, target_parts: list[HandleBinding]
-    ) -> list[QuantumSymbol]:
-        return list(
-            chain.from_iterable(
-                self._get_symbol_parts_unsafe(field_symbol, target_parts)
-                for field_symbol in symbol.fields.values()
-            )
-        )
-
-    @staticmethod
-    def get_bind_ops(symbol_parts: SymbolParts) -> list[BindOperation]:
-        return [
-            BindOperation(
-                in_handles=[handle],
-                out_handles=[part.target_var_handle for part in parts],
-            )
-            for handle, parts in symbol_parts.items()
-        ]
-
-    @staticmethod
-    def get_var_decls(symbol_parts: SymbolParts) -> list[VariableDeclarationStatement]:
-        return [
-            VariableDeclarationStatement(
-                name=part.target_var_name,
-                qmod_type=part.target_var_type,
-            )
-            for part in chain.from_iterable(symbol_parts.values())
-        ]