Automated Process Discovery
- 386 Downloads
An event log contains a historical record of the steps taken in a business process. An event log consists of traces, one for each case, customer, order, etc. in the process. A trace contains events, which represent the steps (activities) that were taken for a particular case, customer, order, etc.
An example of an event log derived from an insurance claim handling process is [〈receive claim, check difficulty, decide claim, notify customer〉10, 〈receive claim, check difficulty, check fraud, decide claim, notify customer〉5]. This event log consists of 15 traces, corresponding to 15 claims made in the process. In 10 of these traces, the claim was received, its difficulty assessed, the claim was decided and the customer was notified.
A workflow net is a Petri net with an initial place (without incoming arcs), a final place (without outgoing arcs) and every place and transition lying on a path between these places. The behaviour of a workflow net is clear: a token is put in the initial place, and every sequence of transitions firings that leads to a token in the final place and nowhere else, is a trace of the behaviour of the net.
A workflow net is sound if the net is free of deadlocks, unexecutable transitions and other anomalies (van der Aalst 2016). A workflow net is relaxed sound if there is a sequence of transition firings that lead to a token in the final place and nowhere else.
Automated process discovery aims to extract information from recorded historical information about business processes by means of automatic methods. In this chapter, we discuss challenges and algorithms for process discovery.
Automated Process Discovery
Organisations nowadays store considerable amounts of data: in many business processes such as for booking a flight, lodging an insurance claim or hiring a new employee, every step is supported and recorded by an information system. From these information systems, event logs can be extracted, which contain the steps that were taken for a particular customer, booking, claim, etc. Process mining aims to derive information and insights from these event logs.
Many process mining techniques depend on the availability of a process model. Process models can be elicited by hand, however this can be a tedious and error-prone task. Instead, if event logs are available, these can be used to discover a process model automatically.
In this chapter, the research field of algorithms that automatically discover process models from event logs is described. First, quality criteria for models are discussed, and how algorithms might have to tradeoff between them. Second, process discovery algorithms are discussed briefly.
Quality Criteria & Tradeoffs
The quality of a discovered model can be assessed using several concepts: whether it possesses clear semantics, whether it is simple, how well it represents the event log and how well it represents the process.
Semantics & Soundness
As a first quality criterion, the behaviour described by the model should be clear. That is, it should be clear which traces the model can produce. If the returned model is a Petri net or a BPMN model, this model should be free of deadlocks, unexecutable transitions and other anomalies (it should be sound (van der Aalst 2016)). While unsound nets can be useful for manual analysis, they should be used with care in automated analyses as, for instance, conformance checking techniques might give unreliable answers or simply not work on unsound nets. At a bare minimum, conformance checking techniques such as alignments (Adriansyah 2014) require relaxed sound models.
Second, given two models, all other things equal, the simplest model is usually the best of the two (a principle known as Occam’s razor). That is, a model should be as understandable as possible, for instance sma.
Third, one can consider the quality of a discovered model with respect to the event log from which it was discovered, to assess whether the model represents the available information correctly. Typically, besides simplicity, three quality dimensions are considered: fitness, precision and generalisation. Fitness expresses the part of the event log that is captured in the behaviour of the process model. Precision expresses the part of the behaviour of the model that is seen in the event log. Generalisation expresses what part of future behaviour will be likely present in the model.
The models shown for L illustrate that process discovery algorithms might have to tradeoff and strike a balance between quality criteria. For some event logs, a model scoring high on all log-quality measures and simplicity might not exist (Buijs et al. 2012b). The necessary balance might depend on the use case at hand. For instance, manual analysis where the “main flow” of a process is sought might require the omittance of the last trace of L from the model, yielding a simple and precise model. However, for auditing purposes, one might opt for a perfectly fitting model by including this last trace of L in the behaviour of the model.
A downside of measuring the quality of a model with respect to the event log is that an event log contains only examples of behaviour of an (unknown) business process rather than the full behaviour, and that the log might contain traces that do not correspond to the business process (noisy traces). Therefore, one can also consider how it compares to the process from which the event log was recorded. In the ideal case, the behaviour of the process is rediscovered by a discovery algorithm. That is, the behaviour (language) of the model is the same as the behaviour of the process.
As the business process is assumed to be unknown, whether an algorithm can find a model that is behaviourally equivalent to the process (rediscoverability) is a formal property of the algorithm. Without rediscoverability, an algorithm is unable to find a model equivalent to the process, which makes the algorithm rather unsuitable to study this process.
Rediscoverability is typically proven using assumptions on the process and the event log, for instance that it is representible as a model in the formalism of the algorithm (Petri nets, BPMN), and for instance that the event log contains enough information and does not contain too much noise, as well as assumptions on the process.
Process Discovery Algorithms
In this section, a selection of process discovery algorithms is discussed. For each algorithm, the algorithmic idea is described briefly, as well as some general advantages and disadvantages, and where it can be downloaded.
For benchmarks and a more exhaustive overview, please refer to Augusto et al. (2017b) (algorithms after 2012) and Weerdt et al. (2012) (algorithms before 2012). Not all algorithms can be benchmarked reliably; the selection here contains all benchmarked algorithms of Augusto et al. (2017b).
Several of these algorithms are available in the ProM framework (van Dongen et al. 2005), which is available for download from http://www.promtools.org, or in the Apromore suite (Rosa et al. 2011), which can be accessed via http://apromore.org.
The algorithms are discussed in three stages: firstly, algorithms that do not support concurrency, secondly algorithms that guarantee soundness and thirdly the remaining algorithms.
Directly Follows-Based Techniques
As a first set, techniques based on the directly follows relations are discussed. The section starts with an explanation of directly follows graphs, after which some tools that use this concept are listed and the limitations of such techniques are discussed.
For more complicated processes, a directly follows graph might get uncomprehensibly complicated. Therefore, discovery techniques typically filter the directly follows graph, for instance by removing little-occurring edges. Commercial techniques that filter and show directly follows graphs include Fluxicon Disco (Fluxicon 2017), Celonis Process Mining (Celonis 2017) and ProcessGold Enterprise Platform (ProcessGold 2017). Another strategy to reduce complexity, applied by the Fuzzy Miner (Günther and van der Aalst 2007), is to cluster similar activities into groups, thereby providing capabilities to zoom in on details of the process (by clustering less), or to abstract to the main flow of the process by clustering more.
While these graphs are intuitive, it can be challenging to distinguish repetitive and concurrent behaviour, as both manifest as edges forth- and back between activities. For instance, in Fig. 6, it seems that b, c and d can be executed repeatedly, while in the log L this never happened for d. In contrast, it also seems that b, c and d are concurrent, while in L, b and c are always executed repeatedly. Due to this, directly follows graphs tend to have a low precision and high generalisation: in our example, almost any sequence of b, c and d is included.
Nevertheless, directly follows-based techniques are often used to get a first idea of the process behind an event log.
Soundness is a prerequisite for further automated or machine-assisted analysis of business process models. In this section, soundness or relaxed soundness guaranteeing algorithms are discussed.
Evolutionary Tree Miner
To address the issue of soundness, the Evolutionary Tree Miner (ETM) (Buijs et al. 2012a) discovers process trees. A process tree is an abstract hierarchical view of a workflow net and is inherently sound.
ETM first constructs an initial population of models; randomly or from other sources. Second, some models are selected based on fitness, precision, generalisation and simplicity with respect to the event log. Third, the selected models are smart-randomly mutated. This process of selection and mutation is repeated until a satisfactory model is found, or until time runs out.
ETM is flexible as both the selection and the stopping criteria can be adjusted to the use case at hand; one can prioritise (combinations of) quality criteria. However, due to the repeated evaluation of models, on large event logs of complex processes, stopping criteria might force a user to make the decision between speed and quality.
Inductive Miner Family
The Inductive Miner (IM) family of process discovery algorithms, like the Evolutionary Tree Miner, discovers process trees to guarantee that all models that are discovered are sound. The IM algorithms apply a recursive strategy: first, the “most important” behaviour of the event log is identified (such as sequence, exclusive choice, concurrency, loop, etc.). Second, the event log is split in several parts, and these steps are repeated until a base case is encountered (such as a log consisting of a single activity). If no “most important” behaviour can be identified, then the algorithms try to continue the recursion by generalising the behaviour in the log, in the worst case ultimately ending in a flower model.
Besides a basic IM (Leemans et al. 2013a), algorithms exist that focus on filtering noise (Leemans et al. 2013b), handling incomplete behaviour (when the event log misses crucial information of the process) (Leemans et al. 2014a), handling lifecycle information of events (if the log contains information of e.g. when activities started and ended) (Leemans et al. 2015), discovering challenging constructs such as inclusive choice and silent steps (Leemans 2017), and handling very large logs and complex processes (Leemans et al. 2016), all available in the ProM framework.
Several IM-algorithms guarantee to return a model that perfectly fits the event log, and all algorithms are capable of rediscovering the process, assuming that the process can be described as a process tree (with some other restrictions, such as no duplicated activities) and assuming that the event log contains “enough” information. However, due to the focus on fitness, precision tends to be lower on event logs of highly unstructured processes.
All Inductive Miner algorithms are available as plug-ins of the ProM framework, and some as plug-ins of the Apromore framework. Furthermore, the plug-in Inductive visual Miner (Leemans et al. 2014b) provides an interactive way to apply these algorithms and perform conformance checking.
An algorithm that uses a similar recursive strategy, but lets constructs compete with one another is the Constructs Competition Miner (Redlich et al. 2014), however its implementation has not been published.
The Structured Miner (STM) (Augusto et al. 2016) applies a different strategy to obtain highly block-structured models and to tradeoff the log quality criteria. Instead of discovering block-structured models directly, SM first discovers BPMN models and, second, structures these models. The models can be obtained from any other discovery technique, for instance Heuristics Miner or Fodina, as these models need not be sound. These models are translated to BPMN, after which they are made block-structured by shifting BPMN-gateways in or out, thereby duplicating activities.
STM benefits from the flexibility of the used other discovery technique to strike a flexible balance between log-quality criteria and can guarantee to return sound models. However, this guarantee comes at the price of equivalence (the model is changed, not just restructured), simplicity (activities are duplicated) and speed (the restructuring is O(n n )).
STM is available as both a ProM and an Apromore plugin.
(Hybrid) Integer Linear Programming Miner
The Integer Linear Programming Miner (ILP) van der Werf et al. (2009) constructs a Petri net, starting with all activities as transitions and no places, such that every activity can be arbitrarily executed. Second, it adds places using an optimisation technique: a place is only added if it does not remove any trace of the event log from the behaviour of the model. Under this condition, the behaviour is restricted as much as possible.
ILP focusses on fitness and precision: it guarantees to return a model that fits the event log, and the most precise model within its representational bias (Petri nets, no duplicated activities). However, the ILP miner does not guarantee soundness, does not handle noise and tends to return complex models (Leemans 2017).
The first of these two have been addressed in the HybridILPMiner (van Zelst et al. 2017), which performs internal noise filtering. Furthermore, it adjusts the optimisation step to guarantee that the final marking is always reachable, and, in some cases, returns workflow nets, thereby achieving relaxed soundness.
Petri nets and BPMN models express what can happen when executing the model. In contrast, declarative models, such as Declare models, express what cannot happen when executing the model, thereby providing greater flexibility in modelling. Declare miners such as Maggi et al. (2011), Di Ciccio et al. (2016), and Ferilli et al. (2016) discover the constraints of which Declare models consist using several acceptance criteria, in order to be able to balance precision and fitness. However, using such models in practice tends to be challenging (Augusto et al. 2017b).
Unsound models are unsuitable for futher automated processing, however might be useful for manual analysis. In the remainder of this section, several algorithms are discussed that do not guarantee soundness.
The first process discovery algorithm described was the α-algorithm (van der Aalst et al. 2004). The α algorithm considers the directly follows graph and identifies three types of relations between sets of activities from the graph: sequence, concurrency and mutual exclusivity. From these relations, a Petri net is constructed by searching for certain maximal patterns.
The α algorithm is provably (Badouel 2012) able to rediscover some processes, assuming that the log contains enough information and with restrictions on the process. In later versions, several restrictions have been addressed, such as: (a) no short loops (activities can follow one another directly; addressed in α+ (de Medeiros et al. 2004)), (b) no long-distance dependencies (choices later in the process depend on choices made earlier; addressed in Wen et al. (2006)), (c) no non-free-choice constructs (transitions that share input places have the same input places; addressed in α++ (Wen et al. 2007a)), and (d) no silent transitions (addressed in α # (Wen et al. 2007b, 2010) and in α $ (Guo et al. 2015)). Furthermore, a variant has been proposed, called the Tsinghua-α (Wen et al. 2009), that deals with non-atomic event logs. That is, event logs in which executions of activities take time.
However, these algorithms guarantee neither soundness nor perfect fitness nor perfect precision, the algorithms cannot handle noise and cannot handle incompleteness. Furthermore, the α algorithms might be less fast on complex event logs, as typically they are exponential. Therefore, the α-algorithms are not very suitable to be applied to real-life logs.
Little Thumb (Weijters and van der Aalst 2003) extends the α algorithms with noise-handling capabilities: instead of considering binary activity relations, these relations are derived probabilistically and then filtered according to a user-set threshold.
The Flexible Heuristics Miner (FHM) (Weijters and Ribeiro 2011) uses the probabilistic activity relations of Little Thumb and focuses on soundness. To solve the issue of soundness, FHM returns causal nets, a model formalism in which it is defined that non-sound parts of the model are not part of the behaviour of the net.
The Fodina algorithm (vanden Broucke and Weerdt 2017) extends FHM with long-distance dependency support and, in some cases, duplicate activities. The Proximity miner (Yahya et al. 2016) extends FHM by incorporating domain knowledge. For more algorithms using causal nets, please refer to Weerdt et al. (2012) and Augusto et al. (2017b).
Even though causal nets are sound by definition, they place the burden of soundness checking on the interpreter/user of the net, and this still does not guarantee, for instance, that every activity in the model can be executed. Therefore, translating a causal net to a Petri net or BPMN model for further processing does not guarantee soundness of the translated model.
To strike a different balance in log-quality criteria compared to IM that favours fitness, while improving in speed over ETM, Split Miner (SPM) (Augusto et al. 2017a) preprocesses the directly follows graph before constructing a BPMN model. In the preprocessing of directly follows graphs, first, loops and concurrency are identified and filtered out. Second, the graph is filtered in an optimisation step: each node must be on a path from start to end, the total number of edges is minimised, while the sum of edge frequencies is maximised. Then, splits and joins (BPMN gateways) are inserted to construct a BPMN model.
SPM aims to improve over the precision of IM and the speed of ETM for real-life event logs. The balance between precision and fitness can be adjusted in the directly follows-optimisation step, which allows users to adjust the amount of noise filtering. However, the returned models are not guaranteed to be sound (proper completion is not guaranteed), and several OR-joins might be inserted, which increases complexity.
SPM is available as a plug-in of Apromore and as a stand-alone tool via https://doi.org/10.6084/m9.figshare.5379190.v1.
Many process mining techniques require a process model as a prerequisite. From an event log, process discovery algorithms aim to discover a process model, this model preferably having clear semantics, being sound, striking a user-adjustable balance between fitness, precision, generalisation and simplicity, and having confidence that the model represents the business process from which the event log was recorded. Three types of process discovery algorithms were discussed: directly follows-based techniques, soundness-guaranteeing algorithms and other algorithms, all targetting a subset of these quality criteria.
In explorative process mining projects, choosing a discovery algorithm and its parameters is a matter of repeatedly trying soundness-guaranteeing algorithms, evaluating their results using conformance checking and adjusting algorithm, parameters and event log as new questions pop up (van Eck et al. 2015).
- Adriansyah A (2014) Aligning observed and modeled behavior. PhD thesis, Eindhoven University of TechnologyGoogle Scholar
- Augusto A, Conforti R, Dumas M, Rosa ML, Bruno G (2016) Automated discovery of structured process models: discover structured vs. discover and structure. In: Comyn-Wattiau I, Tanaka K, Song I, Yamamoto S, Saeki M (eds) Conceptual modeling – Proceedings of the 35th international conference, ER, Gifu, 14–17 Nov 2016. Lecture notes in computer science, vol 9974, pp 313–329. http://doi.org/10.1007/978-3-319-46397-1_25
- Augusto A, Conforti R, Dumas M, Rosa ML (2017a) Split miner: discovering accurate and simple business process models from event logs. In: IEEE international conference on data mining, New Orleans. https://eprints.qut.edu.au/110153/
- Augusto A, Conforti R, Dumas M, Rosa ML, Maggi FM, Marrella A, Mecella M, Soo A (2017b) Automated discovery of process models from event logs: review and benchmark. CoRR abs/1705.02288, http://arxiv.org/abs/1705.02288
- Badouel E (2012) On the α-reconstructibility of workflow nets. In: Haddad S, Pomello L (eds) Application and theory of Petri Nets – Proceedings of the 33rd international conference, PETRI NETS, Hamburg, 25–29 June 2012. Lecture notes in computer science, vol 7347. Springer, pp 128–147. http://doi.org/10.1007/978-3-642-31131-4_8
- Buijs JCAM, van Dongen BF, van der Aalst WMP (2012a) A genetic algorithm for discovering process trees. In: Proceedings of the IEEE congress on evolutionary computation, CEC, Brisbane, 10–15 June 2012. IEEE, pp 1–8. http://doi.org/10.1109/CEC.2012.6256458
- Buijs JCAM, van Dongen BF, van der Aalst WMP (2012b) On the role of fitness, precision, generalization and simplicity in process discovery. In: Meersman R, Panetto H, Dillon TS, Rinderle-Ma S, Dadam P, Zhou X, Pearson S, Ferscha A, Bergamaschi S, Cruz IF (eds) On the move to meaningful internet systems: OTM 2012, Proceedings of the confederated international conferences: CoopIS, DOA-SVI, and ODBASE, Rome, part I, 10–14 Sept 2012. Lecture notes in computer science, vol 7565. Springer, pp 305–322. http://doi.org/10.1007/978-3-642-33606-5_19
- Celonis (2017) Process mining. https://www.celonis.com/. [Online; Accessed 11 Nov 2017]
- DBL (2011) Proceedings of the IEEE symposium on computational intelligence and data mining, CIDM 2011, part of the IEEE symposium series on computational intelligence, 11–15 Apr 2011. IEEE, Paris. http://ieeexplore.ieee.org/xpl/mostRecentIssue.jsp?punumber=5937059
- de Medeiros AKA, van Dongen BF, van der Aalst WMP, Weijters AJMM (2004) Process mining for ubiquitous mobile systems: an overview and a concrete algorithm. In: Baresi L, Dustdar S, Gall HC, Matera M (eds) Ubiquitous mobile information and collaboration systems, second CAiSE workshop, UMICS, Riga, 7–8 June 2004, Revised selected papers. Lecture notes in computer science, vol 3272. Springer, pp 151–165. http://doi.org/10.1007/978-3-540-30188-2_12
- Di Ciccio C, Maggi FM, Mendling J (2016) Efficient discovery of target-branched declare constraints. Inf Syst 56:258–283. http://doi.org/10.1016/j.is.2015.06.009
- Ferilli S, Esposito F, Redavid D, Angelastro S (2016) Predicting process behavior in woman. In: Adorni G, Cagnoni S, Gori M, Maratea M (eds) AI*IA 2016: advances in artificial intelligence – Proceedings of the XVth international conference of the Italian association for artificial intelligence, Genova, 29 Nov–1 Dec 2016. Lecture notes in computer science, vol 10037. Springer, pp 308–320. http://doi.org/10.1007/978-3-319-49130-1_23
- Fluxicon (2017) Disco. http://fluxicon.com, [Online; Accessed 11 Nov 2017]
- Günther C, van der Aalst W (2007) Fuzzy mining–adaptive process simplification based on multi-perspective metrics. Business process management. Springer, Berlin/Heidelberg, pp 328–343Google Scholar
- Guo Q, Wen L, Wang J, Yan Z, Yu PS (2015) Mining invisible tasks in non-free-choice constructs. In: Motahari-Nezhad HR, Recker J, Weidlich M (eds) Business process management – Proceedings of the 13th international conference, BPM, Innsbruck, 31 Aug–3 Sept 2015. Lecture notes in computer science, vol 9253. Springer, pp 109–125. http://doi.org/10.1007/978-3-319-23063-4_7
- Leemans S (2017) Robust process mining with guarantees. PhD thesis, Technische Universiteit EindhovenGoogle Scholar
- Leemans SJJ, Fahland D, van der Aalst WMP (2013a) Discovering block-structured process models from event logs – a constructive approach. In: Colom JM, Desel J (eds) Application and theory of Petri Nets and concurrency – Proceedings of the 34th international conference, PETRI NETS, Milan, 24–28 June 2013. Lecture notes in computer science, vol 7927. Springer, pp 311–329. http://doi.org/10.1007/978-3-642-38697-8_17
- Leemans SJJ, Fahland D, van der Aalst WMP (2013b) Discovering block-structured process models from event logs containing infrequent behaviour. In: Lohmann N, Song M, Wohed P (eds) Business process management workshops – BPM 2013 international workshops, Beijing, 26 Aug 2013, Revised papers. Lecture notes in business information processing, vol 171. Springer, pp 66–78. http://doi.org/l10.1007/978-3-319-06257-0_6
- Leemans SJJ, Fahland D, van der Aalst WMP (2014a) Discovering block-structured process models from incomplete event logs. In: Ciardo G, Kindler E (eds) Application and theory of Petri Nets and concurrency – Proceedings of the 35th international conference, PETRI NETS, Tunis, 23–27 June 2014. Lecture notes in computer science, vol 8489. Springer, pp 91–110. http://doi.org10.1007/978-3-319-07734-5_6
- Leemans SJJ, Fahland D, van der Aalst WMP (2014b) Process and deviation exploration with inductive visual miner. In: Limonad L, Weber B (eds) Proceedings of the BPM demo sessions 2014, co-located with the 12th international conference on business process management(BPM), Eindhoven, 10 Sept 2014, CEUR-WS.org, CEUR workshop proceedings, vol 1295, p 46. http://ceur-ws.org/Vol-1295/paper19.pdf
- Leemans SJJ, Fahland D, van der Aalst WMP (2015) Using life cycle information in process discovery. In: Reichert M, Reijers HA (eds) Business process management workshops – BPM, 13th international workshops, Innsbruck, 31 Aug–3 Sept 2015, Revised papers. Lecture notes in business information processing, vol 256. Springer, pp 204–217. http://doi.org/10.1007/978-3-319-42887-1_17
- Leemans SJJ, Fahland D, van der Aalst WMP (2016) Scalable process discovery and conformance checking. Softw Syst Model Special issue:1–33. http://doi.org/10.1007/s10270-016-0545-x
- OMG (2011) Business process model and notation (BPMN) version 2.0. Technical report, Object management group (OMG)Google Scholar
- ProcessGold (2017) Enterprise platform. http://processgold.com/en/, [Online; Accessed 11 Nov 2017]
- Redlich D, Molka T, Gilani W, Blair GS, Rashid A (2014) Constructs competition miner: process control-flow discovery of bp-domain constructs. In: Sadiq SW, Soffer P, Völzer H (eds) Business process management – Proceedings of the 12th international conference, BPM, Haifa, 7–11 Sept 2014. Lecture notes in computer science, vol 8659. Springer, pp 134–150. http://doi.org/10.1007/978-3-319-10172-9_9
- vanden Broucke SKLM, Weerdt JD (2017) Fodina: a robust and flexible heuristic process discovery technique. Decis Support Syst 100:109–118. http://doi.org/10.1016/j.dss.2017.04.005
- van Dongen BF, de Medeiros AKA, Verbeek HMW, Weijters AJMM, van der Aalst WMP (2005) The prom framework: a new era in process mining tool support. In: Ciardo G, Darondeau P (eds) Applications and theory of Petri Nets 2005, Proceedings of the 26th international conference, ICATPN, Miami, 20–25 June 2005. Lecture notes in computer science, vol 3536. Springer, pp 444–454. http://doi.org/10.1007/11494744_25
- van Eck ML, Lu X, Leemans SJJ, van der Aalst WMP (2015) PMˆ2 : a process mining project methodology. In: Zdravkovic J, Kirikova M, Johannesson P (eds) Advanced information systems engineering – Proceedings of the 27th international conference, CAiSE, Stockholm, 8–12 June 2015. Lecture notes in computer science, vol 9097. Springer, pp 297–313. http://doi.org/10.1007/978-3-319-19069-3_19
- van Zelst SJ, van Dongen BF, van der Aalst WMP, Verbeek HMW (2017) Discovering relaxed sound workflow nets using integer linear programming. CoRR abs/1703.06733. http://arxiv.org/abs/1703.06733
- Weijters AJMM, van der Aalst WMP (2003) Rediscovering workflow models from event-based data using little thumb. Integr Comput Aided Eng 10(2):151–162. http://content.iospress.com/articles/integrated-computer-aided-engineering/ica00143 Google Scholar
- Wen L, Wang J, Sun J (2006) Detecting implicit dependencies between tasks from event logs. In: Zhou X, Li J, Shen HT, Kitsuregawa M, Zhang Y (eds) Frontiers of WWW research and development – APWeb 2006, Proceedings of the 8th Asia-Pacific web conference, Harbin, 16–18 Jan 2006. Lecture notes in computer science, vol 3841. Springer, pp 591–603. http://doi.org/10.1007/11610113_52
- Wen L, Wang J, Sun J (2007b) Mining invisible tasks from event logs. In: Dong G, Lin X, Wang W, Yang Y, Yu JX (eds) Advances in data and web management, Joint 9th Asia-Pacific web conference, APWeb 2007, and Proceedings of the 8th international conference, on web-age information management, WAIM, Huang Shan, 16–18 June 2007. Lecture notes in computer science, vol 4505. Springer, pp 358–365. http://doi.org/10.1007/978-3-540-72524-4_38