⚛️ quantum physics

Millisecond-Scale Calibration and Benchmarking of Superconducting Qubits

This paper presents a low-latency, on-FPGA workflow that integrates pulse generation, acquisition, and optimization to enable millisecond-scale calibration and benchmarking of superconducting qubits, demonstrating that continuous closed-loop recalibration significantly suppresses parameter drift and maintains superior gate performance over extended periods.

Original authors: Malthe A. Marciniak, Rune T. Birke, Johann B. Severin, Fabrizio Berritta, Daniel Kjær, Filip Nilsson, Smitha N. Themadath, Sangeeth Kallatt, James L. Webb, Kristoffer Bentsen, Tonny Madsen, Zhenhai Su

Published 2026-02-13

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Malthe A. Marciniak, Rune T. Birke, Johann B. Severin, Fabrizio Berritta, Daniel Kjær, Filip Nilsson, Smitha N. Themadath, Sangeeth Kallatt, James L. Webb, Kristoffer Bentsen, Tonny Madsen, Zhenhai Sun, Svend Krøjer, Christopher W. Warren, Jacob Hastrup, Morten Kjaergaard

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 are trying to keep a tightrope walker perfectly balanced on a wire. The problem is that the wind is changing direction every few milliseconds, the wire is stretching and shrinking, and the walker's shoes are getting slippery. If you only check the walker's balance once every minute (which is how most quantum computers are currently calibrated), you'll be reacting to weather conditions that happened 60 seconds ago. By the time you adjust the walker's stance, the wind has already changed again, and they might fall.

This paper describes a breakthrough in keeping superconducting quantum computers (the "tightrope walkers") stable. The researchers built a system that checks and adjusts the computer's settings thousands of times faster than before, reacting to changes in real-time.

Here is the breakdown of their solution using simple analogies:

1. The Problem: The "Slow Mailman"

Currently, quantum computers are calibrated using a "slow mailman" approach.

The Process: The computer runs a test, sends the data to a central brain (a regular computer) to analyze it, the brain figures out what's wrong, and then sends the new settings back.
The Bottleneck: This round trip takes about 250 milliseconds. In the quantum world, where things change in the blink of an eye (milliseconds), this is like trying to steer a race car by looking in a rearview mirror that shows you where you were 10 seconds ago. The environment changes too fast for this method to work well.

2. The Solution: The "Smart Reflex" (On-FPGA)

The researchers moved the "brain" right next to the "muscles." They put the analysis and decision-making directly onto the FPGA (a specialized computer chip that controls the quantum hardware).

The Analogy: Instead of sending a letter to a distant office to get advice, the tightrope walker now has a reflex built into their nervous system. They feel the wind, calculate the balance, and adjust their feet instantly, all in one continuous motion.
The Result: They reduced the time from "thinking" to "acting" from 250 milliseconds down to 10 milliseconds. This is fast enough to track the rapid changes in the quantum environment.

3. The Tools: "Smart Shortcuts"

To make these split-second decisions, they couldn't use the usual heavy math, which takes too long to compute. They invented two clever "shortcuts" (algorithms) that work like magic tricks:

The "Three-Point Guess" (Analytical Decay Estimation):
- Normal way: To figure out how fast a battery is draining, you might measure it every second for an hour and draw a smooth curve.
- Their way: They realized they only need three specific measurements to mathematically calculate the exact drain rate instantly. It's like looking at a car's speedometer at three precise moments and instantly knowing the exact acceleration without needing a long video.
- Use: This helps them measure how long the quantum bit stays stable (coherence) in under 10 milliseconds.
The "Goldilocks Search" (Golden-Section Search):
- Normal way: To find the perfect radio station, you might scan every single frequency from 88 to 108 MHz.
- Their way: They use a smart search that cuts the search space in half every time, quickly zeroing in on the perfect frequency without checking every single number. It's like finding a needle in a haystack by folding the haystack in half repeatedly until the needle is obvious.
- Use: This helps them find the perfect signal frequency for the qubit in milliseconds.
The "Sine Wave Fix" (Sparse Phase Estimation):
- Normal way: To fix a wobbly pulse, you might test 50 different power levels and draw a wave.
- Their way: They take three specific samples of the wave and use a formula to instantly calculate exactly how much to tweak the power. It's like a musician hearing a slightly off-note chord and instantly knowing exactly which string to tighten, without playing the whole scale.

4. The Result: The "Self-Healing" Computer

The team tested this system for 6 hours straight.

The Old Way: The computer's performance drifted and got worse over time because it couldn't keep up with the changing environment.
The New Way: The system continuously recalibrated itself. Even though the "wind" (environment) kept changing, the computer adjusted its settings so quickly that it maintained a high level of performance.
The Stats: They performed over 74,000 recalibrations in 6 hours. The error rate dropped by 6.4% compared to the old method, and the computer stayed stable even when the environment was chaotic.

Why This Matters

Think of this as the difference between a manual transmission car and a self-driving car with instant sensors.

Before: You had to stop, check the map, and manually adjust the steering.
Now: The car senses the road, the wind, and the traffic, and steers itself instantly, keeping you on the path no matter how bumpy the road gets.

This paper proves that we can build quantum computers that don't just sit still and wait for instructions, but actively adapt and heal themselves in real-time. This is a crucial step toward building quantum computers that are reliable enough to solve real-world problems.

1. Problem Statement

Superconducting qubit parameters (such as coherence times $T_1$ , gate frequencies, and pulse amplitudes) are subject to rapid fluctuations and drifts. While traditional calibration routines can take minutes to hours, recent observations indicate that environmental fluctuations in superconducting qubits can occur on sub-second to millisecond timescales.

The Bottleneck: Conventional calibration workflows rely on "offloading" data from the FPGA controller to a central CPU for analysis. This round-trip communication (typically 25–100 ms via LAN/WiFi) plus software fitting overhead creates a latency that is fundamentally mismatched to the speed of qubit drift.
The Consequence: By the time a calibration update is computed and applied, the qubit parameters have already shifted, leading to sub-optimal gate fidelities and reduced performance in quantum algorithms.

2. Methodology: On-FPGA Closed-Loop Workflow

The authors propose a fully on-FPGA workflow where pulse generation, data acquisition, analysis, optimization, and feed-forward are executed entirely on the control hardware (Quantum Machines OPX1000). This eliminates CPU round-trips and minimizes "time-to-decision" ( $T$ ).

Key technical components include:

Sparse Sampling & Analytical Estimators: Instead of dense sampling and numerical fitting, the authors introduce closed-form analytical methods that require minimal data points:
- Analytical Decay Estimation (ADE): A three-point estimator for exponential decay curves (e.g., $T_1$ , Randomized Benchmarking). It uses a closed-form solution to extract decay rates without fitting, making it independent of SPAM (State Preparation and Measurement) offsets.
- Sparse Phase Estimation (SPE): A three-point estimator for sinusoidal responses (e.g., pulse amplitude, Ramsey frequency). It samples symmetrically around a central point to cancel unknown offsets and contrasts, providing an analytical phase correction rule.
On-FPGA Optimization Algorithms:
- Nelder-Mead Optimization: Implemented for multi-dimensional readout optimization (finding optimal detuning and amplitude).
- Golden-Section Search (GSS): Implemented for 1D peak finding (e.g., spectroscopy frequency refinement).
Hardware Integration: The entire loop runs on the FPGA, utilizing the QUA intermediate language API to execute optimizers and feedback routines directly on the controller.

3. Key Contributions

Demonstration of Millisecond Latency: The authors successfully reduced the time-to-decision for key calibration primitives from hundreds of milliseconds (or seconds) to the millisecond regime.
Novel Analytical Tools: Introduction of ADE and SPE, which allow for memory-light, SPAM-independent parameter extraction suitable for FPGA implementation.
Continuous Closed-Loop Recalibration: A protocol that runs continuously for 6 hours, performing over 74,000 recalibration cycles without human intervention.
Drift Characterization: Quantitative analysis showing that continuous recalibration suppresses the coupling of control-parameter drift to gate errors, leaving gate performance tightly linked to instantaneous coherence.

4. Key Results

The toolset was deployed on a flux-tunable transmon qubit with the following performance metrics:

Speed Improvements:
- $T_1$ Estimation: 10 ms (vs. ~250 ms for offloading).
- Readout Optimization: 100 ms (vs. ~6 s for dense grid sweeps).
- Pulse Amplitude Calibration: 1.1 ms (vs. ~1.2 s for amplitude scans).
- Clifford Randomized Benchmarking (CRB): 107 ms (vs. ~1.3 s).
Long-Term Stability (6-Hour Run):
- The system performed 74,525 consecutive recalibrations.
- Gate Infidelity Reduction: Continuous recalibration reduced average gate infidelity by 6.4% compared to a static baseline.
- Drift Tracking: The system tracked $T_1$ fluctuations (ranging 14.5–27.5 $\mu$ s), drive frequency drift ( $\pm$ 25 kHz), and pulse amplitude drift in real-time.
Correlation Analysis:
- Static calibration showed gate errors correlated with drift in frequency and amplitudes.
- Recalibrated systems showed gate errors tightly coupled only to instantaneous coherence ( $T_1$ ), effectively decoupling performance from control parameter drift.

5. Significance and Impact

Autonomous Quantum Control: This work establishes a practical pathway for autonomous quantum processors that can self-correct on timescales faster than the environment changes.
Scalability: By moving analysis to the FPGA and using sparse sampling, the computational overhead does not scale linearly with the number of qubits in the same way as CPU-based fitting, making it viable for larger processors.
Performance Optimization: The results prove that "calibration" is not a one-time event but a continuous process. Maintaining high-fidelity operation in drifting environments requires feedback loops that are faster than the drift itself.
Resource Efficiency: The use of analytical estimators (ADE/SPE) drastically reduces the number of measurement shots required, saving time and reducing the total experimental footprint.

In summary, this paper demonstrates that by co-locating control and analysis on FPGAs and utilizing mathematically efficient sparse sampling, it is possible to track and correct superconducting qubit parameters in real-time, significantly enhancing the stability and fidelity of quantum operations in non-static environments.