Code evolution for link prediction in complex networks

Abstract: The problem of predicting links in complex networks appears in different disciplines and has led to a variety of ingenious human-designed methods. We use this rich program space to explore the performance and behavior of automated code-evolution systems tasked to obtain machine-designed methods for link prediction. Despite being trained on limited data, algorithms evolved through code evolution outperform human-designed methods (with an average AUC score of 0.915 vs. 0.783, computed over 580 networks) and show improved computational efficiency, allowing them to be applied to networks with millions of links. The discovered methods follow approaches that have been employed in human-designed methods, but contain key innovations in the selection and combination of node- and link-features. This illustrates the role modern LLMs and genetic algorithms can play in algorithmic innovation and scientific discovery more generally.

• The paper demonstrates that AntEvolve-generated link-prediction programs achieve mean AUC scores of 0.913 on 550 real networks and 0.951 on 30 large networks, exceeding the best human-designed baselines.
• The paper finds that successful evolution requires sequential improvement, fitness-based selection, island-based diversity, and multiple training networks, while the resulting methods mainly recombine known graph features within supervised-learning models.
• The paper shows that the best evolved method scales to networks with millions of links using low-complexity features, but warns that node identifiers can create benchmark leakage and that performance remains uneven across network types.

This paper investigates whether LLM-guided code evolution can automatically discover link-prediction algorithms that outperform decades of human-designed methods. The authors, Vlaskin and Altmann, build "AntEvolve" (AE), a compact implementation of the AlphaEvolve paradigm (2606.26132), and apply it to link prediction in complex networks — a domain chosen deliberately because it possesses an exceptionally rich program space spanning similarity indices (Jaccard, Adamic-Adar), random-walk embeddings (Node2Vec), stochastic block models (SBM), graph neural networks, and stacked supervised models. The central empirical claim is strong: evolved programs trained on only ten networks achieve an average AUC of 0.915 across 580 test networks, versus 0.783 for the best human-designed baseline (the Stacked model of Ghasemian et al.), while also being computationally cheaper to run.

AntEvolve follows a standard evolutionary loop over Python programs. An initial program $p_0$ implements only the evaluation interface (random ranking, hence AUC = 0.5). At each step, ten previously accepted programs are selected by fitness (AUC on training data) to form the context set $S_t$, from which an LLM proposes a new program via mutation of one program or crossover of three. Diversity mechanisms include a 1% probability of selecting a purely random program and a partition into ten islands for the first $K=200$ generations, following Tanese's distributed genetic algorithm scheme. Ten parallel flows accelerate evaluation. Programs are accepted if they are novel, pass pylint static analysis, and evaluate within 1200 seconds; acceptance is unconditional on score, so low-fitness programs persist in the population and continue to be explored.

Fitness is computed on ten networks: six synthetic networks (lattice/clique structures connected by bridge nodes) and four small real networks (Jazz, Crime, London Transport, Bible nouns). Two LLM configurations were run to completion at $M = 1{,}002$ accepted programs: Google Gemini (Flash/Pro mixture) and Qwen3-Coder. Gemini proved markedly more sample-efficient: it required roughly 9.75M completion tokens versus 33M for Qwen, with an 82% versus 36% mutation success rate, at a cost of $52.50 versus $9.60. Both runs produced best programs with comparable training AUC (0.896 vs. 0.878).

The two best programs were evaluated on three ensembles disjoint from training data: eight synthetic configurations (with a computable theoretical maximum AUC as upper bound), the full 550-network benchmark of Ghasemian et al., and 30 large real networks from the Netzschleuder repository. The headline results:

Method	8 Synthetic	30 Large	550 Real
Adamic-Adar	0.490	0.695	0.641
Node2Vec	0.554	0.768	0.635
SBM	0.746	0.851	0.765
Stacked model	0.634	0.869	0.778
AE-Qwen	0.803	0.940	0.877
AE-Gemini	0.755	0.951	0.913

On synthetic networks, both evolved methods track the non-monotonic behaviour of the theoretical maximum, with Qwen-A approaching it closely in all configurations. On the 550 real networks, the advantage is largest for small networks, where prediction is intrinsically harder; in some cases the machine-designed methods exceed the human-designed ones by up to 20% on average. On the 30 large networks, AE-Gemini reaches 0.951 mean AUC. The authors are candid that performance is not uniform: there exist large sparse networks where the evolved methods struggle or underperform alternatives, indicating remaining headroom.

A notable result is computational efficiency achieved without explicit selection pressure: the Gemini-evolved program uses only features with $O(1)$ or $O(k_u k_v)$ complexity, whereas the Qwen program and the Stacked model retain betweenness centrality ($O(|N|\times|E|)$, effectively quadratic in sparse graphs). Consequently, the best-scoring Gemini program also scales to networks with millions of links (demonstrated up to DBLP with ~1M links), while the Stacked model required 128 GB of RAM on a mid-sized network.

Four ablations address which components of code evolution are necessary: (i) "best of M" (all mutations from $p_0$, disabling sequential improvement), (ii) random selection of parent programs (disabling fitness-based selection), (iii) no islands, and (iv) reduced training data (one real network instead of four). All four degrade final training scores substantially relative to the baseline. This is a pointed response to prior work reporting that random LLM baselines can match code evolution on simple problems: surpassing state-of-the-art link prediction appears to require the full apparatus — sequential improvement of top performers, fitness-based selection, and island-based diversity preservation. The authors acknowledge these ablations were each run only once due to cost, so the ablation conclusions rest on single realisations.

All top-performing programs converge on a supervised-learning architecture — classifiers over node- and link-level features — rather than any radically new algorithmic structure. Within this template, the top 100 programs exhibit variety: single classifiers, voting ensembles, and stacking. The Gemini best program uses a single extremely randomized trees classifier over 24 features; the Qwen program stacks five classifiers via linear regression over 40 features.

Feature analysis shows substantial consolidation of known link-prediction heuristics (common neighbours, Adamic-Adar, Jaccard, resource allocation, centrality measures, triangle counts), some apparent re-discoveries of post-cutoff literature (gravity-inspired degree features, combinatorial triangle features), and a small number of genuinely novel features not previously proposed for link prediction (e.g., average absolute log-difference between a node's degree and its neighbours' degrees). Nonsensical proposals during evolution (features based on zodiac signs or digits of $\pi$) were pruned by selection.

The most striking finding concerns node identifiers. The Qwen-A program uses raw node ID difference and ratio as features, and its performance drops significantly when IDs are randomly shuffled — evidence that node labels in many empirical datasets carry predictive information (likely reflecting artefacts of dataset construction or ordering). The authors show this explains part of Qwen-A's near-optimal synthetic-network performance, since training networks had informative IDs. Importantly, the headline Gemini-A program does not exploit ID information and is invariant to shuffling, so the paper's main claims do not depend on this leakage-like channel — but the observation itself is a cautionary result for link-prediction benchmarks generally.

Several limitations are stated plainly. Training used only ten networks, all small; generalisation to very large or dense networks during evolution was never tested. Ablations were single-run, and the robustness analysis covers five evolution scenarios but not systematic replication. The stopping criterion $S_t$0 and LLM choice affect results only mildly, but the dependence on the specific synthetic training networks (which shaped the ID-exploiting behaviour) is unresolved. Most fundamentally, the paper concedes that no radically novel algorithmic architecture emerged: innovation was confined to feature selection and combination within a classical supervised framework. Whether code evolution can produce genuinely new algorithm structures — and what enabling factors would permit this — remains the open question the authors highlight.

This work provides controlled evidence that LLM-driven code evolution can exceed human-designed state-of-the-art in a mature scientific domain, using minimal training data and yielding algorithms that are simultaneously more accurate and more scalable. The gains arise not from new architectures but from automated recombination and refinement of feature sets, including a few features absent from the literature. The identification of predictive node-ID information in standard benchmarks is an independently valuable methodological finding. The results support the view that, at least for problems with rich feature spaces and cheap evaluators, code evolution is a viable engine of incremental algorithmic discovery.