⚛️ quantum physics

BAHAMAS: A Control Plane for Optimization and Execution of Variational Quantum Circuits

The paper introduces BAHAMAS, an online control framework that stabilizes variational quantum algorithm optimization by adaptively selecting physical qubit mappings through consensus-based fidelity estimation, thereby mitigating the effects of temporal noise drift and static mapping distortions without requiring simulators or offline training.

Original authors: Amit Samanta, Mohammad Abrarul Hasanat, Jason Ludmir, Ryan Stutsman, Tirthak Patel, Rohan Basu Roy

Published 2026-09-01

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Amit Samanta, Mohammad Abrarul Hasanat, Jason Ludmir, Ryan Stutsman, Tirthak Patel, Rohan Basu Roy

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

Quantum computers promise to solve problems that are impossible for today's machines, from designing new medicines to optimizing complex logistics. To do this, they rely on a special class of programs called variational quantum algorithms. These programs work like a partnership between a quantum processor and a classical computer. The quantum machine runs a specific circuit, measures the result, and sends a number back to the classical computer. The classical computer then tweaks the settings of the quantum circuit and asks it to run again. This cycle repeats thousands of times, with the classical computer trying to nudge the quantum machine toward a better answer with every turn. The hope is that this back-and-forth will eventually find the perfect solution.

However, this partnership faces a stubborn obstacle: the quantum hardware is inherently unstable. The tiny particles that carry information, known as qubits, are sensitive to their environment. Their behavior drifts over time, and the way they interact with each other changes from one moment to the next. In a perfect world, the classical computer could assume that the number it receives today is directly comparable to the number it received yesterday. In reality, the noise from the hardware distorts these numbers. If the noise changes the ranking of the answers—making a worse solution look better than a good one—the classical computer gets confused. It follows a misleading path, and the entire process fails to find the true solution.

Researchers at the University of Utah and Rice University have developed a new system called BAHAMAS to fix this instability. Instead of accepting the hardware's fluctuations as an unavoidable fact, BAHAMAS acts as a vigilant control plane that monitors the noise in real time. It does not rely on complex simulations or pre-trained models that might become outdated. Instead, it uses the quantum processor itself to check its own reliability. Before the system commits to a new step in the optimization process, it runs several different versions of the same circuit simultaneously on the chip. By comparing the outputs of these parallel runs, the system can determine which version of the circuit is behaving most consistently. If the results agree, the system trusts the data and moves forward. If they disagree, it knows the noise is too high and pauses, preventing the classical computer from making a mistake based on bad data.

The core insight behind this approach is that stability matters more than perfection. The researchers found that simply picking the single best-looking circuit layout at any given moment is not enough, because the "best" layout changes as the hardware drifts. What actually preserves the quality of the optimization is keeping the noise exposure consistent from one step to the next. BAHAMAS achieves this by constantly adjusting which physical parts of the chip it uses. It selects a specific arrangement of qubits that maintains a steady level of noise, ensuring that the comparison between one step and the next remains fair. This allows the classical optimizer to see a clear signal rather than a distorted one.

To test this system, the team ran experiments on real quantum processors from IBM, spanning different generations and physical designs. They compared BAHAMAS against the standard way of running these algorithms, where the hardware layout is chosen once at the beginning and never changed. The results showed that BAHAMAS improved the performance of the algorithms by more than twenty percent on average. More importantly, it made the results far more reliable. When the researchers ran the same experiment multiple times over a month, the standard method produced wildly different outcomes depending on when the test was run. BAHAMAS, however, produced consistent results every time, regardless of the day or the state of the machine.

The system also proved effective when the hardware changed. The researchers tested a scenario where an algorithm was trained on one quantum processor and then deployed on a different one with a completely different layout. Usually, this would require starting the entire training process over. BAHAMAS, however, could adapt the trained solution to the new machine without retraining. It did this by matching the noise characteristics of the new hardware to the conditions under which the solution was originally found. This capability suggests that the system can handle not just daily fluctuations, but also the transition between different types of quantum computers as the technology evolves.

Even as quantum hardware improves and error rates drop, the researchers believe this control method will remain necessary. While future machines may have fewer errors, they will still experience drift and variation. The study showed that BAHAMAS continues to provide significant benefits even when simulating a future where the hardware is nearly perfect. The system's ability to stabilize the optimization process appears to be a fundamental requirement for these algorithms to work reliably, rather than just a temporary fix for current limitations. By turning the chaotic nature of quantum noise into a manageable variable, BAHAMAS offers a path toward making quantum computing a practical tool for solving real-world problems.

Technical Summary: BAHAMAS – A Control Plane for Optimization and Execution of Variational Quantum Circuits

Problem Statement
Variational Quantum Algorithms (VQAs) rely on a hybrid loop where a classical optimizer updates parameters based on cost evaluations from a quantum processor. This process assumes that cost evaluations across iterations are comparable. However, current quantum hardware violates this assumption due to two primary factors:

Static Mappings: Transpilers typically assign logical qubits to physical qubits once at the start of optimization. Different physical subsets expose the circuit to different noise profiles.
Temporal Noise Drift: Even for a fixed physical mapping, hardware noise fluctuates over time due to calibration drift and thermal variations.

These factors cause the relative ranking of parameter configurations to shift unpredictably. Since gradient-based optimizers rely on comparing the relative costs of parameter configurations (e.g., via the parameter-shift rule), noise-induced ranking inversions provide misleading update signals. This leads to unstable convergence, where the optimizer fails to reach the true minimum, and loss plateaus at sub-optimal values with erratic gradients. Existing solutions, such as post-execution error mitigation or noise-aware compilation, generally treat qubit mapping as a one-time decision or lack per-iteration control over both mapping and parameter update quality.

Methodology: The BAHAMAS Control Plane
The authors present BAHAMAS, an online control framework that operates across the transpilation, execution, and parameter update layers of the VQA stack. Its core insight is that preserving optimization quality requires consistent noise exposure across consecutive iterations, rather than simply minimizing noise at a single isolated iteration.

BAHAMAS achieves this through three integrated components:

Noise Estimation and Stabilization:
- Candidate Pruning: A classical TVD (Total Variation Distance) estimator uses backend calibration data and per-resource residuals to rank hundreds of candidate physical maps, shortlisting a small probe set ( $K$ ).
- Co-Located Execution: Instead of running candidates sequentially (which would expose them to different noise snapshots), BAHAMAS packs all $K$ candidate maps onto the quantum processor in a single job. They execute simultaneously on non-overlapping qubit subsets, ensuring they experience identical temporal noise conditions.
- Consensus-Based Reference: Without relying on an ideal simulator (which is infeasible for larger circuits), BAHAMAS constructs a reference distribution from the co-located outputs. The map with the least distortion (closest to the group consensus) serves as the reference. This allows the system to estimate the TVD of each map relative to the consensus, preserving the relative ranking of maps by noise severity.
- Stable Selection: The system selects the map whose estimated TVD is closest to a target TVD ( $\tau_t$ ), which is updated as an exponential moving average. This prioritizes stability over chasing the absolute lowest TVD at any single step.
Trust-Aware Parameter Update Control:
- Before committing a gradient update, BAHAMAS evaluates a "trust state" based on the stability error (deviation from the target TVD) and the consensus confidence (agreement among co-located outputs).
- If consensus is low or stability error is high, the system gates (suppresses) the gradient update or scales its weight ( $\rho_t$ ). This prevents corrupted gradients from destabilizing the optimization trajectory.
Inference-Time Retargeting:
- During the optimization phase, BAHAMAS records an "execution signature" (mean target TVD and coupling structure of selected maps).
- At inference time, if the hardware drifts or the backend changes (different topology), the system uses this signature to retarget the map selection without re-optimizing the parameters. It matches candidate maps to the recorded noise level and interaction structure.

Key Contributions

Identification of Noise Stability: The paper identifies that consistent noise exposure across iterations is the critical property for preserving optimization quality, distinct from minimizing instantaneous noise.
BAHAMAS Control Plane: A novel system design that manages qubit assignment and gradient trust per-iteration using online feedback, requiring no offline training, simulators, or learned models.
Practical Quality Signals: Demonstrates that co-locating candidate maps on the chip and comparing their outputs provides a robust, simulator-free quality signal for per-iteration selection within realistic quantum budgets.
Inference Retargeting: Extends control to the inference phase, enabling robust deployment on drifted or topologically different backends without retraining.
Empirical Validation: Evaluation on real IBM quantum processors (Heron and Nighthawk generations) across multiple VQA families (VQE, QAOA, QNN).

Results
Evaluated across eight benchmarks on real hardware over a 30-day period:

Performance Improvement: BAHAMAS improves VQA performance by an average of 22.39% over the uncontrolled baseline (standard transpiler mapping).
Stability: It significantly reduces the variance of performance metrics. The standard deviation of the performance metric drops from ~13–16% (baseline) to 3.7–6.1% (BAHAMAS), indicating robustness against temporal noise drift.
Convergence: Compared to prior noise-adaptive techniques like QISMET, BAHAMAS converges in far fewer iterations (180 vs. 1250) while achieving higher performance gains (34.6% vs. 21%).
Ranking Preservation: BAHAMAS maintains a Kendall $\tau$ rank correlation of 0.83 against the noiseless ranking, compared to 0.43 for the baseline, effectively preventing the inversion of configuration rankings that misleads the optimizer.
Scalability and Future Regimes: The system remains effective as qubit counts scale to 16 and retains a 14% improvement even when simulating fault-tolerant noise levels (0.1× noise), demonstrating relevance beyond the NISQ era.
Composability: BAHAMAS composes with complementary techniques like NEST (job scheduling) and DISQ (iteration skipping), further boosting performance and throughput.

Significance
The paper claims that BAHAMAS addresses a fundamental gap in current VQA workflows: the lack of coordination between transpilation, runtime execution, and parameter updates to ensure stable noise conditions. By stabilizing the noise exposure across iterations, BAHAMAS allows classical optimizers to receive reliable gradient signals, enabling convergence to better solutions on noisy hardware. The framework is designed to be robust to backend drift and deployable without external data pipelines, making it a practical system software layer for controlling variational quantum workloads on superconducting processors, from current NISQ devices to early fault-tolerant systems.

More like this