Algorithms for B"uchi Games

The classical algorithm for solving B"uchi games requires time $O(n\cdot m)$ for game graphs with $n$ states and $m$ edges. For game graphs with constant outdegree, the best known algorithm has running time $O(n^2/\log n)$. We present two new algorithms for B"uchi games. First, we give an algorithm that performs at most $O(m)$ more work than the classical algorithm, but runs in time O(n) on infinitely many graphs of constant outdegree on which the classical algorithm requires time $O(n^2)$. Second, we give an algorithm with running time $O(n\cdot m\cdot\log\delta(n)/\log n)$, where $1\le\delta(n)\le n$ is the outdegree of the game graph. Note that this algorithm performs asymptotically better than the classical algorithm if $\delta(n)=O(\log n)$.

💡 Research Summary

The paper addresses the computational problem of solving Büchi games, a fundamental class of two‑player turn‑based infinite‑duration games where player 1 aims to visit a designated set of states B infinitely often. The classical solution runs in O(n·m) time (n = number of vertices, m = number of edges) by repeatedly computing the attractor of B, removing the complement closed set, and iterating up to n times. While this algorithm is conceptually simple, it performs a full backward search from B in every iteration, leading to redundant work.

The authors contribute two new algorithms that improve on this baseline under different structural assumptions.

Algorithm 1 – Alternative Iterative Algorithm
The first algorithm modifies only the way the closed set Tᵣ (the set of states from which player 1 cannot force a visit to B) is identified. Instead of a pure backward search from B, it works with the complement C = S \ B. In each iteration it:

1. Computes C₁, the player 1 states whose all successors stay inside C, and C₂, the player 2 states that have at least one successor in C.
2. Forms X = Attr₂(C₁ ∪ C₂), the player 2 attractor to the union of those “safe” states.
3. Intersects X with C to obtain Z = X ∩ C.
4. Determines D, the subset of Z from which player 1 can leave Z in a single move (either a player 1 state with an outgoing edge outside Z or a player 2 state whose all successors are outside Z).
5. Computes L = Attr₁(D, G↾X), the player 1 attractor to D inside the sub‑game induced by X.
6. Sets the closed set cTᵣ = Z \ L, which is guaranteed to be a player 1 closed set disjoint from B.
7. Adds Attr₂(cTᵣ) to the winning region of player 2 and removes it from the game.

All operations besides the initial backward search are confined to the current complement C, so the extra work over the classical algorithm is bounded by O(m). Crucially, the authors exhibit families of constant‑degree graphs (out‑degree = 2) where the classical algorithm needs Θ(n²) time, while this alternative algorithm finishes in Θ(n) time. Conversely, on worst‑case inputs the algorithm still runs in O(n·m) time, matching the classical bound.

Algorithm 2 – Degree‑Sensitive Algorithm
The second algorithm exploits the maximum out‑degree δ(n) of the game graph. Building on the technique of the first algorithm, it refines the forward (player 2) search by limiting the number of times each edge is examined. By grouping vertices into logarithmic buckets based on their degree and reusing previously discovered reachability information, the forward search costs O(n·log δ(n)/log n). The backward search remains O(m). The total running time becomes

  O( n·m·log δ(n) / log n ).

When δ(n) = O(log n) (e.g., graphs where each vertex has at most logarithmic out‑degree), this yields a running time asymptotically better than O(n·m). For constant out‑degree the bound collapses to O(n·m·log log n / log n), improving over the O(n·m) baseline. The algorithm also generalizes the sub‑quadratic O(n²/ log n) result previously known only for constant‑degree graphs.

Correctness and Complexity
Both algorithms rely on standard notions of attractors and closed sets. A closed set for player 1 is a region from which player 1 cannot be forced out, and its complement is an attractor for player 2. The authors prove that the sets identified as cTᵣ (or Tᵣ) satisfy these properties, guaranteeing that the vertices removed in each iteration truly belong to player 2’s winning region. The iterative removal process terminates when no more vertices can be removed, at which point the remaining vertices constitute player 1’s winning set. Complexity analyses show that each iteration performs a constant number of attractor computations, each linear in the size of the sub‑graph examined, leading to the stated overall bounds.

Impact
The paper makes two significant contributions: (1) an alternative iterative scheme that, with only O(m) extra work, can achieve linear time on an infinite family of constant‑degree graphs where the classic method is quadratic; (2) a degree‑sensitive algorithm that beats the classical O(n·m) bound whenever the maximum out‑degree grows at most logarithmically. These results narrow the gap between the known lower bound Ω(m) and the best known upper bounds for Büchi games, and they are directly applicable to model‑checking and synthesis problems where Büchi conditions are prevalent.