Pith. sign in

REVIEW 4 major objections 5 minor 1 cited by

Adaptive Job Scheduling in Quantum Clouds Using Reinforcement Learning

T0 review · 4 major / 5 minor · reviewed 2026-08-07 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read The paper's central claim is that, across 1,000 synthetic circuits of 130–250 qubits run on five simulated 127-qubit processors, error-aware scheduling achieves the highest average fidelity, and that its open-source simulator is the first…

desk verdict The simulator is a genuinely useful artifact, but the RL comparison is undermined by a reward-evaluation mismatch that the authors themselves acknowledge. read the letter →

arxiv 2506.10889 v1 pith:D6QJG5K6 submitted 2025-06-12 cs.DC quant-ph

Waylon Luo (1) , Jiapeng Zhao (2) , Tong Zhan (3) , Qiang Guan (1) ((1) Kent State University , (2) Cisco , (3) Meta) This is my paper
classification cs.DCquant-ph
keywords quantumcloudschedulingdistributedcomputingreinforcementlearningfidelity-awarediscrete-eventsimulationcircuitpartitioningmulti-QPUexecutionproximalpolicyoptimization
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper sets out to show that scheduling large quantum circuits across several connected quantum processors is not only possible but can be guided by hardware noise data, and it provides a simulation testbed to demonstrate this. Its headline experiment runs 1,000 synthetic jobs of 130–250 qubits on five simulated 127-qubit processors and compares four schedulers: speed-first, error-aware, fair, and reinforcement-learning (PPO). The paper claims the error-aware scheduler gives the highest average final fidelity, 0.68781, versus 0.65332 for speed-first and 0.62087 for the reinforcement-learning scheduler, while the RL scheduler finishes fastest but with the lowest fidelity and highest communication overhead. The paper further claims this is the first open-source framework to support scheduling circuits that exceed any single processor's capacity, and that parallelized, noise-aware scheduling can meaningfully improve throughput in distributed quantum infrastructures.

What carries the argument

The load-bearing object is a discrete-event simulator of a quantum cloud: jobs arrive, a broker applies one of four device-selection policies, circuits are partitioned into connected-subgraph allocations across devices, and execution proceeds with blocking classical communication between devices. The simulator's quantitative core is a hand-built performance model, Eqs. (4)–(9), in which device fidelity is the product of single-qubit $(1-\bar{\varepsilon}_{1Q})^{d}$, two-qubit $(1-\bar{\varepsilon}_{2Q})^{\sqrt{N_{2Q}}}$, and readout $(1-\varepsilon_{\mathrm{readout}})^{\sqrt{N_{\mathrm{qubits}}/N_{\mathrm{devices}}}}$ terms; an inter-device penalty applies $\phi^{N_{\mathrm{devices}}-1}$ with $\phi = 0.95$ per link; communication latency scales as $0.02$ seconds per qubit; and execution time is derived from CLOPS and quantum volume. The reinforcement-learning scheduler wraps this same environment as a one-step Markov decision process whose reward is the average per-device fidelity, trained with proximal policy optimization. This model converts the scheduling question into comparable fidelity and runtime numbers, and it is what the four strategies are actually competing on.

What would settle it

Run the same 1,000-job workload on real 127-qubit processors connected by real-time classical links and compare measured final fidelities and runtimes to the model's predictions; if error-aware scheduling no longer beats the speed-first and RL schedulers by roughly 0.03–0.07 in average fidelity, or if the measured per-link survival factor departs from 0.95, the claimed ranking is an artifact of the model.

Watch

Extended reading notes

Core claim

On the paper's own terms, the discovery is a ranking: when large circuits have to be split across multiple noisy QPUs, the scheduler's device-selection policy measurably changes both fidelity and runtime. The fidelity-first strategy, which routes jobs to processors with the lowest calibration-based error scores, attains the best average final fidelity (0.68781 ± 0.02605) and the lowest communication time (3.8 ks), at the cost of the longest simulation time (2.10 × $10^{5}$ s). The speed and fair strategies finish in about half that time (1.09 × $10^{5}$ s) with intermediate fidelity (0.65332 and 0.64373), and the RL policy is fastest (1.06 × $10^{5}$ s) but worst on fidelity (0.62087) and communication (6.1 ks). The paper interprets this as evidence that noise-aware, parallelized scheduling can improve computational throughput in distributed quantum infrastructures, and that the trade-off between speed and fidelity is inherent in current architectures.

Load-bearing premise

The headline ranking depends on the hand-built fidelity and communication model being a faithful stand-in for real multi-QPU execution; if the true per-link fidelity loss is not 0.95, or if routing and synchronization overhead outweigh gate errors, the claim that error-aware scheduling is best could reverse.

Editorial extensions

If this is right

  • Fidelity-sensitive jobs should be scheduled with the error-aware policy, since it improves average final fidelity by about 0.035 over speed-first scheduling and 0.067 over RL scheduling in the reported workload.
  • Reinforcement learning, at least as trained here, is not yet a fidelity-preserving scheduler: it minimizes runtime but produces the lowest fidelity and the highest communication overhead, so the results caution against deploying RL for quality-critical jobs without a communication-aware reward.
  • A reusable simulation testbed for multi-QPU scheduling is now available, so future scheduler designs can be compared on runtime, fidelity, and communication overhead before hardware large enough to run such circuits exists.
  • Splitting a circuit across more devices increases communication penalty and lowers final fidelity, which means the number of QPUs used should be part of the scheduling objective, not just the choice of which devices to use.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • Beyond the paper: because the 0.95 per-link penalty and 0.02 s/qubit latency are estimated rather than measured, a natural sensitivity test is to sweep those constants and observe where the fidelity-versus-speed ordering flips; this would show which part of the claimed trade-off is robust.
  • Beyond the paper: the RL agent's reward excludes the communication penalty that the fidelity model applies at evaluation, so the RL strategy's poor fidelity may be an artifact of the reward design; adding communication cost to the reward is a direct, testable fix.
  • Beyond the paper: the simulator treats any allocated qubit block as a connected subgraph without checking embedding or route placement, so real compilation costs such as SWAP routing and limited connectivity are omitted; extending the model with a placement verification step could change the absolute fidelities and possibly the ranking.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

4 major / 5 minor

Summary. The paper presents a discrete-event simulation framework, built on SimPy, for scheduling quantum circuits that exceed the capacity of a single QPU by partitioning them across multiple QPUs connected via real-time classical communication. The framework models device calibration data, CLOPS, quantum volume, and a collection of fidelity and latency models. Using 1,000 synthetic jobs of 130–250 qubits across five simulated 127-qubit IBM-like devices, the authors compare four scheduling strategies—speed-optimized, error-aware (fidelity), fair (balanced), and reinforcement learning-based (PPO)—reporting average final fidelity, total simulation time, and communication overhead (Table 2). The paper claims to introduce the first open-source framework supporting scheduling of circuits that exceed single-QPU capacity, and concludes that parallelized, noise-aware scheduling can improve computational throughput.

Significance. If validated, the framework would provide a reusable simulation testbed for distributed quantum cloud scheduling, and the comparison of hand-designed heuristics with a learned policy would be of practical interest. The authors supply a public GitHub repository, use real IBM calibration data from March 2025, and explicitly acknowledge that their fidelity estimates are theoretical. These are strengths. However, the central comparison rests on several hand-set constants and a reward definition that is inconsistent with the evaluation metric used in Table 2; consequently, the reported strategy ranking—especially the conclusion that RL underperforms—is not currently supported. The framework itself is a useful artifact, but the empirical claims need substantial revision.

major comments (4)
  1. [§4.1 vs §6.2] The RL reward is misspecified relative to the evaluation metric. In §4.1 the reward is defined as R = (1/k') · Σ F_i, with no inter-device communication penalty, while the final fidelity used in the evaluation is F_final = F_bar_dev · φ^(N_devices−1) with φ = 0.95 (Eq. 8). Section 6.6 explicitly lists 'communication-aware reward shaping' as future work, confirming the penalty is absent during training. Under Eq. (8), fragmenting a job across more devices multiplicatively degrades fidelity, but the RL agent receives no training signal to avoid such fragmentation. The Table 2 result—rlbase has the lowest fidelity (0.62087) and the highest communication time (6,105.52 s)—is exactly what a reward that ignores fragmentation would produce. This is an internal inconsistency in the comparison: the heuristic policies implicitly account for device count through their selection rules, while the learned policy never sees this cost. The claim that RL is a viable scheduling strategy is therefore not supported without retraining on the correct objective.
  2. [§4, §6.2] The fidelity formulas are inconsistent between the problem definition and the evaluation section. In §4 the device fidelity is F_i = (1−ε_1q)^d · (1−ε_ro)^(√a_i) · (1−ε_2q)^(4√t2), whereas §6.2 defines two-qubit fidelity as F_2Q = (1−ε_2Q)^(√N_2Q) and readout fidelity as F_readout = (1−ε_readout)^(√(N_qubits/N_devices)). The two-qubit exponent differs by a factor of 4, and the readout exponent in §4 depends on the per-device qubit allocation a_i while Eq. (6) uses the average qubits per device. These definitions are not equivalent when a_i is not equal to N_qubits/N_devices, and the numerical results in Table 2 depend on which formula was actually implemented. The paper must reconcile these definitions and state exactly which formula was used to produce the reported numbers.
  3. [§5.4, §6.4, §6.5] Several constants that are load-bearing for the fidelity and latency models are attributed to references that do not appear to contain them. The per-link penalty φ = 0.95 in Eq. (8) is cited to [40] (Rigetti, 'A hybrid approach to quantum-classical computing'), which does not provide this specific value; the per-qubit latency λ = 0.02 s/qubit in Eq. (9) is cited to [41] (Yao's STOC 1979 communication-complexity paper), which is not a source for classical communication latency; and the error-score weights α = 0.5, θ = 0.3, γ = 0.2 in Eq. (2) are cited to [37] (randomized benchmarking), which does not prescribe these weights. Since these constants directly determine the ranking in Table 2, the authors must either provide a real empirical basis for each constant or explicitly label them as assumptions and show sensitivity to their values. The acknowledgment in §7.2 that fidelity is based on 'theoretical estimations' does not resolve the mismatch between the claimed citations and the actual sources.
  4. [§4.1, §7] The RL state normalization uses q_max = 50, but the evaluation jobs require between 130 and 250 qubits. This means the normalized qubit count q/q_max ranges from 2.6 to 5.0, which contradicts the stated purpose of normalization and likely degrades the policy's performance. Either q_max should be set to a value consistent with the task (e.g., the total cloud capacity, 635 qubits), or the job generation range should be adjusted to fit the normalization. As written, the RL agent is trained on inputs outside its intended range, which further confounds the comparison in Table 2.
minor comments (5)
  1. [§6] The opening sentence says 'we implemented and tested two allocation algorithms,' but the paper evaluates four allocation modes; this should say 'four.'
  2. [§6.2, Eq. (5)] The text says 'N_2Q is the number of two qubits in the circuit'; this should be 'the number of two-qubit gates in the circuit.'
  3. [§5.2] The paper assumes allocated qubits form a connected subgraph, yet §4 imposes this as a hard constraint. The manuscript should clarify that the simulator does not check or enforce connectivity, and whether the relaxation affects any of the reported metrics.
  4. [§6.6, Fig. 5] The training curve is said to plateau at an average reward around 0.70, but the deployed RL policy achieves an average final fidelity of only 0.62 in Table 2. This discrepancy is likely due to the missing communication penalty in the reward; the paper should comment on it explicitly.
  5. [§1, Ref. [13]] The claim of being 'the first open-source framework' supporting circuits that exceed a single QPU's capacity is supported only by self-reference to a GitHub repository. A dated and externally verifiable literature survey would strengthen this claim, or the statement should be softened.

Circularity Check

2 steps flagged · score 6.0 of 10

The headline fidelity and speed rankings are built into the strategy definitions: the error-aware policy optimizes the same error rates that define the fidelity metric, and the speed policy optimizes the CLOPS that define the runtime metric. A separate reward/evaluation mismatch further compromises the RL comparison.

  1. self definitional [Section 5.1 'Error-aware Mode'; Section 5.4 Eq. (2); Section 6.2 Eqs. (4)-(7); Table 2]
    "Error-aware Mode. This policy aims to maximize circuit fidelity by selecting devices with the lowest gate and readout errors based on calibration data."

    Eq. (2) defines error_score as a weighted combination of mean readout, single-qubit, and two-qubit error rates. Eqs. (4)-(7) define Fdev as a product of (1 - each of the same error rates) to positive exponents, so Fdev is monotonically decreasing in every component of error_score. A policy that selects the lowest-error-score devices is therefore, by construction, selecting devices that score highest on the paper's own fidelity metric. Table 2's conclusion that the fidelity strategy achieves the highest average fidelity (0.68781 vs 0.65332 for speed) restates the selection rule rather than providing an independent empirical test. The claimed fidelity improvement is encoded in the definitions of the policy and the metric.

  2. self definitional [Section 5.1 'Speed-based Mode'; Section 6.1 Eq. (3); Table 2]
    "Speed-based Mode. This policy prioritizes minimizing total execution time by selecting devices with the fastest processing capability, without considering noise levels."

    Execution time in Eq. (3) is tau = M*K*S*D / CLOPS, inversely proportional to CLOPS. The speed policy selects exactly the highest-CLOPS devices, and Section 7 reports it gives the shortest simulation time (1.09e5 s). This is the selection rule translated into the metric, not a discovered trade-off. Combined with the error-aware step, the central 'speed-fidelity trade-off' ranking in Table 2 is largely pre-encoded in the policy definitions and metric equations rather than emerging from an independent evaluation.

full rationale

The main circularity is in the evaluation design, not in the framework's existence. The performance rankings in Table 2 are substantially predetermined by the strategy definitions: the error-aware policy selects devices using an error_score (Eq. 2) built from the same readout, single-qubit, and two-qubit error rates that define the fidelity metric (Eqs. 4-7), and the speed policy selects devices by CLOPS, which is exactly the denominator of the runtime metric (Eq. 3). Thus the reported findings that the fidelity strategy achieves the highest fidelity and the speed strategy minimizes runtime are restatements of the selection criteria rather than independent discoveries. This is a self-definitional circularity in the comparative claim. Separately, the RL evaluation suffers from a reward/evaluation mismatch: Section 4.1 defines the reward as R = (1/k') * sum F_i with no inter-device communication penalty, while Section 6.4 computes final fidelity as F_final = Fbar_dev * phi^(N_devices-1) with phi = 0.95. The authors acknowledge this by listing 'communication-aware reward shaping' as future work in Section 6.6. This mismatch compromises the claim that rlbase's low fidelity reflects a limitation of RL scheduling; it is better viewed as an internal-validity issue than a circular derivation. No load-bearing self-citation chain was found: reference [13] is a self-citation to the project repository, but the framework's open-source existence is verifiable and not used to justify a mathematical result. The score reflects that the central comparative claims reduce by construction, while the framework itself retains independent content as a released simulation tool.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The central claim does not depend on exotic mathematics; it rests on modeling choices the authors made for the simulator. The hand-set constants and the domain assumptions below carry the entire evaluation. Nothing is machine-checked, and the code was not independently run for this review.

free parameters (5)
  • phi (per-link communication fidelity penalty) = 0.95
    Eq. (8); hand-set constant justified by citation [40] (Rigetti blog post) that does not supply this number; central to the fidelity ranking because any multi-device allocation loses 5% fidelity per extra link.
  • lambda (per-qubit classical communication latency) = 0.02 s/qubit
    Eq. (9); hand-set constant cited to a classical communication complexity paper [41], which provides no per-qubit latency value.
  • Error-score weights (alpha, theta, gamma) = 0.5, 0.3, 0.2
    Eq. (2); chosen by the authors and described as adjustable; cited to [37], a randomized benchmarking paper that defines no such weighting.
  • Fidelity exponent scalings (sqrt and 4*sqrt factors) = sqrt(a_i), 4*sqrt(t2), sqrt(N_qubits/N_devices)
    Eqs. (4)-(6) and the problem-definition variant; invented scaling described as moderating fidelity degradation, attributed to [37] which derives no such exponents; the two sections disagree on the two-qubit exponent (4*sqrt(t2) vs sqrt(N2Q)).
  • q_max state normalizer = 50 qubits
    Section 4.1: the RL state uses normalized qubit count q/q_max with q_max=50, but all test jobs require 130-250 qubits, so the normalized qubit count always exceeds 1; the constant is inconsistent with the job distribution.
assumptions (5)
  • domain assumption Gate and readout errors compound independently and multiplicatively across circuit depth, qubit count, and two-qubit gate count (Eqs. 4-7).
    Standard simplified noise assumption [38], but for circuits spanning multiple devices with mid-circuit classical communication, correlated errors and routing (SWAP) overhead are unmodeled; the paper admits fidelity is based on theoretical estimations (Section 7.2).
  • ad hoc to paper Distributed execution fidelity loss is fully captured by a per-link multiplicative penalty phi=0.95 (Eq. 8).
    No synchronization, calibration mismatch, or communication-error model beyond a single constant; this penalty is what makes fragmentation look expensive.
  • domain assumption Allocated qubits form a connected subgraph on each device with no routing or mapping overhead (Section 5.2).
    Explicitly acknowledged by the authors as a black-box abstraction; on realistic IBM heavy-hex topologies, connected subgraph selection and SWAP insertion would change both fidelity and runtime.
  • ad hoc to paper Scheduling can be treated as a single-step allocation decision (contextual bandit), with no time-correlated state (Section 4.1).
    Episodes terminate after one allocation; despite the title's adaptive claim, there is no sequential adaptation or learning from outcomes across episodes.
  • domain assumption CLOPS fully determines job execution time, with fixed M=100 and K=10 from [35], and QV=127 for all five devices (Eq. 3, Section 7).
    Processing time is a deterministic function of CLOPS and quantum volume; queueing dynamics other than partitioning are not modeled.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Adaptive Job Scheduling in Quantum Clouds Using Reinforcement Learning." pith.science (2026). https://pith.science/paper/D6QJG5K6

@misc{pith2026250610889,
  author       = {Pith},
  title        = {Pith review of: Adaptive Job Scheduling in Quantum Clouds Using Reinforcement Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/D6QJG5K6}},
  note         = {Machine review of arXiv:2506.10889}
}
read the original abstract

Present-day quantum systems face critical bottlenecks, including limited qubit counts, brief coherence intervals, and high susceptibility to errors-all of which obstruct the execution of large and complex circuits. The advancement of quantum algorithms has outpaced the capabilities of existing quantum hardware, making it difficult to scale computations effectively. Additionally, inconsistencies in hardware performance and pervasive quantum noise undermine system stability and computational accuracy. To optimize quantum workloads under these constraints, strategic approaches to task scheduling and resource coordination are essential. These methods must aim to accelerate processing, retain operational fidelity, and reduce the communication burden inherent to distributed setups. One of the persistent challenges in this domain is how to efficiently divide and execute large circuits across multiple quantum processors (QPUs), especially in error-prone environments. In response, we introduce a simulation-based tool that supports distributed scheduling and concurrent execution of quantum jobs on networked QPUs connected via real-time classical channels. The tool models circuit decomposition for workloads that surpass individual QPU limits, allowing for parallel execution through inter-processor communication. Using this simulation environment, we compare four distinct scheduling techniques-among them, a model informed by reinforcement learning. These strategies are evaluated across multiple metrics, including runtime efficiency, fidelity preservation, and communication costs. Our analysis underscores the trade-offs inherent in each approach and highlights how parallelized, noise-aware scheduling can meaningfully improve computational throughput in distributed quantum infrastructures.

Figures

Figures reproduced from arXiv: 2506.10889 by the authors.

Figure 2
Figure 2. Connecting two QPUs via real-time classical com [PITH_FULL_IMAGE:figures/full_fig_p002_2.png] view at source ↗
Figure 1
Figure 1. Overview of a quantum cloud computing system. [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 3
Figure 3. The architecture of the simulation framework con [PITH_FULL_IMAGE:figures/full_fig_p003_3.png] view at source ↗
Figures from the paper (3 more)
Figure 4
Figure 4. Figure 4: The ecosystem of the framework simulates the end-to-end orchestration of quantum jobs, beginning from job sources [PITH_FULL_IMAGE:figures/full_fig_p004_4.png]
Figure 5
Figure 5. Figure 5: PPO training progress showing average episode re [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: Fidelity distributions of quantum jobs under four allocation strategies in the simulated quantum cloud environment. [PITH_FULL_IMAGE:figures/full_fig_p009_6.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

  1. Localized Kernel Methods for Signal Processing

    eess.SP 2025-08 reject novelty 2.0 of 10

    The manuscript is internally inconsistent: the abstract describes localized kernel signal processing, while the body is a different paper on quantum task scheduling, leaving the abstract's claims entirely unsupported.

Reference graph

Works this paper leans on

42 extracted references · 37 canonical work pages · cited by 1 Pith paper

  1. [40]

    A hybrid approach to quantum-classical computing, 2018

    Rigetti Computing. A hybrid approach to quantum-classical computing, 2018. Available at https://www.rigetti.com/hybrid

    work page 2018

  2. [41]

    Andrew C. Yao. Some complexity questions related to distributive computing. In Proceedings of the 11th Annual ACM Symposium on Theory of Computing (STOC), pages 209–213, 1979

    work page 1979

  3. [37]

    Characterizing quantum gates via randomized benchmarking.Physical Review A, 85(4):042311, 2012

    Easwar Magesan, Jay M Gambetta, and Joseph Emerson. Characterizing quantum gates via randomized benchmarking.Physical Review A, 85(4):042311, 2012

    work page 2012

  4. [1]

    Quantum computing in the nisq era and beyond.Quantum, 2:79, August 2018

    John Preskill. Quantum computing in the nisq era and beyond.Quantum, 2:79, August 2018

    work page 2018

  5. [2]

    Simulating physics with computers

    Richard P Feynman. Simulating physics with computers. InFeynman and computation, pages 133–153. cRc Press, 2018

    2018

  6. [3]

    Quantum computing’s potential for drug discovery: Early stage industry dynamics.Drug Discovery Today, 26(7):1680–1688, 2021

    Maximillian Zinner, Florian Dahlhausen, Philip Boehme, Jan Ehlers, Linn Bieske, and Leonard Fehring. Quantum computing’s potential for drug discovery: Early stage industry dynamics.Drug Discovery Today, 26(7):1680–1688, 2021

    work page 2021

  7. [4]

    Quantum computing-enhanced algorithm unveils novel inhibitors for kras.arXiv preprint arXiv:2402.08210, 2024

    Mohammad Ghazi Vakili, Christoph Gorgulla, AkshatKumar Nigam, Dmitry Bezrukov, Daniel Varoli, Alex Aliper, Daniil Polykovsky, Krishna M Padman- abha Das, Jamie Snider, Anna Lyakisheva, et al. Quantum computing-enhanced algorithm unveils novel inhibitors for kras.arXiv preprint arXiv:2402.08210, 2024

    arXiv 2024

  8. [5]

    Quantum computing for supply chain finance

    Paul Griffin and Ritesh Sampat. Quantum computing for supply chain finance. In 2021 IEEE International Conference on Services Computing (SCC), pages 456–459, 2021

    work page 2021

Show all 42 references
  1. [6]

    Quantum computing for finance: State-of-the-art and future prospects.IEEE Transactions on Quantum Engineering, 1:1–24, 2020

    Daniel J Egger, Claudio Gambella, Jakub Marecek, Scott McFaddin, Martin Mevis- sen, Rudy Raymond, Andrea Simonetto, Stefan Woerner, and Elena Yndurain. Quantum computing for finance: State-of-the-art and future prospects.IEEE Transactions on Quantum Engineering, 1:1–24, 2020

    2020

  2. [7]

    DeBenedictis

    Erik P. DeBenedictis. A future with quantum machine learning.Computer, 51(2):68–71, 2018

    2018

  3. [8]

    Gambetta et al

    Jay M. Gambetta et al. Building logical qubits in a superconducting quantum computing system.Nature Physics, 13:1050–1056, 2017

    2017

  4. [9]

    Error mitigation extends the computational reach of a noisy quantum processor.Nature, 567:491–495, 2019

    Abhinav Kandala et al. Error mitigation extends the computational reach of a noisy quantum processor.Nature, 567:491–495, 2019

    2019

  5. [10]

    McKay et al

    David C. McKay et al. Qiskit backend specifications for openqasm and openpulse experiments.arXiv, 2019

    2019

  6. [11]

    Almudena Carrera Vazquez, Caroline Tornow, Diego Ristè, Stefan Woerner, Maika Takita, and Daniel J. Egger. Combining quantum processors with real-time classical communication.Nature, 2024

    2024

  7. [12]

    Gymna- sium: A standard api for reinforcement learning environments

    Rafael Rodrigues, Daniel Chan, Andy Kraft, Brandon Castaneda, et al. Gymna- sium: A standard api for reinforcement learning environments. https://github. com/Farama-Foundation/Gymnasium, 2023. Version 0.29.1

    2023

  8. [13]

    Submission to icpp 2025

    Quantum Cloud Simulation. Submission to icpp 2025. https://github.com/ QuantumCloudSimulation/ICPP2025, February 2025. Accessed: April 28, 2025

    2025

  9. [14]

    David Mermin.Quantum Computer Science: An Introduction

    N. David Mermin.Quantum Computer Science: An Introduction. Cambridge University Press, 2007

    2007

  10. [15]

    Simon J. Devitt. Performing quantum computing experiments in the cloud.Phys. Rev. A, 94:032329, Sep 2016

    2016

  11. [16]

    Quantum in the cloud: Application potentials and research opportunities

    Frank Leymann, Johanna Barzen, Michael Falkenthal, Daniel Vietz, Benjamin Weder, and Karoline Wild. Quantum in the cloud: Application potentials and research opportunities. InInternational Conference on Cloud Computing and Services Science, 2020

    2020

  12. [17]

    Smith, Pranav Gokhale, and Frederic T

    Gokul Subramanian Ravi, Kaitlin N. Smith, Pranav Gokhale, and Frederic T. Chong. Quantum computing in the cloud: Analyzing job and machine character- istics, 2022

    2022

  13. [18]

    Cutqc: Using small quantum computers for large quantum circuit evaluations.npj Quantum Information, 7:114, 2021

    Ho Lun Tang, Kunal Sharma, Yvette Norambuena, Mario Berta, and Leonard Wossnig. Cutqc: Using small quantum computers for large quantum circuit evaluations.npj Quantum Information, 7:114, 2021

    2021

  14. [19]

    Diadamo, J

    S. Diadamo, J. Notzel, B. Zanger, and M. M. Bese. Qunetsim: a software framework for quantum networks.IEEE Transactions on Quantum Engineering, 2:1–12, 2021

    2021

  15. [20]

    Netsquid, a network simulator for quantum information using discrete events.Communications Physics, 4:1–15, 2020

    Tim Coopmans, Robert Knegjens, Axel Dahlberg, David Maier, Loek Nijsten, Julio de Oliveira Filho, Martijn Papendrecht, Julian Rabbie, Filip Rozpe ¸dek, Matthew Skrzypczyk, Leon Wubben, Walter de Jong, Damian Podareanu, Ariana Torres- Knoop, David Elkouss, and Stephanie Wehner....

    2020

  16. [21]

    QuEST and high performance simulation of quantum computers.Sci Rep, 9(1):10736, 2019

    Tyson Jones, Anna Brown, Ian Bush, and Simon C Benjamin. QuEST and high performance simulation of quantum computers.Sci Rep, 9(1):10736, 2019

    2019

  17. [22]

    H. Bian, J. Huang, J. Tang, R. Dong, L. Wu, and X. Wang. PAS: A new powerful and simple quantum computing simulator.Software: Practice and Experience, 53(1):142–159, 2023

    2023

  18. [23]

    John Brennan, Lee J O’Riordan, K. G. Hanley, Myles Doyle, Momme Allalen, David Brayford, Luigi Iapichino, and Niall Moran. QXTools: A Julia framework for distributed quantum circuit simulation.J. Open Source Softw., 7:3711, 2022

    2022

  19. [24]

    ProjectQ: An Open Source Software Framework for Quantum Computing.Quantum, 2, 12 2016

    Damian Steiger, Thomas Häner, and Matthias Troyer. ProjectQ: An Open Source Software Framework for Quantum Computing.Quantum, 2, 12 2016

    2016

  20. [25]

    Nguyen, Muhammad Usman, and Rajkumar Buyya

    Hoa T. Nguyen, Muhammad Usman, and Rajkumar Buyya. iQuantum: A Case for Modeling and Simulation of Quantum Computing Environments. In2023 IEEE International Conference on Quantum Software (QSW), pages 21–30, 2023

    2023

  21. [26]

    QSimPy: A Learning- centric Simulation Framework for Quantum Cloud Resource Management.arXiv preprint arXiv:2405.01021, 2024

    Hoa T Nguyen, Muhammad Usman, and Rajkumar Buyya. QSimPy: A Learning- centric Simulation Framework for Quantum Cloud Resource Management.arXiv preprint arXiv:2405.01021, 2024

    2024 arXiv

  22. [27]

    Qucloud: A new qubit mapping mechanism for multi- programming quantum computing in cloud environment

    Lei Liu and Xinglei Dou. Qucloud: A new qubit mapping mechanism for multi- programming quantum computing in cloud environment. In2021 IEEE Inter- national symposium on high-performance computer architecture (HPCA), pages 167–178. IEEE, 2021

    2021

  23. [28]

    Qumc: Hardware- aware multi-programming compiler for quantum computing.Computers, Materi- als & Continua, 79(2):1961–1974, 2024

    Xiangyu Niu, Jianwei Li, Qing Wang, Jialin Yang, and Lei Liu. Qumc: Hardware- aware multi-programming compiler for quantum computing.Computers, Materi- als & Continua, 79(2):1961–1974, 2024

    1961

  24. [29]

    Adaptive job scheduling framework for quantum cloud environments.Journal of Quantum Computing, 78:123–138, 2023

    Subramaniam Ravi, Amandeep Singh, and Ravi Patel. Adaptive job scheduling framework for quantum cloud environments.Journal of Quantum Computing, 78:123–138, 2023

    2023

  25. [30]

    Qure: Quantum resource estimator for cloud environments.Computers, Materials & Continua, 79(2):1957–1974, 2024

    Martin Suchara, Andrew Anderson, Harry Buhrman, and Andrew Schreier. Qure: Quantum resource estimator for cloud environments.Computers, Materials & Continua, 79(2):1957–1974, 2024

    1957

  26. [31]

    Johansson, P.D

    J.R. Johansson, P.D. Nation, and Franco Nori. QuTiP 2: A Python framework for the dynamics of open quantum systems.Computer Physics Communications, 184(4):1234–1240, 2013

    2013

  27. [32]

    Fan and Z

    Y. Fan and Z. Lan. DRAS-CQSim: A reinforcement learning based framework for HPC cluster scheduling.Software Impacts, 8:100077, may 2021

    2021

  28. [33]

    S. N. Agos Jawaddi and A. Ismail. Integrating OpenAI Gym and CloudSim Plus: A simulation environment for DRL agent training in energy-driven cloud scaling. Simulation Modelling Practice and Theory, 130:102858, jan 2024

    2024

  29. [34]

    Discrete event simulation for python, 2024

    SimPy. Discrete event simulation for python, 2024. https://simpy.readthedocs.io/ en/latest/index.html

    2024

  30. [35]

    Quality, speed, and scale: three key attributes to measure the performance of near-term quantum computers

    Andrew Wack, Hanhee Paik, Ali Javadi-Abhari, Petar Jurcevic, Ismael Faro, Jay Gambetta, and Blake Johnson. Quality, speed, and scale: three key attributes to measure the performance of near-term quantum computers. 10 2021

    2021

  31. [36]

    https://docs.quantum.ibm

    IBM about calibration jobs — docs.quantum.ibm.com. https://docs.quantum.ibm. com/admin/calibration-jobs. [Accessed 09-10-2024]

    2024

  32. [38]

    Nielsen and Isaac L

    Michael A. Nielsen and Isaac L. Chuang.Quantum Computation and Quantum Information. Cambridge University Press, 10th anniversary edition edition, 2010

    2010

  33. [39]

    Readout error mitigation in cuda quantum, 2025

    NVIDIA. Readout error mitigation in cuda quantum, 2025. Accessed: 2025-03-06

    2025

  34. [42]

    https://quantum.ibm.com/services/resources

    IBM Quantum Processing Units. https://quantum.ibm.com/services/resources. Accessed: 2025-01-26

    2025

Pith tools

Reviewed August 7, 2026 · model on record in the stance chip above.