⚛️ quantum physics

DynQ: A Dynamic Topology-Agnostic Quantum Virtual Machine via Quality-Weighted Community Detection

DynQ is a dynamic, topology-agnostic Quantum Virtual Machine that leverages quality-weighted community detection on live calibration data to generate resilient, high-quality execution regions, thereby significantly improving output fidelity and reliability across heterogeneous quantum hardware.

Original authors: Shusen Liu, Pascal Jahan Elahi, Ugo Varetto

Published 2026-04-02

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Shusen Liu, Pascal Jahan Elahi, Ugo Varetto

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a massive, incredibly expensive supercomputer. But here's the catch: right now, it's designed so that only one person can use the whole machine at a time. Even if that person only needs to do a tiny calculation on 5 tiny parts of the computer, the other 95% of the machine sits there, completely idle, doing nothing. It's like renting out an entire 50-story skyscraper just so one person can use a single office on the 3rd floor.

This is the current state of Quantum Cloud Computing. It's inefficient, expensive, and leaves most of the hardware wasted.

Enter DynQ, a new system designed to fix this. Think of DynQ as a smart, dynamic property manager for a quantum computer.

The Problem: The "Broken" Building

Quantum computers are fragile. They are like a giant building where some rooms are pristine, some have flickering lights, and some doors are jammed.

Calibration Drift: Just like a building's heating system might drift out of tune, the quantum computer's settings change constantly. A door that was working this morning might be broken by lunch.
Crosstalk: If you try to do work in two rooms right next to each other, the noise from one room might ruin the work in the other.
Static Maps: Current systems try to divide the building into fixed zones (e.g., "Floors 1-10 are for Tenant A"). But if a floor gets broken, the whole zone becomes useless, and the tenant gets kicked out.

The Solution: DynQ's "Smart Neighborhoods"

DynQ solves this by not using fixed maps. Instead, it uses a live, quality-weighted map to find the best "neighborhoods" for each job.

Here is how it works, using a few analogies:

1. The "Quality-Weighted Map"

Imagine the quantum computer is a city. Every street (connection between qubits) has a quality score.

High-quality streets: Smooth, fast, no potholes (high-fidelity gates).
Low-quality streets: Bumpy, dangerous, prone to accidents (noisy, error-prone gates).

DynQ looks at this city map in real-time. It doesn't just look at the roads; it looks at the traffic conditions right now.

2. Community Detection: Finding the Best Neighborhoods

DynQ uses a mathematical trick called Community Detection. Imagine you are trying to form walking groups for a hike.

You want groups where everyone is close to each other and the path between them is smooth (High Cohesion).
You want the groups to be separated from other groups by a wide river or a mountain range, so they don't accidentally bump into each other (Low Coupling).

DynQ does this automatically. It scans the "city" and says, "Hey, these 10 qubits are all connected by smooth, high-quality roads, and they are separated from the rest of the city by some very bumpy, dangerous roads. Let's make this a 'Virtual Machine' (a neighborhood) for Tenant A."

Then it finds another group of 8 qubits with their own smooth roads for Tenant B.

3. The "Dynamic" Part: Adapting to Change

This is the magic. If a "road" breaks (a qubit fails or gets noisy) while the system is running:

Old System: The whole neighborhood might be declared unsafe, and the tenant gets kicked out.
DynQ: It instantly re-draws the map. It sees the broken road, treats it as a "mountain range," and shifts the neighborhood boundaries to avoid it. It finds a new, safe neighborhood for the tenant without them even noticing.

Why This Matters (The Benefits)

No More Wasted Space: Instead of one person renting the whole skyscraper, DynQ can fit 10 different people into different, high-quality "floors" or "wings" of the building simultaneously.
Safety First: By placing the "walls" between tenants along the "bumpy roads" (noisy connections), DynQ ensures that Tenant A's work doesn't accidentally mess up Tenant B's work. It creates natural buffer zones.
Resilience: If a part of the computer breaks, DynQ just routes around it. It's like a GPS that instantly reroutes you when it sees a traffic jam, rather than telling you to stop driving.

The Results

The authors tested DynQ on real quantum computers (IBM and Rigetti).

Better Quality: Programs ran with fewer errors because they were placed on the "smoothest roads."
Fewer Failures: When the hardware had temporary glitches, DynQ saved programs that would have otherwise failed completely.
Cheaper: Because they can run many programs at once, the cost per calculation drops significantly.

In a Nutshell

DynQ is like a smart, self-healing real estate agent for quantum computers. Instead of forcing tenants into rigid, pre-defined apartments, it constantly scans the building, finds the best, quietest, and most reliable clusters of rooms for each tenant, and moves them instantly if the building starts to shake. This turns a fragile, single-user machine into a robust, multi-user cloud service.

1. Problem Statement

Current quantum cloud platforms (e.g., IBM Quantum, AWS Braket) lack a robust virtualization layer comparable to classical cloud computing.

Inefficiency: Small quantum programs monopolize entire processors, leaving vast amounts of hardware idle (e.g., running 5-qubit algorithms on 156-qubit chips).
Brittleness: Existing Quantum Virtual Machine (QVM) designs rely on static, topology-specific partitions (e.g., fixed geometric templates). These fail to adapt to:
- Calibration Drift: Qubit and coupler fidelities change over time.
- Transient Defects: Temporary hardware failures that render specific qubits or links unusable.
- Spatial Heterogeneity: Gate fidelities and crosstalk vary significantly across the chip.
Multi-tenancy Challenges: Without dynamic isolation, concurrent execution leads to crosstalk (interference between programs) and unpredictable output quality.

2. Methodology: DynQ Architecture

DynQ introduces a dynamic, topology-agnostic QVM that derives virtual execution regions directly from live calibration data. It decouples offline region discovery from online allocation.

A. Core Concept: Quality-Weighted Community Detection

Instead of imposing geometric shapes, DynQ models the quantum processor as a weighted graph $G=(V, E, w)$ :

Vertices ( $V$ ): Physical qubits.
Edges ( $E$ ): Native couplers.
Weights ( $w$ ): Encoded as the inverse of gate error rates ( $w_{ij} = 1/(\epsilon_{ij} + \epsilon_0)$ ). High-fidelity links have high weights; degraded or broken links have low or zero weights.

DynQ applies the Louvain algorithm (a modularity-maximizing community detection method) to this graph. The algorithm naturally partitions the graph into communities that maximize internal cohesion (high-fidelity links within a region) and minimize external coupling (low-fidelity/noisy links between regions).

Result: Region boundaries are automatically placed along the "weakest" links (high crosstalk or low fidelity), creating implicit buffer zones that suppress inter-tenant interference without reserving idle qubits.

B. System Layers

Offline Discovery Layer:
- Constructs the weighted graph from calibration snapshots.
- Runs community detection to generate candidate regions.
- Region Scoring: Evaluates candidates based on connectivity, gate quality, readout quality, and internal uniformity.
- Selection: Uses a greedy algorithm to select a non-overlapping set of regions that maximizes aggregate quality while covering the hardware.
Online Allocation Layer:
- Maps incoming tenant circuits to pre-validated regions based on size and quality.
- Maintains isolation by ensuring disjoint physical regions for concurrent jobs.
Hardware-Aware Compilation:
- Compiles each circuit only within its assigned region (subgraph-restricted compilation).
- This prevents the compiler from routing through noisy areas of the chip and ensures strict spatial isolation.

3. Key Contributions

Dynamic Topology-Agnostic QVM: A system that does not require manual engineering for specific topologies (e.g., IBM Heavy-Hex vs. Rigetti Square-Lattice). It adapts to any coupling graph structure.
Quality-Weighted Partitioning Formulation: Formalizes QVM discovery as a community detection problem on a calibration-weighted graph, directly translating hardware physics (fidelity/crosstalk) into virtual boundaries.
Robustness to Transient Defects: By regenerating regions from current calibration data, DynQ automatically routes around degraded couplers or unavailable qubits, recovering workloads that would fail under static mappings.
Decoupled Architecture: Separates computationally intensive region discovery (offline) from low-latency scheduling (online), enabling scalable multi-tenant services.

4. Experimental Results

The authors evaluated DynQ on five simulated IBM backends, two real IBM devices (Kingston, Torino), and the Rigetti Ankaa-3 (via AWS Braket).

Execution Quality Improvement:
- On the most heterogeneous simulated backend (Kingston), DynQ reduced $L_1$ error by up to 45.1% and improved output-similarity scores by up to 19.1% compared to the default compiler.
- It significantly raised the "performance floor," recovering executions that previously collapsed to near-zero fidelity.
Robustness:
- DynQ eliminated observed baseline failures in real-device experiments where transient defects caused the default mapping to fail.
- It demonstrated dead-link immunity, automatically avoiding broken couplers.
Multi-tenancy & Scalability:
- Batching: DynQ enabled concurrent execution of up to 18 programs. Output similarity remained stable as batch size increased, proving effective crosstalk suppression.
- Cost Efficiency: Batching reduced the number of required job submissions by up to 90% (e.g., 29 circuits reduced to 3 jobs) while maintaining high output quality, drastically lowering cloud costs.
Cross-Architecture Portability:
- Successfully adapted to both IBM's sparse Heavy-Hex topology and Rigetti's dense Square-Lattice topology without code changes, validating the topology-agnostic claim.

5. Significance and Impact

Paradigm Shift: DynQ shifts quantum virtualization from a static, template-based problem to a graph-driven, systems-level optimization problem.
Economic Viability: By enabling reliable multi-tenancy and batching, DynQ addresses the economic bottleneck of quantum cloud computing, allowing providers to amortize hardware costs across concurrent users.
Practical Substrate: It provides a practical foundation for reliable, differentiated Quality of Service (QoS) in quantum clouds, allowing high-fidelity regions for premium users and lower-quality regions for noise-tolerant workloads.
Future-Proofing: The approach is scalable to thousands of qubits and adaptable to diverse future architectures (e.g., trapped ions, neutral atoms) as long as connectivity and calibration data are exposed.

In summary, DynQ demonstrates that adaptive, quality-aware virtualization is essential for the next generation of quantum cloud services, transforming fragile, static hardware access into a resilient, shared resource.