Reachability Algorithm Research Articles

A model for slicing JAVA programs hierarchically

Program slicing can be effectively used to debug, test, analyze, understand and maintain object-oriented software. In this paper, a new slicing model is proposed to slice Java programs based on their inherent hierarchical feature. The main idea of hierarchical slicing is to slice programs in a stepwise way, from package level, to class level, method level, and finally up to statement level. The stepwise slicing algorithm and the related graph reachability algorithms are presented, the architecture of the Java program Analyzing TOol (JATO) based on hierarchical slicing model is provided, the applications and a small case study are also discussed.

Covering sharing trees: a compact data structure for parameterized verification

The control state reachability problem is decidable for well-structured infinite-state systems like (Lossy) Petri Nets, Vector Addition Systems, and broadcast protocols. An abstract algorithm that solves the problem is the backward reachability algorithm of [1, 21 ]. The algorithm computes the closure of the predecessor operator with respect to a given upward-closed set of target states. When applied to this class of verification problems, symbolic model checkers based on constraints like [7, 26 ] suffer from the state explosion problem.In order to tackle this problem, in [13] we introduced a new data structure, called covering sharing trees, to represent in a compact way collections of infinite sets of system configurations. In this paper, we will study the theoretical complexity of the operations over covering sharing trees needed in symbolic model checking. We will also discuss several optimizations that can be used when dealing with Petri Nets. Among them, in [14] we introduced a new heuristic rule based on structural properties of Petri Nets that can be used to efficiently prune the search during symbolic backward exploration. The combination of these techniques allowed us to turn the abstract algorithm of [1, 21 ] into a practical method. We have evaluated the method on several finite-state and infinite-state examples taken from the literature [2, 18 , 20 , 30 ]. In this paper, we will compare the results we obtained in our experiments with those obtained using other finite and infinite-state verification tools.

Distributed reachability analysis in timed automata

We evaluate a distributed reachability algorithm suitable for verification of real time critical systems modeled as timed automata. It is discovered that the algorithm suffers from load balancing problems and a high communication overhead. The load balancing problems are caused by the symbolic nature of the representation of the states of a timed automaton. We propose alternative data structures for representing the state-space of a timed automaton and adding a proportional load balancing controller on top of the algorithm. We evaluate various approaches at reducing communication overhead by increasing locality and compressing states. It is experimentally evaluated that by using the techniques speedups between 50% and 90% of linear can be obtained on a 14 node Linux Beowulf cluster on medium sized examples.

What is the impact of Tegaserod on gallbladder emptying?

This paper presents scalable parallel BDD operations for modern multi-core hardware. We aim at increasing the performance of reachability analysis in the context of model checking. Existing approaches focus on performing multiple independent BDD operations rather than parallelizing the BDD operations themselves. In the past, attempts at parallelizing BDD operations have been unsuccessful due to communication costs in shared memory.We solved this problem by extending an existing lockless hashtable to support BDDs and garbage collection and by implementing a lockless memoization table. Using these lockless hashtables and the work-stealing framework Wool, we implemented a multi-core BDD package called Sylvan.We provide the experimental results of using this multi-core BDD package in the framework of the model checker LTSmin. We measured the runtime of the reachability algorithm on several models from the BEEM model database on a 48-core machine, demonstrating speedups of over 30 for some models, which is a breakthrough compared to earlier work.In addition, we improved the standard symbolic reachability algorithm to use a modified BDD operation that calculates the relational product and the variable substitution in one step. We show that this new algorithm improves the performance of symbolic reachability and decreases the memory requirements by up to 40%.

A Performance Study of Distributed Timed Automata Reachability Analysis

We experimentally evaluate an existing distributed reachability algorithm for timed automata on a Linux Beowulf cluster. It is discovered that the algorithm suffers from load balancing problems and a high communication overhead. The load balancing problems are caused by inclusion checking performed between symbolic states unique to the timed automaton reachability algorithm. We propose adding a proportional load balancing controller on top of the algorithm. We evaluate various approaches to reduce communication overhead by increasing locality and reducing the number of messages. Both approaches increase performance but can make load balancing harder and has unwanted side effects that result in an increased workload.

Checking reachability properties for timed automata via SAT

The paper deals with the problem of checking reachability for timed automata. The main idea consists in combining the well-know forward reachability algorithm and the Bounded Model Checking (BMC) m...

Translation from timed Petri nets with intervals on transitions to intervals on places (with urgency)

Petri nets where, to my knowledge, the first theoretical model augmented with time constraints [Mer74], and the support of the first reachability algorithm of timed system [BM83, BD91]. Several approaches have been studied in order to add time on Petri nets: associating intervals on transitions [Mer74], or places [KDCD96], or arcs [Wal83, SDLdSS96], with or without urgency. However, the first comparisons between models where done years later [CMS99, BD99]. It had been shown in [CMS99] that, without urgency, all models are equivalent, in [BD99] that, with urgency, Petri nets with interval on transitions (TTPN) are not more powerful that Petri net with intervals on places (TPPN) or arcs (TLPN), and in [BV00] that TLPN are more powerful that TPPN and TTPN. This paper makes a step further in this area, showing that bounded TPPN are more powerful that 1-bounded TTPN. The proof is made using a translation: from a 1-bounded TTPN, a bounded TPPN is build, that is shown to be timely weakly bisimilar.

A note on well quasi-orderings for powersets

This note characterizes those quasi-orderings (A,⪯) for which ( P(A),⊑) are well quasi-orderings, where B 1⊑B 2 iff (∀y∈B 2)(∃x∈B 1): x⪯y (for B 1,B 2⫅A ). It turns out that they are those which do not contain the “Rado structure”, hence are ω 2 -well quasi-orderings in other words. A motivation for the question has come from the area of verification of infinite-state systems, where the usefulness of well quasi-orderings has already been recognized. This note suggests that finer notions might be useful as well. In particular, ω 2 -well quasi-orderings illuminate a specific problem related to termination of a reachability algorithm, which has been touched on by Abdulla and Jonsson.

Combining relational calculus and the Dijkstra–Gries method for deriving relational programs

We show how to derive imperative programs for relation-based discrete structures by combining relational calculus and the Dijkstra–Gries method. Three examples are given, viz. Warshall's algorithm for transitive closures, a breadth-first-search reachability algorithm, and an algorithm for spanning trees.

Yet another reachability algorithm for Petri nets

A new algorithm for the determination of reachability of a marking in generalized Petri nets is proposed. The algorithm is based on the matrix-equation approach. Given a Petri net, a so called complemented Petri net is created that consists of the given Petri net and a complementary transition with input and output places depending on the initial and target markings. Then the reachability task is reduced to the investigation of T-invariants of the complemented Petri net. Using a technique of search for T-invariants, the algorithm determines minimal-support T-invariants, that include the complementary transition, and then calculates the finite set of their linear combinations. For each T-invariant, the algorithm tries to create sequentially all reachability paths from the given initial marking to the target marking or determines that there are no such paths at all. During creation of the reachability paths, the algorithm needs memory only for storing the reachability path being created. If it is sufficient to determine only one firing sequence that transforms the initial marking into the target one, then the algorithm may be terminated after successful creation of the first reachability path.

What's Decidable about Hybrid Automata?

Hybrid automata model systems with both digital and analog components, such as embedded control programs. Many verification tasks for such programs can be expressed as reachability problems for hybrid automata. By improving on previous decidability and undecidability results, we identify a boundary between decidability and undecidability for the reachability problem of hybrid automata. On the positive side, we give an (optimal) PSPACE reachability algorithm for the case of initialized rectangular automata, where all analog variables follow independent trajectories within piecewise-linear envelopes and are reinitialized whenever the envelope changes. Our algorithm is based on the construction of a timed automaton that contains all reachability information about a given initialized rectangular automaton. The translation has practical significance for verification, because it guarantees the termination of symbolic procedures for the reachability analysis of initialized rectangular automata. The translation also preserves theω-languages of initialized rectangular automata with bounded nondeterminism. On the negative side, we show that several slight generalizations of initialized rectangular automata lead to an undecidable reachability problem. In particular, we prove that the reachability problem is undecidable for timed automata augmented with a single stopwatch.

A fast randomized LOGSPACE algorithm for graph connectivity

We study the relationship between undirected graph reachability and graph connectivity, in the context of randomized LOGSPACE algorithms. Aleluinas et al. [2] show that graph reachability (checking whether there is a path connecting vertices J and ℸ) can be decided in logarithmic space and polynomial time, by starting a random walk at J, and checking whether ℸ is hit within some time limit. The randomized algorithm has one-sided error (with small probability, it fails to determine that J and ℸ are connected). The reachability algorithm may be used in order to decide (with one-sided error) whether a graph is connected, by running it n − 1 times, each time with a different target vertex ℸ. This increases the running time by a factor of n. In this paper we give an alternative randomized LOGSPACE algorithm for graph connectivity. Its running time varies between O( n 2) steps and O( n 3) steps, depending on the structure of the input graph. This matches the fastest known RLOGSPACE algorithm for reachability, up to a constant factor. Our algorithm has two-sided error.

Calculating path algorithms

A calculational derivation is given of two abstract path algorithms. The first is an all-pairs algorithm, two well-known instances of which are Warshall's (reachability) algorithm and Floyd's shortest-path algorithm; instances of the second are Dijkstra's shortest-path algorithm and breadth-first/depth-first search of a directed graph. The basis for the derivations is the algebra of regular languages.

Verification of protocol conformance test cases using reachability analysis

A methodology is presented to verify manually written test cases against the formal specification of a protocol. Initially, a protocol and a test case are modeled as nondeterministic finite state machines and test case verification is viewed as a reachability analysis problem. An existing reachability analysis algorithm, based on the well-known perturbation technique, is modified to take nondeterminism in protocols and special test case features (timeouts and OTHERWISE events) into account. Correctness aspects of the reachability algorithm are proved. The notion of a synchronization error manifesting in a test case due to the nondeterministic nature of a protocol specification is studied. To verify data flow aspects of test cases, we extend our technique by modeling the test case and protocol specification as extended finite state machines. A test case from a proprietary test suite for the transport protocol Class 2 is taken as an example and is shown to contain several design errors.

Protocol validation for large-scale applications

A threefold strategy incorporating formal modeling, structural decomposition and functional abstraction, and reachability analysis is described, and the role of each part in managing complexity is examined. Formal modeling helps weed out extraneous detail so that later work on decomposition and abstraction is easier. Decomposition and abstraction help divide complexity into manageability parts that the reachability algorithm can solve. Examples of the use of each are given.< <ETX xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:xlink="http://www.w3.org/1999/xlink">&gt;</ETX>