Computing the concurrency threshold of sound free-choice workflow nets

Workflow graphs extend classical flow charts with concurrent fork and join nodes. They constitute the core of business processing languages such as BPMN or UML Activity Diagrams. The activities of a workflow graph are executed by humans or machines, generically called resources. If concurrent activities cannot be executed in parallel by lack of resources, the time needed to execute the workflow increases. We study the problem of computing the minimal number of resources necessary to fully exploit the concurrency of a given workflow, and execute it as fast as possible (i.e., as fast as with unlimited resources). We model this problem using free-choice Petri nets, which are known to be equivalent to workflow graphs. We analyze the computational complexity of two versions of the problem: computing the resource and concurrency thresholds. We use the results to design an algorithm to approximate the concurrency threshold, and evaluate it on a benchmark suite of 642 industrial examples. We show that it performs very well in practice: It always provides the exact value, and never takes more than 30 milliseconds for any workflow, even for those with a huge number of reachable markings.


Introduction
A workflow graph is a classical control-flow graph (or flow chart) extended with concurrent fork and join. Workflow graphs represent the core of workflow languages such as BPMN (Business Process Model and Notation), EPC (Eventdriven Process Chain), or UML Activity Diagrams.
In many applications, the activities of an execution workflow graph have to be carried out by a fixed number of resources (for example, a fixed number of computer cores). Increasing the number of cores can reduce the minimal runtime of the workflow. For example, consider a simple deterministic workflow (a workflow without choice or merge nodes), which forks into k parallel activities, all of duration 1, and terminates after a join. With an optimal assignment of resources to activities, the workflow takes time k when executed with one resource, time ⌈k/2⌉ with two resources, and time 1 with k resources; additional resources bring no further reduction. We call k the resource threshold. In a deterministic workflow that forks into two parallel chains of k sequential activities each, one resource leads to runtime 2k, and two resources to runtime k. More resources do not improve the runtime, and so the resource threshold is 2. Clearly, the resource threshold of a deterministic workflow with k activities is a number between 1 and k. Determining this number can be seen as a scheduling problem. However, most scheduling problems assume a fixed number of resources and study how to optimize the makespan [11,16], while we study how to minimize the number of resources. Other works on resource/machine minimization [6,5] consider interval constraints instead of the partial-order constraints given by a workflow graph. Following previous work, we do not directly work with workflow graphs, but with their equivalent representation as free-choice workflow Petri nets, which has been shown to be essentially the same model [10] and allows us to directly use a wealth of results of free-choice Petri nets [7]. Fig. 1(a) shows a free-choice workflow net. The actual workflow activities, also called tasks, which need a resource to execute and which consume time are modeled as the places of the net: Each place p of the net is assigned a time τ (p), depicted in blue. Intuitively, when a token arrives in p, it must execute a task that takes τ (p) time units before it can be used to fire a transition. A free choice exists between transitions t 4 and t 6 , which is a representation of a choice node (if-then-else or loop condition) in the workflow.
If no choice is present or all choices are resolved, we have a deterministic workflow such as the one in Fig. 1(b). In Petri net terminology, deterministic workflows correspond to the class of marked graphs. Deterministic workflows are common in practice: in the standard suite of 642 industrial workflows that we use for experiments, 63.7% percent are deterministic. We show that already for this restricted class, deciding if the threshold exceeds a given bound is NPhard. Therefore, we investigate an over-approximation of the resource threshold, already introduced in [4]: the concurrency threshold. This is the maximal number of task places that can be simultaneously marked at a reachable marking. Clearly, if a workflow with concurrency threshold k is executed with k resources, then we can always start the task of a place immediately after a token arrives, and this schedule already achieves the fastest runtime achievable with unlimited resources. We show that the concurrency threshold can be computed in polynomial time for deterministic workflows.
For workflows with nondeterministic choice, corresponding to free-choice nets, we show that computing the concurrency threshold of free-choice workflow nets is NP-hard, solving a problem left open in [4]. We even prove that the problem remains NP-hard for sound free-choice workflows. Soundness is the dominant behavioral correctness notion for workflows, which rules out basic control-flow errors such as deadlocks. NP-hardness in the sound case is remarkable, because many analysis problems that have high complexity in the unsound case can be solved in polynomial time in the sound case (see e.g. [7,1,8]).
After our complexity analysis, we design an algorithm to compute bounds on the concurrency threshold using a combination of linear optimization and statespace exploration. We evaluate it on a benchmark suite of 642 sound free-choice workflow nets from an industrial source (IBM) [9]. The bounds can be computed in a total of 7 seconds (over all 642 nets). On the contrary, the computation of the exact value by state-space exploration techniques times out for the three largest nets, and takes 7 minutes for the rest. (Observe that partial-order reduction techniques cannot be used, because one may then miss the interleaving realizing the concurrency threshold.) The paper is structured as follows. Section 2 contains preliminaries. Sections 3 and 4 study the resource and concurrency thresholds, respectively. Section 5 presents our algorithms for computing the concurrency bound, and experimental results. Finally, Section 6 contains conclusions.

Preliminaries
Petri nets. A Petri net N is a tuple (P, T, F ) where P is a finite set of places, T is a finite set of transitions (P ∩ T = ∅), and F ⊆ (P × T ) ∪ (T × P ) is a set of arcs. The preset of x ∈ P ∪ T is • x def = {y | (y, x) ∈ F } and its postset is We extend the definition of presets and postsets to sets of places and transitions X ⊆ P ∪ T by • X def = x∈X • x and X • def = x∈X x • . A net is acyclic if the relation F * is a partial order, denoted by and called the causal order. A node x of an acyclic net is causally maximal if no node y satisfies x ≺ y.
A marking of a Petri net is a function M : P → N, representing the number of tokens in each place. For a set of places S ⊆ P , we define M (S) def = p∈S M (p). Further, for a set of places S ⊆ P , we define by M S the marking with M S (p) = 1 for p ∈ S and M S (p) = 0 for p / ∈ S. A transition t is enabled at a marking M if for all p ∈ • t, we have M (p) ≥ 1. If t is enabled at M , it may occur, leading to a marking M ′ obtained by removing one token from each place of • t and then adding one token to each place of t • . We denote this by M Convention: Throughout this paper we assume that systems are 1-safe, i.e., we identify "system" and "1-safe system".
Net classes. A net N = (P, T, F ) is a marked graph if | • p| ≤ 1 and |p • | ≤ 1 for every place p ∈ P , and a free-choice net if for any two places p 1 , p 2 ∈ P either Non-sequential processes of Petri nets. An (A, B)-labeled Petri net is a tuple N = (P, T, F, λ, µ), where λ : P → A and µ : T → B are labeling functions over alphabets A, B. The nonsequential processes of a 1-safe system (N, M ) are acyclic, (P, T )-labeled marked graphs. Say that a set P ′′ of places of a (P, T )labeled acyclic net enables t ∈ T if all the places of P ′′ are causally maximal, carry pairwise distinct labels, and λ(P ′′ ) = • t. -The (P, T )-labeled Petri net containing for each place p ∈ P marked at M one place p labeled by p, no other places, and no transitions, belongs to N P(N, M ). -If Π = (P ′ , T ′ , F ′ , λ, µ) ∈ N P(N, M ) and P ′′ ⊆ P ′ enables some transition t of N , then the (P, T )-labeled net Π t = (P ′ ⊎ P , T ′ ⊎{ t }, F ′ ⊎ F , λ⊎ λ, µ⊎ µ), where p ) | p ∈ P }; also belongs to N P(N, M ). We say that Π t extends Π.
We denote the minimal and maximal places of a process Π w.r.t. the causal order by min(Π) and max(Π), respectively.
As usual, we say that two processes are isomorphic if they are the same up to renaming of the places and transitions (notice that we rename only the names of the places and transitions, not their labels). Fig. 2 shows two processes of the workflow net in Fig. 1(a). (The figure does not show the names of places and transitions, only their labels.) The net containing the white and grey nodes only is already a process, and the grey places are causally maximal places that enable t 6 . Therefore, according to the definition we can extend the process with the green nodes to produce another  Fig. 1(a) process. On the right we extend the same process in a different way, with the transition t 4 .
The following is well known. Let (P ′ , T ′ , F ′ , λ, µ) be a process of (N, M ): -For every linearization σ = t ′ 1 . . . t ′ n of T ′ respecting the causal order , the sequence µ(σ) = µ(t ′ 1 ) . . . µ(t ′ n ) is a firing sequence of (N, M ). Further, all these firing sequences lead to the same marking. We call it the final marking of Π, and say that Π leads from M to its final marking. For example, in Fig. 2 the sequences of the right process labeled by t 1 t 2 t 3 t 4 and t 1 t 3 t 2 t 4 are firing sequences leading to the marking M = {p 2 , p 5 , p 7 }.
-For every firing sequence t 1 · · · t n of (N, M ) there is a process (P ′ , T ′ , F ′ , λ, µ) Workflow nets. We slightly generalize the definition of workflow net as presented in e.g. [1] by allowing multiple initial and final places. A workflow net is a Petri net with two distinguished sets I and O of input places and output places such that (a) • I = ∅ = O • and (b) for all x ∈ P ∪ T , there exists a path from some i ∈ I to some o ∈ O passing through x. The markings M I and M O are called initial and final markings of It is well-known that every sound free-choice workflow net is a 1-safe system with the initial marking M I [2,7]. Given a workflow net according to this definition one can construct another one with one single input place i and output place o and two transitions For all purposes of this paper these two workflow nets are equivalent.
Given a workflow net N , we say that a process Π of (N, M I ) is a run if it leads to M O . For example, the net in Fig. 1(b) is a run of the net in Fig. 1

(a).
Petri nets with task durations We consider Petri nets in which, intuitively, when a token arrives in a place p it has to execute a task taking τ (p) time units before the token can be used to fire any transition. Formally, we consider tuples N = (P, T, F, τ ) where (P, T, F ) is a net and τ : P → N.
Definition 2. Given a nonsequential process Π = (P ′ , T ′ , F ′ , λ, µ) of (N, M ), a time bound t, and a number of resources k, we say that Π is executable within We call a function f satisfying (1) a schedule, a function satisfying (1) and (2) a t-schedule, and a function satsifying (1) Intuitively, f (p ′ ) describes the starting time of the task executed at p ′ . Condition (1) states that if p ′ 1 p ′ 2 , then the task associated to p ′ 2 can only start after the task for p ′ 1 has ended; condition (2) states that all tasks are done by time t, and condition (3) that at any moment in time at most k tasks are being executed. As an example, the process in Fig. 1(b) can be executed with two resources in time 6 with the schedule i, p 1 , p 2 → 0; p 3 , p 4 → 1; p 7 , p 6 → 3, and p 8 , Further, we define the minimal execution time t min (Π) = max{f (p ′ )+τ (λ(p ′′ )) | p ′ ∈ max(Π)}. In the process in Fig. 1(b), the schedule f min is the function that assigns i, p 1 , p 2 , p 7 → 0, p 3 , p 4 → 1, p 6 , p 8 → 3, p 9 → 4, and o → 6, and so t min (Π) = 6. We have: can be executed within time t min (Π) with |P ′ | resources, and cannot be executed faster with any number of resources.
Proof. For k ≥ |P ′ | resources condition (3) of Definition 2 holds vacuously. Π is executable within time t iff conditions (1) and (2) hold. Since f min satisfies (1) and (2) for t = t min (Π), Π can be executed within time t min (Π). Further, t min (Π) is the smallest time for which (1) and (2) can hold, and so Π cannot be executed faster with any number of resources. Definition 3. Let N be a workflow net, and let Π be a run of N . The resource threshold of Π, denoted by RT (Π) is the smallest number k such that Π can be executed in time Example 1. We have seen in the previous section that for the process in Fig. 1(b) we have t min (Π) = 6, and a schedule with two resources already achieves this time. So the resource bound is 2. The workflow net of Fig. 1 has infinitely many runs, in which loosely speaking, the net executes t 4 arbitrarily many times, until it "exits the loop" by choosing t 6 , followed by t 7 and t 8 . It can be shown that all processes have resource threshold 2, and so that is also the resource threshold of the net.
In the rest of the section we obtain two negative results about the result threshold. First, it is difficult to compute: Determining if the resource threshold exceeds a given threshold is NP-complete even for acyclic marked graphs, a very simple class of workflows. Second, we show that even for acyclic free-choice workflow nets the resource threshold may not be realized by any online scheduler.

Resource threshold is NP-complete for acyclic marked graphs
We prove that deciding if the resource threshold exceeds a given bound is NPcomplete even for acyclic sound marked graphs. The proof proceeds by reduction from the following classical scheduling problem, proved NP-complete in [17]: Given: a finite, partially ordered set of jobs with non-negative integer durations, and non-negative integers t and k. Decide: Can all jobs can be executed with k machines within t time units in a way that respects the given partial order, i.e., a job is started only after all its predecessors have been finished?
More formally, the problem is defined as follows: Given jobs J = {J 1 , . . . , J n }, where J i has duration τ (J i ) for every 1 ≤ i ≤ n, and a partial order on J , does there exist a function f : J → N such that These conditions are almost identical to the ones we used to define if a nonsequential process can be executed within time t with k resources. We exploit this to construct an acyclic workflow marked graph that "simulates" the scheduling problem. A proof of the following theorem can be found in the Appendix.

Theorem 1. The following problem is NP-complete:
Given: An acyclic, sound workflow marked graph N , and a number k. Decide: Does RT (N ) ≤ k hold?
3.2 Acyclic free-choice workflow nets may have no optimal online schedulers A resource threshold of k guarantees that every run can be executed without penalty with k resources. In other words, there exists a schedule that achieves optimal runtime. However, in many applications the schedule must be determined at runtime, that is, the resources must be allocated without knowing how choices will be resolved in the future. In order to formalize this idea we define the notion of an online schedule of a workflow net N .

Definition 4.
Let N be a Petri net, and let Π and Π ′ be two processes of (N, M ). We say that Π is a prefix of Π ′ , denoted by Π ⊳ Π ′ , if there is a sequence Π 1 , . . . , Π n of processes such that Π 1 = Π, Π n = Π ′ , and Π i+1 extends Π i by one transition for every 1 ≤ i ≤ n − 1.
Let f be a schedule of (N, M ), i.e., a function assigning a schedule to each process. We say that f is an online schedule if for every two runs Π 1 , Π 2 , and for every two prefixes . Intuitively, if Π ′ 1 and Π ′ 2 are isomorphic then they are the same process Π, which in the future can be extended to either Π 1 or Π 2 , depending on which transitions occur. In an online schedule, Π is scheduled in the same way, independently of whether it will become Π 1 or Π 2 in the future. We show that even for acyclic free-choice workflow nets there may be no online schedule that realizes the resource threshold. That is, even though for every run it is possible to schedule the tasks with RT (N ) resources to achieve optimal runtime, this requires knowing how it will evolve before the execution of the workflow. Proposition 1. There is an acyclic, sound free-choice workflow net for which no online schedule realizes the resource threshold.
Proof. Consider the sound free-choice workflow net (N, M I ) of Fig. 3. It has two runs: Π g , which executes the grey and green transitions, and Π r , which executes the grey and red transitions. Their resource thresholds are RT (Π g ) = RT (Π r ) = 3, realized by the following schedules f g and f r in Fig. 4   Indeed, observe that f g and f r execute Π g and Π r within time 5, and even with unlimited resources no schedule can be faster because of the task p 4 , while two or fewer resources are insufficient to execute either run within time 5.
The schedule of (N, M I ) that assigns f g and f r to Π g and Π r is not an online schedule. Indeed, the process containing one single transition labeled by t 1 and places labeled by i, p 1 , p 2 , p 3 is isomorphic to prefixes of Π g and Π r . However, we have f g (p 3 ) = 0 = 1 = f r (p 3 ). We now claim: (a) Every schedule f g of Π g that realizes the resource threshold (time 5 with 3 resources) satisfies f g (p 3 ) = 0.
Indeed, if f g (p 3 ) ≥ 1, then f g (p 5 ) ≥ 3, f g (p 9 ) ≥ 6, and finally f g (o) ≥ 6, so f g does not meet the time bound. (b) Every schedule f r of Π r that realizes the resource threshold (time 5 with 3 resources) satisfies f r (p 3 ) > 0. Observe first that we necessarily have f r (p 4 ) = 0, and so a resource, say R 1 , is bound to p 4 during the complete execution of the workflow, leaving two resources left. Assume f r (p 3 ) = 0, i.e., a second resource, say R 2 , is bound to p 3 at time 0, leaving one resource left, say R 3 . Since both p 1 and p 2 must be executed before p 8 , and only R 3 is free until time 2, we get f r (p 8 ) ≥ 2. So at time 2 we still have to execute p 6 , p 7 , p 8 with resources R 2 , R 3 . Therefore, two out of p 6 , p 7 , p 8 must be executed sequentially by the same resource. Since p 6 , p 7 , p 8 take 2 time units each, one of the two resources needs time 4, and we get f r (o) ≥ 6.
By this claim, at time 0, an online schedule has to decide whether to allocate a resource to p 3 or not, without knowing which of t 3 or t 4 will be executed in the future. If it schedules f (p 3 ) = 0 and later t 4 occurs, then Π r is executed and the deadline of 5 time units is not met. The same occurs if it schedules f (p 3 ) > 0, and later t 3 occurs.

Concurrency threshold
Due to the two negative results presented in the previous section, we study a different parameter, introduced in [4], called the concurrency threshold. During execution of a business process, information on the resolution of future choices is often not available, and further no information on the possible duration of a task (or only weak bounds) are known. Therefore, the scheduling is performed in practice by assigning a resource to a task at the moment some resource becomes available. The question is: What is the minimal number of resources needed to guarantee the optimal execution time achievable with an unlimited number of resources?
The answer is simple: since there is no information about the duration of tasks, every reachable marking of the workflow net without durations may be also reached for some assignment of durations. Let M be a reachable marking with a maximal number of tokens, say k, in places with positive duration, and let d 1 ≤ d 2 ≤ · · · ≤ d k be the durations of their associated tasks. If less than k resources are available, and we do not assign a resource to the task with duration d k , we introduce a delay with respect to the case of an unlimited number of resources. On the contrary, if the number of available resources is k, then the scheduler for k resources can always simulate the behaviour of the scheduler for an unlimited number of resources. Proof. Follows immediately from the fact that for every schedule f of a run of N , there is a schedule g with CT (N ) machines such that g(p) ≤ f (p) for every place p.
In the rest of the paper we study the complexity of computing the concurrency threshold. In [4], it was shown that the threshold can be computed in polynomial time for regular workflows, a class with a very specific structure, and the problem for the general free-choice case was left open. In Section 4.1 we prove that the concurrency threshold of marked graphs can be computed in polynomial time by reduction to a linear programming problem over the rational numbers. In Section 4.2 we study the free-choice case. We show that deciding if the threshold exceeds a given value is NP-complete for acyclic, sound free-choice workflow nets. Further, it can be computed by solving the same linear programming problem as in the case of marked graphs, but over the integers. Finally, we show that in the cyclic case the problem remains NP-complete, but the integer linear programming problem does not necessarily yield the correct solution.

Concurrency threshold of marked graphs
The concurrency threshold of marked graphs can be computed using a standard technique based on the marking equation [15]. Given a net N = (P, T, F ), define the incidence matrix of N as the |P | × |T | matrix N given by: In the following, we denote by M the representation of a marking M as a vector of dimension |P |. Let N be a Petri net, and let M 1 , M 2 be markings of N . The following results are well known from the literature (see e.g. [15]): Since the solutions of M = M I + N · X contain all the reachable markings of (N, M I ), we have ℓ N ≥ CT (N ). Further, using these results above, we obtain: Theorem 2. Let N be a workflow net, and let ℓ N Q and ℓ N Z be the solution of the linear optimization problem (1) over the rationals and over the integers, respectively. We have: In particular, it follows that CT (N ) can be computed in polynomial time for marked graphs, acyclic or not. (The result about acyclic nets is used in the next section.)

Concurrency threshold of free-choice nets
We study the complexity of computing the concurrency threshold of free-choice workflow nets. We first show that, contrary to numerous other properties for which there are polynomial algorithms, deciding if the concurrency threshold exceeds a given value is NP-complete. Proof. A detailed proof can be found in the appendix, here we only sketch the argument. Membership in NP is nontrivial, and follows from results of [1,7]. We prove NP-hardness by means of a reduction from Maximum Independent Set (MIS): Given: An undirected graph G = (V, E), and a number k ≤ |V |. Decide: Is there a set In ⊆ V such that |In| ≥ k and {v, u} / ∈ E for every u, v ∈ In?
Given a graph G = (V, E), we construct a sound free-choice workflow net N G in polynomial time as follows: -For each e = {v, u} ∈ E we add to N G the "gadget net" N e shown in Fig. 5(a), and for every node v we add the gadget net N v shown in Fig. 5  It is easy to see that N G is free-choice and sound, and in the Appendix we show the result of applying the reduction to a small graph and prove that G has an independent set of size at least k iff the concurrency threshold of (N G , M I ) is at least 2|E| + k. The intuition is that for each edge e ∈ E, we fire the transition [e, u] 1 where u / ∈ In, and for each v ∈ In, we fire the transition v 1 , thus marking one of [e, u] 2 or [e, v] 2 for each edge e ∈ E and the place v 2 for each v ∈ In.

Approximating the concurrency threshold
Recall that the solution of problem (1) over the rationals or the integers is always an upper bound on the concurrency threshold for any Petri net (Theorem 2).
The question is whether any stronger result holds when the workflows are sound and free-choice. Since computing the concurrency threshold is NP-complete, we cannot expect the solution over the rationals, which is computable in polynomial time, to provide the exact value. However, it could still be the case that the solution over the integers is always exact. Unfortunately, this is not true, and we can prove the following results: For (b), we can take the workflow net of Fig. 6. It is easy to see that the concurrency threshold is equal to 1. The marking M that puts one token in each of the two places with weight 1, and no token in the rest of the places, is not reachable from M I . However, it is a solution of the marking equation, even when solved over the integers. Indeed, we have M = M I + N · X for X = (1, 0, 1, 1, 0, 0, 1). Therefore, the upper bound derived from the marking equation is 2.

Concurrency threshold: a practical approach
We have implemented a tool 3 to compute an upper bound on the concurrency threshold by constructing a linear program and solving it by calling the mixed-integer linear programming solver Cbc from the COIN-OR project [14]. Additionally, fixing a number k, we used the state-of-the art Petri net model checker LoLA [18] to both establish a lower bound, by querying LoLA for existence of a reachable marking M with conc(M ) ≥ k; and to establish an upper bound, by querying LoLA if all reachable markings M ′ satisfy conc(M ′ ) ≤ k.
We evaluated the tool on a set of 1386 workflow nets extracted from a collection of five libraries of industrial business processes modeled in the IBM Web-Sphere Business Modeler [9]. For the concurrency threshold, we set D = P \ O. These nets also have multiple output places, however with a slightly different semantics for soundness allowing unmarked output places in the final marking. We applied the transformation described in [12] to ensure all output places will be marked in the final marking. This transformation preserves soundness and the concurrency threshold.
All of the 1386 nets in the benchmark libraries are free-choice nets. We selected the sound nets among them, which are 642. Out of those 642 nets, 409 are marked graphs. Out of the remaining 233 nets, 193 are acyclic and 40 cyclic. We determined the exact concurrency threshold of all sound nets with LoLA using state-space exploration. Fig. 7 shows the distribution of the threshold. On all 642 sound nets, we computed an upper bound on the concurrency threshold using our tool, both using rational and integer variables. We computed lower and upper bounds using LoLA with the value k = CT (N ) of the concurrency threshold. We report the results for computing the lower and upper bound separately.
All experiments were performed on the same machine equipped with an Intel Core i7-6700K CPU and 32 GB of RAM. The results are shown in Table 1. Using the linear program, we were able to compute an upper bound for all nets in total in less than 7 seconds, taking at most 30 milliseconds for any single net. LoLA could compute the lower bound for all nets in 6 seconds. LoLA fails to compute the upper bound in three cases due to reaching the memory limit of 32 GB. For the remaining 639 nets, LoLA could compute the upper bound within 7 minutes in total.
We give a detailed analysis for the 9 nets with a state space of over one million. For three nets with state space of sizes 10 9 , 10 10 and 10 17 , LoLa reaches the memory limit. For four nets with state spaces between 10 6 and 10 8 and concurrency threshold above 25, LoLA takes 2, 10, 48 and 308 seconds each. For two nets with a state space of 10 8 and a concurrency threshold of just 11, LoLA can establish the upper bound in at most 20 milliseconds. The solution of the linear program can be computed in all 9 cases in less than 30 milliseconds.

Net size
Analysis time (sec) Comparing the values of the upper bound, first we observed that we obtained the same value using either rational or integer variables. The time difference between both was however negligible. Second, quite surprisingly, we noticed that the upper bound obtained from the linear program is exact in all of our cases, even for the cyclic ones. Further, it can be computed much faster in several cases than the upper bound obtained by LoLA and it gives a bound in all cases, even when the state-space exploration reaches its limit. By combining linear programming for the upper bound and state-space exploration for the lower bound, an exact bound can always be computed within a few seconds.

Conclusion
Planning sufficient execution resources for a business or production process is a crucial part of process engineering [13,3,19]. We considered a simple version of this problem in which resources are uniform and tasks are not interruptible. We studied the complexity of computing the resource threshold, i.e., the minimal number of resources allowing an optimal makespan. We showed that deciding if the resource threshold exceeds a given bound is NP-hard even for acyclic marked graphs. For this reason, we investigated the complexity of computing the concurrency threshold, an upper bound of the resource threshold introduced in [4]. Solving a problem left open in [4], we showed that deciding if the concurrency threshold exceeds a given bound is NP-hard for general sound free-choice workflow nets. We then presented a polynomial-time approximation algorithm, and showed experimentally that it computes the exact value of the concurrency threshold for all benchmarks of a standard suite of free-choice workflow nets. marking M ′ ≥ M I such that M ′ = M I , and so (N , M I ) would not be bounded. It follows that every reachable marking of (N , M I ) is reachable by means of a firing sequence that does not contain t, and so in particular (N, M I ) and (N , M I ) have the same concurrency threshold.
Let M max be a marking witnessing the concurrency threshold of (N , M I ). By the Shortest Sequence Theorem [7], there exists a firing sequence M I σ − → M max such that |σ| ≤ n(n+1)(n+2)/6, where n = |T |. Therefore, the nondeterministic algorithm that guesses a firing sequence of length at most n(n+1)(n+2)/6 steps, and halts if the current marking has at least k tokens in the places of D, runs in polynomial time.
We prove NP-hardness by means of a reduction from Maximum Independent Set (MIS): Given: An undirected graph G = (V, E), and a number k ≤ |V |. Decide: Is there a set In ⊆ V such that |In| ≥ k and {v, u} / ∈ E for every u, v ∈ In?
We illustrate the reduction on the instance of MIS shown in Fig. 9(a), where {v 1 , v 4 , v 5 } is a maximum independent set. Fig. 9(b) shows the result of the reduction. Here we represent the set D by weights of places as for the equation (1). We use the weight 2 for a place p as a compact representation of two places with weight 1 each and the same pre-and postset as p.
Given a graph G = (V, E), we construct a sound free-choice workflow net N G in polynomial time as follows: -For each e = {v, u} ∈ E we add to N G the "gadget net" N e shown in Fig. 8(a), and for every node v we add the gadget net N v shown in Fig. 8(b). -For every e = {v, u} ∈ E, we add an arc from the place [e, v] 4 of N e to the transition v 1 of N v , and from [e, u] 4 to the transition u 1 of N u (see Fig. 9(b)).   It is easy to see that N G is free-choice and sound. For the latter, observe that after firing either [e, v] 1 and [e, v] 3 , or [e, u] 1 and [e, u] 3 , for every edge e ∈ E, the same marking is reached, namely the one putting a token on all the places of the form [x, y] 4 . From this marking we can then fire all the v 1 i transitions to reach the final marking.
We claim that G has an independent set of size at least k iff the concurrency threshold of (N G , M I ) is at least 2|E| + k.
For the first part, assume G has an independent set In ⊆ V . For every e ∈ E let v e be a vertex of e that does not belong to In. Fire the transition [e, v e ] 1 . Let M be the marking so reached. Since In is an independent set, we have M ([e, v] 4 ) = 1 for every v ∈ In and for every edge e containing v. So M enables v 1 for every v ∈ In. Fire transition v 1 of N v for every v ∈ In, reaching the marking M ′ . We then have M ′ ([e, v e ] 2 ) = 1 for every e ∈ E, and M ′ (v 2 ) = 1 for every v ∈ In. So the concurrency threshold of M ′ is at least 2|E|+|In| ≥ 2|E|+k.
For the second part, assume that the concurrency threshold of (N G , M I ) is at least 2|E|+ k. This can only be achieved by a marking M marking exactly one of [e, u] 2 or [e, v] 2 for every e = {u, v} ∈ E, and additionally marking at least k of the places v 2 . We claim that In = v ∈ V | M (v 2 ) = 1 is an independent set. Indeed, in a sequence reaching M , for every e = {v, u} ∈ E only one of [e, v] 4 or [e, u] 4 can become marked, but not both; so no occurrence sequence leading to M contains both v 1 and u 1 , and so M does not mark both v 2 and u 2 . So G has an independent set of size at least k.