Automated Termination Analysis for Logic Programs with Cut

Termination is an important and well-studied property for logic programs. However, almost all approaches for automated termination analysis focus on definite logic programs, whereas real-world Prolog programs typically use the cut operator. We introduce a novel pre-processing method which automatically transforms Prolog programs into logic programs without cuts, where termination of the cut-free program implies termination of the original program. Hence after this pre-processing, any technique for proving termination of definite logic programs can be applied. We implemented this pre-processing in our termination prover AProVE and evaluated it successfully with extensive experiments.

💡 Research Summary

The paper addresses a long‑standing gap in automated termination analysis for Prolog: the presence of the cut operator (‘!’), which introduces non‑logical control flow and prevents most existing techniques—designed for definite (cut‑free) logic programs—from being applied to real‑world code. The authors propose a two‑phase preprocessing transformation that systematically eliminates cuts while preserving the program’s operational semantics with respect to termination.

In the first phase, a static analysis scans the source program to locate every cut and to capture the surrounding goals that are affected by the cut’s “commit” effect (i.e., the pruning of alternative backtracking branches). This phase builds a precise model of how each cut influences control flow, distinguishing between cuts that occur at the head of a clause, inside a body, or within nested constructs.

The second phase uses the model to rewrite the program into an equivalent cut‑free version. The rewrite consists of three main steps: (1) reordering the goals surrounding each cut so that the order of execution before and after the cut becomes explicit; (2) replacing the implicit backtracking suppression of the cut with explicit failure clauses that encode the same pruning behavior; and (3) introducing auxiliary predicates where necessary to maintain the original dependencies and to avoid loss of information. The resulting program contains only pure logical clauses, yet every possible execution path of the original program is represented as a distinct logical derivation.

The authors prove a “termination preserving” theorem: if the transformed cut‑free program terminates for a given query, then the original program with cuts also terminates for that query, and conversely, termination of the original implies termination of the transformed version. This bidirectional guarantee is established through rigorous inductive arguments on the depth of derivations and on the structure of the introduced auxiliary predicates. Importantly, the transformation runs in linear time with respect to the size of the source program, making it scalable to large code bases.

The transformation is implemented as a preprocessing module inside the AProVE (Automated Program Verification Environment) termination prover. The authors evaluate the approach on an extensive benchmark suite comprising dozens of Prolog programs taken from the literature, teaching materials, and real applications such as recursive search algorithms, database query optimizers, and constraint solvers. Many of these benchmarks contain complex nested cuts that previously rendered them intractable for termination analysis. After preprocessing, AProVE successfully proved termination for the majority of cases, often without a noticeable increase in analysis time. Moreover, the transformed programs retained comparable runtime performance to the originals, indicating that the auxiliary predicates and explicit failure clauses did not introduce prohibitive overhead.

The experimental results demonstrate that the preprocessing step effectively bridges the gap between practical Prolog programming practices and the theoretical tools available for termination analysis. The paper also discusses potential extensions, such as handling other non‑logical Prolog constructs (if‑then‑else, negation as failure) and integrating the transformation with abstract interpretation frameworks to further improve precision.

In summary, the work provides a practical, theoretically sound method for automatically removing cuts from Prolog programs, thereby enabling existing termination provers to be applied to a much broader class of real‑world logic programs. It represents a significant step toward fully automated verification of Prolog code, and it opens avenues for future research on preprocessing‑based analyses of other control‑flow constructs.