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

qilisdk/functionals/functional.py

@@ -0,0 +1,39 @@
+# 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 ClassVar, Generic, TypeVar
+
+from qilisdk.common.parameterizable import Parameterizable
+from qilisdk.functionals.functional_result import FunctionalResult
+
+TResult_co = TypeVar("TResult_co", bound=FunctionalResult, covariant=True)
+
+
+class Functional(ABC):
+    """
+    Abstract interface for executable routines that return a :class:`FunctionalResult`.
+
+    Subclasses detail the concrete `result_type` they generate.
+    """
+
+    result_type: ClassVar[type[FunctionalResult]]
+    """Concrete :class:`~qilisdk.functionals.functional_result.FunctionalResult` subclass returned."""
+
+
+class PrimitiveFunctional(Parameterizable, Functional, ABC, Generic[TResult_co]):
+    """
+    Base class for functionals backed by a :class:`~qilisdk.common.parameterizable.Parameterizable` object.
+    """

qilisdk/{extras/cuda/cuda_digital_result.py → functionals/functional_result.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.digital.digital_result import DigitalResult
-from qilisdk.yaml import yaml
+from qilisdk.common.result import Result
 
 
-@yaml.register_class
-class CudaDigitalResult(DigitalResult): ...
+class FunctionalResult(Result):
+    """Base class for artifacts produced by executing a :class:`Functional`."""

qilisdk/functionals/sampling.py

@@ -0,0 +1,81 @@
+# 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 typing import ClassVar
+
+from qilisdk.common.variables import RealNumber
+from qilisdk.digital.circuit import Circuit
+from qilisdk.functionals.functional import PrimitiveFunctional
+from qilisdk.functionals.sampling_result import SamplingResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class Sampling(PrimitiveFunctional[SamplingResult]):
+    """
+    Execute a digital circuit and collect bitstring samples.
+
+    Example:
+        .. code-block:: python
+
+            from qilisdk.digital.circuit import Circuit
+            from qilisdk.functionals.sampling import Sampling
+
+            circuit = Circuit(nqubits=2)
+            circuit.h(0)
+            sampler = Sampling(circuit, nshots=1024)
+    """
+
+    result_type: ClassVar[type[SamplingResult]] = SamplingResult
+
+    def __init__(self, circuit: Circuit, nshots: int = 1000) -> None:
+        """
+        Args:
+            circuit (Circuit): Circuit to execute for sampling.
+            nshots (int, optional): Number of repetitions used to estimate probabilities. Defaults to 1000.
+        """
+        self.circuit = circuit
+        self.nshots = nshots
+
+    @property
+    def nparameters(self) -> int:
+        """Return the number of parameters exposed by the underlying circuit."""
+        return self.circuit.nparameters
+
+    def set_parameters(self, parameters: dict[str, RealNumber]) -> None:
+        """Assign a subset of circuit parameters provided by label."""
+        self.circuit.set_parameters(parameters)
+
+    def get_parameters(self) -> dict[str, RealNumber]:
+        """Return a mapping of all circuit parameters to their current value."""
+        return self.circuit.get_parameters()
+
+    def get_parameter_names(self) -> list[str]:
+        """Return circuit parameter labels in deterministic order."""
+        return list(self.circuit.get_parameters().keys())
+
+    def get_parameter_values(self) -> list[RealNumber]:
+        """Return the current parameter values following ``get_parameter_names`` order."""
+        return list(self.circuit.get_parameters().values())
+
+    def set_parameter_values(self, values: list[float]) -> None:
+        """Update all circuit parameters using the order defined by ``get_parameter_names``."""
+        self.circuit.set_parameter_values(values)
+
+    def get_parameter_bounds(self) -> dict[str, tuple[float, float]]:
+        """Return lower and upper bounds registered for each circuit parameter."""
+        return self.circuit.get_parameter_bounds()
+
+    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
+        """Update the admissible range for selected circuit parameters."""
+        self.circuit.set_parameter_bounds(ranges)

qilisdk/functionals/sampling_result.py

@@ -0,0 +1,92 @@
+# 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.
+import heapq
+import operator
+from pprint import pformat
+
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class SamplingResult(FunctionalResult):
+    """Store shot counts and derived probabilities for a sampling experiment."""
+
+    def __init__(self, nshots: int, samples: dict[str, int]) -> None:
+        """
+        Args:
+            nshots (int): Total number of circuit evaluations.
+            samples (dict[str, int]): Mapping from bitstring to observed counts.
+
+        Raises:
+            ValueError: If ``samples`` is empty or contains bitstrings with different length.
+        """
+        self._nshots = nshots
+        self._samples = samples
+
+        # Ensure samples is not empty and is correct.
+        if not samples:
+            raise ValueError("The samples dictionary is empty.")
+        bitstrings = list(samples.keys())
+        nqubits = len(bitstrings[0])
+        if not all(len(bitstring) == nqubits for bitstring in bitstrings):
+            raise ValueError("Not all bitstring keys have the same length.")
+
+        # Assign nqubits to attribute
+        self._nqubits = nqubits
+
+        # Calculate probabilities
+        self._probabilities = {
+            bitstring: counts / self._nshots if self._nshots > 0 else 0.0 for bitstring, counts in self._samples.items()
+        }
+
+    @property
+    def nshots(self) -> int:
+        """Total number of repetitions used to gather samples."""
+        return self._nshots
+
+    @property
+    def nqubits(self) -> int:
+        """Number of qubits inferred from the sample bitstrings."""
+        return self._nqubits
+
+    @property
+    def samples(self) -> dict[str, int]:
+        """Return a copy of the raw sample counts."""
+        return dict(self._samples)
+
+    @property
+    def probabilities(self) -> dict[str, float]:
+        """Return a copy of the estimated probability distribution."""
+        return dict(self._probabilities)
+
+    def get_probability(self, bitstring: str) -> float:
+        """Return the probability associated with ``bitstring`` (0.0 if unseen)."""
+        return self._probabilities.get(bitstring, 0.0)
+
+    def get_probabilities(self, n: int | None = None) -> list[tuple[str, float]]:
+        """
+        Args:
+            n (int | None): Maximum number of items to return. Defaults to all outcomes.
+
+        Returns:
+            list[tuple[str, float]]: the ``n`` most probable bitstrings in descending probability order.
+        """
+        if n is None:
+            n = len(self._probabilities)
+        return heapq.nlargest(n, self._probabilities.items(), key=operator.itemgetter(1))
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return f"{class_name}(\n  nshots={self.nshots},\n  samples={pformat(self.samples)}\n)"

qilisdk/functionals/time_evolution.py

@@ -0,0 +1,98 @@
+# 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 typing import ClassVar
+
+from qilisdk.analog.hamiltonian import Hamiltonian, PauliOperator
+from qilisdk.analog.schedule import Schedule
+from qilisdk.common.qtensor import QTensor
+from qilisdk.common.variables import RealNumber
+from qilisdk.functionals.functional import PrimitiveFunctional
+from qilisdk.functionals.time_evolution_result import TimeEvolutionResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class TimeEvolution(PrimitiveFunctional[TimeEvolutionResult]):
+    """
+    Simulate the dynamics induced by a time-dependent Hamiltonian schedule.
+
+    Example:
+        .. code-block:: python
+
+            from qilisdk.analog import Schedule, Hamiltonian, Z
+            from qilisdk.common import ket
+            from qilisdk.functionals.time_evolution import TimeEvolution
+
+            h0 = Z(0)
+            schedule = Schedule(T=10.0, hamiltonians={"h0": h0})
+            functional = TimeEvolution(schedule, observables=[Z(0), X(0)], initial_state=ket(0))
+    """
+
+    result_type: ClassVar[type[TimeEvolutionResult]] = TimeEvolutionResult
+
+    def __init__(
+        self,
+        schedule: Schedule,
+        observables: list[PauliOperator | Hamiltonian],
+        initial_state: QTensor,
+        nshots: int = 1000,
+        store_intermediate_results: bool = False,
+    ) -> None:
+        """
+        Args:
+            schedule (Schedule): Annealing or control schedule describing the Hamiltonian evolution.
+            observables (list[PauliOperator | Hamiltonian]): Observables measured at the end of the evolution.
+            initial_state (QTensor): Quantum state used as the simulation starting point.
+            nshots (int, optional): Number of executions for statistical estimation. Defaults to 1000.
+            store_intermediate_results (bool, optional): Keep intermediate states if produced by the backend. Defaults to False.
+        """
+        super().__init__()
+        self.initial_state = initial_state
+        self.schedule = schedule
+        self.observables = observables
+        self.nshots = nshots
+        self.store_intermediate_results = store_intermediate_results
+
+    @property
+    def nparameters(self) -> int:
+        """Return the number of schedule parameters."""
+        return self.schedule.nparameters
+
+    def get_parameters(self) -> dict[str, RealNumber]:
+        """Return the schedule parameters and their current value."""
+        return self.schedule.get_parameters()
+
+    def set_parameters(self, parameters: dict[str, RealNumber]) -> None:
+        """Update a subset of schedule parameters."""
+        self.schedule.set_parameters(parameters)
+
+    def get_parameter_names(self) -> list[str]:
+        """Return order-stable parameter labels from the schedule."""
+        return self.schedule.get_parameter_names()
+
+    def get_parameter_values(self) -> list[RealNumber]:
+        """Return parameter values in the order provided by ``get_parameter_names``."""
+        return self.schedule.get_parameter_values()
+
+    def set_parameter_values(self, values: list[float]) -> None:
+        """Assign all schedule parameters according to ``get_parameter_names`` order."""
+        self.schedule.set_parameter_values(values)
+
+    def get_parameter_bounds(self) -> dict[str, tuple[float, float]]:
+        """Return current bounds for schedule parameters."""
+        return self.schedule.get_parameter_bounds()
+
+    def set_parameter_bounds(self, ranges: dict[str, tuple[float, float]]) -> None:
+        """Update bounds for selected schedule parameters."""
+        self.schedule.set_parameter_bounds(ranges)

qilisdk/functionals/time_evolution_result.py

@@ -0,0 +1,84 @@
+# 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 pprint import pformat
+
+import numpy as np
+
+from qilisdk.common.model import Model
+from qilisdk.common.qtensor import QTensor
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.yaml import yaml
+
+
+@yaml.register_class
+class TimeEvolutionResult(FunctionalResult):
+    """Container for expectation values and states produced by a time-evolution simulation."""
+
+    def __init__(
+        self,
+        final_expected_values: np.ndarray | None = None,
+        expected_values: np.ndarray | None = None,
+        final_state: QTensor | None = None,
+        intermediate_states: list[QTensor] | None = None,
+    ) -> None:
+        """
+        Args:
+            final_expected_values (np.ndarray | None, optional): Expectation values evaluated at the end of the evolution.
+            expected_values (np.ndarray | None, optional): Time series of expectation values, if recorded.
+            final_state (QTensor | None, optional): Final quantum state associated with the evolution.
+            intermediate_states (list[QTensor] | None, optional): Intermediate states captured during the evolution.
+        """
+        super().__init__()
+        self._final_expected_values = final_expected_values if final_expected_values is not None else np.array([])
+        self._expected_values = expected_values if expected_values is not None else np.array([])
+        self._final_state = final_state
+        self._intermediate_states = intermediate_states or []
+
+    @property
+    def final_expected_values(self) -> np.ndarray:
+        """Final expectation values measured at the end of the evolution."""
+        return self._final_expected_values
+
+    @property
+    def expected_values(self) -> np.ndarray:
+        """Expectation values tracked over the course of the evolution."""
+        return self._expected_values
+
+    @property
+    def final_state(self) -> QTensor | None:
+        """Final quantum state if provided by the backend."""
+        return self._final_state
+
+    @property
+    def intermediate_states(self) -> list[QTensor]:
+        """List of intermediate quantum states captured during the simulation."""
+        return self._intermediate_states
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return (
+            f"{class_name}(\n"
+            + f"  final_expected_values={pformat(self.final_expected_values)},\n"
+            + (f"  expected_values={pformat(self.expected_values)}\n" if len(self.expected_values) > 0 else "")
+            + (f"  final_state={pformat(self.final_state)}\n" if self.final_state is not None else "")
+            + (
+                f"  intermediate_states={pformat(self.intermediate_states)}\n"
+                if len(self.intermediate_states) > 0
+                else ""
+            )
+            + ")"
+        )
+
+    def compute_cost(self, cost_model: Model) -> float:
+        raise NotImplementedError

qilisdk/functionals/variational_program.py

@@ -0,0 +1,80 @@
+# 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, ClassVar, Generic, TypeVar
+
+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.cost_functions.cost_function import CostFunction
+    from qilisdk.optimizers.optimizer import Optimizer
+
+TFunctional = TypeVar("TFunctional", bound=PrimitiveFunctional[FunctionalResult])
+
+
+@yaml.register_class
+class VariationalProgram(Functional, Generic[TFunctional]):
+    """
+    Bundle a parameterized functional, optimizer, and cost function into a variational loop.
+
+    Example:
+        .. code-block:: python
+
+            program = VariationalProgram(functional, optimizer, cost_function)
+    """
+
+    result_type: ClassVar[type[FunctionalResult]] = VariationalProgramResult
+
+    def __init__(
+        self,
+        functional: TFunctional,
+        optimizer: Optimizer,
+        cost_function: CostFunction,
+        store_intermediate_results: bool = False,
+    ) -> None:
+        """
+        Args:
+            functional (PrimitiveFunctional): Parameterized functional to optimize.
+            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.
+        """
+        self._functional = functional
+        self._optimizer = optimizer
+        self._cost_function = cost_function
+        self._store_intermediate_results = store_intermediate_results
+
+    @property
+    def functional(self) -> TFunctional:
+        """Return the wrapped functional that will be optimised."""
+        return self._functional
+
+    @property
+    def optimizer(self) -> Optimizer:
+        """Return the optimizer responsible for parameter updates."""
+        return self._optimizer
+
+    @property
+    def cost_function(self) -> CostFunction:
+        """Return the cost function applied to functional results."""
+        return self._cost_function
+
+    @property
+    def store_intermediate_results(self) -> bool:
+        """Indicate whether intermediate execution data should be stored."""
+        return self._store_intermediate_results

qilisdk/functionals/variational_program_result.py

@@ -0,0 +1,69 @@
+# 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 pprint import pformat
+from typing import Generic, TypeVar
+
+from qilisdk.functionals.functional_result import FunctionalResult
+from qilisdk.optimizers.optimizer_result import OptimizerIntermediateResult, OptimizerResult
+from qilisdk.yaml import yaml
+
+TResult_co = TypeVar("TResult_co", bound=FunctionalResult, covariant=True)
+
+
+@yaml.register_class
+class VariationalProgramResult(FunctionalResult, Generic[TResult_co]):
+    """Aggregate the optimizer summary and best functional result from a variational run."""
+
+    def __init__(self, optimizer_result: OptimizerResult, result: TResult_co) -> None:
+        """
+        Args:
+            optimizer_result (OptimizerResult): Summary produced by the optimiser.
+            result (TResult_co): Functional result evaluated at the final parameters.
+        """
+        super().__init__()
+        self._optimizer_result = optimizer_result
+        self._result = result
+
+    @property
+    def optimal_cost(self) -> float:
+        """Best cost reported by the optimiser."""
+        return self._optimizer_result.optimal_cost
+
+    @property
+    def optimal_execution_results(self) -> TResult_co:
+        """Return the functional result evaluated at the optimal parameters."""
+        return self._result
+
+    @property
+    def optimal_parameters(self) -> list[float]:
+        """Optimised parameter values."""
+        return self._optimizer_result.optimal_parameters
+
+    @property
+    def intermediate_results(self) -> list[OptimizerIntermediateResult]:
+        """Sequence of intermediate optimiser snapshots, if recorded."""
+        return self._optimizer_result.intermediate_results
+
+    def __repr__(self) -> str:
+        class_name = self.__class__.__name__
+        return (
+            f"{class_name}(\n"
+            f"  Optimal Cost={self.optimal_cost},\n"
+            f"  Optimal Parameters={pformat(self.optimal_parameters)},\n"
+            f"  Intermediate Results={pformat(self.intermediate_results)},\n"
+            f"  Optimal Results={pformat(self.optimal_execution_results)}\n"
+            ")"
+        )

qilisdk/logging_config.yaml

@@ -0,0 +1,16 @@
+sinks:
+  - sink: stderr
+    level: WARNING
+    format: "<fg #7f1cdb>QiliSDK</> | <green>{time:YYYY-MM-DD at HH:mm:ss}</green> | <lvl>{level}</> | <lvl>{level.icon} {message}</>"
+    filter: qilisdk
+    colorize: true
+
+intercept_libraries:
+  - name: httpx
+    level: ERROR
+  - name: httpcore
+    level: ERROR
+  - name: keyring
+    level: ERROR
+  - name: matplotlib
+    level: ERROR

qilisdk/{common/backend.py → optimizers/__init__.py}

@@ -12,5 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from .scipy_optimizer import SciPyOptimizer
 
-class Backend: ...
+__all__ = ["SciPyOptimizer"]

qilisdk/optimizers/optimizer.py

@@ -0,0 +1,39 @@
+# 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 abc import ABC, abstractmethod
+from typing import Callable
+
+from .optimizer_result import OptimizerResult
+
+
+class Optimizer(ABC):
+    @abstractmethod
+    def optimize(
+        self,
+        cost_function: Callable[[list[float]], float],
+        init_parameters: list[float],
+        bounds: list[tuple[float, float]],
+        store_intermediate_results: bool = False,
+    ) -> OptimizerResult:
+        """optimize the cost function and return the optimal parameters.
+
+        Args:
+            cost_function (Callable[[list[float]], float]): a function that takes in a list of parameters and returns the cost.
+            init_parameters (list[float]): the list of initial parameters. Note: the length of this list determines the number of parameters the optimizer will consider.
+            bounds (list[float, float]): a list of the variable value bounds.
+
+        Returns:
+            list[float]: the optimal set of parameters that minimize the cost function.
+        """

qilisdk/{common → optimizers}/optimizer_result.py

@@ -13,17 +13,14 @@
 # limitations under the License.
 from __future__ import annotations
 
+from qilisdk.common.result import Result
 from qilisdk.yaml import yaml
 
 
 @yaml.register_class
-class OptimizerIntermediateResult:
+class OptimizerIntermediateResult(Result):
     """
     Represents an intermediate result.
-
-    Attributes:
-        cost (float): The optimal cost value (e.g., minimum energy) found.
-        parameters (List[float]): The parameters that yield the optimal cost.
     """
 
     def __init__(
@@ -50,15 +47,9 @@ class OptimizerIntermediateResult:
 
 
 @yaml.register_class
-class OptimizerResult:
+class OptimizerResult(Result):
     """
     Represents the result of an optimization run.
-
-    Attributes:
-        optimal_cost (float): The optimal cost value (e.g., minimum energy) found.
-        optimal_parameters (List[float]): The parameters that yield the optimal cost.
-        intermediate_results (List[OptimizerResult]): A list of intermediate optimization results.
-            Each intermediate result is an instance of OptimizerResult containing the current cost and parameters.
     """
 
     def __init__(