{'fraction_non_alphanumeric': 0.04797899930419381, 'fraction_numerical': 0.007274337402745272, 'mean_word_length': 3.8288026878436163, 'pattern_counts': {'":': 0, '<': 1, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 2, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 27, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Reasoning about Games via a First-order Modal Model Checking Approach

In this work, we present a logic based on first-order CTL, namely Game Analysis Logic (GAL), in order to reason about games. We relate models and solution concepts of Game Theory as models and formulas of GAL, respectively. Precisely, we express extensive games with perfect in- formation as models of GAL, and Nash equilibrium and subgame perfect equilibrium by means of formulas of GAL. From a practical point of view, we provide a GAL model checker in order to analyze games automatically. We use our model checker in at least two directions: to find solution con- cepts of Game Theory; and, to analyze players that are based on standard algorithms of the AI community, such as the minimax procedure.


Introduction
Games are abstract models of decision-making in which decision-makers (players) interact in a shared environment to accomplish their goals. Several models have been proposed to analyze a wide variety of applications in many disciplines such as mathematics, computer science and even political and social sciences among others.
Game Theory [17] has its roots in the work of von Neumann and Morgenstern [16] and uses mathematics in order to model and analyze games in which the decision-makers pursue rational behavior in the sense that they choose their actions after some process of optimization and take into account their knowledge or expectations of the other players' behavior. Game Theory provides general game definitions as well as reasonable solution concepts for many kinds of situations in games. Typical examples of this kind of research come from phenomena emerging from Markets, Auctions and Elections.
Although historically Game Theory has been considered more suitable to perform quantitative analysis than qualitative ones, there has been a lot of approaches that emphasizes Game Analysis on a qualitative basis, by using an adequate logic in order to express games as well as their solution concepts.
Some of the most representatives of these logics are: Coalitional Logic [20]; Alternating-time Temporal Logic (ATL) [2] and its variation Counter-factual ATL (CATL) [25]; Game Logic [21]; Game Logic with Preferences [26]; Coalitional Game Logic (CGL) [1] that reasons about coalitional games. To see more details about the connections and open problems between logic and games, we point out [24].
The technique of Model Checking [8] is frequently employed in computer science to accomplish formal validation of both software and hardware [6]. Model Checking consists of achieving automatic verification and other forms of formal analysis of a system behavior. A lot of implementations are available in the literature, such as Symbolic Model Verifier (SMV) [15], SPIN [11] and MOCHA [3]. Some other implementations also include specific features in the modeling, UPPAAL [5] works in real-time, HYTECH [10] with hybrid automata and PRISM [19] with stochastic automata. Recently, model checking has also been used to verify proprieties in games [27,4,26,12].
There is a wide range of problems approachable by means of Game Theory. Besides problems and models coming from economics, which usually have quantitative features, as those normally present in econometric models, there is also a range of problems that are strongly related to Multi-Agent systems modeling and that can be consequently also validated by means of well-known CAV tools. However, the presence of intrinsic and quantitative measures in this kind of modeling prevent us from an standard use of the most popular (and efficient) CAV tools, such as Model Checkers (MCs) based on the propositional logic language. One could argue that MCs, like the SPIN MC, that have a richer operational semantics, such as its ability to assign computable meaning to transitions by means of fragments of a Programming Language like coding assertion, might be the right answer to the specification of such kind of modeling. However, the SPIN logic language is not a First-Order logic language, and hence, cannot make assertions on the internal structure of an state, mainly regarding the relationship between the values assigned to the individuals in these states (worlds), properties regarding the very individuals and so generalizations and existential assertions on a state and its individuals cannot be, in general, expressible. Most of the solution concepts used in Game Theory are expressed as general assertions on the relationship between individuals of a possible stateof-affairs in the game. The SPIN logic language is unable, in general, to express such kind of concept either. Concerning the usefulness of an approach based on a logic language more expressible than the presently used in CAV tools, it is worth mentioning new directions in the MC community towards the use of First-Order Logic (see [18,9]). Thus, this article contributes for this kind of research in the Formal Methods community, by providing a First-Order based approach to the problem of validating models able to be expressed by Game Theoretical means. The present approach is not so restricted, since the authors have already presented a result showing how Multi-Agent systems can be viewed and strongly considered as a Game, such that, main solution concepts on the Game side represent important concepts on the Systems side ([30]).
The aim of this article is to present GAL (Game Analysis Logic), a logic based on first-order CTL, in order to reason about games in which a model of GAL is a game, and a formula of GAL is an analysis. We illustrate our approach by showing that GAL is suitable to express models of Game Theory as well as their solution concepts. Precisely, we specify extensive game with perfect information by means of models of GAL. We also express their main solution concepts -namely Nash equilibrium and subgame perfect equilibriumby means of formulas of GAL. In [28], we express the standard noncooperative models (strategic games and the solution concept of Nash equilibrium) and cooperative models (coalition game and the solution concept of Core). In this article, we focus on the extensive games and the solution concepts of Nash equilibrium and subgame perfect equilibrium. As GAL has a first-order apparatus, we are able to define many concepts, such as utility, in an easier way, when compared to the logics mentioned above. Moreover, a first-order apparatus is essential to model and reason about social problems that have been modeled by Game Theory, Econometric Models, etc, as already said. It is worth mentioning that the ATL logic, in which the operators of CTL are parameterized by sets of players, can be seen as a fragment of GAL, using the first-order feature of GAL; thus, there is no need for such a parameterization in GAL. In addition, the CGL logic, which is designed to reason about cooperative models, can also be embed in GAL. See [28] for the proofs that ATL and CGL can be seen as fragments of GAL. We do not focus on such proofs here.
We also provide a model checking algorithm for GAL in order to demonstrate that GAL can be used in practice to analyze games automatically. We have a prototype of a model checker for GAL that has been developed according to the main intentions of the approach advocated here. The model checker is available for download at www.tecmf.inf.puc-rio.br/DaviRomero. All of the examples in this article are implemented in the tool. We will show that, using our prototype, we are able to find solution concepts of Game Theory and to analyze players that are based on standard algorithms [23] of the AI community.
This work is divided into six parts: Section 2 introduces Game Analysis Logic; A model checking algorithm for GAL is presented in Section 3. Standard concepts of Game Theory are expressed in GAL in Section 4. Section 5 presents some experimental results using our algorithm. Finally, Section 6 concludes this work.

Game Analysis Logic (GAL)
GAL is a many-sorted modal first-order logic language that is a logic based on the standard Computation Tree Logic (CTL) [7]. A game is a model of GAL, called game analysis logic structure, and an analysis is a formula of GAL.
The games that we model are represented by a set of states SE and a set of actions CA.
A state is defined by both a first-order interpretation and a set of players, where: 1-The first-order interpretation is used to represent the choices and the consequences of the players' decisions. For example, we can use a list to represent the history of the players' choices until certain state; 2-The set of players represents the players that have to decide simultaneously at a state. This set must be a subset of the players' set of the game. The other players cannot make a choice at this state. For instance, we can model games such as auction games, where all players are in all states, or even games as Chess or turn-based synchronous game structure, where only a single player has to make a choice at each state. Notice that we may even have some states where none of the players can make a decision that can be seen as states of the nature.
An action is a relation between two states e 1 and e 2 , where all players in the state e 1 have committed themselves to move to the state e 2 . Note that this is an extensional view of how the players committed themselves to take a joint action.
We refer to (A k ) k∈K as a sequence of A k 's with the index k ∈ K. Sometimes we will use more than one index as in the example (A k,l ) k,l∈K×L . We can also use (A k , B l ) k∈K,l∈L to denote the sequence of (A k ) k∈K followed by the sequence (B l ) l∈L . Throughout of this article, when the sets of indexes are clear in the context, we will omit them.
A path π(e) is a sequence of states (finite or infinite) that could be reached through the set of actions from a given state e that has the following properties: 1-The first element of the sequence is e; 2-If the sequence is infinite π(e) = (e k ) k∈N , then ∀k ≥ 0 we have e k , e k+1 ∈ CA; 3-If the sequence is finite π(e) = (e 0 , . . . , e l ), then ∀k such that 0 ≤ k < l we have e k , e k+1 ∈ CA and there is no e such that e l , e ∈ CA. The game behavior is characterized by its paths that can be finite or infinite. Finite paths end in a state where the game is over, while infinite ones represent a game that will never end.
Below we present the formal syntax and semantics of GAL. As usual, we call the sets of sorts S, predicate symbols P , function symbols F and players N as a non-logic language in contrast to the logic language that contains the quantifiers and the connectives. We define a term of a sort in a standard way. We denote a term t of sort s as t s . The modalities can be read as follows.
• [EX]α -'exists a path α in the next state' • [AX]α -'for all paths α in the next state' Definition 1 (Syntax of GAL). Let S, F, P, N be a non-logic language, and t 1 s1 , ..., t n sn be terms, and t s1 be a term, and p : s 1 ...s n be a predicate symbol, and i be a player, and x s be a variable of sort s. The logic language of GAL is generated by the following BNF definition: and ∀x can be given by the following usual abbreviations.
Definition 2 (Structure of GAL). Let S, F, P, N be a non-logic language of GAL. A Game Analysis Logic Structure for this non-logic language is a tuple G = SE, SE o , CA, (D s ), (F f,e ), (P p,e ), (N e ) such that: • SE is a non-empty set, called the set of states.
• SE o is a set of initial states, where SE o ⊆ SE.
• For each state e ∈ SE, N e is a subset of N .
• CA ⊆ SE × SE, called the set of actions of the game 1 , in which if there is at least one player in the state e 1 , then exists a state e 2 such that e 1 , e 2 ∈ CA.
• For each sort s ∈ S, D s is a non-empty set, called the domain of sort s 2 .
• For each function symbol f : 1 This relation is not required to be total as in the CTL case. The idea is because we have finite games. 2 In algebraic terminology Ds is a carrier for the sort s.
• For each predicate symbol p : s 1 × . . . × s n of P and state e ∈ SE, P p,e is a relation such that P p,e ⊆ D s1 × . . . × D sn .
A function or predicate is rigidly interpreted if its interpretation is the same for every state. A GAL-structure is finite if the set of states SE and each set of domains D s are finite. Otherwise, it is infinite. Note that even when a GAL-structure is finite we might have infinite paths.
In order to provide the semantics of GAL, we define a valuation function as a mapping σ s that assigns to each free variable x s of sort s some member σ s (x s ) of domain D s . As we use terms, we extend every function σ s to a functionσ s from state and term to element of sort s that is done in a standard way. When the valuation functions are not necessary, we will omit them.
(N e ) be a GAL-structure, and (σ s ) be valuation functions, and α be a GALformula, where s ∈ S, f ∈ F, p ∈ P and e ∈ SE. We write G, (σ s ) |= e α to indicate that the state e satisfies the formula α in the structure G with valuation functions (σ s ). The formal definition of satisfaction |= proceeds as follows: Figure 1.a).
is the function which is exactly like σ s k except for one thing: At the variable x s k it assumes the value d. This can be expressed by the equation:

Satisfatibility and Model Checking for GAL
It is well-known that there is no sound and complete system for a first-order CTL [22]. Thus, GAL is also non-axiomatizable. However, we argue that, using model checking for GAL, we can reason about games as well. Besides that we can also define a non-complete axiomatization of GAL in order to cope with proofs of interesting results, such as the existence of mixed Nash equilibrium in strategic games, but we do not focus on this in this article. In the sequel we state the model checking problem for GAL and also discuss briefly a model checking algorithm for GAL.
, (P p,e ), (N e ) be a GAL-structure with the non-logic language S, F, P, N , and (σ s ) be valuation functions and α be a GAL-formula. The GAL model checking problem is to find the set of states that satisfies the formula α.
In order to have a model checking algorithm for GAL, we assume that all of the games are finite; however, we might still have infinite behavior.
The algorithm for solving the GAL model checking problem uses an explicit representation of the GAL-structure as a labelled, directed graph. The nodes represent the states SE, the arcs in the graph provide the set of actions CA and the labels associated with the nodes describe both the players' set N e and the first-order interpretation (the interpreted functions' set (F f,e ) and the interpreted predicates' set (P p,e )). The algorithm also uses the functions D : S → D s , N : SE → N e , F : F × SE → F f,e and P : P × SE → P p,e in order to provide an implicit representation of the domains' set (D s ), the players' set N e , the functions (F f,e ) and the relations (P p,e ), respectively. Thus, we only evaluate them on demand.
The algorithm is similar to the CTL model checking algorithm [8] that operates by labelling each state e ∈ SE with the set of labels(e) of sub-formulas of α which are true in e. The algorithm starts with the set labels(e) as the empty set 3 and then goes by a series of steps (the number of operators in α). At each step k, sub-formulas with k − 1 nested GAL operators are processed. When a formula is processed, it is added to the labelling of the state in which it is true. Thus, G, (σ s ) |= e α ⇐⇒ α ∈ labels(e).
As GAL-formulas are represented in terms of i, p(t 1 s1 , ..., t n sn ), (t 1 s1 ≈t s1 ), (¬α), (α → β), ∃x s k α, [AX]α, E(αUβ), A(αUβ), it is sufficient to handle these cases. The cases (¬α), (α → β), [AX]α, E(αUβ) and A(αUβ) are similar to the CTL model checking algorithm and we do not present here (see [15] for more details). Below we present and give the time complexity of the other procedures. In order to guarantee termination of the algorithm, the functions (F f,e ) and the relations (P p,e ) must terminate since the model is finite this is accomplished. We use the notationσ s1 (e, t 1 s1 ) as the function that interprets the term t 1 s1 at the state e. We take its complexity as an upper bound on the implementation ofσ s1 taking all states into account. We refer to this upper bound as |σ s1 (e, t 1 s1 )|.
• Case i: The procedure verifyPlayer (see Algorithm 1) labels all states e ∈ SE with the player i if the player i belongs to the set of players in e. This procedure requires time O(|SE|).
• The procedure verifyExists (see Algorithm 4) labels all states e ∈ SE in which the formula α with all occurrences of the variable x s k substituted by at least one element of the domain is true. We use the notation α[x s k ← d] as a function that substitutes all occurrence of x s k by d in α. This procedure requires O(|D s k | × |SE|).
Thus, the complexity of the algorithm regards to: 1-The size of the domains' set; 2-The size of the states' set; 3-The size of the actions' set; 4-The complexity of both functions and predicates in each state.  Below we consider a simpler version of GAL, for the sake of a simpler presentation of the algorithm's complexity. The non-logical language has only one sort D and one unary predicate p : D. Let G S be a GAL-structure, where: 1-The predicate p is interpreted as constant for all states and its time complexity is represented by O(p); 2-The size of sort D's domain is |D|; 3-The size of the states' set is |SE|; 4-The size of the actions' set is |CA|. Let α be a GAL-formula for this language, where α M and α D are the number of modal connectives and the number of quantifier connectives, respectively, in the formula α. The time complexity to verify α for G S is We have a prototype, namely Game Analysis Logic Verifier (GALV), that was written as framework in Java. GALV is available for download at http://www.tecmf.inf.pucrio.br/DaviRomero. All of the examples that we will show in this article are implemented in our prototype. The main advantages of this model checker are: 1-It allows the use of abstract data types, for example, a list can be used to represent the history of the game; 2-It might use a large sort of libraries that are available in Java; 3-Functions and predicates might be used to analyze games, such as the evaluation functions that are used in the AI community to provide an estimate of the expected utility of the game from a given position; 4-GALV allows computational aspects to define the players' actions, for example, a minimax algorithm can be used to define the actions of a certain player, while the other players might use different algorithms. So, the time complexity to generate a game might not be polynomial, i.e., it depends on the algorithms that have been used to define the players' actions.

Game Theory in Game Analysis Logic
We can model both the standard models and the standard solution concepts of Game Theory using GAL. In this section we show that the standard models are related to as GAL-structures and the standard solution concepts are related to as GAL-formulas. Precisely, we present the correspondence between the extensive games and the GAL-structures as well as the solution concepts of Nash equilibrium (NE) and subgame perfect equilibrium (SPE) and the formulas of GAL. For more details about the rationale of the definitions related to Game Theory see [17]. In the sequel, we write down the definitions and theorems used in this article.
An extensive game is a model in which each player can consider his or her plan of action at every time of the game at which he or she has to make a choice. There are two kinds of models: game with perfect information; and games with imperfect information. For the sake of simplicity we restrict the games to models of perfect information. A general model that allows imperfect information is straightforward. Below we present the formal definition and the example depicted in Figure 2.a. • H is a set of sequences of actions (finite or infinite), called the set of histories, that satisfies the following properties the empty sequence is a history, i.e. ∅ ∈ H.
if (a k ) k∈K ∈ H where K ⊆ N and for all l ≤ |K|, then (a k ) k=0,...,l ∈ H.
A history h is terminal if it is infinite or it has no action a such that (h, a) ∈ H. We refer to T as the set of terminals.
• P is a function that assigns to each non-terminal history a player.
A strategy of player i is a function that assigns an action for each nonterminal history for each P (h) = i. For the purpose of this article, we represent a strategy as a tuple. In order to avoid confusing when we refer to the strategies or the histories, we use ' ' and ' ' to the strategies and '(' and ')' to the histories. In Example 1, player 1 has to make a decision only after the initial state and he or she has two strategies A and B . Player 2 has to make a decision after the history (A) and he or she has two strategies L and R . We denote S i as the set of player i's strategies. We denote s = (s i ) as a strategy profile. We refer to O(s 1 , . . . , s n ) as an outcome that is the terminal history when each player follows his or her strategy s i . In Example 1, B , L is a strategy profile in which the player 1 chooses B after the initial state and the player 2 chooses The most used solution concepts for extensive games are Nash equilibrium (NE) and subgame perfect equilibrium (SPE). The solution concept of NE requires that each player's strategy be optimal, given the other players' strategies. And, the solution concept of SPE requires that the action prescribed by each player's strategy be optimal, given the other players' strategies, after every history. In SPE concept, the structure of the extensive game is taken into account explicitly, while, in the solution concept of NE, the structure is taken into account only implicity in the definition of the strategies. Below we present the SPE definition in a standard way. The NE definition below regards to the structure of an extensive game, yet is an equivalent one to the standard.

Definition 5.
A subgame perfect equilibrium (SPE) of an extensive game Γ = N, H, P, (u i ) is a strategy profile s * = s * 1 , . . . , s * n such that for every player i ∈ N and every history h ∈ H for which P (h) = i we have for every strategy s i ∈ S i . Definition 6. A Nash equilibrium (NE) of an extensive game Γ = N, H, P, (u i ) is a strategy profile s * = s * 1 , . . . , s * n such that for every player i ∈ N and every history on the path of the strategy profile s * (i.e. h ∈ O(s * )) for which P (h) = i we have . . , s i , . . . , s * n )), for every strategy s i ∈ S i .
We invite the reader to verify that the strategy profiles A , R and B , L are the Nash equilibria in Example 1. Game theorists can argue that the solution B , L is not reasonable when the players regard to the sequence of the actions. To see that the reader must observe that after the history (A) there is no way for player 2 commit himself or herself to choose L instead of R since he or she will be better off choosing R (his or her utility is 1 instead of 0). Thus, player 2 has an incentive to deviate from the equilibrium, so this solution is not a subgame perfect equilibrium. On the other hand, we invite the reader to verify that the solution A , R is the only subgame perfect equilibrium.
Consider formulas 1 and 2 as expressing subgame perfect equilibrium definition 5 and Nash equilibrium definition 6, respectively. A strategy profile s * = s * 1 , . . . , s * n is a SPE (or NE) if and only if formula 1 (or formula 2) holds at the initial state ∅, where each σ Si (v * si ) = s * i . [AG] [EG] In order to guarantee the correctness of the representation of both subgame perfect equilibrium and Nash equilibrium, we state the theorem below. The proof is provided in Appendix A.
Theorem 1. Let Γ be an extensive game, and G Γ be a GAL-structure for Γ, and α be a subgame perfect equilibrium formula for G as defined in Equation 1, and β be a Nash equilibrium formula as defined in Equation 2, and (s * i ) be a strategy profile, and (σ Si ) be valuations functions for sorts (S i ).

Experimental Results
In this section we show the performance of the GAL model checking algorithm against other algorithms. The algorithm was written in Java and the experiments were executed on a 2.4GHz Celeron with 512 MBytes of RAM, running Windows XP Home Edition.
Several algorithms for the problem of finding a Nash equilibrium are proposed in the literature (see [14] for a survey). Most of them compute a mixed Nash equilibrium. Gambit [13] is the best-known Game Theory software that implements most of all algorithms. We use both Gambit (with its EnumPure-Solve method) and our algorithm in order to compute the pure Nash Equilibria. Figure 3 shows the running times (in seconds) of several two-player games in which the payoffs of the games were randomly generated (Figure 3.a) or were taken as the constant value 0 (Figure 3.b). The difference between the games in Figure 3.a and Figure 3.b relies on the size of the set of equilibria. Our algorithm took almost the same time to find the solution concept regardless of the size of equilibria. On the other hand, Gambit's performance was much more dependent on the size of equilibria as shown in Figure 3. In [27,29] is proposed a metalanguage to describe games, namely RollGame, as well as a translation into the input language of the well-known SMV model checker [15], in order to reason about games. In this section, we take Tic-Tac-Toe game in order to provide an example that an explicit representation of such a game can be more efficient than using an OBDD approach as in SMV. It is worth mentioning that SMV uses a propositional logic (CTL), so it cannot express many solution concepts as defined in Section 4. Moreover, it does not allow the use of abstract data types, yet the usage of integer is prohibited in many situations, such as when one wants to use utilities values.
In [27,29], a version of a Tic-Tac-Toe game is modeled and analyzed. In this version, one of the players (PlayerX) uses a certain strategy, while the other player (PlayerO) spreads all possible actions. It is also shown that the strategy of PlayerX never reaches a losing position in the game. This property is expressed by the CTL formula defined in Equation 3 below, which states that PlayerX will always win or draw. We also model this game with the same strategy using our algorithm, and the performance of verifying this formula is much better in our algorithm (0.001 seconds) than using the SMV model checker (45.211 seconds). However, we should also take into account the time to generate this game in order to compare our algorithm with SMV. The required time was 0.289 seconds; so our algorithm took 0.290 seconds to generate and analyze this version of Tic-Tac-Toe game 6 .
[AF ](winX ∨ Draw) As we have claimed at the end of Section 3, one of the main advantages of the GALV model checker is that it allows computational aspects in the modeling language. Thus, we are able to use standard algorithms of the AI community to model and analyze a game. We take Tic-Tac-Toe as an example again, and we define one of the players (PlayerX), using a minimax algorithm with maximal depth (9), while the other player (PlayerO) spreads all the possible actions. The required time for generate the game was 14.718 seconds and to analyze the GAL formula defined in Equation 3 was 0.001 seconds. Note that this approach is not possible using a standard model checker, such as SMV or SPIN.

Conclusion and Future Works
In this work, we have presented a first-order modal logic (GAL) to model and analyze games. We have also provided a model checking algorithm for GAL to achieve automatic verification for finite games. We have illustrated in Section 4 that standard concepts of Game Theory can be modeled in GAL. Using our prototype of a GAL model checker, we have performed case studies in at least two directions: as a tool to find solution concepts of Game Theory; and as a tool to analyze games that are based on standard algorithms of the AI community, such as minimax algorithm. Despite the fact that our algorithm uses an explicit representation, it outperforms the SMV model-checker as shown in Section 5. This might suggest that an explicit representation is better for games than using a symbolic representation as OBDD. However, a general conclusion cannot be drawn. Some future works are still needed and are listed below • Define an adequate and sound system of GAL that is able to prove formal theorems of Game Theory, such as the existence of mixed Nash equilibrium in strategic games.
• Implement a player of a game using formulas of GAL, such as the subgame perfect equilibrium formula as shown in Section 4. This approach might use evaluation functions and be limited to a certain depth as in a minimax procedure. As this is an heuristic approach, we argue that define other solution concepts in a logic framework is easier than to implement new algorithms. For instance, we can define the strategy of a player according to a conjunction of the subgame perfect formula and a Pareto Optimal formula.
• Improve the performance of the GAL model checker, since it uses an explicit representation. We cannot use an OBDD-approach since in GAL we are dealing with a first-order interpretation that may vary over the states of the game. A Proof of Theorem 1 Theorem 2. Let Γ be an extensive game, and G Γ be a GAL-structure for Γ, and α be a subgame perfect equilibrium formula for G as defined in Equation 1, and β be a Nash equilibrium formula as defined in Equation 2, and (s * i ) be a strategy profile, and (σ Si ) be valuations functions for sorts (S i ).
• A strategy profile (s * i ) is a SPE of Γ ⇐⇒ G Γ , (σ Si ) |= ∅ α, where each σ Si (v * si ) = s * i . A strategy profile (s * i ) is a SPE of Γ. ⇐⇒ for every player i and every history h ∈ H for which P (h) = i we have u i (O h (h, s * 1 , . . . , s * n )) ≥ u i (O h (h, s * 1 , . . . , s i , . . . , s * n )), for every strategy s i ∈ S i . By the definition of G Γ from Γ, we have that every state of G Γ , which represents a history of Γ, is reached by a path from the initial state ∅; moreover, we have that each domain of player i's strategy D Si is interpreted by the set of strategies S i (i.e. D Si = S i ), and the player that has to take a move in a state e k , which represents the history h k , is defined by the function P (i.e. N e k = {P (h k )}), and, finally, the symbol h is interpreted in e k by the history h k (i.e.σ H (e k , h) = h k ). As a consequence of this definition, we have ⇐⇒for all paths π(∅) = e 0 , e 1 , . . . and for all k ≥ 0, for every player i ∈ N such that IF i ∈ N e k THEN we have for all d i ∈ D Si (u i (O h (σ H (e k , h), s * 1 , . . . , s * n ) ≥ u i (O h (σ H (e k , h), s * 1 , . . . , d i , . . . , s * n ))). As function O h and utility functions (u i ) are rigidly interpreted as in the extensive game Γ, we have ⇐⇒ for all paths π(∅) = e 0 , e 1 , . . . and for all k ≥ 0, for every player i ∈ N such that IF G Γ , (σ Si ) |= e k i THEN for all d i ∈ D Si we have G Γ , (σ Si (v Si |d i )) |= e k u i (O h (h, v * S1 , . . . , v * Sn )) ≥ u i (O h (h, v * S1 , . . . , v Si , . . . , v * Sn )) , where σ Si (v * Si ) = s * i . ⇐⇒ for all paths π(∅) = e 0 , e 1 , . . . and for all k ≥ 0 we have G Γ , (σ Si ) |= e k i∈N i → ∀v Si u i (O h (h, v * S1 , . . . , v * Sn )) ≥ u i (O h (h, v * S1 , . . . , v Si , . . . , v * Sn )) , where each σ Si (v * Si ) = s * i .