Structured Scaling of AI Discovery Across Diverse Scientific Domains — part 8/12

Cleaned-text code points [109590, 125360). Bibliography omitted here; source.md includes it.

### F Ablation Studies

In this section, we conduct a series of ablation studies to systematically evaluate the contribution of individual components and the robustness of our proposed framework.

#### F.1 Ablations on Different Designs of Φ \Phi

In this section, we ablate the inspiration sample algorithm—a core component of our framework—to demonstrate how different strategies to sample inspirations from historical attempts can impact the search process.

To systematically investigate this, we evaluate multiple selection algorithms on the First Autocorrelation Inequality and the Erdős Minimum-Overlap Problem. We compare naive baselines, including Random (uniform sampling from all historical nodes) and Balance (a purely score-driven heuristic), against more sophisticated approaches, including RPUCG and LLM-Elite (which uses semantic evaluation to maintain an elite set of inspirations, as detailed in Methods). Additionally, for the RPUCG policy, we ablate the number of provided inspirations ( i ​ n ​ s ​ p ∈ { 1 , 3 , 5 , 10 } insp\in\{1,3,5,10\} ) to understand the effect of context size on the generation quality. The results are summarized in Table 2 .

The results indicate that purely score-based or random sampling methods generally fall short in providing consistent, high-quality guidance compared to advanced strategies like LLM-Elite and RPUCG . Evaluating the heuristic value of a node solely by its current scalar score is often myopic; a node with an ordinary immediate score might actually serve as a critical stepping stone to a globally optimal region. Methods like LLM-Elite address this by leveraging semantic insights, while RPUCG utilizes graph-based state-value estimation, coupled with an explicit balance of exploration and exploitation. This demonstrates that effective inspiration selection must incorporate structural or semantic information beyond mere intermediate performance scores.

The ablation on the number of inspirations ( i ​ n ​ s ​ p insp ) within the RPUCG framework reveals a delicate balance between exploration and context coherence. When the inspiration pool is too small (e.g., i ​ n ​ s ​ p = 1 insp=1 ), the model tends to perform marginal refinements along a single trajectory, severely limiting its ability to crossover ideas and discover novel directions. Conversely, providing an excessively large number of inspirations (e.g., i ​ n ​ s ​ p = 10 insp=10 ) crowds the context window, causing the model to become distracted or confused by overwhelming, and sometimes conflicting, global information. Empirically, for a single continuous run, setting i ​ n ​ s ​ p = 3 insp=3 or i ​ n ​ s ​ p = 5 insp=5 emerges as the optimal sweet spot, providing sufficient diversity without overwhelming the model’s reasoning capabilities.

While these experiments validate the conceptual advantages of using semantically and structurally aware selection policies with an optimal inspiration size, it is worth noting that the absolute numerical differences in peak performance across strategies are relatively modest. This reinforces our central thesis: the primary driver of discovery is the systematic scaling of the evaluation budget (TES), rather than complex selection heuristics. Our overarching evolutionary pipeline is inherently robust, leaving the design of more sophisticated sampling policies as an orthogonal direction for future work.

#### F.2 Ablation on Reflection and Failure Patterns

Recall that our algorithm constructs the next query by integrating the task instruction, the selected inspirations S ( c ) S^{(c)} , and the chain-local memory ℛ ( c ) \mathcal{R}^{(c)} . To further enrich this contextual memory, we introduce and ablate two complementary mechanisms for textual guidance: Reflection and Failure Patterns . Reflection serves as positive guidance; after a generation batch, the system synthesizes the approach and insights from the best-scoring node, appending this textual summary to the inspiration nodes in S ( c ) S^{(c)} . Conversely, Failure Patterns serve as negative guidance; the system aggregates the most frequent evaluation errors across all nodes in the chain and injects them directly into ℛ ( c ) \mathcal{R}^{(c)} . Together, these mechanisms are designed to explicitly inform the generator about “what worked” and “what to avoid.”

To isolate and evaluate the individual contributions of these two mechanisms, we conduct an ablation study on the First Autocorrelation Inequality and the Erdős Minimum-Overlap Problem. We systematically test four configurations: disabling both features, enabling only Reflection, enabling only Failure Patterns, and enabling both. All other hyperparameters remain identical across the runs. The results are detailed in Table 3 .

The results demonstrate that incorporating explicit negative constraints (Failure Patterns) provides a consistently strong foundation. While adding explicit Reflection (the “On / On” setting) achieves the best performance in the First Autocorrelation Inequality, utilizing Failure Patterns alone (“Off / On”) performs slightly better in the Erdős Minimum-Overlap Problem. Crucially, the absolute performance gap across these configurations is relatively marginal. This minimal variance indicates that our evolutionary framework is inherently robust to the specific combination of textual guidance, provided that basic negative constraints are present to prevent repeated errors.

#### F.3 Efficiency Analysis: Trajectory-level Pruning

While scaling the number of parallel chains generally improves search outcomes, the vast search space often leads to many chains exploring suboptimal directions. To effectively scale our search process and prevent the wasting of computational budget on unpromising trajectories, we introduce pruning strategies. Pruning acts as an early-stopping mechanism: by identifying and terminating underperforming chains during the generation process, we can reallocate computational resources toward the most promising directions without significantly compromising the final solution quality.

To systematically evaluate the impact of pruning, we conduct experiments across six mathematical tasks: three autocorrelation tasks, two circle packing tasks, and the Erdős Minimum-Overlap Problem. Each task is evaluated 3 times with a total chain length of L = 100 L=100 and number of chains C = 32 C=32 (Fix K = 16 K=16 ). We examine pruning through two complementary settings: a two-stage sweep with nominal cutoffs at L = 25 L=25 and L = 50 L=50 , summarized in Figure 7 , and a task-level single-cutoff ablation at nominal L = 12 L=12 and L = 25 L=25 , reported in Table 4 . At each designated cutoff, active chains are ranked by the best score attained up to that point, and a predefined proportion of the lowest-scoring chains is eliminated.

The resulting trade-off, summarized in Figure 7 , demonstrates a surprisingly high preservation rate for the best final score under aggressive pruning. For instance, even when applying a stringent first-stage cutoff at the nominal L = 25 L=25 checkpoint that retains only a single chain, the original best final score is preserved in 10 out of the 18 total runs. This suggests that for a substantial portion of successful trials, the structural advantages of the final solution manifest early in the search process. Furthermore, across the two-stage configurations shown in Figure 7 , the relative degradation remains remarkably minimal. In the majority of configurations, the expected score degradation is bounded within 0.01 % 0.01\% , and all configurations exhibit degradation below 0.03 % 0.03\% .

The task-level single-cutoff results in Table 4 further clarify the task dependence underlying the aggregate trend. For the circle packing tasks, early pruning exerts virtually no negative impact, as the performance upper bound is easily accessible and a large proportion of chains can successfully reach it. Conversely, for tasks such as the Autocorrelation Inequalities and the Erdős Minimum-Overlap Problem, initial performance is not always a reliable proxy for final solution quality. In these scenarios, chains often require extended iterative refinement before their true potential is realized. Consequently, the earlier and more aggressive single-cutoff settings can lead to higher elimination rates of optimal solutions and more noticeable score degradation.

These findings affirm that while pruning is an effective and necessary technique for scaling parallel search, its implementation presents multiple challenges. The primary difficulty lies in adaptively selecting a pruning strategy that aligns with the task’s specific landscape. Furthermore, relying solely on intermediate scalar scores for elimination can be myopic. Future work will focus on developing more sophisticated pruning algorithms that incorporate richer contextual signals—such as textual reasoning patterns, trajectory growth trends, and structural heuristics—to make more informed early-stopping decisions.

### G Wall-clock Time Efficiency

We compare the wall-clock time required by SimpleTES and OpenEvolve v0.2.27 to reach the same solution quality under matched search budgets and runtime concurrency. For each task, both methods use the same initial solution and evaluation program. We configure SimpleTES with ( C , K , L ) = ( 16 , 16 , 50 ) (C,K,L)=(16,16,50) , corresponding to 12,800 evaluator queries, and configure OpenEvolve with sixteen islands to match the number of SimpleTES trajectories. Both methods use a maximum concurrency of 128 for generation and evaluation, ensuring comparable evaluator-query budgets, search structures, and aggregate request concurrency. SimpleTES matches OpenEvolve’s whole-run best score 11.8 × 11.8\times faster on third autocorrelation and 18.0 × 18.0\times faster on sum-difference.

### H Quantum Compilation Tasks

This section gives supporting details for the quantum compilation tasks. We separate the material into four parts: problem definitions for the two hardware settings, experimental scaffolds and evaluation setup, discovered programs for the main SimpleTES results, and an additional superconducting routing policy obtained by SimpleTES using Gemini.

#### H.1 Problem definitions

##### Superconducting qubit routing.

On superconducting quantum computers, this compilation task is typically called qubit routing , and is often discussed together with qubit mapping or qubit allocation [ 128 , 28 ] . Superconducting quantum computers encode qubits in electrical circuits fabricated on a chip, typically using Josephson-junction-based devices operated at cryogenic temperatures [ 70 ] . Because these qubits occupy fixed chip locations, native two-qubit operations are available only between selected pairs of physical qubits. This hardware connectivity is represented by a sparse coupling graph, such as a grid lattice or a heavy-hex layout, whose low degree helps reduce frequency collisions and crosstalk while remaining scalable ( Figure 2 a).

This objective is motivated by the fact that SWAPs add extra two-qubit operations and circuit depth; in the evaluation convention used here, one SWAP is decomposed into three added CNOTs [ 76 ] . From a complexity perspective, qubit routing is closely related to token swapping and graph reconfiguration and is NP-hard in general [ 128 , 61 ] . A routing decision that helps one gate may also change the placement seen by all later gates, which makes the long-horizon component essential.

##### Zoned neutral-atom compilation.

Neutral-atom platforms store qubits in atoms and use Rydberg interactions to perform entangling gates. A two-qubit gate can be applied only after the participating atoms are brought within the Rydberg interaction radius [ 133 , 137 ] . In a zoned architecture, the static SLM (Spatial Light Modulator) traps are divided into a storage zone and an entangling zone: idle atoms remain in storage, while atoms participating in the current two-qubit layer are moved into the entangling zone [ 15 , 133 , 80 ] . This separation avoids unnecessarily exposing atoms outside the current interaction layer to a global Rydberg pulse.

Atom transport is implemented by AODs (Acousto-Optic Deflectors), which consist of independently controlled horizontal and vertical tweezer lines. Each intersection between an AOD row and an AOD column creates a potential movable trap. Open activates new AOD rows or columns and loads atoms into AOD traps when these newly activated lines create intersections that coincide with occupied atomic sites. Close deactivates selected AOD rows or columns and releases atoms currently carried on those lines back to the corresponding SLM sites. Move translates the currently activated AOD lines while carrying all atoms loaded on the AOD.

Within one rearrangement step, these operations are subject to two main shuttling constraints. The non-crossing constraint requires active parallel AOD rows or columns to remain separated by at least 2 ​ μ ​ m 2\,\mu\mathrm{m} , so distinct active AOD lines can neither merge into the same position nor exchange their relative order [ 133 , 132 ] . The ghost-spot constraint arises because activating multiple AOD rows and columns simultaneously creates all pairwise row–column intersections as live traps, so a legal rearrangement must avoid unintended auxiliary traps on occupied sites [ 133 , 132 ] ( Figure 2 d).

Zoned neutral-atom compilation involves challenging, tightly coupled decisions about atom placement and AOD-constrained routing. Their effects extend across stages: a placement that shortens one transition can still serialize the next once AOD constraints are enforced, and a reuse decision can save transfers in the current stage while forcing longer motion later. Candidate placements must therefore be evaluated over the full placement trajectory rather than one stage at a time [ 133 , 80 , 132 , 131 ] .

#### H.2 Experimental scaffolds and evaluation setup

##### Superconducting routing setup.

Our experimental scaffold fixes a complete routing engine (circuit parsing, dependency tracking, legality checks, and output construction) and exposes only the decision policy . Concretely, the mutable surface contains two hooks: (i) initial layout construction (a mapping from logical to physical qubits) and (ii) online SWAP selection (choosing a legal SWAP edge at each routing step). This design maximizes the algorithmic search space, allowing the model to implement a broad range of routing strategies. At the same time, it cleanly separates SWAP selection from gate execution, guaranteeing correctness by preventing the model from exploiting invalid gate operations.

Initial program. The initial policy is a refactor of Qiskit’s released LightSABRE Rust implementation, embedded inside the fixed engine. The initial layout procedure is simplified to encourage diverse exploration, while the routing policy stays effectively the same as the LightSABRE regime. This baseline provides a strong hand-engineered starting point with a well-studied quality–runtime tradeoff.

Evaluation. Candidate policies are compiled and executed on a benchmark suite. Routing cost is measured by the number of inserted SWAPs. We evaluate on the 24 circuits selected from the original SABRE study [ 76 ] , across three coupling graphs: IBM’s 20-qubit Q20 , Google’s 105-qubit Willow processor [ 47 ] , and IBM’s 156-qubit heavy-hex architecture Heron [ 97 , 59 ] , yielding 72 routing instances in total. The baselines are SABRE [ 76 ] and its modern variant LightSABRE [ 176 ] . For LightSABRE, we choose the configuration of swap_trials=20, layout_trials=20, max_iterations=4 from the original paper.

##### Zoned neutral-atom setup.