qoro-divi 0.2.2b1__py3-none-any.whl → 0.3.0b1__py3-none-any.whl

divi/qprog/batch.py

@@ -2,6 +2,7 @@
 #
 # SPDX-License-Identifier: Apache-2.0
 
+import atexit
 import traceback
 from abc import ABC, abstractmethod
 from concurrent.futures import ProcessPoolExecutor, as_completed
@@ -51,6 +52,10 @@ def queue_listener(
         )
 
 
+def _default_task_function(program: QuantumProgram):
+    return program.run()
+
+
 class ProgramBatch(ABC):
     """This abstract class provides the basic scaffolding for higher-order
     computations that require more than one quantum program to achieve its goal.
@@ -74,6 +79,7 @@ class ProgramBatch(ABC):
 
         self.backend = backend
         self._executor = None
+        self._task_fn = _default_task_function
         self.programs = {}
 
         self._total_circuit_count = 0
@@ -95,6 +101,12 @@ class ProgramBatch(ABC):
 
     @abstractmethod
     def create_programs(self):
+        if len(self.programs) > 0:
+            raise RuntimeError(
+                "Some programs already exist. "
+                "Clear the program dictionary before creating new ones by using batch.reset()."
+            )
+
         self._manager = Manager()
         self._queue = self._manager.Queue()
 
@@ -118,27 +130,36 @@ class ProgramBatch(ABC):
         if getattr(self, "_listener_thread", None) is not None:
             self._listener_thread.join(timeout=1)
             if self._listener_thread.is_alive():
-                warn(
-                    "Listener thread did not terminate within timeout and may still be running."
-                )
-            else:
-                self._listener_thread = None
-            self._queue.close()
-            self._queue.join_thread()
+                warn("Listener thread did not terminate within timeout.")
+            self._listener_thread = None
+
+        # Shut down the manager process, which handles the queue cleanup.
+        if hasattr(self, "_manager") and self._manager is not None:
+            self._manager.shutdown()
+            self._manager = None
             self._queue = None
 
         # Stop the progress bar if it's still active
         if getattr(self, "_progress_bar", None) is not None:
             try:
                 self._progress_bar.stop()
-                self._progress_bar = None
             except Exception:
                 pass  # Already stopped or not running
-
+            self._progress_bar = None
             self._pb_task_map.clear()
 
+    def _atexit_cleanup_hook(self):
+        # This hook is only registered for non-blocking runs.
+        if self._executor is not None:
+            warn(
+                "A non-blocking ProgramBatch run was not explicitly closed with "
+                "'join()'. The batch was cleaned up automatically on exit.",
+                UserWarning,
+            )
+            self.reset()
+
     def add_program_to_executor(self, program):
-        self.futures.append(self._executor.submit(program.run))
+        self.futures.append(self._executor.submit(self._task_fn, program))
 
         if self._progress_bar is not None:
             with self._pb_lock:
@@ -153,7 +174,7 @@ class ProgramBatch(ABC):
                     mode=("simulation" if self._is_local else "network"),
                 )
 
-    def run(self):
+    def run(self, blocking: bool = False):
         if self._executor is not None:
             raise RuntimeError("A batch is already being run.")
 
@@ -193,10 +214,19 @@ class ProgramBatch(ABC):
         for program in self.programs.values():
             self.add_program_to_executor(program)
 
+        if not blocking:
+            # Arm safety net
+            atexit.register(self._atexit_cleanup_hook)
+
+        if blocking:
+            self.join()
+
+        return self
+
     def check_all_done(self):
         return all(future.done() for future in self.futures)
 
-    def wait_for_all(self):
+    def join(self):
         if self._executor is None:
             return
 
@@ -228,8 +258,25 @@ class ProgramBatch(ABC):
 
         self._total_circuit_count += sum(future.result()[0] for future in self.futures)
         self._total_run_time += sum(future.result()[1] for future in self.futures)
-        self.futures = []
+        self.futures.clear()
+
+        # After successful cleanup, try to unregister the hook.
+        # This will only succeed if it was a non-blocking run.
+        try:
+            atexit.unregister(self._atexit_cleanup_hook)
+        except TypeError:
+            # This is expected for blocking runs where the hook was never registered.
+            pass
 
     @abstractmethod
     def aggregate_results(self):
-        raise NotImplementedError
+        if len(self.programs) == 0:
+            raise RuntimeError("No programs to aggregate. Run create_programs() first.")
+
+        if self._executor is not None:
+            self.join()
+
+        if any(len(program.losses) == 0 for program in self.programs.values()):
+            raise RuntimeError(
+                "Some/All programs have empty losses. Did you call run()?"
+            )

divi/qprog/quantum_program.py

@@ -7,10 +7,9 @@ import pickle
 from abc import ABC, abstractmethod
 from functools import partial
 from queue import Queue
-from typing import Optional
 
 import numpy as np
-from qiskit.result import marginal_counts, sampled_expectation_value
+from pennylane.measurements import ExpectationMP
 from scipy.optimize import OptimizeResult, minimize
 
 from divi import QoroService
@@ -28,8 +27,8 @@ class QuantumProgram(ABC):
     def __init__(
         self,
         backend: CircuitRunner,
-        seed: Optional[int] = None,
-        progress_queue: Optional[Queue] = None,
+        seed: int | None = None,
+        progress_queue: Queue | None = None,
         **kwargs,
     ):
         """
@@ -52,14 +51,14 @@ class QuantumProgram(ABC):
             progress_queue (Queue): a queue for progress bar updates.
 
             **kwargs: Additional keyword arguments that influence behaviour.
-                - grouping_strategy (Optional[Any]): A strategy for grouping operations, used in Pennylane's transforms.
+                - grouping_strategy (Literal["default", "wires", "qwc"]): A strategy for grouping operations, used in Pennylane's transforms.
                     Defaults to None.
-                - qem_protocol (Optional[QEMProtocol]): the quantum error mitigation protocol to apply.
+                - qem_protocol (QEMProtocol, optional): the quantum error mitigation protocol to apply.
                     Must be of type QEMProtocol. Defaults to None.
 
                 The following key values are reserved for internal use and should not be set by the user:
-                - losses (Optional[list]): A list to initialize the `losses` attribute. Defaults to an empty list.
-                - final_params (Optional[list]): A list to initialize the `final_params` attribute. Defaults to an empty list.
+                - losses (list, optional): A list to initialize the `losses` attribute. Defaults to an empty list.
+                - final_params (list, optional): A list to initialize the `final_params` attribute. Defaults to an empty list.
 
         """
 
@@ -264,9 +263,9 @@ class QuantumProgram(ABC):
                 curr_marginal_results = []
                 for observable in curr_measurement_group:
                     intermediate_exp_values = [
-                        sampled_expectation_value(
-                            marginal_counts(shots_dict, observable.wires.tolist()),
-                            "Z" * len(observable.wires),
+                        ExpectationMP(observable).process_counts(
+                            shots_dict,
+                            tuple(reversed(range(len(next(iter(shots_dict.keys())))))),
                         )
                         for shots_dict in group_results.values()
                     ]

divi/qpu_system.py

@@ -0,0 +1,20 @@
+# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, repr=True)
+class QPU:
+    nickname: str
+    q_bits: int
+    status: str
+    system_kind: str
+
+
+@dataclass(frozen=True, repr=True)
+class QPUSystem:
+    name: str
+    qpus: list[QPU]
+    access_level: str

qoro_divi-0.3.0b1.dist-info/LICENSES/.license-header

@@ -0,0 +1,3 @@
+SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
+
+SPDX-License-Identifier: Apache-2.0

{qoro_divi-0.2.2b1.dist-info → qoro_divi-0.3.0b1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: qoro-divi
-Version: 0.2.2b1
+Version: 0.3.0b1
 Summary: 
 Author: Ahmed Darwish
 Author-email: ahmed@qoroquantum.de
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Requires-Dist: cirq-core (<1.5.0)
 Requires-Dist: dill (>=0.4.0,<0.5.0)
+Requires-Dist: dwave-hybrid (>=0.6.14,<0.7.0)
 Requires-Dist: matplotlib (>=3.10.3,<4.0.0)
 Requires-Dist: mitiq (>=0.46,<0.47)
 Requires-Dist: networkx (>=3.5,<4.0)
@@ -19,7 +20,6 @@ Requires-Dist: pymetis (>=2025.1.1,<2026.0.0)
 Requires-Dist: python-dotenv (>=1.1.1,<2.0.0)
 Requires-Dist: qiskit (<2.0)
 Requires-Dist: qiskit-aer (>=0.17.1,<0.18.0)
-Requires-Dist: qiskit-algorithms (>=0.3.1,<0.4.0)
 Requires-Dist: qiskit-ibm-runtime (>=0.37,<0.38)
 Requires-Dist: qiskit-optimization (>=0.6.1,<0.7.0)
 Requires-Dist: requests (>=2.32.4,<3.0.0)
@@ -37,6 +37,9 @@ Divi is designed to allow researchers, students, and enterprises to deploy quant
 
 ---
 
+> [!IMPORTANT]
+> Divi is under active development and in early stages. Users should expect frequent changes that are likely to be incompatible with previously published versions.
+
 ## 🚀 Features
 
 - 🧠 **Smart Job Parallelization**: Automatically parallelizes your quantum programs based on task structure.

{qoro_divi-0.2.2b1.dist-info → qoro_divi-0.3.0b1.dist-info}/RECORD

@@ -1,11 +1,12 @@
 divi/__init__.py,sha256=WNAlzdjio0M5la_NTGk4-0AFqItI6HEBExRs6ck9j0Y,203
-divi/_pbar.py,sha256=YDTXMPa8INGzY2zJRloUj5YVINg6TYDqKDY4Yt1qtek,2051
-divi/circuits.py,sha256=tNNCZ61w06aaysOkr_1-USaeIDu63MbF1k1Ry7Y_T6g,4492
-divi/exp/cirq/__init__.py,sha256=TLt2WskG9j-y17Lv0Zgsg-gQgmZGFbp_lwHQYpj2GsM,312
+divi/_pbar.py,sha256=M6FQByH63bWwzsKtedW49Hm7hFsnb1X5AlFfCZFSvuU,2019
+divi/circuits.py,sha256=OKcwTMXIvCIjvpLvdeQBWGYElcVUNNyA3z8yXnxUXeo,4476
+divi/exp/cirq/__init__.py,sha256=4wd5rEiNgsPVSK8uLYdJMf54B1ITdtKfMJtdnRpfwTE,350
 divi/exp/cirq/_lexer.py,sha256=x5UArrnN_JEyiq7E02ikq0wdmqZ2vEQ3_FADL1LIhQI,3187
 divi/exp/cirq/_parser.py,sha256=z_bSn4m03-sfRlN8eL99Mo4LnjY-zmR-Xt6UrjzstZc,29279
 divi/exp/cirq/_qasm_export.py,sha256=8C5xLYvIIkQTWWAAYo7ZjwtQjvYXNSflbf5UyUx6YUE,1024
 divi/exp/cirq/_qasm_import.py,sha256=HbehrgfLl3iDdRyWr4o26Bek3ZpN-_dvNVSexl5-aVE,969
+divi/exp/cirq/_validator.py,sha256=nYbJdT_0hCVUgZA0YiKZ8G1oDgwmcqEiy-LZH41EgUw,20481
 divi/exp/cirq/exception.py,sha256=w1w2vSubOGMRmyKBFqXejxfeIAzkPZ6V7gSrDX_ap4A,765
 divi/exp/scipy/_cobyla.py,sha256=cnCf5AsOM8JWIMiujuUbWMNOgmUr3ZET9y04hUyumHs,10937
 divi/exp/scipy/pyprima/LICENCE.txt,sha256=mXN5ssG_U6OR0v0yldznW_PJTtKNZIgu3jDRtRjLDdY,1533
@@ -36,23 +37,25 @@ divi/exp/scipy/pyprima/common/ratio.py,sha256=taadehpW0c3ULUggH5frIMpvTom53dsEhv
 divi/exp/scipy/pyprima/common/redrho.py,sha256=J6rJILcOoCeo942LUAXxpUvKLarUGNCGdC-zcmIlVHE,1264
 divi/exp/scipy/pyprima/common/selectx.py,sha256=mXVS2L6AuTmbOhpp1KlXwOBR54ttnbjwagYfnXhezJY,14713
 divi/interfaces.py,sha256=P-8lekQIGwbhHv4ewfMFtKYIjmQHu7nmscwAmxsx72U,594
-divi/parallel_simulator.py,sha256=SjL23zcS-AKyxHG8TeAowDFytpXAshhy64GEkEUnogs,8988
-divi/qasm.py,sha256=agHSRqkIYdfVx1w0zcaIXYe_KDpNz38tni-cu20SMN4,7418
+divi/parallel_simulator.py,sha256=2JCwmootXLtDplplEqtykKc8HiYe6G0zKWemIb-IIdE,8947
+divi/qasm.py,sha256=lfWky4E9qetotVo8BII58svutVVZEV14BntoC14bo40,7384
 divi/qem.py,sha256=o6rMPUcxLuCBitBb8-QcxveUiKZVsP3HMamxyVFLi6M,6805
 divi/qlogger.py,sha256=VaCnw-u8VkR7JukjOp39r0V89wO-SSpDj5l50ejnHUg,3801
-divi/qoro_service.py,sha256=Ry7Pt7EZCpnwwLJ_5Fx2WhXHiFmI6z23zUdAaygkx3Y,11386
-divi/qprog/__init__.py,sha256=z8OTd_PdcnEvrcRGvoGsPjj8WYU8HuMHhNyuVMBsNAE,457
-divi/qprog/_graph_partitioning.py,sha256=61bkhz5VTS_pYHSEKCcnvaawD5p0AHk8Fh1EtEjdLkE,22006
-divi/qprog/_mlae.py,sha256=eLEJqYESZG3oI-XsRjgA5aoNs7Er_CspnJ0wJBX0qdU,5769
-divi/qprog/_qaoa.py,sha256=pDMf5RJQ2YHVYiHBpSPu0WkwD4JjF1ARubRD6xbtceA,15445
-divi/qprog/_vqe.py,sha256=JAow9uDTsAOa-n-N5t4CrA04uVuAbGi20s9qB-FSqYU,9427
-divi/qprog/_vqe_sweep.py,sha256=eKvF6sUeqkyRDKuRxd_k-WoQa9ARkzoOLKolLqkpd5s,4873
-divi/qprog/batch.py,sha256=lXID75p4xU88UbukhGIIv6SI1ZrPHsTBzS9u6fPVyhE,7960
+divi/qoro_service.py,sha256=sv94S_xdY4k4YYSK3PgX4sgvgldFMkjJ3wtQO1a_2Yc,13557
+divi/qprog/__init__.py,sha256=quz1zEdrY71TuNVXUHq9u92sORgPmmNq8y6ozMiYnTI,507
+divi/qprog/_graph_partitioning.py,sha256=ZVDKc5--YB9EmuA7Qsyc0Rc5P-eojWpglO-XqoMmbZk,23620
+divi/qprog/_qaoa.py,sha256=FCO3s0mA6rlrymqUjvpfY640DoLLIFP8tqi8z7UAamM,16129
+divi/qprog/_qubo_partitioning.py,sha256=7MxeUfZ5PDkfzPprcXh_1omdvUuCK_I4qh1915XAVhk,7388
+divi/qprog/_vqe.py,sha256=0MNSZA9wb6CKhLIT5SpM_J2ncW-p1frKBp8k0ipOYwQ,9985
+divi/qprog/_vqe_sweep.py,sha256=lTWPG7vwtVS91Piqc5-_tlhglO8RFkMhlatCTz-8PZg,17214
+divi/qprog/batch.py,sha256=UWiDsABFWNggvR136jBnTg6r5OUuHHh3nOCGL1keAy8,9654
 divi/qprog/optimizers.py,sha256=l19zIyt1l0IhUbLofEXlwE9XnsILk7ANlwACi3KKN4w,2034
-divi/qprog/quantum_program.py,sha256=ZMGPFLYZeLiOiU5S7NSlCPAY5vl0R_bv5SRYdEArjSM,16952
+divi/qprog/quantum_program.py,sha256=hJ5uraX9ZNicfoJu3X0aAe8KTJUzndgX5GyoHZ1GOB8,16921
+divi/qpu_system.py,sha256=teVeG18ukyzMFgbPSr4BLx4MJUHVK382RqZMOy2voFk,374
 divi/utils.py,sha256=EEyGakoz33AvU0Rq7iijL8AULMg4FGcGBtmOlpSw-tY,3603
-qoro_divi-0.2.2b1.dist-info/LICENSE,sha256=NS4JlQrgNwg1bvB3kE5shE-P4cJgnntgl-kClbOpG_Q,10760
-qoro_divi-0.2.2b1.dist-info/LICENSES/Apache-2.0.txt,sha256=yoILHpvVuguUBpk8UwMnzJbcHUUyst9iGNNuEwUtWVc,10270
-qoro_divi-0.2.2b1.dist-info/METADATA,sha256=sDVZbOU64XYPZBF_woJU64eoYKihJgcEfEBnhVdLufM,2102
-qoro_divi-0.2.2b1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
-qoro_divi-0.2.2b1.dist-info/RECORD,,
+qoro_divi-0.3.0b1.dist-info/LICENSE,sha256=NS4JlQrgNwg1bvB3kE5shE-P4cJgnntgl-kClbOpG_Q,10760
+qoro_divi-0.3.0b1.dist-info/LICENSES/.license-header,sha256=2jN_xtJscqP8LG-NaveY2KHUkfRCC543Y_XjOyKEfWY,105
+qoro_divi-0.3.0b1.dist-info/LICENSES/Apache-2.0.txt,sha256=yoILHpvVuguUBpk8UwMnzJbcHUUyst9iGNNuEwUtWVc,10270
+qoro_divi-0.3.0b1.dist-info/METADATA,sha256=P2Au2m2UuCwiwB1TM9eJl6tjTQc6RgTcGnhy6qp2drE,2278
+qoro_divi-0.3.0b1.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+qoro_divi-0.3.0b1.dist-info/RECORD,,

divi/qprog/_mlae.py

@@ -1,182 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from functools import reduce
-
-import numpy as np
-import scipy.optimize as optimize
-from qiskit import QuantumCircuit
-from qiskit_algorithms import EstimationProblem, MaximumLikelihoodAmplitudeEstimation
-
-from divi.circuits import Circuit
-from divi.qprog.quantum_program import QuantumProgram
-
-
-class BernoulliA(QuantumCircuit):
-    """A circuit representing the Bernoulli A operator."""
-
-    def __init__(self, probability):
-        super().__init__(1)
-
-        theta_p = 2 * np.arcsin(np.sqrt(probability))
-        self.ry(theta_p, 0)
-
-
-class BernoulliQ(QuantumCircuit):
-    """A circuit representing the Bernoulli Q operator."""
-
-    def __init__(self, probability):
-        super().__init__(1)
-
-        self._theta_p = 2 * np.arcsin(np.sqrt(probability))
-        self.ry(2 * self._theta_p, 0)
-
-    def power(self, k):
-        # implement the efficient power of Q
-        q_k = QuantumCircuit(1)
-        q_k.ry(2 * k * self._theta_p, 0)
-        return q_k
-
-
-class MLAE(QuantumProgram):
-    """
-    An implementation of the Maximum Likelihood Amplitude Estimateion described in
-    https://arxiv.org/pdf/1904.10246
-    """
-
-    def __init__(
-        self,
-        grovers: list[int],
-        qubits_to_measure: list[int],
-        probability: float,
-        **kwargs,
-    ):
-        """
-        Initializes the MLAE problem.
-        args:
-            grovers (list): A list of non-negative integers corresponding to the powers of the Grover
-            operator for each iteration
-            qubits: An integer or list of integers containing the index of the qubits to measure
-            probability: The probability of being in the good state to estimate
-            shots: The number of shots to run for each circuit. Default set at 5000.
-        """
-
-        super().__init__(**kwargs)
-
-        self.grovers = grovers
-        self.qubits_to_measure = qubits_to_measure
-        self.probability = probability
-        self.likelihood_functions = []
-
-    def _create_meta_circuits_dict(self):
-        return super()._create_meta_circuits_dict()
-
-    def _generate_circuits(self, params=None, **kwargs):
-        """
-        Generates the circuits that perform step one of the MLAE algorithm,
-            the quantum amplitude amplification.
-
-        Inputs a selection of m values corresponding to the powers of the
-            Grover operatorfor each iteration.
-
-        Returns:
-            A list of QASM circuits to run on various devices
-        """
-        self.circuits.clear()
-
-        A = BernoulliA(self.probability)
-        Q = BernoulliQ(self.probability)
-
-        problem = EstimationProblem(
-            state_preparation=A,
-            grover_operator=Q,
-            objective_qubits=self.qubits_to_measure,
-        )
-
-        qiskit_circuits = MaximumLikelihoodAmplitudeEstimation(
-            self.grovers
-        ).construct_circuits(problem)
-
-        for circuit, grover in zip(qiskit_circuits, self.grovers):
-            circuit.measure_all()
-            self.circuits.append(Circuit(circuit, tags=[f"{grover}"]))
-
-    def run(self, store_data=False, data_file=None):
-        self._generate_circuits()
-        self._dispatch_circuits_and_process_results(
-            store_data=store_data, data_file=data_file
-        )
-
-    def _post_process_results(self, results):
-        """
-        Generates the likelihood function for each circuit of the quantum
-        amplitude amplification. These likelihood functions will then
-        be combined to create a maximum likelihood function to analyze.
-
-        Returns:
-            A callable maximum likelihood function
-        """
-
-        # Define the necessary variables Nk, Mk, Lk
-        for label, shots_dict in results.items():
-            mk = int(label)
-            Nk = 0
-            hk = 0
-            for key, shots in shots_dict.items():
-                Nk += shots
-                hk += shots if key.count("1") == len(key) else 0
-
-            def likelihood_function(theta, mk=mk, hk=hk, Nk=Nk):
-                as_theta = np.arcsin(np.sqrt(theta))
-                return ((np.sin((2 * mk + 1) * as_theta)) ** (2 * hk)) * (
-                    (np.cos((2 * mk + 1) * as_theta)) ** (2 * (Nk - hk))
-                )
-
-            self.likelihood_functions.append(likelihood_function)
-
-    def generate_maximum_likelihood_function(self, factor=1.0):
-        """
-        Post-processing takes in likelihood functions.
-
-        A large factor (e.g. 1e200) should be used for visualization purposes.
-        Returns:
-            The maximum likelihood function.
-        """
-
-        def combined_likelihood_function(theta):
-            return (
-                reduce(
-                    lambda result, f: result * f(theta), self.likelihood_functions, 1.0
-                )
-                * factor
-            )
-
-        self.maximum_likelihood_fn = combined_likelihood_function
-
-        return combined_likelihood_function
-
-    def estimate_amplitude(self, factor):
-        """
-        Uses the maximum likelihood function to ascertain
-        a value for the amplitude.
-
-        Returns
-            Estimation of the amplitude
-        """
-
-        def minimum_likelihood_function(theta):
-            # The factor to set to -10e30 in the older branch
-            return (
-                reduce(
-                    lambda result, f: result * f(theta), self.likelihood_functions, 1.0
-                )
-                * factor
-            )
-
-        # create the range of possible amplitudes
-        amplitudes = np.linspace(0, 1, 100)
-
-        bounds = [(min(amplitudes), max(amplitudes))]
-
-        return optimize.differential_evolution(minimum_likelihood_function, bounds).x[0]