Solving high-level Petri games

The manual implementation of local controllers for autonomous agents in a distributed and concurrent setting is an ambitious and error-prune task. Synthesis algorithms, however, allow for the automatic generation of such controllers given a formal specification of the system’s goal. Recently, high-level Petri games were introduced to allow for a concise modeling technique of distributed systems with a safety objective. One way of solving these games is by a translation to low-level Petri games and applying an existing solving algorithm. In this paper we present a new solving technique for a subclass of high-level Petri games with a single uncontrollable player, a bounded number of controllable players, and a local safety objective. The technique exploits symmetries in the high-level Petri game. We report on encouraging experimental results of a prototype implementation generating the reduced state space. The results for four existing and one new benchmark family show a state space reduction by up to three orders of magnitude.


Introduction
Due to the constant availability of networks and the minimization of powerful devices, modern systems are increasingly composed of a huge number of networked computers. Even if the system itself appears to be a single coherent unit, the components of such a distributed system act autonomously [52]. To avoid a constant communication of every single component with a central control, systems are more and more decentralized. This comes with the cost of an incomplete knowledge of the system's components about the system's environment.
Especially in manufacturing there is a rising demand for the development of local controllers and their mutual communication [40,41].
The growth of these systems in size and complexity makes it even more challenging for humans to correctly implement sound controllers. Synthesis [11] avoids this error-prune task by automatically generating controllers from a description of all possible actions in the system and a specification of the system's common goal which should be guaranteed against all possible behavior of the system's environment.
In this paper we consider Petri games [25], a game-theoretic approach for the synthesis of distributed systems. The game is played between two teams: the system players (the controllable behavior) and the environment players (the uncontrollable behavior). Solving such games means finding a strategy for the system players that is winning, i.e., it satisfies a given safety objective against all the environment's decisions. A strategy takes the locally known decisions of the other players as input and produces a deterministic output in form of a decision for the next step. In Petri games the players are the tokens of the underlying place/transition Petri net (P/T Petri net). The places of the net are partitioned into system and environment places. The assignment of the team membership is done via the place the player currently resides on. Players in distant locations do not know anything about each other as long as they are not communicating, i.e., participating on the firing of a joint transition. During such communications the players exchange their knowledge about the causal past of the other players, i.e., the places and transitions the player previously resided on or participated in firing, as well as his or her own past.
The high-level representation of Petri games [30] allows for a concise description of these games. Rather than depending on P/T Petri nets, high-level Petri games are based on schemata of Colored Petri Nets (CPNs) [29,36]. This facilitates to have several individual and distinguishable tokens residing on a single place. So far high-level Petri games are solved via a transformation to the equivalent low-level variant of the game and by applying the solving algorithms for P/T Petri games to the result of the transformation. In practical applications, modeling with high-level Petri games often results in low-level Petri nets exhibiting a large amount of symmetric behavior. The main reason is that in many cases the individual tokens, e.g., robots, processes, work pieces, etc., do not need to behave that differently to win the game.
In this paper we present a solving algorithm for a subclass of high-level Petri games with a single environment player, a bounded number of system players, and a safety objective. This new algorithm exploits the symmetries of the system. The subclass is defined by two restrictions. First, we consider only set-based high-level Petri games, where the markings are sets rather than multisets of individual, colored tokens. Second, we consider only Petri games where the single environment player is recurrently interfering, i.e., in every infinite sequence of transitions there are infinitely many environment transitions.
The key idea of the algorithm is a combination of the reduction technique of the corresponding class of P/T Petri games described in [25] and the construction of a reduced reachability graph for CPNs presented in [8]. We introduce the symbolic two-player game G H , a two-player game over a finite graph with complete information. This game is solvable if and only if the corresponding high-level Petri game H is solvable. The states of G H are equivalence classes of the states of the two-player game G L presented in [25] of the corresponding low-level Petri game, with respect to defined symmetries. The correctness of the construction is shown via a bisimulation between these two-player games. Furthermore, we provide an algorithm to create a winning positional strategy in G L from the winning positional strategy in G H .  The functioning drones can deliver their assigned packages via transition deliver. After each delivery, a drone has the option to save the package of the crashed drone via transition save. The system players win when every package is delivered and thus by firing transition end the place Bad can be avoided We validate the state space reduction of our approach on a set of benchmark families introduced in [21,22] in a prototype implementation. We develop the high-level representation of those benchmark families which had not already been introduced in [30] and introduce a completely new benchmark family about a package delivery service with drones. The experimental results calculated with a two hour time out show a state space reduction of a factor of up to 2366.
The remainder of the paper is structured as follows: We informally introduce the new benchmark family of a package delivery in Sect. 2 and motivate our approach by providing an intuition of the symmetries of the system. Section 3 recalls the formalism of low-level and high-level Petri games. In Sect. 4 the new solving technique for high-level Petri games is introduced and proven to be correct, before Sect. 5 shows the state-space reduction of this new technique on several benchmark families. We finish with the related work and a conclusion in Sects. 6 and 7. on such places belong to the team of system players. However, tokens residing on white places belong to the team of environment players, also called the uncontrollable players. A transition is depicted as a rectangular node. A mode of a transition is a valuation of the variables at the transition's edges. Those variables (like d, d , p in Fig. 1) are bound only locally to the transition. A transition is enabled in a mode iff on the places connected to its incoming edges the necessary tokens are available in this mode and a predicate, written as a dashed box connected to the transition, is satisfied in this mode. A missing dashed box represents the predicate true. The transition fires in a mode by removing the tokens from the places connected to its incoming edges and by putting tokens to the places connected to its outgoing edges. A transition can only fire in a mode if it is enabled in the mode.
Initially, the transitions assign and destroy are concurrently enabled. For simplicity reasons, in descriptions we omit the mode of a transition when it is clear from the context. Thus, the assignment of the packages to drones and the subsequent takeoff (via transition takeoff) may occur concurrently to the decision of the environment which drone will crash. In Petri games the players do not have a global view of the whole system. They only learn something about the other players by taking a joint transition. In this case the participating players exchange their complete knowledge, i.e., all places and transitions they had previously used as well as the knowledge they obtained from other player by previous joint transitions. This knowledge is called their causal past. For the example this means that even in the case that transition destroy fires before transition assign, the drones, each loaded with a package, take off without knowing which drone will crash. The non-functioning drone, say d, cannot take transition deliver due to the predicate d = d . To avoid trivial solutions, where the system decides to just not move any further even though there is still a possible move and only by this is able to prevent ending up in a bad place, we are searching for deadlock-avoiding strategies. Hence, the drone d must take transition crash and has to put its package into the place Lost. The functioning drones can deliver their packages (via transition deliver) and meanwhile receive the emergency signal of the crashed drone. Thus, by taking transition deliver, the drone is getting the environment's decision for the first time because the environment token residing in place Malfunction has the transition destroy in its causal past. This information is passed to the system player via the joint transition. After each delivery, the drone can decide in place Wait to pickup another assigned package via transition takeoff , or, to recover the lost package and call it a day via transition save. By taking transition deliver, a drone not only learns which drone has crashed but also exactly which package is lost and can therewith recover particularly this package. If no drone decides to recover the lost package, the system cannot avoid reaching the bad place Bad due to the deadlock-avoiding constraint. Only when each package is delivered, i.e., all p ∈ P reside on place Delivered, the system can avoid the bad place and reach the place End via transition end. Even in the case that the environment decides to destroy a drone without an assigned package, all loaded drones can take transition Delivered and thus the place End is reached.
Consider for example the case of two drones ordered to deliver three packages. In this case, the system cannot win the game because two packages have to be assigned to the same drone. If the environment now destroys this drone, the other, functioning drone, cannot save both undelivered packages. Therefore, some package has to take transition bad or bad , and the system loses.
In contrast, if three drones, say d 1 , d 2 , and d 3 , have to deliver two packages, say p 1 and p 2 , the system can win this game. Initially, the packages decide on an assignment, say p 1 is assigned to d 1 and p 2 is assigned to d 2 , and the drones take off. In the case of the environment destroying drone d 1 , package p 1 is lost. Then, d 2 can deliver its package, and afterwards can recover p 1 via transition save. Both packages now reside on Delivered, and therefore can take the transition end to avoid taking any bad transition. In the case that the environment decides to let any other drone crash, the system still can win the game because either now the other drone saves the lost package or no package gets lost anyhow.
We see here that the behavior of the game is highly symmetric: it does not matter to which drones the packages p 1 and p 2 get assigned, as long as the two chosen drones are different. For example, there is no difference in the general behavior in the case that p 1 gets assigned to d 3 and p 2 to d 1 . We say, this situation is symmetric to the situation above. It also does not matter which of the drones loaded with a package is destroyed by the environment -the other drone, after delivering its own cargo, will save the lost package.
These observations lead to the idea of exploiting symmetric behavior: we do not have to consider many different situations anymore, but can limit our examination to representatives of whole classes of symmetric situations. This makes it easier to determine whether the system can win the game.

Petri games
In this section we give an informal definition of low-level Petri games and their properties [24] and recall the definitions of high-level Petri games and their reduction technique to low-level Petri games from [30]. We assume some familiarity with Petri nets (e.g., [43,47]).

Low-level Petri games
A Petri game G = (P S , P E , T , F , In, B) models a multi-player game, where the tokens of the underlying Petri net N = (P, T , F , In), with a finite set of places P, a finite set of transitions T , a flow relation F , and an initial marking In, represent the players. Although the solving algorithm in [25] is presented for k-bounded Petri games, in this paper we assume that G is 1-bounded, i.e., in any state of the game each place hosts at most one token. We do so to keep the paper less technical. We distinguish two teams of players: the (uncontrollable) environment players are the tokens residing on environment places P E (depicted as white circles) and the (controllable) system players are the tokens residing on the system places P S (depicted as gray circles). The disjoint union of these sets yields the places of the underlying net: P = P E∪ P S . Additionally, the Petri game identifies a set B ⊆ P of bad places from the point of view of the system (depicted as double circled places). For each transition t ∈ T the pre-and postset of t are defined by Firing an enabled transition at M yields a new marking M = (M\pre(t)) ∪ post(t). This firing relation is denoted by M [t M . We call transitions with a preset only consisting of system places system transitions and all other transitions environment transitions. Transitions with a preset only consisting of environment places are called pure environment transitions. Note that only pure environment transitions are under control of the environment player, whereas transitions which contain at least one system place in its preset are under control of the system players.
Each player knows its own causal past, i.e., the places and transitions which have been used to reach the current place. This information is exchanged with all players participating at a joint transition. The aim of the system players is to cooperate to avoid reaching any bad place p ∈ B. To satisfy this safety objective, the players can solely use their locally available information. Fig. 2 A low-level Petri game in which the environment player (initially residing on place E 1 ) orders the system player (initially residing on place S) to let its processes work jointly or solely. The system can only win, i.e., avoid that any token ever resides on place ⊥, by informing itself over the environment's decision via transition info and let its created processes work together or alone according to the environment's decision Example 1 (Low-level Petri game) Figure 2 shows a simple Petri game with one environment player (initially residing on place E 1 ) and maximally three system players. At the outset there is only one system player (initially residing on place S). Later on, this player can create two independent processes. The environment however can decide whether these processes should work together (via transition order j ) or on their own (via transition order a ). In the beginning, the system player can decide whether it waits for the environment's decision and creates the two processes with this information attached (via transition info) or whether it just creates two processes without any further attached information (transition uninf). In both cases the processes can choose whether they want to work together (transition j) or alone (transition a i for i ∈ {1, 2}). The system can only win, i.e., avoid reaching the bad place ⊥, when it meets the order of the environment. Therefore, the processes must be created with the information about the environment's order. This knowledge is available in the causal past of the token residing on place E 2 and therewith is transmitted via transition info to the system.
The causal dependencies (and independencies) in G are formally represented by the unfolding of the underlying net N [17,19]. There, every loop in N is unrolled and every backward branching place is expanded by multiplying the place, so that every transition in the unfolding stands for the unique occurrence (instance) of a transition of N during an execution. The unfolding exhibits concurrency, causal dependency, and nondeterminism (forward branching of places) of the unique occurrences of the transitions in N during all possible executions. The unfolding is lifted to Petri games by keeping the distinction of environment, system, and bad places. The unfolding of the Petri game presented in Fig. 2 is shown in Fig. 3. The solid elements together with the lighter shaded ones form the complete unfolding of the Petri game.
A strategy for the system players in G describes a local controller for each system player which operates based on its currently available information about the whole system. A strategy is obtained from the unfolding by deleting some of the branches that are under control of the system players. Thus, it is technically a subprocess of the unfolding and describes for each place which transitions the player in that place can take. A strategy has to meet four conditions: (i) The strategy should not disallow any pure environment transition. This means The unfolding and a winning strategy for the system players in the Petri game presented in Fig. 2. The winning strategy is depicted by the solid elements the system players cannot prevent the environment from working on its own. (ii) Each refusal of a transition must be justified, i.e., when a system player refuses an instance of a transition in a place of the strategy, no other instance of this transition is allowed to occur in the postset of this place. This means that in a specific state, the system can only allow or disallow a transition of the original net. It cannot choose between two instances of this transition in the unfolding, when these instances are indistinguishable due to the available knowledge for the system player. (iii) The strategies must be deterministic, i.e., in no state of the strategy two transitions are enabled involving the same system player. (iv) The strategy must be deadlockavoiding, i.e., whenever the system can proceed in G there must also be a continuation in the corresponding situation in the strategy, to avoid trivial solutions. Since we consider a safety objective, the system players would win a non deadlock-avoiding strategy by just doing nothing. In a play conforming to a given strategy for the system players all remaining nondeterminism has been resolved. The system players win this play when it avoids any bad place in B. A strategy σ for the system players in G is winning iff all plays conforming to σ are winning. The formal definitions for unfolding, strategy, and plays are given in "Appendix A". Example 2 (Strategy in a low-level Petri game) The solid elements of Fig. 3 show a winning strategy for the Petri game presented in Fig. 2. Every strategy has to contain transitions order a and order j because all pure environment transitions have to occur. When the system in place S decides to get informed about the environment's decision (as in this winning strategy), it has to do so uniformly in every indistinguishable situation. Thus either no instance of an info transition is present in the strategy or both info and info . After getting informed of the environment's decision (which, due to the different causal pasts, results in two branches) the system can enable the appropriate transitions to avoid a bad place.
The game can only be won because every player memorizes its causal past and transmits this knowledge to all players participating in a joint transition. Suppose in place S the system decides to have uninf in its strategy. By the deterministic constraint, it includes neither transition info nor info and thus it is not informed of the environment's decision. Then the system cannot avoid a bad place while fulfilling the constraints of a winning strategy. Indeed, allowing all three transitions a 1 ,a 2 , and j in the postsets of P 1 , P 2 exhibits nondeterminism. Thus, since the system must not deadlock, either A 1 and A 2 , or J must be part of the strategy. Disallowing the subsequent transitions (⊥ a 1 and ⊥ a 2 , or ⊥ j , respectively) leading to a bad place, however, would yield a deadlock in one of the environment's decision.
A decision taken by the strategy in a place p depends on the causal past of p, which may be arbitrarily large. Similar to model checking approaches based on net unfoldings [18], we use cuts (maximal subsets of pairwise concurrent places in the unfolding) as unique representatives of the causal past. The standard notion of cuts, however, collects places with possibly different knowledge of the individual players about the causal past. Consider for example the cut κ = {E 2 , C a , S} in the unfolding presented in Fig. 3. The environment player residing on E 2 and the system player residing on C a know the same about the causal past because their last move was the joint transition order a . However, the system player residing on S does not know anything about the environment's decision. Therefore, the paper [25] introduced a new kind of cut, called maximal cuts, abbreviated mcut. For an environment place p an mcut is a cut including p such that for all places q in that cut either (1) the system players have maximally progressed at q, in the sense that any further system transition would require an additional environment transition starting from place p, or (2) the future starting at q does not depend on the environment. Mcuts are especially interesting for strategies in Petri games with a single environment player. Consider for example the loosing strategy where the system decides to take transition uninf. There the cut κ is not an mcut because the system player residing on S can still progress without moving the token residing on E 2 . In the presented winning strategy however, κ is an mcut because only transition info with E 2 ∈ pre(info) is enabled. Hence, for the winning strategy also the system player residing in S can be considered to be equally informed about the environment's decision because the only possible next move for this player will provide this information. In general for Petri games with one environment player every maximally progressed system player of an mcut [case (1)] can be considered to be equally informed about the environment because the next transition either directly involves the environment player or at least contains the current environment place in its causal past. This is exploited in [25] to create a two-player game with complete information which is used to solve Petri games. Also the construction of the later introduced symbolic two-player game for high-level Petri games rests on these cuts such that the complete informedness of the players does not cause any harm.
For simplicity, we restrict ourselves in this paper to Petri games G where alternative (2) does not arise. In the terminology of [25], we do not consider type-2 places here. In other words, we require that in every infinite sequence of transitions there are infinitely many environment transitions. Formally, G has a recurrently interfering environment if in every infinite firing sequence of G there are infinitely many i ∈ N with pre(t i ) ∩ P E = ∅. This restriction allows us to keep the formal definitions of elements used in the solving algorithm for Petri games, namely decision sets and the two-player game, as simple as possible and saves to introduce an additional pre-processing algorithm similar to the one presented in [25].

High-level Petri games
Parameterized set-based high-level Petri games were introduced in [30]. The term set-based means that at no point in time two tokens of the same color reside on any place of the game. This corresponds to 1-bounded Petri games in the low-level case. In this paper we restrict ourselves to set-based high-level Petri games without parameters. We recall a slightly adapted version of the definition and its properties.
We consider data values that are called colors, following [36]. We refer to a finite set of colors as a color domain, with typical letter C. Let C denote the set of all considered color domains. We use typed variables that range over a specific color domain. Let Var denote the set of all variables. We use the function t y : Var → C to declare the type t y(x) of a given variable x ∈ Var, i.e., its color domain. In high-level Petri nets individual tokens will be represented by colors.
A high-level Petri game -a type function t y : P H → C , which maps each place p ∈ P H to its color domain, i.e., the colors which can reside on p, -a guarding function g, which assigns to each transition t ∈ T H a guard, i.e., a Boolean expression g(t) which restricts the firing of t, -an arc expression function e, which assigns to each arc ( p, t) ∈ F H and (t, p) ∈ F H an arc expression e( p, t) or e(t, p), respectively, describing which tokens are withdrawn or placed by t from or on the corresponding place p during the firing, -an initial marking In H ⊆ {( p, c) | p ∈ P H ∧ c ∈ t y( p)}, and -a set of bad places B H ⊆ P H .
We require that two different color domains are disjunct, i.e., t y( p 1 ) = t y( p 2 ) ⇒ t y( p 1 ) ∩ t y( p 1 ) = ∅ for all places p 1 , p 2 ∈ P H . For a place p ∈ P H and a color c ∈ t y( p) we often use p.c as abbreviation for ( p, c) to state that the token c resides on the place p. For any set X ⊆ P H of places, we denote by X .t y = {p.c | p ∈ X ∧ c ∈ t y( p)} the set of all possible combinations of places in X with colors according to their types.
For a transition t ∈ T H let var(t) denote the set of free variables occurring in g(t) or any arc expression e( p, t) or e(t, p) for a flow ( p, t) ∈ F H or (t, p) ∈ F H , respectively. A valuation or mode v of a transition t assigns to each variable x ∈ var(t) a value v(x) ∈ t y(x). We denote all valuations of a transition t by Val(t). For a set Y ⊆ T H of transitions, we respectively. Analogously, we define for any combination of a place p ∈ P H and a color c ∈ t y( p) the corresponding

Example 3 (High-level
Petri game) Figure 4 shows a high-level version of the scenario presented as low-level Petri game in Fig. 2. Here we use the set {•} as color domain for the environment and for the initial system player, the set P = {p 1 , . . . , p n } for the created processes, and the set {÷, } for the orders of the environment. The type of the places can easily be inferred by the surrounding arc expressions, for instance, t y(A) = P. The type of the variables is given by t y( p) = P and t y(o) = {÷, }. The guarding function maps every transition to true. Arcs without a depicted expression are by convention implicitly labeled with •. The idea is the same as in the low-level case: The environment decides via transition order whether the processes should work together (token ) or alone (token ÷) and the system can decide to create them with or without this knowledge. The processes again choose to do the work jointly (transition j) or solely (transition a). In the end, the system can only win by getting informed and following the environment's order.
Since we consider set-based high-level Petri games, a marking M of H is a set M ⊆ P H .t y.
We denote by M (H ) = P P H .t y the set of all markings. An element p.c ∈ M states that in marking M a player of color c resides on place p.
A given set-based high-level Petri game H can be transformed into a 1-bounded P/T Petri game L(H ) = (P S , P E , T , F , In, B) with the set of system places P S = P H S .t y, the set of environment places holds for all t.v ∈ T and p.c ∈ P, the initial marking In = In H , and the set of bad places B = B H .t y.
With this notation, the markings of L(H ) are exactly the markings M (H ) of H . Here p.c ∈ M for a marking M of L(H ) means that a player resides on place p.c ∈ P. The enabledness and firing of a transition also directly coincide. Also, H has a recurrently interfering environment player iff L(H ) has a recurrently interfering environment player.
The unfolding of the high-level Petri game H is defined as the unfolding of L(H ). Consequently, a strategy for the system players in H is defined as a strategy in L(H ). By this, we know that the strategy is winning iff all plays conforming to the strategy avoid any bad place in B = B H .t y.
Note that appropriately renaming the nodes of the low-level Petri game presented in Fig. 2 yields an instance of the high-level Petri game presented in Fig. 4 with P = {p 1 , p 2 }. Thus, Fig. 3 also shows (modulo renaming) a winning strategy for the system players in the high-level Petri game in Fig. 4. The concrete mapping is given by the following assignment: Summarizing, a high-level Petri game H is a succinct represention of a detailed low-level Petri game L(H ), but the semantic notions of markings, firing of transitions, unfoldings, strategies, and plays are all borrowed from L(H ).

Solving high-level Petri games
In this section we show how to solve set-based high-level Petri games with a single recurrently interfering environment player and a bounded number of system players with a safety objective while exploiting the symmetries of the system. The key idea of the approach is the combination of two established concepts. Firstly, we use the techniques for the construction of a symbolic reachability graph (SRG) for Coloured Petri Nets with a significantly smaller size (for example presented in [8]). Secondly, we apply these techniques to the two-player game over a finite graph introduced in [24] which serves for solving a low-level Petri game with one environment player and a bounded number of system players with a safety objective. This results in a bisimilar game with a significantly smaller state space. Note that players can terminate and new players can be spawned during the game. The restriction to a bounded number of system players only limits the maximal number of system players in any state of the game, and not the total number of spawned and terminated players. The same applies to the restriction to a single environment player. Proofs that are omitted in this section can be found in "Appendix C".
Given a set-based high-level Petri game H with a single recurrently interfering environment player, a bounded number of system players and a safety objective, the solving algorithm proceeds in four steps: for the two-player game G L described in [25] for a low-level Petri game. Moreover, in the case that G L is created from L(H ), the states of G H are equivalence classes of the states of G L with respect to the system's symmetries. 2. Since G H is a two-player game with complete information, standard game solving algorithms are applied to gain a positional winning strategy σ H in G H . 3. Resolving the symmetries of σ H yields a winning strategy σ L in G L . 4. The techniques in [25] yield a winning strategy σ in L(H ) from σ L .
Since the strategy in a high-level Petri game is defined as the strategy in the corresponding lowlevel Petri game, these four steps yield the strategy σ for the system players in H . An overview of this algorithm and the interplay of the individual components is presented in Fig. 5. Note that step 3 and step 4 could be combined to obtain the Petri game strategy σ directly from the high-level two-player strategy σ H . However, only introducing step 3 and showing its correctness yields together with [25] the same result and simplifies the presentation.
Step 1 is the crucial part of the algorithm and this section serves for its elaboration. We start by recalling the definition of G L from [25] (with minor simplifications and adaptations). The definition of G H is split into three parts. Firstly, we define how to apply symmetries on the states of G L to obtain equivalence classes serving as states of G H . Secondly, we examine the interrelation of the classes to reduce the number of edges induced by G L . The result serves as edges of G H . Finally, we define the two-player game G H and show the correctness of our approach by defining a bisimulation between G L and G H , and generally proving that two bisimilar two-player Büchi games coincide regarding the existence of a winning strategy for Player 0. We start by introducing some general results and definitions for two-player games over a finite graph.

Preliminaries for two-player games:
with the set of all states V , the set of Player 0's states V 0 , the set of Player 1's states V 1 , the initial state v 0 , the edge relation E, and the set of accepting states F. The game is played between two players, namely Player 0 and Player 1. A strategy for Player i, for i ∈ {0, 1}, in G is a function σ : V * V i → V which maps each sequence of states ending in a state of Player i to some successor state, satisfying Player 0 wins a play if it infinitely often contains an accepting state. Otherwise, Player 1 wins. A play π conforms to a strategy σ for Player i if for all prefixes wvv ∈ V * V i V of π the strategy satisfies σ (wv) = v . A strategy σ for Player i is winning if each play which conforms to σ is won by Player i.
From game theory we know that in a Büchi game G, Player 0 has a winning strategy in G iff she has a positional winning strategy in G. Deciding the question whether Player 0 has a winning strategy in a given Büchi game G, and, if possible, generating a winning positional strategy, can be done in polynomial time in the number of edges in the game.

Solving low-level Petri games
In [25] Finkbeiner and Olderog reduce the problem of solving a low-level Petri game G with a single environment player and a bounded number of system players with a safety objective to the solving of a two-player game over a finite graph G L . They show that Player 0 has a winning strategy in G L iff the system players have a winning strategy in G .
In this section we simplify the definition of G L for the subclass of Petri games with a single recurrently interfering environment. We define G L specifically for a given low-level Petri The general idea is that G L simulates L(H ) through a sequence of decision sets, i.e., enriched markings of L(H ). In a decision set each system player is equipped with a commitment set, i.e., a set of transitions which are currently selected by the system player to be allowed to fire (or the special symbol ). If the commitment set is , the system player has to select a new set of transitions. The key idea of the reduction is to delay the environment's moves until all future moves of each system player are dependent on the environment's decision. By this, we ensure that all system players get informed of the environment's decision during their next move and all system player's commitments, which should be made independently of the environment's decision, are made before the environment's choice. This allows for applying solving algorithms for games with complete information to G L .
Formally, a decision set is a set D ⊆ P H .t y × (P(T H .Val) ∪ ) such that in a commitment set only transitions of the place's postset occur, i.e., ( p.c, We denote the set of all decision sets by D(L(H )), and define M to map a decision set D ∈ D(L(H )) to its corresponding marking This means that the transition t.v not only needs to be enabled in the corresponding marking, but also that all players in the transition's preset must allow t.v. The decision set D obtained after firing t.v, denoted by This means that the corresponding markings preserve the firing relation, i.e., holds, and only the moved system players are allowed and have to decide on a new commitment set.
If a decision set D contains a symbol, denoted by D[ , the corresponding system players have to decide on a new commitment set before any other move is allowed. This We call this relation resolution. The definition means that the resolution of a decision set D yields one successor decision set for every possible combination of replacing each in D with a possibly different commitment set C ⊆ T H .Val. The multiple successors are due to the several decisions the system players can make.
A decision set D ∈ D(L(H )) can have the following properties: D is environment-dependent iff there is no symbol in any tuple in D, there is a pair (e.d, post(e.d)) ∈ D for some Note that an mcut in a Petri game strategy corresponds to an environment-dependent decision set, i.e., all next moves of the system players are fixed (there is no symbol in D) and each of these moves is only possible after a progress of the environment of which each player gets informed by this move.
The game graph for a 1-bounded Petri game L(H ) with a single recurrently interfering environment player is a vertex labeled graph i.e., the decision set containing all places of the initial marking and the system players still have to decide for a commitment set, and -the labeled edge relation contains a bad place, is a deadlock, is terminating, or is nondeterministic, there is only a -labeled self-loop originating from D. Otherwise, we consider three disjunct cases for edges originating in D: Case D ∈ V L 1 , i.e., all players have decided for a commitment set, but cannot proceed without the environment. Then for all t.
, at least one system player has yet to decide for a commitment set.
e., all system players made their decisions and can proceed without the environment. Then for all The condition for pre(t.v) ensures that only edges for system transitions are considered.
We define with R(A L ) the elements in V L that are reachable from D 0 under the edge relation E L . We finally define the two-player Büchi game over a finite graph A strategy for Player i, for i ∈ {0, 1}, in G L is a function σ L : (V L ) * V L i → V L which maps each sequence of states ending in a state of Player i to some successor state. A play π on G L is a possibly infinite sequence π = v 0 v 1 v 2 . . . of states with v 0 = I L and (v j , v j+1 ) ∈ E L for all j ∈ N. Player 0 wins if π infinitely often contains a state f ∈ F L . Otherwise, Player 1 wins. A play π conforms to a strategy σ L for Player i if for all prefixes wvv ∈ (V L ) * V L i V L of π the strategy satisfies σ L (wv) = v . A strategy σ L for Player i is winning if each play π which conforms to σ L is won by Player i.
In [25], it is shown that there is a winning strategy for the system players in a P/T Petri game G with one environment player and a bounded number of system players if and only if there is a winning strategy for Player 0 in a two-player Büchi game over a finite graph. This proof caters for the more general case with type-2 places, i.e., where the environment player does not need to recurrently interfere. The proof rests on a link between mcuts in the strategy of the Petri game and the corresponding environment-dependent decision sets in the two-player game. For more details and insights we refer to [25]. Since the low-level Petri game L(H ) considered here is a specific instance of the Petri games G studied in [25], the result still holds for L(H ) and G L . In this paper, we do not reconsider this proof.

Symbolic decision sets
In [8], Chiola et al. construct a Symbolic Reachability Graph (SRG) for high-level Petri nets. In this graph the nodes are equivalence classes of markings with respect to symmetries, and instead of the ordinary firing relation between the markings, the symbolic firing relation is used. The following section introduces equivalence classes of decision sets with respect to symmetries and lifts results of [8] about markings (see "Appendix B") to decision sets. The representatives of the equivalence classes form the vertices of the high-level game graph A H . This is, analogously to the low-level case, the graph over which the symbolic two player game G H is defined.
A symmetry s C on a color domain C ∈ C is a permutation on C. A symmetry s on a highlevel Petri game H is a family (s C ) C∈C (short (s C ) C ) of symmetries on all color domains C.
holds. This condition ensures that the symmetries are "compatible" with the firing of transitions: if a transition t, fireable in mode v, takes the color c from a place p (i.e., p.c ∈ pre(t.v)), then it should be fireable in mode s(v) and, when fired, take color s(c) from place p (i.e., p.s(c) ∈ pre(t.s(v))). The same applies to the postset of t. Hence, admissible symmetries on a high-level Petri game are those symmetries which are compatible with the game's semantics structure.
As for places, we can apply symmetries to sets of transitions A ⊆ T H .Val by s(A) = {t.s(v) | t.v ∈ A}. For a high-level Petri game H we fix one set S satisfying the conditions above, and call it the set of admissible symmetries.

Example 4
Consider the package delivery benchmark family of Fig. 1 with three packages P = {p 1 , p 2 , p 3 }, three drones D = {d 1 , d 2 , d 3 }, and the color domains of the places C 0 = {•}, C 1 = P, C 2 = D, and C 3 = D × P. Thus, every symmetry s ∈ S is of the form s = (s 0 , s 1 , s 2 , s 3 ), where s i is a permutation on C i . This means that there is only one possibility for s 0 (namely, id {•} ), |P|! = 3! = 6 possibilities for s 1 , |D|! = 3! = 6 possibilities for s 2 , and consequently there are 6 · 6 = 36 possibilities for permutations s 3 on the Cartesian product D × P. Ultimately the set S of all symmetries contains 1 · 6 · 6 · 36 = 1296 elements.
We are now interested in the largest set S of admissible symmetries. Therefore, we have to consider the conditions the admissibility property imposes on symmetries. There is only one predicate not equal to true, namely d = d at transition deliver. For all drones d, d ∈ D holds that d = d ⇔ s(d) = s(d ) because all symmetries s ∈ S are bijective. Thus, the predicates do not impose any restricting condition on the symmetries because v(t) = s(v)(t) holds for all t ∈ T H , v ∈ Val(t), and s ∈ S .
Consider now the transition deliver. A valuation v ∈ Val(deliver) assigns to all variables in var(deliver), namely d, d , and p, a value of the corresponding type. We denote . The representatives D are called symbolic decision sets. We fix with s D a symmetry that maps a decision set D to its corresponding representative, i.e., s D (D) = D. Thus, the admissible symmetries on a high-level Petri game are a tool to transform equivalent situations into each other.
As a first property we consider the interplay of symmetries and the relations between decision sets.

Lemma 1
The admissible symmetries are compatible with the firing of a transition t ∈ T H in mode v ∈ Val(t) in a decision set. The same is true for the resolution of a symbol in a decision set. This assumption allows us to show that the following properties of a decision set are preserved by the application of admissible symmetries.

Lemma 2 Let D ∈ D(H ) and s ∈ S. Then D is environment-dependent, contains a bad place, is a deadlock, is terminating or is nondeterministic if and only if s(D) has the same property.
These properties can be proven by using Lemma 1 and the following facts about symmetries (see "Appendix C"). An admissible symmetry s ∈ S applied to a set A.t y with A ⊆ P H leaves the set unchanged, i.e., s

(A.t y) = A.t y. This also holds for a set A.Val with A ⊆ T H . The application of s is compatible with intersections of sets A, B ⊆ P H .t y or sets A, B ∈ T H .Val, i.e., s(A ∩ B) = s(A) ∩ s(B).
Lemma 2 yields the uniform satisfaction of these properties throughout the complete equivalence class.

Corollary 1 Let D be a decision set. Then D has one of the properties listed above if and only if all D ∈ [D] (and in particular D) have the same property.
The representatives D of the decision sets D ∈ V L of the low-level game graph A L form the vertices of the high-level game graph A H . Here you can already feel the spirit of the symbolic reachability graph SRG, where the nodes are symbolic markings M instead of ordinary markings M as in the reachability graph RG.
Usually, the relation on equivalence classes is given by all connections between the individual elements of the corresponding classes. Lemma 1 shows that for equivalence classes of decision sets, we only have to consider connections where the source is a representative of the class. The next section reduces this relation even further, by only considering equivalence classes of firings, local to the source decision set.

Symbolic firing and symbolic resolution
In this section we define equivalence classes of transition firings to define the edge relation of the high-level game graph A H . In general, this relation is smaller than the relation containing an edge for every possible transition firing or resolution between the corresponding equivalence classes of decision sets. Again, results of [8] are lifted from markings to decision sets.

Example 5
Consider the scenario of the package delivery of Fig. 1 with three packages P = { p 1 , p 2 , p 3 } and three drones D = {d 1 , d 2 , d 3 }. Assume the packages assigned themselves to the drones according to their index, and the drones, loaded with their corresponding cargo, took off, i.e., the three tokens (d 1 , p 1 ), (d 2 , p 2 ), and (d 3 , p 3 ) reside on the place Fly. Further assume that the environment decided that drone d 1 is defective via transition destroy in mode v = {d → d 1 }, i.e., a token d 1 resides on Malfunction. The corresponding marking is {Fly.(d 1 , p 1 ), Fly.(d 2 , p 2 ), Fly.(d 3 , p 3 ), Malfunction.d 1 }.
Since the system players do not know which drone got destroyed and must not deadlock, they should allow both transitions crash and deliver in all possible modes to win the game. The environment player d 1 on Malfunction as usual also allows both transitions in all modes. We denote the modes u ∈ Val(crash) by u We abbreviate crash.u (i, j) by cr (i, j) and deliver.v (i, j,k) by del (i, j,k) . The decision set described above is (2,2) , del (2,2,1) , del (2,2,3) (3,3) , del (3,3,1) , del (3,3,2) }), The fireable transitions from this decision set are cr (1,1) , del (2,2,1) , and del (3,3,1) . This means, when the relation on decision sets is lifted to equivalence classes by collecting all connections between individual elements of the corresponding classes, these three transitions all induce an outgoing edge from [D 1 ]. This is illustrated in Fig. 6 where [D 1 ] is depicted in the middle of the figure. The decision sets obtained after the respective firing are D 2 , D 3 , and D 4 . Since D 2 and D 3 are in the same equivalence class, this results in a connection between [D 1 ] and [D 2 ] for del (2,2,1) and del (3,3,1) each. Consider now the symmetry s ∈ S that swaps p 2 and p 3 in P, swaps d 2 and d 3 in D, and accordingly operates on the Cartesian product P × D. This symmetry leaves D 1 invariant. When applied to del (2,2,1) or del (3,3,1) , the respective other transition is obtained. We call these two transitions therefore equivalent with respect to D 1 (since the symmetry s leaves D 1 invariant). Instead of considering both firings, we chose one of these transitions to represent both firings.
From Lemma 1 we see that, if an admissible symmetry s ∈ S leaves a decision set D invariant, then a transition t is fireable in mode v ∈ Val(t) at D if and only if t is fireable in mode s(v). These symmetries form a group (later called the isotropy group of D) and their application leads to equivalence classes of valuations which are locally belonging to the decision set. Instead of considering all valuations in which a transition is fireable from a decision set, it suffices to consider representatives of these equivalence classes. As a result, the size of the firing relation between equivalence classes of decision sets decreases. This Fly.(d 1 , p 1 ), {cr (1,1) , del (1,1,2) , del (1,1,3) } Fly.(d 2 , p 2 ), {cr (2,2) , del (2,2,1) , del ( Fly.(d 2 , p 2 ), {cr (2,2) , del (2,2,1) , del (2,2,3) } Fly.(d 3 , p 3 ), {cr (3,3) , del (3,3,1) , del (3,3,2) del (2,2,1) del (3,3,1) cr (1,1) Fig. 6 An illustration of equivalences of transition firings. The decision set D 1 (depicted in the middle) has three successor decision sets according to the standard firing relation: D 2 , D 3 , which belong to the same symbolic decision set (depicted at the bottom), and D 4 (depicted at the top). Since the transitions del (2,2,1) and del (3,3,1) can be mapped to one another via a symmetry not affecting D 1 , the relation between [D 1 ] and [D 2 ] can be represented by only one of them. The equivalence of the transitions is depicted by the dashed connection in the middle reduced firing relation, called the symbolic firing relation, is the first part of the edge relation of the high-level game graph A H . However, considering a symbolic decision set, after firing a transition in a representative of an equivalence class of valuations, the decision set obtained after the firing does not have to be a symbolic decision set itself. Since the symbolic firing relation will be defined between symbolic decision sets, this fact must be taken into account when defining the relation.
Additionally to the firing relation there is the relation of resolution between decision sets. Thus, we also define the symbolic resolution between symbolic decision sets. This relation forms the rest of the edge relation of We now define the symbolic firing relation between symbolic decision sets. For that, instead of firing a transition in all modes, we only consider the representatives of equivalence classes of modes, local to the symbolic decision set. The symbolic decision set obtained after the symbolic firing is corresponding to the decision set obtained after the ordinary firing of the transition in the representative mode.
We say a transition t can fire symbolically from the symbolic decision set D in mode . The symbolic decision set D obtained after the symbolic firing is determined as follows: To define the symbolic resolution between symbolic decision sets, we can not use representatives of the symbol . Instead, when symbolically resolving a symbol in a symbolic decision set, we declare the possible targets as the representatives of possible targets of an ordinary resolution.
We In the following properties we compare the ordinary firing relation and the ordinary resolution with their symbolic counterparts.

Property 1
Each ordinary transition firing is represented by a symbolic transition firing, and each ordinary resolution is represented by a symbolic one. - The first property can be shown with the help of Lemma 1, analogously to [8]. The proof of the second property has the same structure. Property 2 Each symbolic firing represents a set of ordinary firings, in which all source decision sets belong to the equivalence class of the symbolic source decision set of the symbolic firing. The same holds for the resolution of .
Again, the first property can be shown analogously to [8] using Lemma 1, and the proof of the second property uses the same ideas.

Symbolic two-player game
In this section we define the high-level game graph A H and, based on its structure, the symbolic two-player game G H . We show that Player 0 has a winning strategy in G H if and only if there is a winning strategy for Player 0 in the low-level two-player game G L that corresponds to L(H ). This is proven by introducing a bisimulation on the two-player games. We fix a set-based high-level Petri game with a single recurrently interfering environment player and a bounded number of system players H = (P H S , P H E , T H , F H , t y, g, e, In H , B H ) throughout the section.

Remember that the vertices of A L are decision sets and an edge between two decision sets D and D only exists if D[t.v D or D[ D holds. We analogously define the high-level game graph A H by considering the symbolic counterparts. This means, the vertices of A H are the symbolic decision sets and there is an edge between two symbolic decision sets D and D iff D[[t.v D or D[[ D holds. Note that we represent an equivalence class [D]
with respect to S by the symbolic decision set D when no confusion arises.
For the high-level Petri game H , we define the vertex labeled high-level game graph , at least one system player has yet to decide for a commitment set. Then (D, , D ) e., all system players made their decisions and can proceed without the environment. Then for all t ∈ T H and v ∈ Val(t) D Note that the labeling of the representatives is identical to the labeling in the low-level case and since the initial marking In H is symmetric, D 0 = D 0 holds.
The symbolic two-player Büchi game G H is defined on the structure of A H , as the definition of G L is based on A L . This means that the states in G H are the reachable symbolic decision sets, and there is an edge between two states, if these states are symbolically related.
Let SR(A H ) be the set of vertices in V H that are reachable from D 0 under E H . The high-level two player Büchi game over a finite graph (or symbolic Büchi game) To show that the two-player games G L and G H are bisimilar (which yields the correctness of our approach), we compare the structures of A H and A L . First, the edge relations of the two graphs correspond to each other (Lemma 3). Second, the set of reachable symbolic decision sets in A H is exactly the set of representatives of decision sets reachable in A L (Lemma 4).

Lemma 3 For every edge in A L , there is a corresponding edge in A H , and vice versa:
Since the self-loops of the edge relations, as well as the assignment of the vertices, depend on the properties of the (symbolic) decision sets and the other edges of the relations are induced by the (symbolic) firing relation and the (symbolic) resolution, the proof mainly depends on Corollary 1 and on Properties 1 and 2 (see "Appendix C").

Lemma 4 The representatives of decision sets in R(A L ) are exactly the symbolic decision sets in SR(
This lemma can be proven by an induction over the length of the shortest path from D 0 to a decision set D in A L , or from D 0 to a symbolic decision set D in A H , respectively. The induction step follows from Lemma 3 (see "Appendix C"). We generally define a bisimulation relation on Büchi games and show that two bisimilar Büchi games coincide on the existence of a winning strategy. The instantiation of this result for the low-level two-player game G L and the symbolic high-level game G H yields the correctness of the main step of the solving algorithm for high-level Petri games.
We can view any Büchi game G = (V , V 0 , V 1 , v 0 , E, F) as a state-labeled transition system (V , E, λ, v 0 ) with the set of states V , the transition relation E, and the initial state v 0 as defined in G, and a labeling function λ : A bisimulation between two state-labeled transition systems TS 1 = (S 1 , → 1 , λ 1 , s 0 ) and holds. Two states s ∈ S 1 and t ∈ S 2 are called bisimilar, denoted by s ∼ t, if there is a bisimulation B between TS 1 and TS 2 satisfying (s, t) ∈ B. The transition systems TS 1 and TS 2 are called bisimilar, denoted by TS 1 E , λ , v 0 ). Particularly, this means that for any such bisimulation B and every two states v ∈ V and v ∈ V with (v, v ) ∈ B the assignment of the states coincide, i.e., v Proof For inductively defining a strategy on sequences of length n in a Büchi game, it suffices to only define it on paths that are consistent with the so far defined strategy. All other sequences are mapped to an arbitrary successor.
Let B ⊆ V × V be the bisimulation between G and G and σ a winning strategy for Player 0 in G. We construct a winning strategy σ for Player 0 in G from σ . We define σ inductively on paths of length n through the arena. For that we, also inductively, define a helper mapping τ , that maps paths of length n + 1 in G that are consistent with σ to corresponding paths in G.
The construction will ensure that, for all n, τ is defined for all paths of length n +1 consistent with σ such that the image is consistent with σ , -the states are pairwise bisimilar, i.e., if σ is defined for all consistent paths of length n that end in a state of V 0 .
(IB) Consider the case n = 0. Define τ (v 0 ) = v 0 , and σ is undefined since there are no paths of length 0. (IH) Assume now, for an arbitrary n, that σ is defined for all consistent paths of length n and τ is defined for all paths of length n + 1 consistent with σ .
Let π = v 0 v 1 v 2 . . . be a play in G that is consistent with σ . By defining v j as the last element in τ (v 0 . . . v j ) for every j ≥ 0, we obtain a play π = v 0 v 1 v 2 . . . in G that is consistent with σ . Therefore, Player 0 wins π in G, and since for all j, v j ∈ F iff v j ∈ F , Player 0 wins π in G . Since ∈ B} is a bisimulation between G and G, the converse direction follows analogously.
Lemma 6 together with Lemma 5 yields the conformity of the symbolic high-level game G H and the corresponding low-level game G L regarding the existence of a winning strategy. We define σ L (D) = D 1 . Hence, σ L is positional. The strategy σ L is also winning: Let ρ = D 0 D 1 · · · ∈ (V L ) ω be a play of G L that is consistent with σ L . Then ρ := D 0 D 1 · · · ∈ (V H ) ω is a play of G H , that by definition is consistent with σ H . Therefore, ρ is winning in G H . This, as in the proof of Lemma 6, implies that ρ is winning in G L .
Since the definition of a winning strategy in a high-level Petri game H is defined as a winning strategy in the corresponding low-level Petri game L(H ) (cp. Sect. 3.2), Lemma 7 yields the final result.
Theorem 1 Let H be a set-based high-level Petri game with a single recurrently interfering environment player and a bounded number of system players and G H the corresponding symbolic two-player game. Then the system players have a strategy in H if and only if Player 0 has a winning strategy in G H .
We construct a winning strategy for the system players in H , i.e., a winning strategy for the system players in the corresponding low-level Petri game L(H ), from the positional winning strategy σ H for Player 0 in G H in two steps. First, we create a positional winning strategy σ L for Player 0 in G L from σ H as described above. Second, we apply the algorithm presented in [25] to σ L , i.e., traversing σ L in breadth-first order while adding the corresponding places and transition of the decision sets, to create a winning strategy for the system players in L(H ). Note that the last step would take infinitely long for infinite Petri game strategies such that a practical algorithm has to provide a finite representation of the strategy.

Experimental results
In this section we report on our prototype implementation for generating the symbolic twoplayer game G H . We implemented three algorithms for the creation of the reduced state space and compare their runtime to the complete state space creation of Adam [22]. These results are depicted in Table 1. All algorithms are integrated into the Adam framework to exploit its data structures and functionality for Petri nets and Petri games.
Adam uses Binary Decision Diagrams (BDDs) to answer the question of the existence of a strategy and to calculate a strategy in the positive case. In the original algorithm the explicit state space is never generated and thus, the concrete size of G L could not directly be obtained. To have a proper comparison of the different sizes of the generated state spaces (G H versus G L ) we extended Adam with a fixed point algorithm which calculates a BDD for the reachable states of the two-player game G L and ask for the number of solutions to obtain the number of states of G L as reference value. As input, the Reference-Approach takes the low-level version L(H ) of a high-level Petri game H . The results and used resources for the calculation of the reduced state space are given in column three and four of Table 1.
For the reduced state space generation we use Symmetric Nets (SNs) 1 [9,10] as underlying structure for the high-level Petri game. SNs are a subclass of high-level Petri nets with the same expressive power but allow for an easy and automatic creation of the system's symmetries from the modeled structure. In SNs the colors are grouped into basic color classes and static subclasses. The arc expressions, as well as the predicates, are restricted to some basic functions. This makes the modeling of practical examples only slightly more cumbersome.
The following three algorithm are all based on the algorithm originally presented in [35]: HL-Approach This approach explicitly calculates the reduced state space from the high-level Petri game H .
LL-Approach This approach first transforms the high-level Petri game H into the corresponding low-level Petri game L(H ) and then uses this to explicitly calculate the reduced state space of G H . During this calculation H is still exploited to obtain the symmetries of the system. BDD-Approach This approach uses, as in the Reference-Approach of Adam, BDDs to symbolically calculate the number of states of the reduced two-player game. For this purpose, the high-level Petri game is also first transformed into the corresponding lowlevel one and then the high-level structure is used for the automatic generation of the system's symmetries.
Note that we neither calculate a winning strategy nor clarify its existence. We take a highlevel Petri game and use three different approaches to calculate the reduced state space, i.e., to calculate the number of states of the high-level two-player game G H while exploiting the symmetries of the high-level Petri game as described in Sect. 4.4. Furthermore, we use the adapted algorithm of Adam to compare these sizes to the size of the previously existing low-level two-player game G L . Since the running time of any synthesis algorithm crucially depends on the size of the state space it has to explore, this gives a first impression of the potential of our new method. We applied the algorithms on a set of five scalable benchmark families from applications in robotic control, workflow management, and other distributed domains. For each benchmark the elapsed CPU time (time in s) for calculating the size of the state space |V L | and the size of the reduced state space |V H | are listed in Table 1 for each approach. A timeout for a calculation time of more than two hours is indicated by TO. For each benchmark the time of the fastest of the new approaches is marked bold. The experiments are calculated on an Intel i7-2700K CPU with 3.50 GHz and 32 GB RAM and refer to the following scenarios: Package delivery (PD) There are n drones which should deliver m packages. The packages get assigned to the drones. The hostile environment lets an arbitrary drone crash. Drones get informed of the crash and can decide on recovering the package. The system's goal is to deliver all packages (see Sect. 2). Parameters: n drones / m packages. Alarm system (AS) There are n geographically distributed locations. Every location is secured by an alarm system. A burglar, modeled by the environment, can intrude an arbitrary location. The alarm systems can inform each other about burglaries. The goal is that no alarm system is triggered without an intrusion and all alarm systems indicate the correct intrusion point in case of an intrusion. Parameters: n alarm systems. Concurrent machines (CM) There are n machines which should process m orders. The orders can be processed concurrently, but no machine is allowed to process more than one order. The hostile environment chooses one machine to be defective. The goal is that finally all orders are processed. Parameters: n machines / m orders. Document workflow (DW) and (DWs) There are n clerks endorsing or rejecting a document.
The document is circularly passed on by the clerks. The environment decides on which clerk receives the document first. The goal is that all clerks take an unanimous decision.
In the simple variant DWs the goal is that all clerks endorse the document. Parameters: n clerks.
The package delivery benchmark family is newly presented in this paper. The alarm system benchmark family was introduced in [21] and its high-level version was presented in [30]. The benchmark families CM, DW, and DWs were introduced in [22], the high-level version for CM was already presented in [30], the high-level version for DW and DWs were developed for this paper. The figures show a significant decrease on the size of the state space of the system. The new benchmark PD with parameters 1/8 shows the maximal reduction: 26,299,378 states for the standard state space versus 11,115 states for the reduced one. This is a factor of about 2366. The reason for a comparably small reduction for the DW and DWs benchmark family is the circularly passing of the document which restricts the admissible symmetries to rotations.
The decrease of the state space does not come without a cost. The calculation time of the new algorithms for the reduced state space (the last three columns) is in general notably higher than the ones of the reference algorithm for the standard state space (column three). On the one hand, this is due to the equivalence check which is done every time prior to the adding of a new state. On the other hand, this figures are not directly comparable. Adam uses optimized symbolic algorithms for its calculations which generally outperform explicit algorithms like the ones of the HL-and the LL-Approach on large state spaces. Furthermore, all new algorithms are currently in an early development state.
The main reason of the low performance of the BDD-Approach on larger models is that the current algorithm checks for each newly created state whether there already exists an equivalent one. It is not possible to directly encode this check into a Boolean function for the representation of the two-player game's transition relation. Thus, in this prototype implementation of a symbolic algorithm exploiting the symmetries of the system, the equivalence check is done explicitly. This means, in every round of the fixed point calculation, each explicit state of the BDD representing the successors of this round is calculated. These costly solving steps of the BDDs thwart the use of a symbolic algorithm.
Generally, the LL-Approach outperforms the HL-Approach. This is explicable by the structure of the decision sets. A decision set of the high-level two-player game consists of the concrete instances of the places and transitions of the high-level net. Hence, the HL-Approach calculates these instances over and over each time a high-level transition is requested. An improvement is to buffer these data, but this nearly results in the LL-Approach.
Overall, these figures already show a big step towards a faster practical solving of Petri games because a smaller state space significantly reduces the running time of the synthesis algorithms. Standard algorithms for solving two-player Büchi games with complete information are polynomial in the number of edges of the game and can be applied to the symbolic two-player game G H . The remaining steps for solving high-level Petri games, i.e., resolving the symmetries of the two-player strategy and creating the Petri game strategy, are linear in the number of edges of the strategy and quadratic in the number of admissible symmetries. Given that the presented algorithms are still in a prototype stadium, these results are very encouraging for further work.

Related work
An active research area is Petri net synthesis [2]. Two-player games are studied under the name Petri net supervisory control [2], inspired by the work of Ramadge and Wonham on discrete event systems [45]. A significant body of work on synthesis and control based on Petri nets is in this area (cf. [6,31,46,55]), also for structured Petri nets like modules of signal nets [15]. However, these approaches solve the single-process synthesis problem, as opposed to the multi-process synthesis problem for concurrent systems considered in this paper.
The synthesis of distributed systems (short: distributed synthesis) is much more difficult because one must construct multiple processes that, individually, do not have access to the full system state. Most prominent is the model of Pnueli and Rosner [44], where processes com-municating via single-writer single-reader shared variables with synchronous concurrency are considered. After a series of isolated decidability results [37,44], information forks [26] were identified as the necessary and sufficient criterion for undecidability. For architectures without information forks, the synthesis problem can be solved, however, with nonelementary complexity in the number of processes.
Zielonka's asynchronous automata [56] have been proposed as an alternative setting for distributed synthesis [27,28,39,42]. The decidability of the control problem of asynchronous automata is open in general. There are various decidability results for restricted cases, e.g., concerning the dependencies of actions [27] or the synchronization behavior [39]. Decidability, albeit again with nonelementary complexity, has also been obtained for acyclic communication structures [28,42].
Petri games based on P/T Petri nets were introduced in [24,25]. They exploit concurrency and causality in defining a notion of informedness for the players. In [25] it is shown that the problem whether the system players have a winning strategy for a safety objective, is undecidable for unbounded Petri games. However, for Petri games with one environment player and a bounded number of system players the problem is EXPTIME-complete. The winning strategy can be obtained in single-exponential time by a reduction to a two-player graph game. In [23] it was shown that also for one system player and a bounded number of environment players the synthesis problem can be solved with the same complexity. In [20] a bounded synthesis approach was introduced. It sets a bound for the size of the strategy and constitutes a semi-decision procedure, optimized in finding small implementations. A formal connection between games on asynchronous automata and Petri games is established in [5].
For practical applications, higher-level Petri nets in the form of Coloured Petri Nets (CPN) have been introduced [29,36,47]. In CPNs, individual data values are represented by coloured tokens to describe concurrent systems succinctly. Boolean conditions on these tokens appear as guards of transitions, and expressions define which of these tokens are moved when a transition fires. In general, multisets of coloured tokens may appear as markings. In [36], a translation from CPNs back into normal P/T Petri nets is defined.
There is a significant body of work regarding symmetries. For high-level Petri nets the notion of equivalent markings and the idea of exploiting symmetries was originally introduced in [34,35]. For obtaining the symmetries of the system efficiently, several approaches on different subclasses of high-level Petri nets had been introduced, e.g., in [9,10,16,38,48]. In [8] the idea of using equivalent transitions in addition to the equivalent marking for the creation of the SRG is lifted to CPNs. For low-level Petri nets the reduction ideas are introduced in [51]. From then on lots of work has been done following that direction, e.g., [49,50,54]. Using symmetries for the alleviation of state-explosion problems are also common in model checking [12][13][14]. The complications that arise when using BDDs for the symmetric state space evaluation in this context is elaborated in [14].

Conclusion
We introduced a new, symmetry-exploiting solving algorithm for the subclass of set-based high-level Petri games with a single recurrently interfering source of external information. The main part of the algorithm is a reduction of the high-level Petri game to a two-player game which states consist of enriched equivalence classes of the Petri game's behavior. The key idea of the reduction is borrowed from the reduction of a low-level Petri games with a single external source of information to a two-player game presented in [24]. We proved the correctness of the new reduction by defining a bisimulation between the new game and the game obtained by converting the high-level Petri game to a low-level one and applying the reduction of [24].
Our experimental results show that the new two-player game is significantly smaller than the old one. Utilizing the symmetries of the system enabled us to reduce the state space needed for resolving the synthesis problem in the presented benchmark families by up to three orders of magnitude.
For future work we want to enhance the presented reduction technique to allow for an improved implementation of the solving algorithm. Adam testifies the well-suited applicability of a symbolic game solving algorithm using BDDs for the synthesis of Petri games. As stated in Sect. 5, a drawback of the current approach is that BDDs cannot directly be used profitably for the calculation of the reduced two-player game. In [10] an algorithm for calculating canonical representatives of the equivalences classes of the reachability graph of a Petri net is presented. A corresponding algorithm for calculating canonical representatives of the equivalence classes of the decision sets could allow for a profitable use of BDDs.
Another step is to investigate several improvements regarding symmetries in high-level Petri nets existing in the literature. For example, the papers [1,3,4,7,32] introduce efficiency improvements for systems with a mixture of symmetric and asymmetric behaviors, or, in [53] the symmetries of entirely symmetric models are deduced from the system itself, i.e., the color classes of a SN can be partitioned automatically. It could be interesting to investigate to what extent the synthesis of high-level Petri games could profit from these results.
In this section of the appendix we formally introduce unfoldings, strategies, and plays. Again, we focus only on 1-bounded Petri nets where the preset and the postset of any transition as well as the markings are sets rather than multisets.
Let N = (P, T , F , In) be a Petri net. For two nodes x, y ∈ P ∪ T we call x a causal predecessor of y, written x < y, iff x F + y holds. We write x ≤ y iff x < y or x = y.
We call x, y causally related iff x ≤ y or y ≤ x holds. Two nodes x, y ∈ P ∪ T are in conflict, written x y, iff there is a place p ∈ P\{x, y} and two transitions t 1 , t 2 ∈ post( p) with t 1 = t 2 , such that t 1 ≤ x and t 2 ≤ y holds. Two nodes x, y ∈ P ∪ T are concurrent iff they are neither in conflict nor causally related. A set of places X ⊆ P is called concurrent iff all places are pairwise concurrent.
We introduce occurence nets to represent the occurrences of transitions with their conflicts and causal dependencies. An occurrence net is a Petri net N = (P, T , F , In) with the following constraints: (i) ∀ p ∈ P : |pre( p)| ≤ 1, (ii) ∀t ∈ T : ¬(t t), (iii) ∀x ∈ P ∪ T : ¬(x < x), (iv) ∀x ∈ P ∪ T : |{y ∈ P ∪ T | y < x}| < ∞, and (v) In = {p ∈ P | pre( p) = ∅}. This means that each place only has one ingoing transition, no transition is in self-conflict, the flow relation is acyclic, the relation < is wellfounded, i.e., does not contain any infinitely decreasing sequence, and the initial marking contains exactly the places which do not have a predecessor. We call an occurrence net a causal net, when further (vi) ∀ p ∈ P : |post( p)| ≤ 1 holds. In general we equip the function pre and post with a superscript, e.g., pre N , if we want to stress the dependency on a Petri net N . Let N 1 = (P 1 , T 1 , F 1 , In 1 ) and N 2 = (P 2 , T 2 , F 2 , In 2 ) be two Petri nets. We call N 1 a subnet of N 2 iff P 1 ⊆ P 2 , T 1 ⊆ T 2 , F 1 ⊆ F 2 , and In 1 = In 2 holds. A homomorphism from N 1 to N 2 is a mapping h : P 1 ∪ T 1 → P 2 ∪ T 2 which preserve the types of the nodes and the pre-and postconditions of the transitions, i.e., (i) h(P 1 ) ⊆ P 2 and h(T 1 ) , where the application of the homomorphism to a set X ⊆ P 1 ∪ T 1 is defined component-wise: A homomorphism h is called initial iff also (iii) h(In 1 ) = In 2 . If not differently stated, the elements of a superscripted Petri net N X are also implicitly superscripted, i.e., N X = (P X , T X , F X , In X ), and we abbreviate the pre-and postset functions by pre X and post X , respectively. A branching process β = (N U , λ U ) of a Petri net N consists of on occurrence net N U and a homomorphism λ U : ) ⇒ t 1 = t 2 holds. This means λ U is injective on transitions with the same preset. If λ U is initial, the branching process β is called initial. A branching process β R = (N R , ρ) of N with a causal net N R is called (concurrent) run of N . If furthermore ρ is an initial homomorphism, β R is called an initial (concurrent) run. A run formalizes a single concurrent execution of the net. A branching process β 1 = (N 1 , λ 1 ) is called a subprocess of a branching process β 2 = (N 2 , λ 2 ) iff N 1 is a subnet of N 2 and λ 1 = λ 2 | P 1 ∪T 1 , where h | X restricts the domain of the function h to the set X .
An unfolding of a net N is an initial branching process β = (N U , λ U ) of N satisfying This means that whenever a transition of the net can occur in the unfolding there is indeed a transition with the same label occurring in the unfolding. Note that an unfolding is unique up to isomorphism.
A strategy for the system players of a Petri game G = (P S , P E , T , F , In, B) with an underlying Petri net N is a subprocess σ = (N σ , λ σ ) of the unfolding β = (N U , λ U ) of N satisfying the properties: justified refusal, deterministic, and deadlock-avoiding as defined below. We lift the distinction of environment, system, and bad places of G to the strategy by P σ S = {p ∈ P σ | λ σ ( p) ∈ P S }, P σ E = {p ∈ P σ | λ σ ( p) ∈ P E }, and B σ = {p ∈ P σ | λ σ ( p) ∈ B} and analogously define those sets for unfoldings and runs. The conditions of a strategy are defined by i.e., if an instance t of a transition is forbidden by σ , then the reason is that from a place p in the precondition of t, σ uniformly forbids all instances t of this transition. This condition also ensures that a strategy does not restrict any pure environment transition. Deterministic ∀ p ∈ P σ S , M ∈ R(N σ ) : p ∈ M ⇒ ∃ ≤1 t ∈ post σ ( p) : pre σ (t) ⊆ M, i.e., there is no situation in the strategy, where a system player allows two separate, enabled transitions. Deadlock avoiding ∀ M ∈ R(N σ ) : (∃ t ∈ T U : pre U (t) ⊆ M) ⇒ ∃ t ∈ T σ : pre σ (t) ⊆ M, i.e., whenever the system can proceed in G there must also be a continuation in the corresponding situation in the strategy.
A play π of the Petri game G is an initial concurrent run π = (N R , ρ) of the underlying Petri net N . Up to isomorphism π is a subprocess of the unfolding. The system players win a play π = (N R , ρ) iff B R = ∅. Otherwise, the environment players win. A play π conforms to a strategy σ iff π is a subprocess of σ . A strategy σ is winning for the system players iff all plays conforming to σ are won by the system.

B Equivalence via symmetries
In this section of the appendix, the most important results from [8] are recalled to be available for some of the proofs of this paper.  Finally, we elaborate on the assumption that w.l.o.g. high-level Petri nets have a symmetric initial marking. If the initial marking in a high-level Petri net is not symmetric, we can add an initialization transition and a new initial place as follows.

Construction 1
Let P H 0 = {p ∈ P H | ∃c ∈ t y( p) : p.c ∈ In H }. For all p ∈ P H 0 we define n p = |{c ∈ t y( p) | p.c ∈ In H }| as the number of color tokens initially residing on p. We name the colors in the initial marking by In H = {p.c p 1 , . . . , p.c p n p | p ∈ P H 0 }. We add a new place p 0 with t y( p 0 ) = {c 0 }, a fresh singleton color set with a fresh color c 0 , and a new transition t 0 such that ( p 0 , t) ∈ F H ⇔ t = t 0 , and (t 0 , p) ∈ F H ⇔ p ∈ P H 0 , and ∀t = t 0 , p = p 0 : ( p, t 0 ), ( p 0 , t) / ∈ F H . Let further e( p 0 , t 0 ) = c 0 and ∀ p ∈ P Thus, the admissible symmetries S remain unchanged (except for the addition of id {c 0 } to every symmetry). The new initial marking is { p 0 .c 0 } and therefore trivially symmetric.

C Proofs for the construction of the reduced two-player game
In this section of the appendix, we provide proofs for lemmas of Sect is also true because all s ∈ S are bijective. We list, for each individual property, the needed results: D is environment-dependent: Lemma 1. D contains a bad place: (1) and (2). D is a deadlock: Lemmas 1,8 and (2). D is terminating: Lemma 8 and (2). D is nondeterministic: (2), (1), Lemmas 1, and 8.

Proof (Lemma 3)
1. If D contains a bad place, is a deadlock, is terminating, or nondeterministic, so is D by Corollary 1, and there is also only a -labeled self-loop originating from D as well as from D. Now consider the cases in which D has none of these properties.