Detecting and Repairing Data-Flow Errors in WFD-net Systems

Fang Zhao; Dongming Xiang; Guanjun Liu; Changjun Jiang; Honghao Zhu

doi:10.32604/cmes.2022.018872

1School of Electronics and Information Engineering, Tongji University, Shanghai, 201804, China
2School of Information Science and Technology, Zhejiang Sci-Tech University, Hangzhou, 310018, China
3School of Computer Engineering, Bengbu University, Bengbu, 233030, China
*Corresponding Author: Dongming Xiang. Email: flysky_xdm@163.com
Received: 22 August 2021; Accepted: 03 December 2021

A business process is considered as “the specific ordering of work activities across time and place, with a beginning, an end, and clearly identified input and output” [1]. As an information technology of process automation, workflow systems have become a standard solution for managing complex business process models, such as loan approval management [2], supply chain management [3], and knowledge management [4]. In other words, workflow systems can be used to automate, manage, and optimize different kinds of business processes. In general, the design of a workflow system needs to describe control-/data-flows, and then detect their errors [5]. A successful workflow system depends on error-free modeling and analyzing methods. Therefore, it is necessary to keep the correctness of control-/data-flows in a workflow system. Control-flows mainly focus on the partial orders of business activities, while data-flows mainly involve data operations (e.g., read, write, and delete) and guard functions [6–8].

There are many modeling methods that can be used to describe workflow systems, such as Business Process Modeling Notation (BPMN) [9], Business Process Execution Language (BPEL) [10], Event-Driven Process Chains (EPCs) [11], UML Activity Diagrams [11], and Workflow Net with Data (WFD-net) [12]. Compared with these methods, WFD-nets are much suitable to describe and analyze control-/data-flows due to their data labeling functions and guards.

In order to guarantee the correctness of workflow systems, some methods are developed to detect and repair errors. Unfortunately, most of them only focus on the verifications of control-flows while ignoring the checking of data-flows. In fact, data-flows play an important role in workflow design. This is because routing constraints in a workflow are usually based on data operations and guard functions. Moreover, data-flow errors (e.g., redundant data, missing data, lost data, and inconsistent data) may arise even if control-flows are correct [5,13]. Once a workflow model suffers from missing data, it may need high costs to repair unexpected process interruptions. To repair data-flow errors in workflow systems, many studies are done. Awad et al. [9] presented a method to repair missing data in BPMN. After then, Song et al. [10] provided some methods to preserve data-flow correctness in BPEL. Later on, Sharma et al. [14] presented a method to repair data-flow errors in workflows. However, these methods do not consider data-flow errors caused by delete operations, and their workflow models are usually simple (e.g., no loop structures). In order to remove a kind of data-flow error, they may bring in another one. Therefore, they need multiple attempts to repair these errors. What's worse, they may get an incorrect workflow model.

In this paper, we use WFD-net systems to analyze the correctness of control-/data-flows in workflow systems. It is assumed that our control-flows in WFD-net systems are sound (i.e., no deadlocks [9,15,16] or livelocks [17–19]), without taking data operations into consideration [12,20,21]. The aim of this paper is to detect and repair four kinds of data-flow errors (i.e., redundant data, missing data, lost data, and inconsistent data) in WFD-net systems.

1) Based on weak behavioral relations (i.e., weak sequence relation, weak exclusiveness relation, weak circulation relation, and weak concurrency relation) and order relation, we formalize four kinds of data-flow errors in WFD-net systems.

2) We reveal the relations between different kinds of data-flow errors, and further organize them into a hierarchy, which can contribute to correctly repairing data-flow errors without repeated work.

3) We present some methods to repair data-flow errors in WFD-net systems according to several system requirements and repair strategies.

The rest of this paper is organized as follows. In Section 2, we present some related work about data-flow errors. Then, we introduce workflow system modeling and a motivation example in Section 3. In Section 4, we formalize data-flow errors in WFD-net systems, and provide some new methods to repair them. In Section 5, a case study of campus-card recharging is conducted. In Section 6, we do a group of experiments to show the effectiveness of our methods. Finally, conclusion and future work are given in Section 7.

There have been many methods to detect data-flow errors. Sun et al. [2] provided three basic types of data-flow errors in UML activity diagram, namely missing data, conflicting data, and redundant data. Sundari et al. [22] presented a graph traversal algorithm called GT to detect data-flow errors in workflows. It systematically traversed every workflow route to detect errors like redundant data, missing data, and lost data. Based on the work provided in [2], Sun et al. [23] analyzed the dependencies among different transitions based on the input and output data of activities in a workflow model. Meda et al. [24] provided missing data, inconsistent data, lost data, and redundant data. They also presented a graph traversal algorithm to detect the data-flow errors in unstructured and nested workflows. Sidorova et al. [25] defined the may/must-soundness of a WFD-net system. Haddar et al. [26] provided a data-centric method to manage business processes. Dolean et al. [27] presented a survey of researches on modeling data-flows of business processes, and pointed out that the control-flows cannot be executed without data operations. Kabbaj et al. [5] pointed out that the role of data in a workflow is very important because routing constraints are closely related to data elements. Therefore, a workflow easily leads to an interruption once it contains data-flow errors. In order to solve this problem, they provided a method to detect redundant data, missing data, and lost data (or conflict data). Xiang et al. [6] proposed Petri Net with Data Operations (PN-DO), such as read, write, and delete operations. They formalized redundant data, missing data, lost data, and inconsistent data. Dramski [28] presented missing data in event logs and gave some ways to make some data recovery. Trcka et al. [29,30] put forward six kinds of data-flow errors in WFD-nets, namely missing data, strongly redundant data, weakly redundant data, strongly lost data, weakly lost data, and inconsistent data. von Stackelberg et al. [31] proposed a method to detect strongly redundant data, weakly redundant data, missing data, strongly lost data, weakly lost data, and inconsistent data in BPMN 2.0. Song et al. [32] utilized supervised learning algorithms to predict data-flow errors in an unseen BPEL process. Moreover, they provided an empirical study on data-flow errors in BPEL processes. Mülle et al. [33] considered that the correctness of data-flows in BPMN 2.0 is a challenge. As for the above studies, they did not consider the relations between different kinds of data-flow errors.

There are many studies on repairing data-flow errors. Awad et al. [9] presented a method to repair missing data. Song et al. [10] provided preserve data-flow correctness in process adaptation. They proposed three criteria to make the process free of missing data, redundant data, and lost data. Technically, they assumed that each activity has 0/1 output. Later on, Sharma et al. [14] presented methods to repair redundant data, missing data, lost data, and inconsistent data in workflows. After then, Jovanovikj et al. [34] provided methods to compare and merge two different models with different data operations. The methods are activity inserted, activity deletion, data object creation, data object to read, data object updated, and data object deletion. These methods can contribute to providing possible ways for the designer to repair data-flow errors in a WFD-net system. As mentioned above, these studies did not consider data-flow errors caused by delete operations, and their workflow models are usually without loop structures. What's more, repairing some kinds of data-flow errors may bring in new data-flow errors. In order to solve these problems, we propose some new methods to repair different kinds of data-flow errors according to several system requirements in this paper.

A Petri net is a 3-tuple N=(P,T,F), where P is a limited non-empty set of places, T is a limited non-empty set of transitions, P∩T=∅, and F⊆(P×T)∪(T×P) is the flow relationship in N [35–38]. A Petri net system is a net N=(P,T,F) with an initial marking M0. A marking function of a net is a mapping M:P→N1, where N1 is the set of non-negative integers. Given a node x∈P∪⁡T, its pre-set and post-set are denoted by ⋅x={y|(y∈P∪⁡T)∧(y,x)∈F} and x⋅={y|(y∈P∪⁡T)∧(x,y)∈F}, respectively [39]. If x is a source place, then ⋅x=∅; If x is a sink place, then x⋅=∅. Given a set of nodes X⊆P∪⁡T, and x∈X, its pre-set and post-set are denoted by ⋅X={Y|(Y⊆P∪⁡T)∧(y∈Y)∧(y,x)∈F} and X⋅={Y|(Y⊆P∪⁡T)∧(y∈Y)∧(x,y)∈F}, respectively. For the example of Fig. 1, if X={t2,t3}, then we have ⋅X=⋅t2∪⁡⋅t3={p2,p3}, and X⋅=t2⋅∪⁡t3⋅={p3,p4}. Furthermore, we use k to denote the pre-set number for convenience. Therefore, we have (⋅)1t3=⋅t3={p3}, (⋅)3t3=⋅(⋅(⋅t3))={p2}, (⋅)5t3=⋅(⋅(⋅(⋅(⋅t3))))={p1,p4}, and (⋅)1t3∪⁡(⋅)3t3∪⁡(⋅)5t3={p1,p2,p3,p4}, where k=1,3,5, respectively. With respect to the set of post-sets, it is defined analogously. A Petri net N is called a safe Petri net if all places are marked at most one token. In this paper, our Petri nets are safe by default.

We model the control-flows of a workflow system as a dedicated class of Petri nets, thereby modeling activities by transitions, conditions by places, and cases as tokens. A typical workflow has a well-defined starting point, and a well-defined ending point imposes syntactic restrictions on Petri nets that result in the following definition of a workflow net (WF-net).

Definition 1 (WF-net [40,41]) A Petri net N=(P,T,F) is a workflow net (WF-net) if it satisfies:

(1) There is only one source placepI∈P and only one sink place po∈P in N; and

(2) ∀x∈P∪⁡T:(pI,x)∈F∗ and (x,po)∈F∗, where F∗ is the reflexive-transitive closure of F.

A WF-net is used as a basic description of control-flows in a workflow process. A WF-net system (N,M0) is a WF-net extended with an initial marking M0. In order to model the actual process (including control-/data-flows) of workflow systems, we define a workflow net with data (WFD-net) [29,30] as follows.

Definition 2 (WFD-net [29,30]) A Petri net ND=(P,T,F,D,Guard,R,W,De,Gd) is a WF-net with data (WFD-net) iff:

A WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,R,W,De,Gd) is a WFD-net with a marking M0 in the source place. The function Type:D→{Cons,Vari} denotes the value type of data items. That is, if d∈D is a constant, then we have Type(d)=Cons (resp. if d∈D is a variable, then we have Type(d)=Vari). A guard function is a boolean expression related to data items. In this paper, we suppose that guard functions in each branch are related to the same data items. For the sake of readability, when saying “data item d is read”, it means “data item d is read or used for the evaluation of a guard function” [30]. Therefore, a guard function can be considered as read operations on a transition. For example, we have Gd(t4)=<high(d3)>, Gd(t5)=<middle(d3)>, Gd(t6)=<low(d3)>, Gd(t9)=<high(d6)>, Gd(t10)=<middle(d6)>, and Gd(t11)=<low(d6)> in Fig. 1. The data item d3 (resp. d6) can be considered as read operations on transitions t4, t5, and t6 (resp. t9, t10, and t11).

This part introduces a campus-card recharging process as a motivation example. As shown in Fig. 1, there are 14 places, 16 transitions, 8 data items, 34 data operations (including 19 read operations, 12 write operations, and 3 delete operations), and 6 guard functions. Table 1 illustrates the transitions and data items.

Fig. 1 describes a WFD-net system as follows. Firstly, users log into the system, and produce two data items, i.e., ID and Login Password. Then, they click on the application and campus wallet. After these operations, there are three transitions in weak exclusiveness relations. If the balance of the account is high, users can recharge the campus smart cart. If the balance of the account is middle, they can pay the electricity. Otherwise, they go back to the application. Then, they need to submit orders. After submitting orders, users can choose payment methods, e.g., bank card, Wechat, or Alipay. If the payment amount is high, they can choose bank cards. If the payment amount is middle, they can choose Wechat. Otherwise, they only choose Alipay. After then, they submit and pay for orders. Users need to input account numbers and payment passwords. Finally, they close this deal.

There are some data-flow errors in Fig. 1. For example, the data item d4 on the write operation of t3 is weakly redundant, and the data item d1 on the read operation of t3 is strongly missing. More details about data-flow errors are given in Sections 4 and 5.

Although some methods are used to repair these errors, e.g., Criteria 1−3 [10] and CorrDF [14], they have some limitations. The method of Criteria 1−3 can repair data-flow errors with transition pairs in weak sequence relations. Each transition reads/writes 0/1 data item. The method of CorrDF can repair data-flow errors caused by incorrect read and write operations in process models with transition pairs in weak sequence relations, weak exclusiveness relations, and weak concurrency relations (Section 4). Unfortunately, they cannot repair data-flow errors caused by delete operations, and their workflow models are usually simple (e.g., no loop structures). What's more, repairing one error may bring in some new kinds of errors. For the example of Fig. 4h, when we repair the error of missing data, we may bring in some redundant data. Therefore, we need to reveal the scope of different kinds of data-flow errors, and present new methods to check and repair data-flow errors according to the real system requirements.

In this section, we first define enabled conditions of WFD-net systems, and their weak behavioral relations. Then, we present some methods to check and repair data-flow errors.

Definition 3 (Enabled Conditions) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,

R,W,De,Gd),t∈T is enabled at a marking M if it satisfies the following conditions:

(1) t is control-enabled at M such that ∀p∈⋅t:M(p)≥1, denoted by M[ct>; and

(2) t is data-enabled at M such that each data item read by t must be defined and its guards are evaluated to true, which is denoted by M[dt>.

The firing of an enabled transition t (i.e., control-enabled [42] and data-enabled) at a marking M does not only affect the values of data items and guard functions but also yields a new markingM′ [25], which is denoted by M[t>M′. That is,

A new marking Mk is reachable from the initial marking M0, if and only if there exists a firing sequence σk=t1t2⋯tk such that M0[t1>M1[t2>M2⋯Mk−1[tk>Mk.

Notice that if a transition t∈T is control-enabled at M, we say it is weakly enabled, and its related firing sequence is a weak firing sequence.

Due to the fact that the modeling of a workflow system is process-oriented in reality, we need to analyze its weak order relation [43].

Definition 4 (Weak Order Relation [43]) Let (ND,M0)=(P,T,F,M0,D,Guard,R,W,De,Gd) be a WFD-net system. The weak order relation ≻c⊆T×T contains all pairs of transitions (tα,tβ), such that there exists a weak firing sequence (without taking the data operations and guard functions into consideration) σx=t1t2⋯tx satisfying (ND,M0)[σx>, α∈{1,⋯,x−1}, α<β≤x, and x−1∈N.

In this paper, the set of all weak firing subsequences is denoted by T∗, and T∗={σ(1)}∪⁡{σ(2)}∪⁡⋯∪⁡{σ(ε)}, where σ(ε)=ta1ta2⋯taε, and ta1,ta2,⋯,taε∈T.

Based on the weak order relation, we define weak behavioral relations as follows.

Definition 5 (Weak Behavioral Relations) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,

Guard,R,W,De,Gd), the transition pair (tα,tβ) is in one of the following weak behavioral relations, where k∈{1,3,⋯,n}, n=2m+1, and m+1∈N:

(1) tα and tβ are in weak sequence relation, which is denoted bytα→ctβ, iff (tα≻ctβ)∧(tβ⊁ctα);

(2) tα and tβ are in weak exclusiveness relation, which is denoted bytα⊗ctβ, iff (tα⊁ctβ)∧(tβ⊁ctα);

(3) tα and tβ are in weak circulation relation, which is denoted bytα↔ctβ, iff (tα≻ctβ)∧(tβ≻ctα)∧(tα⋅∩(∪k=1n⁡(⋅)ktβ)≠∅)∧(tβ⋅∩(∪k=1n⁡(⋅)ktα)≠∅); or

(4) tα and tβ are in weak concurrency relation, which is denoted bytα⊕ctβ, iff (tα≻ctβ)∧(tβ≻ctα)∧((tα⋅∩(∪k=1n⁡(⋅)ktβ)=∅)∨(tβ⋅∩(∪k=1n⁡(⋅)ktα)=∅)).

Generally speaking, tα→ctβ represents the transition tβ cannot execute before tα in any traces. tα⊗ctβ means the transitions tα and tβ execute exclusively in any traces. tα↔ctβ illustrates the transitions tα and tβ are in a loop structure. tα⊕ctβ denotes the transitions tα and tβ can execute in different orders. Obviously, these four kinds of weak behavioral relations are mutually exclusive. If tα and tβ are in weak sequence relation and they are in the same branch (i.e., (tα→ctβ)∧(tα⋅=(⋅)k1tβ)∧(|tα⋅|=|(⋅)k1tβ|=1), where \; k1∈{1,3,⋯,n1}, n1=2m1+1, and m1+1∈N), then we denote it as tα↠ctβ. For the example of Fig. 1, we have t1→ct2, t4⊗ct5, t3↔ct6, t12↠ct13, and t14⊕ct15, respectively.

Definition 6 (Concurrency Relation) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,

R,W,De,Gd), the transitions tα and tβ are in concurrency relation, which is denoted by tα⊕cdtβ, iff:

For the example of Fig. 2a, we can find that tα⊕cdtβ if Gd(tα)and Gd(tβ) are evaluated to TRUE at the same time.

Figure 2: Two WFD-net systems. (a) The behavioral relation of tα and tβ depends on their guard functions; (b) tα and tβ are in weak circulation relation (i.e., tα↔ctβ)

Definition 7 (Distance of Transitions in Weak Circulation Relation) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,R,W,De,Gd), ∃tα,tβ∈T: tα↔ctβ, tα∈t(⋅)k1, and tβ∈t(⋅)k2, where t is a transition outside the weak circulation relation, k1 and k2 are the minimum number of post-sets, such that k1,k2∈{2,4,⋯,2m}, and m∈N. The distance between tα and tβ is defined as δ(tβ,tα)=|k2−k1|.

Based on the definitions of weak behavioral relations, concurrency relation, and distance of transitions in weak circulation relation, we further formalize the order relation of transition pairs in a WFD-net system.

Definition 8 (Order Relation) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,R,W,

De,Gd), the order relation tα≻tβ contains all pairs of transitions (tα,tβ), and they satisfy one of the following conditions:

For the example of Fig. 2b, we have t→ctα, t→ctβ, tα↔ctβ, and δ(tβ,tα)=|k2−k1|=2.

Based on order relation, we formalize redundant data, missing data, lost data, and inconsistent data. Before we define these errors, we use A>x<B to denote A∈B or A∉B.

Definition 9 (Redundant Data, RD) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,

R,W,De,Gd), T∗ is the set of all weak firing subsequences, and ∃σ∈T∗, ∃to∈σ:po∈to⋅. A data item d∈D is redundant if it satisfies ∃t∈T, ∀t′∈σ:(t≻t′)∧(d∈W(t))∧[(d>x<De(t))∨(d>x<W(t′)∪⁡De(t′))]∧(d∉R(t′)), which is denoted by d<⋅RD.

Notice that if there exist t,t′∈T such that (t≻t′)∧[d∈W(t)∩R(t′)]∧(d∉De(t))∧[d>x<W(t′)∪⁡De(t′)], then d may be redundant. For the example of Fig. 3e, we have (t1≻t2)∧[d∈W(t1)∩R(t2)]∧(d∉De(t1))∧[d∉W(t2)∪⁡De(t2)], and d<⋅RD.

Figure 3: The data item d is redundant, where Type(d)=Cons or Type(d)=Vari. (a)--(c) d<⋅SRD; (d)--(f) d<⋅WRD

A data item d is strongly redundant data (SRD) if the written values of d in all possible execution paths are never read before it is deleted, or the workflow process is completed. A data item d is weakly redundant data (WRD) if there exist some execution paths in which it is written but never read afterward, i.e., before it is deleted, or the workflow process is completed [30]. SRD and WRD belong to redundant data (RD). As shown in Fig. 3, the data item d is redundant, where (a)--(c) suffer from strongly redundant data, and (d)--(f) suffer from weakly redundant data.

Definition 10 (Missing Data, MD) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,

R,W,De,Gd), T∗ is the set of all weak firing subsequences, ∃σ∈T∗, and ∃ti∈σ:pI∈⋅ti. A data item d∈Dis missing if it satisfies one of the following conditions:

(1) ∃t′∈T, ∀t∈σ:(t≻t′)∧[((d∉W(t))∧(d∈De(t)∪⁡R(t′)))∨((d∉W(t)∪⁡W(t′))∧(d∈

(2) ∃t∈σ, ∃t′′∈T,∀t′∈T:(t≻t′′)∧(t≻t′)∧(t′≻t′′)∧[d∈W(t)∩(De(t)∪⁡De(t′))∩(R(t′′)

∪⁡De(t′′))]∧(d>x<R(t′))∧[d∉W(t′)∪⁡W(t′′)], which is denoted by d<⋅MD.

Notice that if there exist t,t′∈T such that (t≻t′)∧[d∈W(t)∩(R(t′)∪⁡De(t′))]∧[d∉De(t)∪⁡W(t′)], then d may be missing, e.g., Figs. 4c, 4d and 4f.

Figure 4: The data item d is missing, where Type(d)=Cons or Type(d)=Vari. (a)--(c) d<⋅SMD; (d)--(h) d<⋅WMD

A data item d is strongly missing data (SMD) if the read or deleted values of d in all possible execution paths are never written before. A data item d is weakly missing data (WMD) if there exist some execution paths where it is read or deleted but never written before [30]. SMD and WMD belong to the missing data (MD). It is a terminal error for the execution of workflow systems [24]. For example, the data item d is strongly missing in Figs. 4a–4c, and it is weakly missing in Figs. 4d–4h.

Definition 11 (Lost Data, LD) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,Guard,R,W,

De,Gd), a data item d∈D is lost if it satisfies one of the following conditions:

(1) ∃t,t′∈T, t⋅∩⋅t′≠∅:[d∈W(t)∩W(t′)]∧[d∉De(t)∪⁡R(t′)], which is denoted by d<⋅LD; or

(2) ∃t,t′′∈T,∀t′∈T:(t≻t′′)∧(t≻t′)∧(t′≻t′′)∧[d∈W(t)∩W(t′′)]∧[d∉De(t)∪R(t′)∪W(t′)∪De(t′)∪R(t′′)], .

A data item d is strongly lost data (SLD) if the written values of d in all possible execution paths are overwritten without being read or deleted first. A data itemd is weakly lost data (WLD) if there is an execution path where it is overwritten without being read or deleted first [30]. The SLD and WLD all belong to the lost data (LD). In Figs. 5a–5c, the data item d is strongly lost and strongly redundant. Sometimes, weakly redundant in weak circulation relation can lead to weakly lost, as shown in Fig. 5d. In Fig. 5e, the data item d is weakly lost and weakly redundant. In fact, if d<⋅LD, then d<⋅RD [24]. The lost data is also called conflicting data [2].

Figure 5: The data item d is lost, where Type(d)=Cons or Type(d)=Vari. (a)--(c) d<⋅SLD; (d)--(e) d<⋅WLD

Definition 12 (Inconsistent Data, IND) Given a WFD-net system (ND,M0)=(P,T,F,M0,D,

Guard,R,W,De,Gd), a data item d∈D is inconsistent if it satisfies ∃t,t′∈T:(t⊕cdt′)∧(Type(d)=Vari)∧[d∈(R(t)∪⁡W(t)∪⁡De(t))∩(W(t′)∪⁡De(t′))], which is denoted by d<⋅IND.

In Fig. 6, the data item d is inconsistent when Type(d)=Vari. Meanwhile, the data item d is weakly lost and strongly redundant in Figs. 6a and 6c, and d is also strongly lost and strongly redundant in Fig. 6b. The error of inconsistent data comes up when a transition accesses a data item while its concurrent transitions write or delete the same data item (there is no locking mechanism [19]). Notice that, if Type(d)=Cons, there is no inconsistent data on the data item d.

Figure 6: The data item d is inconsistent, where Type(d)=Vari.(a)−(e)d<⋅ IND

A data item written by one transition may belong to several kinds of data-flow errors. The errors of inconsistent data sometimes lead to redundant, missing, or lost data. Lost data causes redundant data. In order to distinguish their relations, we reveal their scopes, as shown in Fig. 7a.

Figure 7: Four kinds of data-flow errors, i.e., redundant data (RD), missing data (MD), lost data (LD), and inconsistent data (IND). (a) The scopes of data-flow errors; (b) The hierarchy of these errors

According to the scopes of data-flow errors, we propose Algorithm 1 to detect them. This algorithm is an iterative procedure, and it consists of seven conditions. It can be used as a road map for implementing data-flow errors detection in a WFD-net system [2].

In order to guarantee the correctness of WFD-net systems, we should provide effective methods to repair different kinds of data-flow errors. However, it is unnecessary to delete the read operation in an original WFD-net system because some transitions can fire only through reading these data items [10]. More importantly, we should not change the value we need to repair all kinds of data-flow errors. When a data item in a WFD-net system only consists of a read, write, or delete operation, we need to add a write operation, remove a write operation, or remove a delete operation. How to place these read, write, and delete operations means configuring the data-flow reasonably. In detail, we need to consider the positions of a data item. If the read and write operations are in inappropriate positions, there may appear new data-flow errors. Therefore, we give the following repair strategies according to the real system requirements to repair different kinds of data-flow errors.

(5) Do not bring in more data operations in order to repair the weakly redundant;

(6) Do not repair some kinds of weakly lost data so as to satisfy the non-determinacy of some read operations afterward;

(8) Make sure that there is no inconsistent data by taking the locking mechanism.

As we know, inconsistent data often exists in concurrent programs. We can adopt the locking mechanism [18] to block the executions of multiple threads, e.g., a thread runs in a concurrent program without intervening in other threads. That is, the data item read/deleted by a thread only comes from the main thread or itself. Therefore, we do not provide related algorithms to repair this kind of error in this paper. After then, we propose Algorithms 2–4 to repair missing data, lost data, and redundant data, respectively. In the following algorithms, when we add or remove a transition, we need to add or remove its related places and arcs.

In order to repair missing data, we need to add a write operation, or remove a delete operation. It is unnecessary to remove read operations in an actual net as some transitions can fire only through reading these data items. Therefore, we propose Algorithm 2 to repair this kind of error. Its basic solutions are to introduce a transition that can write a required data item d at some point where the error occurs (i.e., Steps (1)--(12) and Steps (23)--(28) in Algorithm 2). Meanwhile, we remove some undesirable d in a delete operation (i.e., Steps (1)--(28) in Algorithm 2), and put the existing d just before all the branches where the error occurs (i.e., Steps (18)--(22) and (27)--(36) in Algorithm 2). After Steps (1)--(12), the missing data in Figs. 4a, 4b, 4d, 4e, 4g and 4h can be repaired. As for the errors in Fig. 4c (resp. Fig. 4f), we can take Steps (18)--(22) (resp. Steps (34)--(36)) to repair them. Fig. 8 shows the repairing results of missing data in Fig. 4.

Figure 8: The repairing results of Figs. 4a–4g are shown in (a)--(g), and the repairing result of Fig. 4h is shown in (h1) if Type(d)=Cons (resp. (h2) if Type(d)=Vari)

In order to repair lost data, we need to remove a write operation [10]. However, some kinds of lost data should not be repaired, especially when the type of a data item d is a variable.

If a data item is lost, it must be redundant, but not vice versa. Therefore, we propose Algorithm 3 to repair lost data before repairing redundant data. Figs. 5a–5e illustrates the cases of lost data. Its basic solutions are to remove the unnecessary data item in a write operation (i.e., Steps (1)--(4), (7)--(8), (11)--(15), and (18)--(19) in Algorithm 3) or not repair (i.e., Steps (5)--(6) and (16)--(17) in Algorithm 3). If a data item d satisfiesType(d)=Cons, the lost data in Figs. 5a–5e can be repaired after Steps (1)--(4). If a data item d satisfies Type(d)=Vari, the lost data in Figs. 5a,5c and 5d can be repaired after Steps (7)--(8). However, if a data item d satisfies Type(d)=Vari, the lost data in Figs. 5b and 5e should not be repaired because the data item d read by a transition t4 depends on the branch to fire (Steps (5)--(6) in Algorithm 3). Fig. 9 shows the repairing results of lost data in Fig. 5.

Figure 9: The repairing results of Figs. 5a–5d, are shown in (a)--(d), and the repairing result of Fig. 5e is shown in (e1) if Type(d)=Cons (resp. (e2) if Type(d)=Vari)

If a data item d is redundant, it may reduce the efficiency of programs. In order to repair this error, we need to remove a write operation [10]. However, some kinds of weakly redundant may make programs consume less memory and time. That is to say, the existence of some weakly redundant may be more convenient, and a moderate amount of weakly redundant are required, as shown in Figs. 10a–10b. Notice that we should not change the value we need when we repair this kind of error, as shown in Fig. 10c. Therefore, the following three kinds of weakly redundant should not be repaired, as shown in Fig. 10.

(1) A data item d is weakly redundant, but it is also read by more than one branch. We use n(R) to denote the number of branches that can read d. For the example of Fig. 10a, we have n(R)=2 corresponding to the transitions t2 and t3;

(2) The write operation of d is not in a weak circulation relation while the read operation is in a weak circulation relation. For the example of Fig. 10b, we use ς(W(t1)) to denote the number of times of transitions like t1 that can write d, and we use ς(R(t2)) to denote the number of times of transitions like t2 that can read d. Therefore, we have ς(W(t1))=1 and ς(R(t2))≥1; and

(3) The data item d satisfies Type(d)=Vari, and the transitions which write and read d are in weak circulation relation. For the example of Fig. 10c, we have (t2↔ct3)∧(d∈W(t1)∩R(t2)∩W(t2)∩R(t3)) and the value of d may change as d∈W(t1)∩W(t2). If we put the write operation of t2 into the same branch just before t3, we may change the value of d because t3 may not fire.

Figure 10: Three kinds of weakly redundant shouldn't be repaired. (a) d∈W(t1)∩R(t2)∩R(t3); (b) t1is not in a weak circulation relation, while t2 is in a weak circulation relation; (c) Type(d)=Vari

Figs. 3a–3f illustrates the cases of redundant data. We propose Algorithm 4 to repair this kind of data-flow error. Its basic solutions are to remove some undesirable data item d in a write operation and delete operation (i.e., Steps (1)--(5) in Algorithm 4). Meanwhile, we divide the transition that produces d into some branches, the transition with d in a write operation just before the transition read it (i.e., Steps (6)--(9) in Algorithm 4), or not repair (i.e., Steps (10)--(11) in Algorithm 4). After Steps (1)--(5), the redundant data in Figs. 3a–3d and 3f can be repaired. As for the errors in Fig. 3e, we can take Steps (6)--(9) to repair them. Fig. 11 shows the repairing results of redundant data in Fig. 3.

As we know, the error of inconsistent data exists in weak concurrency relations, and can be avoided by taking a locking mechanism. It needs to be repaired firstly. The errors of redundant data, missing data, and lost data may exist in weak concurrency relations, weak sequence relations, weak exclusiveness relations, and weak circulation relations. For the example of Fig. 4h, we have d<⋅WMD. If Type(d)=Cons, we need to add a new transition tkinto T satisfying (tk→ct2)∧(tk→ct3)∧(d∈W(tk)) (i.e., Steps (4)--(5) in Algorithm 2), as shown in Fig. 8h1. However, this would bring in weakly redundant data (i.e., d<⋅WRD). Based on the Steps (1)--(36) in Algorithm 2 and Steps (1)--(22) in Algorithm 3, when we repair missing data, we haven't brought in lost data, and vice versa. For the example of Fig. 5a, we have d<⋅SLD. We need to remove the data item d from W(t1)(i.e., Steps (1)--(10) in Algorithm 3). However, after taking this algorithm to repair, there are still exist weakly redundant data (i.e., d<⋅WRD), as shown in Fig. 9a. The lost data belongs to redundant data. After repairing lost data, the redundant data may still exist. Based on Steps (1)--(13) in Algorithm 4, when we repair redundant data, we have not brought in lost data or missing data. As we know, the transitions with missing data have no right to fire, and possibly making WFD-net systems stop at a nonterminal state. In other words, missing data may lead to terminal errors [24]. Compared with missing data, lost data and redundant data are not terminal errors. Therefore, the missing data needs to be repaired secondly and the lost data needs to be repaired thirdly. Based on these analyses, we organize the data-flow errors into a hierarchy, as shown in Fig. 7b. This hierarchy can help us avoid bringing in new unnecessary data-flow errors as far as possible when we repair one kind of error.

This paper aims to detect and repair data-flow errors, and guarantees the correctness of a WFD-net system. For the example of Fig. 1, we can find that the data item d7 is a missing data in R(t9), i.e., d7<⋅MD. Obviously, the transition t9 cannot fire if we do not repair this kind of error.

Based on Definitions 9–12, we analyze the data-flow errors in Fig. 1. By taking Algorithms 2–4, we repair these errors, and their results are shown in Fig. 12.

(2) Due to the fact that (d1<⋅SMD)∧(Type(d)=Cons) in R(t3) and R(t7), we can remove d1∈De(t2) (Steps (18)--(22) in Algorithm 2);

(3) Since d7<⋅WMD in R(t9), we can add a transition tk with d7∈W(tk) and related places as well as arcs in the same branch just before t9 (Steps (1)--(12) in Algorithm 2);

(4) Given d5<⋅IND∧SLD∧SRD in W(t13)∩W(t14)∩R(t15), we can adopt the locking mechanism to avoid of IND and SLD (Steps (16)--(17) in Algorithm 3). Therefore, the data item d5 read by t15 can only come from W(t13). After then, we have d5<⋅SRD in W(t14), and we should remove d5∈W(t14)(Steps (1)--(5) in Algorithm 4);

(5) Considering d6<⋅SLD∧SRD in W(t12)∩W(t13)∩R(t14)∩R(t15), we can remove d6∈W(t12) to avoid SLD and SRD (Steps (1)--(10) in Algorithm 3 or Steps (1)--(5) in Algorithm 4); and

(6) Given d4<⋅WRD in W(t3), we can divide the transition t3 into two transitions t3k andt3k′. The transition t3k′ is in the same branch just before t4 (Steps (6)--(9) in Algorithm 4).

After taking these methods, a repaired WFD-net system is shown in Fig. 12. It is a new WFD-net system without any control-flow or data-flow errors.

In this subsection, we compare our methods with some state-of-the-art methods in terms of repairing functions for data-flow errors (Fig. 13). The method of Criterias 1–3 [10] can repair data-flow errors caused by transition pairs only in weak sequence relations, and its transitions read/write at most one data item. The method of CorrDF [14] can repair data-flow errors caused by transition pairs in weak sequence relations, weak exclusiveness relations, or weak concurrency relations. Unfortunately, these methods cannot repair data-flow errors in weak circulation relations and errors caused by delete operations. By comparison, our methods overcome these deficiencies, as shown in Fig. 13.

Figure 13: A comparison with some state-of-the-art methods (e.g., Criterias 1–3 [10] and CorrDF [14]) in terms of repairing functions for data-flow errors. In this figure, N(Read)(resp. N(Write) or N(Delete)) denotes the maximum number of data items on the read (resp. write or delete) operations of a transition, where n∈N. WSR denotes weak sequence relation, WER stands for weak exclusiveness relation, WCR represents weak concurrency relation, and WCIR means weak circulation relation

In reality, a simple pseudo-code easily suffers from different kinds of data-flow errors. In this part, some experimental cases are given to show the advantages of our methods. Their detailed procedures are proceeding as follows. Firstly, we use a WFD-net system to model the real pseudo-code. Secondly, we check the data-flow errors based on Algorithm 1. After that, we use Algorithms 2–4 to repair these data-flow errors in a WFD-net system. Finally, we can obtain the repaired WFD-net system. According to the repaired WFD-net system, we can further repair the errors in the pseudo-code.

In the first experiment, we use a WFD-net system to model a simple pseudo-code with missing data, as shown in Figs. 14a and 15a. Due to the fact that the data item a read by t10 is deleted by t4, we can find (a<⋅MD)∧(Type(a)=Cons). Therefore, it is important to repair this kind of data-flow error in a suitable position. We utilize Algorithm 2 (Steps (18)--(22)) to do this work, and its result is shown in Fig. 15b. Furthermore, we can repair this pseudo-code according to the WFD-net system without missing data, as shown in Fig. 14b.

In the second experiment, we use a WFD-net system to model a simple pseudo-code with unnecessary lost data, as shown in Figs. 16a and 17a. Due to the fact that the data item a is overwritten without being read or deleted first. Therefore, we have a<⋅LD. We utilize Algorithm 3 (Steps (1)--(10)) to do this work, and its result is shown in Fig. 17b. Furthermore, we can repair this pseudo-code according to the WFD-net system without unnecessary lost data, as shown in Fig. 16b.

In the third experiment, we use a WFD-net system to model a simple pseudo-code with redundant data, as shown in Figs. 18a and 19a. Due to the fact that the data item a2 wrote by t3 is only read by t6, we can find a2<⋅RD. We utilize Algorithm 4 (Steps (6)--(9)) to do this work, and its result is shown in Fig. 19b. Furthermore, we can repair this pseudo-code according to the WFD-net system without redundant data, as shown in Fig. 18b.

Figure 18: (a) Pseudo-code with redundant data (RD) and (b) after being repaired

In the following experiment, we consider examples from the existing references. We present the advantages of our methods in repairing four kinds of data-flow errors. Fig. 20 is the result of our experiment. It shows the numbers of data items on read/write/delete operations, the numbers of guards and transitions, and the numbers of data-flow errors before and after repairing. We can find that after taking our Algorithms 2–4, most of the data-flow errors can be repaired. However, as shown in Algorithm 4, some kinds of redundant data should not be repaired, e.g., redundant data item e shown in Fig. 1 in [30]. Therefore, our methods are more effective.

Figure 20: Our experiment result in terms of the numbers of data items on read/write/delete operations, the numbers of guards and transitions, and the numbers of data-flow errors before and after repairing

WFD-net is a formal functional method to describe the control-/data-flows of workflow systems. It extends WF-net systems with three kinds of data operations (i.e., read, write, and delete operations) and guard functions. A good modeling method and efficient detecting and repairing technique are crucial for the correctness of workflow systems. Based on weak behavioral relations (i.e., weak sequence relation, weak exclusiveness relation, weak circulation relation, and weak concurrency relation) and order relation, we formalize four kinds of data-flow errors (e.g., redundant data, missing data, lost data, and inconsistent data) in a WFD-net system. Then, we reveal the relations between these data-flow errors, and organize them into a hierarchy, which is conducive to correctly repairing data-flow errors without repeated work. Furthermore, some algorithms are developed to detect and repair data-flow errors in WFD-net systems according to system requirements and repair strategies. Compared with the existing methods, our methods can repair data-flow errors in weak circulation relations and errors caused by delete operations. What's more, our methods can avoid bringing in new unnecessary errors when repairing some kinds of data-flow errors.

(1) We analyze the behavioral consistency of WFD-net systems, and study what kind of data-flow error affects the behavioral consistency degree;

(2) We develop a tool to repair some unnecessary data-flow errors automatically based on system requirements; and

(3) We intend to consider the process mining with timestamps in the workflow processes, and use the unfolding-based technique [7] to detect and repair their data-flow errors.

Funding Statement: This work was supported in part by the Shanghai Science and Technology Innovation Action Plan (Grant No. 19511101300), in part by the Key Laboratory of EMBEDded System and Service Computing (Ministry of Education) (Grant Nos. ESSCKF201902 and ESSCKF202102), and in part by the National Nature Science Foundation of China (Grant Nos. 62172299 and 62032019).

Conflicts of Interest: The authors declare that they have no conflicts of interest to report regarding the present study.

References

Davenport, T. H. (1993). Process innovation: Reengineering work through information technology. Boston, MA, USA: Harvard Business School Press.
Sun, S. X., Zhao, J. L., & Nunamaker, J. F. (2006). Formulating the data-flow perspective for business process management. Information Systems Research, 17(4), 374-391. [Google Scholar] [CrossRef]
Stohr, E., & Zhao, J. L. (2001). Workflow automation: Overview and research issues. Information Systems Frontiers, 3(3), 281-296. [Google Scholar] [CrossRef]
Sarnikar, S., Zhao, J. L., Kumar, A. (2004). Organizational knowledge distribution: An experimental evaluation. Americas Conference on Information Systems, pp. 2305–2341. New York.
Kabbaj, M. I., Abdelkader, B., Bakkoury, Z., & Rharbi, A. (2015). Towards an active help on detecting data-flow errors in business process models. International Journal of Computer Science and Applications, 12(1), 16-25. [Google Scholar]
Xiang, D. M., Liu, G. J., Yan, C. G., & Jiang, C. J. (2018). Detecting data-flow errors based on petri nets with data operations. IEEE/CAA Journal of Automatica Sinica, 5(1), 251-260. [Google Scholar] [CrossRef]
Xiang, D. M., & Liu, G. J. (2020). Checking data-flow errors based on the Guard-driven reachability graph of WFD-net. Computing and Informatics, 39, 193-212. [Google Scholar] [CrossRef]
Xiang, D. M., Liu, G. J., Yan, C. G., & Jiang, C. J. (2021). A Guard-driven analysis approach of workflow net with data. IEEE Transactions on Services Computing, 14(6), 1650-1661. [Google Scholar] [CrossRef]
Awad, A., Decker, G., Lohmann, N. (2009). Diagnosing and repairing data anomalies in process models. International Conference on Business Process Management. Business Process Management Workshops, pp. 5–16. Germany.
Song, W., Ma, X. X., Cheung, S. C., Hu, H., Lü, J. (2010). Preserving data-flow correctness in process adaptation. IEEE International Conference on Services Computing, pp. 9–16. Miami, USA.
Weidlich, M., Polyvyany, A., Mendling, J., & Weske, M. (2011). Causal behavioral profiles-efficient computation, applications, and evaluation. Fundamental Informaticae, 113(3–4), 399-435. [Google Scholar] [CrossRef]
Koehler, J., Hauser, R., & Kuster, J. M. (2008). The role of visual modeling and model transformations in business-driven development. Electronic Notes Theory Computer Science, 211, 5-15. [Google Scholar] [CrossRef]
Sadiq, S., Orlowska, M., Sadiq, W., Foulger, C. (2003). Data flow and validation in workflow modeling. Conferences in Research and Practice in Information Technology, pp. 207–214. Dunedin, New Zealand.
Sharma, D., Pinjala, S., Sen, A. K. (2014). Correction of data-flow errors in workflows. 25th Australasian Conference on Information Systems, pp. 1–10. Auckland, New Zealand.
Best, E., & Wimmel, H. (2013). Structure theory of Petri nets. Transactions on Petri nets and other models of concurrency VII, 7480, 162-224. [Google Scholar] [CrossRef]
Wang, S. G., Gan, M. D., Zhou, M. C., & You, D. (2015). A reduced reachability tree for a class of unbounded petri nets. IEEE/CAA Journal of Automatica Sinica, 2(4), 345-352. [Google Scholar] [CrossRef]
Fang, X. W., Jiang, C. J., Yin, Z. X., & Fan, X. Q. (2011). The trustworthiness analyzing of interacting business process based on the induction information. Computer Science and Information Systems, 8(3), 843-867. [Google Scholar] [CrossRef]
Clempner, J. (2014). Verifying soundness of business processes: A decision process Petri nets approach. Expert Systems with Applications, 41, 5030-5040. [Google Scholar] [CrossRef]
Lourenco, J. M., Fiedor, J., Krena, B., Vojnar, T. (2018). Discovering concurrency errors. In: Lecture on runtime verification, vol. 10457, pp. 34–60. Germany: Springer.
Henkel, M., Zdravkovic, J., Johannesson, P. (2004). Service-based processes: Design for business and technology, pp. 21–29. USA: ACM Digital Library.
Andersson, B., Bergholtz, M., Edirisuriya, A., Ilayperuma, T., & Johannesson, P. (2005). A declarative foundation of process models. Lecture Notes in Computer Science, 3520, 233-247. [Google Scholar] [CrossRef]
Sundari, M. H., Sen, A. K., Bagchi, A. (2007). Detecting data-flow errors in workflows: A systematic graph traversal approach. 17th Workshop on Information Technology and Systems, pp. 1–6. Montreal.
Sun, S. H., Zhao, J. L. (2008). Developing a workflow design framework based on data-flow analysis. Proceedings of the 41st Hawaii International Conference on System Sciences, pp. 7–10. Waikoloa.
Meda, H. S., Sen, A. K., & Bagchi, A. (2010). On detecting data-flow errors in workflows. ACM Journal of Data and Information Quality, 2(1), 1-31. [Google Scholar] [CrossRef]
Sidorova, N., Stahl, C., & Trcka, N. (2011). Soundness verification for conceptual workflow nets with data: Early detection of errors with the most precision possible. Information Systems, 36, 1026-1043. [Google Scholar] [CrossRef]
Haddar, N., Tmar, M., & Gargouri, F. (2016). A Data-centric approach to manage business processes. Computing, 98, 375-406. [Google Scholar] [CrossRef]
Dolean, C. C., & Petrusel, R. (2012). Data-flow modeling: A survey of issues and approaches. Informatica Economica, 16(4), 117-130. [Google Scholar]
Dramski, M. (2017). Missing data problem in the event logs of transport processes. International Conference on Transport Systems Telematics, pp. 110–120. Katowice.
Trcka, N., van der Aalst, W. M. P., Sidorova, N. (2008). Analyzing control-flow and data-flow in workflow processes in a unified way. Computer Science Reports, 1–23. DOI 10.1.1.501.519.
Trcka, N., van der Aalst, W. M. P., Sidorova, N. (2009). Data-flow anti-patterns: Discovering data-flow errors in workflows. International Conference on Advanced Information Systems Engineering, vol. 5565, pp. 425–439. Amsterdam, Netherlands.
von Stackelberg, S., Putze, S., Mvlle, J., & Bohm, K. (2014). Detecting data-flow errors in BPMN 2.0. Open Journal of Information Systems, 1(2), 1-19. [Google Scholar]
Song, W., Zhang, C., & Jacobsen, H. (2018). An empirical study on data flow bugs in business processes. IEEE Transactions on Cloud Computing, 9(1), 1-14. [Google Scholar] [CrossRef]
Mülle, J., Tex, C., & Bohm, K. (2019). A practical data-flow verification scheme for business processes. Information Systems, 81, 136-151. [Google Scholar] [CrossRef]
Jovanovikj, I., Yigitbas, E., Gerth, C., Sauer, S., Engels, G. (2019). Detection and resolution of data-flow differences in business process models. CAiSE Forumn 2019, vol. 350, pp. 145–157. Germany: Springer.
Wang, M. M., Liu, G. J., Zhao, P. H., Yan, C. G., & Jiang, C. J. (2018). Behavior consistency computation for workflow nets with unknown correspondence. IEEE/CAA Journal of Automatica Sinica, 5(1), 281-291. [Google Scholar] [CrossRef]
Qi, L., Zhou, M. C., & Luan, W. J. (2018). A two-level traffic light control strategy for preventing incident-based urban traffic congestion. IEEE Transactions on Intelligent Transportation Systems, 19(1), 13-24. [Google Scholar] [CrossRef]
Song, W., Chang, Z., Jacobsen, H., Zhang, P. W. (2021). Discovering structural errors from business process event logs. IEEE Transactions on Knowledge and Data Engineering (Early Access), 1–14. DOI 10.1109/TKDE.2021.3052927. [CrossRef]
Wang, S. G., Gan, M. D., & Zhou, M. C. (2015). Macro liveness graph and liveness of w-independent unbounded nets. Science in China Series F: Information Sciences, 58(3), 1-10. [Google Scholar] [CrossRef]
Song, W., Jacobsen, H., & Chen, F. F. (2019). Scientific workflow protocol discovery from public event logs in clouds. IEEE Transactions on Knowledge and Data Engineering, 32(12), 2453-2466. [Google Scholar] [CrossRef]
Liu, C., Zeng, Q. T., Cheng, L., Duan, H., & Zhou, M. C. (2021). Privacy-preserving behavioral correctness verification of cross-organizational workflow with task synchronization patterns. IEEE Transactions on Automation Science and Engineering, 18(3), 1037-1048. [Google Scholar] [CrossRef]
Zhao, F., Xiang, D. M., Liu, G. J., Jiang, C. J. (2021). A new method for measuring the behavioral consistency degree of WF-net systems. IEEE Transactions on Computational Social Systems (Early Access), 1–14. DOI 10.1109/TCSS.2021.3099475. [CrossRef]
Guang, M. J., Yan, C. G., Wang, J. L., Qi, H. D., Jiang, C. J. (2021). Benchmark datasets for stochastic petri net learning. International Joint Conference on Neural Networks, pp. 1–8. Shenzhen, China. DOI 10.1109/IJCNN52387.2021.9533785. [CrossRef]
Weidlich, M., Mendling, J., & Weske, M. (2011). Efficient consistency measurement based on behavioral profiles of process models. IEEE Transactions on Software Engineering, 37(3), 410-429. [Google Scholar] [CrossRef]

Nomenclature
N	Set of Positive Integers
>x<	∈ or ∉
RD	Redundant Data
MD	Missing Data
LD	Lost Data
IND	Inconsistent Data