PaperlayerView exact revision on arXiv

Source-linked AI summary

Structured Scaling of AI Discovery Across Diverse Scientific Domains

Haotian Ye, Haowei Lin, Jingyi Tang, Yizhen Luo, Rahul Thapa, Caiyin Yang, Chang Su, Rui Yang, Ruihua Liu, Rundao Li, Zeyu Li, Pengwei Sun, Chong Gao, Dachao Ding, Guangrong He, Miaolei Zhang, Lina Sun, Wenyang Wang, Yuchen Zhong, Zhuohao Shen, Puheng Li, Pan Lu, Bianxiao Cui, Di He, Jianzhu Ma, Junfeng Li, Hexi Baoyin, Yejin Choi, Stefano Ermon, Xiaowen Chu, Tongyang Li, Yuzhi Xu, James Zou

arXiv:2604.19341v2cs.LGcs.AI

TL;DR

AI-driven discovery must scale evaluation loops in a way that prevents redundant search and allows feedback to compound over long horizons. SimpleTES structures evaluator queries across parallel trajectories, refinement, local selection, and history reuse, using one open-source model across 28 problems. It reaches state-of-the-art solutions across five domains, and trajectory-level post-training improves results on both training and held-out mathematics tasks.

  • Problem

    The central question is how to scale AI-driven discovery loops so evaluator signals guide later proposals and progress compounds on open-ended problems.

  • Method

    SimpleTES structures a fixed evaluator-query budget across independent trajectories, iterative refinement, local candidate selection, and proposal construction from evaluated history.

  • Results

    Across 28 open-ended problems, one open-source GPT-OSS model produces state-of-the-art solutions spanning quantum compilation, astrodynamics, AI, scientific algorithms, biology, and mathematics.

  • Takeaways & Limitations

    Structured evaluation-driven scaling is presented as a general mechanism for scientific discovery, without requiring multi-agent coordination, ensembles, or online parameter updates.

  • Takeaways & Limitations

    SimpleTES is limited to problems with feedback that can be obtained automatically and cheaply enough for repeated evaluator queries, and its fixed C, L, K allocation may not suit every task.

Abstract

from arXiv · show

Scientific discovery often requires many cycles of proposing, testing, and refining candidate solutions. Language models can increasingly participate in these loops, but simply generating more attempts does not ensure progress: parallel searches may duplicate one another and iterative refinement may become trapped in poor directions. The central challenge is therefore not only to scale AI-driven discovery, but to structure that scaling so that evaluation signals compound over time. Here we introduce SimpleTES (Simple Test-time Evaluation-driven Scaling), a framework that focuses on the structured scaling of AI discovery loops, organizing evaluator queries across independent trajectories, iterative refinement, local candidate selection, and the selective reuse of evaluated histories. Drawing on structural features of scientific communities, SimpleTES uses a single open-source GPT-OSS model to establish new state-of-the-art solutions across 28 open-ended problems in diverse scientific domains ranging from quantum physics and astronomy to biology, AI, and mathematics. These include a 24.5% reduction in quantum circuit compilation overhead, up to 23% lower propulsive cost for deep-space trajectories, a 2.17x faster lasso-path solver, an 8.5% lower-error whole-brain neural-activity predictor, the fastest reported TriMul kernel, and new mathematical constructions beyond prior human or AI records. We further post-train the model for long-horizon discovery by assigning each attempt the final outcome of the trajectory it helped produce. This improves performance on both training and held-out mathematics problems, further advancing the frontier. Together, these results establish structured scaling as a general mechanism for advancing AI scientific discovery.

Introduction

SimpleTES structures evaluation-driven scaling across parallel exploration, iterative refinement, local selection, and selective reuse of evaluated histories. Applied with one open-source model across 28 open-ended problems, it produces state-of-the-art results spanning diverse scientific domains.

  • Scope: 28 open-ended problems across quantum compilation, astrodynamics, AI foundations, scientific algorithms, biology, and mathematics are addressed with one unchanged procedure and model.Only the evaluator changes between problems.
  • Framework: SimpleTES allocates evaluator queries across independent trajectories, refinement depth, local candidate selection, and history-based proposal construction.Each trajectory advances through refinement steps; at each step, multiple candidates are scored and the highest-scoring candidate is appended.
  • Quantum compilation: 21.7% and 14.9% lower topology-averaged added SWAP overhead are achieved versus SABRE and LightSABRE, respectively.The best policy also reaches 33.3% and 24.5% reductions on Q20 relative to those baselines.
  • Astrodynamics: Up to 23% lower propulsive cost is achieved on historical deep-space mission windows under the same orbital-dynamics evaluator.The benchmarks compare references reconstructed from historical encounter sequences with evolved trajectories using matched models, constraints, and cost definitions.
  • Scientific algorithms and AI: 2.17× faster lasso solving, 8.5% lower whole-brain forecasting error, and improved GPU-kernel performance demonstrate gains on scientific algorithms and AI-related tasks.The lasso result holds across 11 unseen real-world datasets with held-out correctness checks; the forecasting result is reported for the 32-step ZAPBench horizon.

Methods

SimpleTES scales evaluation-driven discovery by organizing independent exploration, iterative feedback, and local candidate selection within a compact design space. It uses evaluator feedback to guide proposals while addressing trajectory lock-in and noisy local commitments.

  • Evaluation-driven loop: The evaluation-driven loop uses a surrogate evaluator V that returns each candidate’s scalar score and auxiliary feedback for subsequent proposals.The policy can include instructions, historical solutions, feedback, and statistics in new proposals.
  • Global exploration: C independent trajectories counter the lock-in risk of sequential refinement, whose single history can become trapped by early choices.Sequential refinement corresponds to the special case (1, L, 1, Φ).
  • SimpleTES framework: SimpleTES organizes evaluator queries through C independent trajectories, L refinement steps, K local candidates, and a history-to-proposal mapping Φ.These dimensions respectively support global exploration, accumulated feedback, local selection, and reuse of evaluated history.
  • Local selection: K local candidates reduce commitment risk by allowing greedy selection before a candidate enters trajectory history, although excessive K can reduce refinement depth and saturate gains.Moderate K consistently improves performance, while very large K may leave too little depth L.
  • Design space: The design space (C, L, K, Φ) isolates diverse exploration, feedback-driven refinement, and local greedy selection in a practical abstraction for comparing discovery policies.The framework fixes the language model while exposing evaluator-query organization as the principal scaling object.
  • Long-horizon training: SimpleTES trains for long-horizon discovery by valuing attempts according to the final outcome of the trajectory they helped produce rather than immediate reward alone.This targets exploratory attempts that may score poorly initially but expose failure modes or enable later refinement.

Supplementary Information

The work organizes its contributors by working group, including contributors, infrastructure, and advising.

  • Contributors: Contributors are listed under a dedicated working group.The listed contributors include Caiyin Yang, Chang Su, Rui Yang, Ruihua Liu, and others.
  • Infrastructure: Infrastructure contributors are listed separately from the main contributors.The infrastructure group includes Chong Gao, Dachao Ding, Guangrong He, Miaolei Zhang, and others.
  • Advising: Advisors are identified in a separate advising group.The advising group includes Bianxiao Cui, Di He, Jianzhu Ma, Junfeng Li, and others.

B.1 Existing Evaluation-Driven Discovery Methods

Existing evaluation-driven discovery methods can be described as TES policies that allocate evaluator queries, construct proposals, and reuse feedback, while differing in search organization, adaptation, and memory. SimpleTES builds on these paradigms by structuring evaluator feedback for open-ended scientific discovery with a fixed generator and without expert demonstrations.

  • TES formulation: TES policies decide when to query evaluators, how to construct proposals, and how to store feedback for future proposals.This formulation separates evaluation allocation, proposal construction, and feedback reuse as distinct design choices.
  • Asynchronous evolution: AlphaEvolve and OpenEvolve use asynchronous evolutionary pipelines that continuously generate, evaluate, and update candidate programs.AlphaEvolve uses a frozen generator, while OpenEvolve adds features including ensembles, multi-objective evaluation, and archive mechanisms.
  • Adaptation and reuse: ThetaEvolve and TTT-Discover combine evaluator-guided search with broader adaptation mechanisms, including external databases, batch updates, reuse buffers, and online training.Relative to SimpleTES, these methods place greater emphasis on archive-based evolution or test-time training, whereas SimpleTES focuses on organizing evaluator queries with a fixed generator.
  • Adaptive search: AdaEvolve and ShinkaEvolve adapt search by selecting islands, balancing exploration and exploitation, and drawing mutations from archives.AdaEvolve uses hierarchical control, while ShinkaEvolve combines archive sampling, evaluator feedback, scratchpad recommendations, and an LLM ensemble.
  • Strategy evolution: EvoX evolves the discovery strategy itself when progress stagnates over a sliding window.Its inner loop performs solution discovery, while an outer loop updates the active strategy.
  • Textual optimization: GEPA optimizes textual modules through reflection, minibatch evaluation, execution traces, and Pareto-structured memory.Candidates are revised and admitted based on minibatch improvement before broader evaluation updates the Pareto frontier.
  • SimpleTES: SimpleTES extends these paradigms by using explicit evaluator feedback to pursue difficult open-ended scientific problems without expert demonstrations.The framework is presented as an extension of Learning from Evolution and test-time scaling based on evaluator feedback.

C Theoretical Modeling of SimpleTES

Theoretical modeling explains why SimpleTES separates sequential refinement, independent trajectories, and local sampling when open-ended objectives require multidimensional coverage. The analysis characterizes budget allocation and reports empirical evidence that balancing global width and depth can outperform deeper refinement alone.

  • Open-ended solutions require simultaneous multidimensional coverage, whereas sequential refinement can become path-dependent and repeatedly reinforce a narrow direction.
  • SimpleTES models refinement with a D-dimensional solution space, bottleneck score, refinement strength λ, and path-dependence parameter β.
  • At each step, one dimension is selected with probability proportional to 1 + β·y_d(t−1), then its value increases by one while other dimensions remain unchanged.
  • Theorem 3 shows that independent trajectories provide a structural benefit by allocating budget between refinement depth L and global width C under a reliability constraint.
  • Global width supports exploration while refinement depth supports exploitation, producing an asymmetry that motivates balancing C and L rather than maximizing either alone.
  • On the Second Autocorrelation Inequality, SimpleTES matches 0.9438 at ∼60 USD and reaches 0.9627 at ∼400 USD using gpt-oss-120b.
  • Moderate local sample size K improves performance, whereas overly large K reduces refinement steps and can hurt the final bottleneck score.

D.1 Experiments on the Scaling Behavior of SimpleTES

Scaling experiments show that SimpleTES improves with total evaluation budget, while the best allocation among global width, refinement depth, and local sampling depends on the task and chain depth.

  • Scalability of global width (C) and refinement depth (L): SimpleTES exhibits consistent performance gains as both global width C and sequential refinement depth L increase with K fixed at 32.
  • Scalability of global width (C) and refinement depth (L): Scaling C is especially advantageous for mathematical discovery tasks, where diverse starting points help uncover promising structural approaches.
  • Scalability of local sample size (K) and refinement depth (L): Performance consistently improves with L across configurations, while increasing K at shallow depths does not produce a consistent monotonic improvement.
  • Scalability of the total evaluation budget (N): N = L × C × K produces stable performance improvements as the total evaluation budget increases.

D.2 Experimental Details on Post-Training

Post-training on successful TES trajectories improves elite trajectory scores on training tasks and transfers to held-out mathematical problems. The reported results indicate that this training can produce stronger solutions than the vanilla model discovers.

  • Training improves Top 10%, Top 25%, Top 50%, and Top 75% trajectory scores across all training tasks.
  • On held-out tasks, the trained model outperforms gpt-oss-120b in Top 50% and Top 75% scores across all tasks.
  • Training maintains or exceeds baseline Top 10% performance on three of the held-out tasks, with some marginal drops attributed to TES stochasticity.
  • Held-out-task performance improves during the first 2 training iterations and then remains stable during subsequent training.
  • On the held-out Sum–Difference Problem, the trained model reaches 1.144887 versus the prior result of 1.143975.

D.3 From Golden Metrics to Surrogate: Hacking Analysis

The hacking analysis shows that score-driven search can exploit gaps between surrogate evaluators and intended metrics. Examples span numerical tolerances, unstable computations, caching, timing manipulation, baseline corruption, and partial computation.

  • Surrogate-evaluator gaps can drive models to optimize implementation vulnerabilities rather than the underlying task objective.
  • In circle packing, configurations can exploit a 1 × 10−6 overlap tolerance while violating the intended non-overlap condition.
  • Numerical instability can be induced by degenerate configurations, such as coordinates scaled to ∼10−162 or arranged collinearly.
  • Kernel benchmarks can be manipulated through repeated-run caching, timer interception, unmonitored CUDA streams, baseline corruption, or reuse of precomputed outputs.
  • Closing the gap between proxy feedback and intended performance currently relies heavily on human-in-the-loop intervention.

F.1 Ablations on Different Designs of Φ

The ablation compares inspiration-selection strategies and shows that semantic or structural guidance outperforms random or purely score-based sampling, while moderate context sizes balance diversity and coherence. Absolute peak-performance differences remain modest, supporting evaluation-budget scaling as the primary driver.

  • Inspiration selection: Semantic or structural selection provides more consistent, higher-quality guidance than random or purely score-based sampling.Scalar scores can be myopic because ordinary-scoring nodes may lead toward globally strong regions.
  • Inspiration selection: insp = 3 or insp = 5 is the empirical sweet spot for RPUCG in a single continuous run.insp = 1 limits crossover across trajectories, whereas insp = 10 can overwhelm the context with conflicting information.
  • Interpretation: The absolute peak-performance differences across selection strategies are relatively modest.This result reinforces the paper’s thesis that systematic evaluation-budget scaling, rather than complex selection heuristics, primarily drives discovery.

F.2 Ablation on Reflection and Failure Patterns

This ablation tests Reflection and Failure Patterns independently and together, finding that explicit negative constraints are consistently useful while the best combination depends on the task. Performance differences are marginal overall, indicating robustness to the guidance configuration when basic error prevention is present.

  • Guidance mechanisms: Failure Patterns provide a consistently strong foundation across the two evaluated mathematical problems.They encode explicit negative constraints that help prevent repeated errors.
  • Guidance mechanisms: Reflection plus Failure Patterns performs best on the First Autocorrelation Inequality, whereas Failure Patterns alone performs slightly better on the Erdős Minimum-Overlap Problem.All configurations use otherwise identical hyperparameters.
  • Interpretation: The absolute performance gaps across guidance configurations are relatively marginal.The evolutionary framework is therefore robust to the specific combination of textual guidance when basic negative constraints are present.

F.3 Efficiency Analysis: Trajectory-level Pruning

Trajectory-level pruning reallocates computation away from underperforming chains, but its value depends on the task landscape. Aggressive pruning can preserve strong final scores in many runs while still degrading outcomes when early scores poorly predict eventual quality.

  • Pruning strategy: Pruning terminates underperforming chains early so computational resources can be reallocated during parallel search.The experiments use six mathematical tasks with C = 32 chains, L = 100, and K = 16 fixed.
  • Pruning strategy: 10 of 18 runs preserved the original best final score even when the first-stage cutoff retained only one chain.This indicates that successful solutions often exhibit structural advantages early in the search.
  • Task dependence: Circle packing tolerates early pruning, whereas Autocorrelation Inequalities and the Erdős Minimum-Overlap Problem are more vulnerable to eliminating optimal solutions.For the latter tasks, initial performance is not always a reliable proxy for final solution quality.
  • Limitations and future work: Pruning requires task-adaptive strategies because scalar intermediate scores can be myopic.The paper proposes richer signals such as textual reasoning patterns, trajectory growth trends, and structural heuristics for future pruning algorithms.

G Wall-clock Time Efficiency

The wall-clock comparison evaluates SimpleTES against OpenEvolve under matched solution quality, search budgets, and runtime concurrency. SimpleTES reaches the target quality substantially sooner on the reported tasks and later finds stronger solutions.

  • Experimental setup: SimpleTES and OpenEvolve are compared at matched solution quality, evaluator budgets, initial solutions, evaluation programs, and generation concurrency.SimpleTES uses (C, K, L) = (16, 16, 50), totaling 12,800 evaluator queries; OpenEvolve uses sixteen islands.
  • Wall-clock results: 11.2 versus 132.7 minutes on third autocorrelation and 3.3 versus 59.4 minutes on sum-difference are the reported times to the same solution quality.The curves show the best evaluator score found up to each elapsed time.
  • Wall-clock results: SimpleTES subsequently finds stronger solutions on both reported tasks after reaching the matched quality.This compares the best evaluator scores over elapsed time rather than only final scores.

H.2 Experimental scaffolds and evaluation setup

The experiments expose targeted algorithmic decisions within fixed execution and evaluation scaffolds, enabling SimpleTES to search routing and placement policies across quantum hardware settings. Evaluation uses benchmark suites and task-specific costs, with the discovered policies combining structured initialization, routing-aware search, and refinement.

  • Superconducting routing: The superconducting scaffold exposes initial logical-to-physical layout and online legal-SWAP selection while fixing parsing, dependency tracking, legality checks, and output construction.
  • Superconducting routing: 72 routing instances cover 24 circuits across IBM Q20, Google Willow, and IBM Heron coupling graphs, with inserted SWAPs as the routing-cost metric.
  • Zoned neutral-atom placement: The neutral-atom scaffold fixes scheduling, reuse analysis, placement, and routing, while the editable component produces full placement snapshots.
  • Zoned neutral-atom placement: 36 circuits spanning six-to-500-qubit workloads are evaluated for correctness, execution time, and fidelity-related losses from gates, transport, transfers, and decoherence.
  • Discovered policies: The discovered superconducting policy combines interaction-aware initialization, hill-climbing and restarts, broader look-ahead SWAP neighborhoods, and criticality-aware scoring.
  • Discovered policies: The neutral-atom placer constructs complete trajectories, ranks them by router-emitted Moves and travel distance, then applies reverse-through-time refinement and hill climbing.
  • Astrodynamics evaluation: The astrodynamics evaluator is deliberately lower fidelity than operational mission-design models, so trajectory comparisons are controlled within the shared evaluator rather than against flown-mission performance.

I.3 Benchmark instances

The astrodynamics benchmarks span historical and prospective mission windows with explicitly defined boundary conditions, admissible topologies, and evaluator conventions. Search behavior is analyzed through replay instrumentation, showing adaptive allocation across encounter sequences, transfer branches, and solver throughput while limiting claims about heuristic provenance.

  • Benchmark instances: The five historical benchmarks represent distinct trajectory structures, including inner-planet transfers, Jupiter assists, giant-planet tours, and repeated Earth–Mars encounters.
  • Benchmark instances: Boundary tables specify speed and C3 cost models, admissible gravity-assist bodies, minimum flyby altitudes, and topology limits including total node counts.
  • Evaluator conventions: The evaluator derives planetary ephemeris states at candidate boundary epochs, so arrival windows constrain epochs rather than stored Cartesian states.
  • Reference construction: Historical references are reconstructed by locally optimizing around cited encounter orders and nominal epochs, then replaying them through the same evaluator as SimpleTES.
  • Reference construction: The evolved search receives mission windows and allowed flyby bodies but not mission identity, historical order, intermediate epochs, or the optimized reference trajectory and cost.
  • Search analysis: Replay instrumentation records encounter sequences, Lambert-solver branches, and execution time without changing search logic, while costs come from independent checkpoint replay.
  • Search analysis: Evolved programs expand encounter-sequence breadth when useful but narrow it on some tasks, while exploring more Lambert branch types and using caching and pruning to increase solver throughput.
  • Interpretive boundary: The replay characterizes final executable policies but cannot establish how independently each mission-specific heuristic was discovered.

J GPU Kernel Optimization

The GPU-kernel experiments treat implementations as executable candidates that must satisfy numerical correctness while minimizing benchmark runtime. SimpleTES is evaluated on TriMul and additional asymmetric-matrix-multiplication and batched-cumsum tasks, with compiler and hardware alignment explicitly documented.

  • TriMul: TriMul implements normalization, gating, projections, masked interactions when applicable, triangle multiplicative aggregation, output normalization, and final projection.
  • TriMul: Valid TriMul implementations must match the reference within 2 × 10^-2, and the objective is minimum geometric-mean runtime across benchmark settings.
  • Benchmark settings: The benchmark settings define TriMul dimensions, input distributions, masking, asymmetric multiplication dimensions, and batched-cumsum tensor shapes.
  • Additional kernels: Asymmetric matrix multiplication uses strongly unbalanced shapes, FP32 reference outputs, 10^-2 numerical tolerance, and geometric-mean runtime minimization.
  • Additional kernels: Batched cumsum computes inclusive cumulative sums along the last dimension, requiring 10^-4 accuracy and minimizing geometric-mean runtime across prescribed shapes.
  • TriMul evaluation: TriMul comparisons report H100 latency under Triton 3.4.0 and 3.6.0, with three repeated local measurements and the lowest latency among compared methods and public submissions under both versions.
  • TriMul evaluation: A kernel discovered on H200 transfers without retuning to A100, H100, and AMD MI300, achieving lower latency than compared AI-discovery baselines and top-three GPUMode submissions for each target GPU.

K Scaling Law Discovery

Scaling-law discovery searches executable symbolic laws and fitting procedures for extrapolation beyond observed regimes. On SLDBench, SimpleTES is compared under controlled initialization and evaluation settings, with its strongest gains appearing on difficult extrapolative tasks and in downstream hyperparameter selection.

  • Problem formulation: Scaling-law discovery seeks compact symbolic laws that predict performance variables beyond the fitted regime, where extrapolation matters more than interpolation.
  • Problem formulation: The formal objective jointly discovers a symbolic law and per-setting fitting procedure whose instantiated predictors extrapolate accurately to larger-scale or held-out inputs.
  • Experimental setting: The four-task SLDBench subset uses extrapolation splits that hold out largest model sizes, compute regimes, or other extreme settings rather than random interpolation-style splits.
  • Experimental setting: SimpleTES uses the same initialization, task instruction, and evaluator as SLDAgent, starting from a naive power-law function and BFGS-based fitting optimizer.
  • Results: SimpleTES achieves the best average score, 0.674, versus 0.572 for SLDAgent with GPT-5 on the same four-task subset.
  • Results: Its advantage is most pronounced on harder lr&bsz and u_shape extrapolation tasks, where many methods obtain negative test R2 from laws that interpolate well in-range.
  • Case study: On lr&bsz, the discovered symbolic loss law supports direct grid search over feasible hyperparameters in an extrapolated target regime.
  • Case study: SimpleTES selects a configuration 0.058% above the optimum, compared with 0.067% for SLDAgent, while identifying the optimal region more accurately.

N Lasso Regularization Path

The lasso regularization path task evaluates whether SimpleTES can discover a solver faster than glmnet while preserving float64 precision and correctness. The discovered solver generalizes across heterogeneous real-world datasets and adapts its algorithm to problem geometry.

  • Problem and evaluation: The evaluation requires the complete coefficient path across decreasing regularization values while rejecting candidates that fail objective-value or correctness checks.A failed required check assigns the search score zero.
  • Experimental setting: The benchmark evaluates self-contained C++ solvers on separate fresh correctness instances and 17 synthetic timing instances spanning key lasso-path performance regimes.The synthetic instances vary n/p, matrix sparsity, active-set density, and feature correlation.
  • Results: 2.17× average speedup over glmnet and 14.08× over sklearn was achieved across 11 real-world datasets, with every solution passing held-out correctness checks.The correctness check used fresh instances, and the reported per-dataset speedups were averaged arithmetically.
  • Results: 9.56× faster than glmnet was achieved on the tall DNA dataset measuring 1700 × 180.
  • Case analysis: The discovered solver switches between coordinate descent, exact LARS homotopy, and other methods according to the dimensions and sparsity of each problem.This geometry-aware strategy replaces glmnet’s uniform coordinate-descent initialization in relevant regimes.

O.1 Extremal analysis

This section applies deterministic evaluation to extremal-analysis and combinatorial-construction problems, where progress depends on discovering structured feasible solutions. SimpleTES produces interpretable witnesses and constructions across overlap, autocorrelation, packing, sum–difference, and determinant tasks.

  • Erdős Minimum-Overlap Problem: The Erdős minimum-overlap task distributes unit mass on [0, 2] to minimize one-sided overlap with shifted-copy complements.The evaluator reports the translated-overlap objective through 1/Ψ(h) during search and standard Ψ(h) for comparison.
  • Erdős Minimum-Overlap Problem: A near-binary Erdős witness flattens the translated-overlap profile across the high-risk shift range, reducing the worst shift rather than only the average shift.The search uses coarse-to-fine optimization with constrained local refinement and projected polishing.
  • Autocorrelation Inequalities: The three autocorrelation tasks use different witness structures: boundary-concentrated mass for AC1, a sparse near-flat plateau for AC2, and signed oscillatory cancellation for AC3.These structures respectively target the peak of a non-negative autoconvolution, the norm ratio, and the largest absolute autoconvolution value.
  • Sum–Difference Problem: The discovered sum–difference set uses a regular arithmetic backbone with sparse fringe corrections that enlarge the sumset more efficiently than the difference set.The evaluator computes the sumset and difference set exactly using integer arithmetic.
  • Circle Packing in a Unit Square: The n = 26 and n = 32 circle-packing solutions recover the strongest known packing values under the same evaluator, despite having visibly different layouts.The n = 26 construction has a dominant central circle and boundary anchors, whereas n = 32 is more homogeneous and quasi-hexagonal.
  • Hadamard Maximum-Determinant Problem: The discovered sign matrices recover the long-standing classical lower-bound record and exhibit near-orthogonal Gram structure.The Gram matrix is the preferred representation because permutations and sign flips preserve equivalence while changing the raw signs.
Loading 2604.19341v2…