Depth-First Net Unfoldings and Equivalent Reduction

Abstract

In Petri net unfolding, according to the strategies of breadth first and depth first, the biggest problem lies in the potential explosion of the state space. Unfolding generates either accessible trees or branch processes. Making marking reduction or branch cutting accessible proves to be an effective approach to mitigating the state space expansion. In this paper, we propose three reduction rules based on similarity equivalence, conduct state space reduction, present three theorems supported by a case study, and propose a new unfolding algorithm for the unfolding process. In both the new case and the experiments, the completeness, optimality, completeness, and memory and time consumption are reduced by about 60%.

1. Introduction

Exploring the path of a concurrent system [1,2,3,4] may lead to a state space explosion. Partial order semantics [2,5,6,7,8,9,10,11] and prime event structure have proven to be efficacious techniques in alleviating state space explosions during traversal. The concurrency of the Petri net is a valuable tool for concurrent system modeling. Petri net unfolding technology effectively combines partial sequence semantics and prime event structure. However, it can produce state space explosions during the unfolding process and reach a level of proximity at the factorial (n!) level when traversing paths, with n representing the number of changes. The tireless pursuit of scholars in this field is finding ways to reduce the state space, decrease the storage space, and simplify computational complexity. This paper analyzes the state space reduction and the similarity of change to induce a substantial reduction in the state space. Exploring all conceivable paths of a system that are not exhaustive, as well as executing equivalent path reduction, comprise a viable solution to the problem.

Some scholars have made contributions in terms of state space reduction and similarity equivalence. For instance, Jensen [12] applied symmetry to reduce the state space of the CPN (color Petri net) using limited conditions, especially considering only fully symmetrical properties. Chiola [13] made a similar reduction, but also according to the symmetry factor of the emission. Schmidt [14] studied the symmetry reduction in the context of the Petri network. Junttila [15] studied the complexity of the question. However, how to reduce the state space during the unfolding process remains a persisting problem that remains to be solved.

Petri net unfolding [12,13,14,15,16,17,18,19,20] is a concurrency theory that is based on semantics proposed by McMillan. This theory has been extended to support nets with read arcs and applied in the context of both model checking and path traversal in concurrent systems. Prime event structures are utilized to analyze the partial ordering relationship between events, thereby facilitating efficient model checking or path analysis. The starting point of this work is in devising strategies to reduce state space expansion and conserve resources in the process.

This study explores a transition system (in the context of a bounded net), which unfolds into a tree exhibiting the same behavior. The unfolding of the net can be equivalently conceptualized in terms of true concurrency. The deployment process involves non-deterministic selection or marking a cutout event when the same transition rule is encountered, until no further transitions are possible. The unfolding follows a partial order, and as each new transition may be added, the order of selection changes, leading to a different maximum expansion.

To determine whether a specific place p in the net N can be marked, the unfolding process can be extended. This involves adding a marker Mt to each new transition t as it unfolds. When triggering transition t, the process checks whether Mt has already occurred. If it has, Mt is considered a cut-off node and is not executed. The enabled transitions are repeatedly triggered in a cyclic manner until no further transitions are possible in the net, indicating successful and complete deployment.

Otherwise, the algorithm examines whether an earlier added transition t′ fulfils Mt′ = Mt; in such an instance, it designates t as a cut-off node, signifying that this search branch will no longer be explored. The search concludes without success when no additional transition can be incorporated. In the process of unfolding, it is crucial to implement effective measures for state space reduction. The similarity equivalence can effectively reduce the state space while lowering the computational complexity and memory consumption.

As has been widely acknowledged in the literature, the correctness of the search—i.e., the assurance that the search will always terminate with the correct result—is highly dependent on the strategy employed [6]. Several papers [6,7,12] have proposed breadth-first strategies that have been shown to be correct.

Various strategies can be used to conduct the search, with breadth-first and depth-first strategies being the most commonly employed. Figure 1 depicts the paths of the deployment net using depth-first and breadth-first strategies, respectively.

This paper employs the improved instance in [1] to showcase the correctness of a depth-first search in net unfolding, while conducting an equivalence reduction on the unfolding net. This article is structured as follows: In Section 2, the study defines the transition system and related concepts, alongside a presentation of classical algorithms for unfolding. Section 3 introduces the depth-first unfolding algorithm of the net, followed by a case study of the unfolding net, thereby establishing the correctness of the depth-first search algorithm. In Section 4, three reduction strategies are proposed and implemented to reduce the unfolded net, resulting in the final reduced equivalent net. Finally, Section 5 provides a detailed discussion on the results.

2. Unfolding of Petri Net

The following section serves to introduce the net and fundamental concepts of unfolding [1,12,16,18,21,22,23,24,25,26,27,28,29,30]. Readers acquainted with this subject matter may proceed to the subsequent section.

Definition 1.

(Net) A triple N = (P, T, F) is called a net if and when:

(1) 

P and T represent finite sets of places and transitions, respectively;

(2) 

F ⊆ (P × T) ∪ (T × P) arcs set;

(3) 

P ∪ T ≠ ∅ and P ∩ T = ∅.

If N = (P, T, F) is a network, node x ∈ P ∪ T. the predecessor ^•x and successor x^• can be defined as:

(1) 

^•x = {y ∈ P ∪ T|(y, x) ∈ F};

(2) 

x^•= {y ∈ P ∪ T|(x, y) ∈ F}.

Among them, ∀x ∈ P ∪ T: ^•x ∪ x^• ≠ ∅.

Definition 2.

(Reachability) ∑ = (P, T, F, M₀) as a Petri net:

(1) 

If there is a transition t and the markings M and M′ satisfy M[t〉M′, then the marking M′ from M is directly reachable;

(2) 

If there is a sequence of transition occurrence σ = t₁ t₂ t_{3 …} t_n, M[t₁〉M₁[t₂〉M₂…M_n−1[t_n〉M″, that is, M[σ〉M″, then the marking M″ from M is reachable. All sets of identifiers reachable from the marking M are denoted as R(M).

In a net N, nodes x, y ∈ P ∪ T:

(1) 

x and y belong to a causal relationship, denoted as x ≤ y, if and only if there is a path from x to y in N. If x ≠ y, it is recorded as x < y;

(2) 

x and y belong to a conflicting relationship, denoted as x # y, if and only if ∃t₁, t₂ ∈ T: ^•t₁ ∩ ^•t₂ ≠ ∅ ∧ t₁ ≤ x ∧ t₂ ≤ y;

(3) 

x and y belong to a concurrent relationship, denoted as x co y, if and only if they satisfy ¬(x < y ∧ y < x ∧ x # y), that is, x and y are neither causal nor conflicting.

Definition 3.

(Occurrence net) A net N = (P, T, F) is called an occurrence net if and when:

(1) 

∀x, y ∈ P ∪ T: x < y ⇒ y ⊀ x;

(2) 

∀p ∈ P: |^•P| ≤ 1;

(3) 

There is no self-conflicting change, that is, ∀t ∈ T: ¬(t # t).

Definition 4.

(Branch process) Let Petri net ∑ = (P, T, F, M₀). (O, h) is a branching process of ∑; occurrence net O = (B, E, G) and the homomorphic function h: B ∪ E → P ∪ T simultaneously satisfy:

(1) 

h(B) ⊆ P ∧ h(E) ⊆ T;

(2) 

For any event e ∈ E, the h function acting on ^•e (resp., e^•) satisfies the bijection of ^•e to ^•h(e) (resp., e^• and h(e)^•);

(3) 

The h function acting on Min(O) is also limited to the bijection between Min(O) and M₀;

(4) 

For any event e₁, e₂ ∈ E, if ^•e₁ = ^•e₂ and h(e₁) = h(e₂), then e₁ = e₂.

Definition 5.

(Configuration) The configuration set C of a branch process can represent the possible set of events that a Petri net may run, which requires the following conditions to be met:

(1) 

Causal closure: e ∈ C ⇒ ∀e′ ≤ e: e′ ∈ C;

(2) 

No conflict: ∀e, e′ ∈ C: ¬(e # e′).

Definition 6.

(Possible extensions) For configuration C and event set E, C ⊕ E represents an extension of C, if and when C ∪ E is a configuration and C ∩ E = ∅.

Definition 7.

(Completeness) The branching process β of a Petri net is complete, and there exists a configuration C ∪ {e} for any reachable identifier M and its enabling transition t (i.e., M [t〉), and event e satisfies Marking(C) = M ∧ e ∉C ∧ t = h(e).

Definition 8.

(Total order) If the partial order relationship <_e acting on a finite configuration satisfies total order, then the following conditions must be met:

(1) 

<_e satisfies the order relationship;

(2) 

C1⊂ C2⇒ C1 <_e C2;

(3) 

If C1 <_e C2 and Marking(C1) = Marking(C2), then there is an isomorphic relationship I1 and an extended event set E′ to satisfy C1 ⊕ E′ <C2 ⊕ I1(E′).

Definition 9.

(Cut-off event) Let β be a prefix for network expansion, with e₁ and e₂ being two of the events, and satisfy Marking ([e₁]) = Marking([e₂]). If [e1] < e [e₂], then e₂ is called a cut-off event.

3. Net Unfolding

In this section, we provide an informal but precise definition of unfolding. For formal definitions, readers may refer to [7].

Classic unfolding algorithm (Algorithm 1):

Algorithm 1: ERV Net Unfolding Algorithm [12]

input: Petri net ∑ = (P, T, F, M0) output: Finite complete prefix Fin. 1: Fin: = Min (Unf (∑)); 4: Poe: = PE(Fin); /*Possible Extension Set*/ 2: Cutoff: = ∅; /*Cut-off Event Set*/ 5: while Poe ≠ ∅, do 6:     Select the event e with the smallest <e relationship from Poe; 7:        if [e] ∩ Cutoff_node = = ∅, then 8:           Expanding e and e• ∪ •e into Fin; 9:           Poe: = PE(Fin); 18:                 if e is cut-off event, then 19:                    Cutoff_node: = Cutoff _node ∪ {e} 20:                  end if 22:                  else Poe: = Poe \ {e}; 24:           end if 25: end while

The net used in this article is shown in Figure 2 as a secure net.

4. Depth-First Unfolding

Upon net expansion, the process commences with a place for each element of MI, originating from a state. For the Petri net N depicted in Figure 2, MI = {a, b, c, d}.

We proceed to generalize the concept of potential extension: if the current labeled net permits reaching a marking m, labeled by a marking M of the original net, and M enables a transition t culminating in a marking M′, then the unfolding is augmented with a new event labeled by t, and for each output place p of t in N, a new place labeled by p is added.

Depth-first unfolding algorithm (Algorithm 2; conditions are mapped to places, and events to transitions):

Algorithm 2: The Depth-First Unfolding Algorithm

input: a Petri net $\Sigma =(N,M_0)$ output: $\pi -$ a complete prefix of $Un{f}_{\Sigma }^{\max }$ 1. $\pi :=$ the empty branching processes 2. Push all init of the places from $M_0$ to $\pi$ 3. $cut\text{\_}off:=$ M0 4. I = 0;   // Record the subscript of the event 5. $pe:=\mathrm{Po}\mathsf{{\rm T}}\mathrm{E}\mathsf{{\rm X}}\mathsf{{\rm T}}(\pi ,cut\text{\_}off)$//Enabled events 6. while $pe\ne$ Ø, do 7.   pop    $e\in pe$      //using stack for data structure; 8.           i = i + 1; 9.    fire e title with ei (Trigger transition event subscript plus 1)) 10.     add new instances from $\phi {\left(e\right)}^{•}$ to $\pi$ 11.          {If similarity (new instances) does not exist in π, new instances of places Superscript j++; 12.          else, the superscript j is 0 (0 means there is no superscript)// Counting of newly generated library superscripts starting from 0)} 13.       if !C $(e,\pi ,cut\text{\_}off)$ then $cut\text{\_}off:=cut\text{\_}off\cup \left\{e\right\}$ // Become a new node and cut it the next time it appears 14. else $pe:=pe+\mathrm{Po}\mathsf{{\rm T}}\mathrm{E}\mathsf{{\rm X}}\mathsf{{\rm T}}(\pi ,cut\text{\_}off)$ // Become a cutting event (if it already exists, it is a cutting node); 15. End while

In this unfolding algorithm, π represents the complete prefix of expansion. When line 2 is a place with a token, line 5 calculates the possible changes. When line 6 is not empty, one of the changes occurs, using the stack data structure. Line 9 triggers the enabled event, line 10 adds a new marking, and line 11 determines whether a new marking is added. Meanwhile, markings that are deemed equivalent in terms of similarity are considered identical, otherwise line 12 becomes a cut-off node. Line 13 adds a new cut-off node, and line 14 continues to judge the change events that can be started under the new marking until line 15 has no event to be enabled. When unfolding, it is necessary to realize the state space reduction, and this can be accomplished through the state similarity equivalence method. We perform the state similarity equivalence method to reduce the number of traversed paths. To illustrate the concept of similarity equivalence, as shown in Figure 3, we treat the two identifications, M1 and M2, as equivalent in the algorithm.

The complexity analysis for Algorithm 2 (the depth-first unfolding algorithm) achieves a polynomial complexity with N nodes and m places; at most, the complexity is at the level of n × m. Using the depth-first unfolding algorithm to unfold the Petri net in Figure 2 is detailed in

Table 1. Net unfolding process and results of Petri net in Figure 2.

Marking	Enabled	Select	New Marking	Type
a, b, c, d	A, B	A/e1(a, b->i, k)	c, d, i, k	new
a, b, c, d	B	B/e2(c, d->l, j)	a, b, l, j	new
c, d, i, k	C, B	C/e3(k, c, d->e, h)	i, e, h	new
c, d, i, k	B	B′/e4(c, d->l, j)	i, k, l′, j′	new
a, b, l, j	A, D	A′/e5(a, b->i, k)	i′, k′, l, j	new
a, b, l, j	D	D/e6(a, b, l->f, g)	f, g, j	new
i, e, h	E, H	E/e7(e, i->a, c)	h, a′, c′	new
i, e, h	H	H/e8(h->b, d)	i, e, b′, d′	new
l, k, l′, j′	T	T/e9(i, k, l, j->p)	P	end
i′, k′, l, j	T	T′/e10(i, k, l, j->p)	P	end
f, g, j	F, G	F/e11(j->a, c)	a″, c″, g, j	new
f, g, j	G	G/e12(g->b, d)	f, b″, d″	new
h, a′, c′	H	H′/e13(h->b, d)	a, b‴, c, d‴	Cut-off
i, e, b′, d′	E	E′/e14(e, i->a, c)	a‴, b′, c‴, d′	Cut-off
a″, c″, g, j	G	G′/e15(g->b, d)	a″, b⁗, c″, d⁗	Cut-off
f, b″, d″	F	F′/e16(j->a, c)	a⁗, b″, c⁗, d″	Cut-off

.

Figure 4 demonstrates a graphical representation of the unfolding process of SecN. These unfolding prefixes are referred to as such. The initial marking bearing with label {a, b, c, d} enables transitions A and B, resulting in two feasible extensions. We opt to incorporate event e1 first, labeled by A. The prefix now possesses a novel reachable marking, corresponding to marking {c, d, i, k} in SecN, which paves the way for a new potential extension labeled C. Let us assume event e2, labeled by B, is added subsequently.

The prefix now comprises two additional reachable markings: {a, b, j, l} and {i, j, k, l}. These markings facilitate extensions labeled with D and T, respectively. After event e3, labeled by C, a new marking labeled by {e, h, i} emerges, enabling possible extensions with labels E and H, etc.

These algorithms construct progressively larger prefixes of the unfolding of SecN. Similar to transition systems, they examine one event at a time, with some events designated as cut-offs, beyond which successors are no longer explored.

The challenge lies in generalizing the definition of cut-off events for Petri nets. McMillan [12,13] proposed a solution. The crux is to associate each event e with an appropriate reachable marking Me of the original Petri net SecN, accomplished in three steps, exemplified by event e3 in Figure 4:

–

Determine the set [e_n] comprising all predecessors of e_n, i.e., the set of all events e_m such that the unfolding includes a path from e_m to e. In this case, [e3] = {e1, e3};

–

Select any occurrence sequence σ_i containing each element of [e] exactly once (which is guaranteed to exist) and allow it to occur. Here, σ_i = e1e3;

–

Let m denote the marking of the unfolding reached by firing σ_i (which can be proven to be independent of the choice of σ_i) and define Me as the label of m. In this instance, m = {i, e, h} and Me3 = { i, e, h}.

For each novel event e_xt, the algorithms compute and store the marking Mext. It is worth noting that these are the sole markings of SecN known to be reachable by the algorithms.

Conditions (1) and (2) can now be effortlessly generalized. An event e_cut is designated as a cut-off if marking Me satisfies one of these conditions:

(a)

Me(pT) = 1; the algorithm concludes with the result ”reachable”;

(b)

Me′ is already known to be reachable: either Me = MI or Me′ = Me for some other event e′. In such a case, e′ is referred to as the corresponding event of e.

The unfolding prefix in Table 1 exhibits a reachable marking, corresponding to {a, c, b, d}. As this is equivalent to Me1, such an extension would constitute a cut-off.

5. Equivalence Reduction of Unfolded Nets

Table 1, presented above, has not been reduced, and following unfolding, it remains excessively large. In Table 1, distinct colors represent different states, and this article employs various colors for differentiation. For instance, initial states a, b, c, and d are represented in black, while newly generated states c, d, i, and k are depicted in green. Reduction of a net utilizing equivalence [31,32,33] is explored.

For this unfolding net, research has determined that the unfolding net remains overly extensive. This paper employs equivalence-based reduction. The reduction process presents as follows:

For the initial reduction, four rectangles of different colors are reduced based on the same transition (e.g., G, G′; H, H′; E, E′; F, F′ represent identical transitions) guarantee.

Reduction rule: If the same marking M undergoes the same transformation and yields the same marking M′, it is considered a cut-off node. After one reduction, the results are shown in Figure 5.

The reduced graph is as follows in Figure 6.

Following the second reduction, when only a single transition remains (i.e., no branching path), we implement the reduction. After two alterations have transpired, the subsequent changes that can occur are all t_j. For instance, enabling transitions t_i and t_j, regardless of whether ti occurs first or t_j occurs first, the transition that can be triggered after occurrence is t_k. In lines 9 and 10 in

Table 2. Results of the first reduction in the expansion of the net in Figure 2.

No	Marking	Enabled Transfer	Selected	New Marking	Type
1	a, b, c, d	A, B	A/e1(a, b->i, k)	c, d, i, k	new
2	a, b, c, d	B	B/e2(c, d->l, j)	a, b, l, j	new
3	c, d, i, k	C, B	C/e3(k, c, d->e, h)	i, e, h	new
4	c, d, i, k	B	B′/e4(c, d->l, j)	i, k, l′, j′	new
5	a, b, l, j	A, D	A′/e5(a, b->i, k)	i′, k′, l, j	new
6	a, b, l, j	D	D/e6(a, b, l->f, g)	f, g, j	new
7	i, e, h	E, H	E/e7(e, i->a, c)	h, a′, c′	new
8	i, e, h	H	H/e8(h->b, d)	i, e, b′, d′	new
9	l, k, l′, j′	T	T/e9(i, k, l, j->p)	P	end
10	i′, k′, l, j	T′	T′/e10(i, k, l, j->p)	P	end
11	f, g, j	F, G	F/e11(j->a, c)	a″, c″, g, j	new
12	f, g, j	G	G/e12(g->b, d)	f, b″, d″	new

, both of which are transitions T that occur, the resulting states are the same; hence, reduction can be performed.

Upon the completion of the two transitions t_i and t_j, the subsequent transition that can occur is t_k, that is, enabling transitions t_i and t_j, irrespective of whether t_i occurs first or t_j occurs first, the transition that can be triggered.

The third step of the reduction rule: if the same marking M undergoes corresponding transformations and produces an equivalent marking M′, it is considered a cut-off node. As illustrated in Figure 7, distinct transitions yield different identifiers, but analogous identifiers are generated. The unfolding paragraph after the final reduction is displayed in Figure 8.

Theorem 1.

If marking A reaches marking C after transition t₁, and marking B reaches marking C after transition t₂; t₁ is equivalent to t₂.

Proof. 

If Marking C = Marking C, i.e., Mark ([t₁]) = Mark ([t₂]), and then t₁^• = t₂^•, h(t₁^•) = h(t₂^•), namely h(t₁)^• = h(t₂)^•. □

Theorem 2.

If marking A reaches marking C after transition t₁, and marking B reaches marking D after transition t₂, and marking C is equivalent to marking D, then t₁ is equivalent to t₂.

Proof. 

If Marking C = Marking D, i.e., Mark ([t₁]) = Mark ([t₂]), and then t₁^• = t₂^•, h(t₁^•) = h(t₂^•), namely h(t₁)^• = h(t₂)^•. □

Definition 10.

Marking C is approximately equivalent to marking D, that is, the transitions that can occur under marking C are equal to the transitions that can occur under marking D.

Theorem 3.

Marking A reaches C after the transition t₁, and marking B reaches D after the transition t₂, and marking C is approximately equivalent to D, so t₁ is equivalent to t₂.

Proof. 

If Marking C ≈ Marking D, i.e., Mark ([t₁]) = Mark ([t₂]), and then t₁^• = t₂^•, h(t₁^•) = h(t₂^•), namely h(t₁)^• = h(t₂)^•. □

6. Case Study and Experiments Result

This paper employs a case study to scrutinize the process of net reduction through unfolding, predicated on the three reduction rules posited herein. Figure 9a illustrates a Petri net, while Figure 9b portrays the unfolded net. Subsequently, this article puts forth a case study to delineate three reduction rules applicable to the unfolding net reduction procedure.

Table 3. Results of Net unfolding and Reduction in Figure 2.

No	Init	Enabled	Select	New	Type
1	a, b, c, d	A, B	A/e1(a, b->i, k)	c, d, i, k	New
2	a, b, c, d	B	B/e2(c, d->l, j)	a, b, l, j	New
3	c, d, i, k	C, B	C/e3(k, c, d->e, h)	i, e, h	New
6	a, b, l, j	D	D/e6(a, b, l->f, g)	f, g, j	New
8	i, e, h	H	H/e8(h->b, d)	i, e, b′, d′	New
9	l, k, l′, j′	T	T/e9(i, k, l, j->p)	P	end
11	f, g, j	F, G	F/e11(j->a, c)	a″, c″, g, j	Init

shows the result of net reduced unfolding.

The first step of reduction is premised on (1) identical marking M, following the same transition, yielding the same marking M′, regarded as the cut node or, more precisely, the cut-off node.

The second step of reduction is based on (2) the similar transition of marking M, engendering a marking M′ with an identical structure and functioning as a cut-off node, as demonstrated in Figure 10a.

The third step of reduction adheres to the subsequent criterion: (3) identical marking M, upon corresponding alterations, generates an equivalent marking M′, deemed as a cut-off node. The final equivalent unfolding net is exhibited in Figure 11.

We added more experiments to show the scalability of the proposed scheme and a comparison with related state-of-the-art works. Otherwise, it is difficult to evaluate the contributions of this work.

The algorithm satisfies the following three properties:

(i)

Soundness: each complete path explored by the algorithm is a consistent path of the Petri net;

(ii)

Completeness: the algorithm explores all consistent paths of the Petri net;

(iii)

Optimality: each path is explored exactly once.

Based on the open-source tool PIPE (Platform Independent Petri Net Editor), both experiments in this section are conducted on machines with an Intel Core i7-6400 CPU (5.10 GHz) and 64.0 G memory. Each test case set requires 10 experiments with the average of the total number. As shown in

Table 4. Comparison of the ERV unfolding and Similarity unfolding.

	ERV Unfolding			Similarity Unfolding			Accuracy
	Exe	M	Time	Exe	M	Time
SecN (10)	3328	46	0	1228	22	0	55%
SecN (15)	147,456	46	9	20,456	47	11	65%
SecN (20)	6,029,312	46	455	6,029,312	23	127	60%
PeN (8)	10,080	182	1	10,080	46	1
PeN (16)	oom	oom	oom	80,640	46	10
exp-p (9)	oom	oom	oom	725,760	46	103
exp-p (4)	20,736	55	1	12,736	26	1	57%
exp-p (5)	705,600	326	58	705,600	26	32	59%
exp-p (6)	oom	33	177	600	26	1757	62%

, “Exe” represents the number of executed paths, “M” represents memory consumption, “Time” indicates time consumption in seconds, and “Accuracy” denotes the acceleration ratio.

7. Conclusions

In the verification of the concurrent system based on Petri nets, it is inevitable to encounter a state space explosion during the unfolding of the net, and during path exploration, the exponential level of the path trace is increased. How to conduct path exploration to reduce the state space and the equivalence merging of paths are important research directions. In this paper, three kinds of equivalence marking are proposed, but three kinds of equivalence transfers are also based on the three equivalence rules, so as to reduce the equivalence path of exploration. After the corresponding case analysis and experimental results, it is shown that the acceleration ratio in memory consumption and time complexity reaches about 60%.

Depth-first search algorithms in this paper for place reachability in Petri nets are accurate and, expressed otherwise, depth-first search algorithms construct an unfolding signifying all reachable markings. Both depth-first and breadth-first search algorithms produce a complete prefix. In the full prefix of the size of the construction process, in the secure bounded net, the existence of linear algorithm complexity and linear memory consumption in the model checking of Petri nets is likely.

Similar depth-first algorithms and breadth-first search algorithms can select subsequent events, not only in the potential extensions enabled by the last added event, but also in the possible implementation extensions concurrent with this event.

This study proposes three types of reduction: (1) Identical marking M, after the same transition, produces the same marking M′, which is considered the cut node or, more specifically, the cut-off node. (2) The corresponding transition of marking M generates a marking M′ with the same structure, functioning as a cut-off node. (3) Identical marking M, following corresponding modifications, produces an equivalent marking M′, considered as a cut-off node. Utilizing a case study, we managed to diminish the net size by approximately 50%.

In future work, we will propose a theoretical system and whether the reduction algorithm can be applied to the equivalence reduction of color network expansion and the reduction of data-centric values of Petri net unfolding, reducing the traversal path number.