betaFeedback

WorksComputer Science

Hybrid Quantum Selection of Learning Rates in Language-Model Training: Termination Criteria and an Interaction-Guided Schedule Oracle

Abstract

Learning-rate choices strongly affect language-model fine-tuning, but the best joint profile across layer groups is generally unknown. This paper studies quantum minimum finding for layer-group learning-rate selection within a hybrid classical-quantum training framework. It combines Durr-Hoyer minimum finding with BBHT search and compares fixed-budget and confidence-based stopping policies using a lookup oracle built from measured profile scores at fixed training checkpoints. The paper then introduces an Interaction-Guided Schedule Oracle that scores and marks joint schedules in superposition without a precomputed score table. Classical one-step loss measurements supply the main, pairwise and three-way interaction effects between layer groups. The circuit adds the effects for each schedule, compares the resulting score with the current baseline score, and marks improving schedules for amplitude amplification. Measured candidates are checked classically before acceptance. Uniform-rate training supplies the initial baseline; using schedules from classical adaptive methods as baselines for joint refinement is left for future work. In closed-loop fine-tuning of a 1.5-billion-parameter language model, each selected schedule drives the next 200 classical training steps. Benchmark accuracies lie within the range observed across five uniform-rate seeds. The results give a working example of how quantum superposition can support adaptive learning-rate selection during training; the remaining quantum limitations are discussed in the paper.

Introduction

Layer-wise learning rates can improve language-model training. Discriminative fine-tuning assigns different rates across layers (Howard & Ruder, 2018), layer-wise adaptive rate scaling does the same for deep networks (You et al., 2017), and recent work derives layer-dependent rates from model statistics or training dynamics (He et al., 2026; Pang et al., 2026); separate rates can also improve the two factors of a low-rank adapter (Hayou et al., 2024). These methods determine rates individually or by a prescribed rule, rather than jointly selecting one profile from all admissible layer-group combinations. The number of joint profiles grows quickly with the number of groups and candidate rates: six groups with eight admissible rates already define 86=262,1448^6 = 262{,}144 possible profiles. This combinatorial growth motivates the quantum-search formulation developed here.

This paper studies quantum minimum finding for joint learning-rate selection across GG layer groups, where each group chooses from KK admissible rates and one complete profile specifies the rates applied to the model. The quantum search has one task: identify a low-loss learning-rate profile from these combinations, after which the selected rates are used for the next block of classical training. In the first part of the paper, this process is simulated at fixed training checkpoints: candidate profiles are evaluated by short h=25h = 25-step replays whose held-out losses fill a score table and provide the search scores. The checkpoints are spaced every 200 training steps in the experimental design; in a practical system, when to invoke the selector could instead be determined by the training schedule or other monitored signals.

Quantum search enters only at the profile-selection step. Grover’s search can identify marked candidates in an unstructured space of NN possibilities using O(N)O(\sqrt{N}) oracle queries (Grover, 1996), and Dürr & Høyer [9] extend this idea to minimum finding by repeatedly lowering a threshold. In this paper the search space contains N=KGN = K^G learning-rate profiles, each represented by one basis-state index of a quantum search register that holds all of them in superposition. For example, N=8N = 8 candidate profiles require three search qubits, represented by ∣000⟩,…,∣111⟩\lvert000\rangle, \ldots, \lvert111\rangle. The quantum search therefore acts on profile indices and uses the profile score only to determine which candidates improve on the current threshold.

In the score-table experiments, each search round prepares the register, marks the profiles below the current loss threshold, amplifies them by Grover diffusion and measures; because the measurement is probabilistic, a round may return no improving candidate even when one exists. The rounds are simulated without noise, and a small hardware experiment verifies the marking behavior. The marking is carried out by a lookup oracle built from measured profile scores. Run on candidate spaces of N=81N = 81, 128 and 256, these simulations provide the data from which the performance of the termination criteria is determined.

Quantum minimum finding proceeds through both successful and unsuccessful search rounds. A successful round finds a better candidate and lowers the current threshold, whereas an unsuccessful round leaves the threshold unchanged. Because the true minimum is unknown, repeated failures do not by themselves reveal when no better profile remains. The paper therefore compares termination criteria that decide when the search should stop: each rests on its own assumption and stops the search once the observed rounds meet its condition. For each criterion, the work spent finding better profiles is counted, and so is the extra effort spent after the last improvement until the search stops.

The second part of the paper replaces the lookup oracle. The Interaction-Guided Schedule Oracle (Section 2.4) borrows a notion familiar in machine learning, main effects and interaction effects (Tsang et al., 2018), and brings it into superposition. Classical one-step loss measurements give the main effect of each layer group and the interaction effects between groups; the oracle then works in two steps inside one simulated circuit. First, the circuit computes a score for every schedule, one complete set of group rates, in superposition. Second, it marks the schedules whose scores exceed the current threshold, initially the score of the uniform-rate baseline. Grover diffusion then amplifies the marked schedules before measurement. The measured candidate’s score is checked classically: an improvement replaces the current best schedule and raises the threshold; otherwise, the threshold stays unchanged. Search rounds continue, with the rounds and Grover iterations counted, until a termination criterion stops the search. The best schedule found drives the next block of training (Section 3.2).

Machine learning already adapts learning rates during training without exhaustive search: population-based training discovers a schedule of hyperparameter settings rather than one fixed set for the whole course of training (Jaderberg et al., 2017), and hypergradient descent updates the learning rate during optimization from the gradient of the update rule with respect to that rate [3]. The oracle offers a further refinement step: starting from a baseline schedule, it searches for joint changes across layer groups that achieve a higher interaction score. This paper demonstrates that process with a uniform-rate baseline. More generally, a schedule proposed by a classical adaptive method could serve as the baseline: new one-step measurements around that schedule would supply the main and interaction effects, and its score would set the initial threshold. Much as a support vector machine can use different kernels within the same learning framework [8], the oracle could use effects measured around different baseline schedules while retaining the same quantum scoring and marking structure. Extending this process to classical adaptive baselines is a direction for future research. The contributions are a comparison of termination criteria for quantum minimum finding on measured score tables, and a demonstration, with uniform-rate training as the baseline, in which the Interaction-Guided Schedule Oracle searches for improved combinations of group rates and the selected rates are applied to successive blocks of training.

Methodology

From classical training to quantum selection

For scale, the original Transformer was trained for 100,000 steps at about 0.4 s per step in its base configuration and for 300,000 steps at 1.0 s per step in its large configuration (Vaswani et al., 2017). LoRA fine-tuning keeps the same step-based structure while reducing the number of trainable parameters (Hu et al., 2022). For ntrn_{\mathrm{tr}} optimizer steps with mean time ttrt_{\mathrm{tr}}, the classical training time is

TC=ntr ttr.(1)T_{\mathrm{C}} = n_{\mathrm{tr}}\,t_{\mathrm{tr}}. \tag*{(1)}

Nonuniform learning rates have been used in several forms: discriminative fine-tuning assigns layer-specific rates (Howard & Ruder, 2018); layer-wise adaptive scaling treats layers separately (You et al., 2017); model-derived rates use layer statistics or training dynamics (He et al., 2026; Pang et al., 2026); and LoRA-specific rates assign different rates to the two low-rank factors (Hayou et al., 2024). Motivated by these results, this paper groups the trainable layers into GG groups and searches only the rate ηg\eta_g assigned to each group gg:

wg←wg−ηg dg,g=1,…,G,(2)w_g \leftarrow w_g - \eta_g\,d_g,\qquad g=1,\ldots,G, \tag*{(2)}

where wgw_g denotes the trainable parameters of group gg, and dgd_g is the update direction supplied by back-propagation and the optimizer.

From Eq. (2), each group chooses one learning rate. Let E\mathcal{E} contain KK admissible rates. A learning-rate profile zz selects one member of E\mathcal{E} for each of the GG groups, so the complete profile space contains N=KGN=K^G combinations:

E={η(1),…,η(K)},z=(η1,…,ηG)∈EG,N=∣EG∣=KG.(3)\mathcal{E}=\{\eta^{(1)},\ldots,\eta^{(K)}\},\qquad z=(\eta_1,\ldots,\eta_G)\in\mathcal{E}^G,\qquad N=\lvert\mathcal{E}^G\rvert=K^G. \tag*{(3)}

Each of these NN profiles is one candidate learning-rate setting for the model.

The quantum search register encodes the learning-rate profiles of Eq. (3). Let Tableprof\mathit{Table}_{\mathrm{prof}} denote the table of profiles that a search covers, one profile zz per row and NN rows in total. A register of qsrchq_{\mathrm{srch}} qubits has 2qsrch2^{q_{\mathrm{srch}}} computational basis states (Grover, 1996); therefore a Tableprof\mathit{Table}_{\mathrm{prof}} of NN rows requires qsrch=⌈log⁡2N⌉q_{\mathrm{srch}}=\lceil\log_2 N\rceil search qubits. Each profile zz is represented by its binary row index as the basis state ∣z⟩\lvert z\rangle of the register, and the search begins from the uniform superposition over the NN encoded profiles:

qsrch=⌈log⁡2N⌉,z⟷∣z⟩,∣ψ0⟩=1N∑z∣z⟩.(4)q_{\mathrm{srch}}=\lceil\log_2 N\rceil,\qquad z\longleftrightarrow\lvert z\rangle,\qquad\lvert\psi_0\rangle=\frac{1}{\sqrt{N}}\sum_z\lvert z\rangle. \tag*{(4)}

For the complete profile space EG\mathcal{E}^G, Tableprof\mathit{Table}_{\mathrm{prof}} contains KGK^G profiles. When only a subset is searched, NN is the number of rows included in Tableprof\mathit{Table}_{\mathrm{prof}}, and Eq. (4) fixes the width of the search register, so the number of search qubits grows with the logarithm of $N ({xref}Figure A2` shows the mapping at N=8N=8).

To find a useful profile zz during training, the search over Tableprof\mathit{Table}_{\mathrm{prof}} follows the quantum minimum finding of Dürr & Høyer [9], which applies Grover’s search (Grover, 1996) repeatedly while lowering a threshold. Each row carries one score f(z)f(z), the quantity to be minimized. Let yy be the current threshold profile and f(y)f(y) its score, MM the number of profiles in the NN-row Tableprof\mathit{Table}_{\mathrm{prof}} with f(z)<f(y)f(z)<f(y), and jj the number of Grover iterations applied in one search round. For example, at the scale of the held-out losses in the simulations of § 3, if the current threshold has f(y)=2.70f(y)=2.70 and exactly three profiles in Tableprof\mathit{Table}_{\mathrm{prof}} have lower scores, then M=3M=3; the search does not know this value in advance. A round prepares ∣ψ0⟩\lvert\psi_0\rangle of Eq. (4), applies jj Grover iterations, measures once, and tests whether the measured profile lies below the current threshold. A successful round returns some profile zz with f(z)<f(y)f(z)<f(y), which becomes the new threshold profile. For fixed NN, MM, and jj, the probability that a round returns a profile below the threshold is

pj(M)=sin⁡2((2j+1)θ),θ=arcsin⁡MN.(5)p_j(M)=\sin^2\bigl((2j+1)\theta\bigr),\qquad\theta=\arcsin\sqrt{\frac{M}{N}}. \tag*{(5)}

Because MM is unknown, the Grover iteration count that Eq. (5) would favor is unknown too, and too many iterations can rotate the state past the marked subspace. The exponential search of Boyer et al. [4] therefore does not fix a single Grover iteration count jj in advance. Instead, it starts with a small range of possible iteration counts and widens that range after unsuccessful rounds, so the search can reach deeper without assuming MM beforehand. Figure 1 shows one round of this search, and a run is a sequence of such rounds, with failures that widen the range and successes that lower the threshold. Let mBBHTm_{\mathrm{BBHT}} denote the upper scale of this range; in each round jj is drawn uniformly from {0,…,⌈mBBHT⌉−1}\{0,\ldots,\lceil m_{\mathrm{BBHT}\rceil-1\}}. After a failed round the range expands, and after a successful threshold update it resets:

Figure 1. Quantum threshold minimum finding: one search round and when to stop. Each round prepares the search register, chooses an iteration count jj, applies jj oracle–diffuser iterations, measures one row, and checks whether its score improves the current threshold f(y)f(y); a success moves the threshold and resets the range mBBHTm_{\mathrm{BBHT}} from which jj is drawn, a failure keeps it and enlarges that range. At the illustrative size N=16N = 16 with M=2M = 2 rows below the threshold, a round with j=1j = 1 measures a marked row with probability 78.1% by Eq. (5).

j∼U{0,…,⌈mBBHT⌉−1},j \sim\mathcal{U}\{0,\ldots,\lceil m_{\mathrm{BBHT}}\rceil-1\},
failure:mBBHT←min⁡(λmBBHT,N),λ=65,success:mBBHT←1,y←z.(6)\begin{aligned} \text{failure:}\quad&m_{\mathrm{BBHT}} \leftarrow\min(\lambda m_{\mathrm{BBHT}},\sqrt{N}), \qquad\lambda= \frac{6}{5},\\ \text{success:}\quad&m_{\mathrm{BBHT}} \leftarrow1,\qquad y \leftarrow z. \tag*{(6)} \end{aligned}

For any λ∈(1,4/3)\lambda\in(1,4/3), Boyer et al. [4] show that a search with unknown MM requires O(N/M)O(\sqrt{N/M}) Grover iterations in expectation. Across the successive threshold updates, Dürr & Høyer [9] bound the expected total number of Grover iterations QQ needed to reach the minimum by

E[Q]≤454N.(7)\mathbb{E}[Q] \le\frac{45}{4}\sqrt{N}. \tag*{(7)}

This bound characterizes the expected search effort, but does not by itself specify a practical termination criterion; the criteria used in this paper are introduced in § 2.3.

The lookup oracle and the short-horizon score

Grover adaptive search uses a threshold oracle to distinguish improving candidates from the remaining search states (Gilliam et al., 2021). For the learning-rate search, this paper uses the held-out evaluation loss as that criterion: each profile zz receives a score f(z)f(z), obtained by training from the current checkpoint under that profile. Given the current threshold profile yy, profiles satisfying f(z)<f(y)f(z) < f(y) are the improving candidates and are phase-marked by the oracle for subsequent Grover amplification.

Evaluating this score coherently would require the transformer-training dynamics and the held-out loss evaluation to be represented inside the quantum computation, which is beyond the implementation studied here. The experiments of § 3.1 and Appendix § 8 therefore compute the candidate scores classically and store them in a second table, TablescoreTable_{\mathrm{score}}, with one score corresponding to each row of TableprofTable_{\mathrm{prof}}. Thus, TableprofTable_{\mathrm{prof}} specifies the profiles being searched, whereas TablescoreTable_{\mathrm{score}} supplies the scores used by the simulated oracle.

Using TablescoreTable_{\mathrm{score}}, the simulated lookup oracle OyO_y applies the required threshold marking

Oy∣z⟩={−∣z⟩,f(z)<f(y),−∣z⟩,f(z)≥f(y).O_y \lvert z\rangle= \begin{cases} -\lvert z\rangle, & f(z) < f(y),\\ \phantom{-}\lvert z\rangle, & f(z) \ge f(y). \end{cases}

The lookup therefore preserves the marking action required by the search while replacing coherent score evaluation with access to the classically computed scores. Figure A3 contrasts these two paths: the intended coherent oracle evaluates f(z)f(z) on the device, whereas the experiments obtain the same threshold decision from TablescoreTable_{\mathrm{score}}.

Figure A3. Threshold oracle: the proposed coherent circuit and what the experiments simulate. A quantum search over TableprofTable_{\mathrm{prof}} needs an oracle that flips the sign of every row whose score lies below the threshold, f(z)<f(y)f(z) < f(y). The proposed circuit evaluates the score f(z)f(z) on the device and compares it with f(y)f(y) there. The experiments simulate this behavior: the scores are computed classically, one replay of h=25h = 25 optimizer steps per row, and stored in TablescoreTable_{\mathrm{score}}, and a lookup applies the same phase flip from the stored values. The searches of § 3.1 and Appendix § 8 run on this simulated oracle, and the rounds of those searches are the recorded data; the closed-loop searches of § 3.2 use the oracle of § 2.4.

Oracle convention. The lookup experiments use Dürr–Høyer minimum finding [9] with the search dynamics of Eqs. (5)–(6) and Figure 1, with candidate losses supplied by TablescoreTable_{\mathrm{score}}. The quantum search acts on profile indices, while classical replay constructs f(z)f(z); because the score depends on replay length, TablescoreTable_{\mathrm{score}} is defined at a replay horizon hh.

The replay horizon. At checkpoint tt, TablescoreTable_{\mathrm{score}} is constructed by replaying each candidate profile zz for hh optimizer steps from the same saved model and optimizer state, using the same sequence of training batches. Let Lt+h(z)L_{t+h}(z) denote the resulting held-out evaluation loss. The checkpoint-local score at horizon hh is

ft(h)(z):=Lt+h(z).f_t^{(h)}(z) := L_{t+h}(z).

The score has the form of a bilevel hyperparameter objective: an outer loss evaluated on the model that a fixed number of inner optimization steps produces [10]. The inner dynamics are the hh replayed optimizer steps from the checkpoint state, and the outer loss is the held-out evaluation loss.

The horizon was fixed by measuring how well shorter replays preserve the candidate order of a 200-step replay (Appendix § 5): at checkpoints 200 and 600, measured before any TablescoreTable_{\mathrm{score}} of this paper was built, h=25h = 25 is the shortest horizon with the highest rank agreement, whereas the one-step ranking is unstable across checkpoints, in line with the bias of short-horizon objectives toward small step sizes (Wu et al., 2018) and the long-run loss of one-step gains (Roulet et al., 2024). This paper then applies the held-out loss after h=25h = 25 replayed steps as the score,

f(z)=ft(25)(z)=Lt+25(z).(8)f(z) = f_t^{(25)}(z) = L_{t+25}(z). \tag*{(8)}

Selection target. The target of a selection at checkpoint tt is the minimizer of that checkpoint’s own TablescoreTable_{\mathrm{score}}, computed using only measurements up to t+25t + 25:

zt∗=arg⁡min⁡z∈Tableprof ft(25)(z).(9)z_t^* = \underset{z \in Table_{\mathrm{prof}}}{\arg\min}\ f_t^{(25)}(z). \tag*{(9)}

A search that returns the profile z^t\hat{z}_t instead of zt∗z_t^* has the regret f(z^t)−f(zt∗)≥0f(\hat{z}_t) - f(z_t^*) \ge0, zero when the minimizer is returned.

Termination criteria

Because MM, the number of profiles better than the current threshold, is unknown, a failed round does not reveal whether a better profile remains. Dürr & Høyer [9] therefore end the procedure by a global time-out, and Boyer et al. [4] handle the case M=0M = 0 by an O(N)O(\sqrt{N}) time-out. Four termination criteria are compared in this paper, in two families: fixed-budget criteria, and confidence-based criteria that read the failed rounds as evidence. § 3.1 compares them on the measured score tables to choose the criterion of the closed-loop searches.

Fixed-budget termination. During a selection, each round adds its jj Grover iterations to the running total, and each success opens a new threshold visit; both counts are recorded. Criterion A is the global time-out of Dürr & Høyer [9], a limit on the effort of the whole run. Let QQ be the Grover iterations spent so far and VV the threshold visits so far, the initial one included, with lg⁡\lg the base-2 logarithm:

A:stop when Q+(Vlg⁡N)∗∗≥22.5N+1.4lg⁡2N, return y.(10)\mathrm{A:}\quad\text{stop when } Q + (V\lg N)^{**} \ge22.5\sqrt{N} + 1.4\lg^{2}N,\ \text{return } y. \tag*{(10)}

Criterion B instead limits one threshold visit: when the Grover iterations of the current visit reach the budget that the proof of Theorem 3 in Boyer et al. [4] assigns to one exponential search, without a better profile found, the run stops:

B:stop when ∑visitj≥12∑λ=1λN=3N at λ=65, return y.(11)\mathrm{B:}\quad\text{stop when } \sum_{\mathrm{visit}} j \ge\frac{1}{2}\sum_{\lambda=1}^{\lambda} \sqrt{N} = 3\sqrt{N}\text{ at }\lambda= \frac{6}{5},\ \text{return } y. \tag*{(11)}

Derivation note. A double asterisk marks a paper-specific extension of a cited bound; the corresponding derivations are given in Appendix § 6.

Confidence-based termination. The second family treats failed rounds as evidence and stops when they bound (criterion C) or estimate (criterion D) the chance that a better profile remains below a confidence level δ\delta. Both are computed classically from the observed rounds.

Criterion C counts the consecutive failed rounds of one visit once the range mBBHTm_{\mathrm{BBHT}} has saturated, where Boyer et al. [4] guarantee a success probability of at least 14\frac{1}{4} whenever M≥1M \ge1; if a better profile remains, kk such failures occur with probability at most (3/4)k(3/4)^k, and the count restarts at every threshold update:

C:(3/4)k≤δ⟹kstop(δ)=⌈ln⁡δln⁡(3/4)⌉∗∗=25at δ=10−3.(12)\mathrm{C:}\qquad(3/4)^k \le\delta\Longrightarrow k_{\mathrm{stop}}(\delta)=\left\lceil\frac{\ln\delta}{\ln(3/4)}\right\rceil^{**}=25\quad\text{at }\delta=10^{-3}. \tag*{(12)}

Criterion D makes the confidence state-dependent. A success updates the possible rank of the threshold, so the next failure is interpreted from that new state rather than counted equally with earlier failures. The resulting distribution π(r)\pi(r) over the rank rr of the current threshold within Tablescore\mathit{Table}_{\mathrm{score}}, uniform at the start, π0(r)=1/N\pi_0(r)=1/N, is updated after every round of a visit from the distribution πu\pi_u held at its start, and the search stops when the probability that a better profile remains falls below δ\delta, ∑r≥2π(r)≤δ\sum_{r\geq2}\pi(r)\leq\delta:

D∗∗:failure with j:π(r)⟶π(r)[1−pj(r−1)]/cπ,success:πu+1(r)=1cπ∑s>rπu(s)s−1.(13)\begin{aligned} \mathrm{D}^{**}: \qquad&\text{failure with }j:\quad\pi(r)\longrightarrow\pi(r)\left[1-p_j(r-1)\right]/c_\pi,\\ &\text{success}:\quad\pi_{u+1}(r)=\frac{1}{c_\pi}\sum_{s>r}\frac{\pi_u(s)}{s-1}. \tag*{(13)} \end{aligned}

cπc_\pi normalizes π\pi to total mass one after each update, and the next visit starts from πu+1\pi_{u+1}.

Rounds and queries. The four termination criteria differ mainly in how long the search continues after the improving part of the run. The total Grover-iteration count of a selection under criterion x∈{A,B,C,D}x\in\{\mathrm{A},\mathrm{B},\mathrm{C},\mathrm{D}\} therefore splits into the iterations that improve the threshold and those spent in the terminal visit before stopping:

R(x)=#rounds=#preparations=#checks,Q(x)=∑jQj=Qimp(x)+Qstop(x).(14)R^{(x)}=\#\mathrm{rounds}=\#\mathrm{preparations}=\#\mathrm{checks},\qquad Q^{(x)}=\sum_j Q_j=Q_{\mathrm{imp}}^{(x)}+Q_{\mathrm{stop}}^{(x)}. \tag*{(14)}

Here the improvement effort Qimp(x)Q_{\mathrm{imp}}^{(x)} counts the iterations of visits that find a better threshold and the stopping effort Qstop(x)Q_{\mathrm{stop}}^{(x)} those of the final visit before criterion xx stops; each round has one state preparation, one measurement and one classical check. For criteria A–D, rounds and Grover iterations summarize search effort, while timing estimates and detailed cost accounting are given in Appendix § 7.

Interaction-Guided Schedule Oracle

After the termination criterion is chosen from the lookup-oracle data, the Interaction-Guided Schedule Oracle is applied to the same pipeline without a precomputed score table and works in two steps inside one circuit: it first scores all joint schedules at once in superposition, adding up the main and interaction effects of the layer groups that apply to each schedule, and then compares every score with that of the current threshold schedule and marks the schedules that beat it; Grover amplification increases the chance that the measured schedule is an improving candidate. Figure 2 connects the classical loss measurements with the quantum schedule selection and the subsequent training interval.

Figure 2. Hybrid loop with the Interaction-Guided Schedule Oracle: classical measurements construct the interaction score, quantum search selects a schedule, and training applies it.

Checkpoint evaluation and the interaction score. Following the intuition of main effects and interaction effects, a schedule is assumed to change the loss through the effect of each group alone and through interactions between groups. Pair and triple interactions are kept in this first model; further terms can be added. In units of the uniform rate, a schedule z=(η1,…,ηG)z=(\eta_1,\ldots,\eta_G) of Eq. (3) takes ηg∈{0.5,0.7,1.0,1.4}\eta_g\in\{0.5,0.7,1.0,1.4\}, and the uniform-rate baseline zrefz_{\mathrm{ref}} has every ηg=1.0\eta_g=1.0. For comparison, the checkpoint evaluation moves the rates of one, two or three groups away from the baseline and takes one trial optimizer step; the gain is the drop in held-out loss against the same step at the baseline.

The main effect Yt(g;η)Y_t(g;\eta), the single-group gain, is the gain of moving group gg alone to the rate η\eta, measured at 0.5, 0.7 and 1.4. Pairs and triples are measured only at 0.5 and 1.4, a choice that reduces the measurement and computation requirements; their interactions νt,gg′\nu_{t,gg'} and νt,gg′g′′\nu_{t,gg'g''} are derived from the joint gains by removing the lower-order effects. An interaction term with a group at 0.7 shares the term derived at 0.5, written ηˉg=0.5\bar{\eta}_g=0.5 when ηg=0.7\eta_g=0.7 and ηˉg=ηg\bar{\eta}_g=\eta_g otherwise. The interaction score of a schedule is

Y^t(z)=∑g=1GYt(g;ηg)+∑g<g′νt,gg′(ηˉg,ηˉg′)+∑g<g′<g′′νt,gg′g′′(ηˉg,ηˉg′,ηˉg′′).(15)\widehat{Y}_t(z)=\sum_{g=1}^{G}Y_t(g;\eta_g)+\sum_{g<g'}\nu_{t,gg'}(\bar{\eta}_g,\bar{\eta}_{g'})+\sum_{g<g'<g''}\nu_{t,gg'g''}(\bar{\eta}_g,\bar{\eta}_{g'},\bar{\eta}_{g''}). \tag*{(15)}

Compiled into the oracle circuit as integer constants, the terms of Eq. (15) let the oracle score all 4,096 schedules in superposition. The interaction score Y^t(z)\widehat{Y}_t(z) plays a role analogous to the kernel of a support vector machine: its terms can change while the quantum scoring and marking structure is retained. Appendix J gives the evaluation protocol, interaction derivation and integer score.

Quantum search over candidate schedules. Each group’s rate takes two qubits, so qsrch=12q_{\mathrm{srch}}=12 search qubits hold all N=KG=4,096N=K^G=4,096 schedules of K=4K=4 rates over G=6G=6 groups. With Φt(z)\Phi_t(z) the integer form of Y^t(z)\widehat{Y}_t(z) and yy the current threshold schedule, the oracle marks every schedule that scores above the threshold:

Oy∣z⟩=(−1)1[Φt(z)>Φt(y)]∣z⟩.(16)O_y\lvert z\rangle=(-1)^{\mathbf{1}[\Phi_t(z)>\Phi_t(y)]}\lvert z\rangle. \tag*{(16)}

The search starts with the uniform-rate baseline zrefz_{\mathrm{ref}}, whose score is zero, and retains each improving schedule it samples as the new threshold. When termination criterion D is satisfied, it returns the best schedule retained, z^t\hat{z}_t, which sets the group rates of the next 200 training steps, and the next checkpoint repeats the checkpoint evaluation.

Simulation, hardware, and full-run validation

The tables of N=81N=81, 128, and 256 profiles, the noise-free simulation of the search and the trial design are given in Appendix E, and a 16-profile instance of the checkpoint-200 table is run on an IBM Heron r2 device to check the action of the oracle and the diffuser (validation and clocks in Appendix D). A search returns its threshold row as the selected profile of its checkpoint, the estimate of zt∗z_t^* over the nseln_{\mathrm{sel}} selection instants t1<⋯<tnselt_1<\cdots<t_{n_{\mathrm{sel}}}, the minimizers form the series Z∗=(zt1∗,…,ztnsel∗)Z^*=(z_{t_1}^*,\ldots,z_{t_{n_{\mathrm{sel}}}}^*) and the selected profiles Z^\widehat{Z}. Whether a selected series helps the fine-tuning is checked by training under it: a full run FR(Z∗,seed)\mathrm{FR}(Z^*,\mathrm{seed}) trains the ntrn_{\mathrm{tr}} steps under the uniform-rate baseline zrefz_{\mathrm{ref}} until the first selection instant and under each minimizer until the next,

FR(Z∗,seed):z(t)={zref,t<t1,zti∗,ti≤t<ti+1,i=1,…,nsel,tnsel+1=ntr.(17)\mathrm{FR}(Z^*,\mathrm{seed}):\qquad z(t)=\begin{cases} z_{\mathrm{ref}}, & t<t_1,\\ z_{t_i}^*, & t_i\leq t<t_{i+1},\quad i=1,\ldots,n_{\mathrm{sel}}, \end{cases}\qquad t_{n_{\mathrm{sel}}+1}=n_{\mathrm{tr}}. \tag*{(17)}

and the trained model is compared with the run under zrefz_{\mathrm{ref}} by its held-out loss; the executed runs are recorded in Appendix F. A closed-loop run of Section 2.4 is Eq. (17) with z^ti\hat{z}_{t_i} in place of zti∗z_{t_i}^*, each search simulated noise-free.

Section 3.3 repeats the closed loop with every search sampled on an IBM superconducting device, using the full circuit of § 2.4; Appendix § 15 gives the gate limits of the device and the bound they set on the iteration count.

Results

Selecting a termination criterion from measured score tables

Hardware validation of the lookup oracle and diffuser on a 16-profile instance is reported in Appendix § 8. The measured h=25h = 25 score tables are used to compare the stopping effort and selection quality of criteria A–D and guide the choice of criterion for the subsequent closed-loop searches.

Table 1 compares the four termination criteria on the N=81N = 81 tables, pooled over the five checkpoints. All four spend the same improvement effort and reach comparable selection quality, with a mean regret below the replay drift of order 10−410^{-4} (Appendix § 9). Most Grover iterations go into stopping: 76% (D) to 96% (A) of them come after the last improvement, and criterion A uses about 8.7 times the stopping effort Qstop(x)Q_{\mathrm{stop}}^{(x)} of criterion D. Criteria B and D are therefore the practical choices. B caps the iterations of each visit with a fixed budget that needs only NN; D reads the failed rounds of the visit through the classical confidence update and needs the least stopping effort. This paper selects criterion D for the closed-loop searches; detailed data are in Appendices § 12 and § 7.

criterionrounds R(x)R^{(x)}Qimp(x)Q_{\mathrm{imp}}^{(x)}Qstop(x)Q_{\mathrm{stop}}^{(x)}P(min. found)regret
A global time-out77.38.2±0.18.2 \pm0.1222.2±0.2222.2 \pm0.21.0000
B per-visit budget 3N3\sqrt{N}29.38.1±0.18.1 \pm0.129.4±0.029.4 \pm0.00.9991.9×10−61.9 \times10^{-6}
C confidence count52.28.2±0.18.2 \pm0.1121.3±0.2121.3 \pm0.21.0000
D state-dependent stop28.38.1±0.18.1 \pm0.125.6±0.125.6 \pm0.10.9991.4×10−61.4 \times10^{-6}

Table 1. Search effort and selection quality under four termination criteria (N=81N = 81).

Criteria B and D stop after fewer search rounds while maintaining comparable selection quality. 5,000 simulated trials per criterion, δ=10−3\delta= 10^{-3} for C and D; full table and setting in Appendix § 11.

Closed-loop training with a simulated Interaction-Guided Schedule Oracle

The simulated Interaction-Guided Schedule Oracle drove two closed-loop fine-tunes by selecting joint group-rate schedules at each of five checkpoints. Each selected schedule was applied to the next training interval, and both resulting models achieved benchmark accuracies within the range observed across five uniform-rate seeds. The two runs supply different interaction coefficients to the same Schedule Oracle structure: one takes the checkpoint evaluation on a single training batch, the other averages it over five batches. The single-batch and the averaged evaluation select different schedules (Appendix § 14); comparing the performance of the two is a direction for future research. Table 2 compares the runs with the uniform-rate run of the same seed and start, the range over five uniform-rate seeds and the base model. On every benchmark the two oracle runs differ by at most 0.5 percentage points, the largest difference from the uniform-rate run is 0.7 points (single-batch, MMLU), and the single-batch SciQ score lies at the lower end of the five-seed range. Comparable observed scores from one seed per run do not establish equivalence, better training or a quantum speedup: the searches are noise-free statevector simulations, and no error bar exists for the loss of a single run.

runheld-out loss at stepaccuracy (%)
40060080010001221SciQPubMedQAARC-EasyMMLU
oracle, single batch2.66632.66662.67102.67532.682789.462.162.538.4
oracle, five-batch average2.66612.66302.66142.66822.675889.661.662.938.7
oracle, sampled on IBM hardware2.66962.66542.66452.67312.680689.561.362.538.8
uniform rate, same seed2.66702.66392.66732.67152.679589.861.662.639.1
uniform rate, five seeds (range)89.4–90.660.7–64.761.3–63.337.9–41.1
base model, no fine-tuning89.859.661.737.8

Table 2. Held-out loss and benchmark accuracy of the closed-loop fine-tunes, seed 2.

Closed-loop training with the Interaction-Guided Schedule Oracle on IBM hardware

The loop of § 3.2 was repeated with every search sampled on IBM hardware. The five searches of Table 3 ran on three 156-qubit IBM Heron devices, with one shot per circuit and no simulator sample in any decision; the largest circuit had 4,284,266 two-qubit gates. As on the score tables of § 3.1, most Grover iterations went into stopping: 1,207 of the 1,381 (87%) came after the last improvement of each search. All four benchmark accuracies of the trained model on the All runs start from the same checkpoint at step 200 (held-out loss 2.678). Held-out loss on 64 evaluation sequences; zero-shot accuracy in percent, standard errors about 1.0, 1.5, 1.0 and 1.4 points.

checkpointdevicereturned scheduleΦ\PhiRRQQUUlargest jj
200ibm_fez, ibm_marrakesh(1.4, 0.7, 1.4, 1.4, 0.5, 1.4)4243235654
400ibm_marrakesh(0.7, 0.5, 1.4, 0.7, 1.4, 0.7)6435262356
600ibm_kingston(1.4, 1.4, 0.5, 0.5, 0.7, 0.5)6748307345
800ibm_kingston(0.5, 1.4, 1.0, 1.4, 0.7, 1.0)1855298360
1000ibm_marrakesh(1.0, 0.5, 0.7, 0.7, 1.4, 1.4)549279260

Table 3. Hardware-sampled searches at training checkpoints.

five-seed range (Table 2), under the single-seed qualification of § 3.2. Appendices § 15 and § 16 give the device limits, the threshold paths and the IBM turnaround.

One search per checkpoint. Returned schedule from the first layer group to the last; Φ\Phi, final integer interaction score; RR, rounds; QQ, Grover iterations; UU, threshold updates; largest jj, the most Grover iterations in one circuit.

Summary, Discussion and Limitations

Quantum minimum finding was joined to language-model fine-tuning in two parts: a study of termination criteria, and the Interaction-Guided Schedule Oracle. On a lookup oracle over measured score tables, four termination criteria select with comparable quality and differ in stopping effort. The Interaction-Guided Schedule Oracle scores all joint schedules in superposition without a pre-computed score table; its selected schedules drove three closed-loop fine-tunes, one sampled on IBM hardware, with benchmark accuracies within the range of uniform-rate seeds.1 Together, these studies demonstrate how classical checkpoint measurements can support quantum selection of joint learning-rate schedules within a language-model training loop.

Three directions follow. First, the interaction score can be exchanged while the quantum search is kept. The two simulated runs used single-batch and five-batch checkpoint evaluations to supply different interaction coefficients to the same quantum scoring and marking structure (Appendix J). As with the kernel of a support vector machine [8], studies of dynamic learning-rate control can supply coefficients for other groupings, rate menus, models or training phases. Measurements can also be added where evaluations disagree, as in active learning [7] or the reweighting of boosting [11]. The score compiled into the circuit offers an interface for quantum neural-network research.

Second, quantum selection can refine a baseline schedule zbasez_{\mathrm{base}} proposed by a classical adaptive method, such as population-based training (Jaderberg et al., 2017) or hypergradient descent [3]. With the checkpoint evaluation taken around zbasez_{\mathrm{base}}, the interaction score keeps the form of Eq. (15):

Y^t(z∣zbase)=∑g=1GYt(g;ηg)+∑g<g′νt,gg′(ηg,ηg′)+∑g<g′<g′′νt,gg′g′′(ηg,ηg′,ηg′′),(18)\widehat{Y}_t(z \mid z_{\mathrm{base}}) = \sum_{g=1}^{G} Y_t(g;\eta_g) + \sum_{g<g'} \nu_{t,gg'}(\eta_g,\eta_{g'}) + \sum_{g<g'<g''} \nu_{t,gg'g''}(\eta_g,\eta_{g'},\eta_{g''}), \tag*{(18)}

where every gain and interaction is measured around zbasez_{\mathrm{base}} and vanishes when one of its groups stays at its baseline rate. The baseline scores zero and is the first threshold, so the search looks for joint refinements beyond it. The present runs use zbase=zrefz_{\mathrm{base}} = z_{\mathrm{ref}}; other baselines will be studied in future research (Appendix § 14).

Third, stopping-policy design is a route to quantum-search efficiency. Most Grover iterations came after the last improvement in both the IBM hardware searches and the lookup-oracle study. In that study, criterion A used about 8.7 times the stopping effort of criterion D. Criteria B and D are practical choices, and D is used here. Deciding when enough search has been done can avoid unnecessary rounds and use quantum resources more effectively.

This paper presents an early-stage architecture that integrates quantum learning-rate selection with classical machine learning. Any practical benefit will depend on advances in quantum hardware and further evaluation. Developing the algorithms and interfaces now provides a foundation for future research in machine learning and medical imaging.

Protocols of the replay-horizon study

To determine the replay horizon, the study measures how well a shorter replay preserves the candidate order obtained after a longer one. Let hmax⁡h_{\max} be the longest horizon replayed, AA a measured subset of the profiles of TableprofTable_{\mathrm{prof}}, and ρS\rho_S the Spearman rank correlation. At checkpoint tt, the rank agreement of horizon hh with hmax⁡h_{\max} is

τt,A(h)=ρS((ft(h)(z))z∈A,(ft(hmax⁡)(z))z∈A),hmax⁡=200.(19)\tau_{t,A}(h)=\rho_S\left(\left(f_t^{(h)}(z)\right)_{z\in A},\left(f_t^{(h_{\max})}(z)\right)_{z\in A}\right), \qquad h_{\max}=200. \tag*{(19)}

Table A1 reports τt,A16(h)\tau_{t,A_{16}}(h) for h∈{1,10,25,50,100,150}h\in\{1,10,25,50,100,150\} at checkpoints t∈{200,600,1000}t\in\{200,600,1000\}, on the same measured subset A16A_{16} of 16 profiles at every horizon and checkpoint.

hh1∗1^{*}101025255050100100150150
t=200t=2000.6970.9090.9940.9940.9770.991
t=600t=6000.6770.9650.9910.9850.9740.824
t=1000t=1000−0.253-0.2530.9910.9790.9820.9770.994

Table A1. Rank agreement τt,A16(h)\tau_{t,A_{16}}(h) of Eq. (19) at three checkpoints tt of a run under the uniform profile (one seed), over the same measured subset A16A_{16} of 16 candidate profiles.

The one-step ranking is unstable across the three checkpoints, whereas every horizon from 10 to 150 agrees far more strongly with the 200-step order. The literature reports the same disagreement between one step and the long run: short-horizon meta-objectives are biased toward small step sizes (Wu et al., 2018), one-step gains are overtaken by a constant rate in the long term (Roulet et al., 2024), and a schedule search that probes each candidate over a short window fixes that window as a design constant (Jin et al., 2021).

At checkpoints 200 and 600, measured before any TablescoreTable_{\mathrm{score}} of this paper was built, h=25h=25 is the shortest horizon at which τt,A16(h)\tau_{t,A_{16}}(h) reaches its maximum; the later replay at checkpoint 1000 agrees with the 200-step order above 0.97 at every horizon from 10 to 150, and the setting was kept. Table A1 was measured on one run under the uniform profile, on the same 16 candidate profiles at every horizon and checkpoint. For h≥10h\geq10, each profile was replayed for 200 optimizer steps from the saved model and optimizer state of the checkpoint, on the same sequence of training batches, and the held-out evaluation loss was recorded at the marks h∈{10,25,50,100,150,200}h\in\{10,25,50,100,150,200\}; the five entries of a row at h≥10h\geq10 therefore come from one replay per profile, each compared with the 200-step mark of the same replay. The h=1h=1 entry follows a different protocol: one optimizer step under each profile, scored on the two held-out sequences of the scoring batch rather than on the held-out evaluation set. Its value enters Table A1 for its rank only; the same one-step protocol, on a different design of rows, gives the checkpoint evaluation of § 2.4.

Criteria A–D from the cited bounds

Criterion A. Criterion A, Eq. (10), is the interrupt of the minimum-finding algorithm of Dürr & Høyer [9] written in the two counts that a run of this paper records. The convention of that paper charges one time step per Grover iteration of the exponential search and lg⁡N\lg N time steps per execution of the initialization stage, which prepares the uniform state over the NN rows and marks the rows below the current threshold; that stage runs once per threshold visit, and the observation and the threshold update are not counted. A run that has used QQ Grover iterations over VV threshold visits, the initial one included, has therefore used Q+Vlg⁡NQ+V\lg N time steps under that convention, the left side of Eq. (10).

The right side is the interrupt of Dürr & Høyer [9], twice the bound of Lemma 2 of that paper on the expected total time before the threshold holds the minimum, m0=454N+710lg⁡2Nm_0=\frac{45}{4}\sqrt{N}+\frac{7}{10}\lg^2N. The first term bounds the expected number of Grover iterations, Eq. (7). The second term is the initialization cost: by Lemma 1 of the same paper the row of rank rr is ever chosen as the threshold with probability 1/r1/r, so the expected number of threshold updates is ∑r=2N1/r=HN−1\sum_{r=2}^{N}1/r=H_N-1, with HNH_N the NNth harmonic number, and the expected initialization time is at most (HN−1)lg⁡N≤(ln⁡N)lg⁡N=(ln⁡2)lg⁡2N≤710lg⁡2N(H_N-1)\lg N\leq(\ln N)\lg N=(\ln2)\lg^2N\leq\frac{7}{10}\lg^2N. Stopping at 2m0=22.5N+1.4lg⁡2N2m_0=22.5\sqrt{N}+1.4\lg^2N returns the minimum with probability at least 12\frac{1}{2} (Theorem 1 of the same paper).

Criterion B. Criterion B, Eq. (11), limits one threshold visit. Within the current visit the iteration counts jj accumulate across rounds; when the visit has spent the budget that the proof of Theorem 3 in Boyer et al. [4] assigns to one exponential search, 126λ−1N\frac{1}{2}\frac{6}{\lambda-1}\sqrt{N}, without finding a better profile, the run stops and returns the threshold. At λ=65\lambda=\frac{6}{5} the budget is 3N3\sqrt{N}, and it restarts at every threshold update.

Criterion C. Criterion C, Eq. (12), counts failed rounds after the range of Eq. (6) has reached its cap mBBHT=Nm_{\mathrm{BBHT}}=\sqrt{N}, where jj is drawn uniformly from {0,…,⌈N⌉−1}\{0,\ldots,\lceil\sqrt{N}\rceil-1\}. For MM marked rows and jj uniform on {0,…,m−1}\{0,\ldots,m-1\}, Boyer et al. (1998, Lemma 2) give the probability that one round returns a marked row as Pm=12−sin⁡(4mθ)4msin⁡2θP_m=\frac{1}{2}-\frac{\sin(4m\theta)}{4m\sin2\theta} with sin⁡2θ=M/N\sin^2\theta=M/N, and show Pm≥14P_m\geq\frac{1}{4} whenever m≥1/sin⁡2θm\geq1/\sin2\theta. Since sin⁡2θ=2M(N−M)/N\sin2\theta=2\sqrt{M(N-M)}/N, the condition at m=Nm=\sqrt{N} reads 4M(N−M)≥N4M(N-M)\geq N; the product M(N−M)M(N-M) is smallest at M=1M=1 and M=N−1M=N-1, where the condition becomes 4(N−1)≥N4(N-1)\geq N, so it holds for every 1≤M≤N−11\leq M\leq N-1 once N≥2N\geq2, and m=⌈N⌉≥Nm=\lceil\sqrt{N}\rceil\geq\sqrt{N} satisfies it a fortiori. The threshold row is never marked, so M≤N−1M\leq N-1 in every visit, and at M=0M=0 every round fails. Within one visit the threshold, and with it MM, is fixed; each round prepares the uniform state afresh, draws its own jj and measures once, so the saturated rounds of a visit are independent trials with failure probability 1−Pm≤341-P_m\leq\frac{3}{4} whenever M≥1M\geq1. The probability that kk consecutive saturated rounds all fail while a better row exists is therefore at most (3/4)k(3/4)^k, and kstop(δ)=⌈ln⁡δ/ln⁡(3/4)⌉k_{\mathrm{stop}}(\delta)=\lceil\ln\delta/\ln(3/4)\rceil is the smallest kk with (3/4)k≤δ(3/4)^k\leq\delta: 1717, 2525 and 3333 for δ=10−2\delta=10^{-2}, 10−310^{-3} and 10−410^{-4}. The bound holds for every M≥1M\geq1 and every visit, and it bounds the event that a visit with a better row present ends without finding one; a probability over MM itself requires a prior, which criterion D supplies. Rounds before saturation do not enter the count, and the count restarts at every threshold update.

Criterion D. Criterion D, Eq. (13), keeps a distribution over the rank rr of the current threshold in Tablescore_{\mathrm{score}}, rank 1 being the lowest score, and updates it from the outcome and the iteration count jj of each round. The first threshold is a row chosen uniformly at random, step 1 of Dürr & Høyer [9], so its rank is uniform, π0(r)=1/N\pi_0(r)=1/N. A threshold of rank rr has exactly r−1r-1 rows below it, M=r−1M=r-1, so a round with jj iterations fails with probability 1−pj(r−1)1-p_j(r-1) by Eq. (5); a failed round multiplies π(r)\pi(r) by this likelihood, which is Bayes’ rule for that observation, and the factor equals one at r=1r=1 because pj(0)=0p_j(0)=0. After jj iterations from the uniform state the MM marked rows carry one common amplitude sin⁡((2j+1)θ)/M\sin((2j+1)\theta)/\sqrt{M} (Boyer et al., 1998, Eq. (3)), so a successful round from rank ss returns each of the s−1s-1 better rows with probability 1/(s−1)1/(s-1), whatever jj was [9 proof of Lemma 1], and the new rank is uniform on {1,…,s−1}\{1,\ldots,s-1\}. Summing this transition over the old ranks s>rs>r gives the success map πu+1(r)∝∑s>rπu(s)/(s−1)\pi_{u+1}(r)\propto\sum_{s>r}\pi_u(s)/(s-1), applied to the distribution πu\pi_u held at the start of the visit, so πu\pi_u is the rank distribution of the uu-th threshold in the descent of Dürr & Høyer [9] from the uniform start and depends on no jj. The failed rounds of the current visit multiply πu\pi_u in turn, and cπc_\pi restores total mass one after every update; at a success cπ=∑s≥2πu(s)c_\pi= \sum_{s \ge2} \pi_u(s), the mass on the ranks from which a success is possible. The mass on ranks r≥2r \ge2 is the probability, given the number of threshold updates so far and the failed rounds of the current visit, that at least one row of Tablescore\mathit{Table}_{\mathrm{score}} lies below the current threshold; the run stops when this mass is at most δ\delta and returns the threshold.

Cost accounting from the cited analysis

The three clocks. Figure 1 separates each search round into state preparation and measurement, Grover iterations, and a classical check. Summed over R(x)R^{(x)} rounds and Q(x)Q^{(x)} Grover iterations, one quantum selection takes

Tsel(x)=Q(x)titer+R(x)tsetup+R(x)tchk.(20)T_{\mathrm{sel}}^{(x)} = Q^{(x)}t_{\mathrm{iter}} + R^{(x)}t_{\mathrm{setup}} + R^{(x)}t_{\mathrm{chk}}. \tag*{(20)}

Here titert_{\mathrm{iter}} is the time of one Grover iteration, tsetupt_{\mathrm{setup}} the device time for one state preparation and measurement, and tchkt_{\mathrm{chk}} the time of one classical check.

Training totals. With the termination criteria defined, the training cost separates into the ordinary training time TCT_C of Eq. (1) and the cost of the nseln_{\mathrm{sel}} profile selections made during the run. At each selection, exhaustive classical search evaluates all NN profiles at a check time tchkt_{\mathrm{chk}} each, costing N tchkN\,t_{\mathrm{chk}}, whereas quantum minimum finding incurs a selection time Tsel(x)T_{\mathrm{sel}}^{(x)} that depends on the termination criterion x∈{A,B,C,D}x \in\{\mathrm{A}, \mathrm{B}, \mathrm{C}, \mathrm{D}\}. The two total costs are therefore

TCexh=TC+nselN tchk,TQ(x)=TC+nselTsel(x).(21)T_C^{\mathrm{exh}} = T_C + n_{\mathrm{sel}}N\,t_{\mathrm{chk}}, \qquad T_Q^{(x)} = T_C + n_{\mathrm{sel}}T_{\mathrm{sel}}^{(x)}. \tag*{(21)}

Thus, the simulations compare TCexhT_C^{\mathrm{exh}} with TQ(x)T_Q^{(x)}, with the difference determined by the per-selection cost N tchkN\,t_{\mathrm{chk}} versus Tsel(x)T_{\mathrm{sel}}^{(x)}.

Cost convention. In the simulation, the classical work used to construct TablescoreTable_{\mathrm{score}} is not included in the quantum selection time Tsel(x)T_{\mathrm{sel}}^{(x)}. The exhaustive classical selection remains N tchkN\,t_{\mathrm{chk}}, Eq. (21), and the two are compared through the ratio S=N tchk/Tsel(x)S = N\,t_{\mathrm{chk}}/T_{\mathrm{sel}}^{(x)}, priced with equal unit costs or with hardware-informed clocks (below and Appendix § 8).

Counts. Every round of Eq. (6) has one state preparation, jj Grover iterations, and one measurement followed by one classical check, so the number of rounds R(x)R^{(x)} of Eq. (14) equals the number of preparations and the number of checks. The four criteria share the improvement phase on common random numbers (Appendix § 9), so the visits that improve the threshold are the same under every xx in a trial that reaches the minimum and Qimp(x)Q_{\mathrm{imp}}^{(x)} is the same count; a trial that a criterion ends before the minimum truncates it. The number of threshold updates UU is recorded as a diagnostic and never priced: by Dürr & Høyer [9] the element of rank rr becomes the threshold at some point with probability 1/r1/r, so E[U]=HN−1\mathbb{E}[U] = H_N - 1 with HNH_N the NNth harmonic number.

The time convention of the cited analysis. Dürr & Høyer [9] count one time step per Grover iteration and lg⁡N\lg N steps per initialization of a threshold visit, and leave uncounted the stage in which the measured row is compared with the threshold; Criterion A transcribes that convention into Eq. (10) (Appendix § 6). The accounting of Eq. (20) prices that comparison, the classical check, at one tchkt_{\mathrm{chk}} per round, and absorbs the initialization, since every state preparation is one of the R(x)R^{(x)} rounds.

The two ratios. The unit-cost pricing is the convention of query complexity in which the setup, query and checking costs of a search are counted in one unit (Boyer et al., [4]; Jeffery et al., 2013). At titer=tsetup=tchkt_{\mathrm{iter}} = t_{\mathrm{setup}} = t_{\mathrm{chk}} the right-hand side of Eq. (20) is (Q(x)+2R(x)) tchk(Q^{(x)} + 2R^{(x)})\,t_{\mathrm{chk}}, so

Sunit=N tchk(Q(x)+2R(x)) tchk=NQ(x)+2R(x),(22)S_{\mathrm{unit}} = \frac{N\,t_{\mathrm{chk}}}{(Q^{(x)} + 2R^{(x)})\,t_{\mathrm{chk}}} = \frac{N}{Q^{(x)} + 2R^{(x)}}, \tag*{(22)}

a count ratio that holds for any per-row scoring time. Under the hardware-informed pricing the two quantum terms of Eq. (20) are non-negative, so Tsel(x)≥R(x)tchkT_{\mathrm{sel}}^{(x)} \ge R^{(x)}t_{\mathrm{chk}} and

Shw=N tchkTsel(x)≤NR(x),(23)S_{\mathrm{hw}} = \frac{N\,t_{\mathrm{chk}}}{T_{\mathrm{sel}}^{(x)}} \le\frac{N}{R^{(x)}}, \tag*{(23)}

with equality in the limit Q(x)titer+R(x)tsetup≪R(x)tchkQ^{(x)}t_{\mathrm{iter}} + R^{(x)}t_{\mathrm{setup}} \ll R^{(x)}t_{\mathrm{chk}}, the term R(x)tchkR^{(x)}t_{\mathrm{chk}} is the checking cost of Jeffery et al. (2013), the cost of testing whether a returned candidate is marked, which no device clock removes. The hardware-informed pricing follows the literature on the cost of Grover search: Cade et al. [5] quantify Grover speed-ups beyond the asymptotic worst-case analysis; Babbush et al. [2] conclude that a quadratic speedup alone does not give an early fault-tolerant device a runtime advantage; Amy et al. [1] price a quantum computation in units of classical work; and Hoefler et al. (2023) argue that only small-data problems with super-quadratic speedups are useful in practice. Gundlach et al. (2026) list the conditions an end-to-end claim would need in deep learning.

Scope of the timing model. Eq. (20) prices the lookup study, in which one classical check is one replay of h=25h = 25 optimizer steps. A round of the Interaction-Guided Schedule Oracle of § 2.4 also consists of a preparation and measurement, jj Grover iterations and one classical check, but its check is one evaluation of Eq. (27) for the measured schedule rather than a replay, so the clocks of Appendix § 8 do not transfer to it. On hardware the compiled iteration bodies differ in gate count from body to body and from threshold to threshold (Appendix § 15), so titert_{\mathrm{iter}} in Eq. (20) can only be an effective average. The cost of a hardware-sampled selection further contains the checkpoint evaluation of § 2.4, compilation and upload encoding, queueing, every physical execution, including diagnostic shots and circuits submitted but not used by the sequential search, and the training itself; these are accounted per stage in Appendix § 16. No timing comparison is made for the closed-loop runs.

Provenance of the fitted hardware quantities

Grover-iteration decomposition. Figure A1 shows the block decomposition of one Grover iteration. Its scheduled time is

Grover iteration decomposition

Figure A1. Decomposition of one Grover iteration into score computation, threshold marking, score uncomputation, and diffusion. Dashed score blocks denote the declared compute component.

titer(qsrch)=tlayer(q,j)[Ddiff(qsrch,1)+Dmark(qres,1)+2Dcompute](24)t_{\mathrm{iter}}^{(q_{\mathrm{srch}})} = t_{\mathrm{layer}}^{(q,j)} \left[D_{\mathrm{diff}}^{(q_{\mathrm{srch}},1)} + D_{\mathrm{mark}}^{(q_{\mathrm{res}},1)} + 2D_{\mathrm{compute}}\right] \tag*{(24)}

The block timings are estimated from circuits transpiled and scheduled against the calibration of an IBM Heron r2 device. The superscript (q,j)(q,j) records the register size qq and Grover-chain setting jj used for the corresponding compile or fit, with j=1j = 1 denoting a single compiled block. The compilation details and the resulting values follow. The clocks are anchored by one job on the device: the scheduled duration of a circuit is the preparation with its readout plus jj iteration times,

D(j)=t0(4,3)+titer(4,3)j(25)D(j) = t_{0}^{(4,3)} + t_{\mathrm{iter}}^{(4,3)}j \tag*{(25)}

fitted for each threshold, and the job’s executed time gives tsetupt_{\mathrm{setup}}.

Superscripts and bands. Every quantity of Eq. (24) that comes from a compile-and-fit carries a superscript (q,j)(q,j): qq is the register size the circuit was compiled at (qsrchq_{\mathrm{srch}} for the search register, qresq_{\mathrm{res}} for the resolution register) and jj the largest chain length of the fit, a straight line over 1,…,j1,\ldots,j; j=1j = 1 means one block compiled and its depth read directly. A quantity without a superscript is a declared choice or a calibration constant of the device. The layer time is the ratio of the duration slope to the depth slope of the scheduled circuits, a compiler statistic of the layer mix bounded by the gate durations of the device, so it does not scale with circuit size. Each fitted depth and the layer time carry a band, the minimum and maximum over three transpiler seeds and two calibration snapshots around the mean. The setup clock is the executed wall-clock of one round of the job per shot less its iteration content, so it contains the preparation circuit, the readout and the device’s inter-shot reset delay. Compiling the diffuser and the comparator as one circuit is the cross-check of the model form; its depth exceeds the sum of the two blocks by the routing the compiler adds. The break-even of the estimate is the depth DcomputeD_{\mathrm{compute}} at which the share of the two quantum terms of Eq. (20) in Tshw(x)T_{\mathrm{shw}}^{(x)} reaches a given value; below it, ShwS_{\mathrm{hw}} of Eq. (23) sits at its floor.

The hardware job. The job ran on ibm marrakesh: seven circuits (the prepared state alone, and j=1,2,3j = 1, 2, 3 iterations for two thresholds that mark 4 and 1 of the 16 rows), 4,096 shots each, transpiled at optimization level 3 and scheduled against the device calibration of the day (median two-qubit gate 68 ns, single-qubit gate 36 ns, readout 2.68 μ\mus). Eq. (25) is fitted separately for the two thresholds, since the depth of a lookup oracle depends on which rows it marks; the slope is the iteration time at this size and the intercept t0(4,3)t_{0}^{(4,3)} the preparation with its readout. The same circuits are scheduled again against a later calibration to check the slopes, and the job’s own execution metric, the QPU time over all shots, gives the executed cost of one round including reset and repetition delay, from which tsetupt_{\mathrm{setup}} is taken. These four-qubit circuits use a lookup oracle, a diagonal phase over the 16 stored scores, whose depth grows with NN; the job validates the layer time, the diffuser depth at qsrch=4q_{\mathrm{srch}} = 4 and the additivity of iterations, and says nothing about DcomputeD_{\mathrm{compute}}.

Validation of the oracle action. Run on the device and in the noise-free simulation, the oracle and the diffuser of these circuits act as designed on a 16-profile instance of the checkpoint-200 table. With four profiles marked, one iteration raises the probability of a marked profile from 0.25 to 0.85 on the device, against 1.00 in the simulation. With the minimizer alone marked, three iterations raise its probability from 0.07 to 0.63 on the device, against 0.96 in the simulation; the deeper the circuit, the wider the gap, so depth is the quantity a future circuit has to keep in hand.

quantitywhat it ishow obtainedvalue (band)
tlayer(4..9,3)t_{\mathrm{layer}}^{(4..9,3)}layer timemedian of titer(q,3)/Diter(q,3)t_{\mathrm{iter}}^{(q,3)} / D_{\mathrm{iter}}^{(q,3)} over 34 schedules, qsrch=4q_{\mathrm{srch}} = 4 to 9, two oracle families, three seeds, two back-ends33 ns (29–37)
titer(4,3)t_{\mathrm{iter}}^{(4,3)}, t0(4,3)t_{0}^{(4,3)}one lookup iteration; preparation + readout at qsrch=4q_{\mathrm{srch}} = 4slope and intercept of Eq. (25) over j=1,2,3j = 1, 2, 3; executed job2.56 / 5.16 μ\mus; 2.7 μ\mus
Ddiff(18,1)D_{\mathrm{diff}}^{(18,1)}diffuser depth, search registerone block compiled at qsrch=18q_{\mathrm{srch}} = 18; mean over three seeds, two back-ends730 layers (706–747)
Dmark(16,1)D_{\mathrm{mark}}^{(16,1)}comparator depth, resolution registerone block compiled at qres=16q_{\mathrm{res}} = 16; same statistic942 layers (896–969)
Dblock(18,16;1)D_{\mathrm{block}}^{(18,16;1)}diffuser and comparator compiled as one circuitone block, 65 qubits; same statistic; cross-check only2,057 layers (1,986 to 2,187); 68 μ\mus (66 to 73)
DcomputeD_{\mathrm{compute}}coherent evaluation of the replay score f(z)f(z)no circuit is built for itdeclared; break-even under “The clocks as measured.” below
qresq_{\mathrm{res}}resolution register width≥log⁡2(range/σ)\ge\log_{2}(\mathrm{range}/\sigma) with range 4, σ=0.0017\sigma= 0.001716 (derived ≈12\approx12)
tsetupt_{\mathrm{setup}}one round’s executed wall-clock less its iterations276.2−6.6 μ276.2 - 6.6\ \mus from the job metric270 μ\mus
tchkt_{\mathrm{chk}}one classical checkmedian of 389 timed h=25h = 25 replays355.5 s (10th–90th pct. 354.4 to 357.0)

Table A2.

The clocks as measured. Table A2 summarizes the three clocks of Eq. (20). The layer time of Eq. (24) is tlayer(4..9,3)=33t_{\mathrm{layer}}^{(4..9,3)} = 33 ns, the median of 34 schedules from qsrch=4q_{\mathrm{srch}} = 4 to 9, stable at 33±433 \pm4 ns across register sizes and constant in jj; the two oracle families of the executed job give 31.8 and 34.5 ns. The two known depths at the design size are Ddiff(18,1)=730D_{\mathrm{diff}}^{(18,1)} = 730 layers (706–747) and Dmark(16,1)=942D_{\mathrm{mark}}^{(16,1)} = 942 layers (896–969), a known part of 1,672 layers, so

titer(18)=55 μs (53–57)+66 ns×Dcompute.t_{\mathrm{iter}}^{(18)} = 55\ \mu\mathrm{s}\ (53\text{--}57) + 66\ \mathrm{ns} \times D_{\mathrm{compute}}.

Compiling the two blocks as one circuit gives 2,057 layers and 68 μ\mus, about 20% of routing depth above the model form, which remains the printed number. The resolution register follows from a loss range of 4 and a seed-to-seed standard deviation of 0.0017 along the reference run, log⁡2(4/0.0017)≈12\log_{2}(4/0.0017) \approx12 bits, and qres=16q_{\mathrm{res}} = 16 is the margin above it. The executed job gives the slopes of Eq. (25) as titer(4,3)=2.56 μt_{\mathrm{iter}}^{(4,3)} = 2.56\ \mus for the threshold that marks 4 of the 16 rows and 5.16 μ\mus for the one that marks 1, with intercepts t0(4,3)=2.7t_{0}^{(4,3)} = 2.7 to 3.1 μ\mus dominated by readout; scheduled again against a later calibration, the slopes reproduce within about 5%. The setup clock is tsetup(4,3)=270 μt_{\mathrm{setup}}^{(4,3)} = 270\ \mus: the job’s 28,672 shots took 7.92 s of QPU time, 276 μ\mus per shot, less the 6.6 μ\mus per shot, less the 6.6 μ\mus per shot, so the iteration content pooled over its seven circuits; the preparation circuit’s own share is t0(4,3)t_{0}^{(4,3)} and the rest is the device’s inter-shot reset delay, a backend setting taken as independent of the circuit. One classical check costs tchk=355.5t_{\mathrm{chk}} = 355.5 s, the median of 389 timed replays (10th to 90th percentile 354.4 to 357.0 s); a later campaign of the same replay gave 336.6 s, and the slower value is used. One replay restores the checkpoint with its optimizer state and then runs h ttr=25×12.4h\,t_{\mathrm{tr}} = 25 \times12.4 s =310= 310 s of optimizer steps. With these clocks and the counts at N=218N = 2^{18} of Appendix H, the classical checks of one selection take R(D) tchk=70,000R^{(\mathrm{D})}\,t_{\mathrm{chk}} = 70{,}000 s, 19.5 h, and the two quantum terms of Eq. (20) total less than 0.4 s when Dcompute=0D_{\mathrm{compute}} = 0. The share of the two terms reaches 1% only if DcomputeD_{\mathrm{compute}} exceeds about 10610^6 layers at the Heron clock, or about 10410^4 layers at a hypothetical fault-tolerant layer of 7.7 μ\mus, seven cycles of a distance-7 surface code at the 1.1 μ\mus cycle of Google Quantum AI and Collaborators (2025); below that, ShwS_{\mathrm{hw}} of Eq. (23) sits at its floor N/R(x)N/R^{(x)}. At the measured sizes N≤256N \le256 the two quantum terms total less than 0.1 s against R(x)tchkR^{(x)}t_{\mathrm{chk}} of 2.8 to 4.1 h, so the choice of clock changes no measured row; it matters only for the continuation to large NN.

clockvalue (as printed)how obtainedsourceliterature comparison
titer(18)t_{\mathrm{iter}}^{(18)}, one Grover iteration at the design size55 μs55\ \mu\mathrm{s} (53(53–57)57) +66 ns×Dcompute+ 66\ \mathrm{ns} \times D_{\mathrm{compute}}Eq. (24): tlayer=33t_{\mathrm{layer}} = 33 ns, median of 34 compiled schedules (qsrch=4q_{\mathrm{srch}} = 4 to 9; the executed qsrch=4q_{\mathrm{srch}} = 4 job gives 31.8 and 34.5 ns) ×[Ddiff(18,1)=730\times[D_{\mathrm{diff}}^{(18,1)} = 730 (706–747) +Dmark(16,1)=942+ D_{\mathrm{mark}}^{(16,1)} = 942 (896–969)] =1,672= 1{,}672 layers (1,602–1,716), bands over 3 seeds ×\times 2 calibration snapshots; DcomputeD_{\mathrm{compute}} declaredcompiled schedules (this work); App. part AIonQ Forte MS two-qubit gate median 672 μ\mus vs Heron cz 68 ns: about 104×10^4\times slower per two-qubit gate [6]; Willow surface-code cycle 1.1 μ\mus, a logical layer ≈d\approx d cycles (Google Quantum AI and Collaborators, 2025)
tsetup(4,3)t_{\mathrm{setup}}^{(4,3)}, one state preparation + measurement270 μ\mustshot(4,3)t_{\mathrm{shot}}^{(4,3)} − pooled iteration content =276.2−6.6=269.6 μs→270= 276.2 - 6.6 = 269.6\ \mu\mathrm{s} \to270; tshot(4,3)=Texec/shots=7.920t_{\mathrm{shot}}^{(4,3)} = T_{\mathrm{exec}}/\mathrm{shots} = 7.920 s/28,672, one total over the seven circuits (j=0…3j = 0 \ldots3, both families); circuit share t0(4,3)=2.7t_0^{(4,3)} = 2.7–3.1 μ\mus, the rest is the backend’s inter-shot repetition delay (configured 250 μ\mus)job metrics; backend configurationThe cited AES cost model expresses runtime through circuit depth and cycle time, with no setup term (Sarah D., 2024)
tchkt_{\mathrm{chk}}, classical check355.5 s (336.6 s later population)median gap between consecutive h=25h = 25 replay files (restore + 25 steps + evaluation + save): 389 gaps of one replay session, p10–p90 354.4–357.0 s, the slower population printed; later replays: 336.6 s; a GPU clock, never averagedtraining-run replay timing (this work)— (own workload; Eq. (21) N tchkN\,t_{\mathrm{chk}}, Eq. (20) R(x)tchkR^{(x)}t_{\mathrm{chk}})

Table A2 (PDF p. 20). The three clocks of one selection, Eq. (20): the value as printed, how it was obtained, its source, and a literature comparison. titert_{\mathrm{iter}} follows Eq. (24) with DcomputeD_{\mathrm{compute}} declared; tsetupt_{\mathrm{setup}} is taken from the executed job described above; tchkt_{\mathrm{chk}} is a GPU clock. The compile-and-fit quantities behind the first row are listed in the provenance table above.

Experimental and implementation details

Figure A2. TableprofTable_{\mathrm{prof}} mapped to the quantum search register, at an illustrative size (K=2K = 2 admissible rates ηg∈E\eta_g \in\mathcal{E}, G=3G = 3 groups, N=8N = 8 rows, qsrch=3q_{\mathrm{srch}} = 3 qubits). Each row of TableprofTable_{\mathrm{prof}} is one profile zz of Eq. (3), and its row index written in binary is the basis state ∣z⟩\lvert z\rangle of the register; every row enters the search with the same amplitude, the state ∣ψ0⟩\lvert\psi_0\rangle of Eq. (4). The right-hand column shows the amplitudes after the oracle has flipped the sign of the selected rows.

The tables. Figure A4 summarizes the experimental setup: the reference run and its five checkpoints, the tables of N=81N = 81, 128 and 256 rows drawn from the measured cube, and the 25-step replay that scores every row, so nsel=5n_{\mathrm{sel}} = 5. The model, training, table-construction and replay details are given below.

Figure A4. Construction of the score tables: fixed designs of N=81N = 81, 128128 and 256256 profiles from the measured five-level cube, scored at the five checkpoints of the uniform-rate run by the 25-step replay of Eq. (8).

The search. The search runs in a noise-free statevector simulation; Figure A5 shows the trial design. The declared-rule cross-check run supports criterion D: validated at the three measured sizes (Appendix § 12), it carries the rule to larger NN. State preparation, simulation versions, the oracle implementation, the rank bookkeeping and the cross-check run are given below.

Figure A5. Trial design: the four criteria run on shared seeds at every checkpoint; the cross-check run supports criterion D.

Model and training configuration. The model is DeepSeek-R1-Distill-Qwen-1.5B (28 transformer layers), fine-tuned with LoRA adapters of rank 16 on every attention and MLP projection, on the peS2o scientific-text corpus, with AdamW and 16,384 tokens per optimizer step on one NVIDIA RTX 5050 GPU (8 GB). The layers form G=6G = 6 groups of five (three in the last).

The reference run trains the uniform profile ηg=5×10−4\eta_g = 5 \times10^{-4} for all gg, and its checkpoints at steps t∈{200,400,600,800,1000}t \in\{200, 400, 600, 800, 1000\} are the five tables’ origins, so nsel=5n_{\mathrm{sel}} = 5.

Profile-table construction. The design table of Sections 2.1–2.3 and Appendix D has K=8K = 8 admissible rates, N=86=218=262,144N = 8^6 = 2^{18} = 262{,}144 rows and qsrch=18q_{\mathrm{srch}} = 18, with a resolution register of qres=16q_{\mathrm{res}} = 16 qubits for the score; the measured eta space is the K=5K = 5 subset E={0.5,0.7,1.0,1.4,2.0}×5×10−4\mathcal{E} = \{0.5, 0.7, 1.0, 1.4, 2.0\} \times5 \times10^{-4}, 56=15,6255^6 = 15{,}625 rows, from which tables of N=81N = 81, 128128 and 256256 rows are drawn by fixed designs (anchor profiles, two orthogonal arrays, a random set, and stride grids); the row lists are part of the data record. A profile is written by its levels, z=⟨k1k2k3k4k5k6⟩z = \langle k_1k_2k_3k_4k_5k_6\rangle with group gg at rate η(kg)\eta^{(k_g)}; the uniform-rate baseline zrefz_{\mathrm{ref}} is ⟨333333⟩\langle333333\rangle.

Replay and checkpoint protocol. At each checkpoint every row is scored by Eq. (8): 25 optimizer steps replayed from the frozen checkpoint under the row’s profile, with the same batch sequence and a cloned optimizer state for every row. Replaying the uniform profile itself from the checkpoint at step 200 reproduces the logged loss of the reference run exactly at the restart step; over the following 49 steps the replay drifts by 1.9×10−41.9 \times10^{-4} in loss on average, and the evaluation at step 50 of the replay lands within 1.7×10−41.7 \times10^{-4} of the logged value. On the h=25h = 25 tables of Figure A4, the resolution of the score is the drift of the replay itself, of order 10−410^{-4} in loss. Along the run, the score tables of adjacent checkpoints have a rank agreement of 0.919 on the 81 profiles (the mean Spearman correlation of the four adjacent pairs), so the candidate order changes slowly as training proceeds.

Quantum simulation configuration. The search runs in Qiskit 2.4.2 with Qiskit Aer 0.17.2 (state-vector method), noise-free. For N=128N = 128 and 256 the uniform state over the rows is H⊗qsrchH^{\otimes q_{\mathrm{srch}}} on the qsrch=log⁡2Nq_{\mathrm{srch}} = \log_2 N qubits of the search register and the diffuser is the standard reflection; for N=81N = 81 the uniform state over the 81 valid rows is prepared by a dense Householder unitary with the matching reflection, so no padding state is ever marked or measured. The oracle is a diagonal phase over TablescoreTable_{\mathrm{score}}, thresholded at the score f(y)f(y) of the current threshold row. Trial seeds are shared across criteria (common random numbers), so the four criteria share the visits that improve the threshold and differ only in the terminal visit, a paired comparison. Ranks are attached after each trial for evaluation only and are never read by the run. The seed-stability check of Appendix § 13 uses four further disjoint seed blocks of 1,000 trials. The declared-rule cross-check run replays criterion D, with δ\delta and λ\lambda unchanged, on ranks alone: the rank rr of the initial threshold is drawn uniformly from 1 to NN, a round with jj iterations succeeds with the analytic probability of Eq. (5) at M=r−1M = r - 1 rows below the threshold, and a success moves the threshold to a rank drawn uniformly below the old one; no score table and no circuit enter. It is run at N=81N = 81, 128 and 256 against the simulations (Appendix § 12) and then continued to larger NN.

Recorded outcome of the executed full runs

Every run of this section is a full run of Eq. (17), ntr=1,221n_{\mathrm{tr}} = 1{,}221 steps under the setup of § 2.5, either under a series Z∗Z^{*} (table) of § 2.5, whose members are the minimizers of one table at the five selection instants, or under one profile held from the first step; the seed fixes the adapter initialization and the batch order, and FR(z,seed)\mathrm{FR}(z,\mathrm{seed}) denotes the run that holds one profile zz from the first step. The series executed are Z∗(table 81)=(⟨131111⟩,⟨111111⟩,⟨111111⟩,⟨111111⟩,⟨111111⟩)Z^{*}(\text{table 81}) = (\langle131111\rangle,\langle111111\rangle,\langle111111\rangle,\langle111111\rangle,\langle111111\rangle), Z∗(table 128)=(⟨211221⟩,⟨111112⟩,⟨111111⟩,⟨111111⟩,⟨111112⟩)Z^{*}(\text{table 128}) = (\langle211221\rangle,\langle111112\rangle,\langle111111\rangle,\langle111111\rangle,\langle111112\rangle) and Z∗(table 256)=(⟨112111⟩,⟨111112⟩,⟨111111⟩,⟨111111⟩,⟨111112⟩)Z^{*}(\text{table 256}) = (\langle112111\rangle,\langle111112\rangle,\langle111111\rangle,\langle111111\rangle,\langle111112\rangle); every member of a series was also trained as a constant profile. The series were measured on the checkpoints of one uniform run, so in a series run every member after the first acts on a state it was not selected on: the loop is open, and the tables record an outcome, not a winner.

Each run is read by its held-out evaluation loss ℓ(FR,tstep)\ell(\mathrm{FR},t_{\mathrm{step}}), the mean cross-entropy over a fixed set of 64 held-out sequences of 1,024 tokens, written at tstep∈{0,50,…,1200,1221}t_{\mathrm{step}} \in\{0,50,\ldots,1200,1221\}, and compared at equal steps with the mean ℓˉ(tstep)\bar{\ell}(t_{\mathrm{step}}) of the uniform runs FR(⟨333333⟩,seed)\mathrm{FR}(\langle333333\rangle,\mathrm{seed}) over the reference seeds. The statistic is the step-matched excess loss and its mean over the tail window W={800,850,…,1200,1221}\mathcal{W} = \{800,850,\ldots,1200,1221\} of the last ten evaluations,

Δ(FR,tstep)=ℓ(FR,tstep)−ℓˉ(tstep),Δ‾(FR)=1∣W∣∑tstep∈WΔ(FR,tstep),\Delta(\mathrm{FR},t_{\mathrm{step}})=\ell(\mathrm{FR},t_{\mathrm{step}})-\bar{\ell}(t_{\mathrm{step}}),\qquad\overline{\Delta}(\mathrm{FR})=\frac{1}{|\mathcal{W}|}\sum_{t_{\mathrm{step}}\in\mathcal{W}}\Delta(\mathrm{FR},t_{\mathrm{step}}),

together with n−n_{-}, the number of evaluations in W\mathcal{W} at which the run lies below the reference. The reference is the mean of the five uniform runs, seeds 0 to 4; each uniform run is scored leave-one-out, against the mean of the other four, and the five uniform rows give the seed-to-seed scale of Δ‾\overline{\Delta}. The uniform run of seed 2 is the run whose checkpoints are the origin of the tables. The second table compares each series run with runs of its own seed, ℓ(FRa,tstep)−ℓ(FRb,tstep)\ell(\mathrm{FR}_{a},t_{\mathrm{step}})-\ell(\mathrm{FR}_{b},t_{\mathrm{step}}) averaged over W\mathcal{W}: against the uniform run of that seed, and against each of its members held from the first step.

The last column of the first table is a consistency check on public question-answering sets, run zero-shot with the EleutherAI evaluation harness on the saved adapter of each run (SciQ, 1,000 questions; PubMedQA, 1,000; ARC-Easy, 2,376). A run is flagged when its accuracy on any of the three falls below the lowest accuracy of the uniform runs by more than two standard errors of that accuracy. This is a screening rule fixed before the runs, not a hypothesis test at a stated level: the band minimum is itself the lowest of a few noisy scores, every run is checked on three sets, and the seed-to-seed spread of an accuracy is of the same size as its question-sampling standard error. A test at a stated level would need of the order of eight seeds per profile on the noisiest set and is left to later work. No run is flagged.

runtail-mean excess lossevaluations below referencefinal evaluation lossbenchmark flag
FR(⟨333333⟩, seed 0)FR(\langle333333\rangle, \text{ seed } 0)−0.00116 of 102.6842no
FR(⟨333333⟩, seed 1)FR(\langle333333\rangle, \text{ seed } 1)+0.00064 of 102.6798no
FR(⟨333333⟩, seed 2)FR(\langle333333\rangle, \text{ seed } 2)−0.00138 of 102.6795no
FR(⟨333333⟩, seed 3)FR(\langle333333\rangle, \text{ seed } 3)+0.00162 of 102.6831no
FR(⟨333333⟩, seed 4)FR(\langle333333\rangle, \text{ seed } 4)+0.00016 of 102.6809no
FR(⟨232231⟩, seed 0)FR(\langle232231\rangle, \text{ seed } 0)−0.007410 of 102.6721no
FR(⟨212222⟩, seed 0)FR(\langle212222\rangle, \text{ seed } 0)−0.013010 of 102.6634no
FR(⟨212222⟩, seed 1)FR(\langle212222\rangle, \text{ seed } 1)−0.013510 of 102.6641no
FR(⟨131111⟩, seed 0)FR(\langle131111\rangle, \text{ seed } 0)−0.012310 of 102.6632no
FR(⟨131111⟩, seed 1)FR(\langle131111\rangle, \text{ seed } 1)−0.014010 of 102.6626no
FR(⟨211221⟩, seed 0)FR(\langle211221\rangle, \text{ seed } 0)−0.014110 of 102.6612no
FR(⟨211221⟩, seed 1)FR(\langle211221\rangle, \text{ seed } 1)−0.014610 of 102.6630no
FR(⟨112111⟩, seed 0)FR(\langle112111\rangle, \text{ seed } 0)−0.014710 of 102.6593no
FR(⟨112111⟩, seed 1)FR(\langle112111\rangle, \text{ seed } 1)−0.016210 of 102.6605no
FR(⟨111112⟩, seed 0)FR(\langle111112\rangle, \text{ seed } 0)−0.015910 of 102.6583no
FR(⟨111112⟩, seed 1)FR(\langle111112\rangle, \text{ seed } 1)−0.017210 of 102.6593no
FR(⟨111111⟩, seed 0)FR(\langle111111\rangle, \text{ seed } 0)−0.015910 of 102.6576no
FR(⟨111111⟩, seed 1)FR(\langle111111\rangle, \text{ seed } 1)−0.017210 of 102.6594no
FR(Z∗(table 81), seed 0)FR(Z^*(\text{table }81), \text{ seed } 0)−0.016210 of 102.6588no
FR(Z∗(table 81), seed 1)FR(Z^*(\text{table }81), \text{ seed } 1)−0.017310 of 102.6596no
FR(Z∗(table 128), seed 0)FR(Z^*(\text{table }128), \text{ seed } 0)−0.016210 of 102.6595no
FR(Z∗(table 128), seed 1)FR(Z^*(\text{table }128), \text{ seed } 1)−0.016810 of 102.6604no
FR(Z∗(table 256), seed 0)FR(Z^*(\text{table }256), \text{ seed } 0)−0.016010 of 102.6595no
FR(Z∗(table 256), seed 1)FR(Z^*(\text{table }256), \text{ seed } 1)−0.016810 of 102.6605no

Table 4.

series runcompared withdifferenceevaluations lower
FR(Z∗(table 128), seed 0)FR(Z^*(\text{table }128), \text{ seed } 0)FR(⟨333333⟩, seed 0)FR(\langle333333\rangle, \text{ seed } 0)−0.015310 of 10
FR(Z∗(table 128), seed 0)FR(Z^*(\text{table }128), \text{ seed } 0)FR(⟨211221⟩, seed 0)FR(\langle211221\rangle, \text{ seed } 0)−0.002110 of 10
FR(Z∗(table 128), seed 0)FR(Z^*(\text{table }128), \text{ seed } 0)FR(⟨111112⟩, seed 0)FR(\langle111112\rangle, \text{ seed } 0)−0.00035 of 10
FR(Z∗(table 128), seed 0)FR(Z^*(\text{table }128), \text{ seed } 0)FR(⟨111111⟩, seed 0)FR(\langle111111\rangle, \text{ seed } 0)−0.00025 of 10
FR(Z∗(table 81), seed 0)FR(Z^*(\text{table }81), \text{ seed } 0)FR(⟨333333⟩, seed 0)FR(\langle333333\rangle, \text{ seed } 0)−0.015310 of 10
FR(Z∗(table 81), seed 0)FR(Z^*(\text{table }81), \text{ seed } 0)FR(⟨131111⟩, seed 0)FR(\langle131111\rangle, \text{ seed } 0)−0.003910 of 10
FR(Z∗(table 81), seed 0)FR(Z^*(\text{table }81), \text{ seed } 0)FR(⟨111111⟩, seed 0)FR(\langle111111\rangle, \text{ seed } 0)−0.00026 of 10
FR(Z∗(table 256), seed 0)FR(Z^*(\text{table }256), \text{ seed } 0)FR(⟨333333⟩, seed 0)FR(\langle333333\rangle, \text{ seed } 0)−0.015210 of 10
FR(Z∗(table 256), seed 0)FR(Z^*(\text{table }256), \text{ seed } 0)FR(⟨112111⟩, seed 0)FR(\langle112111\rangle, \text{ seed } 0)−0.00139 of 10
FR(Z∗(table 256), seed 0)FR(Z^*(\text{table }256), \text{ seed } 0)FR(⟨111112⟩, seed 0)FR(\langle111112\rangle, \text{ seed } 0)−0.00015 of 10
FR(Z∗(table 256), seed 0)FR(Z^*(\text{table }256), \text{ seed } 0)FR(⟨111111⟩, seed 0)FR(\langle111111\rangle, \text{ seed } 0)−0.00015 of 10
FR(Z∗(table 128), seed 1)FR(Z^*(\text{table }128), \text{ seed } 1)FR(⟨333333⟩, seed 1)FR(\langle333333\rangle, \text{ seed } 1)−0.017310 of 10
FR(Z∗(table 128), seed 1)FR(Z^*(\text{table }128), \text{ seed } 1)FR(⟨211221⟩, seed 1)FR(\langle211221\rangle, \text{ seed } 1)−0.002310 of 10
FR(Z∗(table 128), seed 1)FR(Z^*(\text{table }128), \text{ seed } 1)FR(⟨111112⟩, seed 1)FR(\langle111112\rangle, \text{ seed } 1)+0.00043 of 10
FR(Z∗(table 128), seed 1)FR(Z^*(\text{table }128), \text{ seed } 1)FR(⟨111111⟩, seed 1)FR(\langle111111\rangle, \text{ seed } 1)+0.00044 of 10
FR(Z∗(table 81), seed 1)FR(Z^*(\text{table }81), \text{ seed } 1)FR(⟨333333⟩, seed 1)FR(\langle333333\rangle, \text{ seed } 1)−0.017710 of 10
FR(Z∗(table 81), seed 1)FR(Z^*(\text{table }81), \text{ seed } 1)FR(⟨131111⟩, seed 1)FR(\langle131111\rangle, \text{ seed } 1)−0.003310 of 10
FR(Z∗(table 81), seed 1)FR(Z^*(\text{table }81), \text{ seed } 1)FR(⟨111111⟩, seed 1)FR(\langle111111\rangle, \text{ seed } 1)−0.00015 of 10
FR(Z∗(table 256), seed 1)FR(Z^*(\text{table }256), \text{ seed } 1)FR(⟨333333⟩, seed 1)FR(\langle333333\rangle, \text{ seed } 1)−0.017310 of 10
FR(Z∗(table 256), seed 1)FR(Z^*(\text{table }256), \text{ seed } 1)FR(⟨112111⟩, seed 1)FR(\langle112111\rangle, \text{ seed } 1)−0.00068 of 10
FR(Z∗(table 256), seed 1)FR(Z^*(\text{table }256), \text{ seed } 1)FR(⟨111112⟩, seed 1)FR(\langle111112\rangle, \text{ seed } 1)+0.00043 of 10
FR(Z∗(table 256), seed 1)FR(Z^*(\text{table }256), \text{ seed } 1)FR(⟨111111⟩, seed 1)FR(\langle111111\rangle, \text{ seed } 1)+0.00044 of 10

Table 5.

Termination criteria per checkpoint

Table A3 repeats Table 1 at full width, with the two cost ratios of Appendix C. Per-checkpoint

criterionroundsqueries, improvequeries, stopP(min. found)regretspeedup, unit-costspeedup, hw-informed
A DH96 global cutoff77.38.2±0.18.2 \pm0.1222.2±0.2222.2 \pm0.21.00000.21×0.21\times1.05×1.05\times
B BBHT cascade budget 3N3\sqrt{N}29.38.1±0.18.1 \pm0.129.4±0.029.4 \pm0.00.9991.9e−061.9\mathrm{e}{-06}0.84×0.84\times2.77×2.77\times
C BBHT-confidence stop, δ=10−3\delta= 10^{-3}52.28.2±0.18.2 \pm0.1121.3±0.2121.3 \pm0.21.00000.35×0.35\times1.55×1.55\times
D dynamic stop (N,u,f,δ)(N,u,f,\delta), δ=10−3\delta= 10^{-3}28.38.1±0.18.1 \pm0.125.6±0.125.6 \pm0.10.9991.4e−061.4\mathrm{e}{-06}0.90×0.90\times2.86×2.86\times

Table A3. Four termination criteria for checkpoint-local Dürr–Høyer selection on the h=25h = 25 tables, N=81N = 81, pooled over five checkpoints, 1,000 Aer trials per checkpoint and criterion, common random numbers. Rounds R(x)R^{(x)} count state preparations and classical checks alike (Eq. (14)); queries split into the descent work Qimp(x)Q_{\mathrm{imp}}^{(x)}, identical across criteria, and the stopping work Qstop(x)Q_{\mathrm{stop}}^{(x)}, where the criteria differ. The two speedups are SunitS_{\mathrm{unit}} of Eq. (22) and ShwS_{\mathrm{hw}} of Eq. (23), the latter drawn with the interim clocks titer=1 mst_{\mathrm{iter}} = 1\ \mathrm{ms}, tsetup=40 μst_{\mathrm{setup}} = 40\ \mathrm{\mu s}; the estimate of Eq. (24) is smaller on both and leaves every entry at the floor N/R(x)N/R^{(x)} to two digits.

detail behind Table 1: four criteria, five checkpoints, 20 Aer trials each, δ=10−3\delta= 10^{-3} for C and D. The minimizer column names the row of Eq. (9) at that checkpoint; the threshold-update count is a diagnostic (Appendix C); the rank percentile is 1 when the minimum was returned.

crit.ckptminimiserroundsq. imp.q. stopupdatesP(found)speedup (unit)speedup (hw)
A200L25b_3077.57.5228.93.101.000.21×0.21\times1.04×1.04\times
A400corner_low78.27.2227.83.301.000.21×0.21\times1.04×1.04\times
A600corner_low78.57.3226.23.451.000.21×0.21\times1.03×1.03\times
A800corner_low78.87.7226.63.451.000.21×0.21\times1.03×1.03\times
A1000corner_low77.16.2230.82.951.000.21×0.21\times1.05×1.05\times
B200L25b_3027.57.529.43.101.000.88×0.88\times2.95×2.95\times
B400corner_low27.47.229.03.301.000.89×0.89\times2.96×2.96\times
B600corner_low27.87.329.13.451.000.88×0.88\times2.91×2.91\times
B800corner_low28.57.728.93.451.000.87×0.87\times2.84×2.84\times
B1000corner_low25.76.229.12.951.000.93×0.93\times3.15×3.15\times
C200L25b_3050.77.5121.33.101.000.35×0.35\times1.60×1.60\times
C400corner_low50.87.2121.23.301.000.35×0.35\times1.59×1.59\times
C600corner_low51.27.3121.33.451.000.35×0.35\times1.58×1.58\times
C800corner_low51.87.7120.73.451.000.35×0.35\times1.56×1.56\times
C1000corner_low48.96.2121.32.951.000.36×0.36\times1.66×1.66\times
D200L25b_3026.87.526.63.101.000.92×0.92\times3.02×3.02\times
D400corner_low26.87.225.83.301.000.94×0.94\times3.02×3.02\times
D600corner_low27.17.325.23.451.000.94×0.94\times2.99×2.99\times
D800corner_low27.87.725.53.451.000.91×0.91\times2.92×2.92\times
D1000corner_low25.16.225.92.951.000.99×0.99\times3.23×3.23\times

Table 6.

Figure A6 prices the same counts per checkpoint under the two conventions of Appendix C. Under the unit-cost query model no criterion reaches parity at this size: Q(x)+2R(x)Q^{(x)} + 2R^{(x)} is at least 90 against N=81N = 81, giving SunitS_{\mathrm{unit}} of 0.21, 0.84, 0.35 and 0.90 for A to D. The dotted line marks the bound of Eq. (7) in the same units. Under the hardware-informed estimate every bar collapses onto its checking-cost floor R(x)tchkR^{(x)}t_{\mathrm{chk}}, and ShwS_{\mathrm{hw}} is 1.05, 2.77, 1.55 and 2.86; the quantum terms are invisible at this scale, as follows from Eq. (23). Both readings are conditional on the oracle convention of Appendix C. Criterion D carries the scaling study.

Figure A6. Selection time per checkpoint for the four termination criteria on the h=25h = 25 tables, N=81N = 81, against exhaustive evaluation (dashed, 81×355.5 s=8.00 h81 \times355.5\ \mathrm{s} = 8.00\ \mathrm{h}). One round is one state preparation, jj Grover iterations, one measurement and one classical check, so preparations and checks both appear as the round count R(x)R^{(x)}. (a) Unit-cost query model, titer=tsetup=tchkt_{\mathrm{iter}} = t_{\mathrm{setup}} = t_{\mathrm{chk}}: bars stack the improvement and stopping iterations, the preparations and the checks; the right axis reads the bar in common cost units, and the dotted line is 454N≈101\frac{45}{4}\sqrt{N} \approx101 units. (b) Hardware-informed estimate, drawn with the interim clocks titer=1 mst_{\mathrm{iter}} = 1\ \mathrm{ms} and tsetup=40 μst_{\mathrm{setup}} = 40\ \mu\mathrm{s} and the checks at tchkt_{\mathrm{chk}}; the clocks of Eq. (24) are smaller and change no bar: every bar equals its checking-cost floor R(x)tchkR^{(x)} t_{\mathrm{chk}}. All timings are conditional on the lookup-oracle convention; panel (b) is never a measured speedup.

Declared-rule continuation and its agreement with the measured rows

The declared-rule cross-check of Section 2.5 replays criterion D with the analytic probability of Eq. (5), no table and no circuit. The first table repeats the measured rows at full width; the second continues the rule beyond the measured range; every row of it is a cross-check of the rule and not a measurement, and the times assume tchk=355.5 st_{\mathrm{chk}} = 355.5\ \mathrm{s} and the interim clocks 1 ms1\ \mathrm{ms}, 40 μs40\ \mu\mathrm{s} (Eq. (24) lowers both and moves no entry). The second table is the validation gate at the three measured sizes: the pass band is ∣Aer−model∣≤max⁡(3 s.e.,3%)\lvert A_{\mathrm{er}}-\mathrm{model}\rvert\le\max(3\ \mathrm{s.e.}, 3\%) on both R(D)R^{(\mathrm{D})} and Q(D)Q^{(\mathrm{D})}, and all three sizes pass.

Part A, measured rows (full width)

table size NNrowstrials (Aer runs or model runs)rounds (prep. = checks)±\pm s.e.queries (total)±\pm s.e.thr. updates (diag.)P(minimizer found)P(\mathrm{minimizer\ found})classical exhaustivequantum, unit-costspeedup (unit-cost)quantum, hardware-informedspeedup (hardware-informed)
81measured (Aer)5,000 Aer runs (5 × 1000)28.3 ± 0.133.8 ± 0.13.950.9998.0 h8.9 h0.90×2.8 h2.86×
128measured (Aer)5,000 Aer runs (5 × 1000)33.3 ± 0.146.6 ± 0.14.401.00012.6 h11.2 h1.13×3.3 h3.85×
256measured (Aer)5,000 Aer runs (1 × 5000)41.5 ± 0.271.8 ± 0.25.101.00025.3 h15.3 h1.65×4.1 h6.17×

Table 7.

Part B, declared-rule continuation (not a measurement)

table size NNrowsmodel runsrounds ± s.e.queries (total) ± s.e.thr. updates (diag.)P(minimizer found)P(\mathrm{minimizer\ found})classical exhaustivequantum, unit-costspeedup (unit-cost)quantum, hardware-informedspeedup (hardware-informed)
512theory cross-check (declared rule)2,000 model runs (no table, no circuits)51.0 ± 0.3110.3 ± 0.65.841.0002.1 d21.0 h2.41×5.0 h10.0×
1,024theory cross-check (declared rule)2,000 model runs (no table, no circuits)61.4 ± 0.4164.0 ± 0.86.561.0004.2 d28.3 h3.57×6.1 h16.7×
4,096theory cross-check (declared rule)2,000 model runs (no table, no circuits)86.4 ± 0.6362.4 ± 1.97.891.00016.9 d2.2 d7.65×8.5 h47.4×
16,384theory cross-check (declared rule)2,000 model runs (no table, no circuits)117.1 ± 0.7770.5 ± 4.09.261.00067.4 d4.1 d16.3×11.6 h140×
65,536theory cross-check (declared rule)1,000 model runs (no table, no circuits)154.5 ± 1.31599.1 ± 11.910.691.000269.7 d7.9 d34.3×15.3 h424×
262,144theory cross-check (declared rule)1,000 model runs (no table, no circuits)196.9 ± 1.63253.3 ± 23.212.241.0002.96 yr15.0 d71.9×19.4 h1,331×

Table 8.

Part C, agreement at the measured sizes

table size NNrounds, Aerrounds, modelqueries, Aerqueries, modelthr. updates Aer / model (diag.)
8128.328.4 ± 0.133.833.7 ± 0.13.95 / 3.95
12833.333.2 ± 0.146.646.5 ± 0.24.40 / 4.43
25641.541.3 ± 0.271.871.5 ± 0.25.10 / 5.12

Table 9.

tbl:A4: Selection cost against table size for criterion D (δ=10−3\delta= 10^{-3}), measured rows only: ideal Grover circuits simulated on Qiskit Aer over the real h=25h = 25 scores. Trials are checkpoints times trials per checkpoint; rounds and queries carry standard errors; the speedups follow Eqs. (22) and (23) with tchk=355.5 st_{\mathrm{chk}} = 355.5\ \mathrm{s} and the interim clocks 1 ms1\ \mathrm{ms}, 40 μs40\ \mu\mathrm{s} (Eq. (24) lowers both and moves no entry). The full-width rows (threshold updates, classical and quantum times), the declared-rule continuation beyond N=256N = 256 and its agreement with these rows are given in this appendix.

sizetrialsroundsqueriesP(min. found)P(\mathrm{min.\ found})speedup (unit-cost)speedup (hw-informed)
815 × 1,00028.3 ± 0.133.8 ± 0.10.9990.90×2.86×
1285 × 1,00033.3 ± 0.146.6 ± 0.11.0001.13×3.85×
2561 × 5,00041.5 ± 0.271.8 ± 0.21.0001.65×6.17×

Table 10.

Criterion D is followed across the three measured sizes in Figure A7. At unit cost, one per iteration and two per round, the speedup over exhaustive evaluation crosses unity between N=81N = 81 and 128128: SunitS_{\mathrm{unit}} is (0.90, 1.13, 1.65)(0.90,\ 1.13,\ 1.65) and the break-even sits near N≈100N \approx100. Under the hardware-informed estimate the classical checks dominate and ShwS_{\mathrm{hw}} is (2.86, 3.85, 6.14)(2.86,\ 3.85,\ 6.14), the floor N/RN/R at every size: the quantum terms are negligible, one selection costs its RR classical checks, and the gain comes from needing fewer rounds rather than from a faster circuit. Both ratios exclude the construction of TablescoreTable_{\mathrm{score}}: with each table charged at one replay per profile, a selection over the lookup oracle takes longer than exhaustive evaluation at every measured size, the ratio of exhaustive to quantum time being 0.740.74, 0.790.79 and 0.860.86 at N=81N = 81, 128128 and 256256, so the lookup route carries no end-to-end advantage.

Figure A7. Runtime speedup versus table size NN for criterion D with δ=10−3\delta= 10^{-3}. Dashed curves are the declared-rule cross-check obtained from the analytic success probability of Eq. (5), and are continued to the design size N=262,144N = 262{,}144, where no corresponding table or circuit experiment is run. At the measured sizes, the cross-check agrees with the measured results within 0.5%. The construction of the score table is not included.

The declared-rule cross-check of Section 2.5 reproduces the measured rows within 0.5% in both R(D)R^{(\mathrm{D})} and Q(D)Q^{(\mathrm{D})} at all three sizes, which is the license to draw the same rule beyond the measured range as the dashed curves of Figure A7. Continued to the design size N=86=262,144N = 8^{6} = 262{,}144 the rule gives R(D)≈197R^{(\mathrm{D})} \approx197 rounds and Q(D)≈3,250Q^{(\mathrm{D})} \approx3{,}250 iterations, an SunitS_{\mathrm{unit}} of about 72 and an ShwS_{\mathrm{hw}} of about 1,330. Along the ladder Q(D)Q^{(\mathrm{D})} scales as N/R\sqrt{N}/R from 4.1 to 6.4, inside the 11.25 of Eq. (7) and R(D)R^{(\mathrm{D})} as (ln⁡N)2(\ln N)^2, so the floor N/R(D)N/R^{(\mathrm{D})} grows almost linearly in NN. Nothing beyond N=256N = 256 is a measurement: the continuation assumes distinct scores and a uniform rank of the initial threshold, and, like every selection-time estimate of the lookup study, it is conditional on the lookup-oracle convention.

Seed-stability check at checkpoint 200

Criterion D at checkpoint 200 for N=81N = 81, 128 and 256, with the paper’s seed block (block 0) and four further disjoint blocks of 1,000 trials. The spread of the five block means is 0.62/0.94/1.19 rounds and 0.63/1.02/1.50 queries at the three sizes, i.e. 2.6 to 3.7 standard errors, the range expected for five independent blocks; no block stands out. At N=256N = 256 block 0 is the 5,000-trial file and therefore contains blocks 1–4; blocks 1–4 alone carry the independent statement.

NNblocktrial seedstrialsR±R \pm s.e.Q±Q \pm s.e.P(minimiser found)misses
8101000-19991,00028.61 ± 0.2533.98 ± 0.240.9991
8112000-29991,00027.99 ± 0.2333.35 ± 0.231.0000
8123000-39991,00028.11 ± 0.2333.46 ± 0.231.0000
8134000-49991,00028.36 ± 0.2433.63 ± 0.241.0000
8145000-59991,00028.51 ± 0.2533.65 ± 0.241.0000
12801000-19991,00033.72 ± 0.2947.03 ± 0.351.0000
12812000-29991,00033.42 ± 0.2946.77 ± 0.330.9991
12823000-39991,00032.97 ± 0.2846.01 ± 0.320.9982
12834000-49991,00033.29 ± 0.3046.40 ± 0.331.0000
12845000-59991,00032.78 ± 0.2946.22 ± 0.350.9982
25601000-59995,00041.52 ± 0.1671.78 ± 0.221.0002
25612000-29991,00041.93 ± 0.3672.48 ± 0.510.9991
25623000-39991,00042.04 ± 0.3772.21 ± 0.501.0000
25634000-49991,00040.85 ± 0.3570.98 ± 0.481.0000
25645000-59991,00041.31 ± 0.3671.75 ± 0.501.0000

Table 1 (PDF p. 30).

Interaction-Guided Schedule Oracle: score construction and closed-loop runs

Checkpoint evaluation. At each checkpoint tt, the checkpoint evaluation of § 2.4 measures change patterns around the uniform-rate baseline zrefz_{\mathrm{ref}}. A change pattern γ\gamma moves one, two or three groups away from zrefz_{\mathrm{ref}} and keeps the others at 1.0. For each pattern, the parameters are moved once from the saved model and optimizer state along the optimizer’s update direction for one fixed batch of 16 training sequences, the update of each group scaled by its rate, and Λt(γ)\Lambda_t(\gamma) is the loss of the moved model on two fixed held-out sequences; the baseline takes the same step from the same state. The gain of γ\gamma is Yt(γ)=Λt(zref)−Λt(γ)Y_t(\gamma)=\Lambda_t(z_{\mathrm{ref}})-\Lambda_t(\gamma), and Yt(g;η)Y_t(g;\eta) is the gain of moving group gg alone to the rate η\eta. Every term of Eq. (15) vanishes when one of its groups stays at 1.0, so the baseline scores zero.

Interaction coefficients. For a change pattern γ\gamma, the interaction term is the discrete derivative of the gain over the moved groups (Sundararajan et al., 2020),

νt(γ)=∑γ′⊆γ(−1)∣γ∣−∣γ′∣Yt(γ′),(26)\nu_t(\gamma)=\sum_{\gamma'\subseteq\gamma}(-1)^{|\gamma|-|\gamma'|}Y_t(\gamma'), \tag*{(26)}

where γ′\gamma' runs over the sub-patterns of γ\gamma, each moved group keeping its rate in γ\gamma, the empty one with gain zero. For one group, a pair and a triple, with the rates omitted,

νt,g=Yt,g,νt,gg′=Yt,gg′−Yt,g−Yt,g′,\nu_{t,g}=Y_{t,g},\qquad\nu_{t,gg'}=Y_{t,gg'}-Y_{t,g}-Y_{t,g'},
νt,gg′g′′=Yt,gg′g′′−Yt,gg′−Yt,gg′′−Yt,g′g′′+Yt,g+Yt,g′+Yt,g′′,\nu_{t,gg'g''}=Y_{t,gg'g''}-Y_{t,gg'}-Y_{t,gg''}-Y_{t,g'g''}+Y_{t,g}+Y_{t,g'}+Y_{t,g''},

where Yt,gg′Y_{t,gg'} is the measured gain of moving gg and g′g' together: a pair or triple interaction is the part of a measured joint gain that its lower-order terms do not explain, derived after the joint measurement rather than measured on its own. Summed over the sub-patterns of a measured pattern, the terms of Eq. (15) therefore return its measured gain before rounding. For a schedule with 0.7 in a pair or triple, or with more than three moved groups, Y^t(z)\widehat{Y}_t(z) is a modeled gain rather than a measured joint gain. Taken at the uniform-rate baseline only, these terms are not Shapley–Taylor indices, whose highest-order indices average over orderings.

Design and coefficients. At each checkpoint the measurement design has 249 rows: five repeats of the uniform-rate baseline, the 12 single-group changes to 0.5 and 1.4 times the uniform rate, 12 single-group changes to 0.7 and 2.0 times that rate, the 60 pairs and the 160 triples of § 2.4 at 0.5 and 1.4. The rows at 2.0 enter no coefficient, and the search menu does not contain that rate. Over the moved rates 0.5, 0.7 and 1.4, the three sums of Eq. (15) can draw on 6×3=186\times3=18 single, (62)×32=135\binom{6}{2}\times3^2=135 pair and (63)×33=540\binom{6}{3}\times3^3=540 triple cases, 693 in all; these count possible rate-specific cases, not stored coefficients, of which the design holds the 232 single, pair and triple patterns at 0.5 and 1.4 and at most six corrections at 0.7. A group at 0.7 keeps its own measured single gain, through the correction of Eq. (27), and shares the pair and triple interactions of its lowering to 0.5. The 15×5=7515\times5=75 pair and 20×19=38020\times19=380 triple cases that contain 0.7 have no measured row: sharing the interactions at 0.5 avoids these 455 joint measurements per checkpoint, which would raise the design from 249 to 704 rows, and lets each pair or triple coefficient act on the direction of its groups, lowered or raised, rather than on separate rate-specific terms. The unit ε\varepsilon is the larger of the spread of the uniform repeats and the declared 2×10−42\times10^{-4}; the repeats are identical within one measurement, so ε=2×10−4\varepsilon=2\times10^{-4} in both runs. The five-batch run measures the same rows on five fixed batches of 16 training sequences, the first being the single batch, averages the losses row by row and records the spread of each row without using it. The single-batch measurements were taken with unseeded dropout and non-deterministic GPU kernels and do not repeat exactly: a repeat of the same measurement on one checkpoint changes the losses by 6.8×10−46.8\times10^{-4} on average; the five-batch run used seeded dropout and deterministic kernels.

Integer score. Each coefficient is divided by ε\varepsilon before it is rounded, which enlarges the small gains before the rounding: at(γ)=round⁡(νt(γ)/ε)a_t(\gamma)=\operatorname{round}(\nu_t(\gamma)/\varepsilon) for each of the 232 patterns, and the 0.7 correction of group gg is bt(g)=round⁡((Yt(g;0.7)−Yt(g;0.5))/ε)b_t(g)=\operatorname{round}((Y_t(g;0.7)-Y_t(g;0.5))/\varepsilon), so that a group at 0.7 carries its own measured single gain. With z⪰γz\succeq\gamma when zz moves every group of γ\gamma in the same direction as γ\gamma (0.5 and 0.7 counting as lowered) and Γ\Gamma the set of the 232 patterns, the score evaluated by the circuit and by the classical check of each sample is

Φt(z)=∑γ∈Γat(γ)1[z⊇γ]+∑g=1Gbt(g)1[ηg=0.7].(27)\Phi_t(z) = \sum_{\gamma\in\Gamma} a_t(\gamma)\mathbf{1}[z \supseteq\gamma] + \sum_{g=1}^{G} b_t(g)\mathbf{1}[\eta_g = 0.7]. \tag*{(27)}

At checkpoint 200 of the single-batch run, for example, the second layer group has the single gain 3.69×10−43.69 \times10^{-4} at 0.5, which rounds to zero directly but to at=2a_t = 2 after division by ε\varepsilon (1.85), and the gain 1.14×10−31.14 \times10^{-3} at 0.7 gives bt=4b_t = 4, so the group contributes 6 at 0.7. Patterns whose rounded coefficient is zero add nothing and are left out of the circuit. Because the coefficients and corrections are rounded separately, Φt(z)\Phi_t(z) need not equal Y^t(z)/ε\widehat{Y}_t(z)/\varepsilon rounded once.

Around another baseline. Eq. (18) of § 4 writes the score around a baseline schedule zbasez_{\mathrm{base}} as single-group gains plus pair and triple interactions. With zbase⊕γz_{\mathrm{base}} \oplus\gamma the baseline with only the groups of a pattern γ\gamma moved to the rates of zz, and P(z∣zbase)\mathcal{P}(z \mid z_{\mathrm{base}}) the patterns of one to three groups on which zz differs from zbasez_{\mathrm{base}}, the inclusion–exclusion of Eq. (26) around the baseline gives

Y^t(z∣zbase)=∑γ∈P(z∣zbase)∑γ′⊆γ(−1)∣γ∣−∣γ′∣[Λt(zbase)−Λt(zbase⊕γ′)].(28)\widehat{Y}_t(z \mid z_{\mathrm{base}}) = \sum_{\gamma\in\mathcal{P}(z \mid z_{\mathrm{base}})} \sum_{\gamma' \subseteq\gamma} (-1)^{|\gamma|-|\gamma'|} \left[\Lambda_t(z_{\mathrm{base}}) - \Lambda_t(z_{\mathrm{base}} \oplus\gamma')\right]. \tag*{(28)}

For a pattern of one, two or three groups the inner sum is the single-group gain, the pair interaction or the triple interaction around zbasez_{\mathrm{base}}, so Eq. (28) is Eq. (18) term by term: every group outside a pattern keeps its baseline rate, every term vanishes when one of its groups stays at its baseline rate, and the baseline scores zero. The terms are rate-specific effects measured around zbasez_{\mathrm{base}}; the sharing of the 0.5 interactions at 0.7 is a choice of the reported runs and is not part of this expression.

Circuit and search. The register holds two qubits per group and an accumulator of ⌈log⁡2(span⁡+1)⌉+2\lceil\log_2(\operatorname{span} + 1) \rceil+ 2 qubits, where the span is the range of Φt\Phi_t, so 22 to 25 qubits in all. The accumulator, in the Fourier basis, receives each at(γ)a_t(\gamma) and bt(g)b_t(g) as a phase rotation controlled on the qubits of the groups involved; subtracting Φt(y)+1\Phi_t(y) + 1, flipping the phase of the sign qubit and uncomputing the arithmetic realize Eq. (16) on every schedule at once, and the circuit returns no score as a readable value. The search is the minimum finding of Dürr & Høyer [9] with a larger score being better. Each round prepares the joint schedules in superposition, applies the oracle and diffusion the number of times drawn by Eq. (6), and samples one schedule; a classical evaluation of Eq. (27) on the sample updates the best schedule and the threshold after an improvement, and after an unsuccessful sample criterion D, the criterion chosen in § 3.1, decides whether to continue. The uniform-rate baseline is returned if nothing beats it. Before each run, the circuit was checked on the checkpoint-200 coefficients: at the initial threshold its marks equal those of Eq. (16) evaluated with Eq. (27) on all 4,096 schedules, and the accumulator returns to zero. This enumeration exists only in the test; the search never reads it. Each search is one trial with its random seed set to the checkpoint step. Figure A8 shows the workflow of one checkpoint at this level of detail. Criterion D is reused here as a stopping rule. Its rank distribution (Appendix § 6) assumes a first threshold drawn uniformly at random and distinct scores, whereas this search starts from the fixed uniform-rate baseline and the integer scores of Eq. (27) can tie; the rule was applied unchanged, so δ=10−3\delta= 10^{-3} is a nominal setting and not a calibrated error level, and the returned schedule is not certified as the maximizer of Φt\Phi_t. The single-batch searches ran on a laptop CPU in single precision (4,465 to 16,362 s of simulator time per search), the five-batch searches on a GPU in double precision (158 to 281 s); these are times of the classical simulator, not of a quantum device.

Figure A8. Detailed workflow of the Interaction-Guided Schedule Oracle at one checkpoint. Classical loss measurements define fixed integer coefficients, and the best schedule is initialized at the uniform-rate baseline. Each quantum round prepares 4,096 schedules, applies the chosen number of oracle and diffusion iterations, and measures one schedule. Classical checking updates the best schedule and threshold after an improvement; otherwise criterion D determines whether to continue. After stopping, the best schedule controls the next training interval, and the next checkpoint rebuilds the evidence.

Decisions. Table A5 lists, for each leg, the schedule returned (group order from the first layers to the last), its interaction score Φ\Phi in units of ε\varepsilon, the rounds RR and Grover iterations QQ of the search, the register width, and, for the five-batch run, the number of the 232 interaction terms whose sign differs between the first batch and the five-batch average. Both runs start from the checkpoint at step 200 of the uniform-rate run of seed 2; each interval is 200 steps (221 for the last). Besides the evidence, the two runs also differ in the GPU, the simulator precision and the determinism of the training kernels.

single-batch measurementsfive-batch measurements
legscheduleΦ\PhiRRQQqubitsscheduleΦ\PhiRRQQqubitssign flips
200 → 400(0.5, 1.4, 1.4, 0.5, 0.7, 0.5)1298726424(0.5, 1.0, 1.4, 0.7, 1.4, 0.7)126227122106
400 → 600(0.5, 1.4, 0.7, 0.7, 1.4, 1.4)6610229624(1.4, 0.7, 0.7, 0.7, 0.5, 1.4)25753202276
600 → 800(1.4, 0.5, 1.4, 0.7, 1.4, 1.4)7810949424(0.7, 0.5, 0.5, 0.5, 1.4, 0.5)33772892279
800 → 1000(1.4, 1.4, 0.5, 0.7, 1.4, 1.4)1626129225(1.4, 0.7, 1.4, 0.5, 1.4, 0.5)11522692373
1000 → 1221(0.7, 1.4, 0.5, 1.4, 1.0, 1.4)287630424(1.4, 1.4, 0.5, 1.4, 0.5, 0.7)32762922288

Table A5. The five decisions of each closed-loop run. The scores Φ\Phi of the two runs are not comparable with each other, since the averaged coefficients are smaller.

Hardware-constrained Grover iteration counts

Compiled gate accounting. For the hardware-sampled searches of § 3.3, the circuit of a round with jj Grover iterations is assembled from compiled pieces: a prefix that prepares the uniform superposition on the qsrch=12q_{\mathrm{srch}}=12 search qubits, then jj iteration bodies, then the measurement of the search register. Body j′j' is one Grover iteration, the oracle of Eq. (16) followed by the diffuser, routed on the device starting from the qubit placement that body j′−1j'-1 left, so the bodies are not identical and differ in gate count; the submitted circuit is the concatenation of the cached compiled pieces, with no further compilation. For each gate type,

CCZ(j)=CCZ(0)+∑j′=1jΔCCZ(j′),(29)C_{\mathrm{CZ}}(j)=C_{\mathrm{CZ}}(0)+\sum_{j'=1}^{j}\Delta C_{\mathrm{CZ}}(j'), \tag*{(29)}

and likewise for RZ and SX, the components of C in Eq. (30). Each Hadamard gate of the prefix is compiled as RZ, SX, RZ, so C(0) = (0, 24, 12); the measurement adds no gate of the three types. The counts depend on the checkpoint, through the integer coefficients of Eq. (27), on the threshold, and on the backend, synthesis, layout and routing used at compile time, and they are recomputed for each. On assembled circuits at checkpoint 200, with the threshold score Φt(y)=42\Phi_t(y)=42 on ibm_fez, the gate counts equal the sums of Eq. (29) exactly: 1,799,810 CZ, 2,348,632 RZ and 3,520,886 SX gates at j=28j=28, and 3,478,853, 4,525,511 and 6,797,218 at j=54j=54.

The limit. IBM specifies per-circuit limits of 5×1065 \times10^6 two-qubit gates, 3×1073 \times10^7 RZ gates and 2×1072 \times10^7 SX gates (IBM Quantum documentation, “Job limits”, https://quantum.cloud.ibm.com/docs/en/guides/job-limits, read 11 November 2026). With C(0) the numbers of CZ, RZ and SX gates of the preparation and ΔC(j′)\Delta\mathrm{C}(j') those added by the j′j'-th body, the largest iteration count within the per-circuit gate limits of the service is

Jdev=max⁡{j∈Z≥0: C(0)+∑j′=1jΔC(j′)≤(5,30,20)×106},(30)J_{\mathrm{dev}}=\max\left\{j\in\mathbb{Z}_{\ge0}:\ \mathrm{C}(0)+\sum_{j'=1}^{j}\Delta\mathrm{C}(j')\le(5,30,20)\times10^6\right\}, \tag*{(30)}

the inequality holding for each gate type, recomputed for every checkpoint, threshold and backend. The compiled circuits are CZ-native, so Eq. (30) applies these limits to the counts of Eq. (29). The maximum in Eq. (30) runs over all non-negative integers, so JdevJ_{\mathrm{dev}} is a property of the compiled circuit family and the device limits and does not depend on the range of the BBHT draw. Every body adds gates, so the counts never decrease in jj, the admissible counts form the interval {0,…,Jdev}\{0,\ldots,J_{\mathrm{dev}}\}, and JdevJ_{\mathrm{dev}} is found by compiling bodies until the first one crosses a limit. Two evaluations exist in the program and are kept apart. A measurement stage compiles until a limit is crossed and returns JdevJ_{\mathrm{dev}} exactly. During the search, bodies are compiled only as far as the current block of rounds can draw, at most ⌈N⌉−1=63\lceil\sqrt{N}\rceil-1=63 at N=4,096N=4{,}096; if all of them fit, the search records only Jdev≥63J_{\mathrm{dev}}\ge63 and the bound is inactive. The largest count that the schedule can draw, 63, is a property of the schedule and a different number from JdevJ_{\mathrm{dev}}.

Estimate before compilation. Before the whole range is compiled, a first-order projection follows from the fixed counts and a representative per-iteration count ΔC\Delta C of each gate type,

J^dev=min⁡{⌊5×106−CCZ(0)ΔCCZ⌋,⌊3×107−CRZ(0)ΔCRZ⌋,⌊2×107−CSX(0)ΔCSX⌋}.(31)\widehat{J}_{\mathrm{dev}}=\min\left\{\left\lfloor\frac{5\times10^6-C_{\mathrm{CZ}}(0)}{\Delta C_{\mathrm{CZ}}}\right\rfloor,\left\lfloor\frac{3\times10^7-C_{\mathrm{RZ}}(0)}{\Delta C_{\mathrm{RZ}}}\right\rfloor,\left\lfloor\frac{2\times10^7-C_{\mathrm{SX}}(0)}{\Delta C_{\mathrm{SX}}}\right\rfloor\right\}. \tag*{(31)}

It is a planning estimate only; every decision of the search uses the exact cumulative counts of Eqs. (29) and (30). Table A6 lists the compilations of the same oracle at checkpoint 200 with the threshold score 42 on ibm_fez. In both measured cases the estimate equals the exact value, and CZ is the binding gate type. For the shared-AND synthesis Jdev=77J_{\mathrm{dev}}=77, above the schedule maximum of 63, so every circuit the schedule can draw at this threshold is inside the three counted limits, the largest, j=63j=63, holding 4,062,940 CZ, 5,287,620 RZ and 7,940,324 SX gates. The shared-AND synthesis is the same phase oracle built from shared AND indicators and compute–diagonal–uncompute relative-phase Toffoli operations. It agrees in amplitude with the validated circuit on three- and four-group instances (largest difference 1.5×10−151.5\times10^{-15}), marks all 4,096 basis states of the full register at the threshold score 42 as the validated circuit does (largest deviation 1.0×10−121.0\times10^{-12}), and its chained routing reproduces the marginal of the logical circuit on the search register on two- and three-group instances at j=1j=1 to 4 (largest probability difference 6.1×10−146.1\times10^{-14}).

compilationstatusCZ per body, mean (min–max)J^dev\widehat{J}_{\mathrm{dev}}JdevJ_{\mathrm{dev}}
validated synthesis, chained layoutsmeasured, 62 bodies, CZ counted only95,246 (91,445–97,937)5252; CCZ(52)=4,953,241C_{\mathrm{CZ}}(52)=4,953,241, CCZ(53)=5,046,837C_{\mathrm{CZ}}(53)=5,046,837
shared-AND synthesis, one iteration compiled whole, simulated backendprototype, three routing seeds61,320–64,05078–81not defined (one iteration only)
shared-AND synthesis, chained layouts, live backend (calibration of 11 November 2026)measured, 78 bodies64,522 (61,853–66,987)7777; CCZ(77)=4,966,659C_{\mathrm{CZ}}(77)=4,966,659, CCZ(78)=5,032,743C_{\mathrm{CZ}}(78)=5,032,743

Table A6. The largest executable iteration count at checkpoint 200, threshold score 42, backend ibm_fez: CZ gates per compiled iteration body, the estimate of Eq. (31) and the exact JdevJ_{\mathrm{dev}} of Eq. (30), with the cumulative CZ counts on either side of the limit.

Restricted draw. With mBBHTm_{\mathrm{BBHT}} the range of Eq. (6) at a round, the hardware search draws

j∼U{0,…,min⁡(⌈mBBHT⌉−1,Jdev)}.(32)j \sim U\left\{0,\ldots,\min\left(\lceil m_{\mathrm{BBHT}\rceil}-1,J_{\mathrm{dev}}\right)\right\}. \tag*{(32)}

When Jdev≥⌈mBBHT⌉−1J_{\mathrm{dev}}\ge\lceil m_{\mathrm{BBHT}}\rceil-1, Eq. (32) is the draw of Eq. (6) and leaves the random-number stream unchanged; with the rule switched on but inactive, a simulated search reproduces the sequential reference round for round. When the bound is active, the support of the draw changes, and the search is reported as hardware-constrained BBHT rather than as an unmodified run of the original algorithm. Criterion D updates its rank distribution after each failed round with the success probability of Eq. (5) at the iteration count actually executed, so its update is computed from the executed counts whether or not the bound is active; statements that rely on the unconstrained draw, such as expected numbers of rounds or of Grover iterations before termination, do not carry over. No out-of-range draw is redrawn, no drawn circuit is truncated and no simulator outcome replaces a device measurement.

Restricted rounds. Over the RR executed rounds of a search, the observed fraction of rounds whose draw was restricted is

p^cap=1R∑rounds1[Jdev<⌈mBBHT⌉−1],(33)\widehat{p}_{\mathrm{cap}}=\frac{1}{R}\sum_{\mathrm{rounds}}\mathbf{1}\left[J_{\mathrm{dev}}<\lceil m_{\mathrm{BBHT}}\rceil-1\right], \tag*{(33)}

a count over the executed rounds rather than a probability estimated from hypothetical ones; the search logs the indicator for every round together with jj, the upper end of its draw and JdevJ_{\mathrm{dev}}. The executed values of jj, the total QQ of Eq. (14), p^cap\widehat{p}_{\mathrm{cap}} and every active bound with the threshold and the counts that caused it are reported per checkpoint with the run, in Appendix § 16.

Service-side checks and evidence. The service also limits each qubit to 26.8 million low-level control-system instructions, to which dynamical decoupling adds after the gate count, so Eq. (30) is a necessary screen on the client side and not a guarantee that a circuit is accepted or executed faithfully; a rejection is logged with the service’s error and stops the stage, and the circuit is neither replaced nor given a smaller jj. Two jobs of an earlier compilation on ibm_fez show that the limit binds this workload: one circuit was rejected for 5,010,852 CZ gates against the limit of 5,000,000, and a circuit of 4,116,057 CZ gates, run with dynamical decoupling, was accepted and finished; that circuit, with j=23j=23, was round 39 of the first search. The completed run then executed shared-AND circuits of up to 4,284,266 CZ gates (j=60j=60), all accepted.

Status and scope. Three objects are kept apart: the BBHT schedule of Eq. (6), the feasibility bound JdevJ_{\mathrm{dev}} of the compiled circuits, and the trace of the executed counts jj. The accounting of Eqs. (29) and (30), the draw of Eq. (32) and the logging of Eq. (33) are implemented; Eq. (29) is checked on assembled circuits, JdevJ_{\mathrm{dev}} is measured at one checkpoint, threshold and backend, and the equivalence and routing checks above are passed. In the completed run, the restriction was logged on the 191 rounds from round 40 of the first search onward, when the search changed to the shared-AND compilation, and was active in none of them, so every search used the unmodified draw of (6); the largest count executed, j=60j = 60, stays below the schedule maximum of 63 (§ 3.3, Appendix § 16). The hardware searches use the full Interaction-Guided Schedule Oracle of § 2.4: the integer coefficients from the checkpoint evaluation enter the circuit as constants, the circuit evaluates the score of every schedule coherently and marks the schedules above the threshold, no table of schedule scores is computed or loaded, and each measured schedule is checked by one classical evaluation of Eq. (27). The hardware validation of Appendix § 8, with a 16-row lookup oracle, is a separate experiment. These counts describe feasibility and search behavior on the device and make no statement about end-to-end training acceleration.

Hardware-sampled closed loop: search paths and IBM turnaround

Each search of § 3.3 ran on the least busy of three 156-qubit IBM Heron devices at the start of its checkpoint, with one shot per circuit and up to four circuits per job. Before each search, the compiled oracle was checked on the constants of that checkpoint, in amplitude on a three-group instance and on all 4,096 basis states of the full register. Rounds 1 to 39 of the first search used earlier compilations of the same oracle; every later round used the shared-AND compilation of Appendix § 15. A round draws its iteration count, runs one circuit and checks the sampled schedule classically with Eq. (27); when a job holds several pre-drawn rounds, its results are read in order and the rounds after an improvement or a stop are not used. Every sample that entered a decision was measured on the device: no simulator sample replaced a device sample, no instance was reduced and no draw was changed or truncated.

Table A7 gives the threshold path of each search, the rounds and Grover iterations after its last threshold update, and its circuit with the largest jj. Table A8 gives the IBM turnaround of the jobs, from submission to completion at IBM with the queue included, split into queue and device time, and the QPU time charged. Over the five searches, 94 jobs took 37,300 s (10.4 h) of turnaround for 188 s of charged QPU time. Three further jobs at the first checkpoint, whose rounds were set aside, took 1,768 s and 6 s of QPU time, and an acceptance test before the run took 30 s and 2 s.

checkpointthreshold path Φ\Phi (round)roundsiterationsjj (round)CZ gatesdepth
2000 → 3 (4) → 5 (5) → 9 (7) → 11 (11) → 19 (14) → 42 (19)2422754 (43)3,488,6956,088,686
4000 → 4 (1) → 30 (4) → 64 (10)2526056 (34)3,896,1996,613,655
6000 → 8 (3) → 30 (4) → 67 (23)2520945 (46)3,216,4705,446,316
8000 → 6 (4) → 12 (14) → 18 (29)2626460 (53)4,181,4587,119,097
10000 → 2 (14) → 5 (22)2724760 (48)4,284,2667,236,444
all127 of 2301,207 of 1,381

Table A7. Threshold path, stopping phase and circuit with the largest jj of each hardware-sampled search. The path lists the threshold score Φ\Phi after each update with the round of the update, starting from the uniform-rate baseline at 0. The deepest circuit of the run, round 39 at checkpoint 200 (j=23j = 23, 4,116,057 CZ gates, depth 7,787,203), used an earlier compilation.

checkpointdevicejobsIBM turnaround (s) sumIBM turnaround (s) median / longest jobqueue (s)device (s)QPU charged (s)
200ibm_fez, ibm_marrakesh196,930261 / 1,213406,89038
400ibm_marrakesh174,755219 / 992284,72734
600ibm_kingston2010,588309 / 3,8764,6555,93440
800ibm_kingston206,406210 / 1,057336,37340
1000ibm_marrakesh188,620350 / 1,8781,8496,77136
all9437,3006,60530,696188

Table A8. IBM turnaround of the hardware-sampled searches: jobs with a result, turnaround from submission to completion at IBM (queue included), queue and device time, and QPU time charged.

References

  1. [1]Matthew Amy, Olivia Di Matteo, Vlad Gheorghiu, Michele Mosca, Alex Parent, and John Schanck. Estimating the cost of generic quantum pre-image attacks on SHA-2 and SHA-3. In Selected Areas in Cryptography (SAC 2016), volume 10532 of LNCS, pp. 317–337, 2017. doi: 10.1007/978-3-319-69453-5_18.DOI
  2. [2]Ryan Babbush, Jarrod R. McClean, Michael Newman, Craig Gidney, Sergio Boixo, and Hartmut Neven. Focus beyond quadratic speedups for error-corrected quantum advantage. PRX Quantum, 2:010103, 2021. doi: 10.1103/PRXQuantum.2.010103.DOI
  3. [3]Atılım Güneş Baydin, Robert Cornish, David Martínez Rubio, Mark Schmidt, and Frank Wood. Online learning rate adaptation with hypergradient descent. In International Conference on Learning Representations (ICLR), 2018. URL https://openreview.net/forum?id=BkrsA2ZWaB.arxiv.org/abs/1703.04782
  4. [4]Michel Boyer, Gilles Brassard, Peter Høyer, and Alain Tapp. Tight bounds on quantum searching. Fortschritte der Physik, 46(4-5):493–505, 1998.
  5. [5]Chris Cade, Marten Folkertsma, Ido Niesen, and Jordi Weggemans. Quantifying Grover speed-ups beyond asymptotic analysis. Quantum, 7:1133, 2023. doi: 10.22331/q-2023-10-10-1133.DOI
  6. [6]Jwo-Sy Chen, Erik Nielsen, Matthew Ebert, Volkan Inlek, Kenneth Wright, Vandiver Chaplin, Andrii Maksymov, Eduardo Páez, Amrit Poudel, Peter Maunz, and John Gamble. Benchmarking a trapped-ion quantum computer with 30 qubits. Quantum, 8:1516, 2024. doi: 10.22331/q-2024-11-07-1516.DOI
  7. [7]David A. Cohn, Zoubin Ghahramani, and Michael I. Jordan. Active learning with statistical models. Journal of Artificial Intelligence Research, 4:129–145, 1996. doi: 10.1613/jair.295. URL https://www.jair.org/index.php/jair/article/view/10158.DOI
  8. [8]Corinna Cortes and Vladimir Vapnik. Support-vector networks. Machine Learning, 20(3):273–297, 1995. doi: 10.1007/BF00994018.DOI
  9. [9]Christoph Dürr and Peter Høyer. A quantum algorithm for finding the minimum. arXiv preprint quant-ph/9607014, 1996. URL https://arxiv.org/abs/quant-ph/9607014.
  10. [10]Luca Franceschi, Paolo Frasconi, Saverio Salzo, Riccardo Grazzi, and Massimiliano Pontil. Bilevel programming for hyperparameter optimization and meta-learning. In Proceedings of the 35th International Conference on Machine Learning (ICML 2018), volume 80 of Proceedings of Machine Learning Research, pp. 1568–1577, 2018. URL https://proceedings.mlr.press/v80/franceschi18a.html.
  11. [11]Yoav Freund and Robert E. Schapire. A decision-theoretic generalization of on-line learning and an application to boosting. Journal of Computer and System Sciences, 55(1):119–139, 1997.DOI

Paper details

vlnc:W_pscndwna
Version
v1 · latest
Published
Fresh — added to the Hub within the last 30 days
Added
License
CC BY 4.0
Usage

views · 0

downloads · 0

A view counts once per browser per day, a download each time the PDF is requested.

  • Computer Science

Not recorded for this paper

View statement
Looking for related papers…
Contents