algorithm taxonomy

Current automated algorithm design over-relies on LLM-based performance optimization, lacking interpretable analysis of algorithmic effectiveness—particularly regarding mechanistic principles, critical components, and structural alignment with problem characteristics. Method: We propose “Explainable Automated Algorithm Design,” a novel paradigm built upon three pillars: (1) LLM-driven algorithm discovery, (2) problem-class–aware explainable benchmarking, and (3) problem-class descriptors grounded in landscape-structural analysis. A closed-loop iterative workflow explicitly establishes semantic mappings between algorithmic components and problem structures, shifting from black-box search to structure-aware generation. Contribution/Results: This work is the first to embed interpretability throughout the entire algorithm design pipeline. It yields reusable scientific insights—uncovering the structural conditions and causal mechanisms underlying heuristic efficacy—and advances algorithm design from a performance-centric paradigm toward a unified knowledge loop integrating understanding, discovery, and generalization.

How to quantify substantive semantic differences among algorithms? This problem is critical in applications such as code clone detection and program synthesis, yet has long lacked practical, computable metrics due to undecidability and ambiguity in similarity definitions. To address this, we propose EMOC—a novel framework that enables computable embedding of algorithm implementations along four orthogonal dimensions: behavioral equivalence, memory access patterns, operation sequences, and computational complexity. We further introduce PACD, the first publicly available dataset explicitly designed for algorithm-level similarity assessment. EMOC integrates static and dynamic program analysis for robust feature extraction and supports downstream tasks including clustering, classification, and quantification of LLM-generated program diversity. Extensive experiments demonstrate that EMOC significantly outperforms state-of-the-art baselines across algorithm categorization, approximate clone detection, and generated-program divergence evaluation. All code and data are publicly released.

Existing code similarity metrics struggle to capture essential differences in algorithmic logic and thus fail to effectively evaluate the novelty of algorithms generated by large language models (LLMs). To address this limitation, this work proposes BehaveSim, a novel approach that represents algorithms through their problem-solving trajectories (PSTrajs) and quantifies behavioral similarity during execution using dynamic time warping (DTW), thereby overcoming the constraints of syntax- or output-based methods. Integrated into LLM-driven automated algorithm design frameworks such as FunSearch and EoH, BehaveSim significantly enhances performance across three benchmark tasks and enables behavior-based clustering and strategic analysis of generated algorithms. The implementation and associated data are publicly released.

Understanding the interaction between modular CMA-ES algorithm configurations and problem characteristics remains challenging, as performance varies significantly across optimization problems. Method: Leveraging the BBOB benchmark suite (5D/30D), we propose an “algorithm footprint” modeling framework that quantitatively characterizes how configuration performance responds to landscape features—including condition number, non-convexity, and anisotropy. Contribution/Results: By analyzing footprints across 24 benchmark functions, we identify both universal behavioral patterns and configuration-specific response mechanisms. This work establishes, for the first time, an interpretable, systematic mapping between problem features and configuration preferences. The resulting framework enhances transparency and reliability in black-box optimization—particularly for algorithm selection and adaptive configuration—by grounding empirical performance in explainable landscape-aware principles.

Existing approaches to automated algorithm design suffer from poor computational efficiency, often redundantly generating substructures and discarding low-fitness candidates that may harbor valuable components. This work proposes a directed acyclic graph (DAG)-based representation of algorithms, leveraging large language models (LLMs) to produce fine-grained code-editing operations—insertion, deletion, and replacement—and composing historical edits via the graph structure to efficiently explore the algorithmic search space. The method enables credit assignment at the edit level and, supported by theoretical analysis, balances search depth and breadth under limited computational budgets, thereby transcending conventional full-algorithm generation paradigms. Experiments on three combinatorial optimization problems demonstrate significant outperformance over baseline methods under identical token budgets, with enriched context yielding benefits only when the LLM’s prior knowledge is insufficient.

This work presents the first complete formal verification in Lean 4 of the informal Euclidean domain algorithms originally described in the 1986 ICON language. By separating concerns into mathematical definitions, computable implementations, and output formatting, the project constructs a computable mirror atop Mathlib’s `EuclideanDomain` hierarchy and integrates a regression testing infrastructure to reproduce the original outputs. All 14 algorithms are formally specified, with core procedures such as integer GCD and the extended Euclidean algorithm accompanied by machine-checked correctness proofs. The formalization precisely delineates the boundaries between computability and mathematical correctness while fully replicating the benchmark results reported in Ericson’s technical report.

This work addresses the limitation of existing large language model (LLM)-based heuristic design methods, which rely on delayed final-performance feedback and thus struggle to effectively guide evolutionary search. The authors propose a teacher-aware evolutionary framework that, for the first time, employs an independently trained reinforcement learning policy as a behavioral teacher. This teacher provides fine-grained, local feedback by querying action preferences over states visited by candidate heuristics, enabling simultaneous optimization of task performance and behavioral consistency. By integrating LLMs, evolutionary algorithms, and the policy teacher, the method generates high-performing static heuristic rules without requiring neural network inference at deployment. Experiments across scheduling, path planning, and graph optimization benchmarks demonstrate significant improvements over baseline approaches that rely solely on performance-based feedback.

Tensor network contraction order optimization constitutes a class of combinatorial optimization problems that are notoriously difficult to solve efficiently. This work proposes OpenEvolve, a verifier-guided evolutionary framework powered by large language models (LLMs), which leverages human–machine collaboration to automatically design and refine contraction algorithms. By integrating customized evaluation metrics, program verification mechanisms, and evolutionary strategies, the approach generates algorithms that outperform existing baselines on standard benchmark instances. To the best of our knowledge, this is the first application of LLM-driven evolutionary code generation to the discovery of sophisticated algorithms in scientific computing. The results not only demonstrate the potential of such methods in advancing computational science but also underscore the critical roles of robust evaluation frameworks and human expertise in algorithmic innovation.

Traditional static analysis struggles to incorporate external knowledge such as documentation and security advisories, while large language models (LLMs), despite their capacity for information integration, often lack transparency and traceability in their reasoning. This work proposes an “agentic interpretation” framework that, for the first time, integrates lattice-based static analysis theory into LLM-driven program reasoning. By modeling local program assertions using finite-height lattices and iteratively reconciling LLM judgments through a worklist algorithm, the approach establishes a structured analysis pipeline where evidence is traceable and conclusions are reconcilable. Empirical evaluation demonstrates that this method significantly enhances the reliability and interpretability of LLM-based program analysis, particularly when applied to codebases containing opaque third-party components.

This study addresses the challenge computer science students face in transitioning from operational to structural thinking and in mastering the construction of loop invariants within formal methods. To this end, it proposes a Graphical Loop Invariant-Based Programming (GLIBP) approach that guides learners to first model problems using graphical loop invariants (GLIs) via block diagrams and then derive code from these representations. The work introduces, for the first time, an integrated consistency analysis and automated feedback mechanism that jointly evaluates GLIs and their corresponding code. The accompanying educational tool not only provides personalized guidance to students but also assists instructors in designing programming assignments, thereby significantly enhancing students’ comprehension and application of formal methods.