qilisdk 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

qilisdk/functionals/variational_program.py

@@ -13,14 +13,18 @@
 # limitations under the License.
 from __future__ import annotations
 
+import functools
+import operator
 from typing import TYPE_CHECKING, ClassVar, Generic, TypeVar
 
+from qilisdk.core.variables import BaseVariable, Parameter
 from qilisdk.functionals.functional import Functional, PrimitiveFunctional
 from qilisdk.functionals.functional_result import FunctionalResult
 from qilisdk.functionals.variational_program_result import VariationalProgramResult
 from qilisdk.yaml import yaml
 
 if TYPE_CHECKING:
+    from qilisdk.core.variables import ComparisonTerm
     from qilisdk.cost_functions.cost_function import CostFunction
     from qilisdk.optimizers.optimizer import Optimizer
 
@@ -46,6 +50,7 @@ class VariationalProgram(Functional, Generic[TFunctional]):
         optimizer: Optimizer,
         cost_function: CostFunction,
         store_intermediate_results: bool = False,
+        parameter_constraints: list[ComparisonTerm] | None = None,
     ) -> None:
         """
         Args:
@@ -53,11 +58,29 @@ class VariationalProgram(Functional, Generic[TFunctional]):
             optimizer (Optimizer): Optimization routine controlling parameter updates.
             cost_function (CostFunction): Metric used to evaluate functional executions.
             store_intermediate_results (bool, optional): Persist intermediate executions if requested by the optimizer.
+            parameter_constraints (list[ComparisonTerm] | None): Optional constraints on parameter values that are
+                enforced before optimizer updates are applied.
+
+        Raises:
+            ValueError: if the user applies constraints on parameters that are not present in the variational program.
+                        Or the constraints contain Objects that are not parameters.
         """
         self._functional = functional
         self._optimizer = optimizer
         self._cost_function = cost_function
         self._store_intermediate_results = store_intermediate_results
+        parameter_constraints = parameter_constraints or []
+        functional_params = self._functional.get_parameters()
+        for p in parameter_constraints:
+            if not p.lhs.is_parameterized_term() or not p.rhs.is_parameterized_term():
+                raise ValueError("Only parameters are allowed to be constrained.")
+            variables = p.variables()
+            for v in variables:
+                if v.label not in functional_params:
+                    raise ValueError(
+                        f"Writing a constraint on the parameter ({v}) that is not present in the variational program "
+                    )
+        self._parameter_constraints = parameter_constraints
 
     @property
     def functional(self) -> TFunctional:
@@ -78,3 +101,38 @@ class VariationalProgram(Functional, Generic[TFunctional]):
     def store_intermediate_results(self) -> bool:
         """Indicate whether intermediate execution data should be stored."""
         return self._store_intermediate_results
+
+    def get_constraints(self) -> list[ComparisonTerm]:
+        """Return variational-program-level constraints plus those from the underlying functional."""
+        return self._parameter_constraints + self._functional.get_constraints()
+
+    def _check_constraints(self, parameters: dict[str, float]) -> list[bool]:
+        """Evaluate each constraint with a proposed parameter set.
+
+        Returns:
+            list[bool]: list of booleans that correspond to whether each constraint is satisfied or not.
+
+        Raises:
+            ValueError: if the parameter is not defined in the underlying functional.
+        """
+        params: list[BaseVariable] = functools.reduce(
+            operator.iadd, (con.variables() for con in self.get_constraints()), []
+        )
+        params = list(set(params))
+        if any(not isinstance(p, Parameter) for p in params):
+            raise ValueError("Only Parameters are allowed.")
+        params_dict = {p.label: p for p in params}
+        evaluate_dict: dict[BaseVariable, float] = {}
+        functional_params = self._functional.get_parameters()
+        for label, value in parameters.items():
+            if label not in functional_params:
+                raise ValueError(f"Parameter {label} is not defined in the functional.")
+            if label in params_dict:
+                evaluate_dict[params_dict[label]] = value
+        constraints = self.get_constraints()
+        return [con.evaluate(evaluate_dict) for con in constraints]
+
+    def check_parameter_constraints(self, parameters: dict[str, float]) -> int:
+        """Return a penalty-like score (0 if valid) indicating how many constraints are violated."""
+        const_list = self._check_constraints(parameters)
+        return sum((100 if not con else 0) for con in const_list)

qilisdk/optimizers/optimizer_result.py

@@ -13,7 +13,7 @@
 # limitations under the License.
 from __future__ import annotations
 
-from qilisdk.common.result import Result
+from qilisdk.core.result import Result
 from qilisdk.yaml import yaml
 
 

qilisdk/speqtrum/__init__.py

@@ -25,6 +25,8 @@ OPTIONAL_FEATURES: list[OptionalFeature] = [
             Symbol(path="qilisdk.speqtrum.speqtrum", name="SpeQtrum"),
             Symbol(path="qilisdk.speqtrum.speqtrum_models", name="DeviceStatus"),
             Symbol(path="qilisdk.speqtrum.speqtrum_models", name="DeviceType"),
+            Symbol(path="qilisdk.speqtrum.speqtrum_models", name="JobHandle"),
+            Symbol(path="qilisdk.speqtrum.speqtrum_models", name="TypedJobDetail"),
         ],
     ),
 ]