Second International Symposium on Intelligent Information Technology Application
Formal Semantics of BPMN Process Models using YAWL JianHong YE1, 2 , ShiXin SUN1 , Wen SONG3 , LiJie WEN2, 4 1 School of Computer Science and Engineering, University of Electronic Science and Technology of China, Chengdu Sichuan 610054, China
[email protected],
[email protected] 2 Department of Mathematics and Computer Sciences, Eindhoven University of Technology, NL-5600 MB Eindhoven, The Netherlands 3 School of Mathematics and Computer Engineering, Xihua University,Chengdu Sichuan 610039, China
[email protected] 4 School of Software, Tsinghua University, Beijing 100084, China
[email protected] Abstract
[8, 10, 14, 5], most of them fail to fulfill the key completeness requirements. The translation are likely to require refinement as well as the semantics of the behavior of BPD graphical elements, which defeat the purpose of BPEL as a domain-specific language. Another attempt at defining a formal semantics for a subset of BPMN did so using Petri nets [9, 4, 12]. The semantics is defined as a mapping between BPMN models and Petri nets, the proposed provides a foundation to statically check the semantic correctness of BPMN models. However, their semantics does not properly model macro and message flows in BPMN. YAWL [1] is a workflow language proposed by Van der Aalst, ter Hofstede, Kiepuszewski and Barros. YAWL is gaining increasing attention for supporting a concise and powerful workflow language and handles complex data transformations. Despite its graphical nature, YAWL has a well defined formal semantics. It is a state-based language and the semantics of a workflow specification is defined as a transition system. Furthermore, being based on Petri nets, it provides a firm basis for the formal analysis of real-world services. In order to benefit from the expressive power of YAWL, a large amount business process models are mapping to YAWL, such as the Event-driven Process Chain (EPC) to YAWL [6] and BPEL to YAWL [2]. In prior work [15], we proposed a translation algorithm, which is focused on syntactic rules. Figure 1 and 2 summarizes the core subset of BPMN objects and the basic syntactic translation rules quote from [15]. However, the produced by this algorithm lacks formal semantic and the translation does not exploit the complex relation between BPMN elements. The semantic analysis of BPMN models is hindered by the heterogeneity of its constructs and the lack of an unambiguous definition of the notation. This paper takes on the challenge of defining a formal semantics for a
The Business Process Modeling Notation (BPMN) is an emerging standard for capturing business processes. However, BPMN lacks a formal semantics and many of its features are subject to interpretation, which is hindered the BPMN as a standard to statically check the semantic correctness of models. The fact that BPMN integrates constructs from graph-oriented process definition languages with features for macro of advanced constructs and the transmission of messages between two participants, make it challenging to provide a formal semantics of BPMN. Even more define a semantic that can be used to analyst BPMN models. This paper proposes a formal semantics of BPMN defined in terms of a mapping to YAWL nets, for which efficient analysis techniques exists. The proposed mapping has been implemented as a tool that generates code in the ProM.
1. Introduction The Business Process Modeling Notation (BPMN) [5] has emerged as a standard notation at the level of domain analysis and high-level systems design, BPMN consists of one diagram - called the Business Process Diagram (BPD). It offers a process flow modeling technique that is more conducive to the way business analysts model and its solid mathematical foundation is expressly designed to map to business execution languages. BPMN is already supported by more than 30 tools (see www.bpmn.org), but in its current form, BPMN lacks the semantic precision required to capture fully executable business processes. Close inspection of existing translation from BPMN to BPEL standard 978-0-7695-3497-8/08 $25.00 © 2008 IEEE DOI 10.1109/IITA.2008.68
70
Well-formed core BPMN. The proposed mapping not only serves the purpose of disambiguating the core constructs of BPMN, but it also provides a foundation to statically check the semantic correctness of BPMN models. We assume the reader is familiar with basic terminology of BPMN and YAWL. Abstracting from its concrete syntax, the core BPMN Process (BPD) and Well-formed core BPMN definition can refer to [15]. In this paper, We have excluded exception flows and only consider the well-formed core BPMN models. The simplified notation M = (O, P, L, F, M es) will be used for their representation. The rest of the paper is structured as follows. The complex relation is presented in Section 2. A mathematical definition of the mapping BPMN to YAWL is given in Section 3. Section 4 reports the corresponding tool implementation. Finally, Section 5 concludes and outlines future work.
these rules. Some special rule about the join or split attribute relating task (or composite task) and rules involving start event or end event are also exhibited. We required the BPMN model at least one start event s (or one end event e) has no incoming message (or outcoming message), i.e. at least one start event (or end event) can be kept as YAWL condition when the mapping executed. Otherwise, the model designer will need to determine which of the toplevel process start events is triggered initially or which of the situation will be finished. That will violate the seal principle in the process model design. Figure 4(5) depicts the examples of BPMN models breaks the dependency rule, which consist of two mutual process instantiation P1 , P2 , where each start event s in P1 has an incoming message flow from P2 and vice versa.
2 Complex mapping
We formally define the mapping of BPMN to YAWL (using set notations). To facilitate the definition, we introduce one auxiliary functions predecessor and successor.
3 Formal Semantics of the Mapping
Because of lacking semantics, the complex relation involving the activities attributes and the message flow is lost in the mapping algorithm [15]. This section presents a complement technique to translate BPMN activities and message flow to YAWL elements.
2.1
Definition 1 (Predecessor and Successor Nodes) Let O be a set of objects and Edge be a binary relation over O, Edge = F ∪ Cond. For each node o, we define the set of predecessor nodes • o = {x ∈ O | (x, o) ∈ Edge ∧ o ∈ O}, and the set of successor nodes o• = {x ∈ O | (o, x) ∈ Edge ∧ o ∈ O}.
Activities Macro and Ad-hoc construct
Definition 2 (YAWL semantics of BPMN models) Let M = (O, P, L, F, M es) be a well-formed core BPMN model. Without considering activities attributes and communication between interacting processes (message flow), M can be mapped to a preliminary YAWL Y = (C,Si, o, T, F low, split, join, rem, nof i) where: C = A∈M ({pi } ∪ {po }∪ {p|C −1 (p) ∈ εS ∨ C −1 (p) ∈ εE }) -start/end event i = {pi } -new YAWL input condition o = {p } -new YAWL output condition o S T = O∈M ({tin |• tin = pi ∧ C −1 (t•in ) ∈ εS } ∪ {tout |C −1 (• tout ) ∈ εE ∧ t•out = po }∪ {x|T −1 (x) ∈ A}∪ -task/subprocess −1 {tx |T (x) ∈ εI } ∪ {ty |T −1 (y) ∈ g}) -int.event/gateway F low = F ∪ (pi , tin ) ∪ {(tin , t)|T −1 (t) ∈ εS } ∪ −1 E (tout , po ) ∪ {(t, -sequence flows S tout )|T (t) ∈ ε } split = g∈O ({split(t) = AN D|T −1 (t) ∈ εAs } ∪ {split(t) = OR|T −1 (t) ∈ εOs } ∪ {split(t) = Xs −1 eXs XOR|T −1 (t) ∪ t = tin }) -fork S ∈ ε ∪ T (t) ∈ ε join = g∈O ({join(t) = AN D|T −1 (t) ∈ εAj } ∪ {join(t) = OR|T −1 (t) ∈ εOj } ∪ {join(t) = XOR|T −1 (t) ∈ εXj ∪ t = tout }) -merge rem = ∅ -without exception handling nof i = ∅ -without macro
An activity in a BPD can have attributes specifying its additional behavior, these attributes can be set to determine the values of nofi in the corresponding task in YAWL. Table 1 demonstrated how to map the BPMN attributes to the values of nofi. There is another special attribute for Ad-hoc subprocess activity. This attribute defines if the activities within the process can be performed in parallel or must be performed sequentially. Without lose the generality, the multiple instance attributes for activities in Ad-hoc subprocess can referred from Table 1. The example shown in Figure 3 considers each activity will be performed one at a time.
2.2
Message Flow
The information of pools and lanes will be lost in the conversion. However, some related information such as message flow should be inherited. Message flows are used to model message passing between organizations or applications. It can be mapped to a flow message in YAWL and modify some objects’ join or split attribute relating its input and output. Some special cases for the mapping involves the start event and end event. Figure 4(1) - (4) shows
71
BPMN Object
YAWL Object
YAWL Object
BPMN Object
Event
Start Event
End Event
Intermediate Event
T
Activity
(or Message E, Timer T, Exception Ex,
~ Task
Multiple Instance
Loop
Subprocess-Loop
(or) Data-based XOR Decision Gateway
Parallel Join Gateway
Parallel Fork Gateway
Gateway
SubprocessMultiple Instance
Subprocess
Cancel C)
SubprocessAd-hoc
XOR Merge Gateway
MesE
Inclusive Merge Gateway
Inclusive Decision Gateway
receive
TimT
Event-based XOR Decision Gateway Sequence Flow
T
T
Message Flow Default Flow
Message Flow
Figure 1. A core subset of BPMN elements
A outTask output
Process P2
input B
~ AdhocOrdering attribute set to Parallel AdhocCompletionCondition set to include the completion of Task “A” and “B”
Process P2
inTask
B
Process P1
Process P1
A
Figure 2. Basic BPMN to YAWL based on syntactic rules
A
A inTask
outTask
input
(5) multual process instantiaton dependency
output
Process P2
B
~ AdhocOrdering attribute set to Sequential AdhocCompletionCondition set to include the completion of Task “A” and “B”
Process P2
B
(3) end event to task(subprocess)
Process P1
Process P1
(1) task(subprocess) to task(subprocess)
Process P1
Condition Flow
Process P2
Normal Flow
(2) task(subprocess) to start event
Figure 3. Transformation of Ad-hoc subprocess with different attribute of AdhocOrdering
(4) end event to start event
Figure 4. BPMN message flow transformation to YAWL flow
Table 1. How to map the BPMN attributes to the values of nofi BPMN activity attributes LoopCondition
LoopType LoopMax standard standard
m m
TestTime
The expression xq3 should determine how many instances of activities are to be created The expression xq3 should determine how many instances of activities are to be created BPMN activity attributes
before after
YAWL task nofi nofi
[0, m, xq3 , static] [1, m, xq3 , static] YAWL task nofi
LoopType
LoopMax
MICondition
MIOrdering
MIFlow Condition
nofi
multiInstance
m
parallel
none
[n, m, m, static]
multiInstance
m
parallel
all
[m, m, m, static]
multiInstance
m
All activity instances should generate a token when the instance is completed The token should continue past the activity after all of the activity instances have completed Only one token can passed from the activity
parallel
one
[1, m, 1, static]
multiInstance dynamic The Expression should determine when and how parallel complex [xq1 , xq2 , xq3 , dynamic] many tokens will continue past the activity Note that the n, m is integer and the expression xqi (i = 1, 2, 3) is evaluated at run time to help determine how many instances of activities are to be created. The LoopCondition and MICondition will be replaced in a mathematical expression to be either tested as True or False or to be evaluated to update the value of Properties in actual use
72
Then, by taking into account activities attributes and message flows, M is fully mapped onto a YAWL net Y 0 = (C 0 , i0 , o0 , T 0 , F low0 , split0 , join0 , rem0 , nof i0 ) C 0 = C\{pdelS |(t, pdelS ) ∈ M es ∧ C −1 (pdelS ) ∈ S ε } ∪ {pdelE |(pdelE , t) ∈ M es ∧ C −1 (pdelE ) ∈ εE } ∪ {p(outdelE,indelS) |(poutdelE , pindelS ) ∈ M es ∧ C −1 (poutdelE ) ∈ εE ∧ C −1 (pindelS ) ∈ εS } -condition cancel @ Figure 4 i0 = i o0 = o T0 = T S F low0 = F ∪ (x,y)∈M es ({(x, y)|x ∈ A ∧ y ∈ A} ∪ {(x, y • )|x ∈ A ∧ y ∈ εS } ∪ {(• x, y)|x ∈ εE ∧ y ∈ A}∪{(• x, y • )|x ∈ εE ∧y ∈ εS })\({(tin , px ), (px , p•x )|x = delS ∨ indelS} ∪ {(py , tout ), (• py , py )|y = delE ∨ outdelE}) -adding message flow, cancel redundancy sequence flows S split0 = split ∪ = (x,y)∈M es ({split(t) AN D|T −1 (t) = x ∧ x ∈ A ∧ y ∈ O}) S join0 = join ∪ = (x,y)∈M es ({join(t) AN D|T −1 (t) = y ∧ y ∈ A ∧ x ∈ O}) rem0 = ∅ S nof i0 = = T −1 (t)=x∈A ({t.nof i [0, m, xq3 , static]|x.LoopCondition = xq3 ∧ x.T estT ime = bef ore} ∪ {t.nof i = [1, m, xq3 , static]|x.LoopCondition = xq3 ∧ x.T estT ime = af ter} ∪ {t.nof i = [n, m, m, static]|x.M ICondition = generateT oken ∧ x.M IF lowCondition = none} ∪ {t.nof i = [m, m, m, static]|x.M ICondition = continueT oken ∧ x.M IF lowCondition = all}{t.nof i = [1, m, 1, static]|x.M ICondition = oneT oken ∧ x.M IF lowCondition = one}{t.nof i = [xq1 , xq2 , xq3 , static]|x.LoopM ax = dynamic ∧ x.M ICondition = xqi , i = 1, 2, 3 ∧ x.M IF lowCondition = complex}) -adding macro
Figure 5. Examples of BPMN model (No.4) and transformation to YAWL nets in ProM XML file [13], which is a standardized file format for storing models and can be read by a number of YAWL modelling tools. We choose the YAWL editor2 as the analysis tools, which serves the exports XML file as input. Fig 5 shows a screenshot of ProM, showing the YAWL net mapped from the BPMN model (No.4). We tested BPMN2YAWL on a set of models3 , collected from the BPMN Web log1 , models distributed with the ILOG BPMN Process Modeler, and the others are designed by the authors. Table 2 shows the size of each tested BPMN models in terms of number of tasks, events, gateways, subprocesses and message flows. It also shows the size of the resulting YAWL-nets in terms of number of conditions, atomic tasks and composite tasks. BPMN2YAWL was able to deal with all the models, although preprocessing was needed to transform some of them into well-formed BPMN models, how to generate a well BPD refer to [11, 9, 3, 7]. We detected errors in models 1 and 2 which came from the BPMN Web log. Model 1 contained deaklock and model 2 contained incomplete process executions. Models 0, 3, 4 and 5 did not contain any errors. For space limitations, we do not detail these analysis. The latest version test files can be downloaded from web page3 . We invite the reader to download it and welcome additions to the software, it is an open-source initiative.
4 Empirical Evaluation The formalization from BPMN to YAWL presented in Section 3 serves as a specification for a tool that transforms BPMN models into YAWL nets. Combining with the syntactic translation rules in [15], we have implemented an open-source plug-in called BPMN2YAWL, which is available in ProM 5.0. Each reader interested in this field can use the http://www.processmining.org web page for a more complete overview. The tool takes the ILog BPMN Modeler1 as a graphical editor to create BPMN models. The transformation tool subsequently transforms the BPMN model into a YAWL net and exports the YAWL net as a
5 Conclusion and Future Work The lack of formal semantics of BPMN hinders on the development of tool support for checking the correctness of BPMN models from a semantic perspective. This paper has taken a first step to address this gap by providing a mapping from a comprehensive subset of BPMN to YAWL nets. The 2 http://www.yawl-system.com/ 3 This set of test models are included in the distribution of the BPMN2YAWL tool, http://is.tm.tue.nl/trac/prom/wiki/TestBPMN
1 http://www.ilog.com/products/jviews/diagrammer/bpmnmodeler/
73
Table 2. Results of implementing the mapping tool to existing models Model No. 0 1 2 3 4 5
BPMN Model YAWL net tasks events gateways subprocesses sequence flows message flows composite tasks atomic tasks conditions flows 5 4 9 7 6 15 6 5 2 3 8 2 3 16 12 30 20 10 5 6 30 9 6 47 20 81 20 4 28 22 6 34 2 2 2 6 6 4 10 2 4 3 1 6 4 10
mapping has been implemented in a tool and its application to verifying the soundness and liveness of BPMN models has been tested using the ProM framework. In future research, we aim to use this transformation to convert the whole BPMN process models and analyze them with verification tools for YAWL such as WofYAWL [12]. This will provide insight into the correctness of large enterprise models described in BPMN. We also plan to investigate process mining using BPMN processes as examples and focusing on the OR-join semantic particularities of BPMN.
[7] N. Kavantzas, D. Burdett, G. Ritzinger, T. Fletcher, and Y. Lafon. Web Services Choreography Description Language 1.0. Technical report, W3C Candidate Recommendation, 2005. [8] C. Ouyang, M. Dumas, A. Hofstede, and W. Aalst. Patternbased Translation of BPMN Process Models to BPEL Web Services. In International Journal of Web Service Research, 2007. [9] Y. Peter and J. Gibbons. A Process Semantics for BPMN. Technical report, Oxford University Computing Laboratory, 2007. [10] J. Recker and J. Mendling. On the Translation between BPMN and BPEL. In J. Krogstie, T. Halpin, and H. Proper, editors, Proceedings of the Workshop on Exploring Modeling Methods for Systems Analysis and Design (EMMSAD’06), held in conjunctiun with the 18th Conference on Advanced Information Systems (CAiSE’06), Luxembourg, Luxembourg, EU, pages 521–532. Namur University Press, Namur, Belgium, EU, 2006. [11] M. Remco, M. Dumas, and C. Ouyang. Formal Semantics and Analysis of BPMN Process Models using Petri Nets. Technical report, Queensland University of Technology, 2007. [12] H. Verbeek and W. Aalst. Woflan 2.0: A Petri-net-based Workflow Diagnosis Tool. In M. Nielsen and D. Simpson, editors, Application and Theory of Petri Nets 2000, volume 1825 of Lecture Notes in Computer Science, pages 475–484. Springer-Verlag, Berlin, 2000. [13] WFMC. Workflow Management Coalition Workflow Standard: Workflow Process Definition Interface-XML Process Definition Language (XPDL) (WFMC-TC-1025). Technical report, Workflow Management Coalition, 2002. [14] S. White. Using BPMN to Model a BPEL Process. Technical report, BPTrends, 2005. [15] J. Ye, S. Sun, L. Wen, and S. Wen. Transformation of BPMN to YAWL. In H. Zhou, editor, 2008 International Conference on Computer Science and Software Engineering, CSSE 2008, pages 23–29. IEEE Computer Society, 2008.
Acknowledgement This work is supported by the China Scholarship Council (No. 20073020) and the Project of National Natural Science Foundation of China (No. 60473030). The authors would like to thank W.M.P. van der Aalst for his valuable instruction. We would particularly like to thank Remco M.Dijkman for his remark in the BPMN semantics. Finally, we would like to thank the reviewers for their valuable suggestions.
References [1] W. Aalst and A. Hofstede. YAWL: Yet Another Workflow Language. Information Systems, 30:245–275, 2005. [2] B. Anotnio and P. Razvan. From BPEL Processes to YAWL Workflows. In Proceedings of the 3 rd International Workshop on Web Services and Formal Methods (WS-FM 2006), volume 4184 of Lecture Notes in Computer Science, pages 107–122. Springer Berlin / Heidelberg, 2006. [3] J. Camara, C. Canal, J. Cubo, and A. Vallecillo. Formalizing WSBPEL Business Process using Process Algebra. In CONCUR’2005 Workshop on the Foundations of Coordination Languages and Software Architectures, volume ENTCS 154, pages 159–173. Elsevier, 2005. [4] M. Dumas, A. Grosskopf, T. Hettel, and M. Wynn. Semantics of Standard Process Models with OR-Joins. Technical report, Queensland University of Technology, 2007. [5] O. M. Group. Business Process Modeling Notation (BPMN) Version 1.0. OMG Final Adopted Specification. Object Management Group, 2006. [6] M. Jan, M. Michael, and N. Gustaf. Transformation of yEPC business process models to YAWL. In Proceedings of the 2006 ACM symposium on Applied computing (SAC ’06). ACM, 2006.
74
