Showing papers on "Pushdown automaton published in 2010"

Properties of visibly pushdown transducers

Abstract: Visibly pushdown transducers (VPTs) form a strict subclass of pushdown transducers (PTs) that extends finite state transducers with a stack. Like visibly pushdown automata, the input symbols determine the stack operations. It has been shown that visibly pushdown languages form a robust subclass of context-free languages. Along the same line, we show that word transductions defined by VPTs enjoy strong properties, in contrast to PTs. In particular, functionality is decidable in PTIME, k-valuedness is in NPTIME and equivalence of (non-deterministic) functional VPTs is EXPTIME-C. Those problems are undecidable for PTs. Output words of VPTs are not necessarily well-nested. We identify a general subclass of VPTs that produce well-nested words, which is closed by composition, and for which the type checking problem is decidable.

Analysis of Timed Recursive State Machines

Abstract: The paper proposes a temporal extension of Recursive State Machines (RSMs), called Timed RSMs (TRSMs). A TRSM is an indexed collection of Timed Automata allowed to invoke other Timed Automata (procedural calls). The classes of TRSMs are related to an extension of Pushdown Timed Automata, called EPTAs, where an additional stack, coupled with the standard control stack, is used to store temporal valuations of clocks. A number of subclasses of TRSMs and EPTAs are considered and compared through bisimulation of their timed LTSs. It is shown that EPTAs and TRSMs can be used to recognize classes of timed languages exhibiting contextfree properties not only in the untimed “control” part, but also in the associated temporal dimension. The reachability problem for both TRSMs and EPTAs is investigated, showing that the problem is undecidable in the general case, but decidable for meaningful subclasses. The complexity is stated for a TRSMs subclass.

On the complexity of checking semantic equivalences between pushdown processes and finite-state processes

Abstract: Simulation preorder/equivalence and bisimulation equivalence are the most commonly used equivalences in concurrency theory. Their standard definitions are often called strong simulation/bisimulation, while weak simulation/bisimulation abstracts from internal @t-actions. We study the computational complexity of checking these strong and weak semantic preorders/equivalences between pushdown processes and finite-state processes. We present a complete picture of the computational complexity of these problems and also study fixed-parameter tractability in two important input parameters: x, the size of the finite control of the pushdown process, and y, the size of the finite-state process. All simulation problems are generally EXPTIME-complete and only become polynomial if both parameters x and y are fixed. Weak bisimulation equivalence is PSPACE-complete, but becomes polynomial if and only if parameter x is fixed. Strong bisimulation equivalence is PSPACE-complete, but becomes polynomial if either parameter x or y is fixed.

Bisimilarity of one-counter processes is PSPACE-complete

Abstract: A one-counter automaton is a pushdown automaton over a singleton stack alphabet. We prove that the bisimilarity of processes generated by nondeterministic one-counter automata (with no e-steps) is in PSPACE. This improves the previously known decidability result (Jancar 2000), and matches the known PSPACE lower bound (Srba 2009). We add the PTIME-completeness result for deciding regularity (i.e. finiteness up to bisimilarity) of one-counter processes.

The language theory of bounded context-switching

Abstract: Concurrent compositions of recursive programs with finite data are a natural abstraction model for concurrent programs. Since reachability is undecidable for this class, a restricted form of reachability has become popular in the formal verification literature, where the set of states reached within k context-switches, for a fixed small constant k, is explored. In this paper, we consider the language theory of these models: concurrent recursive programs with finite data domains that communicate using shared memory and work within k round-robin rounds of context-switches, and where further the stack operations are made visible (as in visibly pushdown automata). We show that the corresponding class of languages, for any fixed k, forms a robust subclass of context-sensitive languages, closed under all the Boolean operations. Our main technical contribution is to show that these automata are determinizable as well. This is the first class we are aware of that includes non-context-free languages, and yet has the above properties.

Linear orders in the pushdown hierarchy

Abstract: We investigate the linear orders belonging to the pushdown hierarchy Our results are based on the characterization of the pushdown hierarchy by graph transformations due to Caucal and do not make any use of higher-order pushdown automata machinery Our main results show that ordinals belonging to the n-th level are exactly those strictly smaller than the tower of ω of height n + 1 More generally the Hausdorff rank of scattered linear orders on the n-th level is strictly smaller than the tower of ω of height n As a corollary the Cantor-Bendixson rank of the tree solutions of safe recursion schemes of order n is smaller than the tower of ω of height n As a spin-off result, we show that the ω-words belonging to the second level of the pushdown hierarchy are exactly the morphic words

On Functionality of Visibly Pushdown Transducers

Abstract: Visibly pushdown transducers form a subclass of pushdown transducers that (strictly) extends finite state transducers with a stack. Like visibly pushdown automata, the input symbols determine the stack operations. In this paper, we prove that functionality is decidable in PSpace for visibly pushdown transducers. The proof is done via a pumping argument: if a word with two outputs has a sufficiently large nesting depth, there exists a nested word with two outputs whose nesting depth is strictly smaller. The proof uses technics of word combinatorics. As a consequence of decidability of functionality, we also show that equivalence of functional visibly pushdown transducers is Exptime-Complete.

On probabilistic pushdown automata

Abstract: We study the most important probabilistic computation modes for pushdown automata. First we show that deterministic pushdown automata (pda) are weaker than Las Vegas pda, which in turn are weaker than one-sided-error pda. Next one-sided-error pda are shown to be weaker than (nondeterministic) pda. Finally bounded-error two-sided error pda and nondeterministic pda are incomparable. To show the limited power of bounded-error two-sided pda we apply communication arguments; in particular we introduce a non-standard model of communication which we analyze with the help of the discrepancy method. The power of randomization for pda is considerable, since we construct languages which are not deterministic context-free (resp. not context-free) but are recognizable with even arbitrarily small error by one-sided-error (resp. bounded-error) pda. On the other hand we show that, in contrast to many other fundamental models of computing, error probabilities can in general not be decreased arbitrarily: we construct languages which are recognizable by one-sided-error pda with error probability 12, but not by one-sided-error pushdown automata with error probability p<12. A similar result, with error probability 13, holds for bounded-error two-sided error pda.

Runtime Analysis of Probabilistic Programs with Unbounded Recursion

Abstract: We study termination time and recurrence time in programs with unbounded recursion, which are either randomized or operate on some statistically quantified inputs. As the underlying formal model for such programs we use probabilistic pushdown automata (pPDA) which are equivalent to probabilistic recursive state machines. We obtain tail bounds for the distribution of termination time for pPDA. We also study the recurrence time for probabilistic recursive programs that are not supposed to terminate (such as system daemons, network servers, etc.). Typically, such programs react to certain requests generated by their environment, and hence operate in finite request-service cycles. We obtain bounds for the frequency of long request-service cycles.

Stochastic real-time games with qualitative timed automata objectives

Abstract: We consider two-player stochastic games over real-time probabilistic processes where the winning objective is specified by a timed automaton. The goal of player □ is to play in such a way that the play (a timed word) is accepted by the timed automaton with probability one. Player ⋄ aims at the opposite. We prove that whenever player □ has a winning strategy, then she also has a strategy that can be specified by a timed automaton. The strategy automaton reads the history of a play, and the decisions taken by the strategy depend only on the region of the resulting configuration. We also give an exponential-time algorithm which computes a winning timed automaton strategy if it exists.

From multi to single stack automata

Abstract: We investigate the issue of reducing the verification problem of multistack machines to the one for single-stack machines. For instance, elegant (and practically efficient) algorithms for bounded-context switch analysis of multipushdown systems have been recently defined based on reductions to the reachability problem of (single-stack) pushdown systems [10,18]. In this paper, we extend this view to both bounded-phase visibly pushdown automata (BVMPA) [16]and ordered multi-pushdown automata (OMPA) [1] by showing that each of their emptiness problem can be reduced to the one for a class of single-stack machines. For these reductions, we introduce effective generalized pushdown automata (EGPA) where operations on stacks are (1) pop the top symbol of the stack, and (2) push a word in some (effectively) given set of words L over the stack alphabet, assuming that L is in some class of languages for which checking whether L intersects regular languages is decidable. We show that the automatabased saturation procedure for computing the set of predecessors in standard pushdown automata can be extended to prove that for EGPA too the set of all predecessors of a regular set of configurations is an effectively constructible regular set. Our reductions from OMPA and BVMPA to EGPA, together with the reachability analysis procedure for EGPA, allow to provide conceptually simple algorithms for checking the emptiness problem for each of these models, and to significantly simplify the proofs for their 2ETIME upper bounds (matching their lower-bounds).

Conditional weighted pushdown systems and applications

Abstract: Pushdown systems are well understood as abstract models of programs with (recursive) procedures. Reps et al. recently extended pushdown systems into weighted pushdown systems, which serve as a generalized framework for solving certain kinds of meet-over-all-path problems in program analysis. In this paper, we extend weighted pushdown systems to conditional weighted pushdown systems, by further specifying conditions under which a pushdown transition rule can be applied, and show that model checking problems on conditional weighted pushdown systems can be reduced to those on weighted pushdown systems.There are wider applications of conditional weighted pushdown systems when analyzing programs with objected-oriented features, for which weighted pushdown systems is not precise enough under a direct application. As an example, we lift a stacking-based points-to analysis for Java designed in the framework of weighted pushdown systems to a more precise counterpart in the framework of conditional weighted pushdown systems. In addition to the fundamental context-sensitivity in terms of valid paths, the lifted points-to analysis algorithm further enjoys context-sensitivity with respect to objected-oriented features, including call graph construction, heap abstraction, and heap access. These context-sensitive properties are shown to be crucial to the analysis precision in practice.

On the Krohn-Rhodes cascaded decomposition theorem

Abstract: The Krohn-Rhodes theorem states that any deterministic automaton is a homomorphic image of a cascade of very simple automata which realize either resets or permutations. Moreover, if the automaton is counter-free, only reset automata are needed. In this paper we give a very constructive proof of a variant of this theorem due to Eilenberg.

Synthesizing Checkers from Nondeterministic Finite Automaton

Abstract: The present invention provides for the generation of non-deterministic checker circuits. for use in formal verification of electronic designs. In various implementations, an assertion is first received, subsequently; a failure sequence is derived from the assertion. After which, a non-deterministic finite automaton is derived from the failure sequence. Lastly, a checker circuit is generated directly from the non-deterministic finite automaton.

Mechanisation of PDA and grammar equivalence for context-free languages

Abstract: We provide a formalisation of the theory of pushdown automata (PDAs) using the HOL4 theorem prover. It illustrates how provers such as HOL can be used for mechanising complicated proofs, but also how intensive such a process can turn out to be. The proofs blow up in size in way difficult to predict from examining original textbook presentations. Even a meticulous text proof has "intuitive" leaps that need to be identified and formalised.

Weighted dynamic pushdown networks

Abstract: We develop a generic framework for the analysis of programs with recursive procedures and dynamic process creation. To this end we combine the approach of weighted pushdown systems (WPDS) with the model of dynamic pushdown networks (DPN). The resulting model, weighted dynamic pushdown networks (WDPN), describes processes running in parallel, each of them being able to perform pushdown actions, that may spawn new processes as a side effect. As with WPDS, transitions are labelled by weights to carry additional information. Starting from techniques for WPDS and DPN, we derive a method to determine meet-over-all-paths values for the paths between regular sets of configurations of a WDPN. Using this method we are able to solve basic dataflow analysis problems in a parallel context.

Reversible pushdown automata

Abstract: Reversible pushdown automata are deterministic pushdown automata having the property that any configuration occurring in any computation has exactly one predecessor. In this paper, the computational capacity of reversible computations in pushdown automata is investigated and turns out to lie properly in between the regular and deterministic context-free languages. Furthermore, it can be shown that a deterministic context-free language cannot be accepted reversibly if more than realtime is necessary for acceptance. Closure properties as well as decidability questions for reversible pushdown automata are studied. Finally, the question of whether a given (nondeterministic) pushdown automaton can be algorithmically tested for reversibility is answered in the affirmative, whereas it is shown to be undecidable whether the language accepted by a given nondeterministic pushdown automaton is reversible.

Subtree matching by pushdown automata

Abstract: Subtree matching is an important problem in Computer Science on which a number of tasks, such as mechanical theorem proving, term-rewriting, symbolic computation and nonprocedural programming languages are based on. A systematic approach to the construction of subtree pattern matchers by deterministic pushdown automata, which read subject trees in prefix and postfix notation, is presented. The method is analogous to the construction of string pattern matchers: for a given pattern, a nondeterministic pushdown automaton is created and is then determinised. In addition, it is shown that the size of the resulting deterministic pushdown automata directly corresponds to the size of the existing string pattern matchers based on finite automata.

Descriptional complexity of (un)ambiguous finite state machines and pushdown automata

Abstract: Unambiguity and its generalization to quantified ambiguity are important concepts in, e.g., automata and complexity theory. Basically, an unambiguous machine has at most one accepting computation path for each accepted word. While unambiguous pushdown automata induce a language family strictly in between the deterministic and general context-free languages, unambiguous finite automata capture the regular languages, that is, they are equally powerful as deterministic and nondeterministic finite automata. However, their descriptional capacity is significantly different. In the present paper, we summarize and discuss developments relevant to (un)ambiguous finite automata and pushdown automata problems from the descriptional complexity point of view. We do not prove these results but we merely draw attention to the big picture and some of the main ideas involved.

A model driven internet of things

Abstract: The presented work proposes a model driven development approach employing flexible code generation strategies to overcome the technological gap between networked embedded objects and enterprise back-end system. We design a modeling and generator toolchain based on state of the art technologies to support efficient data exchange between hybrid resource constrained systems. We start by mapping different high level message description languages to a common meta model. From those models we generate visual pushdown automata that are the basis for our code generation and message encoding strategy. On the basis of this representation we present a practical and efficient approach to generate binary representation.

Zigzags in turing machines

Abstract: We study one-head machines through symbolic and topological dynamics. In particular, a subshift is associated to the subshift, and we are interested in its complexity in terms of realtime recognition. We emphasize the class of one-head machines whose subshift can be recognized by a deterministic pushdown automaton. We prove that this class corresponds to particular restrictions on the head movement, and to equicontinuity in associated dynamical systems.

Pushdown System Representation for Unbounded Object Creation

Abstract: We introduce a block-structured programming language which supports object creation, global variables, static scope and recursive procedures with local variables. Because of the combination of recursion, local variables and object creation, the number of objects stored during a computation is potentially unbounded. However, we show that a program can be viewed as a type of pushdown automata, for which the halting problem as well as LTL and CTL model checking are decidable.

Corrigendum to our paper: how expressions can code for automata

Abstract: In a previous paper, we have described the construction of an automaton from a rational expression which has the property that the automaton built from an expression which is itself computed from a co-deterministic automaton by the state elimination method is co-deterministic. It turned out that the definition on which the construction is based was inappropriate, and thus the proof of the property was flawed. We give here the correct definition of the broken derived terms of an expression which allow to define the automaton and the detailed full proof of the property.

Computation with competing patterns in Life-like automaton: Binary adder implementation

Abstract: We study Life-like cellular automaton rule B2/S2345. This automaton exhibits a chaotic behaviour yet capable for purposeful computation. The automaton implements Boolean gates via patterns which compete for the space when propagate in channels. Values of Boolean variables are encoded into two types of patterns --- symmetric 'False' and asymmetric 'True.' We construct basic logical gates and elementary arithmetical circuits by simulating logical signals using glider reactions taking place in the channels built of non-destructible still life. We design a binary adder of majority gates realised in rule B2/S2345.

Automata simulator

Abstract: Software simulation tools supporting a teaching process are highly accepted by both teachers and students. We discuss the possibility of using automata simulators in theoretical computer science courses. The main purpose of this article is to propose key features and requirements of well designed automata simulator and to present our tool SimStudio -- integrated simulator of finite automaton, pushdown automaton, Turing machine, RAM with extension and abacus machine. The aim of this paper is to report our experiences with using of our automata simulators in teaching of the course "Fundamentals of Theoretical Computer Science" in bachelor educational program in software engineering held at Faculty of Informatics and Information Technologies, Slovak University of Technology in Bratislava.

Blackhole State-Controlled Regulated Pushdown Automata

Abstract: In this paper, we introduce and study a variant of regulated pushdown automata, called blackhole state-controlled R-PDA where a symbol can always be pushed to the pushdown, but only a given depth of the pushdown contents is remembered; the rest of the pushdown contents is lost. In addition, the automaton can check the form of its pushdown contents according to a given control language. We present characterizations of several language families in terms of these constructs.

The Pushdown Automaton and Its Coverage Criterion for Testing Undo/Redo Functions of Software

Abstract: UR (undo/redo) functions of software play a great role as the achievement of usability, and they are widely used. However, there are no systematic methods of testing the UR functions that are essentially complex. This paper shows systematic method of modeling the behavior of software using a PDA (pushdown automaton) and generating testcases for the UR functions. The testcase generation is based on the coverage criterion designed for the PDA. We applied this method to an example of software and evaluated its effectiveness.

Modeling and analysis of real -time systems with mutex components

Abstract: Timed automata are popular for formally analyzing real-time systems. However, it is difficult to depict real-time systems with compositional components that interact with each other in a synchronization way or a mutex way. Synchronized components are modeled using parallel composition of timed automata by Larsen et al. [1]. This paper proposes controller automata to represent real-time systems with mutex components. In a controller automaton each state corresponds to a timed automaton with a built-in mechanism of relations, e.g., preemptions, in which every such timed automaton models a component of the real-time system. It is shown that given a strict partial order over states, an ordered controller automaton can be translated into a timed automaton. Various analyses are thus performed by checking the reachability to an error state.