algorithm design

This work proposes a formalization of algorithms within an intensional computability framework and clarifies their relationship to implementations in computational models. Treating computational models as monoid actions on configuration spaces, programs are modeled as dynamical systems constrained by such actions. Algorithms are defined as finite directed graphs of partial maps over edge-labeled abstract data structures, explicitly separating control flow from data operations. By leveraging tools from category theory, dynamical systems theory, and graph theory, the approach constructs a rigorous semantic framework that, for the first time, treats algorithms as abstract specifications of computational behavior and precisely characterizes the structure-preserving implementation relation between programs and algorithms, thereby deepening our understanding of the nature of computation.

Existing automated algorithm detection techniques lack empirical validation of their practical utility in program comprehension. Method: We conducted a controlled experiment with 56 developers to assess the impact of algorithm-level semantic labels—comprising algorithm names and associated semantic information—on code understanding, comparing performance with and without such labels. Contribution/Results: Labels significantly improved comprehension accuracy (median increase of +6 points, ≈23%; *p* = 0.040, Mann–Whitney *U* test), particularly for developers with intermediate experience, without increasing comprehension time; 85% of participants reported that labels aided intent recognition. Through mixed-method analysis—quantitative (nonparametric hypothesis testing) and qualitative (thematic coding)—we systematically identified concrete benefits of algorithm labels in error detection, performance optimization, and library substitution scenarios. This work provides the first empirical foundation for algorithm-aware program understanding and semantic annotation research.

Algorithm engineering has long lacked a unified methodology, resulting in fragmented knowledge across subfields and poor reproducibility. To address this, this paper introduces Karl Popper’s “Three Worlds” theory—comprising ontology (clarifying problems, tasks, design, and implementation), epistemology (distinguishing descriptive from prescriptive knowledge), and methodology (systematizing knowledge evolution)—to establish the first integrated three-dimensional framework for the field. By synthesizing philosophical methodology, ontological modeling, and empirical paradigm analysis, we propose the first formal research framework for algorithm engineering, explicitly defining validity criteria for diverse scholarly contributions. This framework enhances systematicity, rigor, and cross-domain comparability in algorithm design, implementation, and evaluation. It provides foundational methodological support for disciplinary integration and advances algorithm engineering toward a mature, theory-grounded science.

Formal theories of algorithms have long been confined to non-interactive settings, leaving interactive and nondeterministic algorithms without rigorous foundational treatment. Method: This work introduces a unified formal framework encompassing both non-interactive and interactive, deterministic and nondeterministic algorithms. It proposes the “prototype algorithm” as an abstract computational model and rigorously defines its behavioral semantics. Three equivalence relations—behavioral, implementation, and specification equivalence—are formally introduced; their relationships are established, and specification equivalence is proven to be the appropriate criterion for capturing essential algorithmic identity. Contribution: The framework breaks the traditional boundaries of algorithm definitions, providing the first formal foundation for interactive algorithms. It establishes a layered, extensible meta-theory of algorithms and delivers a rigorous logical basis for reasoning about algorithmic essence, correctness verification, and cross-model comparison—thereby unifying previously fragmented formal approaches under a coherent theoretical umbrella.

Repetitive computation in change-sensitive programs—such as database queries, compilers, and real-time analytics—incurs substantial overhead and undermines complexity control. Method: We propose the “incrementalization” paradigm, formalizing incremental computation as a discrete analogue of differentiation and establishing its theoretical foundation in discrete computation. Our approach introduces an “iterate–incrementalize–implement” design framework, featuring a novel meta-level abstraction-driven model for algorithmic complexity refinement, integrating higher-order abstractions over data, control flow, and modules with formal incrementalization transformations. Contribution/Results: We deliver a reusable, formally verifiable incrementalization methodology that guarantees correctness while significantly improving computational efficiency and enhancing controllability of algorithmic complexity. The framework enables systematic, principled application of incremental computation across diverse domains, bridging theory and practice in program optimization and reactive systems.

This work addresses the longstanding challenge of reconciling theoretical correctness with practical efficiency by introducing Algorithmist, a multi-agent autonomous research system built upon GitHub Copilot. Through an iterative research-review cycle, Algorithmist collaboratively performs algorithm design, formal verification, proof-guided code generation, and consistency validation. The system establishes a scalable paradigm for provably correct algorithm synthesis by integrating large language models, structured natural-language proof representations, and formal verification techniques to generate algorithms tailored to specific datasets and deployment scenarios. In applications to privacy-preserving data analysis and clustering tasks, Algorithmist automatically produces novel algorithms that simultaneously offer rigorous theoretical guarantees and strong empirical performance, uncovers previously overlooked proof flaws in existing work, and achieves state-of-the-art results in several settings.

This paper addresses the challenge of establishing performance guarantees for dynamic programming (DP) parsing algorithms in natural language processing. We present the first automated analysis system that unifies program analysis and complexity inference within a DP framework. Our approach integrates static analysis, type inference, abstract interpretation, and dependency graph modeling to enable formal verification and synthesis of efficient data structures. Key contributions include: (1) a unified formal model capturing DP control flow, data flow, and recurrence structure; (2) automatic inference of precise types, detection of dead code, and identification of redundant computations; and (3) generation of tight, parameterized upper bounds on time and space complexity. We evaluate our system on canonical parsing algorithms—including CKY, Earley, and Neural PCFG—demonstrating substantial improvements in both the automation level and precision of complexity analysis.

Existing algorithm selection models exhibit limited generalization capabilities in real-world optimization scenarios, struggling to maintain consistent performance across diverse domains. This work presents the first systematic evaluation of cross-domain generalization between synthetic benchmarks (BBOB, CEC) and practical applications—specifically robotic trajectory optimization and UAV path planning—using an algorithm selection framework grounded in problem features and historical performance data, complemented by a carefully designed cross-benchmark experimental protocol. The study uncovers the failure mechanisms and success boundaries of current approaches when deployed in realistic settings, thereby providing crucial empirical insights for developing more robust and universally applicable algorithm selection systems.

This work addresses the often-overlooked optimization potential in existing published algorithms, where manual refinement is typically costly and inefficient. The authors propose a two-stage AI-assisted pipeline: first, a research-capable large language model identifies recently published algorithms that meet predefined experimental criteria; second, a Claude Code agent automatically reproduces baseline implementations and iteratively optimizes the code. This study presents the first systematic application of embodied coding agents to automate performance improvements across diverse domains of published algorithms, while underscoring the indispensable human role in defining objectives, validating outcomes, and ensuring ethical transparency. Evaluated on eleven cross-domain tasks, the approach consistently achieves performance gains, with each optimization cycle completed within a single day.

This study addresses the challenges of assessing students’ comprehensive competencies in algorithm courses and the disconnect between academic instruction and industry needs. Grounded in the CC2020 competency model, it proposes a multidimensional assessment framework that integrates knowledge, skills, and professional dispositions. Behavioral data from programming assignments and written coursework of 169 students were collected using the xAPI specification. Learning behavior sequences were modeled via Markov processes, and cluster analysis was employed to identify distinct competency profiles. Additionally, a timeliness metric for submissions was introduced to quantify task difficulty. The framework not only enables computable representations of student competencies but also provides empirical support for personalized instructional interventions and curriculum refinement, thereby effectively bridging the gap between academic training and industry requirements.