#
Full Support for Efficiently Mining Multi-Perspective Declarative Constraints from Process Logs^{ †}

^{*}

^{†}

## Abstract

**:**

## 1. Introduction

- (i)
- We introduce algorithms and descriptions for the full set of commonly accepted types of MP-Declare constraints.
- (ii)
- The conceptual architecture of the implementation has been reworked such that new types of constraints can be easily defined and extracted by the user.
- (iii)
- We provide a more detailed description of the conceptual approach as well as the implemented protoype.
- (iv)
- Related work is discussed more thoroughly.

## 2. Related Work

## 3. Preliminaries

#### 3.1. Multi-Perspective, Declarative Process Modelling

- Activation conditions: When a loan is requested and account balance > 4000 EUR, the loan must subsequently be granted.
- Correlation conditions: When a loan is requested, the loan must subsequently be granted and amount requested = amount granted.
- Target conditions: When a loan is requested, the loan must subsequently be granted by a specific member of the financial board.
- Temporal conditions: When a loan is requested, the loan must subsequently be granted within the next 30 days.

#### 3.2. Metrics for Mining MP-Declare Models

#### 3.3. MapReduce

#### 3.3.1. Origin

#### 3.3.2. Implementations

**MapReduce.**Referring to Google’s original paper [42] or Hadoop [43], the open source de-facto standard implementation in Java, MapReduce, implies two functions, namely Map (a parallel transformation) and Reduce (a parallel aggregation). For the sake of performance with large datasets, these implementations include an intermediate shuffle or group phase.**Map and Reduce in Functional Programming.**Functional Programming languages or frameworks, such as Haskell, Java (includes functional concepts since Version 1.8) or Spark, also use the terms map and reduce, but are different from the MapReduce concepts mentioned above. For instance, in functional programming, users specify the semantic logic in a declarative way rather than the control flow [44].

#### 3.3.3. Functionality

**(Process, 1)**). The reduce-function obtains then key–value pairs, whose values are aggregated to identical keys (during the shuffling or grouping phase), e.g., each value

**1**of the three key–value pairs

**(Process, 1)**are aggregated to

**(Process, [1, 1, 1])**in the example below. The Reducer finally processes the list of values, for instance sums up the elements, e.g.,

**(Process, 3)**.

**Input:**Declarative Process Mining discovers Declarative Process Models, used in Business Process Management.

**Mapping:**

**Shuffling:**

**Reducing:**

## 4. Map-Reduce for Declarative Process Mining

#### 4.1. Architecture and Infrastructure

#### 4.1.1. MR-I

**map**-phase of MR-I, key–value pairs are created from the locally provided event data, i.e., a single trace of a log file. Each of the key–value pairs is assigned to a number for further processing. In the case of process discovery, this number is always 1. The challenge is to generate these key–value pairs in order to address the logic for the MP-Declare constraints.

**Example**

**1.**

**reduce**-phase finally obtains the key–value pairs that have been produced. The reduce-function must be declared by the user once again. In the case of constraint checking, this phase depicts a summation of values. To continue the example above, the result of the reducer with trace ${t}_{0}$ is: $((a,b),1),((a,c),1),((b,b),1),((b,c),2)$.

#### $\sigma $-Function

#### $\eta $-Function

#### $\u03f5$-Function

#### 4.1.2. MR-II

#### 4.2. Mapping MP-Declare Templates to MapReduce

#### 4.2.1. Existence Constraints

**future constraining**constraints and describe the presence or absence and in some parts the position of a single event. They consider the number of occurrences of a single event in the trace. This amount is then for example compared to a fixed value n while the constraint is fulfilled if the comparison is true. For existence constraints, no nested loops are necessary and solely the outer loop referring to the loop control variable i is used. Since existence constraints consider exclusively one variable, only

**activation**constraints are meaningful. Therefore, the single event holds the additional condition. The

**trace-based**support and confidence equations (Equations (4) and (6)) are adapted for multi-perspective existence constraints as follows.

- Existence
**Description.**The**future constraining**constraint existence$(n,e)$ indicates that event e must occur at least n-times in the trace. The variable n takes an integer between 1 and the amount of occurrences of the event e in the trace, while e activates the constraint.**Mining**Trace-basedBeginning with the first trace, the constraint is fulfilled for each event e and variable n if the amount of occurrences of e in the trace is equal or greater than the value of n. By iterating through the trace, the fulfilled constraints are contemporaneously computed with the amount of occurrences of the respective event. As explained above, only**activation**constraints are take into account. The initial assignment of i is 0, while j is not considered, because of computing a trace-based constraint. Thus, the event $ax$ is considered first and the amount of occurrences of $ax$ is increased from 0 to 1 (cf. Table 5). The variable n takes the value of the up to this point computed amount of occurrences of the respective event in the trace. Thus, existence$(1,ax)$ is investigated in this first case and ${\sigma}_{E}(1,ax)$ is incremented by 1. In the case of $i=5$, the amount of occurrences of event $by$ in the trace is increased from 1 to 2 and therefore existence$(2,by)$ is fulfilled. - Participation
**Description.**The**future constraining**constraint participation$(e)$ indicates that event e occurs at least once in the trace. This constraint is equivalent to existence$(1,e)$.**Mining**Trace-basedFor each event that occurs in the considered trace, the respective constraint is fulfilled. All traces that fulfil the constraint relating to a certain e are counted to receive the number of fulfillments in the whole log. That value is computed just as the corresponding value of $\u03f5$.Because this constraint is classified as trace-based, only**activation**constraints are considered and there is no nested loop necessary. Similar to the existence constraint, i is initialised with 0 and the computation starts with $ax$. The constraint participation is fulfilled for each event that occurs in the trace, while each event is regarded by the iteration variable i. In the step with $i=5$ and $i=6$, the $\sigma $-value must not be modified, as the constraint participation$(1,by)$ and $(1,ax)$ were already activated and fulfilled with ${}_{2}{e}^{A}$ and ${}_{0}{e}^{A}$ and is stored only once per trace (cf. Table 6). - Absence
**Description.**The**future constraining**constraint absence$(n+1,e)$ indicates that event e may occur at most $n-times$ in the trace. The variable n takes an integer between 2 and the size of the respective trace, while event e activates the constraint.**Mining**Trace-basedIn the first step, the amount of occurrences of each event in a trace is counted by iterating the trace with variable i. Since the absence constraint is limited by this amount, it has to be checked after counting the occurrences of all events. In a second step, two additional nested loops are added. The outer loop considers variable n reaching from 2 to the size of longest trace in the event log. The inner loop iterates all events in the trace and in each cycle, their amount of occurrences which were counted in the first step are compared to the recent value of n. Let $ae$ be the variable for the inner loop that refers to the set of events in the trace, containing each event once in the order predetermined by the control variable i. The constraint is fulfilled for a certain event, if n is greater than the amount of occurrences of the respective event. If the constraint is fulfilled, it is implicitly fulfilled for all values bigger than n.For this constraint, only**activation**constraints are considered and so the event holds the additional condition. The initial assignment of $(n,ae)$ is $(2,0)$, hence absence$(2,ax)$ is investigated in the first case. The constraint is not fulfilled, since $ax$ occurs 2 times in the trace. In the next step, the $\sigma $-value needs to be incremented by 1, as the constraint absence$(2,cz)$ is fulfilled. This constraint is also fulfilled for values of n greater than 2, represented by $2$.. in Table 7. - Uniqueness
**Description.**The**future constraining**constraint uniqueness$(e)$ indicates that event e occurs at most once in the trace. This constraint is equivalent to absence(2,e).**Mining**Trace-basedThe computation for the uniqueness constraint is equal to the computation of the participation constraint. The only difference is the value of n. In the uniqueness constraint, n is fixed to the value 2 and thus the constraint is fulfilled for a certain event, if it does not occur in the trace or occurs only once in the trace. As described in the above section, we consider vacuously defined constraints. For this reason, uniqueness constraint is not fulfilled if the event does not occur in the trace.Since n is fixed, the additional nested loops are not necessary. As the uniqueness constraint is trace-based, only**activation**constraints are taken into account. In the case of ${1}_{U}$ and ${2}_{U}$ in Table 8, the referring constraints uniqueness$(ax)$ and uniqueness$(by)$ are violated because the events $ax$ and $by$ occur 2 times in the trace. - Init
**Description.**The**future constraining**constraint init$(e)$ indicates that event e is the first event that occurs in the trace.**Mining**Trace-basedFor each trace, only the**first**event per trace is taken into account. Each of these events fulfil the constraint. Only the initial assignment of $i=0$, ${e}_{0}^{A}$ and**activation**constraints are considered. The event $ax$ is the first event in the trace and fulfils the constraint, while the fulfillment check for all over events in the trace ${e}_{1}^{A}$ to ${e}_{6}^{A}$ is skipped (cf. Table 9). - End
**Description.**The**future constraining**constraint end$(e)$ indicates that event e is the last event that occurs in the trace.**Mining**Trace-basedFor each trace, only the**last**event per trace is taken into account. Each of these events fulfil the constraint. Only the last assignment of i, which means ${e}_{6}^{A}$, and**activation**constraints are considered. The event $ax$ is the last event in the trace and fulfils the constraint, while the fulfillment check for all over events in the trace ${e}_{0}^{A}$ to ${e}_{5}^{A}$ is skipped (cf. Table 10).

#### 4.2.2. Relation Constraints

**future constraining**and

**history-based**constraints and focus on the relation of two events. In general, they consider the common occurrence of two events a, b in the trace.

**future constraining**relation constraints, event a activates the constraint and the later appearing event b fulfils the constraint. The

**event-based**support and confidence equations (Equations (4) and (6)) are adapted for multi-perspective

**future constraining**relation constraints as follows. The support and confidence for future constraining

**activation**constraints $(FA)$ is stated as ${S}_{FA\_RC}$ and ${C}_{FA\_RC}$, while a, executed by x and b, executed by y, are used as place holders for two arbitrary events with the restriction that b occurs after a in the trace. The value of ${\sigma}_{FA\_RC}$ describes the number of fulfillments of the respective future constraining activation relation constraint.

**target**template $(FT)$ is stated as ${S}_{FT\_RC}$ and ${C}_{FT\_RC}$. The value of ${\sigma}_{FT\_RC}$ describes the number of fulfillments of the respective future constraining target relation constraint.

**history-based**relation constraints, where b activates the constraint and the former appearing event a fulfils the constraint. Equations (5) and (7) are adapted for history-based

**activation**constraints $(BA)$ to ${S}_{BA\_RC}$ and ${C}_{BA\_RC}$. The value of ${\sigma}_{BA\_RC}$ describes the number of fulfillments of the respective history-based activation relation constraint.

**target**relation constraints $(BT)$ is stated as ${S}_{BT\_RC}$ and ${C}_{BT\_RC}$. The value of ${\sigma}_{BT\_RC}$ describes the number of fulfillments of the respective history-based target relation constraint.

- Responded Existence
**Description.**The**future constraining**and**history-based**constraint respondedExistence$(a,b)$ indicates that, if event a occurs in the trace, then event b occurs in the trace as well. Event a activates the constraint.**Mining**Event-basedThe whole trace has to be considered to take all events into account that occur before or after the event that corresponds to the current value of the outer loop variable i. Therefore, the control variable of the inner loop j starts with 0 for each value of i. All pairs with $i\ne j$ fulfil the constraint while this pair occurs the first time for the activating event in the trace.The loop variables $(i,j)$ are initialised with $(0,0)$, thus the event $ax$ would be associated with itself. Such associations are not meaningful and since i and j have the same values, the fulfillment check is skipped. The next value for $(i,j)$ is $(0,1)$ and therefore the events $ax$ and $cz$ are considered. For**activation**constraints, the activating event holds the additional condition solely; hence, respondedExistence$(ax,c)$ is investigated in this case. This constraint, activated with ${}_{0}{e}^{A}(ax)$ is fulfilled with ${e}_{1}^{T}(c)$ and thus ${\sigma}_{RE}(ax,c)$ is incremented by 1. In addition, for $({}_{0}{e}^{A},{e}_{2}^{T})$, the value for ${\sigma}_{RE}(ax,b)$ is incremented. In the next step, i.e., $({}_{0}{e}^{A},{e}_{3}^{T})$, the ${\sigma}_{RE}(ax,b)$ must not be modified, as the constraint respondedExistence$(ax,b)$ activated with the event ${}_{0}{e}^{A}$ was already fulfilled with ${e}_{2}^{T}$ (cf. ${1}_{RE}$ in Table 11a). Cases ${2}_{RE}$–${16}_{RE}$ are similar.For**target**constraints such as respondedExistence$(a,cz)$, the additional condition appears on the right-hand side. That means, the events in the outer loops have to match the target template: ${}_{i}{e}^{T}$. Referring to Table 11b, in Case ${17}_{RE}$, ${\sigma}_{RE}(a,by)$, respectively, must not be increased, as the constraint is also already fulfilled (with ${e}_{2}^{A}(by)$). Cases ${18}_{RE}$–${26}_{RE}$ are similar. - Response
**Description.**The**future constraining**constraint response$(a,b)$ indicates that, if event a occurs in the trace, then event b occurs after a. Event a activates the constraint.**Mining**Event-basedSince the response constraint considers only events that occur after the activating event in a trace, the control variable of the inner loop j depends on the value of the outer loop variable i. Variable j starts with the value $i+1$. All event pairs referring to $(i,j)$ fulfil the constraint while this pair occurs the first time for the activating event in the trace.The initial assignment of $(i,j)$ is $(0,1)$. Since the assignment $(0,0)$ for the loop variables is never considered, the first column and last row that refer to the value $ax$ are omitted in Table 12a. The events $ax$ and $cz$ are taken into account in the first step. If the**activation**conditions are considered, the first constraint is response$(ax,c)$. The constraint is activated with ${}_{0}{e}^{A}(ax)$ and fulfilled with ${e}_{1}^{T}(c)$. This leads to an incrementation of ${\sigma}_{R}(ax,c)$ by 1. In the case of $({}_{0}{e}^{A},{e}_{3}^{T})$, the ${\sigma}_{R}(ax,b)$ must not be modified, as the constraint response$(ax,b)$ activated with the event ${}_{0}{e}^{A}$ was already fulfilled with ${e}_{2}^{T}$. Cases ${2}_{R}$–${5}_{R}$ in Table 12a are similar.In terms of target conditions such as response$(a,by)$, where the event on the right-hand side holds the additional condition, the value of ${\sigma}_{R}(a,by)$ must not be increased in the case of ${6}_{R}$. The constraint is already fulfilled with ${e}_{2}^{A}(by)$. The same also applies to ${7}_{R}$ (cf. Table 12b). - Alternate Response
**Description.**The**future constraining**constraint alternateResponse$(a,b)$ indicates that each time event a occurs in the trace, then event b occurs afterwards, before event a recurs. Event a activates the constraint.**Mining**Event-basedFor this template, the loop variables i and j take the same values as explained for the response constraint. As additional restriction, the constraint alternate response is not fulfilled, if the set of events that occur between the events referring to i and j contains the event that correspond to i. In this case, the iteration is cancelled, i is incremented and the trace is taken into account with the new values.The alternateResponse template shares the pivot constellations for $(i,j)$ for already fulfilled constraints similar to the response template (cf. ${1}_{AR}$–${5}_{AR}$ in Table 13a). Similar to the response template, the initial assignment of $(i,j)$ is $(0,1)$. As instance of an**activation**constraint, the alternate response$(ax,b)$ in iteration $i=0$ from Table 13a is considered. In this case, the constraint is activated by ${}_{0}{e}^{A}(ax)$ and fulfilled with the event ${e}_{2}^{T}(b)$. Additional events b in the same iteration must be ignored (e.g., ${e}_{3}^{T}$).Besides the already-fulfilled-errors, another class of error type is introduced, which was already meant in a similar way in the uniqueness constraint: violations. Consider ${6}_{AR}$ in Table 13a. In this case, the constraint alternate response$(by,a)$ is checked. Although this constellation has not occurred thus far for this activation, the value ${\sigma}_{AR}(by,a)$ must not be modified, because it is violated by ${e}_{5}^{A}(by)$: The activating event $(by)$ recurs before a occurs. This is forbidden within the alternateResponse template. Note that the resource is also decisive, thus alternateResponse$(by,d)$, activated with ${}_{2}{e}^{A}$ is fulfilled with ${e}_{4}^{T}$, although the event b recurs. However, this is executed by x instead of y and so the constraint is not violated (marked with an asterisk in Table 13a).The analysis of the**target**constraints (cf. Table 13b) shows the following anomalies: ${7}_{AR}$ and ${8}_{AR}$ are excluded because of the already-fulfilled-case and cases ${9}_{AR}$–${12}_{AR}$ are excluded because of violations. For instance, ${9}_{AR}$–${11}_{AR}$ are activated with the event ${}_{2}{e}^{A}(b)$ and as the first event in the inner loop is also b (represented with the activation template, i.e., the activity solely $({e}_{2}^{A})$), all constraints with succeeding events in the inner loop are violated. - Chain Response
**Description.**The**future constraining**constraint chainResponse$(a,b)$ indicates that, each time event a occurs in the trace, event b occurs immediately afterwards. Event a activates the constraint.**Mining**Event-basedFor each event referring to i in a trace, only the successive event referring to $i+1$ is considered. Therefore, the inner loop is skipped and j holds a fixed value depending on i.The initial assignment of $(i,j)$ is $(0,1)$, thus the events $ax$ and $cz$ are considered. The corresponding**activation**constraint is chainResponse$(ax,c)$ and the value of ${\sigma}_{CR}({}_{i}{e}^{A},{}_{i+1}{e}^{T})$ is incremented by 1. The**target**constraint for these values of i and j is chainResponse$(a,cz)$. In the next step with $(i,j)=(1,2)$, the activation constraint chainResponse$(cz,b)$ and target constraint chainResponse$(c,by)$ is considered (cf. Table 14). - Precedence
**Description.**The**history-based**constraint precedence$(a,b)$ indicates that event b occurs only in the trace, if preceded by a. Event b activates the constraint.**Mining**Event-basedIntuitively, one would iterate starting from the latest event for the history-based constraints, e.g., the first $(i,j)$-tuple would be $(5,6)$ going on with $(4,6)$, i.e., the constraints precedence$({e}_{5}^{T},{}_{6}{e}^{A})$ and precedence$({e}_{4}^{T},{}_{6}{e}^{A})$, respectively.In the case of**activation**constraints, the former describes that, whenever a occurs and was executed by x, b has to precede. Referring to the latter, precedence$(d,ax)$ describes that if event a occurs in a trace and was executed by x, then event d has to precede.For the sake of performance boost, we propose an algorithm, which handle the history-based constraints also by iterating through the events in a forward direction. To do so, the events of the outer loop $(i)$ fills the role of the target events and the events of the inner loop $(j)$ are now the activating events.Consider Table 15a and the assignment of $(i,j)$ with $(0,1)$. The first constraint under investigation is precedence$(a,cz)$, activated with ${e}_{1}^{A}(cz)$ and fulfilled with ${}_{0}{e}^{T}(a)$. In the next step, precedence$(a,by)$ is considered. It is activated with ${e}_{2}^{A}(by)$ and fulfilled with the same outer loop event ${}_{0}{e}^{T}(a)$.Interesting is the outer loop event ${}_{2}{e}^{T}(b)$ (cf. third row in Table 15a). In the case of ${e}_{4}^{A}(dz)$, the value for ${\sigma}_{P}(b,dz)$ must not be modified $({1}_{P})$. The reason is that this constraint, activated with $dz$ is fulfilled with the outer loop event ${}_{4}{e}^{T}$ and thus, fulfilled in a future step (marked with an asterisk in Table 15a). Hence, the iteration of the inner loop is cancelled, if the event referring to the recent value of i in the outer loop is equal to the event referring to the recent value of j in the inner loop.The**target**constraints show similar behaviour. Whenever the event ${}_{i}{e}^{T}$ occurs also in the inner loop in ${e}_{j}^{T}$, then the rest of the inner loop is neglected because the events are fulfilled afterwards. For example, precedence$(by,a)({5}_{P})$ is fulfilled in the future in the asterisk-marked cell in Table 15b. Notice that, for precedence$(by,d)$ (third row in Table 15b), the value ${\sigma}_{P}(by,d)$ is incremented by 1, since the additional condition has to be considered and the preceding event b is executed by x instead of y. - Alternate Precedence
**Description.**The**history-based**constraint alternatePrecedence$(a,b)$ indicates that, each time event b occurs in the trace, it is preceded by event a and no other event b can recur in between. Event b activates the constraint.**Mining**Event-basedFor this template, the loop variables i and j take the same values as explained for the precedence constraint. As additional restriction, the constraint alternate precedence is not fulfilled, if the set of events that occur between the events referring to i and j contain the event that correspond to j. In this case, the iteration is cancelled, i is incremented and the trace is taken into account with the new values.As example for an**activation**constraint, consider alternatePrecedence$(a,by)$ in Table 16a. The marker ${1}_{AP}$ indicates a violation of this constraint because of the reoccurrence of the activating event ${e}_{2}^{A}(by)$. Case ${2}_{AP}$ is similar.In the case of ${3}_{AP}$, according to the constraint alternatePrecedence$(b,dz)$, ${\sigma}_{AP}(b,dz)$ must not be incremented there, because this constraint activated with ${e}_{4}^{A}(dz)$ is fulfilled with the event ${}_{3}{e}^{T}$ in the next run of the outer loop (note the asterisk in Table 16a). Cases ${4}_{AP}$–${6}_{AP}$ are similar.Table 16b shows the already-fulfilled-cases and violations of the exemplary trace in the case of target constraints. The constraints at ${7}_{AP}$–${11}_{AP}$ are violated, because of the reoccurrence of the events ${e}_{3}^{A}(b)$ and ${e}_{5}^{A}(b)$ in the events ${e}_{2}^{A}$ and ${e}_{3}^{A}$. - Chain Precedence
**Description.**The**history-based**constraint chainPrecedence$(a,b)$ indicates that, each time event b occurs in the trace, event a occurs immediately beforehand. Event b activates the constraint.**Mining**Event-basedSince the precedence and all precedence-subsumed constraints are computed in a forward direction in our work, the inner loop is skipped similar to the chainResponse template and j holds a fixed value depending on i. For each event referring to $j=i+1$ in a trace, only its preceding event referring to i is considered.The initial assignment of $(i,j)$ is $(0,1)$, thus the events $ax$ and $cz$ are considered. The corresponding**activation**constraint is chainPrecedence$(a,cz)$ and the value of ${\sigma}_{CP}({}_{i}{e}^{T},{}_{i+1}{e}^{A})$ is incremented by 1. The**target**constraint for these values of i and j is chainPrecedence$(ax,c)$. In the next step with $(i,j)=(1,2)$, the activation constraint chainPrecedence$(c,by)$ and target constraint chainPrecedence$(cz,b)$ is considered (cf. Table 17).

#### 4.2.3. Mutual Relation Constraints

**future constraining**and

**history-based**constraints. They are especially useful to rate relation constraints. If the computed support of a mutual relation constraint is lower than both of the involved relation constraints, the respective relation constraints are irrelevant. To calculate the

**event-based**support and confidence equations, it is further distinguished between

**activation**and

**target**constraints.

**activation**mutual relation constraints $(A)$, Equations (11), (12), (15) and (16) are merged to ${S}_{A\_MRC}$ and ${C}_{A\_MRC}$. Events a and b are place holders for two arbitrary events with the restriction that they are executed by the same additional condition x. The value of ${\sigma}_{A\_MRC}$ describes the number of fulfillments of the respective mutual relation constraint in case of activation constraints. The value of $\u03f5(ax,bx)$ in the confidence equation corresponds to the number of traces, where the events $ax$ and $bx$ occur together.

**target**mutual relation constraints $(T)$ from a multi-perspective view are stated as ${S}_{T\_MRC}$ and ${C}_{T\_MRC}$ and are based on Equations (13), (14), (17) and (18). The number of fulfillments of the target mutual relation constraint is stored in ${\sigma}_{T\_MRC}$.

- CoExistence
**Description.**The**future constraining**and**history-based**constraint coExistence$(a,b)$ indicates that, if event b occurs in the trace, then event a occurs and vice versa. Event a and event b activate the constraint.**Mining**Event-basedThe coExistence constraint is composed of two respondedExistence constraints. The second respondedExistence constraint considers the events of the first respondedExistence constraint in reversed order.The fulfillment of the two respondedExistence constraints is computed as described in the corresponding item above. The whole trace is considered and the loop variables $(i,j)$ are initialised with $(0,0)$, while events that are associated with themselves are not considered. For example, take the event pair $(ax,by)$ corresponding to $(i,j)=(0,2)$ into account. For**activation**constraints, e.g. coExistence$(ax,b)$, the constraints respondedExistence$(ax,b)$ and respondedExistence$(bx,a)$ are investigated in this case. The events are switched while the additional condition stays on the left-hand side.The first respondedExistence constraint, activated with ${}_{0}{e}^{A}(ax)$, is fulfilled with ${e}_{2}^{T}(b)$ and thus ${\sigma}_{RE}(ax,b)$ is incremented by 1. The second respondedExistence is activated with ${}_{3}{e}^{A}(bx)$ and fulfilled with ${e}_{0}^{T}(a)$ leading to an incrementation of ${\sigma}_{RE}(bx,a)$ by 1. After iterating through the whole trace, the value of ${\sigma}_{RE}(ax,b)$ is 2 and the value of ${\sigma}_{RE}(bx,a)$ stays to 1. These values are summed up and ${\sigma}_{CO}(ax,b)$ is increased by 3. The same value is applied to ${\sigma}_{CO}(bx,a)$. Table 18 is similar to Table 11a but marks the corresponding sigmas, which are summed up with same indices. The notation of the already-fulfilled-constraints (e.g., ${1}_{RE}$) is taken over from Table 11a.For**target**constraints, e.g. coExistence$(a,bx)$, the constraints respondedExistence$(a,bx)$ and respondedExistence$(b,ax)$ have to be considered. Referring to Table 19, the final value of ${\sigma}_{CO}(ax,b)$ is 5. All fullfilments of this constraint are denoted as ${\u2713}_{23}$ in the table. - Succession
**Description.**The**future constraining**and**history-based**constraint succession$(a,b)$ indicates that event a occurs in the trace, if and only if it is followed by event b. Event a and event b activate the constraint.**Mining**Event-basedThe succession constraint is composed of the response and the precedence constraint. The fulfillment of these two constraints is computed as described in the corresponding item above. The constraints are computed successively.The initial assignment of $(i,j)$ is $(0,1)$. The events $ax$ and $cz$ are taken into account in the first step. If the**activation**conditions are considered, the constraints response$(ax,c)$ and precedence$(a,cz)$ would be investigated in the first step.To give an example how the Succession constraint is computed, consider $(i,j)$ = $(0,2)$ for the response constraint and $(i,j)$ = $(0,3)$ for the precedence constraint. According to Table 12a, the response constraint is activated with ${}_{0}{e}^{A}(ax)$ and fulfilled with ${e}_{2}^{T}(b)$. This leads to an incrementation of ${\sigma}_{R}(ax,b)$ by 1. The precedence constraint is activated with ${e}_{3}^{A}(bx)$ and fulfilled with ${}_{0}{e}^{T}(a)$, leading to an incrementation of ${\sigma}_{P}(a,bx)$ by 1 (cf. Table 15a). After iterating through the trace and calculating all fulfilled constraints, the values of ${\sigma}_{R}(ax,b)$ and ${\sigma}_{P}(a,bx)$ are summed up. Therefore, the number of fulfillments of the corresponding constraint succession$(ax,b)$ is calculated, expressed by an incrementation of ${\sigma}_{S}(ax,b)$ by 2. Another example is provided by $(i,j)$ = $(1,4)$, where the response and precedence constraints are activated with the same additional condition z. In this case, ${\sigma}_{R}(cz,d)$ and ${\sigma}_{P}(c,dz)$ are incremented by 1. These both values are used to compute the number of fulfillments of constraint succession$(cz,d)$ through incrementing ${\sigma}_{S}(cz,d)$ by 2.If the**target**conditions are considered, the constraints response$(a,cz)$ and precedence$(ax,c)$ are investigated in the first step (cf. Table 12b and Table 15b). In the case $(i,j)$ = $(1,3)$, the constraints response$(a,bx)$ and precedence$(ax,b)$ are fulfilled with the same additional condition x and the values of ${\sigma}_{R}(a,bx)$ and ${\sigma}_{P}(ax,b)$ are incremented by 1. The sum of these values leads to the number of fulfillments of the target constraint succession$(a,bx)$ by incrementing ${\sigma}_{S}(a,bx)$ by 2. - AlternateSuccession
**Description.**The**future constraining**and**history-based**constraint alternateSuccession$(a,b)$ indicates that event a and event b occur in the trace, if and only if the latter follows the former, and they alternate each other in the trace. Event a and event b activate the constraint.**Mining**Event-basedThe alternateSuccession constraint is composed of the alternateResponse and the alternatePrecedence constraint. The fulfillment of these two constraints is computed as described in the corresponding item above. The constraints are computed successively.The initial assignment of $(i,j)$ is $(0,1)$. The events $ax$ and $cz$ are taken into account in the first step.As example for an**activation**constraint, consider alternateSuccession$(by,b)$. The respective constraints alternateResponse$(by,b)$ and alternatePrecedence$(b,by)$ have to be computed. As presented in Table 13a, the alternateResponse constraint is activated with ${}_{2}{e}^{A}(by)$ and fulfilled with ${e}_{3}^{T}(b)$. Therefore, the value of ${\sigma}_{AR}(by,b)$ is incremented by 1. The alternatePrecedence constraint is activated with ${e}_{5}^{A}(by)$ and fulfilled with ${}_{3}{e}^{T}(b)$, leading to an incrementation of ${\sigma}_{AP}(b,by)$ by 1 (cf. Table 16a). For both constraints, the value of $\sigma $ is not incremented in the case of $(i,j)=(2,5)$ because the constraints are already fulfilled in the past for the alternateResponse constraint or will be fulfilled in the future for the alternatePrecedence constraint. Hence, the number of fulfillments of the composed constraint alternateSuccession$(by,b)$ is 2.For**target**constraints such as alternateSuccession$(a,cz)$, the number of fulfillments of the constraints alternateResponse$(a,cz)$ and alternatePrecedence$(az,c)$ are computed and summed up. Since event a never occurs with the additional condition z, the value of ${\sigma}_{AP}(az,c)$ is never incremented. This leads to the final value of ${\sigma}_{AS}=1$. - ChainSuccession
**Description.**The**future constraining**and**history-based**constraint chainSuccession$(a,b)$ indicates that event a and event b occur in the trace, if and only if the latter immediately follows the former. Event a and event b activate the constraint.**Mining**Event-basedFor the chainSuccession constraint, the computation of the constraints chainResponse and chainPrecedence are necessary. The fulfillment of these two constraints is computed like described in the corresponding item above. The constraints are computed successively.The initial assignment of $(i,j)$ is $(0,1)$, while the inner loop is skipped and $j=i+1$ holds a fixed value depending on i. Therefore, the events $ax$ and $cz$ are considered. For**activation**constraints, chainSuccession$(ax,c)$ including chainResponse$(ax,c)$ and chainPrecedence$(a,cz)$ is computed in the first step. For**target**constraints, chainSuccession$(a,cz)$ and chainPrecedence$(ax,c)$ are considered for the same values of i and j to calculate chainSuccession$(cz,b)$.

#### 4.2.4. Negative Relation Constraints

**activation**constraints $(A)$, the support ${S}_{A\_NRC}$ and confidence ${C}_{A\_NRC}$ are calculated as described below. The support ${S}_{A\_NRC}$ is computed as the negation of the respective mutual relation constraint, while the equation for the confidence calculation corresponds to the confidence calculation for activation mutual relation constraints (cf. Equation (20)).

**target**negative relation constraints $(T)$ from a multi-perspective view are stated as ${S}_{T\_NRC}$ and ${C}_{T\_NRC}$. As for activation constraints, the support ${S}_{T\_NRC}$ negates the support value of the mutual relation constraint and the confidence calculation ${C}_{T\_NRC}$ remains according to Equation (22).

- NotChainSuccession
**Description.**The**future constraining**and**history-based**constraint notChainSuccession$(a,b)$ indicates that event a and event b occur in the trace, if and only if the latter does not immediately follow the former. Event a and event b activate the constraint.**Mining**Event-basedThe notChainSuccession constraint is computed like the chainSuccession constraint for**activation**and**target**conditions. The only difference lies in the determination of the support value ${S}_{NCS}$ which is calculated by negating the support value ${S}_{CS}$ of chainSuccession for each event pair. This negation is expressed formally as ${S}_{NCS}=1.0-{S}_{CS}$. - NotSuccession
**Description.**The**future constraining**and**history-based**constraint notSuccession$(a,b)$ indicates that event a can never occur before event b in the trace. Event a and event b activate the constraint.**Mining**Event-basedThe notSuccession constraint is computed similar to the Succession constraint for**activation**and**target**conditions. Similar to the notChainSuccession constraint, the determination of the support value ${S}_{NS}$ is calculated by negating the support value ${S}_{S}$ of Succession for each event pair. This negation is expressed formally as ${S}_{NS}=1.0-{S}_{S}$. - NotCoExistence
**Description.**The**future constraining**and**history-based**constraint notCoExistence$(a,b)$ indicates that event a and event b never occur together. Event a and event b activate the constraint.**Mining**Event-basedThe notCoExistence constraint is computed similar to the coExistence constraint for**activation**and**target**conditions. Just as the two items above, the determination of the support value ${S}_{NCE}$ is calculated by negating the support value ${S}_{CE}$ of coExistence for each event pair. This negation is expressed formally as ${S}_{NCE}=1.0-{S}_{CE}$.

#### 4.3. Pivot Characteristics Overview

**Class I**(${1}_{PA},{2}_{PA},{1}_{R}-{7}_{R},{1}_{AR}-{5}_{AR},{7}_{AR}-{8}_{AR},{1}_{RE}-{26}_{RE}$). These situations occur when a pair of events is considered, where the activating event was already fulfilled in this case with a previous event. For instance, in a trace $\langle ax,b?,b?\rangle $, the constraint $R(ax,b)$ is fulfilled with the first event b and must not be considered in the next step ($j=2$). For this activation constraint, the additional perspective of the fulfilling event is not crucial (note the ?). A similar case for a target constraint is $\langle a?,bx,bx\rangle $ where $R(a,bx)$ is fulfilled when reading the second $bx$ in the inner loop. In addition, the $alternateResponse$ template suffers from this anomaly: assuming a trace $\langle ax,\overline{ax},b?,\overline{ax},b?\rangle $, the value for ${\sigma}_{AR}(ax,b)$ referring to the constraint $AR(ax,b)$ would be incremented with the first b and the second b. Note that in this class it is forbidden for $ax$ to recur as this would cause a violation (cf. Class II).

**Solution.**The problem is that the events in the inner loop filtered by the target template ${e}_{j}^{T}$ are recurring. To prevent these Class I-failures, all events ${e}_{j}^{T}$ are stored in a list L and $\sigma $ is only incremented if the current ${e}_{j}^{T}$ is not in L.

**Class II**(${6}_{AR},{9}_{AR}-{12}_{AR}$). Class II-errors hits the $alternateResponse$ template solely. The definition of this template forbids the activating event to recur before the second event appears. As an example serves the trace $\langle ax,ax,b?\rangle $ with the constraint $AR(ax,b)$ for an activation constraint and $\langle a?,a?,bx\rangle $ with $AR(a,bx)$ for a target constraint.

**Solution.**If the activating event ${}_{i}{e}^{A}$ recurs in the inner loop as event ${e}_{j}^{A}$, then all succeeding constraints in the inner loop are violated by this recursion and thus the inner loop can be cancelled for this template.

**Class III**(${1}_{P}-{5}_{P},{3}_{AP}-{6}_{AP},{12}_{AP}$). These anomalies are similar to Class I but for history-based constraint templates. Some constraints must not be considered because they will be fulfilled afterwards. For instance, in a trace $\langle b?,b?,ax\rangle $ in the first outer loop run, it is checked if the first $b?$ fulfils a constraint $P(b,ax)$. However, this is not true because this certain constraint is fulfilled in the second outer loop run.

**Solution.**The problem here is that the event of the outer loop ${}_{i}{e}^{T}$ recurs in the inner loop event ${e}_{j}^{T}$. That means that the succeeding inner loop events are fulfilled afterwards with succeeding outer loop events. In case of a recurrence, the consideration of succeeding events in this inner loop run can be cancelled.

**Class IV**(${1}_{AP}-{2}_{AP},{7}_{AP}-{11}_{AP}$). Similar to Class II, errors corresponding to Class IV handle violations of constraints, viz. from the $alternatePrecedence$ template in this particular case. In a trace $\langle a?,bx,bx\rangle $, the activation constraint $alternatePrecedence(a,bx)$, activated with the second $bx$ event, is violated, as $bx$ recurs, before the fulfilling event a proceeds.

**Solution.**As a solution, we store all events ${e}_{j}^{A}$ in a list. If a next event ${e}_{j}^{A}$ with a greater j occurs, the consideration of $alternatePrecedence$ templates can be cancelled for a certain i.

## 5. Implementation

#### 5.1. An extendable Framework

#### 5.2. MapReduce-Miner Library

#### 5.2.1. Package Model

#### 5.2.2. JobRunner and Database as Centerpiece

Algorithm 1: Setup of a mining job. |

1 Configuration configuration = new Configuration(); |

2 configuration |

3 .setEventIdentifier("task") |

4 .setAdditionalAttribute("resource") |

5 .addConstraint(Response.class) |

6 .allConstraintTypes(); |

7 JobRunner job = new JobRunner(eventLog, configuration); |

8 job.run(); |

9 job.getMiningResult(); |

Algorithm 2: The run and map functions. |

1 publicvoid run() { |

2 // MR-I: produce Key–Value Pairs |

3 Database db = eventLog.getTraces().stream().map((trace) -> map(trace)) |

4 .reduce((accDb, currentDb) -> reduce(accDb, currentDb)).get(); |

5 // ’MR-II’: calculate Support and Confidence |

6 mrii(db); |

7 } |

8 publicvoid map(Trace trace) { |

9 Database database = new Database(configuration); |

10 AuxilaryDatabase ad = new AuxilaryDatabase(); |

11 for (int i = 0; i < trace.getEvents().size(); i++) { |

12 //… |

13 for (int j = 0; j < trace.getEvents().size(); j++) { |

14 for (Class<Constraint> c: getConfiguration().getConstraints()) { |

15 Constraint impl = instantiate(c, events.get(i), events.get(j), -1,ConstraintType.ACTIVATION); |

16 if (impl instanceof Eventbased) { |

17 Eventbased eventBasedImpl = (Eventbased) impl; |

18 if (eventBasedImpl.logic(ad)) |

19 database.addSigma(eventBasedImpl, 1); |

20 //… |

21 //Tracebased-Constraints… |

22 } |

#### 5.2.3. Package Constraint

Algorithm 3: Class Init. |

1 publicclassInitextendsSingleEventConstraintimplementsTracebased { |

2 @Override |

3 publicboolean logic(AuxilaryDatabase ad, int position, int size) { |

4 if(position == 0) |

5 return true; |

6 else |

7 return false; |

8 } |

9 @Override |

10 publicResultElement getResult(Database db, double sigma, int logSize) { |

11 returnnewResultElement( |

12 this.getClass().toString(), getEvent(), sigma/logSize, 0.0d, this.getType()); |

13 } |

14 } |

#### 5.3. System Support

`config.addConstraint(WithinFiveSteps.class)`) and a corresponding amended

`AuxiliaryDatabase`(

`config.setAuxiliaryDatabaseClass(CustomAuxiliaryDatabase.class`)). The custom logic is listed in Algorithm 4. The implementation resembles the Response class but uses an additional restriction that the task must not be more than five steps ahead (Line 7). In Line 5, the AuxiliaryDatabase is casted to our custom version, in order to obtain access to the required data structures on Lines 8 and 9.

`testCustomConstraintFulfill()`operates on a trace

`testCustomConstraint()`operates on a trace

Algorithm 4: Custom constraint WithinFiveSteps. |

1 publicclassWithinFiveStepsextendsDoubleEventConstraint |

2 implementsEventbased, FutureBased { |

3 @Override |

4 publicboolean logic(AuxiliaryDatabase ad) { |

5 CustomAuxiliaryDatabase cad = (CustomAuxiliaryDatabase) ad; |

6 if(cad.currentJ < cad.currentI+1) return false; |

7 if(cad.currentJ > cad.currentI+5) return false; |

8 if (!cad.tasksWithinFiveSteps.contains(super.getEventB())) { |

9 cad.tasksWithinFiveSteps.add(super.getEventB()); |

10 return true; |

11 } elsereturn false; } |

12 } |

13 } |

## 6. Evaluation

#### 6.1. Quantitative Performance Analysis

**Comparison with Related Tools**

**Analysis of different Log Files**

#### 6.2. Qualitative Evaluation

**bold**in Table 22). These occur because MINERful also calculates vacuously defined constraints. For instance, the confidence of the constraint $Succession(b,d)$ is calculated as $0.429\xb7\frac{2}{3}=0.286$ in MINERful. The value 2 in the numerator is composed of the occurrence of events d and b in Trace ${t}_{0}$ and the non-occurrence of b in Trace ${t}_{2}$. Per definition, $Succession(b,d)$ is then vacuously fulfilled.

`"WHERE a.Task != b.Task"`in the SQL-script). The rest of the discovered constraints is, besides rounding errors, consistent.

## 7. Conclusions

## Author Contributions

## Funding

## Conflicts of Interest

## References

- Schönig, S.; Zeising, M.; Jablonski, S. Supporting collaborative work by learning process models and patterns from cases. In Proceedings of the 9th IEEE International Conference on Collaborative Computing: Networking, Applications and Worksharing, Austin, TX, USA, 20–23 October 2013; pp. 60–69. [Google Scholar]
- Van der Aalst, W. Process Mining: Discovery, Conformance and Enhancement of Business Processes; Springer: Berlin, Germany, 2011. [Google Scholar]
- Pichler, P.; Weber, B.; Zugal, S.; Pinggera, J.; Mendling, J.; Reijers, H.A. Imperative versus Declarative Process Modeling Languages: An Empirical Investigation. In Proceedings of the International Conference on Business Process Management, Clermont-Ferrand, France, 29 August–2 September 2011; pp. 383–394. [Google Scholar]
- Pesic, M.; Schonenberg, H.; van der Aalst, W.M.P. DECLARE: Full Support for Loosely-Structured Processes. In Proceedings of the 11th IEEE International Enterprise Distributed Object Computing Conference (EDOC 2007), Annapolis, MD, USA, 15–19 October 2007; pp. 287–300. [Google Scholar]
- Zeising, M.; Schönig, S.; Jablonski, S. Towards a Common Platform for the Support of Routine and Agile Business Processes. In Proceedings of the Collaborative Computing: Networking, Applications and Worksharing, Miami, FL, USA, 22–25 October 2014. [Google Scholar]
- De Leoni, M.; van der Aalst, W.M.P.; Dees, M. A general process mining framework for correlating, predicting and clustering dynamic behavior based on event logs. Inf. Syst.
**2016**, 56, 235–257. [Google Scholar] [CrossRef] - Burattin, A.; Maggi, F.M.; Sperduti, A. Conformance Checking Based on Multi-Perspective Declarative Process Models. arXiv, 2015; arXiv:1503.04957. [Google Scholar] [CrossRef]
- Augusto, A.; Conforti, R.; Dumas, M.; La Rosa, M.; Maggi, F.M.; Marrella, A.; Mecella, M.; Soo, A. Automated Discovery of Process Models from Event Logs: Review and Benchmark. CoRR
**2017**, arXiv:1705.02288. [Google Scholar] [CrossRef] - Van der Aalst, W.M.P. Process Mining—Data Science in Action, 2nd ed.; Springer: Berlin, Germany, 2016. [Google Scholar]
- Leemans, S.J.J.; Fahland, D.; van der Aalst, W.M.P. Scalable process discovery and conformance checking. Softw. Syst. Model.
**2018**, 17, 599–631. [Google Scholar] [CrossRef] [PubMed] - Di Ciccio, C.; Mecella, M. A Two-Step Fast Algorithm for the Automated Discovery of Declarative Workflows. In Proceedings of the 2013 IEEE Symposium on Computational Intelligence and Data Mining (CIDM), Singapore, 16–19 April 2013; pp. 135–142. [Google Scholar]
- Di Ciccio, C.; Mecella, M. On the Discovery of Declarative Control Flows for Artful Processes. ACM TMIS
**2015**, 5, 1–37. [Google Scholar] [CrossRef] - Maggi, F.M. Declarative Process Mining with the Declare Component of ProM. In Proceedings of the Business Process Management Demos, Beijing, China, 26–30 August 2013. [Google Scholar]
- Schönig, S.; Rogge-Solti, A.; Cabanillas, C.; Jablonski, S.; Mendling, J. Efficient and Customisable Declarative Process Mining with SQL. In Proceedings of the International Conference on Advanced Information Systems Engineering, Tallinn, Estonia, 11–15 June 2016. [Google Scholar]
- Schönig, S.; Di Ciccio, C.; Maggi, F.M.; Mendling, J. Discovery of Multi-perspective Declarative Process Models. In Proceedings of the International Conference on Service-Oriented Computing, Hangzhou, China, 12–15 November 2016; pp. 87–103. [Google Scholar]
- Sturm, C.; Schönig, S.; Jablonski, S. A MapReduce Approach for Mining Multi-Perspective Declarative Process Models. In Proceedings of the 20th International Conference on Enterprise Information Systems, ICEIS 2018, Funchal, Portugal, 21–24 March 2018; pp. 585–595. [Google Scholar]
- Maggi, F.M.; Mooij, A.; van der Aalst, W. User-Guided Discovery of Declarative Process Models. In Proceedings of the 2011 IEEE Symposium on Computational Intelligence and Data Mining (CIDM), Paris, France, 11–15 April 2011; pp. 192–199. [Google Scholar]
- Di Ciccio, C.; Schouten, M.H.M.; de Leoni, M.; Mendling, J. Declarative Process Discovery with MINERful in ProM. In Proceedings of the Business Process Management Demos, Innsbruck, Austria, 31 August–3 September 2015; pp. 60–64. [Google Scholar]
- Westergaard, M.; Stahl, C.; Reijers, H. UnconstrainedMiner: Efficient Discovery of Generalized Declarative Process Models; BPM CR, No. BPM-13-28; BPM Center: Eindhoven, The Netherlands, 2013. [Google Scholar]
- Maggi, F.; Bose, R.; van der Aalst, W. A Knowledge-Based Integrated Approach for Discovering and Repairing Declare Maps. In Proceedings of the International Conference on Advanced Information Systems Engineering, Tallinn, Estonia, 11–15 June 2013. [Google Scholar]
- Di Ciccio, C.; Maggi, F.M.; Montali, M.; Mendling, J. Ensuring Model Consistency in Declarative Process Discovery. In Proceedings of the International Conference on Business Process Management, Innsbruck, Australia, 31 August–3 September 2015; pp. 144–159. [Google Scholar]
- Di Ciccio, C.; Maggi, F.M.; Montali, M.; Mendling, J. Resolving inconsistencies and redundancies in declarative process models. Inf. Syst.
**2017**, 64, 425–446. [Google Scholar] [CrossRef][Green Version] - Bose, J.C.; Maggi, F.M.; van der Aalst, W. Enhancing Declare Maps Based on Event Correlations. In Proceedings of the Business Process Management, Beijing, China, 26–30 August 2013; pp. 97–112. [Google Scholar]
- Vanden Broucke, S.K.L.M.; Vanthienen, J.; Baesens, B. Declarative process discovery with evolutionary computing. In Proceedings of the 2014 IEEE Congress on Evolutionary Computation (CEC), Beijing, China, 6–11 July 2014; pp. 2412–2419. [Google Scholar] [CrossRef]
- Lamma, E.; Mello, P.; Montali, M.; Riguzzi, F.; Storari, S. Inducing Declarative Logic-Based Models from Labeled Traces. In Proceedings of the International Conference on Business Process Management, Brisbane, Australia, 24–28 September 2007; pp. 344–359. [Google Scholar]
- Chesani, F.; Lamma, E.; Mello, P.; Montali, M.; Riguzzi, F.; Storari, S. Exploiting Inductive Logic Programming Techniques for Declarative Process Mining. Trans. Petri Nets Other Models Concurrency
**2009**, 2, 278–295. [Google Scholar] - Räim, M.; Di Ciccio, C.; Maggi, F.M.; Mecella, M.; Mendling, J. Log-Based Understanding of Business Processes through Temporal Logic Query Checking. In Proceedings of the OTM Confederated International Conferences “On the Move to Meaningful Internet Systems”, Amantea, Italy, 27–31 October 2014; pp. 75–92. [Google Scholar]
- Westergaard, M.; Maggi, F.M. Looking into the Future: Using Timed Automata to Provide A Priori Advice about Timed Declarative Process Models; OTM; LNCS; Springer: Berlin, Germany, 2012; Volume 7565, pp. 250–267. [Google Scholar]
- Maggi, F.M. Discovering Metric Temporal Business Constraints from Event Logs. In Proceedings of the International Conference on Business Informatics Research, Lund, Sweden, 22–24 September 2014; pp. 261–275. [Google Scholar]
- Schönig, S.; Cabanillas, C.; Jablonski, S.; Mendling, J. A Framework for Efficiently Mining the Organisational Perspective of Business Processes. Decis. Support Syst.
**2016**, 89, 87–97. [Google Scholar] [CrossRef] - Cabanillas, C.; Schönig, S.; Sturm, C.; Mendling, J. Mining Expressive and Executable Resource-Aware Imperative Process Models. In Proceedings of the International Conference on Enterprise, Business-Process and Information Systems Modeling, Tallinn, Estonia, 11–12 June 2018; pp. 3–18. [Google Scholar]
- Schönig, S.; Cabanillas, C.; Ciccio, C.D.; Jablonski, S.; Mendling, J. Mining team compositions for collaborative work in business processes. Softw. Syst. Model.
**2018**, 17, 675–693. [Google Scholar] [CrossRef] - Montali, M.; Chesani, F.; Mello, P.; Maggi, F.M. Towards data-aware constraints in declare. In Proceedings of the 28th Annual ACM Symposium on Applied Computing, Coimbra, Portugal, 18–22 March 2013; pp. 1391–1396. [Google Scholar]
- Maggi, F.M.; Dumas, M.; García-Bañuelos, L.; Montali, M. Discovering Data-Aware Declarative Process Models from Event Logs. In Proceedings of the Business Process Management 2013, Beijing, China, 26–30 August 2013; pp. 81–96. [Google Scholar] [CrossRef]
- Burattin, A.; Maggi, F.M.; Sperduti, A. Conformance checking based on multi-perspective declarative process models. Expert Syst. Appl.
**2016**, 65, 194–211. [Google Scholar] [CrossRef][Green Version] - Ackermann, L.; Schönig, S.; Jablonski, S. Simulation of Multi-perspective Declarative Process Models. In Proceedings of the Business Process Management Workshops—BPM 2016 International Workshops, Rio de Janeiro, Brazil, 19 September 2016; Revised Papers. pp. 61–73. [Google Scholar]
- Ackermann, L.; Schönig, S.; Petter, S.; Schützenmeier, N.; Jablonski, S. Execution of Multi-perspective Declarative Process Models. On the Move to Meaningful Internet Systems. In Proceedings of the OTM 2018 Conferences—Confederated International Conferences: CoopIS, C&TC, and ODBASE 2018, Valletta, Malta, 22–26 October 2018; pp. 154–172. [Google Scholar]
- Sturm, C.; Schönig, S.; Ciccio, C.D. Distributed Multi-Perspective Declare Discovery. In Proceedings of the BPM Workshops, Barcelona, Spain, 10–15 September 2017. [Google Scholar]
- Van der Aalst, W.; Pesic, M.; Schonenberg, H. Declarative Workflows: Balancing Between Flexibility and Support. Comput. Sci. Res. Dev.
**2009**, 23, 99–113. [Google Scholar] [CrossRef] - Montali, M.; Pesic, M.; van der Aalst, W.M.P.; Chesani, F.; Mello, P.; Storari, S. Declarative Specification and Verification of Service Choreographies. ACM Trans. Web
**2010**, 4, 3. [Google Scholar] [CrossRef] - Burattin, A.; Maggi, F.M.; van der Aalst, W.M.; Sperduti, A. Techniques for a Posteriori Analysis of Declarative Processes. In Proceedings of the 16th IEEE International Enterprise Distributed Object Computing Conference, EDOC 2012, Beijing, China, 10–14 September 2012; pp. 41–50. [Google Scholar]
- Dean, J.; Ghemawat, S. MapReduce: Simplified Data Processing on Large Clusters. Commun. ACM
**2008**, 51. [Google Scholar] [CrossRef] - Foundation, A.S. Apache Hadoop. 2006. Available online: https://hadoop.apache.org/ (accessed on 5 January 2019).
- Wu, D.; Sakr, S.; Zhu, L. Big Data Programming Models. In Handbook of Big Data Technologies; Zomaya, A.Y., Sakr, S., Eds.; Springer International Publishing: Berlin, Germany, 2017; pp. 31–63. [Google Scholar]
- Boudewijn van Dongen, Real-Life Event Logs—Hospital Log. 2011. Available online: https://doi.org/10.4121/uuid:d9769f3d-0ab0-4fb8-803b-0d1120ffcf54 (accessed on 14 January 2019).
- Boudewijn van Dongen, BPI Challenge 2017. Available online: https://doi.org/10.4121/uuid:5f3067df-f10b-45da-b98b-86ae4c7a310b (accessed on 14 January 2019).
- Boudewijn van Dongen, BPI Challenge 2015. Available online: https://doi.org/10.4121/uuid:31a308ef-c844-48da-948c-305d167a0ec1 (accessed on 14 January 2019).

**Figure 1.**Infrastructure of the calculation [16].

Template | LTL${}_{\mathbf{f}}$ Semantics |
---|---|

existence$(A)$ | $\top \to \mathbf{F}(e(A)\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\vee \mathbf{O}(e(A)\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})$ |

responded existence$(A,B)$ | $\mathbf{G}((A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to (\mathbf{O}(B\begin{array}{c}\hfill {\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array})\vee \mathbf{F}(B\begin{array}{c}\hfill {\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array})))$ |

response$(A,B)$ | $\mathbf{G}((A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \mathbf{F}(B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

alternate response$(A,B)$ | $\mathbf{G}((A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \mathbf{X}(\neg (A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\mathbf{U}(B\begin{array}{c}\hfill {\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

chain response$(A,B)$ | $\mathbf{G}((A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \mathbf{X}(B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

precedence$(A,B)$ | $\mathbf{G}((B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \mathbf{O}(A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

alternate precedence$(A,B)$ | $\mathbf{G}((B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \mathbf{Y}(\neg (B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\mathbf{S}(A\begin{array}{c}\hfill {\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

chain precedence$(A,B)$ | $\mathbf{G}((B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \mathbf{Y}(A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

co existence$(A,B)$ | $respondedexistence(A,B)\wedge respondedexistence(B,A)$ |

succession$(A,B)$ | $response(A,B)\wedge precedence(A,B)$ |

alternate succession$(A,B)$ | $alternateresponse(A,B)\wedge alternateprecedence(A,B)$ |

chain succession$(A,B)$ | $chainresponse(A,B)\wedge chainprecedence(A,B)$ |

not responded existence$(A,B)$ | $\mathbf{G}((A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \neg (\mathbf{O}(B\begin{array}{c}\hfill {\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array})\vee \mathbf{F}(B\begin{array}{c}\hfill {\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array})))$ |

not response$(A,B)$ | $\mathbf{G}((A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \neg \mathbf{F}(B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

not precedence$(A,B)$ | $\mathbf{G}((B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \neg \mathbf{O}(A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

not chain response$(A,B)$ | $\mathbf{G}((A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \neg \mathbf{X}(B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

not chain precedence$(A,B)$ | $\mathbf{G}((B\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}\end{array})\to \neg \mathbf{Y}(A\begin{array}{c}\hfill {\wedge {\phi}_{a}(\overrightarrow{x})}{\wedge {\phi}_{c}(\overrightarrow{x},\overrightarrow{y})\wedge {\phi}_{t}(\overrightarrow{y})}\end{array}))$ |

not co existence$(A,B)$ | $notrespondedexistence(A,B)\wedge notrespondedexistence(B,A)$ |

not succession$(A,B)$ | $notresponse(A,B)\wedge notprecedence(A,B)$ |

not chain succession$(A,B)$ | $notchainresponse(A,B)\wedge notchainprecedence(A,B)$ |

**Table 2.**Output Mapper MR-I [16].

Trace | ${\mathbf{\sigma}}_{\mathit{R}}$ | ${\mathbf{\sigma}}_{\mathit{CR}}$ | $\mathbf{\eta}$ | $\mathbf{\u03f5}$ | |
---|---|---|---|---|---|

a,b,b,c | ab,1 | bc,1 | ab,1 | a,1 | a,1 |

ac,1 | bb,1 | b,1 | b,1 | ||

bb,1 | bc,1 | b,1 | c,1 | ||

bc,1 | c,1 | ||||

a,c,d | ac,1 | ac,1 | a,1 | a,1 | |

ad,1 | cd,1 | c,1 | c,1 | ||

cd,1 | d,1 | d,1 |

**Table 3.**Output Reducer MR-I [16].

${\mathbf{\sigma}}_{\mathit{R}}$ | ${\mathbf{\sigma}}_{\mathit{CR}}$ | $\mathbf{\eta}$ | $\mathbf{\u03f5}$ | ||
---|---|---|---|---|---|

ab,1 | bc,2 | ab,1 | ac,1 | a,2 | a,2 |

ac,2 | ad,1 | bb,1 | cd,1 | b,2 | b,1 |

bb,1 | cd,1 | bc,1 | c,2 | c,2 | |

d,1 | d,1 |

**Table 4.**Overview of all single-perspective constraints according to Di Ciccio and Mecella [12]. The symbol # represents the number of occurrences of the following event. The notation ${t}_{i}\left[first\right]$ refers to the first event and ${t}_{i}\left[last\right]$ to the last event in the trace i in the log containing $m\in \mathbb{N}$ traces with $i\in \{1,\dots ,m\}.$

Constraint | Activated with | Fulfilled with | Trace-/Event-Based |
---|---|---|---|

01. Existence$(n,a)$ | a | #a | Trace-based |

02. Participation$(a)$ | a | #$a\ge 1$ | Trace-based |

03. Absence$(n+1,a)$ | a | #$a\le n$ | Trace-based |

04. Uniqueness$(a)$ | a | #$a\le 1$ | Trace-based |

05. Init$(a)$ | a | ${t}_{i}\left[first\right]=a$ | Trace-based |

06. End$(a)$ | a | ${t}_{i}\left[last\right]=a$ | Trace-based |

07. Responded Existence$(a,b)$ | a | b | Event-based |

08. Response$(a,b)$ | a | b | Event-based |

09. AlternateResponse$(a,b)$ | a | b | Event-based |

10. ChainResponse$(a,b)$ | a | b | Event-based |

11. Precedence$(a,b)$ | b | a | Event-based |

12. AlternatePrecedence$(a,b)$ | b | a | Event-based |

13. ChainPrecedence$(a,b)$ | b | a | Event-based |

14. CoExistence$(a,b)$ | $a,b$ | $a,b$ | Event-based |

15. Succession$(a,b)$ | $a,b$ | $a,b$ | Event-based |

16. AlternateSuccession$(a,b)$ | $a,b$ | $a,b$ | Event-based |

17. ChainSuccession$(a,b)$ | $a,b$ | $a,b$ | Event-based |

18. NotChainSuccession$(a,b)$ | $a,b$ | $a,b$ | Event-based |

19. NotSuccession$(a,b)$ | $a,b$ | $a,b$ | Event-based |

20. NotCoExistence$(a,b)$ | $a,b$ | $a,b$ | Event-based |

ax | cz | by | bx | dz | by | ax |
---|---|---|---|---|---|---|

1 | 1 | 1 | 1 | 1 | 2 | 2 |

ax | cz | by | bx | dz | by | ax |
---|---|---|---|---|---|---|

✓ | ✓ | ✓ | ✓ | ✓ | ${1}_{PA}$ | ${2}_{PA}$ |

ax | cz | by | bx | dz |
---|---|---|---|---|

3.. | 2.. | 3.. | 2.. | 2.. |

ax | cz | by | bx | dz |
---|---|---|---|---|

${1}_{U}$ | ✓ | ${2}_{U}$ | ✓ | ✓ |

ax | cz | by | bx | dz | by | ax |
---|---|---|---|---|---|---|

✓ |

ax | cz | by | bx | dz | by | ax |
---|---|---|---|---|---|---|

✓ |

(a) | |||||||
---|---|---|---|---|---|---|---|

a | c | b | b | d | b | a | |

ax | ✓ | ✓ | ${1}_{RE}$ | ✓ | ${2}_{RE}$ | ✓ | |

cz | ✓ | ✓ | ${3}_{RE}$ | ✓ | ${4}_{RE}$ | ${5}_{RE}$ | |

by | ✓ | ✓ | ✓ | ✓ | ${6}_{RE}$ | ${7}_{RE}$ | |

bx | ✓ | ✓ | ✓ | ✓ | ${8}_{RE}$ | ${9}_{RE}$ | |

dz | ✓ | ✓ | ✓ | ${10}_{RE}$ | ${11}_{RE}$ | ${12}_{RE}$ | |

by | ✓ | ✓ | ✓ | ${13}_{RE}$ | ✓ | ${14}_{RE}$ | |

ax | ✓ | ✓ | ✓ | ${15}_{RE}$ | ✓ | ${16}_{RE}$ | |

(b) | |||||||

ax | cz | by | bx | dz | by | ax | |

a | ✓ | ✓ | ✓ | ✓ | ${17}_{RE}$ | ✓ | |

c | ✓ | ✓ | ✓ | ✓ | ${18}_{RE}$ | ${19}_{RE}$ | |

b | ✓ | ✓ | ✓ | ✓ | ✓ | ${20}_{RE}$ | |

b | ✓ | ✓ | ✓ | ✓ | ${21}_{RE}$ | ${22}_{RE}$ | |

d | ✓ | ✓ | ✓ | ✓ | ${23}_{RE}$ | ${24}_{RE}$ | |

b | ✓ | ✓ | ✓ | ✓ | ✓ | ${25}_{RE}$ | |

a | ✓ | ✓ | ✓ | ✓ | ✓ | ${26}_{RE}$ |

(a) | ||||||
---|---|---|---|---|---|---|

c | b | b | d | b | a | |

ax | ✓ | ✓ | ${1}_{R}$ | ✓ | ${2}_{R}$ | ✓ |

cz | ✓ | ${3}_{R}$ | ✓ | ${4}_{R}$ | ✓ | |

by | ✓ | ✓ | ${5}_{R}$ | ✓ | ||

bx | ✓ | ✓ | ✓ | |||

dz | ✓ | ✓ | ||||

by | ✓ | |||||

(b) | ||||||

cz | by | bx | dz | by | ax | |

a | ✓ | ✓ | ✓ | ✓ | ${6}_{R}$ | ✓ |

c | ✓ | ✓ | ✓ | ${7}_{R}$ | ✓ | |

b | ✓ | ✓ | ✓ | ✓ | ||

b | ✓ | ✓ | ✓ | |||

d | ✓ | ✓ | ||||

b | ✓ |

(a) | ||||||
---|---|---|---|---|---|---|

c(z) | b(y) | b(x) | d(z) | b(y) | a(x) | |

ax | ✓ | ✓ | ${1}_{AR}$ | ✓ | ${2}_{AR}$ | ✓ |

cz | ✓ | ${3}_{AR}$ | ✓ | ${4}_{AR}$ | ✓ | |

by | ✓ | ✓* | ${5}_{AR}$ | ${6}_{AR}$ | ||

bx | ✓ | ✓ | ✓ | |||

dz | ✓ | ✓ | ||||

by | ✓ | |||||

(b) | ||||||

cz | by | bx | dz | by | ax | |

a | ✓ | ✓ | ✓ | ✓ | ${7}_{AR}$ | ✓ |

c | ✓ | ✓ | ✓ | ${8}_{AR}$ | ✓ | |

b | ✓ | ${9}_{AR}$ | ${10}_{AR}$ | ${11}_{AR}$ | ||

b | ✓ | ✓ | ${12}_{AR}$ | |||

d | ✓ | ✓ | ||||

b | ✓ |

cz | by | bx | dz | by | ax | |
---|---|---|---|---|---|---|

ax | ✓ | |||||

cz | ✓ | |||||

by | ✓ | |||||

bx | ✓ | |||||

dz | ✓ | |||||

by | ✓ |

(a) | ||||||
---|---|---|---|---|---|---|

cz | by | bx | dz | by | ax | |

a | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |

c | ✓ | ✓ | ✓ | ✓ | ✓ | |

b | ✓ | ${1}_{P}$ | ${2}_{P}$ | ${3}_{P}$ | ||

b | ✓* | ✓ | ${4}_{P}$ | |||

d | ✓ | ✓ | ||||

b | ✓ | |||||

(b) | ||||||

c | b | b | d | b | a | |

ax | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ |

cz | ✓ | ✓ | ✓ | ✓ | ✓ | |

by | ✓ | ✓ | ✓ | ${5}_{P}$ | ||

bx | ✓ | ✓ | ✓ | |||

dz | ✓ | ✓ | ||||

by | ✓* |

(a) | ||||||
---|---|---|---|---|---|---|

cz | by | bx | dz | by | ax | |

a | ✓ | ✓ | ✓ | ✓ | ${1}_{AP}$ | ✓ |

c | ✓ | ✓ | ✓ | ${2}_{AP}$ | ✓ | |

b | ✓ | ${3}_{AP}$ | ${4}_{AP}$ | ${5}_{AP}$ | ||

b | ✓* | ✓ | ${6}_{AP}$ | |||

d | ✓ | ✓ | ||||

b | ✓ | |||||

(b) | ||||||

c | b | b | d | b | a | |

ax | ✓ | ✓ | ${7}_{AP}$ | ✓ | ${8}_{AP}$ | ✓ |

cz | ✓ | ${9}_{AP}$ | ✓ | ${10}_{AP}$ | ✓ | |

by | ✓ | ✓ | ${11}_{AP}$ | ${12}_{AP}$ | ||

bx | ✓ | ✓ | ✓ | |||

dz | ✓ | ✓ | ||||

by | ✓* |

cz | by | bx | dz | by | ax | |
---|---|---|---|---|---|---|

ax | ✓ | |||||

cz | ✓ | |||||

by | ✓ | |||||

bx | ✓ | |||||

dz | ✓ | |||||

by | ✓ |

a(x) | c(z) | b(y) | b(x) | d(z) | b(y) | a(x) | |
---|---|---|---|---|---|---|---|

ax | ${\u2713}_{1}$ | ${\u2713}_{2}$ | ${1}_{RE}$ | ${\u2713}_{3}$ | ${2}_{RE}$ | ${\u2713}_{4}$ | |

cz | ${\u2713}_{5}$ | ${\u2713}_{6}$ | ${3}_{RE}$ | ${\u2713}_{7}$ | ${4}_{RE}$ | ${5}_{RE}$ | |

by | ${\u2713}_{8}$ | ${\u2713}_{9}$ | ${\u2713}_{10}$ | ${\u2713}_{11}$ | ${6}_{RE}$ | ${7}_{RE}$ | |

bx | ${\u2713}_{2}$ | ${\u2713}_{12}$ | ${\u2713}_{13}$ | ${\u2713}_{14}$ | ${8}_{RE}$ | ${9}_{RE}$ | |

dz | ${\u2713}_{15}$ | ${\u2713}_{7}$ | ${\u2713}_{16}$ | ${10}_{RE}$ | ${11}_{RE}$ | ${12}_{RE}$ | |

by | ${\u2713}_{8}$ | ${\u2713}_{17}$ | ${\u2713}_{10}$ | ${13}_{RE}$ | ${\u2713}_{18}$ | ${14}_{RE}$ | |

ax | ${\u2713}_{4}$ | ${\u2713}_{19}$ | ${\u2713}_{2}$ | ${15}_{RE}$ | ${\u2713}_{20}$ | ${16}_{RE}$ |

ax | cz | by | bx | dz | by | ax | |
---|---|---|---|---|---|---|---|

a(x) | ${\u2713}_{21}$ | ${\u2713}_{22}$ | ${\u2713}_{23}$ | ${\u2713}_{24}$ | ${17}_{RE}$ | ${\u2713}_{25}$ | |

c(z) | ${\u2713}_{26}$ | ${\u2713}_{27}$ | ${\u2713}_{28}$ | ${\u2713}_{29}$ | ${18}_{RE}$ | ${19}_{RE}$ | |

b(y) | ${\u2713}_{23}$ | ${\u2713}_{24}$ | ${\u2713}_{25}$ | ${\u2713}_{26}$ | ${\u2713}_{27}$ | ${20}_{RE}$ | |

b(x) | ${\u2713}_{23}$ | ${\u2713}_{24}$ | ${\u2713}_{27}$ | ${\u2713}_{26}$ | ${21}_{RE}$ | ${22}_{RE}$ | |

d(z) | ${\u2713}_{28}$ | ${\u2713}_{29}$ | ${\u2713}_{30}$ | ${\u2713}_{31}$ | ${23}_{RE}$ | ${24}_{RE}$ | |

b(y) | ${\u2713}_{23}$ | ${\u2713}_{24}$ | ${\u2713}_{27}$ | ${\u2713}_{25}$ | ${\u2713}_{26}$ | ${25}_{RE}$ | |

a(x) | ${\u2713}_{25}$ | ${\u2713}_{21}$ | ${\u2713}_{22}$ | ${\u2713}_{23}$ | ${\u2713}_{24}$ | ${26}_{RE}$ |

**Table 20.**Overview of the support and confidence equations from a multi-perspective view for all presented constraints in Table 4. The variables a and b are placeholders for events that occur in the trace, while the variables x and y refer to the resources that execute these activities. The variables $\u03f5$, l, $\sigma $ and $\eta $ are defined in the respective section.

Support | Confidence | ||
---|---|---|---|

Existence Constraints | Activation | ${S}_{EC}(ax)=\frac{{\sigma}_{EC}(ax)}{\left|l\right|}$ | ${C}_{EC}(ax)={S}_{EC}(ax)\xb7\frac{\u03f5(ax)}{\left|l\right|}$ |

Target | not defined | not defined | |

Relation Constraints (forward constraining) | Activation | ${S}_{FA\_RC}(ax,b)=\frac{{\sigma}_{FA\_RC}(ax,b)}{\eta (ax)}$ | ${C}_{FA\_RC}(ax,b)={S}_{FA\_RC}(ax,b)\xb7\frac{\u03f5(ax)}{\left|l\right|}$ |

Target | ${S}_{FT\_RC}(a,by)=\frac{{\sigma}_{FT\_RC}(a,by)}{\eta (a)}$ | ${C}_{FT\_RC}(a,by)={S}_{FT\_RC}(a,by)\xb7\frac{\u03f5(a)}{\left|l\right|}$ | |

Relation Constraints (history-based) | Activation | ${S}_{BA\_RC}(a,by)=\frac{{\sigma}_{BA\_RC}(a,by)}{\eta (by)}$ | ${C}_{BA\_RC}(a,by)={S}_{BA\_RC}(a,by)\xb7\frac{\u03f5(by)}{\left|l\right|}$ |

Target | ${S}_{BT\_RC}(ax,b)=\frac{{\sigma}_{BT\_RC}(ax,b)}{\eta (b)}$ | ${C}_{BT\_RC}(ax,b)={S}_{BT\_RC}(ax,b)\xb7\frac{\u03f5(b)}{\left|l\right|}$ | |

Mutual Relation Constraints | Activation | ${S}_{A\_MRC}(ax,b)=\frac{{\sigma}_{A\_MRC}(ax,b)}{\eta (ax)+\eta (bx)}$ | ${C}_{A\_MRC}(ax,b)={S}_{A\_MRC}(ax,b)\xb7\frac{\u03f5(ax,bx)}{\left|l\right|}$ |

Target | ${S}_{T\_MRC}(a,bx)=\frac{{\sigma}_{T\_MRC}(a,bx)}{\eta (a)+\eta (b)}$ | ${C}_{T\_MRC}(a,bx)={S}_{T\_MRC}(a,bx)\xb7\frac{\u03f5(a,b)}{\left|l\right|}$ | |

Negative Relation Constraints | Activation | ${S}_{A\_NRC}(ax,b)=1-{S}_{A\_MRC}(ax,b)$ | ${C}_{A\_NRC}(ax,b)={S}_{A\_NRC}(ax,b)\xb7\frac{\u03f5(ax,bx)}{\left|l\right|}$ |

Target | ${S}_{T\_NRC}(a,bx)=1-{S}_{T\_MRC}(a,bx)$ | ${C}_{T\_NRC}(a,bx)={S}_{T\_NRC}(a,bx)\xb7\frac{\u03f5(a,b)}{\left|l\right|}$ |

Single-Perspective * | Multi-Perspective ** | |||||||
---|---|---|---|---|---|---|---|---|

Financial Log | Hospital Log | Hospital Log | ||||||

- | - | - | - | Activation | Target | |||

Approach | seq. | par. | seq. | par. | seq. | par. | seq. | par. |

SQLMiner [14,15] | 01:08 | - | 19:30 | - | 15:43 | - | 06:43:05 | - |

MINERful [11,12] | 00:17 | - | 12:28 | - | - | - | - | - |

MapReduce | 02:03 | 00:30 | 14:35 | 1:57 | 07:09 | 01:07 | 06:44 | 01:00 |

MapReduce | MINERful | ||||
---|---|---|---|---|---|

Task A | Task B | Support | Confidence | Support | Confidence |

a | a | 0.25 | 0.083 | - | - |

a | b | 0.778 | 0.518 | 0.778 | 0.518 |

a | c | 0.85714 | 0.85714 | 0.85714 | 0.85714 |

a | d | 0.66 | 0.44 | 0.66 | 0.44 |

b | a | 0.44 | 0.296 | 0.44 | 0.296 |

b | b | 0.6 | 0.3997 | - | - |

b | c | 0.375 | 0.25 | 0.375 | 0.25 |

b | d | 0.428571 | 0.142857 | 0.428571 | 0.285714 |

c | a | 0.285714 | 0.285714 | 0.285714 | 0.285714 |

c | b | 0.5 | 0.33 | 0.5 | 0.33 |

c | d | 0.8 | 0.533 | 0.8 | 0.5334 |

d | a | 0.33 | 0.22 | 0.33 | 0.22 |

d | b | 0.285714 | 0.095238 | 0.285714 | 0.190476 |

MapReduce | SQLMiner | |||||
---|---|---|---|---|---|---|

Task A | Resource A | Task B | Support | Confidence | Support | Confidence |

a | x | a | 0.33 | 0.22 | - | - |

a | x | b | 0.66 | 0.44 | 0.66 | 0.44 |

a | x | c | 0.66 | 0.44 | 0.66 | 0.44 |

a | y | c | 1.0 | 0.33 | 1.0 | 0.33 |

a | x | d | 0.33 | 0.22 | 0.33 | 0.22 |

a | y | d | 1.0 | 0.33 | 1.0 | 0.33 |

b | x | a | 0.5 | 0.33 | 0.5 | 0.33 |

b | y | a | 0.66 | 0.44 | 0.66 | 0.44 |

b | x | b | 1.0 | 0.66 | - | - |

b | y | b | 0.33 | 0.22 | - | - |

b | x | c | 0.5 | 0.33 | 0.5 | 0.33 |

b | y | c | 0.33 | 0.22 | 0.33 | 0.22 |

b | x | d | 0.5 | 0.33 | 0.5 | 0.33 |

b | y | d | 0.33 | 0.22 | 0.33 | 0.22 |

c | z | a | 1.0 | 0.33 | 1.0 | 0.33 |

c | z | b | 1.0 | 0.33 | 1.0 | 0.33 |

c | x | d | 0.5 | 0.33 | 0.5 | 0.33 |

c | z | d | 1.0 | 0.33 | 1.0 | 0.33 |

d | z | a | 1.0 | 0.33 | 1.0 | 0.33 |

d | z | b | 1.0 | 0.33 | 1.0 | 0.33 |

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

## Share and Cite

**MDPI and ACS Style**

Sturm, C.; Fichtner, M.; Schönig, S.
Full Support for Efficiently Mining Multi-Perspective Declarative Constraints from Process Logs. *Information* **2019**, *10*, 29.
https://doi.org/10.3390/info10010029

**AMA Style**

Sturm C, Fichtner M, Schönig S.
Full Support for Efficiently Mining Multi-Perspective Declarative Constraints from Process Logs. *Information*. 2019; 10(1):29.
https://doi.org/10.3390/info10010029

**Chicago/Turabian Style**

Sturm, Christian, Myriel Fichtner, and Stefan Schönig.
2019. "Full Support for Efficiently Mining Multi-Perspective Declarative Constraints from Process Logs" *Information* 10, no. 1: 29.
https://doi.org/10.3390/info10010029