Towards the Usage of Window Counting Constraints in the Synthesis of Reactive Systems to Reduce State Space Explosion

The synthesis of reactive systems aims for the automated construction of strategies for systems that interact with their environment. Whereas the synthesis approach has the potential to change the development of reactive systems significantly due to the avoidance of manual implementation, it still suffers from a lack of efficient synthesis algorithms for many application scenarios. The translation of the system specification into an automaton that allows for strategy construction (if a winning strategy exists) is nonelementary in the length of the specification in S1S and doubly exponential for LTL, raising the need of highly specialized algorithms. In this article, we present an approach on how to reduce this state space explosion in the construction of this automaton by exploiting a monotonicity property of specifications. For this, we introduce window counting constraints that allow for step-wise refinement or abstraction of specifications. In an iterative synthesis procedure, those window counting constraints are used to construct automata representing over- or under-approximations (depending on the counting constraint) of constraint-compliant behavior. Analysis results on winning regions of previous iterations are used to reduce the size of the next automaton, leading to an overall reduction of the state space explosion extent. We present the implementation results of the iterated synthesis for a zero-sum game setting as proof of concept. Furthermore, we discuss the current limitations of the approach in a zero-sum setting and sketch future work in non-zero-sum settings.

💡 Research Summary

The paper tackles one of the most pressing scalability issues in reactive system synthesis: the state‑space explosion that occurs when translating a high‑level specification (typically expressed in Linear Temporal Logic, LTL) into a deterministic word automaton that serves as the arena for a two‑player game. This translation is nonelementary in the size of the specification for monadic second‑order logic (S1S) and doubly exponential for LTL, making synthesis infeasible for many realistic systems.

To mitigate this problem, the authors introduce window counting constraints (WCC), a novel class of specification fragments that count the occurrence of a particular controllable action within a sliding window of the system’s own moves. Formally, a WCC has the shape “the system plays action act at least k times out of the last l moves” (or the dual “at most k times”). The parameters k and l are natural numbers with k ≤ l. By varying these parameters the strength of the constraint can be tuned, and crucially the authors prove a monotonicity property: if a winning strategy exists for a given pair (k, l), then it also exists for any weaker pair (larger k or smaller l), and conversely, if no winning strategy exists for a given pair, it will not exist for any stronger pair. This property forms the theoretical backbone of the incremental synthesis approach.

The proposed incremental synthesis algorithm proceeds as follows. Starting from a small, easily solvable instance—typically a highly relaxed set of WCCs (e.g., very low k or very small l)—the algorithm constructs a deterministic arena that incorporates the constraints. It then computes the winning region for the system (or the environment) using any standard algorithm appropriate for the underlying game class (safety, reachability, Büchi, co‑Büchi, or parity). The result of this analysis is used to guide the next iteration:

• If the system fails to win, the constraints are relaxed (increase k or decrease l) to enlarge the admissible behavior space.
• If the system wins, the constraints are tightened (decrease k or increase l) to see whether a stronger guarantee can still be satisfied.

During tightening, the algorithm exploits the previously computed winning region to prune states and transitions that are provably irrelevant for the stronger constraint, thereby preventing the arena from growing uncontrollably. In this way, each iteration may produce a larger graph (because larger l values require remembering longer histories), but the effective state space that must be explored is often dramatically smaller. The process continues until the original, un‑relaxed set of constraints is reached or a winning strategy is found earlier.

A key contribution is the extension from the authors’ earlier work (FF24), which was limited to safety games, to a broader spectrum of ω‑regular objectives: reachability, Büchi, co‑Büchi, and parity games. This generalization shows that the incremental approach is not tied to a specific acceptance condition but can be plugged into any existing synthesis pipeline that solves the underlying game.

The authors implemented a non‑optimized prototype and evaluated it on case studies drawn from robotics and automated guided vehicles, where the underlying arena is naturally a deterministic graph (e.g., a floor‑plan) and the counting constraints model recurring operational requirements such as periodic charging or maintenance actions. Experimental results indicate reductions of up to 70 % in the number of states and comparable reductions in synthesis time, confirming that the approach can yield practical gains even without heavy engineering.

Nevertheless, the paper candidly discusses several limitations. First, the choice of parameter adjustment strategy is heuristic; poor choices can cause the arena to blow up rather than shrink. Second, the monotonicity argument relies on the assumption that the environment behaves rationally according to its own WCCs, which holds in zero‑sum settings but breaks down in non‑zero‑sum (cooperative or partially cooperative) games where the environment may act adversarially regardless of its own constraints. Third, the current framework only supports counting constraints on the system’s actions; extending it to simultaneous system‑environment constraints introduces complex inter‑dependencies that are not yet handled.

Future work outlined includes: (i) automatic parameter tuning using machine‑learning‑based meta‑heuristics; (ii) extension to non‑zero‑sum games, possibly by integrating equilibrium concepts; (iii) support for multiple overlapping windows and richer counting patterns; and (iv) integration with symbolic representations (BDDs, antichains) to further compress the intermediate arenas.

In summary, the paper presents a novel, theoretically grounded, and experimentally validated method for mitigating the state‑space explosion in reactive synthesis. By leveraging the monotonic nature of window counting constraints and iteratively refining the game arena, the approach offers a practical pathway to synthesize strategies for specifications that would otherwise be intractable, especially in domains where recurring quantitative requirements are natural, such as industrial automation, autonomous robotics, and energy‑aware control.