Qurator: Scheduling Hybrid Quantum-Classical Workflows Across Heterogeneous Cloud Providers

Qurator is an architecture-agnostic scheduler that jointly optimizes queue time and execution fidelity for hybrid quantum-classical workflows across heterogeneous cloud providers by modeling complex quantum constraints and unifying calibration data, achieving significant latency reductions with minimal fidelity loss.

The Gist

Imagine you are trying to bake a very delicate, high-tech cake (a quantum calculation) using ovens from different bakeries (quantum computers) scattered around the world.

Here is the problem:

1. The Ovens are Crowded: You can't just walk in and bake. You have to get in line. Sometimes, the line is so long that by the time your turn comes, the ingredients have gone bad.
2. The Cake is Fragile: Quantum "cakes" (circuits) are incredibly sensitive. If you wait too long in line, or if the oven isn't perfect, the cake collapses into a mess before you even get it out.
3. The Bakeries are Different: One bakery uses gas ovens, another uses electric, and a third uses magic. They all speak different languages and have different rules.
4. You Can't Make Copies: In normal cooking, if you're worried about a cake failing, you might make two at once. In quantum physics, you cannot copy a cake. If you try to duplicate the batter, the magic disappears.

Enter Qurator: The Super-Intelligent Cake Manager

The paper introduces Qurator, a smart system designed to manage this chaotic baking process. Instead of just picking the fastest line or the best oven, Qurator acts like a master chef who knows exactly how to balance speed and quality.

Here is how it works, using simple analogies:

1. The "Wait vs. Quality" Balancing Act

Imagine you are at a theme park.

• Strategy A (The "Best Ride" Fan): You only want to ride the most thrilling rollercoaster. But the line is 5 hours long. By the time you get on, you're too tired to enjoy it.
• Strategy B (The "Short Line" Fan): You jump on the first ride with a 5-minute wait. But it's a slow, boring carousel.
• Qurator's Strategy: It looks at the whole picture. If the line is short, it picks the best ride. If the line is huge, it says, "Okay, let's take a slightly less thrilling ride that's faster, but still fun enough." It constantly adjusts its choice based on how busy the park is.

2. The "Cut and Paste" Trick (Circuit Cutting)

Sometimes, a cake is too big for any single oven.

• The Problem: You have a giant 20-layer cake, but the biggest oven only fits 10 layers.
• The Old Way: You give up.
• Qurator's Way: It slices the giant cake into two smaller 10-layer cakes. It bakes them separately in different ovens, then uses a special "glue" (classical computer processing) to stick them back together perfectly at the end.
• The Catch: Gluing them takes time and effort. Qurator only does this if the alternative (waiting 10 hours for a giant oven) is worse than the effort of gluing.

3. The "Double-Date" Problem (Entanglement)

Sometimes, you need two cakes to be baked at the exact same moment so they can be magically linked together (this is called entanglement).

• The Problem: If Cake A finishes at 2:00 PM and Cake B finishes at 2:05 PM, the magic link breaks. The link is like a fresh flower; it wilts in seconds.
• Qurator's Solution: It acts like a strict traffic controller. It looks at the lines at both bakeries and says, "Okay, we need to delay Cake A by 10 minutes so both cakes are ready at 2:05 PM exactly." It sacrifices a little bit of speed to ensure they arrive together, or it merges them into a single batch if possible.

4. Speaking All Languages (Unified Fidelity)

Every bakery (IBM, IonQ, Rigetti, etc.) reports their oven quality differently. One says "99% perfect," another says "Low error rate," and another says "High success probability." It's like one bakery uses Celsius and another uses Fahrenheit.

• Qurator's Solution: It has a universal translator. It converts all these different reports into a single, standard score (a "Success Score"). This allows it to compare an IBM oven directly with an IonQ oven and pick the best one for the job, regardless of how they describe themselves.

The Results: Why Does This Matter?

The researchers tested Qurator using real data from the last four months of actual quantum computer usage.

• When the park is empty: Qurator picks the absolute best oven, matching the "perfect quality" strategy almost exactly.
• When the park is packed: Qurator saves you 30% to 75% of your waiting time. It does this by accepting a tiny, controlled drop in quality (which you can fix by baking the cake twice if needed), rather than waiting hours for a perfect oven that might never open.

In Summary:
Qurator is the first system that understands that in the quantum world, waiting is the enemy, but rushing is fatal. It doesn't just pick a line; it slices big problems, synchronizes delicate connections, and translates different languages to find the sweet spot between "getting it done fast" and "getting it done right."

Technical Summary

1. Problem Statement

The integration of Quantum Processing Units (QPUs) into High-Performance Computing (HPC) workflows faces a critical bottleneck: queue latency. While quantum circuits often execute in seconds, they can wait minutes to days in "first-come, first-served" queues at cloud providers (e.g., IBM, IonQ, Rigetti).

• The Trade-off: Minimizing queue time often requires selecting less loaded devices, which may have lower fidelity (accuracy). Conversely, selecting the highest-fidelity device often results in excessive wait times.
• Classical Limitations: Traditional scheduling techniques fail in the quantum domain due to unique constraints:
  • No-Cloning Theorem: Prevents task duplication or work stealing.
  • Non-preemptibility: Jobs cannot be paused or migrated once started.
  • Entanglement Dependencies: Distributed tasks sharing entangled pairs (EPR pairs) must execute nearly simultaneously before decoherence occurs.
  • Heterogeneity: Providers expose incompatible calibration metrics, gate sets, and topologies.
  • Dynamic DAGs: Hybrid workflows (e.g., VQE, QAOA) generate quantum circuits dynamically based on classical feedback, making static scheduling impossible.

2. Methodology: The Qurator Architecture

Qurator is an architecture-agnostic scheduler designed to jointly optimize queue time and circuit fidelity across heterogeneous providers. It models hybrid workloads as Dynamic Directed Acyclic Graphs (DAGs) with explicit quantum semantics.

A. Unified Fidelity Estimation

To compare devices with incompatible data, Qurator normalizes calibration metrics (gate errors, readout errors, coherence times) from six providers (IBM, IonQ, IQM, Rigetti, AQT, QuEra) into a canonical logarithmic success score.

• Model: It calculates an operational success score ($P_{ops}$) based on gate and readout errors, and a decoherence penalty ($P_{decoh}$) based on circuit duration vs. coherence time ($T_2$).
• Result: A unified estimated fidelity ($\hat{F}_{est}$) that allows the scheduler to rank devices regardless of the underlying hardware architecture.

B. Quantum-Aware Scheduling Semantics

Qurator introduces specific mechanisms to handle quantum constraints:

• Circuit Cutting: If a circuit is too large for a single device or requires high fidelity, Qurator partitions it into smaller subcircuits. This trades classical post-processing overhead for reduced queue time and higher fidelity on smaller devices.
• Task Merging: Multiple independent quantum tasks are merged into a single submission to a single QPU to reduce synchronization overhead and queue contention.
• Entanglement Barrier: For distributed tasks, Qurator formalizes a synchronization barrier. It calculates the "frontier" of unfinished ancestors to estimate when entangled tasks will be ready, then assigns devices such that their estimated start times align as closely as possible to minimize the spread (skew) before decoherence destroys the EPR pairs.

C. Load-Adaptive Optimization

Qurator uses a scheduling coefficient ($c_d$) to balance fidelity and queue time dynamically based on system load:

• Low Load: The coefficient prioritizes fidelity (selecting the best device).
• High Load: The coefficient shifts weight toward queue time (selecting the least busy device), but only among those meeting a user-specified fidelity target.
• Prediction: It uses a Gaussian kernel over historical queue data to estimate wait times without needing access to internal queue states.

3. Key Contributions

1. Unified Fidelity Model: A method to reconcile disparate calibration data from major quantum providers into a single, comparable metric, validated against hardware outcomes.
2. Quantum-Specific Semantics: Formalization of constraints like entanglement synchronization barriers and the no-cloning theorem as first-class scheduling decisions (cutting and merging).
3. Joint Optimization: A scheduler that dynamically rebalances the fidelity-queue trade-off, achieving near-optimal fidelity at low loads and significant queue reduction at high loads without violating user-defined fidelity targets.
4. First Distributed Entanglement Benchmark: Since public clouds do not yet support distributed quantum computing, the authors created a simulator and a new set of metrics (start/finish skew, survival proxy) to evaluate scheduling for entangled tasks.

4. Evaluation Results

The system was evaluated using a simulator driven by four months of real queue data from 11 devices, processing up to 35,000 tasks from the Munich Quantum Toolkit (MQT) benchmark suite.

• Low Load (5–500 tasks): Qurator tracks the "highest-fidelity" baseline within 1% fidelity, accepting only minor queue time increases.
• High Load (5,000–35,000 tasks):
  • Achieves a 30–75% reduction in queue time compared to the highest-fidelity baseline.
  • Maintains a fidelity cost bounded by the user-specified target (e.g., 0.90).
  • Outperforms the "least busy" baseline by accepting slightly longer queues to gain 18–40% higher fidelity.
• High Qubit Circuits: By using circuit cutting, Qurator achieves up to 60% fidelity gain over the "least busy" strategy (which often fails completely on large circuits) at the cost of increased queue time due to task splitting.
• Distributed Entanglement: Under realistic queue conditions (thousands of tasks), the "survival proxy" for distributed entangled tasks drops to near zero ($10^{-15}$ to $10^{-239}$), proving that distributed quantum computing is currently infeasible on public clouds. However, circuit merging (executing entangled tasks on a single device) significantly improves survival rates.

5. Significance

• Bridging the Gap: Qurator provides the first practical framework for integrating quantum resources into heterogeneous HPC workflows, addressing the specific limitations of the NISQ (Noisy Intermediate-Scale Quantum) era.
• Scalability: It demonstrates that joint optimization is superior to treating fidelity and latency as separate concerns, enabling efficient use of current quantum hardware despite high queue variability.
• Future Roadmap: The paper establishes concrete baselines for the viability of distributed quantum computing. It highlights that while current network decoherence and queue latencies make distributed execution impossible, the formal models and metrics provided will be essential for tracking progress as quantum networks and hardware mature.
• Practical Impact: By treating circuit cutting and merging as scheduler decisions rather than programmer burdens, Qurator lowers the barrier to entry for running complex hybrid workflows on the cloud.