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

qilisdk/digital/digital_result.py

@@ -1,145 +0,0 @@
-# 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.common.result import Result
-from qilisdk.yaml import yaml
-
-
-@yaml.register_class
-class DigitalResult(Result):
-    """
-    Class representing the result of a quantum circuit measurement.
-
-    DigitalResult encapsulates the outcome of a digital measurement performed on a quantum circuit.
-    It includes the total number of measurement shots, the measurement samples and measurement probabilities.
-
-    Attributes:
-        nshots (int): The number of measurement shots performed in the experiment.
-        nqubits (int): The number of qubits measured.
-        samples (dict[str, int]): A dictionary where keys are bitstrings representing measurement outcomes and values are the number of times each outcome was observed.
-    """
-
-    def __init__(self, nshots: int, samples: dict[str, int]) -> None:
-        """
-        Initializes a DigitalResult instance.
-
-        Args:
-            nshots (int): The total number of measurement shots performed.
-            samples (dict[str, int]): A dictionary mapping bitstring outcomes to their occurrence counts.
-                All keys (bitstrings) must have the same length, which determines the number of qubits.
-
-        Raises:
-            ValueError: If the samples dictionary is empty or if not all bitstring keys have the same 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:
-        """
-        Gets the number of measurement shots.
-
-        Returns:
-            int: The total number of measurement shots performed.
-        """
-        return self._nshots
-
-    @property
-    def nqubits(self) -> int:
-        """
-        Gets the number of qubits involved in the measurement.
-
-        Returns:
-            int: The number of qubits measured.
-        """
-        return self._nqubits
-
-    @property
-    def samples(self) -> dict[str, int]:
-        """
-        Gets the raw measurement samples.
-
-        Returns:
-            dict[str, int]: A dictionary where keys are bitstrings representing measurement outcomes
-            and values are the number of times each outcome was observed.
-        """
-        return dict(self._samples)
-
-    @property
-    def probabilities(self) -> dict[str, float]:
-        """
-        Gets the probabilities for each measurement outcome.
-
-        Returns:
-            dict[str, float]: A dictionary mapping each bitstring outcome to its corresponding probability.
-        """
-        return dict(self._probabilities)
-
-    def get_probability(self, bitstring: str) -> float:
-        """
-        Computes the probability of a specific measurement outcome.
-
-        Args:
-            bitstring (str): The bitstring representing the measurement outcome of interest.
-
-        Returns:
-            float: The probability of the specified bitstring occurring.
-        """
-        return self._probabilities.get(bitstring, 0.0)
-
-    def get_probabilities(self, n: int | None = None) -> list[tuple[str, float]]:
-        """
-        Returns the n most probable bitstrings along with their probabilities.
-
-        Parameters:
-            n (int): The number of most probable bitstrings to return.
-
-        Returns:
-            list[tuple[str, float]]: A list of tuples (bitstring, probability) sorted in descending order by probability.
-        """
-        if n is None:
-            n = len(self._probabilities)
-        return heapq.nlargest(n, self._probabilities.items(), key=operator.itemgetter(1))
-
-    def __repr__(self) -> str:
-        """
-        Returns a string representation of the DigitalResult instance for debugging purposes.
-
-        The representation includes the class name, the number of measurement shots, and a formatted
-        display of the measurement samples.
-
-        Returns:
-            str: A string representation of the DigitalResult instance for debugging.
-        """
-        class_name = self.__class__.__name__
-        return f"{class_name}(\n  nshots={self.nshots},\n  samples={pformat(self.samples)}\n)"

qilisdk/digital/vqe.py

@@ -1,166 +0,0 @@
-# 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 Callable
-
-from qilisdk.common.optimizer import Optimizer
-from qilisdk.common.optimizer_result import OptimizerIntermediateResult, OptimizerResult
-from qilisdk.common.result import Result
-from qilisdk.digital.ansatz import Ansatz
-from qilisdk.digital.digital_algorithm import DigitalAlgorithm
-from qilisdk.digital.digital_backend import DigitalBackend
-from qilisdk.digital.digital_result import DigitalResult
-from qilisdk.yaml import yaml
-
-
-@yaml.register_class
-class VQEResult(Result):
-    """
-    Represents the result of a VQE calculation.
-
-    Attributes:
-        optimal_cost (float): The estimated ground state energy (optimal cost).
-        optimal_parameters (list[float]): The optimal parameters found during the optimization.
-    """
-
-    def __init__(self, optimizer_result: OptimizerResult) -> None:
-        super().__init__()
-        self._optimizer_result: OptimizerResult = optimizer_result
-
-    @property
-    def optimal_cost(self) -> float:
-        """
-        Get the optimal cost (estimated ground state energy).
-
-        Returns:
-            float: The optimal cost.
-        """
-        return self._optimizer_result.optimal_cost
-
-    @property
-    def optimal_parameters(self) -> list[float]:
-        """
-        Get the optimal ansatz parameters.
-
-        Returns:
-            list[float]: The optimal parameters.
-        """
-        return self._optimizer_result.optimal_parameters
-
-    @property
-    def intermediate_results(self) -> list[OptimizerIntermediateResult]:
-        """
-        Get the intermediate results.
-
-        Returns:
-            list[OptimizerResult]: The intermediate results.
-        """
-        return self._optimizer_result.intermediate_results
-
-    def __repr__(self) -> str:
-        """
-        Return a string representation of the VQEResult for debugging.
-
-        Returns:
-            str: A formatted string detailing the optimal cost and parameters.
-        """
-        class_name = self.__class__.__name__
-        return (
-            f"{class_name}(\n  Optimal Cost = {self.optimal_cost},"
-            + f"\n  Optimal Parameters={pformat(self.optimal_parameters)},"
-            + f"\n  Intermediate Results={pformat(self.intermediate_results)})"
-        )
-
-
-@yaml.register_class
-class VQE(DigitalAlgorithm):
-    """
-    Implements the Variational Quantum Eigensolver (VQE) algorithm.
-
-    The VQE algorithm is a hybrid quantum-classical method used to approximate the ground
-    state energy of a quantum system. It relies on a parameterized quantum circuit (ansatz)
-    whose parameters are tuned by a classical optimizer to minimize the cost function—typically
-    the expectation value of the system's Hamiltonian.
-
-    The algorithm outputs a VQEResult that includes the optimal cost (estimated ground state energy)
-    and the optimal parameters that yield this cost.
-    """
-
-    def __init__(
-        self, ansatz: Ansatz, initial_params: list[float], cost_function: Callable[[DigitalResult], float]
-    ) -> None:
-        """
-        Initialize the VQE algorithm.
-
-        Args:
-            ansatz (Ansatz): The parameterized quantum circuit representing the trial state.
-            initial_params (list[float]): The initial set of parameters for the ansatz.
-            cost_function (Callable[[DigitalResult], float]): A function that computes the cost from
-                a DigitalResult obtained after executing the circuit. The cost generally represents the
-                expectation value of the Hamiltonian.
-        """
-        self._ansatz = ansatz
-        self._initial_params = initial_params
-        self._cost_function = cost_function
-        self._execution_results: list[DigitalResult]
-
-    def obtain_cost(self, params: list[float], backend: DigitalBackend, nshots: int = 1000) -> float:
-        """
-        Evaluate the cost at a given parameter set by executing the corresponding quantum circuit.
-
-        The process involves:
-            1. Generating the quantum circuit using the ansatz with the specified parameters.
-            2. Executing the circuit on the provided digital backend with the given number of shots.
-            3. Passing the resulting DigitalResult to the cost_function to obtain the cost value.
-
-        Args:
-            params (list[float]): The ansatz parameters to evaluate.
-            backend (DigitalBackend): The digital backend that executes the quantum circuit.
-            nshots (int, optional): The number of shots (circuit executions). Defaults to 1000.
-
-        Returns:
-            float: The cost computed from the DigitalResult.
-        """
-        circuit = self._ansatz.get_circuit(params)
-        results = backend.execute(circuit=circuit, nshots=nshots)
-        return self._cost_function(results)
-
-    def execute(
-        self,
-        backend: DigitalBackend,
-        optimizer: Optimizer,
-        nshots: int = 1000,
-        store_intermediate_results: bool = False,
-    ) -> VQEResult:
-        """
-        Run the VQE algorithm to obtain the optimal parameters and the corresponding cost.
-
-        This method leverages a classical optimizer to minimize the cost function by varying the
-        ansatz parameters. The optimizer returns a tuple containing the optimal cost and the optimal
-        parameters. A VQEResult object is then created using these values.
-
-        Args:
-            backend (DigitalBackend): The backend for executing quantum circuits.
-            optimizer (Optimizer): The classical optimizer for tuning the ansatz parameters.
-            nshots (int, optional): The number of shots for each circuit execution. Defaults to 1000.
-
-        Returns:
-            VQEResult: An object containing the optimal cost and the optimal ansatz parameters.
-        """
-        optimizer_result = optimizer.optimize(
-            lambda x: self.obtain_cost(x, backend=backend, nshots=nshots),
-            self._initial_params,
-            store_intermediate_results=store_intermediate_results,
-        )
-        return VQEResult(optimizer_result=optimizer_result)

qilisdk/extras/cuda/__init__.py

@@ -1,13 +0,0 @@
-# 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.

qilisdk/extras/qaas/__init__.py

@@ -1,13 +0,0 @@
-# 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.

qilisdk/extras/qaas/models.py

@@ -1,132 +0,0 @@
-# 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 enum import Enum
-
-from pydantic import BaseModel, ConfigDict, Field
-
-from qilisdk.analog import Hamiltonian, QuantumObject, Schedule, TimeEvolution
-from qilisdk.analog.hamiltonian import PauliOperator
-from qilisdk.common.optimizer import Optimizer
-from qilisdk.digital import VQE, Circuit
-from qilisdk.yaml import yaml
-
-from .qaas_analog_result import QaaSAnalogResult
-from .qaas_digital_result import QaaSDigitalResult
-from .qaas_time_evolution_result import QaaSTimeEvolutionResult
-from .qaas_vqe_result import QaaSVQEResult
-
-
-class QaaSModel(BaseModel):
-    model_config = ConfigDict(validate_by_name=True, validate_by_alias=True, arbitrary_types_allowed=True)
-
-
-class LoginPayload(BaseModel): ...
-
-
-class Token(QaaSModel):
-    """
-    Represents the structure of the login response:
-    {
-        "accessToken": "...",
-        "expiresIn": 123456789,
-        "issuedAt": "123456789",
-        "refreshToken": "...",
-        "tokenType": "bearer"
-    }
-    """
-
-    access_token: str = Field(alias="accessToken")
-    expires_in: int = Field(alias="expiresIn")
-    issued_at: str = Field(alias="issuedAt")
-    refresh_token: str = Field(alias="refreshToken")
-    token_type: str = Field(alias="tokenType")
-
-
-class DeviceStatus(str, Enum):
-    """Device status typing for posting"""
-
-    ONLINE = "online"
-    MAINTENANCE = "maintenance"
-    OFFLINE = "offline"
-
-
-class DeviceType(str, Enum):
-    """Device type"""
-
-    QUANTUM_DIGITAL = "quantum_device"
-    QUANTUM_ANALOG = "quantum_analog_device"
-    SIMULATOR = "simulator_device"
-
-
-@yaml.register_class
-class Device(QaaSModel):
-    id: int = Field(...)
-    name: str = Field(...)
-    status: DeviceStatus = Field(...)
-    type: DeviceType = Field(...)
-
-
-class ExecutePayloadType(str, Enum):
-    DIGITAL = "digital"
-    ANALOG = "analog"
-    VQE = "vqe"
-    TIME_EVOLUTION = "time_evolution"
-
-
-@yaml.register_class
-class DigitalPayload(QaaSModel):
-    circuit: Circuit = Field(...)
-    nshots: int = Field(...)
-
-
-@yaml.register_class
-class AnalogPayload(QaaSModel):
-    schedule: Schedule = Field(...)
-    initial_state: QuantumObject = Field(...)
-    observables: list[PauliOperator | Hamiltonian] = Field(...)
-    store_intermediate_results: bool = Field(...)
-
-
-@yaml.register_class
-class VQEPayload(QaaSModel):
-    vqe: VQE = Field(...)
-    optimizer: Optimizer = Field(...)
-    nshots: int = Field(...)
-    store_intermediate_results: bool = Field(...)
-
-
-@yaml.register_class
-class TimeEvolutionPayload(QaaSModel):
-    time_evolution: TimeEvolution = Field()
-    store_intermediate_results: bool = Field()
-
-
-@yaml.register_class
-class ExecutePayload(QaaSModel):
-    type: ExecutePayloadType = Field(...)
-    device_id: int = Field(...)
-    digital_payload: DigitalPayload | None = None
-    analog_payload: AnalogPayload | None = None
-    vqe_payload: VQEPayload | None = None
-    time_evolution_payload: TimeEvolutionPayload | None = None
-
-
-@yaml.register_class
-class ExecuteResponse(QaaSModel):
-    type: ExecutePayloadType = Field(...)
-    digital_result: QaaSDigitalResult | None = None
-    analog_result: QaaSAnalogResult | None = None
-    vqe_result: QaaSVQEResult | None = None
-    time_evolution_result: QaaSTimeEvolutionResult | None = None