Synthesizing Permissive Winning Strategy Templates for Parity Games

We present a novel method to compute \emph{permissive winning strategies} in two-player games over finite graphs with $ \omega $-regular winning conditions. Given a game graph $G$ and a parity winning condition $\Phi$, we compute a \emph{winning strategy template} $\Psi$ that collects an infinite number of winning strategies for objective $\Phi$ in a concise data structure. We use this new representation of sets of winning strategies to tackle two problems arising from applications of two-player games in the context of cyber-physical system design -- (i) \emph{incremental synthesis}, i.e., adapting strategies to newly arriving, \emph{additional} $\omega$-regular objectives $\Phi'$, and (ii) \emph{fault-tolerant control}, i.e., adapting strategies to the occasional or persistent unavailability of actuators. The main features of our strategy templates -- which we utilize for solving these challenges -- are their easy computability, adaptability, and compositionality. For \emph{incremental synthesis}, we empirically show on a large set of benchmarks that our technique vastly outperforms existing approaches if the number of added specifications increases. While our method is not complete, our prototype implementation returns the full winning region in all 1400 benchmark instances, i.e., handling a large problem class efficiently in practice.


Introduction
Two-player ω-regular games on finite graphs are an established modeling and solution formalism for many challenging problems in the context of correct-byconstruction cyber-physical system (CPS) design [38,2,6].Here, control software actuating a technical system "plays" against the physical environment.The winning strategy of the system player in this two-player game results in software which ensures that the controlled technical system fulfills a given temporal specification for any (possible) event or input sequence generated by the environment.Examples include warehouse robot coordination [35], reconfigurable manufacturing systems [25], and adaptive cruise control [32].In these applications, the technical system under control, as well as its requirements, are developing and changing during the design process.It is therefore desirable to allow for maintainable and adaptable control software.This, in turn, requires solution algorithms for two-player ω-regular games which allow for this adaptability.
This paper addresses this challenge by providing a new algorithm to efficiently compute permissive winning strategy templates in parity games which enable Fig. 1.Experimental results over 1400 generalized parity games comparing the performance of our tool PeSTel against the state-of-the-art generalized parity solver GenZiel [15].Data points give the average execution time (in ms) over all instances with the same number of parity objectives.Left: all objectives are given upfront.Right: objectives are added one-by-one.See section 6 for more details on those experiments.rich strategy adaptations.Given a game graph G = (V, E) and an objective Φ a winning strategy template Ψ characterizes the winning region W ⊆ V along with three types of local edge conditions -a safety, a co-live, and a live-group template.The conjunction of these basic templates allows us to capture infinitely many winning strategies over G w.r.t.Φ in a simple data structure that is both (i) easy to obtain during synthesis, and (ii) easy to adapt and compose.
We showcase the usefulness of permissive winning strategy templates in the context of CPS design by two application scenarios: (i) incremental synthesis, where strategies need to be adapted to newly arriving additional ω-regular objectives Φ ′ , and (ii) fault-tolerant control, where strategies need to be adapted to the occasional or persistent unavailability of actuators, i.e., system player edges.
We have implemented our algorithms in a prototype tool PeSTel and run it on more than 1400 benchmarks adapted from the SYNTCOMP benchmark suite [20].These experiments show that our class of templates effectively avoids recomputations for the required strategy adaptations.For incremental synthesis, our experimental results are previewed in fig. 1, where we compare PeSTel against the state-of-the-art solver GenZiel [15] for generalized parity objectives, i.e., finite conjunction of parity objectives.We see that PeSTel is as efficient as GenZiel whenever all conjuncts of the objective are given up-front (fig. 1 (left)) -even outperforming it in more than 90% of the instances.Whenever conjuncts of the objective arrive one at a time, PeSTel outperforms the existing approaches significantly if the number of objectives increases (fig. 1 (right)).This shows the potential of PeSTel towards more adaptable and maintainable control software for CPS.
Illustrative Example.To appreciate the simplicity and easy adaptability of our strategy templates, consider the game graph in fig. 2 (left).The first winning condition Φ 1 requires vertex f to never be seen along a play.This can be enforced by Player 0 from vertices W 0 = {a, b, c, d} called the winning region.The safety template Ψ 1 ensures that the game always stays in W 0 by forcing the edge e de to never be taken.It is easy to see that every Player 0 strategy that follows this rule results in plays which are winning if they start in W 0 .Now consider the second winning condition Φ 2 which requires vertex c or d to be seen infinitely often.This induces the live-group template Ψ 2 which requires that whenever vertex a is seen infinitely often, either edge e ac or edge e ad needs to be taken infinitely often.It is easy to see that any strategy that complies with this edge-condition is winning for Player 0 from every vertex and there are infinitely many such compliant winning strategies.Finally, we consider condition Φ 3 requiring vertex b to be seen only finitely often.This induces the strategy template Ψ 3 which is a co-liveness template requiring that all edges from Player 0 vertices which unavoidably lead to b (i.e., e ab , e bd , and e de ) are taken only finitely often.We can now combine all templates into a new template Ψ ′ = Ψ 1 ∧ Ψ 2 ∧ Ψ 3 and observe that all strategies compliant with Ψ ′ are winning for In addition to their compositionality, strategy templates also allow for local strategy adaptations in case of edge unavailability faults.Consider again the game in fig. 2 with the objective Φ 2 .Suppose that Player 0 follows the strategy π: a → d and d → a, which is compliant with Ψ 2 .If the edge e ad becomes unavailable, we would need to re-solve the game for the modified game graph G ′ = (V, E \ {e ad }).However, given the strategy template Ψ 2 we see that the strategy π ′ : a → c and d → a is actually compliant with Ψ 2 over G ′ .This allows us to obtain a new strategy without re-solving the game.
While these examples demonstrate the potential of templates for strategy adaptation, there exist scenarios where conflicts between templates or graph modifications arise, which require re-computations.Our empirical results, however, show that such conflicts rarely appear in practical benchmarks.This suggests that our technique can handle a large problem class efficiently in practice.

Related work.
The class of templates we use was introduced in [4] and utilized to represent environment assumptions that enable a system to fulfill its specifications in a cooperative setting.Contrary to [4], this paper uses the same class of templates to represent the system's winning strategies in a zero-sum setting.
While the computation of permissive strategies for the control of CPS is an established concept in the field of supervisory control1 [13,41], it has also been addressed in reactive synthesis where the considered specification class is typically more expressive, e.g., Bernet et al. [7] introduce permissive strategies that encompass all the behaviors of positional strategies and Neider et al. [30] introduce permissiveness to subsume strategies that visit losing loops at most twice.Finally, Bouyer et al. [10] take a quantitative approach to measure the permissiveness of strategies, by minimizing the penalty of not being permissive.However, all these approaches are not optimized towards strategy adaptation and thereby typically fail to preserve enough behaviors to be able to effectively satisfy subsequent objectives.A notable exception is a work by Baier et al. [22].While their strategy templates are more complicated and more costly to compute than ours, they are maximally permissive (i.e., capture all winning strategies in the game).However, when composing multiple objectives, they restrict templates substantially which eliminates many compositional solutions that our method retains.This results in higher computation times and lower result quality for incremental synthesis compared to our approach.As no implementation of their method is available, we could not compare both approaches empirically.
Even without the incremental aspect, synthesizing winning strategies for conjunctions of ω-regular objectives is known to be a hard problem -Chatterjee et al. [15] prove that the conjunction of even two parity objectives makes the problem NP-complete.They provide a generalization of Zielonka's algorithm, called GenZiel for generalized parity objectives (i.e., finite conjunction of parity objectives) which is compared to our tool PeSTel in fig. 1.While PeSTel is (in contrast to GenZiel) not complete -i.e., there exist realizable synthesis problems for which PeSTel returns no solution -our prototype implementation returns the full winning region in all 1400 benchmark instances.
Fault-tolerant control is a well-established topic in control engineering [8], with recent emphasis on the logical control layer [29,18].While most of this work is conducted in the context of supervisory control, there are also some approaches in reactive synthesis.While [31,28] considers the addition of "disturbance edges" and synthesizes a strategy that tolerates as many of them as possible, we look at the complementary problem, where edges, in particular system-player edges, disappear.To the best of our knowledge, the only algorithm that is able to tackle this problem without re-computation considers Büchi games [14].In contrast, our method is applicable to the more expressive class of Parity games.

Preliminaries
Notation.We use N to denote the set of natural numbers including zero.Given two natural numbers a, b ∈ N with a < b, we use Languages.Let Σ be a finite alphabet.The notation Σ * and Σ ω respectively denote the set of finite and infinite words over Σ, and Σ ∞ is equal to Σ * ∪ Σ ω .For any word w ∈ Σ ∞ , w i denotes the i-th symbol in w.Given two words u ∈ Σ * and v ∈ Σ ∞ , the concatenation of u and v is written as the word uv.Game Graphs.A game graph is a tuple E) is a finite directed graph with vertices V and edges E, and V 0 , V 1 ⊆ V form a partition of V .Without loss of generality, we assume that for every v ∈ V there exists Winning Conditions/Objectives.Given a game graph G, we consider winning conditions/objectives specified using a formula Φ in linear temporal logic (LTL) over the vertex set V , that is, we consider LTL formulas whose atomic propositions are sets of vertices V .In this case the set of desired infinite plays is given by the semantics of Φ which is an ω-regular language L(Φ) ⊆ V ω .Every game graph with an arbitrary ω-regular set of desired infinite plays can be reduced to a game graph (possibly with a different set of vertices) with an LTL winning condition, as above.The standard definitions of ω-regular languages and LTL are omitted for brevity and can be found in standard textbooks [5].To simplify notation we use e = (u, v) in LTL formulas as syntactic sugar for u∧⃝v, with ⃝ as the LTL next operator.We further use a set of edges E ′ = {e i } i∈[0;k] as atomic proposition to denote i∈[0;k] e i .

Games and Strategies
where G is a game graph and Φ is a winning condition over G.A strategy of Player i, i ∈ {0, 1}, is a function π i : V * V i → V such that for every ρv ∈ V * V i holds that π i (ρv) ∈ E(v).Given a strategy π i , we say that the play ) for all k.We refer to a play compliant with π i and a play compliant with both π 0 and π 1 as a π i -play and a π 0 π 1 -play, respectively.We collect all plays originating in a set S and compliant with π i , (and compliant with both π 0 and π 1 ) in the sets L(S, π i ) (and L(S, π 0 π 1 ), respectively).When S = V , we drop the mention of the set in the previous notation, and when S is singleton {v}, we simply write L(v, π i ) (and L(v, π 0 π 1 ), respectively).
Winning.Given a game G = (G, Φ), a play ρ in G is winning for Player 0, if ρ ∈ L(Φ), and it is winning for Player 1, otherwise.A strategy π i for Player i is winning from a vertex v ∈ V if all plays compliant with π i and originating from v are winning for Player i.We say that a vertex v ∈ V is winning for Player i, if there exists a winning strategy π i from v. We collect all winning vertices of Player i in the Player i winning region W i ⊆ V .We always interpret winning w.r.t.Player 0 if not stated otherwise.
Strategy Templates.Let π 0 be a Player 0 strategy and Φ be an LTL formula.Then we say π 0 follows Φ, denoted π 0 ⊩ Φ, if for all π 0 -plays ρ, ρ belongs to L(Φ), i.e.L(π 0 ) ⊆ L(Φ).We refer to a set Ψ = {Ψ 1 , . . ., Ψ k } of LTL formulas as strategy templates representing the set of strategies that follows Ψ 1 ∧ . . .∧ Ψ k .We say a strategy template Ψ is winning from a vertex v for a game (G, Φ) if every Player 0 strategy following the template Ψ is winning from v.Moreover, we say a strategy template Ψ is winning if it is winning from every vertex in W 0 .In addition, we call Ψ maximally permissive for G, if every Player 0 strategy π which is winning in G also follows Ψ .With slight abuse of notation, we use Ψ for the set of formulas {Ψ 1 , . . ., Ψ k }, and the formula ) be a game graph, U ⊆ V be a subset of vertices, and a ∈ {0, 1} be the player index.Then The universal predecessor operator upre G (U ) computes the set of vertices with all the successors in U and the controllable predecessor operator cpre a G (U ) the vertices from which Player a can force visiting U in exactly one step.In the following, we introduce two types of attractor operators: attr a G (U ) that computes the set of vertices from which Player a can force at least a single visit to U in finitely many steps, and the universal attractor uattr G (U ) that computes the set of vertices from which both players are forced to visit U .For the following, let pre ∈ {upre, cpre a }

Computation of Winning Strategy Templates
Given a 2-player game G with an objective Φ, the goal of this section is to compute a strategy template that characterizes a large class of winning strategies of Player 0 from a set of vertices U ⊆ V in a local, permissive, and computationally efficient way.These templates are then utilized in section 5.1 for computational synthesis.In particular, this section introduces three distinct template classes -safety templates (section 3.1), live-group-templates (section 3.2), and co-livetemplates (section 3.3) along with algorithms for their computation via safety, Büchi, and co-Büchi games, respectively.We then turn to general parity objectives which can be thought of as a sophisticated combination of Büchi and co-Büchi games.We show in section 3.4 how the three introduced templates can be derived for a general parity objective by a suitable combination of the previously introduced algorithms for single templates.All presented algorithms have the same worst-case computation time as the standard algorithms solving the respective game.This shows that extracting strategy templates instead of 'normal' strategies does not incur an additional computational cost.We prove the soundness of the algorithms and discuss the complexities in appendix A.

Safety Templates
We start the construction of strategy templates by restricting ourselves to games with a safety objective -i.e., G = (G, Φ) with Φ := □U for some U ⊆ V .A winning play in a safety game never leaves U ⊆ V .It is well known that such games allow capturing all winning strategies by a simple local template which essentially only allows Player 0 moves from winning vertices to other winning vertices.This is formalized in our notation as a safety template as follows., Theorem 1 ([7, Fact 7]).Let G = (G, □U ) be a safety game with winning region W 0 and is a winning strategy template for the game G which is also maximally permissive.
It is easy to see that the computation of the safety template Ψ unsafe (S) reduces to computing the winning region W 0 in the safety game (G, □U ) and extracting S. We refer to the edges in S as unsafe edges and we call this algorithm computing the set S as SafetyTemplate(G, U ).Note that it runs in O(m) time, where m = |E|, as safety games are solvable in O(m) time.

Live-Group Templates
As the next step, we now move to simple liveness objectives which require a particular vertex set I ⊆ V to be seen infinitely often.Here, winning strategies need to stay in the winning region (as before) but in addition always eventually need to make progress towards the vertex set I. We capture this required progress by live-group templates -given a group of edges H ⊆ E, we require that whenever a source vertex v of an edge in H is seen infinitely often, an edge e ∈ H (not necessarily starting at v) also needs to be taken infinitely often.This template ensures that compliant strategies always eventually make progress towards I, as illustrated by the following example.
Example 1.Consider the game graph in fig. 2 where we require visiting {c, d} infinitely often.To satisfy this objective from vertex a, Player 0 needs to not get stuck at a, and should not visit b always (since Player 1 can force visiting a again, and stop Player 0 from satisfying the objective).Hence, Player 0 has to always eventually leave a and go to {c, d}.This can be captured by the livegroup {e ac , e ad }.Now if the play comes to a infinitely often, Player 0 will go to either c or d infinitely often, hence satisfying the objective.
Formally, such games are called Büchi games, denoted by G = (G = (V, E), Φ) with Φ := □♢I, for some I ⊆ V .In addition, a live-group H = {e j } j≥0 is a set of edges e j = (s j , t j ) with source vertices src(H) := {s j } j≥0 .Given a set of live-groups H = {H i } i≥0 we define a live-group template as The live-group template says that if some vertex from the source of a live-group is visited infinitely often, then some edge from this group should be taken infinitely often by the following strategy.Intuitively, winning strategy templates for Büchi games consist of a safety template conjuncted with a live-group template.While the former enforces all strategies to stay within the winning region W, the latter enforces progress while return H w.r.t. the goal set I within W. Therefore, the computation of a winning strategy template for Büchi games reduces to the computation of the unsafe set S to define Ψ unsafe (S) in ( 5) and the live-group H to define Ψ live (H) in ( 6).We denote by BüchiTemplate(G, I) the algorithm computing the above as detailed in algorithm 1.The algorithm uses some new notations that we define here.
Here, the function Büchi solves a Büchi game and returns the winning region (e.g., using the standard algorithm from [16]), is the set of edges between two subsets of vertices X and Y .
to a subset of its vertices U ⊆ V .We have the following formal result.While live-group templates capture infinitely many winning strategies in Büchi games, they are not maximally permissive, as exemplified next.
Example 2. Consider the game graph in fig. 2 restricted to the vertex set {a, b, d} with the Büchi objective □♢d.Our algorithm outputs the live-group template Ψ = Ψ live ({e ad }).Now consider the winning strategy with memory that takes edge e da from d, and takes e ab for play suffix bda and e ad for play suffix aba.This strategy does not follow the template -the play (abd) ω is in L(π 0 ) but not in L(Ψ ).

Co-Live Templates
We now turn to yet another objective which is the dual of the one discussed before.The objective requires that eventually, only a particular subset of vertices I is seen.A winning strategy for this objective would try to restrict staying or going away from I after a finite amount of time.It is easy to notice that livegroup templates can not ensure this, but it can be captured by co-live templates:

Algorithm 2 coBüchiTemplate(G, I)
Input: A game graph G, and a subset of vertices I Output: A set of unsafe edges S and a set of co-live edges D 1: given a set of edges, eventually these edges are not taken anymore.Intuitively, these are the edges that take or keep a play away from I.
Example 3. Consider the game graph in fig. 2 where we require eventually stop visiting b, i.e. staying in I = {a, c, d}.To satisfy this objective from vertex a, Player 0 needs to stop getting out of I eventually.Hence, Player 0 has to stop taking the edges {e ab , e db , e de }, which can be ensured by marking both edges co-live.Now since no edges are leading to b, the play eventually stays in I, satisfying the objective.We note that this can not be captured by live-groups {e aa , e ac , e ad } and {e da }, since now the strategy that visits c and b alternatively from Player 0's vertices, does not satisfy the objective, but follows the live-group.
Formally, a co-Büchi game is a game G = (G, Φ) with co-Büchi winning condition Φ := ♢□I, for some goal vertices I ⊆ V .A play is winning for Player 0 in such a co-Büchi game if it eventually stays in I forever.The co-live template is defined by a set of co-live edges D as follows, The intuition behind the winning template is that it forces staying in the winning region using the safety template, and ensures that the play does not go away from the vertex set I infinitely often using the co-live template.We provide the procedure in algorithm 2 and its correctness in the following theorem.Here, CoBüchi(G, I) is a standard algorithm solving the co-Büchi game with the goal vertices I, and outputs the winning regions for both players [16].We also use the standard algorithm Safety(G, I) that solves the safety game with the objective to stay in A forever.

Parity Games
We now consider a more complex but canonical class of ω-regular objectives.
Parity objectives are of central importance in the study of synthesis problems as they are general enough to model a huge class of qualitative requirements of cyber-physical systems, while enjoying the properties like positional determinacy.A parity game is a game G = (G, Φ) with parity winning condition Φ = Parity(P), where with P i = {q ∈ Q | P(q) = i} for some priority function P : V → [0; d] that assigns each vertex a priority.A play is winning for Player 0 in such a game if the maximum of priorities seen infinitely often is even.
Although parity objectives subsume previously described objectives, we can construct strategy templates for parity games using the combinations of previously defined templates.To this end, we give the following algorithm.
} is a winning strategy template for the game G, where S = Edges(W 0 , W 1 ).Moreover, the algorithm terminates in time O(n d+O (1) ), which is same as that of Zielonka's algorithm.
We again postpone the proof to the Appendix in appendix A.3, but provide the intuition behind the algorithm and the computation of the algorithm on the parity game in fig. 3. The algorithm follows the divide-and-conquer approach of Zeilonka's algorithm.Since the highest priority occurring is 6 which is even, we first find the vertices A = {d, h} from which Player 0 can force visiting {d} (vertices with priority 6) in line 14.Then since A ̸ = V , we find the winning strategy template in the rest of the graph G 1 = G| V \A .Then the highest priority 5 is odd, hence we compute the region {c} from which Player 1 can ensure visiting 5. We again restrict our graph to G 2 = G| {a,b,e,f,g} .Again, the highest priority is even.We further compute the region A 2 = {a, b} from which Player 0 can ensure visiting the priority 4, giving us G 3 = G| {e,f,g} .In G 3 , Player 0 can ensure visiting the highest priority 2, hence satisfying the condition in line 15.Then since in this small graph, Player 0 needs to keep visiting priority 2 infinitely often, which gives us the live-groups {e gf } and {e f f } in line 15.Coming one recursive step back to G 2 , since G 3 doesn't have a winning vertex for Player 1, the if condition in the line 18 is satisfied.Hence, for the vertices in A 2 , it suffices to keep visiting priority 4 to win, which is ensured by the live-group {e ab } added in the line 18.Now, again going one recursive step back to G 1 , we have W 0 = {a, b, e, f, g}.If Player 0 can ensure reaching and staying in W 0 from the rest of the graph G 1 , it can satisfy the parity condition.Since from the vertex c, W 0 will anyway be reached, we get a co-live edge e bc in line 9 to eventually keep the play in W 0 .Coming back to the initial recursive call, since now again G 1 was winning for Player 0, they only need to be able to visit the priority 6 from every vertex in A, giving another live-group {e hd }.

Extracting Strategies from Strategy Templates
This section discusses how a strategy that follows a computed winning strategy template can be extracted from the template.As our templates are just particular LTL formulas, one can of course use automata-theoretic techniques for this.However, as the types of templates we presented put some local restrictions on strategies, we can extract a strategy much more efficiently.For instance, the game in fig. 2 with strategy template Ψ = Ψ live ({e ac , e ad }) allows the strategy that simply uses the edges e ac and e ad alternatively from vertex a.
However, strategy extraction is not as straightforward for every template, even if it only conjuncts the three template types we introduced in section 3. Fig. 3.A parity game, where a vertex with priority i has label pi.The dotted edge in red is a co-live edge, while the dashed edges in blue are singleton live-groups.
For instance, consider again the game graph from fig. 2 with a strategy template Ψ = {Ψ unsafe (e ac , e ad ), Ψ colive (e aa , e ab )}.Here, non of the four choices of Player 0 (i.e., outgoing edges) from vertex a can be taken infinitely often, and, hence, the only way a play satisfies Ψ is to not visit vertex a infinitely often.On the other hand, given strategy template Ψ ′ = {Ψ colive (e ab , e db ), Ψ live ({e ab , e ac , e db })}, edge e db is both live and co-live, which raises a conflict for vertex d.Hence, the only way a strategy can follow Ψ ′ is again to ensure that d is not visited infinitely often.We call such situations conflicts.Interestingly, the methods we presented in section 3 never create such conflicts and the computed templates are therefore conflict-free, as formalized next and proven in appendix A.4. E) is conflict-free if the following are true: (i) or every vertex v, there is an outgoing edge that is neither co-live nor unsafe, i.e., v × E(v) ̸ ⊆ D ∪ S, and (ii) for every source vertex v in a live-group H ∈ H, there exists an outgoing edge in H which is neither co-live nor unsafe, i.e., v × H(v) ̸ ⊆ D ∪ S.
Due to the given conflict-freeness, winning strategies are indeed easy to extract from winning strategy templates, as formalized next.
Proposition 2. Given a game graph G = (V, E) with conflict-free winning strategy template Ψ = {Ψ unsafe (S), Ψ colive (D), Ψ live (H)}, a winning strategy π 0 that follows Ψ can be extracted in time O(m), where m is the number of edges.
The proof is straightforward by constructing the winning strategy as follows.
We first remove all unsafe and co-live edges from G and then construct a strategy π 0 that alternates between all remaining edges from every vertex in W 0 .This strategy is well defined as condition (i) in definition 1 ensures that after removing all the unsafe and co-live edges a choice from every vertex remains.Moreover, if the vertex is a source of a live-group edge, condition (ii) in definition 1 ensures that there are outgoing edges satisfying every live-group.It is easy to see that the constructed strategy indeed follows Ψ and is hence winning from vertices in W 0 , as Ψ was a winning strategy template.We call this procedure of strategy extraction ExtractStrategy(G, Ψ ).

Applications of Strategy Templates
This section considers two concrete applications of strategy templates which utilize their structural simplicity and easy adaptability.
In the context of CPS control design problems, it is well known that the game graph of the resulting parity game used for strategy synthesis typically has a physical interpretation and results from behavioral constraints on the existing technical system that is subject to control.In particular, following the well-established paradigm of abstraction-based control design (ABCD) [38,2,6], an underlying (stochastic) disturbed non-linear dynamical system can be automatically abstracted into a two-player game graph using standard abstraction tools, e.g.SCOTS [34], ARCS [12], MASCOT [19], P-FACES [21], or ROCS [26].
In contrast to classical problems in reactive synthesis, it is very natural in this context to think about the game graph and the specification as two different objects.Here, specifications are naturally expressed via propositions that are defined over sets of states of this underlying game graph, without changing its structure.This separation is for example also present in the known LTL fragment GR(1) [9].Arguably, this feature has contributed to the success of GR(1)-based synthesis for CPS applications, e.g.[40,39,3,1,23,24,37].
Given this insight, it is natural to define the incremental synthesis problem such that the game graph stays unchanged, while newly arriving specifications are modeled as new parity conditions over the same game graph.Formally, this results in a generalized parity game where the different objectives arrive one at a time.We show an incremental algorithm for synthesizing winning strategies for such games in section 5.1.Similarly, fault-tolerant control requires the controller to adapt to unavailable actuators within the technical system under control.This naturally translates to the removal of Player 0 edges within the game graph given its physical interpretation.We show how strategy templates can be used to adapt winning strategies to these game graph modifications in section 5.2.

Incremental Synthesis via Strategy Templates
In this section we consider a 2-player game G with a conjunction Φ = k i=1 Φ i of multiple parity objectives Φ i , also called a generalized parity objective.However, in comparison to existing work [11,15], we consider the case that different objectives Φ i might not arrive all at the same time.The intuition of our algorithm is to solve each parity game (G, Φ i ) separately and then combine the resulting strategy templates Ψ i to a global template Ψ = k i=1 Ψ i .This allows to easily incorporate newly arriving objectives Φ k+1 .We only need to solve the parity game (G, Φ k+1 ) and then combine the resulting template Ψ k+1 with Ψ .
While proposition 1 ensures that every individual template Ψ i is conflictfree, this does unfortunately not imply that their conjunction is also conflictfree.Intuitively, combinations of strategy templates can cause the condition (i) and (ii) in definition 1 to not hold anymore, resulting in a conflict.As already discussed in section 4, this requires source vertices U ⊆ V with such conflicts to eventually not be visited anymore.We therefore resolve such conflicts by adding the specification ♢□¬U to every objective and recomputing the templates.
To efficiently formalize this objective change, we note that a parity objective Parity(P) with an additional specification ♢□¬U for some U ⊆ V is equivalent to another parity objective P arity(P ′ ), where priority function P ′ can be obtained from P : V → [0; 2d+1] just by modifying the priorities of vertices in U to 2d+1.Let us denote such a priority function by P[U → 2d + 1].In particular, we have the following result: where Φ i = Parity(P i ) Input: A generalized parity game G = (V, E) and objectives (Φi) i≤k with Φi = Parity(Pi) such that Pi : V → [0; 2di + 1] along with a partial winning region, livegroups, and co-live edges (W0, H, D) for the generalized parity game (G, i<ℓ Φi).Output: A partial winning region W0, live-groups H, co-live edges D, and modified parity objectives return (W0, H, D, (Φi) i≤k ) 7: else 8: Lemma 1.Given a game graph G and two parity objectives Φ = Parity(P), Φ ′ = P arity(P ′ ) such that P : V → [0; 2d + 1] and Moreover, if a strategy template is winning from some vertex u in the game G ′ = (G, Φ ′ ), then it is also winning from u in the game G = (G, Φ).
Using the above ideas, we present algorithm 4 to solve generalized parity games (possibly incrementally).If no partial solution to the synthesis problem exists so far we have ℓ = 0, otherwise the game (G, i<ℓ Φ i ) was already solved and the respective winning region and templates are known.In both cases, the algorithm starts with computing a winning strategy template for each game (G, Φ i ) for i ∈ {ℓ + 1, k} (line 1) and conjuncts them with the already computed ones (line 2).Then the algorithm checks for conflicts (line 3-4).If there is some conflict the algorithm modifies the objectives to ensure that the conflicted vertices are eventually not visited anymore (line 8), and then re-computes the templates in the game graph restricted to the intersection of winning regions for all objectives (line 9).If there is no conflict, then the algorithm returns the conjunction of the templates which is conflict-free, and hence, is winning from the intersection of winning regions for every objective (line 6).The latter is formalized in the following theorem.The proof can be found in appendix B.2.
Theorem 5. Given a generalized parity game G = (G, i≤k Φ i ) with Φ i = Parity(P i ) and priority functions } is an conflict-free strategy template that is winning from W 0 in the game G, where S = Edges(W 0 , V \ W 0 ).Further, Ψ is computable in time O(kn 2d+3 ) time, where n = |V | and d = max i≤k d i .
Due to the conflict checks carried out within algorithm 4 the returned modified objectives Φ ′ i ensure that the conjunction Ψ := k i=1 Ψ ′ i of winning strategy templates Ψ ′ i for the games (G, Φ ′ i ) is indeed conflict-free.In particular, the conjuncted template Ψ is actually returned by the algorithm.Hence, incrementally running algorithm 4 is actually sound.This is an immediate consequence of theorem 5 and stated as a corollary next.
We note that the generalized Zielonka algorithm [15] for solving generalized parity games has time complexity O(mn 2di ) di d1,d2,...,d k for a game with n vertices, m edges and k priority functions: P i with 2d i priorities for each i.Clearly, algorithm 4 has a much better time complexity.However, it is not complete, i.e, it does not always return the complete winning region.This is due to templates being not maximally permissive and hence potentially raising conflicts which result in additional specifications that are not actually required.The next example shows such an incomplete instance for illustration.We however note that algorithm 4 returned the full winning region on all benchmarks considered during evaluation, suggesting that such instances rarely occur in practice.The conjunction of both templates marks all outgoing edges of vertex a and d in the live-group co-live.Hence, the algorithm would ensure that these conflicted vertices a and d are eventually not visited anymore.However, the only way to satisfy Φ 3 ∧Φ 4 is by eventually looping on vertex a.But this solution was skipped by the strategy template Ψ 4 by putting edge e ab in a live-group.Therefore, the algorithm resturns the empty set as the winning region, whereas the actual winning region is the whole vertex set.

Fault-Tolerant Strategy Adaptation
In this section we consider a 2-player parity game G = (G, Parity(P)) and a set of faulty Player 0 edges F ⊆ E ∩ (V 0 × V ) which might become unavailable during runtime.Given a strategy template Ψ for G, we can use Ψ ′ = {Ψ, Ψ unsafe (F )} for the (linear-time) extraction of a new strategy for the game, if Ψ ′ is conflict-free for G.In this case, no re-computation is needed.If Ψ ′ is not conflict-free for G, then we can remove the edges in F and compute a new winning strategy template using algorithm 3.This is formalized in algorithm 5, where we slightly abuse notation and assume that ParityTemplate only outputs strategy templates.The correctness of algorithm 5 follows directly from theorem 4.
Corollary 2. Given a 2-player parity game G = (G, Parity(P)) with a strategy template Ψ = ParityTemplate(G, P) and faulty edge set F ⊆ E ∩ (V 0 × V ) it holds that Ψ ′ obtained from algorithm 5 is a winning strategy template for G| E\F .
Faulty edges introduce an additional safety specification for which our templates are maximally permissive.This implies that algorithm 5 is sound and complete -if there exists a winning strategy for (G| E\F , Parity(P)) algorithm 5 finds one.
Let us now assume that F collects all edges controlling vulnerable actuators that might become unavailable.In this scenario, algorithm 5 returns a conservative strategy that never uses vulnerable actuators.It might however be desirable to use actuators as long as they are available to obtain better performance.Formally, this application scenario can be defined via a time-dependent graph who's edges change over time, i.e., E t with E 0 = E are the edges available at time t ∈ N and F := {e ∈ E | e ̸ ∈ E i , for some i}.Given the original parity game G = (G, Parity(P)) with a winning strategy template Ψ we can easily modify ExtractStrategy(G, Ψ ) to obtain a time-dependent strategy π g which reacts to the unavailability of edges, i.e., at time t, π g takes an edge e ∈ E t \(S ∪ D) for all vertices without any live-group, and for the ones with live-groups, it alternates between the edges satisfying the live-groups whenever they are available, and an edge e ∈ E t \(S ∪ D) when no live-group edge is available.
The online strategy π g can be implemented even without knowing when edges are available 2 , i.e., without knowing the time dependent edge sequence {E t } t∈N up front.In this case π g is obviously winning in G = (G, Parity(P)) if Ψ is conflict-free for G| E\F .If this is not the case, one needs to ensure that edges that cause conflicts are always eventually available again, as formalized next.
2 We note that it is reasonable to assume that current actuator faults are visible to the controller at runtime, see e.g.[33] for a real water gate control example.

Algorithm 5 FaultCorrection(G, Ψ, F )
Input: A parity game G = (G, Parity(P)), a strategy template Ψ , and a set of faulty edges F Output: A new strategy template Ψ ′ 1: Intuitively, guaranteed availability faults (GAF) ensure that a faulty edge is always eventually available when a play is in its source vertex.Under this fault, the following fault-correction result holds, which is proven in appendix B.3.Proposition 3. Given a game graph G with a parity objective Φ, a strategy template Ψ = {Ψ unsafe (S), Ψ live (H), Ψ colive (D)} computed by algorithm 3 and a set F = {e ∈ E | e ̸ ∈ E i , for some i} of faulty edges, the game with the objective is realizable under GAF if for every vertex v ∈ V 0 , there is an outgoing edge which is not in S ∪ D ∪ F .This proposition allows a simple linear-time algorithm to check if the templates computed by algorithm 3 are GAF-tolerant: check if every vertex in the winning region has an outgoing edge which is not in S ∪ D ∪ F .If this is not the case, the recomputation is non-trivial and is out of scope of this paper.We can however collect the vertices which do not satisfy the above property and alert the system engineer that these vulnerable actuators require additional maintenance or protective hardware.Our experimental results in section 6 show that conflicts arising from actuator faults are rare and very local.Our strategy templates allow to easily localize them, which supports their use for CPS applications.

Empirical Evaluation
We have developed a C++-based prototype tool PeSTel3 (computing Permissive Strategy Templates) that implements algorithms 1 -5.We have used PeS-Tel to show its superior performance on the two applications considered in section 5, suggesting its practical relevance.All our experiments were performed on a computer equipped with Apple M1 Pro 8-core CPU and 16GB RAM.
Incremental Synthesis.We used PeSTel to solve generalized parity games both in one shot and incremental.We compare our algorithm with existing algorithms, i.e., GenZiel from [15] and three partial solvers4 from [11], by executing them on a large set of benchmarks.We have generated two types of benchmarks from the games used for the Reactive Synthesis Competition (SYNTCOMP) [20].Benchmark A was generated by converting parity games into Streett games using standard methods, and as each Streett pair can be represented by a {0, 1, 2}priority parity game, we represented the complete Streett objective as a conjunction of multiple {0, 1, 2}-priority parity objectives, resulting in a generalized parity game.Benchmark B was generated by adding randomly 5 generated parity objectives to given parity games.We considered 200 examples in Benchmark A and more than 1400 examples in Benchmark B.
PeSTel GenZiel [15] GenZiel & GenBüchi [11] GenZiel & GenGoodEp [11] GenZiel & GenLay [11] Benchmark We summarize the complete set of results of the experiments in 6 table 1 and fig. 1.We performed two kinds of experiments.First, we solved every generalized parity game in Benchmark A and B in one shot using the different methods.The results are shown in table 1 (top) and fig. 1 (left).Although the average time taken by PeSTel is higher than GenZiel and one partial solver, it is fastest in more than 90% of the games in both benchmarks.Thus, it shows that PeSTel is as efficient as the other methods in most cases.Moreover, for every game in both benchmarks, PeSTel succeeded to compute the complete winning region, whereas the partial solvers failed to do so in some cases 7 .. We note that the instances which are hard for PeSTel are those where the winning region becomes empty, which is quickly detected by GenZiel but only seen by PeSTel after most objectives are (separately) considered.
Second, we solved the examples in Benchmark B by adding the objectives one-by-one, i.e., we solved the game with one objective, then we added one more objective and solved it again, and so on.The results are shown in table 1 rigorous proof, it is not clear whether this is an implementation bug or a theoretical mishap, leaving soundness and completeness guarantees of these algorithms open. 5The random generator takes three parameters: game graph "G", number of objectives "k", and maximum priority "m"; and then it generates "k" random parity objectives with maximum priority "m" as follows: 50% of the vertices in "G" are selected randomly, and those vertices are assigned priorities ranging from 0 to "m" (including 0 and m) such that 1/m-th (of those 50%) vertices are assigned priority 0 and 1/mth are assigned priority 1 and so on.The rest 50% are assigned random priorities ranging from 0 to "m".Hence, for every priority, there are at least 1/(2m)-th vertices (i.e., 1/m-th of 50% vertices) with that priority. 6See appendix C for a version of fig. 1 including all solvers considered in table 1. 7 Additionally, we outperform all algorithms on the benchmarks considered by Bruyère et al. [11].We have however chosen to not include them in our analysis as many of their generalized parity games have only one objective and are therefore trivial.(bottom) and fig. 1 (right).As PeSTel can use the pre-computed strategy templates if we add a new objective to a game, it outperforms all the other solvers significantly as they need to re-solve the game from scratch every time.
Fault-tolerant Control.As discussed in section 5.2, strategy templates can be used to implement a fault tolerant time-dependent strategy, if the set of faulty edges F does not cause conflicts with the strategy template.We have used PeSTel on over 200 examples of parity games from SYNTCOMP [20] to evaluate the relevance of such conflicts in practice.For this, we randomly selected different percentages of edges to be faulty and checked for conflicts with the given template.The results are summarized in fig. 4. The left plot shows the number of instances for which a conflict occurs if a certain percentage of randomly selected edges is faulty.We see that the majority of the instances never faces a conflict even when 30% of the edges are faulty.Looking more closely into the instances with conflicts, fig. 4 (right) shows the average number of conflicting vertices in these benchmarks.Here we see that conflicts occur very locally at a very small number of vertices.Our strategy templates allow for a linear-time algorithm to localize them, allowing to mitigate them in practice by additional hardware.
Remark 1.We remark again that our results are directly applicable to CPS with continuous dynamics via the paradigm of abstraction-based control design (ABCD).In particular, standard abstraction tools such as SCOTS [34], ARCS [12], MASCOT [19], P-FACES [19], or ROCS [26] automatically compute a game graph from the (stochastic) continuous dynamics that can directly be used as an input to PeSTel.The winning strategy computed by PeSTel can further be refined into a correct-by-construction continuous feedback controller for the original dynamical system using standard methods from ABCD.We leave these tool integrations to future work.

A Winning Strategy Templates
A.1 Strategy Templates for Büchi Games Here, we restate theorem 2, and formally prove the same.Proof.Before proceeding with the proof of theorem 2 we show that algorithm 1 terminates.
Lemma 2. The algorithm 1 terminates in time O(nm), where n and m are as above.
Proof.Let k ∈ N be such that , where I j is the value of I in the j-th iteration of the while loop in the ReachTemplate procedure.It suffices to show that I k = V , for the graphs where V = Büchi(G, I), since we have already restricted our initial graph to such a graph in line 2. Suppose there exists a vertex v ∈ V \I k .Then v ̸ ∈ I.If v ∈ V 0 , then there is no edge from v into I k , else v would be in B in the k + 1-th iteration, and then there exists an edge from v to V \I k , else v would be in A in the k + 1-th iteration again.
Then there is no strategy for Player 0 to visit I k , and I in particular, from v, implying v ̸ ∈ Büchi(G, I), which would be a contradiction to the fact that every vertex is Büchi winning for Player 0.
Then I k = I k+1 = V .Hence the while loop will be exited, and the procedure, and hence the algorithm, terminates.

Complexity analysis:
The procedure Büchitakes time O(nm).Then the while loop in the ReachTemplate procedure has at most n many iterations since at least one vertex is added to I in each iteration.Each iteration take O(m) time, resulting in the total complexity of O(nm) for the procedure ReachTemplate, and hence, for the algorithm.◁ With this, we are ready to prove soundness of the constructed template.Let π 0 be a strategy following Ψ , and let ρ = v 0 . . .v i . . .be a play compliant with π 0 originating at v 0 ∈ W 0 .
We first note that the play never leaves the winning region due to the safety part of the template.Now let k ∈ N be such that in the proof of the lemma above, and A i and B i be the values of A and B in the i-th iteration of the while loop in the algorithm above, i.e.
We show that ρ visits I = I 0 infinitely often.To this end, let γ = c 0 . . .c i . . .∈ [0; k] ω , such that c i = min{j ∈ [0, k] | v i ∈ I j }, i.e. c i is the iteration of while loop in the ReachTemplate procedure when v i was added in I.We show that 0 occurs infinitely often in γ.Suppose not, i.e. the minimum number m occurring infinitely often in γ is not 0. Then vertices from I m \I m−1 occur infinitely often in ρ.Then if vertices from A m \I m−1 are visited infinitely often, then since both players are forced to visit I m−1 every time A m \I m−1 is visited, by the definition of uattr, we get a contradiction.If vertices from B m are visited infinitely often, then since π 0 follows Ψ live (H), infinitely often edges leading towards A m are taken, again giving rise to a contradiction.Hence, m = 0, proving that ρ is winning for Player 0, and Ψ is a winning strategy template for vertices in W 0 .■

A.2 Strategy Templates for co-Büchi Games
Here, we restate theorem 3, and formally prove the same.Proof.We first note that the inner while loop (line 6-9) terminates.This is simple to observe since A only grows and since there are finitely many vertices the termination condition will be satisfied eventually.
We need to show that every vertex v ∈ V gets added to A in some iteration of the outer while loop.
We prove by induction that after every iteration of the outer loop, every vertex in the remaining graph is still co-Büchi winning in the remaining graph.The base case is trivial, because we recall that every vertex of G is co-Büchi winning, due to line 3.
We denote the graph after the i-th iteration by G i = (V i , E i ).Let the statement above holds true after i-th iteration, i.e.V i = CoBüchi(G i , I i ).Let u ∈ V i+1 .For the i + 1-th iteration A i+1 = Safety(G i , I i ).Now if Player 0 had a strategy of reaching A i+1 in G i , then it would be included in A i+1 after the inner while loop is executed.But since this is not the case, and u is still winning in G i , then the winning strategy is such that the plays do not necessarily stay in A i+1 .Hence, even if A i+1 is removed from the graph, u is still winning in G i+1 with the same winning strategy.Now for a vertex u to be co-Büchi winning, there exists a strategy such that every play starting at u eventually ends up in a subset J of I.But I gets strictly smaller in every iteration of the outer while loop, and it can happen only finitely often.Hence if V never reduces to ∅, there is a winning vertex v ∈ V but there is no J ⊆ I, where the play starting at v can eventually end up in, producing a contradiction.

Complexity analysis:
The CoBüchi procedure takes O(nm) time.Then the outer loop needs at most n iterations, and the inner loop needs at most O(m) time, since it is just the attr computation, resulting in total complexity of O(nm) for the algorithm.◁ Now let π 0 be a strategy following Ψ , and let ρ = v 0 . . .v i . . .be a play compliant with π 0 originating at v 0 ∈ W 0 . Let Intuitively, V i is the set of vertices which have been removed from the initial graph after i-th iteration of the outer while loop.We denote by G ′ i the restricted graph G| Vi .We first show that if a play eventually stays in G ′ i then it is winning for Player 0. For the base case, when i = 1, this is easy to see: because the play can go further away from A i , only finitely often due to the co-live edges added in line 8, and eventually the play stays in A 1 ⊆ I. Hence the play would be co-Büchi winning.Now let the statement holds true for G ′ i−1 for some i − 1 ∈ N. Now if the play stays in G ′ i .Then if the play stays in A i then it is winning by the arguments similar to the base case.Else it will eventually end up in V i−1 , since it can not go to A i infinitely often from V i−1 due to the co-live edges added in line 8 in the last iteration of inner while loop and line 5. Then by the induction hypothesis, it is again winning.
Hence, by induction the statement holds true for every i, and in particular for k, where k is the total number of iterations of the outer while loop.Since due to the safety part of the template, the play ρ stays in G k , and hence is co-Büchi winning.Hence, Ψ is a Player 0 winning template for vertices in W 0 .■

A.3 Strategy Templates for Parity Games
We formally show that the strategy template constructed using algorithm 3 is winning for Player 0. We restate theorem 4 for convenience.
Theorem 4. Given a parity game G = (G, Parity(P)) with priority function } is a winning strategy template for the game G, where S = Edges(W 0 , W 1 ).Moreover, the algorithm terminates in time O(n d+O (1) ), which is same as that of Zielonka's algorithm.
Proof.Before we prove that algorithm 3 gives a winning strategy template, we show that it terminates.Proof.This is fairly easy to see since this is a simple modification of the usual Zeilonka's algorithm for parity games, and the call to the ReachTemplate procedure terminates as shown in previous section.The complexity can be obtained by the usual analysis for Zeilonka's algorithm.◁ We now prove that theorem 4 gives a winning strategy template.Let π 0 be a strategy following Ψ , and let ρ = v 0 . . .v i . . .be a play compliant with π 0 originating at v 0 ∈ W 0 .
We prove by induction on the number of vertices n in G that π 0 is winning.When n = 1, this is trivially true.Now suppose that the statement holds for graphs of size k.Now let n = k + 1, and d be the highest priority occurring in G. First, we notice that π 0 does not allow ρ to visit W 1 by the correctness of safety templates.Now, if d is odd.Note that if ρ visits W 0 infinitely often, it will eventually stay in W 0 due to co-live edges added in line 9, then by induction hypothesis, ρ satisfies the parity winning condition.Else ρ eventually stays in W ′ 0 , since if it goes to B\W ′ 0 infinitely often, then it will again visit W 0 infinitely often due to live-groups added in line 10 and we can argue as above.Again ρ will be winning by induction hypothesis, if it stays in W ′ 0 .Otherwise, if d is even.If the play visits A infinitely often, then P d is visited infinitely often due to the live-groups added in the line 18.Otherwise, by induction hypothesis, if ρ stays in W ′ 0 , it is winning again.Hence, by induction, π 0 is a winning strategy for Player 0, implying that Ψ is a winning strategy template.■

A.4 Extracting Strategies from Strategy Templates
We show that proposition 1 holds, i.e., that Algorithms 1, 2 and 3 always return conflict-free templates.
Proof.The claim directly follows from the definition of the algorithms in the following way.First note that in every of the three algorithms, we only have unsafe edges going out of the winning region and all other restrictions are on the edges inside the winning region.Hence, there cannot be any conflict involving unsafe edges.Moreover, since the template returned by BüchiTemplate does not contain any co-live edge, it is easy to see that for such templates (i) and (ii) in definition 1 can never occur.Furthermore, the algorithm for coBüchiTemplate only adds a co-live edge when there is some other choice from the source vertex, showing that (i) in definition 1 cannot occur.Moreover, there are no live-groups in the templates returned by coBüchiTemplate, hence (ii) in definition 1 cannot occur.Similarly, in the algorithm for ParityTemplate, i.e., algorithm 3, we only add co-live edges in line 9, which are going out of W 0 , where W 0 is the winning region in a restricted game graph.Hence, there is always another choice from source vertices of such edges.Moreover, the live-groups it computes in line 10 contain edges which are inside W 0 ; and the live-groups computed in line 18 can never contain a co-live edge (as in that part of the algorithm we do not add any co-live edge).Therefore, the template returned by algorithm 3 is also conflict-free as cases (i) and (ii) of definition 1 cannot occur.■

B Applications of Strategy Templates
B.1 Proof of lemma 1 Lemma 1.Given a game graph G and two parity objectives Φ = Parity(P), Φ ′ = P arity(P ′ ) such that P : V → [0; 2d + 1] and P ′ = P[U → 2d + 1] for some vertex set U ⊆ V , it holds that L(Φ ′ ) = L(Φ ∧ ♢□¬U ).Moreover, if a strategy template is winning from some vertex u in the game G ′ = (G, Φ ′ ), then it is also winning from u in the game G = (G, Φ).
Note that by the above result, it holds that L(Φ ′ ) ⊆ L(Φ).Now, if a Player 0's strategy π is winning from a vertex u in game G ′ .Then it holds that L(u, π) ⊆ L(Φ ′ ), which implies L(u, π) ⊆ L(Φ).Hence, π is also a winning strategy from u in G. Now, suppose a strategy template Ψ is winning from u in G ′ .Then every strategy satisfying the template Ψ is winning from u in G ′ , and hence, is winning from u in G. Therefore, the template Ψ is also winning from u in G. ■

B.2 Correctness of ComposeTemplate
We recall theorem 5, and prove the correctness and conflict-freeness of the strategy templates obtained by ComposeTemplate here.
Proof.Let us denote P 1,2d+1 to be the set of vertices v such that P 1 (v) = 2d 1 +1.We show every claim using induction on the pair (|W ′ 0 | , |W ′ 0 \ P 1,2d+1 |) (ordered lexicographically), where W ′ 0 is the vertex set taken as input in the algorithm.As in the theorem statement, initially we have W ′ 0 = V .Proof.Suppose that for every vertex v ∈ V 0 , there is an outgoing edge which is not in S ∪ D ∪ F .Then consider the strategy π g that, at time t, takes the edge e ∈ E t \(S ∪ D) for all vertices without any live-group, and for the ones with livegroups, it alternates between the edges satisfying the live-groups whenever they are available, and the edge e ∈ E t \(S ∪ D) when no live-group edge is available.We show that π g is winning for Player 0, by showing that it is compliant with Ψ , and invoking theorem 4. It is easy to observe that π g is compliant with the safely and co-liveness part of Ψ .Now, to be compliant with the live-group template, we observe that the group-live edges will be available infinitely often when the play visits the source vertex, so π g will indeed choose the edges alternately.Hence it will be compliant with the strategy template Ψ .■

C Experimental Results
For completeness, we show a version of fig. 1 including all solvers considered in table 1 in fig. 5.

Theorem 4 .
Given a parity game G = (G, Parity(P)) with priority function P

Fig. 4 .
Fig. 4. Experimental results for parity games with faulty edges.Left: percentage of instances with conflicts given a certain percentage of faulty edges.Right: average percentage of vertices that created conflicts given a certain percentage of faulty edges.

Theorem 3 .Lemma 3 .
Given a co-Büchi game G = (G, ♢□I) for some I ⊆ V , if (S, D) = coBüchiTemplate(G, I) then Ψ = {Ψ unsafe (S), Ψ colive (D)} is a winning strategy template for Player 0, computable in time O(nm) with n = |V | and m = |E|.Proof.Before proceeding with the proof of theorem 3 we show that algorithm 2 indeed terminates.The algorithm 2 terminates in time O(nm), where n and m are as usual.

Fig. 5 .Proposition 3 .
Fig. 5. Experimental results over 1400 benchmark instances showing the sensitivity of different tools on the number of objectives.Data points give the average execution time (in ms) over all instances with the same number of objectives.Left: all objectives are given upfront.Right: objectives are added one by one.B.3 Proof of proposition 3 Proposition 3. Given a game graph G with a parity objective Φ, a strategy template Ψ = {Ψ unsafe (S), Ψ live (H), Ψ colive (D)} computed by algorithm 3 and a set F = {e ∈ E | e ̸ ∈ E i , for some i} of faulty edges, the game with the objective is realizable under GAF if for every vertex v ∈ V 0 , there is an outgoing edge which is not in S ∪ D ∪ F .

Table 1 .
Aggregated experimental results on generalize parity game benchmarks with objectives given up-front (top) and one-by-one (bottom).Subrows: 1st row (mean time) -average computation time (in ms); 2nd row (incomplete) -number of examples where the corresponding tool failed to compute the complete winning region; 3rd row (faster than) -number of examples where PeSTel is faster than the respective tool; 4th row (timeouts) -number of examples where the respective tool timed out (10000 ms).