An Incremental and Backward-Conﬂict Guided Method for Unfolding Petri Nets

: The unfolding technique of Petri net can characterize the real concurrency and alleviate the state space explosion problem. Thus, it is greatly suitable to analyze/check some potential errors in concurrent systems. During the unfolding process of a Petri net, the calculations of conﬁgurations, cuts, and cut-off events are the key factors for the unfolding efﬁciency. However, most of the unfolding methods do not specify a highly efﬁcient calculations on them. In this paper, we reveal some recursive relations and structural properties of these factors. Subsequently, we propose an improved method for computing conﬁgurations and cuts. Meanwhile, backward conﬂicts are used to guide the calculations of cut-off events. Moreover, a case study and a series of experiments are done to illustrate the effectiveness and application scenarios of our methods.


Introduction
Nowadays, concurrent systems have been successfully applied to various scenarios, e.g., large-scale websites, railway traffic systems, and telecom operation-support systems. Although high concurrency can indeed enhance their performance and throughput, it easily leads to some errors, such as deadlocks, a lack of synchronization, and data inconsistencies, especially when a concurrent system deals with a great amount of data. For example, Apache Httpd (an open-source web server) suffered from deadlocks that were caused by its unix mutex (https://www.sqlite.org/src/info/a6c30be214, (accessed on 2 January 2021)). The errors of data inconsistency in an IPO (Initial Public Offering) Cross system made NASDAQ (Nasdaq OMX Group, Inc, NewYork, USA ) lose $13 million in May, 2012 (https://www.computerworld.com/article/2727012/nasdaq-s-facebook-glitch-camefrom-race-conditions.html, (accessed on 5 January 2021)). Therefore, some model-checkingbased methods are proposed for checking the correctness and reliability of concurrent systems. Petri net is widely used to model and verify concurrent systems due to its great capability of explicitly specifying parallelism, concurrency, and synchronization [1][2][3]. The classical reachability graph (CRG) of Petri net is a commonly used technique for checking deadlocks, reachability, and soundness of concurrent systems [4][5][6]. However, this technique easily has the problem of the state space explosion because it is based on the interleaving semantics [7] of concurrent events/actions. The interleaving semantics of CRG only considers the partial orders of business activities, and utilizes the global states of concurrent systems to describe and analyze their behaviors. Thus, a CRG needs to find out all precedence relations between activities, generate successor states, and eventually form some symmetry diamond structures.
When compared with the reachability-graph-based method, the unfolding technique [8] of Petri nets can both alleviate the state space explosion problem and characterize In this paper, we reveal some deep properties of configuration, cuts, and cut-off events, and then utilize recursion formulas and characterized structures to improve these calculations. Some algorithms are developed to perform these calculations and generate finite complete prefixes (FCPs). What is more, all of these improvements can be applied into the existing unfolding techniques and they contribute to the related model checkings.
The main contributions are summarized, as follows: (1) Incremental methods are proposed to calculate configurations, cuts and concurrent conditions. (2) Backward conflicts are used to guide the determination of cut-off events.
(3) A tool is developed to implement our improved methods for unfolding a Petri net.

The Unfolding Techniques of Petri Nets
McMillan [8] initially proposed the net unfolding technique with partial-order semantics of Petri nets. As an improvement of McMillan's unfoldings, Esparza et al. [13] proposed a family of algorithms (i.e., ERV unfolding method) to construct a finite complete prefix. Whereafter, its parallel unfolding [19] came up. Khomenko et al. [20] proposed a cutting context to determine static cut-off events and generate canonical prefixes. Bonet et al. [12] generalized the notion of cutting context and provided a user-oriented framework of the unfolding technique. Couvreur et al. [21] proposed a new model of branching processes without any finiteness or safeness assumptions, which are suitable for describing the behavior of general Petri nets. Bonet [15] utilized the problem-specific information as a heuristic function to guide the unfolding of Petri net towards the desired marking. Rodriguez et al. [22] combined partial order reductions (POR) with net unfoldings to tackle the state space explosion problem. Chatain et al. [23] proposed a goal-driven unfolding technique with model reduction to explore the minimal configurations that can lead to a given marking.
These studies of unfolding methods mainly focus on how to generate a smaller FCP by unfolding a Petri net, or explore different kinds of Petri net unfoldings, e.g., unbound Petri net [24], timed Petri net [25], colored Petri net [26], contextual Petri net [27], and Nested Petri nets (NP-net) [28]. However, they easily have a low efficiency in the calculations of configurations, cuts, and cut-off events. We propose an improved method for unfolding a Petri net in this paper in order to solve this problem.

Model Checking Based on Petri Net Unfolding
The unfolding technique of Petri net has been widely used in model checking, e.g., diagnosing faults in asynchronous discrete event systems [16], making a concurrent planning [17], generating test cases for multi-threads [18], and checking deadlock [29], soundness [5], reachability, and coverability [30].
McMillan [8] first used the unfolding technique to verify asynchronous circuits. De León et al. [31] presented a test generation algorithm for a complete test suite w.r.t. concurrent conformance relation based on the unfolding of IOPN. Jezequel et al. [32] extended a distributed unfolding technique with time stamps to build testers for distributed systems. Saarikivi et al. [33,34] computed the minimal test suites for multi-threaded programs based on unfolding techniques. Liu et al. [5] proposed the basic unfolding of Petri net to check the soundness of workflow systems. Lutz-Ley et al. [35] analyzed the stability of discrete event systems that are based on the unfolding technique of Petri net. Meyer et al. [36] translated finite control processes into a safe Petri net, and utilized the unfolding-based method to verify Mobile Systems. Ponce-de-Leon et al. [37] used the unfolding technique of Petri net to discover a process model. Weidlich et al. [38] calculated the behavioral consistency of process models based on Petri-net unfoldings. Xiang et al. [39] used the unfolding of PD-net to detect the errors of data inconsistency.
When compared with these model checking methods, we can more effectively check errors of concurrent systems based on our unfolding method, since it records as much contextual information as possible and improves the calculational efficiency of Petri net unfolding.

Basic Notations
Some basic notations are introduced in this section, e.g., Petri net, occurrence net, and branching process.

Definition 1.
A net is a triple N = (P, T, F), where (1) P and T are two disjoint and finite sets, which are, respectively, called place set and transition set; and, (2) F ⊆ (P × T) ∪ (T × P) is a flow relation.
A marking of a net is a mapping M: P → N, where N = {0, 1, 2, · · · } is a set of nonnegative integers. In this paper, a multiset of places represents a marking. A Petri net is a net N with an initial marking M 0 , and denoted as Σ = (N, M 0 ). For a node x ∈ P ∪ T, its pre-set is denoted as • x = {y|y ∈ P ∪ T ∧ (y, x) ∈ F} and post-set x • = {y|y ∈ P ∪ T ∧ (x, y) ∈ F}. For a node set X ⊆ P ∪ T, its pre-set is • X = x∈X • x and post-set Given a Petri net Σ = (P, T, F, M 0 ), a transition t ∈ T is enabled at a marking M if ∀p ∈ P: p ∈ • t ⇒ M(t) ≥ 1, which is denoted by M[t . After firing an enabled transition t at M, a new marking M is generated and denoted as The set of reachable markings from M is denoted by R(M). For example, Figure 2a is a Petri net, Definition 2 (Causality, conflict and concurrency). In an acyclic net N = (P, T, F), given two nodes x, y ∈ P ∪ T, (1) x and y are in causality, which is denoted by x ≤ y, if the net contains a path from x to y.
Especially, if x = y, it is denoted as x < y. (2) x and y are in conflict, which is denoted by x#y, if ∃ t 1 , t 2 ∈ T: and t 2 ≤ y; or, (3) x and y are in concurrency, denoted by x co y, if there is neither x < y, nor y < x, nor x#y. An occurrence net is a special net, and its formal definition is given, as follows.
In an occurrence net, places and transitions are usually called conditions and events, respectively. In general, we use O = (B, E, G) to denote an occurrence net, where B, E, and G are, respectively, sets of conditions, events, and arcs. Min Based on occurrence net, a branching process of a Petri net is defined, as follows. (2) for every e ∈ E, the restriction of h onto • e (resp., e • )) is a bijection between • e and • h(e) (resp., between e • and h(e) • ); (3) the restriction of h onto Min(O) is a bijection between Min(O) and M 0 ; and, (4) for every e 1 ,e 2 ∈ E, if • e 1 = • e 2 and h(e 1 ) = h(e 2 ), then e 1 = e 2 .

Finite Complete Prefix
All of the branching processes of a Petri net Σ form a partially ordered set w.r.t. the binary relation prefix. Its greatest element is called Unfolding of Σ, which is denoted as Un f (Σ). In order to generate the unfolding of a Petri net, some related definitions and calculations are introduced, such as configuration, co-set, and cut-off event.
Definition 6 (Configuration [8]). A configuration C of a branching process is defined as a set of events, such that C is causally closed (i.e., e ∈ C ⇒ ∀e ≤ e: e ∈ C) and conflict-free (i.e., ∀e, e ∈C : ¬(e#e )).
A local configuration of an event e is [e] ={e | e ≤ e, e ∈ E}. Especially, if an event set E satisfies ∀e 1 , e 2 ∈ E : e 1 co e 2 , then its local configuration is [E ] = e∈E [e]. The set of all (resp. local) configurations of a branching process β is denoted by C β (resp. C L β ). Obviously, a (local) configuration represents a possible partial run of a Petri net [8].
A set of conditions is a co-set if its elements are pairwise in concurrency relation. A cut is a maximal co-set with respect to the set inclusion relation ⊂. The set of all cuts of a branching process β is denoted by CT β . For the example of Figure 2c, [e 5 ] = {e 0 , e 2 , e 3 , e 5 }, [e 2 , e 3 ] = {e 0 , e 2 , e 3 } and {b 2 , b 9 } is a cut.
In fact, configurations, cuts, and reachable markings are closely connected by the following formulas [13], i.e., where C is a finite configuration of a branching process β, M ∈ R(M 0 ) is a reachable marking, Cut : C β → CT β is a cut function that maps a configuration set into a cut set, and the function Mark : Although the unfolding records all the running information of a Petri net, it is infinite if there exists an infinite firing transition sequence. For example, the unfolding of Figure 2a is infinite, because there is a loop from t 4 to t 6 . Thus, it is hard to utilize an infinite unfolding to analyze a concurrent system. In order to solve this problem, a finite and complete prefix (FCP) [4,5,39] is proposed.
A prefix Fin is an FCP if it satisfies finiteness and completeness, i.e., • Fin only contains finitely many events and conditions; and, • for every reachable marking M there exists a configuration C in Fin such that Mark(C) = M, and for every transition t enabled by M there exists a configuration C ∪ {e} such that e / ∈ C and e is labeled by t.

The Classical Algorithm for Generating an FCP
In order to generate an FCP, cut-off events (Definition. 7) are proposed to determine which events are not added into a given prefix when guaranteeing its finiteness and completeness. In other words, the unfolding of Petri net is truncated by cut-off events. For the example of Figure 2d, e 6 is a cut-off event, because Mark([ where < e is an adequate order and was first used in Petri net unfolding by Esparza et al. [13]. Definition 7 (Cut-off event). Let β be a prefix, and e 1 , e 2 be two events. The event e 2 is a , where is an adequate order that is a strict well-founded partial order on a set of prefix and it refines ⊂, i.e., An FCP can be generated with many unfolding methods. In general, their basic idea is that for a given finite prefix, one of its possible extensions (corresponding to enabled transitions) is selected and added into it if the possible extension is not a cut-off event; and, then, for this new finite prefix, the above operation is continually conducted until all of the possible extensions are cut-off events or there is no possible extension. In this basic process, possible extensions are those transitions that can be added into a given prefix, while cut-off events determine its boundaries and scales. Corresponding to the basic idea, Algorithm 1 [13] shows a general method for producing an FCP. In this algorithm, the function PosExtend(Fin) is used to calculate all possible extensions of a given prefix Fin, i.e.,

Discussion
Many unfolding methods of generating FCPs have been proposed based on Algorithm 1, such as merged process and directed unfolding. Although these methods can generate different FCPs for a given Petri net, all of them cannot work without the calculations of configurations, cuts (or concurrent conditions), and cut-off events, since they are performed according to Definitions 6 and 7 and Equations (1)-(3). Obviously, these calculations can directly affect the unfolding efficiency of Petri nets. However, the related computing methods of configurations, cuts, and cut-off events easily suffer from the following problems: (1) The repeated calculations of configurations and cuts.
The calculations of configurations and cuts need to be repeatedly conducted without considering the causality and recurrence relations between events. For example, in order to calculate the local configuration of e 6 in Figure 2d, it needs to find out all of the events that are in casuality with it. Thus, we can get [e 6 ] = {e 1 , e 4 , e 6 } according to Definition 6. In fact, some events of [e 6 ] have been previously obtained by calculating the local configurations of e 6 's prep-sets. This is because e 4 < e 6 and ∀e ∈ [e 4 ] : e < e 4 ⇒ e < e 6 . Similarly, in order to calculate the cut of [e 6 ], it needs to find out all the pre-/post-sets of [e 6 ], i.e., Cut([ ]. In fact, some results can be calculated by e 6 's prep-sets since their local configurations have been obtained. (2) The blindness in determining cut-off events.
According to the definition of cut-off events, we know that, once a new event is generated and added into a given prefix, it needs to match with all of the existing events, so as to determine whether it is a cut-off event. For example, if we determine whether e 6 is a cut-off event in β 3 of Figure 2d, it has to find out one event e from the existing event set {e 0 , e 1 , e 2 , e 3 , e 4 , e 5 } satisfying [e] [e 6 ] ∧ Mark[e]= Mark[e 6 ]. In fact, some transitions with certain structures correspond to these cut-off events. Hence, we can utilize them to guide the determination of cut-off events rather than the blind matchings with all events.

An Improved Computing Method for Unfolding Petri Nets
In this section, we propose an incremental and backward-conflict guided method for calculating configurations, cuts, and cut-off events. Furthermore, an improved unfolding algorithm is developed to do some model checkings.

The Incremental Calculations of Configurations and Cuts
We can easily derive Lemma 1 because a configuration is causally closed and conflict-free.
From Lemma 1, we can find that the local configuration of an event can be recursively calculated by its prep-sets. Furthermore, these prep-sets can also compute the post-/pre-set of this local configuration.
In this paper, all of the local configurations can be represented by a configuration matrix. Thus, once a new event is added into a given prefix, its new local configuration can be calculated by Lemma 1, and a new configuration matrix of this prefix is accordingly updated. Figure 3 shows the configuration matrices of β 1 and β 2 in Figure 2b,c, respectively. From Figure 3, we can find that the local configuration of e 5 can be calculated by a logical OR operation on the local configurations of e 2 and e 3 in the configuration matrix of β 1 . We propose the following theorems to reveal the recursive relations between an event and its prep-sets in order to improve the calculations of cuts. Theorem 1. If C is a configuration of a branching process β, then there exists a set of events Proof. If e ∈ [E ], then e ∈ C. It is assumed that ∃e ∈ C : e ∈ [E ]. From this assumption, we can easily get e / ∈ E . Because C is a configuration, then ∃e ∈ E : e ≤ e . However, e ∈ E. Obviously, it contradicts the above assumption. Hence, if e ∈ C, then e ∈ [E ]. Therefore, [E ] = C.
According to Theorem 1, we can further obtain the following formula.
Based on Theorem 2 and Equation (5), we can utilize these recursive relations between an event and its prep-set to calculate the related cuts. For the example of Figure 2c Although Equation (3) gives the calculation of possible extensions, it is not easy to find out all of the co-sets in the unfolding process of Petri nets. For example, if we determine whether the transition t 5 can be added into the prefix β 1 in Figure 2b, it has to find out all related concurrent conditions from the existing ones. In fact, we can utilize the concurrency relation of the prep-sets of a condition to recursively calculate its concurrent conditions, and then compute all possible extensions.
Therefore, in order to determine whether a transition t can be added into a given prefix β, it is necessary to find a co-set X in β much more efficiently, which satisfies h(X) = • t and (t, X) / ∈ β. Because of the fact that concurrent conditions make up a co-set, we can utilize the recursive relation between an event and its prep-sets to improve their calculations.
Stefan Romer [40] gives this recursive relation, and shows that the concurrent conditions of one condition can be recursively calculated by its prep-sets. That is, if Cob(b) = {b |b co b , b ∈ B} denotes the concurrent conditions of a condition b, then For the example of Figure 2c, In this paper, all the concurrent relations of conditions can be represented by a concurrency matrix. Thus, once a new event is added into a given prefix, the new concurrent conditions can be calculated by Equation (6), and a new concurrency matrix is accordingly updated. Figure 4 shows the concurrency matrices of β 1 and β 2 in Figure 2b,c, respectively. From Figure 4, we can find that the concurrent conditions of b 9 can be calculated by a logical AND operation on the concurrent conditions of b 6 and b 7 in the concurrency matrix of β 1 . Based on the recursive calculation of concurrent conditions, we give a specific algorithm for calculating possible extensions, as shown in Algorithm 2.

Require:
A prefix β and its concurrency matrix A of conditions; Ensure: A set of possible extensions Pe; 1: for each t ∈ T do 2: Find out a set of event X such that h(X) = • t; 3: if X is a co-set in A and (t, X) / ∈ Pe then 4: Add (t, X) into Pe;

The Backward-Conflict Guided Calculations of Cut-Off Events
According to the definition of cut-off events (Definition 7) and Theorem 2, our incremental calculations of configurations and cuts are also conductive to the determination of cut-off events since they are closely related with these calculations. In this part, we utilize backward conflicts (Definition 9) [17] to further guide the calculations/matchings of cut-off events.
Definition 9 (Backward conflict). Two different transitions, t 1 and t 2 , are in backward conflict if As is well known, the initial marking M 0 of a Petri net is possibly equal to the Mark function value of the local configuration of an event e in a prefix, i.e., Mark([e]) = M 0 . In fact, this event is a cut-off event, and it guarantees the finiteness and completeness of this prefix. Therefore, in order to efficiently calculate cut-off events in this case, we first transform the places with tokens and input transitions into backward-conflict structures (Notice that this transformation does not affect the properties of original Petri nets). That is to say, if there exists a place p in a Petri net Σ that satisfies M 0 (p) > 0 ∧ |p • | > 0, we add a new place p , a new transition t and some arcs (i.e., flow relations {p } × {t } and {t } × {p} ) into Σ. Meanwhile, the new initial marking becomes M 0 , and it satisfies Figure 5 shows this transformation process of a Petri net before unfolding it. After transforming into some backward-conflicts, we can use these structures to guide the related matchings with certain existing events, so as to determine cut-off events.

Lemma 2.
If an event e 2 is a cut-off event of a branching process with respect to an event e 1 , then For example, e 6 is a cut-off event with respect to e 1 in Figure 2d, where h(e 6 ) • ∩ h(e 1 ) • = ∅. In fact, the transitions h(e 6 ) and h(e 1 ) are in backward conflict. Therefore, Lemma 2 shows the relation between cutoff events and backward-conflict transitions. Furthermore, we can determine whether an event is a cutoff event only when it corresponds to a backward-conflict transition.
Specifically, a function of possible cut-off transitions with respect to a Petri net Σ is given to guide the determination of cut-off events in this paper, i.e., Furthermore, we can easily get the following theorem.
Theorem 3. Let Σ be a Petri net and β be a branching process of Σ. If e is a cut-off event of β, then h(e) ∈ PosCuto f f (Σ).
According to Theorem 3, we match a new event with PosCuto f f (Σ) to determine whether it is a cut-off event. For the example of Figure 2d, e 6 is a cut-off event with respect to e 1 , where t • 1 ∩ t • 6 = ∅, PosCuto f f (Σ) = {t 1 , t 6 }, and h(e 6 ) ∈ PosCuto f f (Σ).

An Improved Algorithm for Generating an FCP
Based on the above new calculations of configurations, cuts, and cut-off events, we propose an improved method for unfolding a Petri net, as shown in Figure 6. Corresponding to this basic process, we develop an incremental and backward-conflict guided algorithm for generating an FCP, as shown in Algorithm 3.
• The contexts of events are calculated in Lines 10-15 according to Equation (5) and Theorem 2. • Algorithm 2 is utilized to calculate the possible extensions.
• Linked hash tables are used to store the contexts of events and concurrent conditions, which contribute to the calculations of set operations in Equations (4) and (5). • Cut-off events are determined by Theorem 3, and Lines 19-22 correspond to this point. Determine whether e is a cutoff event through Hash and Pc; 21: if e is a cutoff event then 22: Cuto f f := Cuto f f ∪ {e}; 23: end if 24: end if 25: else 26: pe := pe\{e}; 27: end if 28: end while 29: Delete events, conditions and arcs that are caused by pre-processing Σ. 30: return Fin;

The Validation of Our Improved Unfolding Method
The prefix generated by Algorithm 3 is finite and complete, since it is the same as that by the classical unfolding. What is more, our new computing methods can improve the unfolding efficiency of Petri nets as compared with Algorithm 1 due to the fact that recursive relations, contextual information, and backward conflicts are considered in our specified calculations. Moreover, the result of our improved method is guaranteed by the following factors. On the one hand, we derive Equations (4)-(6) according to Lemma 1, Theorems 1 and 2. Based on these Equations, we can utilize the prep-transition e (i.e., predecessor) of an event e to calculate its cuts if | •• e| = 1 (Algorithm 3).  (7)) to determine whether it is a cut-off event according to Lemma 2 and Theorem 3. By comparison, the classical unfolding methods need to match a new event with all existing events. What is more, the time complexity of classical unfolding methods is generally O(L 2 ), while our improved calculation is O(KL), where L is the number of total events and K is the number of events that map to PosCuto f f (Σ). Note that, K is much less than L (i.e., K << L) with the increase of L. Thus, our improved unfolding method saves much time in the runtime of calculating cut-off events. Nevertheless, our method takes up more space than the classical unfolding, because it needs to store many more contextual results.

Model Checkings Based on the Improved Unfolding Method
Our improved computing method for unfolding Petri nets can be applied to many model checkings.
(1) Embedded into the existing unfolding techniques The new calculations of configurations, cuts, concurrent conditions (possible extensions), and cut-off events can be applied in various kinds of unfolding techniques, e.g., ERV unfolding, merged process and directed unfolding. As is well known, ERV unfolding proposes a new classical algorithm for improving the McMillan's unfolding. The merged process (MP) generates a condensed unfolding of a Petri net's behavior. Directed unfolding (DU) utilizes heuristic functions to guide the unfolding process of Petri nets. Given these unfolding techniques, our improved computing methods can replace their calculations of configurations, cuts, and cut-off events. Meanwhile, our new calculations can be further combined with partial orders, merged conditions and heuristic functions in their related unfolding methods of Petri nets. By this means, our new computing methods can enhance these unfolding techniques and improve their model checkings.

• Reachability
On the one hand, we can utilize the directed unfolding technique [15] to verify the reachability of markings or places. On the other hand, some incremental calculations of configurations (e.g., configuration matrix) can be used to check whether a transition is reachable to the other one in the execution of a Petri net. That is, given two transitions t 1 , t 2 ∈ T and two events e i , e j ∈ E, if the configuration matrix A of an FCP satisfies A (i,j) = 1 ∧ h(e i ) = t 1 ∧ h(e j ) = t 2 , then we can come to the conclusion that t 2 is reachable to t 1 . Notice that e i and e j are, respectively, the i-th and j-th elements of E.

• Properly completed
As is well known, a WF-net where o is the sink place [44]. In order to verify this property, we can determine whether there exist some conditions that are concurrent with sink conditions (i.e., corresponding to the sink places) in our concurrency matrix. If these conditions exist, they indicate that Σ is not properly completed or sound.

• Deadlocks
Because the context of an event is calculated in our improved unfolding method, we can utilize its cuts and Mark functions to check deadlocks, i.e., a marking M is a deadlock if ∃e ∈ E : M = Mark([e]) and no transition t ∈ T is enabled at M.

Case Study
In order to illustrate the application scenarios of our improved method for unfolding Petri nets, a case study of airport check-in is given, as follows.
A passenger must check in at theairport before boarding an airplane. Figure 7 shows the basic business process of an airport check-in system (IBM: https://www.ibm.com/ developerworks/rational/library/2802.html, (accessed on 5 January 2021)). In this business process, the passengers' reservations are first checked. If their reservations are correct, these passengers can choose/change their seats. Otherwise, the incorrect reservations are sent to the airport travel agency. After choosing seats, the airport can receive the passengers' baggages and print their receipts. Meanwhile, the boarding cards are concurrently printed. Finally, all travel of the documents is provided to passengers. As for the above business process, we first use a Petri net Σ of Figure 8a to model it. Table 1 lists the meanings of all transitions in Σ, where the backward-conflict transition set is {t 2 , t 7 , t 4 , t 5 }. Thus, we can obtain the possible cut-off transitions, i.e., PosCuto f f (Σ) = {t 2 , t 7 , t 4 , t 5 }. Give travel documents to passengers According to Algorithm 3, we unfold Σ and generate its FCP, as shown in Figure 8b. During this unfolding process, Table 2 records all contexts of events and Figure 9 shows    Additionally, we can generate a merged process and directed unfolding of Σ, respectively, as shown in Figure 8c,d. Based on these unfoldings, we can verify some properties, such as deadlocks, properly completed, and reachability.
(1) There is no deadlock in Σ because there always exist enabled transitions at any local markings (except for the final state). (2) Σ is properly completed, because no condition is concurrent with the sink condition b 9 in the concurrency matrix of Figure 9a. From this case study, we can find that our improved computing method for unfolding a Petri net is feasible, and its result is correct. Moreover, this method can be applied to different unfolding techniques and model checkings.

Data Collections and Tool
The experiments in this paper are respectively done on the benchmarks of BPM_AIMC (The BPM Academic Initiative Model Collection: https://bpmai.org/download/index. html (accessed on 30 December 2020)) and Dining Philosophers [41]. BPM_AIMC is a famous data collection of formal models, and it has 100 + Petri nets. By now, this benchmark has been utilized by hundreds of academic institutes. The n-Dining-Philosopher is a classical problem in the synchronization of concurrent events/actions, and we can use Petri nets to formalize this problem, where n is from two to 20. For these two benchmarks, we use our tool DICER (DICER is developed based on PIPE (an open source tool), which can unfold Petri nets and PD-nets, and detect errors of data inconsistency.) [39] to implement the new methods and conduct a group of experiments.

Implementation and Results
In order to illustrate the unfolding efficiency of our improved computing method, we compare it with some unfolding methods in terms of runtime, such as ERV unfolding, merged process (MP), and directed unfolding (DU). That is, our improved calculations of configurations/cuts, concurrent conditions, and cut-off events are applied to these unfolding techniques, i.e., improved ERV unfolding (IERV), improved merged process (IMP), and improved directed unfolding (IDU), respectively.
(1) The experiments on BPM_AIM Because to the fact that Petri nets in BPM_AIMC are JSON documents, we first utilize the parsers of JSON and XML to transform them into some PNML (Petri Net Markup Language) [47] documents, which can be loaded by DICER. After getting PNML-based Petri nets, we select bounded ones from them with more than 10 transitions. Meanwhile, we assume that their initial places only have one token. Finally, we import 37 Petri nets of BPM_AIMC into DICER, and then generate their unfoldings. All of these experiments are done in a PC with Intel Core i5-2400 CPU (3.10GHz) and 4.0G memory. Figures 10-12 are the results of our experiments on BPM_AIMC. From Figure 10, we can see that IERV spends less time than ERV to generate an FCP. Similarly, IMP (resp. IDU) takes less time than MP (resp. DU). Obviously, our improved computing method is more effective than others in the runtime of unfolding Petri nets, although the scale of BPM_AIMC is not too large in reality.    Some experiments are done on Dining Philosophers in order to further show the advantage of our method. We first import 10 Petri nets of Dining Philosophers into DICER, and then generate their unfoldings. For example, Figure 13 shows a Petri net of two-philosophers' dining problem in DICER. Figure 14a-c are the results of our experiments on Dining Philosophers. From these results, we can see that ERV (resp. MP, DU) spends much more time than IERV (resp. IMP, IDU) to generate FCPs with the increment of n philosophers.

Conclusions
Concurrent systems easily suffer from some errors, such as deadlocks, lack of synchronization, and data inconsistencies. Although reachability-graph-based methods are proposed to check these errors, they generally have the problems of state space explosion. This is because these methods are based on the interleaving semantics, and the need to consider all partial orders of business activities to analyze their global behaviors of concurrent systems. By comparison, the unfolding technique of Petri net can characterize the real concurrency and alleviate the state space explosion problem, since it uses an acyclic net to represent the system running. Thus, it is greatly suitable to analyze/check some potential errors in a concurrent system.
As for the unfolding technique of Petri nets, the calculations of configurations, cuts, and cut-off events are key factors that make up an absolutely significant share of the total unfolding time. However, most of the unfolding methods do not specify highly efficient calculations on them. They mainly focus on how to generate a smaller FCP, or explore different kinds of Petri net unfoldings and their model checkings. In fact, their calculations of configurations and cuts need a lot of repetitive work, and new events need to match them up with all existing events so as to determine whether they are cut-off events. In order to solve these problems, we propose an improved computing method for unfolding Petri nets. Some recursion formulas and theorems are derived to calculate configurations and cuts. Backward conflicts are used to guide the determinations of cut-off events. Furthermore, we develop some improved algorithms for generating FCPs.
In the future work, we plan to carry out the following studies: (1) we apply our new calculations with heuristic functions into many more model checkings of concurrent systems; (2) timed concurrent systems are simulated and analyzed based on the unfolding techniques of Petri nets; and, (3) we explore the unfolding-based technique of WFD-net [48] to check concurrency bugs [49][50][51].