ALGORITHMS FOR HIGH LEVEL PETRI NETS SIMULATION AND RULE-BASED SYSTEMS

Transcription

1 ALGORITHMS FOR HIGH LEVEL PETRI NETS SIMULATION AND RULE-BASED SYSTEMS Dumitru Dan BURDESCU *, Marius BREZOVAN ** * University of Craiova, Faculty of Automatic Control, Computer and Electronics Software Engineering Department tel/fax: , burdescu@topedge.com ** University of Craiova, Faculty of Automatic Control, Computer and Electronics Software Engineering Department brezovan@comp-craiova.ro Abstract: This paper presents a way for implementing the dynamic semantics of High Level Petri Nets by using a mied version of RETE algorithm. To do this, a rule-based language for High Level Petri Nets specications is described. First a connection between rule-based systems and High Level Petri Nets is presented, and it is sown then that for every Petri net, a rule-based system exists, which is semantic equivalent. The proposed algorithms are algorithms for simulation, and the High Level Petri Nets can be used for discrete event system melling. The algorithms presented in this paper are based on the RETE algorithm for rule-based systems, and avoid the testing of all transitions for enabling determination. The tokens are propagated in the RETE graph, as much as possible; when tokens reach an output ne, they activate the transition associated to that ne. Keywords: Petri nets, rule-based systems, system melling, discrete event systems, algebraical specications. 1. Intruction The structure of a rule-based system contains mainly a fact base, called the working memory of the system where the known facts at different moments are stored, a rule base which contains the rules used to infer new facts, and an inference engine which selects some applicable rules to infer new facts. The rules from the rule base are syntactic structures of the form: If conditions then actions The conditions represent the rule antecedent and they are patterns that are tested for the rule activation. If the conditions match with the facts from the fact base, the rule can re, and the actions representing the consequent of the rule are performed. The pattern-matching process is performed during the inference process, and the variables appearing into the patterns are bound to some constants from the facts of the fact base. There are two important classes of inference algorithms: forward chaining algorithms and backward chaining algorithms. In the following the case of forward chaining algorithms is considered. The main structure of a forward chaining algorithm is presented in procedure Infer: procedure Infer(input rule-base, fact-base) selected-rules Select(rule-base, fact-base) while selected-rules Φ do rule SolveConflicts( selected-rules) ApplyRule(rule) selected-rules Select( rule-base, fact-base) rule-set function Select(rule-base, fact-base)

2 selected-rules Φ for * rule rule-base* do if Match(Antecedent(rule), fact-base) then selected-rules selected rules rule return selected-rules The function Select selects a set of rules, or rule instances in the case of systems allowing variables, from the rule base whose antecedent matches with the facts from the fact base. The function Match determines this matching process. One of the rules selected will be red, which is determined by function SolveConflicts. The procedure ApplyRule res a rule by performing the actions of its consequent. An improved version of this algorithm was described by Forgy [9], which allows to increase the speed of pattern-matching process. This algorithm is called RETE, and it tries to avoid the iterations over facts of the fact base by storing for each pattern a list of the matched rule antecedents. Similarities between Predicate/Transition nets and rule based systems have been established [14, 17, 18]. High Level Petri Nets preserve this property; one can show that for every High Level Petri Net a rule based system exists, which is semantic equivalent. To do this, an appropriate syntax of the pruction rule language, closed to the High Level Petri Nets denition is chosen. rule :: = if antecedent then consequent antecedent :: = λ pattern { pattern } * [ test ] pattern :: = ident ( multiset ) test :: = test ( boolean expression ) multiset :: = integer * ident {, integer * ident } * consequent :: = action { action } * action :: = app delete app :: = add ( ident, { multiset } ) delete :: = del ( ident, { multiset } ) fact :: = { multiset of constants } multiset of constants :: = integer * const {, integer * const } * The transformation of a High Level Petri Net into a rule-based system is made through the following steps: (1) the rule base construction; to each transition of the net, one pruction rule is associated, as in the following: - to each input place of the transition, a pattern is associated; the parameters of the pattern represents the expression L(a) of the arc connecting the place to the transition; - to the selector of the transition, a test condition is associated, specifying its boolean expression; - to each output place of the transition, a delete action is associated, in a similar way to the pattern association; - to each output place of the transition, an app action is associated, by specifying the place name and the expression L(a) of the arc connecting the place to the transition. (2) the construction of initial fact base, which contains all multisets of the initial marking: F = p P (M 0 (p)). In other words, a fact represents a multiset of constants, which is compatible with the type of its associated place. Proposition 1. For every High Level Petri Net, a rulebased system exists, which is semantic equivalent. Proof. In concordance with the steps (1) and (2), a High Level Petri Net is transformed into a knowledge base with the property that a biunivocal correspondence exists between the net transitions and system rules. The following remarks state that the rules red by inference algorithm in procedure Infer represents a subset of the reachability graph of the initial net: (a) the pattern-matching operation, whose effect is the binding of the antecedent variables to appropriate values, is made by matching the multiset of variables (belonging the input arcs of the transition) against the multiset of constants representing the marking of those places. (b) The operation of antecedent evaluation represents the verication of the two important conditions from the denition of enabling transition. Through the pattern-matching operation, the occurrence me of the transition is realised. (c) The performing of consequent actions of a rule represents the operations performed at the ring of the correspondent transition; this means that a rule ring is semantic equivalent to its correspondent transition ring. #. It follows that inference algorithms can be used to implement the semantics of the High Level Petri Nets. 2. RETE algorithms for implementation of High Level Petri Nets semantics In place to translate a net into a pruction system [6], the RETE algorithm is adopted so that it works directly with a High Level Petri Net. The general structure of a sorting net adapted to te High Level Petri Nets is presented in gure 1.

3 p 1 p i p j p n distribution trees test trees t 1 t k Figure 1. The sorting net The inputs for the sorting net correspond to the places of the associated High Level Petri Net, and the output places to the transitions of the net. The sorting net contains two subnets: the distribution net and the test net. The distribution net is composed by a number of trees equal to the number of places from the High Level Petri Net, each tree having two levels: the root and the leaves. To simplify the test net, if a place is an input place for more transitions, this place must be duplicated. As a consequence, the leaves from a distribution tree are duplications of its associated place. The test tree contains one test tree for each transition. The root of the tree is an output ne for the sorting net, and the leaves represent outputs of the distribution net. The construction of the sorting net starts with the test subnet, because the distribution subnet is a simple list of lists, which can be easy constructed if the test subnet is constructed. To simplify the construction operation, one observe some elements: Even if the sorting net is regarded as a directed graph, it represents in fact a set of disjoint trees: general trees in the distribution subnet, and binary trees in the test subnet; the coupling of these subnets is made by using the leaf nes. One use for simplicity three attributes of the nes to specify the links to the neighbour nes: left, right and down; As in RETE graphs, there are two types of nes in the test net: (a) one input nes, called also input nes (denoted by I and representing the leaf nes of the test trees), and (b) two input nes, which can be internal nes (denoted by IO) and internal nes (denoted by O, and representing the roots of the test trees); To specify the connections to the environment, two attributes are used for the input/output nes of the sorting net (specifying the associated ne of the High Level Petri Net): place for input nes, and transition for output nes. Denoting by p 1, p 2,..., p k the input places for a transition t, and by p lm the two input ne obtained from the ascats p l and p m, the order for nes generating (in the test tree for transition t) is: p 1, p 2, p 12, p 3, p 123, p 4, p 1234,..., p n, p 12...n. The root of the tree is p 12...n, for which: transition(p 12...n )=t. The leaf nes are: p 1, p 2,..., p n, for which: place(p i )=p i, i=1,2,..., n. The algorithm to create the test net is presented in function TestNetCreation: ne_list function TestNetCreation (output lq) initq(lq) for * t T do lq TestTreeCreation(t,lq) return lq Each test tree is created by using the function TestTreeCreation. The distribution net is generated having the list lq of the leaf nes of the test net as

4 input parameter, and the list lp of the root nes of the distribution trees as output parameter. ne_list function DistributionNetCreation(output lq) initq(lp) for * p P do n DistributionTreeCreation( p,lq) addq(lp,n) return lp A distribution tree represents in fact the root ne (whose place attribute points to the associated place of the High Level Petri Net) and a list of its descants (indicated by the attribute down). To manage both the tokens from the place markings, and the variable assignment of the occurrence me of a transition, the nes from the sorting net have two additionally attributes: tokens, which represents a multiset of constants, and variables, which represents a list of pairs of the form (variable-value). The tokens propagation is distinct in the two subnets: in the distribution net they are copied in the leaf nes, while in the test net they descs from level to level, if it is possible. When tokens reach an output ne, they activate the transition associated to that ne. The algorithm to add a multiset of tokens in a place of a High Level Petri Net is specied in the procedure AddTokensRete, which has two input parameters: the place and the multiset of tokens: procedure AddTokensRete(input p, e) q Search(lp,p) for * n down(q) do tokens(n) tokens(n) e tokens(place(n)) Match(p,L(p, transition(place(n))),var) variables(place(n)) var Propagate(place(n)) The function Search determines the input ne of the sorting net associated to the place p. The procedure Match(p, L(p,t), var) performs the matching process of the tokens from the marking M(p) with the expression L(p, t), the multiset of variables associated with the arc (p, t). The procedure Propagate propagates the multiset of tokens (as a result of the matching process) in the test net: procedure Propagate(input q) term false if ntype(q) O then q down(q) while term (ntype(q) O) do term Perform(q) q down(q) The variable term is used to determine when an internal ne founds a discordance between the assignments of a variable in two distinct places (by using the function Perform): logic function Perform(input q) if (left(q) λ) (right(q) λ) then if DifferentValues(variables( left(q)), variables( right(q))) then return false tokens(q) tokens(left(q)) tokens(right(q)) variables(q) variables(left(q)) variables(right(q)) if ntype(q) = O then variables(q) variables(q) AssignOut(transition(q)) α(transition(q)) variables(q) addq(enabled, transition(q))) return true In the case when the function Perform works on an output ne of the sorting net, and the matching is not failed, the transition associated this ne is added to the list of the enabled transitions. For simplicity one can assume that the list enabled is a global variable of the algorithm. To delete a multiset of constants from a place marking is similar to the adding operation, unless the fact that the tokens are not propagated in the sorting net. One can observe that the transition enabling operation is made in the procedure AddTokensRete by using the function Perform. The ring procedure calls these two procedures: procedure FiringTransitionRete( input t, a) for * p t do DelTokensRete(p,Eval(L(p,t))) for * p t do AddTokensReteT(p,Eval(L(t,p)))

5 The main algorithm rst generates the sorting net associated with the High Level Petri Net, initialises the sorting net, and calls the procedure ReteCycle: procedure ReteControl InitRete ReteCycle procedure InitRete lq TestNetCreation lp DistributionNetCreation(lq) initq(enabled) for * p P do if M 0 (p) Φ then AddTokensRete(p, M 0 (p)) procedure ReteCycle while enabled Φ do t 1 delq(enabled) FiringTransitionRete(t 1 ) 3. Conclusions A meth of implementing the semantics of High Level Petri Nets is presented, based on the inference algorithms of the rule-based systems. The using of this type of algorithms is possible because it was proved that for every High Level Petri Net a rule-based system exists, which is semantic equivalent. The most proposals use token-player algorithms for semantic implementation of Petri nets [12, 19, 23]. A token-player simulation algorithm for Petri nets can be simple described by an innite loop, at each step the enabled transitions are determined and one enabled transition is red. The main disadvantage is the fact that each iteration, all transition of the top level net must be tested [23]. An optimal alternative uses the launch places [19]. Every transition has assigned an input place, which is tested for enabling: if this place has a non-empty marking, the corresponding transition is possible to be enabled; else the transition is certainly non-enabled. The algorithms presented in this paper are based on the RETE algorithm for rule-based systems, and avoid the testing of all transitions for enabling determination. The tokens are propagated in the RETE graph, as much as possible; when tokens reach an output ne, they activate the transition associated to that ne. In this way, the presented algorithm is faster than a token-player algorithm. An important problem in the system melling is the language used to specify the Petri net, which describe the melled system. The most proposals in system melling with Petri nets, both text oriented and graphic oriented, describe the Petri net conguration, rather than the melled system [6, 8, 12, 15]. The language proposed in this paper uses the pruction rules formalism, having two main advantages: (a) it describes the working of the melled system, and (b) it allows to generate automatically the corresponding High Level Petri Net. References [1] Argewala T., Choed-Amphai Y. A synthesis rule for concurrent systems, Proc. Of the 15th Design Automation Conference, 1978, pp ; [2] Bauman R., Turano T.A. Pruction based language simulation of Petri nets, Simulation, 1986, vol. 47, pp ; [3] Brezovan M. A Formal denition of Hierarchical Hgh Level Petri Nets, Proc. of the International Symposium on Systems Theory, Robotics, Computers and Process Informatics, Craiova, 1998, pp ; [4] Bruno G., Marchetto G. Process-Translatable Petri Nets for the Rapid Prototyping of Process Control Systems, IEEE Trans. on Software Engineering, 1986, vol. 12, no. 2, pp ; [5] Christensen S., Toksvig J. DesignBeta V BETA Ce Segments in CP nets, Lecture Notes OO&CPN, nr. 5, Computer Science Department, Aarhus University, 1993; [6] Colom J.M., Silva M., Villarroel J.L. On software implementation of Petri nets and coloured Petri nets using high-level concurrent languages, European Workshop on Application and Theory of Petri nets, 1986, pp ; [7] Fiswick P.A. The Role of Process Abstraction in Simulation, IEEE Transactions on Systems, Man and Cybernetics, 1988, vol. 18, no. 1, pp ; [8] Fleischack H., Weber A. Rule-based programming, Predicate/Transition nets and the meling of the procedures and flexible manufacturing systems, Proc. of the 10th International Conference on Applications and Theory of Petri Nets, June, 1989; [9] Forgy C. RETE: A Fast Algorithm for Many Pattern/Many Objects, Articial Intelligence, 1982, vol. 19, pp ; [10] Jensen K., Christensen S., Huber P., Holla M. Design/CPN: A Reference Manual, MetaSoftware Corporation, 1992; [11] Jensen K. Coloured Petri Nets. Basic Concepts, Analysis Meths and Practical Use. Vol. 1: Basic Concepts, EATCS Monographs on Theoretical Computer Science, 1992; [12] Martinez J., Muro P.R., Silva M. Melling, Validation and Software Implementation of Pruction Systems Using High Level Petri Nets, Proc. of the IEEE International Conference in Robotics and Automation, 1987, pp ; [13] Martinez J.M., Muro P.R., Silva M., Snith S.F., Villarroel J.L., Merging articial intelligence techniques and Petri nets for real-time scheduling and control of

6 pruction systems, Proc. of the 12th IMACS World Congress on Scientic Computation, 1988, vol. 3, pp ; [14] Murata T., Zhang D. - A Predicate-Transition net mel for parallel interpretation of logic programs, IEEE Transactions on Software Engineering, 1988, vol. 14, no.1; [15] Nelson R.A. Haibt L.M. Sheridan P.B. Casting Petri Nets into Programs, IEEE Transactions on Software Engineering, 1983, vol. 9, no. 5, pp ; [16] Paludetto M., Raymaond S. A methology based on objects and Petri nets for development of realtime software, 1993, LAAS-CNRS, Tech. Rep ; [17] Peterka G., Murata T. Proof procedure and answer extraction in Petri net mel of logic programs, IEEE Transactions on Software Engineering, 1989, vol. 15, no.2; [18] Sahroui A., Atabakhche H., Courvoisier M., Valette R. Joining Petri Nets and Knowlwdge Based Systems for monitoring purposes, Proc. of the IEEE International Conference on Robotics and Automation, 1987, pp ; [19] Taubner D. On the Imlementation of Petri Nets, Lecture Notes in computer Science, 1988, vol. 340; [20] Thiagarajan P.S. Some Behavioural Aspects of Net Theory, Lecture Notes in Computer Science, 1988, vol. 317, pp ; [21] Valette R., Bako B. Software Implementation of Petri Nets and Compilation Rule-Based Systems, Lecture Notes in Computer Science, 1991, vol. 524, pp ; [22] Valette R., Cardoso J., Atabakhche H., Courvoisier M. Petri nets and pruction rules for decision levels in FMS control, Proc. of the 12th IMACS World Congress on Scientic Computation, 1988, vol. 3, pp ; [23] Valette R. Nets in pruction systems, Lecture Notes in Computer Science, 1986, vol. 255, pp ;