Process Algebra (2IF45) Expressiveness of BPArec Suzana Andova

Outline How far can we go with recursive specifications in BPArec(A)? How expressive is BPArec(A)? If it is not expressive as we want can we do better? How? Process Algebra (2IF45)

Recursive specs vs. Transition systems Every recursive specification in BPArec(A) has a solution that can be represented as an LTS For this purpose we use the SOS rules Sometimes we understand the process behaviour better from its LTS representation

Recursive specs vs. Transition systems But sometimes a process LTS has infinitely many states or infinitely many transitions a(i) i<10, b i10, c Symbolic (graphical) representation of the specification but this is not an LTS

Recursive specs vs. Transition systems LTSs are very simple but expressible language They can be finite or infinite, with countable or uncountable number of states or number of transitions The language defined with a given process algebra and its corresponding SOS semantics can specify a subset of LTSs A simple example: BPA(A) cannot be used to specify LTSs with time

Recursive specs vs. Transition systems Question: What sort LTSs are specifiable by recursive specifications in BPArec(A)?

Recursive specs vs. Transition systems Question: What sort LTSs are specifiable by recursive specifications in BPArec(A)? LTSs with finite number of states and finite number of transitions and no loops  closed BPA(A) terms Can we specify LTSs with countable number of states or countable number of transitions?

Recursive specs vs. Transition systems 2. Can we specify LTSs with countable number of states and countable number of transitions? l1: States x Act ↦ States States = Nat A = {a} l1(n,a) = n+1, n  Nat a … 3. Can we specify LTSs with uncountable number of states or uncountable number of transitions? l2: States x Act ↦ States States = [0,1] A = {a} l2(0,a) = r, r  [0,1] l2 is bisimilar to l3: States x Act ↦ States States = {s} A = {a} l3(s,a) = s a a

Expressivity of BPArec(A) Question: What sort LTSs are specifiable by recursive specifications in BPArec(A)? 2. Can we specify any LTSs with countable number of states and transitions? YES! 3. Can we specify any LTSs with uncountable number of states or transitions? NO! Theorem: Up to bisimulation, only LTSs with countable number of states and transitions, and only those are specifiable in BPArec(A).

Expressivity of BPArec(A) Example: 1 2 a 3 … n X = n1 a.a. … a.0 n Is this a proper recursive specification in BPArec(A)? NO!

Expressivity of BPArec(A) Example: S0 = a.S11 + S01 S01 = a.S21 + S02 S02 = a.S31 + S03 … S11 = 0 S21 = a.0 S31 = a.a.0 1 2 a 3 … n Is this a proper recursive specification in BPArec(A)?

Expressivity of BPArec(A) Example: S0 = a.S11 + S01 S01 = a.S21 + S02 S02 = a.S31 + S03 … S11 = 0 S21 = a.0 S31 = a.a.0 1 2 a 3 … n Is this a proper recursive specification in BPArec(A)? YES! This process is specifiable in BPArec(A)!

Expressivity of BPArec(A) Example: S0 = a.S11 + S01 S01 = a.S21 + S02 S02 = a.S31 + S03 … S11 = 0 S21 = a.0 S31 = a.a.0 Observe: It is an infinite rec. spec It is an unguarded rec. spec Some states are bisimilar but the root does not change 1 2 a 3 … n Is this a proper recursive specification in BPArec(A)? YES!

Expressivity of BPArec(A) Example: S0 = a.S11 + S01 S01 = a.S21 + S02 S02 = a.S31 + S03 … S11 = 0 S21 = a.0 S31 = a.a.0 Observe: It is an infinite rec. spec It is an unguarded rec. spec Some states are bisimilar but the root does not change 1 2 a 3 … n Is this a proper recursive specification in BPArec(A)? YES! Can we do better? Can we do guarded specification for this process? Can we do better? Can we do finite specification for this process?

Expressivity of BPArec(A) Example: S0 = a.S11 + S01 S01 = a.S21 + S02 S02 = a.S31 + S03 … S11 = 0 S21 = a.0 S31 = a.a.0 Observe: It is an infinite rec. spec It is an unguarded rec. spec Some states are bisimilar but the root does not change 1 2 a 3 … n Is this a proper recursive specification in BPArec(A)? YES! Can we do better? Can we do guarded specification for this process? NO! Can we do better? Can we do finite specification for this process? NO!

Expressivity of BPArec(A) Question: What sort LTSs are specifiable by guarded recursive specifications in BPArec(A)? Theorem: Up to bisimulation, only finitely branching processes/LTSs and only those are specifiable by a guarded recursive specification in BPArec(A).

Expressivity of BPArec(A): Definability Question: What sort LTSs are specifiable by guarded recursive specifications in BPArec(A)? Theorem: Up to bisimulation, only finitely branching processes/LTSs and only those are specifiable by a guarded recursive specification in BPArec(A). definable

Expressivity of BPArec(A): Definability Example: S0 = a.S11 + S01 S01 = a.S21 + S02 S02 = a.S31 + S03 … S11 = 0 S21 = a.0 S31 = a.a.0 Observe: It is an infinite rec. spec It is an unguarded rec. spec Some states are bisimilar but the root does not change It is infinitely branching 1 2 a 3 … n Can we do better? Can we do guarded specification for this process? NO! Can we do better? Can we do finite specification for this process? NO! This process is not definable in BPArec(A)!

Expressivity of BPArec(A):Stack example We consider a Stack with unlimited capacity Elements are taken from a finite set of data elements D = {d1, d2, …, dn} (n  N) Elements from D can be added to or removed from the top of the stack.

Expressivity of BPArec(A):Stack example We consider a Stack with unlimited capacity Elements are taken from a finite set of data elements D = {d1, d2, …, dn} (n  N) Elements from D can be added to or removed from the top of the stack. Steps: First, define the set of atomic actions. A = { push(d) | d  D }  {pop(d) | d  D } 2. How many recursive variables may be needed S  denotes the situation when the stack is empty S  denotes the state of the stack process when the content is   D*

Expressivity of BPArec(A):Stack example Atomic actions A = { push(d) | d  D }  {pop(d) | d  D } 2. recursive variables S  denotes the situation when the stack is empty S  denotes the state of the stack process when the content is   D* S = dD push(d).Sd, for any d D Sd = eD push(e).Sed + pop(d).S , for any d  D Sd = eD push(e).Sed + pop(d).S, for any d  D and   D*

Expressivity of BPArec(A):Stack example For D = {0,1} S = d{0,1} push(d).Sd, for any d {0,1}, Sd = eD{0,1} push(e).Sed + pop(d).S, for any d  {0,1,   {0,1}* S 1 11 01 10 00 pp(1) pp(0) ps(0) ps(1) … … … …

Expressivity of BPArec(A):Stack example For D = {0,1} S = d{0,1} push(d).Sd, for any d {0,1}, Sd = eD{0,1} push(e).Sed + pop(d).S, for any d  {0,1,   {0,1}* Observe: It is a nice guarded rec. spec S 1 11 01 10 00 pp(1) pp(0) ps(0) ps(1) … … … … This process is definable, therefore it is finitely branching

Expressivity of BPArec(A):Stack example For D = {0,1} S = d{0,1} push(d).Sd, for any d {0,1}, Sd = eD{0,1} push(e).Sed + pop(d).S, for any d  {0,1,   {0,1}* Observe: It is finitely branching S 1 11 01 10 00 pp(1) pp(0) ps(0) ps(1) … … … … There is a guarded spec defining this process

Expressivity of BPArec(A):Stack example For D = {0,1} S = d{0,1} push(d).Sd, for any d {0,1}, Sd = eD{0,1} push(e).Sed + pop(d).S, for any d  {0,1,   {0,1}* Observe: It is finitely branching S 1 11 01 10 00 pp(1) pp(0) ps(0) ps(1) … … … … There is a guarded spec defining this process Can we do better in BPArec(A)? Can we do finite spec?

Expressivity of BPArec(A):Stack example For D = {0,1} S = d{0,1} push(d).Sd, for any d {0,1}, Sd = eD{0,1} push(e).Sed + pop(d).S, for any d  {0,1,   {0,1}* Can we do better in BPArec(A)? Can we do finite spec? S 1 11 01 10 00 pp(1) pp(0) ps(0) ps(1) … … … … Observe: It has infinitely many states None of them are bisimilar Cannot be turned into a finite LTS

Expressivity of BPArec(A):Finite definability Question: What sort LTSs are specifiable by finite guarded recursive specifications in BPArec(A)? Theorem: Up to bisimulation, only processes with finitely many states and finitely many transitions and only those are definable by finite guarded recursive specifications in BPArec(A).

Expressivity of BPArec(A):Finite definability Question: What sort LTSs are specifiable by finite guarded recursive specifications in BPArec(A)? regular processes Theorem: Up to bisimulation, only processes with finitely many states and finitely many transitions and only those are definable by finite guarded recursive specifications in BPArec(A).

Expressivity of BPArec(A):Finite definability Question: What sort LTSs are specifiable by finite guarded recursive specifications in BPArec(A)? regular processes Theorem: Up to bisimulation, only processes with finitely many states and finitely many transitions and only those are definable by finite guarded recursive specifications in BPArec(A). finitely definable

Expressivity of BPArec(A):Finite definability For D = {0,1} S = d{0,1} push(d).Sd, for any d {0,1}, Sd = eD{0,1} push(e).Sed + pop(d).S, for any d  {0,1,   {0,1}* Can we do better in BPArec(A)? NO! Can we do finite spec? NO! S 1 11 01 10 00 pp(1) pp(0) ps(0) ps(1) … … … … Observe: It has infinitely many states None of them are bisimilar Cannot be turned into a finite LTS This is not a regular process There is no finite rec. spec. in BPArec(A) !

Expressivity of BPArec(A) Question: What do we need to add to BPArec(A) just sufficient that this is possible?

Expressivity of BPArec(A) Question: What do we need to add to BPArec(A) just sufficient that this is possible? Very simple extension: (general) sequential composition!

Theory of Sequential Processes TSP Process Algebra (2IF45)

TSPrec(A) = BPArec(A) + sequential composition Language: TSPrec(A) Signature: 0, 1, (a._ )aA, +, •, X Deduction rules for TSPrec(A): Axioms of BPArec(A): (A1) – (A4) (A5) (x+ y)  z = x  z+y  z (A6) (x  y)  z = x  (y  z) (A7) 0  x = 0 (A8) x  1 = x (A9) 1  x = x (A10) a.x  y = a.(x  y) a.x  x  a y (x + y)  ⑥ Process Algebra (2IF45)

TSPrec(A) = BPArec(A) + sequential composition Language: TSPrec(A) Signature: 0, 1, (a._ )aA, +, •, X Deduction rules for TSPrec(A): Axioms of TSPrec(A): (A1) – (A4) (A5) (x+ y)  z = x  z+y  z (A6) (x  y)  z = x  (y  z) (A7) 0  x = 0 (A8) x  1 = x (A9) 1  x = x (A10) a.x  y = a.(x  y) a.x  x  . . . a y (x + y)  ⑥ Deduction rules for sequential composition x  x’ x  y  x’ a x y  y’ x  y  y’ a   a a x y (x  y)   Process Algebra (2IF45)

TSPrec(A) = BPArec(A) + sequential composition Language: TSPrec(A) Signature: 0, 1, (a._ )aA, +, •, X Deduction rules for TSPrec(A): Axioms of TSPrec(A): (A1) – (A4) (A5) (x+ y)  z = x  z+y  z (A6) (x  y)  z = x  (y  z) (A7) 0  x = 0 (A8) x  1 = x (A9) 1  x = x (A10) a.x  y = a.(x  y) a.x  x  . . . a y (x + y)  ⑥ Deduction rules for sequential comosition x  x’ x  y  x’ a x y  y’ x  y  y’ a   a a x y (x  y)   Bisimilarity of LTSs Equality of terms Process Algebra (2IF45)

TSPrec(A) process algebra Congruence of bisimulation with respect to all operators in TSPrec(A) Elimination result: BPA(A) are still basic terms Soundness of TSPrec(A) with respect to the SOS semantic (term model) Ground completeness: bisimilarity between closed terms is derivable in TSP(A)

Stack process in TSPrec(A) Revise the Stack example: We consider a Stack with unlimited capacity Elements are taken from a finite set of data elements D = {d1, d2, …, dn} (n  N) Elements from D can be added to or removed from the top of the stack.

Stack process in TSPrec(A) Revision of the Stack example: We consider a Stack with unlimited capacity Elements are taken from a finite set of data elements D = {d1, d2, …, dn} (n  N) Elements from D can be added to or removed from the top of the stack. Stack2 = T T = dD push(d). ( U  pop(d).1)

Stack process in TSPrec(A) Revision of the Stack example: We consider a Stack with unlimited capacity Elements are taken from a finite set of data elements D = {d1, d2, …, dn} (n  N) Elements from D can be added to or removed from the top of the stack. Stack2 = T T = dD push(d). ( U  pop(d).1) U = 1 + T  U

Stack process in TSPrec(A) Stack1 = S S = dD push(d).Sd, for any d D Sd = eD push(e).Sed + pop(d).S, for any d  D and   D* Stack2 = T T = dD push(d). ( U  pop(d).1) U = 1 + T  U Is Stack1 = Stack2 ? YES! Can be proved using RDP+RSP principles*. *See the proof in the book

Expressivity of TSPrec(A) BSPrec(A) and TSPrec(A) in general are equally expressive! A process is definable in TSPrec(A) if and only if it is a solution of a guarded recursive spec.  the same as in BPSrec(A) Nevertheless in TSPrec(A) infinitely branching processes can be specified by a finite (unguarded) recursive spec. Example: X = X • (a.1) + a.1

Expressivity of TSPrec(A) Example 2: Consider recursive specification in TSPrec(A) X = a. (Y • a.1) Y = a. (Y • Z) + a.1 Z = a.1 + 1 Observe: the specification is guarded the process is finitely branching but “the degree of branching” is unbounded

Expressivity of TSPrec(A) Example 2: Consider recursive specification in TSPrec(A) X = a. (Y • a.1) Y = a. (Y • Z) + a.1 Z = a.1 + 1 Observe: the specification is guarded the process is finitely branching but “the degree of branching” is unbounded Results: In TSPrec(A) unbounded branching processes can be defined by a finite guarded specification This is not the case with BPArec(A)

What about the Bag process? Can we find any BPArec(A) or TSPrec(A) specification of the Bag process? Can we find any which is finite guarded specification? Or do we need to extend TSP(A) with more operators?