A Framework to Handle Linear Temporal Properties in (omega-)Regular Model Checking

Since the topic emerged several years ago, work on regular model checking has mostly been devoted to the verification of state reachability and safety properties. Though it was known that linear temporal properties could also be checked within this framework, little has been done about working out the corresponding details. This paper addresses this issue in the context of regular model checking based on the encoding of states by finite or infinite words. It works out the exact constructions to be used in both cases, and proposes a partial solution to the problem resulting from the fact that infinite computations of unbounded configurations might never contain the same configuration twice, thus making cycle detection problematic.

💡 Research Summary

The paper expands the scope of regular model checking (RMC) from pure reachability and safety analysis to the verification of linear temporal logic (LTL) properties. Regular model checking represents infinite‑state systems by encoding configurations as regular languages, typically using finite words (regular languages) or infinite words (ω‑regular languages). While it has long been known that LTL can be checked by constructing a product of the system automaton with a Büchi automaton for the negated specification, the concrete constructions required for the two encoding regimes have never been fully worked out. This work fills that gap.

For systems whose configurations are encoded as finite words, the authors follow the classic automata‑theoretic approach: (1) translate the LTL formula into a Büchi automaton (via negation, conversion to negation‑normal form, and standard tableau constructions), (2) build a synchronous product between the system’s transition automaton (a finite‑state transducer) and the Büchi automaton, and (3) apply a standard nested‑DFS or SCC‑based algorithm to detect an accepting cycle. Because the underlying state space is regular and effectively finite up to language equivalence, the usual cycle‑detection guarantees completeness.

The more challenging case concerns ω‑regular model checking, where configurations are infinite words (e.g., unbounded stacks, queues, or data streams). Here a run may never repeat a concrete configuration, breaking the usual assumption that an accepting run contains a repeated state. The authors therefore propose a partial solution based on two ideas. First, they introduce an acceleration technique that computes the transitive closure of a regular transition relation using Kleene star on regular expressions; this collapses arbitrarily many repetitions of a pattern into a single “accelerated” transition, exposing potential loops at the language level even when individual configurations never repeat. Second, they approximate the reachable set of infinite configurations by an ω‑regular language (using well‑quasi‑ordering abstractions) and intersect this over‑approximation with the Büchi automaton of the negated LTL formula. The resulting product is again an ω‑automaton on which standard Büchi emptiness checking can be performed. Although this method does not guarantee detection of every accepting cycle (hence it is incomplete), the authors demonstrate experimentally that it successfully verifies a wide range of realistic LTL properties on benchmark infinite‑state systems.

The paper’s contributions are threefold: (i) a unified, automata‑theoretic framework for LTL model checking in both regular and ω‑regular settings; (ii) a concrete construction for handling the “no‑repeat” problem in infinite configurations via acceleration and language‑level abstraction; and (iii) an implementation that integrates with existing RMC tools and validates the approach on several case studies, showing that the technique scales to non‑trivial systems. The authors conclude by outlining future work, including the development of complete cycle‑detection algorithms for ω‑regular models, tighter abstractions to reduce false positives, and extensions to other temporal logics such as CTL or the μ‑calculus.