CC BY
34To The Parallel Composition of Timed Finite State Machines
Olga Kondratyeva, Maxim Gromov Radiophysics Faculty Tomsk State University Tomsk, Russia kondratyeva. olga.vic@gmail. com, [email protected]
Abstract—This paper deals with the problem of the parallel composition construction for two Timed Finite State Machines (TFSMs). As a key to the solution of this problem we use parallel composition of common Finite State Machines (FSMs). We transform given TFSMs to FSMs and prove theorem, that obtained FSMs correctly describe behaviour of the given TFSMs. Then we build parallel composition of these FSMs, which being transformed back to TFSM, gives desired parallel composition of the given TFSMs
Keywords-Finite State Machine; Timed Finite State Machine; parallel composition
I. Introduction
The Timed Finite State Machine (TFSM) is a model based on well-known Finite State Machine (FSM), which allows explicit description of a time aspects of system behaviour. For example, reaction of a system can be different depending on the time moment an input action is applied to it. In the last few years the interest to the various problems of TFSM has increased. The main lines of researches covered by the post papers are the analysis problems: relations between
TFSMs [1, 2] and test generation methods against those relations [3, 4].
In our paper we consider a problem of synthesis, namely the problem of parallel composition construction of two TFSMs. This procedure gives an instrument to build complex systems from simple ones, each described by a TFSM. Also, the approach we used in this paper to describe a parallel composition construction procedure opens the way for solving various problems of TFSMs.
II. Preliminaries
In this section we give some notions and definitions, which we shall use all over the paper.
A. Language
An alphabet is a finite non-empty set of symbols and as usual, given an alphabet X, we denote X* the set of all finite sequences (words) of symbols from X including the empty word e. The number of symbols in a sequence we shall call length of this sequence; by definition, length of the empty word is zero. A subset L c X* is a language over alphabet X.
Let language L be defined over alphabet Y and X be a non-empty subset of Y. The X-restriction L\\X of the language L is derived by deleting from each sequence of L each symbol of the set YX. When the language L is defined over alphabet X, and Y is some alphabet that is disjoint with X, consider the mapping 9: X ^ 2(XuY)* such, that 9(x) = {axp : a, p e Y*}. This mapping can be extended over sequences from X* as follows. Let y be a sequence from X* and x be a symbol from X, then 9(e) = Y* and 9(xy) = 9(x>9(y), where the sign stands for concatenation of sequences. We shall call the language LftY = {9(y) : y e L} the Y-expansion of language L.
B. Finite automata
There exists a special set of languages which can be described by the use of finite automata; those are regular languages, which are closed under union, concatenation, complementation, intersection and also under restriction and expansion.
A finite automaton (FA) is a 5-tuple S = (S, A, s0, 5S, Q), where S is a non-empty finite set of states with the designated initial state s0, A is a finite alphabet of actions, 5S c S x A x S is a transition relation, and Q c S is a set of final (accepting) states. If (si, a, s2) e 5S, then we say, that automaton S in the state s1 takes action a, and changes its state to the state s2; the state s2 is called an a-successor of the state s1 and we denote by sucS(s1, a) the set of all a-successors of the state s1. Function sucS can be extended over sequences from A * as follows:
sucS(s1, pa) = {sucS(s2, a) : s2 e sucS(s1, a)}.
By the definition sucS(s1, e) = s1.
Finite automaton S is called deterministic if for each pair (s1, a) e S x A there is at most one state s2 e S such that (s1, a, s2) e 5S, i.e. |sucS(s1, a)| < 1, otherwise, the finite automaton is non-deterministic.
Finite automaton S is called complete if for each pair (s1, a) e S x A there is at least one state s2 e S such that (s1, a, s2) e 5S, i.e. |sucS(s1, a)| > 1, otherwise, the finite automaton
is partial.
Let us consider a word p e A*. Automaton S recognizes or accepts p if there exists an accepting state q e Q such that q is a p-successor of the initial state, i.e. q e sucS(s0, p). The
This paper is partially supported by Russian Foundation for Basic Research (Grant 10-08-92003-HHC_a)
set LS of all sequences, which are accepted by S, is the language accepted by the automaton or simply the language of the automaton S. The language of a finite automaton is a regular language [5].
C. Finite State Machines
To describe behaviour of a system, which transforms sequences over one (input) alphabet into sequences over another (output) alphabet, special kind of automata, called Finite State Machine, is usually used [6].
A finite state machine (FSM) is a 5-tuple S = (S, I, O, s0, XS), where S is a non-empty finite set of states with initial state s0, I and O are disjoint finite input and output alphabets, XS c S x I x O x S is the transition relation. If (s1, i, o, s2) e XS, then we say, that the FSM S in the state s1 gets the input action i, produces the output action o and changes its state to s2; the state s2 is called an i/o-successor of the state s1. The set of all i/o-successors of the state s1 is denoted sucS(s1, i, o), while
sucS(s1, i) = {s2 e S: 3 o e O such that s2 e sucS(s1, i, o)} is the set of all i-successors of the state s1.
Functions sucS(s1, i, o) and sucS(s1, i) can be extended to the sequences a e I* and p e O*, where lengths of a and p are equal, as follows:
sucS(s1, ai, po) = {sucS(s2, i, o): s2 e sucS(s1, a, p)} and
sucS(s1, ai) = {sucS(s2, i): q e sucS(s1, a)}.
By the definition sucS(s1, e) = sucS(s1, e, e) = s1.
FSM S is deterministic if for each pair (s1, i) e S x I there is at most one pair (o, s2) e S x O such that (s1, i, o, s2) e XS,
i.e. |sucS(s1, i)| < 1, otherwise, FSM S is non-deterministic.
FSM S is complete if for each pair (s1, i) e S x I there is at least one pair (o, s2) e S x O such that (s1, i, o, s2) e XS, i.e. |sucS(s1, i)| > 1, otherwise, FSM S is partial.
FSM S is observable if for each triple (s1, i, o) e S x I x O there is at most one state s2 e S such that
(s1, i, o, s2) e XS, i.e. |sucS(s1, i, o)| < 1, otherwise, FSM S is non-observable.
A sequence ct = (i1, o1)(i2, o2)...(in, on) e (I x O)* is called a trace of given FSM S if the set of a/p-successors, where a = i1i2.in and p = o1o2...on, of the initial state of S is non-empty, i.e. sucS(s0, a, p) 4 0. The set of all traces of the FSM is the language LS of the FSM S. Further, talking about traces of an FSM, we assume that a sequence ct and the corresponding pair a/p are equivalent notions.
Given FSM S = (S, I, O, s0, XS), the automaton Aut(S) is a 5-tuple (S u (S x I), I u O, s0, 8S, S), where for each transition (s1, i, o, s2) in XS there are two transitions (s1, i, (s1, i)), and ((s1, i), o, s2) in 8S. Since the language LSaut of the automaton Aut(S) is the language of the FSM [7] it
holds that LSaut c (IO)*, where IO is concatenation of alphabets I and O.
D. Timed Finite State Machines
A timed finite state machine (TFSM) is a 6-tuple S = (S, I, O, s0, XS, As), where the 5-tuple (S, I, O, s0, XS) is an FSM and AS: S ^ S x (N u {to}) is a time-out function. If AS(s1) = (s2, n), then the TFSM S in the state s1 will wait an input action for n time units (ticks), and if none arrives it will move to the state s2 (possibly the same as s1), without producing any output. If AS(s1) = (s2, to), then we require s2 = s1 and the TFSM can stay in the state s1 infinitely long, waiting for an input. Definitions of a deterministic, complete and observable TFSM are based on the corresponding definitions for underlying FSM.
A special timed or clock variable can be associated with a TFSM; this variable counts time ticks passed from the moment when the last transition has been executed and is reset to 0 after each transition (input-output or time-out). In this paper, for the sake of simplicity, we assume that the output is produced immediately after a machine gets an input, i.e., we do not consider delays when executing transitions.
A pair (i, t) e I x (N u {0}) is a timed input meaning that the input i is submitted to the TFSM t ticks later than the previous output has been produced. A sequence of inputs is a timed input sequence.
We also define a special function timeS [1] as follows:
1. timeS(s, t) = s for all t eNu{0} if AS(s) = (s, to).
2. timeS(s1, t) = s1 for all t < T and AS(s1) = (s2, T).
3. timeS(s1, t) = s2 for t = Tand AS(s1) = (s2, T).
4. for t > T and AS(s1) = (s2, T) define recursively timeS(s1, t) = timeS(s2, t - T), i.e. there is a sequence s1, s2,... sk such that for each j = 1...k - 1 it holds AS(sJ) = (s, + 1, Tj)
and T1 + T2 + ... + Tk-1 < t < T1 + T2 + ... + Tk-1 + Tk, then timeS(s1, t) = sk.
The function sucS is defined similar to that defined for an FSM and is extended to timed inputs as follows:
sucS(s, (i, t), o) = sucS(timeS(s, t), i, o).
A sequence
CT = (i1, t1, o1)(i2, t2, o2).(in, tn, on) e [I x (Nu{0}) x O]*
is called a functional trace of a TFSM S, if the following holds sucS(s0, a, p) ^ 0, where a = (i1, t1)(i2, t2)...(in, tn) and p = o1o2.on. The set LS of all functional traces of the TFSM S is the f-language of the TFSM S. Here we again assume, that the pair a/p and the sequence ct are the equivalent notions, when speaking about f-language of a TFSM.
E. Equivalence of automata, FSMs and TFSMs
Two finite automata S and P with languages LS and LP are said to be equivalent if LS = LP.
Two FSMs S and P with languages LS and LP are said to
be equivalent if LS = LP.
Two TFSMs S and P with f-languages LS and LP are said
to be equivalent if LS = LP.
III. Parallel composition
In this paper we propose definition of parallel composition for two TFSMs. This definition relies on the definition of FSM parallel composition and the latter is defined in terms of parallel composition of corresponding automata. For that reason we also describe the conversion procedure [8] of a TFSM into an FSM, which then is used for the parallel composition construction. We also prove, that built FSM correctly reflects the language of a given TFSM.
A. Parallel composition of languages
Given pairwise disjoint alphabets X, Y, Z, languages Li over Xu Y and L2 over Yu Z, the parallel composition of languages Li and L2 is the language
L = [(Li)ftz n (L2)fe] Ux^
defined over X u Z and denoted Li 0XuZ L2 or just Li 0 L2 when the union X u Z is clear from context.
B. Parallel composition of automata
Given two finite automata S = (S, I u U, s0, 5S, QS) and P = (P, U u O, po, 5p, Qp), the automaton
C = (C, I u O, c0, 5c, Qc) is a parallel composition of automata S and P, denoted C = S 0 P, iff LC = LS 0 LP. To obtain composition of automata define expansion and restriction over automata as follows.
Given disjoint alphabets I and O and an automaton S = (S, I, s0, 5S, QS). O-expansion of S is an automaton Sfto = (S, I u O, s0, 5S u ^S, QS), where ç S x O x S contains all triples (s, o, s), such that o e O and s e S, i.e. to expand an automaton we add loops marked with all symbols of alphabet O for each state.
Given disjoint alphabets I and O and an automaton S = (S, IuO, s0, 5S, QS). I-restriction of S is an automaton Sui = (S, Iu{x}, s0, (xS, QS), where for each transition (si, a, s2) e 5S we add transition (si, a, s2) into (xS in case a e I, while we add transition (si, x, s2) into (xS in case a e O, i.e. to restrict an automaton we replace all symbols of alphabet O by special symbol x. An automaton without x-moves can be derived by the determinization procedure [9].
Now, the procedure of parallel composition construction of two given automata S and P can be described by the formula:
C = [S ft0 n Pm] Uiuo.
C. Parallel composition of FSMs
Following [7], we define the parallel composition of two FSMs (Fig. i) based on their corresponding automata. However, the language of the parallel composition of two automata is not necessary an FSM language. For this reason,
the obtained language should be intersected with the language (IO)*, where I and O are external input and output alphabets of composition, to ensure that each input is followed by some output.
Given FSMs S = (S, I1 u V, U u O1, s0, 1S) and P = (P, I2 u U, V u O2, p0, XP), the parallel composition C = S 0 P is derived in the following way. We first derive corresponding automata Aut(S) and Aut(P) and the parallel composition Aut(S) 0 Aut(P). The obtained automaton then is intersected with the automaton that accepts the language (IO)* and is transformed to the FSM C coupling inputs with the following outputs. FSM C = (C, I, O, c0, XC) is the parallel composition of S and P, where I = I1 u I2 and
O = O1 u O2.
Figure i - Parallel composition of FSMs S and P.
It is proven [7], that parallel composition describes following interaction of composed FSMs S and P (Figure i). The system starts it work, when both S and P are in their initial states, i.e. composition C = S 0 P is in its initial state. External environment applies input action either on channel I1 or I2, but only one at a time, and then waits for an external output reaction of the system through the one of the output channels Oi or O2. The component FSM, which just have got an input action, processes this input and produces either an external output (and so external environment can apply its next input action), or an internal output action that is internal input action for another component FSM. In the latter case, the second component FSM processes a submitted internal input and produces either an external output or an internal output applied to the first component FSM. The dialog between component FSMs continues until one of them produces an external output. When an external output is produced the system is ready to accept the next external input. Here we notice that there can be an external input initiating an infinite dialog between component FSMs. Such infinite cycles of internal actions are called livelocks. However, in practical situations, except of some special cases, input sequences inducing livelocks are usually forbidden.
D. Correspondence between Timed Finite State Machine and
Finite State Machine
Before we propose how to construct the parallel composition of timed finite state machines, we introduce the transformation procedure of a TFSM into an FSM and back, and then prove, that obtained FSM correctly describes f-language of the TFSM.
Given TFSM S = (S, I, O, s0, XS, AS), we can build an FSM with similar set of functional traces by adding designated input 1 g I and output N g O [8]. Corresponding
FSM AS = (S u St, I u{1}, O u{N}, s0, X^ ) can be built by
adding T - 1 copies for each state s e S with defined a finite time-out T > 1. There is a chain of transitions between these copies marked with special input-output symbol 1/N. All other transitions are preserved for each copy. Formally, constructing of AS can be done by the use of the following rules:
1. St contains all such states (s, t), t = 1, ..., T- 1 where
s e S and AS(s) = (s', T), 1 < T < to.
2. For each s e S and (s, t) e St and for each i/o, i e I,
o e O, there are transitions (s, i, s', o), ((s, t), i, s', o) e X^ iff there is a transition (s, i, s', o) e XS.
3. For each s e S such that AS(s) = (s, to) there is a
transition (s, 1, s, N) e X^ .
4. For each s e S such that AS(s) = (s', T), T = 1, there is a transition (s, 1, s', N) e X^ .
5. For each s e S such that AS(s) = (s', T), 1 < T < to, there are transitions (s, 1, (s, 1), N) e X^ ; for eachj = 1, ..., T - 2 there are transitions ((s, j), 1, (s, j + 1), N) e X^ and
((s, T - 1), 1, s', N) e X^ .
We use SA to denote S u St, IA to denote I u{1} and OA to denote O u{N}.
By construction, when a given TFSM S has n states, a corresponding FSM AS has 2 n(s) states, where n(s) = 1 for
seS
AS(s) = (s, to) and n(s) = T for AS(s) = (s', T).
Consider an example in Figure 2. State q of TFSM has timeout 2 and therefore, we add one copy of (q, 1) (denoted “q1”) which is 1/N-successor of the state q while its 1/N-successor is s. The sets of successors of q and (q, 1) for all other I/O pairs coincide.
Figure 2 - TFSM S (top figure) and corresponding FSM AS (bottom figure)
An FSM AS = (SA, IA, OA, s0, X^ ) such that there are no transitions marked with i/o or i/N where o ^ N and i ^ i can be transformed to TFSM S = (S, I, O, s0, XS, AS) using the following rules:
1. AS(s) = (s, to) iff (s, i, s, N) e XR .
2. Define AS(s) = (sT, T) for all such s that there is a
chain of transitions
i/N
i-------^...------^^t_i-------------^st , s, st e Sa,
T > i and for each i/o e I x O and i < j < T - i it holds that
sucg (sj, i, o) = sucg (s, i, o), but for some i/o e I x O it holds that suc$ (s, i, o) ^ suc$ (sT, i, o).
3. For each se SA, i e I and o e O, if (s, i, s', o)e XR
then (s, i, s', o) e XR.
Notice that transformation from a given TFSM to an FSM according to the above rules is unique whereas the back transformation from an FSM to a TFSM could be made in different ways; however all such TFSMs are pairwise equivalent, i.e. their f-languages are the same (see the Corollary 2 to Proposition i).
The following statements establish the relationship between a TFSM and the corresponding FSM built by the above rules.
Proposition 1. FSM AS has a trace 1/N... i/N ii/oi ...
h
1/N ... i/TV im/om iff TFSM S has a functional trace
(i1, t1)/o1-.. (im, tm)/om.
Proof. According to the rules of constructing AS, for each two states s1 and (s1, j) and each i e I and o e O, the set of i/o-successors of (s1, j) coincides with the set of i/o-successors of state s1 in S. Thus if there exists such s2
that (s1, i, s2, o) e XS, then there is a transition s1 —s2 in both machines S and AS and there is a transition (s1, j ——^s2 in AS. Therefore, it is enough to show that AS is moving from state s1 to some state q e S u St under the sequence 1/N ... 1/N with t > 0, and the set of i/o-successors of t
q in AS coincides with the set of i/o-successors of the state
timeS(s1, t) in S.
If AS(s1) = (s1, to), then timeS(s1, t) = s1 holds for each value of t; therefore, there is a transition (s1, 1, s1, N) e X^
and AS remains at state s1 under the sequence 1/N ... 1/N.
t
Consider now AS(s1) = (sT, T). If t < T, then
timeS(s1, t) = s1 and the sequence 1/N ...1/N moves AS from
m
2
s, to (s,, t). The set of i/o-successors of (s,, t) in AS coincides with the set of i/o-successors of s, in S. If t > T, then timeS(s,, t) = timeS(timeS(s1, T), t - T) = timeS(sT, t - T). By construction, the sequence i/N ... i/N moves AS from s, to
T
sT, and the sequence i/N ... i/N is applied to AS at state sT,
t-T
i.e., this case is inductively reduced to the previous case
t < T.D
Corollary 1. TFSMs S and P are equivalent iff corresponding FSMs AS and AP are equivalent.
Corollary 2. If TFSMs S and P both are built by the above procedure from an FSMs AS, then S and P are equivalent.
Proposition 2. TFSM S is deterministic (complete or observable) iff the corresponding FSM AS is deterministic (complete or observable).
Proof. The property to be deterministic, observable and complete is specified by the cardinality of sets of i/o- and
i-successors. FSM AS has one and only one transition with pair i/N at each state, that is why properties of FSM AS to be deterministic, observable and complete depend on transitions with other I/O pairs.
By construction it holds that
sucg ((s, t), i, o) = sucg (s, i, o) = sucS(s, i, o) for each state s, AS(s) = (s', T), and for any value of t < T. Hence | sucg ((s, t), i, o)| = | sucg (s, i, o)| = |sucS(s, i, o)| and | sucg ((s, t), i)| = | sucg (s, i)| = |sucS(s, i)|. □
E. Parallel composition of TFSMs
Parallel composition of two TFSMs S and P is a TFSM C = S 0 P obtained from the FSM AS 0 AP.
Let us illustrate our approach by constructing the parallel composition of TFSMs.
Figure 3 - Parallel composition of TFSMs as a parallel composition of corresponding FSMs
The parallel composition of FSMs that corresponds to the parallel composition of TFSMs is shown in Figure 3. In this case, port 1 is a common port for both machines as it corresponds to a counter of ticks and this accepts the designated input 1 that is an input for both component FSMs and can be considered as an input that synchronizes time
behaviour of component FSMs. The designated output N is observed, when there are no outputs at ports O1 and O2 (it is observed at both of the ports). Each component FSM has its own time variable, which increments every moment when component gets the designated input 1, and since this signal is applied via a common port for both components the global time is used, and thus, we can say that it synchronizes the behaviour of component FSMs.
As an example, consider the composition of TFSM S in Fig. 2 and P in Fig. 4 where corresponding FSMs are shown as bottom figures. Consider symbols a and o to be external input and output respectively, x and b are internal symbols.
x/o 1
Figure 4 - TFSM P (top figure) and corresponding FSM AP (bottom figure)
To derive the parallel composition of FSMs, we firstly construct the related automata which are shown in Figure 5. Double lines denote accepting states.
Figure 5 - Automata Aut(AS) (top figure) and Aut(AP) (bottom figure)
The second step is to derive the intersection of expended automata that is shown in Figure 6. This intersection should be restricted onto external alphabet (I u{1}uO u{N}) and this restriction intersected with an automaton that accepts the language [(I u{1})(O u{N})]* and it is shown in Figure 7.
o, N
Figure 7 - an automaton accepting language [{a, 1}{o, N}]*
We then derive a corresponding FSM coupling inputs and the following outputs (Figure 8) and transform this FSM to a corresponding TFSM (Figure 9) that is the parallel composition of TFSMs S and P.
Figure 8 - Composition of S and P (FSM)
The state (qi, h) is copy of the states (q, h) and (q, gi), so there is a time-out equals 2 in the states (q, h) and (q, gi).
Furthermore, the states (q, h) and (q, g1) are (f-)equivalent likewise the states (s, g) and (s, h). That is why we keep only two states in TFSM, shown in Figure 9.
Figure 9 - Composition of S and P (TFSM)
IV. Conclusion and future work
The propositions 1 and 2 with corollaries give an approach for solving different problems of TFSMs: first, the corresponding FSMs should be constructed, then appropriate methods of FSM theory can be applied to solve the problem of interest and, finally, the result should be converted back to a TFSM. In this paper we used this approach to define, but more importantly, to construct parallel composition of given TFSMs. However, there is a weak point in the presented work. We have not given a proof of the fact, that such a way to construct parallel composition gives a TFSM which describes a system, combined from two TFSMs, operating in the slow environment setting, as it is done for FSM parallel composition [7]. But Propositions 1 and 2 give confidence, that such a proof can be obtained.
Another direction of research with proposed approach, which we want to designate, is solving the TFSM equations. This line of researches is not covered enough in works on timed finite state machines and we believe that known methods for solving the FSM equations can be adapted to TFSMs easily enough.
References
[1] М. Громов, Н. Евтушенко, “Синтез различающих экспериментов для временных автоматов,” Программирование, № 4, Москва: МАИК, 2010, с. 1-11.
[2] M. Gromov, K. El-Fakih, N. Shabaldina and N. Yevtushenko, “Distinguishing non-deterministic timed finite state machines,” in FMOODS/FORTE-2009, LNCS, vol. 5522, Berlin: Springer, pp. 137151, 2009.
[3] M. G. Merayo, M. Nunez and I. Rodrigez, “Formal testing from timed finite state machines,” in Computer Networks, vol. 52(2), 2008, pp. 432-460.
[4] K. El-Fakih, N. Yevtushenko and H. Fouchal, “Testing finite state machines with guaranteed fault coverage,” in TESTC0M/FATES-2009, LNCS vol. 5826, Berlin: Springer, pp. 66-80, 2009.
[5] A. V. Aho and J. D. Ulman, “The theory of parsing, translation and compiling: Parsing,” New Jersey:Prentice-Hall, 1002 p., 1973.
[6] A. Gill, “Introduction to the theory of finite-state machines,” New-York:McGraw-Hill, 207 p., 1962.
[7] Спицына Н. В. Синтез тестов для проверки взаимодействия дискретных управляющих систем методами теории автоматов: Диссертация на соискание ученой степени канд. технических наук. - Томск, 2005. - 158 c.
[8] М. Жигулин, Н. Евтушенко, И. Дмитриев, “Синтез тестов с гарантированной полнотой для временных автоматов,” Известия Томского политехнического университета, Т. 316, № 5, Томск: Издательство ТПУ, с. 104-110, 2010.
[9] J. Tretmans, “Test geniration with inputs, outputs and repetitive quiescence,” Software-Concepts and Tools, vol. 17(3), pp. 103-120, 1996
