compile dynamic-programming recurrences

This work addresses the challenges of modeling higher-order functions and recursive patterns—and the resulting large search space—in program synthesis. We propose two novel algorithms: HOTGP (Higher-Order Type-guided Genetic Programming) and Origami (structured search guided by parametric recursive pattern templates). To our knowledge, this is the first approach to integrate parametric recursive pattern templates into a type-driven synthesis framework, augmented with the AC/DC adaptive search optimization mechanism. On the PSB2 benchmark, our method achieves 100% task success rate—the first to solve all tasks in this benchmark. By synergistically combining type constraints, λ-calculus semantics, parametric polymorphism, and syntax-guided search, our approach uniquely attains 100% success on 18% of tasks and significantly outperforms state-of-the-art genetic programming methods and large language models (e.g., GitHub Copilot) in both overall solution rate and win rate.

This work addresses the challenge in bioinformatics of efficiently implementing dynamic programming algorithms, where performance and development productivity are often compromised by the tight coupling between computation order and pruning strategies. The authors propose FILTR, a domain-specific language and accompanying compilation framework that, for the first time, treats pruning as an approximate computation mechanism decoupled from scheduling logic. This separation enables independent specification of recurrence rules, pruning policies, and execution schedules. The framework automatically generates high-performance C++ code that matches or exceeds the speed of hand-optimized libraries across multiple sequence alignment benchmarks, achieving speedups ranging from 0.95× to 30×. This advancement significantly accelerates the exploration and deployment of novel heuristic methods in dynamic programming–based bioinformatics applications.

This paper addresses the challenge of runtime optimization for recursive programs. We propose a just-in-time (JIT) recursive unfolding technique based on Constraint Handling Rules (CHR), wherein a meta-interpreter dynamically generates specialized rules covering varying recursion depths, thereby reducing the number of recursive calls to logarithmic complexity. To our knowledge, this is the first JIT optimization for repeated recursive unfolding in CHR, and we provide a rigorous theoretical characterization—establishing necessary and sufficient conditions for superlinear (i.e., non-constant-factor) speedup. The approach integrates CHR embedding, runtime rule specialization, and manually guided simplification, requiring only five CHR rules to implement both the full unfolding engine and the meta-interpreter. Empirical evaluation on fundamental solvable algorithms demonstrates speedups of several orders of magnitude—consistent with theoretical predictions—thereby validating both the efficacy and conceptual simplicity of the method.

Formal program specifications are notoriously difficult, error-prone, and inefficient to write manually. To address this, we propose a two-stage LLM-driven approach: dialogue-guided specification synthesis followed by mutation-based verification. First, multi-turn dialogues model complex semantic requirements; second, four mutation operators—insertion, replacement, deletion, and reordering—enable verifiability-driven selection, eliminating reliance on rigid templates or syntactic grammars. Our method integrates code understanding, prompt engineering, and heuristic verifiability assessment. Evaluated on SV-COMP and a custom Java benchmark comprising 385 programs, it generates 279 verifiable specifications. These achieve significantly higher completeness and accuracy than pure-LLM baselines and classical tools (e.g., Houdini, Daikon). To our knowledge, this is the first approach to achieve both high coverage and formal verifiability in fully automated specification generation.

In high-level synthesis (HLS), jointly optimizing code transformations, pragma insertion, and cache-blocking size selection is challenging due to tight coupling, a vast decision space, and difficulty in guaranteeing semantic correctness. Method: This paper proposes the first unified modeling framework that jointly encodes all three aspects as a single, isomorphic optimization problem—supporting “zero-transformation” decisions—and leverages HLS compiler–driven constraint derivation coupled with nonlinear programming (NLP) to automatically and correctly optimize regular loop nests. Contribution/Results: It introduces the first paradigm for co-optimizing transformations, pragmas, and blocking sizes, with built-in semantic equivalence preservation. Evaluated on multiple benchmark kernels, the approach significantly improves quality-of-results (QoR), accurately identifies cases requiring or forbidding transformations, and generates high-performance, formally verifiable optimized code.

This work addresses the challenge of efficiently parallelizing input-dependent affine recurrences—such as the selective scan in Mamba—on GPUs, which is hindered by their strong sequential dependencies. The paper introduces the first compiler-level abstraction for affine recurrences, leveraging the MLIR framework to automatically transform them into associative Blelloch scans and generate end-to-end optimized GPU code. While preserving the original local recurrence semantics, this approach significantly outperforms sequential baselines implemented in PyTorch and CUDA, achieving performance on par with Mamba’s hand-optimized fused kernels. The proposed method thus enables automatic parallelization and high-performance execution of selective scans without manual kernel engineering.

Traditional least fixed-point semantics often fails to support precise static cost analysis due to its neglect of recursive structural information. This work proposes operator semantics as an intermediate representation bridging syntax and denotational semantics, treating programs as operators and constructing a higher-order abstract domain grounded in category theory, with composition as the core primitive. This framework enables abstract compilation that simultaneously achieves soundness, precision, and modularity. The approach supports cost analysis for general functional unknowns and generalized fold-based metrics, leveraging a solver-agnostic technique for extracting optimal recurrence relations. Consequently, it facilitates precise static cost analysis of recursive programs over algebraic data types, encompassing generalized size metrics beyond the reach of conventional methods.

Existing AI-generated code often struggles to simultaneously achieve functional correctness and runtime performance. To address this challenge, this work proposes Copper, a novel framework that, for the first time, integrates formal correctness guarantees with performance optimization objectives within an AI-assisted programming pipeline. Copper establishes a closed-loop optimization mechanism by synergistically combining AI-driven code synthesis, formal verification, automated performance profiling, and performance-aware specifications. Experimental results demonstrate that, across diverse algorithms and real-world programming tasks, Copper consistently produces code that not only rigorously satisfies functional correctness but also significantly outperforms state-of-the-art AI baselines in both execution time and memory efficiency.

This study addresses the common omission in current large language model evaluations of code generation—the iterative refinement process inherent in real-world programming and the models’ capacity for self-correction using feedback. The authors propose a novel framework that leverages execution-based feedback, such as compilation errors and test failures, to systematically investigate how reasoning and non-reasoning models utilize such signals across multiple programming languages. Through multidimensional categorization of code failures and extensive cross-model, cross-language experiments, they demonstrate that reasoning models consistently improve over iterations and significantly outperform non-reasoning counterparts. While syntactic and runtime errors prove relatively amenable to correction, logical and algorithmic errors remain challenging, thereby delineating the current limits of feedback-driven repair mechanisms.