⚛️ quantum physics

When Close Enough Is Not Enough: Autoregressive Drift in Quantum Circuit Synthesis

This paper demonstrates that while transformer-based models can successfully optimize quantum circuits when approximate outputs are correctable via post-processing, their reliability for exact discrete synthesis is fundamentally limited by autoregressive drift that causes performance to degrade sharply as circuit length increases, a problem only partially mitigated by inference-time search and data scaling rather than model-level adjustments.

Original authors: Mehdi Saeedi, Eddie Richter, Paul Hartke

Published 2026-07-15

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Mehdi Saeedi, Eddie Richter, Paul Hartke

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 teach a robot to build a perfect LEGO castle. You show it a messy pile of bricks (the "input circuit") and ask it to rebuild it into a sleek, efficient version using the fewest special "magic" bricks possible. This is the job of quantum circuit optimization, and the researchers at AMD tried to teach a smart AI robot (a "transformer") to do it.

Here is the twist: The robot is amazing at some things but hits a wall at others, and the reason is a glitch they call autoregressive drift.

The Two Worlds: The "Fuzzy" vs. The "Pixel-Perfect"

The researchers tested the robot in two different game modes.

Mode 1: The Fuzzy World (Parameterized Circuits)
In this mode, the robot builds a castle where the angles of the walls can be tweaked slightly. If the robot builds the shape of the castle correctly but the walls are tilted a tiny bit wrong, a human (or a classical calculator) can come in later and just nudge the angles until they are perfect.

The Result: The robot was a superstar here. It learned the structure so well that after a little "nudge," it achieved 100% perfect fidelity (a score of 1.000) on circuits with 3 to 6 qubits. It's like the robot drew the blueprint perfectly, and the builder just fixed the tiny crooked lines.

Mode 2: The Pixel-Perfect World (Clifford+T Circuits)
This is the real challenge. Here, the robot must build with rigid, discrete LEGO bricks. There are no "angles" to nudge later. Every single brick must be in the exact right spot, or the whole castle collapses into a different shape entirely.

The Result: This is where the robot started to trip over its own feet. While it learned the rules of the game (the syntax) and knew roughly how many magic bricks to use, it failed to build the exact correct castle often.
- For short castles (9 bricks or fewer), the robot got it right about 88% of the time.
- For medium castles (15–25 bricks), success dropped to 8.4% with the standard training data, and only rose to 23.4% when the robot was given significantly more practice data.
- For long castles (26+ bricks), the robot got it right 0% of the time with standard data, and only 3.7% even with the extra data.

The Culprit: The "Domino Effect" of Drift

Why did the robot fail on the long, rigid castles? The authors discovered a problem they named autoregressive drift.

Imagine the robot is writing a story, one word at a time, from left to right.

It writes the first word correctly.
It writes the second word correctly.
But then, on the third word, it makes a tiny mistake. Maybe it swaps a "T" for an "S" brick.

In the "Fuzzy World," that mistake wouldn't matter because you could fix the angle later. But in the "Pixel-Perfect World," that single wrong brick changes the context for every single brick that comes after it. The robot tries to build the rest of the castle based on a broken foundation. The error cascades, and by the time it reaches the end, the whole structure is completely wrong.

The paper shows that this drift happens incredibly fast. The robot usually makes its first mistake within the first 1–2 bricks (about 3% into the sequence). Once that happens, the rest of the sequence is doomed.

What Didn't Work (The "Try Harder" Trap)

The researchers tried many ways to fix this, and they were very clear about what didn't help:

Making the robot smarter (More parameters): They tried a bigger brain (133.6 million parameters vs. 44.8 million). It helped a tiny bit, but the drift problem remained.
Fine-tuning: They tried to teach the robot specifically on the hard, long castles. It didn't help.
Mixing models: They tried combining the outputs of two different robots. It didn't help much.
Just trying harder (Inference-time search): They tried generating 200 different versions of the castle and picking the best one. This helped, raising success rates from 7% to 22.5%, but it still couldn't fix the long castles.

The One Thing That Did Help (More Data)

The only thing that gave the robot a significant boost was giving it more practice.

When they increased the training data by 2.5 times (from 200,000 examples to 500,000), the robot's success rate nearly doubled.
With more data, the robot got the short castles right 94% of the time and the medium ones (15–25 bricks) right 23.4% of the time.
However, the drift problem didn't disappear. Even with all that extra practice, the success rate for the longest castles (26+ bricks) was still only 3.7%. The "domino effect" of the first mistake was still too strong to overcome just by reading more books.

The Bottom Line

The paper concludes that for quantum circuits where every single piece must be perfect, being "close enough" isn't good enough.

If you can fix small errors later (like in the Fuzzy World), AI works great. But if you need a perfect, discrete sequence where one wrong step ruins everything, the AI's tendency to drift off-course early on is a major bottleneck. The researchers suggest that for now, this AI might be best used as a "peephole" optimizer—fixing small, short sections of code where it is reliable—rather than trying to rebuild entire complex circuits from scratch.

The authors are careful to say this isn't a solved problem. They measured these results on specific simulations and found that while more data helps, the fundamental issue of "drift" in long sequences remains a stubborn hurdle that current methods haven't cleared.

Problem Statement

The paper addresses the challenge of optimizing quantum circuits for fault-tolerant computing, specifically focusing on minimizing the T-count (the total number of non-Clifford T and T† gates). In fault-tolerant architectures, T gates require expensive magic state distillation, making their minimization a critical compilation step.

The authors investigate whether a learned neural network can perform this optimization task, replacing or augmenting hand-crafted rule libraries (such as those based on ZX-calculus or matroid partitioning). They formulate the problem as a sequence-to-sequence translation task: given an input circuit, the model must generate an equivalent output circuit with a lower T-count. The study contrasts two distinct settings:

Parameterized Circuits: Circuits containing continuous rotation angles.
Clifford+T Circuits: Circuits composed entirely of discrete gates (H, S, T, CNOT, etc.) with no continuous parameters, requiring exact functional equivalence.

Methodology

The authors employ a compact encoder-decoder transformer (44.8 million parameters) trained on 200,000 circuit pairs.

Structured Tokenization: Unlike text-based approaches that parse raw QASM strings, the model uses a structured tokenization scheme where every token carries circuit-semantic information (gate type, qubit index). The vocabulary is small (~102 tokens), with only 25 active tokens for Clifford+T circuits.
Architecture: The model uses pre-layer normalization and causal masking. For parameterized circuits, a separate regression head predicts $(\sin \theta, \cos \theta)$ pairs for rotation angles. For Clifford+T, this head is disabled as all gates are discrete.
Training Data:
- Parameterized: Generated using Qiskit O3 optimization.
- Clifford+T: Generated by creating random circuits, injecting redundancy (e.g., $HH=I$), and optimizing them using PyZX (a ZX-calculus based optimizer) to create the ground-truth targets.
Decoding Strategies: The study evaluates five strategies, all utilizing a verifier-first reranking policy. Candidates are generated (via greedy, beam search, or temperature sampling), verified for unitary equivalence ( $F > 0.999$ ), and the lowest T-count valid candidate is selected.

Key Findings and Results

1. The Dichotomy of Success and Failure

The paper identifies a sharp contrast between the two circuit settings:

Parameterized Circuits: The model achieves median fidelity of 1.000 on 3–6 qubit circuits. The transformer learns the circuit structure with near-perfect validity (100%). Although angle predictions are imprecise, classical post-processing (Nelder-Mead optimization) successfully refines the angles, rescuing the output.
Clifford+T Circuits: The model learns valid syntax and accurate T-count statistics (predicting the correct distribution of gate counts). However, exact functional equivalence degrades sharply as the target circuit length increases.
- On short circuits ( $\le$ 9 gates), exact-match rates are high (88% with beam search).
- On longer circuits ( $\ge$ 26 gates), exact-match rates drop to near zero.

2. Autoregressive Drift

The primary failure mode identified is autoregressive drift.

Mechanism: The model often diverges from the correct output within the first few tokens (median first error at ~3% of the sequence length). Because the decoding is left-to-right, an early error in a discrete token (e.g., swapping an S gate for a T gate) corrupts the context for all subsequent tokens.
Irrecoverability: Unlike parameterized circuits where angles can be re-optimized, a single wrong discrete gate in a Clifford+T circuit irreversibly changes the unitary. The fidelity distribution is bimodal ( $F \approx 1$ or $F \approx 0$ ), with no "close enough" middle ground.
Dominant Predictor: The failure is driven by target circuit length, not the number of qubits. Performance collapses as gate counts move from single digits to double digits.

3. Evaluation of Interventions

The authors tested various strategies to mitigate drift:

Inference-Time Compute: Scaling the number of candidates ( $N$ ) improves results. Temperature sampling with $N=200$ raises exact-match rates from 7% (greedy) to 22.5%. However, this follows a saturation curve with diminishing returns.
Data Scaling: Increasing the training dataset by 2.5× (from 200K to 500K pairs) nearly doubles the exact-match rate to 39.5%. This is the most effective lever.
Fine-Tuning & Diversification: Targeted fine-tuning on long circuits, weighted sampling, hybrid search, and model ensembling yielded only marginal gains (e.g., 21.0% to 24.5%) and did not alter the fundamental degradation pattern with length.
Persistence of Drift: Even with 2.5× more data, the length-dependent degradation persists. Exact equivalence drops from 94% on short circuits to under 4% on circuits with 26+ gates.

Significance and Claims

The paper's central contribution is a diagnosis of autoregressive drift as the fundamental bottleneck for learned quantum circuit compilation when exact discrete correctness is required.

The "Close Enough" Limit: The authors demonstrate that while transformers can learn optimization patterns and structural validity, they cannot reliably recover from early-token errors in discrete domains. Post-processing cannot rescue discrete errors, unlike continuous parameter optimization.
Practical Implications: The model is most viable as a peephole optimization pass for short subcircuits (e.g., $\le$ 14 gates) within production compilers, where it can achieve high exact-match rates. For longer circuits, the current autoregressive approach is unreliable.
Scaling Laws: The study highlights that for tasks with efficient verifiers (like unitary comparison), scaling training data is more effective than scaling model parameters or complex inference-time search strategies.
Future Direction: The authors suggest that overcoming this bottleneck likely requires moving away from pure autoregressive decoding toward non-autoregressive methods (e.g., discrete diffusion, iterative refinement) or subcircuit decomposition strategies that operate within the model's high-accuracy regime.

The paper concludes that while learned models show promise in understanding circuit structure, the autoregressive drift mechanism currently limits their reliability for exact synthesis of complex, discrete quantum circuits.