Process Discovery and Conformance Checking Using Passages · 2017-05-02 · Process discovery and...

1

Process Discovery and Conformance Checking Using Passages

W.M.P. van der AalstDepartment of Mathematics and Computer Science,

Technische Universiteit Eindhoven, The Netherlands.

[email protected]

H.M.W. VerbeekDepartment of Mathematics and Computer Science,

Technische Universiteit Eindhoven, The Netherlands.

[email protected]

Abstract. The two most prominent process mining tasks are process discovery (i.e., learning a pro-cess model from an event log) and conformance checking (i.e., diagnosing and quantifying differ-ences between observed and modeled behavior). The increasing availability of event data makesthese tasks highly relevant for process analysis and improvement. Therefore, process mining is con-sidered to be one of the key technologies for Business Process Management (BPM). However, asevent logs and process models grow, process mining becomes more challenging. Therefore, we pro-pose an approach to decompose process mining problems into smaller problems using the notion ofpassages. A passage is a pair of two non-empty sets of activities (X,Y ) such that the set of directsuccessors of X is Y and the set of direct predecessors of Y is X . Any Petri net can be partitionedusing passages. Moreover, process discovery and conformance checking can be done per passageand the results can be aggregated. This has advantages in terms of efficiency and diagnostics. More-over, passages can be used to distribute process mining problems over a network of computers.Passages are supported through ProM plug-ins that automatically decompose process discovery andconformance checking tasks.

Keywords: process mining, conformance checking, process discovery, distributed computing, busi-ness process management

Address for correspondence: Wil van der Aalst, Department of Mathematics and Computer Science, Technische UniversiteitEindhoven, PO Box 513, 5600 MB, Eindhoven, The Netherlands. E-mail: [email protected]. WWW: vdaalst.com.

2 W. van der Aalst, H. Verbeek / Decomposing Process Mining Problems Using Passages

1. Introduction

The term “Big Data” refers to the spectacular growth of data and the potential economic value such datahas when analyzed using clever algorithms [28, 31]. The exponential growth of event data (e.g., from2.6 exabytes in 1986 to 295 exabytes in 2007 according to [28]) provides new opportunities for processanalysis. As more and more actions of people, organizations, and devices are recorded, there are ampleopportunities to analyze processes based on the footprints they leave in event logs. In fact, the analysis ofhand-made process models will become less important given the omnipresence of event data. This is thereason why process mining is one of the “hot” topics in Business Process Management (BPM). Processmining aims to discover, monitor and improve real processes by extracting knowledge from event logsreadily available in today’s information systems [2].

The starting point for process mining is an event log. Each event in such a log refers to an activity(i.e., a well-defined step in some process) and is related to a particular case (i.e., a process instance). Theevents belonging to a case are ordered and can be seen as one “run” of the process. It is important tonote that an event log contains only example behavior, i.e., we cannot assume that all possible runs havebeen observed. In fact, an event log often contains only a fraction of the possible behavior [2].

The growing interest in process mining is illustrated by the Process Mining Manifesto [29] recentlyreleased by the IEEE Task Force on Process Mining. This manifesto is supported by 53 organizationsand 77 process mining experts contributed to it. The active contributions from end-users, tool vendors,consultants, analysts, and researchers illustrate the significance of process mining as a bridge betweendata mining and business process modeling.

Petri nets are often used in the context of process mining. Various algorithms employ Petri nets asthe internal representation used for process mining. Examples are the region-based process discoverytechniques [7, 15, 37, 21, 42], the α algorithm [8], and various conformance checking techniques [9, 33,34, 36]. Other techniques use alternative internal representations (C-nets, heuristic nets, etc.) that caneasily be converted to (labeled) Petri nets [2].

In this paper, we focus on the following two main process mining tasks:

• Process discovery: Given an event log consisting of a collection of traces (i.e., sequences ofevents), construct a Petri net that “adequately” describes the observed behavior.

• Conformance checking: Given an event log and a Petri net, diagnose the differences between theobserved behavior (i.e., traces in the event log) and the modeled behavior (i.e., firing sequences ofthe Petri net).

Both tasks are formulated in terms of Petri nets. However, other process notations could be used, e.g.,BPMN models, BPEL specifications, UML activity diagrams, Statecharts, C-nets, heuristic nets, etc. Infact, also different types of Petri nets can be employed, e.g., safe Petri nets, labeled Petri nets, free-choicePetri nets, etc.

Process mining problems tend to be very challenging. There are obvious challenges that also applyto many other data mining and machine learning problems, e.g., dealing with noise, concept drift, andthe need to explore a large and complex search space. For example, event logs may contain millionsof events. Moreover, there are also some specific problems that make process discovery even morechallenging:

W. van der Aalst, H. Verbeek / Decomposing Process Mining Problems Using Passages 3

• there are no negative examples (i.e., a log shows what has happened but does not show what couldnot happen);

• due to concurrency, loops, and choices the search space has a complex structure and the logtypically contains only a fraction of all possible behaviors;

• there is no clear relation between the size of a model and its behavior (i.e., a smaller model maygenerate more or less behavior although classical analysis and evaluation methods typically assumesome monotonicity property); and

• there is a need to balance between four (often) competing quality criteria (see Section 4): (1) fitness(be able to generate the observed behavior), (2) simplicity (avoid large and complex models), (3)precision (avoid “underfitting”), and (4) generalization (avoid “overfitting”).

Process discovery and conformance checking are related problems. This becomes evident whenconsidering genetic process discovery techniques [32, 17]. In each generation of models generated bythe genetic algorithm, the conformance of every individual model in the population needs to be assessed(the so-called fitness evaluation). Models that fit well with the event log are used to create the nextgeneration of candidate models. Poorly fitting models are discarded. The performance of genetic processdiscovery techniques will only be acceptable if dozens of conformance checks can be done per second(on the whole event log). This illustrates the need for efficient process mining techniques.

Dozens of process discovery [2, 7, 8, 13, 15, 20, 21, 23, 27, 32, 37, 40, 42] and conformance checking[5, 9, 10, 12, 18, 24, 27, 33, 34, 36, 38] approaches have been proposed in literature. Despite the growingmaturity of these approaches, the quality and efficiency of existing techniques leave much to be desired.State-of-the-art techniques still have problems dealing with large and/or complex event logs and processmodels. Therefore, we proposed a divide-and-conquer approach for process mining. This approach usesa new concept: passages. A passage is a pair of two sets of activity nodes (X,Y ) such thatX• = Y (i.e.,the activity nodes in X influence the enabling of the activity nodes in Y ) and X = •Y (i.e., the activitynodes in Y are influenced by the activity nodes inX). The notion of passages will be formalized in termsof graphs and labeled Petri nets. Passages can be used to decompose process discovery and conformancechecking problems into smaller problems. By localizing process mining techniques to passages, morerefined techniques can be used. Assuming that the event log and process model can be decomposedinto many small passages, substantial speedups are possible. Moreover, passages can also be used todistribute process mining problems over a network of computers (e.g., a grid or cloud infrastructure).

This paper focuses on the theoretical foundations of process mining based on passages and extendsour earlier conference paper [3] in various respects. For example, the results are generalized to a largerclass of models and different passage partitionings. Moreover, we describe new ProM plug-ins based onthis work and present experimental results.

The remainder is organized as follows. Section 2 introduces various preliminaries (Petri nets, eventlogs, etc.). Section 3 defines the notion of passages for arbitrary graphs and analyzes their properties.Section 4 discusses quality criteria for process mining and introduces the notion of alignments to com-pute the level of conformance. The notion of passages is used in Section 5 to decompose the overallconformance checking problem into a set of localized conformance checking problems. Section 6 showshow the same ideas can be used for process discovery, i.e., after determining the causal structure andrelated passages, the overall process discovery problem can be decomposed into a set of local process


discovery problems. Section 7 shows, using a real-life event log, that dividing the problem into smallerproblems using passages may indeed lead to significant speedups. Section 8 describes some of the ProMplug-ins that use passages to decompose process mining tasks into smaller tasks handled by conventionalalgorithms. Related work is discussed in Section 9. Section 10 concludes the paper.

2. Preliminaries

This section introduces basic concepts related to graphs, Petri nets and event logs.

2.1. Graphs and Paths

First, we introduce basic graphs notations. We will use graphs to represent process models (i.e., Petrinets) and the causal structure (also referred to as “skeleton”) of processes.

Definition 2.1. (Graph)A graph is a pair G = (N,E) comprising a set N of nodes and a set E ⊆ N ×N of edges.

For a graph G = (N,E) and n ∈ N , we define presetG• n = {n′ ∈ N | (n′, n) ∈ E} (direct

predecessors) and postset nG•= {n′ ∈ N | (n, n′) ∈ E} (direct successors). This can be generalized to

sets, i.e., for X ⊆ N :G•X =

⋃n∈X

G• n and XG•=

⋃n∈X n

G• . The superscript G can be omitted ifthe graph is clear from the context.

Sequences are used to represent paths in a graph and traces in an event log. As defined next, σ1 · σ1is the concatenation of two sequences and σ�X is the projection of σ on X , e.g., 〈a, b, c, c, b, a〉�{a,b}=〈a, b, b, a〉.

Definition 2.2. (Sequences)Let A be a set. σ = 〈a1, a2, . . . , an〉 ∈ A∗ denotes a sequence over A of length n. For σ1, σ2 ∈ A∗:σ1 · σ2 is the concatenation of two sequences, e.g., 〈a〉 · 〈b, c〉 = 〈a, b, c〉. σ�X is the projection of σ onX ⊆ A, i.e., �X∈ A∗ → X∗ and is defined recursively: (1) 〈〉�X= 〈〉, (2) for a ∈ X and σ ∈ A∗:(〈a〉 · σ)�X= 〈a〉 · σ�X , and (3) for a ∈ A \X and σ ∈ A∗: (〈a〉 · σ)�X= σ�X .

A path in a graph is a sequence of nodes connected through edges. We use the notation xσ:E′#Q y to

state that there is a non-empty path σ from node x to node y using edges in E′ not visiting any nodes inQ.

Definition 2.3. (Path)Let G = (N,E) be a graph, x, y ∈ N , E′ ⊆ E, and Q ⊆ N . x

σ:E′#Q y if and only if σ is a sequence

such that σ = 〈n1, n2, . . . nk〉, k > 1, x = n1, y = nk, for all 1 ≤ i < k: (ni, ni+1) ∈ E′, and for all1 < i < k: ni 6∈ Q. Derived notations:

• x E′#Q y if and only if there exists a sequence σ such that x

σ:E′#Q y,

• nodes(xE′#Q y) = {n ∈ σ | σ ∈ N∗ ∧ x

σ:E′#Q y}, and

• for X,Y ⊆ N : nodes(XE′#Q Y ) =

⋃(x,y)∈X×Y nodes(x

E′#Q y).


Consider the graphG = (N,E) in Fig. 2 which is later used to introduce the notion of passages. aE#Q i

holds for Q = {b, d, e, g} because of the path σ = 〈a, c, f, h, i〉. a E#Q i does not hold if Q = {g, h}

because all paths connecting a to i need to visit g or h. If Q = {d, e, g}, then nodes(aE#Q i) =

{a, b, c, f, h, i} because of the two paths connecting a to i not visiting any of the nodes in Q.

2.2. Multisets

Multisets are used to represent the state of a Petri net and to describe event logs where the same tracemay appear multiple times.B(A) is the set of all finite multisets over some set A. For some multiset b ∈ B(A), b(a) denotes the

number of times element a ∈ A appears in b. Some examples: b1 = [ ], b2 = [x, x, y], b3 = [x, y, z],b4 = [x, x, y, x, y, z], b5 = [x3, y2, z] are multisets over A = {x, y, z}. b1 is the empty multiset, b2 andb3 both consist of three elements, and b4 = b5, i.e., the ordering of elements is irrelevant and a morecompact notation may be used for repeating elements.

The standard set operators can be extended to multisets, e.g., x ∈ b2, b2 ] b3 = b4, and b5 \ b2 = b3.|b| is the size of multiset b, e.g., |b1| = 0 and |b5| = 6. {a ∈ b} denotes the set with all elements a forwhich b(a) ≥ 1.

Let σ = 〈a1, a2, . . . , an〉 ∈ A∗ be a sequence and b = [a1, a2, . . . , an] ∈ B(A) the correspondingmultiset. a ∈ σ if and only if a ∈ b.

∑a∈σ f(a) =

∑a∈b f(a) = f(a1) + f(a2) + . . .+ f(an) for some

function f .Given a function f ∈ A → B and a multiset b ∈ B(A): [f(a) | a ∈ b] denotes the multiset over B

where element f(a) appears∑

x∈A|f(x)=f(a) b(x) times.

2.3. Petri Nets

Most of the results presented in the paper, can be adapted for various process modeling notations. How-ever, we use Petri nets to formalize the main ideas and to prove their correctness.

Definition 2.4. (Petri Net)A Petri net is a tuple PN = (P, T, F ) having a finite set of places P , a finite set of transitions T , and aflow relation F ⊆ (P × T ) ∪ (T × P ).

Figure 1 shows an example Petri net PN = (P, T, F ) with P = {start , c1, . . . , c5, end}, T = {a, b,. . . , h}, and F = {(start , a), (a, c1), (a, c2), . . . , (h, end)}. The state of a Petri net, called marking, is amultiset of places indicating how many tokens each place contains. AnyM ∈ B(P ) is a marking. [start ]is the initial marking shown in Fig. 1. Another potential marking is [c110, c25, c45]. This is the state withten tokens in c1, five tokens in c2, and five tokens in c4.

A Petri net PN = (P, T, F ) defines a graph (P ∪ T, F ). Hence, for any x ∈ P ∪ T ,PN• x =

{y | (y, x) ∈ F} (input nodes) and xPN• = {y | (x, y) ∈ F} (output nodes). As before, we drop the

superscript if it is clear from the context.A transition t ∈ T is enabled in marking M , denoted as M [t〉, if each of its input places •t contains

at least one token. Consider the Petri net in Fig. 1 with M = [c3, c4]: M [e〉 because both input placesare marked.


a

start register

request

b

examine thoroughly

c

examine casually

d

check ticket

decide

pay compensation

reject request

reinitiate request

e

g

h

f

end

c1

c2

c3

c4

c5

Figure 1. A Petri net.

An enabled transition t may fire, i.e., one token is removed from each of the input places •t andone token is produced for each of the output places t• . Formally: M ′ = (M \ •t) ] t• is the markingresulting from firing enabled transition t in marking M . M [t〉M ′ denotes that t is enabled in M andfiring t results in marking M ′. For example, [start ][a〉[c1, c2] and [c3, c4][e〉[c5] for the net in Fig. 1.

Let σ = 〈t1, t2, . . . , tn〉 ∈ T ∗ be a sequence of transitions. M [σ〉M ′ denotes that there is a setof markings M0,M1, . . . ,Mn such that M0 = M , Mn = M ′, and Mi[ti+1〉Mi+1 for 0 ≤ i < n. Amarking M ′ is reachable from M if there exists a σ such that M [σ〉M ′. For example, [start ][σ〉[end ]for σ = 〈a, b, d, e, g〉.

Definition 2.5. (Labeled Petri Net)A labeled Petri net PN = (P, T, F, Tv) is a Petri net (P, T, F ) with visible transitions Tv ⊆ T . Letσv = 〈t1, t2, . . . , tn〉 ∈ T ∗v be a sequence of visible transitions. M [σv BM ′ if and only if there is asequence σ ∈ T ∗ such that M [σ〉M ′ and the projection of σ on Tv yields σv, i.e., σv = σ�Tv .

If we assume Tv = {a, e, g, h} for the Petri net in Fig. 1, then [start ][σvB [end ] for σv = 〈a, e, e, e, e, g〉(i.e., b, c, d, and f are invisible). Note that we consider a very limited form of labeling because any eventin an event log need to deterministically refer to a transition.

In the context of process mining, we always consider processes that start in an initial state and endin a well-defined end state. For example, given the net in Fig. 1 we are interested in firing sequencesstarting in Mi = [start ] and ending in Mo = [end ]. Therefore, we define the notion of a system net.

Definition 2.6. (System Net)A system net is a triplet SN = (PN ,Mi,Mo) where PN = (P, T, F, Tv) is a Petri net with visibletransitions Tv, Mi ∈ B(P ) is the initial marking, and Mo ∈ B(P ) is the final marking.

Given a system net, τ(SN ) is the set of all possible visible full traces, i.e., firing sequences starting inMi and ending in Mo projected onto the set of visible transitions.

Definition 2.7. (Traces)Let SN = (PN ,Mi,Mo) be a system net. τ(SN ) = {σv |Mi[σvBMo} is the set of visible full traces.


In the remainder, we will simply refer to such traces as the visible traces of SN . If we assume Tv ={a, e, f, g, h} for the Petri net in Fig. 1, then τ(SN ) = {〈a, e, g〉, 〈a, e, h〉, 〈a, e, f, e, g〉, 〈a, e, f, e, h〉,. . .}.

Definition 2.8. (Connected)Let SN = (PN ,Mi,Mo) with PN = (P, T, F, Tv) be a system net. SN is connected if and only if

P ∪ T = nodes({p ∈Mi}F#∅ {p ∈Mo}) and τ(SN ) 6= ∅.

In a connected system net all nodes are on a path from some initially marked place to some place markedin the final marking. Moreover, there should be at least one trace leading from Mi to Mo (ensured by therequirement τ(SN ) 6= ∅). System nets that have no traces cannot be used for conformance checking andare not very meaningful from a process discovery point of view. When decomposing a net into passageswe will often assume it is connected, e.g., the connectedness requirement ensures that all nodes end upin at least one passage in Theorem 5.4.

2.4. Event Log

As indicated earlier, event logs serve as the starting point for process mining. An event log is a multisetof traces. Each trace describes the life-cycle of a particular case (i.e., a process instance) in terms of theactivities executed.

Definition 2.9. (Trace, Event Log)Let A be a finite set of activities. A trace σ ∈ A∗ is a finite sequence of activities. L ∈ B(A∗) is an eventlog, i.e., a finite multiset of traces.

An event log is a multiset of traces because there can be multiple cases having the same trace. In thissimple definition of an event log, an event refers to just an activity. Often event logs may store additionalinformation about events. For example, many process mining techniques use extra information such asthe resource (i.e., person or device) executing or initiating the activity, the timestamp of the event, ordata elements recorded with the event (e.g., the size of an order). In this paper, we abstract from suchinformation. However, the results presented in this paper can easily be extended to event logs with moreinformation.

An example log is L1 = [〈a, e, g〉10, 〈a, e, h〉5, 〈a, e, f, e, g〉3, 〈a, e, f, e, h〉2]. L1 contains informa-tion about 20 cases, e.g., 10 cases followed trace 〈a, e, g〉. There are 10×3 + 5×3 + 3×5 + 2×5 = 70events in total.

The projection function �X (cf. Definition 2.2) is generalized to event logs, i.e., for some event logL ∈ B(A∗) and set X ⊆ A: L�X= [σ�X | σ ∈ L]. For example, L1�{a,g,h}= [〈a, g〉13, 〈a, h〉7]. Notethat all e and f events have been removed.

3. Passages

To decompose large process mining problems into smaller problems, we partition process models usingthe notion of passages introduced in this paper. A passage is a pair of non-empty sets of nodes (X,Y )such that the set of direct successors of X is Y and the set of direct predecessors of Y is X .


Definition 3.1. (Passage)LetG = (N,E) be a graph. P = (X,Y ) is a passage if and only if ∅ 6= X ⊆ N , ∅ 6= Y ⊆ N ,X

G•= Y ,

and X =G• Y . X is the set of input nodes of P , and Y is the set of output nodes of P . pas(G) is the set

of all passages of G.

Consider the sets X = {b, c, d} and Y = {d, e, f} in Fig. 2 (for the moment ignore the numbers in thegraph). X• = {b, c, d}• = {d, e, f} = Y and X = {b, c, d} = •{d, e, f} = •Y , so (X,Y ) is indeeda passage.

a

b

c

d

e

f

g

h

i

1

1

2

2

2

2

2

2

3

4

5

5

X Y

Figure 2. A graph with five minimal passages: P1 = ({a}, {b, c}), P2 = ({b, c, d}, {d, e, f}), P3 = ({e}, {g}),P4 = ({f}, {h}), and P5 = ({g, h}, {i}). Passage P2 is highlighted and edges carry numbers to refer to theminimal passage they belong to.

Definition 3.2. (Passages Operators)Let P1 = (X1, Y1) and P2 = (X2, Y2) be two passages.• P1 ≤ P2 if and only if X1 ⊆ X2 and Y1 ⊆ Y2,• P1 < P2 if and only if P1 ≤ P2 and P1 6= P2,• P1 ∪ P2 = (X1 ∪X2, Y1 ∪ Y2),• P1 ∩ P2 = (X1 ∩X2, Y1 ∩ Y2),• P1 \ P2 = (X1 \X2, Y1 \ Y2),• P1 . P2 if and only if Y1 ∩X2 6= ∅, and• P1#P2 if and only if (X1 ∩X2) ∪ (Y1 ∩ Y2) = ∅.

P1 . P2 means that P2 follows P1, i.e., an output node of P1 is an input node of P2. Two passages P1

and P2 are called disjoint if P1#P2. Consider the following two concrete passages in Fig. 2: P4 =({f}, {h}) and P5 = ({g, h}, {i}). P4 . P5 because node h is an output node of P4 and an input nodeof P5. P4#P5 because ({f} ∩ {g, h}) ∪ ({h} ∩ {i}) = ∅.

Lemma 3.3. (Relating Passages)Let G = (N,E) be a graph with passages P1 = (X1, Y1) ∈ pas(G) and P2 = (X2, Y2) ∈ pas(G).• P3 = P1 \ P2 is a passage if P3 6= (∅, ∅),• P4 = P2 \ P1 is a passage if P4 6= (∅, ∅),• P5 = P1 ∩ P2 is a passage if P5 6= (∅, ∅), and


• P6 = P1 ∪ P2 is a passage.

Proof:Let P3 = (X3, Y3) = P1 \ P2, P4 = (X4, Y4) = P2 \ P1, P5 = (X5, Y5) = P1 ∩ P2, and P6 =(X6, Y6) = P1 ∪ P2 as sketched in Fig. 3(a).

Assume P3 6= (∅, ∅). Remains to prove that ∅ 6= X3 ⊆ N , ∅ 6= Y3 ⊆ N , X3• = Y3, and X3 = •Y3.(Recall that X3 = X1 \X2 and Y3 = Y1 \ Y2.)• For any x ∈ X3 there is at least one edge (x, y′) ∈ E because x ∈ X1 and P1 is a passage. For all

such edges: y′ ∈ Y3 because y′ ∈ Y1 (x ∈ X1 and P1 is a passage) and y′ 6∈ Y2 (because P2 is apassage and x 6∈ X2). Note that if (x, y′) ∈ E, x ∈ X3, and y′ ∈ Y2, we find a contradiction (P2

cannot be a passage without x as input node). Hence, ∅ 6= x• ⊆ Y3 for x ∈ X3 which implies thatX3• ⊆ Y3.• For any y ∈ Y3 there is at least one edge (x′, y) ∈ E because y ∈ Y1 and P1 is a passage. For all

such edges: x′ ∈ X3 because x′ ∈ X1 (y ∈ Y1 and P1 is a passage) and x′ 6∈ X2 (because P2 is apassage and y 6∈ Y2). Hence, ∅ 6= •y ⊆ X3 for y ∈ Y3 which implies that •Y3 ⊆ X3.• Since X3• ⊆ Y3, •Y3 ⊆ X3, all nodes in X3 have an outgoing edge, and all nodes in Y3 have an

incoming edge, we conclude: X3• = Y3, and X3 = •Y3. Hence, P3 = P1 \ P2 is a passage.In a similar fashion it can be shown that P4 = P2 \ P1 is a passage if P4 6= (∅, ∅).

Assume P5 6= (∅, ∅). Remains to prove that ∅ 6= X5 ⊆ N , ∅ 6= Y5 ⊆ N , X5• = Y5, and X5 = •Y5.(Recall that X5 = X1 ∩X2 and Y5 = Y1 ∩ Y2.)• For any x ∈ X5 there is at least one edge (x, y′) ∈ E because x ∈ X1 and P1 is a passage (andx ∈ X2 and P2 is a passage). For all such edges: y′ ∈ Y5 because y′ ∈ Y1 (x ∈ X1 and P1 isa passage) and y′ ∈ Y2 (x ∈ X2 and P2 is a passage). Hence, ∅ 6= x• ⊆ Y5 for x ∈ X5 whichimplies that X5• ⊆ Y5.• For any y ∈ Y5 there is at least one edge (x′, y) ∈ E because y ∈ Y1 and P1 is a passage (andy ∈ Y2 and P2 is a passage). For all such edges: x′ ∈ X5 because x′ ∈ X1 (y ∈ Y1 and P1 isa passage) and x′ ∈ X2 (y ∈ Y2 and P2 is a passage). Hence, ∅ 6= •y ⊆ X5 for y ∈ Y5 whichimplies that •Y5 ⊆ X5.• Since X5• ⊆ Y5, •Y5 ⊆ X5, all nodes in X5 have an outgoing edge, and all nodes in Y5 have an

incoming edge, we conclude: X5• = Y5, and X5 = •Y5. Hence, P5 = P1 ∩ P2 is a passage.In a similar fashion it can be shown that P6 = P1 ∪ P2 is a passage. There is no need to requireP6 6= (∅, ∅) because the union of two passages will always contain edges. ut

Definition 3.4. (Edge Representation of Passages)Let G = (N,E) be a graph. For any P = (X,Y ) with X ⊆ N and Y ⊆ N : P = E ∩ (X × Y ) denotesthe set of edges of P .

Sets of edges can be used to fully characterize passages. In fact, any passage P = (X,Y ) with edgesZ = P is uniquely defined by (1) X , (2) Y , and (3) Z separately. If X is known, then we can deriveY = X• and Z = E ∩ (X × Y ) knowing that P is a passage. If Y is known, then X = •Y andZ = E ∩ (X × Y ). If Z is known, then X = {x | (x, y) ∈ Z} and Y = {y | (x, y) ∈ Z} because therecannot be input or output nodes without corresponding edges.


X1

X2

X5

X3

X4

Y1

Y2

Y5

Y3

Y4

X1

X2

Y1

Y2

(a) (b)

Figure 3. Understanding the fabric of passages: (a) only edges between pairs (X3, Y3), (X4, Y4), and (X5, Y5)are possible if (X1, Y1) and (X2, Y2) are passages, and (b) passages are composed of minimal passages. Note thatinput nodes Xi may overlap with output nodes Yj but this is not shown to avoid cluttering the diagrams.

Lemma 3.5. (Relating Passages in Terms of Edges)Let G = (N,E) be a graph with passages P1, P2 ∈ pas(G) and let P3 = P1 \ P2, P4 = P2 \ P1,P5 = P1 ∩ P2, and P6 = P1 ∪ P2. The following properties hold:• P3 = P1 \ P2,• P4 = P2 \ P1,• P5 = P1 ∩ P2, and• P6 = P1 ∪ P2.

Proof:Note that the naming of passages is similar to Fig. 3(a). As shown in the proof of Lemma 3.3: X3• = Y3,X3 = •Y3, X4• = Y4, X4 = •Y4, and X5• = Y5, X5 = •Y5. Moreover, X3, X4, and X5 partitionX6, and Y3, Y4, and Y5 partition Y6. These properties also hold when one of more sets are empty, e.g.,if X3 = ∅, then still X3• = ∅• = ∅ = Y3. This implies that any edge in E ∩ (X6 × Y6) belongs toE ∩ (X3× Y3), E ∩ (X4× Y4), or E ∩ (X5× Y5) as sketched in Fig. 3(a). The partitioning of the edgesover these three sets can be used to prove the properties listed. ut

Corollary 3.6. (Comparing Passages in Terms of Edges)Let G = (N,E) be a graph with passages P1, P2 ∈ pas(G). The following properties hold:

• P1 ≤ P2 if and only if P1 ⊆ P2,• P1 < P2 if and only if P1 ⊂ P2, and• P1#P2 if and only if P1 ∩ P2 = ∅.

To decompose process mining problems, we aim to partition a process model into smaller models usingthe notion of passages. Therefore, we define the notion of a passage partitioning. Consider for examplethe five passages shown in Fig. 2. The edges in Fig. 2 have numbers corresponding to the passagethey belong to, e.g., edges (a, b) and (a, c) have a label “1” showing that they belong to passage P1 =({a}, {b, c}). Passages {P1, P2, P3, P4, P5} in Fig. 2 form a passage partitioning because the passagesare pairwise disjoint and together they cover all edges.


Definition 3.7. (Passage Partitioning)Let G = (N,E) be a graph. {P1, P2, . . . , Pn} is a passage partitioning if and only if

1. P1, P2, . . . , Pn ∈ pas(G) are passages,

2. for all 1 ≤ i < j ≤ n: Pi#Pj , and

3. E =⋃

1≤i≤n Pi.

Consider the graph in Fig. 2 and P6 = P1 ∪ P2 = ({a, b, c, d}, {b, c, d, e, f}) and P7 = P3 ∪ P4 ∪ P5 =({e, f, g, h}, {g, h, i}). P6 and P7 are passages because the union of passages is guaranteed to be apassage (cf. Lemma 3.3). {P6, P7} is a passage partitioning because P6#P7 and P6∪ P7 = E. As Fig. 4shows, relations between passages in a passage partitioning can be visualized using the follows relation.

P1 P2

P3

P4

P5 P6 P7

(a) (b)

Figure 4. Two graphs based on the follows relation (.) showing dependencies between passages in a passagespartitioning, e.g., P2 . P4 because Y2 ∩X4 = {f} 6= ∅.

A passage partitioning {P1, P2, . . . , Pn} defines an equivalence relation on the edges in a graph:(x1, y1) ∼ (x2, y2) if and only if there is a Pi such that {(x1, y1), (x2, y2)} ⊆ Pi. It is easy to see that ∼is reflexive (i.e., (x, y) ∼ (x, y)) , symmetric (i.e., (x1, y1) ∼ (x2, y2) if and only if (x2, y2) ∼ (x1, y1)),and transitive (i.e., (x1, y1) ∼ (x2, y2) and (x2, y2) ∼ (x3, y3) implies (x1, y1) ∼ (x3, y3)). Givenpassage partitioning {P1, P2, P3, P4, P5} in Fig. 2: (b, d) ∼ (b, e) ∼ (b, f) ∼ (c, f) ∼ (d, d) ∼ (d, e),i.e., the arcs having label “2” form an equivalence class.

To prove that a passage partitioning always exists we introduce the notion of minimal passages. Apassage is minimal if it does not “contain” a smaller passage.

Definition 3.8. (Minimal Passage)Let G = (N,E) be a graph with passages pas(G). P ∈ pas(G) is minimal if there is no P ′ ∈ pas(G)such that P ′ < P . pasmin(G) is the set of minimal passages.

The five passages in Fig. 2 are minimal. Note that each edge belongs to precisely one minimal passage.In fact, a minimal passage is uniquely identified by any of its elements as is shown next.

Lemma 3.9. Let G = (N,E) be a graph and (x, y) ∈ E. There is precisely one minimal passageP(x,y) = (X,Y ) ∈ pasmin(G) such that x ∈ X and y ∈ Y .

Proof:Construct P(x,y) = (X,Y ) as follows. Initially: X := {x} and Y := {y}. Then repeat X := X ∪ •Yand Y := Y ∪ X• until X and Y do not change anymore. The algorithm will end because there arefinitely many nodes. When it ends, X = •Y and Y = X• . Hence, P(x,y) = (X,Y ) is passage.No unnecessary elements are added to X and Y , so (X,Y ) is minimal and there is precisely one suchminimal passage for (x, y) ∈ E.


To prove the latter one can also consider all passages Q = {P1, P2, . . . , Pn} that contain (x, y). Theintersection of all such passages

⋂Q contains edge (x, y) and is again a passage because of Lemma 3.3.

Hence,⋂Q = P(x,y). ut

For any {(x, y), (x′, y), (x, y′)} ⊆ E: P(x,y) = P(x′,y) = P(x,y′), i.e., P(x,y) is uniquely determined byx and P(x,y) is also uniquely determined by y. The set of all minimal passages pasmin(G) = {P(x,y) |(x, y) ∈ E} forms a passage partitioning.

Corollary 3.10. (Any Graph Has a Passage Partitioning)Any graph G = (N,E) has a passage partitioning, e.g., the set of minimal passages pasmin(G).

Later we will use this corollary to partition process mining problems into smaller problems. To controlthe granularity of composition it is important that passages can be combined to form larger passages (cf.Lemma 3.3) or split into minimal passages as shown by the following corollary.

Corollary 3.11. (Passages are Composed of Minimal Passages)Let G = (N,E) be a graph. For any passage P ∈ pas(G), there exists a set of minimal passages{P1, P2, . . . , Pn} ⊆ pasmin(G) such that P = P1 ∪ P2 ∪ . . . ∪ Pn.

Figure 3(b) illustrates the “fabric” of passages and the role of minimal passages. The figure shows nodesas black dots and a few example edges are shown (just a sketch). The smaller areas correspond to minimalpassages. Passage P1 = (X1, Y1) is composed of 8 minimal passages, P2 = (X2, Y2) is composed of 7minimal passages. P5 = P1∩P2 is composed of 3 minimal passages shared by P1 and P2. P6 = P1∪P2

is composed of 12 minimal passages. Any edge belongs to precisely one minimal passage. Any nodeon the left-hand side (X1 ∪X2) and any node on the right-hand side (Y1 ∪ Y2) belongs to precisely oneminimal passage. Although not shown, note that the same node may appear on both sides.

4. Conformance Checking

Conformance checking techniques investigate how well an event log L ∈ B(A∗) and a system net SN =(PN ,Mi,Mo) fit together. Note that the process model SN may have been discovered through processmining or may have been made by hand. In any case, it is interesting to compare the observed examplebehavior in L and the potential behavior of SN .

Conformance checking can be done for various reasons. First of all, it may be used to audit processesto see whether reality conforms to some normative or descriptive model [6]. Deviations may point tofraud, inefficiencies, and poorly designed or outdated procedures. Second, conformance checking can beused to evaluate process discovery results. In fact, genetic process mining algorithms use conformancechecking to select the candidate models used to create the next generation of models [32].

There are four quality dimensions for comparing model and log: (1) fitness, (2) simplicity, (3) pre-cision, and (4) generalization [2]. A model with good fitness allows for most of the behavior seen inthe event log. A model has a perfect fitness if all traces in the log can be replayed by the model frombeginning to end. The simplest model that can explain the behavior seen in the log is the best model.This principle is known as Occam’s Razor. Fitness and simplicity alone are not sufficient to judge thequality of a discovered process model. For example, it is very easy to construct an extremely simplePetri net (“flower model”) that is able to replay all traces in an event log (but also any other event log


referring to the same set of activities). Similarly, it is undesirable to have a model that only allows forthe exact behavior seen in the event log. Remember that the log contains only example behavior andthat many traces that are possible may not have been seen yet. A model is precise if it does not allowfor “too much” behavior. Clearly, the “flower model” lacks precision. A model that is not precise is“underfitting”. Underfitting is the problem that the model over-generalizes the example behavior in thelog (i.e., the model allows for behaviors very different from what was seen in the log). At the same time,the model should generalize and not restrict behavior to just the examples seen in the log. A model thatdoes not generalize is “overfitting”. Overfitting is the problem that a very specific model is generatedwhereas it is obvious that the log only holds example behavior (i.e., the model explains the particularsample log, but there is a high probability that the model is unable to explain the next batch of cases).

In the remainder, we will focus on fitness. However, the ideas are applicable to the other qualitydimensions.

Definition 4.1. (Perfectly Fitting Log)Let L ∈ B(A∗) be an event log and let SN = (PN ,Mi,Mo) be a system net. L perfectly fits SN if andonly if {σ ∈ L} ⊆ τ(SN ).

Note that {σ ∈ L} converts multiset L into a set of traces. Consider two event logs L1 = [〈a, e, g〉10,〈a, e, h〉5, 〈a, e, f, e, g〉3, 〈a, e, f, e, h〉2] and L2 = [〈a, e, g〉10, 〈a, g〉3, 〈a, a, g, e, h〉2] and the system netSN of the Petri net depicted in Fig. 1 with Tv = {a, e, f, g, h}. Clearly, L1 perfectly fits SN whereasL2 is not. There are various ways to quantify fitness [2, 5, 9, 27, 32, 33, 34, 36]. To illustrate thatconformance checking tasks can be decomposed using passages, we focus on alignments as the basis forconformance checking.

To measure fitness, one needs to align traces in the event log to traces of the process model. Someexample alignments for L2 and SN :

γ1 =a e g

a e gγ2 =

a � g

a e gγ3 =

a a g e h

a � � e hγ4 =

a a � g e h

a � e g � �

The top row of each alignment corresponds to “moves in the log” and the bottom row corresponds to“moves in the model”. If a move in the log cannot be mimicked by a move in the model, then a “�”(“no move”) appears in the bottom row. For example, in γ3 the model is unable to do the second a moveand is unable to do g before e. If a move in the model cannot be mimicked by a move in the log, then a“�” (“no move”) appears in the top row. For example, in γ2 the log did not do an e move whereas themodel has to make this move to enable g and reach the end. Given a trace in the event log, there may bemany possible alignments. To select the most appropriate one we associate costs to moves and select analignment with the lowest total costs.

A move is a pair (x, y) where the first element refers to the log and the second element refers to themodel. For example, (a, a) means that both log and model make an “a move”. (�, a) means that themodel makes an “a move” without a corresponding move of the log. (a,�) means that the log makesan “a move” not followed by the model.

Definition 4.2. (Alignment)Let L ∈ B(A∗) be an event log and let SN be a system net with visible traces τ(SN ) ⊆ A∗. ALM ={(a, a) | a ∈ A} ∪ {(�, a) | a ∈ A} ∪ {(a,�) | a ∈ A} is the set of legal moves.


Let σL ∈ L be a log trace and σM ∈ τ(SN ) a model trace. An alignment of σL and σM is a sequenceγ ∈ ALM ∗ such that the projection on the first element (ignoring�) yields σL and the projection on thesecond element (again ignoring�) yields σM .

γ1-γ4 are examples of alignments for traces in L2 and the net depicted in Fig. 1 with Tv = {a, e, f, g, h}.Clearly, γ3 is a better alignment than γ4. This can be quantified using a cost function δ.

Definition 4.3. (Cost of Alignment)Cost function δ ∈ ALM → IN assigns costs to legal moves. The cost of an alignment γ is the sum of allcosts: δ(γ) =

∑(x,y)∈γ δ(x, y) for γ ∈ ALM ∗.

Moves where log and model agree have no costs, i.e., δ(a, a) = 0 for all a ∈ A. δ(�, a) > 0 is thecost when the model makes an “a move” without a corresponding move of the log. δ(a,�) > 0 is thecost for an “a move” in just the log. These costs may depend on the nature of the activity, e.g., skippinga payment may be more severe than sending too many letters. However, in this paper we often use astandard cost function δS that assigns unit costs: δS(a, a) = 0 and δS(�, a) = δS(a,�) = 1 for alla ∈ A. For example, δS(γ1) = 0, δS(γ2) = 1, δS(γ3) = 2, and δS(γ4) = 4 (simply count the number of� symbols).

Definition 4.4. (Optimal Alignment)Let L ∈ B(A∗) be an event log and SN be a system net with τ(SN ) 6= ∅.• For σL ∈ L, we define: ΓσL,SN = {γ ∈ ALM ∗ | ∃σM∈τ(SN ) γ is an aligment of σL and σM}.• An alignment γ ∈ ΓσL,SN is optimal for trace σL ∈ L and system net SN if for any γ′ ∈ ΓσL,M :δ(γ′) ≥ δ(γ).• λSN ∈ A∗ → ALM

∗ is a deterministic mapping that assigns any log trace σL to an optimalalignment, i.e., λSN (σL) ∈ ΓσL,SN and λSN (σL) is optimal.• costs(L,SN , δ) =

∑σL∈L δ(λSN (σL)) are the misalignment costs of the whole event log.

γ4 is not an optimal alignment for trace 〈a, a, g, e, h〉 and the net in Fig. 1 with Tv = {a, e, f, g, h}. γ1,γ2, and γ3 are optimal alignments. Hence, costs(L2,SN , δS) = 10×δS(γ1)+3×δS(γ2)+2×δS(γ3) =10× 0 + 3× 1 + 2× 2 = 7.

It is possible to convert misalignment costs into a fitness value between 0 (poor fitness, i.e., maximalcosts) and 1 (perfect fitness, zero costs). We refer to [5, 9] for details. Misalignment costs can be relatedto Definition 4.1, because only perfectly fitting traces have costs 0 (assuming τ(SN ) 6= ∅).

Lemma 4.5. (Perfectly Fitting Log)Event log L perfectly fits system net SN if and only if costs(L,SN , δ) = 0.

Once an optimal alignment has been established for every trace in the event log, these alignments can alsobe used as a basis to quantify other conformance notations such as precision and generalization [5]. Forexample, precision can be computed by counting “escaping edges” as shown in [33, 34]. Recent resultsshow that such computations should be based on alignments [11]. The same holds for generalization [5].Therefore, we focus on alignments when decomposing passages.


5. Distributed Conformance Checking

Conformance checking techniques can be time consuming as potentially many different traces need tobe aligned with a model that may allow for an exponential (or even infinite) number of traces. Eventlogs may contain millions of events. Finding the best alignment may require solving many optimizationproblems [9] or repeated state-space explorations [36]. When using genetic process mining, one needsto check the fitness of every individual model in every generation [32]. As a result, thousands or evenmillions of conformance checks need to be done. For each conformance check, the whole event log needsto be traversed. Given these challenges, we are interested in reducing the time needed for conformancechecking. Moreover, passages can be used to provide local diagnostics (per passage).

In this section, we show that it is possible to decompose and distribute conformance checking prob-lems using the notion of passages defined in Section 3. In order to do this we focus on the visibletransitions and create the so-called skeleton of the process model.

Definition 5.1. (Skeleton)Let PN = (P, T, F, Tv) be a labeled Petri net. The skeleton of PN is the graph skel(PN ) = (N,E)

with N = Tv and E = {(x, y) ∈ Tv × Tv | xF#Tv y}.

Figure 5 shows the skeleton of the net in Fig. 1 assuming that Tv = {a, e, f, g, h}. The resulting graphhas two minimal passages.

aregister

request

decide

reject request

reinitiate request

e g

hf

pay compensation

Figure 5. The skeleton of the labeled Petri net in Fig. 1 (assuming that Tv = {a, e, f, g, h}). There are twominimal passages: ({a, f}, {e}) and ({e}, {f, g, h}).

Note that only the visible transitions Tv appear in the skeleton. For example, if we assume thatTv = {a, g, h} in Fig. 1, then the skeleton is ({a, g, h}, {(a, g), (a, h)}) and there is only one passage({a}, {g, h}).

If there are multiple (minimal) passages in the skeleton, then we can decompose conformance check-ing problems into smaller problems by partitioning the Petri net into net fragments and the event log intosublogs. We will first show that each passage (X,Y ) defines one net fragment PN (X,Y ) (cf. Defini-tion 5.2) and one sublog L�X∪Y . Then we will prove that conformance can be checked per passage.

Consider event logL = [〈a, e, g〉10, 〈a, e, h〉5, 〈a, e, f, e, g〉3, 〈a, e, f, e, h〉2], the Petri net PN shownin Fig. 1 with Tv = {a, e, f, g, h}, and the skeleton shown in Fig. 5. There are two passages: P1 =({a, f}, {e}) and P2 = ({e}, {f, g, h}). Based on this we define two net fragments PN 1 and PN 2

as shown in Fig. 6. Moreover, we define two sublogs: L1 = [〈a, e〉15, 〈a, e, f, e〉5] and L2 = [〈e, g〉10,〈e, h〉5, 〈e, f, e, g〉3, 〈e, f, e, h〉2]. To check the conformance of the overall event log on the overall model,we check the conformance of L1 on PN 1 and L2 on PN 2. Since L1 perfectly fits PN 1 and L2 perfectly


fits PN 2, we can conclude that L perfectly fits PN .1 This illustrates that conformance checking can bedecomposed.

a

register

request

b

examine thoroughly

c

examine casually

d

check ticket

decide pay compensation

reject request

reinitiate request

e g

hf

c1

c2

c3

c4

c5

decide

e

reinitiate request

f

Figure 6. Two net fragments corresponding to the two passages of the skeleton in Fig. 5: PN 1 = PN ({a,f},{e})

(left) and PN 2 = PN ({e},{f,g,h}) (right). The visible transitions Tv = {a, e, f, g, h} that form the boundaries ofthe fragments are highlighted.

In order to prove this, we first define the notion of a net fragment.

Definition 5.2. (Net Fragment)Let PN = (P, T, F, Tv) be a labeled Petri net. For any two sets of transitions X,Y ⊆ Tv, we define thenet fragment PN (X,Y ) = (P ′, T ′, F ′, T ′v) with:

• Z = nodes(XF#Tv Y ) \ (X ∪ Y ) are the internal nodes of the fragment,

• P ′ = P ∩ Z,• T ′ = (T ∩ Z) ∪X ∪ Y ,• F ′ = F ∩ ((P ′ × T ′) ∪ (T ′ × P ′)), and• T ′v = X ∪ Y .

Note that PN 1 = PN ({a,f},{e}) in Fig. 6 has Z = {b, c, d, c1, c2, c3, c4} as internal nodes.Now we can prove the main result of this paper. Figure 7 illustrates our decomposition approach.

A larger model can be decomposed into net fragments corresponding to passages. The event log can bedecomposed in a similar manner and conformance checking can be done per passage.

The fragments corresponding to the passages are initially empty whereas the overall Petri net starts ina particular initial marking and ends in a particular final marking. Therefore, we extend the Petri net andevent log to incorporate initialization and termination (cf. the dashed > and ⊥ transitions in Figure 7).

Definition 5.3. (Extended System Net and Event Log)Let L ∈ B(A∗) be an event log and SN = (PN ,Mi,Mo) be a system net with PN = (P, T, F, Tv).Assume two fresh identifiers > and ⊥ to represent an artificial start (>) and an artificial complete (⊥).• L = [〈>〉 · σ · 〈⊥〉 | σ ∈ L] is the event log extended with explicit start and complete events.• PN = (P, T ∪ {>,⊥}, F ∪ {(>, p) | p ∈Mi} ∪ {(p,⊥) | p ∈Mo}, Tv ∪ {>,⊥}) is the Petri net

extended with with start and complete transitions.• SN = (PN , [ ], [ ]) is the extended system net having empty initial and final markings.

1Here we abstract from initialization and termination. These will be addressed by adding artificial start and complete transi-tions/events (cf. Definition 5.3).


b

a

c

d

e

j

i

hf

nk

l

m

o

pgi o

Figure 7. Petri net PN is decomposed into subnets PN (X,Y ). The “clouds” model the internal structure of thesesubnets (places but possibly also hidden transitions). Due to the decomposition based on passages, one cloudcan only influence another cloud through the visible interface transitions X and Y . Since the visible interfacetransitions are “controlled” by the event log, it is possible to check fitness locally per subnet.

The initial system net will often be a WF-net [1] as shown in Figure 7, i.e., there is one source place i andone sink place o with all nodes on a path from i to o and Mi = [i] and Mo = [o]. However, the resultspresented apply to any connected net and not just WF-nets. Note that Definition 5.3 assumes thatMi andMo are safe, i.e., these two markings have at most one token per place. However, the construction caneasily be generalized by introducing arc weights. Figure 8(a-b) illustrates the net extension described inDefinition 5.3.

To be able to project traces onto the visible nodes of a fragment, we define the following shorthandfor a passage P = (X,Y ): L�P= L�X∪Y , i.e., only the events corresponding to input or output nodesof P are retained in the resulting log.

Theorem 5.4. (Conformance Checking Can be Decomposed)Let L ∈ B(A∗) be an event log and let SN = (PN ,Mi,Mo) be a connected system net. For anypassage partitioning {P1, P2, . . . , Pn} of skel(PN ): L perfectly fits system net SN if and only if for all1 ≤ i ≤ n: L�Pi perfectly fits SN i = (PN

Pi , [ ], [ ]).

Proof:Note that SN is connected. This implies that in PN all nodes are on a path from > to ⊥ and that allnodes and edges in PN (i.e., also the nodes in PN ) are included in at least one net fragment PN Pi , i.e.,⋃i PN

Pi = PN .Second, we argue that L perfectly fits system net SN if and only if L perfectly fits system net SN .

This can be learned from the observation that for any σ: Mi[σ〉Mo in PN if and only if [ ] [(〈>〉 · σ ·〈⊥〉)〉 [ ] in PN . Hence, for σv ∈ L: Mi[σvBMo in PN if and only if [ ] [(〈>〉 · σv · 〈⊥〉)B [ ] in PN .

Hence it suffices to prove that: L perfectly fits the extended system net SN = (PN , [ ], [ ]) if and onlyif for all i: L�Pi perfectly fits SN i = (PN

Pi , [ ], [ ]). In the remainder we use the following notations:PN = (P, T, F, Tv) (note that {>,⊥} ⊆ Tv because PN is the extended Petri net) and PN

Pi =(P i, T i, F i, T iv) (the net fragment corresponding to passage Pi, constructed using Definition 5.2).

(⇒) Let σv ∈ L such that there is a σ ∈ T ∗ with [ ][σ〉[ ] in PN and σ�Tv= σv (i.e., σv fits into the


a b

c d

c1c2

start

end

a b

c d

c1c2

start

end

a b

c d

(a) original model

(b) extended model

(c) skeleton

a b

c d

b

c

(d) two passages

a

b

c d

c1

c2

start

end

b

c

(e) two net fragments

P1P2

PN1

PN2

Figure 8. The system net SN = (PN , [start ], [end ]) shown in (a) is extended into system net SN = (PN , [ ], [ ])by adding artificial start (>) and complete (⊥) transitions as shown in (b). The skeleton skel(PN ) is shown in (c).A passage partitioning composed of P1 = ({>, a}, {a, b, c}) and P2 = ({b, c, d}, {d,⊥}) is shown in (d) and thecorresponding two net fragments are shown in (e).

overall extended system net SN ). For all 1 ≤ i ≤ n, we need to prove that there is a σi with [ ][σi〉[ ]

in PNPi such that σi�Pi= σv�Pi . This follows trivially because SN i can mimic any move of SN with

respect to transitions T i: just take σi = σ�T i .

(⇐) Let σv ∈ L such that for each 1 ≤ i ≤ n there is a σi such that [ ][σi〉[ ] in PNPi and σi�Pi= σv�Pi .

We need to prove that there is a σ ∈ T ∗ such that [ ][σ〉[ ] in PN and σ �Tv= σv. The different σisequences can be stitched together into an overall σ because the different subnets only interface via vis-ible transitions and

⋃i PN

Pi = PN . Take σv and extend it by adding the local events. Transitionsin one subnet can only influence other subnets through visible transitions and these can only move syn-chronously as defined by σv ∈ L. ut

Theorem 5.4 shows that any trace in the log fits the overall model if and only if it fits each of the passage-based fragments. Moreover, as shown next, an upper bound for the degree of fitness can be computed ina distributed manner. For this we introduce an adapted cost function δQ.

Definition 5.5. (Adapted Cost Function)Let Q = {P1, P2, . . . , Pn} be a passage partitioning and δ ∈ ALM → IN a cost function (cf. Defini-tion 4.3). cQ(x, y) = |{1 ≤ j ≤ n | {x, y} ∩ (Xj ∪ Yj) 6= ∅}| counts the number of passages where xor y is an input or output node. The adapted cost function δQ is defined as follows: δQ(>,>) = 0,δQ(>, x) = δQ(x,>) = ∞ if x 6= >, δQ(⊥,⊥) = 0, δQ(⊥, x) = δQ(x,⊥) = ∞ if x 6= ⊥,δQ(x, y) = δ(x,y)

cQ(x,y) for (x, y) ∈ ALM and cQ(x, y) 6= 0.

There should never be a move on log only or a move on model only involving > or ⊥. This can be


avoided by associating extremely high costs (denoted as ∞) to moves other than (>,>) and (⊥,⊥).A visible transition may appear in multiple passages. Therefore, we divide its costs by the number ofpassages in which it appears: δQ(x, y) = δ(x,y)

cQ(x,y) . This way we avoid counting misalignments of thesame activity multiple times.

Theorem 5.6. (Lower Bound for Misalignment Costs)Let L ∈ B(A∗) be an event log and let SN = (PN ,Mi,Mo) be a connected system net. For any passagepartitioning Q = {P1, P2, . . . , Pn} of skel(PN ):

costs(L,SN , δ) ≥∑

1≤i≤ncosts(L�Pi ,SN

i, δQ)

where SN i = (PNPi , [ ], [ ]).

Proof:We can assume that the only moves involving the artificially added nodes are (>,>) and (⊥,⊥). Hence,no costs are added by extending the event log with > at the beginning and ⊥ at end of each trace. Forany σv ∈ L there is an optimal alignment γ of σv and SN such that the projection on the second elementyields a trace σ′v with [ ][σ′vB [ ] in PN , i.e., there is a trace σ with [ ][σ〉[ ] in PN and σ �Tv= σ′v.As shown in the proof of Theorem 5.4 there is a σi with [ ][σi〉[ ] in PN

Pi and σi�Pi= σ′v �Pi for any1 ≤ i ≤ n. In a similar fashion, γ can be decomposed in γ1, γ2, . . . γn where γi is an alignment of σv�Pi

and SN i. The sum of the costs associated with these local alignments γi is exactly the same as the costof the overall alignment γ. However, there may be local improvements lowering the sum of the costsassociated with these local alignments. Hence, costs(L,SN , δ) ≥

∑1≤i≤n costs(L�Pi ,SN

i, δQ). ut

Consider system net SN in Figure 8(a), passages P1 = ({>, a}, {a, b, c}) and P2 = ({b, c, d}, {d,⊥}),and event logs L1 = [〈a, b〉10, 〈c, d〉5], L2 = [〈a, a, b〉], and L3 = [〈a, b, c, d〉]. The correspondingextended system net SN is shown in Figure 8(b) and the corresponding extended event logs are L1 =[〈>, a, b,⊥〉10, 〈>, c, d,⊥〉5], L2 = [〈>, a, a, b,⊥〉], and L3 = [〈>, a, b, c, d,⊥〉]. costs(L1,SN , δS) =costs(L1�P1 ,SN

1, δQ)+costs(L1�P2 ,SN2, δQ) = 0 and costs(L2,SN , δS) = costs(L2�P1 ,SN

1, δQ)+costs(L2�P2 ,SN

2, δQ) = 1 + 0 = 1, i.e., the costs of the optimal overall alignments are equal to thesums of the costs associated to all optimal local alignments. Consider for example the following overalloptimal alignment for 〈a, a, b〉 and optimal local alignments for 〈>, a, a, b,⊥〉:

γ =a a b

a � bγ1 =

> a a b

> a � bγ2 =

b ⊥b ⊥

The costs of the overall optimal alignment γ equals the costs of the two optimal local alignments γ1and γ2. This does not hold for event log L3: costs(L3,SN , δS) = 2, costs(L3 �P1 ,SN

1, δQ) = 0.5,and costs(L3�P2 ,SN

2, δQ) = 0.5. Hence, the total costs are higher than the costs associated to the twooptimal local alignments. To understand this, consider the following optimal alignments for 〈a, b, c, d〉and 〈>, a, b, c, d,⊥〉:

γ =a b c d

a b � �γ′ =

a b c d

� � c dγ1 =

> a b c

> a b �γ2 =

b c d ⊥� c d ⊥


The cost of any of the two overall optimal alignments is δS(γ) = δS(γ′) = 2. The cost of the optimalalignment γ1 for passage P1 is δQ(γ1) = 0 + 0 + 0 + δQ(c,�) = δS(c,�)

cQ(c,�) = 12 = 0.5. The cost of the

optimal alignment γ2 for passage P2 is δQ(γ2) = δQ(b,�) + 0 + 0 + 0 = δS(b,�)cQ(b,�) = 1

2 = 0.5. Hence,

costs(L3,SN , δS) = 2 > costs(L3�P1 ,SN1, δQ) + costs(L3�P2 ,SN

2, δQ) = 1. This shows that theremay indeed be local improvements lowering the sum of the costs associated with local alignments.

Theorem 5.6 shows that the sum of the costs associated to all selected optimal local alignments(using δQ) can never exceed the cost of an optimal overall alignment using δ. Hence, it can be usedfor an optimistic estimate, i.e., computing an upper bound for the overall fitness and a lower bound forthe overall costs. More important, the fitness values of the different passages provide valuable localdiagnostics. The passages with the highest costs are the most problematic parts of the model. Thealignments for these “problem spots” help to understand the main problems without having to look atvery long overall alignments.

Theorem 5.6 shows just one of many possible definitions of fitness. We can also simply countthe fraction of fitting traces. In this case the problem can be decomposed easily using the notationof passages.

Theorem 5.7. (Fraction of Perfectly Fitting Traces)Let L ∈ B(A∗) be an event log and let SN = (PN ,Mi,Mo) be a connected system net. For any passagepartitioning Q = {P1, P2, . . . , Pn} of skel(PN ):

|[σ ∈ L | σ ∈ τ(SN )]||L|

=|[σ ∈ L | ∀1≤i≤n σ�Pi ∈ τ(SN i)]|

|L|

Proof:Follows from the construction used in Theorem 5.4. A trace is fitting the overall model if and only if itfits all passages. ut

As Theorem 5.7 suggests, traces in the event log can be marked as fitting or non-fitting per passage.These results can be merged easily and used to compute the fraction of traces fitting the overall model.

Although the results presented only address the notion of fitness, it should be noted that alignmentsare the starting point for many other types of analysis. For example, precision can be computed bycounting so-called “escaping edges” (sequences of steps allowed by the model but never happening inthe event log) [33, 34]. This can be done at the level of passages even though there is not a straightforwardmanner to compute the overall precision level. Note that relatively many escaping edges in a passagesuggest “underfitting” of that part of model. As shown in [11], alignments should be the basis forprecision analysis. Therefore, the construction used in Theorems 5.4 and 5.6 can be used as a startingpoint. A similar approach can be used for generalization: many unique paths in a passage may indicate“overfitting” of that part of the model [5].

The alignments can be used beyond conformance checking. An alignment γi (see proof of The-orem 5.6) relates observed events to occurrences of transitions of some passage Pi. If the event logcontains timestamps, such alignments can be used to compute times in-between transition occurrences(waiting times, response times, service times, etc.) as shown in [2]. This way bottlenecks can be iden-tified. If the event log contains additional data (e.g., size of order, age of patient, or type of customer),these local alignments can be used for decision mining [35]. For any decision point in a passage (place


with multiple output arcs), one can create a decision tree based on the data available prior to the choice.Note that bottleneck analysis and decision point analysis provide local diagnostics and can be added tothe overall model without any problems.

Assuming a process model with many passages, the time needed for conformance checking can bereduced significantly. There are two reasons for this. First of all, as our theorems show, larger problemscan be decomposed into sets of independent smaller problems. Therefore, conformance checking canbe distributed over multiple computers. Second, due to the exponential nature of most conformancechecking techniques, the time needed to solve “many smaller problems” is less than the time neededto solve “one big problem”. Existing conformance checking approaches use state-space analysis (e.g.,in [36] the shortest path enabling a transition is computed) or optimization over all possible alignments(e.g., in [9] the A∗ algorithm is used to find the best alignment). These techniques do not scale linearlyin the number of activities. Therefore, decomposition is useful even if the checks per passage are doneon a single computer. Moreover, passages are not just interesting from a performance point of view: theycan also be used to pinpoint the most problematic parts of the process (also in terms of performance) andprovide localized diagnostics.

6. Process Discovery: Divide and Conquer

In the previous section, we showed that we can decompose conformance checking tasks using passages.Instead of checking the conformance of the entire event log on the entire system net, we split up thelog and the net into pairs of sublogs and net fragments, and check conformance on each of these pairs.Provided that we have a collection of passages, we can do something similar for discovery: Instead ofdiscovering the whole system net in one go, we first split up the log into sublogs, then discover a netfragment for every sublog, and finally fold all net fragments into one overall system net.

Our approach builds on existing process discovery algorithms. There exist dozens of algorithms –ranging from the simple α miner [8] to the more sophisticated ILP miner [42] – that discover a Petrinet from an event log. For passage-based discovery, we use such an algorithm, discover a fragment perpassage, and apply Definition 5.2 in reverse direction. Γp denotes the class of algorithms that can beused to discover a Petri net PN (X,Y ) for a passage (X,Y ). In order to decompose a discovery problemusing passages, we first need to derive a graph with causal dependencies from the event log. Γc denotesthe class of algorithms that can be used to discover these dependencies.

Definition 6.1. (Γc algorithm)Let L ∈ B(A∗) be an event log over A. A Γc algorithm is an algorithm that takes the event log Land returns a causal structure (i.e. a graph) with nodes V ⊆ A, that is, if γc is a Γc algorithm, thenγc(L) = (V,E) is a graph with V ⊆ A.

Note that many process discovery algorithms have an initial phase deriving these dependencies by scan-ning the event log, e.g., the> (“directly follows”),→ (“causality”), ‖ (“concurrency”), and # (“choice”)relationships inferred by the α miner [8]. The Heuristics miner [41, 39] derives similar relations whiletaking noise and incompleteness into account. These algorithms can easily be distributed as they simplycount basic patterns in the event log. Basically, a Γc algorithm takes an event log as input, and returnsa causal structure as output. Optionally, the discovered causal structure can be edited before computing


the passages from it. After determining the passages, we discover a net fragment per passage using a Γpalgorithm and merge the results.

Definition 6.2. (Γp algorithm)Let L ∈ B(A∗) be an event log over A and let X,Y ⊆ A. A Γp algorithm is an algorithm that takes apassage (X,Y ) and the corresponding sublog L�X∪Y and returns a net fragment with visible transitionsX ∪ Y , that is, if γp is a Γp algorithm, then γp(L�X∪Y , X, Y ) = (P, T, F,X ∪ Y ) is a labeled Petri net.

Note that γc ∈ Γc returns a causal structure that may include some (but not necessarily all) activities(V ⊆ A). This way, the algorithm can effectively remove, for example, infrequent activities that mightonly complicate the discovery process. The resulting causal structure can be inspected and modified bya domain expert. This domain expert can remove any causalities that she knows do not exist, and canadd any causalities that she knows are missing. After the domain expert has thus massaged the causalstructure, a passage partitioning is derived from it and used to decompose the whole event log into acollection of sublogs.

The Γc algorithm operates on the whole event log, whereas we are trying to speed-up discoveryby splitting up the entire log into a collection of sublogs. However, we can use Γc algorithms that arevery fast compared to more sophisticated process mining algorithms, e.g., algorithms based on state-based regions [7, 21, 37], language-based regions [15, 42], or genetic evolution [32] are much moretime consuming. A typical example is the ILP miner [42], which creates an integer-linear programmingproblem that is exponential in the size of A, that is, in the number of activities. By using a fast Γcalgorithm, passages can be used to quickly split up A into smaller sets; as a result the ILP miner canwork much faster. Furthermore, the Γc algorithm need not take the entire log into account. Its purpose isto construct a causal structure, which is more abstract and high-level, whereas the Γp algorithm needs tofill in the nitty-gritty low-level details later. Therefore, it may suffice to use only a sample set of traces.

After having introduced the Γp and Γc classes of algorithms, we now introduce our passage-baseddiscovery approach.

Definition 6.3. (Passage-based Discovery)Let L ∈ B(A∗) be an event log over a set of activities A and let γp ∈ Γp and γc ∈ Γc be the two selectedalgorithms. Our passage-based discovery approach proceeds as follows:

1. Extend each trace in the event log with an artificial start event > and an artificial end event ⊥({>,⊥} ∩A = ∅). L = [〈>〉 · σ · 〈⊥〉 | σ ∈ L] is the resulting log over A = {>,⊥} ∪A.

2. Discover the causal structure using γc. (Aγc , Cγc) = γc(L) is the resulting causal structure with{>,⊥} ⊆ Aγc ⊆ A and Cγc ⊆ Aγc ×Aγc .

3. Optional: Have a domain expert inspect (and massage if needed) the causal structure (Aγc , Cγc).(A′γc , C

′γc) is the resulting, possibly modified, causal structure.

4. Compute the set of minimal passages on the causal structure (A′γc , C′γc). {(X1, Y1), (X2, Y2), . . . ,

(Xk, Yk)} = pasmin(A′γc , C′γc) is the resulting set of passages.

5. For every minimal passage (Xi, Yi): Discover a net fragment using γp. PN i = (Pi, Ti, Fi, Xi ∪Yi) = γp(L�Xi∪Yi , Xi, Yi) is the resulting net fragment for passage i.

6. Merge the individual net fragments PN i into one overall system net. SN = (PN ,Mi,Mo) withPN = (P, T, F, Tv) is the resulting system net, where:• P = {in, out} ∪

⋃1≤i≤k Pi,

• T = ∪1≤i≤k Ti,


• F = {(in,>), (⊥, out)} ∪ (⋃

1≤i≤k Fi),• Tv =

⋃1≤i≤k Xi ∪ Yi,

• Mi = [in], and• Mo = [out ].

The log is extended by adding an artificial start event > and an artificial end event ⊥ to every trace. Thisis just a technicality to ensure that there is a clearly defined start and end. Note that passages can beactivated multiple times, e.g., in case of loops. Therefore, we add transitions > and ⊥ and places in andout . If there is a unique start (end) event, then there is no need to add transition> (⊥). Ideally, the causalstructure (A′γc , C

′γc) has one source node >, one sink node ⊥, and all other nodes are on a path from >

to ⊥ (like in a WF-net [1]).Note that in Step 4 minimal passages are computed since we aim to decompose the discovery problem

in as many small independent problems as possible. However, in principle any passage partitioning maybe used as illustrated by Theorems 5.4, 5.6, and 5.7.

To illustrate our divide-and-conquer approach, consider the event logL = [〈a, b, c, d〉40, 〈b, a, c, d〉35,〈a, b, c, e〉30, 〈b, a, c, e〉25, 〈a, b, x, d〉1, 〈a, b, e〉1]. The log describes 132 cases. We first add artificialevents as described in Step 1: L = [〈>, a, b, c, d,⊥〉40, 〈>, b, a, c, d,⊥〉35, 〈>, a, b, c, e,⊥〉30, 〈>, b, a,c, e,⊥〉25, 〈>, a, b, x, d,⊥〉1, 〈>, a, b, e,⊥〉1]. Then we compute the causal structure using the γc ∈ Γcalgorithm of choice (Step 2). Assume that the causal structure shown in Fig. 9 is computed. Since xoccurs only once whereas the other activities occur more than 50 times, x is excluded. The same holdsfor the dependency between b and e. Furthermore, we assume that the domain expert does not changethe causal structure (Step 3).

a

b

c

d

e

Figure 9. Causal structure γc(L) discovered for the extended event log having four minimal passages.

The causal structure has four minimal passages (Step 4): P1 = ({>}, {a, b}), P2 = ({a, b}, {c}),P3 = ({c}, {d, e}), and P4 = ({d, e}, {⊥}). Based on these passages, we create four correspondingsublogs: L1 = [〈>, a, b〉72, 〈>, b, a〉60], L2 = [〈a, b, c〉70, 〈b, a, c〉60, 〈a, b〉2], L3 = [〈c, d〉75, 〈c, e〉55,〈d〉1, 〈e〉1], and L4 = [〈d,⊥〉76, 〈e,⊥〉56]. One transition-bordered Petri net is discovered per sublogusing the γp ∈ Γp algorithm of choice (Step 5). Figure 10 shows the net fragments discovered perpassage. Note that infrequent behavior has been discarded by γp, i.e., trace 〈a, b〉 in L2 is not possibleaccording to PN 2 (does not end is desired end state), and traces 〈d〉 and 〈e〉 in L3 are not possibleaccording to PN 3.

In the last step of the approach, the four net fragments of Fig. 10 are merged into the overall netsystem shown in Figure 11 (Step 6). Note that this net system is indeed able to replay all frequentbehavior. Two of the 132 cases cannot be replayed because they were treated as noise by the selected γcand γp algorithms.

Although the resulting model in Figure 11 is simple and has no loops, there are no limitations withrespect to the control-flow patterns used and loops can be handled without any problems. The smallexample shows that we can use a divide-and-conquer approach when discovering process models. We


a

b

c

d

e

d

e

a

b

c

Figure 10. The Petri net fragments discovered for the four passages: PN 1, PN 2, PN 3, and PN 4.

in

a

b

c

d

e

out

Figure 11. The Petri net obtained by merging the individual subsets.

deliberately did not restrict ourselves to specific Γc and Γp algorithms. The approach is generic and canbe combined with existing process discovery techniques [2, 7, 8, 13, 15, 20, 21, 23, 27, 32, 37, 40, 42].Moreover, the user can modify the causal structure to guide the discovery process.

By decomposing the overall discovery problem into a collection of smaller discovery problems, it ispossible to do a more refined analysis and achieve significant speed-ups. The γc algorithm only needsto construct an abstract causal structure. Hence, it may take only a sample (say, 100 randomly chosentraces) of the event log into account. The γp algorithm is applied for every net passage, and needs toconstruct a detailed net fragment. Hence, it needs only to consider an event log consisting of just theactivities involved in the corresponding passage. As a result, process discovery tasks can be distributedover a network of computers (assuming there are multiple passages). As most discovery algorithmsare exponential in the number of activities, the sequential discovery of all individual passages on onecomputer is often still faster than solving one big discovery problem. If there are more minimal passagesthan computers, one can merge minimal passages into aggregate passages and use these for discoveryand conformance checking (one passage per computer). However, in most situations, it will be moreefficient to analyze the minimal passages sequentially.

7. Empirical Evaluation

In earlier sections we showed that process mining problems can be divided into smaller problems andthat by doing this, in theory, significant speed-ups are possible. Since our passage-based decompositionapproach is very general, it is not easy to evaluate this empirically. For example, we can choose frommany different process discovery algorithms. Moreover, there are various algorithms that cannot benefitfrom a passage-based decomposition approach because they are linear in the size of the event log. Forexample, the α miner [8] and the heuristics miner [41] make one pass through the whole log whilecounting simple metrics like direct successions. Obvious such techniques will not benefit from passage-based decomposition. However, these algorithms have various limitations: they create models without


I1 I2 I3 I4

IO1 IO2

O1 O2 O3

I1 I2 I3 I4

IO1 IO2

O1 O2 O3

Figure 12. An example passage and a corresponding Petri net.

any guarantees, e.g., the resulting models may have deadlocks, have a poor fitness, and be very complexand under- or over-fitting. Only more expensive algorithms that replay the log and solve optimizationproblems can provide such guarantees.

Therefore, we use a particular setting to provide some insights into the speed-ups possible due topassage-based decomposition. We use a particular process discovery technique that heavily relies onconformance checking (replay). Section 7.1 presents the setting for the evaluation. Section 7.2 presentsthe empirical results obtained. These results clearly show that without using passages we would notbe able to use the given γp algorithm, whereas with using passages it can be used on real-life logs.Section 7.3 discusses the main findings.

7.1. Setting

For the evaluation, we use a real-life event log2 based on the BPI Challenge 2012 event log [26] andaim to discover a process model describing the most frequent behavior. This real-life log contains noise,which we will tackle by using the Heuristic Miner [41]3 as γc algorithm. This miner will provide us witha Heuristic net that shows generic causal relations between actions, but which does not show the specifictransitions that represent these relations. To obtain these specific transitions we will use an exhaustivesearch algorithm as γp algorithm. This algorithm simply iterates over all possible sets of transitions thatsatisfy the causal relations, and takes in the end the set of transitions with maximal fitness.

The left-hand side of Figure 12 shows a passage containing six input nodes and five output nodes.Input node I2 is source to two causal relations: one to IO1 and one to O2. The splitting behavior of I2can be captured by the exhaustive search algorithm in two ways: either there is an XOR-split betweenIO1 and O2, or there is an AND-split to both. The splitting behavior of I1 is slightly more complicated,as it involves three causal relations. This behavior can either be captured using (1) a single XOR-split,(2) a single AND-split, or (3) by a combination of an XOR-split between one and an AND-split for theother two, five possibilities in total.

2The actual event log used can be downloaded from http://www.win.tue.nl/~hverbeek/downloads/preprints/

Aalst13.xes.gz.3For sake of completeness: We used the Heuristics Miner with default settings, except for Relative to best, which we setto 0, and Dependency, which we set to 100.


Table 1 shows the numbers of partitions (Bell numbers) up to sets containing 7 relations. Please notethat we explicitly partition the set of outgoing causal relations, that is, we do not allow multiple splittingtransitions to capture the same outgoing causal relation. Reason for doing so is that the latter would allowfor a Petri net that contains all possible splitting transitions, which would have maximal fitness by default.Instead, we partition the outgoing causal relations over the splitting transitions, and try to maximize thefitness thus. Mutatis mutandis, the same holds for incoming causal relations and joining transitions. Asan example, there are 52 possible sets of transitions that capture the five incoming edges to the O2 outputtransition. In total, this particular passage would require (5× 2× 2× 2)× (2× 52× 2) = 8320 possiblesets of transitions. The right-hand side of Figure 12 shows a possible set of transitions.

To show the effect of passages, we will mine a Petri net for different log sizes (1%, 5%, 10%, 50%,and 100% of the 13, 087 traces of the original log) and for different numbers of passages (20, 15, 10, 7,and 5). Table 2 shows the characteristics of the system we used to run the evaluation on. For sake ofcompleteness, we mention that we set the OpenXES shadow size to 16, which allows OpenXES to keep16 buckets containing event log data in memory.

The log at hand contains 20 passages, of which the most complex passage requires 877 fitness checks,and 2062 fitness checks in total. Starting from these passages, we obtained less (but more complex)passages by combining pairs of passages into single passages. As a result, we obtained situations with15, 10, 7, and 5 passages (see Table 3). Please note that the decision which passages to merge intonew passages may have a huge impact on the resulting run times. For example, if we would merge twopassages with 1 and 877 possibilities, then the resulting passage would have 877 possibilities, whereasif we would merge passages with 300 and 10 possibilities, the the resulting passage would have 3000possibilities. With this in mind, we tried to merge passages that share some nodes in such a way thatthe remaining number of possibilities would not rise too quickly. For example, to obtain 15 passagesfrom the initial 20 passages, we merged four passages with single-possibility passages, which does notincrease the total number of possibilities, and we allowed only a minor increase for the fifth merger (from25 and 5 to 125).

As for the situation with only 5 passages it was already a challenge to discover the model using only1% of the traces in the log, we decided to stop at 5 passages. Clearly, it is impossible to apply our brute-force discovery approach to the overall log without any passages. As the results will show, the situationwhere we would only have a single passage, that is, the situation where we would try an exhaustivesearch for all possible transitions, would take about 3.46× 1019 fitness checks, which would have takeneras to compute even if a single fitness check would take a fraction (say, a hundredth) of a second.

7.2. Results

Table 4 and Figure 13 show the results of the evaluation. These results clearly show that the run timesare positively effected by an increase in the number of passages. For example, when using only 1 percentof the event log, it takes 879,634 seconds (more than 10 days) to discover the process when using 5passages whereas this only takes 873 seconds (less than a quarter) to discover the process when using 20passages.

Figure 14 shows the resulting Petri net from one of the experiments. Please note that not all experi-ments resulted in the same net, which is caused by the fact that we use random samples from the log tocheck the fitness on. From this example we can conclude that, at least for this log, many causal relationscorrespond to XOR-splits and/or XOR-joins, as the resulting net contains only two transitions with mul-


# Edges 1 2 3 4 5 6 7 . . .

# Possibilities 1 2 5 15 52 203 877 . . .

Table 1. The number of potential partitions given a set of k edges corresponds to the k-th Bell number

Key Value

Computer Dell Precision T5400Processor Intel R© Xeon R© CPU, E5430 @ 2.66Ghz (2 processors)Installed memory (RAM) 16.0 GBSystem type 64-bit Windows 7 Enterprise SP 1JRE 64-bit jdk1.6.0 24VM arguments -ea -Xmx4G

Table 2. Basic information on the system used

# PassagesPassage 20 15 10 7 5

1 1 1

2 1 1 1

3 240

4 1 240 240 240 240

5 300 300

6 10 10 3000 3000

7 25

8 5 125 125 125 375, 000

9 1 1

10 2 2 2

11 1

12 30 30 30 60 60

13 2 2

14 300 300 600

15 1

16 60 60 60 36, 000 36, 000

17 1 1

18 877 877 877 877

19 1

20 203 203 203 203 178, 031

Total 2062 2153 5138 40, 505 589, 331

Table 3. Numbers of possibilities per passage


# Passages # Checks 1% 5% 10% 50% 100%

5 589, 331 879, 634 − − − −7 40, 505 36, 183 100, 852 198, 765 − −

10 5138 5308 16, 853 25, 928 86, 116 139, 230

15 2153 1087 2882 4480 13, 995 24, 067

20 2062 873 2487 4040 12, 480 20, 414

Table 4. Obtained run times (in seconds). Due to lack of resources, we were unable to run the situations marked−.

100

1000

10000

100000

1000000

0 20 40 60 80 100

seco

nd

s

Percentage of log size

5 7 10 15 20#Passages:

100

1000

10000

100000

1000000

0 5 10 15 20 25

seco

nd

s

#Passages

1 5 10 50 100Percentage of log size:

Figure 13. Obtained run times (in seconds) per log size (left) and number of passages (right). Note that run timesare plotted on a logarithmic scale and for smaller numbers of passages we were only able to use a fraction of theevent log.

tiple outputs and two transitions with multiple inputs. Also note that, using this technique, we were ableto mine not only the transitions that do correspond to event classes in the log, but also many transitionsthat do not correspond to any event class in the log, that is, we were also able to discover many silenttransitions.

7.3. Discussion of Experimental Results

Passage-based decomposition enabled us to discover a Petri net from a real-life log (based on the BPIChallenge 2012 log) using a brute-force approach. In a first phase, we have used the Heuristic Miner toextract the major causal relations from the log. In a second phase, we have split up these causal relationsinto passages, and have used an exhaustive search miner to convert these causal relations into transitions.As a result, we have obtained a Petri net able to explain the mainstream behavior. The resulting netcontains 36 transitions that correspond to event classes in the log, 22 silent transitions, and 43 places.Note that the fact that the resulting Petri net contains silent transitions can be considered to be a plus,as there are only few techniques that can both handle noise in the log and come up with these silenttransitions.

If we would not have been able to split up the causal relations into smaller parts (like the passages),


SCHEDULE

STARTCOMPL

ETE

W_Valideren aanvraag

A_SUBMITTED

A_PARTLY_SUBMITTED

A_PREACCEPTE

D

A_CANCELED

O_SENT_BACK

A_ACCEPTED

O_SELECTED

A_FINALIZED

O_CANCELED

O_CREATED

O_SENT

O_ACCEPTED

A_APPROVED

A_ACTIVATED

A_REGISTERED

O_DECLINED

A_DECLINE

SCHEDULE

STARTCOMPL

ETE

W_Completeren aanvraag

STARTCOMPL

ETESCHEDU

LE

W_Nabellen offertes

SCHEDULE

STARTCOMPL

ETE

W_Nabellen incomplete dossiers

COMPLETE

STARTSCHEDU

LE

W_Beoordelen fraude

SCHEDULE

STARTCOMPL

ETE

W_Afhandelen leads

W_Wijzigen contractgegevens

Figure 14. Obtained Petri net


then we would have had a hard time to convert these causal relations into transitions and places, as wewould have to check 3.46× 1019 possible combinations of transitions for the entire net.

The mining of the net took almost six hours when using the complete log to check the fitness forall 2062 possible transition sets for the 20 passages. The fewer passages we detect, the more complexthey will be, the more possible transition sets there will be, and the more time it will take to check themall. Therefore, it is important to have as many passages as possible. In our example, our most complexpassage corresponded to 877 possible transitions sets, and even this took almost six hours. Hence, it isvital to be able to break down passages into smaller passages in case the complexity of the passages istoo high. More research is needed to create so-called “approximate passages”, i.e., passages created byinserting artificial events or by leaving out edges that are less important. Obviously, there is a trade-offbetween the desire to include all possible causalities and breaking down larger passages. However, sinceone is often looking for understandable models that capture most of the observed behavior, it is valid toconsider such trade-offs. Note that models obtained using large passages will typically contain complexfragments that are not understandable.

In this section, we focussed on discovery. However, the brute-force approach repeatedly computesfitness. Hence, the results shown in Table 4 and Figure 13 are also representative for conformancechecking.

8. Implementation in ProM

The distributed conformance checking approach presented in Section 5 has been implemented as the“Replay Passages” plug-in in ProM 6.2, and the divide-and-conquer process discovery technique fromSection 6 has been implemented as the “Mine Petri net using Passages” plug-in. Both plug-ins have beenimplemented in the “Passage” package, which is installed in ProM 6.2 by default.

The “Mine Petri net using Passages” plug-in is configured by selecting a γc ∈ Γc algorithm and aγp ∈ Γp algorithm, a maximum size on passages, and which activities to retain in the causal structure.ProM 6.2 supports the following Γc algorithms:Alpha Miner Returns a causal structure based on the → (“causality”) relation constructed by the α

miner [8].Basic Log Relations Constructs basic log relations (similar to those used by the αminer) from the event

log and derives a causal structure from these relations.Heuristics Miner Returns a causal structure using the Heuristics miner [41, 39]. The user is allowed to

configure the Heuristics miner in the usual way (e.g., set thresholds for deriving causalities).Flower Miner Creates a causal structure which results in two passages: One passage containing only

the start (>) and complete (⊥) events, and one passage containing all other (i.e., original) events.This algorithm allows one to run the chosen Γp algorithm on the original log (as the second passagecontains all events from the original, i.e., not extended, log).

Flower and ILP Miner with Proper Completion First creates the two passages like the previous algo-rithm, then runs the ILP miner (with the proper completion option selected) on the second passage,and derives a causal structure from the mined net.

and the following Γp algorithms4:

4The exhaustive miner as used in Section 7 is not included in ProM 6.2, but is included as the Exhaustive Miner in the ProM 6nightly build (See http://www.promtools.org/prom6) as of December 7, 2012.


Alpha Miner Returns a Petri net fragment per passage by applying the α miner [8] to each sublog.ILP Miner Returns a Petri net fragment per passage by applying the ILP miner [42] to each sublog

(using the default configuration).ILP Miner with Proper Completion Returns a Petri net fragment per passage by applying the ILP

miner [42] to each sublog (with the proper completion option selected).The maximum passage size determines for which passages the Γp algorithm is used: If the size of apassage (|X ∪ Y | for a passage (X,Y )) exceeds this threshold, then a dummy net fragment containingonly a transition for every event (i.e, no places) is constructed, otherwise the Γp algorithm is used to minethe net fragment. However, if this size is set to 0, then no maximum size applies, i.e., the Γp algorithm isused to mine every net fragment.

The current implementation does not allow for the interactive editing of the causal structure. Thedomain expert can only inspect the causal structure and select the set of activities to retain. After theplug-in has been configured, the passage-based discovery approach described in Definition 6.3 is used toconstruct the overall process model.

9. Related Work

For an introduction to process mining we refer to [2]. For an overview of best practices and challenges,we refer to the Process Mining Manifesto [29]. The goal of this paper is to decompose challengingprocess discovery and conformance checking problems into smaller problems [4]. Therefore, we firstreview some of the techniques available for process discovery and conformance checking.

Process discovery, i.e., discovering a process model from a multiset of example traces, is a very chal-lenging problem and various discovery techniques have been proposed [7, 8, 13, 15, 20, 21, 23, 27, 32,37, 40, 42]. Many of these techniques use Petri nets during the discovery process and/or to represent thediscovered model. It is impossible to provide a complete overview of all techniques here. Very differ-ent approaches are used, e.g., heuristics [23, 40], inductive logic programming [27], state-based regions[7, 21, 37], language-based regions [15, 42], and genetic algorithms [32]. Classical synthesis techniquesbased on regions [25] cannot be applied directly because the event log contains only example behav-ior. For state-based regions one first needs to create an automaton as described in [7]. Moreover, whenconstructing the regions, one should avoid overfitting. Language-based regions seem good candidatesfor discovering transition-bordered Petri nets for passages [15, 42]. Unfortunately, these techniques stillhave problems dealing with infrequent/incomplete behavior.

As described in [2], there are four competing quality criteria when comparing modeled behavior andrecorded behavior: fitness, simplicity, precision, and generalization. In this paper, we focused on fitness,but also precision and generalization can also be investigated per passage. Various conformance checkingtechniques have been proposed in recent years [5, 9, 10, 12, 18, 24, 27, 33, 34, 36, 38]. Conformancechecking can be used to evaluate the quality of discovered processes but can also be used for auditingpurposes [6]. Most of the techniques mentioned can be applied to passages. The most challenging partis to aggregate the metrics per passage into metrics for the overall model and log. We consider theapproach described in [9] to be most promising as it constructs an optimal alignment given an arbitrarycost function. This alignment can be used for computing precision and generalization [5, 34]. However,the approach can be rather time consuming. Therefore, the efficiency gains can be considerable for largerprocesses with many activities and passages.


Little work has been done on the decomposition and distribution of process mining problems [4].In [17] an approach is described to distribute genetic process mining over multiple computers. In thisapproach candidate models are distributed and in a similar fashion also the log can be distributed. How-ever, individual models are not partitioned over multiple nodes. Therefore, the approach in this paper iscomplementary. Moreover, unlike [17], the decomposition approach based on passages is not restrictedto genetic process mining.

Most related are the divide-and-conquer techniques presented in [22]. In [22] it is shown that region-based synthesis can be done at the level of synchronized State Machine Components (SMCs). Also aheuristic is given to partition the causal dependency graph into overlapping sets of events that are used toconstruct sets of SMCs. Passages provide a different (more local) partitioning of the problem and, unlike[22] which focuses specifically on state-based region mining, we decouple the decomposition approachfrom the actual conformance checking and process discovery approaches.

Several approaches have been proposed to distribute the verification of Petri net properties, e.g., bypartitioning the state space using a hash function [16] or by modularizing the state space using localizedstrongly connected components [30]. These techniques do not consider event logs and cannot be appliedto process mining.

Most data mining techniques can be distributed [19], e.g., distributed classification, distributed clus-tering, and distributed association rule mining [14]. These techniques often partition the input data andcannot be used for the discovery of Petri nets.

This paper is an extended version of a paper presented at Petri nets 2012 [3]. Many of the results havebeen generalized, e.g., from WF-nets to arbitrary nets and from minimal passages to arbitrary passagepartitionings. Moreover, the properties of passages are now described in detail and the notion of passagesis supported through various new ProM plug-ins. Unlike [3] we now also provide experimental resultsshowing that speedups are indeed possible.

10. Conclusion

Computationally challenging process mining problems can be decomposed into smaller problems usingthe new notion of passages. As shown, conformance checking can be done per passage and the resultsper passage can be merged into useful overall conformance diagnostics using the observation that a traceis non-fitting if and only if it is non-fitting for at least one passage. The paper also presents a discoveryapproach where the discovery problem can be decomposed after determining the causal structure. Therefined behavior can be discovered per passage and, subsequently, the discovered net fragments can bemerged into an overall process model. Conformance checking and process discovery can be done muchmore efficiently using such decompositions. Moreover, the notion of passages can be used to local-ize process-related diagnostics. For example, it is easier to explore conformance-related problems perpassage and passages provide a means to hierarchically structure discovered process models. Both ap-proaches have been implemented in ProM 6.2 and can be used for decomposing a variety of conformancechecking and process discovery algorithms.

Future work will focus on more large scale experiments demonstrating the performance gains whendecomposing various process mining tasks. The experiments in this paper show that the actual speedupheavily depends on the number of passages and the size of the largest passage. If there are many smallerpassages, orders of magnitude can be gained. However, in worst case, there is just one passage and no


speed-up is possible. Ideally, we would like to use a passage partitioning Q = {P1, P2, . . . , Pn} suchthat n is as large as possible and the passages Pi are as small as possible. From a practical point of view,models with just a few large passages are less interesting as, by definition, they will be Spaghetti-like[2]. To ensure smaller passages, one may need to abstract from edges that are less important. We arecurrently investigating such “approximate passages”. Clearly, there is a trade-off between the desire toinclude all possible causalities and minimizing the average passage size or the size of the biggest passage.Therefore, we would like to investigate Γc algorithms that try to minimize the number of passages withoutcompromising accuracy too much.

References

[1] W.M.P. van der Aalst. The Application of Petri Nets to Workflow Management. The Journal of Circuits,Systems and Computers, 8(1):21–66, 1998.

[2] W.M.P. van der Aalst. Process Mining: Discovery, Conformance and Enhancement of Business Processes.Springer-Verlag, Berlin, 2011.

[3] W.M.P. van der Aalst. Decomposing Process Mining Problems Using Passages. In S. Haddad and L. Pomello,editors, Applications and Theory of Petri Nets 2012, volume 7347 of Lecture Notes in Computer Science,pages 72–91. Springer-Verlag, Berlin, 2012.

[4] W.M.P. van der Aalst. Distributed Process Discovery and Conformance Checking. In J. de Lara and A. Zis-man, editors, International Conference on Fundamental Approaches to Software Engineering (FASE 2012),volume 7212 of Lecture Notes in Computer Science, pages 1–25. Springer-Verlag, Berlin, 2012.

[5] W.M.P. van der Aalst, A. Adriansyah, and B. van Dongen. Replaying History on Process Models for Confor-mance Checking and Performance Analysis. WIREs Data Mining and Knowledge Discovery, 2(2):182–192,2012.

[6] W.M.P. van der Aalst, K.M. van Hee, J.M. van der Werf, and M. Verdonk. Auditing 2.0: Using ProcessMining to Support Tomorrow’s Auditor. IEEE Computer, 43(3):90–93, 2010.

[7] W.M.P. van der Aalst, V. Rubin, H.M.W. Verbeek, B.F. van Dongen, E. Kindler, and C.W. Gunther. ProcessMining: A Two-Step Approach to Balance Between Underfitting and Overfitting. Software and SystemsModeling, 9(1):87–111, 2010.

[8] W.M.P. van der Aalst, A.J.M.M. Weijters, and L. Maruster. Workflow Mining: Discovering Process Modelsfrom Event Logs. IEEE Transactions on Knowledge and Data Engineering, 16(9):1128–1142, 2004.

[9] A. Adriansyah, B. van Dongen, and W.M.P. van der Aalst. Conformance Checking using Cost-Based FitnessAnalysis. In C.H. Chi and P. Johnson, editors, IEEE International Enterprise Computing Conference (EDOC2011), pages 55–64. IEEE Computer Society, 2011.

[10] A. Adriansyah, B.F. van Dongen, and W.M.P. van der Aalst. Towards Robust Conformance Checking. InM. zur Muehlen and J. Su, editors, BPM 2010 Workshops, Proceedings of the Sixth Workshop on BusinessProcess Intelligence (BPI2010), volume 66 of Lecture Notes in Business Information Processing, pages 122–133. Springer-Verlag, Berlin, 2011.

[11] A. Adriansyah, J. Munoz-Gama, J. Carmona, B.F. van Dongen, and W.M.P. van der Aalst. Alignment BasedPrecision Checking. In B. Weber, D.R. Ferreira, and B. van Dongen, editors, Workshop on Business ProcessIntelligence (BPI 2012), Tallinn, Estonia, 2012.


[12] A. Adriansyah, N. Sidorova, and B.F. van Dongen. Cost-based Fitness in Conformance Checking. In In-ternational Conference on Application of Concurrency to System Design (ACSD 2011), pages 57–66. IEEEComputer Society, 2011.

[13] R. Agrawal, D. Gunopulos, and F. Leymann. Mining Process Models from Workflow Logs. In Sixth Interna-tional Conference on Extending Database Technology, volume 1377 of Lecture Notes in Computer Science,pages 469–483. Springer-Verlag, Berlin, 1998.

[14] R. Agrawal and J.C. Shafer. Parallel Mining of Association Rules. IEEE Transactions on Knowledge andData Engineering, 8(6):962–969, 1996.

[15] R. Bergenthum, J. Desel, R. Lorenz, and S. Mauser. Process Mining Based on Regions of Languages. InG. Alonso, P. Dadam, and M. Rosemann, editors, International Conference on Business Process Management(BPM 2007), volume 4714 of Lecture Notes in Computer Science, pages 375–383. Springer-Verlag, Berlin,2007.

[16] M.C. Boukala and L. Petrucci. Towards Distributed Verification of Petri Nets properties. In Proceedingsof the International Workshop on Verification and Evaluation of Computer and Communication Systems(VECOS’07), pages 15–26. British Computer Society, 2007.

[17] C. Bratosin, N. Sidorova, and W.M.P. van der Aalst. Distributed Genetic Process Mining. In H. Ishibuchi,editor, IEEE World Congress on Computational Intelligence (WCCI 2010), pages 1951–1958, Barcelona,Spain, July 2010. IEEE.

[18] T. Calders, C. Guenther, M. Pechenizkiy, and A. Rozinat. Using Minimum Description Length for ProcessMining. In ACM Symposium on Applied Computing (SAC 2009), pages 1451–1455. ACM Press, 2009.

[19] M. Cannataro, A. Congiusta, A. Pugliese, D. Talia, and P. Trunfio. Distributed Data Mining on Grids:Services, Tools, and Applications. IEEE Transactions on Systems, Man, and Cybernetics, Part B, 34(6):2451–2465, 2004.

[20] J. Carmona and J. Cortadella. Process Mining Meets Abstract Interpretation. In J.L. Balcazar, editor,ECML/PKDD 210, volume 6321 of Lecture Notes in Artificial Intelligence, pages 184–199. Springer-Verlag,Berlin, 2010.

[21] J. Carmona, J. Cortadella, and M. Kishinevsky. A Region-Based Algorithm for Discovering Petri Nets fromEvent Logs. In Business Process Management (BPM2008), pages 358–373, 2008.

[22] J. Carmona, J. Cortadella, and M. Kishinevsky. Divide-and-Conquer Strategies for Process Mining. InU. Dayal, J. Eder, J. Koehler, and H. Reijers, editors, Business Process Management (BPM 2009), volume5701 of Lecture Notes in Computer Science, pages 327–343. Springer-Verlag, Berlin, 2009.

[23] J.E. Cook and A.L. Wolf. Discovering Models of Software Processes from Event-Based Data. ACM Trans-actions on Software Engineering and Methodology, 7(3):215–249, 1998.

[24] J.E. Cook and A.L. Wolf. Software Process Validation: Quantitatively Measuring the Correspondence of aProcess to a Model. ACM Transactions on Software Engineering and Methodology, 8(2):147–176, 1999.

[25] P. Darondeau. Unbounded Petri Net Synthesis. In J. Desel, W. Reisig, and G. Rozenberg, editors, Lectures onConcurrency and Petri Nets, volume 3098 of Lecture Notes in Computer Science, pages 413–438. Springer-Verlag, Berlin, 2004.

[26] B. van Dongen. BPI Challenge 2012. Dataset. http://dx.doi.org/10.4121/uuid:3926db30-f712-4394-aebc-75976070e91f, 2012.

[27] S. Goedertier, D. Martens, J. Vanthienen, and B. Baesens. Robust Process Discovery with Artificial NegativeEvents. Journal of Machine Learning Research, 10:1305–1340, 2009.


[28] M. Hilbert and P. Lopez. The World’s Technological Capacity to Store, Communicate, and Compute Infor-mation. Science, 332(6025):60–65, 2011.

[29] IEEE Task Force on Process Mining. Process Mining Manifesto. In F. Daniel, K. Barkaoui, and S. Dustdar,editors, Business Process Management Workshops, volume 99 of Lecture Notes in Business InformationProcessing, pages 169–194. Springer-Verlag, Berlin, 2012.

[30] C. Lakos and L. Petrucci. Modular Analysis of Systems Composed of Semiautonomous Subsystems. InApplication of Concurrency to System Design (ACSD2004), pages 185–194. IEEE Computer Society, 2004.

[31] J. Manyika, M. Chui, B. Brown, J. Bughin, R. Dobbs, C. Roxburgh, and A. Byers. Big Data: The NextFrontier for Innovation, Competition, and Productivity. McKinsey Global Institute, 2011.

[32] A.K. Alves de Medeiros, A.J.M.M. Weijters, and W.M.P. van der Aalst. Genetic Process Mining: An Exper-imental Evaluation. Data Mining and Knowledge Discovery, 14(2):245–304, 2007.

[33] J. Munoz-Gama and J. Carmona. A Fresh Look at Precision in Process Conformance. In R. Hull, J. Mendling,and S. Tai, editors, Business Process Management (BPM 2010), volume 6336 of Lecture Notes in ComputerScience, pages 211–226. Springer-Verlag, Berlin, 2010.

[34] J. Munoz-Gama and J. Carmona. Enhancing Precision in Process Conformance: Stability, Confidence andSeverity. In N. Chawla, I. King, and A. Sperduti, editors, IEEE Symposium on Computational Intelligenceand Data Mining (CIDM 2011), pages 184–191, Paris, France, April 2011. IEEE.

[35] A. Rozinat and W.M.P. van der Aalst. Decision Mining in ProM. In S. Dustdar, J.L. Fiadeiro, and A. Sheth,editors, International Conference on Business Process Management (BPM 2006), volume 4102 of LectureNotes in Computer Science, pages 420–425. Springer-Verlag, Berlin, 2006.

[36] A. Rozinat and W.M.P. van der Aalst. Conformance Checking of Processes Based on Monitoring RealBehavior. Information Systems, 33(1):64–95, 2008.

[37] M. Sole and J. Carmona. Process Mining from a Basis of Regions. In J. Lilius and W. Penczek, editors,Applications and Theory of Petri Nets 2010, volume 6128 of Lecture Notes in Computer Science, pages226–245. Springer-Verlag, Berlin, 2010.

[38] J. De Weerdt, M. De Backer, J. Vanthienen, and B. Baesens. A Robust F-measure for Evaluating Discov-ered Process Models. In N. Chawla, I. King, and A. Sperduti, editors, IEEE Symposium on ComputationalIntelligence and Data Mining (CIDM 2011), pages 148–155, Paris, France, April 2011. IEEE.

[39] A. Weijters and J. Ribeiro. Flexible Heuristics Miner (FHM). In N. Chawla, I. King, and A. Sperduti,editors, IEEE Symposium on Computational Intelligence and Data Mining (CIDM 2011), pages 310–317,Paris, France, April 2011. IEEE.

[40] A.J.M.M. Weijters and W.M.P. van der Aalst. Rediscovering Workflow Models from Event-Based Data usingLittle Thumb. Integrated Computer-Aided Engineering, 10(2):151–162, 2003.

[41] A.J.M.M. Weijters, W.M.P. van der Aalst, and A.K. Alves de Medeiros. Process Mining with the HeuristicsMiner-algorithm. BETA Working Paper Series, WP 166, Eindhoven University of Technology, Eindhoven,2006.

[42] J.M.E.M. van der Werf, B.F. van Dongen, C.A.J. Hurkens, and A. Serebrenik. Process Discovery usingInteger Linear Programming. Fundamenta Informaticae, 94:387–412, 2010.

Process Discovery and Conformance Checking Using Passages · 2017-05-02 · Process discovery and...

Documents

Transcript of Process Discovery and Conformance Checking Using Passages · 2017-05-02 · Process discovery and...