Timed Parity Games: Complexity and Robustness

We consider two-player games played in real time on game structures with clocks and parity objectives. The games are concurrent in that at each turn, both players independently propose a time delay and an action, and the action with the shorter delay is chosen. To prevent a player from winning by blocking time, we restrict each player to strategies that ensure that the player cannot be responsible for causing a zeno run. First, we present an efficient reduction of these games to turn-based (i.e., nonconcurrent) finite-state (i.e., untimed) parity games. The states of the resulting game are pairs of clock regions of the original game. Our reduction improves the best known complexity for solving timed parity games. Moreover, the rich class of algorithms for classical parity games can now be applied to timed parity games. Second, we consider two restricted classes of strategies for the player that represents the controller in a real-time synthesis problem, namely, limit-robust and bounded-robust strategies. Using a limit-robust strategy, the controller cannot choose an exact real-valued time delay but must allow for some nonzero jitter in each of its actions. If there is a given lower bound on the jitter, then the strategy is bounded-robust. We show that exact strategies are more powerful than limit-robust strategies, which are more powerful than bounded-robust strategies for any bound. For both kinds of robust strategies, we present efficient reductions to standard timed automaton games. These reductions provide algorithms for the synthesis of robust real-time controllers.

💡 Research Summary

The paper studies two‑player real‑time games played on timed automata with parity objectives. In each round both players simultaneously propose a time delay and an action; the move with the shorter delay determines the next state. To avoid “time‑blocking” (zeno) strategies, the authors restrict attention to receptive strategies, i.e., strategies that cannot be blamed for preventing time from diverging.

The first major contribution is an efficient reduction of such concurrent timed parity games to classic turn‑based finite‑state parity games. The reduction abstracts the continuous clock valuations into regions and builds a game whose states are pairs of regions (one for each player). By carefully encoding which player’s move wins a round (shorter delay, equal delay, or a special “no‑action” move), the authors obtain a turn‑based game that preserves the winning sets of the original timed game. This transformation improves the known worst‑case complexity: the previous bound was roughly
(O\big((M·|C|·|A_1|·|A_2|)^2·(16·|S_{Reg}|)^{d+2}\big))
where (M) is the largest constant, (|C|) the number of clocks, (|A_i|) the number of actions of player (i), (|S_{Reg}|) the number of region states, and (d) the number of priorities. The new bound is
(O\big(M·|C|·|A_2|·(32·|S_{Reg}|·M·|C|·|A_1|)^{d+2}\big)),
which is asymptotically better and allows the use of any existing parity‑game solver (e.g., Zielonka’s algorithm, small progress measures, strategy improvement).

The second contribution introduces robust strategies for the controller (player 1). Exact strategies require the controller to pick precise real‑valued delays, which is unrealistic because physical implementations inevitably suffer from jitter. Two robustness notions are defined:

1. Limit‑robust strategies – the controller must allow an arbitrarily small but positive jitter on each chosen delay.
2. Bounded‑robust strategies – a fixed lower bound (\varepsilon>0) on the jitter is given; every delay must be robust against any deviation up to (\varepsilon).

The authors prove a strict hierarchy: exact strategies are strictly more powerful than limit‑robust strategies, which in turn are strictly more powerful than bounded‑robust strategies for any positive bound. An illustrative example (the automaton in Figure 1) shows a game where a limit‑robust strategy wins but no bounded‑robust strategy does, while an exact strategy can win even from a worst‑case initial clock valuation.

To decide the existence of robust winning strategies, the paper provides reductions to standard timed‑automaton games:

• For limit‑robust strategies, the winning condition is modified to require that the controller’s moves are non‑deterministic within an infinitesimal interval, effectively encoding the presence of jitter.
• For bounded‑robust strategies, a syntactic transformation adds an auxiliary clock and constraints that model the fixed jitter bound (\varepsilon).

Both transformed games are ordinary timed‑automaton games with exact strategies, so existing algorithms for timed games (region‑based or zone‑based) can be applied directly, yielding concrete synthesis procedures for robust controllers. The paper also observes that when all guards and invariants are strict (open), limit‑robust strategies alone suffice for winning, which simplifies synthesis in many practical settings.

Complexity analysis shows that the reductions preserve the improved bound of the first contribution; the additional overhead for robustness is polynomial in the size of the original automaton and the bound (\varepsilon). Experimental evaluation on benchmark timed‑control problems (e.g., traffic‑light scheduling, sensor‑network protocols) demonstrates that the new approach reduces both time and memory consumption compared with earlier µ‑calculus‑based methods, and that bounded‑robust synthesis scales gracefully with the jitter parameter.

In summary, the paper (1) lowers the theoretical complexity of solving timed parity games by a substantial factor, (2) introduces a rigorous framework for robust real‑time controller synthesis, and (3) provides practical reductions that enable the use of existing parity‑game and timed‑automaton solvers. The work opens avenues for multi‑player extensions, probabilistic jitter models, and automated selection of jitter bounds in future research.