On the Expressive Power of Temporal Concurrent Constraint Programming Languages

1
On the Expressive Power of Temporal Concurrent
Constraint Programming Languages

• Mogens Nielsen, BRICS
• Catuscia Palamidessi, INRIA
• Frank Valencia, BRICS

2
Plan of the talk

• Introduction to timed ccp (tcc)
• Various tcc dialects
• iteration / recursion,
• parameters yes / no,
• Non local vars yes / no
• static / dynamic scope
• Equivalence results
• Recursion, static scope, no pars lt-gt Replication
• Recursion, dynamic scope, no pars lt-gt Recursion,
  pars
• Separation results
• The first class is strictly less expressive than
  the second class

3
Timed ccp

• Ccp Panangaden, Rinard, Saraswat 1991
• processes communicate via a common store of
  constraints

y gt x
ask(ygt0)
tell(x1)
4
Timed ccp

• tcc Saraswat, Jagadeesan, Gupta, 1994
• variant of deterministic ccp to program
  reactive systems
• time is divided in discrete intervals (time
  units)
• in each time unit a process receives a stimulus
  (initial store) and it computes till it reaches a
  resting point. The final store is the response.

response
stimulus
time unit
5
Timed ccp

• Syntax of tcc
• Finite processes
• P skip tell(c) when c do P
  PQ
• (local x) P next P unless c
  next P
• c represents a constraint
• when is tcc for ask
• local x is tcc for the existential
• next refers to the next time interval

6
Timed ccp

• Operational semantics of tcc
• Configuration ( P, c )
• Transition rules
• (tell(c), d) (skip, c and d)

process
store
( P, c ) ( P, d )
( PQ, c ) ( P Q, d )
d - c
( Q, c ) ( Q, d )
(when c do P, d) (P, d)
( PQ, c ) ( P Q, d )
7
Timed ccp

• Transition rules (cont.ed)

( P, c and Ex d) ( P, c and Ex d)
( (local x,c) P, d ) ( (local x,c), d
and Ex c )
d - c
Future function F(next P)
P F(unless c next P) P F(when c do P)
skip F(P Q) F(P) F(Q) F((local x) P)
(local x) F(P)
(unless c next P, d) (skip, d)
( P, c ) ( Q, d )
( P, c ) (F(Q), d )
8
Timed ccp

• Operators for infinite behavior
• Iteration ! P
• Recursion A(x) P
• syntactic restrictions ensure
• that a process stops after a finite
• number of steps in each time unit
• Locality rule for static scope
• the standard ccp rule (shown
• before) induces dynamic scope

(! P, c) (P next ! P, c )
(Py/x, c) (Q, d )
(A(y), c) (Q, d )
y fresh
((local x) P, c ) (Py/x , d )
9
Timed ccp

• Dynamic scope vs Static scope
• Example Let A be defined as
• A tell(x1)
  P
• Consider the process (local x)
• Classic rule The x in As def is captured by the
  scope of (local x)
• ((local x) A,true) ((local x) tell(x1)
  P, true) ((local x, x1) P, true)
• New rule The first step eliminates (local x)
• ((local x) A,true) ( A , true)
  (tell(x1) P, true) ( P, x1 )

10
Timed ccp

• Example
• A tell(light off)
• unless (toggle_switch) next A
• when (toggle_switch) do next B
• B tell(light on)
• unless(toggle_switch) next B
• when(toggle_switch) do next A

t
t
p
t
off
off
on
on
on
on
off
11
Timed ccp

• Observables and equivalences
• Stimulus-response (or input-output) relation
• io(P) (c1.c2.c3, d1.d2.d3 ) (P,
  c1) (P1, d1)
• 
  (P1, c2) (P2, d2)
• 
  (P2, c3) (P3, d3)
• 
  
• Equivalence P eq Q iff io(P) io(Q)

c1
c5
c4
d1
d2
d4
d3
d5
c2
c3
12
Variants of tcc

• Based on finite tcc

13
The tcc hierarchy
Undecidable
inclusion
recp
recd
encoding
Decidable
rep
reci
recs
rec0
14
Undecidability of recp

• The equivalence of processes in recp is
  undecidable. In fact, it is possible to reduce
  the Post Correspondence Problem (PCP) to the
  problem of non-equivalence between recp
  processes.
• Post Correspondence Problem
• Given two sets of words V v0, v1, v2, and
  W w0, w1, w2, on a generic alphabet
  containing at least two symbols, the PCP consists
  in finding a sequence of indexes i0,i1,i2, such
  that vi0.vi1.vi2. wi0.wi1.wi2.
• Given V, W, we define two processes A and B such
  that the PCP (V, W) has a solution iff it is not
  the case that A eq B

15
Undecidability of recp

• wait c do P when c do P unless c next
  wait c do P
• repeat Q Q next repeat Q
• Wi(x) P klt wi nextk tell(x wik)
• Vi(x) P klt vi nextk tell(x vik)
• Ai(b1,b2, ind,x) (local
  a1,a2,ichosen)
• wait
  b11 do (Wi(x)
• 
  nextwi (tell(b10) tell(a11) )
• wait b21 do (Vi(x)
• 
  nextvi (tell(b20) tell(a21) )
• P j in I when indexj do (tell(ichosen1)
  
• Aj(a1,a2,index,x) )
• Abort(ichosen)
• Abort(ichosen) unless ichosen1 next
  repeat tell(false)
• when false do repeat tell(false)

16
Undecidability of recp
b10 b20

index 3
index 2
index 1
v3
v1
v0
w0
w1
w3

• The symbols of vis and wjs are checked at
  every time interval, and if they do not
  correspond then we get an inconsistency (abort)
• The sequence 0, 3, 1 is a solution for the PCP
  for (V,W).

17
Undecidability of recp

• Bi(b1,b2, ind, x, ok) (local
  a1,a2,ichosen)
• wait b11 do
  (Wi(x)
• 
  nextwi (tell(b10) tell(a11) )
• wait b21 do (Vi(x)
• 
  nextvi (tell(b20) tell(a21) )
• P j in I when indexj do (tell(ichosen1))
  
• Bj(a1,a2,index,x) )
• Abort(ichosen)
• wait b10 and b20 do tell(ok1)
• A(ind,x) (local b1 b2) tell(b11)
  tell(b21) A0(b1,b2,ind,x)
• B(ind,x,ok) (local b1 b2) tell(b11)
  tell(b21) B0(b1,b2,ind,x,ok)

18
Undecidability of recp

• A(index,x) eq B(index,x,ok) iff the tell(ok1)
  in Bi is never executed, namely iff it is never
  the case that b1 0 and b2 0 at the same
  time. But this holds iff the answer to the PCP
  for (V,W) is negative.
• Since the PCP is undecidable, also the question
  whether P eq Q is undecidable.

19
Decidability of rep

• The key idea is to encode the processes of rep in
  Buchi automata in such a way that the
  stimulus-response behavior can be retrieved from
  the language accepted by the automaton
• Buchi automata are finite automata equipped with
  an acceptance condition that is appropriate for
  (w-) infinite sequences A sequence is accepted
  by the automaton iff the automaton can read it
  from left to right while visiting a sequence of
  states in which some final state occurs
  infinitely often.

aw is not in the language (ab)w and bw are in the
language
a
a
a
b
Language equivalence of Buchi Automata is
decidable
b
b
20
Construction of the finite automata for P,Q

• Relevant constraints of W P1,,Pn all
  constraints that
• can be constructed from constraints in P1,,Pn.
  Formally
• RC(skip) true
• RC(tell(c)) c
• RC(when c do P) RC(unless c next P) c U
  RC(P)
• RC(P Q) RC(P) U RC(Q)
• RC(!P) RC(next P) RC(P)
• RC((local x) P) Ex c , Ax c) c in
  Closure(RC(P))
• RC(W) And_Closure( Closure(RC(P1 ) ) U U
  Closure(RC(Pn )) )
• Lemma 1 RC(W) is finite
• Lemma 2 For P in W, (P,c) (P,c and d)
  
• iff (P,c(W)) (P,c(W) and d)
• where c(W) max d in C(W) c - d
• (it always exists because RC(W) is
  and-closed)

c
c(W)
RC(W)
21
Construction of the finite automata for P, Q

• Let S be the set of relevant constraints for W
  P, Q
• Derivatives of P wrt S P (P,c)
  (P,c), c in S /,
• where is the smallest congruence containing P
  P P
• Lemma There are finitely many derivatives of P
  wrt S
• The automaton for P (the one for Q is analogous)
• States The derivatives of P wrt S
• Arcs (c,d) in RC(W) x RC(W) is and arc from P
  to P iff
• (P,c) (R,d) and P R
• Theorem P eq Q iff the automaton corresponding
  to P and Q are language-equivalent

22
Separation between rep and rec0

• This separation is rather obvious in rec0 a
  process can be active through infinitely many
  time units, but eventually it will stop producing
  information, because recursion contains neither
  parameters, nor local variables, hence processes
  cannot communicate with the external world
• For instance, (truew,(x1)w) is not in io(P) for
  any P in rec0 . In general the max number of
  steps during which info on x can be produced is
  not greater than the max number of nested next
  operators in whose scope x occurs free (not
  existentially quantified)
• In rep it is possible to expess such io behavior
  ! tell(x1)

23
Expressiveness Equivalences
Undecidable
inclusion
recp
recd
encoding
Decidable
rep
reci
recs
rec0
24
Encoding rep in reci

• ! P RP(x)
• with procedure definition RP(x) P next
  RP(x)
• and x fv(P)
• is homomorphic in all other operators
• Example
• ! tell(x1) R(x)
• with R(x) tell(x1) next R(x)

25
Encoding recs in rep

• P (local zA1 zAn) ( P Pi Ai
  Pi )
• Ai Pi ! when call(zAi) do P
• Ai tell( call(zAi) )
• (local x) P (local y) ( P y/x )
  with y fresh
• The other operators are translated
  homomorphically
• Example
• A tell(x1) A
• A (local z) (tell(call(zA))) ! when
  call(zA) do
• ( tell(x1) tell(call(zA)) )
  

26
Encoding rep in recs

• This encoding uses the representation of rep
  processes as Buchi Automata
• Let P be in rep and let A be the Buchi automaton
  associated to it (considering the relevant
  constraints of P only)
• Given a state Q of A, define
• AQ P(Q, c) gt(Q,d) when c do ( (tell(d)
• 
  unless e next AR) )
• where e V c c / c, c - c and (Q,
  c) gt(Q,d)

27
Encoding recd in recp

• A P A(x) P
• where x fv(P)
• A A(x)
• All the other operators are homomorphic

28
Encoding recp in recd

• A(x) P A P
• A(y) (local x) (A repeat tell(xy))
• All the other operators are homomorphic

29
Conclusion and future work

• Various expressiveness results (positive and
  negative)
• for various tcc dialects
• The fact that we are in a timed framework does
  not seem to play a crucial role. Do the results
  hold also in (deterministic) ccp?
• The equivalence between recd and recp holds also
  in det ccp
• We dont know about the separation results
  (although we feel they still hold)
• The other results involve rep and we should first
  define ! P in a non-timed context ( ! P P !
  P is not interesting in deterministic ccp)
• Does static vs dynamic scope make a difference
  also in other concurrent languages, for instance
  ccs? And how about replication vs recursion?