3.2 Trace Semantics 63 3.1.4 What Makes a Good Semantics? We look at a number of different semantic models for LOTOS. Before we do this, it is worth considering what constitutes a “good” semantics, and what criteria we can apply to the choice of semantics. The following issues can be highlighted. • A semantics should enable properties of a specification to be verified, e.g. that the specification cannot do a particular “bad thing,” such as deadlock. • The semantics should be unambiguous; i.e. it should not be possible to relate a specification to two different meanings. • The semantics must be intuitively meaningful. Perhaps the most impor- tant criterion for the choice of semantics is that it correctly reflects the “meaning” that is trying to be extracted from a specification. Thus, the semantics should relate specifications that are “intuitively” the same. • A semantics must distinguish specifications that are different. This is just as important as the previous point. If a semantic map relates two “intu- itively” different specifications to the same semantic model we would not be able to differentiate between the specifications in our semantic world. This would, for example, mean that any property that held about one of the specifications would hold for the other. Thus, we must be careful to ensure that our semantics are fully expressive, in the sense that they distinguish between enough specifications. An obvious question that arises from these points is: what is an appropriate intuitive meaning? There are actually a number of different such intuitions. Most of our semantics though seek to describe only the observable behaviour of systems (this applies less to the true concurrency model). Thus, we seek to locate semantics that model the observable behaviour of systems and that abstract from the internals of how this behaviour is obtained. 3.2 Trace Semantics 3.2.1 The Basic Approach This is the first semantic model that was considered for process calculi [95] and it remains the simplest approach that is in use. The idea is to model the semantics of specifications as the set of all possible linear sequences (or traces) of actions that the specification can perform. The “all possible” here is important. In particular, you should notice that we are not solely interested in complete traces, i.e. sequences of actions that cannot be extended. Rather, we are interested in all possible intermediate and complete traces. As a reflection of the fact that trace semantics consider linear traces,such approaches are frequently referred to as linear time models. As suggested earlier, we denote the trace semantic map as 64 3 Basic Interleaved Semantic Models ❏❑ tr : pbLOTOS −→ P (T ) i.e. it maps primitive basic LOTOS specifications to trace sets. The following pbLOTOS behaviours, P 0 := x ; y ; stop P 1 := ( x ; y ; stop )[](z ; w ; stop ) P 2 := ( z ; w ; stop )[](x ; y ; stop ) P 3 := x ; x ; stop P 4 := ( x ; x ; stop )[](x ; x ; stop ) P 5 := stop are mapped to the following trace sets, ❏ P 0 ❑ tr = { , x, xy} ❏ P 1 ❑ tr = { , x, z, xy, zw} ❏ P 2 ❑ tr = { , x, z, xy, zw} ❏ P 3 ❑ tr = { , x, xx} ❏ P 4 ❑ tr = { , x, xx} ❏ P 5 ❑ tr = {  } Notice that we have now equated two of the pairs of specifications that we highlighted as intuitively equal; i.e. ❏ P 1 ❑ tr = ❏ P 2 ❑ tr and ❏ P 3 ❑ tr = ❏ P 4 ❑ tr . The properties of sets play an important role in making these semantic de- scriptions equal; i.e. sets are unordered and duplicates are removed. Also notice that the behaviour stop is mapped to the trace set which includes just one trace: , the empty trace. It is a rule of trace semantics that the trace set of any behaviour will contain the empty trace, because all behaviours can perform an empty trace. Process invocation and action relabelling can also be easily modelled using trace semantics. Consider the following recursive process definition, P [z, w]:=z ; w ; P [w, z] Notice how the action names are flipped on recursive invocation. So, invo- cation of this behaviour with the action z relabelled to x and the action w relabelled to y will have the following infinite trace model, ❏P [x, y]❑ tr = {  , x , xy , xyy , xyyx , xyyxx , xyyxxy , xyyxxyy , . . . } Infinite models typically arise when recursive behaviour is considered. We consider how to handle such behaviour shortly. As already indicated, we are interested in modelling just the observable behaviour of pbLOTOS specifications. As a reflection of this, internal actions do not find their way into trace sets. For example, the behaviours 3.2 Trace Semantics 65 P 0 := i ; y ; stop P 1 := ( x ; i ; stop )[](z ; w ; stop ) P 2 := i ; i ; stop P 3 := hide z in ( x ; z ; y ; stop ) are mapped to the trace sets: ❏ P 0 ❑ tr = { , y} ❏ P 1 ❑ tr = { , x, z, zw} ❏ P 2 ❑ tr = {  } ❏ P 3 ❑ tr = { , x, xy} Notice that this gives us equality between behaviours such as i ; i ; stop , i ; stop and stop and also, between behaviour such as x ; y ; stop and hide z in ( x ; z ; y ; stop ). Because of the suppression of internal actions, the point of sequential compo- sition is not directly reflected in trace semantics. Remember that successful termination in pbLOTOS has the form: B 1 >> B 2 where the behaviour B 1 enables the behaviour B 2 when all concurrent threads in B 1 have performed an exit and an internal action is generated when control is handed from B 1 to B 2 . For example, the behaviour, P := ( x ; y ; exit [] z ; exit ) >> ( w ; stop ) will map to the following trace set, ❏ P ❑ tr = {  , x , z , xy , zw , xyw } However, successful termination actions, denoted δ, can arise in trace sets. Such actions will only appear when an exit is left “dangling” in a behaviour, i.e. is not matched by a sequential composition. Thus, the behaviour Q := ( x ; y ; exit )[](z ; exit ) will map to the following trace set, ❏ Q ❑ tr = {  , x , z , xy , zδ , xyδ } Trace semantics typically model concurrency using interleaving (an exception is found in [139]). This view of concurrency fits naturally with the linear trace approach. For example, the behaviours 66 3 Basic Interleaved Semantic Models P 0 := x ; stop ||| y ; stop P 1 := ( x ; stop ) ||| ( y ; z ; stop ) P 2 := ( x ; z ; stop ) |[z]| ( y ; z ; stop ) P 3 := ( x ; y ; z ; stop ) || ( x ; y ; stop ) are mapped to the following trace sets, ❏ P 0 ❑ tr = { , x, y, xy, yx} ❏ P 1 ❑ tr = { ,x,y,xy,yx,yz,xyz,yxz,yzx} ❏ P 2 ❑ tr = { , x, y, xy, yx, xyz, yxz} ❏ P 3 ❑ tr = { , x, xy} 3.2.2 Formal Semantics This section gives a formal interpretation of trace semantics, which reflects the intuition that we have presented in the examples of the previous section. 3.2.2.1 Preliminaries: Traces First we need to formalise what we mean by a trace and a set of traces. The set of all traces is denoted T ; it contains the special distinguished trace  (which denotes an empty trace) and all sequences, x 0 x 1 x 2 x 3 x n ,wherex i ∈ Act ∪{δ} of observable actions or successful terminations. 1 Notice that these traces are finite; i.e. each trace represents a finite sequence of behaviour. However, the set of all traces of a computation is likely to be infinite. Thus, we model behaviour as a (potentially) infinite set of finite computations. We use σ, σ  ,σ  ,σ 1 ,σ 2 , to range over T and we define a number of basic operations on traces. • Concatenation. Two traces σ and σ  can be concatenated by performing the operation, σ.σ  . Formally, we can define concatenation as: (σ 1 =  =⇒ σ 1 .σ 2 = σ 2 ) ∧ (σ 2 =  =⇒ σ 1 .σ 2 = σ 1 ) ∧ (σ 1 = x 1 x 2 x n ∧ σ 2 = y 1 y 2 y n ) =⇒ σ 1 .σ 2 = x 1 x 2 x n y 1 y 2 y n As a slight abuse of notation, we write x to mean both a single action and the singleton trace; the correct interpretation is clear from the context. 1 In fact, our semantics will ensure that successful termination actions only arise as the last element of a trace, however, for ease of presentation, we use a more liberal definition here. 3.2 Trace Semantics 67 • Star. Given a set A ⊆ Act, we denote the set of all traces that can be formed using actions from the set A as A ∗ . Formally, A ∗  {}∪{x 0 x 1 x n | x i ∈ A } Using this notation we can note that T =(Act ∪{δ}) ∗ . A wealth of additional operators on traces is defined in [96]. 3.2.2.2 A Denotational Trace Semantics for pbLOTOS The following rules define a, so called, denotational semantics for pbLOTOS. This will realise the semantic map ❏❑ tr and, thus, define a function from pbLOTOS specifications to trace sets. The function is expressed by defin- ing the meaning of all the syntactic elements of the language. This is done by traversing the abstract syntax of pbLOTOS. The mathematically correct phrase is that the mapping is defined by induction over the syntax of the lan- guage. So, the rules work construct by construct through the language. The rules we give are based on those presented in [120] with some influence from similar rules presented for CSP in [96]. What we are interested in is the meaning of an arbitrary pbLOTOS spec- ification, i.e. to evaluate ❏ S ❑ tr ,whereS ∈ pbLOTOS and ❏❑ tr has the form: ❏❑ tr : pbLOTOS −→ P (T ) The function ❏❑ tr is defined according to the syntactic alternatives a top- level pbLOTOS specification can be constructed from, i.e. according to the first clause in the pbLOTOS abstract syntax. Thus, we have the following rules, which handle the two alternative forms that a top-level specification can take. ❏ B ❑ tr  B❏ B ❑ (∅) ❏ B where D ❑ tr  B❏ B ❑ (D❏ D ❑) B❏❑is the semantic function that maps behaviour expressions to trace sets. The function B❏❑has two parameters: the behaviour expression to evaluate (here B) and a set of process definitions (the second parameter is written as a subscript of the application, e.g. ❏❑ (d) ). This set of definitions is used in the evaluation of the behaviour B, thus enabling processes defined in D to be instantiated in B. In analogy with programming language semantics d is an environment. The rules state that if the specification just contains a behaviour expres- sion, with no process definitions, then the trace model of the specification is given by applying B❏ B ❑ (∅) (with the definition parameter empty). Alter- natively, if the specification is a behaviour followed by a where clause, then the trace model of the specification is given by applying B❏ B ❑ (D❏ D ❑) , i.e. evaluating behaviour B according to the declarations in D. 68 3 Basic Interleaved Semantic Models Now we step down one level in the pbLOTOS abstract syntax to define the meaning of lists of definitions. All we do here is to place the list of definitions into a set, which can be accessed at a deeper level in the semantics. Thus, we define the function D❏❑ : DefList −→ P (Defs) whichisdefinedas D❏ (P := B) ❑  { P := B } D❏ (P := B) D ❑  { P := B }∪D❏ D ❑ We can now step down another level in the syntax to define the trace mean- ing of behaviour expressions. This is the major part of the semantics and it involves defining the meaning of the function, B❏❑ (d) : Beh ×P(Defs) −→ P (T ) which evaluates behaviour expressions. Notice that the two parameters to the function are made explicit in the typing. In a similar way to earlier, B❏❑is defined by working through the possible syntactic forms that a behaviour expression can take. Thus, we define the meaning of all possible formats that a behaviour expression can take. Stop. The semantics of this behaviour are trivial; it simply yields the set containing the empty t race. This indicates that the behaviour stop cannot perform any nontrivial traces. B❏ stop ❑ (d)  {} Exit. The semantics of exit are only marginally more complex: B❏ exit ❑ (d)  {, δ} exit is a behaviour which can perform one of two traces: the empty trace or a singleton trace just containing an action δ.Theδ action is the special distinguished action which denotes successful termination. The action is used as a signal to indicate successful termination. This becomes clear when we consider the semantics of enabling, >>, which use the δ action to initiate the transfer of control to the enabled behaviour. Ac tion Prefix. There are two clauses for action prefix; the first deals with observable actions and the second deals with internal actions. The first is as follows, B❏ x ; B ❑ (d)  {}∪{x.σ | σ ∈B❏ B ❑ (d) } 3.2 Trace Semantics 69 The trace set for action prefix is defined by taking the traces that can be derived from B (thus, B❏❑is a recursive definition) and prepending the action x on the front of all of them. The empty trace must also be added, because, although B❏ B ❑ (d) will contain an empty trace, it will be lost when x is prepended. The second clause is as follows. B❏ i ; B ❑ (d)  B❏ B ❑ (d) Because i is not observable in trace semantics, the occurrence of such an action is simply ignored. Choice. Choice yields a straightforward trace semantics; it simply corre- sponds to taking the union of the trace sets derived from the two alternative behaviours. B❏ B 1 [] B 2 ❑ (d)  B❏ B 1 ❑ (d) ∪B❏ B 2 ❑ (d) Notice that any traces that can be performed by both B 1 and B 2 will be represented by a single trace in B❏ B 1 [] B 2 ❑ (d) and that choice points are not explicitly reflected in the semantics. Enabling. The semantic rule for sequential composition centres on the han- dling of the δ action. B❏ B 1 >> B 2 ❑ (d)  {  }∪{σ.x | σ.x ∈B❏ B 1 ❑ (d) ∧ x = δ }∪ { σ.σ  | σ.δ ∈B❏ B 1 ❑ (d) ∧ σ  ∈B❏ B 2 ❑ (d) } Firstly, any trace from B 1 that does not successfully terminate, i.e. does not have δ as the last element, is included directly in the semantics of B 1 >> B 2 . These traces reflect the noncomplete evaluations of B 1 , in other words, all the traces that B 1 performs before it terminates. Secondly, all traces from B 1 that finish with δ are concatenated with all traces from B 2 . It is important to note that the δ action does not appear in the concatenated trace (unless it appears in B 2 ). In terms of the informal definition of pbLOTOS, the δ should be transformed into an internal action. However, because internal actions are not depicted in trace semantics, this replacement is not visible. Parallel Composition. The semantics of parallel composition are somewhat more complex. We need to compose the traces of B 1 and B 2 in such a way that the resultant traces reflect the parallel composition of the two behaviours. The basic rule is B❏ B 1 |[x 1 , ,x n ]| B 2 ❑ (d)  { σ |∃σ 1 ∈B❏ B 1 ❑ (d) , ∃σ 2 ∈B❏ B 2 ❑ (d) s.t. σ ∈ σ 1 |{x 1 , ,x n ,δ}|σ 2 } 70 3 Basic Interleaved Semantic Models which returns the set of all traces that are in σ 1 |{x 1 , ,x n ,δ}|σ 2 for all possi- ble traces σ 1 in B❏ B 1 ❑ (d) and σ 2 in B❏ B 2 ❑ (d) . Thus, we determine the traces of B 1 and the traces of B 2 ; then we apply |{x 1 , ,x n ,δ}| to each possible pair of traces from the two. For each of these pairs, |{x 1 , ,x n ,δ}| derives the set of possible interleavings of the two traces subject to synchronisation on actions from {x 1 , ,x n ,δ}. Notice, in particular, that δ is included in this synchronisation set. This is because a parallel composition only success- fully terminates when both its constituent threads have terminated (see the discussion in Section 2.3.7). So, the central aspect of this definition is the mapping |{x 1 , ,x n ,δ}|;it is a function with the following type, |A| : T×T −→ P(T ) where A ⊆ Act ∪{δ} The operator is written infix, as σ 1 |A|σ 2 ,and,broadly,itdenotesthesetof possible interleavings of σ 1 and σ 2 that identify actions in A. The operator is defined as follows, where x, x  ∈ A, x = x  and y, y  ∈ A, σ 1 |A|σ 2  if (σ 1 = x.σ  1 ∧ σ 2 = ) ∨ (σ 1 =  ∧ σ 2 = x  .σ  2 ) ∨ (σ 1 = σ 2 = ) ∨ (σ 1 = x.σ  1 ∧ σ 2 = x  .σ  2 ) then {} otherwise { y.σ | σ ∈ σ  1 |A|σ 2 ∧ σ 1 = y.σ  1 }∪ { y  .σ | σ ∈ σ 1 |A|σ  2 ∧ σ 2 = y  .σ  2 }∪ { x.σ | σ ∈ σ  1 |A|σ  2 ∧ σ 1 = x.σ  1 ∧ σ 2 = x.σ  2 } This definition mirrors, in some respects, the operational semantics definition of parallel composition that we present in Section 3.3.2.2. The operator is best illustrated through an example. Consider the behaviour ( y ; x ; z ; stop ) |[x]| ( x ; w ; stop ) Evaluation of the two component behaviours yields the following two trace sets, { , y, yx, yxz} and { , x, xw} where the first is the trace set for the left-hand behaviour and the second is the trace set for the right-hand behaviour. Our definition of B❏ B 1 |[x 1 , ,x n ]| B 2 ❑ (d) would apply |{x}| to all possible pairings of traces from the two sets (in fact, it would apply |{x, δ}|, but because there is no exit in the original behaviour, δ can be safely ignored). The results of these applications are: 3.2 Trace Semantics 71 |{x}| = {} y|{x}| = {y} yx|{x}| = {y} yxz|{x}| = {y} |{x}|x = {} y|{x}|x = {y} yx|{x}|x = {yx} yxz|{x}|x = {yxz} |{x}|xw = {} y|{x}|xw = {y} yx|{x}|xw = yxz|{x}|xw = {yxw}{yxzw,yxwz} The definition of B❏ B 1 |[x 1 , ,x n ]| B 2 ❑ (d) accumulates traces from the sets, to yield B❏ y ; x ; z ; stop |[x]| x ; w ; stop ❑ (d) = { ,y,yx,yxz,yxw,yxzw,yxwz} as required. Hiding. We need an auxiliary operator in defining the semantics of hiding. Theoperatorisdenoted/ and it has the type: / : T×(Act ∪{δ}−→T) −→ T The operator is written infix and has two arguments: a trace and a function from actions to traces, which is total on Act ∪{δ}. The operator returns a new trace. Given that λ ∈ Act ∪{δ}−→T,thenσ/λ is defined as /λ   ∧ (x.σ  )/λ  λ(x).(σ  /λ) Thus, the application, σ/λ  where λ  (x)  if x = x i (1 ≤ i ≤ n) then σ i else x has the effect of searching along the trace σ and replacing every occurrence of an action x i with the trace σ i . The trace semantics for hiding derives all the traces from B and then removes all occurrences of the (to be hidden) actions x 1 , ,x n from the generated traces, by replacing x i with . B❏ hide x 1 , ,x n in B ❑ (d)  { σ/λ hide | σ ∈B❏ B ❑ (d) } where, λ hide (x)  if x = x i (1 ≤ i ≤ n) then  else x Relabelling. The semantics of relabelling follow very much the same lines as the semantics for hiding. However, rather than replacing actions with a null trace, we replace them with the required relabelling. B❏ B[y 1 /x 1 , ,y n /x n ] ❑ (d)  { σ/λ rel | σ ∈B❏ B ❑ (d) } where, λ rel (x)  if x = x i (1 ≤ i ≤ n) then y i else x Process Instantiation. The semantics of process instantiation are compli- 72 3 Basic Interleaved Semantic Models cated by the need to interpret recursion. In fact, we only give a partial def- inition of such behaviour, as the full semantics are relatively complex. In particular, we do not consider mutual recursion, i.e. indirect recursion result- ing from a series of process instantiations (although, generalisation to such definitions can easily be given) and our presentation is informal. A full formal treatment is beyond the scope of this book. Nonrecursive process definitions can be handled very easily; i.e. B❏ P ❑ (d)  B❏ B ❑ (d) where P := B is a definition in d and P is not referenced in B Notice that it is here, in defining the meaning of process instantiation, that we use the definitions contained in d.Thisrulestatesthatthemeaningofa process instantiation is the meaning of the corresponding process body. In contrast, the semantics of recursion (in fact, only direct recursion) is defined by B❏ P ❑ (d)   n∈N B❏ f n B (stop) ❑ (d) where P := f B (P ) is a definition in d Firstly, we have written the process definition in an unusual manner; viz, P := f B (P ) f B denotes a function, which takes a process instantiation and evaluates it in place in the body of B.Infact,f B can be thought of as a context corresponding to the behaviour B, with holes where P is referenced. Filling these holes corresponds to instantiating a behaviour in place for P. We can think of a recursion as generating a series of models, which are increasingly large; each successive model corresponds to a further unfolding of the recursive call. This series of models is infinite; i.e. we will keep on making recursive calls and increasing the size of the resulting model. We refer to such aseriesofmodelsasachain. The semantic model for this behaviour will have to be an infinite set; it will be an infinite set which contains all the models from all the recursive calls, i.e. every model in the chain. The expression:  n∈N B❏ f n B (stop) ❑ (d) (*) turns out to yield the least upper bound of this chain, i.e. a model which is larger than all elements in the chain, but does not contain more than is found in elements of the chain. It is the union of all models in the chain. The notation f n B is defined as follows. f 0 B (B  )  B  f 1 B (B  )  f B (B  ) f 2 B (B  )  f B (f B (B  )) [...]... P1 is matched by P2 =⇒ P2 and (P1 , P2 ) ∈ S 3 The abuse of notation here, whereby σ is used to denote both a trace and an internal action, does not cause any difficulties 92 3 Basic Interleaved Semantic Models P1 P2 P2 x 1 P1 2 P3 i 2 2 2 P2 P2 P3 y y (i) 1 P2 x x P1 x 1 1 P2 y P3 i i 3 P2 y 3 3 P2 P3 (ii) P1 x P3 x 1 P1 y 1 P3 i 2 P1 2 P3 y (iii) 3 P3 Fig 3. 8 Weak Bisimulation Relations and second,... 88 3 Basic Interleaved Semantic Models bisimulation between these two behaviours is very straightforward and all the states that are related are syntactically equal (i.e denote the same behaviour expression) apart from the root states This, however, is not always the case, as we show shortly P1 x z z P3 1 P1 1 P1 2 P2 x P2 2 y y P3 2 P2 1 (i) P3 x x 1 1 P3 y P1 y P2 3 z x x 3 1 P1 2 1 P3 y P1 (ii) P3... labelled transition system, (S, A, T, s0 ) 3. 3 .3 Development Relations 3. 3 .3. 1 Basic Equivalence Relations In some circumstances, labelled transition systems can be seen to be too discriminating For example, consider the following two pbLOTOS behaviours (these were highlighted in [148]), P1 := x ; y ; stop and P2 := ( x ; ( y ; stop [] y ; stop ) ) [] ( x ; y ; stop ) 86 3 Basic Interleaved Semantic Models... stop ) [] ( x ; y ; stop ) P3 := ( x ; y ; stop ) P4 := ( x ; ( y ; stop [] y ; stop ) ) [] ( x ; y ; stop ) P5 := ( x ; y ; stop ) [] ( x ; ( y ; stop [] y ; stop [] y ; stop ) ) We can identify strong bisimulation relations between a number of these behaviours For example, if we denote behaviours in the evaluation of these expressions as 2 3 1 3 2 3 4 3 4 P1 , P1 , P2 , P2 , P3 , P4 , P4 , P5 , P5 =... labelled transition systems depicted in Figure 3. 1 can more fully be depicted as in Figure 3. 2 3. 3 Labelled Transition Systems x x1 x x2 77 x x1 x2 Fig 3. 1 Labelled Transition Systems (Deterministic and Nondeterministic) x;(x1 ;stop [] x2 ;stop) x; x1 ;stop [] x; x 2 ;stop x x x1 ;stop [] x2 ;stop x1 stop x2 stop x1 ;stop x1 stop x x2 ;stop x2 stop Fig 3. 2 Labelled Transition System with States Explicitly... x 2 P4 y y 3 P3 P4 P4 4 P4 (iii) Fig 3. 6 Examples of Strong Bisimulation Relations It is also easy to locate two behaviours that cannot be related by a strong bisimulation For example, Figure 3. 6(ii) depicts an attempt to relate the states in the two behaviours P3 and P1 All states can be related apart from the root states We can show this by considering Condition (2) of Definition 4 z → 3 Specifically,... we can show that there is more than one strong bisimulation relation between the behaviours P4 and P5 ; Figure 3. 7 highlights two strong bisimulations for P4 and P5 P5 x 2 P5 1 P5 P4 x x 2 1 P4 P4 y y x y y 4 P5 3 P5 x 1 P5 P5 x x 2 P5 y y 3 P5 4 P4 3 P4 1 P4 P4 x 2 P4 y y 4 P5 3 P4 4 P4 Fig 3. 7 Two Strong Bisimulation Relations In general, there can be many strong bisimulation relations between pairs... bisimuσ lation between behaviours This uses a slight enhancement of the relation =⇒, σ ⇒ ⇒ which was introduced in Section 3. 3.2 .3 This is denoted =⇒ and formally, σ σ ⇒ ⇒ ⇒ B1 =⇒ B2 iff ( B1 =⇒ B2 ) ∨ ( B1 = B2 ∧ σ = i ) 3. 3 Labelled Transition Systems 91 Thus, σ ∈ (Act ∪ {δ})∗ or σ = i .3 Definition of this equivalence follows the same lines as that of strong bisimulation Thus, we begin by defining what it... P1 := y ; stop P2 := x ; stop P3 := ( x ; stop ) [] ( y ; stop ) P4 := hide y, z in ( ( y ; x ; z ; stop ) [] ( z ; x ; stop ) ) P5 := ( x ; y ; stop ) |[y]| ( z ; stop ) P6 := ( x ; y ; stop ) ||| ( z ; stop ) The following is a subset of the trace refinement relations amongst these behaviours P1 ≤tr P2 and P2 ≤tr P1 P1 ≤tr P3 and P2 ≤tr P3 P4 ≤tr P3 and P5 ≤tr P3 and P3 ≤tr P5 P2 ≤tr P6 and P4 ≤tr... 2 .3. 4 and, in particular, consider the illustration of these two behaviours in terms of black 78 3 Basic Interleaved Semantic Models boxes offering interactions at buttons Thus, branching time models, such as LTS, can distinguish different forms of choice, whereas trace semantics cannot 3. 3.2 Formal Semantics 3. 3.2.1 Preliminaries: Labelled Transition Systems We begin by giving a formal definition of a labelled . amongst these behaviours. P 1 ≤ tr P 2 and P 2 ≤ tr P 1 P 1 ≤ tr P 3 and P 2 ≤ tr P 3 P 4 ≤ tr P 3 and P 5 ≤ tr P 3 and P 3 ≤ tr P 5 P 2 ≤ tr P 6 and P 4 ≤ tr P 6 and P 5 ≤ tr P 6 You should. labelled transition systems depicted in Figure 3. 1 can more fully be depicted as in Figure 3. 2. 3. 3 Labelled Transition Systems 77 xx 1 2 x x x 1 x 2 x Fig. 3. 1. Labelled Transition Systems (Deterministic. notation that should be viewed as the same. 3. 3 Labelled Transition Systems 79 3. 3.2.2 An Operational Semantics for LOTOS The following rules define a, so-called, operational semantics for pbLOTOS. This