based on Unfoldings

pigeoneggtrainsΔίκτυα και Επικοινωνίες

24 Οκτ 2013 (πριν από 3 χρόνια και 9 μήνες)

83 εμφανίσεις

Modular Processings

based on Unfoldings

Eric Fabre & Agnes Madalinski

DistribCom Team

Irisa/Inria

UFO workshop
-

June 26, 2007



Assembling Petri nets

products, pullbacks, unfoldings and trellises



Modular computations

on a constraint graph : an abstract viewpoint




Application 1: modular diagnosis

or modular computation of a minimal product covering



Application 2: modular prefixes

or how to compute a FCP directly in factorized form



Conclusion


Outline

Nets as Products of Automata


Caution

: in this talk, for simplicity


we limit ourselves to safe Petri nets,

although most results extend to ½ weighted nets


we represent safe nets in “complemented” form,

i.e. their number of tokens remains constant



Building bloc: a
site

or
variable V



= labeled automaton


labeling of transitions


V
= (
S
,
T
,s
0
,

,
¸
,
¤
)

¸
: T


¤

Nets as Products of Automata
(2)


Composition of variables by product :


disjoint union

of places


transitions with shared labels are “glued”


transitions with private labels don’t change

S =
V
1
£

V
2

£

V
3


This product yields a safe (labeled) nets,

and extends to safe nets

Interest of Product Forms


The 1
st

interests are


a natural construction method starting from modules


the compactness of the product form


on this example, the expanded product contains
m*n

transitions, instead of
m+n

in the factorized form

Composition by Pullback


Generalizes the product


allows interactions of nets by an interface (sub
-
net)


outside the interface, interactions are still by shared labels

S =
V
1
£

V
2
£

V
3

= (
V
1
£
V
2
)
Æ

(
V
2
£
V
3
)


Main property

Graph of a Product Net


Interaction graph of a net


shared labels define the local interactions…









… but it’s better to re
-
express interactions under the form of
shared variables (or sub
-
nets).

S =
V
1
£


£

V
n

V
1
£

V
2
£

V
3

= (
V
1
£
V
2
)
Æ

(
V
2
£
V
3
)


= S
1

Æ
S
2


Translation in terms of
pullbacks


define
components

S
i

in order to “cover” the shared labels

Unfoldings in Factorized Form


The key =
Universal Property

of the unfolding of S


Let denote the unfolding of S,

and its associated folding (labeling)




8
O,
8
Á
:O

S,
9
!
Ã
:O

U
(S),
Á
= f
S

±

Ã

f
S
:
U
(S)

S

U
(S)


Consequences:


functor has a left adjoint,

and thus preserves products, pullbacks, …










U

U
(S) =
U
(S
1
)
£
O


£
O

U
(S
n
)

S = S
1
£


£

S
n

)

U
(S) =
U
(S
1
)
Æ
O


Æ
O

U
(S
m
)

S = S
1

Æ


Æ

S
m

)

Unfoldings in Factorized Form
(2)


Example:

U
(S) =
U
(
V
1
)
£
O

U
(
V
2
)
£
O

U
(
V
3
)

S =
V
1
£
V
2
£
V
3


)

Important properties


The category theory approach naturally provides


an expression for operators (and )


recursive procedures

to compute them (as for unfoldings)


notions of
projections

associated to products/pullbacks:

£
O

Æ
O

¦
S
i
:
U
(S)


U
(S
i
)

Important properties


The category theory approach naturally provides


an expression for operators (and )


recursive procedures

to compute them (as for unfoldings)


notions of
projections

associated to products/pullbacks:

£
O

Æ
O

¦
S
i
:
U
(S)


U
(S
i
)

Important properties


The category theory approach naturally provides


an expression for operators (and )


recursive procedures

to compute them (as for unfoldings)


notions of
projections

associated to products/pullbacks:

£
O

Æ
O

¦
S
i
:
U
(S)


U
(S
i
)

Important properties


The category theory approach naturally provides


an expression for operators (and )


recursive procedures

to compute them (as for unfoldings)


notions of
projections

associated to products/pullbacks:

£
O

Æ
O

¦
S
i
:
U
(S)


U
(S
i
)

Important properties
(2)


Thm

let O
i

be an occ. net of component S
i
,

then is an occ. net of


define then

and this is the
minimal product covering

of O



O=O
1
£
O

£
O

O
n

S=S
1
£

£
S
n

O’
i

=
¦
S
i
(O)
v

O
i

O=O’
1
£
O

£
O

O’
n


The
reduced

occurrence nets


represent the behaviors of component S
i

that remain

once S
i

is inserted in the global system S


or the local view in each component S
i

of the behaviors of the
global system S


are interesting objects !


O’
i

v

O
i


Factorized forms of unfoldings are often more compact…

…but they can however contain useless parts.


Trellises in Factorized Form


The trellis of net S is


obtained by merging conditions of with identical height


a close cousin of merged processes
(Khomenko
et al.,

2005)

T
(S)

U
(S)

time is counted

independently in each V
i

for S = V
1
£


£

V
n

Trellises in Factorized Form


The trellis of net S is


obtained by merging conditions of with identical height


a close cousin of merged processes
(Khomenko
et al.,

2005)


enjoys exactly the same factorization properties as unfoldings

T
(S) =
T
(S
1
)
£
T


£
T

T
(S
n
)

S = S
1
£


£

S
n

)

T
(S) =
T
(S
1
)
Æ
T


Æ
T

T
(S
m
)

S = S
1

Æ


Æ

S
m

)

T
(S)

U
(S)



Assembling Petri nets

products, pullbacks, unfoldings and trellises



Modular computations

on a constraint graph : an abstract viewpoint




Application 1: modular diagnosis

or modular computation of a minimal product covering



Application 2: modular prefixes

or how to compute a FCP directly in factorized form



Conclusion


Outline

S
2

S
3

S
4

“Abstract” Constraint Reduction


Ingredients :


variables


“systems” or “components” S
i


defined by (local) constraints on



V
max

= {
V
1
,
V
2
,…}

V
i

µ

{
V
1
,…,V
n
}

S
1

V
1

V
5

V
3

V
2

V
7

V
6

V
4

V
8

S = S
1
Æ
S
2


a composition operator (conjunction)

“Abstract” Constraint Reduction
(2)


Reductions:


for , reduces constraints of S to variables V


reductions are projections



V
µ
V
max

¦
V
(S)

¦
V
1

±

¦
V
2

=
¦
V
1
Å
V
2


Central axiom
:


S
1

operates on V
1
, S
2

operates on V
2


let then


i.e.

all interactions go through shared variables

V
3


V
1
Å
V
2

¦
V
3
(S
1
Æ
S
2
) =
¦
V
3
(S
1
)
Æ
¦
V
3
(S
2
)

Modular reduction algorithms


Problem :


Given where S
i

operates on V
i



compute the reduced components


i.e.
how does S
i

change once inserted into the global S ?


S = S
1
Æ



Æ

S
n

S’
i

=
¦
V
i
(S)


This can be solved by
Message Passing Algorithms

(MPA)










always converges


only involves local computations


exact if the graph of S is a (hyper
-
) tree

Modular reduction algorithms


Problem :


Given where S
i

operates on V
i



compute the reduced components


i.e.
how does S
i

change once inserted into the global S ?


S = S
1
Æ



Æ

S
n

S’
i

=
¦
V
i
(S)


This can be solved by
Message Passing Algorithms

(MPA)










always converges


only involves local computations


exact if the graph of S is a (hyper
-
) tree

Modular reduction algorithms


Problem :


Given where S
i

operates on V
i



compute the reduced components


i.e.
how does S
i

change once inserted into the global S ?


S = S
1
Æ



Æ

S
n

S’
i

=
¦
V
i
(S)


This can be solved by
Message Passing Algorithms

(MPA)










always converges


only involves local computations


exact if the graph of S is a (hyper
-
) tree

Modular reduction algorithms


Problem :


Given where S
i

operates on V
i



compute the reduced components


i.e.
how does S
i

change once inserted into the global S ?


S = S
1
Æ



Æ

S
n

S’
i

=
¦
V
i
(S)


This can be solved by
Message Passing Algorithms

(MPA)










always converges


only involves local computations


exact if the graph of S is a (hyper
-
) tree

Modular reduction algorithms


Problem :


Given where S
i

operates on V
i



compute the reduced components


i.e.
how does S
i

change once inserted into the global S ?


S = S
1
Æ



Æ

S
n

S’
i

=
¦
V
i
(S)


This can be solved by
Message Passing Algorithms

(MPA)










always converges


only involves local computations


exact if the graph of S is a (hyper
-
) tree

Modular reduction algorithms


Problem :


Given where S
i

operates on V
i



compute the reduced components


i.e.
how does S
i

change once inserted into the global S ?


S = S
1
Æ



Æ

S
n

S’
i

=
¦
V
i
(S)


This can be solved by
Message Passing Algorithms

(MPA)










always converges


only involves local computations


exact if the graph of S is a (hyper
-
) tree

What about systems with loops ?


Message passing algorithms


converge to a unique fix point
(independent of message scheduling)


that gives an upper approximation:





How good are their results ?


Local extendibility to any tree around each component.









¦
V
i
(S)
v

S’
i

v

S
i

What about systems with loops ?


Message passing algorithms


converge to a unique fix point
(independent of message scheduling)


that gives an upper approximation:





How good are their results ?


Local extendibility to any tree around each component.









¦
V
i
(S)
v

S’
i

v

S
i



Assembling Petri nets

products, pullbacks, unfoldings and trellises



Modular computations

on a constraint graph : an abstract viewpoint




Application 1: modular diagnosis

or modular computation of a minimal product covering



Application 2: modular prefixes

or how to compute a FCP directly in factorized form



Conclusion


Outline

centralized supervizor

Distributed system monitoring…

ab c

b b

a b

c

aa

distributed supervision


Consider the net

and move to trajectory sets
(unfolding or trellis)



In the category of occurrence nets
(for ex.),

we have


a composition operator, the pullback


trajectories of S are in factorized form




we have projection operators on occ. nets,

where V
i

are the variables of S
i



Thm:
projections and pullback satisfy the central axiom


(here we cheat a little however…)


We are already equipped for that !

Æ
O

S = S
1

Æ


Æ

S
m

U
(S) =
U
(S
1
)
Æ
O


Æ
O

U
(S
m
)

¦
V
i

A computation example

A computation example

A computation example

A computation example

A computation example

A computation example



Assembling Petri nets

products, pullbacks, unfoldings and trellises



Modular computations

on a constraint graph : an abstract viewpoint




Application 1: modular diagnosis

or modular computation of a minimal product covering



Application 2: modular prefixes

or how to compute a FCP directly in factorized form



Conclusion


Outline

Objective


Given

compute a finite complete prefix of in factorized form



Obvious solution:


compute a FCP of


then compute its minimal pullback covering



where


S = S
1

Æ


Æ

S
m

U
(S)

U
s
(S)

U
(S)

U
s
(S)
v

U
’(S
1
)
Æ

Æ U
’(S
m
)

U
’(S
i
) =
¦
V
i
(
U
s
(S))


but this imposes to work on the global unfolding…

… we rather want to
obtain directly the factorized form

Local canonical prefixes don’t work


Canonical prefix


defined by a
cutting context


Θ = ( ~ ,


, {
κ
e
}
e

E

)


~
equivalence relation on
Conf




set of reachable markings




adequate order on
Conf




partial order on
Conf

refining inclusion



{
κ
e
}
e

E
a subset of
Conf
,




configurations used for cut
-
off identification



cut
-
off

event

Extended canonical prefix


Toy example :


two components, elementary interface (=automaton)

S =
A
£
C
£
B

= (
A
£
C
)
Æ
(
C
£
B
)


= S
A

Æ

S
B

interface

Extended canonical prefix
(2)


extended prefix of w.r.t. its interface
C



restriction of the cutting context
Θ
C

= (~,

, {
κ
e
}
e

E

)

to

particular configurations
κ
e










e cut
-
off event, corresponding event e’ :

κ
e
~
κ
e’

and
κ
e’


κ
e

where usually
κ
e
=[e]


if e

is a

private event, then
P
C

(
κ
e

κ
e’
)=Ø


if e is an interface event, then e’ is also an interface event



S
A

where


is the symmetric set difference

Extended cut
-
off event

e : extended cut
-
off

e’ : interface event

Summary net


Summary net =


behaviors allowed by an extended prefix on the interface:


obtained by projecting the extended prefix on the interface,


and refolding matching markings

merge

Distributed computations

augmented

prefixes

Distributed computations

extract

summary nets

Distributed computations


exchange

summary nets

Distributed computations

build

pullbacks

Distributed computations

construct

prefixes

Distributed computations

Killed in the pullback

Local factors are a little too conservative

(not the minimal pullback covering of the FCP)



Assembling Petri nets

products, pullbacks, unfoldings and trellises



Modular computations

on a constraint graph : an abstract viewpoint




Application 1: modular diagnosis

or modular computation of a minimal product covering



Application 2: modular prefixes

or how to compute a FCP directly in factorized form



Conclusion

Outline

A few lessons…


Factorized forms of unfoldings are generally more compact.


One can work directly on them, in an efficient modular
manner, without ever having to compute anything global.


Optimal when component graphs are trees.


Sub
-
optimal, but provide “good” upper approximations
otherwise.

…and some questions


Finite complete prefixes in factorized form:

we need to understand better how to compute them,

and provide complexity results.


Can this be useful for model checking?


Can this be useful for distributed optimal planning?

(see last talk today)