qoro-divi 0.2.0b1__py3-none-any.whl → 0.5.0__py3-none-any.whl

divi/exp/scipy/pyprima/common/selectx.py

@@ -1,346 +0,0 @@
-"""
-This module provides subroutines that ensure the returned X is optimal among all the calculated
-points in the sense that no other point achieves both lower function value and lower constraint
-violation at the same time. This module is needed only in the constrained case.
-
-Translated from Zaikun Zhang's modern-Fortran reference implementation in PRIMA.
-
-Dedicated to late Professor M. J. D. Powell FRS (1936--2015).
-
-Python translation by Nickolai Belakovski.
-"""
-
-import numpy as np
-import numpy.typing as npt
-
-from .consts import CONSTRMAX, DEBUGGING, EPS, FUNCMAX, REALMAX
-from .present import present
-
-
-def isbetter(f1: float, c1: float, f2: float, c2: float, ctol: float) -> bool:
-    """
-    This function compares whether FC1 = (F1, C1) is (strictly) better than FC2 = (F2, C2), which
-    basically means that (F1 < F2 and C1 <= C2) or (F1 <= F2 and C1 < C2).
-    It takes care of the cases where some of these values are NaN or Inf, even though some cases
-    should never happen due to the moderated extreme barrier.
-    At return, BETTER = TRUE if and only if (F1, C1) is better than (F2, C2).
-    Here, C means constraint violation, which is a nonnegative number.
-    """
-
-    # Preconditions
-    if DEBUGGING:
-        assert not any(np.isnan([f1, c1]) | np.isposinf([f2, c2]))
-        assert not any(np.isnan([f2, c2]) | np.isposinf([f2, c2]))
-        assert c1 >= 0 and c2 >= 0
-        assert ctol >= 0
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    is_better = False
-    # Even though NaN/+Inf should not occur in FC1 or FC2 due to the moderated extreme barrier, for
-    # security and robustness, the code below does not make this assumption.
-    is_better = is_better or (
-        any(np.isnan([f1, c1]) | np.isposinf([f1, c1]))
-        and not any(np.isnan([f2, c2]) | np.isposinf([f2, c2]))
-    )
-
-    is_better = is_better or (f1 < f2 and c1 <= c2)
-    is_better = is_better or (f1 <= f2 and c1 < c2)
-
-    # If C1 <= CTOL and C2 is significantly larger/worse than CTOL, i.e., C2 > MAX(CTOL,CREF),
-    # then FC1 is better than FC2 as long as F1 < REALMAX. Normally CREF >= CTOL so MAX(CTOL, CREF)
-    # is indeed CREF. However, this may not be true if CTOL > 1E-1*CONSTRMAX.
-    cref = 10 * max(EPS, min(ctol, 1.0e-2 * CONSTRMAX))  # The MIN avoids overflow.
-    is_better = is_better or (
-        f1 < REALMAX and c1 <= ctol and (c2 > max(ctol, cref) or np.isnan(c2))
-    )
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert not (is_better and f1 >= f2 and c1 >= c2)
-        assert is_better or not (f1 <= f2 and c1 < c2)
-        assert is_better or not (f1 < f2 and c1 <= c2)
-
-    return is_better
-
-
-def savefilt(
-    cstrv, ctol, cweight, f, x, nfilt, cfilt, ffilt, xfilt, constr=None, confilt=None
-):
-    """
-    This subroutine saves X, F, and CSTRV in XFILT, FFILT, and CFILT (and CONSTR in CONFILT
-    if they are present), unless a vector in XFILT[:, :NFILT] is better than X.
-    If X is better than some vectors in XFILT[:, :NFILT] then these vectors will be
-    removed. If X is not better than any of XFILT[:, :NFILT], but NFILT == MAXFILT,
-    then we remove a column from XFILT according to the merit function
-    PHI = FFILT + CWEIGHT * max(CFILT - CTOL, 0)
-    N.B.:
-    1. Only XFILT[:, :NFILT] and FFILT[:, :NFILT] etc contains valid information,
-    while XFILT[:, NFILT+1:MAXFILT] and FFILT[:, NFILT+1:MAXFILT] etc are not
-    initialized yet.
-    2. We decide whether and X is better than another by the ISBETTER function
-    """
-
-    # Sizes
-    if present(constr):
-        num_constraints = len(constr)
-    else:
-        num_constraints = 0
-    num_vars = len(x)
-    maxfilt = len(ffilt)
-
-    # Preconditions
-    if DEBUGGING:
-        # Check the size of X.
-        assert num_vars >= 1
-        # Check CWEIGHT and CTOL
-        assert cweight >= 0
-        assert ctol >= 0
-        # Check NFILT
-        assert nfilt >= 0 and nfilt <= maxfilt
-        # Check the sizes of XFILT, FFILT, CFILT.
-        assert maxfilt >= 1
-        assert np.size(xfilt, 0) == num_vars and np.size(xfilt, 1) == maxfilt
-        assert np.size(cfilt) == maxfilt
-        # Check the values of XFILT, FFILT, CFILT.
-        assert not (np.isnan(xfilt[:, :nfilt])).any()
-        assert not any(np.isnan(ffilt[:nfilt]) | np.isposinf(ffilt[:nfilt]))
-        assert not any(
-            cfilt[:nfilt] < 0 | np.isnan(cfilt[:nfilt]) | np.isposinf(cfilt[:nfilt])
-        )
-        # Check the values of X, F, CSTRV.
-        # X does not contain NaN if X0 does not and the trust-region/geometry steps are proper.
-        assert not any(np.isnan(x))
-        # F cannot be NaN/+Inf due to the moderated extreme barrier.
-        assert not (np.isnan(f) | np.isposinf(f))
-        # CSTRV cannot be NaN/+Inf due to the moderated extreme barrier.
-        assert not (cstrv < 0 | np.isnan(cstrv) | np.isposinf(cstrv))
-        # Check CONSTR and CONFILT.
-        assert present(constr) == present(confilt)
-        if present(constr):
-            # CONSTR cannot contain NaN/-Inf due to the moderated extreme barrier.
-            assert not any(np.isnan(constr) | np.isneginf(constr))
-            assert (
-                np.size(confilt, 0) == num_constraints
-                and np.size(confilt, 1) == maxfilt
-            )
-            assert not (
-                np.isnan(confilt[:, :nfilt]) | np.isneginf(confilt[:, :nfilt])
-            ).any()
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # Return immediately if any column of XFILT is better than X.
-    if any(
-        (
-            isbetter(ffilt_i, cfilt_i, f, cstrv, ctol)
-            for ffilt_i, cfilt_i in zip(ffilt[:nfilt], cfilt[:nfilt])
-        )
-    ) or any(np.logical_and(ffilt[:nfilt] <= f, cfilt[:nfilt] <= cstrv)):
-        return nfilt, cfilt, ffilt, xfilt, confilt
-
-    # Decide which columns of XFILT to keep.
-    keep = np.logical_not(
-        [
-            isbetter(f, cstrv, ffilt_i, cfilt_i, ctol)
-            for ffilt_i, cfilt_i in zip(ffilt[:nfilt], cfilt[:nfilt])
-        ]
-    )
-
-    # If NFILT == MAXFILT and X is not better than any column of XFILT, then we remove the worst column
-    # of XFILT according to the merit function PHI = FFILT + CWEIGHT * MAX(CFILT - CTOL, ZERO).
-    if (
-        sum(keep) == maxfilt
-    ):  # In this case, NFILT = SIZE(KEEP) = COUNT(KEEP) = MAXFILT > 0.
-        cfilt_shifted = np.maximum(cfilt - ctol, 0)
-        if cweight <= 0:
-            phi = ffilt
-        elif np.isposinf(cweight):
-            phi = cfilt_shifted
-            # We should not use CFILT here; if MAX(CFILT_SHIFTED) is attained at multiple indices, then
-            # we will check FFILT to exhaust the remaining degree of freedom.
-        else:
-            phi = np.maximum(ffilt, -REALMAX)
-            phi = np.nan_to_num(
-                phi, nan=-REALMAX
-            )  # Replace NaN with -REALMAX and +/- inf with large numbers
-            phi += cweight * cfilt_shifted
-        # We select X to maximize PHI. In case there are multiple maximizers, we take the one with the
-        # largest CSTRV_SHIFTED; if there are more than one choices, we take the one with the largest F;
-        # if there are several candidates, we take the one with the largest CSTRV; if the last comparison
-        # still leads to more than one possibilities, then they are equally bad and we choose the first.
-        # N.B.:
-        # 1. This process is the opposite of selecting KOPT in SELECTX.
-        # 2. In finite-precision arithmetic, PHI_1 == PHI_2 and CSTRV_SHIFTED_1 == CSTRV_SHIFTED_2 do
-        # not ensure that F_1 == F_2!
-        phimax = max(phi)
-        cref = max(cfilt_shifted[phi >= phimax])
-        fref = max(ffilt[cfilt_shifted >= cref])
-        kworst = np.ma.array(cfilt, mask=(ffilt > fref)).argmax()
-        if kworst < 0 or kworst >= len(keep):  #  For security. Should not happen.
-            kworst = 0
-        keep[kworst] = False
-
-    # Keep the good xfilt values and remove all the ones that are strictly worse than the new x.
-    nfilt = sum(keep)
-    index_to_keep = np.where(keep)[0]
-    xfilt[:, :nfilt] = xfilt[:, index_to_keep]
-    ffilt[:nfilt] = ffilt[index_to_keep]
-    cfilt[:nfilt] = cfilt[index_to_keep]
-    if confilt is not None and constr is not None:
-        confilt[:, :nfilt] = confilt[:, index_to_keep]
-
-    # Once we have removed all the vectors that are strictly worse than x,
-    # we add x to the filter.
-    xfilt[:, nfilt] = x
-    ffilt[nfilt] = f
-    cfilt[nfilt] = cstrv
-    if confilt is not None and constr is not None:
-        confilt[:, nfilt] = constr
-    nfilt += 1  # In Python we need to increment the index afterwards
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        # Check NFILT and the sizes of XFILT, FFILT, CFILT.
-        assert nfilt >= 1 and nfilt <= maxfilt
-        assert np.size(xfilt, 0) == num_vars and np.size(xfilt, 1) == maxfilt
-        assert np.size(ffilt) == maxfilt
-        assert np.size(cfilt) == maxfilt
-        # Check the values of XFILT, FFILT, CFILT.
-        assert not (np.isnan(xfilt[:, :nfilt])).any()
-        assert not any(np.isnan(ffilt[:nfilt]) | np.isposinf(ffilt[:nfilt]))
-        assert not any(
-            cfilt[:nfilt] < 0 | np.isnan(cfilt[:nfilt]) | np.isposinf(cfilt[:nfilt])
-        )
-        # Check that no point in the filter is better than X, and X is better than no point.
-        assert not any(
-            [
-                isbetter(ffilt_i, cfilt_i, f, cstrv, ctol)
-                for ffilt_i, cfilt_i in zip(ffilt[:nfilt], cfilt[:nfilt])
-            ]
-        )
-        assert not any(
-            [
-                isbetter(f, cstrv, ffilt_i, cfilt_i, ctol)
-                for ffilt_i, cfilt_i in zip(ffilt[:nfilt], cfilt[:nfilt])
-            ]
-        )
-        # Check CONFILT.
-        if present(confilt):
-            assert (
-                np.size(confilt, 0) == num_constraints
-                and np.size(confilt, 1) == maxfilt
-            )
-            assert not (
-                np.isnan(confilt[:, :nfilt]) | np.isneginf(confilt[:, :nfilt])
-            ).any()
-
-    return nfilt, cfilt, ffilt, xfilt, confilt
-
-
-def selectx(fhist: npt.NDArray, chist: npt.NDArray, cweight: float, ctol: float):
-    """
-    This subroutine selects X according to FHIST and CHIST, which represents (a part of) history
-    of F and CSTRV. Normally, FHIST and CHIST are not the full history but only a filter, e.g. ffilt
-    and CFILT generated by SAVEFILT. However, we name them as FHIST and CHIST because the [F, CSTRV]
-    in a filter should not dominate each other, but this subroutine does NOT assume such a property.
-    N.B.: CTOL is the tolerance of the constraint violation (CSTRV). A point is considered feasible if
-    its constraint violation is at most CTOL. Not that CTOL is absolute, not relative.
-    """
-
-    # Sizes
-    nhist = len(fhist)
-
-    # Preconditions
-    if DEBUGGING:
-        assert nhist >= 1
-        assert np.size(chist) == nhist
-        assert not any(np.isnan(fhist) | np.isposinf(fhist))
-        assert not any(chist < 0 | np.isnan(chist) | np.isposinf(chist))
-        assert cweight >= 0
-        assert ctol >= 0
-
-    # ====================#
-    # Calculation starts #
-    # ====================#
-
-    # We select X among the points with F < FREF and CSTRV < CREF.
-    # Do NOT use F <= FREF, because F == FREF (FUNCMAX or REALMAX) may mean F == INF in practice!
-    if any(np.logical_and(fhist < FUNCMAX, chist < CONSTRMAX)):
-        fref = FUNCMAX
-        cref = CONSTRMAX
-    elif any(np.logical_and(fhist < REALMAX, chist < CONSTRMAX)):
-        fref = REALMAX
-        cref = CONSTRMAX
-    elif any(np.logical_and(fhist < FUNCMAX, chist < REALMAX)):
-        fref = FUNCMAX
-        cref = REALMAX
-    else:
-        fref = REALMAX
-        cref = REALMAX
-
-    if not any(np.logical_and(fhist < fref, chist < cref)):
-        kopt = nhist - 1
-    else:
-        # Shift the constraint violations by ctol, so that cstrv <= ctol is regarded as no violation.
-        chist_shifted = np.maximum(chist - ctol, 0)
-        # cmin is the minimal shift constraint violation attained in the history.
-        cmin = np.min(chist_shifted[fhist < fref])
-        # We consider only the points whose shifted constraint violations are at most the cref below.
-        # N.B.: Without taking np.maximum(EPS, .), cref would be 0 if cmin = 0. In that case, asking for
-        # cstrv_shift < cref would be WRONG!
-        cref = np.maximum(EPS, 2 * cmin)
-        # We use the following phi as our merit function to select X.
-        if cweight <= 0:
-            phi = fhist
-        elif np.isposinf(cweight):
-            phi = chist_shifted
-            # We should not use chist here; if np.minimum(chist_shifted) is attained at multiple indices, then
-            # we will check fhist to exhaust the remaining degree of freedom.
-        else:
-            phi = np.maximum(fhist, -REALMAX) + cweight * chist_shifted
-            # np.maximum(fhist, -REALMAX) makes sure that phi will not contain NaN (unless there is a bug).
-
-        # We select X to minimize phi subject to f < fref and cstrv_shift <= cref (see the comments
-        # above for the reason of taking "<" and "<=" in these two constraints). In case there are
-        # multiple minimizers, we take the one with the least cstrv_shift; if there is more than one
-        # choice, we take the one with the least f; if there are several candidates, we take the one
-        # with the least cstrv; if the last comparison still leads to more than one possibility, then
-        # they are equally good and we choose the first.
-        # N.B.:
-        # 1. This process is the opposite of selecting kworst in savefilt
-        # 2. In finite-precision arithmetic, phi_2 == phi_2 and cstrv_shift_1 == cstrv_shifted_2 do
-        # not ensure thatn f_1 == f_2!
-        phimin = np.min(phi[np.logical_and(fhist < fref, chist_shifted <= cref)])
-        cref = np.min(chist_shifted[np.logical_and(fhist < fref, phi <= phimin)])
-        fref = np.min(fhist[chist_shifted <= cref])
-        # Can't use argmin here because using it with a mask throws off the index
-        kopt = np.ma.array(chist, mask=(fhist > fref)).argmin()
-
-    # ==================#
-    # Calculation ends #
-    # ==================#
-
-    # Postconditions
-    if DEBUGGING:
-        assert kopt >= 0 and kopt < nhist
-        assert not any(
-            [
-                isbetter(fhisti, chisti, fhist[kopt], chist[kopt], ctol)
-                for fhisti, chisti in zip(fhist[:nhist], chist[:nhist])
-            ]
-        )
-
-    return kopt

divi/interfaces.py

@@ -1,25 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-from abc import ABC, abstractmethod
-
-
-class CircuitRunner(ABC):
-    """
-    A generic interface for anything that can "run" quantum circuits.
-    """
-
-    def __init__(self, shots: int):
-        if shots <= 0:
-            raise ValueError(f"Shots must be a positive integer. Got {shots}.")
-
-        self._shots = shots
-
-    @property
-    def shots(self):
-        return self._shots
-
-    @abstractmethod
-    def submit_circuits(self, circuits: dict[str, str], **kwargs):
-        pass

divi/parallel_simulator.py

@@ -1,258 +0,0 @@
-# SPDX-FileCopyrightText: 2025 Qoro Quantum Ltd <divi@qoroquantum.de>
-#
-# SPDX-License-Identifier: Apache-2.0
-
-import bisect
-import heapq
-import logging
-from functools import partial
-from multiprocessing import Pool
-from typing import Literal, Optional
-from warnings import warn
-
-import qiskit_ibm_runtime.fake_provider as fk_prov
-from qiskit import QuantumCircuit, transpile
-from qiskit.converters import circuit_to_dag
-from qiskit.dagcircuit import DAGOpNode
-from qiskit.providers import Backend
-from qiskit_aer import AerSimulator
-from qiskit_aer.noise import NoiseModel
-
-from divi.interfaces import CircuitRunner
-
-logger = logging.getLogger(__name__)
-
-FAKE_BACKENDS = {
-    5: [
-        fk_prov.FakeManilaV2,
-        fk_prov.FakeBelemV2,
-        fk_prov.FakeLimaV2,
-        fk_prov.FakeQuitoV2,
-    ],
-    7: [
-        fk_prov.FakeOslo,
-        fk_prov.FakePerth,
-        fk_prov.FakeLagosV2,
-        fk_prov.FakeNairobiV2,
-    ],
-    15: [fk_prov.FakeMelbourneV2],
-    16: [fk_prov.FakeGuadalupeV2],
-    20: [
-        fk_prov.FakeAlmadenV2,
-        fk_prov.FakeJohannesburgV2,
-        fk_prov.FakeSingaporeV2,
-        fk_prov.FakeBoeblingenV2,
-    ],
-    27: [
-        fk_prov.FakeGeneva,
-        fk_prov.FakePeekskill,
-        fk_prov.FakeAuckland,
-        fk_prov.FakeCairoV2,
-    ],
-}
-
-
-def _find_best_fake_backend(circuit: QuantumCircuit):
-    keys = sorted(FAKE_BACKENDS.keys())
-    pos = bisect.bisect_left(keys, circuit.num_qubits)
-    return FAKE_BACKENDS[keys[pos]] if pos < len(keys) else None
-
-
-class ParallelSimulator(CircuitRunner):
-    def __init__(
-        self,
-        n_processes: int = 2,
-        shots: int = 5000,
-        simulation_seed: Optional[int] = None,
-        qiskit_backend: Backend | Literal["auto"] | None = None,
-        noise_model: Optional[NoiseModel] = None,
-    ):
-        """
-        A multi-process wrapper around Qiskit's AerSimulator.
-
-        Args:
-            n_processes (int, optional): Number of parallel processes to use for simulation. Defaults to 2.
-            shots (int, optional): Number of shots to perform. Defaults to 5000.
-            simulation_seed (Optional[int], optional): Seed for the random number generator to ensure reproducibility. Defaults to None.
-            backend (Backend or "auto, optional): A Qiskit backend to initiate the simulator from. If "auto" is passed,
-             the best-fit most recent fake backend will be chosen for the given circuit. Defaults to None, resulting in noiseless simulation.
-            noise_model (NoiseModel, optional): Qiskit noise model to use in simulation. Defaults to None.
-        """
-        super().__init__(shots=shots)
-
-        if qiskit_backend and noise_model:
-            warn(
-                "Both `qiskit_backend` and `noise_model` have been provided."
-                " `noise_model` will be ignored and the model from the backend will be used instead."
-            )
-
-        self.n_processes = n_processes
-        self.engine = "qiskit"
-        self.simulation_seed = simulation_seed
-        self.qiskit_backend = qiskit_backend
-        self.noise_model = noise_model
-
-    @staticmethod
-    def simulate_circuit(
-        circuit_data: tuple[str, str],
-        shots: int,
-        simulation_seed: Optional[int] = None,
-        qiskit_backend: Optional[Backend] = None,
-        noise_model: Optional[NoiseModel] = None,
-    ):
-        circuit_label, circuit = circuit_data
-
-        qiskit_circuit = QuantumCircuit.from_qasm_str(circuit)
-
-        resolved_backend = (
-            _find_best_fake_backend(qiskit_circuit)[-1]()
-            if qiskit_backend == "auto"
-            else qiskit_backend
-        )
-
-        aer_simulator = (
-            AerSimulator.from_backend(resolved_backend)
-            if qiskit_backend
-            else AerSimulator(noise_model=noise_model)
-        )
-        transpiled_circuit = transpile(qiskit_circuit, aer_simulator)
-
-        aer_simulator.set_option("seed_simulator", simulation_seed)
-        job = aer_simulator.run(transpiled_circuit, shots=shots)
-
-        result = job.result()
-        counts = result.get_counts(0)
-
-        return {"label": circuit_label, "results": dict(counts)}
-
-    def set_seed(self, seed: int):
-        self.simulation_seed = seed
-
-    def submit_circuits(self, circuits: dict[str, str]):
-        logger.debug(
-            f"Simulating {len(circuits)} circuits with {self.n_processes} processes"
-        )
-
-        with Pool(processes=self.n_processes) as pool:
-            results = pool.starmap(
-                self.simulate_circuit,
-                [
-                    (
-                        circuit,
-                        self.shots,
-                        self.simulation_seed,
-                        self.qiskit_backend,
-                        self.noise_model,
-                    )
-                    for circuit in circuits.items()
-                ],
-            )
-        return results
-
-    @staticmethod
-    def estimate_run_time_single_circuit(
-        circuit: str,
-        qiskit_backend: Backend | Literal["auto"],
-        **transpilation_kwargs,
-    ) -> float:
-        """
-        Estimate the execution time of a quantum circuit on a given backend, accounting for parallel gate execution.
-
-        Parameters:
-            circuit: The quantum circuit to estimate execution time for as a QASM string.
-            qiskit_backend: A Qiskit backend to use for gate time estimation.
-
-        Returns:
-            float: Estimated execution time in seconds.
-        """
-        qiskit_circuit = QuantumCircuit.from_qasm_str(circuit)
-
-        resolved_backend = (
-            _find_best_fake_backend(qiskit_circuit)[-1]()
-            if qiskit_backend == "auto"
-            else qiskit_backend
-        )
-
-        transpiled_circuit = transpile(
-            qiskit_circuit, resolved_backend, **transpilation_kwargs
-        )
-
-        dag = circuit_to_dag(transpiled_circuit)
-
-        total_run_time_s = 0.0
-        for node in dag.longest_path():
-            if not isinstance(node, DAGOpNode):
-                continue
-
-            op_name = node.name
-
-            if node.num_clbits == 1:
-                idx = (node.cargs[0]._index,)
-
-            if op_name != "measure" and node.num_qubits > 0:
-                idx = tuple(qarg._index for qarg in node.qargs)
-
-            try:
-                total_run_time_s += (
-                    qiskit_backend.instruction_durations.duration_by_name_qubits[
-                        (op_name, idx)
-                    ][0]
-                )
-            except KeyError:
-                if op_name == "barrier":
-                    continue
-                warn(f"Instruction duration not found: {op_name}")
-
-        return total_run_time_s
-
-    @staticmethod
-    def estimate_run_time_batch(
-        circuits: Optional[list[str]] = None,
-        precomputed_duration: Optional[list[float]] = None,
-        n_qpus: int = 5,
-        **transpilation_kwargs,
-    ) -> float:
-        """
-        Estimate the execution time of a quantum circuit on a given backend, accounting for parallel gate execution.
-
-        Parameters:
-            circuits (list[str]): The quantum circuits to estimate execution time for, as QASM strings.
-            precomputed_durations (list[float]): A list of precomputed durations to use.
-            n_qpus (int): Number of QPU nodes in the pre-supposed cluster we are estimating runtime against.
-
-        Returns:
-            float: Estimated execution time in seconds.
-        """
-
-        # Compute the run time estimates for each given circuit, in descending order
-        if precomputed_duration is None:
-            with Pool() as p:
-                estimated_run_times = p.map(
-                    partial(
-                        ParallelSimulator.estimate_run_time_single_circuit,
-                        qiskit_backend="auto",
-                        **transpilation_kwargs,
-                    ),
-                    circuits,
-                )
-            estimated_run_times_sorted = sorted(estimated_run_times, reverse=True)
-        else:
-            estimated_run_times_sorted = sorted(precomputed_duration, reverse=True)
-
-        # Just return the longest run time if there are enough QPUs
-        if n_qpus >= len(estimated_run_times_sorted):
-            return estimated_run_times_sorted[0]
-
-        # Initialize processor queue with (total_run_time, processor_id)
-        # Using a min heap to always get the processor that will be free first
-        processors = [(0, i) for i in range(n_qpus)]
-        heapq.heapify(processors)
-
-        # Assign each task to the processor that will be free first
-        for run_time in estimated_run_times_sorted:
-            current_run_time, processor_id = heapq.heappop(processors)
-            new_run_time = current_run_time + run_time
-            heapq.heappush(processors, (new_run_time, processor_id))
-
-        # The total run time is the maximum run time across all processors
-        return max(run_time for run_time, _ in processors)