Transformations of Logic Programs on Infinite Lists

We consider an extension of logic programs, called \omega-programs, that can be used to define predicates over infinite lists. \omega-programs allow us to specify properties of the infinite behavior of reactive systems and, in general, properties of infinite sequences of events. The semantics of \omega-programs is an extension of the perfect model semantics. We present variants of the familiar unfold/fold rules which can be used for transforming \omega-programs. We show that these new rules are correct, that is, their application preserves the perfect model semantics. Then we outline a general methodology based on program transformation for verifying properties of \omega-programs. We demonstrate the power of our transformation-based verification methodology by proving some properties of Buechi automata and \omega-regular languages.

💡 Research Summary

The paper introduces “ω‑programs,” an extension of traditional logic programs that can directly define predicates over infinite lists (ω‑lists). By allowing Horn clauses to contain infinite‑list patterns, ω‑programs become a natural formalism for specifying the infinite behaviour of reactive systems, streaming processes, and ω‑regular languages. The authors first extend the perfect model semantics to accommodate infinite structures. They define an ω‑Herbrand base that contains all possible infinite‑list ground atoms and construct a complete lattice of interpretations over this base. The perfect model is then obtained as the least fixed point of the immediate consequence operator on this lattice, guaranteeing a unique, well‑founded semantics even for programs that generate infinite derivations.

Building on this semantic foundation, the paper develops a suite of transformation rules—unfold and fold—tailored to the ω‑domain. The ω‑unfold rule matches a goal atom against an infinite‑list pattern, expands the clause body, and generates new sub‑goals while ensuring that the expansion does not lead to uncontrolled infinite branching. Structural constraints such as limiting the depth of expansion or sharing common sub‑lists are introduced to preserve termination of the transformation process. The ω‑fold rule identifies sub‑goals that correspond to previously defined predicates (including those that recur on the tail of an infinite list) and replaces them with a single definition clause, effectively compressing self‑similar recursive structures. Additional rules for introducing auxiliary definitions and eliminating redundant ones are provided, completing a full transformation calculus.

The core technical contribution is the proof of semantic preservation for each rule. The authors show that any transformation step yields a program whose immediate consequence operator is identical on the ω‑complete lattice, and therefore both the original and transformed programs share the same perfect model. The proof proceeds by demonstrating operator equivalence and by a logical contradiction argument that any new clause introduced by folding is logically implied by the original set of clauses. This establishes the first known correctness results for unfold/fold transformations in the context of infinite‑list logic programs.

To illustrate the practical impact, the methodology is applied to verification problems involving Büchi automata and ω‑regular languages. The transition relation and accepting condition of a Büchi automaton are encoded as an ω‑program. Using the transformation rules, the authors systematically unfold the language of one automaton, fold it against the definition of another, and thereby prove language inclusion without constructing explicit product automata. Similarly, closure properties of ω‑regular languages (union, intersection, Kleene star) are proved by transforming the corresponding ω‑programs and showing semantic equivalence. These case studies demonstrate that complex infinite‑behaviour verification can be reduced to a series of logical program transformations, sidestepping the state‑space explosion typical of traditional automata‑theoretic techniques.

The paper concludes with a discussion of limitations and future work. While the presented rules are sound, their manual application can be labor‑intensive; the authors suggest the development of automated transformation tools and heuristics for guiding unfold/fold choices. Extensions to other infinite structures such as infinite trees or graphs are identified as promising directions, as is the integration of the transformation framework with existing model‑checking platforms to provide a hybrid verification environment.

In summary, this work establishes a rigorous theoretical basis for logic programming over infinite lists, delivers a sound unfold/fold transformation calculus that preserves perfect‑model semantics, and showcases the utility of this approach through verification of Büchi automata and ω‑regular language properties. It opens a new pathway for applying logic‑program transformation techniques to the verification of systems with inherently infinite behaviours.