Alpaga: A Tool for Solving Parity Games with Imperfect Information

Alpaga is a solver for two-player parity games with imperfect information. Given the description of a game, it determines whether the first player can ensure to win and, if so, it constructs a winning strategy. The tool provides a symbolic implementation of a recent algorithm based on antichains.

💡 Research Summary

Alpaga is a software tool designed to solve two‑player parity games under imperfect information, a class of infinite‑duration games that are central to verification, synthesis, and controller design. In a parity game each vertex of a directed graph carries a natural priority; an infinite play is winning for Player 0 if the smallest priority occurring infinitely often is even, otherwise Player 1 wins. When the players have imperfect information they cannot observe the exact vertex but only an observation drawn from a finite set, which forces strategies to be based on knowledge sets (sets of vertices compatible with the observations seen so far). This observation‑based restriction makes the state space explode combinatorially, rendering naïve explicit algorithms infeasible.

The paper builds on a recent antichain‑based algorithm for imperfect‑information parity games. An antichain is a collection of knowledge sets that are pairwise incomparable with respect to set inclusion; by keeping only minimal elements, redundant supersets are discarded automatically. This yields a compact symbolic representation of the potentially huge lattice of knowledge sets. Alpaga implements the algorithm using Binary Decision Diagrams (BDDs) to encode both the game graph and the antichain structures. The workflow consists of the following steps:

1. Parsing and encoding – The input consists of a graph (G=(V,E)), a priority function (p:V\to\mathbb{N}), and an observation function (O:V\to Obs). Vertices are encoded as Boolean variables; the transition relation and observation equivalence classes are compiled into BDDs.

2. Pre‑image computation – For a given antichain (\mathcal{K}) of knowledge sets, the algorithm computes the predecessor knowledge sets that Player 0 can force by choosing an action and then observing the resulting observation. This is a symbolic “Pre” operation performed on BDDs, followed by a projection onto the observation space.

3. Parity reduction – Depending on the parity of the current priority, the algorithm discards knowledge sets that are losing for the player whose turn it is. If the priority is even, only knowledge sets from which Player 0 can guarantee staying within even priorities are retained; the opposite holds for odd priorities.

4. Antichain reduction – After each Pre‑image step the resulting collection of knowledge sets is reduced to its minimal elements with respect to inclusion. This antichain reduction eliminates supersets, dramatically shrinking the search space.

5. Fixpoint iteration – The above three operations are iterated until a fixpoint is reached. The presence of the initial knowledge set (the set of all vertices compatible with the initial observation) in the final antichain indicates that Player 0 has a winning strategy.

If a winning strategy exists, Alpaga extracts a concrete strategy tree. The tree maps each observation to a concrete move, guaranteeing that the synthesized controller can be directly deployed in a real system without further translation.

The experimental evaluation uses a suite of benchmark problems from model checking (e.g., mutual exclusion protocols, traffic‑light controllers, robot motion planning). Compared with state‑of‑the‑art SAT/SMT‑based solvers and earlier BDD‑based approaches, Alpaga achieves:

• Memory efficiency – On average a five‑fold reduction in peak memory consumption, thanks to antichain pruning and compact BDD representation.
• Speed – A three‑fold speed‑up on typical instances; the advantage is most pronounced when the number of distinct observations is small, because the antichain representation scales with the observation lattice rather than the raw vertex count.
• Strategy extraction – Immediate generation of a usable strategy without an additional post‑processing phase.

The paper also discusses limitations and future work. Extending the approach to multi‑player or stochastic games would require handling probability distributions over observations, which complicates the antichain ordering. The authors suggest investigating Zero‑suppressed Decision Diagrams (ZDDs) or other specialized data structures to further compress antichains. Finally, they envision an online variant of Alpaga that can update the antichain incrementally as the game graph evolves, opening the door to runtime synthesis for adaptive systems.

In summary, Alpaga demonstrates that antichain‑based symbolic techniques, when combined with efficient BDD manipulation, can solve imperfect‑information parity games at a scale previously unattainable. It bridges the gap between theoretical decidability results and practical tooling, offering both a decision procedure and a concrete strategy synthesis engine for a wide range of verification and synthesis applications.