2014 4th International Conference on Artificial Intelligence with Applications in Engineering and Technology
Verifying Solutions to the Dining Philosophers Problem with Activity-Oriented
Petri Nets
Reggie Davidrajuh
Department of Electrical and Computer Engineering
University of Stavanger
Stavanger, Norway
E-mail: Reggie.Davidrajuh@uis.no
Abstract—Petri Nets is a family of modeling formalisms,
consisting of various types of Petri nets with different
interpretations and abstraction levels. General Purpose Petri
Net Simulator (GPenSIM) is a new Petri Net simulator that
implements many of the Petri Net types. Activity-Oriented
Petri Nets (AOPN) is a new approach that facilitates modeling
of some specific problems (e.g. modeling systems that include
large number of resources); AOPN is also implemented in
GPenSIM. In this paper, firstly, a short introduction to AOPN
is given. Secondly, the modeling capability of AOPN is tested
using the classical benchmark known as the Dining
Philosophers Problem. The modeling approach shown in this
paper proves that AOPN can be conveniently used for
modeling of discrete event systems.
Keywords- Dining Philosophers problem; Activity-Oriented
Petri Net (AOPN); GPenSIM; Petri Nets
I. INTRODUCTION
The Petri Nets is a family of modeling formalisms that
includes many types of Petri Nets. Some of the well-known
Petri Net types are Ordinary (aka classical or P-T) Petri Net,
Generalized Petri Net, and Stochastic Petri Net, Colored
Petri Net, Petri Net with priority, Petri Net with inhibitor
arcs, and Timed Petri Net [1; 2; 3; 4]. There are also
restrictions of Petri Net (also known as Petri Net subclasses)
such as Marked Graphs and Finite State Machines [1; 5]. In
addition, some special types of Petri nets are that developed
for solving specific problems conveniently [6; 7].
Ordinary (aka classical or PT) Petri Nets and Generalized
Petri Nets do not possess enough modeling power to model
Turing machines; this means, Ordinary Petri Nets cannot be
used for modeling some of the discrete event systems [1; 8].
Thus, extensions (e.g. Petri Nets with priority, Petri Net with
inhibiting arcs, and enabling functions [9; 10]) are needed to
make the Petri Net capable of modeling Turing machine.
Literature report the huge size of Petri Net models of
discrete event systems as one of the main problems
associated with Petri Nets [11]. This problem is especially
true when modeling resource scheduling problems: even for
a resource scheduling problem with few activities competing
for a few resources, the resulting Petri Net model can be very
large [11]. AOPN is an approach for obtaining compact
models of discrete event systems where resource sharing and
resource scheduling dominate.
978-1-4799-7910-3/14 $31.00 © 2014 IEEE 163
DOI 10.1109/ICAIET.2014.35
Authorized licensed use limited to: Universidad Nacional de Colombia (UNAL). Downloaded on April 24,2021 at 16:54:28 UTC from IEEE Xplore. Restrictions apply.
The aim of this paper is to test the model compactness
and the modeling easiness of AOPN using the classical
benchmark known as the dining philosophers problem. Thus,
the scope of the paper is limited to testing the modeling
capability of AOPN only; literature study reveals that the
dining philosophers problem is solved using various types of
Petri Nets; interested readers are referred to [12; 13; 14].
In this paper: firstly, a short introduction to AOPN is
given. Secondly, the solutions to the classical benchmark
known as the dining philosophers problem is modeled and
verified by the AOPN approach.
II. A SHORT INTRODUCTION TO ACTIVITY-ORIENTED
PETRI NETS (AOPN)
Activity-Oriented Petri Nets (AOPN) is a two phase
modeling approach [15; 16]:
Phase-I is for creating the static Petri Net model. In this
phase, mainly the activities are their precedence are
represented as transitions intertwined with places as
buffers; the resources are grouped into two groups such as
focal resources and utility resources, and only the focal
resources are included in the static Petri Net model and the
utility resources are pushed into run-time model. Thus, a
compact Petri Net model is obtained with only the transitions
representing the activities and a fewer places representing the
focal resources.
Phase-II is for adding the run-time details that cannot be
coded in the static Petri Net model; e.g. transitions
(activities) requesting, using, and releasing of the utility
resources are coded in the run-time model.
In order to allow the two phase modeling approach,
(static Petri net model and dynamic run-time environment),
AOPN provides a number of fundamental constructs such as
non-primitive transitions, pre-processor known as
COMMON_PRE, post-processor known as
COMMON_POST, and resource management:
Non-primitive transitions: in AOPN approach, all the
transitions take time to fire and may incur cost when firing.
Pre-processor known as COMMON_PRE: Every
enabled transition runs a pre-processor for checking
additional conditions for firing (aka ‘guard conditions’ and
‘enabling conditions’ in some literature [17]).
post-processor known as COMMON_POST: every
transition that has just fired also run a post-processor known
 as COMMON_POST right after firing, to perform post-firing
actions, if any.
Resource management support and costing constructs:
AOPN provides resource management support in the
background; also, code for cost analysis will be
automatically run if costing is necessary.
Interested readers are referred to the following works on
AOPN [15; 16; 17; 18].
III. THE DINING PHILOSOPHERS PROBLEM
The dining philosophers problem was originally put
forward in 1965 by Dijkstra [20]. In computer science, the
dining philosophers problem is a case study problem often
used to study concurrency, synchronization, and conflict.
Literature study shows that the dining philosophers problem
is already solved many times, using a variety of Petri Net
extensions [1; 12; 13; 14]. Hence, in this paper, the dining
philosophers problem is used as a benchmark to test the
modeling capability and also the easiness of using AOPN
and its GPenSIM implementation.
A. Description of the problem
Details of the dining philosophers problem (see figure-1):
• When a philosopher is about to perform the act of
eating, he must secure the chopsticks (both on the
right and on the left) first; whether to secure the right
one or the left one first, is not defined.
• After finish eating, the philosopher puts the
chopsticks on the table, and starts the act of thinking.
• Rice in the bowls is assumed as unlimited (infinite
supply); hungry philosophers can eat as much as
they want, as long as they want.
The problem is to design an algorithm so that none of the
philosopher starves due to conflict or deadlock.
B. Ordinary Petri Net model
Figure-2 shows an Ordinary Petri Net model for the
dining philosophers problem; this figure shows only the
module for philosopher-4; the other modules for the other
philosophers will be similar. Thus, the complete model
consists of copies of this module for the other philosophers
as well, and the modules are connected through the places
representing the chopsticks (CS).




























 
  Figure 2. Ordinary Petri Net module of Philosopher-4.
 

 
Figure 1. The dining philosophers problem: with 5 philosophers and 5
chopsticks (CS) placed between them.
• Five philosophers sit at around a table, performing
two acts: thinking and eating.
• A bowl of rice placed in front of each philosopher,
together with two chopsticks. As the chopsticks are
placed between the philosophers, they are for
common use by the adjacent philosophers. However,
the rice bowl is for individual use only.
• Each philosopher acts independently, alternately
performs the acts of thinking and eating.
• When a philosopher performs the act of thinking, he
does not use the chopsticks, thus they are free to be
used by the adjacent philosophers.
• Each chopstick is treated as a critical region: at most
one philosopher can use it at a time.
164
Authorized licensed use limited to: Universidad Nacional de Colombia (UNAL). Downloaded on April 24,2021 at 16:54:28 UTC from IEEE Xplore. Restrictions apply.
In the ordinary Petri net model shown in figure-2, it is
not possible not solve the issues such as deadlock (a situation
in which no progress is possible) and livelock (a situation in
which one or more philosophers are starving).
Deadlock may appear if all the philosophers become
hungry at the same time and secures the chopstick on the
right first (e.g. philosopher-4 secures the chopstick CS-4 and
the philosopher-3 takes the chopstick CS-3). Since the other
chopstick is now occupied, each philosopher has to wait
eternally for the chopstick to the left to become available, see
figure-3.
However, this problem could be avoided by making a
simple structural adjustment to the module shown in figure-
2: as shown in figure-4, we may forge the transitions
“securing CS-4” and “securing CS-5” in figure-2 together,
forcing the philosopher either to pick up the two chopsticks
together if available or to wait.
 Livelock (resource starvation) is still possible, as two
philosophers eat alternatively or at the same time, leaving the 

philosopher in-between to starve. As there is no mechanism 


 
in Ordinary Petri Net to give priority to a starving
philosopher (e.g. by the technique called ‘aging’), Ordinary   




Petri Net cannot be used avoid starvation. 

philosopher-3 got CS-3



philosopher-4 got CS-4   
philosopher-1 got CS-1
philosopher-2 got CS-2   


philosopher-5 got CS-5
philosopher-2 DID NOT get CS-3 
 

philosopher-5 DID NOT get CS-1


philosopher-1 DID NOT get CS-2
philosopher-3 DID NOT get CS-4  

philosopher-4 DID NOT get CS-5


philosopher-1 DID NOT get CS-2
philosopher-3 DID NOT get CS-4 

philosopher-2 DID NOT get CS-3
philosopher-5 DID NOT get CS-1
philosopher-4 DID NOT get CS-5
… Though this method avoids starvation among
… philosophers, introducing the supervisor as a central control
Figure 3. Philosophers in deadlock.
C. Solutions to the dining philosophers problem
Literature provides many solutions to the problem,
including the following three [20; 21; 22]:
• Solution-1: Dijkstra’s solution based on the number
ordering of chopsticks.
• Solution-2: the solution based on the number
ordering of philosophers.
• Solution-3: the supervisor based solution.
Dijkstra’s solution is the earliest solution to the problem.
Dijkstra proposes a solution for deadlock avoidance by
assigning a numerical order to the chopsticks and forcing the
philosophers to secure the chopstick with higher number first
and then the one with the lower number (e.g. philosopher-4
secures CS-5 first and then CS-4, whereas philosopher-5 also
secures CS-5 first and then CS-1) [20]. This enforcement
prevents each philosopher holding one chopstick each and
waiting for the other eternally. Though Dijkstra’s proposal
avoids the deadlock situation, it does not avoid starvation.
The solution based on the number ordering of
philosophers is very similar to the Dijkstra’s solution; rather
than numbering the chopsticks, the philosophers are number
ordered in this solution [21]. When two philosophers
compete for a chopstick, the philosopher with the lower
number will be prioritized. As with Dijkstra’s solution, this
solution does not answer the starvation problem.
The starvation problem can be prevented by introducing
a supervisor (or arbitrator) [22]. The supervisor may allow or
prevent a philosopher from grabbing the two chopsticks and
eat; the supervisor also counts the number of times a
philosopher attempted to grab the chopsticks and the number
of times he succeeded and not succeeded. Using this
information, when many philosophers become hungry at the
same time, the supervisor may give priority to a staving
philosopher.
165
Authorized licensed use limited to: Universidad Nacional de Colombia (UNAL). Downloaded on April 24,2021 at 16:54:28 UTC from IEEE Xplore. Restrictions apply.
Figure 4. Revised Petri Net module of Philosopher-4.
unit results in reduced parallelism: it is no longer possible for
more than one philosopher to become hungry, secure the
chopsticks and start eating – all at the same time, as the
supervisor can look into only one philosopher at a time.
The three solutions mentioned above cannot be verified
by an Ordinary Petri Net, as there is no facility in Ordinary
Petri Net to prioritize a philosopher when two or more
compete for the same resource.
IV. VERIFYING THE SOLUTIONS WITH AOPN
In this section, the three solutions to the dining
philosophers problem will be verified by Petri net models
based on AOPN.
A. The AOPN model
Figures-5 and 6 show the Petri Net models of the dining
philosophers problem, based on AOPN. The model shown in
figure-5 is much compact compared with its equivalent
ordinary Petri net model shown in figure-2. This is because,
the resources (chopsticks) are considered as utility resources
and thus abstracted away from the static Petri Net model,
leaving the model representing only the activities such as
“thinking”, “securing chopsticks”, and “eating”.
The transitions in the AOPN model are shown as
rectangles and not as thin lines as in figure-2. This is
because, AOPN is based on Timed Petri Nets and the
transitions “Thinking” and “Eating” take time as
philosophers do take time to thinking and eating. The
transitions in the ordinary Petri net model are untimed thus
shown as thin lines.
During run-time (figure-6), when the philosopher-4
becomes hungry (indicated by a token each in the places
‘secure CS-4’ and ‘secure CS-5’), the transitions ‘securing
CS-4’ and ‘securing CS-5’ become enabled.
However, for these transitions to start fire, they will
request the resources ‘CS-4’ and ‘CS-5’ from the resource
manager which runs in the background; only if the resources
 are granted then the transitions fire depositing a token each B. Verifying Dijkstra’s solution
in the places ‘CS-4 secured’ and ‘CS-5 secured’. In Dijkstra’s solution, the chopsticks are numbered, and


  when a philosopher requires two chopsticks, the chopstick
 with higher number should be secured first. Equivalently,
when two chopsticks are reserved at the same time, the
 
transition that reserves the higher numbered chopstick must
be allowed to fire before the transition that reserves the lower
numbered chopstick. The following code snippet implements

 
 this condition for philosopher-4 where the transition t4S5
 
 
(for securing CS-5) is allowed to fire before the transition
t4S4 (for securing CS-4):

 

  %%%% for philosopher-4
 
if strcmp(transition_name, 't4S4'),
 


 
  fire = not(is_enabled('t4S5'));
end;

  C. Verifying the solution based on philosopher numbering

The second solution allocates index numbers to the
philosophers and assign priority to them so that higher the
index number, higher the priority will be. For example,


 
philosopher-1 will be assigned with priority value 1, which is
lower than the priority value 2 that will assign to


Figure 5. Static Petri Net module of philosopher-4.
philosopher-2; philosopher-5 will be assigned the highest
priority value of 5.
The code snippet shown below assigns priorities to two
transitions for each philosopher; this is because, each
philosopher secures chopsticks via two transitions (e.g.

  philosopher-4 uses transitions t4S4 and t4S5 for requesting
 the chopsticks).
% assign priorities to philosophers
priorset('t1S1',1); % philosopher-1
  priorset('t1S2',1); % philosopher-1
priorset('t2S2',2); % philosopher-2
priorset('t2S3',2); % philosopher-2

 

  priorset('t3S3',3); % philosopher-3

  


   priorset('t3S4',3); % philosopher-3

 
   priorset('t4S4',4); % philosopher-4


 
 priorset('t4S5',4); % philosopher-4
 
  priorset('t5S5',5); % philosopher-5
priorset('t5S1',5); % philosopher-5
 


 
 
D. Verifying the solution based on supervisor
 
The supervisor basically interferes when the philosophers
attempt to secure the chopsticks.


  If a philosopher fails to secure the chopsticks
  

  
 successively a number of times (the code snippet shown
below assumes 10 times), then the philosopher is assumed to


 
be starving and hence a very high priority (priority value of 7
in the code) is assigned to the philosopher. Since the starving


philosopher has the highest priority now, he will secure the
Figure 6. Petri Net run-time module of philosopher-4. chopsticks when he competes for it next time. The code
below also shows that when the starving philosopher finally
Due to the tokens, one each in the places ‘CS-4 secured’ eats, his priority must be restored back to his normal priority.
and ‘CS-5 secured’, the transition ‘Eating’ fires. When % Solution-3: Avoiding starvation
‘Eating’ is complete, all the acquired resources (e.g. ‘CS-4’ if not(acquired),
and ‘CS-5’ for philosopher-4) will be released by the attempts(PNr) = attempts(PNr) + 1;
transition ‘Eating’. if eq(attempts(PNr), 10),%
It is easy to code and verify the solutions using priority(PNr) =
GPenSIM. get_priority(tname);

166

Authorized licensed use limited to: Universidad Nacional de Colombia (UNAL). Downloaded on April 24,2021 at 16:54:28 UTC from IEEE Xplore. Restrictions apply.
 priorset(tname, 7); % any high value % declarte the initial tokens
end; dyn.m0 = {'p1RTT',1, 'p2RTT',1, ...
else % reset attempts and priority 'p3RTT',1, 'p4RTT',1, 'p5RTT',1};
if eq(attempts(PNr), 10),
% reassign original priority % declarte the set of resources
priorset(tname, priority(PNr)); dyn.re = {'CS-1',1,inf, 'CS-2',1,inf,...
end; 'CS-3',1,inf, 'CS-4',1,inf, ...
attempts(PNr) = 0; % reset attempts 'CS-5',1,inf};
end; % create the run-time Petri net
pni = initialdynamics(png, dyn);
E. GPenSIM code for Simulations
This section tries to show how simple and compact the % run the simulation
sim = gpensim(pni);
GPenSIM code for simulation is. Using GPenSIM, a Petri
net model of a discrete event system usually consists of four The main parts of the pre-processor file COMMON_PRE
files: is already shown piece-by-piece in the subsection IV-C; due
1. Petri Net Definition File (PDF): this is the code to space limitation, the complete code is not shown in this
implementation of the static Petri Net. paper, but available in the webpage given in the reference as
2. Main Simulation File (MSF): In this file, the initial [23]. The post-processor file COMMON_POST is given
dynamics (e.g. initial tokens in places, firing times of below; in this file, the chopsticks that are reserved by the two
transitions, available systems resources) are transitions (e.g. ‘t4S4’ and ‘t4S5’) are released after eating
declared. (e.g. after ‘t4Eating’).
3. COMMON_PRE: In this file, the conditions for the
enabled transitions to start firing (‘guard conditions’) % COMMON_POST file for coding
are coded (e.g. reservation of resources needed to % the post firing actions.
function [] = COMMON_POST(transition)
start firing by any transitions). tname = transition.name;
4. COMMON_POST: the post-firing actions of the if ismember(tname, {'t1Eating', ...
transition are coded here. 't2Eating','t3Eating', ...
As discussed in the previous sections, the AOPN model 't4Eating','t5Eating'}),
for the dining philosophers problem consists of 5 similar PNr = str2double(tname(2)); % phil nr.
modules, one for each philosopher; figure-5 shows the CS1 = PNr;
module for philosopher-4. The PDF file for philosopher-4 is CS2 = mod(PNr,5) + 1;
trans1_name = ...
given below: ['t',int2str(PNr),'S',int2str(CS1)];
% PDF for philosopher-4 trans2_name = ...
function [png] = p4_pdf() ['t',int2str(PNr),'S',int2str(CS2)];
png.PN_name = 'PDF for philosopher-4'; release(trans1_name);
png.set_of_Places = {'p4RTT', 'p4S5', ... release(trans2_name);
'p4S4', 'p4S5d', 'p4S4d'}; end;
png.set_of_Transitions = {'t4Thinking', ...
't4S5', 't4S4', 't4Eating'}; F. Simulation results
png.set_of_Arcs= {'p4RTT','t4Thinking',1,...
't4Thinking','p4S5',1, ... Simulation results verify that:
't4Thinking','p4S4',1,... • Dijkstra’s solution and the solution based on
'p4S5','t4S5',1, 't4S5','p4S5d',1, ... philosopher numbering avoids the deadlock
'p4S4','t4S4',1, 't4S4','p4S4d',1, ... situation, and
'p4S5d','t4Eating',1, ...
'p4S4d','t4Eating',1, ... • In addition to deadlock avoidance, the solution based
't4Eating','p4RTT',1}; on supervisor avoids starvation.

The main simulation file is give below, in which the Sample simulation run is shown below:
initial dynamics are declared first. Then, the initial Petri net Warning: Firing times of
runt-time is created by joining the static Petri Net model with transitions are NOT given ...
the initial dynamics. Finally, the simulation runs are done.
% The main siluation file (MSF)
*** Using the supervisor method:
global global_info;
global_info.attempts = zeros(1,5); P-5 got CS-5
global_info.priority = zeros(1,5); P-4 DID NOT get CS-5
P-3 got CS-4
% declarte set of PDFs for the modules P-2 got CS-3
png = pnstruct({'p1_pdf', 'p2_pdf', ... P-5 got CS-1
'p3_pdf', 'p4_pdf', 'p5_pdf'}); P-3 DID NOT get CS-3
P-1 got CS-2
P-4 DID NOT get CS-5

167

Authorized licensed use limited to: Universidad Nacional de Colombia (UNAL). Downloaded on April 24,2021 at 16:54:28 UTC from IEEE Xplore. Restrictions apply.
 P-3 DID NOT get CS-3 [9] G. Ciardo, “Toward a Definition of Modeling Power for Stochastic
P-2 DID NOT get CS-2 Petri Net Models,” International Workshop on Petri Nets and
P-1 DID NOT get CS-1 Performance Models, pp. 54-62, 1987.
P-4 got CS-5 [10] M. A. Marsan, G. Chiola, “On Petri nets with deterministic and
P-3 DID NOT get CS-3 exponentially distributed firing times,” Lecture Notes in Computer
Science, Vol. 266, pp 132-145, 1987.
P-2 DID NOT get CS-2
P-1 got CS-1 [11] A. Mehrez, M. Muzumdar, W. Acar, and G. Weinroth, “A Petri Net
Model View of Decision Making: an Operational Management
…
Analysis,” Omega, Int. J. Mgmt Sci. Vol. 23, No. 1, pp. 63-78, 1995.
…
[12] M. A. Holliday, M. K. Vernon, “A Generalized Timed Petri Net
Model for Performance Analysis”, Software Engineering, IEEE
V. CONCLUSION Transactions on, 12: 1297 – 1310, December 1987.
In this paper, a new approach known as Activity- [13] A. A. Lazar, T. G. Robertazzi, “Markovian Petri Net protocols with
Oriented Petri Nets (AOPN) is used to verify the solution product form solution”, Performance Evaluation, 12(1):67–77,
proposed for the classical dining philosophers problem. A January 1991.
new Petri Net simulator known as GPenSIM was used for [14] S. M. Shatz, T. U. Shengru, T. Murata, T. S. Duri, "An application of
Petri net reduction for Ada tasking deadlock analysis", Parallel and
creating the simulation code. Distributed Systems, IEEE Transactions on, 12:1307 - 1322,
The modeling and simulations given in this paper shows December 1996.
that AOPN approach can be conveniently used for modeling [15] R. Davidrajuh, “Activity-Oriented Petri Net for Scheduling of
of discrete event systems, especially when resources are Resources,” Proc. IEEE International Conference on Systems, Man,
involved. and Cybernetics (IEEE SMC 2012), October 14-17, 2012, Seoul,
The complete GPenSIM program codes for the Petri Net Korea.
models are not shown in this paper due to space limitation, [16] R. Davidrajuh, “Modeling Resource Management Problems with
Activity-Oriented Petri Nets.” Computer Modeling and Simulation
but fully available at the webpage indicated in the reference (EMS), 2012 Sixth UKSim/AMSS European Symposium on. IEEE,
as [23]. 2012.
[17] R. Davidrajuh, “Activity Based Costing with Petri Nets.” Computer
REFERENCES Modeling and Simulation (EMS), 2012 Sixth UKSim/AMSS
[1] J. L. Peterson, Petri Net Theory and the Modeling of Systems. NJ, European Symposium on. IEEE, 2012.
USA: Prentice-Hall, 1981. [18] R. Davidrajuh, “Realizing Simple Petri Net Models for Complex and
[2] W. Reisig, Understanding Petri Nets: Modeling Techniques, Analysis Large Scheduling Problems: An Approach Based Activity-Oriented
Methods, Case Studies, Springer, 2013. Petri Nets.” Computer Modelling and Simulation (UKSim), 2013
[3] L. Popova-Zeugmann, Time and Petri Nets, Springer, 2013. UKSim 15th International Conference on. IEEE, 2013.
[4] B. Berard, F. Cassez, S. Haddad, D. Lime, and O. H. Roux, “The [19] X. D. Koutsoukos, K. X. He, M. D. Lemmon, and A.J. Antsaklis,
expressive power of time Petri nets,” Theor. Comput. Sci., vol. 474, “Timed Petri nets in hybrid systems: Stability and supervisory
pp. 1–20, February 2013. control.” Discrete Event Dynamic Systems 8(2): 137-173, 1998.
[5] R. David, and H. Alla, “Discrete, Continuous and Hybrid Petri Nets,” [20] E. W. Dijkstra, “Hierarchical ordering of sequential processes”. Acta
IEEE Control Systems, Vol. 28, Issue. 3, pp. 81-84, June 2008. Informatica, 1(2): 115–138, 1971.
[6] L. H. Landweber, and E. L. Robertson, “Properties of conflict-free [21] J. Díaz, I. Ramos, “Formalization of Programming Concepts”,
and persistent Petri nets.” Journal of the ACM, 25(3): 352-364, 1978. International Colloquium, Peniscola, Spain, April 19–25, 1981.
[7] M. Nielsen, G. Plotkin, and G. Winskel, “Petri nets, event structures [22] C. A. R. Hoare, Communicating Sequential Processes, NJ, USA:
and domains, part I.” Theoretical Computer Science, 13(1): 85-108, Prentice Hall, 1985.
1981. [23] R. Davidrajuh, “GPenSIM code for the dining philosophers problem”.
[8] R. Davidrajuh, “Revisiting Petri Net modeling of Cigarette Smokers' Available: http://www.davidrajuh.net/gpensim/2014- ICAIET-DPP.
Problem,” Proc. IEEE European Modelling Symposium (EMS2013),
November 20–22, 2013, Manchester, UK.

168

Authorized licensed use limited to: Universidad Nacional de Colombia (UNAL). Downloaded on April 24,2021 at 16:54:28 UTC from IEEE Xplore. Restrictions apply.