Pushdown automaton

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

Approximate timed abstractions of hybrid automata

Abstract: Given a hybrid automaton and a desired precision, we aim at constructing an approximate abstraction by means of a timed automaton, whose discrete state trajectories approximate the discrete state trajectories of the original system, with the desired precision on switching times. We show that using the Euclidian metric on reals it is not always possible to construct a timed automaton that is close to a hybrid automaton with finite precision. For this reason, we motivate and introduce relative metrics on reachability time, external language and simulation relation to quantify the precision of our abstraction. Our main result is to propose a novel algorithm to construct a timed automaton that is an approximate timed abstraction of a hybrid automaton with desired precision, and study its convergence properties. For an extended version of this paper refer to [D'Innocenzo et al., 2007].

Parallel time O (log n ) acceptance of deterministic CFLs on an exclusive-write P-RAM

Abstract: We give an algorithm for accepting a deterministic context-free language on the P-RAM, an exclusive-write, concurrent-read model of parallel computation. Whereas on inputs of length n, a deterministic push-down automaton will use time linear in n, our algorithm runs in time $O(\log n)$ on $n^3 $ processors. The algorithm is easily generalized to permit parallel simulation of any deterministic auxiliary pushdown automaton that uses space $s(n) \geqq \log n$ and time $2^{O(s(n))} $. The simulation runs in time $O(s(n))$ on $2^{O(s(n))} $ processors, and is nearly optimal, since we observe that any language accepted by a P-RAM in time $T(n)$ is accepted by a deterministic auxiliary pushdown automaton in space $T(n)$ and time $2^{O(T(n)^2 )} $.

A note on deciding controllability in pushdown systems

Abstract: Consider an event alphabet /spl Sigma/. The supervisory control theory of Ramadge and Wonham asks the question, given a plant model G, with language K L/sub M/(G)/spl sube//spl Sigma//sup */ and another language K/spl sube/ L/sub M/(G), is there a supervisor /spl psi/ such that L/sub M/(/spl psi//G)=K. Ramadge and Wonham showed that a necessary condition for this to be true is the so-called controllability of K with respect to L/sub M/(G). They showed that when G is a finite state automaton and K is a regular language (also generated by a finite state automaton), then the controllability property was decidable for K. The class of languages generated by pushdown automata properly includes the regular languages. They are accepted by finite state machines coupled with pushdown stack memory. This makes them interesting candidates as supervisory languages, since the supervisor will have nonfinite memory. In this note, we show the following: i) If S is a specification given by a deterministic pushdown automaton and L is generated by a finite state machine, then there is an algorithm to decide whether K=S/spl cap/L is controllable with respect to L. ii) It is undecidable for an arbitrary specification S generated by a nondeterministic pushdown automaton and plant language L generated by a finite state machine whether K=S/spl cap/L is controllable with respect to L.

On regular tree languages and deterministic pushdown automata

Abstract: The theory of formal string languages and of formal tree languages are both important parts of the theory of formal languages. Regular tree languages are recognized by finite tree automata. Trees in their postfix notation can be seen as strings. This paper presents a simple transformation from any given (bottom-up) finite tree automaton recognizing a regular tree language to a deterministic pushdown automaton accepting the same tree language in postfix notation. The resulting deterministic pushdown automaton can be implemented easily by an existing parser generator because it is constructed for an LR(0) grammar, and its size directly corresponds to the size of the deterministic finite tree automaton. The class of regular tree languages in postfix notation is a proper subclass of deterministic context-free string languages. Moreover, the class of tree languages which are in their postfix notation deterministic context-free string languages is a proper superclass of the class of regular tree languages.

On the Complexity of the Equivalence Problem for Probabilistic Automata

Abstract: Checking two probabilistic automata for equivalence has been shown to be a key problem for efficiently establishing various behavioural and anonymity properties of probabilistic systems. In recent experiments a randomised equivalence test based on polynomial identity testing outperformed deterministic algorithms. In this paper we show that polynomial identity testing yields efficient algorithms for various generalisations of the equivalence problem. First, we provide a randomized NC procedure that also outputs a counterexample trace in case of inequivalence. Second, we show how to check for equivalence two probabilistic automata with (cumulative) rewards. Our algorithm runs in deterministic polynomial time, if the number of reward counters is fixed. Finally we show that the equivalence problem for probabilistic visibly pushdown automata is logspace equivalent to the Arithmetic Circuit Identity Testing problem, which is to decide whether a polynomial represented by an arithmetic circuit is identically zero.