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 possible profiles. This combinatorial growth motivates the quantum-search formulation developed here.
This paper studies quantum minimum finding for joint learning-rate selection across layer groups, where each group chooses from 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 -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 possibilities using 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 learning-rate profiles, each represented by one basis-state index of a quantum search register that holds all of them in superposition. For example, candidate profiles require three search qubits, represented by . 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 , 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 optimizer steps with mean time , the classical training time is
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 groups and searches only the rate assigned to each group :
where denotes the trainable parameters of group , and is the update direction supplied by back-propagation and the optimizer.
From Eq. (2), each group chooses one learning rate. Let contain admissible rates. A learning-rate profile selects one member of for each of the groups, so the complete profile space contains combinations:
Each of these profiles is one candidate learning-rate setting for the model.
The quantum search register encodes the learning-rate profiles of Eq. (3). Let denote the table of profiles that a search covers, one profile per row and rows in total. A register of qubits has computational basis states (Grover, 1996); therefore a of rows requires search qubits. Each profile is represented by its binary row index as the basis state of the register, and the search begins from the uniform superposition over the encoded profiles:
For the complete profile space , contains profiles. When only a subset is searched, is the number of rows included in , 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 ).
To find a useful profile during training, the search over 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 , the quantity to be minimized. Let be the current threshold profile and its score, the number of profiles in the -row with , and 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 and exactly three profiles in have lower scores, then ; the search does not know this value in advance. A round prepares of Eq. (4), applies Grover iterations, measures once, and tests whether the measured profile lies below the current threshold. A successful round returns some profile with , which becomes the new threshold profile. For fixed , , and , the probability that a round returns a profile below the threshold is
Because 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 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 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 denote the upper scale of this range; in each round is drawn uniformly from . 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 , applies oracle–diffuser iterations, measures one row, and checks whether its score improves the current threshold ; a success moves the threshold and resets the range from which is drawn, a failure keeps it and enlarges that range. At the illustrative size with rows below the threshold, a round with measures a marked row with probability 78.1% by Eq. (5).
For any , Boyer et al. [4] show that a search with unknown requires Grover iterations in expectation. Across the successive threshold updates, Dürr & Høyer [9] bound the expected total number of Grover iterations needed to reach the minimum by
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 receives a score , obtained by training from the current checkpoint under that profile. Given the current threshold profile , profiles satisfying 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, , with one score corresponding to each row of . Thus, specifies the profiles being searched, whereas supplies the scores used by the simulated oracle.
Using , the simulated lookup oracle applies the required threshold marking
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 on the device, whereas the experiments obtain the same threshold decision from .
Figure A3. Threshold oracle: the proposed coherent circuit and what the experiments simulate. A quantum search over needs an oracle that flips the sign of every row whose score lies below the threshold, . The proposed circuit evaluates the score on the device and compares it with there. The experiments simulate this behavior: the scores are computed classically, one replay of optimizer steps per row, and stored in , 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 . The quantum search acts on profile indices, while classical replay constructs ; because the score depends on replay length, is defined at a replay horizon .
The replay horizon. At checkpoint , is constructed by replaying each candidate profile for optimizer steps from the same saved model and optimizer state, using the same sequence of training batches. Let denote the resulting held-out evaluation loss. The checkpoint-local score at horizon is
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 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 of this paper was built, 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 replayed steps as the score,
Selection target. The target of a selection at checkpoint is the minimizer of that checkpoint’s own , computed using only measurements up to :
A search that returns the profile instead of has the regret , zero when the minimizer is returned.
Termination criteria
Because , 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 by an 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 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 be the Grover iterations spent so far and the threshold visits so far, the initial one included, with the base-2 logarithm:
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:
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 . Both are computed classically from the observed rounds.
Criterion C counts the consecutive failed rounds of one visit once the range has saturated, where Boyer et al. [4] guarantee a success probability of at least whenever ; if a better profile remains, such failures occur with probability at most , and the count restarts at every threshold update:
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 over the rank of the current threshold within , uniform at the start, , is updated after every round of a visit from the distribution held at its start, and the search stops when the probability that a better profile remains falls below , :
normalizes to total mass one after each update, and the next visit starts from .
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 therefore splits into the iterations that improve the threshold and those spent in the terminal visit before stopping:
Here the improvement effort counts the iterations of visits that find a better threshold and the stopping effort those of the final visit before criterion 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 of Eq. (3) takes , and the uniform-rate baseline has every . 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 , the single-group gain, is the gain of moving group alone to the rate , 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 and 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 when and otherwise. The interaction score of a schedule is
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 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 search qubits hold all schedules of rates over groups. With the integer form of and the current threshold schedule, the oracle marks every schedule that scores above the threshold:
The search starts with the uniform-rate baseline , 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, , 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 , 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 over the selection instants , the minimizers form the series and the selected profiles . Whether a selected series helps the fine-tuning is checked by training under it: a full run trains the steps under the uniform-rate baseline until the first selection instant and under each minimizer until the next,
and the trained model is compared with the run under 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 in place of , 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 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 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 (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 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 ; 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.
| criterion | rounds | P(min. found) | regret | ||
| A global time-out | 77.3 | 1.000 | 0 | ||
| B per-visit budget | 29.3 | 0.999 | |||
| C confidence count | 52.2 | 1.000 | 0 | ||
| D state-dependent stop | 28.3 | 0.999 |
Table 1. Search effort and selection quality under four termination criteria ().
Criteria B and D stop after fewer search rounds while maintaining comparable selection quality. 5,000 simulated trials per criterion, 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.
| run | held-out loss at step | accuracy (%) | |||||||
| 400 | 600 | 800 | 1000 | 1221 | SciQ | PubMedQA | ARC-Easy | MMLU | |
| oracle, single batch | 2.6663 | 2.6666 | 2.6710 | 2.6753 | 2.6827 | 89.4 | 62.1 | 62.5 | 38.4 |
| oracle, five-batch average | 2.6661 | 2.6630 | 2.6614 | 2.6682 | 2.6758 | 89.6 | 61.6 | 62.9 | 38.7 |
| oracle, sampled on IBM hardware | 2.6696 | 2.6654 | 2.6645 | 2.6731 | 2.6806 | 89.5 | 61.3 | 62.5 | 38.8 |
| uniform rate, same seed | 2.6670 | 2.6639 | 2.6673 | 2.6715 | 2.6795 | 89.8 | 61.6 | 62.6 | 39.1 |
| uniform rate, five seeds (range) | 89.4–90.6 | 60.7–64.7 | 61.3–63.3 | 37.9–41.1 | |||||
| base model, no fine-tuning | 89.8 | 59.6 | 61.7 | 37.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.
| checkpoint | device | returned schedule | largest | ||||
| 200 | ibm_fez, ibm_marrakesh | (1.4, 0.7, 1.4, 1.4, 0.5, 1.4) | 42 | 43 | 235 | 6 | 54 |
| 400 | ibm_marrakesh | (0.7, 0.5, 1.4, 0.7, 1.4, 0.7) | 64 | 35 | 262 | 3 | 56 |
| 600 | ibm_kingston | (1.4, 1.4, 0.5, 0.5, 0.7, 0.5) | 67 | 48 | 307 | 3 | 45 |
| 800 | ibm_kingston | (0.5, 1.4, 1.0, 1.4, 0.7, 1.0) | 18 | 55 | 298 | 3 | 60 |
| 1000 | ibm_marrakesh | (1.0, 0.5, 0.7, 0.7, 1.4, 1.4) | 5 | 49 | 279 | 2 | 60 |
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; , final integer interaction score; , rounds; , Grover iterations; , threshold updates; largest , 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 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 , the interaction score keeps the form of Eq. (15):
where every gain and interaction is measured around 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 ; 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 be the longest horizon replayed, a measured subset of the profiles of , and the Spearman rank correlation. At checkpoint , the rank agreement of horizon with is
Table A1 reports for at checkpoints , on the same measured subset of 16 profiles at every horizon and checkpoint.
| 0.697 | 0.909 | 0.994 | 0.994 | 0.977 | 0.991 | |
| 0.677 | 0.965 | 0.991 | 0.985 | 0.974 | 0.824 | |
| 0.991 | 0.979 | 0.982 | 0.977 | 0.994 |
Table A1. Rank agreement of Eq. (19) at three checkpoints of a run under the uniform profile (one seed), over the same measured subset 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 of this paper was built, is the shortest horizon at which 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 , 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 ; the five entries of a row at therefore come from one replay per profile, each compared with the 200-step mark of the same replay. The 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 time steps per execution of the initialization stage, which prepares the uniform state over the 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 Grover iterations over threshold visits, the initial one included, has therefore used 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, . 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 is ever chosen as the threshold with probability , so the expected number of threshold updates is , with the th harmonic number, and the expected initialization time is at most . Stopping at returns the minimum with probability at least (Theorem 1 of the same paper).
Criterion B. Criterion B, Eq. (11), limits one threshold visit. Within the current visit the iteration counts 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, , without finding a better profile, the run stops and returns the threshold. At the budget is , 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 , where is drawn uniformly from . For marked rows and uniform on , Boyer et al. (1998, Lemma 2) give the probability that one round returns a marked row as with , and show whenever . Since , the condition at reads ; the product is smallest at and , where the condition becomes , so it holds for every once , and satisfies it a fortiori. The threshold row is never marked, so in every visit, and at every round fails. Within one visit the threshold, and with it , is fixed; each round prepares the uniform state afresh, draws its own and measures once, so the saturated rounds of a visit are independent trials with failure probability whenever . The probability that consecutive saturated rounds all fail while a better row exists is therefore at most , and is the smallest with : , and for , and . The bound holds for every and every visit, and it bounds the event that a visit with a better row present ends without finding one; a probability over 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 of the current threshold in Table, rank 1 being the lowest score, and updates it from the outcome and the iteration count 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, . A threshold of rank has exactly rows below it, , so a round with iterations fails with probability by Eq. (5); a failed round multiplies by this likelihood, which is Bayes’ rule for that observation, and the factor equals one at because . After iterations from the uniform state the marked rows carry one common amplitude (Boyer et al., 1998, Eq. (3)), so a successful round from rank returns each of the better rows with probability , whatever was [9 proof of Lemma 1], and the new rank is uniform on . Summing this transition over the old ranks gives the success map , applied to the distribution held at the start of the visit, so is the rank distribution of the -th threshold in the descent of Dürr & Høyer [9] from the uniform start and depends on no . The failed rounds of the current visit multiply in turn, and restores total mass one after every update; at a success , the mass on the ranks from which a success is possible. The mass on ranks 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 lies below the current threshold; the run stops when this mass is at most 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 rounds and Grover iterations, one quantum selection takes
Here is the time of one Grover iteration, the device time for one state preparation and measurement, and the time of one classical check.
Training totals. With the termination criteria defined, the training cost separates into the ordinary training time of Eq. (1) and the cost of the profile selections made during the run. At each selection, exhaustive classical search evaluates all profiles at a check time each, costing , whereas quantum minimum finding incurs a selection time that depends on the termination criterion . The two total costs are therefore
Thus, the simulations compare with , with the difference determined by the per-selection cost versus .
Cost convention. In the simulation, the classical work used to construct is not included in the quantum selection time . The exhaustive classical selection remains , Eq. (21), and the two are compared through the ratio , priced with equal unit costs or with hardware-informed clocks (below and Appendix § 8).
Counts. Every round of Eq. (6) has one state preparation, Grover iterations, and one measurement followed by one classical check, so the number of rounds 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 in a trial that reaches the minimum and is the same count; a trial that a criterion ends before the minimum truncates it. The number of threshold updates is recorded as a diagnostic and never priced: by Dürr & Høyer [9] the element of rank becomes the threshold at some point with probability , so with the th harmonic number.
The time convention of the cited analysis. Dürr & Høyer [9] count one time step per Grover iteration and 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 per round, and absorbs the initialization, since every state preparation is one of the 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 the right-hand side of Eq. (20) is , so
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 and
with equality in the limit , the term 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 optimizer steps. A round of the Interaction-Guided Schedule Oracle of § 2.4 also consists of a preparation and measurement, 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 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

Figure A1. Decomposition of one Grover iteration into score computation, threshold marking, score uncomputation, and diffusion. Dashed score blocks denote the declared compute component.
The block timings are estimated from circuits transpiled and scheduled against the calibration of an IBM Heron r2 device. The superscript records the register size and Grover-chain setting used for the corresponding compile or fit, with 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 iteration times,
fitted for each threshold, and the job’s executed time gives .
Superscripts and bands. Every quantity of Eq. (24) that comes from a compile-and-fit carries a superscript : is the register size the circuit was compiled at ( for the search register, for the resolution register) and the largest chain length of the fit, a straight line over ; 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 at which the share of the two quantum terms of Eq. (20) in reaches a given value; below it, of Eq. (23) sits at its floor.
The hardware job. The job ran on ibm marrakesh: seven circuits (the prepared state alone, and 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 s). 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 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 is taken. These four-qubit circuits use a lookup oracle, a diagonal phase over the 16 stored scores, whose depth grows with ; the job validates the layer time, the diffuser depth at and the additivity of iterations, and says nothing about .
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.
| quantity | what it is | how obtained | value (band) |
| layer time | median of over 34 schedules, to 9, two oracle families, three seeds, two back-ends | 33 ns (29–37) | |
| , | one lookup iteration; preparation + readout at | slope and intercept of Eq. (25) over ; executed job | 2.56 / 5.16 s; 2.7 s |
| diffuser depth, search register | one block compiled at ; mean over three seeds, two back-ends | 730 layers (706–747) | |
| comparator depth, resolution register | one block compiled at ; same statistic | 942 layers (896–969) | |
| diffuser and comparator compiled as one circuit | one block, 65 qubits; same statistic; cross-check only | 2,057 layers (1,986 to 2,187); 68 s (66 to 73) | |
| coherent evaluation of the replay score | no circuit is built for it | declared; break-even under “The clocks as measured.” below | |
| resolution register width | with range 4, | 16 (derived ) | |
| one round’s executed wall-clock less its iterations | s from the job metric | 270 s | |
| one classical check | median of 389 timed replays | 355.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 ns, the median of 34 schedules from to 9, stable at ns across register sizes and constant in ; the two oracle families of the executed job give 31.8 and 34.5 ns. The two known depths at the design size are layers (706–747) and layers (896–969), a known part of 1,672 layers, so
Compiling the two blocks as one circuit gives 2,057 layers and 68 s, 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, bits, and is the margin above it. The executed job gives the slopes of Eq. (25) as s for the threshold that marks 4 of the 16 rows and 5.16 s for the one that marks 1, with intercepts to 3.1 s dominated by readout; scheduled again against a later calibration, the slopes reproduce within about 5%. The setup clock is s: the job’s 28,672 shots took 7.92 s of QPU time, 276 s per shot, less the 6.6 s per shot, less the 6.6 s per shot, so the iteration content pooled over its seven circuits; the preparation circuit’s own share is and the rest is the device’s inter-shot reset delay, a backend setting taken as independent of the circuit. One classical check costs 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 s s of optimizer steps. With these clocks and the counts at of Appendix H, the classical checks of one selection take s, 19.5 h, and the two quantum terms of Eq. (20) total less than 0.4 s when . The share of the two terms reaches 1% only if exceeds about layers at the Heron clock, or about layers at a hypothetical fault-tolerant layer of 7.7 s, seven cycles of a distance-7 surface code at the 1.1 s cycle of Google Quantum AI and Collaborators (2025); below that, of Eq. (23) sits at its floor . At the measured sizes the two quantum terms total less than 0.1 s against of 2.8 to 4.1 h, so the choice of clock changes no measured row; it matters only for the continuation to large .
| clock | value (as printed) | how obtained | source | literature comparison |
| , one Grover iteration at the design size | – | Eq. (24): ns, median of 34 compiled schedules ( to 9; the executed job gives 31.8 and 34.5 ns) (706–747) (896–969)] layers (1,602–1,716), bands over 3 seeds 2 calibration snapshots; declared | compiled schedules (this work); App. part A | IonQ Forte MS two-qubit gate median 672 s vs Heron cz 68 ns: about slower per two-qubit gate [6]; Willow surface-code cycle 1.1 s, a logical layer cycles (Google Quantum AI and Collaborators, 2025) |
| , one state preparation + measurement | 270 s | − pooled iteration content ; s/28,672, one total over the seven circuits (, both families); circuit share –3.1 s, the rest is the backend’s inter-shot repetition delay (configured 250 s) | job metrics; backend configuration | The cited AES cost model expresses runtime through circuit depth and cycle time, with no setup term (Sarah D., 2024) |
| , classical check | 355.5 s (336.6 s later population) | median gap between consecutive 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 averaged | training-run replay timing (this work) | — (own workload; Eq. (21) , Eq. (20) ) |
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. follows Eq. (24) with declared; is taken from the executed job described above; 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. mapped to the quantum search register, at an illustrative size ( admissible rates , groups, rows, qubits). Each row of is one profile of Eq. (3), and its row index written in binary is the basis state of the register; every row enters the search with the same amplitude, the state 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 , 128 and 256 rows drawn from the measured cube, and the 25-step replay that scores every row, so . The model, training, table-construction and replay details are given below.
Figure A4. Construction of the score tables: fixed designs of , and 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 . 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 groups of five (three in the last).
The reference run trains the uniform profile for all , and its checkpoints at steps are the five tables’ origins, so .
Profile-table construction. The design table of Sections 2.1–2.3 and Appendix D has admissible rates, rows and , with a resolution register of qubits for the score; the measured eta space is the subset , rows, from which tables of , and 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, with group at rate ; the uniform-rate baseline is .
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 in loss on average, and the evaluation at step 50 of the replay lands within of the logged value. On the tables of Figure A4, the resolution of the score is the drift of the replay itself, of order 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 and 256 the uniform state over the rows is on the qubits of the search register and the diffuser is the standard reflection; for 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 , thresholded at the score 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 and unchanged, on ranks alone: the rank of the initial threshold is drawn uniformly from 1 to , a round with iterations succeeds with the analytic probability of Eq. (5) at 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 , 128 and 256 against the simulations (Appendix § 12) and then continued to larger .
Recorded outcome of the executed full runs
Every run of this section is a full run of Eq. (17), steps under the setup of § 2.5, either under a series (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 denotes the run that holds one profile from the first step. The series executed are , and ; 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 , the mean cross-entropy over a fixed set of 64 held-out sequences of 1,024 tokens, written at , and compared at equal steps with the mean of the uniform runs over the reference seeds. The statistic is the step-matched excess loss and its mean over the tail window of the last ten evaluations,
together with , the number of evaluations in 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 . 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, averaged over : 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.
| run | tail-mean excess loss | evaluations below reference | final evaluation loss | benchmark flag |
| −0.0011 | 6 of 10 | 2.6842 | no | |
| +0.0006 | 4 of 10 | 2.6798 | no | |
| −0.0013 | 8 of 10 | 2.6795 | no | |
| +0.0016 | 2 of 10 | 2.6831 | no | |
| +0.0001 | 6 of 10 | 2.6809 | no | |
| −0.0074 | 10 of 10 | 2.6721 | no | |
| −0.0130 | 10 of 10 | 2.6634 | no | |
| −0.0135 | 10 of 10 | 2.6641 | no | |
| −0.0123 | 10 of 10 | 2.6632 | no | |
| −0.0140 | 10 of 10 | 2.6626 | no | |
| −0.0141 | 10 of 10 | 2.6612 | no | |
| −0.0146 | 10 of 10 | 2.6630 | no | |
| −0.0147 | 10 of 10 | 2.6593 | no | |
| −0.0162 | 10 of 10 | 2.6605 | no | |
| −0.0159 | 10 of 10 | 2.6583 | no | |
| −0.0172 | 10 of 10 | 2.6593 | no | |
| −0.0159 | 10 of 10 | 2.6576 | no | |
| −0.0172 | 10 of 10 | 2.6594 | no | |
| −0.0162 | 10 of 10 | 2.6588 | no | |
| −0.0173 | 10 of 10 | 2.6596 | no | |
| −0.0162 | 10 of 10 | 2.6595 | no | |
| −0.0168 | 10 of 10 | 2.6604 | no | |
| −0.0160 | 10 of 10 | 2.6595 | no | |
| −0.0168 | 10 of 10 | 2.6605 | no |
Table 4.
| series run | compared with | difference | evaluations lower |
| −0.0153 | 10 of 10 | ||
| −0.0021 | 10 of 10 | ||
| −0.0003 | 5 of 10 | ||
| −0.0002 | 5 of 10 | ||
| −0.0153 | 10 of 10 | ||
| −0.0039 | 10 of 10 | ||
| −0.0002 | 6 of 10 | ||
| −0.0152 | 10 of 10 | ||
| −0.0013 | 9 of 10 | ||
| −0.0001 | 5 of 10 | ||
| −0.0001 | 5 of 10 | ||
| −0.0173 | 10 of 10 | ||
| −0.0023 | 10 of 10 | ||
| +0.0004 | 3 of 10 | ||
| +0.0004 | 4 of 10 | ||
| −0.0177 | 10 of 10 | ||
| −0.0033 | 10 of 10 | ||
| −0.0001 | 5 of 10 | ||
| −0.0173 | 10 of 10 | ||
| −0.0006 | 8 of 10 | ||
| +0.0004 | 3 of 10 | ||
| +0.0004 | 4 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
| criterion | rounds | queries, improve | queries, stop | P(min. found) | regret | speedup, unit-cost | speedup, hw-informed |
| A DH96 global cutoff | 77.3 | 1.000 | 0 | ||||
| B BBHT cascade budget | 29.3 | 0.999 | |||||
| C BBHT-confidence stop, | 52.2 | 1.000 | 0 | ||||
| D dynamic stop , | 28.3 | 0.999 |
Table A3. Four termination criteria for checkpoint-local Dürr–Høyer selection on the tables, , pooled over five checkpoints, 1,000 Aer trials per checkpoint and criterion, common random numbers. Rounds count state preparations and classical checks alike (Eq. (14)); queries split into the descent work , identical across criteria, and the stopping work , where the criteria differ. The two speedups are of Eq. (22) and of Eq. (23), the latter drawn with the interim clocks , ; the estimate of Eq. (24) is smaller on both and leaves every entry at the floor to two digits.
detail behind Table 1: four criteria, five checkpoints, 20 Aer trials each, 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. | ckpt | minimiser | rounds | q. imp. | q. stop | updates | P(found) | speedup (unit) | speedup (hw) |
| A | 200 | L25b_30 | 77.5 | 7.5 | 228.9 | 3.10 | 1.00 | ||
| A | 400 | corner_low | 78.2 | 7.2 | 227.8 | 3.30 | 1.00 | ||
| A | 600 | corner_low | 78.5 | 7.3 | 226.2 | 3.45 | 1.00 | ||
| A | 800 | corner_low | 78.8 | 7.7 | 226.6 | 3.45 | 1.00 | ||
| A | 1000 | corner_low | 77.1 | 6.2 | 230.8 | 2.95 | 1.00 | ||
| B | 200 | L25b_30 | 27.5 | 7.5 | 29.4 | 3.10 | 1.00 | ||
| B | 400 | corner_low | 27.4 | 7.2 | 29.0 | 3.30 | 1.00 | ||
| B | 600 | corner_low | 27.8 | 7.3 | 29.1 | 3.45 | 1.00 | ||
| B | 800 | corner_low | 28.5 | 7.7 | 28.9 | 3.45 | 1.00 | ||
| B | 1000 | corner_low | 25.7 | 6.2 | 29.1 | 2.95 | 1.00 | ||
| C | 200 | L25b_30 | 50.7 | 7.5 | 121.3 | 3.10 | 1.00 | ||
| C | 400 | corner_low | 50.8 | 7.2 | 121.2 | 3.30 | 1.00 | ||
| C | 600 | corner_low | 51.2 | 7.3 | 121.3 | 3.45 | 1.00 | ||
| C | 800 | corner_low | 51.8 | 7.7 | 120.7 | 3.45 | 1.00 | ||
| C | 1000 | corner_low | 48.9 | 6.2 | 121.3 | 2.95 | 1.00 | ||
| D | 200 | L25b_30 | 26.8 | 7.5 | 26.6 | 3.10 | 1.00 | ||
| D | 400 | corner_low | 26.8 | 7.2 | 25.8 | 3.30 | 1.00 | ||
| D | 600 | corner_low | 27.1 | 7.3 | 25.2 | 3.45 | 1.00 | ||
| D | 800 | corner_low | 27.8 | 7.7 | 25.5 | 3.45 | 1.00 | ||
| D | 1000 | corner_low | 25.1 | 6.2 | 25.9 | 2.95 | 1.00 |
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: is at least 90 against , giving 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 , and 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 tables, , against exhaustive evaluation (dashed, ). One round is one state preparation, Grover iterations, one measurement and one classical check, so preparations and checks both appear as the round count . (a) Unit-cost query model, : 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 units. (b) Hardware-informed estimate, drawn with the interim clocks and and the checks at ; the clocks of Eq. (24) are smaller and change no bar: every bar equals its checking-cost floor . 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 and the interim clocks , (Eq. (24) lowers both and moves no entry). The second table is the validation gate at the three measured sizes: the pass band is on both and , and all three sizes pass.
Part A, measured rows (full width)
| table size | rows | trials (Aer runs or model runs) | rounds (prep. = checks) | s.e. | queries (total) | s.e. | thr. updates (diag.) | classical exhaustive | quantum, unit-cost | speedup (unit-cost) | quantum, hardware-informed | speedup (hardware-informed) | |
| 81 | measured (Aer) | 5,000 Aer runs (5 × 1000) | 28.3 ± 0.1 | 33.8 ± 0.1 | 3.95 | 0.999 | 8.0 h | 8.9 h | 0.90× | 2.8 h | 2.86× | ||
| 128 | measured (Aer) | 5,000 Aer runs (5 × 1000) | 33.3 ± 0.1 | 46.6 ± 0.1 | 4.40 | 1.000 | 12.6 h | 11.2 h | 1.13× | 3.3 h | 3.85× | ||
| 256 | measured (Aer) | 5,000 Aer runs (1 × 5000) | 41.5 ± 0.2 | 71.8 ± 0.2 | 5.10 | 1.000 | 25.3 h | 15.3 h | 1.65× | 4.1 h | 6.17× |
Table 7.
Part B, declared-rule continuation (not a measurement)
| table size | rows | model runs | rounds ± s.e. | queries (total) ± s.e. | thr. updates (diag.) | classical exhaustive | quantum, unit-cost | speedup (unit-cost) | quantum, hardware-informed | speedup (hardware-informed) | |
| 512 | theory cross-check (declared rule) | 2,000 model runs (no table, no circuits) | 51.0 ± 0.3 | 110.3 ± 0.6 | 5.84 | 1.000 | 2.1 d | 21.0 h | 2.41× | 5.0 h | 10.0× |
| 1,024 | theory cross-check (declared rule) | 2,000 model runs (no table, no circuits) | 61.4 ± 0.4 | 164.0 ± 0.8 | 6.56 | 1.000 | 4.2 d | 28.3 h | 3.57× | 6.1 h | 16.7× |
| 4,096 | theory cross-check (declared rule) | 2,000 model runs (no table, no circuits) | 86.4 ± 0.6 | 362.4 ± 1.9 | 7.89 | 1.000 | 16.9 d | 2.2 d | 7.65× | 8.5 h | 47.4× |
| 16,384 | theory cross-check (declared rule) | 2,000 model runs (no table, no circuits) | 117.1 ± 0.7 | 770.5 ± 4.0 | 9.26 | 1.000 | 67.4 d | 4.1 d | 16.3× | 11.6 h | 140× |
| 65,536 | theory cross-check (declared rule) | 1,000 model runs (no table, no circuits) | 154.5 ± 1.3 | 1599.1 ± 11.9 | 10.69 | 1.000 | 269.7 d | 7.9 d | 34.3× | 15.3 h | 424× |
| 262,144 | theory cross-check (declared rule) | 1,000 model runs (no table, no circuits) | 196.9 ± 1.6 | 3253.3 ± 23.2 | 12.24 | 1.000 | 2.96 yr | 15.0 d | 71.9× | 19.4 h | 1,331× |
Table 8.
Part C, agreement at the measured sizes
| table size | rounds, Aer | rounds, model | queries, Aer | queries, model | thr. updates Aer / model (diag.) |
| 81 | 28.3 | 28.4 ± 0.1 | 33.8 | 33.7 ± 0.1 | 3.95 / 3.95 |
| 128 | 33.3 | 33.2 ± 0.1 | 46.6 | 46.5 ± 0.2 | 4.40 / 4.43 |
| 256 | 41.5 | 41.3 ± 0.2 | 71.8 | 71.5 ± 0.2 | 5.10 / 5.12 |
Table 9.
tbl:A4: Selection cost against table size for criterion D (), measured rows only: ideal Grover circuits simulated on Qiskit Aer over the real scores. Trials are checkpoints times trials per checkpoint; rounds and queries carry standard errors; the speedups follow Eqs. (22) and (23) with and the interim clocks , (Eq. (24) lowers both and moves no entry). The full-width rows (threshold updates, classical and quantum times), the declared-rule continuation beyond and its agreement with these rows are given in this appendix.
| size | trials | rounds | queries | speedup (unit-cost) | speedup (hw-informed) | |
| 81 | 5 × 1,000 | 28.3 ± 0.1 | 33.8 ± 0.1 | 0.999 | 0.90× | 2.86× |
| 128 | 5 × 1,000 | 33.3 ± 0.1 | 46.6 ± 0.1 | 1.000 | 1.13× | 3.85× |
| 256 | 1 × 5,000 | 41.5 ± 0.2 | 71.8 ± 0.2 | 1.000 | 1.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 and : is and the break-even sits near . Under the hardware-informed estimate the classical checks dominate and is , the floor at every size: the quantum terms are negligible, one selection costs its classical checks, and the gain comes from needing fewer rounds rather than from a faster circuit. Both ratios exclude the construction of : 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 , and at , and , so the lookup route carries no end-to-end advantage.
Figure A7. Runtime speedup versus table size for criterion D with . Dashed curves are the declared-rule cross-check obtained from the analytic success probability of Eq. (5), and are continued to the design size , 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 and 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 the rule gives rounds and iterations, an of about 72 and an of about 1,330. Along the ladder scales as from 4.1 to 6.4, inside the 11.25 of Eq. (7) and as , so the floor grows almost linearly in . Nothing beyond 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 , 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 block 0 is the 5,000-trial file and therefore contains blocks 1–4; blocks 1–4 alone carry the independent statement.
| block | trial seeds | trials | s.e. | s.e. | P(minimiser found) | misses | |
| 81 | 0 | 1000-1999 | 1,000 | 28.61 ± 0.25 | 33.98 ± 0.24 | 0.999 | 1 |
| 81 | 1 | 2000-2999 | 1,000 | 27.99 ± 0.23 | 33.35 ± 0.23 | 1.000 | 0 |
| 81 | 2 | 3000-3999 | 1,000 | 28.11 ± 0.23 | 33.46 ± 0.23 | 1.000 | 0 |
| 81 | 3 | 4000-4999 | 1,000 | 28.36 ± 0.24 | 33.63 ± 0.24 | 1.000 | 0 |
| 81 | 4 | 5000-5999 | 1,000 | 28.51 ± 0.25 | 33.65 ± 0.24 | 1.000 | 0 |
| 128 | 0 | 1000-1999 | 1,000 | 33.72 ± 0.29 | 47.03 ± 0.35 | 1.000 | 0 |
| 128 | 1 | 2000-2999 | 1,000 | 33.42 ± 0.29 | 46.77 ± 0.33 | 0.999 | 1 |
| 128 | 2 | 3000-3999 | 1,000 | 32.97 ± 0.28 | 46.01 ± 0.32 | 0.998 | 2 |
| 128 | 3 | 4000-4999 | 1,000 | 33.29 ± 0.30 | 46.40 ± 0.33 | 1.000 | 0 |
| 128 | 4 | 5000-5999 | 1,000 | 32.78 ± 0.29 | 46.22 ± 0.35 | 0.998 | 2 |
| 256 | 0 | 1000-5999 | 5,000 | 41.52 ± 0.16 | 71.78 ± 0.22 | 1.000 | 2 |
| 256 | 1 | 2000-2999 | 1,000 | 41.93 ± 0.36 | 72.48 ± 0.51 | 0.999 | 1 |
| 256 | 2 | 3000-3999 | 1,000 | 42.04 ± 0.37 | 72.21 ± 0.50 | 1.000 | 0 |
| 256 | 3 | 4000-4999 | 1,000 | 40.85 ± 0.35 | 70.98 ± 0.48 | 1.000 | 0 |
| 256 | 4 | 5000-5999 | 1,000 | 41.31 ± 0.36 | 71.75 ± 0.50 | 1.000 | 0 |
Table 1 (PDF p. 30).
Interaction-Guided Schedule Oracle: score construction and closed-loop runs
Checkpoint evaluation. At each checkpoint , the checkpoint evaluation of § 2.4 measures change patterns around the uniform-rate baseline . A change pattern moves one, two or three groups away from 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 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 is , and is the gain of moving group alone to the rate . 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 , the interaction term is the discrete derivative of the gain over the moved groups (Sundararajan et al., 2020),
where runs over the sub-patterns of , each moved group keeping its rate in , the empty one with gain zero. For one group, a pair and a triple, with the rates omitted,
where is the measured gain of moving and 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, 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 single, pair and 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 pair and 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 is the larger of the spread of the uniform repeats and the declared ; the repeats are identical within one measurement, so 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 on average; the five-batch run used seeded dropout and deterministic kernels.
Integer score. Each coefficient is divided by before it is rounded, which enlarges the small gains before the rounding: for each of the 232 patterns, and the 0.7 correction of group is , so that a group at 0.7 carries its own measured single gain. With when moves every group of in the same direction as (0.5 and 0.7 counting as lowered) and the set of the 232 patterns, the score evaluated by the circuit and by the classical check of each sample is
At checkpoint 200 of the single-batch run, for example, the second layer group has the single gain at 0.5, which rounds to zero directly but to after division by (1.85), and the gain at 0.7 gives , 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, need not equal rounded once.
Around another baseline. Eq. (18) of § 4 writes the score around a baseline schedule as single-group gains plus pair and triple interactions. With the baseline with only the groups of a pattern moved to the rates of , and the patterns of one to three groups on which differs from , the inclusion–exclusion of Eq. (26) around the baseline gives
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 , 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 ; 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 qubits, where the span is the range of , so 22 to 25 qubits in all. The accumulator, in the Fourier basis, receives each and as a phase rotation controlled on the qubits of the groups involved; subtracting , 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 is a nominal setting and not a calibrated error level, and the returned schedule is not certified as the maximizer of . 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 in units of , the rounds and Grover iterations 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 measurements | five-batch measurements | ||||||||||
| leg | schedule | qubits | schedule | qubits | sign flips | ||||||
| 200 → 400 | (0.5, 1.4, 1.4, 0.5, 0.7, 0.5) | 129 | 87 | 264 | 24 | (0.5, 1.0, 1.4, 0.7, 1.4, 0.7) | 12 | 62 | 271 | 22 | 106 |
| 400 → 600 | (0.5, 1.4, 0.7, 0.7, 1.4, 1.4) | 66 | 102 | 296 | 24 | (1.4, 0.7, 0.7, 0.7, 0.5, 1.4) | 25 | 75 | 320 | 22 | 76 |
| 600 → 800 | (1.4, 0.5, 1.4, 0.7, 1.4, 1.4) | 78 | 109 | 494 | 24 | (0.7, 0.5, 0.5, 0.5, 1.4, 0.5) | 33 | 77 | 289 | 22 | 79 |
| 800 → 1000 | (1.4, 1.4, 0.5, 0.7, 1.4, 1.4) | 162 | 61 | 292 | 25 | (1.4, 0.7, 1.4, 0.5, 1.4, 0.5) | 11 | 52 | 269 | 23 | 73 |
| 1000 → 1221 | (0.7, 1.4, 0.5, 1.4, 1.0, 1.4) | 28 | 76 | 304 | 24 | (1.4, 1.4, 0.5, 1.4, 0.5, 0.7) | 32 | 76 | 292 | 22 | 88 |
Table A5. The five decisions of each closed-loop run. The scores 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 Grover iterations is assembled from compiled pieces: a prefix that prepares the uniform superposition on the search qubits, then iteration bodies, then the measurement of the search register. Body is one Grover iteration, the oracle of Eq. (16) followed by the diffuser, routed on the device starting from the qubit placement that body 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,
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 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 , and 3,478,853, 4,525,511 and 6,797,218 at .
The limit. IBM specifies per-circuit limits of two-qubit gates, RZ gates and 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 those added by the -th body, the largest iteration count within the per-circuit gate limits of the service is
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 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 , the admissible counts form the interval , and 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 exactly. During the search, bodies are compiled only as far as the current block of rounds can draw, at most at ; if all of them fit, the search records only 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 .
Estimate before compilation. Before the whole range is compiled, a first-order projection follows from the fixed counts and a representative per-iteration count of each gate type,
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 , above the schedule maximum of 63, so every circuit the schedule can draw at this threshold is inside the three counted limits, the largest, , 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 ), marks all 4,096 basis states of the full register at the threshold score 42 as the validated circuit does (largest deviation ), and its chained routing reproduces the marginal of the logical circuit on the search register on two- and three-group instances at to 4 (largest probability difference ).
| compilation | status | CZ per body, mean (min–max) | ||
| validated synthesis, chained layouts | measured, 62 bodies, CZ counted only | 95,246 (91,445–97,937) | 52 | 52; , |
| shared-AND synthesis, one iteration compiled whole, simulated backend | prototype, three routing seeds | 61,320–64,050 | 78–81 | not defined (one iteration only) |
| shared-AND synthesis, chained layouts, live backend (calibration of 11 November 2026) | measured, 78 bodies | 64,522 (61,853–66,987) | 77 | 77; , |
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 of Eq. (30), with the cumulative CZ counts on either side of the limit.
Restricted draw. With the range of Eq. (6) at a round, the hardware search draws
When , 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 executed rounds of a search, the observed fraction of rounds whose draw was restricted is
a count over the executed rounds rather than a probability estimated from hypothetical ones; the search logs the indicator for every round together with , the upper end of its draw and . The executed values of , the total of Eq. (14), 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 . 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 , was round 39 of the first search. The completed run then executed shared-AND circuits of up to 4,284,266 CZ gates (), all accepted.
Status and scope. Three objects are kept apart: the BBHT schedule of Eq. (6), the feasibility bound of the compiled circuits, and the trace of the executed counts . 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, 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, , 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 . 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.
| checkpoint | threshold path (round) | rounds | iterations | (round) | CZ gates | depth |
| 200 | 0 → 3 (4) → 5 (5) → 9 (7) → 11 (11) → 19 (14) → 42 (19) | 24 | 227 | 54 (43) | 3,488,695 | 6,088,686 |
| 400 | 0 → 4 (1) → 30 (4) → 64 (10) | 25 | 260 | 56 (34) | 3,896,199 | 6,613,655 |
| 600 | 0 → 8 (3) → 30 (4) → 67 (23) | 25 | 209 | 45 (46) | 3,216,470 | 5,446,316 |
| 800 | 0 → 6 (4) → 12 (14) → 18 (29) | 26 | 264 | 60 (53) | 4,181,458 | 7,119,097 |
| 1000 | 0 → 2 (14) → 5 (22) | 27 | 247 | 60 (48) | 4,284,266 | 7,236,444 |
| all | 127 of 230 | 1,207 of 1,381 |
Table A7. Threshold path, stopping phase and circuit with the largest of each hardware-sampled search. The path lists the threshold score 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 (, 4,116,057 CZ gates, depth 7,787,203), used an earlier compilation.
| checkpoint | device | jobs | IBM turnaround (s) sum | IBM turnaround (s) median / longest job | queue (s) | device (s) | QPU charged (s) |
| 200 | ibm_fez, ibm_marrakesh | 19 | 6,930 | 261 / 1,213 | 40 | 6,890 | 38 |
| 400 | ibm_marrakesh | 17 | 4,755 | 219 / 992 | 28 | 4,727 | 34 |
| 600 | ibm_kingston | 20 | 10,588 | 309 / 3,876 | 4,655 | 5,934 | 40 |
| 800 | ibm_kingston | 20 | 6,406 | 210 / 1,057 | 33 | 6,373 | 40 |
| 1000 | ibm_marrakesh | 18 | 8,620 | 350 / 1,878 | 1,849 | 6,771 | 36 |
| all | 94 | 37,300 | 6,605 | 30,696 | 188 |
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]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]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]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]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]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]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]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]Corinna Cortes and Vladimir Vapnik. Support-vector networks. Machine Learning, 20(3):273–297, 1995. doi: 10.1007/BF00994018.DOI
- [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]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]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








