automatic memoization by tabling

This work addresses the high re-execution overhead faced by live programming systems under frequent edits. We present Chordata, the first incremental interpreter supporting languages with arbitrary rewrite semantics, which leverages a novel shortcut memoization mechanism to learn and reuse recurring computation patterns from prior executions. We formalize this mechanism and provide a mechanized correctness proof by embedding the Hazel system into a CEK abstract machine framework. Additionally, we design heuristic strategies to efficiently identify high-value shortcuts. Experimental evaluation demonstrates that Chordata achieves an average speedup of 13.03× (with a 19.97× memory overhead) on student programming traces, with particularly pronounced gains for small edits, complex programs, and large inputs—even enabling acceleration within a single execution.

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.

This work proposes “grid programs,” a two-dimensional computational model grounded in an integer lattice, which overcomes limitations of traditional models constrained by linear instruction sequences, named variables, and explicit memory addresses. In this paradigm, computation proceeds as an instruction pointer traverses the grid in four cardinal directions, while program state is maintained through a data stack, an address stack, and a three-pointer cyclic doubly linked list. The model enforces no variable names or syntactic constraints, relying instead on purely spatial control flow. It constitutes the first Turing-complete computational framework that is entirely free of named variables and defined solely by spatial layout. Formal operational semantics demonstrate its ability to simulate any register machine, and practical implementations—including factorial computation and string reversal—highlight its expressiveness. The approach shows promising applications in visual programming, cellular-automaton-inspired hardware, and code obfuscation resistance.

This work addresses the challenge of large language models generating semantically incorrect code in real-world data pipelines due to ambiguous instructions, task complexity, and insufficient structured feedback. To tackle this, the authors propose a multi-agent autonomous framework grounded in dynamic data profiling. The framework establishes a unified execution context integrating three core modules: a Profiler employing ReAct-style exploration, a Generator leveraging knowledge-enhanced operator retrieval, and an Evaluator-Summarizer providing execution assessment and diagnostic feedback. Through interactive exploration, knowledge-guided code synthesis, and closed-loop optimization, the system precisely aligns with user intent. Evaluated on a benchmark encompassing 18 tabular task types, the approach significantly outperforms strong baselines, demonstrating that dynamic data profiling plays a pivotal role in enhancing semantic correctness and compliance, particularly in complex multi-step scenarios.

This work addresses the limitations of existing semantic caching approaches, which rely on embedding similarity for answer reuse but lack formal modeling of authorization, version control, and request equivalence. The authors propose a mathematically grounded, controllable reuse mechanism based on quotient sets: dialogue requests are parsed into structured representations, and fine-grained reuse chains are constructed via three classes of identity relations—reading, parsing, and reuse. Centered on reuse identity relations, the framework derives linguistic-side quotient objects induced by controlled answer partitions and establishes a reuse architecture that is finitely terminating, policy-admissible, and computationally complete. By integrating precise denotational semantics, aggregative design operators, and closure-stable units, the framework guarantees full computability and goal consistency under an untrusted proposal layer, ensuring that pipeline outputs remain invariant along identity chains in deployment logs and that every reuse instance requires verification via an identity or applicability certificate.

This work addresses the underexplored "crystallization" problem in Text-to-SQL systems, where corrected queries are discarded at test time, obscuring the practical value of memory for future queries—such as repeated questions, novel queries, or cross-question generalization within the same database. The study formalizes this issue and introduces a controlled evaluation framework that fixes the solver while varying only the memory strategy, enabling isolated assessment of memory’s multidimensional benefits in replay, cross-question retention, and intra-database transfer. Leveraging verified corrected queries as memory content, combined with a robust validation mechanism and broad-coverage retrieval strategy, the authors systematically compare different memory formats and retrievers. On the BIRD dataset, incorporating memory improves first-attempt accuracy by 4.34 percentage points, achieving 44.4% of the theoretical upper bound attainable through on-demand repair, highlighting database-specific content as critical to memory effectiveness.

Existing Datalog engines struggle to simultaneously achieve efficiency, scalability, and extensible semantics in static analysis, while also lacking robust support for rule debugging and incremental updates. This work proposes a novel approach that compiles Soufflé-style Datalog programs into executable Differential Dataflow programs, yielding a high-performance, memory-efficient static analysis framework capable of millisecond-scale incremental recomputation. The framework natively supports non-standard semantics—such as k-core analysis—and integrates in-browser performance profiling and rule-tuning capabilities. Evaluated on 24 real-world static analysis benchmarks, the system outperforms state-of-the-art engines in both runtime performance and scalability.

Existing computer operation agents inefficiently re-reason from scratch even when repeatedly executing the same tasks. This work proposes a reusable program memory mechanism that compiles the first successful execution of a task into a finite-state-machine program, which is then directly replayed in subsequent runs, relinquishing control back to the agent only upon detecting anomalous screen states. The approach integrates state-machine compilation, screen-state matching, an independent evaluator for correctness verification, and a program selection strategy combining language models with embedding-based retrieval, ensuring reliability and enabling graceful fallback upon failure. Evaluated across mobile, desktop, and web benchmarks, the system achieves 8.5–13× speedup and completes 1.75–2.6 additional tasks on average per benchmark, substantially outperforming strong baseline replay methods.