decouple recurrence and scheduling

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.

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 parameterized approximation algorithms for Vertex Cover and 3-Hitting Set. Methodologically, it introduces a novel randomized branching paradigm grounded in an equivalence between the algorithm’s recursive structure and a binary stochastic process. Leveraging a type-theoretic adaptation of Sanov’s theorem, the framework performs large-deviation analysis on bivariate recurrence relations, yielding an analytically tractable master theorem for asymptotic running time. Contribution-wise, this is the first unified theoretical framework providing rigorous approximation-ratio–dependent guarantees across multiple approximation factors. It substantially improves worst-case time complexity over prior deterministic branching approaches and overcomes fundamental analytical limitations inherent in traditional branching analysis. The framework establishes a general methodology for characterizing the asymptotic performance of parameterized approximation algorithms, bridging stochastic analysis and combinatorial optimization.

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.

This work investigates the closure properties of context-free languages (CFLs) under shuffle operations constrained by regular trajectories, with a particular focus on non-regular CFLs and deterministic CFLs (DCFLs). By leveraging formal language theory and trajectory automaton modeling, the paper proposes a general method to decide whether a given trajectory preserves the CFL or DCFL structure. Building upon the expressiveness lemma of Jančar and Šíma (MFCS’2021), it develops key analytical tools to establish sufficient conditions under which CFLs fail to be closed under such shuffles. The study fully characterizes three distinct behavioral patterns of DCFLs under regular-trajectory shuffling and uncovers their deep connections to scheduling semantics, thereby advancing the theoretical foundations at the intersection of concurrency theory and formal languages.

This work addresses the challenge of efficiently leveraging symbolic patterns to guide search in numeric planning. It proposes a dynamic guidance approach based on Symbolic Pattern Planning (SPP), which incrementally generates intermediate states and refines action schemas during search. Integrated within a "planning as satisfiability" framework, the method encodes symbolic patterns and constructs state reachability formulas to enable a flexible yet sound search strategy. Theoretical analysis establishes the completeness of the approach under certain conditions, while empirical evaluation demonstrates its ability to significantly enhance solving efficiency across multiple planning strategies, effectively balancing correctness and performance.

This work addresses critical limitations in conventional LLM agent loop paradigms—namely implicit dependencies, unbounded recovery, and variable execution histories—which hinder debuggability and controllability. To overcome these issues, the paper introduces SGH, a structured graph framework that, for the first time, integrates classical scheduling theory into LLM agent execution. SGH explicitly models control flow using a static directed acyclic graph (DAG), cleanly separating planning, execution, and recovery into three distinct logical layers. It further incorporates a strict escalation protocol and formal node state machines to enforce rigorous execution semantics. The framework is systematically evaluated across 70 systems, analyzing trade-offs among controllability, expressiveness, and implementability, while providing formal guarantees of termination and correctness. Seven traceable experimental suites are designed to empirically validate its efficacy.