Linear Time Algorithm for Weak Parity Games

We consider games played on graphs with the winning conditions for the players specified as weak-parity conditions. In weak-parity conditions the winner of a play is decided by looking into the set of states appearing in the play, rather than the set of states appearing infinitely often in the play. A naive analysis of the classical algorithm for weak-parity games yields a quadratic time algorithm. We present a linear time algorithm for solving weak-parity games.

💡 Research Summary

The paper addresses the problem of solving weak‑parity games, a class of two‑player turn‑based games played on directed graphs where each vertex is assigned an integer priority. In a weak‑parity objective the winner of an infinite play is determined by the parity (even or odd) of the minimum priority that appears at least once during the play, rather than by the set of priorities that appear infinitely often as in standard parity games.

The classical solution proceeds by iterating over the priorities from 0 up to the maximal priority d − 1. In each iteration i it computes the attractor for the player whose parity matches i (player 1 for even i, player 2 for odd i) to the set of vertices with priority i that are still present in the current sub‑graph G_i. The attractor is added to the corresponding winning region and then removed from the graph before the next iteration. This algorithm is conceptually simple and yields correct winning sets, but a naïve time analysis gives O(d·m) where m is the number of edges. Since d can be Θ(n) (n = number of vertices), the worst‑case running time becomes quadratic, O(n·m).

The authors present two key observations that together reduce the total running time to linear in the size of the graph, O(m).

1. Disjoint Edge Usage in Attractor Computations
   For each iteration i, the attractor computation only touches edges that have their source in the current vertex set S_i and their target in the newly discovered attractor A_i. Because A_i is removed from the graph after the iteration, the edge sets E_{A_i} = E_i ∩ (S_i × A_i) are pairwise disjoint across different i. Lemma 1 shows that an attractor can be computed in time proportional to |E_{A_i}| by maintaining a per‑vertex counter that is incremented only when a successor enters the attractor. Summing over all iterations yields Σ_i |E_{A_i}| = |E| = m, so the total cost of all attractor computations is O(m).

2. Constant‑Time Access to Priority‑Specific Target Sets
   The algorithm needs, at each iteration, the set of remaining vertices of priority i, i.e., p⁻¹(i) ∩ S_i. The authors achieve O(1) access to these sets by a linear‑time preprocessing step that renames vertices so that all vertices of priority 0 appear first, then priority 1, and so on. This is done using counting sort‑style arrays: a counter array ct