Docstoc

Petri Nets - Sesar Lab

Document Sample
Petri Nets - Sesar Lab Powered By Docstoc
					            Petri nets
Classical Petri nets: The basic model




                                        1
Process modeling
• Emphasis on dynamic behavior rather than
  structuring the state space
• Transition system is too low level
• We start with the classical Petri net
• Then we extend it with:
  – Color
  – Time
  – Hierarchy




                                             2
Classical Petri net
• Simple process model
  – Just three elements: places, transitions and arcs.
  – Graphical and mathematical description.
  – Formal semantics and allows for analysis.
• History:
  – Carl Adam Petri (1962, PhD thesis)‫‏‬
  – In sixties and seventies focus mainly on theory.
  – Since eighties also focus on tools and applications (cf.
    CPN work by Kurt Jensen).
  – “Hidden”‫‏‬in‫‏‬many‫‏‬diagramming‫‏‬techniques‫‏‬and‫‏‬
    systems.


                                                         3
                                            p4
                                                       place




Elements                              t34        t43   transition

 (name)                                     p3



          place

                                      t23        t32

                                            p2
 (name)   transition
                                                       token



          arc (directed connection)
                                      t12        t21

          token                             p1




                                      t01        t10

                                            p0



                                                               4
                                  free

Rules

    wait    enter   before   make_picture   after   leave   gone




                               occupied




•   Connections are directed.
•   No connections between two places or two transitions.
•   Places may hold zero or more tokens.
•   First, we consider the case of at most one arc between
    two nodes.

                                                                   5
Enabled
• A transition is enabled if each of its input places
  contains at least one token.
                                free




   wait   enter   before   make_picture   after     leave   gone




                             occupied



enabled                                     Not               Not
                                          enabled           enabled
                                                                   6
Firing
• An enabled transition can fire (i.e., it occurs).
• When it fires it consumes a token from each
  input place and produces a token for each
  output place.         free

fired

  wait   enter   before   make_picture   after   leave   gone




                            occupied




                                                           7
       Play‫“‏‬Token‫‏‬Game”
       • In the new state, make_picture is enabled. It will fire, etc.
                                       free




wait         enter       before   make_picture   after     leave         gone




                                    occupied




                                                                   8
Remarks
• Firing is atomic.
• Multiple transitions may be enabled, but only one
  fires at a time, i.e., we assume interleaving
  semantics (cf. diamond rule).
• The number of tokens may vary if there are
  transitions for which the number of input places is
  not equal to the number of output places.
• The network is static.
• The state is represented by the distribution of
  tokens over places (also referred to as marking).

                                                 9
                            p4                                p4

  Non-determinism
                      t34        t43                    t34         t43

                            p3                                p3




                      t23        t32                    t23         t32
                                       transition t23
                            p2             fires              p2




                      t12        t21                    t12         t21

                            p1                                p1


Two transitions are
enabled but only
                      t01        t10                    t01         t10
one can fire                p0                                p0




                                                                   10
Example: Single traffic light    rg




                                      green




                           red   go




                                      orange




                                 or



                                         11
 Two traffic lights                                 rg




       rg                  rg

                                                          green

            green               green




red    go            red   go

                                         OR   red   go


            orange              orange




                                                         orange
       or                  or




                                                    or



                                                         12
Problem




          13
  Solution
                   rg1            rg2




                         g1             g2




              r1   go1        x   go2        r2




How to make              o1             o2
them
alternate?
                   or1            or2


                                             14
Playing‫‏‬the‫“‏‬Token‫‏‬Game”‫‏‬on‫‏‬the‫‏‬Internet
• Applet to build your own Petri nets and execute
  them:
  http://www.tm.tue.nl/it/staff/wvdaalst/Downloads/
  pn_applet/pn_applet.html
• FLASH animations:
  http://www.tm.tue.nl/it/staff/wvdaalst/courses/pm
  /flash/




                                                15
Exercise: Train system (1)‫‏‬
• Consider a circular railroad system with 4 (one-
  way) tracks (1,2,3,4) and 2 trains (A,B). No two
  trains should be at the same track at the same
  time and we do not care about the identities of
  the two trains.




                                                16
Exercise: Train system (2)‫‏‬
• Consider a railroad system with 4 tracks
  (1,2,3,4) and 2 trains (A,B). No two trains should
  be at the same track at the same time and we
  want to distinguish the two trains.




                                                 17
Exercise: Train system (3)‫‏‬
• Consider a railroad system with 4 tracks
  (1,2,3,4) and 2 trains (A,B). No two trains should
  be at the same track at the same time.
  Moreover the next track should also be free to
  allow for a safe distance. (We do not care about
  train identities.)‫‏‬




                                                 18
Exercise: Train system (4)‫‏‬
• Consider a railroad system with 4 tracks
  (1,2,3,4) and 2 trains. Tracks are free, busy or
  claimed. Trains need to claim the next track
  before entering.




                                                 19
      WARNING
It is not sufficient to understand the
  (process) models. You have to be
     able to design them yourself !
                                    20
Multiple arcs connecting two nodes
• The number of arcs between an input place and
  a transition determines the number of tokens
  required to be enabled.
• The number of arcs determines the number of
  tokens to be consumed/produced.
                              free




 wait   enter   before   make_picture   after   leave   gone




                                                         21
Example: Ball game

       red                black

                     rb




       rr                  bb




                                  22
Exercise: Manufacturing a chair
• Model the manufacturing of
  a chair from its components:
  2 front legs, 2 back legs, 3
  cross bars, 1 seat frame,
  and 1 seat cushion as a
  Petri net.
• Select some sensible
  assembly order.
• Reverse logistics?


                                  23
Exercise: Burning alcohol.
• Model C2H5OH + 3 * O2 => 2 * CO2 + 3 * H2O
• Assume that there are two steps: first each
  molecule is disassembled into its atoms and
  then these atoms are assembled into other
  molecules.




                                                24
   Exercise: Manufacturing a car
   • Model the production process shown in the Bill-
     Of-Materials.
                         car
subassembly2
                               engine
         2
chair
                     subassembly1
                     4
   chassis                 wheel


                                                  25
Formal definition
A classical Petri net is a four-tuple (P,T,I,O)
  where:
• P is a finite set of places,
• T is a finite set of transitions,
• I : P x T -> N is the input function, and
• O : T x P -> N is the output function.

Any diagram can be mapped onto such a four
 tuple and vice versa.

                                                  26
Formal definition (2)‫‏‬
The state (marking) of a Petri net (P,T,I,O) is
  defined as follows:
• s: P-> N, i.e., a function mapping the set of
  places‫‏‬onto‫.}‏…‏,2,1,0{‏‬




                                                  27
Exercise: Map onto (P,T,I,O) and S


        red                black

                   rb




         rr                 bb




                                     28
Exercise: Draw diagram
Petri net (P,T,I,O):
• P = {a,b,c,d}
• T = {e,f}
• I(a,e)=1, I(b,e)=2, I(c,e)=0, I(d,e)=0, I(a,f)=0,
  I(b,f)=0, I(c,f)=1, I(d,f)=0.
• O(e,a)=0, O(e,b)=0, O(e,c)=1, O(e,d)=0,
  O(f,a)=0, O(f,b)=2, O(f,c)=0, O(f,d)=3.
State s:
• s(a)=1, s(b)=2, s(c)=0, s(d) = 0.

                                                      29
Enabling formalized
Transition t is enabled in state s1 if and only if:




                                                      30
Firing formalized
If transition t is enabled in state s1, it can fire and
   the resulting state is s2 :




                                                      31
Mapping Petri nets onto transition systems
A Petri net (P,T,I,O) defines the following
  transition system (S,TR):




                                              32
Reachability graph
•   The reachability graph of a Petri net is the part
    of the transition system reachable from the
    initial state in graph-like notation.
•   The reachability graph can be calculated as
    follows:
     1. Let X be the set containing just the initial state and let Y
        be the empty set.
     2. Take an element x of X and add this to Y. Calculate all
        states reachable for x by firing some enabled transition.
        Each successor state that is not in Y is added to X.
     3. If X is empty stop, otherwise goto 2.


                                                                  33
     Example
red                       black

               rb                       (3,2)‫‏‬      (3,1)‫‏‬      (3,0)‫‏‬


                                        (1,3)‫‏‬      (1,2)‫‏‬      (1,1)‫‏‬
rr                         bb



                                                                (1,0)‫‏‬
     Nodes in the reachability graph can be represented by a
     vector‫‏”)2,3(“‏‬or‫‏‬as‫ 3“‏‬red + 2 black”.‫‏‬The‫‏‬latter‫‏‬is‫‏‬useful‫‏‬for‫‏‬
     “sparse‫‏‬states”‫(‏‬i.e.,‫‏‬few‫‏‬places‫‏‬are‫‏‬marked).

                                                                    34
Exercise: Give the reachability graph using
both notations
               rg1            rg2




                     g1             g2




        r1     go1        x   go2        r2




                     o1             o2




               or1            or2




                                              35
Different types of states
• Initial state: Initial distribution of tokens.
• Reachable state: Reachable from initial state.
• Final state (also‫‏‬referred‫‏‬to‫‏‬as‫“‏‬dead‫‏‬states”):‫‏‬
  No transition is enabled.
• Home state (also referred to as home marking):
  It is always possible to return (i.e., it is
  reachable from any reachable state).

How to recognize these states in the reachability
 graph?

                                                36
Exercise: Producers and consumers
• Model a process with one producer and one
  consumer, both are either busy or free and
  alternate between these two states. After every
  production cycle the producer puts a product in
  a buffer. The consumer consumes one product
  from this buffer per cycle.
• Give the reachability graph and indicate the final
  states.
• How to model 4 producers and 3 consumers
  connected through a single buffer?
• How to limit the size of the buffer to 4?

                                                 37
Exercise: Two switches
• Consider a room with two switches and one
  light. The light is on or off. The switches are in
  state up or down. At any time any of the
  switches can be used to turn the light on or off.
• Model this as a Petri net.
• Give the reachability graph.




                                                   38
Modeling
•   Place: passive element
•   Transition: active element
•   Arc: causal relation
•   Token: elements subject to change

The state (space) of a process/system is modeled
 by places and tokens and state transitions are
 modeled by transitions (cf. transition systems).



                                              39
Role of a token
Tokens can play the following roles:
• a physical object, for example a product, a part, a drug,
  a person;
• an information object, for example a message, a
  signal, a report;
• a collection of objects, for example a truck with
  products, a warehouse with parts, or an address file;
• an indicator of a state, for example the indicator of the
  state in which a process is, or the state of an object;
• an indicator of a condition: the presence of a token
  indicates whether a certain condition is fulfilled.

                                                        40
Role of a place
• a type of communication medium, like a
  telephone line, a middleman, or a
  communication network;
• a buffer: for example, a depot, a queue or a
  post bin;
• a geographical location, like a place in a
  warehouse, office or hospital;
• a possible state or state condition: for
  example, the floor where an elevator is, or the
  condition that a specialist is available.


                                                    41
Role of a transition
• an event: for example, starting an operation, the
  death of a patient, a change seasons or the
  switching of a traffic light from red to green;
• a transformation of an object, like adapting a
  product, updating a database, or updating a
  document;
• a transport of an object: for example,
  transporting goods, or sending a file.



                                                42
Typical network structures
•   Causality
•   Parallelism (AND-split - AND-join)‫‏‬
•   Choice (XOR-split – XOR-join)‫‏‬
•   Iteration (XOR-join - XOR-split)‫‏‬
•   Capacity constraints
    – Feedback loop
    – Mutual exclusion
    – Alternating



                                          43
Causality




            44
Parallelism




              45
Parallelism: AND-split




                         46
Parallelism: AND-join




                        47
Choice: XOR-split




                    48
Choice: XOR-join




                   49
Iteration: 1 or more times




                        XOR-join before XOR-split

                                                50
Iteration: 0 or more times




                        XOR-join before XOR-split

                                                51
Capacity constraints: feedback loop




                       AND-join before AND-split

                                               52
Capacity constraints: mutual exclusion




                         AND-join before AND-split
                                              53
Capacity constraints: alternating




                          AND-join before AND-split
                                               54
  We have seen most patterns, e.g.:
                      rg1            rg2
Example of
mutual
exclusion                   g1             g2




              r1      go1        x   go2        r2




How to make
                            o1             o2
them
alternate?
                      or1            or2


                                                55
   Exercise: Manufacturing a car (2)
                                 • Model the production
                                   process shown in the
                                   Bill-Of-Materials with
                      car          resources.
subassembly2                     • Each assembly step
                            engine requires a dedicated
                                   machine and an
         2                         operator.
chair                            • There are two operators
                   subassembly1    and one machine of
                    4              each type.
   chassis               wheel • Hint: model both the
                                   start and completion of
                                   an assembly step.
                                                   56
Modeling problem (1): Zero testing
• Transition t should fire if place p is empty.



                          t         ?

                         p


                                                  57
Solution
• Only works if place is N-bounded

  N input and
                        t        Initially there
  output arcs                     are N tokens

                   p’


                        p

                                                   58
Modeling problem (2): Priority
• Transition t1 has priority over t2


                  t1
 ?
                   t2

                          Hint: similar to Zero testing!
                                                   59
A bit of theory
• Extensions have been proposed to tackle these
  problems, e.g., inhibitor arcs.
• These extensions extend the modeling power
  (Turing completeness*).
• Without such an extension not Turing complete.
• Still certain questions are difficult/expensive to
  answer or even undecidable (e.g., equivalence
  of two nets).

* Turing completeness corresponds to the ability to execute any
  computation.

                                                            60
Exercise: Witness statements
• As part of the process of handling insurance
  claims there is the handling of witness
  statements.
• There may be 0-10 witnesses per claim. After
  an initialization step (one per claim), each of the
  witnesses is registered, contacted, and informed
  (i.e., 0-10 per claim in parallel). Only after all
  witness statements have been processed a
  report is made (one per claim).
• Model this in terms of a Petri net.

                                                  61
Exercise: Dining philosophers
• 5 philosophers sharing 5 chopsticks: chopsticks are
  located in-between philosophers
• A philosopher is either in state eating or thinking and
  needs two chopsticks to eat.
• Model as a Petri net.




                                                            62
            High level Petri nets
 Extending classical Petri nets with color,
time and hierarchy (informal introduction)‫‏‬

             Prof.dr.ir. Wil van der Aalst
Eindhoven University of Technology, Faculty of Technology Management,
 Department of Information and Technology, P.O.Box 513, NL-5600 MB,
                     Eindhoven, The Netherlands.




                                                                        63
Limitations of classical Petri nets
•   Inability to test for zero tokens in a place.
•   Models tend to become large.
•   Models cannot reflect temporal aspects
•   No support for structuring large models, cf. top-
    down and bottom-up design




                                                   64
Inability to test for zero tokens in a place



                        t          ?

                      p

                  “Tricks”‫‏‬only‫‏‬work‫‏‬if‫‏‬p‫‏‬is‫‏‬bounded

                                                       65
Models tend to become (too) large
 r1           r2           r3           r4              r5




      incr1        incr2        incr3        incr4           incr5




                   wheel         bell        steering
       bike                                                  frame
                                              wheel




      decr1        decr2        decr3        decr4           decr5


                                                                     Size linear in the
                                                                        number of
 l1           l2           l3           l4              l5
                                                                         products.

                                                                                 66
Models tend to become (too) large (2)‫‏‬
          1
          b             2
                        b             3
                                      b             4
                                                    b

rn r
   f
tase           rn r
                  f
               tase          tase
                             rn r
                                f          rn r
                                              f
                                           tase


          1
          c             2
                        c             3
                                      c             4
                                                    c

lm c
 a t r
c i _ak


          1
          f             2
                        f             3
                                      f             4
                                                    f
              lm c
               a t
              c i _ak
                   r         a t
                            c i _ak
                            lm c r        lm c
                                          c i _ak
                                           a t r




                                           Size linear in the
                                           number of tracks.


                                                        67
  Models cannot reflect temporal aspects
                    rg1            rg2




                          g1             g2




               r1   go1        x   go2        r2




Duration of each          o1             o2

 phase is highly
    relevant.
                    or1            or2


                                                   68
No support for structuring large models
                   rg1            rg2




                         g1             g2




          r1       go1        x   go2        r2




                         o1             o2




                   or1            or2


                                                  69
High-level Petri nets
• To tackle the problems identified.
• Petri nets extended with:
  – Color (i.e., data)‫‏‬
  – Time
  – Hierarchy
• For the time being be do not choose a concrete
  language but focus on the main concepts.
• Later we focus on a concrete language: CPN.
• These concepts are supported by many variants
  of CPN including ExSpect, CPN AMI, etc.

                                             70
Running example: Making punch cards
                     free            free desk
                                    employees
  wait                                      done

             start               stop




                     busy

  waiting                                   served
  patients            patient/             patients
                     employees

                                                   71
Extension with color (1)‫‏‬
• Tokens have a color (i.e., a data value)‫‏‬

{Brand="BMW", RegistrationNo="GD-XW-11", Year=1993, Colour="blue", Owner= "Inge"}




     {Brand="Lada", RegistrationNo="PH-14-PX", Year=1986, Color="grey", Owner="Inge"}




                                                                              72
Extension with color (2)‫‏‬
• Places are typed (also referred to as color set).

  record Brand:string * RegistrationNo:string * Year:int *
  Color:string * Owner:string

    {Brand="BMW", RegistrationNo="GD-XW-11", Year=1993, Colour="blue", Owner= "Inge"}




         {Brand="Lada", RegistrationNo="PH-14-PX", Year=1986, Color="grey", Owner="Inge"}




                                                                                            73
Extension with color (3)‫‏‬
• The relation between production and
  consumption needs to be specified, i.e., the
  value of a produced token needs to be related
  to the values of consumed tokens.
             3
        in                      sum

  2               add                        0
  3


             1          The value of the token produced for
                        place sum is the sum of the values of
                                the consumed tokens.
                                                        74
Running example: Tokens are colored

                              {EmpNo=641112, Experience=7}




 wait                                                       done
                               free
                start                        stop




                              busy
 {Name="Klaas", Address="Plein 10", DateOfBirth="13-Dec-1962", Gender="M"}




                                                                         75
Running example: Places are typed
           record EmpNo:int * Experience:int

   wait                                      done
                        free
             start                 stop


                                     record Name:string *
 record Name:string *
                                          Address:string *
 Address:string *       busy
 DateOfBirth:str * record Name:string * DateOfBirth:str *
                   Address:string *         Gender:string
 Gender:string
                   DateOfBirth:str *
                   Gender:string *
                   EmpNo:int *
                   Experience:int
                                                     76
Running example: Initial state
                             {EmpNo=641112, Experience=7}




 wait                                                      done
                              free
               start                        stop




                             busy
{Name="Klaas", Address="Plein 10", DateOfBirth="13-Dec-1962", Gender="M"}


                                                   start is enabled

                                                                      77
    Running example: Transition start fired
               New value is created by simply merging the two records.


    wait                                                     done
                                 free
                  start                        stop




                                busy


{Name="Klaas", Address="Plein 10", DateOfBirth="13-Dec-1962", Gender="M", EmpNo=641112, Experience=7}




                                                                    stop is enabled

                                                                                         78
 Running example: Transition stop fired
                                      {EmpNo=641112, Experience=7}




     wait                                                      done
                                  free
                    start                        stop




                                  busy
  {Name="Klaas", Address="Plein 10", DateOfBirth="13-Dec-1962", Gender="M"}



New values are created by simply spliting the record into two parts.


                                                                              79
The number of tokens produced is no longer
fixed (1)‫‏‬
       {sample_number=931101011, measurement_outcomes="XYV"}



                                             positive


                       test

         sample
                                            negative



          {sample_number=931101023, measurement_outcomes="VXY"}


 Note that the network structure is no longer a complete
 specification!

                                                                  80
The number of tokens produced is no longer
fixed (2)‫‏‬
       {sample_number=931101011, measurement_outcomes="XYV"}



                                             positive


                       test

         sample
                                            negative


 The number of tokens produced for each output place is
 between 0 and 3 and the sum should be 3.

                                                           81
              r1           r2           r3           r4              r5


Example

                   incr1        incr2        incr3        incr4           incr5




                                wheel         bell        steering
                    bike                                                  frame
                                                           wheel




                   decr1        decr2        decr3        decr4           decr5




              l1           l2           l3           l4              l5




Model as a colored Petri net.

                                                                            82
                                in

                                      {prod="bell", num=2}

  Product and
 quantity are in
the value of the     increase

     token
                                      [{prod="bike", num=4},
                      stock           {prod="wheel", num=2},
    The entire                        {prod="bell", number=3},
                                      {prod="steering wheel", num=3},
      stock is                        {prod="frame", num=2}]

represented by
                     decrease
 the value of a
  single token,
   i.e., a list of
      records.
                                out

                                                                 83
                                           in

                                                     {prod="bell", num=2}
   Types
                                                 StockItem

                                increase




                                                     [{prod="bike", num=4},
                                 stock               {prod="wheel", num=2},
                                                     {prod="bell", number=3},
                                                     {prod="steering wheel", num=3},
color Product = string;          Stock               {prod="frame", num=2}]


color Number = int;             decrease

color StockItem = record
prod:Product * num:Number;
color Stock = list StockItem;                    StockItem
                                           out

                                                                                84
Extension with time (1)‫‏‬
• Each token has a timestamp.
• The timestamp specifies the earliest time when
  it can be consumed.
                     2     5




                                             85
 Extension with time (2)‫‏‬
• The enabling time of a transition is the maximum
  of the tokens to be consumed.
• If there are multiple tokens in a place, the earliest
  ones are consumed first.
• A transition with the smallest firing time will fire first.
• Transitions are eager, i.e., they fire as soon as they
  can.
• Produced token may have a delay.
• The timestamp of a produced token is the firing
  time plus its delay.

                                                        86
Running example: Enabling time
• Transition start is enabled at time 2 =
  max{0,min{2,4,4}}.
                          0

              4

       wait                                 done
   2                      free
                  start            stop



         4

                          busy




                                                   87
Running example: Delays
• Tokens for place busy get a delay of 3
• @+3 = firing time plus 3 time units
                               0

             4
                                      @+0
      wait                                               done
  2                            free
                 start                      stop
                         @+3                       @+0

        4

                               busy

                                                          88
Running example: Transition start fired
• Transition start fired a time 2.

         4

  wait                             @+0                done
                            free
              start                      stop
                      @+3                       @+0

                                     5
    4

                            busy


                      Continue‫‏‬to‫‏‬play‫(‏‬timed)‫‏‬token‫‏‬game…

                                                             89
Exercise: Final state?
                   a               d

             1           x
                             @+1

             3     b


            5


                   c               e

                         y
                             @+2


                   4


                                       90
Exercise: Final state?

               3

         red                         black
                   @+2
   1                                         4
                          rb
   2                                         2


                               @+1
                         @+1
          rr                          bb




                                                 91
Extension with hierarchy
• Timed and colored Petri nets result in more
  compact models.
• However, for complex systems/processes the
  model does not fit on a single page.
• Moreover, putting things at the same level does
  not reflect the structure of the process/system.
• Many hierarchy concepts are possible. In this
  course we restrict ourselves to transition
  refinement.


                                                92
Instead of        rg1            rg2




                        g1             g2




             r1   go1        x   go2             r2




                        o1             o2




                  or1            or2



                                            93
We can use hierarchy         tl1                tl2

                                        x




                       rg1                            rg2




                              g1                            g2




                r1     go1                            go2             r2

                                    x       x




                               o1                           o2




                       or1                            or2




                                                                 94
                       tl1                        tl2
Reuse
                                      x


• Reuse saves design
  efforts.                       rg


• Hierarchy can have
  any number of                               g

  levels
• Transition
                                 go                     r
  refinement can be          x

  used for top-down
  and bottom-up                           o

  design
                                 or

                                                            95
Exercise: model three (parallel) punch card
desks in a hierarchical manner


                     free


     wait                           done

             start          stop




                     busy




                                           96
   Analysis of Process Models:
Reachability graphs, invariants, and simulation



             Prof.dr.ir. Wil van der Aalst
Eindhoven University of Technology, Faculty of Technology Management,
 Department of Information and Technology, P.O.Box 513, NL-5600 MB,
                     Eindhoven, The Netherlands.




                                                                        97
Questions raised when considering the
handling of customer orders
• How many orders arrive on average?
• How many orders can be handled?
• Do orders get lost?
• Do back orders always have priority?
• What is the utilization of office workers?
• If the desired product is no longer available,
  does the order get stuck?
• Etc.


                                                   98
Questions raised when considering the
handling of customers in the canteen
• What is the average waiting time from 12.30-
  13.00?
• What is the variance of waiting times?
• What is the effect of an additional cashier on the
  queue length?
• Etc.




                                                 99
Questions raised when considering the an
intersection with multiple traffic lights
• How much traffic can be handled per hour?
• Give some volume of traffic, what is the
  probability to get a red light?
• Is the intersection safe, i.e., crossing flows have
  never a green light at the same time?
• Can a light go from yellow to green?
• Is the intersection fair (i.e., a traffic
  light cannot turn green twice while
  cars are waiting on the other side)?

                                                  100
Questions raised when considering a printer
shared by multiple users
• Can two print jobs get mixed?
• Do small jobs always get priority?
• Can the settings of one job influence the next
  job?
• Do out-of-paper events cause jobs
  to get lost?
• How many jobs can be handled per
  day?
• What is the probability of a paper jam?

                                                   101
Questions raised when considering a teller
machine
• What is the average response time?
• Is there a balance, i.e., the amount of money
  leaving the machine matches the amount taken
  from bank accounts?
• How often should the machine be filled
  to guarantee 90% availability?
• Is fraud possible?
• Etc.


                                             102
Analysis
                                             • Analysis is typically model-
                                               driven to allow e.g. what-if
                                               questions.
                                             • Models of both operational
 Operational process                           processes and/or the
                               Information
                                 System        information systems can be
                                               analyzed.
                                             • Types of analysis:
                       Model                   – validation
                                               – verification
                                               – performance analysis

                                                                      103
Three analysis techniques (Chapter 8)‫‏‬
• Reachability graph
• Place & transition invariants
• Simulation

• Each can be applied to both classical and high-level Petri
  nets. Nevertheless, for the first two we restrict ourselves to
  the classical Petri nets.
• Use:
   – reachability graph (validation, verification)‫‏‬
   – invariants (validation, verification)‫‏‬
   – simulation (validation, performance analysis)‫‏‬



                                                                   104
     Reachability graph

         rg1            rg2




                                        (0,0,1,1,0,0,0)‫‏‬   (1,0,0,0,0,1,0)‫‏‬
               g1             g2




r1       go1        x   go2        r2
                                                 (1,0,0,1,0,0,1)‫‏‬

               o1             o2




                                        (0,1,0,1,0,0,0)‫‏‬   (1,0,0,0,1,0,0)‫‏‬
         or1            or2



                                          Five reachable states.
                                          Traffic lights are safe!
                                                                     105
     Alternative notation

         rg1            rg2




                                        o1+r2             r1+o2
               g1             g2




r1       go1        x   go2        r2
                                                r1+r2+x

               o1             o2




                                        g1+r2             r1+g2
         or1            or2




                                                              106
Reachability graph (2)‫‏‬
• Graph containing a node for each reachable
  state.
• Constructed by starting in the initial state,
  calculate all directly reachable states, etc.
• Expensive technique.
• Only feasible if finitely many states (otherwise
  use coverability graph).
• Difficult to generate diagnostic information.



                                                     107
Infinite reachability graph
                   rg1            rg2




                         g1             g2




          r1       go1        x   go2        r2




                         o1             o2




                   or1            or2



                                                  108
 Exercise: Construct reachability graph

                             free




wait   enter   before   make_picture   after   leave   gone




                          occupied




                                                       109
Exercise: Dining philosophers (1)‫‏‬
• 5 philosophers sharing 5 chopsticks: chopsticks are
  located in-between philosophers
• A philosopher is either in state eating or thinking and
  needs two chopsticks to eat.
• Model as a Petri net.




                                                            110
Exercise: Dining philosophers (2)‫‏‬
• Assume that philosophers take the chopsticks one by
  one such that first the right-hand one is taken and then
  the left-hand one.
• Model as a Petri net.
• Is there a deadlock?




                                                         111
Exercise: Dining philosophers (3)‫‏‬
• Assume that philosopher take the chopsticks one by one
  in any order and with the ability to return a chopstick.
• Model as a Petri net.
• Is there a deadlock?




                                                       112
Structural analysis techniques
• To avoid state-explosion problem and bad
  diagnostics.
• Properties independent of initial state.
• We only consider place and transition
  invariants.
• Invariants can be computed using linear
  algebraic techniques.




                                             113
    Place invariant
              man                 • Assigns a weight to
                                    each place.
                                  • The weight of a
             couple                 token depends on
marriage                divorce
                                    the weight of the
                                    place.
             woman                • The weighted
                                    token sum is
                                    invariant, i.e., no
                                    transition can
1 man + 1 woman + 2 couple          change it

                                                    114
           Other invariants
                                        • 1 man + 0 woman + 1 couple
                  man
                                        (Also denoted as: man + couple)‫‏‬
                                        • 2 man + 3 woman + 5 couple
                  couple
                                        • -2 man + 3 woman + couple
marriage                      divorce
                                        • man – woman
                                        • woman – man
                  woman                 (Any linear combination of
                                          invariants is an invariant.)‫‏‬




                                                                  115
     Example: traffic light
        rg1            rg2
                                       •   r1 + g1 + o1
                                       •   r2 + g2 + o2
              g1             g2
                                       •   r1 + r2 + g1 + g2 + o1 + o2
                                       •   x + g1 + o1 + g2 + o2
r1      go1        x   go2        r2
                                       •   r1 + r2 - x

              o1             o2




        or1            or2




                                                                  116
Exercise: Give place invariants
    start_production                  start_consumption




   free          producer             wait        consumer




                            product




     end_production                    end_consumption


                                                             117
    Transition invariant
                                        • Assigns a weight to
               man                        each transition.
                                        • If each transition
                                          fires the number of
               couple                     times indicated, the
marriage                      divorce     system is back in
                                          the initial state.
               woman                    • I.e. transition
                                          invariants indicate
                                          potential firing sets
                                          without any net
     2 marriage + 2 divorce               effect.

                                                            118
           Other invariants
                                        • 1 marriage + 1 divorce
                  man
                                        (Also denoted as: marriage +
                                          divorce)‫‏‬
                                        • 20 marriage + 20 divorce
                  couple
                                        Any linear combination of
marriage                      divorce
                                          invariants is an invariant, but
                                          transition invariants with
                  woman
                                          negative weights have no
                                          obvious meaning.
                                        Invariants may be not be
                                          realizable.


                                                                     119
     Example: traffic light
        rg1            rg2
                                       • rg1 + go1 + or1
                                       • rg2 + go2 + or2
              g1             g2
                                       • rg1 + rg2 + go1 + go2 + or1
                                         + or2
r1      go1        x   go2        r2   • 4 rg1 + 3 rg2 + 4 go1 +
                                         3 go2 + 4 or1 + 3 or2
              o1             o2




        or1            or2




                                                               120
Exercise: Give transition invariants
    start_production                  start_consumption




   free          producer             wait        consumer




                            product




     end_production                    end_consumption


                                                             121
Exercise: four philosophers
                            st1
                                                         • Give place
                       e1     t1
                                                           invariants.
                            se1
                                                         • Give
                 c4                c1
                                                           transition
      t4                                      e2           invariants
st4        se4                          se2        st2
      e4                                      t2

                  c3               c2


                            se3

                       t3     e3


                            st3

                                                                         122
Two ways of calculating invariants
• "Intuitive way": Formulate the property that you
  think holds and verify it.
• "Linear-algebraic way": Solve a system of linear
  equations.

Humans tend to do it the intuitive way and
 computers do it the linear-algebraic way.




                                                123
                                         man
Incidence matrix of a Petri net
• Each row corresponds to                couple
  a place.
                           marriage                 divorce
• Each column corresponds
  to a transition.                      woman

• Recall that a Petri net is
  described by (P,T,I,O).
• N(p,t)=O(t,p)-I(p,t) where
  p is a place and t a                   −1 1
  transition.                         N= −1 1
                                          1 −1
                                                  124
                                   man
                      woman              marriage
   Example
             man




             couple                −1 1
marriage              divorce
                                N= −1 1
             woman
                                    1 −1

                                couple   divorce

                                                   125
Place invariant
• Let N be the incidence matrix of a net with n
  places and m transitions
• Any solution of the equation X.N = 0 is a
  transition invariant
  – X is a row vector (i.e., 1 x n matrix)‫‏‬
  – O is a row vector (i.e., 1 x m matrix)‫‏‬
• Note that (0,0,... 0) is always a place invariant.
• Basis can be calculated in polynomial time.



                                                   126
           Example                 −1 1
                                 X − 1 1 = 0,0
               man




                                    1 −1
              couple

marriage               divorce



              woman



                                        Solutions:
                                        • (0,0,0)‫‏‬
                       −1 1             • (1,0,1)‫‏‬
     man,woman, couple − 1 1 = 0,0      • (0,1,1)‫‏‬
                        1 −1            • (1,1,2)‫‏‬
                                        • (1,-1,0)‫‏‬
                                                      127
Transition invariant
• Let N be the incidence matrix of a net with n
  places and m transitions
• Any solution of the equation N.X = 0 is a place
  invariant
  – X is a column vector (i.e., m x 1 matrix)‫‏‬
  – 0 is a column vector (i.e., n x 1 matrix)‫‏‬
• Note that (0,0,... 0)T is always a place invariant.
• Basis can be calculated in polynomial time.



                                                   128
           Example               −1 1    0
                                 −1 1 X= 0
               man




                                  1 −1
              couple

marriage



              woman
                       divorce
                                         0

             −1 1             0       Solutions:
                   marriage           • (0,0)T
             −1 1           = 0
                    divorce           • (1,1)T
              1 −1            0       • (32,32)T


                                                   129
            start_production                  start_consumption


Exercise
           free          producer             wait        consumer




                                    product




             end_production                    end_consumption

• Give incidence matrix.
• Calculate/check place invariants.
• Calculate/check transition invariants.

                                                            130
Simulation
• Most widely used analysis technique.
• From a technical point of view just a "walk" in
  the reachability graph.
• By making many "walks" (in case of transient
  behavior) or a very "long walk" (in case of
  steady-state) behavior, it is possible to make
  reliable statements about properties/
  performance indicators.
• Used for validation and performance analysis.
• Cannot be used to prove correctness!


                                                    131
Stochastic process
• Simulation of a deterministic system is not very
  interesting.
• Simulation of an untimed system is not interesting.
• In a timed and non-deterministic system, durations
  and probabilities are described by some
  probability distribution.
• In other words, we simulate a stochastic
  process!
• CPN allows for the use of distributions using some
  internal random generator.


                                                132
Uniform distribution




       pdf             cumulative




                                    133
Negative exponential distribution




                                    134
Normal distribution




                      135
Distributions in CPN Tools
Assume some library with functions:
• uniform(x,y)‫‏‬
• nexp(x)‫‏‬
• erlang(n,x)‫‏‬
• Etc.

A nice function is also C.ran() which returns a randomly
  selected element of finite color set C, e.g.,
  color C = int with 1..5;
  fun select1to5() = C.ran()
  returns a number between 1 and 5

                                                           136
Example



    color BT = unit;
    color Dice = int with 1..6;


             ()      ()
                                               Dice.ran()

trigger      BT     ()            throw_dice          outcome   Dice




                                                                  137
Example(2)‫‏‬


   color INT = int;
   color TINT = int timed;
   color Dice = int with 1..6;
   color Delay = int with 0..99;
               0      x            throw_dice
trigger                                         Dice.ran()

 TINT                                                   outcome   Dice
            (x+1)@+(Delay.ran())




                                                                    138
Subruns and confidence intervals
• A single run does not provide information about
  reliability of results.
• Therefore, multiple runs or one run cut into
  parts: subruns.
• If the subruns are assumed to be mutually
  independent, one can calculate a confidence
  interval, e.g., the flow time is with 95%
  confidence within the interval 5.5+/-0.5 (i.e.
  [5,6]).


                                               139
Example of a simulation model
• Gas station with one pump and space for 4 cars
  (3 waiting and 1 being served).
• Service time: uniform distribution between 2 and
  5 minutes.
• Poisson arrival process with mean time between
  arrivals of 4 minutes.
• If there are more than 3 cars waiting, the "sale"
  is lost.
• Questions: flow time, waiting time, utilization,
  lost sales, etc.


                                                140
    Top-level page: main
color Car = string

                              arrive    Car
                      HS                      HS




               environment                    gas_station



                             drive_on   Car



                              depart    Car



                                                     141
                                                                             In


                                                                    arrive                 Car
                                                                            c              c
  Subpage gas_station                          [len(q)<3]                                             [len(q)>=3]

                                       put_in_queue                                                             drive_on
                                                                                  q
color Car = string;                                                 q^^[c]
                                                           q
                                                                                  q
color Pump = unit;                                                   []
color TCar = Car timed;
color Queue = list Car;                             queue             Queue
var c:Car;                                                  q        c::q
var q:Queue;
fun len(q:Queue) = if q=[] then 0                  start
 else 1+len(tl(q));
                                    c@+uniform(2,5)                          ()                       c

                                                                pump_free             ()

                                         fill_up      TCar                        Pump
                                                      c                     ()

                                                   end

                                                                c
                                                          Out                                  Out



                                                          depart      Car                  drive_on       Car


                                                                                                           142
Assuming pages for the environment and
measurements the last two pages allow for ...
• Calculation of flow time (average, variance,
  maximum, minimum, service level, etc.).
• Calculation of waiting times (average, variance,
  maximum, minimum, service level, etc.).
• Calculation of lost sales (average).
• Probability of no space left.
• Probability of no cars waiting.
For each of these metrics, it is possible to formulate
  a confidence interval given sufficient observations.


                                                 143
                                                                              In


                                                                     arrive                 Car
                                                                             c              c
   Alternatives                                 [len(q)<3]                                             [len(q)>=3]

                                        put_in_queue                                                             drive_on
                                                                                   q
 color Car = string;                                                 q^^[c]
                                                            q
                                                                                   q
 color Pump = unit;                                                   []
 color TCar = Car timed;
 color Queue = list Car;                             queue             Queue
 var c:Car;                                                  q        c::q
 var q:Queue;
 fun len(q:Queue) = if q=[] then 0                  start
  else 1+len(tl(q));
                                     c@+uniform(2,5)                          ()                       c

                                                                 pump_free             ()
Model the following
                                          fill_up      TCar                        Pump
  alternatives:                                        c                     ()

• 5 waiting spaces                                  end

• 2 pumps                                                        c
                                                           Out                                  Out

• 1 faster pump
                                                           depart      Car                  drive_on       Car


                                                                                                            144
        Simulation of a Production system




    S         X         Y        Z          C
A
B
C

                                                145
                                                   Use distributions

Data          X         Y     Z                      X    2
            A 2         5     8                      Y    3
            B 3         6     9                      Z    4
            C 4         7     1                    Resources per
                 Processing times                   work center



  A     2                            A     2                       A     7
  B     1                            B     1                       B     9
  C     2                            C     1                       C     8
 Replenishment                       Kanbans in-                    Time in-
   lead times                       between work                    between
                                       centers                     subsequent
                                                                     orders
                                                                        146
Top level page: main
 color INT = int;
 color Prod = string;
 color PT = product Prod * INT;
 color PTimed = Prod timed;
 color PTTimed = PT timed;
 var p:Prod;
 var t:INT;                                        4                              5                            6
 var i:INT;
                                 resources_X     INT           resources_Y     INT          resources_Z     INT
                 2`"A"++                        2`"A"++                       2`"A"++
                 1`"B"++                        1`"B"++                       1`"B"++
                  1`"C"                          1`"C"                         1`"C"
                                       Prod                          Prod                         Prod                         Prod
            HS             kanban1                      kanban2                         kanban3                     kanban4              HS
                                  work_                         work_                        work_
 supplier                        center_               HS      center_                HS    center_                HS                         customer
                                    X                             Y                            Z




                    product1        Prod          product2         Prod         product3       Prod           product4      Prod
                     1`("A",2)++                   1`("A",2)++                   1`("A",5)++                  1`("A",8)++                   1`("A",7)++
                     1`("B",1)++                   1`("B",3)++                   1`("B",6)++                  1`("B",9)++                   1`("B",9)++
                      1`("C",2)                     1`("C",4)                     1`("C",7)                    1`("C",1)                     1`("C",8)
 io_lead_time        PT          processing_       PT           processing_      PT          processing_      PT         c_ia_time         PTTimed
                                   time_X                         time_Y                       time_Z
   supplier                          work_center                  work_center                  work_center                    customer
   io_lead_time = io_lead_time       processing_time =            processing_time =            processing_time =              c_ia_time = c_ia_time
   kanban_in = kanban1                 processing_time_X            processing_time_Y            processing_time_Z            kanban_out = kanban4
   product_out = product1            resources = resources_X      resources = resources_Y      resources = resources_Z        product_in = product4
                                     kanban_in = kanban2          kanban_in = kanban3          kanban_in = kanban4
                                     product_in = product1        product_in = product2        product_in = product3
                                     kanban_out = kanban1         kanban_out = kanban2         kanban_out = kanban3
                                     product_out = product2       product_out = product3       product_out = product4


                                                                                                                                                147
Sub page: supplier

                                    accept_order                       In
                                                         p

                    (p,t)                                kanban_in      Prod
                                           p@+t
    In/Out                  (p,t)


io_lead_time   PT                   oip     PTimed
                                            p
                                                                       Out
                                                     p

                                    deliver_order        product_out   Prod




                                                                               148
Sub page: customer

      Out                 place_order
                      p

  kanban_out   Prod                            (p,t)

                                (p,t)@+t                In/Out



                                           c_ia_time   PTTimed

       In             p

  product_in   Prod        consume




                                                                 149
Sub page: work_center
           Out



      kanban_out    Prod       p
                                      end_proc
           Out
                           p

                                                               i+1
      product_out   Prod
                                            p              i                   In/Out



                                    wip      PTimed                                INT
                                                                       resources
                                            p@+t
                                   [i>=1]        i-1
           In              p                           i
                                                               (p,t)
      kanban_in     Prod              start_proc                               In/Out
           In              p                       (p,t)

                                                           processing_time         PT
      product_in    Prod




                                                                                         150
                                                                 color INT = int;
                                                                 color Prod = string;
                                                                 color PT = product Prod * INT;
                                                                 color PTimed = Prod timed;
                                                                 color PTTimed = PT timed;
                                                                 var p:Prod;
                                                                 var t:INT;                                          4                                  5                                     6


         Overview                                                var i:INT;


                                                                                   2`"A"++
                                                                                   1`"B"++
                                                                                                 resources_X       INT
                                                                                                                  2`"A"++
                                                                                                                  1`"B"++
                                                                                                                                  resources_Y         INT
                                                                                                                                                    2`"A"++
                                                                                                                                                                        resources_Z        INT


                                                                                                                                                    1`"B"++
                                                                                    1`"C"                          1`"C"                             1`"C"
                                                                                                         Prod                              Prod                                 Prod                            Prod
                                                                             HS              kanban1                      kanban2                                 kanban3                            kanban4              HS


Results:                                                         supplier
                                                                                                  work_
                                                                                                 center_
                                                                                                    X
                                                                                                                         HS
                                                                                                                                   work_
                                                                                                                                  center_
                                                                                                                                     Y
                                                                                                                                                             HS
                                                                                                                                                                         work_
                                                                                                                                                                        center_
                                                                                                                                                                           Z
                                                                                                                                                                                                  HS                           customer




• response time                                                                      product1       Prod            product2             Prod          product3               Prod           product4      Prod


• utilization                                                    io_lead_time
                                                                                     1`("A",2)++
                                                                                     1`("B",1)++
                                                                                      1`("C",2)
                                                                                     PT          processing_
                                                                                                                     1`("A",2)++
                                                                                                                     1`("B",3)++
                                                                                                                      1`("C",4)
                                                                                                                                      processing_
                                                                                                                                                       1`("A",5)++
                                                                                                                                                       1`("B",6)++
                                                                                                                                                        1`("C",7)
                                                                                                                                                       PT                   processing_
                                                                                                                                                                                             1`("A",8)++
                                                                                                                                                                                             1`("B",9)++
                                                                                                                                                                                              1`("C",1)
                                                                                                                                                                                             PT         c_ia_time
                                                                                                                                                                                                                             1`("A",7)++
                                                                                                                                                                                                                             1`("B",9)++
                                                                                                                                                                                                                              1`("C",8)
                                                                                                                                                                                                                            PTTimed


• % backorders
                                                                                                                     PT
                                                                                                   time_X                               time_Y                                time_Z
                                                                   supplier                            work_center                      work_center                           work_center                      customer
                                                                   io_lead_time = io_lead_time         processing_time =                processing_time =                     processing_time =                c_ia_time = c_ia_time
                                                                   kanban_in = kanban1                   processing_time_X                processing_time_Y                     processing_time_Z              kanban_out = kanban4



• average stock
                                                                   product_out = product1              resources = resources_X          resources = resources_Y               resources = resources_Z          product_in = product4
                                                                                                       kanban_in = kanban2              kanban_in = kanban3                   kanban_in = kanban4
                                                                                                       product_in = product1            product_in = product2                 product_in = product3
                                                                                                       kanban_out = kanban1             kanban_out = kanban2                  kanban_out = kanban3
                                                                                                       product_out = product2           product_out = product3                product_out = product4



• etc.
                                                                                                    Out
                                     accept_order                           In
                                                          p                                                                                                                                                                                place_order
                                                                                              kanban_out          Prod            p                                                                             Out
                                                                                                                                          end_proc                                                                                     p
                     (p,t)                                kanban_in         Prod                    Out
                                            p@+t                                                                              p                                                                                                                                 (p,t)
                                                                                                                                                                                                        kanban_out             Prod
     In/Out                  (p,t)
                                                                                                                                                                      i+1
                                                                                              product_out         Prod                                                                                                                                                   In/Out
                                                                                                                                                                                                                                                 (p,t)@+t
                                                                                                                                                p                 i                         In/Out
 io_lead_time   PT                   oip     PTimed
                                             p                                                                                                                                                                                                              c_ia_time   PTTimed
                                                                         Out                                                           wip       PTimed                                      INT
                                                                                                                                                                                 resources
                                                      p                                                                                         p@+t                                                              In
                                                                                                                                      [i>=1]         i-1                                                                               p
                                                                                                    In                        p                               i
                                     deliver_order        product_out   Prod                                                                                                                            product_in             Prod         consume
                                                                                                                                                                      (p,t)
                                                                                              kanban_in           Prod                   start_proc                                        In/Out
                                                                                                    In                        p                             (p,t)

                                                                                                                                                                  processing_time             PT
                                                                                              product_in          Prod




                                                                                                                                                                                                                                                              151
Classical versus high-level Petri nets
•   Simulation clearly works for all types of nets.
•   Hierarchy is never a problem.
•   Time allows for new types of analysis.
•   Reachability graphs and invariants can also be
    extended to high-level nets.
    – More complex (both technique and computation)‫‏‬
• Sometimes abstraction from color is possible to
  derive invariants (consider previous example).



                                                       152
Exercise: Five Chinese philosophers
• Recall hierarchical CPN model of five
  Chinese philosophers alternating between
  states thinking and eating.
  – Give place invariants
  – Give transition invariants
• Change the model such that philosophers
  can take one chopstick at a time but avoid
  deadlocks and a fixed ordering of
  philosophers.
  – Give place invariants
  – Give transition invariants

                                               153
color BlackToken = unit;
var b:BackToken                                  Top-level page
                                               philosopher
                                               left = CS2
                                       HS      right = CS1
                           ()                                CS2   ()
                   CS1

            BlackToken
                                              PH1 BlackToken

                                HS
                  PH5                                                   PH2
                                philosopher
                                left = CS1                              HS
                                right = CS5                             philosopher
                                                                        left = CS3
                           ()                            CS3       ()   right = CS2
                 CS5

           BlackToken                            BlackToken


                                    CS4             ()
                  PH4                                                   PH3
                    HS                                                  HS
            philosopher
                                   BlackToken                       philosopher
            left = CS5                                              left = CS4
            right = CS4                                             right = CS3



                                                                                      154
Page philosopher
            think           ()                eat

     BlackToken                      BlackToken

                    b                               b
                                 b            b
   take_chopsticks                                  put_down_chopsticks



                                     b    b
                                                    b
                        b
           left                                         right


       BlackToken           In/Out        In/Out        BlackToken



                                                                     155
Flat model is obtained by replacing
substitution transitions by subpages
color BlackToken = unit;
var b:BackToken                                                                          Naming:
                                       HS
                                               philosopher
                                               left = CS2
                                               right = CS1
                                                                                         •PH3.think
                   CS1

            BlackToken
                           ()                                CS2   ()
                                                                                         •PH3.eat
                                              PH1 BlackToken
                                                                                         •PH3.take_chopsticks
                  PH5
                                HS
                                philosopher
                                left = CS1
                                                                        PH2
                                                                        HS
                                                                                         •PH3.put_down_chopsticks
                                right = CS5                             philosopher
                                                                        left = CS3
                           ()                            CS3       ()   right = CS2
                 CS5

           BlackToken                            BlackToken                                      think           ()                eat

                                    CS4             ()                                    BlackToken                      BlackToken
                  PH4                                                   PH3
                    HS                                                  HS                               b                               b
            philosopher
                                   BlackToken                       philosopher
                                                                                                                      b            b
            left = CS5                                              left = CS4          take_chopsticks                                  put_down_chopsticks
            right = CS4                                             right = CS3




                                                                                                                          b    b
                                                                                                                                         b
                                                                                                             b
                                                                                                left                                         right


                                                                                            BlackToken           In/Out        In/Out        BlackToken



                                                                                  Repeat 5 times...
                                                                                                                                                     156
                                   think            ()                eat
Alternative page         BlackToken                          BlackToken

                                            b                               b
                                                         b            b
                         start_eating                                            start_thinking



                                                             b    b
                                                                            b
                                                b
                                hold_left                                        hold_ right

                         BlackToken                                               BlackToken
                            b
                                            b                               b                b
           return_left          take_left                                       take_right         return_right




                                                                            b                  b
                           b                    b
                                  left                                             right

                           BlackToken               In/Out        In/Out         BlackToken




                                                                                                   157
You should be able to ...
• Construct a reachability graph for a classical Petri
  net.
• Give meaningful place and transition invariants for
  a classical Petri net.
• Construct a reachability graph and give
  meaningful place and transition invariants for a
  hierarchical CPN after abstracting from data and
  time and removing hierarchy.
• Build a simple simulation model using CPN.
• Motivate the use of each of the analysis
  techniques.

                                                 158

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:161
posted:3/31/2011
language:English
pages:158