Do Quantum Supernets Rank Circuits Correctly When Qubits Leak?

Weight-sharing architecture search trains one large "supernet" whose sub-networks share parameters, so thousands of candidate designs can be scored without training each one separately. This approach has started to reach quantum computing, where the candidates are variational circuits. The method is only useful if the supernet ranks candidates in the same order they would rank if each were trained alone. Quantum supernets have so far been scored with simulators that treat each qubit as an ideal two-level system with memoryless noise. Real superconducting qubits behave differently in two ways. They leak population into a third energy level, and that leaked population persists across many subsequent gates before it returns. Their noise also drifts slowly over time. To a simulator that only tracks the two computational levels, both effects look like noise with memory. We propose to measure, for the first time, how much this memory scrambles a quantum supernet's ranking of circuits. We also propose a cheap correction that tracks where and when leakage builds up inside each candidate circuit.

The central bet is specific. Leakage harm depends on the arrangement of gates: which qubits receive consecutive two-qubit gates, and how long a leaked qubit keeps being used. It does not depend only on how many gates there are. If that is true, two-level simulators and simple gate-count penalties will systematically overrate circuits that pile entangling gates onto the same qubits. A per-qubit leakage tracker that costs time linear in circuit length should then recover most of the ranking that a full three-level simulation gives. If it is false, we will show that a gate-count penalty is enough and say so.

Core Claim

Leakage turns a two-level noise model into a model with hidden memory. That memory is structured by circuit layout, and it is the main reason supernet rankings computed with two-level Markovian simulators would disagree with rankings under realistic hardware noise. We claim three things. First, standalone rankings of candidate circuits under a three-level simulator with slow drift differ measurably from rankings under a two-level Pauli simulator, even after controlling for two-qubit gate count. Second, a supernet scored with a classical per-qubit leakage tracker recovers much of the realistic ranking at a small fraction of the cost. Third, a leakage-aware score pulls the supernet's sampling toward shallow circuits and starves the rest of the search space of training updates. A Kullback-Leibler (KL) penalty that anchors the sampling distribution to a reference distribution can prevent this. The KL penalty is the least certain part of the proposal and is built as a removable ablation.

Why This Gap Is Real

Several papers motivate the measurement. QuantumDARTS built a differentiable quantum supernet. To keep gates exactly unitary, it picks one discrete gate per position in the forward pass and backpropagates through a continuous relaxation. It evaluated only readout noise and never reported a rank correlation, so it left the reliability of its supernet ranking unmeasured. CRLQAS and BenchRL-QAS search with reinforcement-learning agents under hardware-derived or depolarizing noise. Both restrict the simulator to memoryless channels on the two-level subspace, and neither shares weights across candidates.

On the classical side, MAGIC shows how fragile supernet ranking is: gradient conflict between sub-networks holds Kendall's τ at 0.36 on a BERT space until activation and topology alignment raise it to 0.57. That work supplies the evaluation protocol we reuse, comparing supernet rank to standalone rank, but it never faces hardware noise.

Two further papers motivate the leakage-as-memory view. Coupler-assisted leakage reduction shows on hardware that leaked |f⟩ population grows steadily over repeated cycles without active removal, which is exactly a persistent, time-correlated error. Leakage randomized benchmarking extracts average leakage and seepage rates from a static transition matrix. Its authors state that handling non-Markovian noise is open, which is why our tracker models drift explicitly rather than assuming fixed rates.

The modeling technique comes from non-Markovian QAOA. It embeds a memory-carrying environment into a larger memoryless system. We do the same thing by treating the third level, plus a slow drift variable, as the enlarged state.

That paper also reports that environmental memory can help optimization: the probability of finding the optimal Max-Cut rose from 0.4760 to 0.8260. This is in tension with our framing of memory as a source of ranking error. We do not assume memory is always harmful. Our ground truth is whatever the realistic simulator produces, so if drift helps some circuits, the correct ranking will reflect that. The question we ask is only whether cheap evaluators reproduce it.

Research Program

Search space and tasks. We build a layered hardware-efficient search space in the style of QuantumDARTS, on 4 to 6 qubits with nearest-neighbour connectivity. At each slot the space chooses among single-qubit rotations, an entangling gate on one of several qubit pairs, or identity. We use three task families from the files' benchmarks: molecular VQE (variational eigensolver) on H₂-4 and LiH-6, GHZ-state preparation as in BenchRL-QAS, and small Max-Cut QAOA instances. We draw roughly 500 to 1,000 candidates by stratified sampling, so that many candidates share the same two-qubit gate count but differ in where those gates sit. This stratification is what lets us separate a layout effect from a gate-count effect.

Ground truth. Every candidate is trained standalone under a reference simulator. Each transmon is a three-level system. Entangling gates carry leakage and seepage terms, and gates on a leaked qubit propagate errors to its partner. A slow random process, such as an Ornstein–Uhlenbeck process standing in for 1/f-like fluctuation, modulates the leakage rates and coherent over-rotations across the sequence of executions. The file reports no per-gate leakage rates. We therefore sweep leakage strength and drift correlation time over a grid and report results across the whole grid rather than at one tuned point. At 4 to 6 qutrits, density-matrix simulation is affordable for this many candidates. This is the main reason the study stays small.

The leakage tracker. For each qubit $q$ after gate step $t$ we propagate a classical leaked probability $\ell_q^{(t)}$ through the circuit:

$$\ell_q^{(t+1)} = \ell_q^{(t)}\,(1-s_g) + \big(1-\ell_q^{(t)}\big)\,r_g(t) + c_g\,\ell_{q'}^{(t)},$$

where $r_g(t)$ is gate $g$'s leakage rate at that time (drifting), $s_g$ is its seepage rate back to the computational levels, and $c_g$ couples leakage from the gate's partner qubit $q'$. The tracker costs time linear in the number of gates. It is blind to gate count as such and sensitive to placement, because leakage that is not given time to seep away compounds on reused qubits.

A sub-circuit's score is its two-level noisy objective, computed by the supernet as usual, corrected by the expected contribution of trajectories with leaked qubits. In the simplest version, that correction weights the objective by the no-leak probability of the qubits the measured observable depends on. The tracker is applied only when scoring sub-circuits and when computing the training signal. It does not change the supernet's shared parameters.

Time confounding. With drift, the moment at which a sub-circuit happens to be sampled during training affects what it learns. We log sampling times and test whether rank error correlates with the drift state at those times.

Sampling anchor. A leakage-aware score pushes an adaptive sampler toward circuits with few two-qubit gates. Those circuits then absorb most of the shared-weight updates, and the rest of the space is ranked on undertrained weights. This mirrors the collapse toward simple operations documented in progressive search-space design. We regularize the architecture sampling distribution $p_\phi$ toward a reference $p_{\text{ref}}$, which is uniform over choices or stratified by gate count:

$$\max_\phi\; \mathbb{E}_{a\sim p_\phi}\big[\hat{R}(a)\big] - \beta\, D_{\mathrm{KL}}(p_\phi \,\|\, p_{\text{ref}}),$$

where $\hat{R}(a)$ is the tracker-corrected score of sub-circuit $a$ and $\beta$ sets how strongly sampling stays near the reference. This is the policy-anchoring objective used in RLHF, here applied to which circuits get trained rather than which tokens get generated. The Stackelberg reward-shaping work warns that a static anchor passes the reference's biases on to the regularized distribution. We therefore also test α-divergence variants following AlphaNet, which found KL's asymmetry harmful for distillation inside supernets.

Baselines

Do nothing. The naive reference point is a QuantumDARTS-style supernet trained and scored with ideal two-level simulation plus readout noise, matching what QuantumDARTS evaluated. It shows the ranking a practitioner gets today.

Markovian hardware-noise supernet. The strongest existing approach to noise-aware search is to evaluate with a two-level Pauli-transfer-matrix simulator calibrated to hardware, as CRLQAS does. We reimplement that noise model inside the same supernet so that search strategy is held fixed and only the evaluator differs. CRLQAS reports an H₂-4 ground-state error of 7.2×10⁻⁸ Ha without noise, against 4.3×10⁻⁶ for QuantumDARTS. It also reports reaching chemical accuracy (1.6×10⁻³ Ha) at ten times the median noise of IBM Mumbai, and 67 gates on LiH-6 against 132 for earlier methods.

CRLQAS's own agent. We run the reinforcement-learning agent itself on the same tasks under our three-level reference simulator, at an equal budget of simulator calls. This tests whether a non-weight-sharing searcher simply sidesteps the problem.

Gate-count penalty. Here the two-level score is penalized by the number of two-qubit gates times a fitted leakage cost. It is the cheapest plausible leakage correction and the one our core claim must beat.

Ablations. The tracker without its drift term isolates the memory component. The tracker without uniform or anchored sampling isolates the sampling anchor.

Fairness and the success bar. All methods share the candidate pool, the standalone ground truth, the number of supernet training steps, and an equal hyperparameter tuning budget. The penalty weight and β are tuned on one held-out task family and frozen for the others. No quantum supernet rank correlation is reported in the file, so there is no published quantum number to beat. The classical reference is MAGIC's Kendall's τ improvement from 0.36 to 0.57, and RD-NAS's 9.65% τ gain over single-path one-shot training on NAS-Bench-201 (RD-NAS). Beating the strongest baseline means two things. First, a higher Kendall's τ against the realistic ground truth than the Markovian and gate-count evaluators, holding across the sweep of leakage and drift settings. Second, top-5 selected circuits whose realistic-simulator energy error is lower, with the gap larger than the variation across random seeds.

Why not just…?

Why not just penalize two-qubit gate count? This is the most serious threat. If leakage harm scales with gate count, the tracker adds nothing. The stratified candidate pool settles the question directly. Within groups of circuits that have equal two-qubit gate counts, we measure how well the gate-count score and the tracker each rank against ground truth. Gate count is constant within a group, so the penalty cannot rank inside it. If realistic rankings within groups are also nearly random or match the two-level ranking, layout does not matter. The proposal then reduces to recommending the penalty, and we report that outcome.

Why not just Markovianize the noise with randomized compiling? Randomized compiling twirls gates with random Paulis. It cut the model-violation measure from about 535 to about 25 on a superconducting processor, but 25 still indicates a model mismatch. More fundamentally, Pauli twirling acts on the computational levels. The leakage benchmarking paper explicitly avoids twirling over the leakage levels, and nothing in the file suggests that twirling returns leaked population. We include a randomized-compiling evaluator in the comparison. Its ranking error on high-leakage settings shows directly whether it closes the gap.

Why not just let hardware leakage-reduction units clear leaked states? Coupler-based reduction units clear 98.1% of |f⟩ population, but at a 0.58% cost in computational-subspace error and extra pulse time (coupler-assisted leakage reduction). We treat a reduction unit as a candidate operation with that cost. If the search simply inserts reduction units everywhere and the tracker no longer changes rankings, then hardware mitigation makes layout-aware search unnecessary in that regime. That is a legitimate finding.

Why not just use uniform sampling instead of a KL anchor? Uniform single-path sampling, and the stricter fairness of FairNAS, already prevent sampling collapse. The KL anchor only earns its place if adaptive, score-driven sampling improves the ranking of top candidates while uniform sampling preserves coverage. Our experiments compare uniform, unanchored adaptive, and KL-anchored sampling. If uniform sampling matches the anchored version, we drop the KL component.

Proposed Experiments

The first decisive check comes before any supernet is trained. We compute Kendall's τ and top-5 overlap between the two-level Markovian standalone ranking and the three-level drifting standalone ranking, across the grid of leakage and drift settings. If τ stays above roughly 0.9 and the top circuits coincide even at the strongest leakage settings, the premise fails and we publish the study as a negative result.

The second check is the within-group test of the tracker against gate count, described in the gate-count paragraph above.

The third check trains the supernet under each evaluator and reports τ and Spearman's ρ against the realistic ground truth, along with the realistic energy error of the selected circuits on H₂-4 and LiH-6 relative to chemical accuracy. On GHZ preparation we report state fidelity, and on Max-Cut we report approximation ratio.

The fourth check regresses each sub-circuit's rank error on the drift state at the times it was sampled. Running the same training with drift turned off tells us whether drift-related training artifacts are a separate source of error from leakage itself.

Finally, the sampling ablations measure the share of training updates each group of circuits receives, together with τ restricted to the deeper half of the space. This shows whether the KL anchor protects ranking where the leakage-aware score would otherwise starve the sampler of training.