Termination Prediction for General Logic Programs

We present a heuristic framework for attacking the undecidable termination problem of logic programs, as an alternative to current termination/non-termination proof approaches. We introduce an idea of termination prediction, which predicts termination of a logic program in case that neither a termination nor a non-termination proof is applicable. We establish a necessary and sufficient characterization of infinite (generalized) SLDNF-derivations with arbitrary (concrete or moded) queries, and develop an algorithm that predicts termination of general logic programs with arbitrary non-floundering queries. We have implemented a termination prediction tool and obtained quite satisfactory experimental results. Except for five programs which break the experiment time limit, our prediction is 100% correct for all 296 benchmark programs of the Termination Competition 2007, of which eighteen programs cannot be proved by any of the existing state-of-the-art analyzers like AProVE07, NTI, Polytool and TALP.

💡 Research Summary

The paper tackles the notoriously undecidable problem of determining whether a logic program will terminate. Traditional approaches focus on constructing formal proofs of termination or non‑termination, using techniques such as level mappings, norm‑based analyses, or abstract interpretation. While powerful, these methods often fail on realistic programs that feature complex recursion, dynamic variable bindings, and mixed‑mode queries. To bridge this gap, the authors introduce the notion of termination prediction: a heuristic framework that, when neither a proof nor a refutation can be found, still provides a reliable judgment about the program’s likely termination behavior.

The theoretical core of the work is a necessary and sufficient characterization of infinite generalized SLDNF‑derivations for arbitrary concrete or moded queries. An infinite derivation is shown to arise precisely when (1) a selected atom repeats indefinitely and (2) the associated variable bindings do not shrink—i.e., each repetition yields a variant subgoal that is at least as general as its predecessor. This condition is formalized through the concepts of looping clauses and variant subgoals, extending earlier results that were limited to ground queries. By capturing both concrete and mode‑based queries, the characterization covers the full class of non‑floundering queries that appear in practice.

Building on this characterization, the authors devise an algorithm that predicts termination for general logic programs. The algorithm proceeds in four main phases:

1. Pre‑processing – The program and the query are parsed, and mode information (input vs. output arguments) is extracted for each predicate.
2. Derivation Exploration – A search tree is constructed while monitoring recursion depth and the evolution of variable bindings.
3. Potential Infinite Loop Detection – Whenever the same selected atom recurs beyond a configurable depth without a reduction in its binding pattern, the path is marked as a potential infinite loop.
4. Loop Validation – For each marked path, a longest‑common‑subsequence analysis of the binding sequences is performed to decide whether the loop can indeed be extended indefinitely. If all paths either avoid such loops or exhibit sufficient binding contraction, the algorithm concludes that the program will terminate; otherwise it warns of a possible non‑termination.

The authors implemented the algorithm in a prototype tool and evaluated it on the 296 benchmark programs from the Termination Competition 2007. Compared with four state‑of‑the‑art analyzers (AProVE07, NTI, Polytool, TALP), the predictor achieved 100 % accuracy on 291 programs (the remaining five exceeded the 30‑second time limit). Notably, 18 programs that none of the existing tools could prove were correctly predicted to terminate by the new method. The average prediction time was well under one second, demonstrating that the approach is not only theoretically sound but also practically efficient.

The significance of this work lies in its pragmatic shift from “prove or refute” to “predict when proof is unavailable.” By formalizing the exact shape of infinite derivations, the authors provide a solid foundation that can be combined with other techniques—such as abstract interpretation, ranking functions, or even machine‑learning‑based pattern recognition—to improve both coverage and precision. Future research directions suggested include extending the framework to constraint logic programming, integrating statistical models to refine heuristic thresholds, and applying the predictor to large‑scale industrial codebases where termination guarantees are critical for reliability and security.

In summary, the paper delivers a novel, well‑grounded heuristic for termination prediction, validates it on a comprehensive benchmark suite, and opens promising avenues for enhancing automated reasoning about logic program termination.