Managing non-determinism in symbolic robot motion planning and control

Abstract

We study the problem of designing control strategies for non-deterministic transitions systems enforcing the satisfaction of linear temporal logic (LTL) formulas over their set of states. We focus on finite transition systems with inputs, which are often encountered when solving motion planning problems by using discrete quotients induced by a given partition of the state space. Our approach solves the problem conservatively using LTL games, and consists of the following three steps: (1) the original transition system is transformed into a transition system on which an LTL game can be played, (2) a solution of the LTL game on the new transition system is obtained, and (3) an interface between this solution and the initial transition system is constructed. The correctness of the method is ensured by design. The advantages and conservativeness of our approach are discussed and illustrated by simple examples.

Full text

Page 1

Managing non-determinism in symbolic
robot motion planning and control
Marius Kloetzer and Calin Belta
Center for Information and Systems Engineering
Boston University
15 Saint Mary’s Street, Boston, MA 02446
{kmarius,cbelta}@bu.edu
Abstract—We study the problem of designing control strate-
gies for nondeterministic transitions systems enforcing the
satisfaction of Linear Temporal Logic (LTL) formulas over their
set of states. We focus on finite transition systems with inputs,
which are often encountered when solving motion planning
problems by using discrete quotients induced by a given
partition of the state space. Our approach solves the problem
conservatively using LTL games, and consists of the following
three steps: (1) the original transition system is transformed
into a transition system on which an LTL game can be played,
(2) a solution of the LTL game on the new transition system
is obtained, and (3) an interface between this solution and
the initial transition system is constructed. The correctness
of the method is ensured by design. The advantages and
conservativeness of our approach are discussed and illustrated
by simple examples.
I. INTRODUCTION
Motion planning and control of robots with nontrivial
dynamics or kinematics in cluttered environments is usually a
two step process. In the first step, a (cellular) decomposition
of the C-space is constructed, and a “discrete” path is
generated by a search in the quotient graph [1], [2]. In
the second step, a reference trajectory compatible with the
robot dynamics or kinematic is generated, and robot control
laws are designed to follow the trajectory. A very attractive
alternative to this is simultaneous planning and control, in
which the generation of the discrete solution in the partition
quotient is performed at the same time with the assignment
of vector fields in the regions of the partition (robot control
laws), while taking into account the restrictions imposed by
robot under-actuation and speed constraints [3], [4], [5], [6].
In addition, enrichment of the specification language from
the classical planning task “go from A to B while avoiding
obstacles” to temporal logic specifications (e.g., “visit either
A or B”, “reach A and then B infinitely often”) leads to
symbolic approaches to simultaneous planning and control,
where discrete abstractions are used to provide a formal link
between the continuous robot control system and the discrete
representation of the environment, and algorithms resembling
model checking are used to provide a solution to the discrete
problem [7], [8].
All the approaches enumerated above for simultaneous
planning and control face a common problem: the restric-
tions imposed by the robot dynamics or kinematics can,
in general, lead to non-deterministic representations of the
discrete problem. For example, the “prepares” relationship
between a collection of policies in [4] results in non-
determinism of the discrete abstraction. Recent results in
control of affine systems in simplices [9] and of multi-affine
systems in rectangles [10] show that even though controllers
determining the transition of a robot to a specific neighbor
might fail to exist, controllers guaranteeing the transition to
a set of neighbors can be found. In the transition system
corresponding to the discrete part of the problem, this means
non-determinism.
Motivated by the above, in this paper we focus on the
discrete part of simultaneous motion planning and control,
and consider the following problem: given a nondeterministic
transition system with inputs, and a Linear Temporal Logic
(LTL) formula over its set of states, determine a set of
initial states and a control strategy so that the produced
trajectory satisfies the formula. This problem is quite general,
and, to the best of our knowledge, there is no available
computational framework providing a solution. However,
it is related to LTL games [11]. Also, it is possible that
solutions can be found by using results from the control
of discrete event systems from specifications given as ω-
regular expressions (languages) over inputs [12] or by using
tree automata on infinite objects [13].
In this work, we advocate the use of LTL games [11] for
the construction of a (conservative) solution to the problem.
Our fully automatic computational framework consists of
three main steps. First, we convert the original transition
system into a form in which an LTL game can be played.
Second, we find a solution to the LTL game in the form of a
feedback automaton. Third, the solution of the game is used
to generate a control strategy for the initial transition system.
We illustrate our approach for the case of a triangulated
planar environment, where the assignment of affine feedback
controllers in the triangles using the method developed in [9]
leads to nondeterminism.
The remainder of the paper is organized as follows.
Section II provides some definitions necessary throughout
the paper. The problem is formulated in Section III and our
solution is presented in Section IV. Simulation results are
given in Section V and we conclude with final remarks in
Section VI.

Page 2

II. PRELIMINARIES
For a finite set A, we use |A|, Aω, and 2Ato denote its
cardinality, the set of all infinite words over A, and its power
set (the set of all its subsets), respectively.
A. Transition Systems and Linear Temporal Logic
Definition 1 (Nondeterministic transition system):
A finite nondeterministic transition system is a tuple
T = (Q,Σ,δ,h,O), where:
• Q is a finite set of states,
• Σ is a finite input alphabet,
• δ : Q × Σ → 2Qis a transition function,
• h : Q → O is the observation map,
• O is the set of observables.
For a given state q ∈ Q, the set of available (feasible)
inputs is denoted by Σq (i.e., Σq is the set of σi ∈ Σ for
which |δ(q,σi)| ≥ 1). An input word σ ∈ Σωis denoted by
σ = σ1σ2σ3... A trajectory or run of T produced by an
input word σ starting from q is an infinite sequence r ∈ Qω,
r = r1r2r3... with the property that r1 = q and ∀i ≥ 1,
ri+1∈ δ(ri,σi). A trajectory r of T produces a word w ∈
Oωdefined as w = w1w2w3..., wi= h(qi), for all i ≥ 1.
A transition system T = (Q,Σ,δ,h,O) for which the
observation map is identity (i.e., the states are of interest
Q = O, and can be observed) is denoted for simplicity by
T = (Q,Σ,δ).
Definition 2: [Syntax of LTL formulas] An LTL formula
over O is recursively defined as follows:
• Every observable o ∈ O is a formula, and
• If φ1 and φ2 are formulas, then ¬φ1, φ1∨ φ2, ?φ1,
φ1Uφ2are also formulas.
The semantics of LTL formulas are given over words of
transition system T.
Definition 3: [Semantics of LTL formulas] The satisfac-
tion of formula φ at position i ∈ N of word w, denoted by
wi? φ, is defined recursively as follows:
• wi? o if o = wi,
• wi? ¬φ if wi? φ,
• wi? φ1∨ φ2if wi? φ1or wi? φ2,
• wi? ?φ if wi+1? φ,
• wi? φ1Uφ2if there exist a j ≥ i such that wj ? φ2
and for all i ≤ k < j we have wk? φ1
A word w satisfies an LTL formula φ, written as w ? φ, if
w1? φ.
The symbols ¬ and ∨ stand for negation and disjunction.
The Boolean constants ? and ⊥ are defined as ? = π ∨¬π
and ⊥ = ¬?. The other Boolean connectors ∧ (conjunction),
⇒ (implication), and ⇔ (equivalence) are defined from ¬
and ∨ in the usual way. The unary temporal operator ?
is called next, and the binary temporal operator U is called
the until operator. Two useful additional temporal operators,
”eventually” and ”always” can be defined as ♦φ = ?Uφ
and ?φ = φU⊥, respectively. Formula ♦φ means that φ
becomes eventually true, whereas ?φ indicates that φ is true
at all positions of a trajectory.
Remark 1: In general, the semantics of LTL formulas are
given over infinite words in the power set of a set of atomic
propositions. We use the simplified semantics of Definition
3 motivated by the problem formulated in Section III.
A B¨ uchi automaton is a finite state automaton accepting
infinite strings. The definition of a B¨ uchi automaton and its
acceptance condition is beyond the scope of this paper, and
we refer the interested reader to [13]. For any LTL formula,
there exists a nondeterministic B¨ uchi automaton accepting
all and only the runs satisfying it [14] (this automaton is
also called a generator of the LTL formula).
B. LTL Games
An LTL game is defined on a graph G = (V,E,h,O),
where V is the set of vertices, E ⊆ V ×V is the set of edges,
O is a set of observables, and h : V → O is an observation
map. The game specification is an LTL formula over the
observable set O [15] (see also [11] for the case of graphs
with no observables). There are two players in the game: P
(the player) and A (the adversary). The set of vertices V is
partitioned in two sets: Vp, which is the set of states from
which the player can choose a move (an edge leading to the
next vertex), and Va, which is the set of states from which
the adversary has a choice of an edge. We assume that the
player can always read the current vertex from set V and not
just its observable.
An (infinite) play consists of an infinite sequence of states
resulted from an infinite sequence of transitions (edges)
chosen by the two players. The player P wins a play if the
produced word w ∈ Oωsatisfies the LTL formula. Starting
from a given initial state, the player has a winning strategy if,
whenever the current state is in Vp, she manages to choose
edges such that she wins the current play, no matter what
edges the adversary chooses when the current state is in Va.
The goal of an LTL game is to find a set of initial states
Ws⊆ V from where the player has winning strategies and
a winning strategy for plays starting in those initial states.
The standard algorithm for solving an LTL game involves
the transformation of the nondeterministic B¨ uchi automa-
ton corresponding to the LTL formula into a deterministic
generator [16]. When a deterministic B¨ uchi automaton can
be constructed, the initial game is reduced to an easier to
solve B¨ uchi game, at the price of a significant increase in
the number of nodes. A B¨ uchi game is an LTL game in
which the winning specification requires that a subset of
vertices (accepting nodes) is visited infinitely often (similar
to the acceptance condition for B¨ uchi automata [13]). The
B¨ uchi game is solved by using a fixed point strategy for
searching the set of all vertices of the graph from where
the player can enforce an infinite number of visits to the set
of accepting nodes. If the found set is empty, there is no
solution (winning strategy) for the game. This means that a
smart adversary can always prevent the player from winning
the game. Otherwise, the found set is projected to the
corresponding subset Ws⊆ V and a solution for the initial
game is constructed by taking into account the moves the
player had to make in order to win the B¨ uchi game. However,

Page 3

not any B¨ uchi automaton can be determinized [17]. When a
deterministic B¨ uchi automaton does not exist for a given
LTL formula, the LTL game becomes more complicated
and the algorithms for finding winning strategies involve
the translation of a nondeterministic B¨ uchi automaton into
a deterministic Muller [18] or Rabin [19] automaton. For
more details of the steps involved in solving LTL games the
interested reader is referred to [16], [15].
The result of solving an LTL game on G = (V,E,h,O)
(as outlined above) is a set of initial states Ws ⊆ V (if
non-empty) and a winning strategy, defined as:
Definition 4: A winning strategy is an automaton W =
(S,V,O,s0,τ,π), where:
• S is the finite set of states (the memory),
• V is the input alphabet,
• O is the set over which the LTL formula φ was defined,
• s0∈ S is the initial state (initial memory),
• τ : S × O → S is the memory update function,
• π : S×Vp→ V is the function giving the chosen move
when the current state of G is in Vp.
The states S result from the states of the deterministic
automaton (e.g., B¨ uchi) corresponding to the LTL formula.
The current vertex of G gives the input of W and it is used
for generating the player’s moves, while the corresponding
observable is used for updating the internal memory of W.
Thus, given the current state (memory) of W, the strategy π
depends on the current state of G, while the memory update
function τ depends only on the observable of this state.
Although the upper bound for complexity of solving LTL
games is double-exponential in the size of the LTL formula
[20], there are some isolated fragments of LTL for which
the complexity is much lower [21]. For formulas in these
fragments, deterministic B¨ uchi automata of low complexity
can be constructed, the game becomes a B¨ uchi game, and
the problem becomes feasible even for large graphs.
The relation between graphs and transition systems is
immediate. When playing an LTL game on a transition
system, instead of choosing the next state, we choose an
input producing the desired transition. This is possible if
player’s states have only deterministic outgoing transitions,
and then the function π from the winning strategy will take
values in the input set of the transition system instead of V .
III. PROBLEM FORMULATION AND APPROACH
In this paper we consider the following problem:
Problem 1: Given a nondeterministic transition system
T = (Q,Σ,δ) and an LTL formula φ over Q, find a set
of feasible initial states Q0⊆ Q and a control strategy such
that formula φ is satisfied by all resulting infinite words.
Remark 2: If the transition system T was deterministic
(i.e., δ : Q × Σ → Q), then a solution to Problem 1
could be found by using an idea similar to model checking
[22], [7], [23]: the LTL formula φ is transformed into a
B¨ uchi automaton Bφand the product automaton T × Bφis
computed. In this product automaton an accepting run with
a specific structure is found and projected to a run of T.
Since T is deterministic, a control strategy implementing the
desired run can be constructed.
Remark 3: To the best of our knowledge there is no direct
approach for solving Problem 1. Besides LTL games, the
problem seems to be related to the problem of controlling
a discrete event system from a specification given as an
ω-regular expressions [12]. However, the difference arises
from the following facts: the ω-regular expressions are
given over the set of inputs Σ, while we are interested in
specifications over the set of states Q. A supervisor enforcing
a desired ω-regular language reads the current input (event)
from the plant T, while our controller will read the current
state. Moreover, we assume that we have full control when
choosing the current input (all events are controllable) and
that we can correctly observe the current state of T.
We propose to use the framework of LTL games to provide
a solution to Problem 1. For this, we need to reformulate
the problem from a graph to a transition system, and then
define a partition of the set of states into player’s states and
adversary’s states.
Remark 4: One quick way of solving this would be to
label as adversary’s state each state from where there exists
at least one input yielding a non-determinist transition.
However, such an approach would be pretty conservative,
because if such an adversary’s state had more than one
feasible input, we wouldn’t use our freedom of choosing
one from these inputs and thus restricting the set of possible
next states.
Our approach involves three main steps. First, we create a
new transition system Tgwith observables, where we choose
the player’s states by looking for states and inputs with
deterministic behavior. Tgwill, in general, have more states
and inputs than T, and its observable set will be Q. Second,
we search for a winning strategy for the LTL game on Tg.
Finally, when such a strategy exists, we adapt it to a control
strategy providing at each step the input to be applied to our
initial transition system T.
IV. CONTROL STRATEGY USING LTL GAMES
We start by transforming T into another transition system
Tg= (Qg,Σg,δg,hg,Q), where:
• Qg is the finite set of states, partitioned into sets Qp
(player’s states) and Qa(adversary’s states),
• Σgis the new alphabet, Σ ⊆ Σg,
• δg: Qg× Σg→ 2Qgis the transition function,
• hg: Qg→ Q is the observation map.
The actual construction of Tgis described in Section IV-A
(the partition of Qgis given in Algorithm 1 and the transition
function δg is constructed in Algorithm 2). Here we give
some definitions and outline how the game is played. The
transition function δgis defined as:
• its restriction to Qp×Σgis deterministic, i.e. ∀q ∈ Qp
and ∀σ ∈ Σg, |δg(q,σ)| ≤ 1,
• its restriction to Qa×Σgis nondeterministic, and there
is only one feasible (enabled) input in every state from
Qa, i.e. ∀q ∈ Qa, there exists an unique input σ ∈ Σg

Page 4

such that |δg(q,σ)| ≥ 2 and all other inputs σ?∈ Σg\
{σ} are not feasible at q (or |δg(q,σ?)| = 0).
These properties of δgshow that when the current state is
in Qp, the player P can always choose the next state from
a feasible set (by applying a feasible input), and when the
current state is in Qa, P has no control on the next state
(we only know that the next state will be in a subset of Qg,
given by the unique feasible input). Thus, the structure of Tg
is appropriate for an LTL game as described in Section II-B.
By solving the LTL game over Tg with winning condition
φ, one can obtain a set of winning initial states, Ws⊆ Qg,
and, if Ws?= ∅, a winning strategy in the form of a finite
automaton, similar to the one from Definition 4. When Wsis
nonempty, the winning strategy is W = (S,Qg,Q,s0,τ,π),
where:
• S is a finite set of states,
• Qgis the input alphabet,
• Q is the set over which the LTL formula φ was defined,
• s0∈ S is the initial state,
• τ : S × Q → S is the memory update function,
• π : S × Qp→ Σgis the function giving the choice of
the next applied input (move) when the current state of
Tgis in the set Qp.
The difference between this winning strategy and the one
from Definition 4 is that here π takes values in Σginstead of
Qg. Because of the mentioned properties of δg, every move
the player should make when the play is in Qpcorresponds
to an unique input from Σg. In order to obtain an input to
be applied to Tg in every state, the map π is extended to
S × Qg, by letting π(s,q) = σ, where σ ∈ Σg is the only
feasible input in state q, ∀q ∈ Qa.
The winning strategy given by automaton W is imple-
mented in a feedback form. At each step, the following
actions are performed (a step is the interval between two
successive transitions of Tg): (1) it reads the current state of
Tg, (2) according to function π, it applies an input from the
set Σgto Tg, and (3) it updates its state according to function
τ. If the initial state of Tg is in the set Ws, this feedback
control strategy guarantees that the game will be won. Note
that this feedback controller assumes that we can always read
the current state of Tgand not only its observable. The details
of the control strategy for T will be given in Algorithm 3,
after the steps involved in obtaining the transition system Tg
are presented.
A. Construction of Tg
We use Algorithms 1 and 2 for transforming the initial
transition system T into the new transition system Tg, with
the above mentioned properties. In both these algorithms, the
states of T are denoted by Q = {q1,q2,...,qn}.
Algorithm 1 creates the states and the observation map of
Tg. First, the states from Q are labelled by a function l : Q →
{det,ndet,mix}: a state with only deterministic outgoing
transitions or without outgoing transitions is labelled with
det, a state with only one feasible input, for which the
outgoing transitions are nondeterministic, is labelled with
q1
q2
q3
q4
a
a
a
a
b
b
q4
a
a
b1
b
2
q1
q4
1
q1
1
q2
1
q3
1
b2
a
a
a
bq4
q4
q2
q3
(a)(b)
Fig. 1.
q4 is mix. (b) Obtained Tg: q4 from T was split in two ndet states in Tg
and two new inputs appeared in Σg. In Tg, the observables are placed near
the states, and the adversary’s states are doubly encircled. All deterministic
transitions are represented with continuous lines, nondeterministic ones with
dashed lines, and each input is placed near the corresponding transition(s).
(a) Transition system T: q1and q3are det states, q2is ndet, and
ndet, and a state with more feasible inputs, from which at
least one yields nondeterministic transitions, is labelled with
mix. Each mix state is split in one or more ndet states and
at most one det state in the new transition system Tg (for
simplicity of writing, we assume that the attributes ndet and
det for states of Tghave exactly the same meaning as in T).
The observable of all these new states is the old mix state.
Each det (respectively ndet) state from T corresponds to a
det (respectively ndet) state in Tg. Thus, Tgwill have only
det (in the subset Qp) and ndet states (in the subset Qa).
Fig. 1 gives a simple example of transforming a transition
system T into Tg. In T, q1 and q3 are det states, q2 is
ndet, and q4 is mix and it will be split in two ndet in Tg.
The obtained Tg will have two player’s states and three
adversary’s states.
For a state qi∈ Q, the variables and sets from Algorithm
1 have the following meaning: ni is the number of states
from Tg in which qi is split, Si = {q1
the set of states from Tg in which qi is split (all these
states have observable qi), Di is the set of inputs from Σ
yielding deterministic transitions from qi, and Niis the set
of inputs from Σ yielding nondeterministic transitions from
qi. If l(qi) = mix then from the set Siat most qni
a det state. Clearly, the following equivalences hold:
i,q2
i,...,qni
i} is
i
can be
• l(qi) = det ⇔ (ni= 1, Si= {q1
• l(qi) = ndet ⇔ (ni= 1, Si= {q1
• l(qi) = mix ⇔ (ni> 1, Ni?= ∅)
Algorithm 2 creates the input alphabet Σg and the tran-
sition function δg. Tghas a larger input set than T because
the det states from T must remain det in Tg. This can be
explained by following the example in Fig. 1: in T, the det
state q3has a transition with input b to the mix state q4. q3
corresponds to one state of Tg (q1
states (q1
for going from q1
inputs b1and b2. Thus, by applying b1when Tgis in q1
next state is q1
In T this has the effect of applying input b while in q3and
enforcing input a when q4is reached. Similarly, when b2is
applied to Tgwhile in q1
i}, Ni= ∅)
i},Di= ∅, |Ni| = 1)
3), but q4 is split in two
4and q2
4). Since we need deterministic transitions
3to either q1
4or q2
4, we introduce the new
3, the
4and there is only one next feasible input (a).
3, this induces the sequence of inputs

Page 5

Algorithm 1 States and observation map of Tg
Qp= ∅, Qa= ∅
for all i = 1,...,n do
if |δ(qi,σ)| ≤ 1, ∀σ ∈ Σ then
l(qi) = det
ni= 1, Si= {q1
Di= {σ ∈ Σ||δ(qi,σ)| = 1}
Qp= Qp∪ {q1
else
if ∃σ ∈ Σ, σ unique, such that |δ(qi,σ)| ≥ 2 and
∀σ?∈ Σ \ {σ}, |δ(qi,σ?)| = 0 then
l(qi) = ndet
ni= 1, Si= {q1
Ni= {σ ∈ Σ||δ(qi,σ)| ≥ 2}
Qa= Qa∪ {q1
else
l(qi) = mix
ni= 0, Si= ∅, Ni= ∅, Di= ∅
for all σ ∈ Σ do
if |δ(qi,σ)| ≥ 2 then
ni= ni+1, Si= Si∪{qni
Qa= Qa∪ {qni
end if
if |δ(qi,σ)| = 1 then
Di= Di∪ {σ}
end if
end for
if |Di| ≥ 1 then
ni= ni+ 1, Si= Si∪ {qni
Qp= Qp∪ {qni
end if
end if
end if
end for
Qg= Qp∪ Qa
i},Ni= ∅
i}, hg(q1
i) = qi
i},Di= ∅
i}, hg(q1
i) = qi
i}, Ni= Ni∪{σ}
i) = qi
i}, hg(qni
i}
i}, hg(qni
i) = qi
b, b starting from q3in T. Although the adversary has full
control on the transitions from q1
has control in going to either q1
adversary’s power. Following the same idea, each det state
of Tg(including those obtained by splitting mix states of T)
might add some new inputs to the alphabet Σg. In order to
adapt these new inputs to inputs of T, Algorithm 2 creates
a map α : Σg→ Σ, which will be used by the controller for
T. For all inputs in set Σ, α is just the identity map.
4and q2
4or q2
4in Tg, the player
4, thus restricting the
The ndet states of Tg (from adversary’s set Qa) will not
add new inputs. Each of these states will have only one
feasible input (from set Σ), and thus the adversary power
in these states comes only from the nondeterminism induced
by that feasible input. A ndet state qj
input a ∈ Σ and observable qi) will have transitions to all the
states resulted by splitting states of T from the set δ(qi,a)
(for example see transitions from q1
iof Tg (with feasible
2, q1
4, q2
4in Fig. 1).
Algorithm 2 Input alphabet and transitions of Tg
Σg= Σ
for all i = 1,...,n do
for all σ ∈ Dido
find the unique j ∈ {1,...,n} s.t. δ(qi,σ) = qj
if nj= 1 then
δg(qni
j
else
for all k = 1,...,njdo
Σg= Σg∪ {σk}
δg(qni
end for
end if
end for
if Ni?= ∅ then
for all j = 1,...,|Ni| do
let σ be the jthelement of Ni
δg(qj
K = {k ∈ {1,...,n}|qk∈ δ(qi,σ)}
for all k ∈ K do
δg(qj
end for
end for
end if
end for
for all q ∈ Qg,σ ∈ Σg for which δg(q,σ) is undefined
do
δg(q,σ) = ∅
end for
for all σi∈ {Σg\ Σ} do
α(σi) = σ
end for
for all σ ∈ Σ do
α(σ) = σ
end for
i,σ) = q1
i,σk) = qk
j
i,σ) = ∅
i,σ) = δg(qj
i,σ) ∪ Sk
B. Solution to Problem 1
We now have all the necessary information to present the
solution to Problem 1. The set of initial states of T from
where the controller guarantees the satisfaction of the LTL
formula φ is:
Q0= {q ∈ Q|∃q?∈ Wss.t.hg(q?) = q}
The set Q0 from (1) is in accordance with the solution
of the LTL game for the transition system Tg: if the initial
state of Tgis in the set Ws, then the strategy generated by
automaton W guarantees the satisfaction of formula φ by
any produced run of Tg. Of course, Q0 = ∅ if and only
if Ws = ∅, case when we conclude that we cannot solve
Problem 1.
If Q0?= ∅, the control strategy for the transition system
T will be a feedback controller, which will also include the
interface between T and the play on Tg, supervised by W.
This controller must include the transition system Tg, the
winning strategy automaton W, the sets Wsand Σ, and the
(1)