{'fraction_non_alphanumeric': 0.027629885695541367, 'fraction_numerical': 0.008175418233201281, 'mean_word_length': 4.551477798010926, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 3, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
Local State Space Analysis to Assist Partial Order Reduction

This paper presents an approach to more efficient partial order reduction for model checking concurrent systems. This approach utilizes a compositional reachability analysis to generate over-approximate local state transition models for all processes in a concurrent system where an independence relation and other useful information can be extracted. The extracted independence relation, compared to what can be obtained by statically analyzing the system descriptions, is more precise and refined, therefore leads to more efficient partial order reduction. This approach is demonstrated on a set of concurrent system examples. Significantly higher reduction in state space has been observed in several cases compared to what can be obtained using SPIN.


Introduction
This paper considers an approach to the state explosion problem in model checking concurrent systems. A concurrent system typically consists of a number of processes running asynchronously. The communication and synchronization are accomplished by either message passing or shared memory. When verifying such a system, concurrently enabled process executions need to be interleaved so that all possible orderings of executions are considered to avoid missing any behavior. The need to consider all possible interleavings of concurrent executions is the main cause of state explosion as the number of interleavings grows exponentially if a system has a high degree of concurrency, and this leads to an excessively large state space for even a relatively small system.
In practice, specifications often are not sensitive to the different orderings of concurrent executions. In order to address state explosion due to the interleavings of concurrent executions, various partial order reduction (POR) methods have been developed [14,5,1,4], which aim to restrict verification to a (significantly smaller) subset of behaviors of a system with guarantee of soundness. In other words, the ignored behaviors do not carry any new information and do not affect the final verification results. The general idea of POR is that a subset of all enabled executions in a state is computed for verification, while the ignored ones are deemed irrelevant. If the computed subset is much smaller that the full set of enabled executions for many states, it can lead to an exponentially smaller state space while still representing sufficient behavior for verification to derive the same arXiv:2004.14971v1 [cs.SE] 30 Apr 2020 II results as on the original full state space. Identifying unnecessary interleavings among the enabled executions plays an important role in POR which is based on examining the dependency relations that exist between the executions of a system. A dependence relation represents possible interference among concurrent executions, and it is used to identify whether different orderings of concurrent executions are relevant to the specification under verification.
The efficiency and effectiveness of POR relies on the precision of the derived dependence relations. Traditionally, they are derived by applying static analysis a priori to the system descriptions by detecting any potential interference between any two executions. As computing the precise dependency relations between executions may be as hard as verifying the whole system itself, a conservative statically computed approximation is used by POR [7,4]. Dynamic POR [1,5], which excludes the need to apply static analysis a priori by detecting dependencies on-the-fly, and previous work shows that these dynamic approaches achieve higher reduction due to more precise dependences obtained.
This paper presents an alternative approach to computing (in)dependence relations. It is similar to the static analysis approach in that the dependence relations are computed a priori. In this approach, a compositional state space construction method [18] is applied to a concurrent system to find the local state transition model for each consisting process, and subsequently dependence relations are obtained by analyzing these local state transition models. As the generated local state transition models over-approximate the concrete state space of the processes in the system, the derived dependence relations also hold in the non-reduced state space of the whole system. This ensures the soundness of this approach. Once the necessary information is gleaned, model checking with POR can be performed as usual. The dependence relation found this way is more refined and accurate compared with the traditional static analysis based approaches, and this leads to more significant reduction than allowed by the static approaches. After a dependence relation is obtained, another key step is to produce a subset of all enabled executions in every state. This paper follows the correctness conditions of the ample set method [3] to produce such subsets. Ideally, the ample set generated in each state should be minimized to achieve the maximal reduction. To meet this requirement, this paper also show how other useful information can be extracted from the local state space analysis.
The main contribution of this paper is the use of local state space analysis to assist POR to achieve much higher reduction during model checking compared with the static analysis based approaches. This improvement is due to the more precise and refined dependence relations that can be extracted from the local state transition models. To the best of our knowledge, this is the first work that combines the compositional state space construction with the dependence relation computation for POR. The presented approach is implemented in a prototype, and tried on a small set of examples. The experimental results show definitive improvements over the POR implemented in the SPIN.
In this paper, it is assumed that the state space models considered have cycles, and model checking with POR used is stateful. Also, process executions are also referred to as transitions, a term commonly used in POR literatures.

State Graphs
A concurrent system is typically described in some high-level language. Since the exact formalism for describing a concurrent system is not important, this paper simply assumes that a system is described with an initial state init and a set of transitions T defining how the system changes its states when transitions in T are executed. Each transition in T is predicated with a guard defining when it becomes enabled, and one or more actions defining how state variables are changed once the transition is executed. Furthermore, given a system state s, the set of transitions enabled in state s is denoted by enabled(s). The successor state s after executing a transition t is denoted by t(s).
This paper uses state graphs (SGs) to represent the state transition level semantics of these systems. The definition of state graphs is given as follows. First, Let Z be the set of integers.
Definition 21 A state graph G is a tuple (V, Dom, P, S, init, R, L, F ) where 1. V is a finite set of discrete variables. 2. Dom : V → 2 Z is a function that specifies a finite domain for each variable in V . 3. P = {(v, i) | v ∈ V and i ∈ Dom(v)} is a finite set of atomic propositions on the variables in V . 4. S is a finite non-empty set of states, 5. init ∈ S is the initial state. 6. R ⊆ S × S is the set of state transitions. A state transition is the result of executing a transition in T . 7. L : S → (V × Z) |V | is a labeling function that associates each state with a set of atomic propositions, one for each variable in V .
A large and complex system usually consists of processs connected in a network where communications among the processs can be done through shared variables. It is possible to construct process SGs first, and then the SG of the entire system by composing the process SGs asynchronously.
, be two process SGs, and C ⊆ P 1 ∩ P 2 be the set of all propositions on the shared variables V 1 ∩ V 2 between G 1 and G 2 . The Asynchronous parallel composition G 1 G 2 is a SG G = (V, Dom, P, S, init, R, L, F ) such that
In the above definition, when several processs execute concurrently, they synchronize on the changes of the shared variables, and proceed independently otherwise. n the actual implementation, when composing two SGs, a reachability analysis algorithm is performed from the initial composite state following the definition for transition relation R, and therefore, the resulting composite SG contains only the reachable states. Fig. 1 shows a simple example of a concurrent system with three processes. The local state graphs for the processes are shown in this figure labeled under G 1 , G 2 , and G 3 , respectively. The local and shared variables in this example are shown on the right hand side of the figure. For clarity, the state labelings are not shown. Instead, state transitions are labeled to indicate how states are

Reachability Analysis
A basic approach for analyzing the dynamic behavior of a concurrent system is reachability analysis, which finds all possible state transitions and thus reachable states for such a system. The reachable state space is typically represented by a state graph, and can be found by exhaustively executing every enabled transitions starting from the initial state. A general reachability analysis procedure is given in Algorithm 1. Checking safety properties can be easily combined with the given algorithm, and liveness properties can be checked using nested-DFS [6].

Computing Independence Relations
The major bottleneck for monolithic approaches such as the one shown in Algorithm 1 for handling large and complex systems is the excessively large number of states generated due to that all possible orderings of the enabled transitions need to be considered If several are enabled in a state. On the other hand, it has been discovered that most of the transition interleavings are often irrelevant to the properties under verification. Therefore, the goal of POR is to identify and remove the redundant interleavings as much as possible. To make sure that the ignored behaviors do not carry di↵erent information for verification, POR relies on transition independence relations.
In general, the more precise an independence relation is, more redundant interleavings can be identified, thus more e cient POR is. As indicated at the beginning of this paper, traditional static analysis approaches to computing independence relations have to be conservative for soundness, however they often result in less e cient POR. This section presents an alternative approach that, instead of based on static analysis of the structures of system models, extract changed. The labelings also make referencing to the transitions easier. For each a ∈ {u, v, w, x, y, z}, a+ means that a changes to 1 from 0, and a− changes a to 0 from 1. These three SGs can be composed together to form the SG for the whole system as shown in Figure 2.

Reachability Analysis
A basic approach for analyzing the dynamic behavior of a concurrent system is reachability analysis, which finds all possible state transitions and thus reachable states for such a system. The reachable state space is typically represented by a state graph, and can be found by exhaustively executing every enabled transitions starting from the initial state. A general reachability analysis procedure is given in Algorithm 1. Checking safety properties can be easily combined with the given algorithm, and liveness properties can be checked using nested-DFS [6].

Computing Independence Relations
The major bottleneck for monolithic approaches such as the one shown in Algorithm 1 for handling large and complex systems is the excessively large number of states generated due to that all possible orderings of the enabled transitions need to be considered If several are enabled in a state. On the other hand, it has been discovered that most of the transition interleavings are often irrelevant to the properties under verification. Therefore, the goal of POR is to identify and remove the redundant interleavings as much as possible. To make sure that the ignored behaviors do not carry different information for verification, POR relies on transition independence relations.  In general, the more precise an independence relation is, more redundant interleavings can be identified, thus more efficient POR is. As indicated at the beginning of this paper, traditional static analysis approaches to computing independence relations have to be conservative for soundness, however they often result in less efficient POR. This section presents an alternative approach that, instead of based on static analysis of the structures of system models, extract independence relations by analyzing the local state graphs of the consisting processes in a system. Since the local state graphs capture all runtime behaviors of the processes, the obtained independence relations are much more precise and refined that what can be obtained by static analysis.
This section first reviews the general requirements of independent transitions. It then reviews a compositional SG construction method [18] for finding local SGs, and shows how an independence relation can be extracted from these local SGs.

General Definition of Independence Relations
The state space of a concurrent system often contains many execution paths that correspond to different execution orderings of transitions in different parts of the system [6]. If transitions are independent, then their executions do not interfere with each other, which means that changing the execution orderings does not modify their the system behavior [1]. In this case, it is sufficient to consider only one execution ordering. The notion of independence transitions similar to those in [6,7,3] is formalized in the following definition.
Definition 31 An independence relation I ⊆ T × T is a symmetric and antireflexive relation over transitions in T such that for each (t 1 , t 2 ) ∈ I, the following conditions need to hold in every state s ∈ S.
Intuitively, independent transitions cannot disable each other, and the executions of independent transitions in different orders are indistinguishable to the specification. Additionally, the independence is defined for transitions enabled in a state. It is possible for two transitions not enabled together in every state. In a state where they are not both enabled, they are regarded as independent in that state by the definition. This definition, however, do not affect the verification results as partial order reduction is only applied to independent transitions that are both enabled.

Compositional State Space Construction
Given a concurrent system consisting of with a number of processes, this section reviews a compositional local SG construction method for finding SGs for the processes in a system in a high-level description [19]. This paper assumes that a system is described as a network of concurrent processes communicating through shared variables. When generating the local SGs, the interleavings of the invisible state transitions from different processes are not considered, therefore the complexity of generating the local SGs is much lower than that for considering the whole system at the beginning. Consider a concurrent system M = M 1 ||M 2 ||...||M n which is the parallel composition of processes M i (1 ≤ i ≤ n) described in some high-level description language such as Promela. Moreover, every process is assumed to share some variables with some other processes. The compositional state space construction method builds the SG G i for each process M i (1 ≤ i ≤ n) from an underapproximate context, and gradually expands its SG by including all state and transitions allowed by its neighboring processes. The main idea is as follows. Initially, the shared variables that a process depends on are fixed. Then, this method iteratively performs the following two tasks in each step.
1. For every process, use the traditional reachability analysis to find all states and state transitions allowed by its definition. 2. For every process, if the above step finds state transitions that cause changes on the shared variables that other processes depend on, extract constraints from these transitions, and apply these constraints to those processes depending on these shared variables. Applying constraints to a process SG would introduce additional states and state transitions to simulate the synchronization in the SG parallel composition definition in section 2.1.
The above two tasks are performed repetitively until no new state or state transitions can be found for any process SG.
The key to this method is the representation of the changes on the shared variables. First, let L i and L j be the state labeling functions for process SGs G i and G j , and C ij = P i ∩ P j be the set of propositions on the shared variables between G i and G j . Suppose that the traditional reachability analysis finds a state transition (s i , s i ) for a process SG G i , and this transition changes some shared variables that another process SG G j depends on. This method would extract a constraint (X, Y ) which is a pair of sets of propositions on these shared variables such that From an external view, the constraint (X, Y ) indicates that whenever these shared variables assume the values satisfying the propositions in X, process SG G i may change the values of these variables to satisfy the propositions in Y . From G i , a set of such constraints can be extracted in every step.
When applying these constraints to G j that depend on the same shared variables, for each constraint (X, Y ), this method checks if there is any state s j in G j such that X ⊆ L j (s j ). If s j exists, then a new state s j and a new state transition (s j , s j ) due to this constraint are generated for G j such that L j (s j ) = (L j (s j ) − X) ∪ Y . State s j and transition (s j , s j ) are added to reflect the effect of G j 's environment on its behavior. From these new states, more new states and transitions may be found according to the definition of process M j . Subsequently, the traditional reachability is applied again. Now consider the simple asynchronous circuit example as shown in Fig ??(a) with three processes M 1 , M 2 and M 3 . Both M 1 and M 2 depend on variable z while M 3 depends on variables x from M 2 and y from M 1 . Suppose that the initial states for these processes are defined below, respectively, In the first step, no states and transitions can be added to G 1 and G 2 as no variables can be changed according to the circuit definition. For M 3 , variable z is changed to 1 from 0, therefore a new state s 16 and a new transition (s 0 , s 16 ) are added to G 3 . The result is shown in Fig 3(a). Since the transition (s 0 , s 16 ) changes z that M 1 and M 2 depend on, a constraint ({z = 0}, {z = 1}) is extracted from G 3 , and applied to G 1 and G 2 where states p 1 and q 1 are generated. After the traditional reachability analysis is applied to all three SGs, more states and transitions are added to G 1 and G 2 , respectively, while G 3 remains unchanged as shown in Fig 3(b). Now, G 1 has a transition (p 2 , p 4 ) that changes variable y to 1 from 0, and G 2 has a transition (q 2 , q 4 ) that changes variable x to 1 from 0. Since G 3 depends on both variables, two constraints are extracted from G 1 and G 2 , respectively, After applying these constraints to G 3 , three new states, s 6 , s 12 , and s 4 are added. From these new states, the traditional reachability analysis finds two  Figures in (a)-(c) show the partial process state graphs generated during the compositional reachability analysis.The final process state graphs generated when the compositional reachability analysis is shown in Fig 1. new states s 3 and s 2 as defined in the SG G 3 in Fig. 1. The results after this step is shown in Fig 3(c). Eventually, all states and transitions are found for these three processes, and their SGs are shown in Fig 1. In the end, the generated process SGs are an over-approximations of the concrete process SGs if they were produced when the whole design was considered. This means that the process SGs may contain states and state transitions that do not exist in the global SGs obtained by applying reachability analysis directly to the whole system description. This is proved in [19]. This property of the generated process SGs guarantees the soundness of the approach presented in this paper.

Extracting Dependence Relations
According to Definition 31, the dependence relation is the complement of the independence relation. Therefore, after the process state graphs are generated, Fig. 4. Examples of dependent transitions that can be found in the state graphs as defined in Definition 31.
transition dependence relations are found by checking if there is a violation of any condition in Definition 31 in any state in any process state graph. More specifically, two transitions t 1 and t 2 are dependent with each other if in any process state graph, there exists a state s such that one of the following conditions holds.
In the above definition, two transitions depend on each other if firing one can disable the other one as stated in the first two conditions, or firing these two transitions in different orders leads to different states. Fig 4 illustrates two cases of dependent transitions found when one of the above conditions holds. In Case 1 shown in Fig 4, t 1 and t 2 are dependent because condition 1 or 2 is violated, while in Case 2, condition 3 is violated. Note that in this method if any of these conditions holds for transitions in any state in any process state graph, they are regarded as dependent globally.
In this local SG analysis based approach, much more accurate information on how different orderings of firing transitions affect, for example, whether a transition can possibly be disabled by another transition, is readily available, therefore much more refined dependence relations, and equivalently independence relations, can be derived. This allows many transitions enabled in each state to be removed during state space search, thus leading to enormous reduction in state space, as shown by the experimental results in section 5. On other hand, the local state graphs generated are over-approximations as these models may contain additional states and state transitions that would not exist if the monolithic state graph is generated for the whole system as shown in [19]. Because of these additional states and state transitions, dependence relation found may still be conservative. This is equivalent to saying that some transitions that should be independent may be found as being dependent due to the additional states and state transitions. However, this does not affect the correctness of this method, and it would only cause partial order reduction to be less effective.

Partial Order Reduction
First of all, it is necessary to differentiate the global states of the whole design and the local states of the processs of the design. Typically, a concurrent system consists of processes, each of which makes changes to variables responding the input changes caused by its neighboring processes. Let M = M 1 . . . M n be the description of a system where M i (1 ≤ i ≤ n) is the description for the ith process, and is the parallel composition operator appropriately defined for such a description. The states of the whole system M are referred to as the global states denoted s, and the states of the individual modules are referred to as local states denoted s. The global states for M are not represented as monolithic entities either. Instead, they have similar structure to that of M . More specifically, a global state s of M is a n-tuple of the local states (s 1 , . . . , s n ) where each s i (1 ≤ i ≤ n) is a local state of LPN module M i . The shared variables are replicated in the state of the local SGs where they belong. The global states are found when the state space of the whole system is searched, while the local states are generated during the compositional state space construction as described in the last section. For convenience, a predicate in(s, s i ) is defined to indicate whether the local state s i is part of the global state s. in(s, s i ) holds if the local state s i is part of the global state s.
After the independence relation is obtained, the next step is to compute a subset of the enabled transitions in each state for POR during the state space exploration. This paper considers ample set method as described in [3]. Let ample(s) denote the ample set computed for a global state s. To reduce the complexity of the state space exploration, the size of ample(s) should be as small as possible, and computing ample(s) should have low overhead. To preserve the sufficient behavior to verify all properties soundly, four conditions need to be satisfied for ample set construction as described in [3], which are listed below for convenience.
C0 ample(s) = ∅ iff enabled(s) = ∅. C1 In the full state graph, on any path starting from a state s, a transition dependent on a transition in ample(s) cannot occur before some transition from ample(s) occurs first. C2 If a state is not fully expanded, every transition in the ample set is inisible. C3 If a cycle contains a state in which some transition t is enabled, then it also contains a state s such that t ∈ ample(s).
Among all four conditions, C0 and C2 can be readily satisfied. Some more discussion on C3 is givne in a later section. This section considers C1 for computing ample(s) as it is the most difficult one.

Computing Ample Set
This section presents two conditions to make sure that all essential interleavings between dependent transitions are preserved. Condition 1 For all enabled transitions t 1 , t 2 ∈ enabled(s), if t 1 ∈ ample(s) and t 2 ∈ ample(s), then I(t 1 , t 2 ) holds.
Intuitively, Condition 1 requires that every transition in enabled(s)\ample(s) is independent on every transition in ample(s). This condition guarantees that transitions in enabled(s)\ample(s) are still enabled after any transition in ample(s) is fired. However, this condition alone is not sufficient to guarantee that no states can be missed by firing transitions in ample(s) first. Refer to Fig. 5 for a simple example. In the initial state s 0 = (p 0 , q 0 , s 0 ), enabled(s 0 ) = {t 1 , t 2 , t 4 }. Suppose that every transition in enabled(s 0 ) is independent with each other. Therefore, any single transition can be chosen to be included in ample(s 0 ) according to Condition 1, and it can be seen that the other transitions can still remain enabled after firing the transition in ample(s 0 ). First, choose t 1 to be included in ample(s 0 ). Suppose that another state s 1 = (p k , q 0 , s 0 ) is reached after firing t 1 and some other transitions where t k and t 4 are enabled. From Fig. 5 it can be seen that firing t k and t 4 in different orders may lead to different state spaces since firing t 4 first disables t k . Now suppose ample(s 0 ) = {t 4 } and firing t 1 is delayed. This is still valid according to Condition 1. Since transition t 4 fires before t 1 , t k may never get a chance to fire, thus possibly causing certain states not to be found. To avoid this situation, the following condition needs to be satisfied as well when computing the ample set. Condition 2 For each transition t ∈ enabled(s), if there is another transition t ∈ enabled(s) such that D(t, t ) holds, then t ∈ ample(s).
Intuitively, this condition requires that firing an enabled transition, if it is dependent with any other transition that may be enabled in the future, needs to be delayed until its dependent transition also becomes enabled in the same state. This makes sure that the interleavings involving a currently enabled transition and another one to be enabled in the future are not lost. In the example shown in Fig. 5, since D(t 4 , t k ) holds for t k / ∈ enabled(s 0 ), in the initial state s 0 , t 4 ∈ ample(s 0 ). In other words, with Condition 2, firing t 4 needs to be delayed until both t 4 and t k are enabled, therefore firings of t 2 and t k can be interleaved.
The basic idea behind Condition 2 is that if a currently enabled transition is dependent with another transition that might be enabled in the future, the computed ample set must preserve the interleavings of firing these two transitions whenever possible by putting off firing the currently enabled transition as late as possible. It is possible that the only ample set that satisfies both conditions is empty. In this case, all the enabled transitions have to be included in the ample set, i.e. if ample(s) = ∅ according to Condition 1 and 2, then ample(s) = enabled(s).
An ample set that meet the above two conditions includes only the transitions that are globally independent with any other transitions, thus satisfying the condition described in C1 trivially. This implies an ample set satisfies C1 if it satisfies both condition 1 and 2 defined in this section.
Based on the above discussion, ample(s) can be computed from enabled(s) as follows.

First, enabled(s) is partitioned to two subsets dep(s) and indep(s). dep(s)
includes all transitions t enabled in s such that D(t, t ) for some transition t , and indep(s) = enabled(s)\dep(s) is the set of transitions enabled in s such that each transition t ∈ indep(s) does not depend with any other transitions. If indep(s) = ∅, we can choose any single transition of indep(s) to be included in ample(s). 2. If indep(s) = ∅, perform this step. First note that condition 2 only requires that a currently enabled transition cannot be included in the ample set if it is dependent with a transition not currently enabled. However, it is fine to include both t 1 and t 2 into the ample set if t 1 , t 2 ∈ enabled(s), and t 1 and t 2 are only dependent with each other. Therefore, ample(s) can be found such that every transition in ample(s) is independent with any other transition not in ample(s) including enabled and disabled ones. 3. If indep(s) is still ∅, ample(s) = enabled(s).
The above partitioning approach is simple to implement, and its overhead for computing the ample set during the runtime is negligible. On the other hand, the above two conditions could be overly conservative, and thus might cause the reduction less effective. Consider the example shown Fig. 5 again. Based on the above two conditions, firing transition t 4 in state s 0 needs to delayed to avoid losing the interleavings between t k and t 4 if t k could be enabled in the future. Now suppose there exists a transition t i between t 1 and t k such that t i can be enabled only after t 4 is fired, and it needs to be fired first before t k can be enabled. In this case, transitions t k and t 4 can never be enabled together in any state reachable from s 0 , and the dependency between t k and t 4 does not actually hold in s 0 . Therefore, knowing this information can help to expose more independent transitions for reduction not restricted by Condition 2. This is commonly known as conditional dependency [7].
According to the above discussion, in general, given a state s such that t 1 , t 2 ∈ enabled(s) and D(t 2 , t 3 ) holds for some transition t 3 , it is necessary to know if another state s n where D(t 2 , t 3 ) holds is reachable from s in order to generate a smaller ample set in state s. This information can also be computed from the local state graphs generated using the method as described in the last section as follows.
1. Consider every local state s n where a dependency D(t 2 , t 3 ) holds. Then, for each predecessor state s n−1 of s n , if either t 2 ∈ enabled(s n−1 ) or t 3 ∈ enabled(s n−1 ), add (s n−1 , t 2 ) or (s n−1 , t 3 ) into a set D C . If enabled(s n−1 ) does not include either t 2 or t 3 , it is not considered further. This is because it is only necessary to consider if states with t 2 or t 3 enabled can reach a state where the dependency involving either t 2 or t 3 actually holds, and this dependency is irrelevant to other states, therefore they do not need to be considered. 2. The above step repeats on state s n−1 if s n−1 exists.
The above procedure is applied to every local state graph for every pair of dependent transitions. Note that the above procedure traverses paths in local SGs to determine reachable dependencies for a local state. Since these local SGs are over-approximations of the concrete ones, these reachable dependencies may or may not hold in the global state space of the whole system. On the other hand, it still guarantees the correctness as no dependencies are ignored.
With D C computed as described above, Condition 2 can be changed to the one shown below. Since the dependency involving a transition enabled in a state may or may not hold, more enabled transitions can be considered for the ample set, and this could lead to a smaller ample set, therefore more reduction in state space complexity. Condition 2 For each transition t ∈ enabled(s), if (s, t) ∈ D C and in(s, s) hold in a global state s, then t ∈ ample(s).

Experimental Results
The partial order reduction method described in this paper is implemented in a concurrent system verification tool P latu, an explicit model checker implemented in Java. Experiments have been been performed on a number of examples. These examples include asynchronous circuit designs from previously published papers [9,2,12,17,10]. All these examples are experimented with the POR method described in this paper and the one implemented in SPIN [8]. This provides a comparison of the approach presented in this paper to the state-of-the-art. In the experiments, only deadlock-freedom and safety properties are considered. The state spaces of all examples contain cycles, a form of weak proviso algorithm [6] is implemented to fulfill the cycle condition C4 as shown in section 4.
All experiments are performed on a Linux workstation with a Intel Pentium Dual-Core CPU and 4 GB memory, and the results are shown in Table 1. For each example, its state space is searched by monolithic reachability analysis On the other hand, this approach is far more efficient as it can finish more and much larger examples. These results show that the behavioral analysis approach indeed is capable of deriving more accurate independence relations from state space models, thus allowing more transitions to be identified as independent.
The overhead of the compositional reachability analysis is relatively small in total runtime. Except for mmu, generally 10 percent of the total runtime is spent on constructing the local state graphs, and deriving the dependence information from these state space models. For mmu, the overhead of the behavioral analysis is about 35 percent of the total runtime. This is due to that many components in this design have quite complex interfaces, and a large number of extra states and state transitions are generated for each component during the compositional readability analysis.

Previous Work
Persistent set [7] or stubborn set [13] are some of the early work on partial order reduction. These methods, relying on the notion of transition dependence, compute a sufficient subset of enabled transition in each state visited during state space exploration such that every execution path not in the reduced state space is represented by an equivalent one with respect to the properties to be checked. An alternative technique, sleep sets [7], avoids traversing certain state transitions based on the information on the transition dependence in the current state and the states visited in the past. The sleep set technique sometimes can reduce certain states, but the persistent method outperforms in reduction of states. Both can be used together to achieve better performance.
As pointed out earlier, traditional POR methods rely on the dependence relations obtained by the static analysis on the system descriptions, and the conservative approximation of dependence relations is often produced for the soundness. The consequence is often larger persistent sets calculated for the reachable states encountered on-the-fly, thus large state space to be explored. To address this problem, dynamic POR as in [1] detects dependency among transitions on-the-fly, and this dynamically obtained dependence relation can be very precise and often leads to smaller persistent sets. Dynamic POR [1] is expensive because it is a stateless model checking procedure, which traverses a sufficient number of execution paths in a concurrent system. This is in contrast to the stateful approach implemented in SPIN which aims to traverse sufficient set of states with respect to a given property. The dynamic POR may be inefficient because the number of execution paths that need to be traversed can be exponential compared to the set of state that need to be traversed. Plus, the state space of the systems under verification is assumed to be acyclic in [1]. There are also efforts for making the original dynamic POR algorithm stateful [14,16], and extend it to systems that allow cycles in their state space.
POR has been combined with symbolic methods [15,14], but these approaches are for bounded model checking using SAT solvers.
The cycle condition as formulated for the ample set method can be fulfilled by the so called proviso [7] algorithm by fully expanding at least one state in every cycle found during POR state space search. This proviso is strong as it allows full LT L −X formulas to be checked by POR approaches. For safety properties, a weak form of proviso, where the full expansion is not required if at least one enabled transition in the ample set does not close a cycle, can be used. A more sophisticated approach to meet the cycle for the safety properties is based on detecting the maximal terminal strongly connected components [7]. However, its implementation could be more involved than the weak proviso approach. In [11], a two-phase POR algorithm is described and better reductions are shown on a number of examples compared to the POR combined the proviso. However, its effectiveness relies on if a system model displays sufficient amount of determinism among concurrent processes; otherwise, its performance could be as bad as that of monolithic search.

Conclusion
This paper introduces a new approach to computing independence relations for partial order reduction. Since the analysis is applied on the state space models, the derived independence relations are more refined and accurate, which lead to more effective partial order reduction as shown by the experimental results. In the future, we plan to integrate this approach with compositional verification in order to scale model checking for even larger designs, and also extend the idea presented in this paper to real-time system verification. Additionally, this approach relies on an efficient local state graph construction method. If the constructed local state graphs include too many extra states or state transitions, it may have a negative impact on the precision of the derived dependence relations and the efficiency of the overall POR procedure. The performance of the local state graph construction procedure itself can also be greatly degraded if the generated local state graphs are too large. Therefore, a better local state graph construction method is needed in terms of local state graphs generated with least number of extra states and transitions and short runtime.