# A Pattern Based Method for Simplifying a BPMN Process Model

^{*}

## Abstract

**:**

## Featured Application

**To work with a simplified version of a BPMN model that condenses the information of interest can be very interesting from a human point of view (the understanding of the model is facilitated). Moreover, an optimised version of a BPMN model can yield in more efficient results for mining process software and data analytic techniques**.

## Abstract

## 1. Introduction

- Provide a cleaner and easier to understand graphic representation. Therefore, a better understanding with less effort of these workflows will be provided to human readers [7].
- Reduce the complexity of the model for its processing by software agents. An optimised version of a BPMN model will yield more efficient results for process mining software and data analytic techniques.

## 2. Related Work

## 3. Pattern Repository

#### 3.1. Repository Population

- Identify a set of pattern pairs that would substantially reduce a BPMN process model.
- Get the minimal set of them. Thus, greater efficiency is guaranteed when carrying out the search and replacement tasks performed by the simplification algorithm.

#### 3.2. Pattern Representation

**searchPattern**This method has to look for the reducible pattern in the model to simplify. If the pattern is found, it returns the point in the model in which the pattern has been identified.**reducePattern**This method has to simplify a pattern in a model (found previously by the previous method) by replacing the reducible pattern with the simplified pattern associated (that contains less elements).

- 1
`public interface``SimplifiablePattern {` - 2
`public``BpmnId searchPattern ( Bpmn model );` - 3
`public``Bpmn reducePattern ( Bpmn model , BpmnId startElmnt );` - 4
`}`

- 1
`public class``PA``implements``SimplifiablePattern {` - 2
`@Override` - 3
`public``BpmnId searchPattern ( Bpmn model ){` - 4
`ArrayList < BpmnExGateway > exGateways = model . getExclusiveGateways ();` - 5
`for``( BpmnExGateway gateway : exGateways )` - 6
`{` - 7
`ArrayList < BpmnId > outSequencesIds = gateway . getOutSequencesIds ();` - 8
`for``( BpmnId seqId : outSequencesIds )` - 9
`{``// check if some sequence returns to gateway` - 10
`BpmnId nextElmnt = model . getSequenceById ( seqId ). target ();` - 11
`if``( nextElmnt . equals ( gateway . getId ()))` - 12
`{``// Element found` - 13
`return new``BpmnId ( gateway . getId ());` - 14
`}` - 15
`}` - 16
`}` - 17
`return null``;` - 18
`}` - 19
- 20
`@Override` - 21
`public``Bpmn reducePattern ( Bpmn model , BpmnId start ){` - 22
`BpmnId gId = startElement ;` - 23
`BpmnExGateway gateway = model . getGatewayById ( gId );` - 24
`ArrayList < BpmnId > outSequencesIds = gateway . getOutSequencesIds ();` - 25
`for``( BpmnId seqId : outSequencesIds )` - 26 {
`// search all sequence returning to gateway` - 27
`BpmnId nextElmnt = model . getSequenceById ( seqId ). getTarget ();` - 28
`if``( nextElmnt . equals ( gateway . getId ()))` - 29
`{``// Element found` - 30
`model . deleteSequence ( seqId );` - 31
`gateway . deleteOutgoing ( seqId );` - 32
`gateway . deleteIncoming ( seqId );` - 33
`}` - 34
`}` - 35
`return``model ;` - 36
`}` - 37
`}`

## 4. Algorithm Description

- Operations performed by the client using a computer terminal (C).
- Operations involving interaction with the bank staff (BS).

#### 4.1. First Stage: Deleting Undesired Activities

- 1
`public``Bpmn firstStage ( Bpmn model , ArrayList < BpmnId > tasksToDeleteIds ){` - 2
`for``(Id taskToDeleteId : tasksToDeleteIds )` - 3
`{``// Search each task to delete ...` - 4
`BpmnTask task2Del = model . searchTaskById ( taskToDeleteId );` - 5
- 6
`// ... and delete it safetely` - 7
`model =``this``. deleteTask (model , task2Del );` - 8
`}` - 9
`return``model ;` - 10
`}` - 11
- 12
`// Deletes a task in a safetely way` - 13
`private``Bpmn deleteTask ( Bpmn model , BpmnTask task2Del ){` - 14
- 15
`// Search sequences Ids` - 16
`BpmnId inSeq = task2Del . getInSequenceId ();` - 17
`BpmnId outSeq = task2Del . getOutSequenceId ();` - 18
- 19
`// Search elements before / after these sequences` - 20
`BpmnId elmntBeforeTaskId = model . getSequenceById ( inSeq ). getSource ();` - 21
`BpmnId elmntAfterTaskId = model . getSequenceById ( outSeq ). getTarget ();` - 22
- 23
`// New connection skipping the activity` - 24
`model . createSequenceBetweenElements ( elmntBeforeTaskId , elmntAfterTaskId );` - 25
- 26
`// Delete activity and old sequences` - 27
`model . deleteTask ( task2Del );` - 28
`model . deleteSequence ( inSequenceId );` - 29
`model . deleteSequence ( outSequenceId );` - 30
- 31
`return``model ;` - 32
`}`

#### 4.2. Second Stage: Simplifying the Model

- 1
`public class``PatternsEngine` - 2
`{` - 3
`ArrayList < SimplifiablePattern > patterns ;` - 4
`int``current ;` - 5
- 6
`// Engine constructor` - 7
`PatternsEngine (){` - 8
`// Load dinamically all patterns in repository` - 9
`// Exception handling omited` - 10
`Reflections r =``new``Reflections (``" repository . package "``);` - 11
`Set <Class <?``extends``SimplifiablePattern >> repo =` - 12
`r. getSubTypesOf ( SimplifiablePattern .``class``);` - 13
- 14
`patterns =``new``ArrayList < >();` - 15
`for``(Class <?``extends``SimplifiablePattern > pat : repo ) {` - 16
`patterns .add (pat . newInstance ());` - 17
`}` - 18
`}` - 19
- 20
`// Simplify next pattern in the BPMN model` - 21
`public``Bpmn simplifyNext ( Bpmn model ){` - 22
`SimplifiablePattern aPattern = patterns . get ( current );` - 23
`if``(``this``. hasNext ()){` - 24
`currentPattern ++;` - 25
`}` - 26
`BpmnId startElmnt = aPattern . searchPattern ( model );` - 27
`if``( startElmnt !=``null``){` - 28
`model = aPattern . reducePattern (model , startElmnt );` - 29
`}` - 30
`return``model ;` - 31
`}` - 32
- 33
`public boolean``hasNext (){` - 34
`if``(currentPattern < patterns . size ())` - 35
`return true``;` - 36
`else` - 37
`return false``;` - 38
`}` - 39
- 40
`public void``rewindPatterns (){` - 41
`currentPattern = 0;` - 42
`}` - 43
`}`

## 5. Complexity

#### 5.1. Complexity Regarding the Size of the BPMN Model

#### 5.2. Complexity Regarding the Size of the Repository

## 6. Validation. Testing the Simplification

#### 6.1. Repository of BPMN Models and Inputs for the Algorithm

- 38 models have been translated from the Event-Driven Process Chains (EPC) model collection provided by Laue et al. that was used for the study [40].

- If at least one pattern has been identified and simplified, the number of elements in the simplified model must be less than the number of elements in the input model (regarding gateways and sequences).
- No wrong behaviour is introduced in the simplified model. The preserved activities must keep the causal dependency between them. If, for example, activity A is followed by activity B, but A never follows B, then it is assumed that there is a causal dependency between A and B (that must be preserved in the simplified model).

#### 6.2. How to Check the Causal Dependency?

- $a{>}_{M}b$ if only if there is a possible path $p=\langle {t}_{1},{t}_{2},\dots ,{t}_{n}\rangle $ and $i\in 1,\dots ,n-1$ such that $p\in M$ and ${t}_{i}=a$ and ${t}_{i+1}=b$. This relation is also known as “direct follows” relation.
- $a{\to}_{M}b$ if only if $a{>}_{M}b$ and ${b}_{M}a$
- $a{\#}_{M}b$ if only if ${a}_{M}b$ and ${b}_{M}a$
- ${a\parallel}_{M}b$ if only if $a{>}_{M}b$ and $b{>}_{M}a$

#### 6.3. Results

## 7. A Proof of Concept on a Real Scenario

## 8. Conclusions

## Author Contributions

## Funding

## Conflicts of Interest

## References

- Object Management Group (OMG). Business Process Model And Notation (BPMN); Version 2.0.2; OMG Document Number formal/13-12-09 2014. Available online: https://www.omg.org/spec/BPMN/2.0.2/PDF (accessed on 4 June 2019).
- Van Der Aalst, W.; Adriansyah, A.; De Medeiros, A.K.A.; Arcieri, F.; Baier, T.; Blickle, T.; Bose, J.C.; van den Brand, P.; Brandtjen, R.; Buijs, J.; et al. Process mining manifesto. In International Conference on Business Process Management; Springer: New York, NY, USA, 2011; pp. 169–194. [Google Scholar]
- Telang, P.R.; Kalia, A.K.; Singh, M.P. Modeling healthcare processes using commitments: An empirical evaluation. PLoS ONE
**2015**, 10, e0141202. [Google Scholar] [CrossRef] [PubMed] - Pillat, R.M.; Oliveira, T.C.; Alencar, P.S.; Cowan, D.D. BPMNt: A BPMN extension for specifying software process tailoring. Inf. Softw. Technol.
**2015**, 57, 95–115. [Google Scholar] [CrossRef] - Vaziri, R.; Mohsenzadeh, M.; Habibi, J. TBDQ: A Pragmatic Task-Based Method to Data Quality Assessment and Improvement. PLoS ONE
**2016**, 11, e0154508. [Google Scholar] [CrossRef] [PubMed] - Meyer, S.; Ruppen, A.; Hilty, L. The Things of the Internet of Things in BPMN. In International Conference on Advanced Information Systems Engineering; Springer: New York, NY, USA, 2015; pp. 285–297. [Google Scholar]
- Mendling, J.; Reijers, H.A.; van der Aalst, W.M. Seven process modeling guidelines (7PMG). Inf. Softw. Technol.
**2010**, 52, 127–136. [Google Scholar] [CrossRef] [Green Version] - Smirnov, S.; Reijers, H.A.; Weske, M.; Nugteren, T. Business process model abstraction: A definition, catalog, and survey. Distrib. Parallel Databases
**2012**, 30, 63–99. [Google Scholar] [CrossRef] - Bobrik, R.; Reichert, M.; Bauer, T. View-based process visualization. In Business Process Management; Springer: New York, NY, USA, 2007; pp. 88–95. [Google Scholar]
- Eshuis, R.; Grefen, P. Constructing customized process views. Data Knowl. Eng.
**2008**, 64, 419–438. [Google Scholar] [CrossRef] [Green Version] - Tsagkani, C.; Tsalgatidou, A. Abstracting BPMN models. In Proceedings of the 19th Panhellenic Conference on Informatics, Athens, Greece, 1–3 October 2015; pp. 243–244. [Google Scholar]
- McMaster, R.B.; Shea, K.S. Generalization in Digital Cartography; Association of American Geographers: Washington, DC, USA, 1992. [Google Scholar]
- Polyvyanyy, A.; Smirnov, S.; Weske, M. Reducing Complexity of Large EPCs. In Proceedings of the Lecture Notes in Informatics: Modellierung betrieblicher Informationssysteme, Gesellschaft für Informatik, Bonn, Saarbrücken, Germany, 27–28 November 2008; pp. 195–207. [Google Scholar]
- Polyvyanyy, A.; Smirnov, S.; Weske, M. On Application of Structural Decomposition for Process Model Abstraction. In Proceedings of the Business Process, Services Computing and Intelligent Service Management, Leipzig, Germany, 23–25 March 2009; pp. 110–122. [Google Scholar]
- Bobrik, R.; Reichert, M.; Bauer, T. Parameterizable Views for Process Visualization; University of Twente: Ernscott, The Netherlands, 2007. [Google Scholar]
- Van der Aalst, W.M. Formalization and verification of event-driven process chains. Inf. Softw. Technol.
**1999**, 41, 639–650. [Google Scholar] [CrossRef] - Sadiq, W.; Orlowska, M.E. Analyzing process models using graph reduction techniques. Inf. Syst.
**2000**, 25, 117–134. [Google Scholar] [CrossRef] - Rosa, M.L.; Van Der Aalst, W.M.; Dumas, M.; Milani, F.P. Business process variability modeling: A survey. ACM Comput. Surv. (CSUR)
**2017**, 50, 2. [Google Scholar] [CrossRef] - Hallerbach, A.; Bauer, T.; Reichert, M. Managing Process Variants in the Process Lifecycle. In Proceedings of the 10th International Conference on Enterprise Information Systems (ICEIS’08), Barcelona, Spain, 12–16 June 2008. [Google Scholar]
- Hallerbach, A.; Bauer, T.; Reichert, M. Guaranteeing soundness of configurable process variants in Provop. In Proceedings of the 2009 IEEE Conference on Commerce and Enterprise Computing, Vienna, Austria, 20–23 July 2009; pp. 98–105. [Google Scholar]
- Hallerbach, A.; Bauer, T.; Reichert, M. Issues in modeling process variants with provop. In International Conference on Business Process Management; Springer: New York, NY, USA, 2008; pp. 56–67. [Google Scholar]
- Hallerbach, A.; Bauer, T.; Reichert, M. Capturing variability in business process models: The Provop approach. J. Softw. Maint. Evolut. Res. Pract.
**2010**, 22, 519–546. [Google Scholar] [CrossRef] - Kumar, A.; Yao, W. Process materialization using templates and rules to design flexible process models. In International Workshop on Rules and Rule Markup Languages for the Semantic Web; Springer: New York, NY, USA, 2009; pp. 122–136. [Google Scholar]
- Kumar, A.; Yao, W. Design and management of flexible process variants using templates and rules. Comput. Ind.
**2012**, 63, 112–130. [Google Scholar] [CrossRef] - Russell, N.; van der Aalst, W.M.; ter Hofstede, A.H. Workflow Patterns: The Definitive Guide; MIT Press: Cambridge, MA, USA, 2016. [Google Scholar]
- Ramos-Merino, M.; Santos-Gago, J.M.; Álvarez-Sabucedo, L.M.; Alonso-Roris, V.M.; Sanz-Valero, J. BPMN-E2: A BPMN extension for an enhanced workflow description. Softw. Syst. Model.
**2018**. [Google Scholar] [CrossRef] - Mkaouer, M.W.; Kessentini, M.; Bechikh, S.; Cinnéide, M.Ó.; Deb, K. On the use of many quality attributes for software refactoring: A many-objective search-based software engineering approach. Empir. Softw. Eng.
**2016**, 21, 2503–2545. [Google Scholar] [CrossRef] - Morales, R.; Soh, Z.; Khomh, F.; Antoniol, G.; Chicano, F. On the use of developers’ context for automatic refactoring of software anti-patterns. J. Syst. Softw.
**2017**, 128, 236–251. [Google Scholar] [CrossRef] - Mansoor, U.; Kessentini, M.; Wimmer, M.; Deb, K. Multi-view refactoring of class and activity diagrams using a multi-objective evolutionary algorithm. Softw. Qual. J.
**2017**, 25, 473–501. [Google Scholar] [CrossRef] - Jensen, A.C.; Cheng, B.H. On the use of genetic programming for automated refactoring and the introduction of design patterns. In Proceedings of the 12th Annual Conference on Genetic and Evolutionary Computation, Portland, OR, USA, 7–11 July 2010; pp. 1341–1348. [Google Scholar]
- Khan, Y.A.; El-Attar, M. Using model transformation to refactor use case models based on antipatterns. Inf. Syst. Front.
**2016**, 18, 171–204. [Google Scholar] [CrossRef] - Küster, J.; Völzer, H.; Favre, C.; Branco, M.C.; Czarnecki, K. Supporting different process views through a shared process model. Softw. Syst. Model.
**2016**, 15, 1207–1233. [Google Scholar] [CrossRef] - Sahraoui, H.; Syriani, E. Recommending Model Refactoring Rules from Refactoring Examples. In Proceedings of the 21th ACM/IEEE International Conference on Model Driven Engineering Languages and Systems, Copenhagen, Denmark, 14–19 October 2018; pp. 257–266. [Google Scholar]
- Bodhuin, T.; Canfora, G.; Troiano, L. SORMASA: A tool for Suggesting Model Refactoring Actions by Metrics-led Genetic Algorithm. In Proceedings of the 1st Workshop on Refactoring Tools, WRT, Berlin, Germany, 30 July–3 August 2007; pp. 23–24. [Google Scholar]
- Camunda. BPMN Examples–Best Practices for Creating BPMN 2.0 Process Diagrams. 2018. Available online: https://camunda.com/bpmn/examples/ (accessed on 5 May 2019).
- Brosch, P.; Langer, P.; Seidl, M.; Wimmer, M. Towards end-user adaptable model versioning: The by-example operation recorder. In Proceedings of the 2009 ICSE Workshop on Comparison and Versioning of Software Models, Vancouver, BC, USA, 17 May 2009; pp. 55–60. [Google Scholar]
- Sun, Y.; Gray, J.; White, J. MT-Scribe: An end-user approach to automate software model evolution. In Proceedings of the 2011 33rd International Conference on Software Engineering (ICSE), Honolulu, HI, USA, 21–28 May 2011; pp. 980–982. [Google Scholar]
- Mariani, T.; Vergilio, S.R. A systematic review on search-based refactoring. Inf. Softw. Technol.
**2017**, 83, 14–34. [Google Scholar] [CrossRef] - Alotaibi, Y. Business process modelling challenges and solutions: A literature review. J. Intell. Manuf.
**2016**, 27, 701–723. [Google Scholar] [CrossRef] - Gruhn, V.; Laue, R. A heuristic method for detecting problems in business process models. Bus. Process Manag. J.
**2010**, 16, 806–821. [Google Scholar] [CrossRef] - Vázquez-Barreiros, B.; Mucientes, M.; Lama, M. ProDiGen: Mining complete, precise and minimal structure process models with a genetic algorithm. Inf. Sci.
**2015**, 294, 315–333. [Google Scholar] [CrossRef] - Vázquez-Barreiros, B.; Mucientes, M.; Lam, M. ProDiGen Software. From Log to Petri Net. 2015. Available online: http://tec.citius.usc.es/processmining/prodigen (accessed on 2 February 2019).
- Van Der Aalst, W. Process mining: Overview and opportunities. ACM Trans. Manag. Inf. Syst.
**2012**, 3, 7. [Google Scholar] [CrossRef] - Bose, R.; Van Der Aalst, W.M.; Zliobaite, I.; Pechenizkiy, M. Dealing with concept drifts in process mining. IEEE Trans. Neural Netw. Learn. Syst.
**2014**, 25, 154–171. [Google Scholar] [CrossRef] [PubMed] - Van der Aalst, W.; Weijters, T.; Maruster, L. Workflow mining: Discovering process models from event logs. IEEE Trans. Knowl. Data Eng.
**2004**, 16, 1128–1142. [Google Scholar] [CrossRef] - Van Der Aalst, W.M. Process Mining: Data Science in Action; Springer: New York, NY, USA, 2016. [Google Scholar]
- Ramos-Merino, M.; Santos-Gago, J.; Álvarez-Sabucedo, L.; de Arriba-Pérez, F.; Simplification of BPMN Process Models. Data Repository. 2019. Available online: https://osf.io/94scm/?view_only=4cebebc2e80c43fe94bb18bf16a3b95b (accessed on 17 April 2019).
- Sanz-Valero, J.; Sabucedo, L.Á.; Wanden-Berghe, C.; Roris, V.A.; Gago, J.S. Sun-pp236: Deployment of a tag-based system to ensure traceability management of parenteral nutrient mixtures. Clin. Nutr.
**2015**, 34, S111. [Google Scholar] [CrossRef] - Bernabeu-Martínez, M.A.; Merino, M.R.; Gago, J.M.S.; Sabucedo, L.M.Á.; Wanden-Berghe, C.; Sanz-Valero, J. Guidelines for safe handling of hazardous drugs: A systematic review. PLoS ONE
**2018**, 13, e0197172. [Google Scholar] [CrossRef] [PubMed] - Connor, T.H.; McDiarmid, M.A. Preventing occupational exposures to antineoplastic drugs in health care settings. CA Cancer J. Clin.
**2006**, 56, 354–365. [Google Scholar] [CrossRef] [PubMed] - Ramos-Merino, M.; Álvarez-Sabucedo, L.M.; Santos-Gago, J.M.; Sanz-Valero, J. A BPMN Based Notation for the Representation of Workflows in Hospital Protocols. J. Med. Syst.
**2018**, 42, 181. [Google Scholar] [CrossRef] [PubMed] - Khandke, S.; Mayes, T. HACCP implementation: A practical guide to the implementation of the HACCP plan. Food Control
**1998**, 9, 103–109. [Google Scholar] [CrossRef] - Rorís, V.M.A.; Sabucedo, L.M.Á.; Wanden-Berghe, C.; Gago, J.M.S.; Sanz-Valero, J. Towards a mobile-based platform for traceability control and hazard analysis in the context of parenteral nutrition: Description of a framework and a prototype app. JMIR Res. Protoc.
**2016**, 5, e57. [Google Scholar] [CrossRef] - Alonso-Rorís, V.M.; Álvarez-Sabucedo, L.; Santos-Gago, J.M.; Ramos-Merino, M. Towards a cost-effective and reusable traceability system. A semantic approach. Comput. Ind.
**2016**, 83, 1–11. [Google Scholar] [CrossRef] - Verbeek, H.; Buijs, J.; Van Dongen, B.; van der Aalst, W.M. Prom 6: The process mining toolkit. Proc. BPM Demonstr. Track
**2010**, 615, 34–39. [Google Scholar]

**Figure 8.**Opening a bank account. (

**a**) All the operations; (

**b**) Operations involving interaction with the bank staff.

**Figure 11.**Flow diagrams to analyse the complexity. (

**a**) Algorithm flow diagram; (

**b**) Patterns pair flow diagram; (

**c**) Search simplifiable pattern.

d | e | f | g | |
---|---|---|---|---|

d | ${\#}_{M1}$ | ${\to}_{M1}$ | ${\to}_{M1}$ | ${\#}_{M1}$ |

e | ${\leftarrow}_{M1}$ | ${\#}_{M1}$ | ${\#}_{M1}$ | ${\to}_{M1}$ |

f | ${\leftarrow}_{M1}$ | ${\#}_{M1}$ | ${\#}_{M1}$ | ${\to}_{M1}$ |

g | ${\#}_{M1}$ | ${\leftarrow}_{M1}$ | ${\leftarrow}_{M1}$ | ${\#}_{M1}$ |

d | e | f | g | |
---|---|---|---|---|

d | ${\#}_{M2}$ | ${\to}_{M2}$ | ${\to}_{M2}$ | ${\#}_{M2}$ |

e | ${\leftarrow}_{M2}$ | ${\#}_{M2}$ | ${\#}_{M2}$ | ${\to}_{M2}$ |

f | ${\leftarrow}_{M2}$ | ${\#}_{M2}$ | ${\#}_{M2}$ | ${\to}_{M2}$ |

g | ${\#}_{M2}$ | ${\leftarrow}_{M2}$ | ${\leftarrow}_{M2}$ | ${\#}_{M2}$ |

Original Model | Simplified Model | |||||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|

ID | Tasks | Gats | sFlows | Total | Tasks | Gats | sFlows | Total | A | B | C | D | E | Fitness |

... | . | . | . | . | . | . | . | . | . | . | . | . | . | . |

pm15_073 | 6 | 14 | 28 | 48 | 6 | 6 | 17 | 29 | 0 | 3 | 3 | 0 | 2 | 1.0 |

pm15_074 | 6 | 14 | 28 | 48 | 6 | 4 | 14 | 24 | 0 | 4 | 3 | 0 | 3 | 1.0 |

pm15_075 | 6 | 14 | 28 | 48 | 6 | 5 | 16 | 27 | 0 | 4 | 3 | 0 | 2 | 1.0 |

pm15_076 | 6 | 14 | 28 | 48 | 6 | 5 | 16 | 27 | 0 | 4 | 3 | 0 | 2 | 1.0 |

pm15_077 | 6 | 14 | 28 | 48 | 6 | 5 | 16 | 27 | 0 | 4 | 2 | 0 | 3 | 1.0 |

... | . | . | . | . | . | . | . | . | . | . | . | . | . | . |

Administration Method | Key on the Diagram | |
---|---|---|

Administration 1 | intravenous | TI |

Administration 2 | subcutaneous | TII |

Administration 3 | ophthalmic | TIII |

Administration 4 | urinary catheter | TIV |

© 2019 by the authors. Licensee MDPI, Basel, Switzerland. This article is an open access article distributed under the terms and conditions of the Creative Commons Attribution (CC BY) license (http://creativecommons.org/licenses/by/4.0/).

## Share and Cite

**MDPI and ACS Style**

Ramos-Merino, M.; Álvarez-Sabucedo, L.M.; Santos-Gago, J.M.; de Arriba-Pérez, F.
A Pattern Based Method for Simplifying a BPMN Process Model. *Appl. Sci.* **2019**, *9*, 2322.
https://doi.org/10.3390/app9112322

**AMA Style**

Ramos-Merino M, Álvarez-Sabucedo LM, Santos-Gago JM, de Arriba-Pérez F.
A Pattern Based Method for Simplifying a BPMN Process Model. *Applied Sciences*. 2019; 9(11):2322.
https://doi.org/10.3390/app9112322

**Chicago/Turabian Style**

Ramos-Merino, Mateo, Luis M. Álvarez-Sabucedo, Juan M. Santos-Gago, and Francisco de Arriba-Pérez.
2019. "A Pattern Based Method for Simplifying a BPMN Process Model" *Applied Sciences* 9, no. 11: 2322.
https://doi.org/10.3390/app9112322