Non-looping Non-termination in Abstract Systems

• Non-looping non-termination is defined as the existence of an infinite computation without any finite repeatable loop, in contrast to periodic non-termination.
• The approach utilizes methods like recurrent pairs, automata-based certificates, and pattern unfolding to identify infinite evolution in term rewriting and logic programming contexts.
• Empirical evaluations demonstrate that these techniques extend non-termination proofs beyond traditional loop detection, addressing cases with dynamically growing or descending configurations.

Searching arXiv for the cited papers and closely related work on non-looping non-termination. Non-looping non-termination denotes the existence of an infinite computation in which no finite loop can be isolated and pumped forever. In contrast to periodic non-termination, where a fixed finite pattern of rule applications repeats indefinitely, non-looping behavior proceeds through structurally changing states, growing arguments, or descending configurations that never return to an earlier phase. In the cited literature, this phenomenon is formalized in abstract reduction systems, term rewriting, and logic programming, and it also appears in geometric refinement and higher-order calculi with references (Payet, 2023, Payet, 12 Jul 2025).

1. Formal definitions and conceptual boundaries

In the abstract framework of Payet, an abstract reduction system is a pair $(A,\to_{\Pi})$ with $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$, where each $\to_{\pi}\subseteq A\times A$. Term rewriting and logic programming are presented as concrete instances: in the former, $A=T(\Sigma)$ and $\Pi$ is a term rewrite system; in the latter, $A=\mathrm{Goals}$ and $\Pi$ is the set of program clauses under Prolog’s leftmost rule (Payet, 2023). Non-termination is the existence of an infinite $\to_{\Pi}$-chain.

The same work distinguishes loops from binary chains. A loop is defined through a compatibility relation $\phi$ and a finite label sequence $w\in\Pi^*$: if $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$0 is a $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$1-loop, then compatibility yields an infinite chain

$\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$2

By contrast, a binary chain is an infinite $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$3-chain for two fixed sequences $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$4. Every loop is therefore a trivial binary chain, but binary chains permit a broader two-phase alternation and need not arise from a single repeatable finite loop (Payet, 2023).

For logic programming, Payet gives a more direct characterization. Let

$\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$5

be a leftmost rewrite sequence. A program loops if there is a finite period of rules and queries that may be repeated forever. It is non-terminating without looping if there is an infinite chain

$\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$6

but no finite subchain ever re-occurs as a period. Equivalently, for every finite segment, there is no later identical segment of rule labels and queries. The contrast drawn in that formulation is between “periodic” looping behavior and non-periodic growth in which successive steps use new rule instances or increasing arguments (Payet, 12 Jul 2025).

These definitions delimit a common misconception: non-termination is not exhausted by loop detection. The cited work treats looping non-termination as an important special case, but not as the general one.

2. Proof principles in term rewriting

Three proof styles recur in the term-rewriting literature cited here: syntactic recurrent-pair criteria, regular-language recurrence sets, and finite-automata encodings.

The recurrent-pair criterion of Payet isolates two finite chains

$\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$7

together with contexts $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$8 and parameters satisfying a specific schema. Intuitively, phase $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$9 “adds a context” in one position while phase $\to_{\pi}\subseteq A\times A$0 “removes” or redistributes it. Lemma 3.2 and Lemma 3.3 then show that one can drain a tower of unary context applications down to a threshold and re-inflate it, and Corollary 3.5 concludes that any term of the form

$\to_{\pi}\subseteq A\times A$1

with $\to_{\pi}\subseteq A\times A$2 starts an infinite $\to_{\pi}\subseteq A\times A$3-chain (Payet, 2023). The method is explicitly syntactic and depends on closure under substitution.

A different line, developed by Endrullis and Zantema, uses a recurrence set $\to_{\pi}\subseteq A\times A$4 of ground terms such that $\to_{\pi}\subseteq A\times A$5 is non-empty, every term in $\to_{\pi}\subseteq A\times A$6 has a redex, and $\to_{\pi}\subseteq A\times A$7 is weakly closed under rewriting. Theorem 2.2 then yields non-termination without any looping assumption. In this approach, $\to_{\pi}\subseteq A\times A$8 is represented by a nondeterministic finite tree automaton $\to_{\pi}\subseteq A\times A$9, and closure is enforced by requiring $A=T(\Sigma)$0 to be a quasi-model of the rewrite system. For left-linear systems, the set $A=T(\Sigma)$1 is a regular tree language, so the condition that every accepted term has a redex reduces to an inclusion test $A=T(\Sigma)$2 (Endrullis et al., 2014).

The later SAT-based formulation fixes the number of automaton states in advance and encodes three requirements: non-emptiness, absence of normal forms, and weak closure. Boolean variables represent accepting states and transitions, while additional variables encode whether a term instance reaches a given state. Satisfiability of the resulting formula yields a certificate of non-termination. The method is complete with respect to regular witness languages for non-termination, modulo the stated transformation handling collapsing rules, and it succeeds on examples such as the S-rule where previous loop-search techniques fail (Endrullis et al., 2015).

These approaches are complementary rather than redundant. Recurrent pairs exploit a highly structured two-phase growth pattern; automata methods search for a regular closed language of reducible terms. The pattern-based approach later adapted to logic programming originates in term rewriting and likewise aims at non-looping cases that do not admit a finite repeatable loop (Payet, 12 Jul 2025).

3. Pattern-based non-looping non-termination in logic programs

Payet’s 2025 contribution adapts a term-rewriting approach based on patterns to logic programming by introducing a one-shot pattern unfolding operator

$A=T(\Sigma)$3

which mirrors the ordinary binary unfolding $A=T(\Sigma)$4 of Codish and Taboch but operates on pattern rules (Payet, 12 Jul 2025). Pattern substitutions are pairs $A=T(\Sigma)$5, with $A=T(\Sigma)$6; a pattern term $A=T(\Sigma)$7 describes the infinite set $A=T(\Sigma)$8, and a pattern rule $A=T(\Sigma)$9 describes the infinite set of concrete rules $\Pi$0.

Given an initial set $\Pi$1 of pattern rules, the operator $\Pi$2 closes $\Pi$3 under renaming and unfolds program clauses by choosing a prefix of body atoms, matching them with pattern rules from $\Pi$4, computing an $\Pi$5 of their left-patterns with the selected atoms, and propagating the resulting pattern substitution to a new pair $\Pi$6. The least fixed point

$\Pi$7

is then computed. Soundness, stated as Theorem 4, shows that every concrete rule in $\Pi$8 lies in the ordinary binary unfolding $\Pi$9, so any infinite chain observed at the pattern level is a valid chain in the original program (Payet, 12 Jul 2025).

A worked example exhibits the characteristically non-periodic nature of the construction. For the program with rules $A=\mathrm{Goals}$0 and an identity rule $A=\mathrm{Goals}$1, one obtains an infinite chain

$A=\mathrm{Goals}$2

where each round increases the number of nested calls to $A=\mathrm{Goals}$3 and $A=\mathrm{Goals}$4. No finite loop repeats. From the initial set $A=\mathrm{Goals}$5 extracted from $A=\mathrm{Goals}$6 and $A=\mathrm{Goals}$7, unfolding yields a single pattern rule with

$A=\mathrm{Goals}$8

and

$A=\mathrm{Goals}$9

Hence

$\Pi$0

This pattern rule is “special” in the sense of Definition 11, with threshold $\Pi$1, and Theorem 12 states that every query of the form $\Pi$2 with $\Pi$3 generates an infinite non-looping chain (Payet, 12 Jul 2025).

The associated implementation in NTI has three phases. Initialization extracts a small set $\Pi$4 of starter pattern rules via Proposition 3. Pattern unfolding then iterates

$\Pi$5

until a fixpoint is reached. Finally, NTI scans $\Pi$6 for a “special” pattern rule, computes $\Pi$7, extracts an initial query $\Pi$8, and reports that query as non-terminating. The tool restricts to “simple patterns” with unary symbols only, so pattern unification reduces to first-order unification plus a trivial check; because simple patterns use only countably many unary symbols $\Pi$9, the fixpoint process always terminates in finitely many steps (Payet, 12 Jul 2025).

4. Representative constructions beyond simple loops

The cited literature emphasizes that non-looping non-termination is not confined to first-order rewriting and logic programming.

In computational geometry, Pav shows that Ruppert’s algorithm can fail to terminate on a planar straight-line graph whose smallest input angle is about $\to_{\Pi}$0, for any refinement threshold $\to_{\Pi}$1 (Rand, 2011). The initial mesh contains a Delaunay triangle $\to_{\Pi}$2 with smallest angle at $\to_{\Pi}$3 equal to about $\to_{\Pi}$4. Its circumcenter encroaches the longest side $\to_{\Pi}$5, so Ruppert’s rule inserts the midpoint of $\to_{\Pi}$6 instead. Re-triangulation then creates a new triangle $\to_{\Pi}$7 of the same combinatorial type and the same smallest angle, but scaled by a factor $\to_{\Pi}$8, with $\to_{\Pi}$9. Because each iteration produces a strictly smaller similar bad triangle, edge lengths form a strictly descending sequence, no vertex position recurs, and no triangulation is revisited. The process is therefore infinite but non-looping.

In typed higher-order calculi, Birkedal and collaborators analyze Landin’s Knot in a simply typed $\phi$0-calculus with references and, after closure conversion, existential types (Koronkevich et al., 28 Jul 2025). The source term

$\phi$1

diverges. In the closure-converted target, the crucial point is not merely that references store functions, but that the function’s environment type is hidden by impredicative quantification. At runtime, the reference is first initialized with a trivial closure and then overwritten by a closure whose code refers back to that reference, producing “an infinite descending chain of environments.” There is no decrementing counter or explicit loop, yet no normal form is ever reached (Koronkevich et al., 28 Jul 2025).

That same work states a converse observation: higher-order references alone are not sufficient for non-termination. If existential hiding of the environment type is disallowed, so that closure environments have known monomorphic type, then cyclic backpatching is not well typed. A predicative, level-annotated restriction is proposed under which “Theorem (Conjectured Strong Normalization)” asserts termination of all well-typed terms; the status is explicitly conjectural rather than proved (Koronkevich et al., 28 Jul 2025).

5. Automation and empirical record

Automation is a central theme of the cited work. NTI implements loop detection via guided unfoldings and binary-chain detection via recurrent pairs for term rewriting and logic programming (Payet, 2023). In the Termination Competition 2023, on “TRS Standard” with $\phi$2 benchmarks, NTI proved $\phi$3 non-termination claims, second only to AProVE’s $\phi$4; it was the only tool to detect $\phi$5 instances in the Payet_23 suite, and in the Zantema_15 suite it detected $\phi$6 cases via recurrent pairs. In “Logic Programming” with $\phi$7 benchmarks, NTI was the only tool to find non-termination, namely $\phi$8 logic programs, $\phi$9 of them via binary-chain detection (Payet, 2023).

The 2025 logic-programming extension evaluates NTI on $w\in\Pi^*$0 logic programs derived from the TPDB’s non-looping non-terminating TRSs (Payet, 12 Jul 2025). On the $w\in\Pi^*$1 AProVE_10 programs, NTI proved non-termination of $w\in\Pi^*$2, generating between $w\in\Pi^*$3 and $w\in\Pi^*$4 pattern rules in less than $w\in\Pi^*$5 seconds each. On the $w\in\Pi^*$6 EEG_IJCAR_12 cases, it found non-looping non-termination in $w\in\Pi^*$7, with $w\in\Pi^*$8 ranging from $w\in\Pi^*$9 to $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$00 and running times from $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$01 to $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$02 seconds; four of those $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$03 were marked “hard,” meaning that no other TRS tool had previously proved them. The remaining $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$04 benchmarks timed out at the $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$05-second limit because of more complex context-variable interactions (Payet, 12 Jul 2025).

The automata-based line is likewise explicitly mechanized. Endrullis and Zantema formulate certificate search as a finite-state or SAT problem: build or guess a small tree automaton $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$06, check that $\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$07, verify closure under rewriting by quasi-model or related constraints, and enforce inclusion in the regular language of reducible terms via a product construction with a deterministic redex automaton (Endrullis et al., 2014, Endrullis et al., 2015). These methods are designed precisely for non-looping cases where a direct loop witness is unavailable.

The empirical record therefore supports a division of labor. Loop-detection remains important, but the cited data show that recurrent pairs, pattern rules, and automata certificates extend the set of tractable non-termination proofs beyond what loop search alone can establish.

6. Misconceptions, limitations, and significance

A recurrent misconception is that non-termination must manifest as repetition of a prior state. The examples above contradict that view in several ways. Binary chains require only repeated alternation of two phases, not recurrence of an entire configuration (Payet, 2023). Pattern rules can describe an infinite family of finite unfoldings whose parameters grow monotonically (Payet, 12 Jul 2025). Ruppert’s algorithm diverges through a strictly descending sequence of edge lengths rather than revisiting a triangulation (Rand, 2011). Landin’s Knot diverges through cyclic environment backpatching with “no explicit looping construct” (Koronkevich et al., 28 Jul 2025).

Another misconception is that a single proof technology subsumes the others. The automata literature states an explicit limitation: some non-terminating term rewrite systems admit only context-free patterns of non-termination, such as

$\to_{\Pi}=\bigcup\{\to_{\pi}\mid \pi\in\Pi\}$08

for which no regular witness language exists, so the regular-language method cannot prove them (Endrullis et al., 2015). Conversely, the pattern-based logic-programming method currently restricts itself to simple patterns with unary symbols, a restriction used to make unification reduce to first-order unification plus a trivial check and to ensure finite fixpoint saturation (Payet, 12 Jul 2025).

The cited work also draws a sharp boundary around what causes higher-order non-looping recursion. In the Landin’s Knot analysis, the key enabler is impredicative quantification over a closure environment, not higher-order references by themselves (Koronkevich et al., 28 Jul 2025). This corrects a broader but inaccurate intuition that references storing functions are already enough to destroy normalization.

The significance claimed in Payet’s 2025 logic-programming paper is correspondingly specific. By lifting term-rewriting pattern grammars into logic programming via a compact unfolding operator and simple unification of simple patterns, the work provides “the first practical, automatic detector of non-looping non-termination in Prolog-style rewrite systems,” and its experiments are presented as “the first fully automatic tool to handle this class of logic programs” (Payet, 12 Jul 2025). More generally, the cited literature establishes non-looping non-termination as a distinct technical object: it requires proof methods that can certify infinite evolution without periodicity, finite pumping, or return to a prior state.