The modeling of temporal aspects in business processes is based on the representation of time as a mere property of control- ow constructs. Other timepoints cannot be represented, which limits the types of temporal constraints that modelers can express. Additionally, such representation of time hinders modularization and support for privacy in distributed processes. Here we propose a new process metamodel in which temporal aspects are explicitly modeled with temporal variables. We show that our metamodel gives modelers increased expressiveness to represent temporal constraints. We then give indications on how our metamodel can be used for overcoming the identi ed gaps.
E ective business processes management requires expressive models to capture
all the relevant aspects of processes. The correct and comprehensive modeling
of temporal aspects plays a crucial role in this perspective. Extensive research
has been conducted over time and processes in the last decades, corroborating
the relevance of temporal aspects in business process modeling. Despite the
numerous approaches to conceptual modeling and veri cation of timed processes,
such as [
Here we propose a process metamodel that allows to represent temporal aspects as data elements. The reason behind it is that processes manipulate data, and temporal information handled at runtime is data too. This explicit representation of time allows modeling additional temporal information which are unrelated to process activities, de ning a more extensive set of temporal constraints, while still allowing the veri cation of temporal properties of a process.
This work is supervised by Prof. Johann Eder from the Information and Communication Systems research group at the Alpen-Adria-Universitat Klagenfurt, Austria.
The remainder of this paper is structured as follows: in Sect. 2 we present a series of motivating examples to show the gaps that our work aims at lling. Sect. 3 presents our research questions and methods. In Sect. 4 we present the state of the art. In Sect. 5 we de ne our process metamodel and brie y show how we can evaluate it. Sect. 6 gives an overview of the next steps of work, and we draw conclusions in Sect. 7. 2
Most business processes comprise temporal requirements to be ful lled for a correct execution. Temporal properties of such processes can be checked at design time. However, there are real-world scenarios for which no mapping of temporal information or constraint is possible with the current modeling approaches. Here we show examples of such cases.
{ Temporal information unrelated to control ow elements. Since existing approaches to time modeling only consider temporal aspects related to control ow elements, no other timepoints can be referred to. Suppose a medical scenario in which a patient comes to the hospital for urgent treatment. The treatment is possible only if the patient has not taken a speci c medicine in the previous 24 hours. The medicine intake is not an activity of the treatment process, since it might have happened before. Therefore, the temporal information related to it is not part of the process. While in the real world it could be obtained from an interview with the patient, in a process model there would be no way to represent and directly refer to such a temporal information. More in general, with the existing approaches, all temporal information that is not bounded to an executable element is not representable and cannot be used for de ning temporal constraints. { Temporal constraints across modules. The advantages of modularizing processes span from the ability to reuse existing processes inside new ones, to the simpli cation of the overall process models thanks to abstraction. The presence of temporal constraints crossing modules, however, nullify these advantages. A temporal constraint involving a timepoint ti within a module and one outside of it would require the outer process to have access to the module internals in order to refer to ti, because it is a property of an activity in the module. Moreover, the outer process could require to dynamically constrain durations inside of the module, in order to satisfy some overall temporal constraint. In such a case there is no way to convey temporal information from the outside process to the internals of the module. { Temporal constraints across distributed processes. A distributed process is realized by the interplay of local processes executed by di erent process partners; no central authority exists for computing a global schedule, and a shared-nothing architecture is assumed. The presence of temporal constraints across local processes then requires the access to the internals of those processes by other process partners, which is undesirable since it means a lack of privacy and a potential exposition of business secrets. Similarly to the case of modules, currently no way to directly refer to temporal information originating outside of a local process is possible either. 3
The research questions that arise by looking at our examples, and that we try to answer with this work are the following: 1. How can we explicitly model temporal aspects of business processes as data elements such as temporal variables? 2. What are the semantics of such process models? 3. Which expressive power will be enabled in (possibly modularized or distributed) process models, if temporal variables are introduced? 4. How can we de ne the correctness and other temporal properties, such as controllability, for (possibly modularized or distributed) process models, if temporal variables are introduced? 5. How can we check the correctness and other temporal properties, such as controllability, for (possibly modularized or distributed) process models, if temporal variables are introduced?
The rst contribution of this project is to provide a formalism with increased
expressiveness for de ning timed business processes, overcoming the
expressiveness issues presented in Sect. 2 and allowing the modeling of a broader range of
real-world processes. By applying design science methods, a language for de
ning (possibly modularized or distributed) process models with temporal variables
will be produced, based on the one we presented in [
An additional contribution is the production of a set of tools for assessing properties of processes expressed with the proposed language. Production of formal de nitions, theorems and proofs will be the method applied for de ning the notions of correctness and controllability of processes expressed with the proposed language. Algorithm design will be the method for checking such properties, also in modularized and distributed processes. Also in this case, proofs of soundness and completeness will be given for validation, and algorithm implementation will assess the feasibility of the approach. 4
Numerous previous works considered the incorporation of temporal aspects in
work ows. The modeling of timepoints in BPMN is considered in [
Since our aim is to allow expressing additional temporal aspects in process
models, we need to address time at metamodel level. We propose a metamodel that
aims at overcoming the expressiveness issues discussed before. It includes a
minimal set of control- ow constructs that allow to model the most common control
patterns [
Since we consider time as data, following our previous work on handling data in
distributed processes [
Nodes can be of di erent types: start, end, activity, xor-split, xor-join. Each node n has two associated temporal variables representing its minimum and maximum durations: n:dmin and n:dmax. Furthermore, it has two temporal variables representing its start and end times at process runtime: n:s and n:e, respectively. The following inequality must hold for all nodes n: 0 n:dmin n:e n:s n:dmax. Each node n is also associated with two sets of variables n:r; n:w V containing the variables read and written in it.
Edges connect nodes and de ne the control ow of a process. We use edges to de ne the sets of predecessors, resp. successors of a node n as: n:pred = fm 2 N j 9(m; n) 2 Eg, n:succ = fm 2 N j 9(n; m) 2 Eg. A node n with kn:predk = 0 is a start node; a node n with kn:succk = 0 is an end node.
We use propositional letters to construct labels. Labels indicate through which paths a certain node can be reached from the start node. Di erent paths are possible due to the presence of decisions taken at xor-splits. For each xor-split node xs we associate a propositional letter (xs) = 2 . The two outgoing edges e1 and e2 of a xor-split xs have labels e1: = (xs) and e2: = : (xs), respectively. All other edges e have label e: = T rue. Each node n of a process graph has a label n: which is de ned depending on the type of the node: { n: = fT rueg if n is a start node; { n: = Sm2n:pred(m: ) if n:type = xor-join; { n: = fm: ^(m; n): j (m; n) 2 Eg for any other node, where the operator is de ned as the cross-conjunction of a set of sets i of conjunctive terms: = f 1 ^ ^ n j i 2 i; 1 i ng.
The set V is partitioned in the set of generic (data elements) variables Vd and the set of temporal variables Vt. Temporal variables encode temporal information such as durations, timepoints, deadlines. We de ne three partitions of Vt, depending on the type of information a temporal variable represents. 1. Vtn is the set of temporal variables derived from all nodes in the process graph: Vtn = fn:dmin j n 2 N g [ fn:dmax j n 2 N g [ fn:s j n 2 N g [ fn:e j n 2 N g; 2. Vtd is the set of temporal variables referring to temporal information that is written in some node in the process and is not derived as a temporal property of that node; 3. Vte is the set of temporal variables given by the environment, such as deadline for process termination (temporal variable ), maximum time of start for a node, elapsed time since process start (temporal variable ).
Each vt 2 Vt is associated with a label (vt), depending on its type: { { { (vt) = n: if vt 2 Vtn; (vt) = Sn n: ; vt 2 n:w if vt 2 Vtd; (vt) = T rue if vt 2 Vte.
The label determined by corresponds to the values of the decision variables under which a temporal variable is correctly initialized.
Constraints re ect restrictions on the values that can be assumed by variables at runtime. Here we concentrate on temporal constraints, as they are the ones that most in uence the execution of a process and determine if certain temporal properties, such as controllability, hold. Two types of temporal constraints exist: upper- and lower-bound. Upper-bound constraints express maximum allowed durations between events, while lower-bound constraints express minimum required durations between events. The set C of constraints is therefore partitioned into the sets U BC and LBC of upper-, resp. lower-bound constraints. The semantics of a constraint c = (s; d; ) is de ned after the partition it belongs to: { d { d s s if c 2 U BC; if c 2 LBC. 5.2
For space reasons, we informally de ne the requirements for a process to be wellformed, in order to avoid ill process de nitions. In a nutshell: each xor-join node must not be reached by two di erent paths at the same time (disjoint paths); for all nodes that are not xor-joins their predecessors must be compatible; for each temporal constraint, there must be at least one path in which both the involved temporal variables are correctly initialized; each temporal variable must not be written more than once in a same process instance. 5.3
We sketch the steps needed to evaluate our metamodel: we rst need to show that
it is able to express all the established time patterns [
Having our process metamodel at disposal, we identify three main avenues for further work, guided by our research questions: the automated check for temporal properties, in particular controllability, the support for modularized processes, and the support for distributed processes. 6.1
Given a process model, it is interesting for modelers to determine its correctness and its controllability. For correctness here we refer to an assignment of timestamps to temporal variables which is not contradictory. The concept of controllability covers the problem of determining the possibility of executing a process without violating its temporal constraints. Temporal Constraint Networks, and their specialization which includes decision points and uncertain durations given by contingency (CSTNUs), are a widely used graph-based structure for representing timepoints and their dependencies. Since established methods exist for determining their controllability, we plan to develop a mapping to transform our process models into CSTNUs for controllability check. The idea is to map each temporal variable to a timepoint of a CSTNU, and each temporal constraint to an edge of the CSTNU. This method will allow to exploit the established results for controllability check in CSTNUs to determine the controllability of our process models. A formalization of the concepts of correctness and controllability through formal de nitions will be provided. Algorithms for determining if a process is correct and controllable, as well as for mapping process models to CSTNUs, will be developed and implemented. 6.2
The explicit representation of temporal information opens new possibilities for modularized processes by allowing the expression of temporal constraints without exposing module internals. Temporal variables can be used both as input and output parameters of a module, and be referenced in constraints within the module or in the outer process containing it. With constraints, input parameters coming from the outer process can in uence timepoints within a module, and output parameters from a module can in uence timepoints in the outer process. The in uence of parameters opens questions such as whether and under which conditions it is necessary to recompute temporal properties of modules for checking the ones of the outer process. Methods for determining the required data exchanges across modules, and the need to recompute temporal properties of modules when required, will be identi ed, and corresponding algorithms will be designed and implemented. Additionally, as it is possible to assign ranges for the timestamps referenced in temporal constraints crossing modules, algorithms to predetermine such ranges will be designed and implemented. 6.3
Our metamodel can be applied to distributed processes, allowing to keep
local process internals hidden even in the presence of temporal constraints across
local processes. In a distributed process, several participants enact their local
processes in coordination with each other. The coordination between di erent
local processes can be realized by introducing communication primitives to
exchange data at required points, as shown in [
Despite temporal aspects being of humongous importance in business processes, most existing approaches neglect those which are not directly related to process activities, and provide a limited expressiveness for representing time. In this paper we have introduced a new metamodel for processes which is the rst using temporal variables to represent temporal aspects. We have sketched proof that our proposed metamodel is able to capture all the compatible established time patterns, and that our explicit representation of time provides additional expressiveness by enabling the modeling of new temporal aspects and constraints. Future work includes the veri cation of temporal properties of processes, possibly by mapping our metamodel to CSTNUs, the automatic generation of interfaces for process modules and for distributed processes.