Topics in Concurrency

Transcription

1 Topics in Concurrency Lecture 3 Jonathan Hayman 18 February 2015

2 Recap: Syntax of CCS Expressions: Arithmetic a and Boolean b Processes: p ::= nil nil process (τ p) silent/internal action (α!a p) output (α?x p) input (b p) Boolean guard p 0 + p 1 non-deterministic choice p 0 p 1 parallel composition p\l restriction (L a set of channel identifiers) p[f ] relabelling (f a function on channel identifiers) P(a 1,, a k ) process identifier Process definitions: P(x 1,, x k ) def = p (free variables of p {x 1,, x n })

3 Towards a more basic language Aim: removal of variables to reveal symmetry of input and output Transitions for value-passing carry labels τ, α?n, α!n α?x p α?0 p[0/x] α?n p[n/x] This suggests introducing prefix α?n.p (as well as α!n.p) and view α?x p as a sum n α?n.p[n/x] infinite sum View α?n and α!n as complementary actions Synchronization can only occur on complementary actions

4 Pure CCS Actions: a, b, c,... Complementary actions: a, b, c,... Internal action: τ Notational convention: a = a Processes: p ::= λ.p prefix λ ranges over τ, a, a for any action a i I p i sum I is an indexing set p 0 p 1 parallel p\l restriction L a set of actions p[f ] relabelling f a function on actions P process identifier Process definitions: P def = p

5 Transition rules for pure CCS Nil process no rules Guarded processes Sum Parallel composition λ.p λ p λ p j p j I i I p λ i p 0 λ p 0 p λ 0 p 1 p 1 λ p 0 p 1 p λ 0 p 1 p 0 p 1 p0 p 1 p 0 a p 0 p 1 a p 1 p 0 p 1 τ p 0 p 1

6 Restriction Relabelling p λ p λ L L p \ L λ p \ L p λ p p[f ] f (λ) p [f ] where L = {a a L} where f is a function such that f (τ) = τ and f (a) = f (a) Identifiers p λ p P λ p P def = p

7 Transition systems Given a CCS process p, can construct its transition system A transition system is: (S, i, L, tran)

8 Transition systems Given a CCS process p, can construct its transition system A transition system is: initial state transition relation, tran S L S (S, i, L, tran) 6 set of states set of labels

9 Transition systems Given a CCS process p, can construct its transition system A transition system is: initial state transition relation, tran S L S (S, i, L, tran) 6 set of states set of labels Graphically: s t a c v b d u S = {s, t, u, v} i = s L = {a, b, c, d} tran = { (s, a, t), (s, b, u), (t, c, v), (u, d, v) }

10 Transition systems from CCS The transition system for a CCS process p has reachable terms as states and transitions as generated by the operational semantics Example: a.b.nil + b.a.nil Example: a b Example: a a Example: (a a) \ a Example: (a b)[f ] where f (a) = w and f (b) = w Example: a[f ] b[f ] where f (a) = w and f (b) = w Example: P where (note: dropped.nil) P Q def = a.q def = b.q + a.p

11 Realising transition systems Give pure CCS terms for: a b a a b a d a b

12 CCS operations on transition systems λ.p: λ.p λ p

13 CCS operations on transition systems λ.p: λ.p λ p p 0 + p 1 : p 0 α p 0 + p 1 α β p 1 β

14 a.b b: a b τ b b b a.b.nil b.nil a b

15 a.b b: a b τ b b b P where P def = p: a.b.nil b.nil p α a α b P

16 a.b b: a b τ b b b P where P def = p: a.b.nil b.nil p α a α b P p \ L, p[f ]:... A denotational semantics!

17 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p nil p nil

18 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p)

19 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p) (α!a p) αm. p where a evaluates to m

20 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p) (α!a p) αm. p where a evaluates to m (α?x p) m Num αm. p[m/x]

21 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p) (α!a p) αm. p where a evaluates to m (α?x p) m Num αm. p[m/x] (b p) p if b evaluates to true nil if b evaluates to false

22 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p) (α!a p) αm. p where a evaluates to m (α?x p) m Num αm. p[m/x] (b p) p if b evaluates to true nil if b evaluates to false p 0 + p 1 p 0 + p 1

23 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p) (α!a p) αm. p where a evaluates to m (α?x p) m Num αm. p[m/x] (b p) p if b evaluates to true nil if b evaluates to false p 0 + p 1 p 0 + p 1 p 0 p 1 p 0 p 1

24 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p) (α!a p) αm. p where a evaluates to m (α?x p) m Num αm. p[m/x] (b p) p if b evaluates to true nil if b evaluates to false p 0 + p 1 p 0 + p 1 p 0 p 1 p 0 p 1 p \ L p \ {αm α L & m Num}

25 From value-passing to pure A translation giving a pure CCS process p from a value-passing CCS closed term p p p nil nil (τ p) (τ. p) (α!a p) αm. p where a evaluates to m (α?x p) m Num αm. p[m/x] (b p) p if b evaluates to true nil if b evaluates to false p 0 + p 1 p 0 + p 1 p 0 p 1 p 0 p 1 p \ L p \ {αm α L & m Num} P(a 1,, a k ) P m1,,m k where a i evaluates to m i For every definition P(x 1,, x k ), we have a collection of definitions P m1,...,m k indexed by m 1,, m k Num.

26 Examples Let translate(p) = p: translate(α?x (x 5 (β!x nil))) = n Num αn.translate(x 5 (β!x nil))

27 Examples Let translate(p) = p: translate(α?x (x 5 (β!x nil))) = n Num αn.translate(x 5 (β!x nil)) translate(n 5 (β!n nil)) = { βn.nil if n 5 nil if n 5

28 Correspondence Theorem p λ p implies p λ p if p λ q then there exist p, κ such that p κ p and λ = κ and q = p where α?n = αn and α!n = αn

29 Recursion: an alternative Instead of a process we can use with rule P where P def = p rec(p = p) p[rec(p = p)/p] λ p rec(p = p) λ p Example: rec(p = a.nil + b.p)

30 Recursion: an alternative Instead of a process we can use the notation and for Q we can use P where P def = p and Q = q rec 1 (P = p, Q = q) rec 2 (P = p, Q = q)

31 Recursion: an alternative Instead of a process we can use the notation and for Q we can use P where P def = p and Q = q rec 1 (P = p, Q = q) rec 2 (P = p, Q = q) Generally, instead of P j where P i = p i is a collection of definitions indexed by i I, can use rec j (P i = p i ) i I which is also written rec j ( P = p)

32 Proofs of correctness By satisfying formulas in a logic By satisfying an equivalence