Stuttering Equivalence for Parity Games

We study the process theoretic notion of stuttering equivalence in the setting of parity games. We demonstrate that stuttering equivalent vertices have the same winner in the parity game. This means that solving a parity game can be accelerated by minimising the game graph with respect to stuttering equivalence. While, at the outset, it might not be clear that this strategy should pay off, our experiments using typical verification problems illustrate that stuttering equivalence speeds up solving parity games in many cases.

💡 Research Summary

Parity games are a central model in formal verification, especially for solving the modal μ‑calculus model‑checking problem. A parity game is played on a finite directed graph where each vertex is owned by one of two players (even = 0, odd = 1) and is labelled with a natural‑number priority. The token moves indefinitely according to the owner’s choice, and the winner of an infinite play is determined by the parity of the lowest priority that occurs infinitely often. Solving a parity game means computing, for every vertex, which player has a winning strategy. Although the decision problem lies in UP ∩ co‑UP, a polynomial‑time algorithm is still unknown, and practical performance depends heavily on preprocessing and algorithmic heuristics.

The paper introduces stuttering equivalence as a preprocessing reduction for parity games. Stuttering equivalence originates from process theory (Kripke structures) and identifies states that have identical labels (priority and owner) and can simulate each other while allowing arbitrarily long sequences of “silent” moves that do not change the label. Compared with strong bisimulation, stuttering equivalence is coarser (it collapses more vertices) but, crucially, it is still finer than winner equivalence: any two stuttering‑equivalent vertices are guaranteed to be won by the same player, although the converse does not hold.

The authors prove this preservation property by constructing, from an arbitrary winning strategy φ for a player i starting at a vertex v, a derived strategy mimick φ,v that works from any vertex w that is stuttering‑equivalent to v. The construction proceeds as follows. For a current finite path p that is consistent with φ, they define the set reach φ,v(p) of vertices that can be reached by extending a φ‑consistent path from v which is stuttering‑bisimilar to p. If this set is non‑empty, they select a target class – the minimal equivalence class (according to a global total order ⊏) intersecting reach φ,v(p) – and then a target vertex τ φ,v(p) as the minimal element of that class that is reachable via a single edge from the last vertex of p. The mimick strategy simply follows τ φ,v(p) whenever possible, otherwise it follows any edge staying inside the current equivalence class. By induction on the length of plays, they show that any play consistent with mimick φ,v remains stuttering‑bisimilar to a φ‑consistent play, and therefore inherits the same winner. Consequently, stuttering equivalence respects the winner partition.

From a computational standpoint, the authors note that the classic algorithm for computing stuttering equivalence runs in O(n·m) time (n vertices, m edges), which is dramatically faster than the O(n³·m·d²) bound for delayed simulation (d = number of distinct priorities). Moreover, the relation can be computed using BDD‑based or distributed algorithms, making it scalable to large verification instances.

The experimental evaluation targets typical model‑checking benchmarks where parity games have few priorities (often ≤ 3) and exhibit regular structure. For each benchmark the authors (1) solve the original game with several solvers (Small Progress Measures, McNaughton’s recursive algorithm, etc.) and (2) first minimise the game graph using stuttering equivalence and then solve the quotient. The results show that in the majority of cases the minimised games are substantially smaller and the total solving time drops by factors ranging from 2 to 5. Compared with reductions based on strong bisimulation or strong bisimilarity, stuttering‑equivalence achieves greater compression because it ignores the exact number of steps needed to reach an equivalence class. However, the authors also observe that when the game graph has many distinct priorities or a highly irregular topology, the overhead of computing the equivalence can outweigh the benefits, and in such cases the naïve solve‑directly approach may be preferable.

In summary, the paper makes two main contributions: (i) a rigorous proof that stuttering‑equivalent vertices share the same winner, enabling sound quotienting of parity games; and (ii) an empirical study demonstrating that, for a wide range of verification‑derived parity games, preprocessing with stuttering equivalence yields significant performance gains over both solving the original game and using other reduction techniques. The work suggests that stuttering‑equivalence‑based minimisation should be considered a standard preprocessing step in parity‑game solvers, especially when dealing with verification problems that naturally produce low‑priority, regular graphs. Future work may explore hybrid reductions, integration with on‑the‑fly solving, and extensions to richer game models.