[Paper Review] An Ordered Approach to Solving Parity Games in Quasi Polynomial Time and Quasi Linear Space

John Fearnley, Sanjay Jain+3 more|arXiv (Cornell University)|Mar 3, 2017

Formal Methods in Verification26 references9 citations

TL;DR

This paper presents a novel progress-measure-based algorithm for solving parity games in quasi-polynomial time and quasi-linear space by reinterpreting Calude et al.'s succinct witnesses in a backward, value-iteration fashion. The key contribution is a more efficient implementation that achieves quasi-bi-linear time complexity for fixed numbers of colors and provides new upper bounds, while outperforming existing algorithms on certain benchmark classes like Friedmann's trap examples.

ABSTRACT

Parity games play an important role in model checking and synthesis. In their paper, Calude et al. have shown that these games can be solved in quasi-polynomial time. We show that their algorithm can be implemented efficiently: we use their data structure as a progress measure, allowing for a backward implementation instead of a complete unravelling of the game. To achieve this, a number of changes have to be made to their techniques, where the main one is to add power to the antagonistic player that allows for determining her rational move without changing the outcome of the game. We provide a first implementation for a quasi-polynomial algorithm, test it on small examples, and provide a number of side results, including minor algorithmic improvements, a quasi bi-linear complexity in the number of states and edges for a fixed number of colours, and matching lower bounds for the algorithm of Calude et al.

Motivation & Objective

• To develop an efficient implementation of Calude et al.'s quasi-polynomial time algorithm for solving parity games.
• To enable backward processing of the succinct witnesses originally designed for forward computation.
• To achieve quasi-linear space complexity while maintaining quasi-polynomial time performance.
• To provide a more practical and optimized alternative to existing algorithms, especially for specific game classes.
• To establish new theoretical complexity bounds and lower bounds for the algorithm.

Proposed method

• Reformulating Calude et al.'s forward-moving witnesses as backward-progress measures for value iteration.
• Introducing a modified progress measure that allows backward traversal of game graphs without full state history.
• Using a backward value iteration process to compute winning strategies via compact witness representations.
• Applying a modified version of the antagonistic player's rational move selection to preserve game outcome during backward processing.
• Integrating standard color representations into the progress measure for efficient implementation.
• Deriving complexity bounds through detailed analysis of witness updates and iteration counts.

Experimental results

Research questions

• RQ1 Can Calude et al.'s succinct witnesses be effectively repurposed for backward, value-iteration-based computation in parity games?
• RQ2 What is the time and space complexity of a backward-progress-measure algorithm using these witnesses?
• RQ3 How does the performance of this algorithm compare to existing algorithms like strategy improvement and recursive algorithms on benchmark game families?
• RQ4 What are the tightest upper bounds achievable for this algorithm, especially for fixed or logarithmic numbers of colors?
• RQ5 Can a lower bound be established that matches the worst-case quasi-polynomial time of the algorithm?

Key findings

• The proposed algorithm achieves a quasi-bi-linear time complexity of O(mn log(n)c−1) for a fixed number of colors, matching the best-known bounds for similar algorithms.
• The algorithm provides a new quasi-bi-linear FPT bound of O(mna(n)log log n), where a(n) is the inverse Ackermann function, improving on previous bounds.
• For games with a high number of colors, the algorithm achieves an upper bound of O(m · h · nc1.45+log2(h)), where h = ⌈1 + c/log(n)⌉ and c1.45 < 1.45.
• The algorithm outperforms classic strategy improvement and recursive algorithms on Friedmann’s trap examples, solving them in under 0.01 seconds.
• A family of single-player games is constructed that serve as worst-case examples, achieving the quasi-polynomial running time for both this algorithm and Calude et al.'s original algorithm.
• The implementation demonstrates superior performance on recursive ladder constructions and Friedmann’s traps, while being outperformed on random games, highlighting its class-dependent efficiency.