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

qilisdk/{extras/cuda/cuda_analog_result.py → cost_functions/__init__.py}

@@ -11,9 +11,8 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-from qilisdk.analog.analog_result import AnalogResult
-from qilisdk.yaml import yaml
 
+from .model_cost_function import ModelCostFunction
+from .observable_cost_function import ObservableCostFunction
 
-@yaml.register_class
-class CudaAnalogResult(AnalogResult): ...
+__all__ = ["ModelCostFunction", "ObservableCostFunction"]

qilisdk/cost_functions/cost_function.py

@@ -0,0 +1,77 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from abc import ABC
+from typing import TYPE_CHECKING, Callable, TypeVar, cast, overload
+
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.functionals.sampling_result import SamplingResult
+from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
+
+if TYPE_CHECKING:
+    from qilisdk.common.variables import Number
+
+TResult = TypeVar("TResult", bound=FunctionalResult)
+
+
+class CostFunction(ABC):
+    """
+    Base class that maps functional results into scalar costs.
+    """
+
+    def __init__(self) -> None:
+        self._handlers: dict[type[FunctionalResult], Callable[[FunctionalResult], Number]] = {
+            SamplingResult: lambda f: self._compute_cost_sampling(cast("SamplingResult", f)),
+            TimeEvolutionResult: lambda f: self._compute_cost_time_evolution(cast("TimeEvolutionResult", f)),
+        }
+
+    @overload
+    def compute_cost(self, results: SamplingResult) -> Number: ...
+
+    @overload
+    def compute_cost(self, results: TimeEvolutionResult) -> Number: ...
+
+    @overload
+    def compute_cost(self, results: FunctionalResult) -> Number: ...
+
+    def compute_cost(self, results: TResult) -> Number:
+        """
+        Dispatch to the appropriate cost implementation based on the result type.
+
+        Args:
+            results (FunctionalResult): Output of a functional execution.
+
+        Returns:
+            Number: Scalar cost extracted from the results.
+
+        Raises:
+            NotImplementedError: If the concrete cost function does not support the given result type.
+        """
+        try:
+            handler = self._handlers[type(results)]
+        except KeyError as exc:
+            raise NotImplementedError(
+                f"{type(self).__qualname__} does not support {type(results).__qualname__}"
+            ) from exc
+
+        return handler(results)
+
+    def _compute_cost_sampling(self, results: SamplingResult) -> Number:
+        """Compute the cost associated with a :class:`SamplingResult`."""
+        raise NotImplementedError
+
+    def _compute_cost_time_evolution(self, results: TimeEvolutionResult) -> Number:
+        """Compute the cost associated with a :class:`TimeEvolutionResult`."""
+        raise NotImplementedError

qilisdk/cost_functions/model_cost_function.py

@@ -0,0 +1,145 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from qilisdk.common.model import QUBO, Model
+from qilisdk.common.qtensor import QTensor, expect_val, ket
+from qilisdk.cost_functions.cost_function import CostFunction
+
+if TYPE_CHECKING:
+    from qilisdk.common.variables import Number
+    from qilisdk.functionals.sampling_result import SamplingResult
+    from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
+
+
+class ModelCostFunction(CostFunction):
+    """
+    Evaluate the cost of functional results with respect to a :class:`~qilisdk.common.model.Model`.
+
+    Example:
+        .. code-block:: python
+
+            from qilisdk.common import BinaryVariable, Model, LEQ
+            from qilisdk.cost_functions import ModelCostFunction
+
+            model = Model("demo")
+            x0, x1 = BinaryVariable("x0"), BinaryVariable("x1")
+            model.set_objective(x0 + x1)
+            model.add_constraint("limit", LEQ(x0 + x1, 1))
+            cost_fn = ModelCostFunction(model)
+    """
+
+    def __init__(self, model: Model) -> None:
+        """
+        Args:
+            model (Model): Classical model describing objective and constraints.
+        """
+        super().__init__()
+        self._model = model
+
+    @property
+    def model(self) -> Model:
+        """Return the underlying optimisation model."""
+        return self._model
+
+    def _compute_cost_time_evolution(self, results: TimeEvolutionResult) -> Number:
+        """
+        Compute the expectation value of the model objective using a time-evolution result.
+
+        Evaluates the model on each computational basis state with probability extracted from the final state.
+
+        Returns:
+            Number: Expectation value of the model objective.
+
+        Raises:
+            ValueError: If the final state is not provided in the results.
+        """
+        if results.final_state is None:
+            raise ValueError(
+                "can't compute cost using Models from time evolution results when the state is not provided."
+            )
+
+        if isinstance(self.model, QUBO):
+            ham = self.model.to_hamiltonian()
+            total_cost = complex(np.real_if_close(expect_val(QTensor(ham.to_matrix()), results.final_state)))
+            if total_cost.imag == 0:
+                return total_cost.real
+            return total_cost
+
+        total_cost = complex(0.0)
+
+        if results.final_state.is_density_matrix(tol=1e-5):
+            rho = results.final_state.dense
+            n = results.final_state.nqubits
+            for i in range(rho.shape[0]):
+                state = [int(b) for b in f"{i:0{n}b}"]
+                _ket_state = ket(*state)
+                _prob = complex(np.real_if_close(np.trace((_ket_state @ _ket_state.adjoint()).dense @ rho)))
+                variable_map = {v: int(state[i]) for i, v in enumerate(self.model.variables())}
+                evaluate_results = self.model.evaluate(variable_map)
+                total_cost += sum(v for v in evaluate_results.values()) * _prob
+            if total_cost.imag == 0:
+                return total_cost.real
+            return total_cost
+
+        dense_state = None
+        if results.final_state.is_ket():
+            dense_state = results.final_state.dense.T[0]
+        elif results.final_state.is_bra():
+            dense_state = results.final_state.dense[0]
+
+        if dense_state is None:
+            raise ValueError("The final state is invalid.")
+
+        n = len(self.model.variables())
+
+        for i, prob in enumerate(dense_state):
+            state = [int(b) for b in f"{i:0{n}b}"]
+            variable_map = {v: state[i] for i, v in enumerate(self.model.variables())}
+            evaluate_results = self.model.evaluate(variable_map)
+            total_cost += sum(v for v in evaluate_results.values()) * np.abs(prob**2)
+
+        total_cost = complex(np.real_if_close(total_cost, tol=1e-12))
+        if total_cost.imag == 0:
+            return total_cost.real
+        return total_cost
+
+    def _compute_cost_sampling(self, results: SamplingResult) -> Number:
+        """
+        Compute the model cost by averaging over sampled bitstrings.
+
+        Each sample is mapped onto the model variables and evaluated using ``model.evaluate``.
+
+        Returns:
+            Number: Average cost of the model objective over all samples.
+
+        Raises:
+            ValueError: If the number of model variables does not match the sample size.
+        """
+        total_cost = complex(0.0)
+        for sample, prob in results.get_probabilities():
+            bit_configuration = [int(i) for i in sample]
+            if len(self.model.variables()) != len(bit_configuration):
+                raise ValueError("Mapping samples to the model's variables is ambiguous.")
+            variable_map = {v: bit_configuration[i] for i, v in enumerate(self.model.variables())}
+            evaluate_results = self.model.evaluate(variable_map)
+            total_cost += sum(v for v in evaluate_results.values()) * prob
+
+        if total_cost.imag == 0:
+            return total_cost.real
+        return total_cost

qilisdk/cost_functions/observable_cost_function.py

@@ -0,0 +1,109 @@
+# Copyright 2025 Qilimanjaro Quantum Tech
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+
+from qilisdk.analog.hamiltonian import Hamiltonian, PauliOperator
+from qilisdk.common.qtensor import QTensor, expect_val, ket, tensor_prod
+from qilisdk.cost_functions.cost_function import CostFunction
+
+if TYPE_CHECKING:
+    from qilisdk.common.variables import Number
+    from qilisdk.functionals.sampling_result import SamplingResult
+    from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
+
+
+class ObservableCostFunction(CostFunction):
+    """
+    Compute costs by taking expectation values of observables.
+
+    Example:
+        .. code-block:: python
+
+            from qilisdk.analog.hamiltonian import Z
+            from qilisdk.cost_functions import ObservableCostFunction
+
+            cost_fn = ObservableCostFunction(Z(0))
+    """
+
+    def __init__(self, observable: QTensor | Hamiltonian | PauliOperator) -> None:
+        """
+        Args:
+            observable (QTensor | Hamiltonian | PauliOperator): Quantum observable whose expectation value defines the cost.
+
+        Raises:
+            ValueError: If the provided observable type is unsupported.
+        """
+        super().__init__()
+        if isinstance(observable, QTensor):
+            self._observable = observable
+        elif isinstance(observable, Hamiltonian):
+            self._observable = QTensor(observable.to_matrix())
+        elif isinstance(observable, PauliOperator):
+            self._observable = QTensor(observable.matrix)
+        else:
+            raise ValueError(
+                f"Observable needs to be of type QTensor, Hamiltonian, or PauliOperator but {type(observable)} was provided"
+            )
+
+    @property
+    def observable(self) -> QTensor:
+        """Return the observable in ``QTensor`` form."""
+        return self._observable
+
+    def _compute_cost_time_evolution(self, results: TimeEvolutionResult) -> Number:
+        """
+        Returns:
+            Number: the expectation value of ``observable`` given a final quantum state.
+
+        Raises:
+            ValueError: If the final state is not provided in the results.
+
+        """
+        if results.final_state is None:
+            raise ValueError(
+                "can't compute cost using Observables from time evolution results when the state is not provided."
+            )
+        total_cost = complex(np.real_if_close(expect_val(self._observable, results.final_state)))
+        if total_cost.imag == 0:
+            return total_cost.real
+        return total_cost
+
+    def _compute_cost_sampling(self, results: SamplingResult) -> Number:
+        """
+        Estimate the observable expectation value using measured bitstring probabilities.
+
+        Returns:
+            Number: the expectation value of ``observable`` estimated from sampled bitstrings.
+
+        Raises:
+            ValueError: If the number of qubits in the observable does not match the sample size
+        """
+        total_cost = complex(0.0)
+        nqubits = self._observable.nqubits
+        for sample, prob in results.get_probabilities():
+            state = tensor_prod([ket(int(i)) for i in sample])
+            if nqubits != state.nqubits:
+                raise ValueError(
+                    f"The samples provided have {state.nqubits} qubits but the observable has {nqubits} qubits"
+                )
+            evaluate_results = complex(np.real_if_close(expect_val(self._observable, state)))
+            total_cost += evaluate_results * prob
+
+        if total_cost.imag == 0:
+            return total_cost.real
+        return total_cost

qilisdk/digital/__init__.py

@@ -14,26 +14,7 @@
 
 from .ansatz import HardwareEfficientAnsatz
 from .circuit import Circuit
-from .digital_backend import DigitalSimulationMethod
-from .gates import (
-    CNOT,
-    CZ,
-    RX,
-    RY,
-    RZ,
-    U1,
-    U2,
-    U3,
-    Gate,
-    H,
-    M,
-    S,
-    T,
-    X,
-    Y,
-    Z,
-)
-from .vqe import VQE
+from .gates import CNOT, CZ, RX, RY, RZ, SWAP, U1, U2, U3, Gate, H, I, M, S, T, X, Y, Z
 
 __all__ = [
     "CNOT",
@@ -41,15 +22,15 @@ __all__ = [
     "RX",
     "RY",
     "RZ",
+    "SWAP",
     "U1",
     "U2",
     "U3",
-    "VQE",
     "Circuit",
-    "DigitalSimulationMethod",
     "Gate",
     "H",
     "HardwareEfficientAnsatz",
+    "I",
     "M",
     "S",
     "T",