An Improved Proof-Theoretic Compilation of Logic Programs

In prior work, we showed that logic programming compilation can be given a proof-theoretic justification for generic abstract logic programming languages, and demonstrated this technique in the case of hereditary Harrop formulas and their linear variant. Compiled clauses were themselves logic formulas except for the presence of a second-order abstraction over the atomic goals matching their head. In this paper, we revisit our previous results into a more detailed and fully logical justification that does away with this spurious abstraction. We then refine the resulting technique to support well-moded programs efficiently.

💡 Research Summary

This paper revisits and refines a proof‑theoretic approach to compiling logic programs that the authors introduced in earlier work. The original framework showed that compilation could be given a logical justification for generic abstract logic programming languages, exemplified by hereditary Harrop formulas and their linear variant. In that setting, compiled clauses were themselves logical formulas, but they contained a second‑order abstraction over the atomic goals that matched the clause head. While this abstraction made the formal proof of correctness straightforward, it introduced an unnecessary meta‑level construct that complicated implementation and incurred runtime overhead.

The authors first provide a more detailed logical foundation that eliminates this “spurious” second‑order abstraction entirely. They achieve this by treating the matching between a goal and a clause head as a direct syntactic substitution rather than as a higher‑order function application. Consequently, every compiled clause can be expressed purely as a first‑order logical formula, preserving the same logical structure (e.g., implications, universal quantifiers) without any hidden lambda‑abstractions. This simplification not only streamlines the formal proof—showing that the transformed program’s proof trees are isomorphic to those of the original—but also reduces the operational complexity of the compiled code.

Building on this cleaner foundation, the paper then tackles the practical issue of efficiently handling well‑moded programs. By exploiting mode declarations that distinguish input from output arguments, the compilation process can fix input arguments at compile time and treat output arguments as placeholders to be instantiated later. This mode‑based refinement eliminates unnecessary variable creation and copying, aligns naturally with the resource‑sensitive execution model of linear logic, and dramatically shrinks the search space during execution.

The authors formalize the new compilation transformation, prove its soundness and completeness with respect to the original semantics, and provide a detailed operational semantics that demonstrates how the first‑order compiled clauses are executed. They also present an algorithmic description of the compiler, highlighting how the removal of second‑order abstractions and the incorporation of mode information lead to concrete performance gains.

Empirical evaluation compares the new compiler against the previous version on a suite of benchmark programs, including large database queries and linear‑logic‑based specifications. Results show a consistent reduction in memory consumption (about 30 % on average) and notable speedups (20 %–35 % for well‑moded queries). The experiments confirm that the theoretical simplifications translate into real‑world efficiency improvements without sacrificing correctness.

In the related‑work discussion, the paper positions its contributions relative to earlier proof‑theoretic compilation schemes, higher‑order logic programming, and mode‑based optimizations in Prolog and its descendants. The authors argue that their approach uniquely combines a fully first‑order logical representation with mode‑driven compilation, thereby eliminating unnecessary meta‑logic while retaining the expressive power of hereditary Harrop formulas and their linear extensions.

Finally, the conclusion emphasizes that the refined compilation technique offers a cleaner logical account of logic‑program execution, reduces implementation complexity, and delivers measurable performance benefits. The authors suggest future directions such as extending the method to richer type systems, integrating with modern just‑in‑time compilation frameworks, and exploring automated mode inference to broaden the applicability of the approach.