We present a folding algorithm to construct a business process model from a specification. The process model is a workflow net, i.e. a Petri net with explicit split- and join-transitions and the specification is a set of example runs. Each example run is a labeled partial order of events, and each event relates to the occurrence of an activity of the underlying business process. In contrast to sequentially ordered runs, a partially ordered run includes information about dependencies and independencies of events. Consequently, such a run is a precise and intuitive specification of an execution of a business process [5, 11]. The folding algorithm is based on the algorithm introduced in [1]. This algorithm constructs a process model which is able to execute all example runs of the specification, but may introduce a significant amount of not specified behavior to the business process model. We show how to improve this folding procedure, by adapting ideas known from the theory of regions, in order to restrict additional and not specified behavior of the process model whenever possible.
Business process management [
It is particularly challenging to build a complex process model from scratch. For
most applications it is easier to first explore single example runs and set up a formal
specification before building a complex model [
Process mining algorithms (see [
We consider a specification to be a set of labeled partial orders. A labeled partial
order is a partially ordered set of events. An event and its label relate to the occurrence
of an activity in the business process. In contrast to a sequence of events, a partial order
can express dependencies and independencies of events. A set of labeled partial orders
is a precise and intuitive specification of a business process [
As an example we consider our coffee brewing process. Figure 1 and Figure 2 depict two labeled partial orders (we omit transitive arcs) specifying two different runs of this process. In Figure 1, we grind beans and switch off the coffee machine. We unlock the machine once it is turned off. We fill the strainer as soon as it is empty. We fetch water from the kitchen using the coffee-pot. This pot is only available after the machine is unlocked. Once the strainer is filled and the water is fetched, we assemble the coffee machine. In Figure 2, we use a glass-pot (instead of the coffee-pot) to fetch water from the kitchen. This activity does not depend on unlocking the coffee machine. We can fetch the water right at the beginning of the process. Figure 1 and Figure 2 depict a complete and intuitive specification of our coffee brewing process.
We present an algorithm to construct a workflow net from a specification. As stated above, a specification is a set of labeled partial orders. A workflow net is a Petri net with explicit split- and join-connectors. and-splits and and-joins duplicate and merge the control flow of a workflow net if actions of the business process occur concurrently. xor-splits and xor-joins act like switches and steer the course of the control flow of a workflow net if activities of the business process are in conflict.
The new algorithm is based on the folding algorithm presented in [
Folding the specification depicted in Figure 1 and Figure 2 results in the workflow net depicted in Figure 3. Both labeled partial orders of the specification are enabled in this net. For simplification, we omit places between transitions.
Folding labeled partial orders is an elegant approach to generating a business process model from a specification. Folding constructs well readable results in very good runtime. Every labeled partial order of the specification is enabled in the generated process model. Unfortunately, folding algorithms tend to introduce additional, not specified behavior to the business process model. Such additional behavior is either a suitable completion of the specification or an inadequate extension yielding an inaccurate business process model. The risk of creating an unfaithful model is due to the fact that the basis for folding is the neighborhood relation introduced by the Hasse-diagrams. Some of the causal structure of the business process may be hidden in the transitive closure of the specified example runs. Transitive dependencies are not considered by the folding algorithm.
Figure 4 illustrates additional behavior enabled in the workflow net depicted in Figure 3. In compliance with the diagram in Figure 1, we grind beans, turn the machine off, and get water using the glass-pot right at the beginning. We also unlock the coffee machine and fetch water using the coffee-pot. This behavior is possible in the workflow net, because the alternative between using the glass- and coffee-pot is not reflected by any neighborhood relation of the diagrams depicted in Figure 1 and Figure 2.
In this paper we present a revised folding algorithm. We fold the Hasse-diagrams of the specification into a workflow net. If the workflow net contains additional and inadequate behavior, the revised folding algorithm proceeds to exclude this behavior by changing the workflow net. Nevertheless, all changes lead to a new model which is still able to perform the specified behavior. To improve the model, we use methods known from the theory of synthesis. Each non-specified run of a workflow net has a maximal, specified (not necessarily unique) prefix. Any event ordered after this specified part should not occur at this point. Such specified prefix together with such an event is called a wrong continuation of the workflow net. To eliminate such a wrong continuation from our workflow net, we modify the Hasse-diagrams of our specification. We add a set of transitive arcs to the Hasse-diagrams, so that folding regarding these updated diagrams leads to a workflow net without the wrong continuation. Note, we only add arcs of the transitive closure of the Hasse-diagrams. Thereby, the initial specified behavior is not changed. A more detailed neighborhood relation yields a more restrictive workflow net. We stop if we can not get a more restrictive workflow net by adding transitive arcs. This solution is not unique. It depends on the unfolding and the selected arcs.
We will present the theory and implementation of this revised folding algorithm and we will show that it constructs well readable models. The main advantage of such a folding procedure is that it provides good control of the behavior of the constructed business process model. In an interactive version of our algorithm, it is even possible to distinguish two sets of wrong continuations. The first set is not specified but valid process behavior and extends the specification, the second set is excluded from the model.
The paper is organized as follows: Section 2 defines workflow nets and labeled partial orders. Section 3 presents a folding algorithm. Section 4 presents our new revised folding algorithm and outlines its implementation. Section 5 concludes the paper. 2
In this paper, a workflow net is a Petri net with additional connector nodes. We consider
a special class of these nets where transitions and places do not branch. This class of
nets has a very intuitive semantics and is built with elements present in almost every
other process modeling language. A workflow net can easily be translated into any
business process modeling language such as place/transition nets [
Definition 1. A workflow net structure is a tuple wn = (T; P; Cxor; Cand; F ) where T is a finite set of transitions, P is a finite set of places, Cxor resp. Cand are finite sets of xor- resp. and-connectors, and F ((T [Cxor [Cand) P )[(P (T [Cxor [Cand)) is a set of directed arcs connecting transitions and connectors to places and vice versa.
(i) There is one place, called initial place, having one outgoing and no incoming arc.
Definition 2. Let w = (T; P; Cxor; Cand; F ) be a workflow net. A marking of w is a function m : P ! N0. A pair (w; m) is called marked workflow net. A place p 2 P is called marked if m(p) > 0, marked by one if m(p) = 1 and unmarked if m(p) = 0 holds. The initial marking m0 of a workflow net is defined as follows: The initial place is marked by one and all other places are unmarked.
There is a simple firing rule for workflow nets. A node is enabled to fire if every place in its preset is marked. An xor-join is also enabled if there is at least one marked place in its preset.
Definition 3. Let wn = (T; P; Cxor; Cand; F; m) be a marked workflow net. A node n 2 fT [ Candg is enabled if every place in n is marked. A node n 2 Cxor is enabled if there is a marked place in n. If a node is enabled, it can fire, changing the marking of the workflow net. Firing n 2 (T [ Cand) leads to the marking m0 defined by: 8 m(p) 1; p 2 m0(p) = < m(p) + 1; p 2 n : m(p) else: n n n n n
pout 2 n . Firing n leads to the marking m0 defined by: n and a place 8 m(p) 1; pin = p 6= pout m0(p) = < m(p) + 1; pout = p 6= pin : m(p) else:
A set of nodes is called a step. In a workflow net there are no conflicts regarding the consumption of tokens. Consequently, a step is enabled if each node of the step is enabled. Firing a step leads to the same marking as firing all nodes.
in m if each n 2 N is enabled in m. If an enabled step N fires and changes m to m0, we write m[N im0. Firing N = fn1; : : : ; nng leads to the same marking as firing all n 2 N , i.e. m[n1im1[n2i : : : [nnim0.
Let = N1 N2 : : : Nn be a sequence of steps. The sequence is enabled in m if there are m1; m2; : : : ; mn, so that m[N1im1[N2i : : : [Nnimn holds. If is enabled, we define T; = (N1 \ T ) (N2 \ T ) : : : (Nn \ T ). We omit all empty sets in T; to define T . We call T the transition step sequence of .
enabled in m if there is an enabled sequence of steps 0 so that = T0 holds.
In Figure 3, the transition step sequence fgrind beans, turn offgfunlockgfempty
strainer, get water using coffee-potgffill strainergfassemble and turn ong is enabled in
the initial marking. We use transition step sequences to define enabled labeled partial
orders [
Definition 5. Let T be a set of labels, a labeled partial order is a triple lpo = (V; <; l), where V is a finite set of events, < is an irreflexive and transitive binary relation over
autoconcurrency, i.e. e; e0 2 V; e 6= e0; e 6< e0; e0 6< e ) l(e) 6= l(e0):
The Hasse-diagram of a labeled partial order is lpo/ = (V; /; l), where / is the set of skeleton arcs, i.e. / = f(v; v0) j v < v0 ^ @v00 : v < v00 < v0g.
Let lpo = (V; <; l) and lpo0 = (V; <0; l) be labeled partial orders. If < <0 holds, lpo0 is a sequentialisation of lpo. If V = V1 [_ : : : [_ Vn and <0= Si<j Vi Vj hold, we call the sequence l(V1) : : : l(Vn) a transition step sequence of lpo.
coffee-potgffill strainergfassemble and turn ong is a transition step sequence of the labeled partial order of Figure 1.
in wn if all transition step sequences of lpo are enabled in the initial marking of wn.
We introduce a folding algorithm to construct a workflow net from a specification which
is a set of labeled partial orders. Each partial order corresponds to a run of the
business process. Events model occurrences of activities, arcs model dependencies between
events, and unordered events can occur concurrently. Our revised folding algorithm is
based on the folding algorithm presented in [
Definition 7. Let lpo = (V; <; l) be a labeled partial order, let (V; /; l) be its Hassediagram, and let T be a set of labels with l(V ) T . Let e 2 V be an event, denote pred(e) = fl(e0)je0 / eg the set of preceding labels, and denote succ(e) = fl(e0)je / e0g the set of succeeding labels.
Let L be a set of labeled partial orders. Let t 2 T be a label, denote predset(t) = fpred(e)j(V; <; l) 2 L; e 2 V; l(e) = tg the set of preceding label sets, and denote succset(t) = fsucc(e)j(V; <; l) 2 L; e 2 V; l(e) = tg the set of succeeding label sets.
To construct a workflow net from a specification, we construct a transition for every label and connect transitions according to the corresponding preceding and succeeding label sets. For every transition we will define a so called building block. The center of each building block is the transition, surrounded by three layers of connectors. Next to the transition is a layer of two xor-connectors, because each transition can have multiple preceding and multiple succeeding label sets. For each of these sets, there is an andconnector on the second layer, because each set can have multiple labels. If succeeding or preceding label sets share labels, there is a xor-connector on the third layer. We define a building block as follows:
each label t 2 T we define a workflow net structure wnt = (ftg; P t; Cxtor; Catnd; F t) called building block of t. The sets P t, Cxtor, and Catnd are defined as follows: Cxtor = fxorptre; xorptostg [ fxorptre;t0 jt0 2 X; X 2 predset(t)g [
fxorptost;t0 jt0 2 X; X 2 succset(t)g, Catnd = fandtpre;X jX 2 predset(t)g [ fandtpost;X jX 2 succset(t)g, P t = fppre; ptpostg [ t t t fppre;X jX 2 predset(t)g [ fppost;X jX 2 succset(t)g [
t t fppre;t0;X jt0 2 X; X 2 predset(t)g [ fppost;X;t0 jt0 2 X; X 2 succset(t)g [ t t fppre;t0 jt0 2 X; X 2 predset(t)g [ fppost;t0 jt0 2 X; X 2 succset(t)g. The set of arcs F t is defined as follows: F t = f(xorptre; ptpre); (ptpre; t); (t; ptpost); (ptpost; xorptost)g [ f(andtpre;X ; ptpre;X )jX 2 predset(t)g [ f(ptpre;X ; xorptre)jX 2 predset(t)g [ f(xorptost; ptpost;X )jX 2 succset(t)g [ f(ptpost;X ; andtpost;X jX 2 succset(t)g [ f(xorptre;t0 ; ptpre;t0;X )jt0 2 X; X 2 predset(t)g [ f(ptpre;t0;X ; andtpre;X )jt0 2 X; X 2 predset(t)g [ f(andpost;X ; ptpost;X;t0 )jt0 2 X; X 2 succset(t)g [
t f(ptpost;X;t0 ; xorptost;t0 )jt0 2 X; X 2 succset(t)g [ f(ptpre;t0 ; xorptre;t0 )jt0 2 X; X 2 predset(t)g [ f(xorptost;t0 ; ptpost;t0 )jt0 2 X; X 2 succset(t)g.
Figure 5 depicts the building block of label unlock. There are two events labeled by unlock in Figure 1 and Figure 2. Both events have the same set of preceding labels, i.e. fturn off g, but have different sets of succeeding labels. According to these sets there is one xor-connector and two and-connectors right behind transition unlock. Since both sets share the label empty strainer, the control flow is joined with xorpuonslto;cekmpty strainer in front of the outgoing interface place ppuonslto;cekmpty strainer.
We call a building block a compressed building block if all superfluous connectors and the corresponding places are removed. A connector is superfluous if it has one ingoing and one outgoing arc. As an example, Figure 6 depicts the set of compressed building blocks of our coffee brewing process. Note that, before building these blocks, an event labeled with start, and an event labeled with stop, are added to every labeled partial order. In this figure, we depict transition start by a big black dot, transition stop by a circle with a dot. We hide most places and only sketch interface places by small dots labeled by the corresponding preceding or succeeding labels. On the top left of Figure 6, we depict the building block of label start. Next to this block, there is the compressed version of the building block depicted in Figure 5. We merge all compressed building blocks depicted in Figure 6 to get the workflow net depicted in Figure 3.
Fig. 6. Compressed building blocks.
Algorithm 1 implements the folding procedure. The input is a set of labeled partial
orders. In Line 2 and Line 3 we add two additional events, one labeled start and one
labeled stop, to every labeled partial order. We extend each partial order so that the start
events are earlier than every other event of their partial order and the stop events are
later than every other event of their partial order. These new events will result in two
additional building blocks responsible for starting and ending runs of the workflow net
model. In Line 4, we reduce the specifications to Hasse-diagrams and collect the set
of labels (including start and stop). In Line 6, according to Definition 8, we build a
building block for every label and in Line 7, we merge all building blocks at matching
t0
interface places, i.e. for every pair of labels we merge all places ptpost;t0 and ppre;t. In
Line 8, we delete superfluous connectors. In addition, we remove the xor-connector in
front of transition start and the xor-connector right behind transition stop. We remove
connectors by merging preset and postset places and we also delete corresponding arcs.
In Line 9, we delete transition start and place psptraert in its preset. Thereby, place psptraert
becomes the initial place of the workflow net and we mark this place by one token. In
Line 11, we remove transition stop and place psptoospt in its preset to get the final result
of the folding procedure. Altogether, Algorithm 1 constructs a workflow net enabled to
execute every labeled partial order of the specification. For the proof we refer the reader
to [
from L using Algorithm 1. Each labeled partial order lpo 2 L is enabled in wn. 4
In this section we will introduce a revised folding algorithm to construct a workflow net from a specification. Folding is very efficient and generates an intuitive workflow net, but for most examples the workflow net is able to execute additional runs. This is reasonable if the specification is incomplete. However, if we assume that the specification is complete, additional behavior should not be included in the business process model. In the following, we detect and deal with additional behavior introduced within the folding procedure.
During the folding procedure, Hasse-diagrams define sets of preceding and succeeding transitions but sometimes, considering only these dependencies is insufficient. In a business process an early decision can easily determine later alternatives.
We consider Figure 1 and Figure 2 as an example. There is only one event labeled get water using coffee-pot. The building block of get water using coffee-pot has one preceding label set, i.e. funlockg. According to Figure 2, the transitions get water using glass-pot, turn off, and unlock can occur. This prefix enables get water using coffee-pot by the occurrence of unlock. This results in the Hasse-diagram depicted in Figure 4.
As stated above, the Hasse-diagrams of the specification define preceding and succeeding label sets to construct building blocks. Considering these sets defined by the transitive relation of the labeled partial orders constructs a workflow net with minimal additional behavior. The occurrence of any transition in this net is conditioned by the occurrence of all transitions corresponding to the complete history of a corresponding event. Obviously, this leads to an unreadable workflow net with a huge number of connectors and arcs.
Our aim is to identify so-called dependency diagrams, a compromise between the Hasse-diagrams and the partial orders, in order to modify the specification thus that additional behavior of a folded model is restricted as far as possible. The fewer dependencies we add, the smaller is the constructed workflow net.
and denote T the set of labels. Let (D; E) be a pair of sets of labels, we denote /[D;E] = / [ f(e; e0)je < e0; l(e) 2 D; l(e0) 2 Eg the dependency relation of < with regard to (D; E). We call (V; /[D;E]; l) the dependency diagram of (V; <; l) with regard to (D; E).
Of course, /[;;;] = / and /[T;T ] =<, i.e. every dependency diagram is some tradeoff between the Hasse-diagram and the labeled partial order.
Our revised folding algorithm starts by constructing a workflow net from a set of Hasse-diagrams. If this workflow net contains additional behavior, an enabled but not specified partial order is generated. We modify the set of Hasse-diagrams to get a set of dependency diagrams so that folding these diagrams leads to a net that does not enable the additional partial order. We repeat this procedure to get a workflow net that has no additional behavior if such a workflow net exists. Let us now take a closer look at every step of the revised folding algorithm.
We construct the initial workflow net using Algorithm 1. We generate the behavior
of this model by an unfolding procedure. We calculate a so-called branching process
[
order (V; <; l) 62 L is called a wrong continuation if there is an event e 2 V so that
We consider Figure 4 as an example. The events grind beans, turn off, unlock, get water using coffee-pot, and get water using glass-pot form a wrong continuation.
In the last step of the revised folding algorithm, we modify the specification to exclude a wrong continuation. The main idea is to extend the preceding and succeeding label sets appropriately, before restarting the folding procedure.
Definition 11. Let L = f(V1; <1; l1); : : : ; (Vn; <n; ln)g be a specification and L/ = f(V1; /1; l1); : : : ; (Vn; /n; ln)g be its set of Hasse-diagrams. Denote T the set of labels. Let (Vw; <w; lw) be a wrong continuation and (Vw; /w; lw) be its Hasse-diagram.
Let (D; E) be a pair of label sets and let l; l0 be two labels. We call l dependent on l0 if for all (V; <; l) 2 L; v 2 V; l(v) = l: l0 2 fl(v0)jv0 /[D;E] vg. We denote M [D;E](l0) the set of all labels that depend on l0.
(D; E) is called disabling pair of (Vw; <w; lw) if one of the following conditions holds: (a) There is an e0 2 Vw so that there is no (Vi; <i; li) 2 L; e 2 Vi; li(e) = lw(e0): fli(v)jv /[iD;E] eg
flw(v)jv <w e0g holds. fli(v)je /[iD;E] vg
flw(v)je0 /[wD;E] vg \ M [D;E](lw(e0)) holds. (b) There is an e0 2 Vw so that there is no (Vi; <i; li) 2 L; e 2 Vi; li(e) = lw(e0):
A disabling pair (D; E) defines a modification of a specification. This modification yields a set of dependency diagrams. Every dependency diagram includes the Hassediagram and extends this diagram by all transitive arcs leading from labels in D to labels in E. We denote the resulting specification by L[D;E]. Theorem 2. Let L be a specification, lpow be a wrong continuation, and (D; E) be a disabling pair of lpow. If we construct a workflow net wn from L[D;E] using Algorithm 1, lpow is not enabled in wn.
Proof. Either (a) or (b) of Definition 11 holds.
If (a) holds, there is an event e0 2 Vw for which no event e 2 Vi, (Vi; <i; li) 2 L, li(e) = lw(e0) exists so that fli(v)jv /[iD;E] eg flw(v)jv <w e0g holds.
Algorithm 1 will build and-connectors related to preceding label sets in the building block of l(e0). For every and-connector there is a choice of e 2 Vi, (Vi; <i; li) 2 L, li(e) = lw(e0) so that the and-connector is related to fli(v)jv /[iD;E] eg. fli(v)jv /[iD;E] eg is not included in flw(v)jv <w e0g. After the occurrence of flw(v)jv <w e0g the and-connector is not enabled. The same holds for every other preceding and-connector of the building block of lw(e0). e0 can not occur after the occurrence of its prefix. lpow is not enabled in wn.
If (b) holds, there is an event e0 2 Vw for which no event e 2 Vi, (Vi; <i; li) 2 L, li(e) = lw(e0) exists so that fli(v)je /[iD;E] vg flw(v)je0 /[wD;E] vg \ M [D;E](lw(e0)) holds.
Algorithm 1 will build and-connectors related to succeeding label sets in the building block of l(e0). For every and-connector there is a choice of e 2 Vi, (Vi; <i; li) 2 L, li(e) = lw(e0) so that the and-connector is related to fli(v)je/[iD;E] vg. flw(v)je0 /[wD;E] vg \ M [D;E](lw(e0)) is not included in fli(v)je /[iD;E] vg. The occurrence of this andconnector will not enable all actions in flw(v)je0 /[wD;E] vg \ M [D;E](lw(e0)), but every such action depends on the occurrence of l(e0). The same holds for every other andconnector of the building block l(e0). When executing lpow in wn there is at least one action missing a token from the building block l(e0). lpow is not enabled in wn.
Both conditions (a) and (b) suppress the executability of a wrong continuation in a workflow net representing the dependencies introduced from the disabling pair. As an example, we consider the wrong continuation depicted in Figure 4. A disabling pair of label sets is (fstartg; fget water using coffee-potg). In the Hasse-diagram depicted in Figure 1, the succeeding label set B1 of start according to this disabling pair is fgrind beans, turn off, get water using coffee-potg. In other words, get water using coffee-pot is added to the original succeeding label set. The succeeding label set B2 of start of Figure 2 stays unchanged. In Figure 4 the succeeding label set W of start according to the disabling pair is fgrind beans, turn off, get water using glass-pot, get water using coffee-potg. This set W is not covered by B1 or B2 so that condition (b) of Definition 11 holds. The wrong continuation is not enabled if the additional dependency between start and get water using coffee-pot is considered when constructing corresponding building blocks. Altogether, if we add one transitive arc to the Hasse-diagram depicted in Figure 1 (from start to get water using coffee-pot) and apply Algorithm 1, we construct a workflow net which is not able to execute the Hasse-diagram depicted in Figure 4. In this example, the resulting workflow net (depicted in Figure 7) behaves exactly as specified.
Algorithm 2 implements the revised folding procedure. The input is a set of labeled partial orders. In Line 3 and Line 4, we invoke Algorithm 1. While the result of Algorithm 1 has additional behavior, we calculate a wrong continuation in Line 6. We construct a disabling pair (if such a pair exists) or add the wrong continuation to a set W . W contains all wrong continuations which cannot be excluded from a workflow net including the specified behavior. In Line 8, we update the set of Hasse-diagrams by constructing a set of dependency diagrams. We fold again to get a new workflow net still including the specified behavior (and W ), but excluding the wrong continuations (Line 9). Just like Algorithm 1, Algorithm 2 constructs a workflow net able to execute every labeled partial order of the specification. Furthermore, Algorithm 2 excludes not specified behavior whenever possible.
The runtime of the new algorithm consists of three parts. It is the sum of the runtime of the folding procedures, the runtime of the unfolding procedures (to check for wrong continuations), and the runtime of the calculations of disabling pairs. Every folding procedure is fast. For every event we compute the preceding and succeeding labels and build the corresponding connectors in the workflow net. The worst case complexity of the unfolding procedure is in exponential time. However, the average runtime, where a workflow net has a reasonable level of concurrent activities, is still fast and is determined by the number of xor-split connectors. The most time consuming part is to find a disabling pair. Altogether, the presented algorithm can be slow, especially if the workflow net has a lot of wrong behavior and describes a lot of concurrency. But in this case, it is possible to stop the algorithm after each iteration and still have a reasonable result.
The presented revised folding approach is implemented and available in our tool
called MoPeBs Cheetah. MoPeBs Cheetah is a lightweight editor showcasing the
revised folding algorithm plug-in of our tool set VipTool [
We recapitulated a folding algorithm to generate a workflow net from a specification. The specification is a set of labeled partial orders. The presented algorithm generates an intuitive model by representing the direct dependencies included in the specification. The generated workflow net is able to execute all specified runs. Moreover, this algorithm usually rounds off the specification, i.e. additional runs which are similar to the specified labeled partial orders are executable in the generated workflow net as well. This is reasonable in cases where the specification is considered to be incomplete.
Reusing the folding algorithm, we introduced a revised folding approach. Starting with an initial model, this iterative approach is able to discover transitive dependencies in the specification which yield a more precise process model. The size of the generated model heavily depends on the number of wrong continuations but for most examples, the generated results are readable as well. The generated workflow net can easily be translated into an EPC, BMPN-model, YAWL-model or an Activity Diagram. These are often used for practical applications. Using an interactive version of the revised folding approach, it is easy to validate the specification while generating a process model. We can add reasonable wrong continuations to the specification while excluding unwanted behavior. All in all, in contrast to other process mining algorithms, the revised folding approach provides perfect control over the language of the generated business process model.