Beat Gfeller

Identifying refactoring opportunities in process model repositories

Context: In order to ensure high quality of a process model repository, refactoring operations can be applied to correct anti-patterns, such as overlap of process models, inconsistent labeling of activities and overly complex models. However, if a process model collection is created and maintained by different people over a longer period of time, manual detection of such refactoring opportunities becomes difficult, simply due to the number of processes in the repository. Consequently, there is a need for techniques to detect refactoring opportunities automatically. Objective: This paper proposes a technique for automatically detecting refactoring opportunities. Method: We developed the technique based on metrics that can be used to measure the consistency of activity labels as well as the extent to which processes overlap and the type of overlap that they have. We evaluated it, by applying it to two large process model repositories. Results: The evaluation shows that the technique can be used to pinpoint the approximate location of three types of refactoring opportunities with high precision and recall and of one type of refactoring opportunity with high recall, but low precision. Conclusion: We conclude that the technique presented in this paper can be used in practice to automatically detect a number of anti-patterns that can be corrected by refactoring.

A randomized distributed algorithm for the maximal independent set problem in growth-bounded graphs

The efficient distributed construction of a maximal independent set (MIS) of a graph is of fundamental importance. We study the problem in the class of Growth-Bounded Graphs, which includes for example the well-known Unit Disk Graphs. In contrast to the fastest (time-optimal) existing approach [11], we assume that no geometric information (e.g., distances in the graphs embedding) is given. Instead, nodes employ randomization for their decisions. Our algorithm computes a MIS in O(log log n • log* n) rounds with very high probability for graphs with bounded growth, where n denotes the number of nodes in the graph. In view of Linials Ω(log* n) lower bound for computing a MIS in ring networks [12], which was extended to randomized algorithms independently by Naor [18] and Linial [13], our solution is close to optimal. In a nutshell, our algorithm shows that for computing a MIS, randomization is a viable alternative to distance information.

Towards optimal range medians

We consider the following problem: Given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which needs O(nlogk+klogn) time to answer k such median queries. This improves previous algorithms by a logarithmic factor and matches a comparison lower bound for k=O(n). The space complexity of our simple algorithm is O(nlogn) in the pointer machine model, and O(n) in the RAM model. In the latter model, a more involved O(n) space data structure can be constructed in O(nlogn) time where the time per query is reduced to O(logn/loglogn). We also give efficient dynamic variants of both data structures, achieving O(log^2n) query time using O(nlogn) space in the comparison model and O((logn/loglogn)^2) query time using O(nlogn/loglogn) space in the RAM model, and show that in the cell-probe model, any data structure which supports updates in O(log^O^(^1^)n) time must have @W(logn/loglogn) query time. Our approach naturally generalizes to higher-dimensional range median problems, where element positions and query ranges are multidimensional-it reduces a range median query to a logarithmic number of range counting queries.

Counting targets with mobile sensors in an unknown environment

We consider the problem of counting the number of indistinguishable targets using a simple binary sensing model. Our setting includes an unknown number of point targets in a (simply- or multiply-connected) polygonal workspace, and a moving point-robot whose sensory input at any location is a binary vector representing the cyclic order of the polygon vertices and targets visible to the robot. In particular, the sensing model provides no coordinates, distance or angle measurements. We investigate this problem under two natural models of environment, friendly and hostile, which differ only in whether the robot can visit the targets or not, and under three different models of motion capability. In the friendly scenario we show that the robots can count the targets, whereas in the hostile scenario no (2 - Ɛ)-approximation is possible, for any Ɛ > 0. Next we consider two, possibly minimally more powerful robots that can count the targets exactly.

Towards Optimal Range Medians

We consider the following problem: given an unsorted array of n elements, and a sequence of intervals in the array, compute the median in each of the subarrays defined by the intervals. We describe a simple algorithm which uses O (n ) space and needs O (n logk + k logn ) time to answer k such median queries. This improves previous algorithms by a logarithmic factor and matches a lower bound for k = O (n ). Since, in contrast to previous approaches, the algorithm decomposes the range of element values rather than the array, it has natural generalizations to higher-dimensional problems --- it reduces a range median query to a logarithmic number of range counting queries.

A Distributed Algorithm for Finding All Best Swap Edges of a Minimum-Diameter Spanning Tree

Communication in networks suffers if a link fails. When the links are edges of a tree that has been chosen from an underlying graph of all possible links, a broken link even disconnects the network. Most often, the link is restored rapidly. A good policy to deal with this sort of transient link failures is swap rerouting, where the temporarily broken link is replaced by a single swap link from the underlying graph. A rapid replacement of a broken link by a swap link is only possible if all swap links have been precomputed. The selection of high-quality swap links is essential; it must follow the same objective as the originally chosen communication subnetwork. We are interested in a minimum-diameter tree in a graph with edge weights (so as to minimize the maximum travel time of messages). Hence, each swap link must minimize (among all possible swaps) the diameter of the tree that results from swapping. We propose a distributed algorithm that efficiently computes all of these swap links, and we explain how to route messages across swap edges with a compact routing scheme. Finally, we consider the computation of swap edges in an arbitrary spanning tree, where swap edges are chosen to minimize the time required to adapt routing in case of a failure, and give efficient distributed algorithms for two variants of this problem.

A faster distributed approximation scheme for the connected dominating set problem for growth-bounded graphs

We present a distributed algorithm for finding a (1 + Ɛ)- approximation of a Minimum Connected Dominating Set in the class of Growth-Bounded graphs, which includes Unit Disk graphs. In addition, the computed Connected Dominating Set guarantees a constant stretch factor on the length of a shortest path with respect to the original graph and induces a subgraph of constant degree. The nodes do not require any positioning or distance information. The algorithm runs in O(TMIS+1/ƐO(1) ċ log* n)synchronous rounds, where TMIS is the time for computing a Maximal Independent Set (MIS) in the network graph. Using the fastest known deterministic algorithm for computing a MIS, the total running time is O((logΔ+1/ƐO(1)) ċ log* n), where Δ is the maximum degree of the network graph. If one allows randomization, the running time reduces to O((log log n+1/ƐO(1))ċ log* n) rounds.

A distributed algorithm for finding all best swap edges of a minimum diameter spanning tree

Communication in networks suffers if a link fails. When the links are edges of a tree that has been chosen from an underlying graph of all possible links, a broken link even disconnects the network. Most often, the link is restored rapidly. A good policy to deal with this sort of transient link failures is swap rerouting, where the temporarily broken link is replaced by a single swap link from the underlying graph. A rapid replacement of a broken link by a swap link is only possible if all swap links have been precomputed. The selection of high quality swap links is essential; it must follow the same objective as the originally chosen communication subnetwork. We are interested in a minimum diameter tree in a graph with edge weights (so as to minimize the maximum travel time of messages). Hence, each swap link must minimize (among all possible swaps) the diameter of the tree that results from swapping. We propose a distributed algorithm that efficiently computes all of these swap links, and we explain how to route messages across swap edges with a compact routing scheme.

Finding longest approximate periodic patterns

Motivated by the task of finding approximate periodic patterns in real-world data, we consider the following problem: Given a sequence S of n numbers in increasing order, and α ∈ [0, 1], find a longest subsequence Τ = s1, s2,..., sk of numbers si ∈ S, ordered as in S, under the condition that maxi=1,...,k-1{si+1-si}/ mini=1,...,k-1{si+1-si}, called the period ratio of Τ, is at most 1+α. We give an exact algorithm with run time O(n3) for this problem. This bound is too high for large inputs in practice. Therefore, we describe an algorithm which approximates the longest periodic pattern present in the input in the following sense: Given constants α and e, the algorithm computes a subsequence with period ratio at most (1+α)(1+e), whose length is greater or equal to the longest subsequence with period ratio at most (1+α). This latter algorithm has a much smaller run time of O(n1+γ), where γ > 0 is an arbitrarily small positive constant. As a byproduct which may be of independent interest, we show that an approximate variant of the well-known 3SUM problem can also be solved in O(n1+γ + Tsort(n)) time, for any constant γ > 0, where Tsort(n) is the time required to sort n numbers.

Faster Or-Join Enactment for BPMN 2.0

We propose an efficient algorithm that enacts the control-flow of BPMN, in particular the inclusive Or-join gateway. The original algorithm for enacting Or-joins in BPMN 2.0 needs, upon each token move in the diagram, linear time in the number of edges of the diagram to find out whether a given Or-join is enabled, whereas our proposal essentially needs only constant time to do so.