Pushdown automaton

About: Pushdown automaton is a research topic. Over the lifetime, 1868 publications have been published within this topic receiving 35399 citations.

Model-Checking Pushdown Systems

Abstract: The thesis investigates an approach to automated software verification based on pushdown systems. Pushdown systems are, roughly speaking, transition systems whose states include a stack of unbounded length; there is a natural correspondence between them and the execution sequences of programs with (possibly recursive) subroutines. The thesis examines model-checking problems for pushdown systems, improving previously known algorithms in terms of both asymptotic complexity and practical usability. The improved algorithms are used in a tool called Moped. The tool acts as a model-checker for linear-time logic (LTL) on pushdown systems. Two different symbolic techniques are combined to make the model-checking feasible: automata-based techniques are used to handle infinities raised by a program's control, and Binary Decision Diagrams (BDDs) to combat the state explosion raised by its data. It is shown how the resulting system can be used to verify properties of algorithms with recursive procedures by means of several examples. The checker has also been used on automatically derived abstractions of some large C programs. Moreover, the thesis investigates several optimizations which served to improve the efficiency of the checker.

Analysis of recursive state machines

Abstract: Recursive state machines (RSMs) enhance the power of ordinary state machines by allowing vertices to correspond either to ordinary states or to potentially recursive invocations of other state machines. RSMs can model the control flow in sequential imperative programs containing recursive procedure calls. They can be viewed as a visual notation extending Statecharts-like hierarchical state machines, where concurrency is disallowed but recursion is allowed. They are also related to various models of pushdown systems studied in the verification and program analysis communities.After introducing RSMs and comparing their expressiveness with other models, we focus on whether verification can be efficiently performed for RSMs. Our first goal is to examine the verification of linear time properties of RSMs. We begin this study by dealing with two key components for algorithmic analysis and model checking, namely, reachability (Is a target state reachable from initial states?) and cycle detection (Is there a reachable cycle containing an accepting state?). We show that both these problems can be solved in time O(nθ2) and space O(nθ), where n is the size of the recursive machine and θ is the maximum, over all component state machines, of the minimum of the number of entries and the number of exits of each component. From this, we easily derive algorithms for linear time temporal logic model checking with the same complexity in the model. We then turn to properties in the branching time logic CTL*, and again demonstrate a bound linear in the size of the state machine, but only for the case of RSMs with a single exit node.

On the Tape Complexity of Deterministic Context-Free Languages

Abstract: Let DSPACE(L(n)) denote the family of languages recognized by deterministic L(n)-tape bounded Turmg machines The pnnopal result described m this paper is the equivalence of the following statements (l) The determtmsttc context-free language L~ 2) (described m the paper) is m DSPACE(Iog(n)) (2) The simple LL(I) languages are m DSPACE(tog(n)) (3) The simple precedence languages are in DSPACE(Iog(n)). (4) DSPACE(Iog(n)) is identical to the famdy of languages recogmzed by deterministic two-way multlhead pushdown automata m polynomml tmae These results are obtained by constructing a determlmstlc context-free language L~ 2~ which is log(n)-complete for the family of determlmstlc context-free languages In other words, a tape hardest deterministic context-free language is described The best upper bound known on the tape complexity of (deterministic) context-free languages is (log(n)) 2

Verification on Infinite Structures

Abstract: In this chapter, we present a hierarchy of infinite-state systems based on the primitive operations of sequential and parallel composition; the hierarchy includes a variety of commonly-studied classes of systems such as context-free and pushdown automata, and Petri net processes. We then examine the equivalence and regularity checking problems for these classes, with special emphasis on bisimulation equivalence, stressing the structural techniques which have been devised for solving these problems. Finally, we explore the model checking problem over these classes with respect to various linear- and branching-time temporal logics.