Conditional Schedules for Processes with Temporal Constraints

Temporal aspects are among the most important quality criteria for executing business processes. It is mandatory to check process definitions at design time for temporal properties to avoid that structural properties of process models cause time failures at run-time. Here, we propose to check process models for conditional controllability and to compute conditional schedules for their execution without time failures. Schedules have to be conditional, since it is a characteristics of business processes, that control flow decisions are based on conditions, which can only be evaluated in the course of process execution at run-time and not before the process starts. We present a procedure for checking the conditional controllability of processes with temporal constraints, which is both sound and complete and effectively and efficiently computes conditional schedules for temporally constrained business processes.


Introduction
Processes have been successfully introduced for modeling the dynamics in many areas like trade, production, health care, etc. in various forms like workflows [23], extended transactions [29], business processes [13], web-service orchestrations [11], distributed workflows [22], etc. In many of these application areas, temporal aspects are crucial for the correct and admissible execution of processes. This observation led to a substantial body of research to master the plenitude of temporal aspects of process engineering: expressing temporal aspects in process models, formulating different notions of correctness of process models with temporal constraints, checking the temporal correctness of process definitions, computing execution schedules for processes, recognizing and handling temporal exceptions, and supporting process controllers to adhere to temporal constraints at run-time with proactive time management (see [5,20,25] for overviews).
What is the right correctness criterion for temporally constrained processes? Satisfiability, or conformance [10,17] turned out to be not sufficient, respectively, not strong enough, because satisfiability only checks, whether there exists an execution of the process without time failures. However, the execution might depend on factors, which cannot be influenced by the process controller. Hence the process controller cannot guarantee that the execution will be free of time failures. Therefore, the notion of controllability of process definitions [10,36] gained support. In a nutshell: the concept of controllability regards a process definition as correct, if it is possible to state a schedule such that all temporal constraints are obeyed, if all process steps are executed within the intervals defined in the schedule [9]. Controllability guarantees a correct execution for all foreseeable circumstances. Nevertheless, strict controllability is quite restrictive, such that more relaxed notions were developed, which still hold the guarantee. Conditional controllability (also called history dependent controllability [10,14]) allows that the execution interval for a step in a conditional schedule depends on the observations of flow decisions, if these flow decisions happen before the activation of this step. Dynamic controllability relaxes this notion even further and requires that there is an execution strategy for a process controller to make decisions based on all observations (flow decisions and observed duration of activities) temporally prior to the enactment of an activity such that no temporal constraint is violated. Similar problems where studied in the area of AI and in the area of constraint satisfaction in form of temporal constraint networks of different flavors as described in [8].
Several algorithms for checking controllability resp. dynamic controllability of process definitions with several sets of temporal constraints have been proposed for different flavors of process models, e.g., [2,3,6,8,15,26,27,30,37]. Nevertheless, an algorithm which is computationally feasible, both sound and complete and effectively computes a conditional schedule was still missing. It is the ambition of this paper to contribute to closing this gap. We build on our earlier approaches for checking the correctness of temporal process specifications and the computation of execution plans (schedules) [17][18][19]21]. This paper is based on [14] and extends it with several optimizations of the algorithms reducing the average case complexity, increasing practical scalability and improving the performance of computing conditional schedules.
We present our methods with a seemingly rather simple model for defining processes with temporal constraints: we only consider contingent nodes and upper-bound constraints on end-events of activities. This is, however, without loss of generality, as it does not cause any restriction of the expressiveness. We can show, that our lean process model is expressive enough to also express non-contingency of activities, lower-bound constraints, constraints on the start-events of activities, and contingent and non-contingent constraints on links between activities [16].
The particular contributions of this paper are: -We provide a formalization of conditional controllability.
-We propose a procedure for checking the conditional controllability of temporally constrained process definitions and proof that it is both sound and complete. -This algorithm also computes a conditional schedule.
-We proof that the problem of computing a conditional schedule for a temporally constrained process has exponential complexity in the worst case. -We provide optimizations for computing conditional schedules where the complexity corresponds to the intricacy of mutually influencing temporal constraints and structural characteristics.
The rest of this paper is organized as follows: first, we define our process modelling notation. Given that, we introduce schedules and controllability, and in the next section, we present an algorithm for computing schedules. In the following section, we introduce conditional schedules and conditional controllability and the notion of an unfolded graph, and we show the relationship between conditional controllability and the controllability of an unfolded process. After that, we analyse the complexity of conditional schedules. In the following section, we show an improved algorithm for checking conditional controllability with a partially unfolded process graph. Later we present an implementation and report on a series of experiments with the proposed algorithms. In the last sections, we contrast our approach to related work and draw some conclusions.

Process Model with Temporal Constraints
We consider here a minimal but quite expressive process model: we focus on the standard minimum workflow control patterns [35]: acyclic workflow nets composed of nodes and edges. Some of the nodes are XOR-splits and -joins. All other nodes contain implicitly AND-splits and -joins. XOR-splits have exactly 2 outgoing and XOR-joins 1 or 2 incoming nodes. XOR-joins have the semantics of simple merge, i.e., it is not possible that more than predecessors of an XOR-join node will be executed in a single process instance. For all nodes with the exception of XOR-splits: if there are several successor nodes, then the semantics is that of an (implicit) AND-split. For all nodes with the exception of XOR-joins: if there are several predecessors the semantics is that of an AND-join. This definition of a process graph is a relaxation of the usual workflow net definitions [34] and it is easy to see that all traditional workflow nets can easily be expressed in this formalism. Nevertheless, we introduce the model below, as it makes the transformations we propose in the following sections for checking controllability a lot easier and more comprehensive and does not require to introduce an additional model for the result of unfolding operations.
In addition, we consider the following temporal information and constraints: minimum and maximum duration of nodes, and upper-bound constraints. See Fig.1 as an example for such a process with labels, discussed below. Activities are represented as rectangles with their activity name (e.g., G, their minimum and maximum duration (e.g., 5..8) and their labels (e.g.,{p, ¬p} . XOR-split nodes are represented as diamonds, XOR-join nodes as shaded diamonds. Upper-bound constraints are represented as dashed arrows from destination to source. Temporal aspects are represented by durations and time points in form of real numbers, where all durations have to be greater or equal 0. Time points are represented as distance to a time origin (here usually the time point of the start of a process). Activity instances start at a certain time point (time point for the start event of an activity instance) and end at a certain time point (end event); their distance is the duration of an activity instance.
In the following we only consider contingent activities. The duration of contingent activities can only be observed by the process controller, but not influenced. The process controller can only rely on the actual duration being between the minimum and maximum duration specified.
In analogy to [8], we use propositional labels for nodes to indicate through which path(s) a node can be reached, SN Computer Science i.e., which decisions were taken to reach a node. In contrast to [8], we define a label as a set of different possible decisions which can lead to the considered node. We formally define the basis for representing these paths and for comparing these paths below.
Definition 1 (Propositional Terms) Let L be a set of propositional letters. Let p ∈ L : then p and ¬p are literals, L is the set of all literals over L. Let l 1 , … l n be literals, then l 1 ∧ ⋯ ∧ l n are conjunctive terms.
We call t a minterm over a set of letters L, if t is a conjunctive term over the set of literals L and for each p ∈ L either p or ¬p appears in t. M(L) is the set of all minterms over L.
Let T = T 1 , … T n be sets of conjunctive terms over L . We define the cross conjunction of T as We assign a unique propositional letter p to each XORsplit and adorn one outgoing edge of the split node with p, the other with ¬p . The labels, we assign to the nodes, are sets of conjunctive terms over the propositional letters of predecessors of these nodes. Each term in the label of a node represents a different path to reach this node. In other terms it represents all possible combinations of decisions at XOR-split nodes leading to this node. In the following we define the representation of the model in form of a process graph formally. A node n has the following properties: Type: n.type ∈ {node, xs, xj} , where xs represents Xorsplit and xj Xor-join.
A n e d g e e ∈ E h a s t h e p r o p e r t y e.l ∈ {True} ∪ L ∪ {¬l|l ∈ L}.
Constraints: B consist of upper-bound constraints, (s, d, ) representing the constraint d ≤ s + , where s ∈ N is called the source and d ∈ N is called the destination node, and ≥ 0 is some real.
The function x.l assigns a unique propositional letter p ∈ L to each Xor-split node x ∈ N . For each Xor-split node x there are two outgoing edges e 1 and e 2 in E with e 1 .l = x.l and e 2 .l = ¬x.l . All other edges have the label True.
A process graph has 1 start node, which has no predecessor and at least 1 stop node which has no successor. There is a path from the start node to every stop node. Every node is on a path from the start node to a stop node. A node of type xs has exactly 2 successor nodes, a node of type xj can have one or two predecessor nodes. E + denotes the transitive closure of E. For a node n, n.Pred denotes the set of all direct predecessors of n: n.Pred ∶= {m|∃(m, n) ∈ E} , and n.Succ the set of all direct successors of n: n.Succ ∶= {m|∃(n, m) ∈ E} . n.Pred + denotes the set of all (direct or indirect) predecessors of n: n.Pred + ∶= {m|∃(m, n) ∈ E + } , and n.Succ + is the set of all successor of n: n.Succ + ∶= {m|∃(n, m) ∈ E + }.
The label of a node n is defined as ( It is easy to see that every well formed workflow net [34] can be represented as process graph according to the definition above. Figure 1 shows an example for a process graph with labels. The activities are represented as rectangles with their names, minimum and maximum duration, and labels. White diamonds represent XOR-split nodes and black diamonds XOR-join nodes. Upper-bound constraints ubc(s, d, ) are shown as dotted arcs from destination d to source node s with the label .
To avoid questionable process definitions with impossible paths, ill defined joins and void constraints we define requirements for well-formed process graphs: for simplemerge XOR-joins it must not happen that both of its predecessor are executed in a single instance, i.e. the predecessors of an XOR-join node must have disjoint labels. If a node has several predecessors (implicit And-join) all these predecessors have equivalent labels. For all nodes except (except XOR-join nodes) we require that their predecessors are not mutually exclusive, i.e., False must not appear in labels of nodes. The stop nodes are mutually exclusive. And finally, for source and destination nodes of an upper bound constraint there has to be the possibility for an instance of the process in which both are activated -requiring that their labels are compatible.

Definition 3 (Well-Formed Process Graph) A process graph P(N, E, B, L) is well-formed, iff
(1) ∀n, n 1 , n 2 ∈ N ∶ n.type = xj, n 1 ≠ n 2 , (n 1 , n), (n 2 , n) ∈ E ⇒ n 1 .L ∧ n 2 .L → False , and (2) ∀n ∈ N ∀p ∈ n.L ∶ p ≠ False , and In the following, we assume that all process graphs are well-formed. Below we formalize some properties of well formed process graphs which we will need later. The first observation is that the terms in the label of a node are pairwise disjoint.

Proof Follows from Definitions 2 and 4. ◻
The next lemma states that for all nodes except XOR-join nodes, the label implies the label of the predecessor nodes.
Proof Follows from Definition 4(2): if the labels of the predecessor of a node are incompatible, then the cross product of their labels would contain False, which is a contradiction to P being well-formed. ◻ We define 2 nodes as parallel if they can be both in one run, but neither is successor of the other. (1) ∃a ∈ N, a.type ≠ xs, n, m ∈ a.Succ + ,

Proof
(1) If n and m are not successors in one way or the other, and they are not mutually exclusive, they they must have a common ancestor, which is not an XOR-split node, since all nodes are successors of the start node. (2) Definition 4(3) requires that both have a common successor, which is not an XOR-join, and then, the lemma follows from Lemma 2. (3) The immediate successors of a node which is not an XOR-split-node have the same labels. Parallel successors of a node can only have those propositional letters in their labels in common, which are already in the letter of their common predecessor (there cannot be the same XOR-split node between n resp. m and their closest common predecessor node. Hence, (3) follows from Lemmas 1 and 2. ◻ The lemma above states that if 2 nodes are not successors or mutually exclusive then they can both appear in a run independent of the path by which they are reached.

Schedules and Controllability
Now, we can define the semantics of the temporal constraints by defining which possible execution scenarios (traces with time stamps) are considered as correct. Then we define schedules as a definition of admissible intervals for the start and end events of the nodes in a process graph. Based on these definitions, we can define the properties of controllability and dynamic controllability as notions of the correctness of a process definition with temporal constraints.

SN Computer Science
Definition 5 (Scenario) A scenario S for a process P(N, E, B, L) associates each n ∈ N : with 2 timestamps t s and t e , the time points of the start and end events of a process instance.
Definition 6 (Valid Scenario) A scenario S for a process P(N, E, B, L) is valid, iff the following constraints hold: A schedule defines execution intervals for activities.
Definition 7 (Schedule) A schedule S for a process P(N, E, B, L) associates each n ∈ N with (F s , T s ) and (F e , T e ) , execution intervals for start and end events. We write (n, (F s , T s ), (F e , T e ) ∈ S for a schedule entry.
In this definition F s (From start) represents the earliest time point for starting node n, T s (To start) the latest time point for starting n, and F e (From end) the earliest time point for finishing n, and finally T e (To end) the latest time point for finishing n.
The property of controllability of a process requires that there is a schedule for the process, such that all scenarios are valid, for which the time-stamps of the scenarios are taken from the respective intervals of this schedule. In the following, we will call a schedule with such a property controllability schedule.

Definition 8 (Controllability) A process P(N, E, B, L)
is controllable, iff it has a schedule S (controllability schedule), such that each scenario S for P is valid, if ∀n n.F s ≤ n.t s ≤ n.T s and n.F e ≤ n.t e ≤ n.T e . This definition of controllability leads to rather rigid schedules as controllability schedules, in which the start of each activity is fixed to a single point in time instead of a time interval. In practice, for some activities, an interval is expected. Nevertheless, we follow here the usual definitions, which are sufficient for theoretical considerations on controllability and conditional controllability. This more rigid definition is also easier and does not cause a loss of generality. However, we consider that the definition of controllability can be relaxed to allow more flexible schedules without sacrificing the notion and the check-ability of controllability, and our definition of schedule already cares for these less rigid definitions.

Lemma 4
In each controllability schedule n.F s = n.T s has to hold for all nodes n.
Proof If n starts at T s then it has to finish before T s + n.d max ; if it starts at F s , then it could finish at F s + d or later. Hence, n.d ≤ F e − T s ≤ T e − F s ≤ n.d max , or n.T s + n.d max ≤ n.T e ≤ n.F s + n.d max can only be satisfied if n.T s = n.F s and n.T e = n.F s + n.d max has to hold, which is only possible, if T s = F s ◻ Next, we define, when we regard a schedule as correct. As might be expected, we are able to proof, that correct schedules imply controllability.
In this definition, the last item requires that the end event of the destination node m is at most time units after the end event of the source node n, if there is an instance type which contains both n and m. This is the case, if the labels of n and m are not contradictory ( n.L ≃ m.L ). If no instance type contains both source and destination node (their labels are contradictory), then the upper-bound constraint is trivially satisfied.

Lemma 5 (Controllability Schedule) A process is controllable, iff it has a correct schedule.
Proof That a correct schedule fulfills all requirements of a controllability schedule follows immediately from the definitions. In the other direction: it is easy to see that each controllability schedule is correct. ◻ All time points and durations in the definition of a temporally constrained process are always relative to the process start. If a schedule exists for a process, we can shift the schedule as long as we maintain the relative position of each event, i.e. we can add an integer to all start-and endtimes. Therefore, if a schedule exists, actually a manifold of schedules exist, in particular one, where the start time of the process is 0. Proof Let S be a correct schedule, let n ∈ N , let (n, ( s , s ), ( � , �� )) ∈ S . Then, S 0 n is derived from S by adding − s to all From and To values in S. S 0 n is a correct schedule, because adding a scalar is an equivalence transformation for the inequalities of Definition 9 and n.Fs = n.Ts = 0 . □ With this lemma, we know that it is sufficient to check whether a schedule exists in which the start node of the process starts at time point 0.

Computation of Schedules
In this section we combine the checking, whether a process is controllable, with the actual computation of a correct schedule for a process. For the rest of this section we assume that a process has a deadline ( ), i.e., an upper-bound constraint from the start node to all end nodes of the process. In [14] we presented an algorithm without this assumption, which splits up a process graph into cliques (strong connected components), computes a schedule for each clique and then stitches together a complete schedule from these component schedules. In this paper, we essentially assume the whole process graph is one clique by assuming a deadline. However, with reference to [14], we claim that this is without loss of generality.
For computing a schedule for a temporally constrained process we use an intermediary structure called schedule frame (formerly also known as (unfolded) timed graph [14,18,19]). The schedule frame of a process P has the same structure as P, but has additional attributes for each node. Figure 2 shows the schedule frame for the process of Fig. 1. Activities are represented as rectangles with their activity name (e.g., G, their minimum and maximum duration (e.g. 5..8) and their labels (e.g., {p, ¬p} . XOR-split nodes are represented as diamonds, XOR-join nodes as shaded diamonds. Upper-bound constraints are represented as dashed arrows from destination to source. Each node shows the name of the activity, and the minimum and maximum duration in the top line. Below the values for E b , L b , E w , andL w are given. In a schedule frame we consider intervals for the end event of each node x for each term in x.L. We will show later that all entries of a 0-schedule have to be within these intervals. The intervals are defined in terms of E-and L-values. A node n of the schedule frame cannot finish before n.E b (Earliest time point best case), if all contingent activities up to n finish at their minimum duration. It cannot finish before n.E w (Earliest time point worst case), if they take their maximum duration. The L-values represent time points when a node has to finish at the latest, to satisfy all temporal constraints: if n finishes before n.L b all constraints are satisfied, if all succeeding contingent activities only take their minimum duration; if n finishes before n.L w all constraints are satisfied, even if all succeeding activities use their maximum duration.
is a schedule frame for a process P(N, E, L, B) with each n ∈ N associated with intervals for end events of activities: We now analyze the relationship between a schedule frame and a schedule. It is easy to see that a schedule frame is more general than a schedule. However, as we

Lemma 7 A temporally constrained process graph has a correct schedule, iff it has correct schedule frame.
Proof Algorithm 1 (CompS) computes a schedule from a correct schedule frame. We can show that this schedule frame is correct by checking all conditions of Definition 9 assuming the conditions of Definition 10 to hold. On the other hand, the values of a correct schedule can be immediately used for a correct schedule frame by setting n.E b = n.E w = n.F e and n.L b = n.L w = n.F s for each n. ◻ The procedure of computing a correct schedule frame (Algorithm 2) consists of the following steps. First, we initialize the temporal values of the schedule frame: the E values of all nodes are set to 0, and the L values of all nodes are set to the deadline (for ubc (start, end, ) ). Then we compute the schedule frame according to the structural constraints defined by the topology of the graph by forward calculation of E values and backward calculation of L values. Then we check all upper-bound constraints. If an upperbound constraint is violated, we incorporate it by increasing the E values of the source node and/or the L values of the destination node. This procedure is repeated, until all constraints are satisfied, or there is a node n, for which the invariant n.E < n.L is violated and hence no solution exists. This algorithm is an adaption of the algorithms presented in [19] to also deal with contingent activities. n.E b , E w := 0; L b , L w := Ω 6: end for 7: while not ok do 8: ok:= true 9: for all n ∈ N in a topological order do 10: {forward calculation} 11: n. 13: if n.L w < n.E w then 14: return False   Figure 2 shows the schedule frame for the our example in Fig. 1 with the E and L values of each node after CompTG finished successfully.
The next theorem states that the CompTG procedure is sound and complete, which means that if there is a correct schedule for a temporally constrained process then the procedure will compute a correct schedule and return TRUE, and if there is no correct schedule for the process it will return FALSE.

Theorem 1 CompTG (Algorithm 2) is sound and complete in the sense that (a) if it returns TRUE then the computed schedule frame is correct, and (b) if it returns FALSE then there is no correct schedule frame.
Proof Soundness can be easily shown as in CompTG all conditions for a correct schedule frame are either checked explicitly in the algorithm or are ensured by the assignments in the forward and backward calculations.
◻ For showing completeness we refer to Lemma 6 and the overall deadline such that no correct schedule entry can have a value outside the interval [0, ] can be valid. Hence the schedule frame is correctly initialized. Furthermore, we observe that for every node every execution interval of a correct conditional 0-schedule has to be within the interval of E and L values with which the schedule frame is initialized. In addition, it is easy to show that the requirements of correctness for a conditional schedule are more strict than for a correct schedule frame. The forward resp. backward calculations set the E values resp. L values to the lowest resp. greatest values that satisfy the conditions (1) to (5) of Definition 10. The algorithm iteratively checks all temporal constraints. If an inequality in the definition of a constraint is violated the algorithm sets the E values to the smallest and L values to the greatest values such that this inequality is satisfied and thus computes the largest interval which avoids this violation. So if the algorithm cannot compute a correct schedule frame, there is no correct schedule frame (and hence also no correct conditional schedule). ◻ With this theorem, we can conclude that applying the CompTG procedure to a temporally constrained process with a deadline is a sound and complete algorithm for checking its controllability.

Conditional Schedules and Conditional Controllability
As discussed above, a process is controllable if it admits a schedule. This notion is known to be too restrictive [17,27] and therefore, the notion of a history-dependent or conditional schedule was introduced [10, 14,17], which offers the possibility to define the execution intervals for a node depending on past decisions or observations. In the definition of conditional controllability, we use here, the execution interval of a node might depend on the observed outcomes of XOR-splits preceding this node. There are other more general definitions of dynamic controllability [3,8,27], which allow all information (in particular start and end time of contingent activities), which temporally precedes the node, can be used by a node to define its allowed time interval. Now, we can define the semantics of the temporal constraints by defining, which possible execution scenarios (traces with time stamps) are considered as correct. A conditional scenario takes into account that not every node of the process appears in every process instance due to XORsplits. The possible combinations of nodes are determined by any possible combination of decisions which are in turn represented by all minterms over the propositional letters of the process definition. In such a conditional scenario a node n can have different time points for different minterms. A conditional scenario is valid, if each of its scenario projections (defined by a particular minterm) is a valid scenario. P(N, E, L, B) associates for each t ∈ M(L) each n ∈ N with t → n.L with 2 timestamps t s and t e , the time points of the start and end events of a process instance. We call (t, n, t s , t e ) ∈S a scenario entry.
In a conditional schedule, the execution interval for a node n in the process graph may depend only on the decisions taken before the execution of n. The decisions are observed by monitoring which outgoing edge of XOR split nodes preceding n were taken, resp. which successors of an XOR-split were enabled. Therefore, different paths to a node n might lead to different execution intervals for n. The label of a node n in a process graph P exactly contains the different possibilities for reaching this node. So in a conditional schedule we assign (possibly different) execution intervals to each node for each of the terms in its label. As it is possible to assign the same execution interval for different paths leading to a node, we use a more compact representation and allow the disjunction of label elements in the definition of schedule entries.

Definition 12 (Conditional Schedule)
A conditional schedule S for a process graph P (N, E, L, B) is a set of schedule entries {(n, q, (F s , T s ), (F e , T e ))} which associate each n ∈ N and a propositional term q with intervals for the start and end events of n, such that for each n ∈ N and for each p ∈ n.L ∃(n, q, (F s , T s ), (F e , T e )) ∈ S with p → q and for each (n, q, (F s , T s ), (F e , T e )) ∈ S there is a set {p 1 , … , p i } ⊆ n.L with q ≡ p 1 ∨ ⋯ ∨ p i . The definition of conditional controllability requires that a conditional schedule exists such that each scenario is valid, if its time points are within the limits of the execution intervals defined in the conditional schedule.

SN Computer Science
Definition 13 (Conditional Controllability) A process graph P (N, E, L, B) is conditionally controllable, iff it has a conditional schedule S such that each conditional scenario S is valid, if for each minterm t for each scenario entry (t, n, t s , t e ) ∈S for (n, p, (F s , T s ), (F e , T e )) ∈ S with t → p : This definition is well formed since each minterm t implies at most one term in the label of a node, as all terms in a label are pairwise disjoint (Lemma 1).

Lemma 8 A process is conditionally controllable, iff it has a correct conditional schedule.
Proof From Definitions 12, 13, and 14 we can easily see, that a correct conditional schedule fulfills all requirements of a controllability conditional schedule. In the other direction: each controllability conditional schedule is correct as it satisfies all conditions of Definition 14. ◻ If a process admits a correct conditional schedule, then for all nodes n it also admits a correct schedule where the node n starts at time point 0.
Lemma 9 (Conditional 0-Schedule) If there is a correct conditional schedule S for P (N, E, L, B), then for each n ∈ N there is a correct conditional schedule S 0 n with n.F s = n.T s = 0.
Proof Let S be a correct conditional schedule for a process P (N, E, L, B), let n ∈ N , let (n, p, ( s , s ), ( � , �� )) ∈ S . Then , S 0 n is derived from S by adding − s to all From and To values in S. S 0 n is a correct conditional schedule since addition of scalars is an equivalence transformation for the inequalities of Definition 14 and n.Fs = n.Ts = 0 . ◻ The major difference between a schedule and a conditional schedule is that a conditional schedule can assign different start times to a node in the process graph, depending on the different paths by which this node can be reached.
We now define an unfolded process graph (shown in Fig. 3) which separates all these paths by duplicating a node, if it can be reached by several paths. The unfolded process graph is equivalent to the original process graph in that it admits exactly the same set of traces as the original graph but separates the possible traces.
In an unfolded process each node of the source process has a copy for each term in its label and the edges are wired accordingly, if the predecessor has a compatible label. In an unfolded graph each XOR-join node has exactly 1 predecessor.

Definition 15 (Unfolded Graph) U(N, E, L, B)
is an unfolded processes graph for a process Essentially, an unfolded process graph can be constructed by duplicating all XOR-join nodes, which have more than one predecessor, and all their successors.
is a well-formed process, then its unfolded process U (N, E, L, B) is a well formed process.
Proof Let a process graph P(N � , E � , L, B � ) be well formed. Its unfolded process graph is well formed (Definition 4) as (1) in U each xj-node has only 1 predecessor holds since p ≃ q according to Definition 15. ◻ Now we can show the relationship between unfolding, schedules and conditional schedules:

Theorem 2 A process graph is conditionally controllable, iff its unfolded graph is controllable.
Proof Let P(N � , E � , L, B � ) be process,and U(N, E, L, B) its unfolded process. If P is conditionally controllable, it has a conditional schedule S ′ . It is easy to see that S = {((n, p), (F s , T s ), (F e , T e ))|(n, p, (F s , T s ), (F e , T e )) ∈ S} is a correct schedule for U, hence U is controllable. The other direction follows in analogy. ◻ Figure 3 shows the schedule frame for the unfolded process graph of Fig. 1

Problem Complexity
In this section, we study the complexity of the problem of computing conditional schedules by analyzing the possible size of a conditional schedule for a given process model. We formalize and show below that in the worst case the size of a schedule is exponential in the number of XOR-splits. Let P(N, E, L, B) and let x be the number of XOR-split nodes in N ( x = |{n ∈ N|n.type = xs} ). The minimum size of a conditional schedule for P is |N| and the maximum necessary size is |N| * 2 x .

Theorem 3 (Problem Complexity)
Proof For the minimum size: Any conditional schedule contains at least one schedule entry for each activity. Actually, if a process is controllable, then one schedule entry for each node is also sufficient, making the number of nodes the minimum size of a conditional schedule.
◻ For the maximum necessary size: The number of different possible propositional terms in the labels of the nodes is 2 x for x = |{n ∈ N|n.type = xs} , a conditional schedule cannot be larger than |N| x . We show that the size can be exponential in the number of XOR-splits by constructing a process (proof-process) with x XOR-splits with a set of temporal constraints and show that in its only schedule there is an activity which has 2 x different disjoint scheduling intervals. Figure 4 shows the pattern for this process. It consist of an activity A followed by n XOR-blocks numbered from n to 1 followed by activity D. Each XOR-block X i , 1 ≤ i ≤ n consists of two alternate activities B i and C i . The min-and max-durations of the nodes are as follows: B i .d = B i .x = 1 and C i .d = C i .x = 2 i−1 + 1 for all i from 1 to n, D.d = D.x = 1 . All other nodes have duration 0. We define the following upper-bound constraints: D, 1) . After some calculations it is easy to see that there is only one possible conditional schedule and in this conditional schedule there are 2 n non-overlapping intervals for activity D: [n + 1, n + 1] … [2 n + n] . Figure 5 shows the schedule for n = 3 . ◻

Efficient Computation of Conditional Schedules
In a straightforward way we can exploit Theorem 2 to realize a procedure to check the conditional controllability of a process and to compute a conditional schedule: unfold the process graph and then compute a schedule for the unfolded process with the presented algorithm. It is easy to see that this is a sound, complete, and effective procedure. The disadvantage of this procedure is, that the complexity of this algorithm is always exponential. In the last section we showed that indeed such as a procedure has to be exponential in the number of XOR-split nodes in the worst case. However, there are more efficient procedures for average cases. In the best case, i.e., if the process is even strictly controllable, the size of a conditional schedule is linear in the number of nodes. Therefore, we aim at more efficient ways for computing a conditional schedule than by computing a schedule for the original rather than the unfolded process. Essentially, our strategy to improve the algorithm aims at reducing the unfolding of the process graph, thus reducing the size of the schedule frame for the computation using partially unfolded graphs. We apply the following strategies: The size of the schedule frame can be reduced, if not all nodes are unfolded, but only those relevant for incorporation of upper-bound constraints.
The goal of unfolding is to separate those paths of a process graph which are affected by the incorporation of an upper-bound constraint from those which are not. When we incorporate an upper-bound constraint, we change Eand L-values of nodes, which affect the values of other nodes. We unfold to separate those nodes that have to be affected by the change of values from those which need not be changed.
In a partially unfolded process graph a node combines potentially several nodes of the unfolded processes graph. So there is not a copy of a node for each term in the label of the node, but the labels are partitioned into disjoint subsets of terms and there is a copy for each partition.
For defining a partially unfolded process graph, it is sufficient to define a partition of the label of each node. The edges and the constraints are then determined accordingly. {The copies are not successors of s} 16: Which nodes have to be duplicated for a given upperbound constraint ubc(s, d, ) ? If we incorporate this upperbound constraint, we change the E values of s and the L values of d. This in turn may cause changes in the predecessors of s and the successors of d. We now have to check which of these possible affected nodes in a partially unfolded graph could be duplicated, such that one copy is affected and the other not.
Let us first check the successors of s. Some of these nodes might be also reachable by paths which do not include s. And exactly these nodes form the unfold set of nodes, as they could be unfolded, such that their twin is not affected. Therefore, these nodes need to be duplicated and the partially unfolded graph has to contain 2 copies of these nodes: one which is a successor of s and one which does not have s.
If d is a successor of s also d might be included in these nodes and might be duplicated. If this is the case, only one copy of d is the destination node of the upper-bound constraint, the other not.
In the other direction: all predecessors of d are affected by a change of d's L values. It is easy to see, that these nodes can only be reached through nodes, which are also predecessors of d in an unfolded graph. Hence, the predecessors of d do not need to be considered for unfolding.
We formalize these considerations in the following theorem, which states that a process graph is sufficiently unfolded, if no successor of a source node s of an upperbound constraint ubc(s, d, ) is reachable through a path which does not include this source node s. Formally, this requires that each successor node of such s have only terms in their label which imply a term in the label of s.  (s, d, ) ∈ B, ∀n ∈ s.Succ + ∀p ∈ n.L ∃q ∈ s.L ∶ p → q.
The definition above requires (1) U to be well formed. This means in particular, that if a node is duplicated, also its successors are duplicated, as otherwise U would not be well formed (see Definition 4). It also requires a proper mapping of upper-bound constraints, i.e., an upper-bound constraint ubc (s, d, ) is included, if all upper-bound constraints are between nodes which can actually appear in the same run, technically, if they are both induced by the same minterm over M⇐L⇒ (see Definition 4). Then the definition requires, that the source nodes of all upper-bound constraints are fully unfolded, i.e., for each term in their labels, there is a different node in the graph. The definition also requires (3) that each successor n of a source node s can only be part of a scenario, if the source node is also part of it. It also means that each minterm over L which implies n.L also implies s.L. Therefore, this condition requires essentially that if the source node of an upper-bound constraint is unfolded, so are all its successors. ◻ With Theorem 2, we have to show that all copies of node of a sufficiently unfolded graph in an unfolded graph have the same values. I.e. ∀n ∈ N �� , ∀(n, Q) ∈ N � ∀q ∈ Q, ∀(n, q) ∈ N ∶ (n, Q).E b = (n, q).E b , etc.
The proof follows the argumentation above: the only condition for values of a correct schedule frame, in which values of a node do not depend on all of their immediate predecessors, their immediate successor, or their own duration are the conditions (6) and (7) of Definition 10, i.e. when the values are determined by an upper-bound constraint. Differences in the values of copies (n, p) and (n, q) of the same node n ∈ N in the schedule frame are only possible, if n is source or destination of an upper-bound constraint. As the algorithm only changes the L values of a destination node, and these changes are propagated to the predecessors of a node anyhow, their unfolding would not change the values of these predecessors. Changes to the E values of a source node s of an upper-bound constraint, however propagates to all successors, even if they are reachable through different paths and therefore for runs which do not include S. Condition (3) of the definition requires, that all successors of a source node can only be reached through this source node, which eliminates the possibility above. ◻ With the theorem above, we now develop an algorithm for computing a sufficiently unfolded graph for an upper-bound constraint ubc (s, d, ).
We observe that the label of a node is different from the label of its predecessor node only if it is (i) an XOR-join node (then the labels of its predecessors are disjoint), or (ii) the successor of a XOR-split node, where the label of the successor implies the label of the predecessor.
Each node, which has to be duplicated, has a predecessor XOR-join node, which also has to be duplicated. A node will be duplicated, if this preceding XOR-join node is duplicated. It is therefore sufficient to check for XOR-join nodes, which are successor of s and which have a direct predecessor, which is not a successor of s. We therefore define the unfold set for s as {(n, p) ∈ N|n.type = xj, (n, p) ∈ s.Succ + , ∃(m, q) ∈ (n, p). Pred, (m, q) ∉ s.Succ + } and unfold the graph at these nodes.
Algorithm 7 shows the procedure for partially unfolding a process graph. It unfolds the graph for all XOR-join nodes in the unfold set of all upper-bound constraints. Unfolding at a particular XOR-join node x duplicates all successors of x and adjusts the edges accordingly. Now, we study the mapping of an upper-bound constraint ubc(s, d, ) for the unfolding of one XOR-join node x, which duplicates some of the nodes. The nodes s, d, and their closest common predecessor a might each be duplicated, with s ′ , d ′ , a ′ , respectively, as their possible twins with s ′ ≠ s , d ′ ≠ d , a ′ ≠ a , or they are not duplicated which means that ( s � = s , d � = d , a � = a ). The following cases have to be distinguished for the inclusion of additional upper-bound constraints: Figure 6 shows the schedule frame for the partially unfolded process of Fig. 1 (for explanations see Fig. 2). The partial unfolding of a schedule frame leads to smaller graphs and hence to a faster computation of a correct schedule frame in comparison to a fully unfolded graph. Although in this example, the difference to the fully unfolded schedule frame in Fig. 3 is not breathtaking, and of course, the reduction in size depends on the number and position of upperbound constraints and XOR-split and XOR-join nodes. In the worst case, the partially unfolded graph is identical to the fully unfolded graph. In the next section, we empirically explore the possible gains.

Implementation and Evaluation
We implemented all the presented algorithms for full unfold, partial unfold (Algorithm 7), checking (conditional) controllability by computation of correct schedule frames (Algorithm 2) and computation of correct schedules (Algorithm 1) in Java. With these implementations, we performed experiments to evaluate the feasibility of the approach and, in particular, to explore potential improvements achieved by partial unfold versus full unfold.
We ran our experiments on a Windows 10 server with an Intel Xeon CPU with 16 cores and 2.2 GHz computation power and 132 GB of RAM. For the experiments we randomly generated 1600 processes with around 200 activities each and varying numbers of XOR constructs and upperbound constraints. Also the placement of the defined number of XOR-splits and XOR-joins was generated randomly, as well as the defined number of upper-bound constraints.
We structured the test set into subsets according to their number of XOR-splits and UBCs. We specified a timeout after 30 min of computation, considering exceeding instances as not feasible. The following graphs summarize the figures collected by the experiments. Figure 7 shows the size of the graphs in number of nodes for the full unfolded graph and the partial unfolded graph in relation to the number of XOR-splits. The experiments showed convincingly that the number of nodes of the partially unfolded graphs is significantly smaller. Figure 8 shows the size of the graphs for different amounts of upper-bound constraints. The size of the fully unfolded graph only depends on the number and placement of XOR-splits and -joins. The slight variations are due to the randomly selected placement of these nodes. Apart from this, the size of the graph does not depend on the number of upper-bound constraints. In contrast, the number of nodes of partially unfolded graphs increases with the number of upper-bound constraints. However, even for very large numbers of upper-bound constraints (50 in our experiments), the size of the partially unfolded graphs is still 40% smaller than the size of the fully unfolded graphs. Figure 9 documents the high performance gains achieved by applying the partial unfold algorithm in comparison to the full unfold. The performance figures are given for the different amounts of XOR constructs. This figure also shows that the approach is feasible for realistic sizes of process graphs. For 200 activities with 17 XOR constructs, the average time for computing a correct schedule frame did not exceed 40 s.
We can summarize the results of the experiments as follows: the presented approach for checking the conditional controllability of temporally constrained processes proved to be feasible for realistic sizes of processes and temporal constraints, in particular taking into account, that these are design time algorithms. In addition, the experiments show that applying partial rather than full unfold greatly reduces the size of the graphs and significantly improves the performance of the computation of conditional schedules.

Related Work
Our approach tries to contribute to the integration of time management in workflows, temporal consistency in service composition [24] and temporal constraint networks. There is already quite some body of research results in the area of temporal aspects of workflows and business processes. We refer to [5,20,25] for an overview. Recently the work of Lanz et al. [31,32] brought some consolidation of expressing temporal constraints and defining the semantics of temporal constraints. The upper-bound constraints used here are correspond to TP 3 "maximum time lag between events".
Early approaches checking temporal qualities of process definitions are [1,19,33] with techniques rooted in network analysis, scheduling, or constraint networks. These techniques stimulated the development of more advanced networks, the consideration of inter-organizational processes and for supporting temporal service level agreements for service compositions [4,24].
Our approach is based on the algorithms for computing schedules for time constrained workflows presented in [17], but is extended to capture the uncertainty of the duration of contingent activities, and delivers a new formalization and proofs for soundness and completeness of the algorithms. This paper is an extension of [14] now including partial unfold as well as a set of additional experiments in the evaluation. The terminology was changed from history-dependent controllability to conditional controllability, as the latter, although introduced in the literature earlier (e.g. [10]) lead to frequent misunderstanding with schedules derived from process logs (or process histories).
Another stream of research studies temporal constraint networks [12], which were applied for workflows in [1], and now reached the necessary expressiveness for analyzing business process models: checking the controllability [7] and dynamic controllability of temporal networks, as discussed in [8]. In particular, [6,26,28] present algorithms for checking the controllability of conditional simple temporal networks with a sound-and-complete algorithm for conditional simple temporal networks with uncertainty (CSTNU), the type of network corresponding to the process models discussed here. While these approaches check, whether an execution strategy avoiding time failures exists,  Algorithms for other types of temporal constraint networks have been proposed in [2,37]. Algorithms for computing conditional schedules for these types of networks is subject of ongoing research.

Conclusions
Among the most important quality criteria for the definition and execution of processes is to fulfill temporal requirements and do not violate temporal constraints. Time failures such as missed deadlines cause exception handling and might be costly. Therefore, we propose to use controllability and in particular conditional controllability as important characteristics for the quality of process definitions. We presented a sound and complete algorithm for checking conditional controllability of temporally constrained process definitions, and for computing conditional schedules at design time. This algorithm provides a good basis for developing more efficient algorithms for the computation of conditional schedules with better average case complexity. The worst case complexity was shown to be exponential in the number of XOR-splits in a process. However, with the strategy to only partially unfold a process graph depending on the location of upper-bound constraints we achieved a significant improvement of both the size of the resulting graphs and the time for calculating conditional schedules. Our experiments showed that the proposed procedure for checking conditional controllability is feasible for realistic sized process models.
Our major aim is to compute schedules, and to support the time aware execution of processes avoiding temporal failures. To improve the qualities of schedules, in particular less rigid schedules with start time intervals and a good distribution of slack time as well as efficient algorithms for computing good schedules remain on our research agenda. Furthermore, efficient run-time monitoring of adherence to schedules and efficient computing of task deadlines when tasks are dispatched to actors is subject of ongoing research.