Timed Parity Games: Complexity and Robustness

We consider two-player games played in real time on game structures with clocks where the objectives of players are described using parity conditions. The games are \emph{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 play strategies that ensure that the player cannot be responsible for causing a zeno run. First, we present an efficient reduction of these games to \emph{turn-based} (i.e., not concurrent) \emph{finite-state} (i.e., untimed) parity games. 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. The states of the resulting game are based on clock regions of the original game, and the state space of the finite game is linear in the size of the region graph. Second, we consider two restricted classes of strategies for the player that represents the controller in a real-time synthesis problem, namely, \emph{limit-robust} and \emph{bounded-robust} winning strategies. Using a limit-robust winning 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 winning. We show that exact strategies are more powerful than limit-robust strategies, which are more powerful than bounded-robust winning 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 addresses two fundamental challenges in the synthesis and analysis of real‑time reactive systems: (1) the high computational complexity of solving timed parity games, which are two‑player concurrent games on timed automata with parity winning conditions, and (2) the need for controllers that remain correct under inevitable timing uncertainties (jitter).

Model and Problem Setting
A timed parity game is defined on a timed automaton where, at each round, both players independently propose a delay and an action. The action associated with the smaller delay is executed; if the delays are equal a predefined tie‑breaking rule applies. The objective for each player is expressed as a parity condition over the infinite run. To avoid trivial “time‑blocking” strategies that force a Zeno run (infinitely many actions in a finite amount of time), the authors restrict strategies to be non‑Zeno: a player may not be solely responsible for making the elapsed time converge to a limit.

From Concurrent to Turn‑Based Finite‑State Parity Games
The first major contribution is an efficient reduction that transforms any timed parity game into a turn‑based, untimed parity game whose state space is linear in the size of the region graph of the original timed automaton. The construction proceeds as follows: (i) the continuous clock space is partitioned into finitely many regions (the classic region abstraction for timed automata); (ii) each region is represented as a single vertex in the reduced game; (iii) the concurrent choice of delays is encoded by a deterministic “shortest‑delay wins” rule that can be simulated by a single turn where the controller first selects a delay, then the opponent selects a possibly smaller delay, and the resulting transition is determined accordingly. Crucially, the reduction preserves the parity winning condition: a player has a winning strategy in the original game iff she has a winning strategy in the reduced turn‑based game. Because the number of regions is exponential only in the number of clocks and the maximal constant, the resulting finite game is exponentially smaller than the naïve product construction used in earlier work. Consequently, the overall decision problem drops from the previously known 2‑EXPTIME bound to EXPTIME, matching the best known bound for untimed parity games. This also opens the door to applying any modern parity‑game solver (e.g., Zielonka’s recursive algorithm, Small Progress Measures, or quasi‑polynomial time algorithms) directly to timed parity games.

Robust Strategies for Controllers
The second contribution focuses on robust synthesis, motivated by the fact that physical controllers cannot select an exact real‑valued delay; they must tolerate some non‑zero jitter. Two robustness notions are introduced:

1. Limit‑Robust Strategies – The controller may not specify an exact delay; instead, any positive jitter around the chosen value is allowed. Formally, for every ε > 0 there exists a δ ∈ (0, ε) such that the strategy remains winning when the actual delay deviates by at most δ.

2. Bounded‑Robust Strategies – A stricter variant where a concrete lower bound β > 0 on the jitter is given, and the controller must guarantee winning for all deviations up to β.

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 fixed bound. To make these notions algorithmically tractable, each robustness class is reduced to a standard timed‑automaton game:

• For limit‑robustness, a fresh “jitter clock” is introduced that can nondeterministically advance within any positive interval, thereby modeling the unavoidable timing uncertainty. The parity condition is left unchanged, and the resulting game is again a timed parity game that can be solved using the reduction from the first part.

• For bounded‑robustness, an additional clock enforces that the jitter never exceeds the prescribed bound β. This yields a timed parity game with an extra invariant that restricts the admissible delays.

Both reductions are linear in the size of the original region graph, preserving the improved complexity. Consequently, robust controllers can be synthesized by invoking any parity‑game solver on the transformed untimed game, without needing specialized algorithms for robustness.

Implications and Future Work
By bridging the gap between concurrent timed games and the rich algorithmic toolbox for untimed parity games, the paper dramatically lowers the computational barrier for solving a broad class of real‑time synthesis problems. Moreover, the robustness framework provides a principled way to incorporate timing uncertainties directly into the synthesis pipeline, yielding controllers that are provably correct even when the hardware exhibits jitter. Future research directions suggested include empirical evaluation of the reductions on benchmark real‑time systems, integration with symbolic zone‑based techniques to handle larger clock spaces, and extension of the robustness notions to multi‑objective settings (e.g., combining safety, liveness, and energy constraints).