Mining Usage Scenarios in Business Processes : Outlier-Aware Discovery and Run-Time Prediction Appendix : Complexity Issues and Experimental Results

This document is devoted to discuss some issues concerning the complexity and the implementation of the proposed algorithms (Section A), and further results of experiments on real data (Section B). A Details on Complexity and Implementation Issues A.1 Algorithm OASC We next provide a complexity analysis of algorithm OASC, assuming that the input log consists of N traces, spanning across T tasks, and that the maximal size of the S-patterns used for the clustering is S (i.e. pattSize = S). Let us first focus on function FindPatterns, while denoting by Pcan the maximum number of patterns generated at any iteration of its main loop (Steps P3-P9). To keep thinks simple, let us assume that each log trace contains at most one occurrence (or a constant number of occurrences) of any task, i.e., the unknown workflow process that generated the log is acyclic. It is worth noticing that this assumption lowly impacts on our cost analysis, and that usually the number of iterations of any task cycle is bounded in real-world processes. On the other hand, some preprocessing techniques and tools (e.g., in ProM [1]) have been developed to eliminate duplicated activities from log traces, in order to make simpler process mining analyses. Moreover, we assume that the set L1 is stored in a sparse matrix of size T 2, which can be computed in O(N × T) time (Step P1), provided a reasonably high (e.g., σ > 0.04) support threshold is used1. In fact, search-tree structures can be used to keep 1By putting σ far from 0, the number of spurious tasks admitted between the vertices of any elementary (single-edge) pattern in L1 gets lower than T − 1. Indeed, recall we are assuming that log traces are long T at most. For example, for σ = 0.05 the maximum number of spurious activities is 2 (= b− ln(0.05)c). Preprint submitted to Elsevier September 22, 2010 the patterns generated in the two latter iterations of the loop over Steps P3-P9, and to efficiently prevent the insertion of duplicated candidates2. Under this assumption, generating any higher level of candidate patterns (Step P4) only consumes O(T ×Pcan) time. Calculating the support scores of level-i candidate patterns (Step P5) can be done instead in O(N× (T + Pcan× i))—the support of all edges contained in each candidate pattern is evaluated for each log trace t encountered in the current scan of the log, after suitably converting t into a vector storing the position of all the activities in t. Therefore, the overall computation time of function FindPatterns is O(N× (T + Pcan× S2) + T × Pcan), with the rightmost addend playing no relevant role in most practical cases. Clearly, this cost is influenced by parameter Pcan, which may be combinatorial in the number T of process tasks. In fact, this problem is inherent to the levelwise generation-and-test strategy adopted by the function, which risks producing a great deal of candidate patterns, similarly to several classical pattern mining algorithms, such as Apriori, AprioriAll and GSP (see, e.g., [3]). A pessimistic estimate for the number of level-i S-patterns is indeed |Li|= O(T × T−1 i ) ), which actually corresponds to the rare case of a completely chaotic process logs, featuring most of all possible task sequences, combined with the usage of very low values for the minimum support threshold σ. In actual fact, Pcan also strongly depends on σ and on the actual distribution of activity sequences in the given log. In typical situations, where a more aggressive pruning strategy is used and the execution of process activities obeys stricter precedence constraints and routing rules, the actual number of patterns at each step of the levelwise computation is far lower than the above estimate, and not really combinatorial in T . The complexity of function FindCoClusters mainly depends on the number Pmax of maximal patterns eventually used for the clustering—notice that the maximal patterns returned by FindPatterns are usually far less than Pcan×S, and that the analyst can anyway decide to only keep the a restricted number of them having the top-Pmax support scores. Let us assume that threshold α is chosen in a way that allows to identify, for any trace t, any pattern p with supp(p, t)> α by only using a sliding window over the activities of t. In this case, the similarity matrix over the patterns can be computed in linear time (i.e. in O(N×(T +Pmax×S))) with respect to the size of the log (cf. Step C1). Applying algorithm MCL [2] for a preliminary clustering of these Pmax patterns (cf. Step C2) takes O(Pmax×K), where K is a parameter controlling matrix sparsity (precisely, the number of nonzero entries per column) in the computation of matrix squares, which is typically set between 500 and 1500. Step C5 in the loop requires to evaluate the support of all patterns w.r. t. each log trace, which can still be done in O(T +Pmax×S). Assuming that the set P of pattern clusters is stored search-tree-based structure, the following Steps C6-C11 do not augment the complexity, since they can Therefore, a fixed length forward window can be used for each element of a trace, when scanning the log for the computation of L1, which can then be accomplished in O(N×T ). 2We actually represent any size-i (with i > 1) fork (resp. join) pattern as a pair consisting of: (i) the synchronization (resp. splitting) task a shared by all of its constituent edges, and (ii) a bitmap vector encoding the set of tasks that follow (resp. precede) a in the pattern. At iteration i, all the patterns with size equal to i− 1 or i and hinged in the same task are stored in a separate search tree, and kept ordered with respect to their respective bitmap elements.