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

classiq/interface/generator/grover_diffuser.py

@@ -1,93 +0,0 @@
-from typing import Any, Union
-
-import pydantic
-from pydantic_core.core_schema import ValidationInfo
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import (
-    ArithmeticIODict,
-    FunctionParams,
-    parse_function_params_values,
-)
-from classiq.interface.generator.state_preparation import StatePreparation
-from classiq.interface.generator.user_defined_function_params import CustomFunction
-
-GroverStatePreparation = Union[StatePreparation, CustomFunction]
-
-
-class GroverDiffuser(FunctionParams):
-    variables: list[RegisterUserInput]
-    state_preparation: str = pydantic.Field(
-        default="", description="State preparation function"
-    )
-    state_preparation_params: GroverStatePreparation = pydantic.Field(
-        description="State preparation function parameters",
-        default_factory=CustomFunction,
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {reg.name: reg for reg in self.variables}
-        self._outputs = {reg.name: reg for reg in self.variables}
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _validate_state_preparation_name(cls, values: Any) -> dict[str, Any]:
-        if (
-            isinstance(values, dict)
-            and isinstance(values.get("state_preparation_params"), CustomFunction)
-            and not values.get("state_preparation")
-        ):
-            raise ClassiqValueError(
-                "Must receive the function name from the `state_preparation` field for user defined functions"
-            )
-        return values
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _parse_state_preparation(cls, values: Any) -> dict[str, Any]:
-        if isinstance(values, dict):
-            parse_function_params_values(
-                values=values,
-                params_key="state_preparation_params",
-                discriminator_key="state_preparation",
-                param_classes={StatePreparation, CustomFunction},
-                default_parser_class=CustomFunction,
-            )
-        return values
-
-    @pydantic.field_validator("variables")
-    @classmethod
-    def _validate_variables(
-        cls, variables: list[RegisterUserInput]
-    ) -> list[RegisterUserInput]:
-        names = {reg.name for reg in variables}
-        assert len(variables) == len(names), "Repeating names not allowed"
-        return variables
-
-    @pydantic.field_validator("state_preparation_params")
-    @classmethod
-    def _validate_state_preparation(
-        cls, state_preparation_params: GroverStatePreparation, info: ValidationInfo
-    ) -> GroverStatePreparation:
-        variables = info.data.get("variables", list())
-        sp_inputs = state_preparation_params.inputs_full(strict_zero_ios=False)
-        sp_outputs = state_preparation_params.outputs
-        if len(sp_inputs) == 1 and len(sp_outputs) == 1:
-            var_size = sum(reg.size for reg in variables)
-            assert (
-                state_preparation_params.num_input_qubits(strict_zero_ios=False)
-                == var_size
-            )
-            assert state_preparation_params.num_output_qubits == var_size
-        else:
-            variable_names_and_sizes = cls._names_and_sizes(
-                {var.name: var for var in variables}
-            )
-            assert cls._names_and_sizes(sp_inputs) == variable_names_and_sizes
-            assert cls._names_and_sizes(sp_outputs) == variable_names_and_sizes
-        return state_preparation_params
-
-    @staticmethod
-    def _names_and_sizes(transputs: ArithmeticIODict) -> set[tuple[str, int]]:
-        return {(name, reg.size) for name, reg in transputs.items()}

classiq/interface/generator/grover_operator.py

@@ -1,106 +0,0 @@
-from typing import Any, Optional
-
-import pydantic
-from pydantic_core.core_schema import ValidationInfo
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.function_params import (
-    FunctionParams,
-    FunctionParamsDiscriminator,
-    parse_function_params,
-)
-from classiq.interface.generator.grover_diffuser import (
-    GroverDiffuser,
-    GroverStatePreparation,
-)
-from classiq.interface.generator.oracles import ArithmeticOracle, OracleABC
-from classiq.interface.generator.oracles.oracle_function_param_list import (
-    oracle_function_param_library,
-)
-from classiq.interface.generator.range_types import NonNegativeFloatRange
-from classiq.interface.generator.state_preparation import Metrics, StatePreparation
-
-_DEFAULT_ORACLE_DISCRIMINATOR: FunctionParamsDiscriminator = (
-    ArithmeticOracle.discriminator()
-)
-
-
-class GroverOperator(FunctionParams):
-    oracle: str = pydantic.Field(
-        default=_DEFAULT_ORACLE_DISCRIMINATOR,
-        description="Oracle function",
-        validate_default=True,
-    )
-    oracle_params: OracleABC = pydantic.Field(description="Oracle function parameters")
-    state_preparation: str = pydantic.Field(
-        default="",
-        description="State preparation function",
-        validate_default=True,
-    )
-    state_preparation_params: GroverStatePreparation = pydantic.Field(
-        default=None,
-        description="State preparation function parameters",
-        validate_default=True,
-    )
-
-    def _create_ios(self) -> None:
-        self._inputs = {**self.oracle_params.inputs}
-        self._outputs = {**self.oracle_params.outputs}
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _parse_oracle(cls, values: Any) -> dict[str, Any]:
-        if isinstance(values, dict):
-            oracle_params = values.get("oracle_params")
-            if isinstance(oracle_params, dict):
-                values["oracle_params"] = parse_function_params(
-                    params=oracle_params,
-                    discriminator=values.get("oracle", _DEFAULT_ORACLE_DISCRIMINATOR),
-                    param_classes=oracle_function_param_library.param_list,
-                    no_discriminator_error=ClassiqValueError("Invalid oracle name"),
-                    bad_function_error=ClassiqValueError("Invalid oracle params"),
-                )
-            elif isinstance(oracle_params, FunctionParams):
-                values["oracle"] = oracle_params.discriminator()
-            else:
-                raise ClassiqValueError("Invalid oracle params")
-        return values
-
-    @pydantic.field_validator("state_preparation_params", mode="before")
-    @classmethod
-    def _validate_state_preparation(
-        cls,
-        state_preparation_params: Optional[GroverStatePreparation],
-        info: ValidationInfo,
-    ) -> GroverStatePreparation:
-        oracle = info.data.get("oracle_params")
-        assert oracle is not None, "Must receive an oracle"
-        state_preparation_params = (
-            state_preparation_params
-            or cls._default_state_preparation_params(
-                num_qubits=oracle.num_input_qubits(strict_zero_ios=True)
-            )
-        )
-        assert GroverDiffuser(
-            state_preparation_params=state_preparation_params,
-            state_preparation=info.data.get("state_preparation", ""),
-            variables=oracle.variables(),
-        ), "Cannot construct a GroverDiffuser"
-        return state_preparation_params
-
-    @staticmethod
-    def _default_state_preparation_params(num_qubits: int) -> StatePreparation:
-        num_states: int = 2**num_qubits
-        return StatePreparation(
-            probabilities=[1.0 / float(num_states)] * num_states,
-            error_metric={
-                Metrics.L2: NonNegativeFloatRange(lower_bound=0.0, upper_bound=0.0)
-            },
-        )
-
-    def get_diffuser(self) -> GroverDiffuser:
-        return GroverDiffuser(
-            variables=self.oracle_params.variables(),
-            state_preparation=self.state_preparation,
-            state_preparation_params=self.state_preparation_params,
-        )

classiq/interface/generator/oracles/__init__.py

@@ -1,3 +0,0 @@
-from .arithmetic_oracle import ArithmeticOracle
-from .custom_oracle import CustomOracle
-from .oracle_abc import OracleABC

classiq/interface/generator/oracles/arithmetic_oracle.py

@@ -1,82 +0,0 @@
-import ast
-import re
-
-import numexpr  # type: ignore[import]
-
-from classiq.interface.exceptions import ClassiqArithmeticError, ClassiqValueError
-from classiq.interface.generator.arith import number_utils
-from classiq.interface.generator.arith.arithmetic import Arithmetic
-from classiq.interface.generator.arith.arithmetic_expression_abc import (
-    ArithmeticExpressionABC,
-)
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.oracles.oracle_abc import (
-    ArithmeticIODict,
-    OracleABC,
-    VariableBinResultMap,
-    VariableTypedResultMap,
-)
-
-
-class ArithmeticOracle(OracleABC[float], ArithmeticExpressionABC):
-    @staticmethod
-    def _validate_ast_obj(ast_obj: ast.AST) -> None:
-        if not isinstance(ast_obj, ast.Expression):
-            raise ClassiqValueError("Must be an expression")
-        if not isinstance(ast_obj.body, (ast.Compare, ast.BoolOp)):
-            raise ClassiqValueError("Must be a comparison expression")
-
-    def get_arithmetic_expression_params(self) -> Arithmetic:
-        return Arithmetic(
-            machine_precision=self.machine_precision,
-            expression=self.expression,
-            definitions=self.definitions,
-            uncomputation_method=self.uncomputation_method,
-            qubit_count=self.qubit_count,
-            target=RegisterArithmeticInfo(size=1),
-            inputs_to_save=set(self.definitions.keys()),
-        )
-
-    def _get_register_transputs(self) -> ArithmeticIODict:
-        return {
-            name: register
-            for name, register in self.definitions.items()
-            if name in self._get_literal_set()
-            and isinstance(register, RegisterArithmeticInfo)
-        }
-
-    def is_good_result(self, problem_result: VariableTypedResultMap[float]) -> bool:
-        expression = self._simplify_negations_of_boolean_variables(
-            expression=self.expression, input_definitions=self.inputs
-        )
-        for var_name, value in problem_result.items():
-            expression = re.sub(r"\b" + var_name + r"\b", str(value), expression)
-        try:
-            return bool(numexpr.evaluate(expression).item())
-        except TypeError:
-            raise ClassiqArithmeticError(
-                f"Cannot evaluate expression {expression}"
-            ) from None
-
-    @staticmethod
-    def _simplify_negations_of_boolean_variables(
-        expression: str, input_definitions: dict[str, RegisterArithmeticInfo]
-    ) -> str:
-        for var_name in input_definitions:
-            if getattr(input_definitions[var_name], "size", 0) == 1:
-                expression = re.sub(
-                    rf"~\s*{var_name}\b", f"(1 - {var_name})", expression
-                )
-        return expression
-
-    def binary_result_to_typed_result(
-        self, bin_result: VariableBinResultMap
-    ) -> VariableTypedResultMap[float]:
-        typed_result: VariableTypedResultMap[float] = {}
-        for var_name, var_string in bin_result.items():
-            var = self.inputs[var_name]
-            var_value = number_utils.binary_to_float_or_int(
-                var_string, var.fraction_places, var.is_signed
-            )
-            typed_result[var_name] = var_value
-        return typed_result

classiq/interface/generator/oracles/custom_oracle.py

@@ -1,65 +0,0 @@
-from typing import Any
-
-import pydantic
-
-from classiq.interface.exceptions import ClassiqValueError
-from classiq.interface.generator.function_params import parse_function_params_values
-from classiq.interface.generator.oracles.oracle_abc import (
-    ArithmeticIODict,
-    OracleABC,
-    VariableBinResultMap,
-    VariableTypedResultMap,
-)
-from classiq.interface.generator.user_defined_function_params import CustomFunction
-
-QubitState = str
-
-
-class CustomOracle(OracleABC[QubitState]):
-    custom_oracle: str = pydantic.Field(description="Oracle function")
-    custom_oracle_params: CustomFunction = pydantic.Field(
-        description="Oracle function parameters",
-        default_factory=CustomFunction,
-    )
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _parse_oracle(cls, values: Any) -> dict[str, Any]:
-        if isinstance(values, dict):
-            parse_function_params_values(
-                values=values,
-                params_key="custom_oracle_params",
-                discriminator_key="custom_oracle",
-                param_classes={CustomFunction},
-                default_parser_class=CustomFunction,
-            )
-        return values
-
-    @pydantic.field_validator("custom_oracle_params")
-    @classmethod
-    def _validate_names_match_oracle(
-        cls, custom_oracle_params: CustomFunction
-    ) -> CustomFunction:
-        if set(custom_oracle_params.input_decls.keys()) != set(
-            custom_oracle_params.output_decls.keys()
-        ):
-            raise ClassiqValueError("Oracle IO names must be identical")
-        if any(
-            custom_oracle_params.output_decls[name].size != input_decl.size
-            for name, input_decl in custom_oracle_params.input_decls.items()
-        ):
-            raise ClassiqValueError("Oracle IO sizes must be identical")
-        return custom_oracle_params
-
-    def _get_register_transputs(self) -> ArithmeticIODict:
-        return {**self.custom_oracle_params.input_decls}
-
-    def binary_result_to_typed_result(
-        self, bin_result: VariableBinResultMap
-    ) -> VariableTypedResultMap[QubitState]:
-        return bin_result
-
-    def is_good_result(
-        self, problem_result: VariableTypedResultMap[QubitState]
-    ) -> bool:
-        return True

classiq/interface/generator/oracles/oracle_abc.py

@@ -1,76 +0,0 @@
-import abc
-from collections.abc import Sequence
-from typing import Generic, Optional, TypeVar
-
-import numpy as np
-
-from classiq.interface.exceptions import ClassiqOracleError
-from classiq.interface.executor.result import State
-from classiq.interface.generator.arith.register_user_input import RegisterUserInput
-from classiq.interface.generator.function_params import ArithmeticIODict, FunctionParams
-from classiq.interface.generator.generated_circuit_data import IOQubitMapping
-
-ProblemResultType = TypeVar("ProblemResultType")
-
-VariableBinResultMap = dict[str, State]
-VariableTypedResultMap = dict[str, ProblemResultType]
-
-
-class OracleABC(abc.ABC, FunctionParams, Generic[ProblemResultType]):
-    def get_power_order(self) -> Optional[int]:
-        return 2
-
-    @abc.abstractmethod
-    def _get_register_transputs(self) -> ArithmeticIODict:
-        pass
-
-    def _create_ios(self) -> None:
-        self._inputs = self._get_register_transputs()
-        self._outputs = {**self._inputs}
-
-    def is_good_state(self, state: str, indices: IOQubitMapping) -> bool:
-        bin_result = self.split_state_by_variables(state, indices)
-        problem_result = self.binary_result_to_typed_result(bin_result)
-        return self.is_good_result(problem_result)
-
-    def split_state_by_variables(
-        self, state: str, indices: IOQubitMapping
-    ) -> VariableBinResultMap:
-        self._check_indices(indices)
-
-        input_values: VariableBinResultMap = {}
-        state_as_array = np.array(list(state))
-        for var_name, var_indices in indices.items():
-            var_string = "".join(
-                state_as_array[sorted(_reverse_endianness(var_indices, len(state)))]
-            )
-            input_values[var_name] = var_string
-        return input_values
-
-    @abc.abstractmethod
-    def binary_result_to_typed_result(
-        self, bin_result: VariableBinResultMap
-    ) -> VariableTypedResultMap[ProblemResultType]:
-        pass
-
-    @abc.abstractmethod
-    def is_good_result(
-        self, problem_result: VariableTypedResultMap[ProblemResultType]
-    ) -> bool:
-        pass
-
-    def variables(self) -> list[RegisterUserInput]:
-        return [
-            RegisterUserInput.from_arithmetic_info(info=info, name=name)
-            for name, info in self._inputs.items()
-        ]
-
-    def _check_indices(self, indices: IOQubitMapping) -> None:
-        if set(indices.keys()) != {reg.name for reg in self.variables()}:
-            raise ClassiqOracleError(
-                "Argument name mismatch between indices and registers"
-            )
-
-
-def _reverse_endianness(indices: Sequence[int], state_length: int) -> list[int]:
-    return [state_length - 1 - index for index in indices]

classiq/interface/generator/oracles/oracle_function_param_list.py

@@ -1,6 +0,0 @@
-from classiq.interface.generator.function_param_library import FunctionParamLibrary
-from classiq.interface.generator.oracles import ArithmeticOracle, CustomOracle
-
-oracle_function_param_library: FunctionParamLibrary = FunctionParamLibrary(
-    param_list=[ArithmeticOracle, CustomOracle]
-)

classiq/interface/generator/piecewise_linear_amplitude_loading.py

@@ -1,165 +0,0 @@
-import math
-from collections.abc import Sequence
-from typing import Any, Generic, TypeVar
-
-import pydantic
-from pydantic import BaseModel, ConfigDict, Field, field_validator
-from pydantic_core.core_schema import ValidationInfo
-
-from classiq.interface.exceptions import ClassiqError
-from classiq.interface.generator.arith.register_user_input import RegisterArithmeticInfo
-from classiq.interface.generator.function_params import FunctionParams
-from classiq.interface.helpers.hashable_pydantic_base_model import (
-    HashablePydanticBaseModel,
-)
-
-STATE_NAME: str = "state"
-TARGET_NAME: str = "target"
-_REL_TOLERANCE: float = 0.01
-
-Breakpoint = TypeVar("Breakpoint")
-
-
-class AffineMap(HashablePydanticBaseModel):
-    slope: float = Field(default=1.0)
-    offset: float = Field(default=0.0)
-
-    def evaluate(self, x: float) -> float:
-        return self.offset + self.slope * x
-
-    def image_bounds(self, domain_bounds: tuple[float, float]) -> tuple[float, float]:
-        return self.evaluate(domain_bounds[0]), self.evaluate(domain_bounds[1])
-
-    model_config = ConfigDict(frozen=True)
-
-
-class PiecewiseLinearAmplitudeLoadingABC(
-    FunctionParams, BaseModel, Generic[Breakpoint]
-):
-    num_qubits: int = Field()
-    breakpoints: Sequence[int] = Field()
-    affine_maps: Sequence[AffineMap] = Field()
-
-    def _create_ios(self) -> None:
-        self._inputs = {
-            STATE_NAME: RegisterArithmeticInfo(size=self.num_qubits),
-            TARGET_NAME: RegisterArithmeticInfo(size=1),
-        }
-        self._outputs = {**self._inputs}
-
-    @property
-    def _max_index(self) -> int:
-        return 2**self.num_qubits - 1
-
-    def _get_image_bounds(self) -> tuple[float, float]:
-        piece_bounds: Sequence[tuple[float, float]] = [
-            affine_map.image_bounds((self.breakpoints[idx], self.breakpoints[idx + 1]))
-            for idx, affine_map in enumerate(self.affine_maps)
-        ]
-        bottom = min(min(piece) for piece in piece_bounds)
-        top = max(max(piece) for piece in piece_bounds)
-        return bottom, top
-
-    @field_validator("breakpoints", mode="before")
-    @classmethod
-    def _validate_breakpoints(cls, breakpoints: Sequence[int]) -> Sequence[int]:
-        return cls.validate_breakpoints(breakpoints)
-
-    @classmethod
-    def validate_breakpoints(cls, breakpoints: Sequence[int]) -> Sequence[int]:
-        assert len(breakpoints) == len(
-            set(breakpoints)
-        ), "Repeated breakpoints encountered"
-        assert list(breakpoints) == sorted(breakpoints), "Breakpoints not sorted"
-        return list(map(int, breakpoints))
-
-    @pydantic.model_validator(mode="before")
-    @classmethod
-    def _validate_lengths(cls, values: Any) -> dict[str, Any]:
-        breakpoints = values.get("breakpoints", list())
-        affine_maps = values.get("affine_maps", list())
-        num_qubits = values.get("num_qubits", int)
-        if isinstance(values, dict):
-            breakpoints = values.get("breakpoints", list())
-            affine_maps = values.get("affine_maps", list())
-            num_qubits = values.get("num_qubits", int)
-        elif isinstance(values, PiecewiseLinearAmplitudeLoadingABC):
-            breakpoints = values.breakpoints
-            affine_maps = values.affine_maps
-            num_qubits = values.num_qubits
-            values = values.__dict__
-
-        assert len(breakpoints) - 1 == len(
-            affine_maps
-        ), "Size mismatch between the number of slopes and breakpoints. The number of breakpoints should be the number of slopes + 1"
-        assert (
-            len(breakpoints) <= num_qubits**2
-        ), "Number of breakpoints must be equal to or smaller than num_qubits**2"
-        return values
-
-
-class PiecewiseLinearRotationAmplitudeLoading(PiecewiseLinearAmplitudeLoadingABC[int]):
-    pass
-
-    @field_validator("breakpoints")
-    @classmethod
-    def _validate_breakpoints_field(
-        cls, breakpoints: Sequence[int], info: ValidationInfo
-    ) -> Sequence[int]:
-        num_qubits = info.data.get("num_qubits")
-        assert isinstance(num_qubits, int), "Must have an integer number of qubits"
-        assert min(breakpoints) == 0, "First breakpoint must be 0"
-        assert (
-            max(breakpoints) == 2**num_qubits - 1
-        ), f"Last breakpoint must be {2**num_qubits - 1}"
-        return PiecewiseLinearAmplitudeLoadingABC.validate_breakpoints(
-            breakpoints=breakpoints
-        )
-
-
-class PiecewiseLinearAmplitudeLoading(PiecewiseLinearAmplitudeLoadingABC[float]):
-    rescaling_factor: float = Field(default=0.25 * math.pi)
-
-    def rescaled(self) -> PiecewiseLinearRotationAmplitudeLoading:
-        c, d = self._get_image_bounds()
-        if math.isclose(c, d):
-            raise ClassiqError("Cannot rescale flat linear maps")
-
-        a, b = self.breakpoints[0], self.breakpoints[-1]
-
-        normalized_breakpoints: list[int] = [
-            round(self._max_index * (point - a) / (b - a)) for point in self.breakpoints
-        ]
-
-        normalized_affine_maps: list[AffineMap] = list()
-        for affine_map in self.affine_maps:
-            normalized_slope = (
-                2 * affine_map.slope * self.rescaling_factor * (b - a)
-            ) / (self._max_index * (d - c))
-            normalized_offset = (
-                (2 * self.rescaling_factor * (affine_map.evaluate(a) - c)) / (d - c)
-                - self.rescaling_factor
-                + math.pi / 4
-            )
-            normalized_affine_maps.append(
-                AffineMap(slope=normalized_slope, offset=normalized_offset)
-            )
-        return PiecewiseLinearRotationAmplitudeLoading(
-            num_qubits=self.num_qubits,
-            breakpoints=normalized_breakpoints,
-            affine_maps=normalized_affine_maps,
-        )
-
-    @staticmethod
-    def _descaled_value(
-        *, scaled_expectation_value: float, rescaling_factor: float
-    ) -> float:
-        return 0.5 * ((scaled_expectation_value - 0.5) / rescaling_factor + 1)
-
-    def compute_expectation_value(self, scaled_expectation_value: float) -> float:
-        bounds = self._get_image_bounds()
-        image_bottom, image_top = min(bounds), max(bounds)
-        return image_bottom + (image_top - image_bottom) * self._descaled_value(
-            rescaling_factor=self.rescaling_factor,
-            scaled_expectation_value=scaled_expectation_value,
-        )